@autorag/librarian 2.1.0 → 2.2.0

package/dist/datasource/connector-skill.d.ts

@@ -1,7 +1,7 @@
 /**
  * Shared {@link DatasourceSkill} implementation for connector-backed
  * datasources (Slack, Discord, Notion, GitHub, Google Drive, Gmail/IMAP,
- * local mail exports, Obsidian vaults, RSS/news).
+ * local mail exports, RSS/news).
  *
  * Composition: a trusted {@link DatasourceConnector} fetches documents, a
  * {@link DatasourceChunkStore} persists and lexically indexes them, and this

package/dist/datasource/connector.d.ts

@@ -1,6 +1,6 @@
 /**
  * Connector contract shared by the built-in datasource skills (Slack, Discord,
- * Notion, GitHub, Google Drive, Gmail/IMAP, local mail exports, Obsidian,
+ * Notion, GitHub, Google Drive, Gmail/IMAP, local mail exports,
  * RSS/news).
  *
  * A *connector* is the trusted, server-configured bridge to one external

package/dist/datasource/crawler-client.d.ts

@@ -0,0 +1,9 @@
+import type { CrawlerCliOptions, CrawlerProfile, CrawlerSearchOptions, CrawlerSearchResult, CrawlerSyncResult } from "./crawler-types.js";
+export declare class CrawlerCliClient {
+    private readonly profile;
+    private readonly options;
+    constructor(profile: CrawlerProfile, options?: CrawlerCliOptions);
+    sync(signal?: AbortSignal): Promise<CrawlerSyncResult>;
+    search(query: string, options?: CrawlerSearchOptions): Promise<CrawlerSearchResult>;
+    private run;
+}

package/dist/datasource/crawler-skill.d.ts

@@ -0,0 +1,41 @@
+import type { RetrievalMethod } from "../retrieval/types.js";
+import type { CrawlerSearchOptions, CrawlerSearchResult, CrawlerSyncResult } from "./crawler-types.js";
+import type { DatasourceIndexResult, DatasourceSkill, DatasourceSkillDescriptor, DatasourceSkillManifest, PollingMetadata, SourceDescription } from "./types.js";
+export interface CrawlerSkillClient {
+    sync(signal?: AbortSignal): Promise<CrawlerSyncResult>;
+    search(query: string, options?: CrawlerSearchOptions): Promise<CrawlerSearchResult>;
+}
+export interface CrawlerDatasourceDefinition {
+    readonly datasourceId: string;
+    readonly skillType: string;
+    readonly description: string;
+    readonly defaultTags: readonly string[];
+    readonly contentType: string;
+    readonly manifestDescription: string;
+    readonly backendName: string;
+}
+export interface CrawlerDatasourceSkillOptions {
+    readonly client: CrawlerSkillClient;
+    readonly instanceId?: string;
+    readonly instances?: readonly string[];
+    readonly pollingIntervalMs?: number;
+    readonly tags?: readonly string[];
+    readonly lastIndexedAt?: number;
+}
+export declare class CrawlerDatasourceSkill implements DatasourceSkill {
+    private readonly definition;
+    private readonly client;
+    private readonly instanceId;
+    private readonly instances;
+    private readonly pollingIntervalMs;
+    private readonly tags;
+    private lastIndexedAt;
+    constructor(definition: CrawlerDatasourceDefinition, options: CrawlerDatasourceSkillOptions);
+    describe(): DatasourceSkillDescriptor;
+    polling(): PollingMetadata;
+    index(): Promise<DatasourceIndexResult>;
+    retrievalMethods(): readonly RetrievalMethod[];
+    describeSources(): readonly SourceDescription[];
+    skillManifest(): DatasourceSkillManifest;
+    private fail;
+}

package/dist/datasource/crawler-types.d.ts

@@ -0,0 +1,53 @@
+import type { RetrievalOptions } from "../retrieval/types.js";
+export type CrawlerFailureReason = "binary-missing" | "nonzero-exit" | "spawn-error" | "timeout" | "aborted" | "stdout-too-large" | "stderr-too-large" | "invalid-output";
+export interface CrawlerFailure {
+    readonly ok: false;
+    readonly reason: CrawlerFailureReason;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number | null;
+}
+export interface CrawlerHit {
+    readonly id: string;
+    readonly content: string;
+    readonly score: number;
+    readonly title?: string;
+    readonly hierarchy?: readonly string[];
+    readonly publishedAt?: number;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface CrawlerSyncOk {
+    readonly ok: true;
+    readonly count: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number;
+}
+export interface CrawlerSearchOk {
+    readonly ok: true;
+    readonly hits: readonly CrawlerHit[];
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number;
+}
+export type CrawlerSyncResult = CrawlerSyncOk | CrawlerFailure;
+export type CrawlerSearchResult = CrawlerSearchOk | CrawlerFailure;
+export type CrawlerSearchOptions = RetrievalOptions;
+export interface CrawlerCliOptions {
+    readonly binaryPath?: string;
+    readonly databasePath?: string;
+    readonly sourcePath?: string;
+    readonly configPath?: string;
+    readonly syncSource?: string;
+    readonly timeoutMs?: number;
+    readonly maxBufferBytes?: number;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+}
+export interface CrawlerProfile {
+    readonly binaryName: string;
+    readonly allowedEnvPrefixes: readonly string[];
+    readonly syncArgs: (options: CrawlerCliOptions) => readonly string[];
+    readonly searchArgs: (options: CrawlerCliOptions, query: string, topK: number) => readonly string[];
+    readonly parseSyncCount: (stdout: string) => number | undefined;
+    readonly parseHits: (stdout: string) => readonly CrawlerHit[] | undefined;
+}

package/dist/datasource/index.d.ts

@@ -7,7 +7,7 @@ export { type CronParseResult, isDue, parseCronExpr } from "./polling.js";
 export { DatasourceSkillRegistry, type RegisteredDatasourceSkill } from "./registry.js";
 export { DatasourceResultFilter, type ResultsByMethod } from "./result-filter.js";
 export { buildDatasourceChunkSource, buildDatasourceInstanceSource, DATASOURCE_CHUNKS_SEGMENT, datasourceSourceHasFragment, datasourceSourcePath, isDatasourceSource, matchesDatasourceScope, matchesVirtualPathScope, normalizeVirtualPath, } from "./scope.js";
-export { DiscordConnector, type DiscordConnectorOptions, DiscordSkill, type DiscordSkillOptions, } from "./skills/discord/index.js";
+export { DEFAULT_DISCRAWL_EMBEDDING_MODEL, DEFAULT_DISCRAWL_MODE, DEFAULT_DISCRAWL_SOURCE, DiscrawlClient, type DiscrawlFailureReason, DiscrawlFtsMethod, DiscrawlHybridMethod, type DiscrawlOptions, type DiscrawlSearchHit, type DiscrawlSearchMode, type DiscrawlSearchOptions, type DiscrawlSearchResult, DiscrawlSemanticMethod, DiscrawlSkill, type DiscrawlSkillClient, type DiscrawlSkillOptions, type DiscrawlSourceKind, 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 { GDriveConnector, type GDriveConnectorOptions, GDriveSkill, type GDriveSkillOptions, } from "./skills/gdrive/index.js";
 export { GitHubConnector, type GitHubConnectorOptions, GitHubSkill, type GitHubSkillOptions, } from "./skills/github/index.js";
@@ -15,9 +15,11 @@ export { GmailConnector, type GmailConnectorOptions, GmailSkill, type GmailSkill
 export type { KatokFailureReason, KatokHit, KatokOptions, KatokSearchMode, KatokSearchOptions, KatokSearchResult, KatokSkillClient, KatokSkillOptions, } from "./skills/katok/index.js";
 export { KatokBm25Method, KatokClient, KatokSemanticMethod, KatokSkill } from "./skills/katok/index.js";
 export { MailExportConnector, type MailExportConnectorOptions, MailExportSkill, type MailExportSkillOptions, } from "./skills/mail-export/index.js";
-export { NotionConnector, type NotionConnectorOptions, NotionSkill, type NotionSkillOptions, } from "./skills/notion/index.js";
-export { ObsidianConnector, type ObsidianConnectorOptions, ObsidianSkill, type ObsidianSkillOptions, } from "./skills/obsidian/index.js";
+export { NotcrawlClient, type NotcrawlOptions, NotionSkill, type NotionSkillOptions, } from "./skills/notion/index.js";
+export { ObsidianBm25Method, ObsidianSemanticMethod, ObsidianSkill, type ObsidianSkillClient, type ObsidianSkillOptions, QmdClient, type QmdOptions, type QmdSearchHit, type QmdSearchMode, type QmdSearchResult, } from "./skills/obsidian/index.js";
 export { RssConnector, type RssConnectorOptions, type RssFeedConfig, RssSkill, type RssSkillOptions, } from "./skills/rss/index.js";
-export { SlackConnector, type SlackConnectorOptions, SlackSkill, type SlackSkillOptions, } from "./skills/slack/index.js";
+export { SlackSkill, type SlackSkillOptions, SlacrawlClient, type SlacrawlOptions, } from "./skills/slack/index.js";
 export { SpotlightConnector, type SpotlightConnectorOptions, SpotlightSkill, type SpotlightSkillOptions, } from "./skills/spotlight/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 type { DatasourceAccessible, DatasourceDiagnostic, DatasourceDiagnosticCode, DatasourceIndexFail, DatasourceIndexOk, DatasourceIndexResult, DatasourceInstance, DatasourceSkill, DatasourceSkillDescriptor, DatasourceSkillManifest, PollingMetadata, SourceDescription, } from "./types.js";

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

@@ -0,0 +1,23 @@
+import type { DiscrawlDoctorResult, DiscrawlEmbedResult, DiscrawlOptions, DiscrawlSearchMode, DiscrawlSearchOptions, DiscrawlSearchResult, DiscrawlStatusResult, DiscrawlSyncResult } from "./types.js";
+/**
+ * Thin external `discrawl` CLI wrapper. Every method spawns the `discrawl`
+ * binary as a child process, parses JSON from stdout, and returns a
+ * discriminated ok/fail union. No method throws for expected failures (missing
+ * binary, rejected user token, CLI nonzero exit, timeout, oversized output, or
+ * invalid JSON). The client never opens the Discord archive database directly.
+ *
+ * `--json` is a *global* discrawl flag and must precede the subcommand;
+ * `discrawl search --json` is rejected by the CLI as an unknown flag.
+ */
+export declare class DiscrawlClient {
+    private readonly options;
+    constructor(options?: DiscrawlOptions);
+    doctor(signal?: AbortSignal): Promise<DiscrawlDoctorResult>;
+    status(signal?: AbortSignal): Promise<DiscrawlStatusResult>;
+    sync(signal?: AbortSignal): Promise<DiscrawlSyncResult>;
+    embed(limit?: number, signal?: AbortSignal): Promise<DiscrawlEmbedResult>;
+    search(mode: DiscrawlSearchMode, query: string, options?: DiscrawlSearchOptions): Promise<DiscrawlSearchResult>;
+    private runJson;
+    private run;
+}
+export declare function discrawlWorkspace(options: DiscrawlOptions): string | undefined;

