@plebeiantech/lat.md 0.12.3-fork.1

package/dist/src/extensions/wiki-link/to-markdown.js

@@ -0,0 +1,28 @@
+/**
+ * mdast-util extension to serialize wiki-link nodes back to markdown.
+ */
+function handler(node, _parent, state, _info) {
+    const exit = state.enter('wikiLink');
+    const target = state.safe(node.value, { before: '[', after: ']' });
+    let value;
+    if (node.data.alias) {
+        const alias = state.safe(node.data.alias, { before: '[', after: ']' });
+        value = `[[${target}|${alias}]]`;
+    }
+    else {
+        value = `[[${target}]]`;
+    }
+    exit();
+    return value;
+}
+export function wikiLinkToMarkdown() {
+    return {
+        unsafe: [
+            { character: '[', inConstruct: ['phrasing', 'label', 'reference'] },
+            { character: ']', inConstruct: ['label', 'reference'] },
+        ],
+        handlers: {
+            wikiLink: handler,
+        },
+    };
+}

package/dist/src/extensions/wiki-link/types.d.ts

@@ -0,0 +1,34 @@
+import type { Data, Literal } from 'mdast';
+/**
+ * mdast node for a wiki-style link like [[target]] or [[target|alias]].
+ */
+export interface WikiLink extends Literal {
+    type: 'wikiLink';
+    value: string;
+    data: Data & {
+        alias: string | null;
+    };
+}
+declare module 'mdast' {
+    interface RootContentMap {
+        wikiLink: WikiLink;
+    }
+    interface PhrasingContentMap {
+        wikiLink: WikiLink;
+    }
+}
+declare module 'micromark-util-types' {
+    interface TokenTypeMap {
+        wikiLink: 'wikiLink';
+        wikiLinkMarker: 'wikiLinkMarker';
+        wikiLinkData: 'wikiLinkData';
+        wikiLinkTarget: 'wikiLinkTarget';
+        wikiLinkAliasMarker: 'wikiLinkAliasMarker';
+        wikiLinkAlias: 'wikiLinkAlias';
+    }
+}
+declare module 'mdast-util-to-markdown' {
+    interface ConstructNameMap {
+        wikiLink: 'wikiLink';
+    }
+}

package/dist/src/extensions/wiki-link/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/format.d.ts

@@ -0,0 +1,8 @@
+import type { Section, SectionMatch } from './lattice.js';
+import type { CmdContext, Styler } from './context.js';
+export declare function formatSectionId(id: string, s: Styler): string;
+export declare function formatSectionPreview(ctx: CmdContext, section: Section, opts?: {
+    reason?: string;
+}): string;
+export declare function formatResultList(ctx: CmdContext, header: string, matches: SectionMatch[]): string;
+export declare function formatNavHints(ctx: CmdContext): string;

package/dist/src/format.js

