@kurtel/cli 0.1.11 → 0.1.13

package/dist/commands/hook.js

@@ -1,5 +1,6 @@
 import { repoRoot, repoFullName, loadIndex, loadMemoryCache, memoryEnabled, loadMemoryState, saveMemoryState, queueTelemetry, } from "../memory/store.js";
 import { compileCapsule, compileZoneCapsule, findSimilarRoutes } from "../memory/capsule.js";
+import { resolveTarget, computeImpact } from "../memory/impact.js";
 import { syncInBackground } from "../memory/sync.js";
 function readStdin() {
     return new Promise((resolve) => {
@@ -129,6 +130,24 @@ function onPostToolUse(root, input) {
         state.session_zones[sid] = [...seen, zone];
         saveMemoryState(root, state);
     }
+    // 3. Fichier à fort couplage: une ligne d'impact, la même vue que le dev.
+    if (index) {
+        const mod = index.modules.find((m) => m.id === filePath);
+        const isHot = mod && (mod.degree >= 8 || index.god_nodes.some((g) => g.id === filePath));
+        if (isHot && !seen.has("impact:" + filePath)) {
+            const t = resolveTarget(index, filePath);
+            if (t) {
+                const r = computeImpact(index, t, 3);
+                if (r.transitive > 0) {
+                    messages.push(`[Kurtel impact] ${filePath}: ${r.direct} direct dependents, ${r.transitive} transitive (≤3 hops)` +
+                        (r.affectedRoutes.length ? ` — routes in blast radius: ${r.affectedRoutes.slice(0, 3).map((x) => x.path).join(", ")}` : "") +
+                        `. Check dependents before changing signatures; run \`kurtel impact ${filePath} --json\` for the full set.`);
+                    state.session_zones[sid] = [...(state.session_zones[sid] ?? []), "impact:" + filePath];
+                    saveMemoryState(root, state);
+                }
+            }
+        }
+    }
     if (messages.length)
         emitContext("PostToolUse", messages.join("\n\n"));
 }

package/dist/commands/impact.js

@@ -0,0 +1,32 @@
+import { c, symbols } from "../ui/colors.js";
+import { repoRoot, loadIndex } from "../memory/store.js";
+import { resolveTarget, computeImpact, renderImpactForAgent } from "../memory/impact.js";
+export async function impactCommand(target, opts = {}) {
+    if (!target) {
+        console.log(`${c.red(symbols.cross)} Usage: ${c.indigo('kurtel impact <file | file::function | function>')}`);
+        process.exitCode = 1;
+        return;
+    }
+    const root = repoRoot();
+    const index = loadIndex(root);
+    if (!index) {
+        console.log(`${c.red(symbols.cross)} No index. Run ${c.indigo("kurtel onboard")} first.`);
+        process.exitCode = 1;
+        return;
+    }
+    const resolved = resolveTarget(index, target);
+    if (!resolved) {
+        console.log(`${c.red(symbols.cross)} Target ${c.white(target)} not found (or ambiguous — use file::function).`);
+        process.exitCode = 1;
+        return;
+    }
+    const depth = Math.min(6, Math.max(1, parseInt(opts.depth ?? "4", 10) || 4));
+    const result = computeImpact(index, resolved, depth);
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(result));
+        return;
+    }
+    console.log("");
+    console.log(renderImpactForAgent(result));
+    console.log("");
+}

package/dist/commands/installClaudeCode.js