package/dist/datasource/skills/discrawl/config.d.ts

@@ -0,0 +1,9 @@
+import type { DiscrawlOptions } from "./types.js";
+/**
+ * Creates or updates AutoRAG's workspace-local discrawl config.
+ *
+ * Only the fields AutoRAG owns are changed: the workspace database path and
+ * embedding enablement/provider/model. Existing operator settings such as
+ * guilds, source filters, sync policy, and search mode are preserved.
+ */
+export declare function ensureManagedDiscrawlConfig(configPath: string, databasePath: string, options: DiscrawlOptions): void;

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

@@ -0,0 +1,5 @@
+export { DiscrawlClient, discrawlWorkspace } from "./client.js";
+export { DiscrawlFtsMethod, DiscrawlHybridMethod, type DiscrawlMethodOptions, type DiscrawlSearchClient, DiscrawlSemanticMethod, } from "./methods.js";
+export { DISCRAWL_SOURCE_KIND, discrawlConfigPath, discrawlDatabasePath, discrawlDatasourceRoot, discrawlSourcePath, parseDiscrawlSourcePath, } from "./paths.js";
+export { DiscrawlSkill, type DiscrawlSkillClient, type DiscrawlSkillOptions } from "./skill.js";
+export { DEFAULT_DISCRAWL_BINARY, DEFAULT_DISCRAWL_EMBEDDING_MODEL, DEFAULT_DISCRAWL_EMBEDDING_PROVIDER, DEFAULT_DISCRAWL_MAX_BUFFER_BYTES, DEFAULT_DISCRAWL_MODE, DEFAULT_DISCRAWL_SOURCE, DEFAULT_DISCRAWL_TIMEOUT_MS, type DiscrawlDoctorInfo, type DiscrawlDoctorResult, type DiscrawlEmbedInfo, type DiscrawlEmbedResult, type DiscrawlFailure, type DiscrawlFailureReason, type DiscrawlMessage, type DiscrawlOptions, type DiscrawlSearchHit, type DiscrawlSearchMode, type DiscrawlSearchOptions, type DiscrawlSearchResult, type DiscrawlSourceKind, type DiscrawlStatusInfo, type DiscrawlStatusResult, type DiscrawlSyncInfo, type DiscrawlSyncResult, ENGLISH_ONLY_EMBEDDING_MODELS, } from "./types.js";

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

