@ssmeo/mcp-local-rag 0.18.6

package/dist/utils/base-dirs.d.ts

@@ -0,0 +1,145 @@
+import { AppError } from './errors.js';
+/**
+ * Effective document roots, in two index-aligned forms. This is the canonical
+ * statement of the path policy; other sites reference it.
+ *
+ * - `baseDirs`: realpath-resolved — the containment boundary for
+ *   `DocumentParser`, and the ONLY place realpath is used.
+ * - `rawBaseDirs`: the same roots, resolve()-only. Everything user-facing
+ *   scans and displays in this space so paths match the resolve()-stored DB
+ *   keys; otherwise a symlinked prefix (macOS /tmp → /private/tmp) would make
+ *   ingested files look un-ingested.
+ */
+export interface BaseDirsConfig {
+    baseDirs: string[];
+    rawBaseDirs: string[];
+}
+/**
+ * Discriminated union of configuration warnings surfaced by helpers in this
+ * module. Both CLI (stderr) and MCP (tool response content block) paths
+ * consume these — the consumer decides how to render them.
+ */
+export type BaseDirsConfigWarning = {
+    kind: 'nested-root-pruned';
+    message: string;
+    parent: string;
+    pruned: string;
+} | {
+    kind: 'base-dirs-overrides-base-dir';
+    message: string;
+};
+/**
+ * Configuration error raised by parsers and the realpath helper. Modeled as
+ * a dedicated subclass so consumers can distinguish configuration problems
+ * from other I/O errors (e.g. `ValidationError` from `DocumentParser`).
+ */
+export declare class BaseDirsConfigError extends AppError {
+    constructor(message: string, options?: {
+        cause?: Error;
+    });
+}
+/**
+ * Result of {@link parseBaseDirsEnv}. A discriminated union avoids forcing
+ * callers to use `try/catch` for what is a routine configuration-validation
+ * branch (invalid input → structured error → user-facing message).
+ */
+export type ParseBaseDirsResult = {
+    ok: true;
+    value: string[];
+} | {
+    ok: false;
+    error: BaseDirsConfigError;
+};
+/**
+ * Substitute `$HOME` with `~` for a user-visible path, so a warning flowing
+ * out through MCP does not leak the OS username. `$HOME` is read at call time,
+ * never cached.
+ */
+export declare function displayPath(path: string): string;
+/**
+ * Parse `BASE_DIRS`: only a JSON array of non-empty strings is accepted, so
+ * delimiter syntax like `'/a:/b'` is an error rather than a silent misread.
+ * Syntax only — existence is {@link normalizeRealpath}'s job.
+ */
+export declare function parseBaseDirsEnv(raw: string): ParseBaseDirsResult;
+/**
+ * Append a trailing path separator if the input does not already end with
+ * one. This is the prefix-safety pattern used throughout the parser
+ * (`/foo/bar` must not match `/foo/barista`).
+ */
+export declare function withTrailingSeparator(path: string): string;
+/**
+ * Resolve a directory to its realpath and append a trailing separator, so the
+ * result works directly as a prefix in a containment check.
+ *
+ * Throws when the path is not an existing directory: a root must point at one.
+ */
+export declare function normalizeRealpath(path: string): Promise<string>;
+/**
+ * Output of {@link dedupAndPruneRoots}.
+ */
+export interface DedupAndPruneResult {
+    /** Effective roots in input order, after exact dedup and nested pruning. */
+    roots: string[];
+    /** Warnings describing pruned nested roots, in pruning order. */
+    warnings: BaseDirsConfigWarning[];
+}
+/**
+ * Reduce realpath-normalized roots to the effective set.
+ *
+ * Exact duplicates are dropped silently — that is convenience, not a mistake.
+ * A nested root is pruned in favour of its parent with a warning, which keeps
+ * scan output free of duplicates without widening the boundary past the parent
+ * the user already configured. Surviving order is preserved so the first
+ * element stays a meaningful legacy `baseDir`.
+ *
+ * Every input MUST already end with a separator — that is what makes the
+ * `startsWith` check safe against a sibling like `/foo/barista`.
+ */
+export declare function dedupAndPruneRoots(inputs: string[]): DedupAndPruneResult;
+/**
+ * Input to {@link resolveBaseDirs}, in precedence order: `cliRoots` (highest),
+ * `envBaseDirs`, `envBaseDir`, `cwd`.
+ *
+ * The resolver reads no process state, so both entry points can share it and
+ * tests can drive it deterministically.
+ */
+export interface ResolveBaseDirsInput {
+    cliRoots?: string[] | undefined;
+    envBaseDirs?: string | undefined;
+    envBaseDir?: string | undefined;
+    cwd: string;
+}
+/**
+ * Result of {@link resolveBaseDirs}, discriminated by `ok` — invalid
+ * `BASE_DIRS` is a routine user-facing path, not an exception.
+ *
+ * `warnings` is in display order: the precedence note first, then one entry
+ * per pruned root.
+ */
+export type ResolveBaseDirsResult = {
+    ok: true;
+    config: BaseDirsConfig;
+    warnings: BaseDirsConfigWarning[];
+} | {
+    ok: false;
+    error: BaseDirsConfigError;
+};
+/**
+ * Resolve effective base directories from CLI / env / cwd.
+ *
+ * `cliRoots` REPLACES the env roots rather than merging with them; otherwise
+ * precedence falls through `BASE_DIRS`, `BASE_DIR`, `cwd`. The
+ * `BASE_DIRS > BASE_DIR` warning therefore fires only on an env-driven run.
+ *
+ * An invalid `BASE_DIRS`, or a root that is not a readable directory, returns
+ * `{ ok: false }`. The resolver never falls back to `BASE_DIR` or `cwd` — each
+ * caller surfaces the error per its own UI contract.
+ */
+export declare function resolveBaseDirs(input: ResolveBaseDirsInput): Promise<ResolveBaseDirsResult>;
+/**
+ * The legacy single-root `baseDir`: the first effective root after pruning.
+ * Holds only for a config built via {@link dedupAndPruneRoots}.
+ */
+export declare function legacyBaseDir(config: BaseDirsConfig): string;
+//# sourceMappingURL=base-dirs.d.ts.map

