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

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 '@plebeiantech/lat.md-core/lattice';
+import { commandProjectAnalysis } from '@plebeiantech/lat.md-core/project-analysis';
+import { plainStyler, } from '@plebeiantech/lat.md-core/context';
+import { expandPrompt } from '@plebeiantech/lat.md-core/cli/expand';
+import { runSearch } from '../cli/search.js';
+import { getSection, formatSectionOutput, } from '@plebeiantech/lat.md-core/cli/section';
+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('@plebeiantech/lat.md-core/cli/check');
+                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: (root: string, configPath: string, key: string) => boolean;
+    addMcpServer: (root: string, 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(root, mcpPath, 'mcpServers')) {
+        console.log(styleText('green', '  MCP server') + ' already configured');
+    }
+    else {
+        addMcpServer(root, mcpPath, 'mcpServers', style);
+        console.log(styleText('green', '  MCP server') + ' registered in .mcp.json');
+    }
+    ensureGitignored(root, '.mcp.json');
+}

package/dist/src/fork/upstream-drift-cli.js

@@ -0,0 +1,2 @@
+import { main } from './upstream-drift.js';
+process.exit(main(process.argv.slice(2)));

package/dist/src/fork/upstream-drift.d.ts

@@ -0,0 +1,26 @@
+export declare const UPSTREAM_URL = "https://github.com/vercel-labs/lat.md.git";
+export declare const UPSTREAM_REF = "refs/remotes/upstream/main";
+export type Drift = {
+    upstream: string;
+    ahead: number;
+    behind: number;
+    upstreamFiles: string[];
+    forkFiles: string[];
+    overlap: string[];
+    conflicts: string[];
+    mergesCleanly: boolean;
+};
+/**
+ * Conflicting paths from `git merge-tree --write-tree --name-only`, whose
+ * output is the written tree id, then one path per line, then a blank line
+ * and the human-readable log. Everything after that blank line is prose.
+ */
+export declare function parseMergeTree(stdout: string): string[];
+export declare function fetchUpstream(repo: string, url: string, ref: string): void;
+export declare function analyzeDrift(opts: {
+    repo: string;
+    syncPoint: string;
+    upstreamRef: string;
+}): Drift;
+export declare function formatDrift(drift: Drift): string;
+export declare function main(argv: string[]): number;