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

package/dist/src/fork/antigravity-hook.d.ts

@@ -0,0 +1,47 @@
+export type AntigravityPreInvocationInput = {
+    conversationId?: string;
+    workspacePaths?: string[];
+    transcriptPath?: string;
+    artifactDirectoryPath?: string;
+    modelName?: string;
+    user_prompt?: string;
+    prompt?: string;
+    userPrompt?: string;
+};
+export type AntigravityPreInvocationOutput = {
+    injectSteps: Array<{
+        ephemeralMessage?: string;
+    }>;
+};
+export type AntigravityPreToolUseInput = {
+    toolCall?: {
+        name?: string;
+        args?: Record<string, unknown>;
+    };
+    stepIdx?: number;
+    workspacePaths?: string[];
+};
+export type AntigravityPreToolUseOutput = {
+    decision: 'allow' | 'deny';
+    reason?: string;
+};
+export type AntigravityStopInput = {
+    executionNum?: number;
+    execution_num?: number;
+    stop_hook_active?: boolean;
+    stopHookActive?: boolean;
+    terminationReason?: string;
+    error?: string;
+    fullyIdle?: boolean;
+    workspacePaths?: string[];
+};
+export type AntigravityStopOutput = {
+    decision?: 'continue';
+    reason?: string;
+};
+export declare function extractLastUserPrompt(transcriptPath?: string): string | null;
+export declare function handleAntigravityPreInvocation(rawInput?: string, writeOutput?: boolean): Promise<AntigravityPreInvocationOutput>;
+export declare function handleAntigravityPreToolUse(rawInput?: string, writeOutput?: boolean): Promise<AntigravityPreToolUseOutput>;
+export declare function handleAntigravityPostToolUse(rawInput?: string, writeOutput?: boolean): Promise<Record<string, unknown>>;
+export declare function handleAntigravityStop(rawInput?: string, writeOutput?: boolean): Promise<AntigravityStopOutput>;
+export declare function handleAntigravityHook(event: string, rawInput?: string): Promise<void>;

package/dist/src/fork/antigravity-hook.js