@@ -0,0 +1,43 @@
+import { join, relative } from 'node:path';
+export function formatSectionId(id, s) {
+    const parts = id.split('#');
+    return parts.length === 1
+        ? s.boldWhite(parts[0])
+        : s.dim(parts.slice(0, -1).join('#') + '#') +
+            s.boldWhite(parts[parts.length - 1]);
+}
+export function formatSectionPreview(ctx, section, opts) {
+    const s = ctx.styler;
+    const relPath = relative(process.cwd(), join(ctx.projectRoot, section.filePath));
+    const kind = section.id.includes('#') ? 'Section' : 'File';
+    const reasonSuffix = opts?.reason ? ' ' + s.dim(`(${opts.reason})`) : '';
+    const lines = [
+        `${s.dim('*')} ${s.dim(kind + ':')} [[${formatSectionId(section.id, s)}]]${reasonSuffix}`,
+        `  ${s.dim('Defined in')} ${s.cyan(relPath)}${s.dim(`:${section.startLine}-${section.endLine}`)}`,
+    ];
+    if (section.firstParagraph) {
+        lines.push('', `  ${s.dim('>')} ${section.firstParagraph}`);
+    }
+    return lines.join('\n');
+}
+export function formatResultList(ctx, header, matches) {
+    const lines = ['', `## ${header}`, ''];
+    for (let i = 0; i < matches.length; i++) {
+        if (i > 0)
+            lines.push('');
+        lines.push(formatSectionPreview(ctx, matches[i].section, {
+            reason: matches[i].reason,
+        }));
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+export function formatNavHints(ctx) {
+    const s = ctx.styler;
+    const hints = ctx.mode === 'cli'
+        ? `${s.dim('*')} \`lat section "section#id"\` \u2014 show full content with outgoing/incoming refs\n` +
+            `${s.dim('*')} \`lat search "new query"\` \u2014 search for something else`
+        : `${s.dim('*')} \`lat_section\` \u2014 show full content with outgoing/incoming refs\n` +
+            `${s.dim('*')} \`lat_search\` \u2014 search for something else`;
+    return `\n## To navigate further:\n\n${hints}`;
+}

package/dist/src/graph-export.d.ts

@@ -0,0 +1,60 @@
+export type GraphNodeType = 'document' | 'section' | 'code' | 'tag';
+export type GraphEdgeType = 'contains' | 'wikilink' | 'code-ref' | 'tag';
+export type GraphNode = {
+    id: string;
+    type: GraphNodeType;
+    label: string;
+    file?: string;
+    mode?: string;
+    status?: string;
+    reviewedHash?: string;
+};
+export type GraphEdge = {
+    from: string;
+    to: string;
+    type: GraphEdgeType;
+};
+export type Graph = {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+};
+/** A lat.md markdown file's project-root-relative path and content. */
+export type GraphSourceFile = {
+    /** Project-root-relative, posix-separated path (e.g. "lat.md/tests.md"). */
+    relPath: string;
+    content: string;
+};
+/**
+ * Build the knowledge graph from a set of already-loaded lat.md file
+ * contents. Used for both the working tree and a reconstructed git
+ * revision -- the only difference between the two call sites is where the
+ * file contents came from.
+ *
+ * `includeCode` controls whether the code-ref and source-wikilink halves of
+ * the graph are built by scanning the live project tree on disk. This is
+ * only meaningful for the working tree: a git revision's source tree is not
+ * reconstructed, only its lat.md/ documents are, so `includeCode` is false
+ * for `--at` / `--since`.
+ */
+export declare function buildGraph(files: GraphSourceFile[], projectRoot: string, includeCode: boolean): Promise<Graph>;
+/** Read the working tree's lat.md files straight off disk. */
+export declare function loadWorkingTreeFiles(latticeDir: string, projectRoot: string): Promise<GraphSourceFile[]>;
+/**
+ * Reconstruct the lat.md/ markdown tree as it existed at a git revision.
+ * Only the documents are reconstructed, not the surrounding source tree —
+ * `buildGraph` is called with `includeCode: false` for these.
+ */
+export declare function loadRevisionFiles(projectRoot: string, latticeDir: string, rev: string): Promise<GraphSourceFile[]>;
+export type GraphDiff = {
+    added: string[];
+    removed: string[];
+    changed: string[];
+};
+/** Diff two graphs' section nodes by id, reporting added/removed/changed. */
+export declare function diffGraphs(before: Graph, after: Graph): GraphDiff;
+export declare function formatGraphJson(graph: Graph): string;
+export declare function formatGraphMermaid(graph: Graph): string;
+export declare function formatGraphDot(graph: Graph): string;
+export type GraphFormat = 'json' | 'mermaid' | 'dot';
+export declare function formatGraph(graph: Graph, format: GraphFormat): string;
+export declare function formatGraphDiff(diff: GraphDiff): string;

package/dist/src/graph-export.js

@@ -0,0 +1,309 @@
+// Export the whole lat.md knowledge graph: sections, documents, code refs,
+// wiki links, and test-spec coverage, at the working tree or at a git
+// revision. See lat-t1y.10.
+//
+// Every label placed into a mermaid or dot rendering is repository text, so
+// it is passed through `cleanUntrustedId` before it becomes a node id or
+// label -- never a hand-rolled sanitizer. `cleanUntrustedId` (not
+// `quoteUntrusted`) is correct here: node ids and labels must not be
+// truncated, and quoting them would corrupt them as identifiers.
+import { execFile } from 'node:child_process';
+import { join, relative } from 'node:path';
+import { promisify } from 'node:util';
+import { extractRefs, buildFileIndex, buildSectionSlugIndex, parseSections, parseFrontmatter, resolveRef, } from './lattice.js';
+import { scanCodeRefs } from './code-refs.js';
+import { DIATAXIS_MODES, MODE_DIRS } from './cli/check-mode.js';
+import { readProvenance } from './cli/check-status.js';
+import { cleanUntrustedId } from './untrusted.js';
+import { toPosix } from './walk.js';
+const execFileAsync = promisify(execFile);
+function docId(relPath) {
+    return `doc:${relPath}`;
+}
+function sectionId(id) {
+    return `section:${id}`;
+}
+function codeId(target) {
+    return `code:${target}`;
+}
+function tagId(tag) {
+    return `tag:${tag}`;
+}
+function modeForFile(relPath, fm) {
+    const declared = fm['mode'];
+    if (typeof declared === 'string')
+        return declared;
+    for (const mode of DIATAXIS_MODES) {
+        const dir = MODE_DIRS[mode];
+        if (relPath.includes(`/${dir}/`) || relPath.startsWith(`${dir}/`)) {
+            return mode;
+        }
+    }
+    return undefined;
+}
+function tagsForFile(fm) {
+    const raw = fm['tags'];
+    if (Array.isArray(raw))
+        return raw.filter((t) => typeof t === 'string');
+    if (typeof raw === 'string')
+        return [raw];
+    return [];
+}
+/**
+ * Build the knowledge graph from a set of already-loaded lat.md file
+ * contents. Used for both the working tree and a reconstructed git
+ * revision -- the only difference between the two call sites is where the
+ * file contents came from.
+ *
+ * `includeCode` controls whether the code-ref and source-wikilink halves of
+ * the graph are built by scanning the live project tree on disk. This is
+ * only meaningful for the working tree: a git revision's source tree is not
+ * reconstructed, only its lat.md/ documents are, so `includeCode` is false
+ * for `--at` / `--since`.
+ */
+export async function buildGraph(files, projectRoot, includeCode) {
+    const nodes = new Map();
+    const edges = [];
+    const addNode = (node) => {
+        if (!nodes.has(node.id))
+            nodes.set(node.id, node);
+    };
+    const addEdge = (edge) => {
+        edges.push(edge);
+    };
+    const ensureSectionNode = (id, label) => {
+        const sid = sectionId(id);
+        if (!nodes.has(sid)) {
+            addNode({
+                id: sid,
+                type: 'section',
+                label: cleanUntrustedId(label ?? id),
+            });
+        }
+        return sid;
+    };
+    const allSections = [];
+    const sortedFiles = [...files].sort((a, b) => a.relPath.localeCompare(b.relPath));
+    for (const f of sortedFiles) {
+        const absPath = join(projectRoot, f.relPath);
+        const sections = parseSections(absPath, f.content, projectRoot);
+        allSections.push(...sections);
+        const fm = parseFrontmatter(f.content).raw;
+        const provenance = readProvenance(f.content);
+        const mode = modeForFile(toPosix(f.relPath), fm);
+        const tags = tagsForFile(fm);
+        const dId = docId(f.relPath);
+        addNode({
+            id: dId,
+            type: 'document',
+            label: cleanUntrustedId(f.relPath),
+            file: f.relPath,
+            mode,
+            status: provenance.status,
+            reviewedHash: provenance.reviewedHash,
+        });
+        for (const tag of tags) {
+            const tId = tagId(tag);
+            addNode({ id: tId, type: 'tag', label: cleanUntrustedId(tag) });
+            addEdge({ from: dId, to: tId, type: 'tag' });
+        }
+        const walkSection = (section, parentId) => {
+            const sId = ensureSectionNode(section.id, section.heading);
+            const node = nodes.get(sId);
+            node.file = f.relPath;
+            addEdge({ from: parentId, to: sId, type: 'contains' });
+            for (const child of section.children) {
+                walkSection(child, sId);
+            }
+        };
+        for (const root of sections) {
+            walkSection(root, dId);
+        }
+    }
+    const flat = [];
+    const flatten = (secs) => {
+        for (const s of secs) {
+            flat.push(s);
+            flatten(s.children);
+        }
+    };
+    flatten(allSections);
+    const sectionIds = new Set(flat.map((s) => s.id.toLowerCase()));
+    const fileIndex = buildFileIndex(allSections);
+    const slugIndex = buildSectionSlugIndex(allSections);
+    // Wiki links: section -> section (or section -> code target).
+    for (const f of sortedFiles) {
+        const absPath = join(projectRoot, f.relPath);
+        const refs = extractRefs(absPath, f.content, projectRoot);
+        for (const ref of refs) {
+            const { resolved, ambiguous } = resolveRef(ref.target, sectionIds, fileIndex, slugIndex);
+            const fromId = ensureSectionNode(ref.fromSection);
+            if (!ambiguous && sectionIds.has(resolved.toLowerCase())) {
+                const toId = ensureSectionNode(resolved);
+                addEdge({ from: fromId, to: toId, type: 'wikilink' });
+            }
+            else {
+                const cId = codeId(ref.target);
+                addNode({
+                    id: cId,
+                    type: 'code',
+                    label: cleanUntrustedId(ref.target),
+                });
+                addEdge({ from: fromId, to: cId, type: 'wikilink' });
+            }
+        }
+    }
+    // Code refs (the `// @lat: [[section-id]]` comment marker) and test-spec coverage: code -> section.
+    if (includeCode) {
+        const scan = await scanCodeRefs(projectRoot);
+        for (const ref of scan.refs) {
+            const { resolved, ambiguous } = resolveRef(ref.target, sectionIds, fileIndex, slugIndex);
+            const label = `${ref.file}:${ref.line}`;
+            const cId = codeId(label);
+            addNode({ id: cId, type: 'code', label: cleanUntrustedId(label) });
+            const toId = !ambiguous && sectionIds.has(resolved.toLowerCase())
+                ? ensureSectionNode(resolved)
+                : ensureSectionNode(ref.target);
+            addEdge({ from: cId, to: toId, type: 'code-ref' });
+        }
+    }
+    return { nodes: [...nodes.values()], edges };
+}
+/** Read the working tree's lat.md files straight off disk. */
+export async function loadWorkingTreeFiles(latticeDir, projectRoot) {
+    const { listLatticeFiles } = await import('./lattice.js');
+    const { readFile } = await import('node:fs/promises');
+    const paths = await listLatticeFiles(latticeDir);
+    const files = [];
+    for (const p of paths) {
+        const content = await readFile(p, 'utf-8');
+        files.push({ relPath: toPosix(relative(projectRoot, p)), content });
+    }
+    return files;
+}
+/**
+ * Reconstruct the lat.md/ markdown tree as it existed at a git revision.
+ * Only the documents are reconstructed, not the surrounding source tree —
+ * `buildGraph` is called with `includeCode: false` for these.
+ */
+export async function loadRevisionFiles(projectRoot, latticeDir, rev) {
+    const latRelDir = toPosix(relative(projectRoot, latticeDir));
+    let lsOutput;
+    try {
+        const { stdout } = await execFileAsync('git', ['ls-tree', '-r', '--name-only', rev, '--', latRelDir], { cwd: projectRoot });
+        lsOutput = stdout;
+    }
+    catch (err) {
+        throw new Error(`failed to list "${latRelDir}" at revision "${rev}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const paths = lsOutput
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((l) => l.endsWith('.md'));
+    const files = [];
+    for (const p of paths) {
+        const { stdout } = await execFileAsync('git', ['show', `${rev}:${p}`], {
+            cwd: projectRoot,
+        });
+        files.push({ relPath: p, content: stdout });
+    }
+    return files;
+}
+/** Diff two graphs' section nodes by id, reporting added/removed/changed. */
+export function diffGraphs(before, after) {
+    const beforeSections = new Map(before.nodes.filter((n) => n.type === 'section').map((n) => [n.id, n]));
+    const afterSections = new Map(after.nodes.filter((n) => n.type === 'section').map((n) => [n.id, n]));
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [id, node] of afterSections) {
+        const prior = beforeSections.get(id);
+        if (!prior) {
+            added.push(id);
+        }
+        else if (prior.label !== node.label) {
+            changed.push(id);
+        }
+    }
+    for (const id of beforeSections.keys()) {
+        if (!afterSections.has(id))
+            removed.push(id);
+    }
+    return { added, removed, changed };
+}
+// --- Formatters -----------------------------------------------------------
+export function formatGraphJson(graph) {
+    return JSON.stringify(graph, null, 2);
+}
+const NODE_SHAPE = {
+    document: ['([', '])'],
+    section: ['[', ']'],
+    code: ['[[', ']]'],
+    tag: ['((', '))'],
+};
+function mermaidEscape(label) {
+    return label.replace(/"/g, '#quot;');
+}
+export function formatGraphMermaid(graph) {
+    const idMap = new Map();
+    graph.nodes.forEach((n, i) => idMap.set(n.id, `n${i}`));
+    const lines = ['flowchart TD'];
+    for (const node of graph.nodes) {
+        const [open, close] = NODE_SHAPE[node.type];
+        const label = mermaidEscape(`${node.type}: ${node.label}`);
+        lines.push(`  ${idMap.get(node.id)}${open}"${label}"${close}`);
+    }
+    for (const edge of graph.edges) {
+        const from = idMap.get(edge.from);
+        const to = idMap.get(edge.to);
+        if (!from || !to)
+            continue;
+        lines.push(`  ${from} -->|${edge.type}| ${to}`);
+    }
+    return lines.join('\n');
+}
+function dotEscape(label) {
+    return label.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+export function formatGraphDot(graph) {
+    const idMap = new Map();
+    graph.nodes.forEach((n, i) => idMap.set(n.id, `n${i}`));
+    const lines = ['digraph lat {'];
+    for (const node of graph.nodes) {
+        const label = dotEscape(`${node.type}: ${node.label}`);
+        lines.push(`  ${idMap.get(node.id)} [label="${label}"];`);
+    }
+    for (const edge of graph.edges) {
+        const from = idMap.get(edge.from);
+        const to = idMap.get(edge.to);
+        if (!from || !to)
+            continue;
+        lines.push(`  ${from} -> ${to} [label="${dotEscape(edge.type)}"];`);
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+export function formatGraph(graph, format) {
+    switch (format) {
+        case 'mermaid':
+            return formatGraphMermaid(graph);
+        case 'dot':
+            return formatGraphDot(graph);
+        case 'json':
+        default:
+            return formatGraphJson(graph);
+    }
+}
+export function formatGraphDiff(diff) {
+    const lines = [];
+    lines.push(`added (${diff.added.length}):`);
+    for (const id of diff.added)
+        lines.push(`  + ${cleanUntrustedId(id)}`);
+    lines.push(`removed (${diff.removed.length}):`);
+    for (const id of diff.removed)
+        lines.push(`  - ${cleanUntrustedId(id)}`);
+    lines.push(`changed (${diff.changed.length}):`);
+    for (const id of diff.changed)
+        lines.push(`  ~ ${cleanUntrustedId(id)}`);
+    return lines.join('\n');
+}

package/dist/src/init-version.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Bump this number whenever `lat init` setup or defaults change in a way that
+ * requires users to re-run it (e.g. new hooks, generated files, MCP config, or
+ * a configuration migration).
+ */
+export declare const INIT_VERSION = 5;
+export declare function readInitVersion(latDir: string): number | null;
+export declare function readFileHash(latDir: string, relPath: string): string | null;
+export declare function contentHash(content: string): string;
+export declare function writeInitMeta(latDir: string, fileHashes: Record<string, string>): void;

package/dist/src/init-version.js

@@ -0,0 +1,49 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Bump this number whenever `lat init` setup or defaults change in a way that
+ * requires users to re-run it (e.g. new hooks, generated files, MCP config, or
+ * a configuration migration).
+ */
+export const INIT_VERSION = 5;
+function cachePath(latDir) {
+    return join(latDir, '.cache', 'lat_init.json');
+}
+function readMeta(latDir) {
+    const p = cachePath(latDir);
+    if (!existsSync(p))
+        return null;
+    try {
+        return JSON.parse(readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function readInitVersion(latDir) {
+    const meta = readMeta(latDir);
+    if (!meta)
+        return null;
+    return typeof meta.init_version === 'number' ? meta.init_version : null;
+}
+export function readFileHash(latDir, relPath) {
+    const meta = readMeta(latDir);
+    return meta?.file_hashes?.[relPath] ?? null;
+}
+export function contentHash(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+export function writeInitMeta(latDir, fileHashes) {
+    const cacheDir = join(latDir, '.cache');
+    mkdirSync(cacheDir, { recursive: true });
+    // Merge with existing hashes so we don't lose entries from agents
+    // that weren't selected this run
+    const existing = readMeta(latDir);
+    const mergedHashes = { ...existing?.file_hashes, ...fileHashes };
+    const data = {
+        init_version: INIT_VERSION,
+        file_hashes: mergedHashes,
+    };
+    writeFileSync(cachePath(latDir), JSON.stringify(data, null, 2) + '\n');
+}

package/dist/src/knowledge/bd.d.ts

@@ -0,0 +1,2 @@
+import type { Store } from './types.js';
+export declare const bdStore: Store;

package/dist/src/knowledge/bd.js

@@ -0,0 +1,107 @@
+import { execFile, } from 'node:child_process';
+const CALL_TIMEOUT_MS = 2000;
+/**
+ * Run `bd memories --json <term>` for a single term. Never throws: a missing
+ * binary (ENOENT), non-zero exit, timeout, or unparseable JSON all collapse
+ * to "no matches for this term" so one bad term can't sink the whole query.
+ *
+ * Uses the async `execFile` (not `execFileSync`) so this call never blocks
+ * the event loop: `federateTags` fans out to all three stores with
+ * `Promise.allSettled`, and that fan-out only buys real concurrency if each
+ * store's I/O actually yields control while its subprocess runs.
+ */
+function queryTerm(term) {
+    return new Promise((resolvePromise) => {
+        // argv form, no shell: terms come from repository frontmatter and are
+        // attacker-controlled when `lat` runs in a repo we don't own, so a term
+        // must never be interpretable as shell syntax.
+        // stdin: 'ignore' is load-bearing, not cosmetic. The shell version this
+        // replaced ran its per-term loop inside a `while read` on stdin; an
+        // external tool in that loop that itself read stdin would silently
+        // consume the remaining terms, and the symptom was some documents just
+        // never showing up — indistinguishable from "no match". Detaching stdin
+        // here removes that whole class of bug. `stdio` isn't in the string-
+        // encoding overload's declared option type even though Node accepts it
+        // at runtime, hence the explicit cast.
+        const options = {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: CALL_TIMEOUT_MS,
+            encoding: 'utf-8',
+        };
+        execFile('bd', ['memories', '--json', term], options, (error, stdout) => {
+            // execFile's async form reports a non-zero exit and a timeout kill
+            // both through `error`, and never rejects — so every failure mode
+            // is handled right here rather than via a catch on the returned
+            // promise. Match `queryTerm`'s old spawnSync contract of "empty
+            // object" for anything that isn't a clean, parseable JSON object.
+            if (error || !stdout) {
+                resolvePromise({});
+                return;
+            }
+            try {
+                const parsed = JSON.parse(stdout);
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    resolvePromise(parsed);
+                }
+                else {
+                    resolvePromise({});
+                }
+            }
+            catch {
+                resolvePromise({});
+            }
+        });
+    });
+}
+async function query(q) {
+    try {
+        return await rank(q);
+    }
+    catch {
+        // The store contract is that a lookup never fails the caller's prompt.
+        // queryTerm already absorbs a failing `bd`, but the surrounding logic
+        // could still throw on an unexpected input, so the guarantee is made
+        // unconditional here.
+        return [];
+    }
+}
+async function rank(q) {
+    // key -> { content, count }, built in first-seen order so a stable sort
+    // below keeps ties in the author's original term order rather than an
+    // alphabetical accident.
+    const seen = new Map();
+    // Terms belong to the same document, so their subprocess calls are
+    // independent of each other — run them concurrently rather than one at a
+    // time. Each individual call still enforces CALL_TIMEOUT_MS; running them
+    // together bounds the whole document's bd lookup by that same timeout
+    // instead of `terms.length * CALL_TIMEOUT_MS`.
+    const perTerm = await Promise.all(q.terms.map((term) => queryTerm(term)));
+    for (const memories of perTerm) {
+        for (const [key, content] of Object.entries(memories)) {
+            if (!key || typeof content !== 'string' || content === '')
+                continue;
+            const existing = seen.get(key);
+            if (existing) {
+                existing.count += 1;
+            }
+            else {
+                seen.set(key, { content, count: 1 });
+            }
+        }
+    }
+    const hits = [...seen.entries()].map(([key, v]) => ({
+        store: 'bd',
+        key,
+        title: key,
+        detail: v.content.split('\n')[0] ?? '',
+        score: v.count,
+    }));
+    // Array.prototype.sort is stable, so entries with equal score retain the
+    // first-seen (author's term) order from the map iteration above.
+    hits.sort((a, b) => b.score - a.score);
+    return hits.slice(0, q.limit);
+}
+export const bdStore = {
+    name: 'bd',
+    query,
+};

package/dist/src/knowledge/claude-memory.d.ts

@@ -0,0 +1,13 @@
+import type { Store } from './types.js';
+/**
+ * Match Claude Code's own project-directory slug: every character that
+ * isn't a letter or digit becomes `-`, including `.` — a project root like
+ * `/Users/dave/projects/claude-code/lat.md` slugifies to
+ * `-Users-dave-projects-claude-code-lat-md`, verified against a real
+ * `~/.claude/projects/` listing. Replacing only `/` (the previous
+ * implementation) leaves dots in the slug and never matches the real
+ * directory, so the store silently finds nothing for any project root
+ * containing a dot.
+ */
+export declare function slugify(absPath: string): string;
+export declare const claudeMemoryStore: Store;