@kurtel/cli 0.1.13 → 0.1.14

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/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/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,7 +41,6 @@ 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",
@@ -154,12 +154,6 @@ 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) ──
@@ -221,22 +215,30 @@ function buildSymbols(all, resolve) {
             const name = qualified ? raw.slice(0, -1) : raw;
             if (!qualified && locals.has(name))
                 return `${rel}::${name}`;
-            const spec = f.namedImports[name];
-            if (spec) {
+            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(name) || exportNames.get(file)?.has(name))) {
-                    return `${file}::${name}`;
+                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;
-            for (const s of symbols) {
-                if (s.line <= call.line)
-                    caller = s;
-                else
-                    break;
+            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;
@@ -281,13 +283,24 @@ 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);
         }
@@ -338,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.13",
+  "version": "0.1.14",
   "description": "Launch self-improving coding agents in the cloud — the Kurtel CLI.",
   "type": "module",
   "bin": {