Code reference detail
azure-pipelines.yml
azure-pipelines.yml
| Idea | Status | Tags | Summary | Katz |
|---|---|---|---|---|
| check | done | `reqlan check` should run perform the following checks: - ensure all rq [reference] point to real nodes, unless rq ignored with [comment_reference_ignore]. - this tests rqcomments point to real parts of the namespace, that code references exist, and that rq references exists. - report unresolved imports: [check_unresolved_imports]. - report a comment reference with invalid syntax: [code_comment_syntax_errors]. - report a qualified reference whose file is not on disk: [check_qualified_missing_file]. - report a qualified reference whose `.rq` file does not declare the idea: [check_qualified_missing_idea]. - it should really just be a wrapper of the [index] and return the issues ( as a pipe, terminal output, or json ). Issue order: [check_order_by_target]. Sparse wildcards: [check_wildcard_sparse] via flags [check_wildcard_zero] and [check_wildcard_one]. Path globs: [check_glob_patterns]. Skip missing targets: [check_skip_targets] [check_skip_gitignored_targets]. CLI: ["../cli/cli_package.rq".commands]. MCP: ["../extension/agent/skills-and-mcp.rq".mcp_check]. CI: [check_meta_implementation]. Site demo: ["../site/site.rq".broken_links_showcase]. | 1.000 | |
| check_meta_implementation | done | [check] is a step in the sequential GitHub CI job after one workspace build. Pull requests use ["../../.github/workflows/ci.yml"]. Main uses the same workflow through ["../../.github/workflows/release.yml"] ( ["../distribution/distribution.rq".ci_gate] ). The job installs workspace packages once ( `pnpm install --frozen-lockfile` ), asserts `@reqlan/*` resolve under `packages/` ( ["../../scripts/assert-workspace-reqlan.mjs"] ), compiles crates and TypeScript, then runs crate tests, `node packages/cli/bin/cli.js check`, and JS / TS tests against that build. Do not install `@reqlan/cli` or other `@reqlan/*` packages from npm. Platform natives in this workspace come from `packages/analytical-native/` via `packageExtensions` in ["../../pnpm-workspace.yaml"], not from the registry. Do not call a global `reqlan` binary. Do not run a second install before check. GitHub and Azure pass `--skip-gitignored-targets` because gitignored files are not in a CI checkout ( [check_skip_gitignored_targets] ). Azure uses the same workspace CLI after its package build on `ext/v*` tags. Related: [check] [check_skip_targets] [check_skip_gitignored_targets] ["../distribution/distribution.rq".ci_gate] | 0.355 | |
| check_skip_gitignored_targets | done | [check] omits a file [reference] issue when Git ignore rules ignore the missing target. The analyser function `check_references` takes `skip_gitignored_targets` ( default false ). Match uses the workspace ["../../.gitignore"] and nested `.gitignore` files on the target path. Match uses the resolved path from the workspace root, not the authored path in the source file. Idea references, comment references, and missing imported idea names stay in the issue list. Missing import paths follow the same skip as file references ( [check_unresolved_imports] ). Use this when a referenced file is build output or editor config that git does not store. Examples: `.cursor/` for ["../extension/agent/chat-participant.rq".mcp], and `packages/extension/media/webviews/` for ["../extension/host/onboarding/page-thanks-for-installing.rq".installation_event]. CLI: `--skip-gitignored-targets` ( ["../cli/cli_package.rq".commands] ). API: `AnalysisApi.check({ skipGitignoredTargets })`. CI: ["../../.github/workflows/ci.yml"] and ["../../azure-pipelines.yml"] pass `--skip-gitignored-targets` because a CI checkout does not contain gitignored files ( [check_meta_implementation] ). Related: [check] [check_skip_targets] [check_unresolved_imports] [check_meta_implementation] | 0.445 | |
| extension_host_native_stage | done | Local F5 and `pnpm run build` / `build:ext` stage the host-matching core engine `.node` into `packages/extension/native/` so activation loads the same layout as a per-target VSIX ( [distribution.vsix_export], ["../distribution/native_host_binary.rq".native_host_binary_development] ). The same build copies the `.node` into `packages/analytical-native/<napiSuffix>/` so the workspace optionalDependency matches a production npm install ( [distribution.rust_binary_distribution] ). The orchestrator builds `cargo build -p reqlan-napi -p reqlan-lsp --release` when needed, then copies `reqlan_napi.node` beside the extension. It is not a separate manual install. That command writes `reqlan-lsp` into `crates/target` ( ["../extension/language/support/language-server-rust.rq".language_server_rust] ). Azure compiles the [distribution.native_targets] matrix, then stages those binaries with `prepare-native-packages.mjs --binary-dir` before tests and VSIX packaging. Versions come from git at the `ext/v*` tag. Do not fetch platform packages from npm on Azure ( [distribution.extension_distribution] ). Implementation: ["../../scripts/stage-host-native.mjs"], ["../../scripts/ensure-host-native.mjs"], ["../../packages/extension/scripts/build.mjs"], ["../../azure-pipelines.yml"]. | 0.140 | |
| scope | extension build steps for local development and CI | 0.040 | ||
| typescript_compile | done | Langium writes `packages/language/src/generated` ( ast, grammar, module ). That directory is gitignored. `tsc -b tsconfig.build.json` fails on a clean checkout if those files are missing. Root script `build:tsc` is `langium:generate` then that `tsc -b`. Full `pnpm run build` starts with `build:tsc`. GitHub CI, Azure package build, and npm deploy use `build:tsc` so compile matches a clean local build ( [distribution.prerelease_tests], [distribution.ci_gate], [distribution.npm_distribution] ). GitHub CI compiles the TypeScript workspace once in the sequential job, then reuses that emit for [check.check] and package tests ( [check.check_meta_implementation] ). `langium generate` validates ["../../packages/language/langium-config.json"] against the langium-cli schema. langium-cli 4. 3. 0 does not set schema `$id`. jsonschema 1. 5. 0 then throws `ERR_INVALID_URL` for `#/$defs/languageItem` on Node 24. The workspace pins jsonschema 1. 4. 1 for langium-cli in ["../../pnpm-workspace.yaml"] until a langium-cli release includes that `$id`. | 0.045 | |
| extension_distribution | in-progress | Azure DevOps builds, tests, packages, and publishes the VS Code extension only for tags matching `ext/v*`. Tags are created by ["./distribution.rq".deployment_flow]. The extension version comes from packages / extension / package. json at the tag; the pipeline must not overwrite it from the tag suffix. The implementation lives in ["../../azure-pipelines.yml"]. The pipeline builds language, packages, and the extension only; it does not run the site static build or install Playwright ( [site_distribution] owns site CI ). Native core-engine binaries for VSIX come from the Azure `build_native` matrix on this git tag ( [vsix_native_not_from_npm], [rust_binary_distribution], [vsix_export] ). GitHub Actions still builds and publishes platform packages on `analytical/v*` for CLI / MCP ( [npm_distribution] ). Before tests Azure stages matrix artifacts into workspace packages ( `prepare-native-packages.mjs --binary-dir` ) and checks the host optionalDependency ( `scripts/ensure-host-native.mjs --no-build` ). VSIX packaging follows ["./distribution.rq".vsix_export]: one VSIX per [native_targets] tuple; Marketplace selects the VSIX matching the extension-host target ( [extension_host_target] ). Marketplace publish is complemented by Open VSX per ["./distribution.rq".openvsx_registry]. Pipeline cache and publish parallelism: [extension_pipeline_cache], [extension_pipeline_publish]. | 0.243 | |
| extension_pipeline_cache | done | Azure `build_native` mirrors GitHub `Swatinem/rust-cache` via `Cache@2`: cache rustup + cargo home under `$(Pipeline.Workspace)/rust-cache` ( `CARGO_HOME` / `RUSTUP_HOME` ) and `crates/target`, keyed by OS, `rustTarget`, and `crates/Cargo.lock`. Install rustup only when `$CARGO_HOME/bin/rustc` is missing after restore; otherwise reuse the cached toolchain ( `--no-modify-path` ). Azure `build_test_package` caches the pnpm store keyed by OS and `pnpm-lock.yaml` ( same role as `cache: pnpm` on GitHub ). Do not cache VSIX or napi pipeline artifacts across tags; git at `ext/v*` stays canonical ( [vsix_native_not_from_npm] ). Implementation: ["../../azure-pipelines.yml"]. Related: [extension_distribution], ["./distribution.rq".ci_gate] ( GitHub rust-cache + pnpm ). | 0.072 | |
| extension_pipeline_publish | done | Marketplace and Open VSX publish every per-target VSIX in parallel ( `ForEach-Object -ThrottleLimit 6 -Parallel` ), not one after another. Open VSX uses the workspace `ovsx` package ( `pnpm --filter./packages/extension exec ovsx` ); do not `pnpm dlx ovsx` per file. Local `--openvsx` in ["../../scripts/package-extension-targets.mjs"] uses the same `pnpm exec ovsx` path. Implementation: ["../../azure-pipelines.yml"], ["../../packages/extension/package.json"], ["../../scripts/package-extension-targets.mjs"]. Related: [extension_distribution], [openvsx_registry], [vsix_export]. | 0.094 | |
| openvsx_registry | in-progress | The extension should be published to the Open VSX registry at https://open-vsx.org so it is installable in editors that use Open VSX instead of the Visual Studio Marketplace. Publishing should use the same tag-driven `ext/v*` releases as ["./distribution.rq".extension_distribution]. Each per-target VSIX from ["./distribution.rq".vsix_export] is published to Open VSX ( Marketplace and Open VSX both select by extension-host `targetPlatform` ). Azure DevOps is the authoritative publish workflow; Open VSX publish belongs in ["../../azure-pipelines.yml"] alongside marketplace deploy. Publish path follows [extension_pipeline_publish]. | 0.166 | |
| rust_binary_distribution | in-progress | One platform-specific npm package per [native_targets] tuple: `@reqlan/analytical-<platform>-<arch>` ( napi suffixes: `linux-x64-gnu`, `linux-arm64-gnu`, `darwin-x64`, `darwin-arm64`, `win32-x64-msvc`, `win32-arm64-msvc` ). Each package declares `os` and `cpu`, contains the matching core engine `.node`, and uses the `@reqlan/analytical` package. json version as the single source of truth. ["../../scripts/prepare-native-packages.mjs"] writes that version. Changesets ignores `@reqlan/analytical-*` in ["../../.changeset/config.json"]. Git `@reqlan/analytical` does not list platform packages as `optionalDependencies`; this workspace links them through `packageExtensions` in ["../../pnpm-workspace.yaml"]. The published tarball lists pinned optionalDependencies ( `--publish-versions` ) ( [version_management] ). CLI and MCP install the host-matching binary from those published optionalDependencies. The published tarball runs ["./native_host_binary.rq".published_host_native_install] so a host miss prints a warning. Published on the existing `analytical/v*` channel ( [npm_distribution] / [release_tagging] ); not a separate tag channel. The napi build runs when this channel moved: a direct `analytical/v*` tag, or `analytical_tag` from [deployment_flow]. The first npm tag ( `npm_ref` ) can be `language/v*` in the same release, so that ref is not the native-build gate. Website download listing and GitHub-release postinstall are later follow-ups ( out of scope here ). Engine port: ["../core_analysis/rust_port.rq".analytical_rust_port] / ["../core_analysis/rust_port.rq".native_bridge]. Per-target VSIX packaging uses the same package layout under ["../../packages/analytical-native/"], filled by Azure from this git commit ( [vsix_export], [vsix_native_not_from_npm] ). npm tarballs of those packages are for CLI / MCP only. `collect-napi-binary.mjs` copies `reqlan-lsp` only with `--with-lsp`. The npm workflow does not pass that flag. Azure does, because the VSIX ships `bin/reqlan-lsp` ( [vsix_export] ). Implementation: ["../../packages/analytical-native/"], ["../../scripts/prepare-native-packages.mjs"], ["../../scripts/require-natives-published.mjs"], ["../../packages/analytical/scripts/check-host-native.mjs"], ["../../.changeset/config.json"], ["../../.github/workflows/deploy-npm.yml"] build-native job, ["../../azure-pipelines.yml"] build_native job. | 0.380 | |
| stopgap | Stopgap distribution is at https://marketplace.visualstudio.com/manage/publishers/reqlan | 0.040 | ||
| vsix_export | in-progress | One VSIX is built per [native_targets] tuple via `vsce package --target <tuple> --no-dependencies`. Each VSIX keeps today's esbuild-bundled JS ( TS dependency graph stays bundled ); only the matching platform native package is staged into the VSIX so other targets' binaries are excluded. The same VSIX packs `bin/reqlan-lsp` for that target ( ["../extension/language/support/language-server-rust.rq".language_server_rust] ). Azure `collect-napi-binary.mjs --with-lsp` copies that binary into the native artifact. The pack script checks that zip entry by `file_size`. It does not read the binary through a pipe. The napi addon stays for the index host. npm platform packages do not contain it ( [rust_binary_distribution] ). Stamp `targetPlatform` so Marketplace / Open VSX route by extension host ( [extension_host_target], ["./native_host_binary.rq".native_host_binary_distributed] ). Artifact name shape: `reqlan-extension-<version>-<target>.vsix`. The VSIX includes logo assets from the extension media build: PNG for marketplace icon, language file icon, activity bar, and README; WebP as a raster fallback. Implementation: ["../../scripts/package-extension-targets.mjs"], ["../../scripts/prepare-native-packages.mjs"], ["../../scripts/collect-napi-binary.mjs"], ["../../packages/extension/.vscodeignore"] ( `native/`, `bin/` ), ["../../azure-pipelines.yml"]. | 0.446 | |
| vsix_native_not_from_npm | done | Azure must not use the npm deploy path as an input when it packs VSIXes. Git at the `ext/v*` tag is canonical. Azure compiles the [native_targets] matrix from that commit ( [vsix_export], [extension_distribution] ). npm stays the install path for CLI and MCP only ( [npm_distribution], [rust_binary_distribution] ). | 0.241 | |
| native_host_binary | done | Select the native core-engine binary from the extension host. The host is the Node process that runs the extension. Read `process.platform` and `process.arch` from that process. Do not use the platform of the VS Code UI client. Examples: - UI on Windows and host on Linux SSH: use a linux tuple. - UI on Windows and host on WSL: use a linux tuple. - UI and host on macOS: use a darwin tuple. Map the platform and the arch to one tuple in ["./distribution.rq".native_targets]. Load only the binary that matches that tuple. Do not load a binary for a different tuple. If the platform and the arch are not in ["./distribution.rq".native_targets], fail. If the binary is missing, fail. Do not use sql. js. Keep the loader map the same as ["../../scripts/native-targets.mjs"]. Local development: [native_host_binary_development]. Production distribution: [native_host_binary_distributed]. Implementation: ["../../packages/analytical/src/native/load-native.ts"]. | 0.144 | |
| native_host_binary_distributed | in-progress | Use this procedure for a published VSIX and for published npm packages. VS Code extension: The registry installs the VSIX that has `targetPlatform` equal to the extension host. Each VSIX contains one `.node` file for one ["./distribution.rq".native_targets] tuple. The file name is `native/reqlan_napi.node`. The VSIX also contains `native/target.json`. At run time, read `process.platform` and `process.arch` on the extension host. If `target.json` records a different tuple, do not load `native/reqlan_napi.node`. Do not put binaries for other platforms in that VSIX. The Azure pipeline compiles each platform binary from this git commit ( `build_native` + `collect-napi-binary.mjs` + `prepare-native-packages.mjs --binary-dir` ). Package versions in git are canonical. The pipeline does not wait for npm. Related: ["./distribution.rq".vsix_export], ["./distribution.rq".extension_distribution], ["./distribution.rq".vsix_native_not_from_npm]. CLI and MCP: npm installs the host package from `optionalDependencies` on the published `@reqlan/analytical` tarball. Git does not list those entries. ["../../scripts/prepare-native-packages.mjs"] `--publish-versions` writes them at npm publish. The loader resolves that package from `@reqlan/analytical/package.json` ( `createRequire` ), which is where the optional dependency is attached after `npm install`. Published installs also run [published_host_native_install]. Related: ["./distribution.rq".rust_binary_distribution], [rust_port.native_bridge]. Implementation: ["../../scripts/package-extension-targets.mjs"], ["../../scripts/prepare-native-packages.mjs"], ["../../packages/analytical/src/native/load-native.ts"], ["../../packages/analytical/scripts/check-host-native.mjs"], ["../../azure-pipelines.yml"]. | 0.129 | |
| language_server_rust | in-progress | A Rust binary replaces the Langium language-server process. The extension launches `reqlan-lsp` over stdio. Open `.rq` buffers parse with [parser_rust]. The open sequence is ["open-file-sequencing.rq".open_file_algorithm]. Workspace names and rename targets come from the ideas index under [application_memory]. Inbound hints wait for the host snapshot of that index. The inbound inlay hover is markdown. It lists each referencer as a file link. An idea hover shows styled idea content when ["../syntax/features-syntax.rq".idea_content_tooltip] is on. A closed file has no retained syntax tree. Go-to-definition cost is ["../syntax/features-syntax-highlighting.rq".reference_goto_definition_speed]. When the engine is `rust`, the server also serves `rq:[…]` document links, go-to-definition, and missing-idea diagnostics in non- `.rq` comments. One resolution supplies the link, the definition target, and the underline. The host strips file document links; Ctrl + click uses definition ( ["../syntax/features-syntax-highlighting.rq".editor_reference_activation] ). The host serves those links when the engine is `node`. Host commands prefer LSP custom requests, napi extract, and the ideas index. Move / delete planners still use Langium until index-backed planners land. The setting `reqlan.languageServer.engine` selects the binary. The default is `rust`. `node` remains only when the setting says so, or when the binary is not on disk yet. A local extension build compiles this binary with the napi addon ( [extension_host_native_stage] ). The extension launches `bin/reqlan-lsp`, else that release build. It never launches a debug build, because a debug build is slow and the extension build does not refresh it. Code actions match ["../vsc-primitives.rq".code_actions]: ignore, create below, import fixes, search or wrap, idea move and delete, and barrel page. Attribute and name catalogs drive completion. Rename and find-references use open buffers plus the ideas index. Inlay hints honour `reqlan.referencesInlayHints.enabled` and the host inbound snapshot. An import link uses the parser token span ( [import_from] ). The path links to the file. An imported idea name and its alias each link to that declaration. A namespace reference links the alias and the idea as separate names. A missing leaf reports an unresolved idea on that name. Related: [language_server], [grammar_and_parser], [analytical_rust_port], [vsix_export]. | 0.580 |
Reference labels
"../../../../azure-pipelines.yml", "../../azure-pipelines.yml", ../../../../azure-pipelines.yml, ../../azure-pipelines.yml