diffninja 0.1.0

package/dist/languages/swift.js

@@ -0,0 +1,268 @@
+import { heuristicCallSyntax } from "./call-syntax.js";
+import { childByType, collapseWs, locFromNode, namedChildren, } from "./types.js";
+function isPrivate(node) {
+    const mods = childByType(node, "modifiers");
+    if (!mods)
+        return false;
+    return /\bprivate\b|\bfileprivate\b/.test(mods.text);
+}
+function isLikelyTypeName(name) {
+    const c = name[0];
+    return c !== undefined && c === c.toUpperCase() && c !== c.toLowerCase();
+}
+function getParamsLabel(node) {
+    const params = namedChildren(node).filter((c) => c.type === "parameter");
+    if (params.length === 0)
+        return "()";
+    const names = [];
+    for (const p of params) {
+        // Prefer external/local simple_identifier; last id is usually the local name
+        const ids = namedChildren(p).filter((c) => c.type === "simple_identifier");
+        names.push(ids.at(-1)?.text ?? "_");
+    }
+    return `(${names.join(", ")})`;
+}
+function navigationProp(nav) {
+    const suffix = childByType(nav, "navigation_suffix");
+    const id = suffix ? childByType(suffix, "simple_identifier") : null;
+    return id?.text ?? null;
+}
+function calleeKey(node, className) {
+    if (node.type === "simple_identifier") {
+        if (isLikelyTypeName(node.text))
+            return `new ${node.text}`;
+        return node.text;
+    }
+    if (node.type === "navigation_expression") {
+        const object = node.namedChild(0);
+        const prop = navigationProp(node);
+        if (!object || !prop)
+            return null;
+        if (object.type === "self_expression" && className) {
+            return `${className}.${prop}`;
+        }
+        if (object.type === "simple_identifier") {
+            return `${object.text}.${prop}`;
+        }
+        if (className)
+            return `${className}.${prop}`;
+        return prop;
+    }
+    return null;
+}
+function statementsOf(body) {
+    if (!body)
+        return [];
+    if (body.type === "function_body") {
+        const stmts = childByType(body, "statements");
+        return stmts ? namedChildren(stmts) : [];
+    }
+    if (body.type === "statements")
+        return namedChildren(body);
+    return [body];
+}
+function collectStatements(file, statements, className) {
+    const steps = [];
+    const seen = new Set();
+    const addCall = (key, node) => {
+        const mark = `${key}:${node.startIndex}`;
+        if (seen.has(mark))
+            return;
+        seen.add(mark);
+        const step = { type: "call", key, ...locFromNode(file, node) };
+        step.syntax = heuristicCallSyntax(node, key);
+        steps.push(step);
+    };
+    const pushIfChain = (node, asElseIf) => {
+        const kids = namedChildren(node);
+        const stmtBlocks = kids.filter((c) => c.type === "statements");
+        const nestedIf = kids.find((c) => c.type === "if_statement") ?? null;
+        const cond = kids.find((c) => c.type !== "statements" &&
+            c.type !== "else" &&
+            c.type !== "if_statement") ?? null;
+        const condText = cond ? collapseWs(cond.text) : "";
+        const kind = asElseIf ? "else-if" : "if";
+        const labelKind = asElseIf ? "else if" : "if";
+        steps.push({
+            type: "branch",
+            key: condText ? `${kind}:${condText}` : kind,
+            label: condText ? `${labelKind} ${condText}` : labelKind,
+            ...locFromNode(file, cond ?? node),
+            children: collectStatements(file, statementsOf(stmtBlocks[0] ?? null), className),
+        });
+        if (nestedIf) {
+            pushIfChain(nestedIf, true);
+            return;
+        }
+        if (stmtBlocks[1]) {
+            steps.push({
+                type: "branch",
+                key: "else",
+                label: "else",
+                ...locFromNode(file, stmtBlocks[1]),
+                children: collectStatements(file, statementsOf(stmtBlocks[1]), className),
+            });
+        }
+    };
+    const walk = (node) => {
+        if (node.type === "function_declaration" ||
+            node.type === "init_declaration" ||
+            node.type === "class_declaration" ||
+            node.type === "lambda_literal") {
+            return;
+        }
+        if (node.type === "if_statement") {
+            pushIfChain(node, false);
+            return;
+        }
+        if (node.type === "do_statement") {
+            const doBody = childByType(node, "statements");
+            steps.push({
+                type: "branch",
+                key: "do",
+                label: "do",
+                ...locFromNode(file, node),
+                children: doBody
+                    ? collectStatements(file, namedChildren(doBody), className)
+                    : [],
+            });
+            for (const clause of namedChildren(node)) {
+                if (clause.type === "catch_block") {
+                    const body = childByType(clause, "statements");
+                    steps.push({
+                        type: "branch",
+                        key: "catch",
+                        label: "catch",
+                        ...locFromNode(file, clause),
+                        children: body
+                            ? collectStatements(file, namedChildren(body), className)
+                            : [],
+                    });
+                }
+            }
+            return;
+        }
+        if (node.type === "switch_statement") {
+            for (const entry of namedChildren(node)) {
+                if (entry.type !== "switch_entry")
+                    continue;
+                const pattern = childByType(entry, "switch_pattern");
+                const isDefault = namedChildren(entry).some((c) => c.type === "default_keyword");
+                const body = childByType(entry, "statements");
+                if (isDefault || !pattern) {
+                    steps.push({
+                        type: "branch",
+                        key: "default",
+                        label: "default",
+                        ...locFromNode(file, entry),
+                        children: body
+                            ? collectStatements(file, namedChildren(body), className)
+                            : [],
+                    });
+                }
+                else {
+                    const text = collapseWs(pattern.text);
+                    steps.push({
+                        type: "branch",
+                        key: text ? `case:${text}` : "case",
+                        label: text ? `case ${text}` : "case",
+                        ...locFromNode(file, pattern),
+                        children: body
+                            ? collectStatements(file, namedChildren(body), className)
+                            : [],
+                    });
+                }
+            }
+            return;
+        }
+        if (node.type === "call_expression") {
+            const callee = node.namedChild(0);
+            if (callee) {
+                const key = calleeKey(callee, className);
+                if (key)
+                    addCall(key, node);
+            }
+            for (const child of namedChildren(node).slice(1))
+                walk(child);
+            return;
+        }
+        // Unwrap try openIt() → still see the call
+        if (node.type === "try_expression") {
+            for (const child of namedChildren(node))
+                walk(child);
+            return;
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    for (const stmt of statements)
+        walk(stmt);
+    return steps;
+}
+function handleFunction(file, node, className, functions) {
+    const name = childByType(node, "simple_identifier")?.text ?? null;
+    if (!name)
+        return;
+    const body = childByType(node, "function_body");
+    const key = className ? `${className}.${name}` : name;
+    functions.push({
+        key,
+        label: `${key}${getParamsLabel(node)}`,
+        file,
+        steps: collectStatements(file, statementsOf(body), className),
+        exported: !isPrivate(node),
+        start: node.startIndex,
+        end: node.endIndex,
+    });
+}
+function handleInit(file, node, className, functions) {
+    const body = childByType(node, "function_body");
+    const info = {
+        key: `${className}.init`,
+        label: `${className}${getParamsLabel(node)}`,
+        file,
+        steps: collectStatements(file, statementsOf(body), className),
+        exported: !isPrivate(node),
+        start: node.startIndex,
+        end: node.endIndex,
+    };
+    functions.push(info);
+    functions.push({ ...info, key: `new ${className}` });
+}
+function handleClass(file, node, functions) {
+    const className = childByType(node, "type_identifier")?.text ?? null;
+    if (!className)
+        return;
+    const body = childByType(node, "class_body");
+    if (!body)
+        return;
+    for (const element of namedChildren(body)) {
+        if (element.type === "function_declaration") {
+            handleFunction(file, element, className, functions);
+        }
+        else if (element.type === "init_declaration") {
+            handleInit(file, element, className, functions);
+        }
+        else if (element.type === "class_declaration") {
+            handleClass(file, element, functions);
+        }
+    }
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    for (const stmt of namedChildren(tree.rootNode)) {
+        if (stmt.type === "function_declaration") {
+            handleFunction(file, stmt, null, functions);
+        }
+        else if (stmt.type === "class_declaration") {
+            handleClass(file, stmt, functions);
+        }
+    }
+    return functions;
+}
+export const swiftExtractor = {
+    id: "swift",
+    extensions: [".swift"],
+    grammarPackage: "tree-sitter-swift",
+    extract: extractFromTree,
+};

package/dist/languages/types.d.ts

@@ -0,0 +1,36 @@
+import type Parser from "tree-sitter";
+import type { DeclaredParams, FunctionInfo, SourceLoc } from "../types.js";
+export type SyntaxNode = Parser.SyntaxNode;
+export type Tree = Parser.Tree;
+export interface LanguageExtractor {
+    /** Stable id, e.g. "typescript" | "python" | "go" */
+    id: string;
+    /** File extensions including dot, lowercase */
+    extensions: string[];
+    /** npm package providing the tree-sitter grammar */
+    grammarPackage: string;
+    /** Named export on the grammar package, if any (e.g. "typescript", "tsx") */
+    grammarExport?: string;
+    extract(file: string, source: string, tree: Tree): FunctionInfo[];
+}
+export declare function namedChildren(node: SyntaxNode): SyntaxNode[];
+/**
+ * Whether two handles name the same syntax node. The native binding may return
+ * a fresh JS object for a node on each access, and whether it does depends on
+ * garbage collection, so `===` on nodes gives different answers from run to run.
+ * A node's id is stable within its tree.
+ */
+export declare function sameNode(a: SyntaxNode | null | undefined, b: SyntaxNode | null | undefined): boolean;
+export declare function childByType(node: SyntaxNode, type: string): SyntaxNode | null;
+export declare function collapseWs(text: string): string;
+/**
+ * Call-site / branch span for a syntax node.
+ * Uses tree-sitter 0-based rows → 1-based display lines.
+ */
+export declare function locFromNode(file: string, node: SyntaxNode): SourceLoc;
+/**
+ * Declared parameter list of a definition, read from the AST: the verbatim
+ * list text, with no slots. Text alone keeps argument binding `unknown`, which
+ * is what the extractors that do not build lexical scopes can honestly claim.
+ */
+export declare function declaredParamsOf(node: SyntaxNode): DeclaredParams | undefined;

package/dist/languages/types.js

@@ -0,0 +1,74 @@
+import { parameterText, textOnlyParams } from "./call-syntax.js";
+export function namedChildren(node) {
+    const out = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child)
+            out.push(child);
+    }
+    return out;
+}
+/**
+ * Whether two handles name the same syntax node. The native binding may return
+ * a fresh JS object for a node on each access, and whether it does depends on
+ * garbage collection, so `===` on nodes gives different answers from run to run.
+ * A node's id is stable within its tree.
+ */
+export function sameNode(a, b) {
+    return a !== null && a !== undefined && b !== null && b !== undefined && a.id === b.id;
+}
+export function childByType(node, type) {
+    return namedChildren(node).find((c) => c.type === type) ?? null;
+}
+export function collapseWs(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+/**
+ * Call-site / branch span for a syntax node.
+ * Uses tree-sitter 0-based rows → 1-based display lines.
+ */
+export function locFromNode(file, node) {
+    const line = node.startPosition.row + 1;
+    const endLine = node.endPosition.row + 1;
+    return endLine > line ? { file, line, endLine } : { file, line };
+}
+/**
+ * Parameter-list containers the grammars declare. A list is a direct child of
+ * the definition node, or of its declarator (`int callee(int param);`).
+ */
+const PARAMETER_CONTAINERS = {
+    formal_parameters: true,
+    parameters: true,
+    parameter_list: true,
+    method_parameters: true,
+    function_value_parameters: true,
+    lambda_parameters: true,
+    parameter_clause: true,
+};
+/** Nodes that hold a parameter list one level below the definition. */
+const PARAMETER_DECLARATORS = {
+    function_declarator: true,
+    declarator: true,
+    method_declarator: true,
+    call_signature: true,
+    function_declarator_body: true,
+};
+function namedChildrenTyped(node, types) {
+    return namedChildren(node).filter((child) => types[child.type] === true);
+}
+/**
+ * Declared parameter list of a definition, read from the AST: the verbatim
+ * list text, with no slots. Text alone keeps argument binding `unknown`, which
+ * is what the extractors that do not build lexical scopes can honestly claim.
+ */
+export function declaredParamsOf(node) {
+    const direct = namedChildrenTyped(node, PARAMETER_CONTAINERS)[0];
+    if (direct)
+        return textOnlyParams(parameterText(direct));
+    for (const declarator of namedChildrenTyped(node, PARAMETER_DECLARATORS)) {
+        const nested = namedChildrenTyped(declarator, PARAMETER_CONTAINERS)[0];
+        if (nested)
+            return textOnlyParams(parameterText(nested));
+    }
+    return undefined;
+}

package/dist/languages/typescript-contracts.d.ts

@@ -0,0 +1,57 @@
+/**
+ * TypeScript / TSX type contracts for review context.
+ *
+ * An interface, type alias, or enum is syntactic evidence about a shape, not a
+ * callable: the entries this helper adds carry `review.kind`, no steps, and the
+ * whole declaration span, and the extractor keeps them out of the callable
+ * index. What they *do* carry is `review.references`: the type names written in
+ * a definition's signature, body, or declaration — `Promise<Foo>`,
+ * `x as Bar`, `interface A extends B`, `foo<Baz>()`, `import("m").Q` — each
+ * with the module specifier and original name it was written through.
+ *
+ * {@link resolveTypeContracts} turns those references into snapshot-local
+ * edges. Relative imports bind to snapshot paths; a bare or aliased module
+ * path binds only when one snapshot file's path suffix matches it. Unresolved
+ * imports stay unresolved, even when another file has a unique same-named
+ * declaration. Unimported names prefer the same file, then a unique snapshot
+ * candidate. These are syntactic candidates, not TypeScript symbol resolution.
+ *
+ * Every step is derived from the source and the snapshot declarations, so the
+ * same input always yields the same edges.
+ *
+ * Deliberate limits: only module-level declarations are extracted; references
+ * in module-level value code, class field annotations, and heritage clauses
+ * belong to no definition and are dropped; re-export/barrel hops are not
+ * followed; a default import is matched by its local binding name; a
+ * declaration that names itself is not an edge. External types absent from
+ * the snapshot remain unresolved.
+ */
+import type Parser from "tree-sitter";
+import type { FunctionInfo } from "../types.js";
+type Tree = Parser.Tree;
+/**
+ * Record the type contracts of one file: append a non-callable definition per
+ * interface / type alias / enum, then attach each written reference to the
+ * innermost definition (callable or contract) whose span contains it. A
+ * reference in module-level code that belongs to no definition is left out
+ * rather than credited to a sibling.
+ */
+export declare function extractTypeContracts(file: string, tree: Tree, functions: FunctionInfo[]): void;
+/** One `owner -> target` type-contract relation for the context graph. */
+export interface TypeContractEdge {
+    owner: FunctionInfo;
+    target: FunctionInfo;
+    evidence: string;
+    kind: "contract";
+    /** 1-based line of the written reference, not of either definition. */
+    line: number;
+}
+/**
+ * Resolve one reference against the snapshot. A relative specifier must name a
+ * snapshot file (exact binding); a bare or aliased specifier binds only when
+ * exactly one snapshot file's path ends with its tail; a name written without a
+ * module binds to the file's own declaration. Only a name no module explains
+ * may fall back to a globally unique declaration.
+ */
+export declare function resolveTypeContracts(functions: readonly FunctionInfo[]): TypeContractEdge[];
+export {};