abb-opencode-local-rag 0.1.0

package/dist/utils/base-dirs.js

@@ -0,0 +1,422 @@
+// Shared base-dirs module.
+//
+// Provides one internal representation of the effective document roots used
+// by both the CLI (`ingest`, `list`, ...) and the MCP server entry point
+// (`server-main.ts`), plus the pure helpers needed to derive it from raw
+// configuration inputs (env vars, CLI flags).
+//
+// Scope: this file ships only pure helpers and the types so every consumer
+// can adopt the same realpath/prefix-safety semantics without duplicating
+// the trailing-separator pattern.
+import { realpath, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { resolve, sep } from 'node:path';
+import { AppError } 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, cause) {
+        super(message, 'config', 'config', cause);
+        this.name = 'BaseDirsConfigError';
+    }
+}
+// ============================================
+// Path display helpers
+// ============================================
+/**
+ * Render an absolute path for inclusion in user-visible error/warning
+ * messages, substituting the current `$HOME` prefix with `~`. The substitution
+ * keeps the message useful for debugging while avoiding leaking the operating
+ * username when warnings/errors flow out through MCP responses to clients.
+ *
+ * `$HOME` resolution is read once at call time, so processes that mutate
+ * `HOME` between invocations still see the current value (no caching).
+ *
+ * Exact-match on the home directory itself (`/Users/me` → `~`) and prefix
+ * match with a trailing separator (`/Users/me/work` → `~/work`) are both
+ * supported; other paths pass through unchanged.
+ */
+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 the `BASE_DIRS` environment variable.
+ *
+ * Accepts only a JSON array of one or more non-empty, non-whitespace-only
+ * strings — e.g. `'["/Users/me/work","/Users/me/specs"]'`. Anything else
+ * (delimiter syntax such as `'/a:/b'`, an empty array, an array containing
+ * empty strings, non-string elements, JSON scalars, JSON objects, ...)
+ * produces a {@link BaseDirsConfigError}.
+ *
+ * This helper performs only syntactic validation. It does not resolve
+ * realpaths or check that the directories exist — that is the job of
+ * {@link normalizeRealpath} after the resolver picks a source.
+ */
+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)}`, 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 form and append a trailing separator
+ * so the result can be used directly as a prefix in security checks.
+ *
+ * realpath here is the security boundary (see {@link BaseDirsConfig} for the
+ * path policy); user-facing surfaces use the resolve()-only `rawBaseDirs`.
+ *
+ * Throws {@link BaseDirsConfigError} when the directory does not exist or
+ * is not a directory — root configuration must point at real directories
+ * the process is allowed to read.
+ */
+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.`, error);
+    }
+    let stats;
+    try {
+        stats = await stat(resolved);
+    }
+    catch (error) {
+        throw new BaseDirsConfigError(`Failed to stat resolved base directory: ${displayPath(resolved)}.`, error);
+    }
+    if (!stats.isDirectory()) {
+        throw new BaseDirsConfigError(`Base directory is not a directory: ${displayPath(path)} (resolved: ${displayPath(resolved)}).`);
+    }
+    return withTrailingSeparator(resolved);
+}
+/**
+ * Reduce a list of realpath-normalized roots to the effective set.
+ *
+ * Behavior:
+ *  - Exact duplicates (`A === B` after realpath normalization) are silently
+ *    deduplicated. This is treated as user convenience rather than a
+ *    configuration mistake, so no warning is emitted.
+ *  - Nested roots (`B` lives under `A` after realpath normalization) are
+ *    pruned: the parent `A` is kept, the child `B` is dropped, and a
+ *    `nested-root-pruned` warning describes both paths. This avoids
+ *    duplicate `list_files` / CLI scan output without widening the security
+ *    boundary beyond the parent root the user already configured.
+ *
+ * Input order is preserved for the surviving roots so the first element
+ * remains a meaningful legacy `baseDir` (see {@link legacyBaseDir}).
+ *
+ * All inputs MUST already have a trailing separator (see
+ * {@link normalizeRealpath}) — that is what makes the `startsWith`-based
+ * nested check safe against sibling-prefix paths 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.
+    //
+    // A root `child` is pruned when some other root `parent` (parent !== child)
+    // is a strict prefix of `child`. Because every input ends with `sep`, the
+    // prefix check correctly distinguishes `/foo/bar/` (parent of `/foo/bar/baz/`)
+    // from `/foo/barista/` (sibling, not a parent).
+    //
+    // When a chain like `[grandparent, parent, child]` is provided, both
+    // `parent` and `child` are pruned and each emits a warning referencing the
+    // closest SURVIVING ancestor (the grandparent). This is the same result the
+    // user would have gotten by passing only the grandparent, and avoids the
+    // confusing case where a warning points at another path that was itself
+    // pruned. Implementation note: this runs in two passes over `deduped`. The
+    // pre-pass computes the `survivors` set (candidates with no ancestor in
+    // `deduped`); the main pass then resolves each candidate's closest ancestor
+    // against `survivors` so the reported parent is always a surviving root.
+    // The two `findParent` scans make this O(n^2) in the number of roots, which
+    // is harmless at realistic root counts.
+    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 };
+}
+/**
+ * Return the closest ancestor of `candidate` in `all` (excluding `candidate`
+ * itself), or `undefined` if no ancestor exists. Closest is measured by
+ * prefix length — longer prefix wins so we report the most specific
+ * surviving parent.
+ */
+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 inputs.
+ *
+ * Resolution order (per the multi-base-dirs plan):
+ *   1. `cliRoots` (one or more `--base-dir` flags) — when non-empty, replaces
+ *      env roots. CLI and env are never merged.
+ *   2. `envBaseDirs` (JSON array) — when CLI roots are absent.
+ *   3. `envBaseDir` (single path) — when CLI and `BASE_DIRS` are absent.
+ *   4. `cwd` — when none of the above are set.
+ *
+ * Warning rules:
+ *  - `BASE_DIRS > BASE_DIR` precedence warning fires only when CLI roots are
+ *    absent AND both `BASE_DIRS` and `BASE_DIR` are set. CLI-driven runs do
+ *    not produce this warning even if both env vars are also set.
+ *  - Nested-root pruning warnings always fire when applicable, regardless
+ *    of which source provided the roots.
+ *
+ * Error rules:
+ *  - Invalid `BASE_DIRS` (malformed JSON, non-array, empty array, empty
+ *    string element, ...) returns `{ ok: false, error }`. The resolver does
+ *    NOT fall back to `BASE_DIR` or `cwd` — callers surface the error per
+ *    their UI contract (CLI exit code, MCP tool error, `status` diagnostic).
+ *  - A path that fails realpath resolution (does not exist, not a directory,
+ *    permission denied) also returns `{ ok: false, error }`. Roots must
+ *    point at real directories the process is allowed to read.
+ *
+ * Post-resolution normalization:
+ *  - Every selected path is realpath-normalized and gets a trailing path
+ *    separator (see {@link normalizeRealpath}) so it can be used as a prefix
+ *    in security checks.
+ *  - Exact duplicates are silently deduplicated.
+ *  - Nested roots are pruned with a warning (see {@link dedupAndPruneRoots}).
+ */
+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,
+    };
+}
+/**
+ * Apply the source-precedence rules to pick which input set of roots to use.
+ *
+ * Kept as a small helper so the realpath normalization in
+ * {@link resolveBaseDirs} stays focused on I/O, not precedence logic. This
+ * function performs only string-level parsing and selection — no fs access.
+ */
+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
+// ============================================
+/**
+ * Return the legacy single-root `baseDir` value for a {@link BaseDirsConfig}.
+ *
+ * Used for backward compatibility with consumers (and response fields) that
+ * pre-date the multi-root model. The contract is "first effective root after
+ * normalization and nested-root pruning"; callers must build the config via
+ * {@link dedupAndPruneRoots} for this to hold.
+ */
+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;
+}
+// ============================================
+// Private helpers
+// ============================================
+/**
+ * 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,24 @@
+/** 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, cause?: 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,aAAa,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE,KAAK,EAO7F;CACF;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,53 @@
+// 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, cause) {
+        super(message);
+        this.layer = layer;
+        this.kind = kind;
+        if (cause !== undefined) {
+            this.cause = cause;
+        }
+    }
+}
+/** 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,YAAsB,OAAe,EAAE,KAAoB,EAAE,IAAkB,EAAE,KAAa;QAC5F,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAClB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QACpB,CAAC;IACH,CAAC;CACF;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"}

package/dist/utils/limits.js

@@ -0,0 +1,28 @@
+// Cross-cutting numeric limits shared across CLI and MCP server entry points.
+// Dependency-free leaf module so any layer can import it without coupling.
+/**
+ * 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 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 const DEFAULT_MAX_FILE_SIZE = 104_857_600;
+/**
+ * Hard upper bound (inclusive) for the configurable max file size, in bytes
+ * (500 MB). Values above this are rejected by `validateMaxFileSize`.
+ */
+export const MAX_FILE_SIZE_LIMIT = 524_288_000;
+/** Inclusive result-count range shared by CLI, MCP validation, and VectorStore. */
+export const MIN_QUERY_LIMIT = 1;
+export const MAX_QUERY_LIMIT = 20;
+/** Maximum number of adjacent chunks accepted on either side of a target. */
+export const MAX_NEIGHBOR_COUNT = 50;
+/** Inclusive upper bound for the configurable minimum chunk length. */
+export const MAX_CHUNK_MIN_LENGTH = 10_000;
+/** Maximum encoded bytes for one visual attachment returned with a chunk. */
+export const MAX_VISUAL_RENDITION_BYTES = 512 * 1024;
+//# sourceMappingURL=limits.js.map

