@kurtel/cli 0.1.12 → 0.1.14

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/commands/onboard.js

@@ -9,7 +9,7 @@ export async function onboardCommand(opts = {}) {
     const root = repoRoot();
     // 1. Index structurel — local, déterministe, 0 token.
     const spin = opts.json ? null : new Spinner("Indexing codebase (local, deterministic)…").start();
-    const index = buildIndex(root, (n) => {
+    const index = await buildIndex(root, (n) => {
         spin?.update(`Indexing codebase… ${n} files`);
     });
     saveIndex(root, index);

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/ast.js

@@ -0,0 +1,365 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
+const require = createRequire(import.meta.url);
+let initFailed = false;
+let parser = null;
+const languages = new Map(); // grammarName → Language
+const missing = new Set();
+function grammarFor(ext) {
+    switch (ext) {
+        case ".ts":
+        case ".mts":
+        case ".cts": return "typescript";
+        case ".tsx": return "tsx";
+        case ".js":
+        case ".jsx":
+        case ".mjs":
+        case ".cjs": return "javascript"; // jsx couvert par la grammaire JS
+        case ".py": return "python";
+        default: return null;
+    }
+}
+async function getParser(ext) {
+    if (initFailed)
+        return null;
+    const grammar = grammarFor(ext);
+    if (!grammar || missing.has(grammar))
+        return null;
+    try {
+        if (!parser) {
+            const Parser = require("web-tree-sitter");
+            await Parser.init();
+            parser = new Parser();
+            getParser.ParserClass = Parser;
+        }
+        let lang = languages.get(grammar);
+        if (!lang) {
+            const wasmDir = join(dirname(require.resolve("tree-sitter-wasms/package.json")), "out");
+            const wasmPath = join(wasmDir, `tree-sitter-${grammar}.wasm`);
+            if (!existsSync(wasmPath)) {
+                missing.add(grammar);
+                return null;
+            }
+            const Parser = getParser.ParserClass;
+            lang = await Parser.Language.load(wasmPath);
+            languages.set(grammar, lang);
+        }
+        return { parser, lang };
+    }
+    catch {
+        initFailed = true; // environnement sans WASM: fallback regex global, une seule tentative
+        return null;
+    }
+}
+// ── Helpers communs ──────────────────────────────────────────────────────────
+const HTTP_METHODS = new Set(["get", "post", "put", "patch", "delete", "head", "options", "all"]);
+const ROUTE_OBJECTS = new Set(["app", "router", "server", "api", "fastify"]);
+const NEST_DECORATORS = new Set(["Get", "Post", "Put", "Patch", "Delete", "Head", "Options"]);
+function stripQuotes(s) {
+    return s.replace(/^["'`]|["'`]$/g, "");
+}
+function line(n) { return n.startPosition.row + 1; }
+/** Ligne de la définition nommée englobante (0 = top-level / handler anonyme → "(module)").
+ *  Renvoie la ligne du NŒUD PORTEUR DU NOM (def enregistrée dans facts.defs), pour
+ *  que l'attribution par `owner` matche `byLine` côté buildSymbols. */
+function enclosingDefLine(node, defKinds, nameOf) {
+    let cur = node.parent;
+    while (cur) {
+        if (defKinds.has(cur.type)) {
+            const name = nameOf(cur);
+            if (name) {
+                // La def est enregistrée à la ligne du déclarateur/méthode, pas de l'arrow.
+                if (cur.type === "arrow_function" || cur.type === "function" || cur.type === "function_expression") {
+                    const carrier = cur.parent; // variable_declarator | public_field_definition
+                    return line(carrier ?? cur);
+                }
+                return line(cur);
+            }
+            // fonction anonyme (callback inline): on continue de remonter
+        }
+        cur = cur.parent;
+    }
+    return 0;
+}
+function emptyFacts(rel, src) {
+    return {
+        rel, loc: src.split("\n").length, exports: [], importSpecs: [], routes: [],
+        defs: [], namedImports: {}, rawCalls: [],
+    };
+}
+// ── TypeScript / JavaScript ──────────────────────────────────────────────────
+const JS_DEF_KINDS = new Set(["function_declaration", "generator_function_declaration", "method_definition", "arrow_function", "function", "function_expression"]);
+function jsDefName(n) {
+    if (n.type === "function_declaration" || n.type === "generator_function_declaration" || n.type === "method_definition") {
+        return n.childForFieldName("name");
+    }
+    // arrow/function expression: nommée seulement si assignée directement à un déclarateur
+    const p = n.parent;
+    if (p?.type === "variable_declarator")
+        return p.childForFieldName("name");
+    if (p?.type === "public_field_definition")
+        return p.childForFieldName("name");
+    return null;
+}
+function extractJs(rel, src, root) {
+    const facts = emptyFacts(rel, src);
+    // Imports (statiques + re-exports + require)
+    for (const imp of root.descendantsOfType("import_statement")) {
+        const source = imp.childForFieldName("source");
+        if (!source)
+            continue;
+        const spec = stripQuotes(source.text);
+        facts.importSpecs.push(spec);
+        for (const clause of imp.descendantsOfType("import_clause")) {
+            for (const child of clause.namedChildren) {
+                if (child.type === "identifier") {
+                    facts.namedImports[child.text] = spec; // default import
+                }
+                else if (child.type === "namespace_import") {
+                    const id = child.descendantsOfType("identifier")[0]; // import * as utils
+                    if (id)
+                        facts.namedImports[id.text] = spec;
+                }
+                else if (child.type === "named_imports") {
+                    for (const isp of child.descendantsOfType("import_specifier")) {
+                        // local = alias si présent, sinon name. On ignore les imports de type.
+                        if (isp.children.some((c) => c.type === "type"))
+                            continue;
+                        const nameNode = isp.childForFieldName("name");
+                        const aliasNode = isp.childForFieldName("alias");
+                        const local = (aliasNode ?? nameNode)?.text;
+                        const orig = nameNode?.text;
+                        if (local && orig)
+                            facts.namedImports[local] = local === orig ? spec : { spec, orig };
+                    }
+                }
+            }
+        }
+    }
+    for (const exp of root.descendantsOfType("export_statement")) {
+        const source = exp.childForFieldName("source");
+        if (source)
+            facts.importSpecs.push(stripQuotes(source.text)); // re-export = arête
+        const decl = exp.childForFieldName("declaration");
+        const name = decl?.childForFieldName("name");
+        if (name)
+            facts.exports.push(name.text);
+        for (const spec of exp.descendantsOfType("export_specifier")) {
+            const n = (spec.childForFieldName("alias") ?? spec.childForFieldName("name"))?.text;
+            if (n)
+                facts.exports.push(n);
+        }
+    }
+    // Définitions
+    for (const fn of root.descendantsOfType(["function_declaration", "generator_function_declaration"])) {
+        const name = fn.childForFieldName("name");
+        if (name)
+            facts.defs.push({ name: name.text, line: line(fn) });
+    }
+    for (const decl of root.descendantsOfType("variable_declarator")) {
+        const value = decl.childForFieldName("value");
+        const name = decl.childForFieldName("name");
+        if (name?.type === "identifier" && value && (value.type === "arrow_function" || value.type === "function" || value.type === "function_expression")) {
+            facts.defs.push({ name: name.text, line: line(decl) });
+        }
+    }
+    for (const m of root.descendantsOfType("method_definition")) {
+        const name = m.childForFieldName("name");
+        if (name && name.text !== "constructor")
+            facts.defs.push({ name: name.text, line: line(m) });
+    }
+    for (const f of root.descendantsOfType("public_field_definition")) {
+        const value = f.childForFieldName("value");
+        const name = f.childForFieldName("name");
+        if (name && value?.type === "arrow_function")
+            facts.defs.push({ name: name.text, line: line(f) });
+    }
+    for (const c of root.descendantsOfType("class_declaration")) {
+        const name = c.childForFieldName("name");
+        if (name)
+            facts.exports.push(name.text);
+    }
+    // Appels + routes
+    for (const call of root.descendantsOfType("call_expression")) {
+        const fn = call.childForFieldName("function");
+        if (!fn)
+            continue;
+        if (fn.type === "identifier") {
+            if (fn.text === "require") {
+                const arg = call.childForFieldName("arguments")?.namedChildren[0];
+                if (arg && (arg.type === "string" || arg.type === "template_string"))
+                    facts.importSpecs.push(stripQuotes(arg.text));
+                continue;
+            }
+            facts.rawCalls.push({ name: fn.text, line: line(call), owner: enclosingDefLine(call, JS_DEF_KINDS, jsDefName) });
+        }
+        else if (fn.type === "member_expression") {
+            const obj = fn.childForFieldName("object");
+            const prop = fn.childForFieldName("property");
+            if (!obj || !prop)
+                continue;
+            // Route express-like: app.get("/x", ...)
+            if (obj.type === "identifier" && ROUTE_OBJECTS.has(obj.text) && HTTP_METHODS.has(prop.text)) {
+                const arg = call.childForFieldName("arguments")?.namedChildren[0];
+                if (arg && (arg.type === "string" || arg.type === "template_string")) {
+                    facts.routes.push({ method: prop.text.toUpperCase(), path: stripQuotes(arg.text), file: rel, line: line(call), framework: "express-like" });
+                }
+            }
+            // Appel qualifié résoluble: ImportéOuClasse.method(...)
+            if (obj.type === "identifier") {
+                facts.rawCalls.push({ name: obj.text + ".", line: line(call), owner: enclosingDefLine(call, JS_DEF_KINDS, jsDefName) });
+            }
+        }
+    }
+    // Décorateurs Nest: @Get("/x")
+    for (const dec of root.descendantsOfType("decorator")) {
+        const call = dec.namedChildren[0];
+        if (call?.type !== "call_expression")
+            continue;
+        const fn = call.childForFieldName("function");
+        if (fn?.type === "identifier" && NEST_DECORATORS.has(fn.text)) {
+            const arg = call.childForFieldName("arguments")?.namedChildren[0];
+            facts.routes.push({
+                method: fn.text.toUpperCase(),
+                path: arg && (arg.type === "string") ? stripQuotes(arg.text) : "",
+                file: rel, line: line(dec), framework: "nest",
+            });
+        }
+    }
+    return facts;
+}
+// ── Python ───────────────────────────────────────────────────────────────────
+const PY_DEF_KINDS = new Set(["function_definition"]);
+const pyDefName = (n) => n.childForFieldName("name");
+/** "from .sub import x" → spec JS-style "./sub" résoluble par le résolveur existant. */
+function pyRelativeSpec(dots, mod) {
+    const up = dots <= 1 ? "./" : "../".repeat(dots - 1);
+    return up + mod.replace(/\./g, "/");
+}
+function extractPy(rel, src, root) {
+    const facts = emptyFacts(rel, src);
+    for (const imp of root.descendantsOfType("import_from_statement")) {
+        // forme: from <relative_import|dotted_name> import a, b as c | from . import service
+        const modNode = imp.childForFieldName("module_name");
+        let spec = "";
+        let relative = false;
+        if (modNode) {
+            if (modNode.type === "relative_import") {
+                relative = true;
+                const dots = (modNode.text.match(/^\.+/) ?? ["."])[0].length;
+                const mod = modNode.text.slice(dots);
+                spec = pyRelativeSpec(dots, mod);
+            }
+            else {
+                spec = modNode.text;
+            }
+        }
+        const names = [];
+        for (const child of imp.namedChildren) {
+            if (child === modNode)
+                continue;
+            if (child.type === "dotted_name")
+                names.push(child.text);
+            if (child.type === "aliased_import") {
+                const alias = child.childForFieldName("alias");
+                if (alias)
+                    names.push(alias.text);
+            }
+        }
+        if (relative && !spec.replace(/^\.\/|\.\.\//g, "")) {
+            // "from . import service" → chaque nom est un module frère
+            for (const n of names) {
+                const s = pyRelativeSpec(1, n);
+                facts.importSpecs.push(s);
+                facts.namedImports[n] = s;
+            }
+        }
+        else if (spec) {
+            facts.importSpecs.push(spec);
+            for (const n of names)
+                facts.namedImports[n] = spec;
+        }
+    }
+    for (const imp of root.descendantsOfType("import_statement")) {
+        for (const d of imp.descendantsOfType("dotted_name"))
+            facts.importSpecs.push(d.text);
+    }
+    for (const fn of root.descendantsOfType("function_definition")) {
+        const name = fn.childForFieldName("name");
+        if (name) {
+            facts.defs.push({ name: name.text, line: line(fn) });
+            facts.exports.push(name.text);
+        }
+    }
+    for (const cls of root.descendantsOfType("class_definition")) {
+        const name = cls.childForFieldName("name");
+        if (name)
+            facts.exports.push(name.text);
+    }
+    for (const call of root.descendantsOfType("call")) {
+        const fn = call.childForFieldName("function");
+        if (!fn)
+            continue;
+        if (fn.type === "identifier") {
+            facts.rawCalls.push({ name: fn.text, line: line(call), owner: enclosingDefLine(call, PY_DEF_KINDS, pyDefName) });
+        }
+        else if (fn.type === "attribute") {
+            const obj = fn.childForFieldName("object");
+            const attr = fn.childForFieldName("attribute");
+            if (obj?.type === "identifier" && attr) {
+                // Route FastAPI/Flask: app.get("/x") en position de décorateur
+                if (call.parent?.type === "decorator" && (HTTP_METHODS.has(attr.text) || attr.text === "route")) {
+                    const arg = call.childForFieldName("arguments")?.namedChildren[0];
+                    if (arg?.type === "string") {
+                        facts.routes.push({
+                            method: attr.text === "route" ? "*" : attr.text.toUpperCase(),
+                            path: stripQuotes(arg.text), file: rel, line: line(call), framework: "python",
+                        });
+                    }
+                }
+                facts.rawCalls.push({ name: obj.text + ".", line: line(call), owner: enclosingDefLine(call, PY_DEF_KINDS, pyDefName) });
+            }
+        }
+    }
+    return facts;
+}
+// ── Point d'entrée ───────────────────────────────────────────────────────────
+const MAX_DEFS = 40;
+const MAX_CALLS = 1000;
+/** Extraction AST. Retourne null si tree-sitter indisponible pour ce fichier → fallback regex. */
+export async function extractFileAst(rel, src, ext) {
+    const ctx = await getParser(ext);
+    if (!ctx)
+        return null;
+    let tree = null;
+    try {
+        ctx.parser.setLanguage(ctx.lang);
+        tree = ctx.parser.parse(src);
+        const facts = ext === ".py" ? extractPy(rel, src, tree.rootNode) : extractJs(rel, src, tree.rootNode);
+        // Bornes + dédupe defs (première occurrence par nom), tri par ligne — comme la voie regex.
+        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, MAX_DEFS);
+        facts.rawCalls = facts.rawCalls.slice(0, MAX_CALLS).sort((a, b) => a.line - b.line);
+        facts.routes = facts.routes.slice(0, 200);
+        facts.exports = [...new Set(facts.exports)];
+        return facts;
+    }
+    catch {
+        return null; // fichier illisible par l'AST → regex
+    }
+    finally {
+        tree?.delete(); // mémoire WASM: indispensable sur des milliers de fichiers
+    }
+}
+/** Routes par convention de fichier Next.js — indépendant du parseur, partagé. */
+export function nextRouteFor(rel) {
+    const nm = rel.replace(/\\/g, "/").match(/(^|\/)(pages|app)\/(.+?)\/?(route|page|index)?\.(ts|tsx|js|jsx)$/);
+    if (!nm)
+        return null;
+    const urlPath = "/" + nm[3].replace(/\[(\w+)\]/g, ":$1").replace(/\/index$/, "");
+    return { method: "*", path: urlPath, file: rel, line: 1, framework: "next" };
+}

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

@@ -2,6 +2,7 @@ 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";
+import { extractFileAst, nextRouteFor } from "./ast.js";
 // ─────────────────────────────────────────────────────────────────────────────
 // Indexeur structurel — 100% local, 0 token, déterministe (même input → même
 // output). Heuristiques regex pragmatiques pour TS/JS/Python ; le point
@@ -40,26 +41,105 @@ const PY_ROUTE_PATTERNS = [
         path: (m) => m[2],
     },
 ];
-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(/^(?:def|class)\s+(\w+)/gm))
+        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(/^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) {
@@ -74,16 +154,10 @@ function extractFile(root, rel, src) {
             });
         }
     }
-    // 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) {
+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 +167,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 +193,64 @@ 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 entry = f.namedImports[name];
+            if (entry) {
+                const spec = typeof entry === "string" ? entry : entry.spec;
+                const orig = typeof entry === "string" ? name : entry.orig; // alias → nom exporté côté cible
+                const file = resolve(rel, spec);
+                if (file && file !== rel && (defNames.get(file)?.has(orig) || exportNames.get(file)?.has(orig))) {
+                    return `${file}::${orig}`;
+                }
+            }
+            return null;
+        };
+        const byLine = new Map(symbols.map((s) => [s.line, s]));
+        for (const call of f.rawCalls) {
+            let caller = topLevel;
+            if (call.owner !== undefined) {
+                caller = call.owner === 0 ? topLevel : (byLine.get(call.owner) ?? topLevel);
+            }
+            else {
+                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;
@@ -151,19 +283,31 @@ function* walk(dir, root) {
     }
 }
 // ── Construction de l'index ─────────────────────────────────────────────────
-export function buildIndex(root, onProgress) {
+export async function buildIndex(root, onProgress) {
     const files = new Map();
     let n = 0;
+    let regexFallbacks = 0;
     for (const rel of walk(root, root)) {
         try {
             const src = readFileSync(join(root, rel), "utf8");
-            files.set(rel, extractFile(root, rel, src));
+            const ast = await extractFileAst(rel, src, extname(rel));
+            if (ast) {
+                files.set(rel, ast);
+            }
+            else {
+                files.set(rel, extractFile(root, rel, src));
+                regexFallbacks++;
+            }
+            const next = nextRouteFor(rel);
+            if (next)
+                files.get(rel).routes.push(next);
             if (onProgress && ++n % 50 === 0)
                 onProgress(n);
         }
         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 +322,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
@@ -206,6 +351,7 @@ export function buildIndex(root, onProgress) {
     catch { /* pas un repo git */ }
     return {
         version: 1,
+        parser: { engine: regexFallbacks === files.size ? "regex" : "tree-sitter", regex_fallbacks: regexFallbacks },
         repo: repoFullName(root),
         commit,
         generated_at: new Date().toISOString(),

package/package.json

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