knodin 0.7.6 → 0.8.3

package/dist/src/graph-layout.js

@@ -0,0 +1,173 @@
+/**
+ * Deterministic force-directed layout.
+ *
+ * Coordinates are computed here, at artifact-generation time, rather than by a
+ * script in the rendered page. That keeps a generated artifact reproducible:
+ * the same graph over the same evidence lays out identically, so its SHA-256 is
+ * stable and the output is snapshot-testable. It also means the artifact needs
+ * no JavaScript and no external library, which keeps it self-contained.
+ *
+ * The simulation is a bounded Fruchterman-Reingold: repulsion between every
+ * pair, attraction along every edge, and a linearly decaying temperature that
+ * caps per-iteration displacement. Iteration count is fixed rather than
+ * convergence-driven so that runtime is a function of graph size alone.
+ */
+import { mulberry32, seedFromString } from "./deterministic-random.js";
+/** Square viewport side, in user units, that coordinates are fitted into. */
+const VIEWPORT = 1000;
+/** Fixed iteration count. Bounded work; not a convergence guarantee. */
+const ITERATIONS = 300;
+/** Fraction of the viewport a node may move on the first iteration. */
+const INITIAL_TEMPERATURE = 0.1;
+/** Minimum separation used when two nodes land on the same point. */
+const EPSILON = 0.01;
+/**
+ * Lays out `nodes` connected by `edges` inside a square viewport.
+ *
+ * `seed` should be derived from repository-scoped evidence (a commit id, say)
+ * so that unchanged evidence reproduces an identical layout. Edges naming a
+ * node that is not in `nodes` are ignored rather than throwing: callers cap
+ * node and edge counts independently, and a dangling edge is a truncation
+ * artifact, not a caller error.
+ */
+export function layoutGraph(nodes, edges, seed) {
+    if (nodes.length === 0)
+        return { positions: [], viewport: VIEWPORT };
+    if (nodes.length === 1) {
+        return {
+            positions: [{ id: nodes[0].id, x: VIEWPORT / 2, y: VIEWPORT / 2 }],
+            viewport: VIEWPORT,
+        };
+    }
+    const random = mulberry32(seedFromString(seed));
+    const index = new Map();
+    for (let position = 0; position < nodes.length; position++)
+        index.set(nodes[position].id, position);
+    // Seeded initial placement. A deterministic ring with a jittered radius
+    // avoids the degenerate all-collinear start that a pure grid produces.
+    const xs = new Float64Array(nodes.length);
+    const ys = new Float64Array(nodes.length);
+    for (let i = 0; i < nodes.length; i++) {
+        const angle = (2 * Math.PI * i) / nodes.length;
+        const radius = (VIEWPORT / 2) * (0.35 + 0.6 * random());
+        xs[i] = VIEWPORT / 2 + radius * Math.cos(angle);
+        ys[i] = VIEWPORT / 2 + radius * Math.sin(angle);
+    }
+    // Resolve edges to index pairs once; drop any endpoint we do not hold.
+    const links = [];
+    for (const edge of edges) {
+        const from = index.get(edge.from);
+        const to = index.get(edge.to);
+        if (from === undefined || to === undefined || from === to)
+            continue;
+        links.push([from, to]);
+    }
+    // Ideal edge length: spread nodes evenly over the viewport area.
+    const k = Math.sqrt((VIEWPORT * VIEWPORT) / nodes.length);
+    const dx = new Float64Array(nodes.length);
+    const dy = new Float64Array(nodes.length);
+    const state = { count: nodes.length, xs, ys, dx, dy };
+    for (let iteration = 0; iteration < ITERATIONS; iteration++) {
+        dx.fill(0);
+        dy.fill(0);
+        accumulateRepulsion(state, k);
+        accumulateAttraction(state, links, k);
+        // Linear cooling caps displacement and lets the layout settle.
+        applyDisplacement(state, VIEWPORT * INITIAL_TEMPERATURE * (1 - iteration / ITERATIONS));
+    }
+    return { positions: fitToViewport(nodes, xs, ys), viewport: VIEWPORT };
+}
+/**
+ * Repulsion between every pair. O(n^2): callers cap node count, and the cap is
+ * small enough that a Barnes-Hut tree would cost more than it saves.
+ */
+function accumulateRepulsion({ count, xs, ys, dx, dy }, k) {
+    for (let i = 0; i < count; i++) {
+        for (let j = i + 1; j < count; j++) {
+            let deltaX = xs[i] - xs[j];
+            let deltaY = ys[i] - ys[j];
+            let distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+            if (distance < EPSILON) {
+                // Coincident nodes: nudge along a deterministic direction so the
+                // pair separates instead of dividing by ~zero forever.
+                deltaX = EPSILON;
+                deltaY = 0;
+                distance = EPSILON;
+            }
+            const force = (k * k) / distance;
+            const unitX = (deltaX / distance) * force;
+            const unitY = (deltaY / distance) * force;
+            dx[i] += unitX;
+            dy[i] += unitY;
+            dx[j] -= unitX;
+            dy[j] -= unitY;
+        }
+    }
+}
+/** Attraction along every resolved edge, pulling its endpoints together. */
+function accumulateAttraction({ xs, ys, dx, dy }, links, k) {
+    for (const [from, to] of links) {
+        const deltaX = xs[from] - xs[to];
+        const deltaY = ys[from] - ys[to];
+        const distance = Math.max(Math.sqrt(deltaX * deltaX + deltaY * deltaY), EPSILON);
+        const force = (distance * distance) / k;
+        const unitX = (deltaX / distance) * force;
+        const unitY = (deltaY / distance) * force;
+        dx[from] -= unitX;
+        dy[from] -= unitY;
+        dx[to] += unitX;
+        dy[to] += unitY;
+    }
+}
+/**
+ * Moves every node along its accumulated displacement, capped at `temperature`
+ * so late iterations refine rather than reshuffle.
+ */
+function applyDisplacement({ count, xs, ys, dx, dy }, temperature) {
+    for (let i = 0; i < count; i++) {
+        const magnitude = Math.max(Math.sqrt(dx[i] * dx[i] + dy[i] * dy[i]), EPSILON);
+        const step = Math.min(magnitude, temperature);
+        xs[i] += (dx[i] / magnitude) * step;
+        ys[i] += (dy[i] / magnitude) * step;
+    }
+}
+/**
+ * Rescales raw simulation output into the viewport with a uniform margin,
+ * preserving aspect ratio so the drawing is not distorted. Coordinates are
+ * rounded to two decimals: enough precision to draw, few enough digits to keep
+ * the artifact small and its bytes stable.
+ */
+function fitToViewport(nodes, xs, ys) {
+    const margin = VIEWPORT * 0.04;
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < nodes.length; i++) {
+        if (xs[i] < minX)
+            minX = xs[i];
+        if (xs[i] > maxX)
+            maxX = xs[i];
+        if (ys[i] < minY)
+            minY = ys[i];
+        if (ys[i] > maxY)
+            maxY = ys[i];
+    }
+    const spanX = maxX - minX;
+    const spanY = maxY - minY;
+    const usable = VIEWPORT - 2 * margin;
+    // One shared scale keeps the aspect ratio; a zero span means every node
+    // collapsed onto one axis, so that axis simply centres.
+    const scale = Math.min(spanX > EPSILON ? usable / spanX : Number.POSITIVE_INFINITY, spanY > EPSILON ? usable / spanY : Number.POSITIVE_INFINITY);
+    const effective = Number.isFinite(scale) ? scale : 1;
+    const offsetX = margin + (usable - spanX * effective) / 2;
+    const offsetY = margin + (usable - spanY * effective) / 2;
+    return nodes.map((node, i) => ({
+        id: node.id,
+        x: round2((xs[i] - minX) * effective + offsetX),
+        y: round2((ys[i] - minY) * effective + offsetY),
+    }));
+}
+function round2(value) {
+    return Math.round(value * 100) / 100;
+}

