knodin 0.10.2 → 0.10.4

package/dist/bin/cli.js

@@ -77,8 +77,17 @@ function integrationAgents(repo) {
     const repositoryDetected = inspectRepositoryIntegrationStatus(repo)?.agents ?? [];
     return [...new Set([...detectSupportedAgents(), ...previous, ...repositoryDetected])];
 }
-function formatInitHuman(result) {
-    let agents = `${result.paths.scope} — no supported coding agents detected`;
+export function formatInitHuman(result) {
+    // `configured` is what THIS run wrote, not what exists on the machine. The
+    // old wording called an empty list "no supported coding agents detected",
+    // asserting a detection result init never computed — and it read as a flat
+    // contradiction of the `status` line seconds later, which lists the agents
+    // that genuinely are configured (EASFDC-8499).
+    //
+    // Deliberately not calling the detector here: a formatter that reads the
+    // machine cannot be tested deterministically, and the honest fix is to stop
+    // claiming more than this value supports rather than to go find more.
+    let agents = `${result.paths.scope} — no agents configured by this run`;
     if (result.paths.scope === "cli-only")
         agents = "CLI-only — AI agents are not configured to discover knodin";
     else if (result.paths.agentIntegration.configured.length > 0)
@@ -138,16 +147,29 @@ function formatRepairHuman(result) {
     const detail = firstIssue ? ` First issue: ${firstIssue}.` : "";
     return `Repair finished with ${outstanding.toLocaleString()} remaining issue(s).${detail} Run \`knodin status --deep\` for details.\n`;
 }
+/**
+ * The semantic gap, stated rather than left to be discovered.
+ *
+ * An index that deferred embeddings leaves `search` returning a short list, and
+ * a short list is indistinguishable from a thorough search that found little.
+ * Saying nothing here is what turns a deliberate deferral into a silent one.
+ */
+function formatSemanticGap(readiness) {
+    if (readiness === undefined || readiness === "ready")
+        return "";
+    return ` Semantic coverage is ${readiness}: \`search\` will under-return until \`knodin index\` completes embeddings.`;
+}
 function formatIndexHuman(result) {
+    const semantic = formatSemanticGap(result.semanticReadiness);
     if (result.indexed.length === 0 && result.unchanged.length > 0) {
         const noun = result.unchanged.length === 1 ? "file" : "files";
-        return `Graph already current: ${result.unchanged.length.toLocaleString()} requested ${noun} needed no work; health verified.\n`;
+        return `Graph already current: ${result.unchanged.length.toLocaleString()} requested ${noun} needed no work; health verified.${semantic}\n`;
     }
     const unchanged = result.unchanged.length > 0
         ? `; ${result.unchanged.length.toLocaleString()} already current`
         : "";
     const noun = result.indexed.length === 1 ? "file" : "files";
-    return `Index complete: ${result.indexed.length.toLocaleString()} ${noun} indexed${unchanged}; graph health verified.\n`;
+    return `Index complete: ${result.indexed.length.toLocaleString()} ${noun} indexed${unchanged}; graph health verified.${semantic}\n`;
 }
 function formatIndexVerificationError(result) {
     const firstIssue = result.verification.missing.files[0] ?? result.verification.missing.records[0];
@@ -2168,6 +2190,8 @@ async function main() {
                 process.exit(1);
             }
             const clean = rest.includes("--clean") || rest.includes("--force");
+            const skipEmbeddings = rest.includes("--skip-embeddings");
+            const under = selectorValue("--under");
             const scipPath = selectorValue("--scip");
             const sarifPath = selectorValue("--sarif");
             // A bound the operator cannot move is just a failure, so every import
@@ -2198,6 +2222,8 @@ async function main() {
             let indexResult;
             try {
                 indexResult = await engine.index(plan.repo, plan.files, clean, {
+                    skipEmbeddings,
+                    ...(under !== undefined ? { under } : {}),
                     scip: scipPath
                         ? {
                             path: scipPath,
@@ -2904,6 +2930,17 @@ async function main() {
         process.exitCode = finalExitCode;
         return;
     }
+    // `search` has no human formatter — results fall through to the generic JSON
+    // emitter — so a semantically incomplete graph produced a short list with
+    // nothing saying why. The list looks like a thorough answer, which is the
+    // whole failure. Printed to stderr so it annotates without corrupting output
+    // anyone is piping.
+    if (cmd === "search" && !jsonOutput) {
+        const readiness = result.semanticReadiness;
+        const gap = formatSemanticGap(readiness);
+        if (gap)
+            process.stderr.write(`${gap.trim()}\n`);
+    }
     if (cmd === "status" && !jsonOutput) {
         process.stdout.write(formatStatusHuman(boundedResult));
         process.exitCode = finalExitCode;

package/dist/src/cli-args.js

@@ -36,6 +36,10 @@ const GLOBAL_BOOLEAN_FLAGS = new Set(["--exclude-tests", "--data-flow", "--json"
  * not to index the log as a source file.
  */
 const COMMAND_VALUE_FLAGS = new Set([
+    // Takes a directory. Without this its argument reads as a positional, and
+    // `knodin index --under src` would be rejected as "a directory positional"
+    // by the very rule that exists to stop people scoping this way by accident.
+    "--under",
     "--scip",
     "--scip-max-bytes",
     "--scip-max-files",

package/dist/src/cli-model.js

@@ -288,6 +288,8 @@ function createCliProgram(capture = () => { }) {
     leaf(program, "index [files...]", "index a repository or selected files", capture)
         .option("--clean", "rebuild selected index state")
         .option("--force", "force clean indexing")
+        .option("--skip-embeddings", "build structure only and defer semantic embeddings; `search` under-returns until a later `knodin index` completes them")
+        .option("--under <dir>", "rebuild only the files under a repository-relative directory; coverage is then reported as a lower bound until a full index runs")
         .option("--scip <file>", "opt in to a bounded local SCIP protobuf import")
         .addOption(option("--scip-max-bytes <count>", "raise the SCIP input size ceiling", "integer"))
         .addOption(option("--scip-max-files <count>", "raise the SCIP document ceiling", "integer"))

package/dist/src/engine/candidate-database.js

@@ -66,6 +66,59 @@ export function candidateRoot(repo) {
 export function promotionMarkerPath(repo) {
     return path.join(resolveStateDir(repo), PROMOTION_MARKER);
 }
+/**
+ * Candidates left on disk for this repository, newest first.
+ *
+ * A clean index discards its candidate on failure, but a killed process runs no
+ * discard — so survivors are exactly the runs that were interrupted rather than
+ * the ones that failed. Listing them is what lets the next run continue instead
+ * of repeating hours of work.
+ *
+ * Returns descriptors only. Whether any of them is safe to resume is decided by
+ * the caller from the database's own contents, not from the fact it exists.
+ */
+export function listCandidates(repo) {
+    const resolvedRepo = path.resolve(repo);
+    const root = candidateRoot(resolvedRepo);
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const found = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.startsWith("candidate-"))
+            continue;
+        const databasePath = path.join(root, entry.name, "db.sqlite");
+        let modifiedMs;
+        try {
+            modifiedMs = fs.statSync(databasePath).mtimeMs;
+        }
+        catch {
+            // A directory with no database is a half-created candidate, not a
+            // resumable one.
+            continue;
+        }
+        found.push({
+            candidate: {
+                schemaVersion: 1,
+                id: entry.name,
+                repo: resolvedRepo,
+                databasePath,
+                createdAt: new Date(modifiedMs).toISOString(),
+            },
+            modifiedMs,
+        });
+    }
+    // Sorted as its own statement rather than mid-chain: an in-place `sort`
+    // inside an expression mutates the array being read, which is harmless for
+    // this local but reads as a side effect at a glance. (`toSorted` would be
+    // the nicer form but needs a newer `lib` than this project targets.)
+    found.sort((a, b) => b.modifiedMs - a.modifiedMs);
+    return found.map((item) => item.candidate);
+}
 export function allocateCandidate(repo) {
     const resolvedRepo = path.resolve(repo);
     const root = candidateRoot(resolvedRepo);