@@ -0,0 +1,424 @@
+import { existsSync, openSync, readSync, closeSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { findLatticeDir, findSections } from '../lattice.js';
+import { commandProjectAnalysis } from '../project-analysis.js';
+import { plainStyler } from '../context.js';
+import { expandPrompt } from '../cli/expand.js';
+import { runSearch } from '../cli/search.js';
+import { getSection, formatSectionOutput } from '../cli/section.js';
+import { getStopStatus, formatStopReason, } from '../cli/hook.js';
+import { computeCommentBlock } from '../cli/comment-guard.js';
+import { taggedDocsForFiles, federateTags } from '../knowledge/index.js';
+import { loadSessionMarkers, saveSessionMarkers, } from '../knowledge/session.js';
+async function readStdin(timeoutMs = 300) {
+    if (process.stdin.isTTY)
+        return '';
+    return new Promise((resolve) => {
+        const chunks = [];
+        let timer = null;
+        const cleanup = () => {
+            if (timer)
+                clearTimeout(timer);
+            try {
+                process.stdin.pause();
+            }
+            catch { }
+            process.stdin.removeListener('data', onData);
+            process.stdin.removeListener('end', onEnd);
+            process.stdin.removeListener('error', onError);
+        };
+        const onData = (chunk) => {
+            chunks.push(chunk);
+        };
+        const onEnd = () => {
+            cleanup();
+            resolve(Buffer.concat(chunks).toString('utf-8'));
+        };
+        const onError = () => {
+            cleanup();
+            resolve(Buffer.concat(chunks).toString('utf-8'));
+        };
+        timer = setTimeout(() => {
+            cleanup();
+            resolve(Buffer.concat(chunks).toString('utf-8'));
+        }, timeoutMs);
+        process.stdin.on('data', onData);
+        process.stdin.on('end', onEnd);
+        process.stdin.on('error', onError);
+        process.stdin.resume();
+    });
+}
+export function extractLastUserPrompt(transcriptPath) {
+    if (!transcriptPath || !existsSync(transcriptPath))
+        return null;
+    let fd = null;
+    try {
+        const stat = statSync(transcriptPath);
+        if (stat.size === 0)
+            return null;
+        fd = openSync(transcriptPath, 'r');
+        const chunkSize = Math.min(64 * 1024, stat.size);
+        const buffer = Buffer.alloc(chunkSize);
+        readSync(fd, buffer, 0, chunkSize, stat.size - chunkSize);
+        closeSync(fd);
+        fd = null;
+        const chunkStr = buffer.toString('utf-8');
+        const lines = chunkStr.trim().split('\n');
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            const entry = JSON.parse(line);
+            const isUser = entry.type === 'USER_INPUT' ||
+                entry.type === 'user' ||
+                entry.role === 'user';
+            if (isUser) {
+                if (typeof entry.content === 'string')
+                    return entry.content;
+                if (typeof entry.text === 'string')
+                    return entry.text;
+                if (typeof entry.message === 'string')
+                    return entry.message;
+                if (Array.isArray(entry.content)) {
+                    const text = entry.content
+                        .map((p) => typeof p === 'string'
+                        ? p
+                        : (p?.text ??
+                            p?.content ??
+                            ''))
+                        .filter(Boolean)
+                        .join('\n');
+                    if (text)
+                        return text;
+                }
+                if (Array.isArray(entry.parts)) {
+                    const text = entry.parts
+                        .map((p) => typeof p === 'string'
+                        ? p
+                        : (p?.text ??
+                            p?.content ??
+                            ''))
+                        .filter(Boolean)
+                        .join('\n');
+                    if (text)
+                        return text;
+                }
+            }
+        }
+    }
+    catch {
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                closeSync(fd);
+            }
+            catch { }
+        }
+    }
+    return null;
+}
+function makeHookCtx(latDir) {
+    return {
+        latDir,
+        projectRoot: dirname(latDir),
+        styler: plainStyler,
+        mode: 'cli',
+    };
+}
+export async function handleAntigravityPreInvocation(rawInput, writeOutput = true) {
+    const emptyOutput = { injectSteps: [] };
+    try {
+        const raw = rawInput ?? (await readStdin().catch(() => ''));
+        let input = {};
+        try {
+            input = JSON.parse(raw);
+        }
+        catch { }
+        const userPrompt = input.user_prompt ||
+            input.prompt ||
+            input.userPrompt ||
+            extractLastUserPrompt(input.transcriptPath) ||
+            '';
+        const workspacePaths = input.workspacePaths ??
+            input.workspace_paths;
+        const latDir = findLatticeDir(workspacePaths?.[0]) ?? findLatticeDir();
+        if (!latDir) {
+            if (writeOutput)
+                process.stdout.write(JSON.stringify(emptyOutput) + '\n');
+            return emptyOutput;
+        }
+        const ctx = makeHookCtx(latDir);
+        const parts = [];
+        const searchFilePaths = [];
+        if (userPrompt) {
+            // Memoised on ctx, so the expansion, search, and federation below
+            // share one parse of the tree — same contract as cli/hook.ts.
+            const allSections = await commandProjectAnalysis(ctx)
+                .then((analysis) => analysis.allSections)
+                .catch(() => []);
+            if (/\[\[[^\]]+\]\]/.test(userPrompt)) {
+                try {
+                    const expanded = await expandPrompt(ctx, userPrompt);
+                    if (expanded && expanded !== userPrompt) {
+                        parts.push(expanded, '');
+                    }
+                }
+                catch { }
+            }
+            try {
+                const searchResult = await runSearch(ctx.latDir, userPrompt, 5, undefined, {
+                    buildIndex: false,
+                });
+                if (searchResult.matches.length > 0) {
+                    parts.push(`Search results for user prompt (${searchResult.matches.length} matches):`, '');
+                    for (const match of searchResult.matches) {
+                        searchFilePaths.push(match.section.filePath);
+                        const sectionResult = await getSection(ctx, match.section.id);
+                        if (sectionResult.kind === 'found') {
+                            parts.push(formatSectionOutput(ctx, sectionResult));
+                            parts.push('');
+                        }
+                    }
+                }
+            }
+            catch { }
+            try {
+                const filePaths = [];
+                const refTargets = [...userPrompt.matchAll(/\[\[([^\]]+)\]\]/g)].map((m) => m[1]);
+                for (const target of refTargets) {
+                    const matches = findSections(allSections, target);
+                    if (matches.length > 0) {
+                        filePaths.push(matches[0].section.filePath);
+                    }
+                }
+                filePaths.push(...searchFilePaths);
+                if (filePaths.length > 0) {
+                    const docs = await taggedDocsForFiles(ctx.projectRoot, filePaths);
+                    const sessionId = input.conversationId ??
+                        input.conversation_id ??
+                        input.session_id ??
+                        '';
+                    const sessionMarkers = loadSessionMarkers(sessionId);
+                    const federated = await federateTags(docs, {
+                        projectRoot: ctx.projectRoot,
+                        seen: sessionMarkers.markers.seen,
+                        attemptedEmpty: sessionMarkers.markers.attemptedEmpty,
+                    });
+                    saveSessionMarkers(sessionMarkers);
+                    if (federated) {
+                        parts.push('', federated);
+                    }
+                }
+            }
+            catch { }
+        }
+        parts.push('Review whether `lat.md/` needs a current-state update; do not add journal/changelog notes just to satisfy this reminder. Run `lat search` to find relevant sections and `lat check` at the end.');
+        const output = {
+            injectSteps: [
+                {
+                    ephemeralMessage: parts.join('\n').trim(),
+                },
+            ],
+        };
+        if (writeOutput) {
+            process.stdout.write(JSON.stringify(output) + '\n');
+        }
+        return output;
+    }
+    catch {
+        if (writeOutput) {
+            process.stdout.write(JSON.stringify(emptyOutput) + '\n');
+        }
+        return emptyOutput;
+    }
+}
+export async function handleAntigravityPreToolUse(rawInput, writeOutput = true) {
+    const allow = { decision: 'allow' };
+    try {
+        const raw = rawInput ?? (await readStdin().catch(() => ''));
+        let input = {};
+        try {
+            input = JSON.parse(raw);
+        }
+        catch {
+            if (writeOutput)
+                process.stdout.write(JSON.stringify(allow) + '\n');
+            return allow;
+        }
+        const rawToolName = input.toolCall?.name ?? '';
+        const toolName = rawToolName.split(':').pop() ?? rawToolName;
+        const args = input.toolCall?.args ?? {};
+        let toolInput = {};
+        if (toolName === 'replace_file_content') {
+            toolInput = {
+                file_path: (args.TargetFile ??
+                    args.target_file ??
+                    args.filePath ??
+                    args.file_path),
+                new_string: (args.ReplacementContent ??
+                    args.replacement_content ??
+                    args.new_string),
+                old_string: (args.TargetContent ??
+                    args.target_content ??
+                    args.old_string),
+            };
+        }
+        else if (toolName === 'write_to_file') {
+            toolInput = {
+                file_path: (args.TargetFile ??
+                    args.target_file ??
+                    args.filePath ??
+                    args.file_path),
+                content: (args.CodeContent ?? args.code_content ?? args.content),
+            };
+        }
+        else {
+            if (writeOutput)
+                process.stdout.write(JSON.stringify(allow) + '\n');
+            return allow;
+        }
+        const cwd = input.workspacePaths?.[0] ??
+            input.workspace_paths?.[0] ??
+            process.cwd();
+        if (!toolInput.file_path) {
+            if (writeOutput)
+                process.stdout.write(JSON.stringify(allow) + '\n');
+            return allow;
+        }
+        if (!isAbsolute(toolInput.file_path)) {
+            toolInput.file_path = resolve(cwd, toolInput.file_path);
+        }
+        const reason = computeCommentBlock({
+            tool_name: toolName === 'replace_file_content' ? 'Edit' : 'Write',
+            tool_input: toolInput,
+            cwd,
+        });
+        if (reason) {
+            const deny = {
+                decision: 'deny',
+                reason,
+            };
+            if (writeOutput)
+                process.stdout.write(JSON.stringify(deny) + '\n');
+            return deny;
+        }
+        if (writeOutput)
+            process.stdout.write(JSON.stringify(allow) + '\n');
+        return allow;
+    }
+    catch {
+        if (writeOutput)
+            process.stdout.write(JSON.stringify(allow) + '\n');
+        return allow;
+    }
+}
+export async function handleAntigravityPostToolUse(rawInput, writeOutput = true) {
+    const output = {};
+    try {
+        const raw = rawInput ?? (await readStdin().catch(() => ''));
+        let input = {};
+        try {
+            input = JSON.parse(raw);
+        }
+        catch { }
+        const workspacePath = input.workspacePaths?.[0] ??
+            input.workspace_paths?.[0] ??
+            input.cwd;
+        const latDir = findLatticeDir(workspacePath) ?? findLatticeDir();
+        if (latDir) {
+            try {
+                const { checkIndex } = await import('../cli/check.js');
+                await checkIndex(latDir, undefined, { fix: true });
+            }
+            catch { }
+        }
+    }
+    catch { }
+    if (writeOutput) {
+        process.stdout.write(JSON.stringify(output) + '\n');
+    }
+    return output;
+}
+export async function handleAntigravityStop(rawInput, writeOutput = true) {
+    const allowStop = {};
+    try {
+        const raw = rawInput ?? (await readStdin().catch(() => ''));
+        let input = {};
+        try {
+            input = JSON.parse(raw);
+        }
+        catch { }
+        const workspacePath = input.workspacePaths?.[0] ??
+            input.workspace_paths?.[0] ??
+            input.cwd;
+        const latDir = findLatticeDir(workspacePath) ?? findLatticeDir();
+        if (!latDir) {
+            if (writeOutput)
+                process.stdout.write(JSON.stringify(allowStop) + '\n');
+            return allowStop;
+        }
+        const execNum = typeof input.executionNum === 'number'
+            ? input.executionNum
+            : typeof input.execution_num === 'number'
+                ? input.execution_num
+                : undefined;
+        const stopHookActive = Boolean(input.stop_hook_active ||
+            input.stopHookActive ||
+            (execNum !== undefined && execNum > 1));
+        let status;
+        try {
+            status = await getStopStatus(latDir);
+        }
+        catch {
+            if (writeOutput)
+                process.stdout.write(JSON.stringify(allowStop) + '\n');
+            return allowStop;
+        }
+        const reason = formatStopReason(status);
+        if (!reason) {
+            if (writeOutput)
+                process.stdout.write(JSON.stringify(allowStop) + '\n');
+            return allowStop;
+        }
+        if (stopHookActive) {
+            console.error('Warning: `lat check` still reports errors or sync gaps, but continuing stop to prevent loop.');
+            if (writeOutput)
+                process.stdout.write(JSON.stringify(allowStop) + '\n');
+            return allowStop;
+        }
+        const output = {
+            decision: 'continue',
+            reason,
+        };
+        if (writeOutput)
+            process.stdout.write(JSON.stringify(output) + '\n');
+        return output;
+    }
+    catch {
+        if (writeOutput)
+            process.stdout.write(JSON.stringify(allowStop) + '\n');
+        return allowStop;
+    }
+}
+export async function handleAntigravityHook(event, rawInput) {
+    const normalized = event.toLowerCase();
+    switch (normalized) {
+        case 'preinvocation':
+        case 'userpromptsubmit':
+            await handleAntigravityPreInvocation(rawInput);
+            return;
+        case 'pretooluse':
+            await handleAntigravityPreToolUse(rawInput);
+            return;
+        case 'posttooluse':
+            await handleAntigravityPostToolUse(rawInput);
+            return;
+        case 'stop':
+            await handleAntigravityStop(rawInput);
+            return;
+        default:
+            console.error(`Unknown hook event for antigravity: ${event}. Supported: PreInvocation, PreToolUse, PostToolUse, Stop`);
+            process.exit(1);
+    }
+}