package/dist/utils/base-dirs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-dirs.d.ts","sourceRoot":"","sources":["../../src/utils/base-dirs.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,QAAQ,EAAW,MAAM,aAAa,CAAA;AAM/C;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,WAAW,EAAE,MAAM,EAAE,CAAA;CACtB;AAED;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAC7B;IACE,IAAI,EAAE,oBAAoB,CAAA;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf,GACD;IACE,IAAI,EAAE,8BAA8B,CAAA;IACpC,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAEL;;;;GAIG;AACH,qBAAa,mBAAoB,SAAQ,QAAQ;IAC/C,YAAY,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,EAGvD;CACF;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAC7B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,mBAAmB,CAAA;CAAE,CAAA;AAM7C;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgBhD;AAMD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CA+DjE;AAMD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BrE;AAMD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,iEAAiE;IACjE,QAAQ,EAAE,qBAAqB,EAAE,CAAA;CAClC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,mBAAmB,CA6CxE;AAwBD;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;IAC/B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAChC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,GAAG,EAAE,MAAM,CAAA;CACZ;AAED;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAC7B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,qBAAqB,EAAE,CAAA;CAAE,GACvE;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,mBAAmB,CAAA;CAAE,CAAA;AAE7C;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAiDjG;AAkED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAM5D"}

package/dist/utils/base-dirs.js

