jev-agent-tools 0.1.4 → 0.3.0

package/dist/adapters/ask-syntax.js

@@ -0,0 +1,385 @@
+import { loadSyntaxRootParser } from "./syntax.js";
+function nodes(root, kinds) {
+    const result = [];
+    for (const kind of kinds) {
+        try {
+            result.push(...root.findAll({ rule: { kind } }));
+        }
+        catch {
+            /* Node kinds differ across the supported language grammars. */
+        }
+    }
+    return result
+        .map((node) => ({ node, index: node.range().start.index }))
+        .sort((a, b) => a.index - b.index)
+        .map((entry) => entry.node);
+}
+function names(root, includeTypes = true) {
+    const result = new Set();
+    const excluded = nodes(root, [
+        "import_statement",
+        "import_from_statement",
+        "export_clause",
+    ]).map((node) => node.range());
+    const typeScopes = [];
+    if (includeTypes) {
+        for (const binder of nodes(root, [
+            "type_parameter",
+            "infer_type",
+            "mapped_type_clause",
+        ])) {
+            const name = binder.field("name") ??
+                binder.children().find((node) => node.kind() === "type_identifier");
+            let scope = binder.parent();
+            if (binder.kind() === "type_parameter")
+                scope = scope?.parent() ?? null;
+            if (binder.kind() === "infer_type") {
+                while (scope && scope.kind() !== "conditional_type")
+                    scope = scope.parent();
+                const own = name?.range();
+                if (name && own)
+                    typeScopes.push({
+                        name: name.text(),
+                        start: own.start.index,
+                        end: own.end.index,
+                    });
+                scope = scope?.field("consequence") ?? null;
+            }
+            if (name && scope) {
+                const range = scope.range();
+                typeScopes.push({
+                    name: name.text(),
+                    start: range.start.index,
+                    end: range.end.index,
+                });
+            }
+        }
+    }
+    for (const node of nodes(root, [
+        "identifier",
+        "type_identifier",
+        "nested_type_identifier",
+        "member_expression",
+        "attribute",
+    ])) {
+        const position = node.range().start.index;
+        if (node.kind() === "type_identifier") {
+            if (!includeTypes ||
+                node.parent()?.kind() === "nested_type_identifier" ||
+                typeScopes.some((scope) => scope.name === node.text() &&
+                    position >= scope.start &&
+                    position < scope.end))
+                continue;
+        }
+        if (!includeTypes && node.kind() === "nested_type_identifier")
+            continue;
+        if (excluded.some((range) => position >= range.start.index && position < range.end.index))
+            continue;
+        if (node.kind() === "identifier" || node.kind() === "type_identifier")
+            result.add(node.text());
+        else {
+            const owner = node.field("object") ?? node.field("module");
+            const property = node.field("property") ?? node.field("attribute") ?? node.field("name");
+            if (owner && property)
+                result.add(`${owner.text()}.${property.text()}`);
+        }
+    }
+    return [...result];
+}
+function literal(node) {
+    if (!node || !["string", "string_literal"].includes(String(node.kind())))
+        return undefined;
+    const fragments = nodes(node, ["string_fragment", "string_content"]);
+    if (nodes(node, ["interpolation", "escape_sequence"]).length)
+        return undefined;
+    return fragments.map((fragment) => fragment.text()).join("");
+}
+/** Collect AST metadata only; repository resolution remains in the shared I8 graph. */
+export async function collectProofSyntax(files, before, sourceParser) {
+    const declarations = [];
+    const bindings = [];
+    const limits = [];
+    const uses = new Map();
+    const parser = sourceParser ?? (await loadSyntaxRootParser());
+    for (const file of files) {
+        if (!parser?.supports(file.path)) {
+            limits.push({
+                fact: `${file.path} : unsupported language${/\.[cm]?[jt]sx?$|\.py$/.test(file.path) ? ", optional parser unavailable" : ""}`,
+                next: "Install the language parser or provide the required declarations.",
+            });
+            continue;
+        }
+        const python = file.path.endsWith(".py");
+        const parsed = parser.parseRaw(file.path, file.text);
+        if (!parsed.ok) {
+            limits.push({
+                fact: `${file.path}: parse_failed`,
+                next: "read the complete source and check its syntax",
+            });
+            continue;
+        }
+        const root = parsed.root;
+        const cachedParser = Object.create(parser);
+        cachedParser.parseRaw = () => parsed;
+        const syntax = cachedParser.declarations(file.path, file.text, {
+            descendAbove: Infinity,
+        });
+        for (const limit of syntax.limits) {
+            if (limit.kind === "parse_partial" && limit.declaration)
+                continue;
+            limits.push({
+                fact: `${file.path} : ${limit.kind}`,
+                next: "check the complete supplied source",
+            });
+        }
+        if (syntax.limits.some((limit) => limit.kind === "parse_failed"))
+            continue;
+        const usedNames = names(root);
+        const valueNames = names(root, false);
+        uses.set(file.path, usedNames);
+        const collectDeclarations = (tree) => {
+            const result = [];
+            for (const outer of tree.children()) {
+                const envelope = outer;
+                const node = ["export_statement", "decorated_definition"].includes(String(outer.kind()))
+                    ? (outer
+                        .children()
+                        .find((child) => [
+                        "function_declaration",
+                        "generator_function_declaration",
+                        "class_declaration",
+                        "lexical_declaration",
+                        "variable_declaration",
+                        "function_definition",
+                        "class_definition",
+                        "type_alias_declaration",
+                        "interface_declaration",
+                        "enum_declaration",
+                    ].includes(String(child.kind()))) ?? outer)
+                    : outer;
+                if ([
+                    "function_declaration",
+                    "generator_function_declaration",
+                    "class_declaration",
+                    "function_definition",
+                    "class_definition",
+                    "type_alias_declaration",
+                    "interface_declaration",
+                    "enum_declaration",
+                ].includes(String(node.kind()))) {
+                    const name = node.field("name")?.text();
+                    if (name)
+                        result.push({ name, text: envelope.text(), node: envelope });
+                }
+                else if (["lexical_declaration", "variable_declaration"].includes(String(node.kind()))) {
+                    for (const variable of node
+                        .children()
+                        .filter((child) => child.kind() === "variable_declarator")) {
+                        const name = variable.field("name")?.text();
+                        if (name)
+                            result.push({ name, text: envelope.text(), node: envelope });
+                    }
+                }
+                else if (python && node.kind() === "expression_statement") {
+                    const assignment = node
+                        .children()
+                        .find((child) => child.kind() === "assignment");
+                    const name = assignment?.field("left")?.text();
+                    if (name)
+                        result.push({ name, text: envelope.text(), node: envelope });
+                }
+            }
+            for (const declaration of result) {
+                if (!declaration.node.find({ rule: { kind: "ERROR" } }))
+                    continue;
+                const fact = `${file.path} : parse_partial (${declaration.name})`;
+                if (!limits.some((limit) => limit.fact === fact))
+                    limits.push({
+                        fact,
+                        next: "check the complete supplied source declaration",
+                    });
+            }
+            return result;
+        };
+        const old = before && Object.hasOwn(before, file.path)
+            ? before[file.path]
+            : undefined;
+        const oldRoot = typeof old === "string" ? parser.parseRaw(file.path, old) : undefined;
+        const oldDeclarations = oldRoot?.ok
+            ? collectDeclarations(oldRoot.root)
+            : [];
+        const currentDeclarations = collectDeclarations(root);
+        for (const declaration of currentDeclarations) {
+            const tree = declaration.node;
+            const decorators = nodes(tree, ["decorator"]);
+            declarations.push({
+                path: file.path,
+                name: declaration.name,
+                text: declaration.text,
+                ...(old !== undefined
+                    ? {
+                        before: oldDeclarations.find((item) => item.name === declaration.name)
+                            ?.text ?? null,
+                    }
+                    : {}),
+                usedNames: names(tree),
+                fixture: python &&
+                    decorators.some((node) => nodes(node, ["identifier"]).some((item) => item.text() === "fixture")),
+                autouse: python &&
+                    decorators.some((node) => nodes(node, ["keyword_argument"]).some((item) => item.field("name")?.text() === "autouse" &&
+                        item.field("value")?.text() === "True")),
+            });
+        }
+        for (const declaration of oldDeclarations) {
+            if (!currentDeclarations.some((item) => item.name === declaration.name))
+                declarations.push({
+                    path: file.path,
+                    name: declaration.name,
+                    text: "",
+                    before: declaration.text,
+                    usedNames: names(declaration.node),
+                    deleted: true,
+                });
+        }
+        const add = (local, imported, specifier, reexport, data = false) => bindings.push({
+            path: file.path,
+            local,
+            imported,
+            specifier,
+            reexport,
+            used: data ||
+                usedNames.includes(local) ||
+                usedNames.some((name) => name.startsWith(`${local}.`)),
+            ...(data ? { data: true } : {}),
+            typeOnly: !data &&
+                !valueNames.some((name) => name === local || name.startsWith(`${local}.`)),
+            valueMembers: valueNames.filter((name) => name.startsWith(`${local}.`)),
+        });
+        for (const node of nodes(root, [
+            "import_statement",
+            "import_from_statement",
+            "export_statement",
+        ])) {
+            if (python) {
+                const children = node.children();
+                const module = node.kind() === "import_from_statement"
+                    ? children.find((child) => ["relative_import", "dotted_name"].includes(String(child.kind())))
+                    : undefined;
+                for (const child of children) {
+                    if (child === module)
+                        continue;
+                    if (child.kind() === "aliased_import") {
+                        const original = child.field("name")?.text() ??
+                            child
+                                .children()
+                                .find((item) => item.kind() === "dotted_name")
+                                ?.text();
+                        const alias = child.field("alias")?.text() ??
+                            child
+                                .children()
+                                .filter((item) => item.kind() === "identifier")
+                                .at(-1)
+                                ?.text();
+                        if (original)
+                            add(alias ?? original, module ? original : "*", module?.text() ?? original, file.path.endsWith("__init__.py"));
+                    }
+                    else if (child.kind() === "dotted_name")
+                        add(child.text().split(".")[0] ?? child.text(), module ? child.text() : "*", module?.text() ?? child.text(), file.path.endsWith("__init__.py"));
+                    else if (child.kind() === "wildcard_import" && module)
+                        add("*", "*", module.text(), file.path.endsWith("__init__.py"));
+                }
+            }
+            else {
+                const specifier = literal(node.field("source") ??
+                    node.children().find((child) => child.kind() === "string"));
+                const reexport = node.kind() === "export_statement";
+                const specs = nodes(node, ["import_specifier", "export_specifier"]);
+                if (specifier) {
+                    for (const spec of specs) {
+                        const ids = spec
+                            .children()
+                            .filter((child) => child.kind() === "identifier");
+                        const imported = spec.field("name")?.text() ?? ids[0]?.text();
+                        const alias = spec.field("alias")?.text() ?? ids.at(-1)?.text();
+                        if (imported)
+                            add(alias ?? imported, imported, specifier, reexport);
+                    }
+                    const clause = node
+                        .children()
+                        .find((child) => child.kind() === "import_clause");
+                    const defaultName = clause
+                        ?.children()
+                        .find((child) => child.kind() === "identifier");
+                    if (defaultName)
+                        add(defaultName.text(), "default", specifier, false);
+                    const namespace = nodes(node, [
+                        "namespace_import",
+                        "namespace_export",
+                    ])[0];
+                    if (namespace)
+                        add(namespace
+                            .children()
+                            .find((child) => child.kind() === "identifier")
+                            ?.text() ?? "*", "*", specifier, reexport);
+                    else if (reexport &&
+                        !specs.length &&
+                        node.children().some((child) => child.text() === "*"))
+                        add("*", "*", specifier, true);
+                }
+                else if (reexport) {
+                    if (node.children().some((child) => child.kind() === "default")) {
+                        const declaration = node
+                            .children()
+                            .find((child) => child.field("name") !== null);
+                        const name = declaration?.field("name")?.text();
+                        if (name)
+                            add("default", name, "", true);
+                    }
+                    for (const spec of specs) {
+                        const ids = spec
+                            .children()
+                            .filter((child) => child.kind() === "identifier");
+                        if (ids[0])
+                            add(ids.at(-1)?.text() ?? ids[0].text(), ids[0].text(), "", true);
+                    }
+                }
+            }
+        }
+        const readAliases = bindings
+            .filter((binding) => binding.path === file.path && binding.imported === "readFileSync")
+            .map((binding) => binding.local);
+        for (const call of nodes(root, python ? ["call"] : ["call_expression"])) {
+            const fn = call.field("function");
+            const fnName = fn?.text() ?? "";
+            if (fnName === "readFileSync" ||
+                fnName.endsWith(".readFileSync") ||
+                readAliases.includes(fnName)) {
+                const argument = (call.field("arguments") ??
+                    call.children().find((child) => child.kind() === "arguments"))
+                    ?.children()
+                    .find((child) => child.kind() === "string");
+                const specifier = literal(argument);
+                if (specifier !== undefined)
+                    add(specifier, "*", specifier, false, true);
+                else
+                    limits.push({
+                        fact: `${file.path} : unresolved dynamic readFileSync call`,
+                        next: "Provide the data file explicitly.",
+                    });
+            }
+            if (["import", "__import__", "importlib.import_module"].includes(fnName))
+                limits.push({
+                    fact: `${file.path} : unresolved dynamic import ${call.text()}`,
+                    next: "Provide the dependency explicitly.",
+                });
+        }
+    }
+    return {
+        declarations,
+        bindings,
+        limits,
+        sources: files,
+        uses,
+        ...(before ? { before } : {}),
+    };
+}