package/dist/src/fork/antigravity-init.d.ts

@@ -0,0 +1,17 @@
+export declare function antigravityHooksTemplate(latBin: string): string;
+export declare function mergeAntigravityHooks(existingRaw: string | null, latBin: string): string;
+export type SetupAntigravityOptions = {
+    root: string;
+    latDir: string;
+    template: string;
+    hashes: Record<string, string>;
+    ask: (message: string) => Promise<boolean>;
+    style: 'global' | 'local' | 'npx';
+    latBin: string;
+    appendTemplateSection: (root: string, latDir: string, relPath: string, template: string, label: string, indent: string, ask: (message: string) => Promise<boolean>) => Promise<string | null>;
+    writeTemplateFile: (root: string, latDir: string, relPath: string, template: string, genTarget: string | null, label: string, indent: string, ask: (message: string) => Promise<boolean>) => Promise<string | null>;
+    ensureGitignored: (root: string, entry: string) => void;
+    hasMcpServer: (configPath: string, key: string) => boolean;
+    addMcpServer: (configPath: string, key: string, style: 'global' | 'local' | 'npx') => void;
+};
+export declare function setupAntigravity(opts: SetupAntigravityOptions): Promise<void>;

package/dist/src/fork/antigravity-init.js

@@ -0,0 +1,124 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { styleText } from 'node:util';
+import { readSkillTemplate } from '../cli/gen.js';
+import { readForkConventions, SKILL_FRONTMATTER, } from '../cli/fork-instructions.js';
+export function antigravityHooksTemplate(latBin) {
+    return (JSON.stringify({
+        'lat-md': {
+            PreInvocation: [
+                {
+                    type: 'command',
+                    command: `${latBin} hook antigravity PreInvocation`,
+                },
+            ],
+            PreToolUse: [
+                {
+                    matcher: 'replace_file_content|write_to_file',
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: `${latBin} hook antigravity PreToolUse`,
+                        },
+                    ],
+                },
+            ],
+            PostToolUse: [
+                {
+                    matcher: 'replace_file_content|write_to_file',
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: `${latBin} hook antigravity PostToolUse`,
+                        },
+                    ],
+                },
+            ],
+            Stop: [
+                {
+                    type: 'command',
+                    command: `${latBin} hook antigravity Stop`,
+                },
+            ],
+        },
+    }, null, 2) + '\n');
+}
+export function mergeAntigravityHooks(existingRaw, latBin) {
+    let config = {};
+    if (existingRaw) {
+        try {
+            const parsed = JSON.parse(existingRaw);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                config = parsed;
+            }
+        }
+        catch {
+            try {
+                const stripped = existingRaw
+                    .replace(/\/\*[\s\S]*?\*\//g, '')
+                    .replace(/\/\/.*/g, '')
+                    .replace(/,\s*([}\]])/g, '$1');
+                const parsed = JSON.parse(stripped);
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    config = parsed;
+                }
+            }
+            catch {
+                config = {};
+            }
+        }
+    }
+    const template = JSON.parse(antigravityHooksTemplate(latBin));
+    config['lat-md'] = template['lat-md'];
+    return JSON.stringify(config, null, 2) + '\n';
+}
+export async function setupAntigravity(opts) {
+    const { root, latDir, template, hashes, ask, style, latBin, appendTemplateSection, writeTemplateFile, ensureGitignored, hasMcpServer, addMcpServer, } = opts;
+    const geminiHash = await appendTemplateSection(root, latDir, 'GEMINI.md', template, 'GEMINI.md', '  ', ask);
+    if (geminiHash)
+        hashes['GEMINI.md'] = geminiHash;
+    console.log('');
+    console.log(styleText('dim', '  Antigravity hooks inject lat.md reminders into prompts, enforce the'));
+    console.log(styleText('dim', '  comment convention on edits, and block finishing on check failures.'));
+    const existingHooksPath = join(root, '.agents/hooks.json');
+    let hooksContent;
+    if (existsSync(existingHooksPath)) {
+        try {
+            const existingRaw = readFileSync(existingHooksPath, 'utf-8');
+            hooksContent = mergeAntigravityHooks(existingRaw, latBin);
+        }
+        catch {
+            hooksContent = antigravityHooksTemplate(latBin);
+        }
+    }
+    else {
+        hooksContent = antigravityHooksTemplate(latBin);
+    }
+    const hooksHash = await writeTemplateFile(root, latDir, '.agents/hooks.json', hooksContent, null, 'Hooks (.agents/hooks.json)', '  ', ask);
+    if (hooksHash)
+        hashes['.agents/hooks.json'] = hooksHash;
+    console.log('');
+    console.log(styleText('dim', '  The lat-md skills teach the agent how to write and maintain lat.md/ files.'));
+    const skillTemplate = readSkillTemplate();
+    const skillHash = await writeTemplateFile(root, latDir, '.agents/skills/lat-md/SKILL.md', skillTemplate, 'skill.md', 'Skill (.agents/skills/lat-md/SKILL.md)', '  ', ask);
+    if (skillHash)
+        hashes['.agents/skills/lat-md/SKILL.md'] = skillHash;
+    try {
+        const conventionsSkill = `${SKILL_FRONTMATTER}${readForkConventions()}`;
+        const conventionsHash = await writeTemplateFile(root, latDir, '.agents/skills/lat-md-conventions/SKILL.md', conventionsSkill, 'skill.md', 'Skill (.agents/skills/lat-md-conventions/SKILL.md)', '  ', ask);
+        if (conventionsHash) {
+            hashes['.agents/skills/lat-md-conventions/SKILL.md'] = conventionsHash;
+        }
+    }
+    catch { }
+    ensureGitignored(root, '.gemini');
+    const mcpPath = join(root, '.mcp.json');
+    if (hasMcpServer(mcpPath, 'mcpServers')) {
+        console.log(styleText('green', '  MCP server') + ' already configured');
+    }
+    else {
+        addMcpServer(mcpPath, 'mcpServers', style);
+        console.log(styleText('green', '  MCP server') + ' registered in .mcp.json');
+    }
+    ensureGitignored(root, '.mcp.json');
+}

