@autorag/librarian 2.10.1 → 2.10.2

package/dist/jikji/client.d.ts

@@ -3,9 +3,9 @@ export declare class JikjiClient {
     private readonly options;
     private resolvedCommand;
     private installCommandInFlight;
+    private readonly prepareQueue;
+    private readonly findQueue;
     constructor(options?: JikjiOptions);
-    /** Jikji stores prepared corpus metadata under a hidden directory in each root. */
-    isPrepared(root: string): boolean;
     /**
      * Resolve the jikji command following the priority chain:
      * 1. explicit binaryPath
@@ -22,5 +22,16 @@ export declare class JikjiClient {
     private resolveCommand;
     prepare(root: string, options?: JikjiPrepareOptions): Promise<JikjiPrepareResult>;
     find(root: string, query: string, options?: JikjiFindOptions): 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
+     * cut by its size. The slice defaults to the per-file parse limit
+     * (`parseTimeout`, seconds) that jikji itself enforces by skipping the file,
+     * so only a run that outlives even an all-files-hit-the-limit budget is
+     * killed (reported as a degraded root). `prepareTimeoutMsPerFile` overrides
+     * the slice; `0` restores a flat `timeoutMs` wall. A per-call `timeoutMs`
+     * bypasses all of this.
+     */
+    private prepareTimeoutMs;
     private spawn;
 }

package/dist/jikji/index.d.ts

@@ -5,6 +5,6 @@ export { jikjiFindDiagnostic, jikjiPrepareDiagnostic } 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, planJikjiSourceRoots, resolveReturnedPath } 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 { DEFAULT_JIKJI_OPTIONS } from "./types.js";

package/dist/jikji/path-map.d.ts

@@ -3,6 +3,15 @@ export interface JikjiSourceRoot extends SourceRoot {
     readonly searchPath: string;
 }
 export declare function planJikjiSourceRoots(searchPaths: readonly string[]): readonly JikjiSourceRoot[];
+/**
+ * Reduce search roots to the ones Jikji should index and query: duplicates
+ * collapse to their first occurrence and a root nested inside another root is
+ * dropped, because the outer root's index already covers it. Upstream Jikji
+ * rejects `prepare` on a root that overlaps an indexed one, so passing nested
+ * roots through only produces failed refreshes and duplicate answer paths.
+ * Input order is preserved for the survivors.
+ */
+export declare function outermostJikjiRoots(searchPaths: readonly string[]): readonly string[];
 export declare function mapJikjiPath(sourceRoot: SourceRoot, returnedPath: string): string | undefined;
 export declare function resolveReturnedPath(rootPath: string, returnedPath: string): string | undefined;
 export declare function isUnsafeReturnedPath(normalizedPath: string): boolean;

package/dist/jikji/prepare-budget.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Largest delay `setTimeout` honors (2^31 - 1 ms, ~24.8 days); Node fires a
+ * larger delay after 1 ms. This is a platform limit, not a policy cap.
+ */
+export declare const MAX_TIMER_MS = 2147483647;
+/**
+ * `base + perFile * fileCount`. There is deliberately no policy ceiling: the
+ * budget grows with the root, so a huge root is never cut by a fixed wall while
+ * a hung run on a small root still is. Clamped only to the timer limit.
+ */
+export declare function scaledPrepareTimeoutMs(baseMs: number, perFileMs: number, fileCount: number): number;
+/**
+ * Count regular files under `root`. Symlinks are not followed and hidden
+ * entries are skipped unless `includeHidden` (matching what `jikji prepare`
+ * indexes by default). `exclude` globs are ignored: over-counting only
+ * lengthens the budget. Stops early when `signal` aborts.
+ */
+export declare function countFiles(root: string, includeHidden: boolean, signal?: AbortSignal): Promise<number>;

package/dist/jikji/serial-queue.d.ts

@@ -0,0 +1,17 @@
+/** What a queued task resolves to when its signal aborts before its turn. */
+export interface SerialQueueSkip<S> {
+    readonly signal: AbortSignal | undefined;
+    readonly value: S;
+}
+/**
+ * Runs async tasks strictly one after another, in submission order. A task that
+ * throws rejects only its own caller; the queue keeps serving later tasks.
+ *
+ * A caller whose signal aborts while it is still waiting resolves immediately
+ * with `skip.value` and its task never runs. Once a task has started, aborting
+ * is the task's own business.
+ */
+export declare class SerialQueue {
+    private tail;
+    run<T, S = never>(task: () => Promise<T>, skip?: SerialQueueSkip<S>): Promise<T | S>;
+}

package/dist/jikji/types.d.ts

@@ -8,7 +8,20 @@ export interface JikjiOptions {
      * cargo. Set false to disable auto-installation.
      */
     readonly autoInstall?: boolean;
+    /**
+     * Wall-clock budget for one `jikji` process. Default 60 s. For `prepare` this
+     * is only the base of a hang guard that grows with the root's file count
+     * (see `prepareTimeoutMsPerFile`), not a total cap.
+     */
     readonly timeoutMs?: number;
+    /**
+     * Milliseconds each file under the root adds to `timeoutMs` for `prepare`.
+     * There is no overall ceiling, so a very large root is never cut by its
+     * size. Defaults to `parseTimeout` (5 s) per file, i.e. the budget only
+     * expires when the run is stuck beyond what per-file parse limits allow.
+     * `0` restores a flat `timeoutMs` wall.
+     */
+    readonly prepareTimeoutMsPerFile?: number;
     readonly maxBufferBytes?: number;
     readonly includeHidden?: boolean;
     readonly includeSensitive?: boolean;
@@ -49,6 +62,10 @@ export interface JikjiDefaultOptions {
 export declare const DEFAULT_JIKJI_OPTIONS: JikjiDefaultOptions;
 export interface JikjiPrepareOptions {
     readonly signal?: AbortSignal;
+    /** Hard wall for this one root; replaces the client budget (including the size-scaled one). */
+    readonly timeoutMs?: number;
+    /** `--parse-timeout` seconds for this root; replaces the client `parseTimeout`. */
+    readonly parseTimeout?: number;
 }
 export type JikjiFailureReason = "aborted" | "nonzero-exit" | "spawn-error" | "stderr-too-large" | "stdout-too-large" | "timeout" | "bad-answer-pack";
 export type JikjiPrepareResult = {