@autorag/librarian 2.13.3 → 2.13.5

package/dist/jikji/answer-pack.d.ts

@@ -1,5 +1,11 @@
 import type { SourceRoot } from "../filesystem/source-paths.js";
-import type { JikjiAnswerPack } from "./types.js";
+import type { JikjiAnswerPack, JikjiConfidence } from "./types.js";
+/**
+ * Combine the confidence of several roots' responses into one. Weakest wins: the root with the lowest level
+ * (then lowest score) supplies every field, and `requiresLlmRerank` is true when any root asked for it. A
+ * missing or unknown level counts as the weakest.
+ */
+export declare function mergeJikjiConfidence(entries: readonly (JikjiConfidence | undefined)[]): JikjiConfidence | undefined;
 /**
  * Strict-parse and validate a `jikji find --json` answer-pack from raw stdout.
  *

package/dist/jikji/client.d.ts

@@ -1,27 +1,41 @@
-import type { JikjiFindOptions, JikjiFindResult, JikjiOptions, JikjiPrepareOptions, JikjiPrepareResult } from "./types.js";
+import type { JikjiFindOptions, JikjiFindResult, JikjiOptions, JikjiPrepareOptions, JikjiPrepareResult, JikjiRetryStep } from "./types.js";
 export declare class JikjiClient {
     private readonly options;
-    private resolvedCommand;
-    private installCommandInFlight;
+    private resolved;
+    private installInFlight;
     private readonly prepareQueue;
     private readonly findQueue;
     constructor(options?: JikjiOptions);
     /**
-     * Resolve the jikji command following the priority chain:
-     * 1. explicit binaryPath
-     * 2. PATH lookup for `jikji`
-     * 3. cached `<root>/.autorag/bin/jikji`
-     * 4. autoInstall (default true) via `cargo install jikji-cli` into the cache
-     *    — only for `prepare` (refresh); `find` passes `install: false` so a
-     *    query never waits on an install
-     * 5. bare `jikji` (spawn-error degrade preserves the previous behavior)
-     * A found binary is cached per client. The bare fallback is cached only after
-     * an install attempt, so a query-time miss does not block a later refresh
-     * from installing.
+     * Resolve the jikji command, refusing any binary below {@link JIKJI_MIN_VERSION}:
+     * 1. explicit binaryPath: used as given, never probed (the operator chose it).
+     * 2. PATH lookup for `jikji`, then cached `<root>/.autorag/bin/jikji`. The first one
+     *    whose `--version` clears the floor wins. A binary whose `--version` output is
+     *    not recognised is used as-is, so a custom build is never locked out.
+     * 3. Every candidate was below the floor (or none exists): `prepare` installs the
+     *    pinned {@link JIKJI_INSTALL_VERSION} into the cache with `cargo install --force`.
+     *    `find` (`install: false`) never installs; it reports the stale version instead.
+     * 4. Nothing resolvable and no root or autoInstall off: bare `jikji` (spawn-error
+     *    degrade preserves the previous behavior).
+     * A usable result is cached per client. A query-time miss is not cached, so a later
+     * refresh can still install.
      */
     private resolveCommand;
+    /** Run `<candidate> --version` and decide whether it clears the floor. */
+    private probe;
     prepare(root: string, options?: JikjiPrepareOptions): Promise<JikjiPrepareResult>;
     find(root: string, query: string, options?: JikjiFindOptions): Promise<JikjiFindResult>;