package/dist/src/fork/frontmatter-fields.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The fork's frontmatter surface, kept out of upstream's type module so a
+ * field added later costs one edit here instead of two upstream.
+ *
+ * Upstream reads `require-code-mention` out of the block with a regex and asks
+ * nothing else of it. This fork parses the block as YAML and hands the whole
+ * `lat:` mapping to its own checks, which means it also has to report the two
+ * ways that parse can go wrong.
+ */
+/**
+ * Every field this build reads out of the `lat:` mapping. Kept in one place so
+ * a field added later is covered by the misplacement check without a second
+ * edit — the trap this list guards against is silent, so it must not depend on
+ * whoever adds the next field remembering to register it twice.
+ */
+export declare const LAT_FIELDS: readonly ["require-code-mention", "mode", "require-mode", "status", "reviewed-hash", "tags"];
+/**
+ * Something wrong with the frontmatter itself, carried out of the parser for a
+ * caller to report. Both kinds fail OPEN if they stay quiet: a misplaced or
+ * unparseable `require-code-mention` turns a validation off and `lat check`
+ * then reports success on a file that is no longer being validated.
+ */
+export type FrontmatterProblem = {
+    kind: 'root-level-field';
+    field: string;
+} | {
+    kind: 'parse-error';
+    message: string;
+};
+/** Mixed into upstream's `LatFrontmatter` rather than replacing it. */
+export type ForkFrontmatter = {
+    /** Every key under the `lat:` mapping, parsed but not mapped to a field. */
+    raw: Record<string, unknown>;
+    /** Populated only when something is wrong; absent on a healthy document. */
+    problems?: FrontmatterProblem[];
+};