@@ -0,0 +1,344 @@
+// Shared base-dirs module: one internal representation of the effective
+// document roots, used by both the CLI and the MCP server entry point, plus
+// the pure helpers that derive it from env vars and CLI flags.
+import { realpath, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { resolve, sep } from 'node:path';
+import { AppError, toError } from './errors.js';
+/**
+ * Configuration error raised by parsers and the realpath helper. Modeled as
+ * a dedicated subclass so consumers can distinguish configuration problems
+ * from other I/O errors (e.g. `ValidationError` from `DocumentParser`).
+ */
+export class BaseDirsConfigError extends AppError {
+    constructor(message, options) {
+        super(message, 'config', 'config', options);
+        this.name = 'BaseDirsConfigError';
+    }
+}
+// ============================================
+// Path display helpers
+// ============================================
+/**
+ * Substitute `$HOME` with `~` for a user-visible path, so a warning flowing
+ * out through MCP does not leak the OS username. `$HOME` is read at call time,
+ * never cached.
+ */
+export function displayPath(path) {
+    const home = process.env['HOME'] || homedir();
+    if (home.length === 0) {
+        return path;
+    }
+    const isWin = process.platform === 'win32';
+    const cmp = (s) => (isWin ? s.toLowerCase() : s);
+    const homeCmp = cmp(home);
+    const pathCmp = cmp(path);
+    if (pathCmp === homeCmp) {
+        return '~';
+    }
+    if (pathCmp.startsWith(homeCmp + sep) || pathCmp.startsWith(`${homeCmp}/`)) {
+        return `~${path.slice(home.length)}`;
+    }
+    return path;
+}
+// ============================================
+// JSON-array parser for BASE_DIRS
+// ============================================
+/**
+ * Parse `BASE_DIRS`: only a JSON array of non-empty strings is accepted, so
+ * delimiter syntax like `'/a:/b'` is an error rather than a silent misread.
+ * Syntax only — existence is {@link normalizeRealpath}'s job.
+ */
+export function parseBaseDirsEnv(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        return {
+            ok: false,
+            error: new BaseDirsConfigError('BASE_DIRS must be a JSON array of non-empty path strings (received empty value).'),
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: new BaseDirsConfigError(`BASE_DIRS must be a JSON array of non-empty path strings. Failed to parse as JSON: ${truncate(raw)}`, { cause: toError(error) }),
+        };
+    }
+    if (!Array.isArray(parsed)) {
+        return {
+            ok: false,
+            error: new BaseDirsConfigError(`BASE_DIRS must be a JSON array (received ${describeJsonShape(parsed)}).`),
+        };
+    }
+    if (parsed.length === 0) {
+        return {
+            ok: false,
+            error: new BaseDirsConfigError('BASE_DIRS must not be an empty array.'),
+        };
+    }
+    const value = [];
+    for (let i = 0; i < parsed.length; i++) {
+        const item = parsed[i];
+        if (typeof item !== 'string') {
+            return {
+                ok: false,
+                error: new BaseDirsConfigError(`BASE_DIRS[${i}] must be a string (received ${describeJsonShape(item)}).`),
+            };
+        }
+        if (item.trim().length === 0) {
+            return {
+                ok: false,
+                error: new BaseDirsConfigError(`BASE_DIRS[${i}] must be a non-empty, non-whitespace path string.`),
+            };
+        }
+        value.push(item);
+    }
+    return { ok: true, value };
+}
+// ============================================
+// Realpath normalization
+// ============================================
+/**
+ * Append a trailing path separator if the input does not already end with
+ * one. This is the prefix-safety pattern used throughout the parser
+ * (`/foo/bar` must not match `/foo/barista`).
+ */
+export function withTrailingSeparator(path) {
+    return path.endsWith(sep) ? path : path + sep;
+}
+/**
+ * Resolve a directory to its realpath and append a trailing separator, so the
+ * result works directly as a prefix in a containment check.
+ *
+ * Throws when the path is not an existing directory: a root must point at one.
+ */
+export async function normalizeRealpath(path) {
+    let resolved;
+    try {
+        resolved = await realpath(resolve(path));
+    }
+    catch (error) {
+        throw new BaseDirsConfigError(`Failed to resolve base directory: ${displayPath(path)}. The directory may not exist or is inaccessible.`, { cause: toError(error) });
+    }
+    let stats;
+    try {
+        stats = await stat(resolved);
+    }
+    catch (error) {
+        throw new BaseDirsConfigError(`Failed to stat resolved base directory: ${displayPath(resolved)}.`, { cause: toError(error) });
+    }
+    if (!stats.isDirectory()) {
+        throw new BaseDirsConfigError(`Base directory is not a directory: ${displayPath(path)} (resolved: ${displayPath(resolved)}).`);
+    }
+    return withTrailingSeparator(resolved);
+}
+/**
+ * Reduce realpath-normalized roots to the effective set.
+ *
+ * Exact duplicates are dropped silently — that is convenience, not a mistake.
+ * A nested root is pruned in favour of its parent with a warning, which keeps
+ * scan output free of duplicates without widening the boundary past the parent
+ * the user already configured. Surviving order is preserved so the first
+ * element stays a meaningful legacy `baseDir`.
+ *
+ * Every input MUST already end with a separator — that is what makes the
+ * `startsWith` check safe against a sibling like `/foo/barista`.
+ */
+export function dedupAndPruneRoots(inputs) {
+    // Pass 1: exact dedup, preserving order.
+    const deduped = [];
+    const seen = new Set();
+    for (const root of inputs) {
+        if (!seen.has(root)) {
+            seen.add(root);
+            deduped.push(root);
+        }
+    }
+    // Pass 2: nested-root pruning.
+    //
+    // In a chain like `[grandparent, parent, child]` both descendants are pruned
+    // and each warning names the closest SURVIVING ancestor, so a warning never
+    // points at a path that was itself pruned. Hence two passes: the pre-pass
+    // computes the survivors, the main pass resolves ancestors against them.
+    // O(n^2) in root count, which is harmless at realistic sizes.
+    const roots = [];
+    const warnings = [];
+    // Pre-pass: identify every candidate that has any ancestor in `deduped`
+    // (these are the pruned candidates). The candidates that do NOT have any
+    // ancestor in `deduped` are the surviving roots.
+    const survivors = [];
+    for (const candidate of deduped) {
+        if (findParent(candidate, deduped) === undefined) {
+            survivors.push(candidate);
+        }
+    }
+    for (const candidate of deduped) {
+        const survivingAncestor = findParent(candidate, survivors);
+        if (survivingAncestor === undefined) {
+            // This candidate is itself a surviving root.
+            roots.push(candidate);
+            continue;
+        }
+        warnings.push({
+            kind: 'nested-root-pruned',
+            message: `Nested base directory pruned: ${displayPath(candidate)} is inside ${displayPath(survivingAncestor)}. Keeping ${displayPath(survivingAncestor)} only.`,
+            parent: survivingAncestor,
+            pruned: candidate,
+        });
+    }
+    return { roots, warnings };
+}
+/** Closest ancestor of `candidate` in `all`, measured by prefix length. */
+function findParent(candidate, all) {
+    let best;
+    for (const other of all) {
+        if (other === candidate) {
+            continue;
+        }
+        // `other` ends with `sep` (precondition), so this prefix check is
+        // sibling-prefix safe.
+        if (candidate.startsWith(other)) {
+            if (best === undefined || other.length > best.length) {
+                best = other;
+            }
+        }
+    }
+    return best;
+}
+/**
+ * Resolve effective base directories from CLI / env / cwd.
+ *
+ * `cliRoots` REPLACES the env roots rather than merging with them; otherwise
+ * precedence falls through `BASE_DIRS`, `BASE_DIR`, `cwd`. The
+ * `BASE_DIRS > BASE_DIR` warning therefore fires only on an env-driven run.
+ *
+ * An invalid `BASE_DIRS`, or a root that is not a readable directory, returns
+ * `{ ok: false }`. The resolver never falls back to `BASE_DIR` or `cwd` — each
+ * caller surfaces the error per its own UI contract.
+ */
+export async function resolveBaseDirs(input) {
+    const selection = selectRoots(input);
+    if (!selection.ok) {
+        return selection;
+    }
+    const warnings = [];
+    if (selection.precedenceWarning) {
+        warnings.push(selection.precedenceWarning);
+    }
+    // Realpath-normalize each selected root. Failures (missing directory,
+    // permission denied, ...) are surfaced as a structured config error.
+    //
+    // Pair each realpath'd root (security form) with its resolve()-only form so
+    // `rawBaseDirs` mirrors the dedup/prune decisions index-for-index. See
+    // {@link BaseDirsConfig} for the path policy.
+    const normalized = [];
+    const realToRaw = new Map();
+    for (const root of selection.roots) {
+        let real;
+        try {
+            real = await normalizeRealpath(root);
+        }
+        catch (error) {
+            if (error instanceof BaseDirsConfigError) {
+                return { ok: false, error };
+            }
+            throw error;
+        }
+        normalized.push(real);
+        // First-occurrence-wins so the surviving raw root matches the first
+        // configured spelling of a root that realpaths to the same directory.
+        if (!realToRaw.has(real)) {
+            realToRaw.set(real, withTrailingSeparator(resolve(root)));
+        }
+    }
+    const { roots, warnings: pruningWarnings } = dedupAndPruneRoots(normalized);
+    warnings.push(...pruningWarnings);
+    // Project the surviving realpath'd roots back to their resolve()-only forms,
+    // preserving order so `rawBaseDirs[i]` and `baseDirs[i]` are the same root.
+    const rawRoots = roots.map((real) => realToRaw.get(real) ?? real);
+    return {
+        ok: true,
+        config: { baseDirs: roots, rawBaseDirs: rawRoots },
+        warnings,
+    };
+}
+/**
+ * Pick which input set of roots wins. String-level only, so the realpath I/O
+ * in {@link resolveBaseDirs} stays separate from the precedence rules.
+ */
+function selectRoots(input) {
+    // 1. CLI roots — when non-empty, replace env entirely (no precedence
+    //    warning even if env vars are also set, because the user explicitly
+    //    overrode them via CLI).
+    if (input.cliRoots !== undefined && input.cliRoots.length > 0) {
+        return { ok: true, roots: input.cliRoots };
+    }
+    // 2. BASE_DIRS — when CLI absent. Whitespace-only is treated as an
+    //    invalid value (consistent with parseBaseDirsEnv), not as "unset",
+    //    so the user notices a malformed env var instead of silently falling
+    //    through to BASE_DIR.
+    if (input.envBaseDirs !== undefined && input.envBaseDirs.length > 0) {
+        const parsed = parseBaseDirsEnv(input.envBaseDirs);
+        if (!parsed.ok) {
+            return { ok: false, error: parsed.error };
+        }
+        const precedenceWarning = input.envBaseDir !== undefined && input.envBaseDir.trim().length > 0
+            ? {
+                kind: 'base-dirs-overrides-base-dir',
+                message: 'BASE_DIRS is set; BASE_DIR is ignored. Unset BASE_DIR or remove BASE_DIRS to silence this warning.',
+            }
+            : undefined;
+        return precedenceWarning
+            ? { ok: true, roots: parsed.value, precedenceWarning }
+            : { ok: true, roots: parsed.value };
+    }
+    // 3. BASE_DIR — when CLI and BASE_DIRS are absent. Whitespace-only is
+    //    treated as "unset" (a user clearing the value with spaces gets the
+    //    same behavior as not setting it at all).
+    if (input.envBaseDir !== undefined && input.envBaseDir.trim().length > 0) {
+        return { ok: true, roots: [input.envBaseDir] };
+    }
+    // 4. cwd — final fallback.
+    return { ok: true, roots: [input.cwd] };
+}
+// ============================================
+// Legacy single-root accessor
+// ============================================
+/**
+ * The legacy single-root `baseDir`: the first effective root after pruning.
+ * Holds only for a config built via {@link dedupAndPruneRoots}.
+ */
+export function legacyBaseDir(config) {
+    const first = config.baseDirs[0];
+    if (first === undefined) {
+        throw new BaseDirsConfigError('BaseDirsConfig must contain at least one base directory.');
+    }
+    return first;
+}
+/**
+ * Describe a JSON value's shape for error messages without dumping its full
+ * (possibly large) content.
+ */
+function describeJsonShape(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (Array.isArray(value)) {
+        return 'array';
+    }
+    return typeof value;
+}
+/**
+ * Truncate user-supplied input so configuration error messages stay readable
+ * even when the offending value is large.
+ */
+function truncate(input, max = 100) {
+    if (input.length <= max) {
+        return input;
+    }
+    return `${input.slice(0, max)}...`;
+}
+//# sourceMappingURL=base-dirs.js.map

