@plebeiantech/lat.md 0.12.3-fork.13 → 0.12.3-fork.14

package/dist/src/cli/index.js

@@ -8,6 +8,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Command, InvalidArgumentError } from 'commander';
 import { resolveCheckContext, resolveContext } from './context.js';
+import { DEFAULT_SEARCH_LIMIT, DEFAULT_SEARCH_THRESHOLD, } from '../search/search.js';
 function parsePort(value) {
     if (!/^\d+$/.test(value)) {
         throw new InvalidArgumentError('port must be an integer from 1 to 65535');
@@ -18,6 +19,13 @@ function parsePort(value) {
     }
     return port;
 }
+function parseSimilarityThreshold(value) {
+    const threshold = Number(value);
+    if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
+        throw new InvalidArgumentError('threshold must be a number from 0 to 1');
+    }
+    return threshold;
+}
 /** Reserve `-- <directory>` for an explicit check target. */
 function splitCheckTarget(args) {
     let commandIndex = -1;
@@ -138,15 +146,53 @@ program
     const { refsCommand } = await import('./refs.js');
     handleResult(await refsCommand(ctx, query, scope));
 });
+const external = program
+    .command('external')
+    .description('Manage pinned external source repositories');
+external
+    .command('add')
+    .argument('[handle]', 'stable external source handle')
+    .argument('[repo]', 'canonical HTTPS Git repository')
+    .option('--commit <commit-or-ref>', 'commit, branch, or tag to pin')
+    .option('--prefix <path>', 'repository path prefix')
+    .option('--default-file-extension <extension>', 'extension for external paths that omit one')
+    .option('--strategy <strategy>', 'retrieval strategy: fetch or checkout')
+    .option('--fetch-url <template>', 'raw-file URL template')
+    .action(async (handle, repo, opts) => {
+    const ctx = resolveContext(program.opts());
+    const { externalAddCommand } = await import('./external.js');
+    handleResult(await externalAddCommand(ctx, handle, repo, opts));
+});
+external
+    .command('show')
+    .argument('<source>', 'handle or exact external target')
+    .option('--json', 'emit structured JSON')
+    .action(async (source, opts) => {
+    const ctx = resolveContext(program.opts());
+    const { externalShowCommand } = await import('./external.js');
+    handleResult(await externalShowCommand(ctx, source, !!opts.json));
+});
+external
+    .command('list')
+    .option('--json', 'emit structured JSON')
+    .action(async (opts) => {
+    const ctx = resolveContext(program.opts());
+    const { externalListCommand } = await import('./external.js');
+    handleResult(await externalListCommand(ctx, !!opts.json));
+});
 const check = program
     .command('check')
     .usage('[subcommand] [-- <directory>]')
     .description('Validate markdown, links, code references, and structure')
     .option('--fix', 'generate/update directory index files from frontmatter')
+    .option('--profile', 'show detailed validation timing')
     .action(async (opts) => {
     const ctx = resolveCheckContext(program.opts(), checkTargetArgs.target);
     const { checkAllCommand } = await import('./check.js');
-    handleResult(await checkAllCommand(ctx, { fix: opts.fix }));
+    handleResult(await checkAllCommand(ctx, {
+        fix: opts.fix,
+        profile: !!opts.profile,
+    }));
 });
 check
     .command('md')
@@ -258,12 +304,18 @@ program
     .command('search')
     .description('Semantic search across lat.md sections')
     .argument('[query]', 'search query in plain English')
-    .option('--limit <n>', 'max results', '5')
+    .option('--limit <n>', `max results (default: ${DEFAULT_SEARCH_LIMIT})`, String(DEFAULT_SEARCH_LIMIT))
+    .option('--debug', 'show result similarity scores')
+    .option('--threshold <score>', `minimum cosine similarity score (default: ${DEFAULT_SEARCH_THRESHOLD})`, parseSimilarityThreshold)
     .action(async (query, opts) => {
     const ctx = resolveContext(program.opts());
     const { searchCommand, cliProgress } = await import('./search.js');
     const progress = cliProgress(ctx.styler);
-    const result = await searchCommand(ctx, query, { limit: parseInt(opts.limit) }, progress);
+    const result = await searchCommand(ctx, query, {
+        limit: parseInt(opts.limit),
+        debug: opts.debug,
+        threshold: opts.threshold,
+    }, progress);
     handleResult(result);
 });
 program

