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

package/dist/src/cli/checklist-menu.d.ts

@@ -5,8 +5,9 @@ export interface ChecklistOption {
 /**
  * Display an interactive multi-select checklist with arrow-key navigation.
  * Returns an array of checked values.
+ * Known initial values start checked; unknown values are ignored.
  *
  * Keys: Up/Down (j/k) to move, Space to toggle, Enter to confirm, Ctrl+C to exit.
  * Non-TTY fallback: returns [].
  */
-export declare function checklistMenu(options: ChecklistOption[], prompt?: string): Promise<string[]>;
+export declare function checklistMenu(options: ChecklistOption[], prompt?: string, initialValues?: readonly string[]): Promise<string[]>;

package/dist/src/cli/checklist-menu.js

@@ -2,18 +2,19 @@ import { styleText } from 'node:util';
 /**
  * Display an interactive multi-select checklist with arrow-key navigation.
  * Returns an array of checked values.
+ * Known initial values start checked; unknown values are ignored.
  *
  * Keys: Up/Down (j/k) to move, Space to toggle, Enter to confirm, Ctrl+C to exit.
  * Non-TTY fallback: returns [].
  */
-export async function checklistMenu(options, prompt) {
+export async function checklistMenu(options, prompt, initialValues = []) {
     if (options.length === 0)
         return [];
     if (!process.stdin.isTTY)
         return [];
     return new Promise((resolve) => {
         let cursor = 0;
-        const checked = new Set();
+        const checked = new Set(options.flatMap((option, index) => initialValues.includes(option.value) ? [index] : []));
         const stdin = process.stdin;
         const wasRaw = stdin.isRaw;
         stdin.setRawMode(true);

package/dist/src/cli/index.js

@@ -19,6 +19,18 @@ function parsePort(value) {
     }
     return port;
 }
+function parseUiServerBuildTarget(value) {
+    if (value !== 'node' && value !== 'vercel') {
+        throw new InvalidArgumentError('target must be node or vercel');
+    }
+    return value;
+}
+function configureUiRun(command) {
+    return command
+        .option('--logo-text <text>', 'top-left logo text')
+        .option('--no-git', 'disable Git working-tree integration')
+        .option('--port <number>', 'server port (default: 4242; explicit ports are strict)', parsePort);
+}
 function parseSimilarityThreshold(value) {
     const threshold = Number(value);
     if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
@@ -108,27 +120,52 @@ program
     const { sectionCommand } = await import('./section.js');
     handleResult(await sectionCommand(ctx, query));
 });
-const ui = program
-    .command('ui')
-    .description('Open lat.md in a local browser')
-    .option('--logo-text <text>', 'top-left logo text')
-    .option('--port <number>', 'server port (default: 4242; explicit ports are strict)', parsePort)
-    .action(async (opts) => {
+async function runUi(opts) {
     const ctx = resolveContext(program.opts());
     const { uiCommand } = await import('./ui.js');
-    handleResult(await uiCommand(ctx, { logoText: opts.logoText, port: opts.port }));
+    handleResult(await uiCommand(ctx, {
+        git: opts.git,
+        logoText: opts.logoText,
+        port: opts.port,
+    }));
+}
+const ui = configureUiRun(program.command('ui').description('Run or build the Lat UI')).action(runUi);
+configureUiRun(ui.command('run').description('Run the local Lat UI server')).action(async (opts) => {
+    await runUi(opts);
 });
-ui.command('build')
-    .description('Export lat.md as a static website')
-    .argument('[output]', 'output directory relative to the project', 'lat-ui')
+const uiBuild = ui.command('build').description('Build a deployable Lat UI');
+uiBuild
+    .command('static')
+    .description('Build a fully static, read-only Lat UI')
+    .argument('[output]', 'output directory relative to the project (default: .lat-build/static)', '.lat-build/static')
     .option('--base <path>', 'deployment base path', '/')
+    .option('--force', 'replace an existing output path')
     .option('--logo-text <text>', 'top-left logo text')
     .action(async (output, opts) => {
     const ctx = resolveContext(program.opts());
     const { uiBuildCommand } = await import('./ui-build.js');
     handleResult(await uiBuildCommand(ctx, output, {
         basePath: opts.base,
+        force: opts.force,
+        logoText: opts.logoText ?? ui.opts().logoText,
+    }));
+});
+uiBuild
+    .command('server')
+    .description('Build a static Lat UI with a portable search server')
+    .argument('[output]', 'output directory (default: .lat-build/server for node, .vercel/output for vercel)')
+    .option('--base <path>', 'deployment base path', '/')
+    .option('--force', 'replace an existing output path')
+    .option('--logo-text <text>', 'top-left logo text')
+    .option('--target <target>', 'deployment target: node or vercel', parseUiServerBuildTarget, 'node')
+    .action(async (output, opts) => {
+    const ctx = resolveContext(program.opts());
+    const { uiBuildServerCommand } = await import('./ui-build-server.js');
+    handleResult(await uiBuildServerCommand(ctx, output, {
+        basePath: opts.base,
+        force: opts.force,
         logoText: opts.logoText ?? ui.opts().logoText,
+        target: opts.target,
     }));
 });
 program

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

@@ -0,0 +1,4 @@
+/** Read machine-local checklist defaults without inferring installed agents. */
+export declare function readInitAgents(latDir: string): string[];
+/** Update just the confirmed selection, preserving other YAML and comments. */
+export declare function writeInitAgents(latDir: string, agents: string[]): void;

package/dist/src/cli/init-preferences.js

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isMap, parseDocument } from 'yaml';
+function readPreferences(latDir) {
+    const path = join(latDir, 'config.local.yaml');
+    const document = parseDocument(existsSync(path) ? readFileSync(path, 'utf8') : '');
+    if (document.errors.length > 0) {
+        throw new Error(`Cannot parse ${path}: ${document.errors[0].message}`);
+    }
+    if (document.contents !== null && !isMap(document.contents)) {
+        throw new Error(`${path} must be a mapping`);
+    }
+    if (document.has('init') && !isMap(document.get('init', true))) {
+        throw new Error(`${path}: init must be a mapping`);
+    }
+    return { path, document };
+}
+/** Read machine-local checklist defaults without inferring installed agents. */
+export function readInitAgents(latDir) {
+    const { path, document } = readPreferences(latDir);
+    const agents = document.toJS()?.init?.agents;
+    if (agents === undefined)
+        return [];
+    if (!Array.isArray(agents) ||
+        agents.some((agent) => typeof agent !== 'string')) {
+        throw new Error(`${path}: init.agents must be a list of strings`);
+    }
+    return agents;
+}
+/** Update just the confirmed selection, preserving other YAML and comments. */
+export function writeInitAgents(latDir, agents) {
+    const { path, document } = readPreferences(latDir);
+    document.setIn(['init', 'agents'], agents);
+    writeFileSync(path, document.toString());
+}

package/dist/src/cli/init.js

@@ -18,6 +18,7 @@ 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';
+import { readInitAgents, writeInitAgents } from './init-preferences.js';
 async function confirm(rl, message) {
     while (true) {
         let answer;
@@ -916,6 +917,7 @@ export async function initCmd(targetDir) {
             writeForkScaffold(latDir);
         }
         ensureLatLocalConfigIgnored(latDir);
+        ensureGitignored(root, '.lat-build');
         // 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.
@@ -931,7 +933,7 @@ export async function initCmd(targetDir) {
             { label: 'Codex', value: 'codex' },
             { label: 'Antigravity / Gemini', value: 'antigravity' },
         ];
-        const selectedAgents = await checklistMenu(allAgents, 'Which coding agents do you use?');
+        const selectedAgents = await checklistMenu(allAgents, 'Which coding agents do you use?', readInitAgents(latDir));
         const useClaudeCode = selectedAgents.includes('claude');
         const usePi = selectedAgents.includes('pi');
         const useCursor = selectedAgents.includes('cursor');
@@ -978,6 +980,8 @@ export async function initCmd(targetDir) {
             // agent. Stamp the version so future non-interactive runs do not reapply
             // fresh/outdated defaults and overwrite the chosen backend.
             writeInitMeta(latDir, {});
+            if (interactive)
+                writeInitAgents(latDir, selectedAgents);
             console.log('');
             console.log(styleText('dim', 'No agents selected. You can re-run') +
                 ' lat init ' +
@@ -1049,6 +1053,8 @@ export async function initCmd(targetDir) {
         await writeForkInstructions(root, latDir, fileHashes, ask);
         // Record init version and file hashes so `lat check` can detect stale setups
         writeInitMeta(latDir, fileHashes);
+        if (interactive)
+            writeInitAgents(latDir, selectedAgents);
         console.log('');
         console.log(styleText('green', 'Done!') +
             ' Run ' +

package/dist/src/cli/search.js

@@ -5,7 +5,7 @@ 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 { searchIndexedSections } from '../search/query.js';
+import { resolveSearchMatches, 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';
@@ -97,12 +97,7 @@ export async function runSearch(latDir, query, limit, progress, opts) {
         const results = await searchSections(db, query, embedder, limit, opts?.threshold);
         return {
             query,
-            matches: results.flatMap((result) => {
-                const section = analyzed.sectionById.get(result.id.toLowerCase());
-                return section
-                    ? [{ section, reason: 'semantic match', score: result.score }]
-                    : [];
-            }),
+            matches: resolveSearchMatches(results, analyzed.sectionById),
         };
     });
 }

package/dist/src/cli/ui-build-server.d.ts

@@ -0,0 +1,12 @@
+import type { CmdContext, CmdResult } from '../context.js';
+import { buildServerView, type ServerViewBuildOptions, type ServerViewBuildResult } from '../view/server-build.js';
+export type ServerViewBuildTarget = 'node' | 'vercel';
+export type UiBuildServerOptions = ServerViewBuildOptions & {
+    target?: ServerViewBuildTarget;
+};
+export type UiBuildServerDependencies = {
+    buildNode: typeof buildServerView;
+    buildVercel?: (ctx: CmdContext, output: string, options: ServerViewBuildOptions) => Promise<ServerViewBuildResult>;
+};
+/** Export immutable UI data with a Node or Vercel semantic-search service. */
+export declare function uiBuildServerCommand(ctx: CmdContext, output: string | undefined, options?: UiBuildServerOptions, dependencies?: UiBuildServerDependencies): Promise<CmdResult>;

package/dist/src/cli/ui-build-server.js

@@ -0,0 +1,26 @@
+import { buildServerView, } from '../view/server-build.js';
+const defaultDependencies = {
+    buildNode: buildServerView,
+};
+/** Export immutable UI data with a Node or Vercel semantic-search service. */
+export async function uiBuildServerCommand(ctx, output, options = {}, dependencies = defaultDependencies) {
+    try {
+        const { target = 'node', ...buildOptions } = options;
+        const resolvedOutput = output ?? (target === 'vercel' ? '.vercel/output' : '.lat-build/server');
+        let result;
+        if (target === 'vercel') {
+            const buildVercel = dependencies.buildVercel ??
+                (await import('../view/vercel-server-build.js')).buildVercelServerView;
+            result = await buildVercel(ctx, resolvedOutput, buildOptions);
+        }
+        else {
+            result = await dependencies.buildNode(ctx, resolvedOutput, buildOptions);
+        }
+        return {
+            output: `Built ${result.documents} documents and ${result.sources} source views for ${target} at ${result.outputDir}`,
+        };
+    }
+    catch (error) {
+        return { output: error.message, isError: true };
+    }
+}

package/dist/src/cli/ui-build.js

@@ -1,6 +1,6 @@
 import { buildStaticView, } from '../view/static-build.js';
 /** Export the current vault as a serverless, read-only Lat UI. */
-export async function uiBuildCommand(ctx, output = 'lat-ui', options = {}) {
+export async function uiBuildCommand(ctx, output = '.lat-build/static', options = {}) {
     try {
         const result = await buildStaticView(ctx, output, options);
         return {

package/dist/src/cli/ui.js

@@ -38,7 +38,7 @@ export async function uiCommand(ctx, options = {}) {
     options.onStarted?.(server);
     const lines = [
         `Viewing lat.md at ${server.url}`,
-        'Note: you can use `lat ui build` to build a static version of the UI',
+        'Note: use `lat ui build static` or `lat ui build server` to build a deployable UI',
     ];
     try {
         await (options.openBrowser ?? openBrowser)(server.url);

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

@@ -1,15 +1,18 @@
 import type { Section, SectionMatch } from '../lattice-model.js';
 import { type CreateSearchEngine } from './embedder.js';
+import { type SearchResult } from './search.js';
 export type IndexedSearchResult = {
     query: string;
     matches: SectionMatch[];
 };
 export type IndexedSearchSession = {
-    search: (query: string, limit: number, threshold?: number) => Promise<IndexedSearchResult>;
+    search: (query: string, limit: number, threshold?: number) => Promise<SearchResult[]>;
     close: () => Promise<void>;
 };
+/** Resolve scored index rows against one already-analyzed project snapshot. */
+export declare function resolveSearchMatches(results: readonly SearchResult[], sectionById: ReadonlyMap<string, Section>): SectionMatch[];
 /** Open one reusable database and embedder for a sequence of index queries. */
-export declare function openIndexedSearchSession(latDir: string, sectionById: ReadonlyMap<string, Section>, options?: {
+export declare function openIndexedSearchSession(latDir: string, options?: {
     cacheDir?: string;
     createSearchEngine?: CreateSearchEngine;
 }): Promise<IndexedSearchSession>;

package/dist/src/search/query.js

@@ -1,8 +1,23 @@
 import { closeDb, ensureMeta, ensureSectionsSchema, getStoredModel, openDb, } from './db.js';
 import { embedderForIndex } from './embedder.js';
 import { searchSections } from './search.js';
+/** Resolve scored index rows against one already-analyzed project snapshot. */
+export function resolveSearchMatches(results, sectionById) {
+    return results.flatMap((result) => {
+        const section = sectionById.get(result.id.toLowerCase());
+        return section
+            ? [
+                {
+                    section,
+                    reason: 'semantic match',
+                    score: result.score,
+                },
+            ]
+            : [];
+    });
+}
 /** Open one reusable database and embedder for a sequence of index queries. */
-export async function openIndexedSearchSession(latDir, sectionById, options = {}) {
+export async function openIndexedSearchSession(latDir, options = {}) {
     const db = openDb(latDir, options.cacheDir);
     let closed = false;
     const close = async () => {
@@ -16,10 +31,10 @@ export async function openIndexedSearchSession(latDir, sectionById, options = {}
         const stored = await getStoredModel(db);
         if (stored === null) {
             return {
-                search: async (query) => {
+                search: async () => {
                     if (closed)
                         throw new Error('Search session is closed');
-                    return { query, matches: [] };
+                    return [];
                 },
                 close,
             };
@@ -30,22 +45,7 @@ export async function openIndexedSearchSession(latDir, sectionById, options = {}
             async search(query, limit, threshold) {
                 if (closed)
                     throw new Error('Search session is closed');
-                const results = await searchSections(db, query, embedder, limit, threshold);
-                return {
-                    query,
-                    matches: results.flatMap((result) => {
-                        const section = sectionById.get(result.id.toLowerCase());
-                        return section
-                            ? [
-                                {
-                                    section,
-                                    reason: 'semantic match',
-                                    score: result.score,
-                                },
-                            ]
-                            : [];
-                    }),
-                };
+                return searchSections(db, query, embedder, limit, threshold);
             },
             close,
         };
@@ -57,9 +57,13 @@ export async function openIndexedSearchSession(latDir, sectionById, options = {}
 }
 /** Query a finished index and resolve its ids from precomputed section data. */
 export async function searchIndexedSections(latDir, query, limit, sectionById, options = {}) {
-    const session = await openIndexedSearchSession(latDir, sectionById, options);
+    const session = await openIndexedSearchSession(latDir, options);
     try {
-        return await session.search(query, limit, options.threshold);
+        const results = await session.search(query, limit, options.threshold);
+        return {
+            query,
+            matches: resolveSearchMatches(results, sectionById),
+        };
     }
     finally {
         await session.close();

package/dist/src/source-formats.d.ts

@@ -1,5 +1,5 @@
 /** Source file extensions supported by Lat's parser and code-reference scan. */
-export declare const SOURCE_FILE_EXTENSIONS: readonly [".c", ".dart", ".go", ".h", ".java", ".js", ".jsx", ".py", ".rs", ".ts", ".tsx"];
+export declare const SOURCE_FILE_EXTENSIONS: readonly [".c", ".dart", ".go", ".h", ".java", ".js", ".jsx", ".py", ".rake", ".rb", ".rs", ".ts", ".tsx"];
 /** A source extension supported everywhere Lat accepts source files. */
 export type SourceFileExtension = (typeof SOURCE_FILE_EXTENSIONS)[number];
 export declare function isSourceFileExtension(extension: string): extension is SourceFileExtension;

package/dist/src/source-formats.js

@@ -9,6 +9,8 @@ export const SOURCE_FILE_EXTENSIONS = [
     '.js',
     '.jsx',
     '.py',
+    '.rake',
+    '.rb',
     '.rs',
     '.ts',
     '.tsx',

package/dist/src/source-parser.js

@@ -34,6 +34,8 @@ const grammarMap = {
     '.js': 'tree-sitter-javascript.wasm',
     '.jsx': 'tree-sitter-javascript.wasm',
     '.py': 'tree-sitter-python.wasm',
+    '.rake': 'tree-sitter-ruby.wasm',
+    '.rb': 'tree-sitter-ruby.wasm',
     '.rs': 'tree-sitter-rust.wasm',
     '.ts': 'tree-sitter-typescript.wasm',
     '.tsx': 'tree-sitter-tsx.wasm',
@@ -246,6 +248,202 @@ function extractPySymbols(tree) {
     }
     return symbols;
 }
+function collectRubyScope(scope, parent, symbols) {
+    for (const node of scope.namedChildren) {
+        const startLine = node.startPosition.row + 1;
+        const endLine = node.endPosition.row + 1;
+        const signature = firstLine(node.text);
+        if (node.type === 'class' || node.type === 'module') {
+            const nameNode = node.childForFieldName('name');
+            if (nameNode) {
+                let childPart;
+                let parentPart;
+                if (nameNode.type === 'scope_resolution' &&
+                    nameNode.namedChildren.length === 2) {
+                    parentPart = nameNode.namedChildren[0].text;
+                    childPart = nameNode.namedChildren[1].text;
+                    symbols.push({
+                        name: childPart,
+                        kind: 'class',
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                    symbols.push({
+                        name: childPart,
+                        kind: 'class',
+                        parent: parentPart,
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                }
+                else {
+                    childPart = nameNode.text;
+                    symbols.push({
+                        name: childPart,
+                        kind: 'class',
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                    if (parent) {
+                        symbols.push({
+                            name: childPart,
+                            kind: 'class',
+                            parent,
+                            startLine,
+                            endLine,
+                            signature,
+                        });
+                    }
+                }
+                const body = node.childForFieldName('body');
+                if (body) {
+                    collectRubyScope(body, childPart, symbols);
+                }
+            }
+        }
+        else if (node.type === 'method' || node.type === 'singleton_method') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: parent ? 'method' : 'function',
+                    ...(parent ? { parent } : {}),
+                    startLine,
+                    endLine,
+                    signature,
+                });
+            }
+        }
+        else if (node.type === 'assignment') {
+            const left = node.childForFieldName('left');
+            if (left) {
+                if (left.type === 'scope_resolution' &&
+                    left.namedChildren.length === 2) {
+                    const parentPart = left.namedChildren[0].text;
+                    const childPart = left.namedChildren[1].text;
+                    symbols.push({
+                        name: childPart,
+                        kind: 'const',
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                    symbols.push({
+                        name: childPart,
+                        kind: 'const',
+                        parent: parentPart,
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                }
+                else if (left.type === 'constant' ||
+                    (left.type === 'identifier' && /^[A-Z]/.test(left.text))) {
+                    const name = left.text;
+                    symbols.push({
+                        name,
+                        kind: 'const',
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                    if (parent) {
+                        symbols.push({
+                            name,
+                            kind: 'const',
+                            parent,
+                            startLine,
+                            endLine,
+                            signature,
+                        });
+                    }
+                }
+            }
+        }
+        else if (node.type === 'call') {
+            const methodNode = node.childForFieldName('method');
+            const methodName = methodNode?.text;
+            if (methodName === 'task' ||
+                methodName === 'multitask' ||
+                methodName === 'file') {
+                const name = extractRubyRakeName(node);
+                if (name) {
+                    symbols.push({
+                        name,
+                        kind: parent ? 'method' : 'function',
+                        ...(parent ? { parent } : {}),
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                }
+            }
+            else if (methodName === 'namespace') {
+                const name = extractRubyRakeName(node);
+                if (name) {
+                    symbols.push({
+                        name,
+                        kind: 'class',
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                    if (parent) {
+                        symbols.push({
+                            name,
+                            kind: 'class',
+                            parent,
+                            startLine,
+                            endLine,
+                            signature,
+                        });
+                    }
+                    const block = node.childForFieldName('block') ??
+                        node.namedChildren.find((n) => n.type === 'do_block' || n.type === 'block');
+                    if (block) {
+                        const body = block.childForFieldName('body') ??
+                            block.namedChildren.find((n) => n.type === 'body_statement' || n.type === 'block_body') ??
+                            block;
+                        collectRubyScope(body, name, symbols);
+                    }
+                }
+            }
+        }
+    }
+}
+function extractRubyRakeName(node) {
+    const args = node.childForFieldName('arguments');
+    if (!args || args.namedChildren.length === 0)
+        return null;
+    let first = args.namedChildren[0];
+    if (first.type === 'pair') {
+        first = first.childForFieldName('key') ?? first.namedChildren[0];
+    }
+    if (!first)
+        return null;
+    if (first.type === 'simple_symbol') {
+        return first.text.replace(/^:/, '');
+    }
+    if (first.type === 'hash_key_symbol') {
+        return first.text.replace(/:$/, '');
+    }
+    if (first.type === 'string') {
+        const content = first.namedChildren.find((c) => c.type === 'string_content');
+        return content ? content.text : first.text.replace(/^['"]|['"]$/g, '');
+    }
+    if (first.type === 'identifier') {
+        return first.text;
+    }
+    return null;
+}
+function extractRubySymbols(tree) {
+    const symbols = [];
+    collectRubyScope(tree.rootNode, undefined, symbols);
+    return symbols;
+}
 function dartDirectChild(node, type) {
     return node.namedChildren.find((child) => child.type === type) ?? null;
 }
@@ -1102,6 +1300,8 @@ const symbolExtractors = {
     '.js': extractTsSymbols,
     '.jsx': extractTsSymbols,
     '.py': extractPySymbols,
+    '.rake': extractRubySymbols,
+    '.rb': extractRubySymbols,
     '.rs': extractRustSymbols,
     '.ts': extractTsSymbols,
     '.tsx': extractTsSymbols,