package/dist/utils/base-dirs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-dirs.js","sourceRoot":"","sources":["../../src/utils/base-dirs.ts"],"names":[],"mappings":"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"}

package/dist/utils/errors.d.ts

@@ -0,0 +1,32 @@
+/** Architectural layer that raised the error. */
+export type AppErrorLayer = 'embedder' | 'parser' | 'vectordb' | 'config' | 'pdf-visual';
+/** Nature of the failure, independent of layer. */
+export type AppErrorKind = 'validation' | 'io' | 'config' | 'internal';
+/**
+ * Abstract base for every domain error. Stores the `layer`/`kind`
+ * discriminants and the originating `cause`, leaving the concrete subclass to
+ * own its public constructor signature and its `name`.
+ */
+export declare abstract class AppError extends Error {
+    readonly layer: AppErrorLayer;
+    readonly kind: AppErrorKind;
+    readonly cause?: Error;
+    protected constructor(message: string, layer: AppErrorLayer, kind: AppErrorKind, options?: {
+        cause?: Error;
+    });
+}
+/**
+ * Narrow a caught value to an `Error` so it can be stored as a `cause`. A
+ * non-`Error` is wrapped as `String(value)`, so its text survives in the chain
+ * but its structure does not.
+ */
+export declare function toError(value: unknown): Error;
+/** Type guard: narrows an unknown value to the shared error taxonomy. */
+export declare function isAppError(value: unknown): value is AppError;
+/**
+ * Walks the `.cause` chain starting from `error`, returning errors in order
+ * `[outer, cause, cause.cause, ...]`. The walk stops at the first link whose
+ * `.cause` is not an `Error`. Self-referential chains are guarded against.
+ */
+export declare function getCauseChain(error: Error): Error[];
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/utils/errors.ts"],"names":[],"mappings":"AAWA,iDAAiD;AACjD,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,YAAY,CAAA;AAExF,mDAAmD;AACnD,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,IAAI,GAAG,QAAQ,GAAG,UAAU,CAAA;AAEtE;;;;GAIG;AACH,8BAAsB,QAAS,SAAQ,KAAK;IAC1C,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAA;IAC7B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAI3B,SAAkB,KAAK,CAAC,EAAE,KAAK,CAAA;IAE/B,SAAS,aACP,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,EAQ5B;CACF;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAE7C;AAED,yEAAyE;AACzE,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,EAAE,CAWnD"}

