@kurtel/cli 0.1.6 → 0.1.11

package/dist/memory/capsule.js

@@ -0,0 +1,137 @@
+import { findSimilarRoutes } from "./indexer.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// Capsule — le cœur du produit. À chaque prompt:
+//   intention → résolution spatiale (zones du graphe) → sélection de patterns
+//   → capsule compacte (budget ~400 tokens) injectée via le hook.
+// Tout se calcule en local, en millisecondes, sans réseau.
+// ─────────────────────────────────────────────────────────────────────────────
+const TOKEN_BUDGET_CHARS = 1600; // ~400 tokens
+const STOPWORDS = new Set([
+    "the", "a", "an", "to", "for", "of", "in", "on", "and", "or", "with", "add",
+    "create", "make", "fix", "update", "change", "new", "page", "file", "please",
+    "le", "la", "les", "un", "une", "des", "de", "du", "et", "ou", "pour", "dans",
+    "ajoute", "ajouter", "crée", "creer", "modifie", "modifier", "corrige", "il", "faut",
+]);
+export function tokenize(text) {
+    return [...new Set(text.toLowerCase()
+            .split(/[^a-z0-9_]+/)
+            .filter((w) => w.length >= 3 && !STOPWORDS.has(w)))];
+}
+// ── Résolution spatiale: quelles zones du repo l'intention touche-t-elle ? ──
+export function resolveZones(index, promptTokens) {
+    const scores = new Map();
+    for (const m of index.modules) {
+        const hay = m.id.toLowerCase();
+        let s = 0;
+        for (const t of promptTokens)
+            if (hay.includes(t))
+                s += 2;
+        for (const e of m.exports) {
+            const el = e.toLowerCase();
+            for (const t of promptTokens)
+                if (el.includes(t))
+                    s += 1;
+        }
+        if (s > 0) {
+            const zone = m.id.includes("/") ? m.id.split("/").slice(0, 2).join("/") : m.id;
+            scores.set(zone, (scores.get(zone) ?? 0) + s);
+        }
+    }
+    return [...scores.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([z]) => z);
+}
+export function selectPatterns(patterns, promptTokens, zones, max = 5) {
+    const out = [];
+    for (const p of patterns) {
+        if (p.score < 0.3 && !p.pinned)
+            continue; // les mourants ne parlent plus
+        let s = 0;
+        if (p.pinned)
+            s += 10; // socle: toujours présent
+        for (const trig of p.triggers) {
+            const tl = trig.toLowerCase();
+            if (promptTokens.some((t) => t === tl || tl.includes(t) || t.includes(tl)))
+                s += 4;
+        }
+        for (const z of p.zones) {
+            if (zones.some((zone) => zone.startsWith(z) || z.startsWith(zone)))
+                s += 3;
+        }
+        if (p.zones.length === 0 && s > 0)
+            s += 1; // global + déjà pertinent
+        if (s > 0)
+            out.push({ pattern: p, score: s * (0.5 + p.score) });
+    }
+    return out.sort((a, b) => b.score - a.score).slice(0, max);
+}
+// ── Routes pertinentes pour l'intention (anti-duplication proactive) ────────
+export function relevantRoutes(index, promptTokens) {
+    const scored = index.routes.map((r) => {
+        const hay = `${r.path} ${r.file}`.toLowerCase();
+        let s = 0;
+        for (const t of promptTokens)
+            if (hay.includes(t))
+                s++;
+        return { r, s };
+    });
+    return scored.filter((x) => x.s > 0).sort((a, b) => b.s - a.s).slice(0, 6).map((x) => x.r);
+}
+export function compileCapsule(index, patterns, prompt) {
+    const tokens = tokenize(prompt);
+    if (!tokens.length)
+        return null;
+    const zones = index ? resolveZones(index, tokens) : [];
+    const selected = selectPatterns(patterns, tokens, zones);
+    const routes = index ? relevantRoutes(index, tokens) : [];
+    const gods = index
+        ? index.god_nodes.filter((g) => zones.some((z) => g.id.startsWith(z))).slice(0, 2)
+        : [];
+    if (!selected.length && !routes.length && !gods.length)
+        return null; // le silence est le défaut
+    const parts = [];
+    parts.push(`[Kurtel memory — auto-injected, relevant to this task only]`);
+    if (routes.length) {
+        parts.push(`Existing routes in this area (do NOT recreate; extend or reuse):`);
+        for (const r of routes)
+            parts.push(`- ${r.method} ${r.path} → ${r.file}:${r.line}`);
+    }
+    if (selected.length) {
+        parts.push(`Team conventions learned from merged PRs (follow them):`);
+        for (const { pattern } of selected) {
+            const conf = Math.round(pattern.score * 100);
+            parts.push(`- ${pattern.rule} (confidence ${conf}%)`);
+        }
+    }
+    if (gods.length) {
+        parts.push(`High-coupling modules in this zone — changes here have a wide blast radius, check dependents:`);
+        for (const g of gods)
+            parts.push(`- ${g.id} (${g.degree} edges)`);
+    }
+    let text = parts.join("\n");
+    if (text.length > TOKEN_BUDGET_CHARS)
+        text = text.slice(0, TOKEN_BUDGET_CHARS - 1) + "…";
+    return { text, injectedPatternIds: selected.map((s) => s.pattern.id), zones };
+}
+// ── Capsule de zone (dérive d'intention en cours de session) ────────────────
+export function compileZoneCapsule(index, patterns, filePath) {
+    const zone = filePath.includes("/") ? filePath.split("/").slice(0, 2).join("/") : filePath;
+    const zonePatterns = patterns.filter((p) => p.score >= 0.3 && p.zones.some((z) => zone.startsWith(z) || z.startsWith(zone))).sort((a, b) => b.score - a.score).slice(0, 3);
+    const zoneRoutes = index ? index.routes.filter((r) => r.file.startsWith(zone)).slice(0, 5) : [];
+    if (!zonePatterns.length && !zoneRoutes.length)
+        return null;
+    const parts = [`[Kurtel memory — you just entered zone "${zone}"]`];
+    if (zonePatterns.length) {
+        parts.push(`Conventions for this zone:`);
+        for (const p of zonePatterns)
+            parts.push(`- ${p.rule}`);
+    }
+    if (zoneRoutes.length) {
+        parts.push(`Routes defined here:`);
+        for (const r of zoneRoutes)
+            parts.push(`- ${r.method} ${r.path} (${r.file}:${r.line})`);
+    }
+    let text = parts.join("\n");
+    if (text.length > 800)
+        text = text.slice(0, 799) + "…";
+    return { text, injectedPatternIds: zonePatterns.map((p) => p.id), zones: [zone] };
+}
+export { findSimilarRoutes };

