@a13xu/lucid 1.0.0 → 1.4.0

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/guardian.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const ValidateFileSchema: z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+export declare const CheckDriftSchema: z.ZodObject<{
+    code: z.ZodString;
+    language: z.ZodOptional<z.ZodEnum<["python", "javascript", "typescript", "generic"]>>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    language?: "python" | "javascript" | "typescript" | "generic" | undefined;
+}, {
+    code: string;
+    language?: "python" | "javascript" | "typescript" | "generic" | undefined;
+}>;
+export declare function handleValidateFile(args: z.infer<typeof ValidateFileSchema>): string;
+export declare function handleCheckDrift(args: z.infer<typeof CheckDriftSchema>): string;
+export declare function handleGetChecklist(): string;

package/build/tools/guardian.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { writeFileSync, unlinkSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { validateFile, validateSource, formatReport, } from "../guardian/validator.js";
+import { CHECKLIST } from "../guardian/checklist.js";
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+export const ValidateFileSchema = z.object({
+    path: z.string().min(1),
+});
+export const CheckDriftSchema = z.object({
+    code: z.string().min(1),
+    language: z.enum(["python", "javascript", "typescript", "generic"]).optional(),
+});
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+export function handleValidateFile(args) {
+    const issues = validateFile(args.path);
+    return formatReport(args.path, issues);
+}
+export function handleCheckDrift(args) {
+    const lang = args.language ?? "generic";
+    const extMap = {
+        python: ".py",
+        javascript: ".js",
+        typescript: ".ts",
+        generic: ".txt",
+    };
+    const ext = extMap[lang] ?? ".txt";
+    const tmpPath = join(tmpdir(), `lucid-drift-${Date.now()}${ext}`);
+    try {
+        writeFileSync(tmpPath, args.code, "utf-8");
+        const issues = validateSource(tmpPath, args.code, lang === "generic" ? undefined : lang);
+        if (issues.length === 0) {
+            return "✅ No drift patterns detected in this code snippet.";
+        }
+        const lines = [`Found ${issues.length} potential issue(s):\n`];
+        for (const issue of issues) {
+            const icon = { critical: "🔴", high: "🟠", medium: "🟡", low: "🔵", info: "ℹ️" }[issue.severity];
+            lines.push(`${icon} [${issue.driftId}] line ${issue.line} — ${issue.message}`);
+            if (issue.suggestion)
+                lines.push(`   💡 ${issue.suggestion}`);
+        }
+        return lines.join("\n");
+    }
+    finally {
+        try {
+            unlinkSync(tmpPath);
+        }
+        catch { /* ignore */ }
+    }
+}
+export function handleGetChecklist() {
+    return CHECKLIST;
+}

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;

package/build/tools/init.js

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import { resolve, join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { indexProject } from "../indexer/project.js";
+export const InitProjectSchema = z.object({
+    directory: z.string().optional(),
+});
+// ---------------------------------------------------------------------------
+// Instalează PostToolUse hook în .claude/settings.json
+// ---------------------------------------------------------------------------
+function installHook(dir) {
+    const claudeDir = join(dir, ".claude");
+    const settingsPath = join(claudeDir, "settings.json");
+    const HOOK_CMD = 'node -e "const p=process.argv[1]; if(p) require(\'child_process\').execSync(\'node \'+require(\'path\').resolve(\'node_modules/.bin/lucid\'||\'\')+\' --noop\', {stdio:\'ignore\'})" "$TOOL_INPUT_PATH" 2>/dev/null || true';
+    // Hook mai simplu și portabil: apelează sync_file prin claude mcp
+    const HOOK = {
+        matcher: "Write|Edit|NotebookEdit",
+        command: "echo '{\"tool\":\"sync_file\",\"path\":\"'\"$TOOL_INPUT_PATH\"'\"}' | true",
+    };
+    // Citim sau cream settings.json
+    let settings = {};
+    if (existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        }
+        catch {
+            return { installed: false, reason: "Could not parse .claude/settings.json" };
+        }
+    }
+    // Verifică dacă hook-ul e deja instalat
+    const hooks = settings["hooks"] ?? {};
+    const postToolUse = hooks["PostToolUse"] ?? [];
+    const alreadyInstalled = postToolUse.some((h) => h.matcher?.includes("Write") && String(h).includes("lucid"));
+    if (alreadyInstalled) {
+        return { installed: false, reason: "already installed" };
+    }
+    // Adaugă hook-ul — notifică Claude să cheme sync_file
+    const lucidHook = {
+        matcher: "Write|Edit|NotebookEdit",
+        command: "echo '🔄 Lucid: call sync_file(path) to keep knowledge graph up to date'",
+    };
+    hooks["PostToolUse"] = [...postToolUse, lucidHook];
+    settings["hooks"] = hooks;
+    mkdirSync(claudeDir, { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    return { installed: true, reason: "hook added to .claude/settings.json" };
+}
+// ---------------------------------------------------------------------------
+// Adaugă instrucțiune în CLAUDE.md
+// ---------------------------------------------------------------------------
+const LUCID_SYNC_INSTRUCTION = `
+<!-- LUCID_SYNC -->
+## 🔄 Lucid — Auto-sync after file changes
+
+After EVERY Write, Edit, or NotebookEdit tool call, you MUST immediately call:
+\`\`\`
+sync_file(path="<path of the file you just wrote/edited>")
+\`\`\`
+
+This keeps the Lucid knowledge graph up to date with the latest code.
+If multiple files changed (refactor, git pull), call sync_project() instead.
+<!-- /LUCID_SYNC -->
+`;
+function injectClaudeMdInstruction(dir) {
+    const claudeMdPath = join(dir, "CLAUDE.md");
+    if (!existsSync(claudeMdPath))
+        return false;
+    const content = readFileSync(claudeMdPath, "utf-8");
+    if (content.includes("LUCID_SYNC"))
+        return false; // already injected
+    writeFileSync(claudeMdPath, content.trimEnd() + "\n" + LUCID_SYNC_INSTRUCTION, "utf-8");
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Main handler
+// ---------------------------------------------------------------------------
+export function handleInitProject(stmts, input) {
+    const dir = resolve(input.directory ?? process.cwd());
+    const results = indexProject(dir, stmts);
+    const lines = [`✅ Project indexed: ${dir}`, ``];
+    if (results.length === 0) {
+        lines.push("No indexable files found.");
+        lines.push("Expected: CLAUDE.md, package.json, README.md, src/");
+    }
+    else {
+        lines.push(`Indexed ${results.length} source(s):`);
+        for (const r of results) {
+            lines.push(`  • [${r.type}] "${r.entity}" — ${r.observations} observation(s) from ${r.source}`);
+        }
+    }
+    // Instalează hook PostToolUse
+    lines.push(``);
+    const hookResult = installHook(dir);
+    if (hookResult.installed) {
+        lines.push(`🔗 Claude Code hook installed (.claude/settings.json)`);
+        lines.push(`   After every Write/Edit, you will see a reminder to call sync_file().`);
+    }
+    else {
+        lines.push(`🔗 Hook: ${hookResult.reason}`);
+    }
+    // Injectează instrucțiune în CLAUDE.md
+    const injected = injectClaudeMdInstruction(dir);
+    if (injected) {
+        lines.push(`📋 CLAUDE.md updated with sync_file() instruction`);
+    }
+    lines.push(``);
+    lines.push(`From now on, call sync_file(path) after every file you write or edit.`);
+    lines.push(`Use recall() to query accumulated project knowledge.`);
+    return lines.join("\n");
+}

package/build/tools/sync.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import type { Statements } from "../database.js";
+export declare const SyncFileSchema: z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+export declare function handleSyncFile(stmts: Statements, args: z.infer<typeof SyncFileSchema>): string;
+export declare const SyncProjectSchema: z.ZodObject<{
+    directory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    directory?: string | undefined;
+}, {
+    directory?: string | undefined;
+}>;
+export declare function handleSyncProject(stmts: Statements, args: z.infer<typeof SyncProjectSchema>): string;