package/dist/utils/errors.js

@@ -0,0 +1,61 @@
+// Shared error taxonomy foundation.
+//
+// `AppError` is the abstract base every domain error class extends. It carries
+// two discriminants — `layer` (which architectural layer raised it) and `kind`
+// (the nature of the failure) — so a single boundary mapper can convert errors
+// to client codes and to logs without each handler re-deriving identity.
+//
+// This module is behavior-preserving on its own: it adds the `layer`/`kind`
+// metadata and centralizes `cause` storage, while the concrete classes keep
+// their existing names, messages, and `cause` semantics.
+/**
+ * Abstract base for every domain error. Stores the `layer`/`kind`
+ * discriminants and the originating `cause`, leaving the concrete subclass to
+ * own its public constructor signature and its `name`.
+ */
+export class AppError extends Error {
+    layer;
+    kind;
+    // Declared explicitly so the type is `Error | undefined` (not `unknown`,
+    // as on the native `Error.cause`) and assignment honors
+    // `exactOptionalPropertyTypes`.
+    cause;
+    constructor(message, layer, kind, options) {
+        super(message);
+        this.layer = layer;
+        this.kind = kind;
+        if (options?.cause !== undefined) {
+            this.cause = options.cause;
+        }
+    }
+}
+/**
+ * Narrow a caught value to an `Error` so it can be stored as a `cause`. A
+ * non-`Error` is wrapped as `String(value)`, so its text survives in the chain
+ * but its structure does not.
+ */
+export function toError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
+/** Type guard: narrows an unknown value to the shared error taxonomy. */
+export function isAppError(value) {
+    return value instanceof AppError;
+}
+/**
+ * Walks the `.cause` chain starting from `error`, returning errors in order
+ * `[outer, cause, cause.cause, ...]`. The walk stops at the first link whose
+ * `.cause` is not an `Error`. Self-referential chains are guarded against.
+ */
+export function getCauseChain(error) {
+    const chain = [];
+    const seen = new Set();
+    let current = error;
+    while (current !== undefined && !seen.has(current)) {
+        chain.push(current);
+        seen.add(current);
+        const next = current.cause;
+        current = next instanceof Error ? next : undefined;
+    }
+    return chain;
+}
+//# sourceMappingURL=errors.js.map