+    /**
+     * Run the follow-up step jikji named in a `jikji_retry` answer: `discover`
+     * with the proof it issued, parsed like a `find` result. Queued with finds
+     * (a query never waits behind a refresh) and, like `find`, never installs the
+     * binary, refreshes in the background, or reindexes. A step whose root is not
+     * the root being queried is refused before anything is spawned: jikji binds
+     * each proof to one root, so it must not be applied to another.
+     */
+    discover(root: string, step: JikjiRetryStep, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<JikjiFindResult>;
     /**
      * Hang guard for one root, never a fixed total wall: `timeoutMs` (base) plus a
      * per-file slice for every file under the root, so a very large root is not

package/dist/jikji/diagnostics.d.ts

@@ -5,10 +5,10 @@ import type { JikjiFindResult, JikjiPrepareResult } from "./types.js";
  * path-free so they can be surfaced through public search/refresh diagnostics
  * without leaking filesystem or binary paths.
  */
-export type JikjiDiagnosticCode = "jikji-unavailable" | "jikji-prepare-failed" | "jikji-find-failed";
+export type JikjiDiagnosticCode = "jikji-unavailable" | "jikji-prepare-failed" | "jikji-cloud-root-skipped" | "jikji-find-failed" | "jikji-discover-failed" | "jikji-unsupported-version";
 export interface JikjiDiagnostic {
     readonly code: JikjiDiagnosticCode;
-    readonly severity: "warning" | "error";
+    readonly severity: "info" | "warning" | "error";
     readonly message: string;
     readonly source: "jikji";
 }
@@ -22,5 +22,19 @@ export declare function jikjiPrepareDiagnostic(result: JikjiPrepareResult): Jikj
  * Maps a {@link JikjiFindResult} to a path-opaque degraded-mode diagnostic.
  * Successful results map to `undefined`. The message never echoes the binary
  * path, stderr, or any filesystem path so it is safe for public diagnostics.
+ * The one exception is an unsupported version, see {@link unsupportedVersionDiagnostic}.
  */
 export declare function jikjiFindDiagnostic(result: JikjiFindResult): JikjiDiagnostic | undefined;
+/**
+ * Maps a failed `discover` retry step to a diagnostic. Unlike find/prepare
+ * diagnostics it is deliberately NOT path-opaque: the retry step is the one
+ * place AutoRAG runs jikji on the model's behalf after a miss, so a failure
+ * must be debuggable and carries the CLI exit status and stderr verbatim,
+ * real paths included. Successful results map to `undefined`.
+ */
+export declare function jikjiDiscoverDiagnostic(result: JikjiFindResult): JikjiDiagnostic | undefined;
+/**
+ * `jikji_retry` named follow-up commands AutoRAG could not turn into a
+ * `discover` step. The commands are quoted verbatim so the shape can be fixed.
+ */
+export declare function jikjiUnusableRetryDiagnostic(nextCommands: readonly string[]): JikjiDiagnostic;

package/dist/jikji/index.d.ts

@@ -1,10 +1,10 @@
-export { normalizeJikjiAnswerPath, parseJikjiAnswerPack, } from "./answer-pack.js";
+export { mergeJikjiConfidence, normalizeJikjiAnswerPath, parseJikjiAnswerPack, } from "./answer-pack.js";
 export { JikjiClient } from "./client.js";
 export type { JikjiDiagnostic, JikjiDiagnosticCode } from "./diagnostics.js";
-export { jikjiFindDiagnostic, jikjiPrepareDiagnostic } from "./diagnostics.js";
+export { jikjiDiscoverDiagnostic, jikjiFindDiagnostic, jikjiPrepareDiagnostic, jikjiUnusableRetryDiagnostic, } from "./diagnostics.js";
 export type { EnsureJikjiBinaryOptions, EnsureJikjiBinaryResult, JikjiInstallRunner, JikjiInstallRunResult, } from "./installer.js";
 export { cachedJikjiBinaryPath, ensureJikjiBinary, JIKJI_CRATE_NAME, JIKJI_INSTALL_TIMEOUT_MS, jikjiExecutableName, lookupExecutableInPath, } from "./installer.js";
 export type { JikjiSourceRoot } from "./path-map.js";
 export { mapJikjiPath, outermostJikjiRoots, planJikjiSourceRoots, resolveReturnedPath } from "./path-map.js";
-export type { JikjiAnswerPack, JikjiCandidate, JikjiEvidence, JikjiFailureReason, JikjiFindOptions, JikjiFindResult, JikjiHandoffAction, JikjiNextRead, JikjiOptions, JikjiPrepareOptions, JikjiPrepareResult, JikjiToolCallPolicy, } from "./types.js";
+export type { JikjiAnswerPack, JikjiCandidate, JikjiConfidence, JikjiEvidence, JikjiFailureReason, JikjiFindOptions, JikjiFindResult, JikjiHandoffAction, JikjiNextRead, JikjiOptions, JikjiPrepareOptions, JikjiPrepareResult, JikjiRetryStep, JikjiToolCallPolicy, } from "./types.js";
 export { DEFAULT_JIKJI_OPTIONS } from "./types.js";

package/dist/jikji/installer.d.ts

@@ -1,9 +1,10 @@
 /**
  * Jikji CLI installer. Jikji ships as the `jikji-cli` crate on crates.io
- * (binary name `jikji`); there are no prebuilt GitHub release binaries, so
- * installation compiles from source through the user's Rust toolchain.
- * The binary is cached under `<root>/.autorag/bin` — the same directory the
- * MinSync installer uses.
+ * (binary name `jikji`). Since v0.2.0 it also publishes prebuilt GitHub release
+ * archives, but AutoRAG still installs by compiling the crate through the user's
+ * Rust toolchain so the pinned version (`JIKJI_INSTALL_VERSION`) is built from the
+ * published, checksummed source. The binary is cached under `<root>/.autorag/bin`
+ * — the same directory the MinSync installer uses.
  */
 export declare const JIKJI_CRATE_NAME = "jikji-cli";
 export declare const JIKJI_INSTALL_TIMEOUT_MS: number;
@@ -20,8 +21,13 @@ export type JikjiInstallRunner = (args: readonly string[], timeoutMs: number) =>
 export interface EnsureJikjiBinaryOptions {
     /** Workspace root; the binary is cached at `<root>/.autorag/bin/jikji`. */
     readonly root: string;
-    /** crates.io version pin for `jikji-cli`. Defaults to latest. */
+    /** crates.io version pin for `jikji-cli`. Omit to install the latest release. */
     readonly version?: string;
+    /**
+     * Reinstall over an existing cached binary (`cargo install --force`). Without it a
+     * cached binary is returned untouched, so a stale cached build would never be replaced.
+     */
+    readonly force?: boolean;
     readonly env?: NodeJS.ProcessEnv;
     readonly timeoutMs?: number;
     /** Injectable process runner for tests. Defaults to spawning `cargo install`. */

package/dist/jikji/retry-command.d.ts

@@ -0,0 +1,10 @@
+import type { JikjiRetryStep } from "./types.js";
+/**
+ * Read the `jikji discover` step out of a `next_commands` entry. The command is
+ * data: AutoRAG builds its own argv from the parsed root, query, top-k and
+ * proof, never runs the string. Returns `undefined` unless the line is exactly
+ * a `discover <root> <query>` retry (`--after-jikji-retry` plus a proof, only
+ * flags AutoRAG understands) whose proof matches `envelopeProof` when jikji
+ * also reports one, so an unknown or tampered shape never reaches a process.
+ */
+export declare function parseJikjiRetryCommand(command: string, envelopeProof: string | undefined): JikjiRetryStep | undefined;

package/dist/jikji/types.d.ts

@@ -66,8 +66,15 @@ export interface JikjiPrepareOptions {
     readonly timeoutMs?: number;
     /** `--parse-timeout` seconds for this root; replaces the client `parseTimeout`. */
     readonly parseTimeout?: number;
+    /**
+     * Extra `--exclude` patterns for this one root, appended to the client's own list. AutoRAG passes the
+     * relative paths of cloud or network folders nested under the root so `jikji prepare` never reads them.
+     */
+    readonly exclude?: readonly string[];
 }
-export type JikjiFailureReason = "aborted" | "nonzero-exit" | "spawn-error" | "stderr-too-large" | "stdout-too-large" | "timeout" | "bad-answer-pack";
+export type JikjiFailureReason = "aborted" | "cloud-root-skipped" | "nonzero-exit" | "spawn-error" | "stderr-too-large" | "stdout-too-large" | "timeout" | "bad-answer-pack" | "bad-retry-step"
+/** The resolved `jikji` is older than {@link JIKJI_MIN_VERSION}; it was probed, never run for real. */
+ | "unsupported-version";
 export type JikjiPrepareResult = {
     readonly ok: true;
     readonly stdout: string;
@@ -79,6 +86,8 @@ export type JikjiPrepareResult = {
     readonly stdout: string;
     readonly stderr: string;
     readonly code: number | null;
+    /** Set with `reason: "unsupported-version"`: the version `jikji --version` reported. */
+    readonly detectedVersion?: string;
 };
 export type JikjiNextRead = "cache" | "wiki" | "original" | "none";
 export interface JikjiCandidate {
@@ -87,6 +96,18 @@ export interface JikjiCandidate {
     readonly label?: string;
     readonly score?: number;
 }
+/**
+ * Response-level confidence jikji reports for one `find`. A signal, not a verdict: jikji reports `high`
+ * confidence for weak matches, so nothing here may skip reranking or verification.
+ */
+export interface JikjiConfidence {
+    readonly level?: string;
+    readonly score?: number;
+    readonly answerability?: string;
+    readonly recommendedAction?: string;
+    readonly requiresLlmRerank?: boolean;
+    readonly indexStatus?: string;
+}
 export interface JikjiEvidence {
     readonly path: string;
     readonly nextRead: JikjiNextRead;
@@ -97,6 +118,17 @@ export interface JikjiToolCallPolicy {
     readonly allowedFollowups: readonly string[];
 }
 export type JikjiHandoffAction = "direct_use" | "jikji_retry" | "raw_fallback_after_retry";
+/**
+ * The follow-up step jikji names when `find` answers `jikji_retry`: a
+ * `discover` run on the same root with the rewritten query and the proof jikji
+ * issued for exactly that root and query.
+ */
+export interface JikjiRetryStep {
+    readonly root: string;
+    readonly query: string;
+    readonly topK?: number;
+    readonly proof: string;
+}
 export interface JikjiAnswerPack {
     readonly answerPaths: readonly string[];
     readonly paths: readonly string[];
@@ -105,6 +137,18 @@ export interface JikjiAnswerPack {
     readonly handoffAction: JikjiHandoffAction;
     readonly toolCallPolicy: JikjiToolCallPolicy;
     readonly agentShouldNotRerank: boolean;
+    /** Absent when jikji reported none of the confidence fields. */
+    readonly confidence?: JikjiConfidence;
+    /** `raw_fallback_allowed`; derived from the handoff when the envelope omits it. */
+    readonly rawFallbackAllowed: boolean;
+    /** `max_jikji_retries`: how many more jikji steps jikji allows before raw fallback. */
+    readonly maxJikjiRetries?: number;
+    /** `max_raw_fallback_commands`: raw shell commands jikji allows once raw fallback is open. */
+    readonly maxRawFallbackCommands?: number;
+    /** `next_commands` verbatim. */
+    readonly nextCommands?: readonly string[];
+    /** Present only for `jikji_retry` when `next_commands` names an understood discover step. */
+    readonly retry?: JikjiRetryStep;
 }
 export interface JikjiFindOptions {
     readonly topK?: number;
@@ -126,4 +170,6 @@ export type JikjiFindResult = {
     readonly stdout: string;
     readonly stderr: string;
     readonly code: number | null;
+    /** Set with `reason: "unsupported-version"`: the version `jikji --version` reported. */
+    readonly detectedVersion?: string;
 };

package/dist/jikji/version.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Jikji version policy.
+ *
+ * AutoRAG talks to the `jikji` CLI through a fixed argv, so it must refuse a binary that
+ * cannot accept that argv instead of spawning it and reporting a generic failure.
+ */
+/**
+ * Oldest `jikji` AutoRAG will run. `jikji find` only accepts `--no-background-refresh`
+ * from 0.2.0 (0.1.1 exits 2 with `unexpected argument`), and AutoRAG passes it on every find.
+ */
+export declare const JIKJI_MIN_VERSION = "0.2.0";
+/**
+ * Version AutoRAG installs and pins. 0.2.1 is the first 0.2.x with the Windows rooted
+ * cache-path rejection (a path such as `\secret` or `C:\x` is no longer joined onto the store).
+ */
+export declare const JIKJI_INSTALL_VERSION = "0.2.1";
+/** Version from `jikji --version` output, or `undefined` when the output is not a jikji version line. */
+export declare function parseJikjiVersion(output: string): string | undefined;
+/** True when `version` is at or above {@link JIKJI_MIN_VERSION}. Numeric, per component. */
+export declare function isSupportedJikjiVersion(version: string): boolean;