@plebeiantech/lat.md 0.12.3-fork.2 → 0.12.3-fork.20

package/dist/src/cli/search.js

@@ -1,82 +1,65 @@
 import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { openDb, ensureMeta, getStoredModel, setStoredModel, ensureSectionsSchema, dropSections, closeDb, } from '../search/db.js';
-import { getLlmKey } from '../config.js';
+import { LEXICAL_VERSION } from '../search/lexical.js';
+import { hasIndex } from '../search/db.js';
+import { embeddingFingerprint } from '../search/chunks.js';
+import { writeIndex } from '../search/cache.js';
+import { dirname, join } from 'node:path';
+import { openDb, setStoredModel, ensureSectionsSchema, closeDb, } from '../search/db.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 { formatSectionPreview, formatNavHints } from '../format.js';
-import { provenanceNote, formatProvenanceNote } from './check-status.js';
-async function withDb(latDir, progress, fn) {
-    const db = openDb(latDir);
-    try {
-        await ensureMeta(db);
-        const stored = await getStoredModel(db);
-        // The stored model is authoritative — no silent backend switch. Throws
-        // ReindexRequiredError if the environment can't serve the stored index.
-        // Rebuilding / switching backends is `lat reindex`, never `lat search`.
-        const embedder = await embedderForIndex(stored, latDir);
-        await ensureSectionsSchema(db, embedder.dimensions);
-        const countResult = await db.execute('SELECT COUNT(*) as n FROM sections');
-        let isEmpty = countResult.rows[0].n === 0;
-        // Legacy cache: a version before the model was recorded left rows behind
-        // with no `meta.embedding_model`. Those vectors may be a different backend
-        // (and dimension) than the resolved embedder, and `CREATE TABLE IF NOT
-        // EXISTS` won't migrate the column width — so drop and rebuild from scratch
-        // under the resolved backend rather than querying a mismatched table.
-        if (!stored && !isEmpty) {
-            await dropSections(db);
-            await ensureSectionsSchema(db, embedder.dimensions);
-            isEmpty = true;
+import { indexSections, projectFingerprint, } from '../search/index.js';
+import { searchSections, prepareSearchQuery } from '../search/search.js';
+import { indexMetadata, sameIndexMetadata, resolveSearchMatches, searchIndexedSections, } from '../search/query.js';
+import { analyzeMarkdownProject, commandProjectAnalysis, } from '@plebeiantech/lat.md-core/project-analysis';
+import { formatSectionPreview, formatNavHints, } from '@plebeiantech/lat.md-core/format';
+import { provenanceNote, formatProvenanceNote, } from '@plebeiantech/lat.md-core/cli/check-status';
+async function withDb(latDir, progress, project, cacheDir, fn, prepare) {
+    for (let attempt = 0; hasIndex(cacheDir ?? join(latDir, '.cache')); attempt++) {
+        if (attempt >= 3)
+            throw new Error('Search index keeps changing; retry shortly.');
+        const metadataDb = openDb(latDir, cacheDir, true);
+        let metadata;
+        try {
+            metadata = await indexMetadata(metadataDb);
         }
-        // If the repo is pinned to local but a key is set, say so — otherwise it
-        // looks like the key is being silently ignored.
-        if (isEmpty && embedder.name.startsWith('local:') && process.stderr.isTTY) {
-            let hasKey = false;
-            try {
-                hasKey = !!getLlmKey();
-            }
-            catch {
-                /* key source misconfigured — irrelevant, we're local */
-            }
-            if (hasKey) {
-                process.stderr.write('This repo is configured for local embeddings; ignoring LAT_LLM_KEY.\n');
-            }
+        finally {
+            await closeDb(metadataDb);
         }
-        progress?.beforeIndex?.(isEmpty);
+        const stored = metadata.get('embedding_model') ?? null;
+        const embedder = await embedderForIndex(stored, latDir);
+        if (metadata.get('fingerprint') !== embeddingFingerprint(embedder))
+            throw new ReindexRequiredError('Search chunking or embedding model changed; run lat reindex.');
+        if (!stored ||
+            metadata.get('lexical_version') !== LEXICAL_VERSION ||
+            metadata.get('project_hash') !== projectFingerprint(project))
+            break;
+        await prepare?.(embedder);
+        const db = openDb(latDir, cacheDir, true);
         try {
-            const stats = await indexSections(latDir, db, embedder);
-            // Pin the backend only after a successful index, so a failed build never
-            // leaves the repo wrongly pinned to an empty index.
-            if (!stored)
-                await setStoredModel(db, modelKey(embedder));
-            progress?.afterIndex?.(stats, isEmpty);
+            if (!sameIndexMetadata(metadata, await indexMetadata(db)))
+                continue;
+            progress?.afterIndex?.({
+                added: 0,
+                updated: 0,
+                removed: 0,
+                unchanged: project.sections.length,
+            }, false);
+            return await fn(db, embedder, project);
         }
-        catch (err) {
-            // Failed fresh build → drop the half-created table so the next run is
-            // truly fresh (re-resolves the backend cleanly) rather than stuck.
-            if (!stored)
-                await dropSections(db);
-            throw err;
+        finally {
+            await closeDb(db);
         }
-        return await fn(db, embedder);
-    }
-    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
-        .map((r) => byId.get(r.id))
-        .filter((s) => !!s)
-        .map((s) => ({ section: s, reason: 'semantic match' }));
+    return writeIndex(latDir, cacheDir, false, async (db, stored) => {
+        const embedder = await embedderForIndex(stored, latDir);
+        await ensureSectionsSchema(db, embedder.dimensions);
+        const isEmpty = (await db.execute('SELECT COUNT(*) AS n FROM sections')).rows[0].n === 0;
+        progress?.beforeIndex?.(isEmpty);
+        const stats = await indexSections(latDir, db, embedder, undefined, project);
+        await setStoredModel(db, modelKey(embedder));
+        progress?.afterIndex?.(stats, isEmpty);
+        await prepare?.(embedder);
+        return fn(db, embedder, project);
+    });
 }
 /**
  * Run a semantic search across lat.md sections.
@@ -90,40 +73,41 @@ 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,
+            minSimilarity: opts.minSimilarity,
+        });
     }
-    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',
+        }));
+    let vector;
+    return withDb(latDir, progress, project, opts?.cacheDir, async (db, embedder, analyzed) => {
+        const results = await searchSections(db, query, embedder, limit, opts?.minSimilarity, vector);
         return {
             query,
-            matches: await resolveMatches(latDir, results, opts?.preloadedSections),
+            matches: resolveSearchMatches(results, analyzed.sectionById),
         };
+    }, async (embedder) => {
+        vector = await prepareSearchQuery(query, embedder, limit, opts?.minSimilarity);
     });
 }
 /**
  * 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 {
@@ -151,7 +135,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;
@@ -171,6 +155,32 @@ async function formatSearchMatches(ctx, query, matches) {
             lines.push('');
         lines.push(formatSectionPreview(ctx, matches[i].section, {
             reason: matches[i].reason,
+            spans: opts?.preview === 'intro'
+                ? undefined
+                : matches[i].evidence?.[0]?.spans,
+            score: opts?.showScores ? matches[i].rankScore : undefined,
+            text: opts?.preview === 'intro'
+                ? undefined
+                : matches[i].evidence?.length
+                    ? (opts?.preview === 'both'
+                        ? matches[i].section.firstParagraph + '\n\n'
+                        : '') + matches[i].evidence[0].text
+                    : undefined,
+            debug: opts?.showScores && matches[i].rankScore !== undefined
+                ? JSON.stringify({
+                    lexicalRank: matches[i].lexicalRank,
+                    semanticRank: matches[i].semanticRank,
+                    lexicalScore: matches[i].lexicalScore,
+                    semanticSimilarity: matches[i].semanticSimilarity,
+                    lexicalContribution: matches[i].lexicalRank
+                        ? 1 / (60 + matches[i].lexicalRank)
+                        : 0,
+                    semanticContribution: matches[i].semanticRank
+                        ? 1 / (60 + matches[i].semanticRank)
+                        : 0,
+                    ...matches[i].diagnostics,
+                })
+                : undefined,
         }));
         const note = notes.get(matches[i].section.filePath);
         if (note)
@@ -183,16 +193,22 @@ 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,
+            minSimilarity: opts.minSimilarity,
+        });
         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,
+                preview: opts.preview ?? 'passage',
+            })) + formatNavHints(ctx),
         };
     }
     catch (err) {

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

@@ -0,0 +1,12 @@
+import type { CmdContext, CmdResult } from '@plebeiantech/lat.md-core/context';
+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.d.ts

@@ -0,0 +1,4 @@
+import type { CmdContext, CmdResult } from '@plebeiantech/lat.md-core/context';
+import { type StaticViewBuildOptions } from '../view/static-build.js';
+/** Export the current vault as a serverless, read-only Lat UI. */
+export declare function uiBuildCommand(ctx: CmdContext, output?: string, options?: StaticViewBuildOptions): Promise<CmdResult>;

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

@@ -0,0 +1,13 @@
+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-build/static', options = {}) {
+    try {
+        const result = await buildStaticView(ctx, output, options);
+        return {
+            output: `Built ${result.documents} documents and ${result.sources} source views at ${result.outputDir}`,
+        };
+    }
+    catch (error) {
+        return { output: error.message, isError: true };
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { CmdContext, CmdResult } from '../context.js';
+import type { CmdContext, CmdResult } from '@plebeiantech/lat.md-core/context';
 import { type ViewServer, type ViewServerOptions } from '../view/server.js';
 type UiCommandOptions = ViewServerOptions & {
     openBrowser?: (url: string) => Promise<void>;

package/dist/src/cli/ui.js

@@ -21,9 +21,25 @@ export function openBrowser(url) {
 }
 /** Start `lat ui`, report its URL, and launch the default browser. */
 export async function uiCommand(ctx, options = {}) {
-    const server = await startViewServer(ctx, options);
+    let server;
+    try {
+        server = await startViewServer(ctx, options);
+    }
+    catch (error) {
+        if (options.port !== undefined &&
+            error.code === 'EADDRINUSE') {
+            return {
+                isError: true,
+                output: `Port ${options.port} is already in use. Choose another with --port <number>.`,
+            };
+        }
+        throw error;
+    }
     options.onStarted?.(server);
-    const lines = [`Viewing lat.md at ${server.url}`];
+    const lines = [
+        `Viewing lat.md at ${server.url}`,
+        '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/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>;