@autorag/librarian 2.0.0 → 2.2.0

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/factory.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Config-driven factory for the built-in connector-backed datasource skills.
+ *
+ * The CLI/server layer passes the trusted `datasources` section of
+ * `config.json`; this factory materializes one skill per configured entry.
+ * Model/tool arguments never reach this factory — it is part of the trusted
+ * configuration path. Unknown skill names and disabled entries are skipped
+ * and reported so setup surfaces actionable (but path-opaque) feedback.
+ */
+import type { DatasourceSkill } from "../types.js";
+/** One configured datasource entry (the trusted `datasources.<name>` value). */
+export interface DatasourceSkillConfig {
+    readonly enabled?: boolean;
+    readonly instanceId?: string;
+    readonly pollingIntervalMs?: number;
+    readonly tags?: readonly string[];
+    /** Connector-specific options (token env names, repos, feeds, paths, …). */
+    readonly connector?: Record<string, unknown>;
+}
+/** The trusted `datasources` config section: skill name → config. */
+export type DatasourcesConfig = Readonly<Record<string, DatasourceSkillConfig | boolean>>;
+export interface BuildDatasourceSkillsResult {
+    readonly skills: readonly DatasourceSkill[];
+    /** Names that were configured but not recognized. */
+    readonly unknown: readonly string[];
+}
+/** Skill names this factory can build. */
+export declare const BUILTIN_DATASOURCE_SKILL_NAMES: readonly string[];
+/**
+ * Build datasource skills from the trusted config section. `false` or
+ * `{ enabled: false }` entries are skipped silently; unrecognized names are
+ * collected in `unknown` (never thrown) so callers can surface setup
+ * feedback without failing agent construction.
+ */
+export declare function buildDatasourceSkills(config: DatasourcesConfig | undefined, workspaceRoot?: string): BuildDatasourceSkillsResult;