package/dist/src/fork/frontmatter-fields.js

@@ -0,0 +1,23 @@
+/**
+ * The fork's frontmatter surface, kept out of upstream's type module so a
+ * field added later costs one edit here instead of two upstream.
+ *
+ * Upstream reads `require-code-mention` out of the block with a regex and asks
+ * nothing else of it. This fork parses the block as YAML and hands the whole
+ * `lat:` mapping to its own checks, which means it also has to report the two
+ * ways that parse can go wrong.
+ */
+/**
+ * Every field this build reads out of the `lat:` mapping. Kept in one place so
+ * a field added later is covered by the misplacement check without a second
+ * edit — the trap this list guards against is silent, so it must not depend on
+ * whoever adds the next field remembering to register it twice.
+ */
+export const LAT_FIELDS = [
+    'require-code-mention',
+    'mode',
+    'require-mode',
+    'status',
+    'reviewed-hash',
+    'tags',
+];

package/dist/src/format.d.ts

@@ -1,8 +1,11 @@
-import type { Section, SectionMatch } from './lattice.js';
+import type { Section, SectionMatch } from './lattice-model.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;
+    score?: number;
+}): string;
+export declare function formatResultList(ctx: CmdContext, header: string, matches: SectionMatch[], opts?: {
+    showScores?: boolean;
 }): string;
-export declare function formatResultList(ctx: CmdContext, header: string, matches: SectionMatch[]): string;
 export declare function formatNavHints(ctx: CmdContext): string;