@a13xu/lucid 1.1.0 → 1.4.0

package/build/index.js

@@ -11,6 +11,9 @@ import { recallAll } from "./tools/recall-all.js";
 import { forget, ForgetSchema } from "./tools/forget.js";
 import { memoryStats } from "./tools/stats.js";
 import { handleValidateFile, ValidateFileSchema, handleCheckDrift, CheckDriftSchema, handleGetChecklist, } from "./tools/guardian.js";
+import { handleGrepCode, GrepCodeSchema } from "./tools/grep.js";
+import { handleInitProject, InitProjectSchema } from "./tools/init.js";
+import { handleSyncFile, SyncFileSchema, handleSyncProject, SyncProjectSchema, } from "./tools/sync.js";
 // ---------------------------------------------------------------------------
 // Init DB
 // ---------------------------------------------------------------------------
@@ -90,6 +93,67 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
             description: "Get memory usage statistics.",
             inputSchema: { type: "object", properties: {} },
         },
+        // ── Init / Indexing ──────────────────────────────────────────────────────
+        {
+            name: "init_project",
+            description: "Scan and index a project directory into the knowledge graph. " +
+                "Reads CLAUDE.md (directives, conventions), package.json / pyproject.toml (dependencies, scripts), " +
+                "README.md (description), .mcp.json (MCP servers), logic-guardian.yaml (drift patterns), " +
+                "and source files (exported functions/classes). " +
+                "Call this once when starting work on a project to bootstrap memory with project context.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    directory: {
+                        type: "string",
+                        description: "Absolute path to the project root. Defaults to current working directory.",
+                    },
+                },
+            },
+        },
+        {
+            name: "sync_file",
+            description: "Index or re-index a single source file after it was written or modified. " +
+                "Extracts exports, description, and open TODOs, then updates the knowledge graph. " +
+                "IMPORTANT: call this automatically after every Write or Edit tool call.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Absolute or relative path to the modified file." },
+                },
+                required: ["path"],
+            },
+        },
+        {
+            name: "sync_project",
+            description: "Re-index the entire project directory incrementally. " +
+                "Use this when multiple files have changed (e.g. after a refactor or git pull).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    directory: {
+                        type: "string",
+                        description: "Project root directory. Defaults to current working directory.",
+                    },
+                },
+            },
+        },
+        {
+            name: "grep_code",
+            description: "Search indexed source files using a regex pattern. " +
+                "Decompresses stored binary content and returns only matching lines with context. " +
+                "Token-efficient: returns ~20-50 tokens instead of full file contents. " +
+                "Useful for finding function calls, variable usages, import patterns.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    pattern: { type: "string", description: "Regex pattern to search for." },
+                    language: { type: "string", enum: ["python", "javascript", "typescript", "generic"], description: "Filter by language." },
+                    context: { type: "number", description: "Lines of context before/after each match (0-10, default 2)." },
+                },
+                required: ["pattern"],
+            },
+        },
         // ── Logic Guardian ───────────────────────────────────────────────────────
         {
             name: "validate_file",
@@ -156,6 +220,20 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "memory_stats":
                 text = memoryStats(db, stmts);
                 break;
+            // Init & Sync
+            case "init_project":
+                text = handleInitProject(stmts, InitProjectSchema.parse(args));
+                break;
+            case "sync_file":
+                text = handleSyncFile(stmts, SyncFileSchema.parse(args));
+                break;
+            case "sync_project":
+                text = handleSyncProject(stmts, SyncProjectSchema.parse(args));
+                break;
+            // Grep
+            case "grep_code":
+                text = handleGrepCode(stmts, GrepCodeSchema.parse(args));
+                break;
             // Logic Guardian
             case "validate_file":
                 text = handleValidateFile(ValidateFileSchema.parse(args));

package/build/indexer/file.d.ts

@@ -0,0 +1,15 @@
+import type { Statements } from "../database.js";
+export interface FileIndex {
+    module: string;
+    exports: string[];
+    description: string;
+    todos: string[];
+    language: string;
+}
+export declare function indexFile(filepath: string): FileIndex | null;
+export interface UpsertResult {
+    observations: string[];
+    stored: boolean;
+    savedBytes: number;
+}
+export declare function upsertFileIndex(index: FileIndex, source: string, stmts: Statements): UpsertResult;

package/build/indexer/file.js

@@ -0,0 +1,100 @@
+import { readFileSync } from "fs";
+import { extname } from "path";
+import { compress, sha256 } from "../store/content.js";
+function extractTS(source) {
+    const exports = [];
+    const todos = [];
+    // Exported symbols
+    for (const m of source.matchAll(/export\s+(?:async\s+)?(?:function|class|const|type|interface|enum)\s+(\w+)/g)) {
+        exports.push(m[1]);
+    }
+    // First JSDoc / block comment as description
+    const docMatch = source.match(/^\/\*\*([\s\S]*?)\*\//m) ?? source.match(/^\/\/(.*)/m);
+    const description = docMatch
+        ? docMatch[1].replace(/\s*\*\s*/g, " ").trim().slice(0, 200)
+        : "";
+    // TODOs
+    for (const m of source.matchAll(/\/\/\s*(TODO|FIXME|HACK)[:\s]+(.+)/gi)) {
+        todos.push(`${m[1]}: ${m[2].trim()}`);
+    }
+    return { exports, description, todos };
+}
+function extractPython(source) {
+    const exports = [];
+    const todos = [];
+    // Public functions and classes
+    for (const m of source.matchAll(/^(?:def|class|async def)\s+(\w+)/gm)) {
+        if (!m[1].startsWith("_"))
+            exports.push(m[1]);
+    }
+    // Module docstring
+    const docMatch = source.match(/^["']{3}([\s\S]*?)["']{3}/m);
+    const description = docMatch ? docMatch[1].trim().slice(0, 200) : "";
+    // TODOs
+    for (const m of source.matchAll(/#\s*(TODO|FIXME|HACK)[:\s]+(.+)/gi)) {
+        todos.push(`${m[1]}: ${m[2].trim()}`);
+    }
+    return { exports, description, todos };
+}
+function extractGeneric(source) {
+    const todos = [];
+    for (const m of source.matchAll(/(?:\/\/|#)\s*(TODO|FIXME|HACK)[:\s]+(.+)/gi)) {
+        todos.push(`${m[1]}: ${m[2].trim()}`);
+    }
+    return { exports: [], description: "", todos };
+}
+export function indexFile(filepath) {
+    let source;
+    try {
+        source = readFileSync(filepath, { encoding: "utf-8" });
+    }
+    catch {
+        return null;
+    }
+    const ext = extname(filepath).toLowerCase();
+    const module = filepath.replace(/\\/g, "/");
+    let extracted;
+    let language;
+    if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+        extracted = extractTS(source);
+        language = ext.includes("ts") ? "typescript" : "javascript";
+    }
+    else if (ext === ".py") {
+        extracted = extractPython(source);
+        language = "python";
+    }
+    else {
+        extracted = extractGeneric(source);
+        language = "generic";
+    }
+    return { module, language, ...extracted };
+}
+export function upsertFileIndex(index, source, stmts) {
+    const fileHash = sha256(source);
+    // Change detection — skip everything se hash-ul e identic
+    const existing = stmts.getFileByPath.get(index.module);
+    if (existing?.content_hash === fileHash) {
+        return { observations: [], stored: false, savedBytes: 0 };
+    }
+    // Comprimă și stochează conținutul binar
+    const blob = compress(source);
+    stmts.upsertFile.run(index.module, blob, fileHash, Buffer.byteLength(source, "utf-8"), blob.byteLength, index.language);
+    // Index structural în entities (compact, pentru recall)
+    const observations = [];
+    if (index.description)
+        observations.push(`description: ${index.description}`);
+    if (index.exports.length > 0)
+        observations.push(`exports: ${index.exports.join(", ")}`);
+    if (index.todos.length > 0)
+        observations.push(`TODOs: ${index.todos.join(" | ")}`);
+    observations.push(`language: ${index.language}`);
+    const entityRow = stmts.getEntityByName.get(index.module);
+    if (entityRow) {
+        stmts.updateEntity.run(JSON.stringify(observations), entityRow.id);
+    }
+    else {
+        stmts.insertEntity.run(index.module, "pattern", JSON.stringify(observations));
+    }
+    const savedBytes = Buffer.byteLength(source, "utf-8") - blob.byteLength;
+    return { observations, stored: true, savedBytes };
+}

package/build/indexer/project.d.ts

@@ -0,0 +1,8 @@
+import type { Statements } from "../database.js";
+export interface IndexResult {
+    entity: string;
+    type: string;
+    observations: number;
+    source: string;
+}
+export declare function indexProject(directory: string, stmts: Statements): IndexResult[];

package/build/indexer/project.js

@@ -0,0 +1,312 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, extname, basename } from "path";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function readFile(path) {
+    try {
+        return readFileSync(path, { encoding: "utf-8" });
+    }
+    catch {
+        return null;
+    }
+}
+function upsert(stmts, name, type, observations) {
+    const existing = stmts.getEntityByName.get(name);
+    if (existing) {
+        const current = JSON.parse(existing.observations);
+        const merged = [...current];
+        for (const obs of observations) {
+            if (!merged.includes(obs))
+                merged.push(obs);
+        }
+        stmts.updateEntity.run(JSON.stringify(merged), existing.id);
+    }
+    else {
+        stmts.insertEntity.run(name, type, JSON.stringify(observations));
+    }
+}
+function relate(stmts, from, to, type) {
+    const fromRow = stmts.getEntityByName.get(from);
+    const toRow = stmts.getEntityByName.get(to);
+    if (fromRow && toRow) {
+        stmts.insertRelation.run(fromRow.id, toRow.id, type);
+    }
+}
+// ---------------------------------------------------------------------------
+// Parsers per file type
+// ---------------------------------------------------------------------------
+function indexClaudeMd(path, stmts, results) {
+    const content = readFile(path);
+    if (!content)
+        return;
+    // Indexează fiecare secțiune H2 ca observație separată pe entitatea proiectului
+    const sections = content.split(/\n##\s+/).filter(Boolean);
+    const observations = [];
+    for (const section of sections) {
+        const lines = section.trim().split("\n");
+        const title = lines[0]?.trim() ?? "directive";
+        const body = lines.slice(1).join("\n").trim();
+        if (body.length > 0) {
+            observations.push(`[${title}] ${body.slice(0, 300)}`);
+        }
+    }
+    if (observations.length > 0) {
+        upsert(stmts, "CLAUDE.md directives", "convention", observations);
+        results.push({ entity: "CLAUDE.md directives", type: "convention", observations: observations.length, source: "CLAUDE.md" });
+    }
+}
+function indexPackageJson(path, stmts, results) {
+    const content = readFile(path);
+    if (!content)
+        return;
+    let pkg;
+    try {
+        pkg = JSON.parse(content);
+    }
+    catch {
+        return;
+    }
+    const name = pkg["name"] ?? "project";
+    const version = pkg["version"] ?? "unknown";
+    const description = pkg["description"] ?? "";
+    const projectName = name.replace(/^@[\w-]+\//, ""); // strip scope
+    const obs = [`version: ${version}`];
+    if (description)
+        obs.push(`description: ${description}`);
+    // Scripts
+    const scripts = pkg["scripts"];
+    if (scripts) {
+        for (const [k, v] of Object.entries(scripts).slice(0, 6)) {
+            obs.push(`script ${k}: ${v}`);
+        }
+    }
+    upsert(stmts, projectName, "project", obs);
+    results.push({ entity: projectName, type: "project", observations: obs.length, source: "package.json" });
+    // Dependențe principale
+    const deps = {
+        ...(pkg["dependencies"] ?? {}),
+        ...(pkg["devDependencies"] ?? {}),
+    };
+    for (const [dep, ver] of Object.entries(deps).slice(0, 20)) {
+        upsert(stmts, dep, "tool", [`version: ${ver}`, `used in: ${projectName}`]);
+        relate(stmts, projectName, dep, "depends_on");
+    }
+    if (Object.keys(deps).length > 0) {
+        results.push({ entity: `${Object.keys(deps).length} dependencies`, type: "tool", observations: 1, source: "package.json" });
+    }
+}
+function indexPyprojectToml(path, stmts, results) {
+    const content = readFile(path);
+    if (!content)
+        return;
+    const nameMatch = content.match(/^name\s*=\s*["']([^"']+)["']/m);
+    const versionMatch = content.match(/^version\s*=\s*["']([^"']+)["']/m);
+    const descMatch = content.match(/^description\s*=\s*["']([^"']+)["']/m);
+    const name = nameMatch?.[1] ?? "project";
+    const obs = [];
+    if (versionMatch?.[1])
+        obs.push(`version: ${versionMatch[1]}`);
+    if (descMatch?.[1])
+        obs.push(`description: ${descMatch[1]}`);
+    // Dependencies
+    const depsSection = content.match(/\[tool\.poetry\.dependencies\]([\s\S]*?)(?=\[|$)/)?.[1]
+        ?? content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/)?.[1]
+        ?? "";
+    const deps = [...depsSection.matchAll(/["']?([\w-]+)["']?\s*[=:]/g)].map((m) => m[1]).filter(Boolean);
+    for (const dep of deps.slice(0, 20)) {
+        upsert(stmts, dep, "tool", [`used in: ${name}`]);
+        relate(stmts, name, dep, "depends_on");
+    }
+    upsert(stmts, name, "project", obs);
+    results.push({ entity: name, type: "project", observations: obs.length, source: "pyproject.toml" });
+}
+function indexReadme(path, projectName, stmts, results) {
+    const content = readFile(path);
+    if (!content)
+        return;
+    // Prima secțiune (descriere)
+    const firstParagraph = content.replace(/^#[^\n]*\n/, "").trim().split("\n\n")[0] ?? "";
+    if (firstParagraph.length < 10)
+        return;
+    upsert(stmts, projectName, "project", [
+        `README: ${firstParagraph.slice(0, 400)}`,
+    ]);
+    results.push({ entity: projectName, type: "project", observations: 1, source: "README.md" });
+}
+function indexMcpJson(path, stmts, results) {
+    const content = readFile(path);
+    if (!content)
+        return;
+    let cfg;
+    try {
+        cfg = JSON.parse(content);
+    }
+    catch {
+        return;
+    }
+    const servers = cfg.mcpServers ?? {};
+    for (const [serverName, config] of Object.entries(servers)) {
+        const c = config;
+        const obs = [`MCP server configured in project`];
+        if (c.command)
+            obs.push(`command: ${c.command} ${(c.args ?? []).join(" ")}`);
+        upsert(stmts, serverName, "tool", obs);
+        results.push({ entity: serverName, type: "tool", observations: obs.length, source: ".mcp.json" });
+    }
+}
+function indexLogicGuardianYaml(path, stmts, results) {
+    const content = readFile(path);
+    if (!content)
+        return;
+    // Extrage known_drift_patterns
+    const patternMatches = [...content.matchAll(/id:\s*["']?(DRIFT-\d+)["']?\s*\n\s*name:\s*["']?([^\n"']+)["']?\s*\n\s*description:\s*["']?([^\n"']+)/g)];
+    for (const m of patternMatches) {
+        const [, id, name, desc] = m;
+        upsert(stmts, `${id}: ${name.trim()}`, "pattern", [
+            `drift pattern: ${desc.trim()}`,
+            "source: logic-guardian.yaml",
+        ]);
+    }
+    // Invarianți de proiect
+    const invariantsMatch = content.match(/project_invariants:([\s\S]*?)(?=\n\w|\n#|$)/);
+    if (invariantsMatch) {
+        const invariants = [...invariantsMatch[1].matchAll(/-\s+"([^"]+)"/g)].map((m) => m[1]);
+        if (invariants.length > 0) {
+            upsert(stmts, "project invariants", "convention", invariants);
+            results.push({ entity: "project invariants", type: "convention", observations: invariants.length, source: "logic-guardian.yaml" });
+        }
+    }
+    if (patternMatches.length > 0) {
+        results.push({ entity: `${patternMatches.length} drift patterns`, type: "pattern", observations: patternMatches.length, source: "logic-guardian.yaml" });
+    }
+}
+// Source file indexing — extrage exporturi, clase, funcții principale
+const SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs"]);
+const SKIP_DIRS = new Set(["node_modules", ".git", "build", "dist", "__pycache__", ".next", "venv", ".venv", "target"]);
+const MAX_SOURCE_FILES = 30;
+function indexSourceFile(filepath, projectName, stmts) {
+    const content = readFile(filepath);
+    if (!content)
+        return [];
+    const exports = [];
+    const lang = extname(filepath);
+    // TypeScript / JavaScript
+    if ([".ts", ".tsx", ".js", ".jsx"].includes(lang)) {
+        for (const m of content.matchAll(/export\s+(?:async\s+)?(?:function|class|const|type|interface)\s+(\w+)/g)) {
+            exports.push(m[1]);
+        }
+    }
+    // Python
+    if (lang === ".py") {
+        for (const m of content.matchAll(/^(?:def|class|async def)\s+(\w+)/gm)) {
+            if (!m[1].startsWith("_"))
+                exports.push(m[1]);
+        }
+    }
+    if (exports.length === 0)
+        return [];
+    const relPath = filepath.replace(/\\/g, "/").split("/src/")[1] ?? basename(filepath);
+    const obs = [`exports from ${relPath}: ${exports.slice(0, 10).join(", ")}`];
+    upsert(stmts, projectName, "project", obs);
+    return exports;
+}
+function scanSources(dir, projectName, stmts, results) {
+    const srcDir = join(dir, "src");
+    const scanDir = existsSync(srcDir) ? srcDir : dir;
+    let fileCount = 0;
+    const exportedSymbols = [];
+    function walk(d, depth) {
+        if (depth > 3 || fileCount >= MAX_SOURCE_FILES)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(d);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (SKIP_DIRS.has(entry))
+                continue;
+            const full = join(d, entry);
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                walk(full, depth + 1);
+            }
+            else if (SOURCE_EXTS.has(extname(entry))) {
+                const syms = indexSourceFile(full, projectName, stmts);
+                exportedSymbols.push(...syms);
+                fileCount++;
+            }
+        }
+    }
+    walk(scanDir, 0);
+    if (fileCount > 0) {
+        results.push({
+            entity: projectName,
+            type: "project",
+            observations: fileCount,
+            source: `${fileCount} source files (${exportedSymbols.length} exports)`,
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+export function indexProject(directory, stmts) {
+    const results = [];
+    const dir = directory.replace(/\\/g, "/");
+    // Detectează numele proiectului din package.json sau pyproject.toml
+    let projectName = basename(dir);
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+        const raw = readFile(pkgPath);
+        if (raw) {
+            try {
+                const pkg = JSON.parse(raw);
+                if (pkg.name)
+                    projectName = pkg.name.replace(/^@[\w-]+\//, "");
+            }
+            catch { /* ignore */ }
+        }
+    }
+    // 1. CLAUDE.md — cel mai important
+    const claudeMdPaths = ["CLAUDE.md", ".claude/CLAUDE.md", "claude.md"];
+    for (const p of claudeMdPaths) {
+        const full = join(dir, p);
+        if (existsSync(full)) {
+            indexClaudeMd(full, stmts, results);
+            break;
+        }
+    }
+    // 2. package.json
+    if (existsSync(join(dir, "package.json"))) {
+        indexPackageJson(join(dir, "package.json"), stmts, results);
+    }
+    // 3. pyproject.toml
+    if (existsSync(join(dir, "pyproject.toml"))) {
+        indexPyprojectToml(join(dir, "pyproject.toml"), stmts, results);
+    }
+    // 4. README
+    for (const p of ["README.md", "readme.md", "Readme.md"]) {
+        if (existsSync(join(dir, p))) {
+            indexReadme(join(dir, p), projectName, stmts, results);
+            break;
+        }
+    }
+    // 5. MCP config
+    for (const p of [".mcp.json", "mcp.json"]) {
+        if (existsSync(join(dir, p))) {
+            indexMcpJson(join(dir, p), stmts, results);
+            break;
+        }
+    }
+    // 6. Logic Guardian config
+    if (existsSync(join(dir, "logic-guardian.yaml"))) {
+        indexLogicGuardianYaml(join(dir, "logic-guardian.yaml"), stmts, results);
+    }
+    // 7. Surse
+    scanSources(dir, projectName, stmts, results);
+    return results;
+}

package/build/store/content.d.ts

@@ -0,0 +1,3 @@
+export declare function compress(source: string): Buffer;
+export declare function decompress(blob: Buffer): string;
+export declare function sha256(source: string): string;

package/build/store/content.js

@@ -0,0 +1,11 @@
+import { deflateSync, inflateSync } from "zlib";
+import { createHash } from "crypto";
+export function compress(source) {
+    return deflateSync(Buffer.from(source, "utf-8"), { level: 9 });
+}
+export function decompress(blob) {
+    return inflateSync(blob).toString("utf-8");
+}
+export function sha256(source) {
+    return createHash("sha256").update(source).digest("hex");
+}

package/build/tools/grep.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import type { Statements } from "../database.js";
+export declare const GrepCodeSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    language: z.ZodOptional<z.ZodEnum<["python", "javascript", "typescript", "generic"]>>;
+    context: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    pattern: string;
+    context: number;
+    language?: "python" | "javascript" | "typescript" | "generic" | undefined;
+}, {
+    pattern: string;
+    language?: "python" | "javascript" | "typescript" | "generic" | undefined;
+    context?: number | undefined;
+}>;
+export type GrepCodeInput = z.infer<typeof GrepCodeSchema>;
+export declare function handleGrepCode(stmts: Statements, input: GrepCodeInput): string;

package/build/tools/grep.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { decompress } from "../store/content.js";
+export const GrepCodeSchema = z.object({
+    pattern: z.string().min(1),
+    language: z.enum(["python", "javascript", "typescript", "generic"]).optional(),
+    context: z.number().int().min(0).max(10).default(2),
+});
+export function handleGrepCode(stmts, input) {
+    let regex;
+    try {
+        regex = new RegExp(input.pattern, "i");
+    }
+    catch {
+        return `Invalid regex pattern: ${input.pattern}`;
+    }
+    const files = stmts.getAllFiles.all();
+    const matches = [];
+    for (const file of files) {
+        if (input.language && file.language !== input.language)
+            continue;
+        let source;
+        try {
+            source = decompress(file.content);
+        }
+        catch {
+            continue; // skip fișiere corupte
+        }
+        const lines = source.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            if (!regex.test(lines[i]))
+                continue;
+            matches.push({
+                filepath: file.filepath,
+                line: i + 1,
+                text: lines[i],
+                contextBefore: lines.slice(Math.max(0, i - input.context), i),
+                contextAfter: lines.slice(i + 1, i + 1 + input.context),
+            });
+            if (matches.length >= 30)
+                break; // cap la 30 match-uri
+        }
+        if (matches.length >= 30)
+            break;
+    }
+    if (matches.length === 0) {
+        return `No matches for /${input.pattern}/ in ${files.length} indexed file(s).`;
+    }
+    const lines = [
+        `Found ${matches.length} match(es) for /${input.pattern}/ across ${files.length} file(s):\n`,
+    ];
+    let lastFile = "";
+    for (const m of matches) {
+        if (m.filepath !== lastFile) {
+            lines.push(`── ${m.filepath}`);
+            lastFile = m.filepath;
+        }
+        for (const l of m.contextBefore)
+            lines.push(`  ${m.line - m.contextBefore.length + m.contextBefore.indexOf(l)}│ ${l}`);
+        lines.push(`▶ ${m.line}│ ${m.text}`);
+        for (const l of m.contextAfter)
+            lines.push(`  ${m.line + 1 + m.contextAfter.indexOf(l)}│ ${l}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/build/tools/init.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import type { Statements } from "../database.js";
+export declare const InitProjectSchema: z.ZodObject<{
+    directory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    directory?: string | undefined;
+}, {
+    directory?: string | undefined;
+}>;
+export type InitProjectInput = z.infer<typeof InitProjectSchema>;
+export declare function handleInitProject(stmts: Statements, input: InitProjectInput): string;