brito-cli 0.0.0-stage → 0.3.2

package/dist/graph/langs.js

@@ -0,0 +1,526 @@
+import fs from "node:fs";
+import path from "node:path";
+export const EXTRA_EXT = {
+    ".java": "java", ".kt": "kotlin", ".go": "go", ".rb": "ruby", ".php": "php", ".cs": "c_sharp", ".rs": "rust",
+};
+export const isExtraLang = (l) => l in HOOKS;
+const f = (n, name) => n.childForFieldName(name);
+const nameOf = (n) => f(n, "name")?.text || null;
+const lastSeg = (s) => s.split(/[.\\/:]+/).filter(Boolean).pop() ?? s;
+const SELF_TYPES = new Set(["this", "this_expression", "self"]);
+const IDENT_TYPES = new Set(["identifier", "simple_identifier", "constant", "type_identifier", "name", "field_identifier", "property_identifier"]);
+/** x.y / x->y / x::y: separa a base do nome do membro, em qualquer gramática. */
+function member(n) {
+    switch (n.type) {
+        case "field_access": {
+            const b = f(n, "object"), m = f(n, "field");
+            return b && m ? { base: b, name: m.text } : null;
+        }
+        case "member_access_expression":
+        case "nullsafe_member_access_expression": {
+            const b = f(n, "object") ?? f(n, "expression"), m = f(n, "name");
+            return b && m ? { base: b, name: m.text } : null;
+        }
+        case "field_expression": {
+            const b = f(n, "value"), m = f(n, "field");
+            return b && m ? { base: b, name: m.text } : null;
+        }
+        case "selector_expression": {
+            const b = f(n, "operand"), m = f(n, "field");
+            return b && m ? { base: b, name: m.text } : null;
+        }
+        case "navigation_expression": {
+            const b = n.namedChild(0), m = n.namedChildren.filter((c) => c.type === "navigation_suffix").pop()?.namedChild(0);
+            return b && m ? { base: b, name: m.text } : null;
+        }
+    }
+    return null;
+}
+const isSelf = (n, self) => SELF_TYPES.has(n.type) || n.text === "$this" || (!!self && n.type === "identifier" && n.text === self);
+/** O "obj" de uma chamada: this, o nome da variável/tipo, o nome do campo (this.repo.x() → "repo") ou "?". */
+function objOf(o, self) {
+    if (!o)
+        return "";
+    if (isSelf(o, self))
+        return "this";
+    if (IDENT_TYPES.has(o.type) || o.type === "variable_name")
+        return o.text.replace(/^\$/, "");
+    if (o.type === "scoped_identifier" || o.type === "qualified_name" || o.type === "scope_resolution")
+        return lastSeg(o.text);
+    const m = member(o);
+    if (m && isSelf(m.base, self))
+        return m.name;
+    return "?";
+}
+function ofTypes(map) {
+    return (n) => {
+        const kind = map[n.type];
+        const name = kind ? nameOf(n) : null;
+        return name ? { name, kind } : null;
+    };
+}
+// ───────────── Java ─────────────
+const java = {
+    implicitSelf: true,
+    type: ofTypes({ class_declaration: "class", interface_declaration: "interface", enum_declaration: "enum", record_declaration: "class", annotation_type_declaration: "interface" }),
+    func: (n) => (n.type === "method_declaration" || n.type === "constructor_declaration") && nameOf(n) ? { name: nameOf(n) } : null,
+    call: (n, self) => {
+        if (n.type !== "method_invocation")
+            return null;
+        const name = nameOf(n);
+        return name ? { name, obj: objOf(f(n, "object"), self) } : null;
+    },
+    imports: (n, acc) => {
+        if (n.type !== "import_declaration")
+            return;
+        const id = n.namedChildren.find((c) => c.type === "scoped_identifier" || c.type === "identifier");
+        if (!id)
+            return;
+        acc.imports.push(id.text);
+        if (!n.children.some((c) => c.type === "asterisk"))
+            acc.bindings.push([lastSeg(id.text), id.text, lastSeg(id.text)]);
+    },
+};
+// ───────────── Kotlin ─────────────
+const kotlin = {
+    implicitSelf: true,
+    type: (n) => {
+        if (n.type !== "class_declaration" && n.type !== "object_declaration")
+            return null;
+        const name = n.namedChildren.find((c) => c.type === "type_identifier")?.text;
+        if (!name)
+            return null;
+        const kind = n.children.some((c) => c.type === "interface") ? "interface" : /\benum\b/.test(n.namedChildren.find((c) => c.type === "modifiers")?.text ?? "") ? "enum" : "class";
+        return { name, kind };
+    },
+    func: (n) => {
+        const name = n.type === "function_declaration" ? n.namedChildren.find((c) => c.type === "simple_identifier")?.text : null;
+        return name ? { name } : null;
+    },
+    call: (n, self) => {
+        if (n.type !== "call_expression")
+            return null;
+        const callee = n.namedChild(0);
+        if (!callee)
+            return null;
+        if (callee.type === "simple_identifier")
+            return { name: callee.text, obj: "" };
+        const m = member(callee);
+        return m ? { name: m.name, obj: objOf(m.base, self) } : null;
+    },
+    imports: (n, acc) => {
+        if (n.type !== "import_header")
+            return;
+        const id = n.namedChildren.find((c) => c.type === "identifier");
+        if (!id)
+            return;
+        acc.imports.push(id.text);
+        if (!n.text.includes("*")) {
+            const alias = n.namedChildren.find((c) => c.type === "import_alias")?.namedChild(0)?.text;
+            acc.bindings.push([alias ?? lastSeg(id.text), id.text, lastSeg(id.text)]);
+        }
+    },
+};
+// ───────────── Go ─────────────
+/** Nome do tipo do receiver: `(s *Service)` → "Service". */
+function goReceiver(n) {
+    const p = f(n, "receiver")?.namedChildren.find((c) => c.type === "parameter_declaration");
+    if (!p)
+        return null;
+    let t = f(p, "type");
+    while (t && t.type !== "type_identifier")
+        t = t.namedChild(0);
+    return t ? { type: t.text, self: f(p, "name")?.text ?? null } : null;
+}
+const go = {
+    implicitSelf: false,
+    type: (n) => {
+        if (n.type !== "type_spec" && n.type !== "type_alias")
+            return null;
+        const name = nameOf(n);
+        if (!name)
+            return null;
+        const t = f(n, "type")?.type;
+        return { name, kind: t === "struct_type" ? "struct" : t === "interface_type" ? "interface" : "type" };
+    },
+    func: (n) => {
+        const name = nameOf(n);
+        if (!name)
+            return null;
+        if (n.type === "function_declaration")
+            return { name };
+        if (n.type !== "method_declaration")
+            return null;
+        const r = goReceiver(n);
+        return { name, cls: r?.type, self: r?.self ?? null };
+    },
+    call: (n, self) => {
+        if (n.type !== "call_expression")
+            return null;
+        const fn = f(n, "function");
+        if (!fn)
+            return null;
+        if (fn.type === "identifier")
+            return { name: fn.text, obj: "" };
+        const m = member(fn);
+        return m ? { name: m.name, obj: objOf(m.base, self) } : null;
+    },
+    imports: (n, acc) => {
+        if (n.type !== "import_spec")
+            return;
+        const spec = f(n, "path")?.text.replace(/^["`]|["`]$/g, "");
+        if (!spec)
+            return;
+        acc.imports.push(spec);
+        const alias = f(n, "name")?.text;
+        if (alias === "_" || alias === ".")
+            return;
+        const segs = spec.split("/");
+        const last = /^v\d+$/.test(segs[segs.length - 1]) && segs.length > 1 ? segs[segs.length - 2] : segs[segs.length - 1];
+        acc.bindings.push([alias ?? last.replace(/^go-|\.go$/g, "").replace(/[.-].*$/, ""), spec, "*"]);
+    },
+};
+// ───────────── Ruby ─────────────
+const RUBY_SKIP = new Set(["require", "require_relative", "load", "include", "extend", "prepend", "attr_accessor", "attr_reader", "attr_writer", "private", "public", "protected", "module_function", "raise", "puts", "p", "print"]);
+const ruby = {
+    implicitSelf: true,
+    type: (n) => {
+        if (n.type !== "class" && n.type !== "module")
+            return null;
+        const name = f(n, "name");
+        return name ? { name: lastSeg(name.text), kind: n.type === "module" ? "module" : "class" } : null;
+    },
+    func: (n) => (n.type === "method" || n.type === "singleton_method") && nameOf(n) ? { name: nameOf(n) } : null,
+    call: (n, self) => {
+        if (n.type !== "call")
+            return null;
+        const name = f(n, "method")?.text;
+        if (!name)
+            return null;
+        const recv = f(n, "receiver");
+        if (!recv && RUBY_SKIP.has(name))
+            return null;
+        return { name, obj: objOf(recv, self) };
+    },
+    imports: (n, acc) => {
+        if (n.type !== "call" || f(n, "receiver"))
+            return;
+        const m = f(n, "method")?.text;
+        if (m !== "require" && m !== "require_relative" && m !== "load")
+            return;
+        const arg = f(n, "arguments")?.namedChild(0);
+        const spec = arg?.type === "string" ? arg.namedChildren.find((c) => c.type === "string_content")?.text : null;
+        if (spec)
+            acc.imports.push(m === "require_relative" ? (spec.startsWith(".") ? spec : "./" + spec) : spec);
+    },
+};
+// ───────────── PHP ─────────────
+const php = {
+    implicitSelf: false,
+    type: ofTypes({ class_declaration: "class", interface_declaration: "interface", trait_declaration: "trait", enum_declaration: "enum" }),
+    func: (n) => (n.type === "method_declaration" || n.type === "function_definition") && nameOf(n) ? { name: nameOf(n) } : null,
+    call: (n, self) => {
+        switch (n.type) {
+            case "function_call_expression": {
+                const fn = f(n, "function");
+                return fn && (fn.type === "name" || fn.type === "qualified_name") ? { name: lastSeg(fn.text), obj: "" } : null;
+            }
+            case "member_call_expression":
+            case "nullsafe_member_call_expression": {
+                const name = nameOf(n);
+                return name ? { name, obj: objOf(f(n, "object"), self) } : null;
+            }
+            case "scoped_call_expression": {
+                const name = nameOf(n), scope = f(n, "scope");
+                if (!name || !scope)
+                    return null;
+                return { name, obj: scope.type === "relative_scope" ? "this" : lastSeg(scope.text) };
+            }
+        }
+        return null;
+    },
+    imports: (n, acc) => {
+        if (n.type !== "namespace_use_declaration")
+            return;
+        const add = (spec, alias) => {
+            spec = spec.replace(/^\\/, "");
+            acc.imports.push(spec);
+            acc.bindings.push([alias ?? lastSeg(spec), spec, lastSeg(spec)]);
+        };
+        const aliasOf = (c) => c.namedChildren.find((x) => x.type === "namespace_aliasing_clause")?.namedChild(0)?.text;
+        const group = n.namedChildren.find((c) => c.type === "namespace_use_group");
+        if (group) {
+            const prefix = n.namedChildren.find((c) => c.type === "namespace_name")?.text.replace(/\\$/, "") ?? "";
+            for (const c of group.namedChildren) {
+                const nm = c.namedChildren.find((x) => x.type === "namespace_name" || x.type === "name" || x.type === "qualified_name");
+                if (nm)
+                    add(`${prefix}\\${nm.text}`, aliasOf(c));
+            }
+            return;
+        }
+        for (const c of n.namedChildren.filter((x) => x.type === "namespace_use_clause")) {
+            const q = c.namedChildren.find((x) => x.type === "qualified_name" || x.type === "name");
+            if (q)
+                add(q.text, aliasOf(c));
+        }
+    },
+};
+// ───────────── C# ─────────────
+const csharp = {
+    implicitSelf: true,
+    type: ofTypes({ class_declaration: "class", interface_declaration: "interface", struct_declaration: "struct", record_declaration: "class", record_struct_declaration: "struct", enum_declaration: "enum" }),
+    func: (n) => (n.type === "method_declaration" || n.type === "constructor_declaration" || n.type === "local_function_statement") && nameOf(n) ? { name: nameOf(n) } : null,
+    call: (n, self) => {
+        if (n.type !== "invocation_expression")
+            return null;
+        const fn = f(n, "function");
+        if (!fn)
+            return null;
+        if (fn.type === "identifier")
+            return { name: fn.text, obj: "" };
+        if (fn.type === "generic_name")
+            return { name: fn.namedChild(0)?.text ?? fn.text, obj: "" };
+        const m = member(fn);
+        return m ? { name: m.name.replace(/<.*$/, ""), obj: objOf(m.base, self) } : null;
+    },
+    imports: (n, acc) => {
+        if (n.type !== "using_directive")
+            return;
+        const id = n.namedChildren.filter((c) => c.type === "identifier" || c.type === "qualified_name").pop();
+        if (id && !n.namedChildren.some((c) => c.type === "name_equals"))
+            acc.imports.push(id.text);
+    },
+};
+// ───────────── Rust ─────────────
+function rustTypeName(t) {
+    for (let i = 0; t && i < 6; i++) {
+        if (t.type === "type_identifier")
+            return t.text;
+        t = f(t, "type") ?? f(t, "name") ?? t.namedChild(0);
+    }
+    return null;
+}
+function rustUses(a, prefix, out) {
+    switch (a.type) {
+        case "scoped_use_list": {
+            const p = prefix.concat(f(a, "path")?.text.split("::") ?? []);
+            for (const c of f(a, "list")?.namedChildren ?? [])
+                rustUses(c, p, out);
+            break;
+        }
+        case "use_as_clause":
+            out.push({ path: prefix.concat(f(a, "path")?.text.split("::") ?? []), alias: f(a, "alias")?.text });
+            break;
+        case "use_wildcard":
+            out.push({ path: prefix.concat(a.text.replace(/\*$/, "").split("::").filter(Boolean)), wildcard: true });
+            break;
+        case "identifier":
+        case "scoped_identifier":
+        case "self":
+        case "crate":
+            out.push({ path: prefix.concat(a.text.split("::")) });
+            break;
+    }
+}
+const rust = {
+    implicitSelf: false,
+    type: ofTypes({ struct_item: "struct", enum_item: "enum", trait_item: "trait", union_item: "struct" }),
+    scope: (n) => (n.type === "impl_item" ? rustTypeName(f(n, "type")) : null),
+    func: (n) => (n.type === "function_item" || n.type === "function_signature_item") && nameOf(n) ? { name: nameOf(n) } : null,
+    call: (n, self) => {
+        if (n.type !== "call_expression")
+            return null;
+        let fn = f(n, "function");
+        if (fn?.type === "generic_function")
+            fn = f(fn, "function");
+        if (!fn)
+            return null;
+        if (fn.type === "identifier")
+            return { name: fn.text, obj: "" };
+        if (fn.type === "scoped_identifier") {
+            const name = nameOf(fn), owner = lastSeg(f(fn, "path")?.text ?? "");
+            if (!name)
+                return null;
+            // Tipo::f() é método associado; modulo::f() é função solta.
+            return { name, obj: owner === "Self" ? "this" : /^[A-Z]/.test(owner) ? owner : "" };
+        }
+        const m = member(fn);
+        return m ? { name: m.name, obj: objOf(m.base, self) } : null;
+    },
+    imports: (n, acc) => {
+        if (n.type !== "use_declaration")
+            return;
+        const arg = f(n, "argument");
+        if (!arg)
+            return;
+        const uses = [];
+        rustUses(arg, [], uses);
+        for (const u of uses) {
+            if (u.path[u.path.length - 1] === "self")
+                u.path.pop();
+            if (!u.path.length)
+                continue;
+            const spec = u.path.join("::");
+            acc.imports.push(spec);
+            if (!u.wildcard)
+                acc.bindings.push([u.alias ?? u.path[u.path.length - 1], spec, u.path[u.path.length - 1]]);
+        }
+    },
+};
+const HOOKS = { java, kotlin, go, ruby, php, c_sharp: csharp, rust };
+export function extractLang(root, lang, file) {
+    const h = HOOKS[lang];
+    const syms = [], calls = [];
+    const acc = { imports: [], bindings: [] };
+    const mk = (name, kind, n) => {
+        const s = { id: `${file}::${name}:${n.startPosition.row + 1}`, name, kind, file, startLine: n.startPosition.row + 1, endLine: n.endPosition.row + 1 };
+        syms.push(s);
+        return s;
+    };
+    const walk = (n, owner, cls, self) => {
+        let nextOwner = owner, nextCls = cls, nextSelf = self;
+        const t = h.type?.(n);
+        if (t) {
+            nextOwner = mk(t.name, t.kind, n);
+            nextCls = t.name;
+        }
+        else {
+            const sc = h.scope?.(n);
+            if (sc)
+                nextCls = sc;
+            const fn = h.func?.(n);
+            if (fn) {
+                const c = fn.cls ?? cls;
+                nextOwner = mk(c ? `${c}.${fn.name}` : fn.name, c ? "method" : "function", n);
+                if (fn.cls)
+                    nextCls = fn.cls;
+                if (fn.self !== undefined)
+                    nextSelf = fn.self;
+            }
+        }
+        const c = h.call?.(n, nextSelf);
+        if (c && nextOwner)
+            calls.push({ callerId: nextOwner.id, callee: c.name, obj: !c.obj && h.implicitSelf && nextCls ? "@" : c.obj, file });
+        h.imports?.(n, acc);
+        for (const ch of n.namedChildren)
+            walk(ch, nextOwner, nextCls, nextSelf);
+    };
+    walk(root, null, null, null);
+    return { syms, calls, imports: acc.imports, bindings: acc.bindings };
+}
+const FAMILY = { ".java": "jvm", ".kt": "jvm", ".go": "go", ".rb": "ruby", ".php": "php", ".cs": "cs", ".rs": "rust" };
+const MAX_TARGETS = 40;
+/**
+ * Nessas linguagens o import nomeia um pacote/namespace/módulo, não um caminho. O índice casa o especificador com o
+ * final do caminho dos arquivos do projeto (com.acme.Repo ↔ src/main/java/com/acme/Repo.java), sem depender de
+ * convenção de build. Pacote externo (java.util, serde, github.com/gin-gonic/gin) não casa com nada e volta [].
+ */
+export class ProjectIndex {
+    root;
+    known;
+    files = new Map();
+    dirs = new Map();
+    dirsFull = new Map();
+    goModule = null;
+    constructor(root, known) {
+        this.root = root;
+        this.known = known;
+        for (const file of known) {
+            const ext = path.posix.extname(file);
+            if (!FAMILY[ext])
+                continue;
+            let base = file.slice(0, -ext.length).toLowerCase();
+            if (ext === ".rs" && base.endsWith("/mod"))
+                base = base.slice(0, -4);
+            this.addSuffixes(this.files, base, file);
+            const dir = path.posix.dirname(file).toLowerCase();
+            if (dir !== ".")
+                this.addSuffixes(this.dirs, dir, file);
+            (this.dirsFull.get(dir) ?? this.dirsFull.set(dir, new Set()).get(dir)).add(file);
+        }
+        try {
+            this.goModule = fs.readFileSync(path.join(root, "go.mod"), "utf8").match(/^module\s+(\S+)/m)?.[1] ?? null;
+        }
+        catch { /* sem go.mod */ }
+    }
+    addSuffixes(map, p, file) {
+        const segs = p.split("/");
+        for (let i = 0; i < segs.length; i++) {
+            const k = segs.slice(i).join("/");
+            (map.get(k) ?? map.set(k, new Set()).get(k)).add(file);
+        }
+    }
+    /** Tenta o especificador inteiro e depois sem os últimos (membro/classe aninhada) e os primeiros (prefixo raiz) segmentos. */
+    find(map, parts, fam, p) {
+        const minLen = p.minLen ?? (parts.length >= 2 ? 2 : 1);
+        const keys = parts.map((x) => x.toLowerCase());
+        for (let t = 0; t <= p.trail; t++) {
+            for (let l = 0; l <= p.lead && keys.length - t - l >= minLen; l++) {
+                const hit = [...(map.get(keys.slice(l, keys.length - t).join("/")) ?? [])].filter((x) => FAMILY[path.posix.extname(x)] === fam && !x.endsWith("_test.go"));
+                if (hit.length)
+                    return hit;
+            }
+        }
+        return [];
+    }
+    /** null = o arquivo de origem não é de uma linguagem tratada aqui (quem resolve é o resolveImport de TS/Python). */
+    resolve(from, spec) {
+        const fam = FAMILY[path.posix.extname(from)];
+        if (!fam)
+            return null;
+        let hits = [];
+        switch (fam) {
+            case "jvm": {
+                const parts = spec.split(".");
+                hits = this.find(this.files, parts, fam, { trail: 2, lead: 0 });
+                if (!hits.length)
+                    hits = this.find(this.dirs, parts, fam, { trail: 1, lead: 0 });
+                break;
+            }
+            case "php":
+                hits = this.find(this.files, spec.replace(/^\\/, "").split("\\"), fam, { trail: 0, lead: 3 });
+                break;
+            case "cs": {
+                const parts = spec.split(".");
+                hits = this.find(this.dirs, parts, fam, { trail: 0, lead: 2 });
+                if (!hits.length)
+                    hits = this.find(this.files, parts, fam, { trail: 1, lead: 2 });
+                break;
+            }
+            case "rust": {
+                const parts = spec.split("::");
+                while (["crate", "self", "super"].includes(parts[0]))
+                    parts.shift();
+                if (!parts.length || ["std", "core", "alloc"].includes(parts[0]))
+                    break;
+                hits = this.find(this.files, parts, fam, { trail: 2, lead: 0, minLen: 1 });
+                break;
+            }
+            case "ruby": {
+                if (spec.startsWith(".")) {
+                    const base = path.posix.normalize(path.posix.join(path.posix.dirname(from), spec)).replace(/\.rb$/, "") + ".rb";
+                    hits = this.known.has(base) ? [base] : [];
+                }
+                else
+                    hits = this.find(this.files, spec.replace(/\.rb$/, "").split("/"), fam, { trail: 0, lead: 0 });
+                break;
+            }
+            case "go": {
+                const m = this.goModule;
+                if (m && (spec === m || spec.startsWith(m + "/"))) {
+                    const rel = (spec === m ? "." : spec.slice(m.length + 1)).toLowerCase();
+                    hits = [...(this.dirsFull.get(rel) ?? [])].filter((x) => !x.endsWith("_test.go") && x.endsWith(".go"));
+                    if (!hits.length)
+                        hits = this.find(this.dirs, rel.split("/"), fam, { trail: 0, lead: 0, minLen: 1 });
+                }
+                else if (!m)
+                    hits = this.find(this.dirs, spec.split("/"), fam, { trail: 0, lead: 4 });
+                break;
+            }
+        }
+        return hits.slice(0, MAX_TARGETS);
+    }
+}
+// Para suportar outra linguagem (Scala, Swift, Elixir…): 1) acrescente a extensão em EXTRA_EXT e ExtraLang (a gramática
+// precisa existir em tree-sitter-wasms/out); 2) escreva os hooks (use scripts de dump da AST para achar os tipos de nó);
+// 3) registre-os em HOOKS e a família de resolução em FAMILY/ProjectIndex.resolve.

package/dist/graph/sfc.js

@@ -0,0 +1,52 @@
+// Componentes de arquivo único (.svelte, .vue, .astro): para o parser só o(s) bloco(s) de script é código;
+// o resto é template e estilo. Tudo fora do script vira espaço (as quebras de linha ficam), então a linha de
+// cada símbolo no grafo é a linha real do arquivo.
+export const SFC_EXT = new Set([".svelte", ".vue", ".astro"]);
+const blank = (s) => s.replace(/[^\r\n]/g, " ");
+/** `<script type="application/json">`, `text/template`… não são código. */
+const JS_TYPES = /^(module|(text|application)\/(javascript|typescript|ecmascript))$/;
+export function splitSfc(src, ext) {
+    const ranges = [];
+    let tsx = false;
+    for (const m of src.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script\s*>/gi)) {
+        const attrs = m[1] ?? "";
+        const type = /\btype\s*=\s*["']?([^"'\s>]+)/i.exec(attrs)?.[1]?.toLowerCase();
+        if (type && !JS_TYPES.test(type))
+            continue;
+        if (/\blang\s*=\s*["']?tsx\b/i.test(attrs))
+            tsx = true;
+        const start = m.index + m[0].indexOf(">") + 1;
+        ranges.push([start, start + m[2].length]);
+    }
+    // Astro: o código do servidor fica no frontmatter (--- … ---) no topo do arquivo.
+    if (ext === ".astro") {
+        const fm = /^(\s*---[ \t]*\r?\n)([\s\S]*?)(\r?\n---)/.exec(src);
+        if (fm)
+            ranges.push([fm[1].length, fm[1].length + fm[2].length]);
+    }
+    ranges.sort((a, b) => a[0] - b[0]);
+    let script = "", template = "", pos = 0;
+    for (const [s, e] of ranges) {
+        if (s < pos)
+            continue; // sobreposição (ex.: "<script>" citado dentro do frontmatter)
+        script += blank(src.slice(pos, s)) + src.slice(s, e);
+        template += src.slice(pos, s) + blank(src.slice(s, e));
+        pos = e;
+    }
+    script += blank(src.slice(pos));
+    template += src.slice(pos);
+    template = template.replace(/<style\b[\s\S]*?<\/style\s*>|<!--[\s\S]*?-->/gi, blank);
+    return { script, template, tsx };
+}
+/**
+ * Chamadas feitas no markup (`{formatar(x)}`, `onclick={() => salvar()}`). Só conta nome que o script declara
+ * ou importa (`known`): assim `class="a (b)"` ou texto solto não viram aresta, e nada cai na heurística por nome.
+ */
+export function templateCalleeNames(template, known) {
+    const out = new Set();
+    for (const m of template.matchAll(/(?<![\w$.#])([A-Za-z_$][\w$]*)\s*\(/g))
+        if (known.has(m[1]))
+            out.add(m[1]);
+    return [...out];
+}
+export const componentName = (rel) => rel.slice(rel.lastIndexOf("/") + 1).replace(/\.[^.]+$/, "");

package/dist/graph/store.js

@@ -0,0 +1,96 @@
+import kuzu from "kuzu";
+import fs from "node:fs";
+import path from "node:path";
+/** Lê as linhas e fecha cada QueryResult na hora: o finalizer do GC depois de db.close() derruba o processo (segfault). */
+async function drain(r, read = true) {
+    const all = Array.isArray(r) ? r : [r];
+    try {
+        return read ? await all[all.length - 1].getAll() : [];
+    }
+    finally {
+        for (const x of all)
+            x.close();
+    }
+}
+/** Outro processo do Brito está com o banco aberto: o Kùzu só deixa um processo por projeto. */
+export class GraphLockedError extends Error {
+    constructor(file) {
+        super(`O grafo deste projeto está em uso por outro processo do Brito (${file}).\n` +
+            "O banco aceita um processo por vez: provavelmente há outro terminal com o Brito, ou uma sessão do Claude Code usando o Brito, neste mesmo diretório.\n" +
+            "Feche o outro, ou espere o turno em andamento terminar, e tente de novo.");
+        this.name = "GraphLockedError";
+    }
+}
+const isLockError = (e) => /could not set lock/i.test(String(e?.message ?? e));
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Quanto esperar o banco liberar antes de desistir: cobre sobreposições curtas (a reflexão de skills e o turno, por exemplo). */
+const LOCK_WAIT_MS = 4000;
+export class GraphStore {
+    db;
+    conn;
+    queue = Promise.resolve();
+    constructor(db, conn) {
+        this.db = db;
+        this.conn = conn;
+    }
+    static async open(root, waitMs = LOCK_WAIT_MS) {
+        const dir = path.join(root, ".brito");
+        fs.mkdirSync(dir, { recursive: true });
+        const file = path.join(dir, "graph.kuzu");
+        const deadline = Date.now() + waitMs;
+        for (;;) {
+            try {
+                const db = new kuzu.Database(file);
+                const store = new GraphStore(db, new kuzu.Connection(db));
+                await store.migrate();
+                return store;
+            }
+            catch (e) {
+                if (!isLockError(e))
+                    throw e;
+                if (Date.now() >= deadline)
+                    throw new GraphLockedError(file);
+                await sleep(250);
+            }
+        }
+    }
+    async migrate() {
+        const ddl = [
+            "CREATE NODE TABLE IF NOT EXISTS File(path STRING, lang STRING, hash STRING, calls STRING[], imports STRING[], bindings STRING[], PRIMARY KEY(path))",
+            "CREATE NODE TABLE IF NOT EXISTS Symbol(id STRING, name STRING, kind STRING, file STRING, startLine INT64, endLine INT64, PRIMARY KEY(id))",
+            "CREATE NODE TABLE IF NOT EXISTS Note(id STRING, kind STRING, text STRING, refs STRING[], ts INT64, PRIMARY KEY(id))",
+            "CREATE REL TABLE IF NOT EXISTS DEFINES(FROM File TO Symbol)",
+            "CREATE REL TABLE IF NOT EXISTS CALLS(FROM Symbol TO Symbol)",
+            "CREATE REL TABLE IF NOT EXISTS IMPORTS(FROM File TO File)",
+        ];
+        for (const q of ddl)
+            await drain(await this.conn.query(q), false);
+        // Bancos criados antes do indexador incremental não têm estas colunas.
+        for (const col of ["calls", "imports", "bindings"])
+            await drain(await this.conn.query(`ALTER TABLE File ADD IF NOT EXISTS ${col} STRING[] DEFAULT []`), false);
+    }
+    /** Serializa as queries: leituras paralelas de subagentes dividem uma única Connection. */
+    run(cypher, params = {}) {
+        const next = this.queue.then(() => this.exec(cypher, params));
+        this.queue = next.catch(() => undefined);
+        return next;
+    }
+    async exec(cypher, params) {
+        if (Object.keys(params).length === 0) {
+            return drain(await this.conn.query(cypher));
+        }
+        const ps = await this.conn.prepare(cypher);
+        if (!ps.isSuccess())
+            throw new Error(ps.getErrorMessage());
+        return drain(await this.conn.execute(ps, params));
+    }
+    /** Apaga só o grafo de código; notas (memória) são preservadas. */
+    async clearCode() {
+        await this.run("MATCH (s:Symbol) DETACH DELETE s");
+        await this.run("MATCH (f:File) DETACH DELETE f");
+    }
+    async close() {
+        await this.conn.close();
+        await this.db.close();
+    }
+}