@autorag/librarian 2.4.1 → 2.5.0

package/dist/cli/output.d.ts

@@ -11,6 +11,12 @@ export interface RenderOptions {
 export declare function renderRefresh(result: AutoRAGRefreshResult, opts: RenderOptions): string;
 export declare function renderStatus(status: AutoRAGRefreshStatus, opts: RenderOptions): string;
 export declare function renderSearch(resp: SearchDocumentsResponse, opts: RenderOptions): string;
+/**
+ * Render the two-phase search's immediate first answer. Kept distinct from
+ * the final response so callers can show "fast answer → verified answer"
+ * progression; the JSON shape wraps the normal search envelope.
+ */
+export declare function renderPreliminary(resp: SearchDocumentsResponse, opts: RenderOptions): string;
 export declare function renderMemory(schema: MemorySchemaV4, opts: RenderOptions): string;
 export declare function renderFeedback(result: {
     applied: boolean;

package/dist/cli/setup.d.ts

@@ -0,0 +1,59 @@
+import { type RuntimeStatus } from "../embedding-runtime/index.js";
+import { resolveProfile } from "../embedding-runtime/manifest.js";
+import type { ProfileId } from "../embedding-runtime/types.js";
+import { type FileLockHandle } from "../filesystem/file-lock.js";
+export type SetupDatasourceState = "configured" | "skipped" | "blocked";
+export interface SetupDatasourceReport {
+    readonly name: string;
+    readonly state: SetupDatasourceState;
+    readonly reason?: string;
+}
+export interface SetupReport {
+    readonly ok: boolean;
+    readonly mode: "semantic" | "bm25";
+    readonly runtime: {
+        readonly state: string;
+        readonly health: boolean;
+        readonly model: string;
+    };
+    readonly model: {
+        readonly valid: boolean;
+        readonly profile: ProfileId;
+    };
+    readonly datasources: readonly SetupDatasourceReport[];
+    readonly remediation?: string;
+    readonly changed: boolean;
+}
+export interface SetupRuntime {
+    runtimeStatus(): Promise<RuntimeStatus>;
+    verifyModel(profileId?: ProfileId): Promise<{
+        profileId: ProfileId;
+        path: string;
+        hash: string;
+    }>;
+    ensureRuntime?(input?: {
+        profileId?: ProfileId;
+    }): Promise<{
+        baseUrl: string;
+        profile: ReturnType<typeof resolveProfile>;
+        identity: {
+            provider: string;
+            model: string;
+            dimension: number;
+            profileId: ProfileId;
+        };
+    }>;
+}
+export interface SetupDeps {
+    readonly runtime?: SetupRuntime;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly pathExists?: (path: string) => boolean;
+    readonly executable?: (name: string) => string | undefined;
+    readonly acquireLock?: (path: string) => FileLockHandle;
+}
+export declare function runSetup(options: {
+    configPath: string;
+    workspacePath: string;
+    profileId?: ProfileId;
+    deps?: SetupDeps;
+}): Promise<SetupReport>;

package/dist/core.d.ts

@@ -0,0 +1,67 @@
+import type { AutoRAGJikjiPrepareResult, AutoRAGRefreshOptions, AutoRAGRefreshResult, AutoRAGRefreshStatus, AutoRAGWatchRefreshHandle, AutoRAGWatchRefreshOptions } from "./agent/agent.js";
+import type { AutoRAGResultsDetails } from "./agent/emit-results-tool.js";
+import { type SearchDocumentsResponse } from "./agent/search-documents.js";
+import { type CliConfig, type ResolveConfigInput } from "./cli/config.js";
+import type { MemorySchemaV4 } from "./memory/memory.js";
+import type { MinSyncSyncResult } from "./minsync/types.js";
+import type { ParsedMirrorSyncResult } from "./mirror/sync.js";
+import type { RetrievalEngine } from "./retrieval/engine.js";
+import type { CuratedResult, RetrievalDiagnostic, RetrievalOptions, RetrievalResult } from "./retrieval/types.js";
+/** Input accepted by {@link createAutoRAGLite}. Flags keep CLI precedence intact. */
+export interface AutoRAGLiteOptions {
+    readonly flags?: ResolveConfigInput["flags"];
+    readonly env?: NodeJS.ProcessEnv;
+    readonly cwd?: string;
+    readonly readOnly?: boolean;
+}
+/** The model-free AutoRAG runtime facade. */
+export declare class AutoRAGLite {
+    readonly config: CliConfig;
+    private readonly agent;
+    private readonly retrievalEngine;
+    private readonly memory;
+    private readonly sessions;
+    constructor(config: CliConfig);
+    /** Refresh parsed mirrors and configured indexes without constructing a model. */
+    refresh(force?: boolean, options?: AutoRAGRefreshOptions): Promise<AutoRAGRefreshResult>;
+    /** Alias for callers that model indexing as a lifecycle operation. */
+    index(force?: boolean, options?: AutoRAGRefreshOptions): Promise<AutoRAGRefreshResult>;
+    /** Return the path-opaque refresh and index health snapshot. */
+    getRefreshStatus(): Promise<AutoRAGRefreshStatus>;
+    /** Short status alias for headless lifecycle callers. */
+    status(): Promise<AutoRAGRefreshStatus>;
+    /** Run only parsed-mirror indexing while preserving the agent's path pinning. */
+    syncParsedMirrors(force?: boolean): Promise<ParsedMirrorSyncResult>;
+    /** Run the configured MinSync indexer without constructing a model. */
+    syncMinSync(): Promise<MinSyncSyncResult | undefined>;
+    /** Run the configured Jikji preparer without constructing a model. */
+    prepareJikji(): Promise<readonly AutoRAGJikjiPrepareResult[] | undefined>;
+    /** Start an opt-in incremental filesystem refresh watcher. */
+    startWatchRefresh(options?: AutoRAGWatchRefreshOptions): AutoRAGWatchRefreshHandle;
+    /** Return the deterministic retrieval engine used by this configured runtime. */
+    getRetrievalEngine(): RetrievalEngine;
+    /** Retrieve merged results without entering the model-backed agent loop. */
+    retrieve(query: string, options?: RetrievalOptions): Promise<{
+        results: RetrievalResult[];
+        diagnostics: RetrievalDiagnostic[];
+    }>;
+    /** Retrieve per-method results without entering the model-backed agent loop. */
+    retrieveByMethod(query: string, options?: RetrievalOptions): Promise<{
+        byMethod: Map<string, RetrievalResult[]>;
+        diagnostics: RetrievalDiagnostic[];
+    }>;
+    /** Persist a typed structured report for later evidence and feedback commands. */
+    recordStructuredResultsSession(sessionId: string, query: string, details: AutoRAGResultsDetails): SearchDocumentsResponse;
+    /** Generate a session id and persist a typed structured report. */
+    recordReport(query: string, details: AutoRAGResultsDetails): SearchDocumentsResponse;
+    /** Return the opaque result registry associated with a persisted report. */
+    getResultRegistry(sessionId: string): ReadonlyMap<number, CuratedResult>;
+    /** Record numbered feedback against a report persisted by this facade. */
+    recordFeedbackByNumbers(sessionId: string, usefulNumbers: readonly number[], notUsefulNumbers?: readonly number[]): void;
+    /** Return a detached snapshot of persisted evidence and feedback state. */
+    getMemorySchema(): MemorySchemaV4;
+}
+/** Resolve the existing CLI config and construct a model-free runtime. */
+export declare function createAutoRAGLite(options?: AutoRAGLiteOptions): AutoRAGLite;
+export type { AgentModelAuth, AgentModelConfig, AgentModelResolutionSource, CliConfig, MinSyncMethodConfig, NormalizedIndexingConfig, RawIndexingMethods, ResolveConfigInput, ResolvedAgentModel, ResolvedAgentModelDetailed, ResolvedAgentModelRole, ResolvedConfigPath, UiConfig, } from "./cli/config.js";
+export { AUTORAG_HOME_ENV, buildAgentOptions, ConfigError, DEFAULT_CONFIG_FILENAME, LEGACY_CONFIG_FILENAME, normalizeEmbedder, normalizeIndexingConfig, normalizeLegacyConfigPaths, readRawConfigObject, resolveAgentModel, resolveAgentModelDetailed, resolveConfig, resolveConfigPath, resolveConfigReadOnly, resolveModel, writeConfigObject, writeDefaultConfig, } from "./cli/config.js";