@autorag/librarian 2.13.4 → 2.13.5

package/dist/datasource/index.d.ts

@@ -6,7 +6,6 @@ export { mapDatasourceDiagnostic, mapDatasourceDiagnostics } from "./diagnostics
 export { type CronParseResult, isDue, parseCronExpr } from "./polling.js";
 export { DatasourceSkillRegistry, type RegisteredDatasourceSkill } from "./registry.js";
 export { buildDatasourceChunkSource, buildDatasourceInstanceSource, DATASOURCE_CHUNKS_SEGMENT, datasourceSourceHasFragment, datasourceSourcePath, filterDatasourceScope, isDatasourceSource, matchesDatasourceScope, matchesVirtualPathScope, normalizeVirtualPath, type ResultsByMethod, } from "./scope.js";
-export { CLOUD_DRIVE_SKILL_DEFINITION, CloudDriveSkill, type CloudDriveSkillOptions, RcloneConnector, type RcloneConnectorOptions, type RcloneRunner, type RcloneRunResult, } from "./skills/cloud-drive/index.js";
 export { DEFAULT_DISCRAWL_EMBEDDING_MODEL, DEFAULT_DISCRAWL_MODE, DiscrawlClient, type DiscrawlFailureReason, DiscrawlFtsMethod, DiscrawlHybridMethod, type DiscrawlOptions, type DiscrawlSearchHit, type DiscrawlSearchMode, type DiscrawlSearchOptions, type DiscrawlSearchResult, DiscrawlSemanticMethod, DiscrawlSkill, type DiscrawlSkillClient, type DiscrawlSkillOptions, ENGLISH_ONLY_EMBEDDING_MODELS, } from "./skills/discrawl/index.js";
 export { BUILTIN_DATASOURCE_SKILL_NAMES, type BuildDatasourceSkillsResult, buildDatasourceSkills, type DatasourceSkillConfig, type DatasourcesConfig, } from "./skills/factory.js";
 export { GitHubConnector, type GitHubConnectorOptions, GitHubSkill, type GitHubSkillOptions, } from "./skills/github/index.js";