package/dist/utils/limits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.js","sourceRoot":"","sources":["../../src/utils/limits.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,2EAA2E;AAE3E;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,CAAA;AAEhC;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,WAAW,CAAA;AAEhD;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,WAAW,CAAA;AAE9C,mFAAmF;AACnF,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAA;AAChC,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,CAAA;AAEjC,6EAA6E;AAC7E,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,CAAA;AAEpC,uEAAuE;AACvE,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAA;AAE1C,6EAA6E;AAC7E,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAG,GAAG,IAAI,CAAA"}

package/dist/utils/list-sources.d.ts

@@ -0,0 +1,47 @@
+/**
+ * An ingested entry paired with its identity key (`realpathForMatch` of the
+ * stored `filePath`). Only the fields the classifier reads are required, so the
+ * caller's richer row type is consumed structurally.
+ */
+export interface KeyedIngestedEntry {
+    entry: {
+        filePath: string;
+        chunkCount: number;
+        timestamp: string;
+    };
+    key: string;
+}
+/**
+ * A classified source: a raw-data entry restored to its original `source`, or a
+ * real-file / orphaned entry keyed by `filePath`. Structurally compatible with
+ * the `SourceEntry` union both surfaces already return (no type-move refactor).
+ */
+export type ClassifiedSource = {
+    source: string;
+    chunkCount: number;
+    timestamp: string;
+} | {
+    filePath: string;
+    chunkCount: number;
+    timestamp: string;
+};
+/**
+ * Classify the ingested entries that matched no scanned file into `sources`.
+ *
+ * Base filter (always): keep only entries whose `key` is absent from
+ * `matchedKeys`.
+ *
+ * When `scope` is present (non-empty): raw-data entries
+ * Managed raw-data entries have no filesystem path under a base directory, so
+ * they are always emitted regardless of scope; real-file entries are kept only
+ * when their stored `filePath` is under scope (`matchesAnyScope`) — a real-file
+ * entry outside scope is dropped so it appears in neither `files[]` (already
+ * pruned from the scan) nor `sources[]` (no orphan misclassification), while an
+ * unmatched real-file entry under scope remains an orphan source.
+ *
+ * When `scope` is absent (or empty): behavior is unchanged from the pre-extraction
+ * inline block — every unmatched entry is emitted, raw-data as `{ source }` when
+ * `extractSourceFromPath` yields one, else as `{ filePath }`.
+ */
+export declare function classifyIngestedSources(ingestedKeyed: readonly KeyedIngestedEntry[], matchedKeys: ReadonlySet<string>, dbPath: string, scope?: string[]): ClassifiedSource[];
+//# sourceMappingURL=list-sources.d.ts.map

package/dist/utils/list-sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-sources.d.ts","sourceRoot":"","sources":["../../src/utils/list-sources.ts"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;IAClE,GAAG,EAAE,MAAM,CAAA;CACZ;AAED;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAA;AAE/D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,SAAS,kBAAkB,EAAE,EAC5C,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,MAAM,EAAE,GACf,gBAAgB,EAAE,CAoBpB"}