@spikedpunch/mast 0.1.0

package/assets/skill.md

@@ -0,0 +1,45 @@
+# Using MAST
+
+You have MAST tools for navigating this codebase. MAST parses **TypeScript, JavaScript,
+and Markdown** into an AST-level index and answers structural questions from a symbol
+graph, so prefer it over reading files or grepping.
+
+## Rules
+
+- Call `mast_status` at the start of a session to confirm the index is fresh.
+- **Search before opening any file.** No file path without a MAST result behind it.
+- **Use code tokens in queries** — function names, type names, column names.
+  `createTable uuid primaryKey` beats `migration pattern`. An exact symbol name in the
+  query anchors its declaration to the top.
+- When a query returns nothing, **change vocabulary — do not repeat it**.
+- Call `mast_reindex` after writing files, to keep the index current.
+
+## Picking the right tool
+
+| tool | use it for |
+|---|---|
+| `mast_search` | lexical BM25 + declaration-exact discovery |
+| `mast_signature` | a symbol's declaration and resolved parameter types |
+| `mast_callers` | who calls a function — run before any refactor |
+| `mast_implementors` | which classes implement an interface |
+| `mast_exports` | a module's public API, without reading the file |
+| `mast_dependencies` | what a file imports, and what it re-exports |
+| `mast_project_skeleton` | a directory map of all exported symbols |
+| `mast_rename_impact` | rename checklist: verified callers, review sites, barrel exports |
+| `mast_efficiency` | token accounting for the session |
+| `mast_status` | index freshness and health |
+| `mast_reindex` | refresh the index after edits |
+
+## Reading the answers honestly
+
+MAST reports what it does not know, and those signals are load-bearing:
+
+- A result carrying **`file_busy_returning_stale_cache`** or a staleness flag means the
+  answer may predate the file on disk. Do not treat it as current.
+- A **`truncated`** or **`potential_truncated`** flag means the set was capped. The real
+  count is larger than what you were shown.
+- An **empty result is not proof of absence.** MAST indexes TypeScript, JavaScript, and
+  Markdown only — a symbol defined in Python, Go, Java, or any other language is absent
+  from the index, not absent from the repository. Check the flags before concluding
+  "it isn't there", and never delete or rewrite code on the strength of an empty result
+  alone.

package/dist/ast/extract.d.ts

@@ -0,0 +1,65 @@
+import type { FileExtraction, IdentifierRow } from './extractor.js';
+import type { Chunk } from './types.js';
+import { type ExtractedSignature } from './extractors/typescript.js';
+export type { ExtractedSignature } from './extractors/typescript.js';
+export declare function supportsExtension(extension: string): boolean;
+export type ExtractResult = FileExtraction;
+/**
+ * Extract chunks, symbols, imports, edges, and identifier rows from a single
+ * file, dispatching to the registered extractor for its extension.
+ *
+ * Throws if the file cannot be read. On parse errors the caller should catch
+ * and log at `warn` level per §7.1 (never abort the full run).
+ */
+export declare function extractFile(filePath: string, projectRoot: string, contextLines: number, chunkSplitThreshold: number, markdownHeadingDepth?: number): ExtractResult;
+/**
+ * Disambiguate `chunk_id` collisions within one file's chunk list. The first
+ * chunk seen for a given id keeps it; the 2nd+ occurrence gets a namespaced
+ * ordinal suffix, assigned in stable source order so two runs over identical
+ * input produce identical ids (§7.1 determinism).
+ *
+ * The preimage is `${file_path}:${start_line}#dup:${n}` — NOT the raw
+ * `file:start:n` — because that would collide with the existing sub-chunk id
+ * scheme `sha256(file:startLine:subIndex)` (typescript.ts, `pushChunks`).
+ * `#dup` namespaces the two preimage families apart. Content-hash ids were
+ * rejected: they would break the documented "a content edit keeps the same
+ * chunk_id" contract that `vectorKey` (embedder.ts) and `isFileUnchanged`
+ * (indexer/index.ts) depend on. A `(file, start, end, type)` composite was
+ * also rejected — it still collides when multiple same-type siblings share
+ * one line (see lab3.ts in GITNEXUS_COMPARISON.md §15.3).
+ */
+export declare function dedupeChunkIds(chunks: readonly Chunk[]): readonly Chunk[];
+/**
+ * Re-key `identifierRows` (produced by the extractor against pre-dedup
+ * `chunk_id`s) to the post-dedup ids from `dedupeChunkIds`, so
+ * `identifier_fts` rows stay attributable to the right chunk.
+ *
+ * **Positional**, not keyed by `chunk_id` — which is exactly the point. Before
+ * dedup a `chunk_id` does NOT identify a chunk uniquely (that is what dedup is
+ * for), so a row carrying a colliding id names a *group*, not a member. The
+ * previous implementation resolved that ambiguity with a per-id FIFO and was
+ * exact only while every chunk in a group also produced a row — an invariant
+ * stated in this comment and enforced by nothing. It held in practice (measured:
+ * zero violations over n8n at its pinned SHA, 19,056 files / 4 collision groups,
+ * and mast's own src, 130 files), but it rested on an argument about identifier
+ * emission inside a 1,637-line extractor rather than on anything a compiler or a
+ * test could see. `FileExtraction.identifierRows` now carries one row per chunk,
+ * so the correspondence is total and this function is a zip (D040).
+ *
+ * @throws Error if the list is neither empty nor one-per-chunk. That is a broken
+ * extractor contract, not a data condition: it is caught per-file by `runIndex`,
+ * counted as a parse error, and retried — loudly, rather than writing identifier
+ * rows onto the wrong chunk where nothing downstream could detect it.
+ */
+export declare function remapIdentifierRows(originalChunks: readonly Chunk[], dedupedChunks: readonly Chunk[], identifierRows: readonly IdentifierRow[]): readonly IdentifierRow[];
+/**
+ * Extract body-free signatures (with params + return type) for every symbol in
+ * a file. Used by `mast_signature` and `mast_exports` at query time so they
+ * report declarations, not function bodies (§10.2). Returns `[]` for
+ * unsupported extensions or on parse failure.
+ *
+ * Deliberately TypeScript-only: signatures are a code concept, and doc chunks
+ * have none — a non-TS extension takes the same `[]` path as an unsupported one.
+ */
+export declare function extractFileSignatures(absPath: string): readonly ExtractedSignature[];
+//# sourceMappingURL=extract.d.ts.map