@@ -0,0 +1,55 @@
+import type { RetrievalMethod, RetrievalMethodDescriptor, RetrievalOptions, RetrievalResult } from "../../../retrieval/types.js";
+import type { DiscrawlSearchMode, DiscrawlSearchOptions, DiscrawlSearchResult } from "./types.js";
+/**
+ * Narrow client surface required by the Discord retrieval methods. The real
+ * {@link DiscrawlClient} satisfies this structurally; tests may stub it.
+ */
+export interface DiscrawlSearchClient {
+    search(mode: DiscrawlSearchMode, query: string, options?: DiscrawlSearchOptions): Promise<DiscrawlSearchResult>;
+}
+export interface DiscrawlMethodOptions {
+    readonly client: DiscrawlSearchClient;
+    readonly instanceId: string;
+    readonly tags?: readonly string[];
+}
+/**
+ * Lexical (SQLite FTS5) retrieval over a Discord archive via the external
+ * `discrawl` CLI. All client failures collapse to an empty result set;
+ * retrieval never throws.
+ */
+export declare class DiscrawlFtsMethod implements RetrievalMethod {
+    private readonly client;
+    private readonly instanceId;
+    private readonly tags;
+    constructor(options: DiscrawlMethodOptions);
+    describe(): RetrievalMethodDescriptor;
+    retrieve(query: string, options: RetrievalOptions): Promise<RetrievalResult[]>;
+}
+/**
+ * Semantic (vector) retrieval over a Discord archive via the external
+ * `discrawl` CLI. Requires a configured embedding provider and a completed
+ * `discrawl embed` pass; when either is missing the CLI exits non-zero and
+ * this method returns no results rather than throwing.
+ */
+export declare class DiscrawlSemanticMethod implements RetrievalMethod {
+    private readonly client;
+    private readonly instanceId;
+    private readonly tags;
+    constructor(options: DiscrawlMethodOptions);
+    describe(): RetrievalMethodDescriptor;
+    retrieve(query: string, options: RetrievalOptions): Promise<RetrievalResult[]>;
+}
+/**
+ * Hybrid retrieval (FTS5 + semantic, deduplicated by message id). This is the
+ * preferred Discord method: discrawl's FTS index welds words across newlines
+ * into one token, so semantic recall is what covers terms FTS cannot reach.
+ * See AutoRAG issue #1413.
+ */
+export declare class DiscrawlHybridMethod implements RetrievalMethod {
+    private readonly client;
+    private readonly instanceId;
+    private readonly tags;
+    constructor(options: DiscrawlMethodOptions);
+    describe(): RetrievalMethodDescriptor;
+    retrieve(query: string, options: RetrievalOptions): Promise<RetrievalResult[]>;
+}