package/dist/src/cli/init.d.ts

@@ -5,5 +5,6 @@ type LatCommandStyle = 'global' | 'local' | 'npx';
  */
 export declare function syncLatHooks(settingsPath: string, style: LatCommandStyle, agent?: 'claude' | 'codex'): void;
 export declare function readLogo(): string;
+export declare function ensureLatLocalConfigIgnored(latDir: string): void;
 export declare function initCmd(targetDir?: string): Promise<void>;
 export {};

package/dist/src/cli/init.js

@@ -17,6 +17,7 @@ import { selectMenu } from './select-menu.js';
 import { checklistMenu } from './checklist-menu.js';
 import { writeForkInstructions } from './fork-instructions.js';
 import { offerRequireMode, writeForkScaffold } from './fork-scaffold.js';
+import { setupAntigravity } from '../fork/antigravity-init.js';
 async function confirm(rl, message) {
     while (true) {
         let answer;
@@ -819,6 +820,7 @@ function printNextSteps(selectedAgents) {
         pi: 'Pi',
         opencode: 'OpenCode',
         codex: 'Codex',
+        antigravity: 'Antigravity',
     };
     if (!hasClaudeCode && ideAgents.length === 0)
         return;
@@ -841,6 +843,15 @@ function printNextSteps(selectedAgents) {
 export function readLogo() {
     return readFileSync(join(findTemplatesDir(), 'logo.txt'), 'utf-8');
 }
+export function ensureLatLocalConfigIgnored(latDir) {
+    const path = join(latDir, '.gitignore');
+    const entry = 'config.local.yaml';
+    const current = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    if (current.split(/\r?\n/).includes(entry))
+        return;
+    const prefix = current && !current.endsWith('\n') ? `${current}\n` : current;
+    writeFileSync(path, `${prefix}${entry}\n`);
+}
 export async function initCmd(targetDir) {
     console.log(styleText('cyan', readLogo()));
     // Upfront version check — let the user upgrade before proceeding
@@ -904,6 +915,7 @@ export async function initCmd(targetDir) {
             console.log(styleText('green', 'Created lat.md/'));
             writeForkScaffold(latDir);
         }
+        ensureLatLocalConfigIgnored(latDir);
         // Step 2: Configure fresh/outdated setups, ask interactive users about an
         // available key, and offer to rebuild an index whose backend differs. This
         // happens before agent selection so "no agents" still completes it.
@@ -917,6 +929,7 @@ export async function initCmd(targetDir) {
             { label: 'VS Code Copilot', value: 'copilot' },
             { label: 'OpenCode', value: 'opencode' },
             { label: 'Codex', value: 'codex' },
+            { label: 'Antigravity / Gemini', value: 'antigravity' },
         ];
         const selectedAgents = await checklistMenu(allAgents, 'Which coding agents do you use?');
         const useClaudeCode = selectedAgents.includes('claude');
@@ -925,13 +938,15 @@ export async function initCmd(targetDir) {
         const useCopilot = selectedAgents.includes('copilot');
         const useOpenCode = selectedAgents.includes('opencode');
         const useCodex = selectedAgents.includes('codex');
+        const useAntigravity = selectedAgents.includes('antigravity');
         const anySelected = selectedAgents.length > 0;
         const needsLatCommand = useClaudeCode ||
             usePi ||
             useCursor ||
             useCopilot ||
             useOpenCode ||
-            useCodex;
+            useCodex ||
+            useAntigravity;
         // Step 4: How should agents run lat?
         let commandStyle = 'local';
         if (anySelected && needsLatCommand && interactive) {
@@ -973,7 +988,12 @@ export async function initCmd(targetDir) {
         const template = readAgentsTemplate();
         const fileHashes = {};
         // Step 5: AGENTS.md (shared by non-Claude agents)
-        const needsAgentsMd = usePi || useCursor || useCopilot || useOpenCode || useCodex;
+        const needsAgentsMd = usePi ||
+            useCursor ||
+            useCopilot ||
+            useOpenCode ||
+            useCodex ||
+            useAntigravity;
         if (needsAgentsMd) {
             await setupAgentsMd(root, latDir, template, fileHashes, ask);
         }
@@ -1008,6 +1028,24 @@ export async function initCmd(targetDir) {
             console.log(styleText('bold', 'Setting up Codex...'));
             await setupCodex(root, latDir, fileHashes, ask, commandStyle);
         }
+        if (useAntigravity) {
+            console.log('');
+            console.log(styleText('bold', 'Setting up Antigravity / Gemini...'));
+            await setupAntigravity({
+                root,
+                latDir,
+                template,
+                hashes: fileHashes,
+                ask,
+                style: commandStyle,
+                latBin: latBinString(commandStyle),
+                appendTemplateSection,
+                writeTemplateFile,
+                ensureGitignored,
+                hasMcpServer,
+                addMcpServer,
+            });
+        }
         await writeForkInstructions(root, latDir, fileHashes, ask);
         // Record init version and file hashes so `lat check` can detect stale setups
         writeInitMeta(latDir, fileHashes);

package/dist/src/cli/locate.js

@@ -1,9 +1,10 @@
-import { loadAllSections, findSections } from '../lattice.js';
+import { findSections } from '../lattice-model.js';
 import { formatResultList } from '../format.js';
+import { commandProjectAnalysis } from '../project-analysis.js';
 export async function locateCommand(ctx, query) {
     const stripped = query.replace(/^\[\[|\]\]$/g, '');
-    const sections = await loadAllSections(ctx.latDir);
-    const matches = findSections(sections, stripped);
+    const project = await commandProjectAnalysis(ctx);
+    const matches = findSections(project.allSections, stripped);
     if (matches.length === 0) {
         const s = ctx.styler;
         return {

package/dist/src/cli/refs.d.ts

@@ -1,4 +1,4 @@
-import { type Section, type SectionMatch } from '../lattice.js';
+import { type Section, type SectionMatch } from '../lattice-model.js';
 import type { CmdContext, CmdResult } from '../context.js';
 export type Scope = 'md' | 'code' | 'md+code';
 export type RefsFound = {
@@ -10,6 +10,7 @@ export type RefsFound = {
 export type RefsError = {
     kind: 'no-match';
     suggestions: SectionMatch[];
+    message?: string;
 };
 export type RefsResult = RefsFound | RefsError;
 /**

package/dist/src/cli/refs.js

@@ -1,21 +1,9 @@
-import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { extname, join, relative } from 'node:path';
-import { listLatticeFiles, loadAllSections, findSections, extractRefs, flattenSections, buildFileIndex, buildSectionSlugIndex, resolveRef, } from '../lattice.js';
+import { findSections, resolveRef, } from '../lattice-model.js';
 import { formatResultList } from '../format.js';
-import { scanCodeRefs } from '../code-refs.js';
-/** Extensions recognized as source code for ref queries. */
-const SOURCE_EXTS = new Set([
-    '.ts',
-    '.tsx',
-    '.js',
-    '.jsx',
-    '.py',
-    '.rs',
-    '.go',
-    '.c',
-    '.h',
-]);
+import { commandProjectAnalysis, commandProjectSession, } from '../project-analysis.js';
+import { isSourceFileExtension } from '../source-formats.js';
 /**
  * Check if a query looks like a source file path (has a recognized extension
  * and the file exists on disk).
@@ -25,7 +13,7 @@ function isSourceQuery(query, projectRoot) {
     const filePart = hashIdx === -1 ? query : query.slice(0, hashIdx);
     const symbolPart = hashIdx === -1 ? '' : query.slice(hashIdx + 1);
     const ext = extname(filePart);
-    if (!SOURCE_EXTS.has(ext))
+    if (!isSourceFileExtension(ext))
         return null;
     if (!existsSync(join(projectRoot, filePart)))
         return null;
@@ -36,7 +24,8 @@ function isSourceQuery(query, projectRoot) {
  * For file-level queries (no #symbol), matches all wiki links targeting
  * that file or any symbol in it.
  */
-async function findSourceRefs(latDir, projectRoot, query, scope) {
+async function findSourceRefs(ctx, query, scope) {
+    const { projectRoot } = ctx;
     const hashIdx = query.indexOf('#');
     const filePart = hashIdx === -1 ? query : query.slice(0, hashIdx);
     const isFileLevel = hashIdx === -1;
@@ -59,7 +48,7 @@ async function findSourceRefs(latDir, projectRoot, query, scope) {
         const { resolveSourceSymbol } = await import('../source-parser.js');
         if (hashIdx !== -1) {
             const symbolPart = query.slice(hashIdx + 1);
-            const { found, symbols } = await resolveSourceSymbol(filePart, symbolPart, projectRoot);
+            const { found, symbols } = await resolveSourceSymbol(filePart, symbolPart, projectRoot, commandProjectSession(ctx).sourceSymbolOptions());
             if (found) {
                 const parts = symbolPart.split('#');
                 const sym = symbols.find((s) => parts.length === 1
@@ -76,17 +65,14 @@ async function findSourceRefs(latDir, projectRoot, query, scope) {
     catch {
         // source parser unavailable — proceed without line info
     }
-    const allSections = await loadAllSections(latDir);
-    const flat = flattenSections(allSections);
+    const project = await commandProjectAnalysis(ctx);
+    const flat = project.sections;
     const mdRefs = [];
     const codeRefs = [];
     if (scope === 'md' || scope === 'md+code') {
-        const files = await listLatticeFiles(latDir);
         const matchingFromSections = new Set();
-        for (const file of files) {
-            const content = await readFile(file, 'utf-8');
-            const fileRefs = extractRefs(file, content, projectRoot);
-            for (const ref of fileRefs) {
+        for (const file of project.files.values()) {
+            for (const ref of file.wikiRefs) {
                 const targetLower = ref.target.toLowerCase();
                 const matches = isFileLevel
                     ? targetLower === fileLower || targetLower.startsWith(fileLower + '#')
@@ -104,7 +90,7 @@ async function findSourceRefs(latDir, projectRoot, query, scope) {
         }
     }
     if (scope === 'code' || scope === 'md+code') {
-        const { refs: scannedRefs } = await scanCodeRefs(projectRoot);
+        const { refs: scannedRefs } = await commandProjectSession(ctx).codeRefs();
         for (const ref of scannedRefs) {
             const targetLower = ref.target.toLowerCase();
             const matches = isFileLevel
@@ -118,6 +104,56 @@ async function findSourceRefs(latDir, projectRoot, query, scope) {
     }
     return { kind: 'found', target, mdRefs, codeRefs };
 }
+async function findExternalRefs(ctx, query, scope) {
+    const external = await commandProjectSession(ctx).external();
+    const parsed = external.parse(query);
+    const target = {
+        id: parsed.identity,
+        heading: parsed.fragment || parsed.authoredPath,
+        depth: 0,
+        file: parsed.identity,
+        filePath: parsed.identity,
+        children: [],
+        startLine: 0,
+        endLine: 0,
+        firstParagraph: '',
+    };
+    const project = await commandProjectAnalysis(ctx);
+    const flat = project.sections;
+    const matchingSections = new Set();
+    const codeRefs = [];
+    const matchesTarget = (candidate) => {
+        try {
+            return external.parse(candidate)?.identity === parsed.identity;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (scope !== 'code') {
+        for (const file of project.files.values()) {
+            for (const ref of file.wikiRefs) {
+                if (matchesTarget(ref.target))
+                    matchingSections.add(ref.fromSection.toLowerCase());
+            }
+        }
+    }
+    if (scope !== 'md') {
+        for (const ref of (await commandProjectSession(ctx).codeRefs()).refs) {
+            if (matchesTarget(ref.target)) {
+                codeRefs.push(`${relative(process.cwd(), join(ctx.projectRoot, ref.file))}:${ref.line}`);
+            }
+        }
+    }
+    return {
+        kind: 'found',
+        target,
+        mdRefs: flat
+            .filter((section) => matchingSections.has(section.id.toLowerCase()))
+            .map((section) => ({ section, reason: 'wiki link' })),
+        codeRefs,
+    };
+}
 /**
  * Find all sections and code locations that reference a given section or
  * source file. Accepts section ids (full-path, short-form) and source file
@@ -126,15 +162,29 @@ async function findSourceRefs(latDir, projectRoot, query, scope) {
  */
 export async function findRefs(ctx, query, scope) {
     query = query.replace(/^\[\[|\]\]$/g, '');
+    const external = await commandProjectSession(ctx).external();
+    try {
+        if (external.parse(query))
+            return findExternalRefs(ctx, query, scope);
+    }
+    catch (error) {
+        return {
+            kind: 'no-match',
+            suggestions: [],
+            message: error.message,
+        };
+    }
+    const unknownExternal = external.unknownTargetMessage(query);
+    if (unknownExternal) {
+        return { kind: 'no-match', suggestions: [], message: unknownExternal };
+    }
     // Source file queries bypass section resolution
     if (isSourceQuery(query, ctx.projectRoot)) {
-        return findSourceRefs(ctx.latDir, ctx.projectRoot, query, scope);
+        return findSourceRefs(ctx, query, scope);
     }
-    const allSections = await loadAllSections(ctx.latDir);
-    const flat = flattenSections(allSections);
-    const sectionIds = new Set(flat.map((s) => s.id.toLowerCase()));
-    const fileIndex = buildFileIndex(allSections);
-    const slugIndex = buildSectionSlugIndex(allSections);
+    const project = await commandProjectAnalysis(ctx);
+    const { allSections, sections: flat, fileIndex, slugIndex } = project;
+    const sectionIds = new Set(project.sectionIds);
     const { resolved } = resolveRef(query, sectionIds, fileIndex, slugIndex);
     const q = resolved.toLowerCase();
     let exactMatch = flat.find((s) => s.id.toLowerCase() === q);
@@ -157,17 +207,9 @@ export async function findRefs(ctx, query, scope) {
     const mdRefs = [];
     const codeRefs = [];
     if (scope === 'md' || scope === 'md+code') {
-        const files = await listLatticeFiles(ctx.latDir);
         const matchingFromSections = new Set();
-        for (const file of files) {
-            const content = await readFile(file, 'utf-8');
-            const fileRefs = extractRefs(file, content, ctx.projectRoot);
-            for (const ref of fileRefs) {
-                const { resolved: refResolved } = resolveRef(ref.target, sectionIds, fileIndex, slugIndex);
-                if (refResolved.toLowerCase() === targetId) {
-                    matchingFromSections.add(ref.fromSection.toLowerCase());
-                }
-            }
+        for (const ref of project.incomingRefsBySection.get(targetId) ?? []) {
+            matchingFromSections.add(ref.fromSection.toLowerCase());
         }
         if (matchingFromSections.size > 0) {
             const referrers = flat.filter((s) => matchingFromSections.has(s.id.toLowerCase()));
@@ -177,7 +219,7 @@ export async function findRefs(ctx, query, scope) {
         }
     }
     if (scope === 'code' || scope === 'md+code') {
-        const { refs: scannedRefs } = await scanCodeRefs(ctx.projectRoot);
+        const { refs: scannedRefs } = await commandProjectSession(ctx).codeRefs();
         for (const ref of scannedRefs) {
             const { resolved: codeResolved } = resolveRef(ref.target, sectionIds, fileIndex, slugIndex);
             if (codeResolved.toLowerCase() === targetId) {
@@ -192,6 +234,9 @@ export async function refsCommand(ctx, query, scope) {
     const result = await findRefs(ctx, query, scope);
     if (result.kind === 'no-match') {
         const s = ctx.styler;
+        if (result.message) {
+            return { output: s.red(result.message), isError: true };
+        }
         if (result.suggestions.length > 0) {
             const suggestions = result.suggestions
                 .map((m) => `  ${s.dim('*')} ${s.white(m.section.id)} ${s.dim(`(${m.reason})`)}`)

package/dist/src/cli/reindex.js

@@ -3,6 +3,7 @@ import { openDb, ensureMeta, setStoredModel, ensureSectionsSchema, dropSections,
 import { embedderFromEnv, localEmbedder, modelKey, EmbeddingAuthError, } from '../search/embedder.js';
 import { getLlmKey, getRepoEmbedding, setRepoEmbedding } from '../config.js';
 import { indexSections } from '../search/index.js';
+import { commandProjectAnalysis } from '../project-analysis.js';
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 async function confirmUseLocal(ctx, status, assumeYes) {
     const s = ctx.styler;
@@ -106,7 +107,7 @@ export async function reindexCommand(ctx, opts) {
             process.stderr.write(s.dim(label + '…\n'));
         let stats;
         try {
-            stats = await indexSections(ctx.latDir, db, embedder, onProgress);
+            stats = await indexSections(ctx.latDir, db, embedder, onProgress, await commandProjectAnalysis(ctx));
             // Pin the backend only after a successful build, so a failed reindex never
             // records a model that doesn't match a completed index.
             await setStoredModel(db, modelKey(embedder));

package/dist/src/cli/search.d.ts

@@ -1,6 +1,8 @@
 import type { CmdContext, CmdResult, Styler } from '../context.js';
 import { type IndexStats } from '../search/index.js';
-import { type Section, type SectionMatch } from '../lattice.js';
+import type { SectionMatch } from '../lattice-model.js';
+import type { Section } from '../lattice-model.js';
+import { type MarkdownProjectAnalysis } from '../project-analysis.js';
 export type SearchResult = {
     query: string;
     matches: SectionMatch[];
@@ -23,14 +25,21 @@ export type IndexProgress = {
  */
 export declare function runSearch(latDir: string, query: string, limit: number, progress?: IndexProgress, opts?: {
     buildIndex?: boolean;
-    preloadedSections?: Section[];
+    project?: MarkdownProjectAnalysis;
+    sectionById?: ReadonlyMap<string, Section>;
+    threshold?: number;
+    cacheDir?: string;
 }): Promise<SearchResult>;
 /**
  * Index-only mode (no query) — builds the index on first use. Rebuilding is
  * `lat reindex`, not a flag here.
  */
-export declare function runIndex(latDir: string, progress?: IndexProgress): Promise<void>;
+export declare function runIndex(latDir: string, progress?: IndexProgress, analyzedProject?: MarkdownProjectAnalysis, options?: {
+    cacheDir?: string;
+}): Promise<void>;
 export declare function cliProgress(s: Styler): IndexProgress;
 export declare function searchCommand(ctx: CmdContext, query: string | undefined, opts: {
     limit: number;
+    debug?: boolean;
+    threshold?: number;
 }, progress?: IndexProgress): Promise<CmdResult>;

package/dist/src/cli/search.js

@@ -1,15 +1,16 @@
 import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { openDb, ensureMeta, getStoredModel, setStoredModel, ensureSectionsSchema, dropSections, closeDb, } from '../search/db.js';
 import { getLlmKey } from '../config.js';
 import { embedderForIndex, modelKey, ReindexRequiredError, EmbeddingAuthError, } from '../search/embedder.js';
 import { indexSections } from '../search/index.js';
 import { searchSections } from '../search/search.js';
-import { loadAllSections, flattenSections, } from '../lattice.js';
+import { searchIndexedSections } from '../search/query.js';
+import { analyzeMarkdownProject, commandProjectAnalysis, } from '../project-analysis.js';
 import { formatSectionPreview, formatNavHints } from '../format.js';
 import { provenanceNote, formatProvenanceNote } from './check-status.js';
-async function withDb(latDir, progress, fn) {
-    const db = openDb(latDir);
+async function withDb(latDir, progress, project, cacheDir, fn) {
+    const db = openDb(latDir, cacheDir);
     try {
         await ensureMeta(db);
         const stored = await getStoredModel(db);
@@ -46,7 +47,7 @@ async function withDb(latDir, progress, fn) {
         }
         progress?.beforeIndex?.(isEmpty);
         try {
-            const stats = await indexSections(latDir, db, embedder);
+            const stats = await indexSections(latDir, db, embedder, undefined, project);
             // Pin the backend only after a successful index, so a failed build never
             // leaves the repo wrongly pinned to an empty index.
             if (!stored)
@@ -60,26 +61,12 @@ async function withDb(latDir, progress, fn) {
                 await dropSections(db);
             throw err;
         }
-        return await fn(db, embedder);
+        return await fn(db, embedder, project);
     }
     finally {
         await closeDb(db);
     }
 }
-/** Resolve raw search hits (by id) to full section matches. */
-async function resolveMatches(latDir, results, preloadedSections) {
-    if (results.length === 0)
-        return [];
-    const allSections = preloadedSections ?? (await loadAllSections(latDir));
-    const flat = flattenSections(allSections);
-    const byId = new Map(flat.map((s) => [s.id, s]));
-    return results.flatMap((result) => {
-        const section = byId.get(result.id);
-        return section
-            ? [{ section, reason: 'semantic match', score: result.score }]
-            : [];
-    });
-}
 /**
  * Run a semantic search across lat.md sections.
  * Handles indexing (with optional progress callback). Returns matched sections.
@@ -92,31 +79,30 @@ async function resolveMatches(latDir, results, preloadedSections) {
  */
 export async function runSearch(latDir, query, limit, progress, opts) {
     if (opts?.buildIndex === false) {
-        const db = openDb(latDir);
-        try {
-            await ensureMeta(db);
-            const stored = await getStoredModel(db);
-            // Never built (or a legacy pre-versioning cache) — leave building to
-            // `lat search`; don't load the embedder just to embed the query.
-            if (stored === null)
-                return { query, matches: [] };
-            const embedder = await embedderForIndex(stored, latDir);
-            await ensureSectionsSchema(db, embedder.dimensions);
-            const results = await searchSections(db, query, embedder, limit);
-            return {
-                query,
-                matches: await resolveMatches(latDir, results, opts?.preloadedSections),
-            };
-        }
-        finally {
-            await closeDb(db);
-        }
+        const sectionById = opts.sectionById ??
+            opts.project?.sectionById ??
+            (await analyzeMarkdownProject(latDir, dirname(latDir), {
+                executor: 'auto',
+            })).sectionById;
+        return searchIndexedSections(latDir, query, limit, sectionById, {
+            cacheDir: opts.cacheDir,
+            threshold: opts.threshold,
+        });
     }
-    return withDb(latDir, progress, async (db, embedder) => {
-        const results = await searchSections(db, query, embedder, limit);
+    const project = opts?.project ??
+        (await analyzeMarkdownProject(latDir, dirname(latDir), {
+            executor: 'auto',
+        }));
+    return withDb(latDir, progress, project, opts?.cacheDir, async (db, embedder, analyzed) => {
+        const results = await searchSections(db, query, embedder, limit, opts?.threshold);
         return {
             query,
-            matches: await resolveMatches(latDir, results, opts?.preloadedSections),
+            matches: results.flatMap((result) => {
+                const section = analyzed.sectionById.get(result.id.toLowerCase());
+                return section
+                    ? [{ section, reason: 'semantic match', score: result.score }]
+                    : [];
+            }),
         };
     });
 }
@@ -124,8 +110,12 @@ export async function runSearch(latDir, query, limit, progress, opts) {
  * Index-only mode (no query) — builds the index on first use. Rebuilding is
  * `lat reindex`, not a flag here.
  */
-export async function runIndex(latDir, progress) {
-    await withDb(latDir, progress, async () => { });
+export async function runIndex(latDir, progress, analyzedProject, options = {}) {
+    const project = analyzedProject ??
+        (await analyzeMarkdownProject(latDir, dirname(latDir), {
+            executor: 'auto',
+        }));
+    await withDb(latDir, progress, project, options.cacheDir, async () => { });
 }
 export function cliProgress(s) {
     return {
@@ -153,7 +143,7 @@ export function cliProgress(s) {
  * say whether a person ever checked that claim. Frontmatter is read once per
  * file rather than once per match, since several matches routinely share one.
  */
-async function formatSearchMatches(ctx, query, matches) {
+async function formatSearchMatches(ctx, query, matches, opts) {
     const notes = new Map();
     for (const match of matches) {
         const filePath = match.section.filePath;
@@ -173,6 +163,7 @@ async function formatSearchMatches(ctx, query, matches) {
             lines.push('');
         lines.push(formatSectionPreview(ctx, matches[i].section, {
             reason: matches[i].reason,
+            score: opts?.showScores ? matches[i].score : undefined,
         }));
         const note = notes.get(matches[i].section.filePath);
         if (note)
@@ -185,16 +176,21 @@ export async function searchCommand(ctx, query, opts, progress) {
     const s = ctx.styler;
     try {
         if (!query) {
-            await runIndex(ctx.latDir, progress);
+            await runIndex(ctx.latDir, progress, await commandProjectAnalysis(ctx));
             return { output: '' };
         }
-        const result = await runSearch(ctx.latDir, query, opts.limit, progress);
+        const project = await commandProjectAnalysis(ctx);
+        const result = await runSearch(ctx.latDir, query, opts.limit, progress, {
+            project,
+            threshold: opts.threshold,
+        });
         if (result.matches.length === 0) {
             return { output: 'No results found.' };
         }
         return {
-            output: (await formatSearchMatches(ctx, query, result.matches)) +
-                formatNavHints(ctx),
+            output: (await formatSearchMatches(ctx, query, result.matches, {
+                showScores: opts.debug,
+            })) + formatNavHints(ctx),
         };
     }
     catch (err) {