@arnilo/prism-coding-agent 0.2.3 → 0.2.5

package/dist/repository/search.js

@@ -0,0 +1,284 @@
+/** Repository search family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from repository.ts; public surface unchanged behind the barrel. */
+import { HARD_MAX_SEARCH_CONTEXT_LINES, HARD_MAX_SEARCH_MATCHES, validateCodingLimit, validateCodingLimitAllowZero } from "../limits.js";
+import { lstat, open } from "node:fs/promises";
+import { RepositoryError } from "./types.js";
+import { assertDeadline, assertNotAborted, isBinaryBuffer, resolveRepoPath } from "./path.js";
+export function compileSearchPattern(query, caseSensitive, maxPatternBytes) {
+    const patternBytes = Buffer.byteLength(query, "utf8");
+    if (patternBytes < 1)
+        throw new RepositoryError("query must be non-empty");
+    if (patternBytes > maxPatternBytes) {
+        throw new RepositoryError(`query exceeds ${maxPatternBytes} byte pattern limit`);
+    }
+    if (caseSensitive) {
+        return {
+            patternBytes,
+            testLine: (line) => {
+                const column = line.indexOf(query);
+                return column >= 0 ? { column: column + 1 } : null;
+            },
+        };
+    }
+    const needle = query.toLowerCase();
+    return {
+        patternBytes,
+        testLine: (line) => {
+            const column = line.toLowerCase().indexOf(needle);
+            return column >= 0 ? { column: column + 1 } : null;
+        },
+    };
+}
+async function searchFileLines(absolutePath, relativePath, testLine, options) {
+    assertNotAborted(options.signal);
+    assertDeadline(options.deadlineAt);
+    const handle = await open(absolutePath, "r");
+    try {
+        const st = await handle.stat();
+        if (st.size > options.maxFileBytes)
+            return "oversize";
+        const sniff = Buffer.allocUnsafe(Math.min(options.binarySniffBytes, st.size));
+        const { bytesRead: sniffed } = await handle.read(sniff, 0, sniff.length, 0);
+        if (isBinaryBuffer(sniff.subarray(0, sniffed)))
+            return "binary";
+        // Rewind and stream the whole file (already size-capped).
+        let offset = 0;
+        let lineStart = 0;
+        let lineNumber = 1;
+        let pending = Buffer.alloc(0);
+        const before = [];
+        const pendingAfter = [];
+        const readBuf = Buffer.allocUnsafe(64 * 1024);
+        const emitLine = (raw) => {
+            assertNotAborted(options.signal);
+            assertDeadline(options.deadlineAt);
+            const lineBytes = raw.length;
+            if (lineBytes > options.maxLineBytes) {
+                // Skip oversized lines but still charge scan budget for the bytes seen.
+                options.chargeScan(lineBytes);
+                if (options.maxScanBytesRemaining() < 0)
+                    return "scan";
+                lineNumber++;
+                return "ok";
+            }
+            options.chargeScan(lineBytes);
+            if (options.maxScanBytesRemaining() < 0)
+                return "scan";
+            const text = raw.toString("utf8");
+            // Drain after-context for previous matches.
+            for (let i = pendingAfter.length - 1; i >= 0; i--) {
+                const item = pendingAfter[i];
+                if (item.remaining > 0) {
+                    item.match.after.push(text);
+                    item.remaining--;
+                }
+                if (item.remaining <= 0)
+                    pendingAfter.splice(i, 1);
+            }
+            const hit = testLine(text);
+            if (hit) {
+                if (options.maxMatchesRemaining() <= 0)
+                    return "matches";
+                const match = {
+                    path: relativePath,
+                    line: lineNumber,
+                    column: hit.column,
+                    text,
+                    before: before.slice(-options.context),
+                    after: [],
+                };
+                options.pushMatch(match);
+                if (options.context > 0)
+                    pendingAfter.push({ match, remaining: options.context });
+            }
+            if (options.context > 0) {
+                before.push(text);
+                if (before.length > options.context)
+                    before.shift();
+            }
+            lineNumber++;
+            return "ok";
+        };
+        while (offset < st.size) {
+            assertNotAborted(options.signal);
+            assertDeadline(options.deadlineAt);
+            if (options.maxScanBytesRemaining() <= 0)
+                return "scan";
+            if (options.maxMatchesRemaining() <= 0)
+                return "matches";
+            const { bytesRead } = await handle.read(readBuf, 0, readBuf.length, offset);
+            if (bytesRead === 0)
+                break;
+            offset += bytesRead;
+            pending = Buffer.concat([pending, readBuf.subarray(0, bytesRead)]);
+            let start = 0;
+            for (let i = 0; i < pending.length; i++) {
+                if (pending[i] === 0x0a) {
+                    const end = i > start && pending[i - 1] === 0x0d ? i - 1 : i;
+                    const status = emitLine(pending.subarray(start, end));
+                    if (status !== "ok")
+                        return status;
+                    start = i + 1;
+                    lineStart = offset - (pending.length - start);
+                }
+            }
+            pending = pending.subarray(start);
+            void lineStart;
+        }
+        if (pending.length > 0) {
+            const status = emitLine(pending);
+            if (status !== "ok")
+                return status;
+        }
+        return "ok";
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function searchLocal(request, defaults, walk) {
+    const mode = request.mode ?? "literal";
+    if (mode !== "literal") {
+        throw new RepositoryError(`unsupported search mode: ${String(mode)} (literal only)`);
+    }
+    const caseSensitive = request.caseSensitive === true;
+    const { testLine } = compileSearchPattern(request.query, caseSensitive, defaults.maxPatternBytes);
+    const resolved = await resolveRepoPath(request.root, request.path);
+    const maxMatches = validateCodingLimit("maxMatches", request.maxMatches ?? defaults.maxMatches, HARD_MAX_SEARCH_MATCHES);
+    const context = validateCodingLimitAllowZero("context", request.context ?? defaults.maxContextLines, HARD_MAX_SEARCH_CONTEXT_LINES);
+    const exclude = new Set(request.exclude ?? defaults.exclude);
+    const deadlineAt = request.deadlineMs !== undefined ? Date.now() + request.deadlineMs : Date.now() + defaults.maxTimeMs;
+    const matches = [];
+    let scannedBytes = 0;
+    let scannedFiles = 0;
+    let scannedEntries = 0;
+    let filesSkippedBinary = 0;
+    let filesSkippedOversize = 0;
+    let truncated = false;
+    let truncatedBy = null;
+    const runFile = async (absolutePath, relativePath) => {
+        if (truncated)
+            return;
+        const status = await searchFileLines(absolutePath, relativePath, testLine, {
+            maxFileBytes: defaults.maxFileBytes,
+            maxLineBytes: defaults.maxLineBytes,
+            maxScanBytesRemaining: () => defaults.maxScanBytes - scannedBytes,
+            chargeScan: (n) => {
+                scannedBytes += n;
+            },
+            context,
+            maxMatchesRemaining: () => maxMatches - matches.length,
+            pushMatch: (match) => {
+                if (matches.length < maxMatches)
+                    matches.push(match);
+            },
+            signal: request.signal,
+            deadlineAt,
+            binarySniffBytes: defaults.binarySniffBytes,
+        });
+        if (status === "binary")
+            filesSkippedBinary++;
+        else if (status === "oversize")
+            filesSkippedOversize++;
+        else if (status === "scan") {
+            truncated = true;
+            truncatedBy = "scan";
+        }
+        else if (status === "matches") {
+            truncated = true;
+            truncatedBy = "matches";
+        }
+    };
+    try {
+        const startStat = await lstat(resolved.absolute);
+        if (startStat.isFile()) {
+            scannedEntries = 1;
+            scannedFiles = 1;
+            await runFile(resolved.absolute, resolved.relative);
+        }
+        else if (startStat.isDirectory()) {
+            for await (const event of walk(resolved.rootReal, resolved.absolute, {
+                maxDepth: defaults.maxDepth,
+                maxEntries: defaults.maxEntries,
+                maxFiles: defaults.maxFiles,
+                exclude,
+                includeHidden: request.includeHidden === true,
+                signal: request.signal,
+                deadlineAt,
+            })) {
+                if (truncated)
+                    break;
+                if (event.type === "limit") {
+                    truncated = true;
+                    truncatedBy = event.truncatedBy;
+                    break;
+                }
+                scannedEntries++;
+                if (event.entry.kind !== "file")
+                    continue;
+                scannedFiles++;
+                try {
+                    await runFile(event.absolutePath, event.entry.path);
+                }
+                catch (error) {
+                    if (error instanceof RepositoryError) {
+                        if (error.message === "Operation aborted") {
+                            truncated = true;
+                            truncatedBy = "abort";
+                            break;
+                        }
+                        if (error.message === "Repository operation exceeded time limit") {
+                            truncated = true;
+                            truncatedBy = "time";
+                            break;
+                        }
+                    }
+                    // Unreadable files are skipped; walk continues.
+                }
+            }
+        }
+        else if (startStat.isSymbolicLink()) {
+            // Symlink starts are not followed for search content.
+            scannedEntries = 1;
+        }
+    }
+    catch (error) {
+        if (error instanceof RepositoryError && error.message === "Operation aborted") {
+            truncated = true;
+            truncatedBy = "abort";
+        }
+        else if (error instanceof RepositoryError && error.message === "Repository operation exceeded time limit") {
+            truncated = true;
+            truncatedBy = "time";
+        }
+        else if (error instanceof RepositoryError) {
+            throw error;
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new RepositoryError(`cannot search path: ${message}`);
+        }
+    }
+    if (!truncated && matches.length >= maxMatches) {
+        truncated = true;
+        truncatedBy = "matches";
+    }
+    matches.sort((a, b) => {
+        if (a.path !== b.path)
+            return a.path < b.path ? -1 : 1;
+        if (a.line !== b.line)
+            return a.line - b.line;
+        return a.column - b.column;
+    });
+    return {
+        matches: matches.slice(0, maxMatches),
+        truncated,
+        truncatedBy,
+        scannedBytes,
+        scannedFiles,
+        scannedEntries,
+        filesSkippedBinary,
+        filesSkippedOversize,
+    };
+}
+//# sourceMappingURL=search.js.map

package/dist/repository/types.d.ts

@@ -0,0 +1,126 @@
+export type RepoEntryKind = "file" | "directory" | "symlink" | "other";
+export interface RepoListEntry {
+    readonly path: string;
+    readonly kind: RepoEntryKind;
+    readonly size?: number;
+}
+export interface RepositoryListResult {
+    readonly entries: readonly RepoListEntry[];
+    readonly truncated: boolean;
+    readonly truncatedBy: "results" | "entries" | "files" | "depth" | "time" | "abort" | null;
+    readonly scannedEntries: number;
+    readonly scannedFiles: number;
+    readonly nextOffset?: number;
+    readonly offset: number;
+}
+export interface RepositoryGlobResult {
+    readonly paths: readonly string[];
+    readonly truncated: boolean;
+    readonly truncatedBy: RepositoryListResult["truncatedBy"];
+    readonly scannedEntries: number;
+    readonly scannedFiles: number;
+    readonly nextOffset?: number;
+    readonly offset: number;
+}
+export type RepoSearchOutputMode = "content" | "files_with_matches" | "count";
+export interface RepositorySearchMatch {
+    readonly path: string;
+    readonly line: number;
+    readonly column: number;
+    readonly text: string;
+    readonly before: readonly string[];
+    readonly after: readonly string[];
+}
+export interface RepositorySearchResult {
+    readonly matches: readonly RepositorySearchMatch[];
+    readonly truncated: boolean;
+    readonly truncatedBy: "matches" | "scan" | "file" | "entries" | "files" | "depth" | "time" | "abort" | "pattern" | null;
+    readonly scannedBytes: number;
+    readonly scannedFiles: number;
+    readonly scannedEntries: number;
+    readonly filesSkippedBinary: number;
+    readonly filesSkippedOversize: number;
+}
+export interface ResolvedRepositoryLimits {
+    readonly maxDepth: number;
+    readonly maxEntries: number;
+    readonly maxFiles: number;
+    readonly maxResults: number;
+    readonly maxConcurrency: number;
+    readonly maxScanBytes: number;
+    readonly maxFileBytes: number;
+    readonly maxMatches: number;
+    readonly maxPatternBytes: number;
+    readonly maxLineBytes: number;
+    readonly maxContextLines: number;
+    readonly maxTimeMs: number;
+    readonly binarySniffBytes: number;
+    readonly exclude: readonly string[];
+}
+export interface RepositoryLimitOptions {
+    readonly maxDepth?: number;
+    readonly maxEntries?: number;
+    readonly maxFiles?: number;
+    readonly maxResults?: number;
+    readonly maxConcurrency?: number;
+    readonly maxScanBytes?: number;
+    readonly maxFileBytes?: number;
+    readonly maxMatches?: number;
+    readonly maxPatternBytes?: number;
+    readonly maxLineBytes?: number;
+    readonly maxContextLines?: number;
+    readonly maxTimeMs?: number;
+    /** Basename denylist skipped during descent (default `.git`, `node_modules`, `dist`). */
+    readonly exclude?: readonly string[];
+}
+export interface RepositoryListRequest {
+    readonly root: string;
+    readonly path?: string;
+    readonly includeHidden?: boolean;
+    readonly exclude?: readonly string[];
+    readonly maxDepth?: number;
+    readonly maxResults?: number;
+    readonly offset?: number;
+    readonly signal?: AbortSignal;
+    readonly deadlineMs?: number;
+}
+export interface RepositorySearchRequest {
+    readonly root: string;
+    readonly query: string;
+    readonly path?: string;
+    readonly mode?: "literal";
+    readonly outputMode?: RepoSearchOutputMode;
+    readonly caseSensitive?: boolean;
+    readonly includeHidden?: boolean;
+    readonly exclude?: readonly string[];
+    readonly context?: number;
+    readonly maxMatches?: number;
+    readonly signal?: AbortSignal;
+    readonly deadlineMs?: number;
+}
+export interface RepositoryGlobRequest {
+    readonly root: string;
+    readonly pattern: string;
+    readonly path?: string;
+    readonly includeHidden?: boolean;
+    readonly exclude?: readonly string[];
+    readonly maxDepth?: number;
+    readonly maxResults?: number;
+    readonly offset?: number;
+    /** Opt-in bounded `{a,b}` expansion (default false; expansion bounds in glob-match.ts). */
+    readonly braceExpansion?: boolean;
+    readonly signal?: AbortSignal;
+    readonly deadlineMs?: number;
+}
+export interface RepositoryOperations {
+    list(request: RepositoryListRequest): Promise<RepositoryListResult>;
+    search(request: RepositorySearchRequest): Promise<RepositorySearchResult>;
+    glob(request: RepositoryGlobRequest): Promise<RepositoryGlobResult>;
+}
+export declare const DEFAULT_REPO_EXCLUDE: readonly string[];
+export declare class RepositoryError extends Error {
+    readonly code = "ERR_PRISM_REPOSITORY";
+    constructor(message: string);
+}
+export declare function resolveRepositoryLimits(options?: RepositoryLimitOptions): ResolvedRepositoryLimits;
+/** Normalize a workspace-relative path to stable forward-slash form. */

package/dist/repository/types.js

@@ -0,0 +1,31 @@
+/** Repository types family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from repository.ts; public surface unchanged behind the barrel. */
+import { DEFAULT_BINARY_SNIFF_BYTES, DEFAULT_MAX_REPO_CONCURRENCY, DEFAULT_MAX_REPO_DEPTH, DEFAULT_MAX_REPO_ENTRIES, DEFAULT_MAX_REPO_FILES, DEFAULT_MAX_REPO_RESULTS, DEFAULT_MAX_SEARCH_CONTEXT_LINES, DEFAULT_MAX_SEARCH_FILE_BYTES, DEFAULT_MAX_SEARCH_LINE_BYTES, DEFAULT_MAX_SEARCH_MATCHES, DEFAULT_MAX_SEARCH_PATTERN_BYTES, DEFAULT_MAX_SEARCH_SCAN_BYTES, DEFAULT_MAX_SEARCH_TIME_MS, HARD_MAX_REPO_CONCURRENCY, HARD_MAX_REPO_DEPTH, HARD_MAX_REPO_ENTRIES, HARD_MAX_REPO_FILES, HARD_MAX_REPO_RESULTS, HARD_MAX_SEARCH_CONTEXT_LINES, HARD_MAX_SEARCH_FILE_BYTES, HARD_MAX_SEARCH_LINE_BYTES, HARD_MAX_SEARCH_MATCHES, HARD_MAX_SEARCH_PATTERN_BYTES, HARD_MAX_SEARCH_SCAN_BYTES, HARD_MAX_SEARCH_TIME_MS, validateCodingLimit, validateCodingLimitAllowZero, } from "../limits.js";
+export const DEFAULT_REPO_EXCLUDE = Object.freeze([".git", "node_modules", "dist"]);
+export class RepositoryError extends Error {
+    code = "ERR_PRISM_REPOSITORY";
+    constructor(message) {
+        super(message);
+        this.name = "RepositoryError";
+    }
+}
+export function resolveRepositoryLimits(options) {
+    return {
+        maxDepth: validateCodingLimit("maxDepth", options?.maxDepth ?? DEFAULT_MAX_REPO_DEPTH, HARD_MAX_REPO_DEPTH),
+        maxEntries: validateCodingLimit("maxEntries", options?.maxEntries ?? DEFAULT_MAX_REPO_ENTRIES, HARD_MAX_REPO_ENTRIES),
+        maxFiles: validateCodingLimit("maxFiles", options?.maxFiles ?? DEFAULT_MAX_REPO_FILES, HARD_MAX_REPO_FILES),
+        maxResults: validateCodingLimit("maxResults", options?.maxResults ?? DEFAULT_MAX_REPO_RESULTS, HARD_MAX_REPO_RESULTS),
+        maxConcurrency: validateCodingLimit("maxConcurrency", options?.maxConcurrency ?? DEFAULT_MAX_REPO_CONCURRENCY, HARD_MAX_REPO_CONCURRENCY),
+        maxScanBytes: validateCodingLimit("maxScanBytes", options?.maxScanBytes ?? DEFAULT_MAX_SEARCH_SCAN_BYTES, HARD_MAX_SEARCH_SCAN_BYTES),
+        maxFileBytes: validateCodingLimit("maxFileBytes", options?.maxFileBytes ?? DEFAULT_MAX_SEARCH_FILE_BYTES, HARD_MAX_SEARCH_FILE_BYTES),
+        maxMatches: validateCodingLimit("maxMatches", options?.maxMatches ?? DEFAULT_MAX_SEARCH_MATCHES, HARD_MAX_SEARCH_MATCHES),
+        maxPatternBytes: validateCodingLimit("maxPatternBytes", options?.maxPatternBytes ?? DEFAULT_MAX_SEARCH_PATTERN_BYTES, HARD_MAX_SEARCH_PATTERN_BYTES),
+        maxLineBytes: validateCodingLimit("maxLineBytes", options?.maxLineBytes ?? DEFAULT_MAX_SEARCH_LINE_BYTES, HARD_MAX_SEARCH_LINE_BYTES),
+        maxContextLines: validateCodingLimitAllowZero("maxContextLines", options?.maxContextLines ?? DEFAULT_MAX_SEARCH_CONTEXT_LINES, HARD_MAX_SEARCH_CONTEXT_LINES),
+        maxTimeMs: validateCodingLimit("maxTimeMs", options?.maxTimeMs ?? DEFAULT_MAX_SEARCH_TIME_MS, HARD_MAX_SEARCH_TIME_MS),
+        binarySniffBytes: DEFAULT_BINARY_SNIFF_BYTES,
+        exclude: Object.freeze([...(options?.exclude ?? DEFAULT_REPO_EXCLUDE)]),
+    };
+}
+/** Normalize a workspace-relative path to stable forward-slash form. */
+//# sourceMappingURL=types.js.map

package/dist/repository/walk.d.ts

@@ -0,0 +1,22 @@
+import type { RepoListEntry } from "./types.js";
+export interface RepositoryWalkLimits {
+    maxDepth: number;
+    maxEntries: number;
+    maxFiles: number;
+    exclude: ReadonlySet<string>;
+    includeHidden: boolean;
+    signal?: AbortSignal;
+    deadlineAt?: number;
+}
+export type RepositoryWalkEvent = {
+    type: "entry";
+    entry: RepoListEntry;
+    absolutePath: string;
+    depth: number;
+} | {
+    type: "limit";
+    truncatedBy: "entries" | "files" | "depth";
+};
+/** Injectable enumerator for list/search/glob. Default is the native opendir walker. */
+export type RepositoryWalk = (rootReal: string, startAbsolute: string, limits: RepositoryWalkLimits) => AsyncGenerator<RepositoryWalkEvent>;
+export declare function walkRepository(rootReal: string, startAbsolute: string, limits: RepositoryWalkLimits): AsyncGenerator<RepositoryWalkEvent>;

package/dist/repository/walk.js

@@ -0,0 +1,99 @@
+import { join } from "node:path";
+import { lstat, opendir } from "node:fs/promises";
+import { RepositoryError } from "./types.js";
+import { assertDeadline, assertNotAborted, isPathInsideRoot, kindFromDirent, shouldSkipName, toRepoRelative } from "./path.js";
+export async function* walkRepository(rootReal, startAbsolute, limits) {
+    const queue = [
+        {
+            absolute: startAbsolute,
+            relative: toRepoRelative(rootReal, startAbsolute),
+            depth: 0,
+        },
+    ];
+    let scannedEntries = 0;
+    let scannedFiles = 0;
+    while (queue.length > 0) {
+        assertNotAborted(limits.signal);
+        assertDeadline(limits.deadlineAt);
+        const current = queue.shift();
+        if (current.depth > limits.maxDepth) {
+            yield { type: "limit", truncatedBy: "depth" };
+            return;
+        }
+        let dir;
+        try {
+            dir = await opendir(current.absolute);
+        }
+        catch (error) {
+            if (current.relative === "." || current.depth === 0) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new RepositoryError(`cannot open directory: ${message}`);
+            }
+            continue;
+        }
+        const names = [];
+        try {
+            for await (const dirent of dir) {
+                assertNotAborted(limits.signal);
+                assertDeadline(limits.deadlineAt);
+                names.push(dirent);
+            }
+        }
+        finally {
+            await dir.close().catch(() => undefined);
+        }
+        names.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        for (const dirent of names) {
+            assertNotAborted(limits.signal);
+            assertDeadline(limits.deadlineAt);
+            if (shouldSkipName(dirent.name, limits.includeHidden, limits.exclude))
+                continue;
+            if (scannedEntries >= limits.maxEntries) {
+                yield { type: "limit", truncatedBy: "entries" };
+                return;
+            }
+            scannedEntries++;
+            const absolutePath = join(current.absolute, dirent.name);
+            if (!isPathInsideRoot(rootReal, absolutePath))
+                continue;
+            let kind = kindFromDirent(dirent);
+            let size;
+            // Re-check with lstat so we never follow symlinks for type/size.
+            try {
+                const st = await lstat(absolutePath);
+                if (st.isSymbolicLink())
+                    kind = "symlink";
+                else if (st.isDirectory())
+                    kind = "directory";
+                else if (st.isFile())
+                    kind = "file";
+                else
+                    kind = "other";
+                if (kind === "file")
+                    size = st.size;
+            }
+            catch {
+                continue;
+            }
+            if (kind === "file") {
+                if (scannedFiles >= limits.maxFiles) {
+                    yield { type: "limit", truncatedBy: "files" };
+                    return;
+                }
+                scannedFiles++;
+            }
+            const relativePath = current.relative === "." ? dirent.name : `${current.relative}/${dirent.name}`;
+            const entry = size === undefined ? { path: relativePath, kind } : { path: relativePath, kind, size };
+            yield { type: "entry", entry, absolutePath, depth: current.depth };
+            if (kind === "directory") {
+                const nextDepth = current.depth + 1;
+                if (nextDepth > limits.maxDepth) {
+                    yield { type: "limit", truncatedBy: "depth" };
+                    return;
+                }
+                queue.push({ absolute: absolutePath, relative: relativePath, depth: nextDepth });
+            }
+        }
+    }
+}
+//# sourceMappingURL=walk.js.map