package/dist/utils/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/utils/errors.ts"],"names":[],"mappings":"AAAA,oCAAoC;AACpC,EAAE;AACF,+EAA+E;AAC/E,+EAA+E;AAC/E,+EAA+E;AAC/E,yEAAyE;AACzE,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,yDAAyD;AAQzD;;;;GAIG;AACH,MAAM,OAAgB,QAAS,SAAQ,KAAK;IACjC,KAAK,CAAe;IACpB,IAAI,CAAc;IAC3B,yEAAyE;IACzE,wDAAwD;IACxD,gCAAgC;IACd,KAAK,CAAQ;IAE/B,YACE,OAAe,EACf,KAAoB,EACpB,IAAkB,EAClB,OAA2B;QAE3B,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAClB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,OAAO,EAAE,KAAK,KAAK,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAA;QAC5B,CAAC;IACH,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,UAAU,OAAO,CAAC,KAAc;IACpC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;AAClE,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,UAAU,CAAC,KAAc;IACvC,OAAO,KAAK,YAAY,QAAQ,CAAA;AAClC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,KAAY;IACxC,MAAM,KAAK,GAAY,EAAE,CAAA;IACzB,MAAM,IAAI,GAAG,IAAI,GAAG,EAAS,CAAA;IAC7B,IAAI,OAAO,GAAsB,KAAK,CAAA;IACtC,OAAO,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;QACnD,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QACnB,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QACjB,MAAM,IAAI,GAAY,OAAO,CAAC,KAAK,CAAA;QACnC,OAAO,GAAG,IAAI,YAAY,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAA;IACpD,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC"}