package/dist/datasource/skills/discrawl/paths.d.ts

@@ -0,0 +1,30 @@
+export declare const AUTORAG_DIRNAME = ".autorag";
+export declare const DATASOURCES_DIRNAME = "datasources";
+export declare const DISCRAWL_DATASOURCE_DIRNAME = "discrawl";
+/** Logical datasource kind for source identifiers. */
+export declare const DISCRAWL_SOURCE_KIND: "discord";
+/**
+ * Root directory for discrawl-managed state under a workspace. This is where
+ * the external `discrawl` CLI stores its SQLite archive, FTS index, and
+ * message vectors.
+ */
+export declare function discrawlDatasourceRoot(workspaceRoot: string): string;
+/** Config file discrawl reads for embedding provider/model settings. */
+export declare function discrawlConfigPath(workspaceRoot: string): string;
+/** SQLite archive maintained by the discrawl CLI. */
+export declare function discrawlDatabasePath(workspaceRoot: string): string;
+/**
+ * Builds the slash-hierarchical source identifier for a single archived
+ * message. Discord message ids are stable snowflakes, so these sources stay
+ * traceable across re-syncs.
+ */
+export declare function discrawlSourcePath(instanceId: string, messageId: string): string;
+/**
+ * Parses a discrawl source identifier back into its components. Returns
+ * `undefined` for malformed or non-discord sources so deny decisions stay
+ * explicit rather than undefined-as-deny.
+ */
+export declare function parseDiscrawlSourcePath(source: string): {
+    readonly instanceId: string;
+    readonly messageId: string;
+} | undefined;

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

