knodin 0.6.0 → 0.7.3

package/dist/src/failure-diagnosis.js

@@ -397,18 +397,16 @@ function truncateUtf8(value, byteBudget) {
     return output;
 }
 function sourceSnippet(repo, file, line, contextLines, remainingBytes) {
-    if (remainingBytes <= 0)
-        return { snippet: null, truncated: true };
     const absolute = path.join(repo, file);
     let lines;
     try {
         const stat = fs.statSync(absolute);
         if (!stat.isFile() || stat.size > MAX_SOURCE_FILE_BYTES)
-            return { snippet: null, truncated: true };
+            return { snippet: null, truncated: true, omittedBytes: 0 };
         lines = fs.readFileSync(absolute, "utf8").split(/\r?\n/);
     }
     catch {
-        return { snippet: null, truncated: true };
+        return { snippet: null, truncated: true, omittedBytes: 0 };
     }
     const startLine = Math.max(1, line - contextLines);
     const endLine = Math.min(lines.length, line + contextLines);
@@ -416,12 +414,16 @@ function sourceSnippet(repo, file, line, contextLines, remainingBytes) {
         .slice(startLine - 1, endLine)
         .map((value, index) => `${startLine + index}: ${value.slice(0, 2_000)}`)
         .join("\n");
+    const contentBytes = Buffer.byteLength(content);
+    if (remainingBytes <= 0)
+        return { snippet: null, truncated: true, omittedBytes: contentBytes };
     const bounded = truncateUtf8(content, remainingBytes);
     if (!bounded)
-        return { snippet: null, truncated: true };
+        return { snippet: null, truncated: true, omittedBytes: contentBytes };
     return {
         snippet: { file, startLine, endLine, content: bounded },
         truncated: bounded !== content,
+        omittedBytes: contentBytes - Buffer.byteLength(bounded),
     };
 }
 function diagnosisSource(repo, request) {
@@ -464,7 +466,7 @@ function diagnosisSource(repo, request) {
 }
 async function relationsForOwner(graph, repo, file, owner, limit) {
     if (!owner?.symbol)
-        return { tests: [], upstream: [], downstream: [] };
+        return { tests: [], upstream: [], downstream: [], omitted: 0 };
     const selector = owner.identity ? { identity: owner.identity, file } : { file };
     const query = (pattern, options) => graph.query(pattern, owner.symbol ?? "", repo, undefined, limit, pattern === "impact" ? 2 : undefined, undefined, selector, options);
     const [tests, upstream, downstream] = await Promise.all([
@@ -472,11 +474,17 @@ async function relationsForOwner(graph, repo, file, owner, limit) {
         query("impact", { direction: "upstream", includeTests: true }),
         query("impact", { direction: "downstream", includeTests: true }),
     ]);
-    return {
+    const mapped = {
         tests: relationRows(tests, limit),
         upstream: relationRows(upstream, limit),
         downstream: relationRows(downstream, limit),
     };
+    return {
+        ...mapped,
+        omitted: Math.max(0, tests.count - mapped.tests.length) +
+            Math.max(0, upstream.count - mapped.upstream.length) +
+            Math.max(0, downstream.count - mapped.downstream.length),
+    };
 }
 function ownerEvidence(owner) {
     if (!owner?.symbol)
@@ -502,10 +510,13 @@ async function diagnoseResolvedReference(graph, repo, reference, file, options)
             file,
             package: owningPackage(repo, file),
             owner: ownerEvidence(owner),
-            ...relationships,
+            tests: relationships.tests,
+            upstream: relationships.upstream,
+            downstream: relationships.downstream,
             recentChanges: options.recentCommitLimit > 0 ? recentChanges(repo, file, options.recentCommitLimit) : [],
         },
         source: sourceSnippet(repo, file, evidenceLineNumber, options.contextLines, options.remainingContextBytes),
+        omittedRelations: relationships.omitted,
     };
 }
 function diagnosisLimitations(inputComplete, referenceCount, contextTruncated, freshnessState) {
@@ -531,17 +542,22 @@ function diagnosisStatus(resolvedCount, unresolvedCount, inputComplete, contextT
 }
 export async function diagnoseFailure(graph, repo, request) {
     const maxDiagnostics = integer("maxDiagnostics", request.maxDiagnostics, DEFAULT_DIAGNOSTICS, 1, MAX_DIAGNOSTICS);
+    const diagnosticOffset = integer("diagnosticOffset", request.diagnosticOffset, 0, 0, 1_000_000);
     const contextLines = integer("contextLines", request.contextLines, 2, 0, 10);
     const contextByteBudget = integer("contextByteBudget", request.contextByteBudget, DEFAULT_CONTEXT_BYTES, 256, MAX_CONTEXT_BYTES);
     const relationLimit = integer("relationLimit", request.relationLimit, DEFAULT_RELATIONS, 1, MAX_RELATIONS);
     const recentCommitLimit = integer("recentCommitLimit", request.recentCommitLimit, 3, 0, 10);
     const input = diagnosisSource(repo, request);
-    const references = extractDiagnosticReferences(input.content, maxDiagnostics);
+    const detectedReferences = extractDiagnosticReferences(input.content, Number.MAX_SAFE_INTEGER);
+    const references = detectedReferences.slice(diagnosticOffset, diagnosticOffset + maxDiagnostics);
+    const omittedDiagnostics = Math.max(0, detectedReferences.length - diagnosticOffset - references.length);
     const diagnostics = [];
     const unresolved = [];
     const snippets = [];
     let contextBytes = 0;
     let contextTruncated = false;
+    let omittedRelations = 0;
+    let omittedContextBytes = 0;
     for (const reference of references) {
         const resolved = await resolveReferencePath(graph, repo, reference);
         if (!resolved.file) {
@@ -563,10 +579,28 @@ export async function diagnoseFailure(graph, repo, request) {
             contextBytes += Buffer.byteLength(resolvedDiagnosis.source.snippet.content);
         }
         contextTruncated ||= resolvedDiagnosis.source.truncated;
+        omittedRelations += resolvedDiagnosis.omittedRelations;
+        omittedContextBytes += resolvedDiagnosis.source.omittedBytes;
         diagnostics.push(resolvedDiagnosis.diagnostic);
     }
     const health = await graph.status(repo, { audit: "cached" });
-    const status = diagnosisStatus(diagnostics.length, unresolved.length, input.complete, contextTruncated, health.freshness.state);
+    const status = diagnosisStatus(diagnostics.length, unresolved.length + omittedDiagnostics, input.complete, contextTruncated, health.freshness.state);
+    const omissionReasons = [];
+    if (omittedDiagnostics > 0)
+        omissionReasons.push("diagnostic-item-budget");
+    if (omittedRelations > 0)
+        omissionReasons.push("relation-item-budget");
+    if (contextTruncated)
+        omissionReasons.push("context-byte-budget");
+    if (!input.complete)
+        omissionReasons.push("input-byte-budget");
+    const confidenceReasons = [
+        ...(diagnostics.length === 0 ? ["no-safe-source-reference"] : []),
+        ...(unresolved.length > 0 ? ["unresolved-source-reference"] : []),
+        ...omissionReasons,
+        ...(health.freshness.state !== "fresh" ? [`freshness-${health.freshness.state}`] : []),
+    ];
+    const returnedRelations = diagnostics.reduce((total, diagnostic) => total + diagnostic.tests.length + diagnostic.upstream.length + diagnostic.downstream.length, 0);
     return {
         schemaVersion: 1,
         status,
@@ -585,6 +619,31 @@ export async function diagnoseFailure(graph, repo, request) {
             snippets,
         },
         freshness: health.freshness,
+        confidence: {
+            level: diagnostics.length === 0 ? "refused" : status === "resolved" ? "exact" : "qualified",
+            reasons: confidenceReasons,
+        },
+        omissions: {
+            diagnostics: omittedDiagnostics,
+            relations: omittedRelations,
+            contextBytes: omittedContextBytes,
+            reasons: omissionReasons,
+            continuation: omittedDiagnostics > 0 && input.artifactId
+                ? { artifactId: input.artifactId, nextDiagnostic: diagnosticOffset + references.length }
+                : null,
+        },
+        telemetry: {
+            commandRerun: false,
+            referencesDetected: detectedReferences.length,
+            resolved: diagnostics.length,
+            unresolved: unresolved.length,
+            caps: {
+                diagnostics: maxDiagnostics,
+                relationsPerKind: relationLimit,
+                contextBytes: contextByteBudget,
+            },
+            returned: { diagnostics: diagnostics.length, relations: returnedRelations, contextBytes },
+        },
         limitations: diagnosisLimitations(input.complete, references.length, contextTruncated, health.freshness.state),
     };
 }

package/dist/src/hook-manager-integration.js

@@ -0,0 +1,156 @@
+import fs from "node:fs";
+import path from "node:path";
+import { isMap, parseDocument } from "yaml";
+export const KNODIN_LEFTHOOK_COMMAND = "knodin-refresh";
+const MANAGED_COMMENT = "Managed locally by knodin init; repository hook configuration is not modified.";
+const LEFTHOOK_CONFIGS = [
+    { main: "lefthook.yml", local: "lefthook-local.yml" },
+    { main: "lefthook.yaml", local: "lefthook-local.yaml" },
+    { main: ".lefthook.yml", local: ".lefthook-local.yml" },
+    { main: ".lefthook.yaml", local: ".lefthook-local.yaml" },
+    { main: ".config/lefthook.yml", local: ".config/lefthook-local.yml" },
+    { main: ".config/lefthook.yaml", local: ".config/lefthook-local.yaml" },
+];
+const HOOK_COMMANDS = {
+    "post-commit": { run: ".knodin/hooks/manager-dispatch.sh post-commit" },
+    "post-checkout": {
+        run: ".knodin/hooks/manager-dispatch.sh post-checkout {1} {2} {3}",
+    },
+    "post-merge": { run: ".knodin/hooks/manager-dispatch.sh post-merge {1}" },
+    "post-rewrite": {
+        run: ".knodin/hooks/manager-dispatch.sh post-rewrite {1}",
+        use_stdin: true,
+    },
+};
+export const LEFTHOOK_DISPATCHER = `#!/bin/sh
+# knodin manager-native lifecycle dispatcher. Generated by knodin init.
+set -u
+[ "\${KNODIN_WRAPPER_ACTIVE:-0}" = "1" ] && exit 0
+REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+[ -n "$REPO_ROOT" ] || exit 0
+BACKGROUND="$REPO_ROOT/.knodin/hooks/background-index.sh"
+[ -x "$BACKGROUND" ] || exit 0
+HOOK="\${1:-}"
+shift || true
+case "$HOOK" in
+  post-commit)
+    set -- commit
+    ;;
+  post-checkout)
+    [ "$#" -ge 2 ] || exit 0
+    set -- checkout "$1" "$2"
+    ;;
+  post-merge)
+    BEFORE="$(git rev-parse ORIG_HEAD 2>/dev/null || true)"
+    AFTER="$(git rev-parse HEAD 2>/dev/null || true)"
+    [ -n "$BEFORE" ] && [ -n "$AFTER" ] || exit 0
+    set -- merge "$BEFORE" "$AFTER"
+    ;;
+  post-rewrite)
+    INPUT="$(mktemp "$REPO_ROOT/.knodin/hooks/rewrite-input.XXXXXX")" || exit 0
+    cat > "$INPUT"
+    set -- rewrite "$INPUT"
+    ;;
+  *) exit 0 ;;
+esac
+nohup "$BACKGROUND" "$@" >/dev/null 2>&1 &
+exit 0
+`;
+function lefthookFiles(repo) {
+    for (const candidate of LEFTHOOK_CONFIGS) {
+        if (fs.existsSync(path.join(repo, candidate.main)))
+            return candidate;
+    }
+    return null;
+}
+function assertRegularOrMissing(target) {
+    try {
+        const stat = fs.lstatSync(target);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error(`knodin init: refusing non-regular hook-manager config: ${target}`);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+function atomicWrite(target, content, mode) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, content, { encoding: "utf-8", mode, flag: "wx" });
+    fs.renameSync(temporary, target);
+    if (mode !== undefined)
+        fs.chmodSync(target, mode);
+}
+function ensureMap(document, keys) {
+    const existing = document.getIn(keys, true);
+    if (existing !== undefined && !isMap(existing))
+        throw new Error(`knodin init: cannot merge Lefthook integration because ${keys.join(".")} is not a map`);
+}
+/**
+ * Add a local-only Lefthook overlay. The repository-owned main configuration is
+ * never edited; an existing local overlay is parsed and merged by key.
+ */
+export function installHookManagerIntegration(repoPath) {
+    const repo = path.resolve(repoPath);
+    const files = lefthookFiles(repo);
+    if (!files)
+        return null;
+    const localPath = path.join(repo, files.local);
+    assertRegularOrMissing(localPath);
+    const existing = fs.existsSync(localPath) ? fs.readFileSync(localPath, "utf-8") : "";
+    const document = parseDocument(existing || "{}\n", { keepSourceTokens: true });
+    if (document.errors.length > 0)
+        throw new Error(`knodin init: cannot parse ${files.local}: ${document.errors[0]?.message}`);
+    if (!isMap(document.contents))
+        throw new Error(`knodin init: cannot merge ${files.local}: root must be a map`);
+    if (!existing)
+        document.commentBefore = MANAGED_COMMENT;
+    for (const [hook, command] of Object.entries(HOOK_COMMANDS)) {
+        ensureMap(document, [hook]);
+        ensureMap(document, [hook, "commands"]);
+        document.setIn([hook, "commands", KNODIN_LEFTHOOK_COMMAND], command);
+    }
+    atomicWrite(localPath, document.toString({ lineWidth: 0 }));
+    const dispatcher = path.join(repo, ".knodin", "hooks", "manager-dispatch.sh");
+    assertRegularOrMissing(dispatcher);
+    atomicWrite(dispatcher, LEFTHOOK_DISPATCHER, 0o755);
+    return {
+        manager: "lefthook",
+        localConfig: files.local,
+        dispatcher: ".knodin/hooks/manager-dispatch.sh",
+    };
+}
+export function inspectLefthookIntegration(repoPath) {
+    const repo = path.resolve(repoPath);
+    const files = lefthookFiles(repo);
+    if (!files)
+        return { configured: false, localConfig: null };
+    try {
+        const document = parseDocument(fs.readFileSync(path.join(repo, files.local), "utf-8"));
+        if (document.errors.length > 0)
+            return { configured: false, localConfig: files.local };
+        for (const [hook, command] of Object.entries(HOOK_COMMANDS)) {
+            const run = document.getIn([hook, "commands", KNODIN_LEFTHOOK_COMMAND, "run"]);
+            if (run !== command.run)
+                return { configured: false, localConfig: files.local };
+            if ("use_stdin" in command &&
+                document.getIn([hook, "commands", KNODIN_LEFTHOOK_COMMAND, "use_stdin"]) !== true)
+                return { configured: false, localConfig: files.local };
+        }
+        const dispatcher = path.join(repo, ".knodin", "hooks", "manager-dispatch.sh");
+        const stat = fs.statSync(dispatcher);
+        return {
+            configured: stat.isFile() &&
+                (stat.mode & 0o111) !== 0 &&
+                fs.readFileSync(dispatcher, "utf-8") === LEFTHOOK_DISPATCHER,
+            localConfig: files.local,
+        };
+    }
+    catch {
+        return { configured: false, localConfig: files.local };
+    }
+}
+export function isActiveLefthookHook(content) {
+    return /\bcall_lefthook\b|\blefthook(?:\s|")/.test(content);
+}