package/dist/utils/limits.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Maximum directory recursion depth when scanning a base directory or ingest
+ * target. Applied identically by the CLI `ingest`/`list` walkers and the MCP
+ * server's `list_files` scan so the boundary is consistent everywhere.
+ */
+export declare const MAX_SCAN_DEPTH = 10;
+/**
+ * Default maximum file size for ingestion, in bytes (100 MB). Used when neither
+ * the CLI `--max-file-size` flag nor the `MAX_FILE_SIZE` env var is provided.
+ */
+export declare const DEFAULT_MAX_FILE_SIZE = 104857600;
+/**
+ * Hard upper bound (inclusive) for the configurable max file size, in bytes
+ * (500 MB). Values above this are rejected by `validateMaxFileSize`.
+ */
+export declare const MAX_FILE_SIZE_LIMIT = 524288000;
+/** Inclusive result-count range shared by CLI, MCP validation, and VectorStore. */
+export declare const MIN_QUERY_LIMIT = 1;
+export declare const MAX_QUERY_LIMIT = 20;
+/** Maximum number of adjacent chunks accepted on either side of a target. */
+export declare const MAX_NEIGHBOR_COUNT = 50;
+/** Inclusive upper bound for the configurable minimum chunk length. */
+export declare const MAX_CHUNK_MIN_LENGTH = 10000;
+/** Maximum encoded bytes for one visual attachment returned with a chunk. */
+export declare const MAX_VISUAL_RENDITION_BYTES: number;
+//# sourceMappingURL=limits.d.ts.map

package/dist/utils/limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../../src/utils/limits.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,cAAc,KAAK,CAAA;AAEhC;;;GAGG;AACH,eAAO,MAAM,qBAAqB,YAAc,CAAA;AAEhD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,YAAc,CAAA;AAE9C,mFAAmF;AACnF,eAAO,MAAM,eAAe,IAAI,CAAA;AAChC,eAAO,MAAM,eAAe,KAAK,CAAA;AAEjC,6EAA6E;AAC7E,eAAO,MAAM,kBAAkB,KAAK,CAAA;AAEpC,uEAAuE;AACvE,eAAO,MAAM,oBAAoB,QAAS,CAAA;AAE1C,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B,QAAa,CAAA"}