@@ -0,0 +1,58 @@
+import type { RetrievalMethod } from "../../../retrieval/types.js";
+import type { DatasourceIndexResult, DatasourceSkill, DatasourceSkillDescriptor, DatasourceSkillManifest, PollingMetadata, SourceDescription } from "../../types.js";
+import { type DiscrawlSearchClient } from "./methods.js";
+import type { DiscrawlDoctorResult, DiscrawlEmbedResult, DiscrawlSearchMode, DiscrawlSyncResult } from "./types.js";
+export interface DiscrawlSkillClient extends DiscrawlSearchClient {
+    doctor(): Promise<DiscrawlDoctorResult>;
+    sync(): Promise<DiscrawlSyncResult>;
+    embed(limit?: number): Promise<DiscrawlEmbedResult>;
+}
+export interface DiscrawlSkillOptions {
+    readonly client: DiscrawlSkillClient;
+    readonly instanceId?: string;
+    readonly instances?: readonly string[];
+    readonly pollingIntervalMs?: number;
+    readonly tags?: readonly string[];
+    readonly lastIndexedAt?: number;
+    readonly embeddingModel?: string;
+    readonly defaultMode?: DiscrawlSearchMode;
+    /** Max messages embedded per index pass. Undefined drains the whole backlog. */
+    readonly embedLimit?: number;
+}
+/**
+ * Discord datasource skill backed by the external `discrawl` CLI.
+ *
+ * Mirrors the katok model: the CLI owns the archive, the FTS5 index, and the
+ * vector index; AutoRAG only spawns it and maps results. AutoRAG never calls
+ * the Discord API itself and never reads the Discord Desktop cache directly.
+ *
+ * `index()` runs the CLI's two-phase pipeline — `sync` (incremental, cursor
+ * based) then `embed` (drains the embedding queue) — so a poll costs work
+ * proportional to what changed rather than to archive size.
+ */
+export declare class DiscrawlSkill implements DatasourceSkill {
+    private readonly client;
+    private readonly instanceId;
+    private readonly instances;
+    private readonly pollingIntervalMs;
+    private readonly tags;
+    private readonly embeddingModel;
+    private readonly defaultMode;
+    private readonly embedLimit;
+    private lastIndexedAt;
+    constructor(options: DiscrawlSkillOptions);
+    describe(): DatasourceSkillDescriptor;
+    polling(): PollingMetadata;
+    index(): Promise<DatasourceIndexResult>;
+    retrievalMethods(): readonly RetrievalMethod[];
+    describeSources(): readonly SourceDescription[];
+    skillManifest(): DatasourceSkillManifest;
+    private runEmbed;
+    /**
+     * English-only embedders map non-English text into one narrow similarity
+     * band, so semantic search degrades to noise without ever erroring. Surfacing
+     * it as a diagnostic keeps that failure visible. See AutoRAG issue #1414.
+     */
+    private englishOnlyModelDiagnostic;
+    private fail;
+}

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