@@ -16,9 +15,10 @@ export type { LazykatokFailureReason, LazykatokHit, LazykatokOptions, LazykatokS
 export { LazykatokBm25Method, LazykatokClient, LazykatokHybridMethod, LazykatokSkill, } from "./skills/lazykatok/index.js";
 export { MAILCRAWL_MODES, MailcrawlClient, type MailcrawlFailure, type MailcrawlFailureReason, type MailcrawlIndexInfo, MailcrawlMethod, type MailcrawlOptions, type MailcrawlSearchHit, type MailcrawlSearchMode, type MailcrawlSearchResult, MailcrawlSkill, type MailcrawlSyncInfo, type MailcrawlSyncResult, } from "./skills/mailcrawl/index.js";
 export { NotcrawlClient, type NotcrawlOptions, NotionSkill, type NotionSkillOptions, } from "./skills/notion/index.js";
-export { ObsidianBm25Method, type ObsidianMethodOptions, ObsidianSemanticMethod, ObsidianSkill, type ObsidianSkillOptions, } from "./skills/obsidian/index.js";
+export { type ObsidianMethodOptions, ObsidianSemanticMethod, ObsidianSkill, type ObsidianSkillOptions, ObsidianSparseMethod, } from "./skills/obsidian/index.js";
 export { RssConnector, type RssConnectorOptions, type RssFeedConfig, RssSkill, type RssSkillOptions, } from "./skills/rss/index.js";
 export { SlackSkill, type SlackSkillOptions, SlacrawlClient, type SlacrawlOptions, } from "./skills/slack/index.js";
 export { TelecrawlClient, type TelecrawlOptions, TelecrawlSkill, type TelecrawlSkillOptions, } from "./skills/telecrawl/index.js";
 export { WacrawlClient, type WacrawlOptions, WacrawlSkill, type WacrawlSkillOptions } from "./skills/wacrawl/index.js";
+export { WOMBAT_MODES, WombatClient, type WombatFailure, type WombatFailureReason, WombatMethod, type WombatOptions, type WombatSearchHit, type WombatSearchMode, type WombatSearchResult, WombatSkill, type WombatSkillOptions, type WombatSyncResult, } from "./skills/wombat/index.js";
 export type { DatasourceDiagnostic, DatasourceDiagnosticCode, DatasourceIndexFail, DatasourceIndexOk, DatasourceIndexOptions, DatasourceIndexResult, DatasourceInstance, DatasourceSkill, DatasourceSkillDescriptor, DatasourceSkillManifest, PollingMetadata, SourceDescription, } from "./types.js";

package/dist/datasource/skills/obsidian/index.d.ts

@@ -1,4 +1,4 @@
-export { ObsidianBm25Method, type ObsidianMethodOptions, ObsidianSemanticMethod } from "./methods.js";
+export { type ObsidianMethodOptions, ObsidianSemanticMethod, ObsidianSparseMethod } from "./methods.js";
 export { encodeSourceSegment, obsidianDatasourceDir, obsidianInstanceSource, obsidianMinSyncWorkspace, obsidianNoteSource, } from "./paths.js";
 export { ObsidianSkill, type ObsidianSkillOptions } from "./skill.js";
 export type { ObsidianMinSyncOptions, ObsidianSearchMode } from "./vault-index.js";

package/dist/datasource/skills/obsidian/methods.d.ts

@@ -13,7 +13,7 @@ declare class ObsidianMinSyncMethod implements RetrievalMethod {
     describe(): RetrievalMethodDescriptor;
     retrieve(query: string, options: RetrievalOptions): Promise<RetrievalResult[]>;
 }
-export declare class ObsidianBm25Method extends ObsidianMinSyncMethod {
+export declare class ObsidianSparseMethod extends ObsidianMinSyncMethod {
     constructor(options: ObsidianMethodOptions);
 }
 export declare class ObsidianSemanticMethod extends ObsidianMinSyncMethod {

package/dist/datasource/skills/obsidian/skill.d.ts

@@ -28,6 +28,7 @@ export declare class ObsidianSkill implements DatasourceSkill {
     private readonly instances;
     private readonly pollingIntervalMs;
     private readonly tags;
+    private readonly sparseOnly;
     private lastIndexedAt;
     private lastError;
     constructor(options?: ObsidianSkillOptions);

package/dist/datasource/skills/obsidian/vault-index.d.ts

@@ -9,7 +9,7 @@ export interface ObsidianVaultIndexOptions {
     readonly workspaceRoot: string | undefined;
     readonly minSync?: ObsidianMinSyncOptions;
 }
-export type ObsidianSearchMode = "bm25" | "semantic";
+export type ObsidianSearchMode = "sparse" | "semantic";
 export interface ObsidianSearchOptions {
     readonly topK?: number;
     readonly scope?: string;

package/dist/datasource/skills/wombat/client.d.ts

@@ -0,0 +1,17 @@
+import type { WombatDoctorResult, WombatOptions, WombatSearchMode, WombatSearchOptions, WombatSearchResult, WombatSyncResult } from "./types.js";
+export interface WombatSearchClient {
+    search(mode: WombatSearchMode, query: string, options?: WombatSearchOptions): Promise<WombatSearchResult>;
+}
+export interface WombatSyncClient extends WombatSearchClient {
+    doctor(signal?: AbortSignal): Promise<WombatDoctorResult>;
+    sync(signal?: AbortSignal): Promise<WombatSyncResult>;
+}
+export declare class WombatClient implements WombatSyncClient {
+    private readonly options;
+    constructor(options?: WombatOptions);
+    doctor(signal?: AbortSignal): Promise<WombatDoctorResult>;
+    /** Parse new and changed sessions into the mirror, then let MinSync index it incrementally. */
+    sync(signal?: AbortSignal): Promise<WombatSyncResult>;
+    search(mode: WombatSearchMode, query: string, options?: WombatSearchOptions): Promise<WombatSearchResult>;
+    private run;
+}

package/dist/datasource/skills/wombat/index.d.ts

@@ -0,0 +1,4 @@
+export { WombatClient, type WombatSearchClient, type WombatSyncClient } from "./client.js";
+export { WOMBAT_MODES, WombatMethod } from "./methods.js";
+export { validateWombatInstanceId, WombatSkill, type WombatSkillOptions } from "./skill.js";
+export type { WombatDoctorInfo, WombatDoctorResult, WombatFailure, WombatFailureReason, WombatOptions, WombatSearchHit, WombatSearchMode, WombatSearchOptions, WombatSearchResult, WombatSyncInfo, WombatSyncResult, } from "./types.js";

package/dist/datasource/skills/wombat/methods.d.ts

@@ -0,0 +1,15 @@
+import type { RetrievalMethod, RetrievalMethodDescriptor, RetrievalOptions, RetrievalResult } from "../../../retrieval/types.js";
+import type { WombatSearchClient } from "./client.js";
+import type { WombatSearchMode } from "./types.js";
+export declare const WOMBAT_MODES: readonly WombatSearchMode[];
+/** Retrieval over indexed coding-agent sessions (Codex, Claude Code, OpenCode, pi, omp) through the external wombat CLI. */
+export declare class WombatMethod implements RetrievalMethod {
+    private readonly client;
+    private readonly mode;
+    private readonly instanceId;
+    private readonly tags;
+    private readonly agents;
+    constructor(client: WombatSearchClient, mode: WombatSearchMode, instanceId: string, tags: readonly string[], agents?: readonly string[]);
+    describe(): RetrievalMethodDescriptor;
+    retrieve(query: string, options: RetrievalOptions): Promise<RetrievalResult[]>;
+}

package/dist/datasource/skills/wombat/skill.d.ts

@@ -0,0 +1,38 @@
+import type { RetrievalMethod } from "../../../retrieval/types.js";
+import type { DatasourceIndexOptions, DatasourceIndexResult, DatasourceSkill, DatasourceSkillDescriptor, DatasourceSkillManifest, PollingMetadata, SourceDescription } from "../../types.js";
+import { type WombatSyncClient } from "./client.js";
+import type { WombatOptions } from "./types.js";
+export interface WombatSkillOptions extends WombatOptions {
+    readonly client?: WombatSyncClient;
+    readonly datasourceId?: string;
+    readonly instanceId?: string;
+    readonly instances?: readonly string[];
+    readonly pollingIntervalMs?: number;
+    readonly tags?: readonly string[];
+    readonly connectorOptions?: WombatOptions;
+}
+/** An instance id becomes a path segment of every source, so it must be one safe segment. */
+export declare function validateWombatInstanceId(instanceId: string): void;
+/**
+ * Coding-agent session history (Codex, Claude Code, OpenCode, pi, omp) indexed by the external `wombat` CLI.
+ * wombat parses each agent's own log format, keeps only the user and assistant conversation, and lets MinSync
+ * index it incrementally; AutoRAG never reads those logs or the MinSync store itself.
+ */
+export declare class WombatSkill implements DatasourceSkill {
+    private readonly client;
+    private readonly instanceId;
+    private readonly instances;
+    private readonly interval;
+    private readonly tags;
+    private readonly agents;
+    private lastIndexedAt;
+    constructor(options?: WombatSkillOptions);
+    describe(): DatasourceSkillDescriptor;
+    polling(): PollingMetadata;
+    index(options?: DatasourceIndexOptions): Promise<DatasourceIndexResult>;
+    /** Hybrid first; SPLADE keyword search when the dense side is unavailable (for example, no embedder yet). */
+    retrievalMethods(): readonly RetrievalMethod[];
+    describeSources(): readonly SourceDescription[];
+    skillManifest(): DatasourceSkillManifest;
+    private fail;
+}

package/dist/datasource/skills/wombat/types.d.ts

@@ -0,0 +1,89 @@
+/** Retrieval modes of the `wombat` CLI: `keyword` is SPLADE sparse, `semantic` is dense, `hybrid` fuses both. */
+export type WombatSearchMode = "keyword" | "semantic" | "hybrid";
+export interface WombatSearchOptions {
+    readonly topK?: number;
+    readonly signal?: AbortSignal;
+}
+export interface WombatOptions {
+    readonly binaryPath?: string;
+    readonly instanceId?: string;
+    /** `--data-dir`: holds the mirror, the MinSync index and the session catalog (default `~/.wombat`). */
+    readonly dataDir?: string;
+    /** `--config`: a wombat `config.toml`. */
+    readonly configPath?: string;
+    /** Restrict indexing and search to these coding agents (`codex`, `claude-code`, `opencode`, `pi`, `omp`). */
+    readonly agents?: readonly string[];
+    /** `--include-subagents`: index subagent / sidechain transcripts too. */
+    readonly includeSubagents?: boolean;
+    /** `--include-ephemeral`: index headless, benchmark and temp-directory sessions too. */
+    readonly includeEphemeral?: boolean;
+    /** Applies to search and `doctor`; `sync` honors `indexTimeoutMs` instead. */
+    readonly timeoutMs?: number;
+    /** Non-interactive budget for `sync --index`; defaults to one hour. */
+    readonly indexTimeoutMs?: number;
+    readonly maxBufferBytes?: number;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+}
+export type WombatFailureReason = "binary-missing" | "nonzero-exit" | "spawn-error" | "timeout" | "aborted" | "stdout-too-large" | "stderr-too-large" | "invalid-output" | "remote-embedding-rejected";
+export interface WombatFailure {
+    readonly ok: false;
+    readonly reason: WombatFailureReason;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number | null;
+}
+export interface WombatDoctorInfo {
+    readonly ready: boolean;
+    readonly version?: string;
+    readonly minsyncVersion?: string;
+    readonly indexedSessions: number;
+    readonly indexedTurns: number;
+}
+export interface WombatSyncInfo {
+    readonly discovered?: number;
+    readonly processed?: number;
+    readonly written?: number;
+    readonly skipped?: number;
+    readonly deleted?: number;
+    readonly failed?: number;
+    readonly totalSessions: number;
+    readonly totalMessages: number;
+    /** Chunks MinSync added or updated while indexing; absent when MinSync reported nothing. */
+    readonly chunkCount?: number;
+    readonly indexOk: boolean;
+}
+/** One indexed chunk of a coding-agent session, with the pointers needed to reach the full trace. */
+export interface WombatSearchHit {
+    readonly chunkId: string;
+    readonly snippet: string;
+    readonly score: number;
+    readonly mode: WombatSearchMode;
+    readonly agent: string;
+    readonly sessionId: string;
+    /** `<agent>:<session id>`: what `wombat show` and `wombat trace` take. */
+    readonly catalogKey: string;
+    readonly title: string;
+    readonly cwd?: string;
+    readonly sourcePath?: string;
+    readonly startTurn?: number;
+    readonly endTurn?: number;
+    readonly startedAt?: string;
+    readonly endedAt?: string;
+}
+export interface WombatOk<T> {
+    readonly ok: true;
+    readonly data: T;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number;
+}
+export interface WombatSearchOk {
+    readonly ok: true;
+    readonly hits: readonly WombatSearchHit[];
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number;
+}
+export type WombatDoctorResult = WombatOk<WombatDoctorInfo> | WombatFailure;
+export type WombatSyncResult = WombatOk<WombatSyncInfo> | WombatFailure;
+export type WombatSearchResult = WombatSearchOk | WombatFailure;

package/dist/dupey/cli.d.ts

@@ -34,10 +34,30 @@ export interface DupeyCliOptions {
     readonly timeoutMs?: number;
     readonly run?: (args: readonly string[]) => Promise<string>;
 }
+/** One file's identity as `dupey fingerprint` reports it. `exact` equals `dupey scan --json`'s `content_hash`. */
+export interface DupeyFingerprint {
+    readonly path: string;
+    readonly format: string;
+    readonly chars: number;
+    readonly exact: string;
+    readonly minhashWidth: number;
+    /** The document's own last-modified time, or `null` when dupey records none (`-`). */
+    readonly modified: string | null;
+    readonly revision: string | null;
+}
 export declare class DupeyCliError extends Error {
     constructor(message: string);
 }
-export declare function scanWithDupey(dir: string, options?: DupeyCliOptions): Promise<DupeyScanResult>;
+export declare function scanWithDupey(dir: string, options?: DupeyCliOptions & {
+    readonly excludeDirs?: readonly string[];
+}): Promise<DupeyScanResult>;
+/**
+ * Read one file's canonical-text identity with `dupey fingerprint` while it is on disk. This is how a cloud
+ * file is judged for exact-duplicate exclusion without ever reading it again after its single download:
+ * `exact` is the same hash `dupey scan --json` would report (`content_hash`), so a scanned copy elsewhere
+ * and this stored fingerprint group together.
+ */
+export declare function fingerprintWithDupey(path: string, options?: DupeyCliOptions): Promise<DupeyFingerprint>;
 export type DupeyRelation = "exact" | "near" | "contains" | "different";
 export type DupeyCompareResult = {
     readonly relation: DupeyRelation;

package/dist/dupey/filter.d.ts

@@ -4,6 +4,13 @@ export interface ExactDuplicateFilterResult {
     readonly keepers: ReadonlySet<string>;
     readonly errors: readonly string[];
 }
+/** A cloud or network file's stored dupey identity: its exact hash and the document's own modified time (if any). */
+export interface ExactDuplicateFingerprint {
+    readonly exact: string;
+    readonly modified: string | null;
+    /** Characters dupey extracted. `0` means no text, so the hash says nothing about the content. */
+    readonly chars: number;
+}
 /** Selects the newest copy for each exact canonical-text hash.
  *
  * Uses dupey's own latest-copy ranking — the most recent internal document
@@ -11,4 +18,4 @@ export interface ExactDuplicateFilterResult {
  * none — so AutoRAG and dupey never disagree about which copy is newest.
  * Filesystem mtime is consulted only when dupey supplies no ranking.
  */
-export declare function selectExactDuplicateExclusions(root: string, scan: DupeyScanResult, isUnavailable?: (path: string) => boolean): Promise<ExactDuplicateFilterResult>;
+export declare function selectExactDuplicateExclusions(root: string, scan: DupeyScanResult, isUnavailable?: (path: string) => boolean, fingerprints?: ReadonlyMap<string, ExactDuplicateFingerprint>): Promise<ExactDuplicateFilterResult>;

package/dist/dupey/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./cli.js";
 export * from "./filter.js";
+export * from "./scan-plan.js";

package/dist/dupey/scan-plan.d.ts

@@ -0,0 +1,23 @@
+import { type CloudFileProbe, type CloudRoot } from "../filesystem/cloud-placeholder.js";
+/** One `dupey scan` to run: the directory and the cloud or network folder names nested in it that must not be walked. */
+export interface DupeyScanTarget {
+    readonly path: string;
+    readonly excludeDirs: readonly string[];
+}
+export interface DupeyScanPlan {
+    readonly targets: readonly DupeyScanTarget[];
+    /** Roots inside a cloud or network folder: never scanned, because `dupey scan` opens every file's contents. */
+    readonly skipped: readonly string[];
+}
+/**
+ * The machine's cloud and network roots for the roots about to be scanned. A probe that is missing or fails
+ * reads as no roots, never an error: an unknown root is scanned as before.
+ */
+export declare function listCloudRoots(probe: CloudFileProbe | undefined, roots: readonly string[]): Promise<readonly CloudRoot[]>;
+/**
+ * Which roots `dupey scan` may walk. A root inside a cloud or network folder is skipped whole and a cloud or
+ * network folder nested under a root is excluded by name: `dupey scan` reads file contents, which re-downloads
+ * a released placeholder (measured: a OneDrive folder of 1.1k placeholders ran past the 120 s scan timeout and
+ * every read failed with ETIMEDOUT) and re-reads a network file over the wire.
+ */
+export declare function planDupeyScans(roots: readonly string[], cloudRoots: readonly CloudRoot[]): DupeyScanPlan;

package/dist/embedding/index.d.ts

@@ -17,7 +17,9 @@ export interface EmbedderFromConfigOptions {
 /**
  * The single embedder AutoRAG shares between its own semantic stores and the datasources: a configured
  * remote endpoint, else the `minsync serve` daemon the operator runs, else MinSync's in-process engine.
- * AutoRAG never starts the daemon for it.
+ * AutoRAG never starts the daemon for it. A sparse-only config (`minSync.embedder.id: "none"`) asked for no
+ * dense model, so the embedder reports no backend and every embed fails with that reason: consumers keep their
+ * lexical path and nothing loads Qwen3.
  */
 export declare function createEmbedderFromConfig(options: EmbedderFromConfigOptions): ManagedEmbedder;
 /**

package/dist/everything/client.d.ts

@@ -110,7 +110,7 @@ export declare class EverythingClient {
     private readonly stateDir;
     private readonly isExcludedPath;
     private binaries;
-    private operation;
+    private readonly queue;
     constructor(options: EverythingClientOptions);
     isSupported(): boolean;
     /**
@@ -129,7 +129,6 @@ export declare class EverythingClient {
     index(): Promise<EverythingIndexResult>;
     /** Exit this workspace's Everything instance if it is running. Never installs binaries. */
     stop(): Promise<void>;
-    private serialize;
     /**
      * Resolve the ES + Everything executables. `"cached"` reads only the
      * already extracted, hash-verified workspace cache and never writes;