@plebeiantech/lat.md 0.12.3-fork.9 → 0.13.4-fork.2

package/dist/src/wiki/transform.js

@@ -0,0 +1,264 @@
+import { existsSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { buildFileIndex, buildSectionSlugIndex, flattenSections, resolveRef, } from '@plebeiantech/lat.md-core/lattice';
+import { inspectRepositoryPath, normalizeRepositoryPath, } from '@plebeiantech/lat.md-core/repository-path';
+import { resolveSourceSymbol, } from '@plebeiantech/lat.md-core/source-parser';
+import { isSourceFilePath } from '@plebeiantech/lat.md-core/source-formats';
+import { parse } from '@plebeiantech/lat.md-core/parser';
+import { toPosix } from '@plebeiantech/lat.md-core/path';
+function collectTargetNodes(node, list) {
+    if ((node.type === 'wikiLink' || node.type === 'link') &&
+        node.position?.start?.offset != null &&
+        node.position?.end?.offset != null) {
+        list.push(node);
+        return;
+    }
+    if ('children' in node &&
+        Array.isArray(node.children)) {
+        for (const child of node.children) {
+            collectTargetNodes(child, list);
+        }
+    }
+}
+async function rewriteText(text, baseDir, ctx) {
+    if (!text)
+        return text;
+    const tree = parse(text);
+    const nodes = [];
+    collectTargetNodes(tree, nodes);
+    if (nodes.length === 0)
+        return text;
+    const repoUrl = ctx.options?.repoUrl?.replace(/\/+$/, '');
+    const ref = ctx.options?.ref ?? 'HEAD';
+    const replacements = [];
+    for (const node of nodes) {
+        const start = node.position.start.offset;
+        const end = node.position.end.offset;
+        if (node.type === 'wikiLink') {
+            const target = (node.value ?? '').trim();
+            const alias = node.data?.alias ? node.data.alias.trim() : undefined;
+            // 1. Try to resolve as Markdown section
+            const refResult = resolveRef(target, ctx.sectionIds, ctx.fileIndex, ctx.slugIndex);
+            const section = refResult?.resolved
+                ? ctx.sectionByLowerId.get(refResult.resolved.toLowerCase())
+                : undefined;
+            if (section) {
+                const doc = ctx.docByFilePath.get(section.filePath);
+                const label = alias ?? section.heading;
+                if (doc) {
+                    // Exported Diataxis section link
+                    const dest = section.depth === 1
+                        ? doc.slug
+                        : `${doc.slug}#${section.githubSlug}`;
+                    replacements.push({ start, end, replacement: `[${label}](${dest})` });
+                }
+                else {
+                    // Non-exported lat.md section link
+                    if (repoUrl) {
+                        const frag = section.githubSlug ? `#${section.githubSlug}` : '';
+                        replacements.push({
+                            start,
+                            end,
+                            replacement: `[${label}](${repoUrl}/blob/${ref}/${section.filePath}${frag})`,
+                        });
+                    }
+                    else {
+                        replacements.push({ start, end, replacement: label });
+                    }
+                }
+                continue;
+            }
+            // 2. Source code and repository path link
+            const hashIdx = target.indexOf('#');
+            const filePart = hashIdx >= 0 ? target.slice(0, hashIdx) : target;
+            const symbolPath = hashIdx >= 0 ? target.slice(hashIdx + 1) : undefined;
+            const normalizedPath = normalizeRepositoryPath(filePart);
+            if (!normalizedPath) {
+                replacements.push({ start, end, replacement: alias ?? target });
+                continue;
+            }
+            const inspected = await inspectRepositoryPath(ctx.catalog.projectRoot, normalizedPath);
+            if (inspected.kind !== 'file' && inspected.kind !== 'directory') {
+                replacements.push({ start, end, replacement: alias ?? target });
+                continue;
+            }
+            const label = alias ?? (symbolPath || normalizedPath);
+            if (symbolPath && isSourceFilePath(normalizedPath)) {
+                const symbolResult = await resolveSourceSymbol(normalizedPath, symbolPath, ctx.catalog.projectRoot, { latDir: ctx.catalog.latDir });
+                const parts = symbolPath.split('#');
+                let symbol;
+                if (parts.length === 1) {
+                    symbol = symbolResult.symbols.find((s) => s.name === parts[0] && !s.parent);
+                }
+                else if (parts.length === 2) {
+                    symbol = symbolResult.symbols.find((s) => s.name === parts[1] && s.parent === parts[0]);
+                }
+                if (symbol) {
+                    const lineFrag = symbol.startLine === symbol.endLine
+                        ? `#L${symbol.startLine}`
+                        : `#L${symbol.startLine}-L${symbol.endLine}`;
+                    if (repoUrl) {
+                        replacements.push({
+                            start,
+                            end,
+                            replacement: `[${label}](${repoUrl}/blob/${ref}/${normalizedPath}${lineFrag})`,
+                        });
+                    }
+                    else {
+                        replacements.push({ start, end, replacement: label });
+                    }
+                }
+                else {
+                    if (repoUrl) {
+                        replacements.push({
+                            start,
+                            end,
+                            replacement: `[${label}](${repoUrl}/blob/${ref}/${normalizedPath})`,
+                        });
+                    }
+                    else {
+                        replacements.push({ start, end, replacement: label });
+                    }
+                }
+            }
+            else {
+                const action = inspected.kind === 'directory' ? 'tree' : 'blob';
+                if (repoUrl) {
+                    replacements.push({
+                        start,
+                        end,
+                        replacement: `[${label}](${repoUrl}/${action}/${ref}/${normalizedPath})`,
+                    });
+                }
+                else {
+                    replacements.push({ start, end, replacement: label });
+                }
+            }
+        }
+        else if (node.type === 'link') {
+            const url = node.url ?? '';
+            // Skip same-page anchors and external URLs
+            if (url.startsWith('#') ||
+                url.startsWith('http://') ||
+                url.startsWith('https://') ||
+                url.startsWith('mailto:') ||
+                url.startsWith('tel:')) {
+                continue;
+            }
+            // Extract inner label text
+            let label = '';
+            if (node.children && node.children.length > 0) {
+                const first = node.children[0];
+                const last = node.children[node.children.length - 1];
+                if (first.position?.start?.offset != null &&
+                    last.position?.end?.offset != null) {
+                    label = text.slice(first.position.start.offset, last.position.end.offset);
+                }
+            }
+            const hashIdx = url.indexOf('#');
+            const pathPart = hashIdx >= 0 ? url.slice(0, hashIdx) : url;
+            const frag = hashIdx >= 0 ? url.slice(hashIdx) : '';
+            const resolvedPath = resolve(baseDir, pathPart);
+            const relToRoot = relative(ctx.catalog.projectRoot, resolvedPath);
+            const isInsideRoot = !relToRoot.startsWith('..') && !isAbsolute(relToRoot);
+            if (!isInsideRoot) {
+                // Prevent path traversal escape: do not rewrite links escaping project root
+                continue;
+            }
+            const repoRelPath = toPosix(relToRoot);
+            const doc = ctx.docByFilePath.get(repoRelPath) ??
+                ctx.docByFilePath.get(repoRelPath + '.md');
+            if (doc) {
+                replacements.push({
+                    start,
+                    end,
+                    replacement: `[${label}](${doc.slug}${frag})`,
+                });
+            }
+            else if (existsSync(resolvedPath)) {
+                let isDir = false;
+                try {
+                    isDir = statSync(resolvedPath).isDirectory();
+                }
+                catch {
+                    // ignore
+                }
+                const action = isDir ? 'tree' : 'blob';
+                if (repoUrl) {
+                    replacements.push({
+                        start,
+                        end,
+                        replacement: `[${label}](${repoUrl}/${action}/${ref}/${repoRelPath}${frag})`,
+                    });
+                }
+                else {
+                    replacements.push({ start, end, replacement: label });
+                }
+            }
+        }
+    }
+    // Apply replacements in reverse order of appearance
+    replacements.sort((a, b) => b.start - a.start);
+    let result = text;
+    for (const rep of replacements) {
+        result =
+            result.slice(0, rep.start) + rep.replacement + result.slice(rep.end);
+    }
+    return result;
+}
+function createTransformContext(catalog, options) {
+    const flat = flattenSections(catalog.allSections);
+    const sectionIds = new Set(flat.map((s) => s.id.toLowerCase()));
+    const sectionByLowerId = new Map(flat.map((s) => [s.id.toLowerCase(), s]));
+    const fileIndex = buildFileIndex(catalog.allSections);
+    const slugIndex = buildSectionSlugIndex(catalog.allSections);
+    const docByFilePath = new Map(catalog.docs.map((d) => [d.filePath, d]));
+    const docByRelPath = new Map(catalog.docs.map((d) => [d.relPath, d]));
+    return {
+        catalog,
+        options,
+        sectionIds,
+        sectionByLowerId,
+        fileIndex,
+        slugIndex,
+        docByFilePath,
+        docByRelPath,
+    };
+}
+export async function transformWikiDocument(doc, catalog, options) {
+    const ctx = createTransformContext(catalog, options);
+    const baseDir = resolve(catalog.projectRoot, dirname(doc.filePath));
+    const [body, firstParagraph] = await Promise.all([
+        rewriteText(doc.body, baseDir, ctx),
+        rewriteText(doc.firstParagraph, baseDir, ctx),
+    ]);
+    return {
+        ...doc,
+        body,
+        firstParagraph,
+    };
+}
+export async function transformWikiCatalog(catalog, options) {
+    const ctx = createTransformContext(catalog, options);
+    const transformedDocs = await Promise.all(catalog.docs.map(async (doc) => {
+        const baseDir = resolve(catalog.projectRoot, dirname(doc.filePath));
+        const [body, firstParagraph] = await Promise.all([
+            rewriteText(doc.body, baseDir, ctx),
+            rewriteText(doc.firstParagraph, baseDir, ctx),
+        ]);
+        return {
+            ...doc,
+            body,
+            firstParagraph,
+        };
+    }));
+    let rootOverview = catalog.rootOverview;
+    if (rootOverview) {
+        rootOverview = await rewriteText(rootOverview, catalog.latDir, ctx);
+    }
+    return {
+        ...catalog,
+        rootOverview,
+        docs: transformedDocs,
+    };
+}

package/dist/vendor/lat.md-server/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/vendor/lat.md-server/cli.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { runLatServer } from './index.js';
+const entry = process.argv[2];
+if (!entry)
+    throw new Error('Usage: lat-ui-server <app-module>');
+const module = (await import(pathToFileURL(resolve(entry)).href));
+if (typeof module.default !== 'function') {
+    throw new Error(`${entry} must default-export an Express app`);
+}
+await runLatServer(module.default, { close: module.close });

package/dist/vendor/lat.md-server/index.d.ts

@@ -0,0 +1,38 @@
+import { type IncomingMessage, type RequestListener, type Server, type ServerResponse } from 'node:http';
+import { type Express } from 'express';
+export declare const LAT_UI_CONTENT_SECURITY_POLICY = "default-src 'self'; connect-src 'self' https://tiles.openfreemap.org; font-src 'self' data:; img-src 'self' data: https://github.com https://github.githubassets.com https://img.shields.io; style-src 'self' 'unsafe-inline'; worker-src 'self' blob:; object-src 'none'; base-uri 'none'; frame-ancestors 'none'";
+export type LatServerAppOptions = {
+    /** Handle dynamic routes before immutable files and fallback handlers. */
+    handle?: LatServerRequestHandler;
+    /** Serve a completed Lat UI export after dynamic routes. */
+    publicDir?: string;
+};
+export type LatServerApp = RequestListener;
+export type LatServerRequestHandler = (req: IncomingMessage, res: ServerResponse, next: (error?: unknown) => void) => void | Promise<void>;
+export type ListenLatServerOptions = {
+    host: string;
+    port: number;
+    /** Advance through occupied ports. Explicit user ports should leave this off. */
+    findAvailablePort?: boolean;
+};
+export type RunningLatServer = {
+    server: Server;
+    host: string;
+    port: number;
+    url: string;
+    close: () => Promise<void>;
+};
+/** Create the common Express stack used by live and exported Lat UI servers. */
+export declare function createLatServerApp(options?: LatServerAppOptions, app?: Express): LatServerApp;
+/** Listen with the same strict-or-next-port behavior in every Lat UI host. */
+export declare function listenLatServer(app: LatServerApp, options: ListenLatServerOptions): Promise<RunningLatServer>;
+export type RunLatServerOptions = {
+    host?: string;
+    port?: number;
+    close?: () => void | Promise<void>;
+    log?: (message: string) => void;
+};
+/** Run an exported Express app until the standalone process is terminated. */
+export declare function runLatServer(app: LatServerApp, options?: RunLatServerOptions): Promise<RunningLatServer>;
+/** Read this published package's exact version for generated artifacts. */
+export declare function getLatServerVersion(): string;

package/dist/vendor/lat.md-server/index.js

@@ -0,0 +1,128 @@
+import { createServer, } from 'node:http';
+import { readFileSync } from 'node:fs';
+import express from 'express';
+export const LAT_UI_CONTENT_SECURITY_POLICY = "default-src 'self'; connect-src 'self' https://tiles.openfreemap.org; font-src 'self' data:; img-src 'self' data: https://github.com https://github.githubassets.com https://img.shields.io; style-src 'self' 'unsafe-inline'; worker-src 'self' blob:; object-src 'none'; base-uri 'none'; frame-ancestors 'none'";
+function setSecurityHeaders(res) {
+    res.setHeader('Content-Security-Policy', LAT_UI_CONTENT_SECURITY_POLICY);
+    res.setHeader('Referrer-Policy', 'no-referrer');
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+}
+function isImmutablePublicFile(path) {
+    const parts = path.split(/[/\\]/);
+    if (parts.includes('assets'))
+        return true;
+    return /[/\\]data[/\\][^/\\]+[/\\][a-f0-9]{20}\.json$/.test(path);
+}
+/** Create the common Express stack used by live and exported Lat UI servers. */
+export function createLatServerApp(options = {}, app = express()) {
+    app.disable('x-powered-by');
+    app.use((_req, res, next) => {
+        setSecurityHeaders(res);
+        next();
+    });
+    if (options.handle) {
+        app.use((req, res, next) => {
+            try {
+                void Promise.resolve(options.handle(req, res, next)).catch(next);
+            }
+            catch (error) {
+                next(error);
+            }
+        });
+    }
+    if (options.publicDir) {
+        app.use(express.static(options.publicDir, {
+            setHeaders(res, path) {
+                res.setHeader('Cache-Control', isImmutablePublicFile(path)
+                    ? 'public, max-age=31536000, immutable'
+                    : 'no-cache');
+            },
+        }));
+    }
+    app.use((_req, res) => {
+        res.status(404).type('text/plain').send('Not found');
+    });
+    app.use((error, _req, res, _next) => {
+        console.error(error);
+        res.status(500).json({ error: 'Internal server error' });
+    });
+    return app;
+}
+function listen(server, host, port) {
+    return new Promise((resolveListen, reject) => {
+        const onError = (error) => {
+            server.off('listening', onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off('error', onError);
+            resolveListen();
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(port, host);
+    });
+}
+function closeServer(server) {
+    return new Promise((resolveClose, reject) => {
+        server.close((error) => (error ? reject(error) : resolveClose()));
+    });
+}
+/** Listen with the same strict-or-next-port behavior in every Lat UI host. */
+export async function listenLatServer(app, options) {
+    const server = createServer(app);
+    let port = options.port;
+    while (true) {
+        try {
+            await listen(server, options.host, port);
+            break;
+        }
+        catch (error) {
+            if (!options.findAvailablePort ||
+                error.code !== 'EADDRINUSE' ||
+                port === 65_535) {
+                throw error;
+            }
+            port++;
+        }
+    }
+    const address = server.address();
+    if (!address) {
+        await closeServer(server);
+        throw new Error('Could not determine Lat UI server address');
+    }
+    return {
+        server,
+        host: options.host,
+        port: address.port,
+        url: `http://${options.host}:${address.port}/`,
+        close: () => closeServer(server),
+    };
+}
+/** Run an exported Express app until the standalone process is terminated. */
+export async function runLatServer(app, options = {}) {
+    const host = options.host ?? process.env.HOST ?? '0.0.0.0';
+    const rawPort = options.port ?? Number(process.env.PORT ?? 3000);
+    if (!Number.isInteger(rawPort) || rawPort < 1 || rawPort > 65_535) {
+        throw new Error('PORT must be an integer from 1 to 65535');
+    }
+    const running = await listenLatServer(app, { host, port: rawPort });
+    (options.log ?? console.log)(`Lat UI listening on ${running.url}`);
+    let closing = false;
+    const shutdown = () => {
+        if (closing)
+            return;
+        closing = true;
+        void Promise.all([running.close(), options.close?.()]).catch((error) => {
+            console.error(error);
+            process.exitCode = 1;
+        });
+    };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
+    return running;
+}
+/** Read this published package's exact version for generated artifacts. */
+export function getLatServerVersion() {
+    return JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plebeiantech/lat.md",
-  "version": "0.12.3-fork.9",
+  "version": "0.13.4-fork.2",
   "description": "A knowledge graph for your codebase, written in markdown",
   "type": "module",
   "license": "MIT",
@@ -22,66 +22,112 @@
   "bin": {
     "lat": "./dist/src/cli/index.js"
   },
+  "exports": {
+    "./server": {
+      "types": "./dist/src/view/server-deployment.d.ts",
+      "import": "./dist/src/view/server-deployment.js"
+    }
+  },
   "files": [
     "dist/src",
-    "templates"
+    "dist/vendor",
+    "templates",
+    "plugins"
   ],
   "devDependencies": {
+    "@codemirror/commands": "^6.11.0",
+    "@codemirror/lang-markdown": "^6.5.2",
+    "@codemirror/language": "^6.12.4",
+    "@codemirror/merge": "^6.12.2",
+    "@codemirror/state": "^6.7.1",
+    "@codemirror/view": "^6.43.9",
+    "@fontsource-variable/geist": "^5.3.0",
+    "@fontsource-variable/geist-mono": "^5.3.0",
+    "@lezer/highlight": "^1.2.3",
+    "@types/express": "^5.0.6",
+    "@types/geojson": "^7946.0.16",
+    "@types/hast": "^3.0.5",
     "@types/mdast": "^4.0.4",
     "@types/node": "^25.3.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
+    "@types/three": "^0.185.4",
+    "@types/topojson-client": "^3.1.5",
     "@vitejs/plugin-react": "^5.0.0",
     "graphology": "^0.26.0",
     "highlight.js": "^11.12.0",
+    "jsdom": "^30.0.1",
+    "katex": "^0.18.4",
+    "lowlight": "^3.3.0",
+    "maplibre-gl": "^5.24.0",
     "mdast-util-from-markdown": "^2.0.3",
+    "mermaid": "^11.17.2",
     "micromark-util-types": "^2.0.2",
     "prettier": "^3.8.1",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
+    "rehype-stringify": "^10.0.1",
     "sigma": "^3.0.3",
+    "three": "^0.185.1",
+    "topojson-client": "^3.1.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.7.0",
+    "typescript": "7.0.2",
     "vite": "^7.0.0",
-    "vitest": "^3.0.0"
+    "vitest": "^3.0.0",
+    "web-tree-sitter": "^0.26.6",
+    "micromark-extension-gfm-table": "^2.1.1",
+    "mdast-util-gfm-table": "^2.0.0",
+    "remark-math": "^6.0.0",
+    "@folder/xdg": "^4.0.1",
+    "@lat.md/server": "0.1.0"
   },
   "dependencies": {
-    "@folder/xdg": "^4.0.1",
+    "@asciidoctor/core": "4.0.6",
     "@libsql/client": "^0.17.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
-    "@repomix/tree-sitter-wasms": "^0.1.16",
+    "@tursodatabase/database": "0.8.2",
+    "@vercel/nft": "^1.10.0",
     "commander": "^14.0.3",
-    "github-slugger": "^2.0.0",
-    "ignore-walk": "^8.0.0",
-    "mdast-util-to-markdown": "^2.1.0",
+    "diff": "^8.0.4",
+    "express": "^5.2.1",
+    "fs-native-extensions": "1.5.1",
+    "rehype-katex": "^7.0.1",
+    "rehype-raw": "^7.0.0",
     "rehype-sanitize": "^6.0.0",
     "rehype-slug": "^6.0.0",
-    "rehype-stringify": "^10.0.1",
-    "remark-frontmatter": "^5.0.0",
-    "remark-parse": "^11.0.0",
+    "remark-emoji": "^5.0.2",
     "remark-rehype": "^11.1.2",
-    "remark-stringify": "^11.0.0",
+    "rst-compiler": "0.5.9",
     "unified": "^11.0.0",
     "unist-util-visit": "^5.0.0",
-    "web-tree-sitter": "^0.26.6",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
-    "@lat.md/embed": "0.2.0",
-    "@lat.md/embed-minilm-fp16": "0.1.0"
+    "@lat.md/embed": "0.2.2",
+    "@lat.md/embed-minilm-fp16": "0.1.1",
+    "@lat.md/stemmer": "0.1.0",
+    "@plebeiantech/lat.md-core": "0.13.4-fork.2"
   },
   "scripts": {
-    "build": "tsc && pnpm build:view",
+    "build": "tsc && tsx scripts/fork-vendor-ui-server.ts && pnpm build:view",
     "build:view": "vite build --config view/vite.config.ts && vite build --config view/highlight.vite.config.ts",
+    "build:site": "pnpm --filter @lat.md/server build && node scripts/prepare-site-packages.mjs && pnpm build && node dist/src/cli/index.js ui build server --force",
+    "build:site:vercel": "pnpm build:site && node scripts/vendor-site-packages.mjs && npm install --prefix .lat-build/server --ignore-scripts --no-package-lock && node scripts/build-vercel-output.mjs",
+    "build:site:source": "pnpm buildall && node dist/src/cli/index.js ui build server --force",
     "buildall": "pnpm build:packages && pnpm build",
     "setup:rust": "pnpm --filter @lat.md/embed setup:rust",
     "build:wasm": "pnpm --filter @lat.md/embed build:wasm",
     "build:weights": "pnpm --filter @lat.md/embed-minilm-fp16 build:weights",
-    "build:packages": "pnpm --filter @lat.md/embed build && pnpm --filter @lat.md/embed-minilm-fp16 build",
+    "build:packages": "pnpm build:core && pnpm --filter @lat.md/server build && pnpm --filter @lat.md/stemmer build && pnpm --filter @lat.md/embed build && pnpm --filter @lat.md/embed-minilm-fp16 build",
     "test": "vitest run",
     "test:watch": "vitest",
-    "typecheck": "tsc --noEmit && tsc --noEmit -p view/tsconfig.json",
-    "format": "prettier --write \"src/**/*.ts\" \"view/**/*.{ts,tsx,css,html}\"",
-    "format:check": "prettier --check \"src/**/*.ts\" \"view/**/*.{ts,tsx,css,html}\"",
-    "cook-test-rag": "tsx scripts/cook-test-rag.ts"
+    "typecheck": "pnpm build:core && pnpm --filter @lat.md/server build && pnpm typecheck:no-build",
+    "typecheck:no-build": "pnpm --filter @plebeiantech/lat.md-core typecheck && pnpm --filter @lat.md/server typecheck && tsc --noEmit && tsc --noEmit -p view/tsconfig.json",
+    "format": "prettier --write \"src/**/*.ts\" \"packages/core/src/**/*.ts\" \"packages/server/src/**/*.ts\" \"view/**/*.{ts,tsx,css,html}\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"packages/core/src/**/*.ts\" \"packages/server/src/**/*.ts\" \"view/**/*.{ts,tsx,css,html}\"",
+    "cook-test-rag": "tsx scripts/cook-test-rag.ts",
+    "build:core": "pnpm --filter @plebeiantech/lat.md-core build",
+    "build:action-test": "pnpm build:core && node scripts/build-action-test.mjs",
+    "test:core": "node --test scripts/test-core-distribution.js",
+    "test:action": "node --test scripts/test-check-action.js"
   }
 }

package/plugins/lat-md/README.md

@@ -0,0 +1,61 @@
+# Antigravity & Gemini CLI Plugin for lat.md
+
+This plugin integrates [lat.md](https://github.com/PlebeianTech/lat.md) with Google Antigravity and Gemini CLI. It grounds the agent in your codebase knowledge graph, prevents multi-line rationale comments in source code, maintains directory indexes, and blocks finishing work on check failures.
+
+## Features
+
+- **PreInvocation Hook**: Automatically expands wiki links (`[[section]]`) in user prompts, retrieves relevant sections using semantic search, and reminds the agent to maintain the knowledge graph.
+- **PreToolUse Hook**: Intercepts file edits (`replace_file_content` and `write_to_file`) and blocks multi-line rationale comments, prompting the agent to document the reasoning in `lat.md/` with a `@lat:` pointer instead.
+- **PostToolUse Hook**: Runs index synchronization after file modifications.
+- **Stop Hook**: Enforces `lat check` (including Diátaxis mode validation) before the agent completes its work, refusing stop if errors remain.
+- **Bundled Skills**: Provides `lat-md` (syntax & structure authoring guide) and `lat-md-conventions` (fork conventions & rules).
+- **Rules**: Injects core `lat.md` workflow directives via `rules/AGENTS.md`.
+
+## Installation
+
+### Option 1: Via `lat init` (Zero Clone, Recommended)
+
+You do not need to clone the repository to use lat.md with Antigravity. Install the CLI and initialize your repository directly:
+
+```bash
+npm install -g @plebeiantech/lat.md
+# or: mise use -g npm:@plebeiantech/lat.md@latest
+
+lat init
+```
+
+Select **Antigravity / Gemini** from the agent checklist menu. This automatically writes `.agents/hooks.json`, `GEMINI.md`, and `.agents/skills/`.
+
+### Option 2: Global User Plugin (Without Cloning)
+
+To install the plugin bundle globally across all repositories without cloning:
+
+```bash
+mkdir -p ~/.gemini/config/plugins/lat-md && \
+curl -sL https://github.com/PlebeianTech/lat.md/archive/refs/heads/main.tar.gz | \
+  tar -xz -C ~/.gemini/config/plugins/lat-md --strip-components=2 lat.md-main/plugins/lat-md
+```
+
+### Option 3: Workspace Plugin (Without Cloning)
+
+To install the plugin bundle into a specific repository without cloning:
+
+```bash
+mkdir -p .agents/plugins/lat-md && \
+curl -sL https://github.com/PlebeianTech/lat.md/archive/refs/heads/main.tar.gz | \
+  tar -xz -C .agents/plugins/lat-md --strip-components=2 lat.md-main/plugins/lat-md
+```
+
+## Requirements
+
+The plugin requires the `@plebeiantech/lat.md` CLI on your `PATH`:
+
+```bash
+npm install -g @plebeiantech/lat.md
+```
+
+Or using [mise](https://mise.jdx.dev/):
+
+```bash
+mise use -g npm:@plebeiantech/lat.md@latest
+```