@@ -42,6 +42,18 @@ The user said: "$ARGUMENTS"
 - If it contains "pattern" → run \`kurtel memory patterns --json\` and present the patterns as a readable list (rule, confidence, zones, evidence count), sorted by confidence
 - Otherwise → run \`kurtel memory status --json\` and present a one-line summary
 Relay the result conversationally. Never paste raw JSON to the user.
+`,
+    "impact.md": `---
+description: Blast radius of changing a file or function (who breaks if I touch X)
+allowed-tools: Bash(kurtel impact:*)
+---
+The user wants the impact of changing: "$ARGUMENTS"
+Run \`kurtel impact $ARGUMENTS --json\` with the Bash tool, then present:
+1. Direct vs transitive dependent counts.
+2. The dependency layers (depth 1 first) as a short readable list.
+3. The reverse call chain if present (which functions call the target).
+4. Routes in the blast radius — these are user-facing surfaces, flag them clearly.
+If the command says the target was not found, suggest the file::function syntax.
 `,
     "status.md": `---
 description: Show Kurtel memory status for this repo

package/dist/index.js

@@ -15,6 +15,7 @@ import { onboardCommand } from "./commands/onboard.js";
 import { memoryCommand } from "./commands/memory.js";
 import { installClaudeCodeCommand, uninstallClaudeCodeCommand } from "./commands/installClaudeCode.js";
 import { hookCommand } from "./commands/hook.js";
+import { impactCommand } from "./commands/impact.js";
 const program = new Command();
 program
     .name("kurtel")
@@ -118,6 +119,13 @@ program
     .option("--json", "Machine-readable output (used by /kurtel:onboard)", false)
     .option("--local", "Skip cloud upload — index stays on disk", false)
     .action(async (opts) => onboardCommand(opts));
+program
+    .command("impact")
+    .description("Blast radius of changing a file or function (reverse imports + call graph)")
+    .argument("[target...]", "file path, file::function, or unique function name")
+    .option("--json", "Machine-readable output", false)
+    .option("--depth <n>", "Max BFS depth (default 4)")
+    .action(async (parts, opts) => impactCommand((parts ?? []).join(" "), opts));
 program
     .command("memory")
     .description("Inspect or toggle Kurtel memory (status | on | off | sync | patterns)")

package/dist/memory/api.js

@@ -39,7 +39,11 @@ export function pullPatterns(repo, since) {
 export function pushIndex(repo, index) {
     const digest = {
         ...index,
-        modules: index.modules.map((m) => ({ ...m, exports: m.exports.slice(0, 10) })).slice(0, 3000),
+        modules: index.modules.map((m) => ({
+            ...m,
+            exports: m.exports.slice(0, 10),
+            symbols: (m.symbols ?? []).slice(0, 25).map((sy) => ({ ...sy, calls: sy.calls.slice(0, 15) })),
+        })).slice(0, 3000),
     };
     return authed("PUT", `/api/memory/index${q(repo)}`, digest);
 }

package/dist/memory/impact.js

@@ -0,0 +1,152 @@
+/** Adjacences inverses précalculées depuis l'index. */
+export function buildReverse(index) {
+    const fileRev = new Map(); // file ← importeurs
+    const symbolRev = new Map(); // "f::fn" ← appelants
+    for (const m of index.modules) {
+        for (const t of m.imports) {
+            (fileRev.get(t) ?? fileRev.set(t, []).get(t)).push(m.id);
+        }
+        for (const s of m.symbols ?? []) {
+            const from = `${m.id}::${s.name}`;
+            for (const call of s.calls) {
+                (symbolRev.get(call) ?? symbolRev.set(call, []).get(call)).push({ from, via: call });
+            }
+        }
+    }
+    return { fileRev, symbolRev };
+}
+const MAX_NODES = 400;
+/** Résout une cible libre: "src/billing/service.ts", "service.ts::chargeCustomer", ou juste "chargeCustomer". */
+export function resolveTarget(index, query) {
+    const q = query.trim().replace(/\\/g, "/");
+    if (q.includes("::")) {
+        const [file, fn] = q.split("::");
+        const mod = index.modules.find((m) => m.id === file || m.id.endsWith("/" + file));
+        if (mod?.symbols?.some((s) => s.name === fn))
+            return { id: `${mod.id}::${fn}`, kind: "symbol" };
+        return null;
+    }
+    const exact = index.modules.find((m) => m.id === q);
+    if (exact)
+        return { id: exact.id, kind: "file" };
+    const suffix = index.modules.filter((m) => m.id.endsWith("/" + q) || m.id.endsWith(q));
+    if (suffix.length === 1)
+        return { id: suffix[0].id, kind: "file" };
+    // nom de fonction seul: unique dans le repo ?
+    const owners = index.modules.filter((m) => m.symbols?.some((s) => s.name === q));
+    if (owners.length === 1)
+        return { id: `${owners[0].id}::${q}`, kind: "symbol" };
+    return null;
+}
+export function computeImpact(index, target, maxDepth = 4) {
+    const { fileRev, symbolRev } = buildReverse(index);
+    const fileDepth = new Map();
+    const symbols = [];
+    let truncated = false;
+    if (target.kind === "symbol") {
+        // BFS inverse sur le graphe d'appels; les fichiers porteurs héritent de la profondeur.
+        const seen = new Map([[target.id, 0]]);
+        let frontier = [target.id];
+        for (let d = 1; d <= maxDepth && frontier.length; d++) {
+            const next = [];
+            for (const sym of frontier) {
+                for (const caller of symbolRev.get(sym) ?? []) {
+                    if (seen.has(caller.from))
+                        continue;
+                    if (seen.size >= MAX_NODES) {
+                        truncated = true;
+                        break;
+                    }
+                    seen.set(caller.from, d);
+                    symbols.push({ symbol: caller.from, depth: d, via: sym });
+                    next.push(caller.from);
+                    const file = caller.from.split("::")[0];
+                    if (!fileDepth.has(file))
+                        fileDepth.set(file, d);
+                }
+            }
+            frontier = next;
+        }
+        // Le fichier hôte du symbole est impacté à profondeur 0 (on le modifie).
+        fileDepth.set(target.id.split("::")[0], 0);
+    }
+    else {
+        const seen = new Map([[target.id, 0]]);
+        let frontier = [target.id];
+        for (let d = 1; d <= maxDepth && frontier.length; d++) {
+            const next = [];
+            for (const f of frontier) {
+                for (const importer of fileRev.get(f) ?? []) {
+                    if (seen.has(importer))
+                        continue;
+                    if (seen.size >= MAX_NODES) {
+                        truncated = true;
+                        break;
+                    }
+                    seen.set(importer, d);
+                    next.push(importer);
+                }
+            }
+            frontier = next;
+        }
+        for (const [f, d] of seen)
+            if (d > 0)
+                fileDepth.set(f, d);
+        // Bonus: appels symboliques inverses depuis tous les symboles du fichier (profondeur 1 du détail).
+        const mod = index.modules.find((m) => m.id === target.id);
+        for (const s of mod?.symbols ?? []) {
+            for (const caller of symbolRev.get(`${target.id}::${s.name}`) ?? []) {
+                symbols.push({ symbol: caller.from, depth: 1, via: `${target.id}::${s.name}` });
+                if (symbols.length >= 60)
+                    break;
+            }
+        }
+    }
+    const byDepth = new Map();
+    for (const [f, d] of fileDepth) {
+        if (d === 0)
+            continue;
+        (byDepth.get(d) ?? byDepth.set(d, []).get(d)).push(f);
+    }
+    const layers = [...byDepth.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([depth, files]) => ({ depth, files: files.sort() }));
+    const impactedFiles = new Set(fileDepth.keys());
+    const affectedRoutes = index.routes
+        .filter((r) => impactedFiles.has(r.file))
+        .map((r) => ({ method: r.method, path: r.path, file: r.file }))
+        .slice(0, 40);
+    return {
+        target: target.id,
+        kind: target.kind,
+        direct: layers[0]?.files.length ?? 0,
+        transitive: layers.reduce((s, l) => s + l.files.length, 0),
+        layers,
+        symbols: symbols.slice(0, 60),
+        affectedRoutes,
+        truncated,
+    };
+}
+/** Rendu texte compact pour l'agent (~ borné, lisible par un LLM). */
+export function renderImpactForAgent(r) {
+    const lines = [];
+    lines.push(`[Impact analysis] ${r.target} (${r.kind})`);
+    lines.push(`Direct dependents: ${r.direct} · transitive (≤4 hops): ${r.transitive}${r.truncated ? " (truncated)" : ""}`);
+    for (const layer of r.layers.slice(0, 3)) {
+        lines.push(`Depth ${layer.depth}: ${layer.files.slice(0, 10).join(", ")}${layer.files.length > 10 ? ` … +${layer.files.length - 10}` : ""}`);
+    }
+    if (r.symbols.length) {
+        lines.push(`Call chain (who calls this):`);
+        for (const s of r.symbols.slice(0, 10))
+            lines.push(`  d${s.depth} ${s.symbol} → ${s.via}`);
+    }
+    if (r.affectedRoutes.length) {
+        lines.push(`Routes in blast radius:`);
+        for (const rt of r.affectedRoutes.slice(0, 8))
+            lines.push(`  ${rt.method} ${rt.path} (${rt.file})`);
+    }
+    let out = lines.join("\n");
+    if (out.length > 1800)
+        out = out.slice(0, 1799) + "…";
+    return out;
+}

package/dist/memory/indexer.js

@@ -41,25 +41,105 @@ const PY_ROUTE_PATTERNS = [
     },
 ];
 const NEXT_ROUTE_FILE = /(^|\/)(pages|app)\/(.+?)\/?(route|page|index)?\.(ts|tsx|js|jsx)$/;
+const JS_KEYWORDS = new Set([
+    "if", "for", "while", "switch", "catch", "return", "function", "new", "typeof",
+    "await", "async", "import", "export", "require", "console", "constructor",
+    "super", "this", "throw", "delete", "void", "in", "of", "do", "else", "try",
+]);
+const PY_KEYWORDS = new Set([
+    "if", "for", "while", "return", "print", "len", "range", "str", "int", "dict",
+    "list", "set", "tuple", "type", "isinstance", "super", "open", "enumerate",
+]);
+function lineOf(src, index) {
+    let n = 1;
+    for (let i = 0; i < index; i++)
+        if (src.charCodeAt(i) === 10)
+            n++;
+    return n;
+}
 function extractFile(root, rel, src) {
     const lines = src.split("\n");
-    const facts = { rel, loc: lines.length, exports: [], importSpecs: [], routes: [] };
+    const facts = {
+        rel, loc: lines.length, exports: [], importSpecs: [], routes: [],
+        defs: [], namedImports: {}, rawCalls: [],
+    };
     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]);
+    const isPy = ext === ".py";
+    if (isPy) {
+        for (const m of src.matchAll(/^\s*(?:from\s+([\w.]+)\s+import\s+([\w ,]+)|import\s+([\w.]+))/gm)) {
+            facts.importSpecs.push(m[1] ?? m[3]);
+            // from x import a, b → imports nommés
+            if (m[1] && m[2]) {
+                for (const name of m[2].split(",").map((s) => s.trim().split(/\s+as\s+/)[0])) {
+                    if (/^\w+$/.test(name))
+                        facts.namedImports[name] = m[1];
+                }
+            }
+        }
+        for (const m of src.matchAll(/^(?:\s*)(?:async\s+)?def\s+(\w+)/gm)) {
+            facts.exports.push(m[1]);
+            facts.defs.push({ name: m[1], line: lineOf(src, m.index ?? 0) });
         }
-        for (const m of src.matchAll(/^(?:def|class)\s+(\w+)/gm))
+        for (const m of src.matchAll(/^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(/import\s+(?:type\s+)?(?:(\w+)\s*,?\s*)?(?:{([^}]*)})?\s*from\s+["']([^"']+)["']|\brequire\s*\(\s*["']([^"']+)["']\s*\)/g)) {
+            const spec = m[3] ?? m[4];
+            if (!spec)
+                continue;
+            facts.importSpecs.push(spec);
+            if (m[1])
+                facts.namedImports[m[1]] = spec; // import défaut
+            if (m[2]) {
+                for (const part of m[2].split(",")) {
+                    const name = part.trim().split(/\s+as\s+/).pop()?.trim();
+                    if (name && /^\w+$/.test(name))
+                        facts.namedImports[name] = spec;
+                }
+            }
+        }
+        // Définitions: function decl, const fléchée, méthodes de classe.
+        for (const m of src.matchAll(/\b(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)/g)) {
+            facts.defs.push({ name: m[1], line: lineOf(src, m.index ?? 0) });
+        }
+        for (const m of src.matchAll(/\b(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s*)?(?:\([^)]*\)|\w+)\s*(?::\s*[^=]+)?=>/g)) {
+            facts.defs.push({ name: m[1], line: lineOf(src, m.index ?? 0) });
+        }
+        for (const m of src.matchAll(/^\s{2,}(?:public\s+|private\s+|protected\s+|static\s+)*(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*[\w<>[\]| .]+)?\s*{/gm)) {
+            if (!JS_KEYWORDS.has(m[1]))
+                facts.defs.push({ name: m[1], line: lineOf(src, m.index ?? 0) });
         }
         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]);
         }
     }
+    // Dédupe les defs (même nom: garder la première occurrence), tri par ligne.
+    const seen = new Set();
+    facts.defs = facts.defs
+        .sort((a, b) => a.line - b.line)
+        .filter((d) => (seen.has(d.name) ? false : (seen.add(d.name), true)))
+        .slice(0, 40);
+    // Sites d'appel candidats: identifiant suivi de "(", hors mots-clés.
+    const kw = isPy ? PY_KEYWORDS : JS_KEYWORDS;
+    let count = 0;
+    for (const m of src.matchAll(/(?<![\w.])([A-Za-z_]\w{2,})\s*\(/g)) {
+        if (kw.has(m[1]))
+            continue;
+        facts.rawCalls.push({ name: m[1], line: lineOf(src, m.index ?? 0) });
+        if (++count >= 800)
+            break;
+    }
+    // Appels qualifiés "Prefix.method(" → candidat "Prefix." (résolu vers la
+    // classe/module importé en post-passe; le point final marque le cas qualifié).
+    for (const m of src.matchAll(/(?<![\w.])([A-Z]\w{2,})\.\w+\s*\(/g)) {
+        if (kw.has(m[1]))
+            continue;
+        facts.rawCalls.push({ name: m[1] + ".", line: lineOf(src, m.index ?? 0) });
+        if (++count >= 1000)
+            break;
+    }
+    facts.rawCalls.sort((a, b) => a.line - b.line);
     // 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) {
@@ -83,7 +163,7 @@ function extractFile(root, rel, src) {
     return facts;
 }
 // ── Résolution d'imports internes (TS/JS relatifs + Python par module path) ──
-function resolveImports(all) {
+function buildResolver(all) {
     const byNoExt = new Map();
     for (const rel of all.keys()) {
         const noExt = rel.replace(/\.(ts|tsx|js|jsx|mjs|cjs|py)$/, "");
@@ -93,25 +173,25 @@ function resolveImports(all) {
         if (noExt.endsWith("/__init__"))
             byNoExt.set(noExt.slice(0, -"/__init__".length), rel);
     }
+    return (rel, spec) => {
+        if (spec.startsWith(".")) {
+            const base = join(dirname(rel), spec).replace(/\\/g, "/").replace(/\.(js|ts|tsx|jsx)$/, "");
+            return byNoExt.get(base);
+        }
+        if (spec.includes(".") && extname(rel) === ".py") {
+            return byNoExt.get(spec.replace(/\./g, "/"));
+        }
+        const cleaned = spec.replace(/^@\//, "src/").replace(/^~\//, "src/");
+        return byNoExt.get(cleaned);
+    };
+}
+function resolveImports(all) {
+    const resolve = buildResolver(all);
     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);
-            }
+            const candidate = resolve(rel, spec);
             if (candidate && candidate !== rel)
                 targets.push(candidate);
         }
@@ -119,6 +199,56 @@ function resolveImports(all) {
     }
     return resolved;
 }
+// ── Graphe d'appels: résolution des sites d'appel en arêtes symbole→symbole ──
+const MAX_SYMBOLS_PER_FILE = 25;
+const MAX_CALLS_PER_SYMBOL = 15;
+function buildSymbols(all, resolve) {
+    const defNames = new Map();
+    const exportNames = new Map();
+    for (const [rel, f] of all) {
+        defNames.set(rel, new Set(f.defs.map((d) => d.name)));
+        exportNames.set(rel, new Set(f.exports));
+    }
+    const out = new Map();
+    for (const [rel, f] of all) {
+        const locals = defNames.get(rel);
+        const symbols = f.defs.slice(0, MAX_SYMBOLS_PER_FILE).map((d) => ({ ...d, calls: [] }));
+        // Pseudo-symbole pour les appels hors fonction (handlers de routes inline,
+        // initialisation module) — c'est là que vivent les arêtes des fichiers routes.
+        const topLevel = { name: "(module)", line: 0, calls: [] };
+        const resolveCall = (raw) => {
+            const qualified = raw.endsWith(".");
+            const name = qualified ? raw.slice(0, -1) : raw;
+            if (!qualified && locals.has(name))
+                return `${rel}::${name}`;
+            const spec = f.namedImports[name];
+            if (spec) {
+                const file = resolve(rel, spec);
+                if (file && file !== rel && (defNames.get(file)?.has(name) || exportNames.get(file)?.has(name))) {
+                    return `${file}::${name}`;
+                }
+            }
+            return null;
+        };
+        for (const call of f.rawCalls) {
+            let caller = topLevel;
+            for (const s of symbols) {
+                if (s.line <= call.line)
+                    caller = s;
+                else
+                    break;
+            }
+            if (caller.name === call.name || caller.calls.length >= MAX_CALLS_PER_SYMBOL)
+                continue;
+            const target = resolveCall(call.name);
+            if (target && target !== `${rel}::${caller.name}` && !caller.calls.includes(target)) {
+                caller.calls.push(target);
+            }
+        }
+        out.set(rel, topLevel.calls.length ? [topLevel, ...symbols] : symbols);
+    }
+    return out;
+}
 // ── Parcours ────────────────────────────────────────────────────────────────
 function* walk(dir, root) {
     let entries;
@@ -164,6 +294,7 @@ export function buildIndex(root, onProgress) {
         catch { /* binaire/illisible: skip */ }
     }
     const imports = resolveImports(files);
+    const symbolMap = buildSymbols(files, buildResolver(files));
     const inDegree = new Map();
     for (const targets of imports.values()) {
         for (const t of targets)
@@ -178,6 +309,7 @@ export function buildIndex(root, onProgress) {
             imports: out,
             loc: f.loc,
             degree: out.length + (inDegree.get(rel) ?? 0),
+            symbols: symbolMap.get(rel) ?? [],
         };
     })
         .sort((a, b) => a.id.localeCompare(b.id)); // tri stable → déterminisme

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kurtel/cli",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Launch self-improving coding agents in the cloud — the Kurtel CLI.",
   "type": "module",
   "bin": {