@cue-dev/retrieval-core 0.1.3

package/dist/indexing-ignore.d.ts

@@ -0,0 +1,9 @@
+export declare const INDEXING_IGNORE_FILENAMES: readonly [".contextignore", ".cueignore"];
+type IndexingPathKind = "file" | "dir";
+export interface IndexingIgnoreMatcher {
+    patterns: string[];
+    shouldIgnorePath(path: string, kind: IndexingPathKind): boolean;
+}
+export declare function normalizeRepoRelativePath(path: string): string;
+export declare function loadIndexingIgnoreMatcher(projectRootPath: string): Promise<IndexingIgnoreMatcher>;
+export {};

package/dist/indexing-ignore.js

@@ -0,0 +1,151 @@
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+export const INDEXING_IGNORE_FILENAMES = [".contextignore", ".cueignore"];
+const INDEXING_CONTROL_FILENAMES = new Set(INDEXING_IGNORE_FILENAMES.map((name) => name.toLowerCase()));
+function escapeRegexChar(char) {
+    return /[\\^$+?.()|[\]{}]/.test(char) ? `\\${char}` : char;
+}
+function compileGlobPattern(pattern) {
+    let output = "";
+    for (let i = 0; i < pattern.length; i += 1) {
+        const char = pattern[i];
+        if (char === undefined) {
+            continue;
+        }
+        if (char === "*") {
+            const next = pattern[i + 1];
+            if (next === "*") {
+                const afterDouble = pattern[i + 2];
+                if (afterDouble === "/") {
+                    output += "(?:.*/)?";
+                    i += 2;
+                    continue;
+                }
+                output += ".*";
+                i += 1;
+                continue;
+            }
+            output += "[^/]*";
+            continue;
+        }
+        if (char === "?") {
+            output += "[^/]";
+            continue;
+        }
+        output += escapeRegexChar(char);
+    }
+    return new RegExp(`^${output}$`);
+}
+export function normalizeRepoRelativePath(path) {
+    const normalized = path
+        .replace(/\\/g, "/")
+        .replace(/^\.\/+/, "")
+        .replace(/^\/+/, "")
+        .replace(/\/+/g, "/")
+        .replace(/\/+$/, "");
+    return normalized;
+}
+function basename(path) {
+    const normalized = normalizeRepoRelativePath(path);
+    if (normalized.length === 0) {
+        return "";
+    }
+    const lastSlash = normalized.lastIndexOf("/");
+    return lastSlash === -1 ? normalized : normalized.slice(lastSlash + 1);
+}
+function listAncestorDirectories(path, kind) {
+    const normalized = normalizeRepoRelativePath(path);
+    if (normalized.length === 0) {
+        return [];
+    }
+    const segments = normalized.split("/");
+    const depth = kind === "dir" ? segments.length : Math.max(segments.length - 1, 0);
+    const output = [];
+    let current = "";
+    for (let i = 0; i < depth; i += 1) {
+        current = current.length === 0 ? segments[i] : `${current}/${segments[i]}`;
+        output.push(current);
+    }
+    return output;
+}
+function parseIgnorePatterns(content) {
+    const lines = content.split(/\r?\n/);
+    const output = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            continue;
+        }
+        // v1 is exclude-only; ignore negation directives for deterministic behavior.
+        if (trimmed.startsWith("!")) {
+            continue;
+        }
+        const normalized = normalizeRepoRelativePath(trimmed);
+        if (normalized.length === 0) {
+            continue;
+        }
+        output.push(trimmed.endsWith("/") ? `${normalized}/` : normalized);
+    }
+    return output;
+}
+function compileIgnoreRules(patterns) {
+    return patterns
+        .map((pattern) => {
+        const directoryOnly = pattern.endsWith("/");
+        const normalizedPattern = directoryOnly ? pattern.slice(0, -1) : pattern;
+        const normalized = normalizeRepoRelativePath(normalizedPattern);
+        if (normalized.length === 0) {
+            return undefined;
+        }
+        return {
+            directory_only: directoryOnly,
+            has_slash: normalized.includes("/"),
+            regex: compileGlobPattern(normalized)
+        };
+    })
+        .filter((rule) => rule !== undefined);
+}
+function matchesRule(rule, path, kind) {
+    const normalized = normalizeRepoRelativePath(path);
+    if (normalized.length === 0) {
+        return false;
+    }
+    if (!rule.directory_only) {
+        if (rule.has_slash) {
+            return rule.regex.test(normalized);
+        }
+        return rule.regex.test(basename(normalized));
+    }
+    const ancestors = listAncestorDirectories(normalized, kind);
+    if (rule.has_slash) {
+        return ancestors.some((ancestor) => rule.regex.test(ancestor));
+    }
+    return ancestors.some((ancestor) => rule.regex.test(basename(ancestor)));
+}
+export async function loadIndexingIgnoreMatcher(projectRootPath) {
+    const root = resolve(projectRootPath);
+    const patterns = [];
+    for (const filename of INDEXING_IGNORE_FILENAMES) {
+        try {
+            const content = await readFile(join(root, filename), "utf8");
+            patterns.push(...parseIgnorePatterns(content));
+        }
+        catch {
+            continue;
+        }
+    }
+    const rules = compileIgnoreRules(patterns);
+    return {
+        patterns,
+        shouldIgnorePath(path, kind) {
+            const normalized = normalizeRepoRelativePath(path);
+            if (normalized.length === 0) {
+                return false;
+            }
+            if (kind === "file" && INDEXING_CONTROL_FILENAMES.has(basename(normalized).toLowerCase())) {
+                return true;
+            }
+            return rules.some((rule) => matchesRule(rule, normalized, kind));
+        }
+    };
+}