package/dist/memory/indexer.js

@@ -0,0 +1,280 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative, extname, dirname } from "node:path";
+import { execSync } from "node:child_process";
+import { repoFullName } from "./store.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// Indexeur structurel — 100% local, 0 token, déterministe (même input → même
+// output). Heuristiques regex pragmatiques pour TS/JS/Python ; le point
+// d'extension propre pour passer à tree-sitter plus tard est extractFile().
+// ─────────────────────────────────────────────────────────────────────────────
+const CODE_EXT = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"]);
+const IGNORE_DIRS = new Set([
+    "node_modules", ".git", "dist", "build", "out", ".next", ".nuxt", "coverage",
+    "vendor", "__pycache__", ".venv", "venv", ".kurtel", ".claude", ".idea", ".vscode",
+]);
+// Filtrage anti-bruit (la leçon Graphify) : on indexe le code, pas les assets/config.
+const IGNORE_FILES = /\.(min\.js|d\.ts|test\.[jt]sx?|spec\.[jt]sx?|stories\.[jt]sx?)$|(^|\/)(conftest|setup)\.py$/;
+// Patterns par langage — jamais croisés (sinon `@app.get(...)` Python matche aussi le pattern Express).
+const JS_ROUTE_PATTERNS = [
+    // Express / Fastify / Koa-router (router.get("/x"), app.post('/y'))
+    {
+        re: /\b(?:app|router|server|api|fastify)\s*\.\s*(get|post|put|patch|delete|head|options|all)\s*\(\s*["'`]([^"'`]+)["'`]/g,
+        framework: "express-like",
+        method: (m) => m[1].toUpperCase(),
+        path: (m) => m[2],
+    },
+    // Décorateurs Nest: @Get("/x"), @Post()
+    {
+        re: /@(Get|Post|Put|Patch|Delete|Head|Options)\s*\(\s*(?:["'`]([^"'`]*)["'`])?\s*\)/g,
+        framework: "nest",
+        method: (m) => m[1].toUpperCase(),
+        path: (m) => m[2] ?? "",
+    },
+];
+const PY_ROUTE_PATTERNS = [
+    // FastAPI / Flask: @app.get("/x"), @router.post("/y"), @app.route("/z", methods=["POST"])
+    {
+        re: /@\s*[\w.]+\.(get|post|put|patch|delete|route)\s*\(\s*["']([^"']+)["']/g,
+        framework: "python",
+        method: (m) => (m[1] === "route" ? "*" : m[1].toUpperCase()),
+        path: (m) => m[2],
+    },
+];
+const NEXT_ROUTE_FILE = /(^|\/)(pages|app)\/(.+?)\/?(route|page|index)?\.(ts|tsx|js|jsx)$/;
+function extractFile(root, rel, src) {
+    const lines = src.split("\n");
+    const facts = { rel, loc: lines.length, exports: [], importSpecs: [], routes: [] };
+    const ext = extname(rel);
+    if (ext === ".py") {
+        for (const m of src.matchAll(/^\s*(?:from\s+([\w.]+)\s+import|import\s+([\w.]+))/gm)) {
+            facts.importSpecs.push(m[1] ?? m[2]);
+        }
+        for (const m of src.matchAll(/^(?:def|class)\s+(\w+)/gm))
+            facts.exports.push(m[1]);
+    }
+    else {
+        for (const m of src.matchAll(/\bfrom\s+["']([^"']+)["']|\brequire\s*\(\s*["']([^"']+)["']\s*\)/g)) {
+            facts.importSpecs.push(m[1] ?? m[2]);
+        }
+        for (const m of src.matchAll(/\bexport\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var|interface|type|enum)\s+(\w+)/g)) {
+            facts.exports.push(m[1]);
+        }
+    }
+    // Routes par appel/décorateur, avec n° de ligne — patterns du bon langage uniquement.
+    const routePatterns = ext === ".py" ? PY_ROUTE_PATTERNS : JS_ROUTE_PATTERNS;
+    for (const p of routePatterns) {
+        for (const m of src.matchAll(p.re)) {
+            const upto = src.slice(0, m.index ?? 0);
+            facts.routes.push({
+                method: p.method(m),
+                path: p.path(m),
+                file: rel,
+                line: upto.split("\n").length,
+                framework: p.framework,
+            });
+        }
+    }
+    // Routes par convention de fichier (Next.js app/pages router).
+    const nm = rel.replace(/\\/g, "/").match(NEXT_ROUTE_FILE);
+    if (nm) {
+        const urlPath = "/" + nm[3].replace(/\[(\w+)\]/g, ":$1").replace(/\/index$/, "");
+        facts.routes.push({ method: "*", path: urlPath, file: rel, line: 1, framework: "next" });
+    }
+    return facts;
+}
+// ── Résolution d'imports internes (TS/JS relatifs + Python par module path) ──
+function resolveImports(all) {
+    const byNoExt = new Map();
+    for (const rel of all.keys()) {
+        const noExt = rel.replace(/\.(ts|tsx|js|jsx|mjs|cjs|py)$/, "");
+        byNoExt.set(noExt.replace(/\\/g, "/"), rel);
+        if (noExt.endsWith("/index"))
+            byNoExt.set(noExt.slice(0, -"/index".length), rel);
+        if (noExt.endsWith("/__init__"))
+            byNoExt.set(noExt.slice(0, -"/__init__".length), rel);
+    }
+    const resolved = new Map();
+    for (const [rel, facts] of all) {
+        const targets = [];
+        for (const spec of facts.importSpecs) {
+            let candidate;
+            if (spec.startsWith(".")) {
+                // relatif TS/JS
+                const base = join(dirname(rel), spec).replace(/\\/g, "/").replace(/\.(js|ts|tsx|jsx)$/, "");
+                candidate = byNoExt.get(base);
+            }
+            else if (spec.includes(".") && extname(rel) === ".py") {
+                // module python "app.services.billing" → app/services/billing.py
+                candidate = byNoExt.get(spec.replace(/\./g, "/"));
+            }
+            else {
+                // alias absolu fréquent: "src/lib/foo", "@/lib/foo"
+                const cleaned = spec.replace(/^@\//, "src/").replace(/^~\//, "src/");
+                candidate = byNoExt.get(cleaned);
+            }
+            if (candidate && candidate !== rel)
+                targets.push(candidate);
+        }
+        resolved.set(rel, [...new Set(targets)]);
+    }
+    return resolved;
+}
+// ── Parcours ────────────────────────────────────────────────────────────────
+function* walk(dir, root) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        if (name.startsWith(".") && name !== ".")
+            continue;
+        const full = join(dir, name);
+        let st;
+        try {
+            st = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory()) {
+            if (!IGNORE_DIRS.has(name))
+                yield* walk(full, root);
+        }
+        else if (st.isFile() && st.size < 1_000_000) {
+            const rel = relative(root, full).replace(/\\/g, "/");
+            if (CODE_EXT.has(extname(name)) && !IGNORE_FILES.test(rel))
+                yield rel;
+        }
+    }
+}
+// ── Construction de l'index ─────────────────────────────────────────────────
+export function buildIndex(root, onProgress) {
+    const files = new Map();
+    let n = 0;
+    for (const rel of walk(root, root)) {
+        try {
+            const src = readFileSync(join(root, rel), "utf8");
+            files.set(rel, extractFile(root, rel, src));
+            if (onProgress && ++n % 50 === 0)
+                onProgress(n);
+        }
+        catch { /* binaire/illisible: skip */ }
+    }
+    const imports = resolveImports(files);
+    const inDegree = new Map();
+    for (const targets of imports.values()) {
+        for (const t of targets)
+            inDegree.set(t, (inDegree.get(t) ?? 0) + 1);
+    }
+    const modules = [...files.entries()]
+        .map(([rel, f]) => {
+        const out = imports.get(rel) ?? [];
+        return {
+            id: rel,
+            exports: f.exports.slice(0, 30),
+            imports: out,
+            loc: f.loc,
+            degree: out.length + (inDegree.get(rel) ?? 0),
+        };
+    })
+        .sort((a, b) => a.id.localeCompare(b.id)); // tri stable → déterminisme
+    const god_nodes = [...modules]
+        .sort((a, b) => b.degree - a.degree || a.id.localeCompare(b.id))
+        .slice(0, 10)
+        .filter((m) => m.degree >= 5)
+        .map((m) => ({ id: m.id, degree: m.degree }));
+    const domainMap = new Map();
+    for (const m of modules) {
+        const top = m.id.includes("/") ? m.id.split("/")[0] : "(root)";
+        const d = domainMap.get(top) ?? { files: 0, loc: 0 };
+        d.files += 1;
+        d.loc += m.loc;
+        domainMap.set(top, d);
+    }
+    const domains = [...domainMap.entries()]
+        .map(([name, d]) => ({ name, ...d }))
+        .sort((a, b) => b.loc - a.loc);
+    const routes = [...files.values()].flatMap((f) => f.routes)
+        .sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+    let commit = "unknown";
+    try {
+        commit = execSync("git rev-parse HEAD", { cwd: root, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    }
+    catch { /* pas un repo git */ }
+    return {
+        version: 1,
+        repo: repoFullName(root),
+        commit,
+        generated_at: new Date().toISOString(),
+        files_indexed: files.size,
+        routes,
+        modules,
+        god_nodes,
+        domains,
+    };
+}
+// ── Rapport d'audit (le "moment wow" du jour 0) ─────────────────────────────
+export function renderReport(index) {
+    const lines = [];
+    lines.push(`# Kurtel — Architecture Report`);
+    lines.push(``);
+    lines.push(`Repo **${index.repo}** · ${index.files_indexed} files indexed · commit \`${index.commit.slice(0, 8)}\` · ${index.generated_at}`);
+    lines.push(``);
+    lines.push(`## Domains`);
+    for (const d of index.domains.slice(0, 12)) {
+        lines.push(`- **${d.name}** — ${d.files} files, ${d.loc.toLocaleString()} LOC`);
+    }
+    lines.push(``);
+    if (index.god_nodes.length) {
+        lines.push(`## God nodes (high-coupling hotspots)`);
+        lines.push(`These modules concentrate the most connections; changes here have the widest blast radius.`);
+        for (const g of index.god_nodes) {
+            lines.push(`- \`${g.id}\` — **${g.degree} edges**`);
+        }
+        lines.push(``);
+    }
+    lines.push(`## Route inventory (${index.routes.length})`);
+    lines.push(`The agent receives this inventory before creating any endpoint — duplicates get flagged.`);
+    const byFw = new Map();
+    for (const r of index.routes) {
+        const arr = byFw.get(r.framework) ?? [];
+        arr.push(r);
+        byFw.set(r.framework, arr);
+    }
+    for (const [fw, rs] of byFw) {
+        lines.push(``);
+        lines.push(`### ${fw}`);
+        for (const r of rs.slice(0, 80)) {
+            lines.push(`- \`${r.method.padEnd(6)} ${r.path}\` → ${r.file}:${r.line}`);
+        }
+        if (rs.length > 80)
+            lines.push(`- … and ${rs.length - 80} more`);
+    }
+    lines.push(``);
+    return lines.join("\n");
+}
+// ── Recherche de routes proches (anti-duplication) ──────────────────────────
+/** Similarité grossière entre deux chemins de route (segments partagés, params normalisés). */
+function routeSimilarity(a, b) {
+    const norm = (p) => p.replace(/:(\w+)|\{(\w+)\}|\[(\w+)\]/g, ":p").toLowerCase()
+        .split("/").filter(Boolean);
+    const sa = norm(a), sb = norm(b);
+    if (!sa.length || !sb.length)
+        return 0;
+    let shared = 0;
+    for (let i = 0; i < Math.min(sa.length, sb.length); i++)
+        if (sa[i] === sb[i])
+            shared++;
+    return (2 * shared) / (sa.length + sb.length);
+}
+export function findSimilarRoutes(index, path, threshold = 0.6) {
+    return index.routes
+        .map((r) => ({ r, s: routeSimilarity(r.path, path) }))
+        .filter((x) => x.s >= threshold)
+        .sort((a, b) => b.s - a.s)
+        .slice(0, 5)
+        .map((x) => x.r);
+}

package/dist/memory/store.js

@@ -0,0 +1,125 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+// ─────────────────────────────────────────────────────────────────────────────
+// Emplacements disque
+//   ~/.kurtel/cache/<repo-slug>/patterns.json   ← mémoire darwinienne (pull Supabase)
+//   <repo>/.kurtel/index.json                   ← mémoire de codebase (déterministe)
+//   <repo>/.kurtel/REPORT.md                    ← rapport d'audit lisible
+//   <repo>/.kurtel/memory.json                  ← état local (on/off, session zones)
+// ─────────────────────────────────────────────────────────────────────────────
+export function repoRoot(cwd = process.cwd()) {
+    try {
+        return execSync("git rev-parse --show-toplevel", { cwd, stdio: ["ignore", "pipe", "ignore"] })
+            .toString().trim();
+    }
+    catch {
+        return cwd;
+    }
+}
+export function repoSlug(root) {
+    // owner/name depuis le remote si possible, sinon basename — slugifié pour un nom de dossier.
+    let name = root.split(/[\\/]/).filter(Boolean).pop() ?? "repo";
+    try {
+        const url = execSync("git remote get-url origin", { cwd: root, stdio: ["ignore", "pipe", "ignore"] })
+            .toString().trim();
+        const m = url.match(/[:/]([^/:]+\/[^/]+?)(?:\.git)?$/);
+        if (m)
+            name = m[1];
+    }
+    catch { /* pas de remote */ }
+    return name.replace(/[^a-zA-Z0-9._-]+/g, "__");
+}
+export function repoFullName(root) {
+    try {
+        const url = execSync("git remote get-url origin", { cwd: root, stdio: ["ignore", "pipe", "ignore"] })
+            .toString().trim();
+        const m = url.match(/[:/]([^/:]+\/[^/]+?)(?:\.git?)?$/);
+        if (m)
+            return m[1].replace(/\.git$/, "");
+    }
+    catch { /* ignore */ }
+    return root.split(/[\\/]/).filter(Boolean).pop() ?? "repo";
+}
+function cacheDir(root) {
+    return join(homedir(), ".kurtel", "cache", repoSlug(root));
+}
+function readJSON(file, fallback) {
+    try {
+        if (!existsSync(file))
+            return fallback;
+        return { ...fallback, ...JSON.parse(readFileSync(file, "utf8")) };
+    }
+    catch {
+        return fallback;
+    }
+}
+function writeJSON(file, data) {
+    const dir = join(file, "..");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(file, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+// ── Cache mémoire darwinienne (par user × repo, hors du repo: ne se versionne pas) ──
+const EMPTY_CACHE = { patterns: [], patterns_synced_at: null, pending_telemetry: [] };
+export function loadMemoryCache(root) {
+    return readJSON(join(cacheDir(root), "memory.json"), EMPTY_CACHE);
+}
+export function saveMemoryCache(root, cache) {
+    writeJSON(join(cacheDir(root), "memory.json"), cache);
+}
+export function queueTelemetry(root, ev) {
+    const cache = loadMemoryCache(root);
+    cache.pending_telemetry.push(ev);
+    // borne dure: jamais plus de 500 événements en attente (pas de croissance infinie)
+    if (cache.pending_telemetry.length > 500) {
+        cache.pending_telemetry = cache.pending_telemetry.slice(-500);
+    }
+    saveMemoryCache(root, cache);
+}
+// ── Index de codebase (dans le repo: partageable, déterministe) ──
+export function indexPath(root) {
+    return join(root, ".kurtel", "index.json");
+}
+export function reportPath(root) {
+    return join(root, ".kurtel", "REPORT.md");
+}
+export function loadIndex(root) {
+    const file = indexPath(root);
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveIndex(root, index) {
+    writeJSON(indexPath(root), index);
+}
+const EMPTY_STATE = { enabled: true, session_zones: {} };
+function statePath(root) {
+    return join(cacheDir(root), "state.json");
+}
+export function loadMemoryState(root) {
+    return readJSON(statePath(root), EMPTY_STATE);
+}
+export function saveMemoryState(root, state) {
+    // garde-fou: ne garder que les 20 dernières sessions
+    const ids = Object.keys(state.session_zones);
+    if (ids.length > 20) {
+        for (const id of ids.slice(0, ids.length - 20))
+            delete state.session_zones[id];
+    }
+    writeJSON(statePath(root), state);
+}
+export function memoryEnabled(root) {
+    return loadMemoryState(root).enabled;
+}
+export function setMemoryEnabled(root, enabled) {
+    const s = loadMemoryState(root);
+    s.enabled = enabled;
+    saveMemoryState(root, s);
+}

package/dist/memory/sync.js

@@ -0,0 +1,70 @@
+import { spawn } from "node:child_process";
+import { loadMemoryCache, saveMemoryCache, repoFullName } from "./store.js";
+import { pullPatterns, pushTelemetry, pushIndex } from "./api.js";
+import { loadIndex } from "./store.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// Sync — règle d'or: AUCUN appel réseau sur le chemin critique d'un prompt.
+// Les hooks lisent le cache local; le sync tourne en arrière-plan (process
+// détaché) au SessionStart et après chaque session.
+// ─────────────────────────────────────────────────────────────────────────────
+/** Sync synchrone (utilisé par `kurtel memory sync` et le process détaché). */
+export async function syncNow(root) {
+    const repo = repoFullName(root);
+    const cache = loadMemoryCache(root);
+    // 1. Pull delta des patterns darwiniens.
+    let pulled = 0;
+    try {
+        const res = await pullPatterns(repo, cache.patterns_synced_at);
+        if (res.delta) {
+            const byId = new Map(cache.patterns.map((p) => [p.id, p]));
+            for (const p of res.patterns)
+                byId.set(p.id, p);
+            cache.patterns = [...byId.values()].filter((p) => p.score > 0); // score 0 = mort, purgé
+        }
+        else {
+            cache.patterns = res.patterns;
+        }
+        cache.patterns_synced_at = res.synced_at;
+        pulled = res.patterns.length;
+    }
+    catch { /* offline / pas loggé: le cache continue de servir */ }
+    // 2. Flush de la télémétrie en attente.
+    let flushed = 0;
+    if (cache.pending_telemetry.length) {
+        try {
+            await pushTelemetry(repo, cache.pending_telemetry);
+            flushed = cache.pending_telemetry.length;
+            cache.pending_telemetry = [];
+        }
+        catch { /* on réessaiera au prochain sync */ }
+    }
+    saveMemoryCache(root, cache);
+    return { pulled, flushed };
+}
+/** Push de l'index de codebase vers le backend (pour l'onglet Memory in-app). */
+export async function syncIndexUp(root) {
+    const index = loadIndex(root);
+    if (!index)
+        return false;
+    try {
+        await pushIndex(index.repo, index);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Lance un sync en arrière-plan, détaché — fire & forget, jamais bloquant. */
+export function syncInBackground(root) {
+    try {
+        const child = spawn(process.execPath, [process.argv[1], "memory", "sync", "--quiet"], {
+            cwd: root,
+            stdio: "ignore",
+            detached: true,
+            env: process.env,
+        });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch { /* best effort */ }
+}