knodin 0.5.1 → 0.7.3

package/dist/src/lifecycle-health.js

@@ -1,7 +1,8 @@
 import childProcess from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-const MANAGED_MARKERS = ["KNODIN MANAGED HOOK", "RECKON-GRAPH MANAGED HOOK"];
+import { inspectLefthookIntegration, isActiveLefthookHook } from "./hook-manager-integration.js";
+const MANAGED_MARKER = "KNODIN MANAGED HOOK";
 const HOOK_NAMES = ["post-commit", "post-checkout", "post-merge", "post-rewrite"];
 const HOOK_FAILURE_FILE = "last-refresh-failure";
 function readEvent(target) {
@@ -35,11 +36,11 @@ function readEvent(target) {
     }
 }
 function readLastEvent(repo) {
-    return readEvent(path.join(repo, ".reckon", "hooks", "last-refresh-event"));
+    return readEvent(path.join(repo, ".knodin", "hooks", "last-refresh-event"));
 }
 function readPendingEvent(repo) {
     try {
-        const directory = path.join(repo, ".reckon", "hooks", "events");
+        const directory = path.join(repo, ".knodin", "hooks", "events");
         const next = fs
             .readdirSync(directory)
             .filter((entry) => entry.endsWith(".event"))
@@ -51,7 +52,7 @@ function readPendingEvent(repo) {
     }
 }
 function processorState(repo) {
-    const pidPath = path.join(repo, ".reckon", "hooks", "refresh.lock", "pid");
+    const pidPath = path.join(repo, ".knodin", "hooks", "refresh.lock", "pid");
     if (!fs.existsSync(path.dirname(pidPath)))
         return { state: "idle", pid: null };
     let pid = null;
@@ -78,7 +79,7 @@ function processorState(repo) {
 function queuedEventCount(repo) {
     try {
         return fs
-            .readdirSync(path.join(repo, ".reckon", "hooks", "events"))
+            .readdirSync(path.join(repo, ".knodin", "hooks", "events"))
             .filter((entry) => entry.endsWith(".event")).length;
     }
     catch {
@@ -89,26 +90,45 @@ function activeHooksDirectory(repo) {
     const output = childProcess.execFileSync("git", ["rev-parse", "--path-format=absolute", "--git-path", "hooks"], { cwd: repo, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
     return output.trim();
 }
-function inspectManagedHooks(hooksDirectory) {
+function inspectManagedHooks(repo, hooksDirectory) {
     const activeHooks = [];
     const missingHooks = [];
+    let wrappers = 0;
+    let managerNative = 0;
+    const lefthook = inspectLefthookIntegration(repo);
     for (const hookName of HOOK_NAMES) {
         try {
             const hookPath = path.join(hooksDirectory, hookName);
             const content = fs.readFileSync(hookPath, "utf-8");
             const mode = fs.statSync(hookPath).mode;
-            const active = (mode & 0o111) !== 0 &&
-                MANAGED_MARKERS.some((marker) => content.startsWith(`#!/bin/sh\n# ${marker}: ${hookName}\n`));
+            const wrapper = content.startsWith(`#!/bin/sh\n# ${MANAGED_MARKER}: ${hookName}\n`);
+            const native = lefthook.configured && isActiveLefthookHook(content);
+            const active = (mode & 0o111) !== 0 && (wrapper || native);
+            if (active && wrapper)
+                wrappers++;
+            else if (active && native)
+                managerNative++;
             (active ? activeHooks : missingHooks).push(hookName);
         }
         catch {
             missingHooks.push(hookName);
         }
     }
-    return { activeHooks, missingHooks };
+    return {
+        activeHooks,
+        missingHooks,
+        hookManager: lefthook.configured ? "lefthook" : null,
+        routing: wrappers > 0 && managerNative > 0
+            ? "mixed"
+            : wrappers > 0
+                ? "managed-wrapper"
+                : managerNative > 0
+                    ? "manager-native"
+                    : "unavailable",
+    };
 }
 function readRefreshFailure(repo) {
-    const failurePath = path.join(repo, ".reckon", "hooks", HOOK_FAILURE_FILE);
+    const failurePath = path.join(repo, ".knodin", "hooks", HOOK_FAILURE_FILE);
     if (!fs.existsSync(failurePath))
         return null;
     try {
@@ -122,7 +142,7 @@ function readRefreshFailure(repo) {
 /** Read-only proof that committed Git activity can still reach knodin's indexer. */
 export function inspectLifecycleHealth(repoPath) {
     const repo = path.resolve(repoPath);
-    if (!fs.existsSync(path.join(repo, ".reckon", "db.sqlite"))) {
+    if (!fs.existsSync(path.join(repo, ".knodin", "db.sqlite"))) {
         return {
             status: "unconfigured",
             refreshCapable: false,
@@ -135,6 +155,8 @@ export function inspectLifecycleHealth(repoPath) {
             pendingEvent: null,
             lastEvent: null,
             lastError: null,
+            hookManager: null,
+            routing: "unavailable",
         };
     }
     let hooksDirectory;
@@ -154,17 +176,19 @@ export function inspectLifecycleHealth(repoPath) {
             pendingEvent: readPendingEvent(repo),
             lastEvent: readLastEvent(repo),
             lastError: null,
+            hookManager: null,
+            routing: "unavailable",
         };
     }
-    const { activeHooks, missingHooks } = inspectManagedHooks(hooksDirectory);
-    const background = path.join(repo, ".reckon", "hooks", "background-index.sh");
+    const { activeHooks, missingHooks, hookManager, routing } = inspectManagedHooks(repo, hooksDirectory);
+    const background = path.join(repo, ".knodin", "hooks", "background-index.sh");
     const backgroundReady = fs.existsSync(background) && (fs.statSync(background).mode & 0o111) !== 0;
     const issues = missingHooks.map((hook) => `${hook} no longer routes through knodin's active Git hook path`);
     if (!backgroundReady)
         issues.push("background indexer is missing or not executable");
     const lastError = readRefreshFailure(repo);
     if (lastError)
-        issues.push(`${lastError} See .reckon/indexer.log for details`);
+        issues.push(`${lastError} See .knodin/indexer.log for details`);
     const refreshCapable = missingHooks.length === 0 && backgroundReady && issues.length === 0;
     return {
         status: refreshCapable ? "healthy" : "degraded",
@@ -178,6 +202,8 @@ export function inspectLifecycleHealth(repoPath) {
         pendingEvent: readPendingEvent(repo),
         lastEvent: readLastEvent(repo),
         lastError,
+        hookManager,
+        routing,
     };
 }
 /** Merge graph and refresh-path health without reporting absent evidence as healthy. */
@@ -211,3 +237,14 @@ export function attachLifecycleHealth(repo, graph) {
         lifecycle,
     };
 }
+/** Keep graph-repair success distinct from lifecycle integration health. */
+export function attachRepairLifecycle(repo, result) {
+    const lifecycle = inspectLifecycleHealth(repo);
+    return {
+        ...result,
+        lifecycle,
+        nextSteps: lifecycle.status === "degraded"
+            ? ["Run `knodin init` to restore lifecycle routing, then `knodin status`."]
+            : [],
+    };
+}

package/dist/src/lsp-readonly.js

@@ -59,7 +59,7 @@ function filesForService(repoPath, ts) {
     const files = [];
     const visit = (directory) => {
         for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-            if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".reckon")
+            if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".knodin")
                 continue;
             const candidate = path.join(directory, entry.name);
             if (entry.isDirectory())

package/dist/src/output-compression.js

@@ -335,7 +335,7 @@ function percentReduction(input, output) {
 }
 function artifactDirectory(repo) {
     const resolvedRepo = fs.realpathSync(repo);
-    const knodinDirectory = path.join(resolvedRepo, ".reckon");
+    const knodinDirectory = path.join(resolvedRepo, ".knodin");
     const outputDirectory = path.join(knodinDirectory, "output");
     for (const candidate of [knodinDirectory, outputDirectory]) {
         if (fs.existsSync(candidate) && fs.lstatSync(candidate).isSymbolicLink())

package/dist/src/output-telemetry.js

@@ -5,7 +5,7 @@ import { encode } from "gpt-tokenizer/encoding/o200k_base";
 export const TELEMETRY_TOKENIZER = "gpt-tokenizer@3.4.0:o200k_base";
 export const countOutputTokens = (value) => encode(value).length;
 export const DEFAULT_TELEMETRY_RETENTION_DAYS = 30;
-const DEFAULT_INPUT = ".reckon-telemetry.jsonl";
+const DEFAULT_INPUT = ".knodin-telemetry.jsonl";
 function lineCount(value) {
     return value.length === 0 ? 0 : value.split(/\r?\n/).length;
 }
@@ -104,7 +104,7 @@ export function measureOutput(options) {
     const availability = options.output.availability;
     const freshness = options.output.freshness;
     const fidelity = options.output.fidelity;
-    const database = path.join(fs.realpathSync(options.repo), ".reckon", "db.sqlite");
+    const database = path.join(fs.realpathSync(options.repo), ".knodin", "db.sqlite");
     const latencyMs = Math.round((performance.now() - options.startedAt) * 100) / 100;
     const outcome = (status !== undefined &&
         ["error", "failed", "unavailable", "blocked", "timeout"].includes(status)) ||
@@ -121,6 +121,7 @@ export function measureOutput(options) {
         at: new Date().toISOString(),
         repositoryId: repositoryIdentifier(options.repo),
         operation: options.operation,
+        ...(options.executionProfile ? { executionProfile: options.executionProfile } : {}),
         latencyMs,
         rssBytes: process.memoryUsage().rss,
         temperature: "cold",
@@ -180,7 +181,7 @@ function telemetrySummary(records) {
         indexingMs: records.reduce((sum, record) => sum + (record.indexingMs ?? 0), 0),
     };
 }
-export function writeTelemetryReport(repoPath, records, outputPath = ".reckon/telemetry-report.html") {
+export function writeTelemetryReport(repoPath, records, outputPath = ".knodin/telemetry-report.html") {
     const { repo, target: output } = privatePath(repoPath, outputPath, "report");
     const groups = new Map();
     for (const record of records) {
@@ -231,6 +232,9 @@ function sanitizeTelemetryRecord(record) {
         at: record.at,
         repositoryId: record.repositoryId,
         operation: record.operation,
+        ...(record.executionProfile && /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(record.executionProfile)
+            ? { executionProfile: record.executionProfile }
+            : {}),
         latencyMs: record.latencyMs,
         rssBytes: record.rssBytes,
         temperature: record.temperature,
@@ -326,7 +330,7 @@ export function telemetryStatus(repoPath, inputPath = DEFAULT_INPUT, retentionDa
         tokenizer: TELEMETRY_TOKENIZER,
     };
 }
-export function exportTelemetry(repoPath, records, outputPath = ".reckon/telemetry-export.json") {
+export function exportTelemetry(repoPath, records, outputPath = ".knodin/telemetry-export.json") {
     const { repo, target } = privatePath(repoPath, outputPath, "export");
     const bundle = {
         schemaVersion: 1,

package/dist/src/pr-triage.js

@@ -12,10 +12,10 @@
  * than `ensureGhAvailable()` (throwing, still used by the CLI's hard-fail).
  */
 import child_process from "node:child_process";
-/** Resolve the `gh` binary to invoke. Tests override via `RECKON_GH_BIN` to
+/** Resolve the `gh` binary to invoke. Tests override via `KNODIN_GH_BIN` to
  * point at a stub script fixture — no network in tests. */
 function ghBin() {
-    return process.env.RECKON_GH_BIN || "gh";
+    return process.env.KNODIN_GH_BIN || "gh";
 }
 const STALE_DAYS = 30;
 const PR_LIST_FIELDS = "number,title,updatedAt,reviewDecision,statusCheckRollup,files,headRefName";