package/dist/src/graph-query-health.js

@@ -0,0 +1,115 @@
+function hasNonReconciliableDamage(graph) {
+    if (Object.values(graph.orphaned).some((count) => count > 0))
+        return true;
+    const lifecycleIssues = new Set(graph.lifecycle?.issues ?? []);
+    const reconcilablePrefixes = [
+        "indexed file no longer exists: ",
+        "indexed file is no longer eligible: ",
+        "indexed snapshot differs from disk: ",
+    ];
+    return graph.missing.records.some((record) => !lifecycleIssues.has(record) &&
+        !reconcilablePrefixes.some((prefix) => record.startsWith(prefix)));
+}
+function unavailableState(graph) {
+    if (graph.freshness?.state === "queued")
+        return "queued";
+    if (graph.freshness?.state === "indexing")
+        return "indexing";
+    if (graph.status === "indexing")
+        return "indexing";
+    if (graph.schemaVersion === 0)
+        return graph.coverage.sourceFiles === 0 ? "empty-repository" : "not-initialized";
+    if (graph.coverage.sourceFiles === 0)
+        return "empty-repository";
+    if (graph.coverage.indexedFiles === 0)
+        return "empty-index";
+    if (graph.status === "repair-needed" && hasNonReconciliableDamage(graph))
+        return "repair-needed";
+    return null;
+}
+export async function inspectGraphQueryHealth(repo, status) {
+    try {
+        const graph = await status(repo);
+        const state = unavailableState(graph);
+        if (!state)
+            return {
+                available: true,
+                state: graph.lifecycle && graph.lifecycle.status !== "healthy"
+                    ? "lifecycle-degraded"
+                    : "healthy",
+                graph,
+            };
+        return {
+            available: false,
+            status: "unavailable",
+            state,
+            graph,
+            remediation: graph.repairSteps,
+        };
+    }
+    catch (error) {
+        return {
+            available: false,
+            status: "unavailable",
+            state: "unknown",
+            remediation: ["Run `knodin doctor` and `knodin status --deep`."],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function hasNoMatches(value) {
+    if (Array.isArray(value.results))
+        return value.results.length === 0;
+    if (typeof value.count === "number")
+        return value.count === 0;
+    if (typeof value.changedFileCount === "number")
+        return value.changedFileCount === 0;
+    if (typeof value.summary === "string" && /\bnot found\b/i.test(value.summary))
+        return true;
+    if (typeof value.refused === "string" &&
+        /\b(?:not found|no edit sites|no matches)\b/i.test(value.refused))
+        return true;
+    return false;
+}
+/** Add an explicit healthy/no-match outcome without replacing operation data. */
+export function decorateGraphQueryResult(value, graphState = "healthy", freshness) {
+    if (value === null || value === undefined) {
+        return {
+            status: "no-match",
+            result: value ?? null,
+            ...(freshness ? { freshness } : {}),
+            availability: { state: "no-match", graphState, outcome: "no-match" },
+        };
+    }
+    if (Array.isArray(value)) {
+        return {
+            status: value.length === 0 ? "no-match" : "ok",
+            results: value,
+            ...(freshness ? { freshness } : {}),
+            availability: {
+                state: value.length === 0 ? "no-match" : graphState,
+                graphState,
+                outcome: value.length === 0 ? "no-match" : "matches",
+            },
+        };
+    }
+    if (typeof value !== "object") {
+        return {
+            result: value,
+            ...(freshness ? { freshness } : {}),
+            availability: { state: graphState, outcome: "complete" },
+        };
+    }
+    const root = value;
+    const noMatch = hasNoMatches(root) && root.ambiguity === undefined;
+    return {
+        ...root,
+        ...(freshness ? { freshness } : {}),
+        ...(noMatch && root.status === undefined ? { status: "no-match" } : {}),
+        availability: {
+            state: noMatch ? "no-match" : graphState,
+            graphState,
+            outcome: noMatch ? "no-match" : "matches",
+        },
+    };
+}

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);
+}

package/dist/src/index-activity.js

@@ -0,0 +1,126 @@
+import child_process from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveStateDir } from "./engine/state-paths.js";
+function activityPath(repo) {
+    return path.join(resolveStateDir(repo), "index-activity.json");
+}
+const ACTIVITY_CLOCK_SKEW_MS = 2_000;
+const MAX_ACTIVITY_AGE_MS = 7 * 24 * 60 * 60 * 1_000;
+const INDEX_PHASES = new Set([
+    "starting",
+    "collecting-files",
+    "indexing-files",
+    "embedding-model",
+    "embedding-symbols",
+    "finalizing",
+    "verifying",
+    "completed",
+]);
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function processStartedAt(pid) {
+    if (pid === process.pid)
+        return Date.now() - process.uptime() * 1_000;
+    if (process.platform === "win32")
+        return null;
+    try {
+        const output = child_process.execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const startedAt = Date.parse(output.trim());
+        return Number.isFinite(startedAt) ? startedAt : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Cross-process, source-safe status for a currently running index operation. */
+export function createIndexActivityReporter(repo) {
+    const target = activityPath(repo);
+    const startedAt = new Date().toISOString();
+    const write = (activity) => {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        const temporary = `${target}.${process.pid}.tmp`;
+        try {
+            fs.writeFileSync(temporary, `${JSON.stringify(activity)}\n`, "utf8");
+            fs.renameSync(temporary, target);
+        }
+        finally {
+            fs.rmSync(temporary, { force: true });
+        }
+    };
+    return {
+        start() {
+            write({
+                pid: process.pid,
+                startedAt,
+                updatedAt: startedAt,
+                phase: "starting",
+                phaseCompleted: 0,
+                message: "Opening local graph database",
+            });
+        },
+        update(event) {
+            write({
+                pid: process.pid,
+                startedAt,
+                updatedAt: new Date().toISOString(),
+                phase: event.phase,
+                phaseCompleted: event.phaseCompleted,
+                ...(event.phaseTotal === undefined ? {} : { phaseTotal: event.phaseTotal }),
+                message: event.message,
+            });
+        },
+        stop() {
+            try {
+                const current = JSON.parse(fs.readFileSync(target, "utf8"));
+                if (current.pid === process.pid)
+                    fs.unlinkSync(target);
+            }
+            catch { }
+        },
+    };
+}
+/** Return only a live operation; crash-left activity files never claim freshness. */
+export function readIndexActivity(repo) {
+    try {
+        const activity = JSON.parse(fs.readFileSync(activityPath(repo), "utf8"));
+        if (!Number.isInteger(activity.pid) || activity.pid <= 0 || !processIsAlive(activity.pid))
+            return null;
+        const now = Date.now();
+        const startedAt = Date.parse(activity.startedAt);
+        const updatedAt = Date.parse(activity.updatedAt);
+        if (!Number.isFinite(startedAt) ||
+            !Number.isFinite(updatedAt) ||
+            startedAt > now + ACTIVITY_CLOCK_SKEW_MS ||
+            updatedAt < startedAt ||
+            updatedAt > now + ACTIVITY_CLOCK_SKEW_MS ||
+            now - startedAt > MAX_ACTIVITY_AGE_MS ||
+            !INDEX_PHASES.has(activity.phase) ||
+            !Number.isFinite(activity.phaseCompleted) ||
+            activity.phaseCompleted < 0 ||
+            (activity.phaseTotal !== undefined &&
+                (!Number.isFinite(activity.phaseTotal) ||
+                    activity.phaseTotal < 0 ||
+                    activity.phaseCompleted > activity.phaseTotal)) ||
+            typeof activity.message !== "string") {
+            return null;
+        }
+        const processStart = processStartedAt(activity.pid);
+        if (processStart !== null && processStart > startedAt + ACTIVITY_CLOCK_SKEW_MS)
+            return null;
+        return activity;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/init-progress-worker.js

@@ -1,3 +1,71 @@
 #!/usr/bin/env node
-import{a as i,b as d}from"../chunks/chunk-SIJAQVSX.js";import{clearLine as v,moveCursor as x,cursorTo as h}from"node:readline";import w from"ora";var T=process.stderr.isTTY===!0||process.env.KNODIN_FORCE_PROGRESS_TTY==="1",O={isTTY:T,columns:i(process.stderr.columns,80),rows:i(process.stderr.rows,24),write:process.stderr.write.bind(process.stderr),cursorTo:(e,r,t)=>h(process.stderr,e,r,t),moveCursor:(e,r,t)=>x(process.stderr,e,r,t),clearLine:(e,r)=>v(process.stderr,e,r),once:process.stderr.once.bind(process.stderr),removeListener:process.stderr.removeListener.bind(process.stderr)},n=w({text:"[init:starting] Opening local graph database (0s elapsed)",stream:O,isEnabled:T,discardStdin:!1}),s="",f=!1,m=!1,g=0,o="init",p="[init:starting] Opening local graph database",a;function c(){let e=Math.max(0,Math.floor((Date.now()-g)/1e3));n.text=`${p} (${e}s elapsed)`}function u(e=o){n.isSpinning||(o=e,p=`[${o}:starting] Opening local graph database`,g=Date.now(),c(),n.start(),a=setInterval(c,250))}function l(e=!1){if(f||(f=!0,a&&clearInterval(a),n.stop()),e&&!m){m=!0;let r=setTimeout(()=>process.exit(0),100);process.stderr.write("\r\x1B[2K",()=>{clearTimeout(r),process.exit(0)})}}function b(e){if(!e)return;let r=JSON.parse(e);r.type==="start"?u(r.operation):r.type==="progress"?(n.isSpinning||u(),p=d(r.event,void 0,o),c()):l(!0)}process.stdin.setEncoding("utf8");process.stdin.on("data",e=>{for(s+=e;;){let r=s.indexOf(`
-`);if(r<0)break;let t=s.slice(0,r);s=s.slice(r+1);try{b(t)}catch{}}});process.stdin.on("end",()=>{if(s)try{b(s)}catch{}l(!0)});process.on("SIGTERM",()=>{l(),process.exit(0)});
+import ora from "ora";
+import { formatProgress } from "./init-progress.js";
+import { consumeProgressLines, createProgressStream } from "./progress-worker-runtime.js";
+const terminalEnabled = process.stderr.isTTY === true || process.env.KNODIN_FORCE_PROGRESS_TTY === "1";
+// Ora divides rendered text width by `stream.columns`. Some pseudo-terminals
+// report zero columns, which turns its clear loop into an infinite loop. Keep
+// the real terminal methods while guaranteeing finite viewport dimensions.
+const progressStream = createProgressStream(terminalEnabled);
+const spinner = ora({
+    text: "[init:starting] Opening local graph database (0s elapsed)",
+    stream: progressStream,
+    isEnabled: terminalEnabled,
+    discardStdin: false,
+});
+let stopped = false;
+let exiting = false;
+let startedAt = 0;
+let operation = "init";
+let current = "[init:starting] Opening local graph database";
+let clock;
+function refreshText() {
+    const elapsed = Math.max(0, Math.floor((Date.now() - startedAt) / 1_000));
+    spinner.text = `${current} (${elapsed}s elapsed)`;
+}
+function start(nextOperation = operation) {
+    if (spinner.isSpinning)
+        return;
+    operation = nextOperation;
+    current = `[${operation}:starting] Opening local graph database`;
+    startedAt = Date.now();
+    refreshText();
+    spinner.start();
+    clock = setInterval(refreshText, 250);
+}
+function stop(exitAfter = false) {
+    if (!stopped) {
+        stopped = true;
+        if (clock)
+            clearInterval(clock);
+        spinner.stop();
+    }
+    if (exitAfter && !exiting) {
+        exiting = true;
+        const exitTimer = setTimeout(() => process.exit(0), 100);
+        process.stderr.write("\r\x1b[2K", () => {
+            clearTimeout(exitTimer);
+            process.exit(0);
+        });
+    }
+}
+function handle(line) {
+    if (!line)
+        return;
+    const message = JSON.parse(line);
+    if (message.type === "start")
+        start(message.operation);
+    else if (message.type === "progress") {
+        if (!spinner.isSpinning)
+            start();
+        current = formatProgress(message.event, undefined, operation);
+        refreshText();
+    }
+    else
+        stop(true);
+}
+consumeProgressLines(handle, () => stop(true));
+process.on("SIGTERM", () => {
+    stop();
+    process.exit(0);
+});