package/dist/datasource/skills/gdrive/connector.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Google Drive connector (issue #1301).
+ *
+ * Lists files through the Drive v3 API with a trusted, server-configured
+ * OAuth access token, exporting Google Docs/Sheets as plain text/CSV and
+ * downloading plain-text files. Binary formats are skipped. Per-file export
+ * failures degrade to warnings. Never throws; messages stay path/PII-opaque.
+ */
+import type { ConnectorFetchResult, DatasourceConnector } from "../../connector.js";
+export interface GDriveConnectorOptions {
+    /** Drive v3 REST base; override to point at a mock server in tests. */
+    readonly baseUrl?: string;
+    /** OAuth access token; explicit value wins over {@link tokenEnv}. */
+    readonly token?: string;
+    /** Env var name holding the access token. Default `GDRIVE_ACCESS_TOKEN`. */
+    readonly tokenEnv?: string;
+    /** Restrict to files whose parent is this folder id. */
+    readonly folderId?: string;
+    /** Include shared-drive items in listings. */
+    readonly includeSharedDrives?: boolean;
+    readonly timeoutMs?: number;
+    readonly fetchImpl?: typeof fetch;
+    readonly maxPages?: number;
+    readonly maxDocuments?: number;
+}
+export declare class GDriveConnector implements DatasourceConnector {
+    private readonly options;
+    constructor(options?: GDriveConnectorOptions);
+    fetch(signal?: AbortSignal): Promise<ConnectorFetchResult>;
+}

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

@@ -0,0 +1,3 @@
+export { GDriveConnector, type GDriveConnectorOptions } from "./connector.js";
+export { RcloneConnector, type RcloneConnectorOptions, type RcloneRunner, type RcloneRunResult, } from "./rclone-connector.js";
+export { GDRIVE_SKILL_DEFINITION, GDriveSkill, type GDriveSkillOptions } from "./skill.js";

package/dist/datasource/skills/gdrive/rclone-connector.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Rclone-backed drive connector (issue #1301, rclone path).
+ *
+ * Uses the external `rclone` CLI (https://rclone.org) as the trusted bridge
+ * to Google Drive — or any of rclone's 70+ storage backends — so OAuth
+ * setup and token refresh live entirely in `rclone config`, not here
+ * (katok/himalaya pattern). Google Docs/Sheets are transparently exported
+ * as text via rclone's `--drive-export-formats`. Never throws; failures map
+ * onto the coarse connector failure union with path/PII-opaque messages.
+ *
+ * Listing: `rclone lsjson <remote> --recursive --files-only`
+ * Content: `rclone cat <remote>/<path>` (bounded, text formats only)
+ */
+import type { ConnectorFetchResult, DatasourceConnector } from "../../connector.js";
+export interface RcloneRunResult {
+    readonly ok: boolean;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number | null;
+}
+export type RcloneRunner = (args: readonly string[], timeoutMs: number) => Promise<RcloneRunResult>;
+export interface RcloneConnectorOptions {
+    /** Path to the rclone binary. Default bare `rclone` PATH lookup. */
+    readonly binaryPath?: string;
+    /**
+     * Rclone remote path, e.g. `gdrive:` or `gdrive:Team/Docs`. Required
+     * trusted configuration (`rclone config` defines the remote).
+     */
+    readonly remote?: string;
+    /**
+     * Indexable file extensions (lowercase, with dot). Google Docs/Sheets
+     * surface as these after `--drive-export-formats txt,csv`.
+     */
+    readonly extensions?: readonly string[];
+    /** Drive export formats forwarded to rclone. Default `txt,csv`. */
+    readonly exportFormats?: string;
+    /** Max files whose contents are fetched per run. Default 200. */
+    readonly maxDocuments?: number;
+    /** Files larger than this are skipped. Default 2 MiB. */
+    readonly maxBytesPerFile?: number;
+    /** Per-spawn timeout. Default 60s (cloud listings can be slow). */
+    readonly timeoutMs?: number;
+    /** Injectable process runner for tests. */
+    readonly runner?: RcloneRunner;
+}
+export declare class RcloneConnector implements DatasourceConnector {
+    private readonly options;
+    private readonly runner;
+    constructor(options?: RcloneConnectorOptions);
+    fetch(): Promise<ConnectorFetchResult>;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Google Drive datasource skill (issue #1301).
+ *
+ * Thin composition of GDriveConnector with the shared
+ * {@link ConnectorDatasourceSkill} base: descriptor, polling metadata,
+ * ok/fail indexing with path/PII-opaque diagnostics, lexical retrieval via
+ * the shared pipeline, opaque `/gdrive/<instance>/…` sources, and a
+ * progressive-disclosure agent-skill manifest.
+ */
+import type { DatasourceConnector } from "../../connector.js";
+import { ConnectorDatasourceSkill, type ConnectorSkillDefinition, type ConnectorSkillOptions } from "../../connector-skill.js";
+import { type GDriveConnectorOptions } from "./connector.js";
+export declare const GDRIVE_SKILL_DEFINITION: ConnectorSkillDefinition;
+export interface GDriveSkillOptions extends Omit<ConnectorSkillOptions, "connector"> {
+    /**
+     * Trusted pre-built connector; wins over {@link connectorOptions}. Accepts
+     * any drive-backed connector (Drive REST or the rclone CLI bridge).
+     */
+    readonly connector?: DatasourceConnector;
+    readonly connectorOptions?: GDriveConnectorOptions;
+}
+export declare class GDriveSkill extends ConnectorDatasourceSkill {
+    constructor(options?: GDriveSkillOptions);
+}

package/dist/datasource/skills/github/connector.d.ts

@@ -0,0 +1,28 @@
+/**
+ * GitHub Issues/PRs connector (issue #1303).
+ *
+ * Fetches issues and pull requests for a trusted list of `owner/repo`
+ * targets through the GitHub REST API. A token is optional (public repos
+ * work unauthenticated). Per-repo 404s degrade to warnings; 401 fails as
+ * auth and rate limiting fails the whole fetch. Never throws.
+ */
+import type { ConnectorFetchResult, DatasourceConnector } from "../../connector.js";
+export interface GitHubConnectorOptions {
+    /** GitHub REST base; override to point at a mock server in tests. */
+    readonly baseUrl?: string;
+    /** Optional token; explicit value wins over {@link tokenEnv}. */
+    readonly token?: string;
+    /** Env var name holding the token. Default `GITHUB_TOKEN`. */
+    readonly tokenEnv?: string;
+    /** Repositories to index as `owner/repo`. Required trusted configuration. */
+    readonly repos?: readonly string[];
+    readonly timeoutMs?: number;
+    readonly fetchImpl?: typeof fetch;
+    readonly maxPages?: number;
+    readonly maxDocuments?: number;
+}
+export declare class GitHubConnector implements DatasourceConnector {
+    private readonly options;
+    constructor(options?: GitHubConnectorOptions);
+    fetch(signal?: AbortSignal): Promise<ConnectorFetchResult>;
+}

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

@@ -0,0 +1,2 @@
+export { GitHubConnector, type GitHubConnectorOptions } from "./connector.js";
+export { GITHUB_SKILL_DEFINITION, GitHubSkill, type GitHubSkillOptions } from "./skill.js";

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

@@ -0,0 +1,20 @@
+/**
+ * GitHub Issues/PRs datasource skill (issue #1303).
+ *
+ * Thin composition of GitHubConnector with the shared
+ * {@link ConnectorDatasourceSkill} base: descriptor, polling metadata,
+ * ok/fail indexing with path/PII-opaque diagnostics, lexical retrieval via
+ * the shared pipeline, opaque `/github/<instance>/…` sources, and a
+ * progressive-disclosure agent-skill manifest.
+ */
+import { ConnectorDatasourceSkill, type ConnectorSkillDefinition, type ConnectorSkillOptions } from "../../connector-skill.js";
+import { GitHubConnector, type GitHubConnectorOptions } from "./connector.js";
+export declare const GITHUB_SKILL_DEFINITION: ConnectorSkillDefinition;
+export interface GitHubSkillOptions extends Omit<ConnectorSkillOptions, "connector"> {
+    /** Trusted connector configuration; a pre-built connector wins. */
+    readonly connector?: GitHubConnector;
+    readonly connectorOptions?: GitHubConnectorOptions;
+}
+export declare class GitHubSkill extends ConnectorDatasourceSkill {
+    constructor(options?: GitHubSkillOptions);
+}

package/dist/datasource/skills/gmail/connector.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Gmail connector (issue #1304).
+ *
+ * Lists and fetches messages through the Gmail REST v1 API with a trusted,
+ * server-configured OAuth access token. Per-message fetch failures degrade
+ * to warnings. Never throws; messages stay path/PII-opaque (addresses appear
+ * only inside indexed chunk content, never in diagnostics).
+ */
+import type { ConnectorFetchResult, DatasourceConnector } from "../../connector.js";
+export interface GmailConnectorOptions {
+    /** Gmail REST base; override to point at a mock server in tests. */
+    readonly baseUrl?: string;
+    /** OAuth access token; explicit value wins over {@link tokenEnv}. */
+    readonly token?: string;
+    /** Env var name holding the access token. Default `GMAIL_ACCESS_TOKEN`. */
+    readonly tokenEnv?: string;
+    /** Restrict to these label ids (e.g. `["INBOX"]`). */
+    readonly labelIds?: readonly string[];
+    /** Gmail search query (the `q` parameter). */
+    readonly query?: string;
+    readonly timeoutMs?: number;
+    readonly fetchImpl?: typeof fetch;
+    readonly maxPages?: number;
+    readonly maxDocuments?: number;
+}
+export declare class GmailConnector implements DatasourceConnector {
+    private readonly options;
+    constructor(options?: GmailConnectorOptions);
+    fetch(signal?: AbortSignal): Promise<ConnectorFetchResult>;
+}

package/dist/datasource/skills/gmail/himalaya-connector.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Himalaya-backed mail connector (issue #1304, IMAP path).
+ *
+ * Uses the external `himalaya` CLI (https://pimalaya.org) as the trusted
+ * bridge to any IMAP/Maildir account it has configured — Gmail included —
+ * so no OAuth token plumbing is needed here. Mirrors the katok pattern:
+ * AutoRAG never opens the mailbox itself; it spawns the CLI, parses JSON
+ * envelopes, and reads message bodies. Never throws; failures map onto the
+ * coarse connector failure union with path/PII-opaque messages.
+ */
+import type { ConnectorFetchResult, DatasourceConnector } from "../../connector.js";
+export interface HimalayaRunResult {
+    readonly ok: boolean;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number | null;
+}
+export type HimalayaRunner = (args: readonly string[], timeoutMs: number) => Promise<HimalayaRunResult>;
+export interface HimalayaConnectorOptions {
+    /** Path to the himalaya binary. Default bare `himalaya` PATH lookup. */
+    readonly binaryPath?: string;
+    /** Himalaya account name (`himalaya account list`). Default account when omitted. */
+    readonly account?: string;
+    /** Mail folder, e.g. `INBOX`. Himalaya's default folder when omitted. */
+    readonly folder?: string;
+    /** Envelopes per listing page. Default 100. */
+    readonly pageSize?: number;
+    /** Max messages whose bodies are fetched per run. Default 50. */
+    readonly maxDocuments?: number;
+    /** Per-spawn timeout. Default 30s (IMAP fetches can be slow). */
+    readonly timeoutMs?: number;
+    /** Injectable process runner for tests. */
+    readonly runner?: HimalayaRunner;
+}
+export declare class HimalayaConnector implements DatasourceConnector {
+    private readonly options;
+    private readonly runner;
+    constructor(options?: HimalayaConnectorOptions);
+    fetch(): Promise<ConnectorFetchResult>;
+}

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

@@ -0,0 +1,3 @@
+export { GmailConnector, type GmailConnectorOptions } from "./connector.js";
+export { HimalayaConnector, type HimalayaConnectorOptions, type HimalayaRunner, type HimalayaRunResult, } from "./himalaya-connector.js";
+export { GMAIL_SKILL_DEFINITION, GmailSkill, type GmailSkillOptions } from "./skill.js";

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

@@ -0,0 +1,24 @@
+/**
+ * Gmail datasource skill (issue #1304).
+ *
+ * Thin composition of GmailConnector with the shared
+ * {@link ConnectorDatasourceSkill} base: descriptor, polling metadata,
+ * ok/fail indexing with path/PII-opaque diagnostics, lexical retrieval via
+ * the shared pipeline, opaque `/gmail/<instance>/…` sources, and a
+ * progressive-disclosure agent-skill manifest.
+ */
+import type { DatasourceConnector } from "../../connector.js";
+import { ConnectorDatasourceSkill, type ConnectorSkillDefinition, type ConnectorSkillOptions } from "../../connector-skill.js";
+import { type GmailConnectorOptions } from "./connector.js";
+export declare const GMAIL_SKILL_DEFINITION: ConnectorSkillDefinition;
+export interface GmailSkillOptions extends Omit<ConnectorSkillOptions, "connector"> {
+    /**
+     * Trusted pre-built connector; wins over {@link connectorOptions}. Accepts
+     * any mail-backed connector (Gmail REST or the himalaya CLI bridge).
+     */
+    readonly connector?: DatasourceConnector;
+    readonly connectorOptions?: GmailConnectorOptions;
+}
+export declare class GmailSkill extends ConnectorDatasourceSkill {
+    constructor(options?: GmailSkillOptions);
+}

package/dist/datasource/skills/mail-export/connector.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Local mail export connector (issue #1311).
+ *
+ * Parses `.eml` files and `.mbox` archives from trusted, server-configured
+ * filesystem paths using the existing `mailparser` dependency. No network
+ * access. Per-message parse failures aggregate into one count-only warning;
+ * absolute paths never appear in warnings or failure messages.
+ */
+import type { ConnectorFetchResult, DatasourceConnector } from "../../connector.js";
+export interface MailExportConnectorOptions {
+    /** Files or directories containing `.eml` / `.mbox` archives. Required. */
+    readonly paths?: readonly string[];
+    readonly maxDocuments?: number;
+    /** Files larger than this are skipped with a warning. Default 50 MiB. */
+    readonly maxBytesPerFile?: number;
+}
+export declare class MailExportConnector implements DatasourceConnector {
+    private readonly options;
+    constructor(options?: MailExportConnectorOptions);
+    fetch(): Promise<ConnectorFetchResult>;
+}

package/dist/datasource/skills/mail-export/index.d.ts

@@ -0,0 +1,2 @@
+export { MailExportConnector, type MailExportConnectorOptions } from "./connector.js";
+export { MAIL_EXPORT_SKILL_DEFINITION, MailExportSkill, type MailExportSkillOptions } from "./skill.js";

package/dist/datasource/skills/mail-export/skill.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Local mail export datasource skill (issue #1311).
+ *
+ * Thin composition of MailExportConnector with the shared
+ * {@link ConnectorDatasourceSkill} base: descriptor, polling metadata,
+ * ok/fail indexing with path/PII-opaque diagnostics, lexical retrieval via
+ * the shared pipeline, opaque `/mail-export/<instance>/…` sources, and a
+ * progressive-disclosure agent-skill manifest.
+ */
+import { ConnectorDatasourceSkill, type ConnectorSkillDefinition, type ConnectorSkillOptions } from "../../connector-skill.js";
+import { MailExportConnector, type MailExportConnectorOptions } from "./connector.js";
+export declare const MAIL_EXPORT_SKILL_DEFINITION: ConnectorSkillDefinition;
+export interface MailExportSkillOptions extends Omit<ConnectorSkillOptions, "connector"> {
+    /** Trusted connector configuration; a pre-built connector wins. */
+    readonly connector?: MailExportConnector;
+    readonly connectorOptions?: MailExportConnectorOptions;
+}
+export declare class MailExportSkill extends ConnectorDatasourceSkill {
+    constructor(options?: MailExportSkillOptions);
+}

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,6 @@
+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;