package/dist/ast/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../src/ast/extract.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAqB,cAAc,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACvF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAkD,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAGrH,YAAY,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAkBrE,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE5D;AAMD,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC;AAE3C;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,mBAAmB,EAAE,MAAM,EAC3B,oBAAoB,SAAI,GACvB,aAAa,CAsCf;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,SAAS,KAAK,EAAE,CAQzE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,SAAS,KAAK,EAAE,EAChC,aAAa,EAAE,SAAS,KAAK,EAAE,EAC/B,cAAc,EAAE,SAAS,aAAa,EAAE,GACvC,SAAS,aAAa,EAAE,CAe1B;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,kBAAkB,EAAE,CAUpF"}

package/dist/ast/extract.js

@@ -0,0 +1,147 @@
+import { extname } from 'node:path';
+import { readFileSync, statSync } from 'node:fs';
+import { parseSource } from './parser.js';
+import { TypeScriptExtractor, extractSignatures, sha256 } from './extractors/typescript.js';
+import { MarkdownExtractor } from './extractors/markdown.js';
+// ---------------------------------------------------------------------------
+// Extractor registry
+// ---------------------------------------------------------------------------
+// Adding a language = adding one entry here. Each extractor owns its full
+// extraction story (parsing included) behind the LanguageExtractor contract,
+// so the pipeline never branches on language.
+const EXTRACTORS = [new TypeScriptExtractor(), new MarkdownExtractor()];
+const EXT_TO_EXTRACTOR = new Map();
+for (const ext of EXTRACTORS) {
+    for (const extension of ext.extensions) {
+        EXT_TO_EXTRACTOR.set(extension, ext);
+    }
+}
+export function supportsExtension(extension) {
+    return EXT_TO_EXTRACTOR.has(extension);
+}
+/**
+ * Extract chunks, symbols, imports, edges, and identifier rows from a single
+ * file, dispatching to the registered extractor for its extension.
+ *
+ * Throws if the file cannot be read. On parse errors the caller should catch
+ * and log at `warn` level per §7.1 (never abort the full run).
+ */
+export function extractFile(filePath, projectRoot, contextLines, chunkSplitThreshold, markdownHeadingDepth = 2) {
+    const extension = extname(filePath);
+    const extractor = EXT_TO_EXTRACTOR.get(extension);
+    if (extractor === undefined) {
+        throw new Error(`No extractor registered for extension "${extension}"`);
+    }
+    const src = readFileSync(filePath, 'utf-8');
+    const mtime = statSync(filePath).mtimeMs / 1_000;
+    // Relative path for chunk IDs and stored file_path field.
+    const relativePath = filePath.startsWith(projectRoot)
+        ? filePath.slice(projectRoot.length).replace(/^\//, '')
+        : filePath;
+    const extraction = extractor.extract(src, relativePath, mtime, {
+        projectRoot,
+        contextLines,
+        chunkSplitThreshold,
+        markdownHeadingDepth,
+    });
+    // Collision guard (GITNEXUS_COMPARISON.md §15.3): genuine same-line
+    // siblings — multiple real declarations sharing one physical line (e.g.
+    // several methods on one line), or generated/minified files where every
+    // top-level statement shares start_line — produce identical chunk_ids
+    // under the position-based `sha256(file:start_line)` scheme. Applied here,
+    // the one dispatch chokepoint, so every extractor (typescript, markdown) is
+    // covered without scattering disambiguation through individual chunkId
+    // call sites. The first chunk at a given id is left unchanged, so the
+    // ~99.97% of files with no collision see zero id churn.
+    const chunks = dedupeChunkIds(extraction.chunks);
+    // Re-key BEFORE dropping empties: the re-keying is positional, and filtering
+    // first is what destroys the position (D040).
+    const identifierRows = remapIdentifierRows(extraction.chunks, chunks, extraction.identifierRows)
+        .filter((row) => row.identifiers.length > 0);
+    return { ...extraction, chunks, identifierRows };
+}
+/**
+ * Disambiguate `chunk_id` collisions within one file's chunk list. The first
+ * chunk seen for a given id keeps it; the 2nd+ occurrence gets a namespaced
+ * ordinal suffix, assigned in stable source order so two runs over identical
+ * input produce identical ids (§7.1 determinism).
+ *
+ * The preimage is `${file_path}:${start_line}#dup:${n}` — NOT the raw
+ * `file:start:n` — because that would collide with the existing sub-chunk id
+ * scheme `sha256(file:startLine:subIndex)` (typescript.ts, `pushChunks`).
+ * `#dup` namespaces the two preimage families apart. Content-hash ids were
+ * rejected: they would break the documented "a content edit keeps the same
+ * chunk_id" contract that `vectorKey` (embedder.ts) and `isFileUnchanged`
+ * (indexer/index.ts) depend on. A `(file, start, end, type)` composite was
+ * also rejected — it still collides when multiple same-type siblings share
+ * one line (see lab3.ts in GITNEXUS_COMPARISON.md §15.3).
+ */
+export function dedupeChunkIds(chunks) {
+    const occurrences = new Map();
+    return chunks.map((chunk) => {
+        const occurrence = occurrences.get(chunk.chunk_id) ?? 0;
+        occurrences.set(chunk.chunk_id, occurrence + 1);
+        if (occurrence === 0)
+            return chunk;
+        return { ...chunk, chunk_id: sha256(`${chunk.file_path}:${chunk.start_line}#dup:${occurrence}`) };
+    });
+}
+/**
+ * Re-key `identifierRows` (produced by the extractor against pre-dedup
+ * `chunk_id`s) to the post-dedup ids from `dedupeChunkIds`, so
+ * `identifier_fts` rows stay attributable to the right chunk.
+ *
+ * **Positional**, not keyed by `chunk_id` — which is exactly the point. Before
+ * dedup a `chunk_id` does NOT identify a chunk uniquely (that is what dedup is
+ * for), so a row carrying a colliding id names a *group*, not a member. The
+ * previous implementation resolved that ambiguity with a per-id FIFO and was
+ * exact only while every chunk in a group also produced a row — an invariant
+ * stated in this comment and enforced by nothing. It held in practice (measured:
+ * zero violations over n8n at its pinned SHA, 19,056 files / 4 collision groups,
+ * and mast's own src, 130 files), but it rested on an argument about identifier
+ * emission inside a 1,637-line extractor rather than on anything a compiler or a
+ * test could see. `FileExtraction.identifierRows` now carries one row per chunk,
+ * so the correspondence is total and this function is a zip (D040).
+ *
+ * @throws Error if the list is neither empty nor one-per-chunk. That is a broken
+ * extractor contract, not a data condition: it is caught per-file by `runIndex`,
+ * counted as a parse error, and retried — loudly, rather than writing identifier
+ * rows onto the wrong chunk where nothing downstream could detect it.
+ */
+export function remapIdentifierRows(originalChunks, dedupedChunks, identifierRows) {
+    if (identifierRows.length === 0)
+        return identifierRows;
+    if (identifierRows.length !== originalChunks.length || dedupedChunks.length !== originalChunks.length) {
+        throw new Error(`identifier row remap requires one identifier row per chunk: got ${identifierRows.length} rows, ` +
+            `${originalChunks.length} chunks, ${dedupedChunks.length} deduped chunks`);
+    }
+    return identifierRows.map((row, i) => {
+        const deduped = dedupedChunks[i];
+        if (deduped === undefined || deduped.chunk_id === row.chunk_id)
+            return row;
+        return { ...row, chunk_id: deduped.chunk_id };
+    });
+}
+/**
+ * Extract body-free signatures (with params + return type) for every symbol in
+ * a file. Used by `mast_signature` and `mast_exports` at query time so they
+ * report declarations, not function bodies (§10.2). Returns `[]` for
+ * unsupported extensions or on parse failure.
+ *
+ * Deliberately TypeScript-only: signatures are a code concept, and doc chunks
+ * have none — a non-TS extension takes the same `[]` path as an unsupported one.
+ */
+export function extractFileSignatures(absPath) {
+    const extension = extname(absPath);
+    if (!(EXT_TO_EXTRACTOR.get(extension) instanceof TypeScriptExtractor))
+        return [];
+    try {
+        const src = readFileSync(absPath, 'utf-8');
+        const tree = parseSource(src, extension);
+        return extractSignatures(tree, src);
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=extract.js.map

package/dist/ast/extract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.js","sourceRoot":"","sources":["../../src/ast/extract.ts"],"names":[],"mappings":"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"}

package/dist/ast/extractor.d.ts

@@ -0,0 +1,85 @@
+import type { Chunk, Language, SymbolRecord, ImportRecord, EdgeRecord } from './types.js';
+/**
+ * One `identifier_fts` row: the identifier tokens extracted from a chunk.
+ * Produced by the extractor (not the graph layer) because what counts as an
+ * "identifier" is a language-level judgment — e.g. markdown prose contributes
+ * none, since a doc that merely mentions a symbol name is not a call site.
+ */
+export interface IdentifierRow {
+    readonly chunk_id: string;
+    /** Space-separated identifier tokens for the FTS index. */
+    readonly identifiers: string;
+}
+/**
+ * File-level `export * from './x'` (star barrel re-export). Named re-exports
+ * need no dedicated record — they ride the existing symbols + edges pipeline
+ * (a marker symbol of kind `export` plus a RE_EXPORTS edge, §10.1). Stars
+ * have no per-symbol identity, so they persist as `re_export_files` rows.
+ */
+export interface StarReExportRecord {
+    readonly module: string;
+    /** Resolved relative path for intra-monorepo targets; null for external. */
+    readonly resolvedPath: string | null;
+    /** 1-indexed source line of the `export *` statement. */
+    readonly line: number;
+}
+/**
+ * Everything the indexing pipeline needs from one source file. Each extractor
+ * owns the full story for its language: languages without a symbol graph
+ * (markdown) return empty `symbols` / `edges` / … and the pipeline needs no
+ * per-language branches.
+ */
+export interface FileExtraction {
+    /** Concrete language of THIS file — may differ from the extractor's primary
+     *  language (the TypeScript extractor also handles `.js`/`.jsx`). */
+    readonly language: Language;
+    readonly chunks: readonly Chunk[];
+    readonly symbols: readonly SymbolRecord[];
+    readonly imports: readonly ImportRecord[];
+    readonly edges: readonly EdgeRecord[];
+    /**
+     * Either empty, or **exactly one row per chunk, in chunk order** — including
+     * chunks whose identifier bag is empty. `extractFile` relies on that positional
+     * correspondence to re-key rows after `dedupeChunkIds`, and drops the empty ones
+     * afterwards; a partial list cannot be re-keyed, because `chunk_id` does not
+     * identify a chunk uniquely before dedup (D040).
+     */
+    readonly identifierRows: readonly IdentifierRow[];
+    readonly starReExports: readonly StarReExportRecord[];
+}
+/** Per-run knobs passed to every extractor; each reads what applies to it. */
+export interface ExtractorOptions {
+    /** Absolute project root — used for import specifier resolution (§13.7). */
+    readonly projectRoot: string;
+    /** Source lines expanded around AST boundaries in stored content. */
+    readonly contextLines: number;
+    /** Lines above which a declaration/section splits into sub-chunks (§10.1). */
+    readonly chunkSplitThreshold: number;
+    /** Max ATX heading level that starts a markdown doc chunk (§10.1). */
+    readonly markdownHeadingDepth: number;
+}
+/**
+ * Contract every language extractor must satisfy.
+ *
+ * Parsing strategy is the implementer's concern — the TypeScript extractor
+ * parses with tree-sitter internally, the markdown extractor line-scans. The
+ * pipeline (extract.ts) only dispatches by extension and consumes the
+ * `FileExtraction`; it never special-cases a language.
+ */
+export interface LanguageExtractor {
+    /** Primary language identifier for this extractor. */
+    readonly language: Language;
+    /** File extensions this extractor handles (e.g. `['.ts', '.tsx']`). */
+    readonly extensions: readonly string[];
+    /**
+     * Extract everything the index needs from one file. Called once per file
+     * per index run. May throw on unparseable input — the indexer catches and
+     * logs per §7.1 (never aborts the full run).
+     *
+     * @param src - Raw UTF-8 source text.
+     * @param filePath - Relative to project root; used in chunk IDs.
+     * @param fileMtime - File modification time at index time (unix seconds).
+     */
+    extract(src: string, filePath: string, fileMtime: number, options: ExtractorOptions): FileExtraction;
+}
+//# sourceMappingURL=extractor.d.ts.map

package/dist/ast/extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../src/ast/extractor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAM1F;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,yDAAyD;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B;yEACqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;IACtC;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,EAAE,SAAS,aAAa,EAAE,CAAC;IAClD,QAAQ,CAAC,aAAa,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACvD;AAED,8EAA8E;AAC9E,MAAM,WAAW,gBAAgB;IAC/B,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,qEAAqE;IACrE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,8EAA8E;IAC9E,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,sEAAsE;IACtE,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;CACvC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,sDAAsD;IACtD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC;;;;;;;;OAQG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,cAAc,CAAC;CACtG"}

package/dist/ast/extractor.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=extractor.js.map

package/dist/ast/extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.js","sourceRoot":"","sources":["../../src/ast/extractor.ts"],"names":[],"mappings":""}

package/dist/ast/extractors/markdown.d.ts

@@ -0,0 +1,40 @@
+import type { Chunk } from '../types.js';
+import type { LanguageExtractor, FileExtraction, ExtractorOptions } from '../extractor.js';
+/**
+ * Heading-based chunker for markdown documents.
+ *
+ * No parser: a line scan with fence tracking is sufficient and avoids
+ * shipping a markdown grammar — parsing strategy is internal to each
+ * `LanguageExtractor`. Doc chunks carry no symbol graph: `extract` returns
+ * empty `symbols` / `imports` / `edges`, and empty `identifierRows` because
+ * `identifier_fts` feeds `mast_callers` potential_matches, where prose that
+ * merely mentions a symbol name is noise, not a call site — docs participate
+ * in search via chunk_fts + vectors only.
+ *
+ * Chunking rules (documented in MAST_SPEC.md §10.1):
+ * - A new chunk starts at every ATX heading of level ≤ `maxHeadingDepth`;
+ *   deeper headings fold into the enclosing section's content.
+ * - `symbol_name` is the heading path: file name + every ancestor heading +
+ *   the section's own heading, joined with " > ".
+ * - Content before the first boundary heading becomes a preamble chunk whose
+ *   `symbol_name` is the file name alone.
+ * - `#` lines inside fenced code blocks (``` or ~~~) are not headings.
+ * - Setext headings (`===` / `---` underlines) are not recognised — this
+ *   repo's docs use ATX exclusively, and supporting both complicates the
+ *   fence-aware scan for no observed payoff.
+ * - Sections longer than `chunkSplitThreshold` lines split into overlapping
+ *   sub-chunks using the same window/overlap/ID scheme as code declarations,
+ *   so no single doc chunk exceeds the token budget the threshold encodes.
+ * - No `context_lines` expansion: sections are self-delimiting, and expansion
+ *   would duplicate neighbouring sections' text into every chunk.
+ * - Doc chunks carry no `declaration_hash`/`body_hash` — there is no symbol
+ *   row to compare against, so the incremental "unchanged file" fast path
+ *   conservatively rewrites markdown files instead (see indexer/index.ts).
+ */
+export declare class MarkdownExtractor implements LanguageExtractor {
+    readonly language = "markdown";
+    readonly extensions: readonly string[];
+    extract(src: string, filePath: string, fileMtime: number, options: ExtractorOptions): FileExtraction;
+    extractChunks(src: string, filePath: string, fileMtime: number, chunkSplitThreshold: number, maxHeadingDepth: number): Chunk[];
+}
+//# sourceMappingURL=markdown.d.ts.map

package/dist/ast/extractors/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/ast/extractors/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAoB3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,iBAAkB,YAAW,iBAAiB;IACzD,QAAQ,CAAC,QAAQ,cAAc;IAC/B,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAW;IAEjD,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,cAAc;IAKpG,aAAa,CACX,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,mBAAmB,EAAE,MAAM,EAC3B,eAAe,EAAE,MAAM,GACtB,KAAK,EAAE;CA6EX"}

package/dist/ast/extractors/markdown.js

@@ -0,0 +1,175 @@
+import { chunkId, sha256 } from './typescript.js';
+// ---------------------------------------------------------------------------
+// Markdown extractor — heading-based doc chunking (§10.1)
+// ---------------------------------------------------------------------------
+/** ATX heading: 1–6 `#` followed by whitespace and the heading text. */
+const HEADING_RE = /^(#{1,6})\s+(.*?)\s*#*\s*$/;
+/** Fence opener/closer: ``` or ~~~ optionally followed by an info string. */
+const FENCE_RE = /^\s{0,3}(```|~~~)/;
+/**
+ * Heading-based chunker for markdown documents.
+ *
+ * No parser: a line scan with fence tracking is sufficient and avoids
+ * shipping a markdown grammar — parsing strategy is internal to each
+ * `LanguageExtractor`. Doc chunks carry no symbol graph: `extract` returns
+ * empty `symbols` / `imports` / `edges`, and empty `identifierRows` because
+ * `identifier_fts` feeds `mast_callers` potential_matches, where prose that
+ * merely mentions a symbol name is noise, not a call site — docs participate
+ * in search via chunk_fts + vectors only.
+ *
+ * Chunking rules (documented in MAST_SPEC.md §10.1):
+ * - A new chunk starts at every ATX heading of level ≤ `maxHeadingDepth`;
+ *   deeper headings fold into the enclosing section's content.
+ * - `symbol_name` is the heading path: file name + every ancestor heading +
+ *   the section's own heading, joined with " > ".
+ * - Content before the first boundary heading becomes a preamble chunk whose
+ *   `symbol_name` is the file name alone.
+ * - `#` lines inside fenced code blocks (``` or ~~~) are not headings.
+ * - Setext headings (`===` / `---` underlines) are not recognised — this
+ *   repo's docs use ATX exclusively, and supporting both complicates the
+ *   fence-aware scan for no observed payoff.
+ * - Sections longer than `chunkSplitThreshold` lines split into overlapping
+ *   sub-chunks using the same window/overlap/ID scheme as code declarations,
+ *   so no single doc chunk exceeds the token budget the threshold encodes.
+ * - No `context_lines` expansion: sections are self-delimiting, and expansion
+ *   would duplicate neighbouring sections' text into every chunk.
+ * - Doc chunks carry no `declaration_hash`/`body_hash` — there is no symbol
+ *   row to compare against, so the incremental "unchanged file" fast path
+ *   conservatively rewrites markdown files instead (see indexer/index.ts).
+ */
+export class MarkdownExtractor {
+    language = 'markdown';
+    extensions = ['.md'];
+    extract(src, filePath, fileMtime, options) {
+        const chunks = this.extractChunks(src, filePath, fileMtime, options.chunkSplitThreshold, options.markdownHeadingDepth);
+        return { language: 'markdown', chunks, symbols: [], imports: [], edges: [], identifierRows: [], starReExports: [] };
+    }
+    extractChunks(src, filePath, fileMtime, chunkSplitThreshold, maxHeadingDepth) {
+        if (src.trim() === '')
+            return [];
+        const lines = src.split('\n');
+        // Drop a trailing empty element produced by a terminating newline so the
+        // last section's end_line matches the real last line of the file.
+        if (lines[lines.length - 1] === '')
+            lines.pop();
+        const fileName = fileNameOf(filePath);
+        const sections = [];
+        // Last-seen heading text per level (1-indexed); shallower ancestors form
+        // the heading path of each new section. Sparse when a document skips
+        // levels (e.g. `#` straight to `###`) — holes are filtered from paths.
+        const headingStack = [];
+        let inFence = false;
+        let fenceMarker = '';
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i] ?? '';
+            const fence = FENCE_RE.exec(line);
+            if (fence !== null) {
+                const marker = fence[1] ?? '';
+                if (!inFence) {
+                    inFence = true;
+                    fenceMarker = marker;
+                }
+                else if (marker === fenceMarker) {
+                    inFence = false;
+                }
+                continue;
+            }
+            if (inFence)
+                continue;
+            const heading = HEADING_RE.exec(line);
+            if (heading === null)
+                continue;
+            const level = (heading[1] ?? '').length;
+            const text = heading[2] ?? '';
+            // Track ancestors at every level so folded deep headings still
+            // contribute to the path of later, shallower-or-equal siblings' children.
+            headingStack.splice(level - 1);
+            headingStack[level - 1] = text;
+            if (level > maxHeadingDepth)
+                continue; // folds into the current section
+            // First boundary heading below line 1 implies a preamble chunk.
+            if (sections.length === 0 && i > 0) {
+                sections.push({ startLine: 1, symbolName: fileName });
+            }
+            const ancestors = headingStack.slice(0, level).filter((t) => t !== undefined);
+            const path = [fileName, ...ancestors].join(' > ');
+            sections.push({ startLine: i + 1, symbolName: path });
+        }
+        // No headings at all — the whole file is one preamble chunk.
+        if (sections.length === 0) {
+            sections.push({ startLine: 1, symbolName: fileName });
+        }
+        const chunks = [];
+        for (let s = 0; s < sections.length; s++) {
+            const section = sections[s];
+            if (section === undefined)
+                continue;
+            const next = sections[s + 1];
+            const endLine = next !== undefined ? next.startLine - 1 : lines.length;
+            pushSectionChunks(chunks, {
+                lines,
+                filePath,
+                fileMtime,
+                chunkSplitThreshold,
+                symbolName: section.symbolName,
+                startLine: section.startLine,
+                endLine,
+            });
+        }
+        return chunks;
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Basename of a relative path — the heading-path root. */
+function fileNameOf(filePath) {
+    const idx = filePath.lastIndexOf('/');
+    return idx === -1 ? filePath : filePath.slice(idx + 1);
+}
+/**
+ * Push one doc chunk — or N overlapping sub-chunks when the section exceeds
+ * `chunkSplitThreshold` lines. Mirrors the code-side split rule (window =
+ * threshold, 10-line overlap, sub-index-qualified chunk IDs) so downstream
+ * consumers see one consistent scheme.
+ */
+function pushSectionChunks(chunks, opts) {
+    const { lines, filePath, fileMtime, symbolName, startLine, endLine } = opts;
+    const base = {
+        file_path: filePath,
+        chunk_type: 'doc',
+        symbol_name: symbolName,
+        parent_symbol: null,
+        is_exported: false,
+        language: 'markdown',
+        file_mtime: fileMtime,
+    };
+    if (endLine - startLine + 1 <= opts.chunkSplitThreshold) {
+        chunks.push({
+            ...base,
+            chunk_id: chunkId(filePath, startLine),
+            start_line: startLine,
+            end_line: endLine,
+            content: lines.slice(startLine - 1, endLine).join('\n'),
+        });
+        return;
+    }
+    const OVERLAP_LINES = 10;
+    let subStart = startLine;
+    let subIndex = 0;
+    while (subStart <= endLine) {
+        const subEnd = Math.min(subStart + opts.chunkSplitThreshold - 1, endLine);
+        chunks.push({
+            ...base,
+            chunk_id: sha256(`${filePath}:${startLine}:${subIndex}`),
+            start_line: subStart,
+            end_line: subEnd,
+            content: lines.slice(subStart - 1, subEnd).join('\n'),
+        });
+        if (subEnd >= endLine)
+            break;
+        subStart = subEnd - OVERLAP_LINES + 1;
+        subIndex++;
+    }
+}
+//# sourceMappingURL=markdown.js.map

package/dist/ast/extractors/markdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.js","sourceRoot":"","sources":["../../../src/ast/extractors/markdown.ts"],"names":[],"mappings":"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"}