package/dist/remote-sync.d.ts

@@ -0,0 +1,193 @@
+export declare const REMOTE_SYNC_STATE_MODE: "remote_delta_v1";
+export declare const DEFAULT_REMOTE_SYNC_MAX_FILE_SIZE_BYTES = 1000000;
+export interface RemoteSyncUploadCandidate {
+    path: string;
+    content: string;
+    language?: string;
+}
+export interface RemoteSyncProjectFileStat {
+    path: string;
+    full_path: string;
+    size: number;
+    mtime_ms: number;
+    language?: string;
+}
+export interface RemoteSyncStateEntry {
+    content_hash: string;
+    size: number;
+    mtime_ms: number;
+    language?: string;
+}
+export interface RemoteSyncStateFile {
+    mode: typeof REMOTE_SYNC_STATE_MODE;
+    workspace_id?: string;
+    last_index_version?: string;
+    files: Record<string, RemoteSyncStateEntry>;
+    updated_at: string;
+}
+export interface RemoteSyncDeltaPayload {
+    upsert_files: RemoteSyncUploadCandidate[];
+    deleted_paths: string[];
+}
+export interface RemoteSyncDeltaBatch {
+    upsert_files: RemoteSyncUploadCandidate[];
+    deleted_paths: string[];
+    approx_bytes: number;
+}
+export interface BuildRemoteSyncDeltaResult {
+    delta: RemoteSyncDeltaPayload;
+    upsert_state_entries: Record<string, RemoteSyncStateEntry>;
+    next_files: Record<string, RemoteSyncStateEntry>;
+}
+export interface RemoteSyncScanOptions {
+    max_file_size_bytes?: number;
+    excluded_dirs?: Set<string>;
+    excluded_files?: Set<string>;
+    excluded_file_suffixes?: Set<string>;
+}
+export declare class RemoteSyncHttpResponseError extends Error {
+    readonly status: number;
+    readonly payload?: unknown | undefined;
+    constructor(message: string, status: number, payload?: unknown | undefined);
+}
+export interface RunRemoteDeltaSyncInput {
+    project_root_path: string;
+    scan_root_path?: string;
+    workspace_id?: string;
+    previous_state?: RemoteSyncStateFile;
+    force_full_upsert?: boolean;
+    max_body_bytes: number;
+    retries?: number;
+    initial_delay_ms?: number;
+    stale_base_error?: (error: unknown) => boolean;
+    persist_state?: (state: RemoteSyncStateFile) => Promise<void>;
+    on_batch_processed?: (event: {
+        batch_index: number;
+        batch_count: number;
+        approx_bytes: number;
+        upsert_files: number;
+        deleted_paths: number;
+        latency_ms: number;
+    }) => void | Promise<void>;
+    push_delta: (request: {
+        workspace_id?: string;
+        project_root_path: string;
+        base_index_version?: string;
+        upsert_files: RemoteSyncUploadCandidate[];
+        deleted_paths: string[];
+    }) => Promise<{
+        workspace_id?: string;
+        index_version?: string;
+    }>;
+}
+export interface RunRemoteDeltaSyncResult {
+    state: RemoteSyncStateFile;
+    changed: boolean;
+    workspace_id?: string;
+    index_version?: string;
+    applied_delta: {
+        upsert_files: number;
+        deleted_paths: number;
+    };
+    stats: {
+        batches_total: number;
+        bytes_total: number;
+        latency_ms: number;
+    };
+}
+export interface RemoteSyncCapabilities {
+    max_body_bytes: number;
+    sync_protocols?: string[];
+    max_blob_bytes?: number;
+    max_blob_batch_bytes?: number;
+    max_commit_body_bytes?: number;
+    upload_concurrency_hint?: number;
+}
+export interface RunRemoteAdaptiveSyncInput {
+    project_root_path: string;
+    scan_root_path?: string;
+    workspace_id?: string;
+    previous_state?: RemoteSyncStateFile;
+    force_full_upsert?: boolean;
+    capabilities: RemoteSyncCapabilities;
+    retries?: number;
+    initial_delay_ms?: number;
+    stale_base_error?: (error: unknown) => boolean;
+    persist_state?: (state: RemoteSyncStateFile) => Promise<void>;
+    push_delta: RunRemoteDeltaSyncInput["push_delta"];
+    upload_blobs: (request: {
+        workspace_id?: string;
+        project_root_path: string;
+        blobs: Array<{
+            hash: string;
+            content: string;
+            size_bytes: number;
+        }>;
+    }) => Promise<{
+        accepted_hashes: string[];
+        already_present_hashes: string[];
+        rejected: Array<{
+            hash: string;
+            reason: string;
+        }>;
+    }>;
+    commit_v2: (request: {
+        workspace_id?: string;
+        project_root_path: string;
+        base_index_version?: string;
+        upsert_files: Array<{
+            path: string;
+            blob_hash: string;
+            language?: string;
+            generated?: boolean;
+            binary?: boolean;
+            updated_at?: string;
+        }>;
+        deleted_paths: string[];
+    }) => Promise<{
+        workspace_id?: string;
+        index_version?: string;
+    }>;
+    on_upload_strategy_change?: (event: {
+        previous_concurrency: number;
+        next_concurrency: number;
+        reason: "success" | "error";
+    }) => void | Promise<void>;
+}
+export interface RunRemoteAdaptiveSyncResult extends RunRemoteDeltaSyncResult {
+    protocol: "delta_v1" | "blob_commit_v2";
+}
+export declare function collectProjectFileStats(project_root_path: string, options?: RemoteSyncScanOptions): Promise<Map<string, RemoteSyncProjectFileStat>>;
+export declare function collectUploadCandidates(project_root_path: string, options?: RemoteSyncScanOptions): Promise<RemoteSyncUploadCandidate[]>;
+export declare function buildRemoteSyncDeltaFromState(input: {
+    project_root_path: string;
+    previous_state?: RemoteSyncStateFile;
+    force_full_upsert: boolean;
+    options?: RemoteSyncScanOptions;
+}): Promise<BuildRemoteSyncDeltaResult>;
+export declare function estimateRemoteSyncDeltaRequestSize(input: {
+    project_root_path: string;
+    workspace_id?: string;
+    base_index_version?: string;
+    upsert_files: RemoteSyncUploadCandidate[];
+    deleted_paths: string[];
+}): number;
+export declare function splitRemoteSyncDeltaIntoBatches(input: {
+    project_root_path: string;
+    workspace_id?: string;
+    base_index_version?: string;
+    delta: RemoteSyncDeltaPayload;
+    max_body_bytes: number;
+}): RemoteSyncDeltaBatch[];
+export declare function readRemoteSyncState(path: string): Promise<RemoteSyncStateFile | undefined>;
+export declare function writeRemoteSyncState(path: string, state: RemoteSyncStateFile): Promise<void>;
+export declare function isStaleBaseIndexError(error: unknown): boolean;
+export declare function isDeltaUnsupportedError(error: unknown): boolean;
+export declare function isBlobCommitV2UnsupportedError(error: unknown): boolean;
+export declare function runRemoteAdaptiveSync(input: RunRemoteAdaptiveSyncInput): Promise<RunRemoteAdaptiveSyncResult>;
+export declare function retryWithBackoff<T>(input: {
+    fn: () => Promise<T>;
+    retries: number;
+    initial_delay_ms: number;
+}): Promise<T>;
+export declare function runRemoteDeltaSync(input: RunRemoteDeltaSyncInput): Promise<RunRemoteDeltaSyncResult>;