package/dist/adapters/canonical-path.js

@@ -0,0 +1,17 @@
+import { realpath } from "node:fs";
+import { promisify } from "node:util";
+const nativeRealpath = promisify(realpath.native);
+/**
+ * Canonical form of an existing path: resolves symlinks and, on Windows,
+ * expands 8.3 short names (C:\Users\NAME~1) so the path relates correctly to
+ * `git rev-parse --show-toplevel`, which always reports the long form. Falls
+ * back to the input when the path cannot be resolved.
+ */
+export async function canonicalPath(path) {
+    try {
+        return await nativeRealpath(path);
+    }
+    catch {
+        return path;
+    }
+}

package/dist/adapters/command.js

@@ -0,0 +1,234 @@
+import { chmod, mkdtemp, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ASK_TIMEOUT_S, OUTPUT_CHUNK_CHARS, OUTPUT_FAILURE_WINDOW_LINES, OUTPUT_FILE_MAX_BYTES, OUTPUT_FIND_MAX_CALLS, OUTPUT_LINE_MAX_CHARS, OUTPUT_REPEAT_MIN, OUTPUT_SHAPE_MAX_COUNT, } from "../constants.js";
+import { cleanOutput, createRarityCompressor, failureTargets, lineShape, } from "../core/command-output.js";
+import { outputLines } from "./output-lines.js";
+import { resolveShell } from "./shell.js";
+const TRUNCATION_MARK = `…[line truncated at ${OUTPUT_LINE_MAX_CHARS} chars]`;
+/** Shortest key prefix worth redacting when a line cut leaves only its start. */
+const SECRET_PREFIX_MIN = 4;
+/**
+ * Replace every occurrence of `secret` in `text`, counting replacements. A
+ * line cut at OUTPUT_LINE_MAX_CHARS can end inside the key; that trailing key
+ * prefix is redacted too.
+ */
+export function redactSecret(text, secret) {
+    if (!secret)
+        return { text, count: 0 };
+    const parts = text.split(secret);
+    let result = parts.join("[redacted]");
+    let count = parts.length - 1;
+    if (result.endsWith(TRUNCATION_MARK)) {
+        const kept = result.slice(0, -TRUNCATION_MARK.length);
+        const min = Math.min(SECRET_PREFIX_MIN, secret.length);
+        for (let length = Math.min(secret.length - 1, kept.length); length >= min; length--) {
+            if (kept.endsWith(secret.slice(0, length))) {
+                result = `${kept.slice(0, -length)}[redacted]${TRUNCATION_MARK}`;
+                count++;
+                break;
+            }
+        }
+    }
+    return { text: result, count };
+}
+export async function captureCommand(exec, cwd, command, timeoutS = ASK_TIMEOUT_S, signal, 
+/** Configured Jev API key, replaced in the captured command and output. */
+secret) {
+    const directory = await mkdtemp(join(tmpdir(), "jev-output-"));
+    let commandExecution = "not_started";
+    let completion;
+    try {
+        await chmod(directory, 0o700);
+        const stdoutPath = join(directory, "stdout");
+        const stderrPath = join(directory, "stderr");
+        signal?.throwIfAborted();
+        let executed;
+        try {
+            const shell = resolveShell();
+            // Fail closed: never spawn a bare name that PATH could resolve to WSL.
+            if (!shell.ok)
+                return {
+                    ok: false,
+                    cause: "file_unavailable",
+                    commandExecution: "not_started",
+                    error: shell.error,
+                };
+            commandExecution = "unknown";
+            executed = await exec(shell.executable, [
+                ...shell.prefix,
+                "-c",
+                `${shell.scriptPrefix}exec >"$1" 2>"$2"; set --; (\n${command}\n)\nexit $?`,
+                "jev",
+                stdoutPath,
+                stderrPath,
+            ], { cwd, timeout: timeoutS * 1000, signal });
+            commandExecution = "finished";
+            completion = {
+                commandExitCode: executed.killed ? null : executed.code,
+                commandTimedOut: executed.killed,
+            };
+        }
+        catch (error) {
+            signal?.throwIfAborted();
+            return {
+                ok: false,
+                cause: "file_unavailable",
+                commandExecution,
+                error: `Command executable unavailable: ${String(error)}`,
+            };
+        }
+        signal?.throwIfAborted();
+        const sizes = await Promise.all([stdoutPath, stderrPath].map(async (path) => {
+            try {
+                return (await stat(path)).size;
+            }
+            catch (error) {
+                if (error instanceof Error &&
+                    "code" in error &&
+                    error.code === "ENOENT")
+                    return 0;
+                throw error;
+            }
+        }));
+        if (sizes.some((size) => size > OUTPUT_FILE_MAX_BYTES))
+            return {
+                ok: false,
+                cause: "evidence_too_large",
+                commandExecution: "finished",
+                ...completion,
+                error: `output exceeded ${OUTPUT_FILE_MAX_BYTES} bytes per stream; narrow command`,
+            };
+        const targets = [];
+        let signature;
+        let compressedChars = 0;
+        let linesTruncated = false;
+        let lineOmittedChars = 0;
+        let shapeLimitExceeded = false;
+        const texts = [];
+        let redactions = 0;
+        const redacted = (text) => {
+            const result = redactSecret(text, secret);
+            redactions += result.count;
+            return result.text;
+        };
+        for (const [index, path] of [stdoutPath, stderrPath].entries()) {
+            if (!sizes[index]) {
+                texts.push(redacted(index === 0 ? executed.stdout : executed.stderr));
+                continue;
+            }
+            const frequencies = new Map();
+            let shapeLimit = false;
+            for await (const raw of outputLines(path, signal)) {
+                signal?.throwIfAborted();
+                const line = redactSecret(cleanOutput(raw), secret).text;
+                linesTruncated ||= raw.endsWith(TRUNCATION_MARK);
+                const shape = lineShape(line);
+                if (!frequencies.has(shape) &&
+                    frequencies.size >= OUTPUT_SHAPE_MAX_COUNT) {
+                    shapeLimit = true;
+                    shapeLimitExceeded = true;
+                    frequencies.clear();
+                    break;
+                }
+                frequencies.set(shape, Math.min(OUTPUT_REPEAT_MIN, (frequencies.get(shape) ?? 0) + 1));
+            }
+            let text = "";
+            const compressor = createRarityCompressor(frequencies, (line) => {
+                compressedChars += line.length + 1;
+                const remaining = OUTPUT_CHUNK_CHARS * OUTPUT_FIND_MAX_CALLS + 1 - text.length;
+                if (remaining > 0)
+                    text += `${line}\n`.slice(0, remaining);
+            });
+            const failureWindow = [];
+            let failureSeen = false;
+            let afterFailure = 0;
+            // node:test prints its failing-test block ("✖ failing tests:" then
+            // "test at <file>:<line>:<col>") after one summary line per test, so
+            // the block can sit more than one window past the first anchor. Once
+            // the first window closes, keep scanning for that header and collect
+            // the next window after it. At most two windows (2 * (WINDOW + 1)
+            // lines) are ever buffered per stream.
+            let secondSeen = false;
+            let afterSecond = 0;
+            const isAnchor = (line) => failureTargets(line).signature !== undefined ||
+                /^\s*(?:✖|ERROR |FAIL |test at )/.test(line);
+            const isFailingTestsHeader = (line) => /^\s*(?:✖\s+)?failing tests:?\s*$/.test(line);
+            if (shapeLimit)
+                compressor.line(`…[shape limit exceeded at ${OUTPUT_SHAPE_MAX_COUNT}; rarity grouping disabled]`);
+            for await (const raw of outputLines(path, signal, (chars) => {
+                lineOmittedChars += chars;
+            })) {
+                signal?.throwIfAborted();
+                linesTruncated ||= raw.endsWith(TRUNCATION_MARK);
+                // Redact before compression, failure windows and state assembly.
+                const line = redacted(cleanOutput(raw));
+                compressor.line(line);
+                if (!failureSeen) {
+                    failureWindow.push(line);
+                    if (failureWindow.length > OUTPUT_FAILURE_WINDOW_LINES + 1)
+                        failureWindow.shift();
+                    if (isAnchor(raw))
+                        failureSeen = true;
+                }
+                else if (afterFailure++ < OUTPUT_FAILURE_WINDOW_LINES) {
+                    failureWindow.push(line);
+                    if (!secondSeen && afterFailure > 1 && isFailingTestsHeader(raw)) {
+                        secondSeen = true;
+                        afterSecond = 0;
+                    }
+                }
+                else if (!secondSeen) {
+                    if (isFailingTestsHeader(raw)) {
+                        secondSeen = true;
+                        afterSecond = 0;
+                        failureWindow.push(line);
+                    }
+                }
+                else if (afterSecond++ < OUTPUT_FAILURE_WINDOW_LINES) {
+                    failureWindow.push(line);
+                }
+            }
+            compressor.finish();
+            const failure = failureTargets(failureWindow.join("\n"));
+            signature ??= failure.signature;
+            targets.push(...failure.targets.slice(0, 20 - targets.length));
+            texts.push(text);
+        }
+        return {
+            ok: true,
+            commandExecution: "finished",
+            ...completion,
+            output: {
+                command: redacted(command),
+                exit_code: executed.killed ? null : executed.code,
+                timed_out: executed.killed,
+                stdout: texts[0] ?? "",
+                stderr: texts[1] ?? "",
+                compressed: true,
+                truncated: linesTruncated,
+            },
+            originalBytes: sizes.reduce((sum, size) => sum + size, 0),
+            compressedChars,
+            lineOmittedChars,
+            shapeLimitExceeded,
+            selectedPassages: false,
+            assertion: signature === "assertion",
+            targets,
+            redactions,
+        };
+    }
+    catch (error) {
+        signal?.throwIfAborted();
+        return {
+            ok: false,
+            cause: "file_unavailable",
+            commandExecution,
+            ...completion,
+            error: `Command capture unavailable: ${String(error)}`,
+        };
+    }
+    finally {
+        await rm(directory, { recursive: true, force: true });
+    }
+}