@@ -0,0 +1,198 @@
+import type { RetrievalOptions } from "../../../retrieval/types.js";
+/**
+ * Search modes accepted by the external `discrawl search --mode` flag.
+ *
+ * - `fts`      — SQLite FTS5 lexical ranking over archived messages.
+ * - `semantic` — dense vector similarity over locally stored message vectors.
+ * - `hybrid`   — runs both, deduplicates by message id, falls back to FTS when
+ *                semantic is unavailable.
+ */
+export type DiscrawlSearchMode = "fts" | "semantic" | "hybrid";
+/**
+ * Where the `discrawl` CLI reads Discord data from.
+ *
+ * - `wiretap`  — the local Discord Desktop cache. Requires no token and issues
+ *                no Discord API calls; it reads only files Discord already
+ *                wrote to disk. Includes classifiable direct messages.
+ * - `discord`  — the Discord bot API using a server-configured bot token. This
+ *                is the ToS-sanctioned automation path (a bot token identifies
+ *                an OAuth2 application, not a human user).
+ * - `both`     — bot API plus desktop cache.
+ *
+ * AutoRAG never uses a Discord *user* token: automating a user account is
+ * prohibited by Discord's Community Guidelines and can get the account
+ * terminated.
+ */
+export type DiscrawlSourceKind = "wiretap" | "discord" | "both";
+/**
+ * Embedding models known to be English-only. Selecting one for a non-English
+ * archive silently degrades semantic search to noise rather than failing, so
+ * the skill emits a diagnostic instead of staying quiet.
+ *
+ * Measured on a real Korean archive: unrelated `nomic-embed-text` Korean
+ * sentence pairs score 0.65-0.82 cosine (vs 0.30-0.46 for English), i.e. the
+ * embedding space collapses and top-k ranking becomes random.
+ *
+ * See AutoRAG issue #1414.
+ */
+export declare const ENGLISH_ONLY_EMBEDDING_MODELS: ReadonlySet<string>;
+/**
+ * Default embedding model AutoRAG configures for workspace-managed discrawl
+ * configs. `embeddinggemma`
+ * (Gemma 3 300M, 768 dimensions) covers 100+ languages and matches the
+ * EmbeddingGemma embedder katok uses for KakaoTalk, so every CLI-backed
+ * datasource shares one local embedding model (served through Ollama).
+ */
+export declare const DEFAULT_DISCRAWL_EMBEDDING_MODEL = "embeddinggemma";
+export declare const DEFAULT_DISCRAWL_EMBEDDING_PROVIDER = "ollama";
+/**
+ * Configuration for the discrawl client. All fields optional; defaults mirror
+ * the katok client. The client spawns the `discrawl` binary as a child process
+ * — it never opens the Discord archive database directly.
+ */
+export interface DiscrawlOptions {
+    /** Explicit path to the `discrawl` binary. Defaults to a bare PATH lookup. */
+    readonly binaryPath?: string;
+    /** Spawn timeout in milliseconds. Default 30_000 (sync/embed are slow). */
+    readonly timeoutMs?: number;
+    /** Max stdout/stderr bytes retained. Default 1_048_576 (1 MiB). */
+    readonly maxBufferBytes?: number;
+    /** Archive source for the CLI. Default `wiretap` (no token required). */
+    readonly source?: DiscrawlSourceKind;
+    /**
+     * Explicit operator-owned discrawl config file passed as `--config`.
+     * AutoRAG never rewrites an explicit config.
+     */
+    readonly configPath?: string;
+    /** Workspace root used to compute the default discrawl workspace path. */
+    readonly root?: string;
+    /** Explicit workspace directory overriding the computed default. */
+    readonly workspacePath?: string;
+    /** Restrict search and sync to one guild id. */
+    readonly guildId?: string;
+    /**
+     * Embedding provider written to AutoRAG's workspace-local discrawl config.
+     * Defaults to `ollama`; explicit operator-owned config files are untouched.
+     */
+    readonly embeddingProvider?: string;
+    /**
+     * Embedding model discrawl should use for semantic/hybrid search. Defaults
+     * to {@link DEFAULT_DISCRAWL_EMBEDDING_MODEL}. English-only models are
+     * accepted but reported through a diagnostic.
+     */
+    readonly embeddingModel?: string;
+    /**
+     * Default search mode. Defaults to `hybrid` so semantic retrieval covers
+     * terms FTS cannot reach: discrawl strips newlines without substituting a
+     * space, welding words across line breaks into a single unsearchable token
+     * (measured at ~47% of post-newline words on a real archive). See AutoRAG
+     * issue #1413.
+     */
+    readonly defaultMode?: DiscrawlSearchMode;
+    /** Environment overrides merged on top of `process.env` for the child. */
+    readonly env?: Readonly<Record<string, string | undefined>>;
+}
+export declare const DEFAULT_DISCRAWL_BINARY = "discrawl";
+export declare const DEFAULT_DISCRAWL_TIMEOUT_MS = 30000;
+export declare const DEFAULT_DISCRAWL_MAX_BUFFER_BYTES = 1048576;
+export declare const DEFAULT_DISCRAWL_SOURCE: DiscrawlSourceKind;
+export declare const DEFAULT_DISCRAWL_MODE: DiscrawlSearchMode;
+/**
+ * Reasons a discrawl CLI invocation can fail. The client never throws for
+ * these — every method returns a discriminated union with `ok: false`.
+ */
+export type DiscrawlFailureReason = "binary-missing" | "user-token-rejected" | "nonzero-exit" | "spawn-error" | "timeout" | "aborted" | "stdout-too-large" | "stderr-too-large" | "invalid-json" | "invalid-shape";
+/** Common failure payload shared by every method result union. */
+export interface DiscrawlFailure {
+    readonly ok: false;
+    readonly reason: DiscrawlFailureReason;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number | null;
+    /**
+     * The offending environment key when `reason === "user-token-rejected"`.
+     * A config key name (never a path, never the key's value).
+     */
+    readonly violatingKey?: string;
+    readonly hits?: readonly unknown[];
+}
+/** A single archived Discord message returned by the discrawl CLI. */
+export interface DiscrawlMessage {
+    readonly messageId: string;
+    readonly content: string;
+    readonly channelId?: string;
+    readonly channelName?: string;
+    readonly guildId?: string;
+    readonly guildName?: string;
+    readonly authorName?: string;
+    readonly timestamp?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** A scored search hit. */
+export interface DiscrawlSearchHit extends DiscrawlMessage {
+    readonly score: number;
+}
+/** Result of `discrawl status`. */
+export interface DiscrawlStatusInfo {
+    readonly messages: number;
+    readonly channels: number;
+    readonly guilds: number;
+    readonly databasePath?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Result of `discrawl doctor`. */
+export interface DiscrawlDoctorInfo {
+    readonly ready: boolean;
+    readonly configOk: boolean;
+    readonly databaseOk: boolean;
+    readonly ftsOk: boolean;
+    readonly embeddingsOk: boolean;
+    readonly embeddingModel?: string;
+    readonly embeddingProvider?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Result of `discrawl sync` / `discrawl wiretap`. */
+export interface DiscrawlSyncInfo {
+    readonly messages: number;
+    readonly guilds?: number;
+    readonly channels?: number;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Result of `discrawl embed`. */
+export interface DiscrawlEmbedInfo {
+    readonly processed: number;
+    readonly succeeded: number;
+    readonly failed: number;
+    readonly remainingBacklog: number;
+    readonly model?: string;
+    readonly provider?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Discriminated ok-success shape carrying typed `data`. */
+export interface DiscrawlOk<T> {
+    readonly ok: true;
+    readonly data: T;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number;
+}
+export interface DiscrawlSearchOk {
+    readonly ok: true;
+    readonly hits: readonly DiscrawlSearchHit[];
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number;
+    readonly data: {
+        readonly hits: readonly DiscrawlSearchHit[];
+    };
+}
+export type DiscrawlDoctorResult = DiscrawlOk<DiscrawlDoctorInfo> | DiscrawlFailure;
+export type DiscrawlStatusResult = DiscrawlOk<DiscrawlStatusInfo> | DiscrawlFailure;
+export type DiscrawlSyncResult = DiscrawlOk<DiscrawlSyncInfo> | DiscrawlFailure;
+export type DiscrawlEmbedResult = DiscrawlOk<DiscrawlEmbedInfo> | DiscrawlFailure;
+export type DiscrawlSearchResult = DiscrawlSearchOk | DiscrawlFailure;
+/**
+ * Search-specific options. Reuses the shared {@link RetrievalOptions} so the
+ * retrieval methods can pass their options straight through.
+ */
+export type DiscrawlSearchOptions = RetrievalOptions;

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

@@ -1,2 +1,15 @@
-export { NotionConnector, type NotionConnectorOptions } from "./connector.js";
-export { NOTION_SKILL_DEFINITION, NotionSkill, type NotionSkillOptions } from "./skill.js";
+import { CrawlerCliClient } from "../../crawler-client.js";
+import { CrawlerDatasourceSkill, type CrawlerDatasourceSkillOptions, type CrawlerSkillClient } from "../../crawler-skill.js";
+import type { CrawlerCliOptions } from "../../crawler-types.js";
+export interface NotcrawlOptions extends CrawlerCliOptions {
+}
+export declare class NotcrawlClient extends CrawlerCliClient {
+    constructor(options?: NotcrawlOptions);
+}
+export interface NotionSkillOptions extends Omit<CrawlerDatasourceSkillOptions, "client"> {
+    readonly client?: CrawlerSkillClient;
+    readonly connectorOptions?: NotcrawlOptions;
+}
+export declare class NotionSkill extends CrawlerDatasourceSkill {
+    constructor(options?: NotionSkillOptions);
+}

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

@@ -0,0 +1,15 @@
+import type { QmdEmbedResult, QmdEnsureResult, QmdOptions, QmdSearchMode, QmdSearchOptions, QmdSearchResult, QmdUpdateResult } from "./types.js";
+/**
+ * Thin external `qmd` CLI wrapper for Obsidian vault indexing/search.
+ * Every method spawns the `qmd` binary, never throws for expected failures,
+ * and isolates config/cache under the AutoRAG workspace.
+ */
+export declare class QmdClient {
+    private readonly options;
+    constructor(options?: QmdOptions);
+    ensureCollection(signal?: AbortSignal): Promise<QmdEnsureResult>;
+    update(signal?: AbortSignal): Promise<QmdUpdateResult>;
+    embed(signal?: AbortSignal): Promise<QmdEmbedResult>;
+    search(mode: QmdSearchMode, query: string, options?: QmdSearchOptions): Promise<QmdSearchResult>;
+    private run;
+}

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

@@ -1,2 +1,6 @@
-export { ObsidianConnector, type ObsidianConnectorOptions } from "./connector.js";
-export { OBSIDIAN_SKILL_DEFINITION, ObsidianSkill, type ObsidianSkillOptions } from "./skill.js";
+export { QmdClient } from "./client.js";
+export { ObsidianBm25Method, type ObsidianMethodOptions, type ObsidianSearchClient, ObsidianSemanticMethod, } from "./methods.js";
+export { obsidianDatasourceRoot, obsidianQmdCacheDir, obsidianQmdConfigDir, obsidianSourcePath, parseObsidianSourcePath, stripEdgeDashes, toQmdCollectionName, } from "./paths.js";
+export { ObsidianSkill, type ObsidianSkillClient, type ObsidianSkillOptions } from "./skill.js";
+export type { QmdEmbedResult, QmdEnsureResult, QmdFailureReason, QmdOptions, QmdSearchHit, QmdSearchMode, QmdSearchOptions, QmdSearchResult, QmdUpdateResult, } from "./types.js";
+export { DEFAULT_QMD_BINARY, DEFAULT_QMD_MAX_BUFFER_BYTES, DEFAULT_QMD_TIMEOUT_MS, } from "./types.js";

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

@@ -0,0 +1,26 @@
+import type { RetrievalMethod, RetrievalMethodDescriptor, RetrievalOptions, RetrievalResult } from "../../../retrieval/types.js";
+import type { QmdSearchMode, QmdSearchOptions, QmdSearchResult } from "./types.js";
+export interface ObsidianSearchClient {
+    search(mode: QmdSearchMode, query: string, options?: QmdSearchOptions): Promise<QmdSearchResult>;
+}
+export interface ObsidianMethodOptions {
+    readonly client: ObsidianSearchClient;
+    readonly instanceId: string;
+    readonly tags?: readonly string[];
+}
+export declare class ObsidianBm25Method implements RetrievalMethod {
+    private readonly client;
+    private readonly instanceId;
+    private readonly tags;
+    constructor(options: ObsidianMethodOptions);
+    describe(): RetrievalMethodDescriptor;
+    retrieve(query: string, options: RetrievalOptions): Promise<RetrievalResult[]>;
+}
+export declare class ObsidianSemanticMethod implements RetrievalMethod {
+    private readonly client;
+    private readonly instanceId;
+    private readonly tags;
+    constructor(options: ObsidianMethodOptions);
+    describe(): RetrievalMethodDescriptor;
+    retrieve(query: string, options: RetrievalOptions): Promise<RetrievalResult[]>;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Path helpers for the Obsidian (`qmd`) datasource skill.
+ *
+ * All AutoRAG-managed state lives under
+ * `<workspaceRoot>/.autorag/datasources/obsidian/<instanceId>/`. The external
+ * `qmd` CLI is pointed at isolated config/cache dirs so multiple workspaces
+ * never share an index. Callers surface opaque slash-hierarchical sources of
+ * the form `/obsidian/<instance-id>/chunks/<chunk-id>`.
+ */
+export declare const AUTORAG_DIRNAME = ".autorag";
+export declare const DATASOURCES_DIRNAME = "datasources";
+export declare const OBSIDIAN_DATASOURCE_DIRNAME = "obsidian";
+export declare const OBSIDIAN_SOURCE_KIND: "obsidian";
+export declare function obsidianDatasourceRoot(workspaceRoot: string, instanceId: string): string;
+/** Directory passed to `QMD_CONFIG_DIR` (holds `index.yml`). */
+export declare function obsidianQmdConfigDir(workspaceRoot: string, instanceId: string): string;
+/** Directory passed to `XDG_CACHE_HOME` (holds `qmd/index.sqlite`). */
+export declare function obsidianQmdCacheDir(workspaceRoot: string, instanceId: string): string;
+export declare function obsidianSourcePath(instanceId: string, chunkId: string): string;
+export declare function parseObsidianSourcePath(source: string): {
+    readonly instanceId: string;
+    readonly chunkId: string;
+} | undefined;
+/** Strip leading and trailing ASCII dashes without a quadratic regex. */
+export declare function stripEdgeDashes(value: string): string;
+/** Sanitize an instance id into a qmd collection name. */
+export declare function toQmdCollectionName(instanceId: string): string;