Cluster detail
reqlan rq/indexer
Ideas located under folder reqlan rq/indexer.
folder
63 ideas
7 files
| Idea | File | Status | Summary | Katz |
|---|---|---|---|---|
| already_cached | reqlan rq/indexer/cache-reuse.rq | Mechanisms that already reuse stored state: - Soft sync mtime skip on [ideas_schema.documents_table] ( [nonblocking_index] ) - Idle stale check that indexes only dirty paths ( [indexing_trigger_auto] ) - Git date columns on [ideas_schema.ideas_table] ( no git walk on every UI paint ) - Fuzzy search and paged Ideas Summary SQL over SQLite ( avoid full in-memory dumps when used ) [index_cache_reuse] | 0.040 | |
| avoid_full_list_all_ideas | reqlan rq/indexer/cache-reuse.rq | draft | Prefer `fuzzySearch`, paged SQL, or catalog deltas over materialising every idea. Avoid: - reference-search / wildcard panels calling `listAllIdeas` when search APIs suffice - Ideas Summary `sendFullGraph` dumping all ideas and edges ( [graphical_graph] guidance ) - repeated full-catalog pushes when only a few documents changed [index_cache_reuse] [consumers.extension_ui_consumers] | 0.051 |
| inbound_snapshot_events | reqlan rq/indexer/cache-reuse.rq | done | Host → LSP inbound snapshots are event-driven and incremental. Push only when the ideas index is ready ( catalog update, ready-edge, visible-editor change, or window focus ). While Syncing or not ready, do not push an empty batch that clears the language-server last-good map; set a deferred flag and flush on the next ready event. The language client often starts before the index — registration must ensure-open / defer, not skip forever. Each notification is a per-document merge for visible editors; URIs not in the batch stay as last-good until replaced or the document closes. After a single-file enqueue reaches ready, notify catalog so consumers get a ready-state event ( mid-sync catalog notifies alone are not enough ). Coalesce concurrent push work so catalog spam drains to one ready pass. Related: [unify_inbound_indexes], ["../extension/language/support/open-file-sequencing.rq".lazy_features_after_outbound], ["../extension/language/syntax/features-syntax-highlighting.rq".inbound_inlay_index_performance]. | 0.133 |
| index_cache_reuse | reqlan rq/indexer/cache-reuse.rq | draft | Identify where the ideas index, diagnostics store, or in-process caches already hold data that other modules recompute. Goal: one walk, one sync, one open store where possible; reuse SQLite edges and mtime maps instead of rebuilding graphs from scratch. Related: [nonblocking_index], [indexing_incrementality], [consumers.index_consumers], [sequencing.index_sequencing]. | 0.164 |
| overview_coverage_reuse | reqlan rq/indexer/cache-reuse.rq | draft | Overview coverage must not re-walk the base with `.rqignore` when a soft sync just produced an equivalent file set. Reuse the last sync document list or a cheap SQLite documents query. [index_cache_reuse] [sequencing.soft_sync] | 0.040 |
| path_completion_listing_cache | reqlan rq/indexer/cache-reuse.rq | draft | Import and anonymous file-path completion ( [import_code_completion_ranking], [anonymous_reference_code_completion], [reference_code_completion_objects] ) walk directories via [path_completion]. Reuse directory listings across keystrokes ( TTL cache ) so each keystroke does not re-walk the filesystem; clear the cache in tests and on demand. [index_cache_reuse] | 0.040 |
| reuse_sqlite_edges_for_hops | reqlan rq/indexer/cache-reuse.rq | draft | Activity bar and Ideas Summary already query hop neighbourhoods from SQLite edges. Language-server reference ranking ( [reference_code_completion_sequencing] ) rebuilds adjacency from open Langium documents in [completion_provider]. When the index is ready, completion hop ranking should prefer indexed edges ( or a shared hop API ) over a second AST-derived graph. [index_cache_reuse] [consumers.extension_ui_consumers] | 0.040 |
| single_open_store | reqlan rq/indexer/cache-reuse.rq | draft | The extension adapter owns a live [workspace_index] / SQLite connection per base. `getAnalysisApi()` / [analysis_runtime] must not open a second runtime that re-runs `ensure_ready` → `sync_workspace` when the adapter already synced. Reuse the open store for file-context, deprecation, and semantic commands. [index_cache_reuse] [consumers.extension_ui_consumers] | 0.040 |
| single_sync_walk | reqlan rq/indexer/cache-reuse.rq | done | One native directory walk records base roots, `.rq` paths, and allowlisted code paths. The walk does not read file bodies. Startup, Refresh, and create-base each run that walk once. They do not call `findFiles` and they do not run a second native `syncWorkspace` walk. Soft sync indexes the path list and skips unchanged mtimes. Idle stale check stats paths already stored in SQLite. New files arrive from the file watcher. The language server does not walk. The extension sends the base roots after the scan. Overlapping callers share one in-flight scan. CLI and MCP `sync_workspace` uses the same walk ( one pass, stop at nested bases ). [index_cache_reuse] [sequencing.soft_sync] [sequencing.scan_limits] | 0.080 |
| unify_inbound_indexes | reqlan rq/indexer/cache-reuse.rq | done | Inlay hints and code lens must read inbound edges from [ideas_schema.edges_table], not Langium IndexManager. Query: edges whose `target_id` is an idea in the open file, plus `comment_link` / `file_reference` rows whose `target_file` matches that file. File-top CodeLens uses the `file_reference` subset ( ["../extension/language/syntax/features-syntax-highlighting.rq".file_inbound_code_lens] ). The extension host runs the query and pushes a snapshot to the language server. The language server does not open SQLite ( [consumers.extension_ui_consumers] ). Updates follow index sync independently of open-file parse ( ["../language/syntax.rq".open_file_reference_sequencing], [inbound_snapshot_events] ). Mutation hooks already use the same store. Share one graph. Related: [index_cache_reuse], ["../indexer/indexer.rq".local_symbolic_analysis], ["../extension/language/syntax/features-syntax-highlighting.rq".inbound_inlay_index_performance]. | 0.213 |
| diagnostics_consumers | reqlan rq/indexer/consumers.rq | Readers of [diagnostics_schema.diagnostics_sqlite] / [index_diagnostics_store]: - Index diagnostics webview ( [diagnostics_panel] / [index_diagnostics_webview] ) - Soft / hard sync writers that append sync_runs and file_timings - Ideas Summary timeline / problem list for activity rings and file issues ( Rust schema v2 ) [index_consumers] | 0.068 | |
| extension_ui_consumers | reqlan rq/indexer/consumers.rq | VS Code surfaces that query the live ideas store through [editor_index_adapter]: - Activity bar workspace / search / minigraph / todo ( [activity_bar_host] ) - Ideas Summary panel ( [ideas_summary_panel] ) — prefer paged SQL and capped graph queries - Reference-search and wildcard-match panels ( may call `listAllIdeas`; see [cache_reuse.avoid_full_list_all_ideas] ) - Chat / AI commands that call `getFileContext`, `getLocalGraph`, or semantic search - Refactor and mutation hooks that read inbound edges from the store - Name and attribute catalog sync that pushes index rows into the language server The Rust language server may open the ideas index read-only for rename, find-references, and fallback completion. Open-file inbound inlays and file CodeLens use the host-pushed snapshot first ( no SQLite in those handlers ). [index_consumers] | 0.086 | |
| headless_consumers | reqlan rq/indexer/consumers.rq | CLI and MCP open the same per-base application memory via [analysis_runtime] / `openAnalysisApi`. They sync on activate or command ( ["./sequencing.rq".headless_sync_on_ready] ). They have no file watchers and no idle stale loop. Shared path rules: [application_memory], `REQLAN_INDEX_PATH` when set. [index_consumers] [cli_package] [mcp_server] | 0.054 | |
| index_consumers | reqlan rq/indexer/consumers.rq | done | Modules that read or write [ideas_schema.ideas_index_sqlite] / [index]: - Engine write / read: [workspace_index], Rust sync / store under [ownership] - Extension adapter: [editor_index_adapter] ( watchers, Uri conversion, multi-base ) - Headless: [analysis_runtime] for [cli_package] and [mcp_server] - Activity bar: [activity_bar_host] ( ideas-in-file, hop refs, search via fuzzy ) - Ideas Summary: [ideas_summary_panel] ( table SQL, graph slices, overview ) - Search: [fuzzy_search], [file_search] - Check / analyse / export: [check], analytical export APIs - Local graph: [local_graph_analysis] Product aliases: [index_ideas], [index_technology], [consumption]. Related: [cache_reuse.index_cache_reuse], ["./sequencing.rq".index_sequencing]. | 0.169 |
| activity_ring_tables | reqlan rq/indexer/diagnostics-schema.rq | Rust diagnostics schema v2 also keeps activity rings: - `document_updates` — Ideas Summary timeline “ index ” events ( `file_uri`, `idea_count`, `ideas`, `at` ) - `workspace_changes` — watcher create / change / delete activity ( `file_uri`, `change`, `at` ) Cap: 50 rows each ( [diagnostics_rust] `MAX_ACTIVITY` ). [diagnostics_sqlite] | 0.040 | |
| diagnostics_meta_table | reqlan rq/indexer/diagnostics-schema.rq | Table `meta` — `key TEXT PRIMARY KEY`, `value TEXT NOT NULL`. Stores `schema_version` for [diagnostics_sqlite]. | 0.040 | |
| diagnostics_sqlite | reqlan rq/indexer/diagnostics-schema.rq | done | Per-base timing and index-issue store at `<base>/.reqlan/index-diagnostics.sqlite` ( [index_diagnostics_store] / [application_memory] ). Sibling of [ideas_schema.ideas_index_sqlite]; Clear & rebuild of the ideas index must not delete it. Authoritative schema lives in Rust ( [diagnostics_rust], `DIAGNOSTICS_SCHEMA_VERSION = 2` ). The TypeScript facade ( [diagnostics_store_ts] ) is thinner and focuses on timing rows. Related: [index_diagnostics_timing], [index_diagnostics], [index_diagnostics_metrics], [index_diagnostics_webview], [sidecars.sqlite_wal_sidecars], [consumers.diagnostics_consumers]. | 0.210 |
| file_index_issues_table | reqlan rq/indexer/diagnostics-schema.rq | Table `file_index_issues` ( Rust diagnostics schema v2 ) persists parse / extract / persist problems. Columns: `file_uri`, `line`, `column`, `message`, `phase`, `idea_names`, `cause`, `at`. Cap: 500 rows. Survives editor restart for Ideas Summary problem lists. [diagnostics_sqlite] | 0.040 | |
| file_timings_table | reqlan rq/indexer/diagnostics-schema.rq | Table `file_timings` stores per-file duration rows for a sync run. Columns: `id`, `run_id` ( FK → `sync_runs` ), `file_uri`, `duration_ms`, `outcome`, `path_depth`. Indexes: `idx_file_timings_run`, `idx_file_timings_duration`. [diagnostics_sqlite] [index_diagnostics_timing] | 0.040 | |
| sync_runs_table | reqlan rq/indexer/diagnostics-schema.rq | Table `sync_runs` records one soft / hard / idle indexing pass. Columns include: `id`, `started_at`, `finished_at`, `duration_ms`, `trigger`, `total_files`, `skipped_mtime`, `indexed_files`, `error_files`, `cancelled`, `sum_file_duration_ms`, `avg_path_depth`. Retention keeps the latest 50 runs ( [diagnostics_rust] `MAX_RETAINED_RUNS` ). Feeds [index_diagnostics_metrics] and [index_diagnostics_webview]. [diagnostics_sqlite] ["./sequencing.rq".index_triggers] | 0.070 | |
| capabilities | reqlan rq/indexer/indexer.rq | Product capabilities over the [index]: [index_ideas], [index_technology], [local_graph_analysis], [semantic_analysis], [git_dates], [completion_tracking], [deprecation_impact_analysis], [index_comment_reference_inclusion], and host triggers in [graph_analysers]. Indexing performance timing and diagnostic UI: ["../extension/index-host/index-diagnostics.rq".index_diagnostics]. | 0.040 | |
| completion_tracking | reqlan rq/indexer/indexer.rq | Track and surface completion, outstanding work, and open issues across the requirement graph. Completion tracking should derive from @ status, @ tags, and other lifecycle attributes where present. | 0.050 | |
| consumption | reqlan rq/indexer/indexer.rq | Consumers of the analytical [index]: - [extension] — thin VS Code adapter [editor_index_adapter] ( file watchers, Uri conversion, UI status ) - CLI ( `["../cli/cli_package.rq".cli_package]` ) and MCP — headless [analysis_runtime] The extension does not own the indexing engine; it only hosts the adapter. Module map: [consumers.index_consumers]. | 0.146 | |
| definition | reqlan rq/indexer/indexer.rq | The indexer should live in the [core_analysis] module. On-disk schema: [sqlite_schema.ideas_index_sqlite] and [diagnostics_schema.diagnostics_sqlite]. Layout and WAL sidecars: [sidecars.reqlan_directory_layout]. Consumers: [consumers.index_consumers] ( extends [consumption] ). Sequencing and triggers: [sequencing.index_sequencing] ( extends [triggers] ). Cache reuse opportunities: [cache_reuse.index_cache_reuse]. | 0.040 | |
| deprecation_impact_analysis | reqlan rq/indexer/indexer.rq | Analyse the impact of deprecated ideas on dependent requirements. Deprecation analysis should report downstream ideas that reference or depend on deprecated items. | 0.050 | |
| git_dates | reqlan rq/indexer/indexer.rq | done | Creation and last-modified dates, and change count, for ideas via git history where available. Values are written into the ideas index by the `git_dates` analyser as a silent background job after soft-sync / catalog updates ( batched, yielded ) — not triggered by Activity Bar focus, opening Timeline, or Ideas table load. Host queue and rate caps: ["../extension/index-host/git-codelens.rq".git_dates_background_indexing]. | 0.143 |
| index | reqlan rq/indexer/indexer.rq | The ideas graph indexer: parse `.rq` with the native engine, extract ideas / edges, persist to rusqlite SQLite. Same-file `[ideaset.member]` edges target the member leaf ( ["../language/syntax.rq".references_to_subidea] ). Wildcard path + idea fan-out: [wildcard_reference_edges] ( ["../language/imports.rq".wildcard_references] ). Ideas Summary graph can hide those edges via [ideas_summary_doc] / ["../extension/workspace-summary/ideas_summary/graphical_graph.rq".wildcard_refs_toggle]. Soft mtime sync skips unchanged files. `extract_version` in the ideas index meta is the extract-rule generation. When that number does not match the engine, sync rebuilds so stale edges do not remain ( ["../language/syntax.rq".inline_code] ). Owned by [ownership]; consumed per [consumption]. | 0.587 | |
| index_code_files | reqlan rq/indexer/indexer.rq | done | Index non- `.rq` source files that contain [comment_reference] ( `rq:[idea]` / `rq:["path".idea]` ). The same directory scan records allowlisted text paths ( respecting `.rqignore`, [app_memory_doc.binary_ignore], [app_memory_doc.commentless_file_ignore], and nested child bases ). Content reads use that list. They are not a second directory walk. [app_memory_doc.text_prefix_skip] skips non-text before a full read. Binary files stay out unless a negation such as `!*.bin` opts them in. The walk cheap-filters on `rq:`, and persists matching files as documents plus `comment_link` edges. Edge shape: source = referenced idea, `target_file` = code file URI, kind `comment_link` ( no synthetic file ideas ). Reindex of a `.rq` file updates kept ideas in place, so their comment links stay. Deletion of a removed idea cascades to its links. Code documents are re-linked only when the set of idea names in that `.rq` file changes, because links resolve on names only. A body edit must not read the code files again. Watcher + idle stale check cover code documents as well as `.rq` files ( [triggers], [nonblocking_index] ). Consumers: [graph_analysers.file_related_requirements], ["../core_analysis/search.rq".file_search], ["../core_analysis/html_export.rq".html_export_code_reference_pages], Ideas Summary comment-reference rows, local graph ( idea → external file node ), ["../cli/click.rq".click_code_file]. See [index_comment_reference_inclusion], ["../ontology.rq".referenced_files]. | 0.394 |
| index_comment_reference_inclusion | reqlan rq/indexer/indexer.rq | done | Comment `rq:[…]` sites are indexed as `comment_link` edges plus first-class code-file documents, not a separate idea kind. Graph surfaces them as idea → external file nodes ( same file-node id as outbound ["../reference_types.rq".file_reference] ). Live editor links still use the comment grammar / resolver; the index path is native [index_code_files]. | 0.098 |
| index_diagnostics_timing | reqlan rq/indexer/indexer.rq | Soft sync and per-file index paths record durations into the diagnostic index under [app_memory_doc.index_diagnostics_store]. See ["../extension/index-host/index-diagnostics.rq".index_diagnostics_metrics]. Must not block [nonblocking_index]; recording failures are swallowed / logged by the store and must not fail the sync. | 0.096 | |
| index_ideas | reqlan rq/indexer/indexer.rq | Each ["../bases/base.rq".base] maintains an index of its ideas for fast lookup and navigation ( [index] ). The index should update incrementally as. rq files change within that base ( nested child bases excluded ). Persistence lives in [app_memory_doc.application_memory] per base, shared with CLI and MCP — not VS Code extension storage. Engine ownership: [workspace_index] in `@reqlan/analytical`; multi-base via BaseRegistry; editor watches via [editor_index_adapter]. | 0.173 | |
| index_technology | reqlan rq/indexer/indexer.rq | The [index_ideas] graph database is rusqlite via the core native engine. On-disk location is [app_memory_doc.application_memory] ( `<base>/.reqlan/ideas-index.sqlite` ), not `context.globalStorageUri`. Implementation: [application_memory_impl], [workspace_index], headless [analysis_runtime] for CLI / MCP, and [editor_index_adapter] for the VS Code host. | 0.152 | |
| indexer_rust | reqlan rq/indexer/indexer.rq | in-progress | The [index] engine ( parse-for-index → extract → SQLite persist → incremental sync ) should be written in Rust. Crate: `reqlan-index` over `reqlan-parse` per ["../core_analysis/rust_port.rq".rust_crate_layout]. Extractor ports ["../../crates/reqlan-index/src/extract.rs"] including [wildcard_reference_edges]. Store ports schema v4 ( ["../../packages/analytical/src/index-store/schema.ts"] ) via rusqlite; diagnostics live in `index-diagnostics.sqlite` on the same engine. Sync keeps [nonblocking_index]: per-file upsert, mtime skip, hard rebuild, cancellable progress. Not the Langium LSP. Comment-file indexing: [index_code_files]. | 0.172 |
| indexing_incrementality | reqlan rq/indexer/indexer.rq | Indexing should be incremental: watcher-driven single-file updates, and soft full syncs that skip unchanged files by stored mtime. Hard rebuilds reparse everything. Detail and UX ( progress, cancel, non-blocking UI ): [nonblocking_index]. | 0.161 | |
| local_graph_analysis | reqlan rq/indexer/indexer.rq | Provide a function to access a small slice of the graph around a given idea. | 0.118 | |
| local_symbolic_analysis | reqlan rq/indexer/indexer.rq | done | Open-file symbolic analysis must run in Rust on one file only. Input: file URI plus source text ( and optional import-root mappings ). Output: ideas in that file, import binding names in that file, outbound edges with UTF-8 source byte spans, and same-file inbound backlinks ( edges whose target is an idea declared in this file ). Import binding names let a qualified reference name an import alias ( ["../core_analysis/check.rq".check_qualified_missing_idea] ). LSP document-link and error underlines must convert those spans to UTF-16 ( ["../extension/language/syntax/features-syntax-highlighting.rq".reference_underline_syntax_align] ). Cross-file inbound still comes from SQLite via ["./cache-reuse.rq".unify_inbound_indexes]. Do not read SQLite. Do not walk other workspace documents. Do not load an idea catalog. The open-buffer model is ["../extension/language/support/open-file-sequencing.rq".ast_lifecycle]. The hot path parses this buffer once. It does not run this extract as a second parse. Import-target confirmation is a separate depth-1 parse ( ["../extension/language/support/open-file-sequencing.rq".outbound_one_hop] ). That parse is not this extract. The language server caches the open buffer by URI plus text fingerprint ( ["../extension/language/support/open-file-sequencing.rq".open_file_hot_path] ). Wildcard forms stay one `wildcard_reference` pattern edge ( unresolved ); sync still expands them later via [wildcard_reference_edges]. Flag: `ExtractOptions.local_symbolic` forces an empty candidate list. CLI: ["../cli/cli_package.rq".commands] `analyse --local-symbolic <file>`. Sidebar: ["../extension/local-context/activitybar-panels/current_context_scope.rq".reference_lists_pane] merges live same-file inbound / outbound with indexed refs ( [local_symbolic_sidebar] ). Related: ["../language/syntax.rq".open_file_reference_sequencing], [index], ["./cache-reuse.rq".unify_inbound_indexes]. | 0.387 |
| local_symbolic_sidebar | reqlan rq/indexer/indexer.rq | done | The activity bar reference lists and current-file scope must consume [local_symbolic_analysis] for the open buffer text so same-file inbound backlinks and outbound refs appear even when the SQLite index is stale or not ready. Merge live local rows with indexed `listReferencesForIdea` / hop-depth rows; dedupe by direction plus edge id ( and by idea id for scope idea chips ). Prefer the referencer name as the inbound label ( not the edge target label ). | 0.108 |
| nonblocking_index | reqlan rq/indexer/indexer.rq | done | Index sync must stay non-blocking for the host UI ( notably [activity_bar_doc.activity_bar] and [workspace_pane_doc.workspace_loading] ). Editor startup is gated by ["../extension/host/activation.rq".first_paint_startup]; discovering a base must not construct Langium services, which are initialized lazily on the first parse. While syncing, surface progress — state, processed / total, and the current file — in [workspace_pane_doc.workspace_pane] and [ideas_summary_doc.index_panel]. In-flight sync must be cancellable from those surfaces; cancel keeps already-indexed rows and returns the index to ready. Incremental behaviour ( see also [indexing_incrementality] ): - Single-file create / change / delete via watchers indexes only that file — never a full base walk. - Soft full sync ( `syncWorkspace` / Refresh ) skips parse + persist when the file's mtime matches the value stored on the documents row. - Hard refresh ( `clearAndRebuildIndex` / Clear & rebuild ) wipes the store and reindexes every file. - Every sync and stale check applies `.rqignore` to the paths it receives, the same as the base walk; the native single-file index also drops an ignored path. Thus base discovery cannot make the first sync index ignored files. Implemented by [workspace_index]; editor adapter [editor_index_adapter]. | 0.372 |
| ownership | reqlan rq/indexer/indexer.rq | The [index] / indexer lives in `packages/analytical` ( `@reqlan/analytical` ). Canonical single-base engine: [workspace_index] ( `WorkspaceIndex` facade ). Sync / idle impl: [workspace_index_sync]; one-file parse + persist: [workspace_index_file]; mtime stale diff: [workspace_mtime]. Multi-base registry: one `WorkspaceIndex` per discovered ["../bases/base.rq".base] under [app_memory_doc.application_memory] ( `<base>/.reqlan/` ). Headless entry: [analysis_runtime] via native-only `openAnalysisApi` ( CLI / MCP ). On-disk store path: [application_memory_impl] under `<base>/.reqlan/` — see [app_memory_doc.application_memory]. | 0.237 | |
| semantic_analysis | reqlan rq/indexer/indexer.rq | Search the graph for ideas related to a given idea or ideaset. | 0.050 | |
| triggers | reqlan rq/indexer/indexer.rq | Index refresh behaviour: - [indexing_incrementality] / [nonblocking_index] — incremental where possible - [graph_analysers.indexing_trigger_filesave] / [app_memory_doc.idea_index_triggers] — on `.rq` or indexed code-file change - [graph_analysers.indexing_trigger_manual] — manual reindex commands - [graph_analysers.indexing_trigger_open] — one soft sync after the activity-bar first-paint gate - [graph_analysers.indexing_trigger_auto] — idle background mtime staleness check ( cheap; not a full reindex ) Editor watches + idle scheduler: [editor_index_adapter]; headless syncs on runtime activate. Full sequence: [sequencing.index_sequencing]. | 0.148 | |
| wildcard_reference_edges | reqlan rq/indexer/indexer.rq | done | Native extract ( `["../../crates/reqlan-index/src/extract.rs"]` ) expands each AST wildcard against the idea catalog ( `match_wildcard` / workspace candidate list ). Persist one edge of kind `wildcard_reference` per matching idea ( label = target idea name ); never emit plain `references` for wildcard forms. Zero matches → one unresolved edge of the same kind ( `isResolved: false`, label = pattern text ). Edge ids use `edgeId(source, 'wildcard_reference', targetOrUnresolvedKey)`. Sync walks sorted `.rq` files and grows the catalog as it goes, so a wildcard file is expanded against ideas already stored plus files earlier in that walk ( ["../../crates/reqlan-index/src/sync.rs"] ). Ancestor / reference-chain walks treat `wildcard_reference` like `references` ( ["../../packages/analytical/src/index-store/sqlite-store.ts"] ). Ideas Summary references table groups them under sub-idea with other idea-to-idea links; graph visibility is [ideas_summary_doc] / ["../extension/workspace-summary/ideas_summary/graphical_graph.rq".wildcard_refs_toggle]. Soft mtime sync skips unchanged files — after introducing this edge kind, reindex ( or touch ) `.rq` files that contain wildcards so stored rows leave any legacy `references` fan-out. Langium `idea-extractor` keeps the same kind for remaining TS extract paths. Open-file local extract ( [local_symbolic_analysis] ) does not expand wildcards against a catalog. Related: ["../language/imports.rq".wildcard_references], [index], [indexer_rust], ["../extension/workspace-summary/ideas_summary/graphical_graph.rq".wildcard_refs_toggle], [local_symbolic_analysis]. | 0.353 |
| base_catch_up | reqlan rq/indexer/sequencing.rq | Activating or pinning a base schedules an open + soft sync when that base is not ready. Nested child bases stay excluded from the parent walk ( [index] ). [index_sequencing] [indexing_trigger_open] | 0.040 | |
| extension_startup_sequence | reqlan rq/indexer/sequencing.rq | Extension host order ( [first_paint_startup], [background_startup] ): 1. `activate` registers UI only; it must not await index sync. 2. Activity bar paints → startup gate; language client may start on a short fallback. 3. Index adapter activates after paint ( or a short fallback timer ). 4. One native scan ( [cache_reuse.single_sync_walk], [scan_limits] ) records bases and file paths. Soft [soft_sync] then runs for the **active** base only ( [indexing_trigger_open] ); other bases stay closed until pin / focus / file events ( ["../extension/index-host/sqlite-artifact-lifecycle.rq".event_driven_base_access] ). 5. Install watchers for `.rq` and code globs; watch `.reqlan` marker create / delete for rediscovery ( not SQLite child writes ). 6. Idle timer runs [idle_stale_check] on already-open bases, then releases unused SQLite artifacts ( ["../extension/index-host/sqlite-artifact-lifecycle.rq".release_when_idle] ). [index_sequencing] [editor_index_adapter] Open-file editor links follow ["../extension/language/support/open-file-sequencing.rq".open_file_algorithm] and must not wait for this crawl. | 0.054 | |
| hard_rebuild | reqlan rq/indexer/sequencing.rq | Hard rebuild ( `clearAndRebuildIndex` / Clear & rebuild ) wipes ideas-index rows and reindexes every file. It must not delete [diagnostics_schema.diagnostics_sqlite]. Trigger: [indexing_trigger_manual]. [index_sequencing] [nonblocking_index] | 0.040 | |
| headless_sync_on_ready | reqlan rq/indexer/sequencing.rq | CLI and MCP call [analysis_runtime] `ensure_ready`, which runs a soft [soft_sync] from [cache_reuse.single_sync_walk] once before serving commands. No watchers and no idle loop ( [consumers.headless_consumers] ). [index_sequencing] | 0.054 | |
| idle_stale_check | reqlan rq/indexer/sequencing.rq | When the editor is idle, use document paths already stored in SQLite ( do not scan the tree ), load mtimes in one SQLite read, compare FS mtimes in memory, and index only mismatched or new files; drop deleted docs in one batch. If nothing is stale: no state transition, no progress UI, no parse. Prefer unfocused windows; cancel if the user becomes active again. Only bases that are already open participate — idle must not reopen every discovered base ( ["../extension/index-host/sqlite-artifact-lifecycle.rq".release_when_idle] ). After the check, release unused SQLite artifacts ( inactive bases always; all bases when unfocused ). Extension host only — see [indexing_trigger_auto]. [index_sequencing] | 0.075 | |
| index_sequencing | reqlan rq/indexer/sequencing.rq | done | Describe when the ideas index starts, updates, and idles, and which trigger owns each pass. Capability aliases live in [triggers] and [idea_index_triggers]. Detail ideas below; keep [nonblocking_index] and [indexing_incrementality] as the UX rules. Related: [consumers.index_consumers], [cache_reuse.index_cache_reuse], [ideas_schema.documents_table], [diagnostics_schema.sync_runs_table]. | 0.179 |
| index_triggers | reqlan rq/indexer/sequencing.rq | Trigger map for [index_sequencing]: - [indexing_trigger_open] — one soft sync after activity-bar first paint / base activate - [indexing_trigger_filesave] — watcher create / change / delete on `.rq` and allowlisted code files - [indexing_trigger_manual] — Refresh ( soft ) or Clear & rebuild ( hard ) - [indexing_trigger_auto] — idle mtime stale check; index only dirty paths Git-dates fill is not an index trigger ( [idea_index_triggers] ). Each sync run may record a `trigger` string in [diagnostics_schema.sync_runs_table]. | 0.049 | |
| scan_limits | reqlan rq/indexer/sequencing.rq | done | The workspace scan has two caps. There is no unlimited setting. Defaults and clamp bounds are the `scan` object in ["../../packages/analytical/src/core/defaults.json"]. `reqlan.scan.maxDepth` uses `defaultMaxDepth`, `minDepth`, and `maxDepthLimit` from that file. The workspace folder is depth 0. A directory deeper than the cap is not entered. `reqlan.scan.maxEntries` uses `defaultMaxEntries`, `minEntries`, and `maxEntriesLimit` from that file. The count is directories plus files visited. When a cap hits, the walk stops, keeps the partial result, and the editor shows a warning. It does not start another scan to finish. Refresh uses the same caps. CLI and MCP use the same defaults. Built-in ignore also skips `target/` so a Cargo tree does not consume the entry budget. [extension_startup_sequence] [cache_reuse.single_sync_walk] | 0.064 |
| soft_sync | reqlan rq/indexer/sequencing.rq | Soft full sync ( `syncWorkspace` / Refresh ) indexes the path list from [cache_reuse.single_sync_walk]. It skips files whose FS mtime matches [ideas_schema.documents_table]. `mtime_ms`, and upserts changed files only. Progress and cancel follow [nonblocking_index]. Prefer a single walk ( [cache_reuse.single_sync_walk] ). Triggers: [indexing_trigger_open], [indexing_trigger_manual] ( Refresh ). [index_sequencing] | 0.081 | |
| watcher_incremental | reqlan rq/indexer/sequencing.rq | File create / change / delete indexes or deletes that one path only — never a full base walk. Covers `.rq` sources and allowlisted code files for [index_code_files]. Trigger: [indexing_trigger_filesave]. [index_sequencing] [indexing_incrementality] | 0.040 | |
| json_siblings | reqlan rq/indexer/sidecars.rq | JSON files under `.reqlan/` are application-memory siblings, not SQLite sidecars: - `config.json` — base import roots and settings ( [base_configuration] ) - `export_settings.json` — export form defaults for [export_webview] They do not hold idea graph rows. Tools must not treat them as index cache. [reqlan_directory_layout] | 0.063 | |
| reqlan_directory_layout | reqlan rq/indexer/sidecars.rq | done | Each base owns `<base>/.reqlan/` ( [application_memory] ). Contents: - `ideas-index.sqlite` — [ideas_schema.ideas_index_sqlite] - `index-diagnostics.sqlite` — [diagnostics_schema.diagnostics_sqlite] / [index_diagnostics_store] - `click-sessions.sqlite` — ["../cli/click.rq".click_session] - SQLite WAL / SHM / journal sidecars — [sqlite_wal_sidecars] - `config.json` — [json_siblings] / [base_configuration] - `.rqignore` — [rqignore] - `.gitignore` — [base_initialisation_ignore] / [vcs_ignore_for_stores] - `export_settings.json` — [json_siblings] Path helpers: [application_memory_impl]. Override: `REQLAN_INDEX_PATH` for a single store. | 0.177 |
| sqlite_wal_sidecars | reqlan rq/indexer/sidecars.rq | done | When a SQLite file opens in WAL mode, the engine may create sibling files next to the DB: - `ideas-index.sqlite-wal` / `ideas-index.sqlite-shm` / `ideas-index.sqlite-journal` - `index-diagnostics.sqlite-wal` / `-shm` / `-journal` - `click-sessions.sqlite-wal` / `-shm` / `-journal` These are true sidecars of the open database, not separate product stores. Index walks skip them through [rqignore] ( `*.sqlite-wal`, `*.sqlite-shm`, `*.sqlite-journal`, and the same suffixes on `.sqlite3`, `.db`, and `.db3` ). Seeded `.reqlan/.gitignore` must keep `*.sqlite*` artifacts out of VCS ( [base_initialisation_ignore], [ignore_rust] `default_gitignore_file_contents` ). [reqlan_directory_layout] [ideas_schema.schema_migrations] | 0.138 |
| vcs_ignore_for_stores | reqlan rq/indexer/sidecars.rq | New bases seed `.reqlan/.gitignore` so SQLite databases and their WAL / SHM / journal sidecars stay out of version control ( [base_initialisation_ignore] ). `.rqignore` is separate: it filters discovery / index walks, not VCS ( [rqignore] ). [sqlite_wal_sidecars] [reqlan_directory_layout] | 0.063 | |
| documents_table | reqlan rq/indexer/sqlite-schema.rq | Table `documents` tracks which files the indexer has seen. Columns: - `file_uri` TEXT PRIMARY KEY — base-relative path - `content_hash` TEXT NOT NULL - `indexed_at` TEXT NOT NULL - `mtime_ms` REAL ( schema v3 ) — soft sync skip when FS mtime matches Soft sync and idle stale checks use this table ( ["./sequencing.rq".soft_sync], ["./sequencing.rq".idle_stale_check] ). [ideas_index_sqlite] | 0.080 | |
| edge_kinds | reqlan rq/indexer/sqlite-schema.rq | Persisted edge `kind` values ( [index_types] / analytical `EdgeKind` ): - `references` — idea → idea bracket or wiki reference - `wildcard_reference` — one row per wildcard match ( or one unresolved row ) - `file_reference` — idea → file path reference - `ideaset_member` — ideaset → member idea - `import` — import relationship - `comment_link` — idea ← code-file `rq:` comment ( ["./indexer.rq".index_code_files] ) [edges_table] | 0.051 | |
| edges_table | reqlan rq/indexer/sqlite-schema.rq | Table `edges` stores directed links in the ideas graph. Columns: - `id` TEXT PRIMARY KEY - `source_id` TEXT NOT NULL — FOREIGN KEY → `ideas(id)` ON DELETE CASCADE - `target_id` TEXT nullable — idea target when resolved - `target_file` TEXT nullable — file target ( for example comment links ) - `kind` TEXT NOT NULL — see [edge_kinds] - `label` TEXT nullable - `source_line` INTEGER ( schema v2 ) - `snippet` TEXT ( schema v2 ) - `is_resolved` INTEGER NOT NULL DEFAULT 1 ( schema v2 ) Indexes: `idx_edges_source`, `idx_edges_target`, `idx_edges_target_file`. [ideas_index_sqlite] ["./indexer.rq".wildcard_reference_edges] ["./indexer.rq".index_code_files] | 0.082 | |
| ideas_index_sqlite | reqlan rq/indexer/sqlite-schema.rq | done | The ideas graph for one [base_ownership] lives at `<base>/.reqlan/ideas-index.sqlite` under [application_memory]. Schema version is in ( `SCHEMA_VERSION` in [schema_ts] and [schema_rust] ). Runtime migrate runs in Rust ( [store_rust] ); TypeScript opens the store and calls native migrate ( [sqlite_store] ). Keep [schema_ts] aligned with [schema_rust]. Related: [index], [indexer_rust], [ownership], [sidecars.sqlite_wal_sidecars], [diagnostics_schema.diagnostics_sqlite], [consumers.index_consumers]. | 0.226 |
| ideas_table | reqlan rq/indexer/sqlite-schema.rq | Table `ideas` stores one row per idea, one-liner, or ideaset. Columns: - `id` TEXT PRIMARY KEY - `name` TEXT NOT NULL - `kind` TEXT NOT NULL — `block` | `oneliner` | `ideaset` ( [index_types] ) - `file_uri` TEXT NOT NULL — path relative to the owning base root - `line_start` / `line_end` INTEGER NOT NULL - `summary` TEXT NOT NULL - `attributes_json` TEXT NOT NULL DEFAULT `'{}'` - `content_hash` TEXT NOT NULL - `git_created_at` / `git_modified_at` TEXT nullable - `git_change_count` INTEGER nullable ( schema v4 ) Indexes: `idx_ideas_file(file_uri)`, `idx_ideas_name(name)`. [ideas_index_sqlite] ["../extension/index-host/git-codelens.rq".git_dates_background_indexing] | 0.045 | |
| meta_table | reqlan rq/indexer/sqlite-schema.rq | Table `meta` holds key / value rows ( `key TEXT PRIMARY KEY`, `value TEXT NOT NULL` ). Known keys: - `schema_version` — string form of [ideas_index_sqlite] version ( `"4"` ). - `extract_version` — extract-rule generation from the native engine. When it does not match the running engine, soft sync rebuilds so stale edges do not remain ( ["./indexer.rq".index], ["../language/syntax.rq".inline_code] ). [ideas_index_sqlite] | 0.040 | |
| schema_migrations | reqlan rq/indexer/sqlite-schema.rq | Base tables use `CREATE … IF NOT EXISTS` ( [schema_ts] `BASE_MIGRATIONS` / [schema_rust] ). Versioned upgrades run `(current+1)..=SCHEMA_VERSION`: - v2 — edge `source_line`, `snippet`, `is_resolved` - v3 — document `mtime_ms` - v4 — idea `git_change_count` Duplicate-column errors on ALTER are ignored so re-open is safe. Fresh databases create full v4 columns, then set `schema_version` to 4. Open pragmas: `foreign_keys=ON`, `journal_mode=WAL` ( [sidecars.sqlite_wal_sidecars] ). [ideas_index_sqlite] | 0.058 |
Cluster graph
Initialising graph…