@arnilo/prism-coding-agent 0.0.96 → 0.1.0

package/dist/process/types.d.ts

@@ -0,0 +1,146 @@
+import type { AgentIdentity, ExecutionPolicy, OwnershipScope } from "@arnilo/prism";
+/** Duck-typed long-running sandbox handle (mirrors coding-security SandboxProcessHandle). */
+export interface ProcessSandboxHandle {
+    write(data: Uint8Array): Promise<void>;
+    signal(name: string): Promise<void>;
+    kill(): Promise<void>;
+    release(): Promise<void>;
+    wait(options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<{
+        exitCode: number | null;
+    }>;
+}
+export interface ProcessSandboxStartRequest {
+    readonly file: string;
+    readonly args: readonly string[];
+    readonly cwd?: string;
+    readonly env?: Readonly<Record<string, string>>;
+    readonly onData?: (data: Buffer) => void;
+    readonly signal?: AbortSignal;
+    readonly timeout?: number;
+}
+/**
+ * Optional sandbox backend for ProcessSessions.
+ * Presence of `startProcess` = long-running capable; absence fails closed.
+ */
+export interface ProcessSandboxBackend {
+    startProcess?(request: ProcessSandboxStartRequest): Promise<ProcessSandboxHandle>;
+    status?(): Promise<{
+        readonly state: string;
+    }>;
+}
+export type ProcessSessionState = "starting" | "running" | "exited" | "killed" | "released" | "expired" | "unknown";
+export type ProcessSessionErrorCode = "ERR_PRISM_PROCESS_POLICY" | "ERR_PRISM_PROCESS_OWNERSHIP" | "ERR_PRISM_PROCESS_STATE" | "ERR_PRISM_PROCESS_LIMIT" | "ERR_PRISM_PROCESS_PTY_UNSUPPORTED" | "ERR_PRISM_PROCESS_UNSUPPORTED";
+export declare class ProcessSessionError extends Error {
+    readonly code: ProcessSessionErrorCode;
+    constructor(code: ProcessSessionErrorCode, message: string);
+}
+export interface ProcessSessionLimits {
+    readonly maxSessions?: number;
+    readonly maxInputBytes?: number;
+    readonly maxLifetimeMs?: number;
+    readonly maxOutputChunkBytes?: number;
+    readonly maxTotalOutputBytes?: number;
+}
+export interface ResolvedProcessSessionLimits {
+    readonly maxSessions: number;
+    readonly maxInputBytes: number;
+    readonly maxLifetimeMs: number;
+    readonly maxOutputChunkBytes: number;
+    readonly maxTotalOutputBytes: number;
+}
+export declare function resolveProcessSessionLimits(limits?: ProcessSessionLimits): ResolvedProcessSessionLimits;
+export interface ProcessStartRequest {
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly cwd?: string;
+    readonly env?: Readonly<Record<string, string>>;
+    /** Default false. true on unsupported platform → ERR_PRISM_PROCESS_PTY_UNSUPPORTED. */
+    readonly pty?: boolean;
+    readonly lifetimeMs?: number;
+    /** Owner string for this session; defaults to registry ownership key. */
+    readonly owner?: string;
+    /** When true, run cancel releases instead of killing (default kill). */
+    readonly releaseOnCancel?: boolean;
+}
+export interface ProcessOutputChunk {
+    readonly data: string;
+    /** Next byte cursor for paging. */
+    readonly cursor: number;
+    readonly eof: boolean;
+}
+export interface ProcessExitResult {
+    readonly exitCode: number | null;
+    readonly state: ProcessSessionState;
+}
+export interface ProcessSessionMetadata {
+    readonly id: string;
+    readonly commandFingerprint: string;
+    readonly owner: string;
+    readonly workspace: string;
+    readonly policyDecision: string;
+    readonly startedAt: string;
+    readonly exitedAt?: string;
+    readonly state: ProcessSessionState;
+    readonly releaseOnCancel: boolean;
+}
+export interface ProcessSession {
+    readonly id: string;
+    readonly state: ProcessSessionState;
+    readonly owner: string;
+    metadata(): ProcessSessionMetadata;
+    output(request?: {
+        cursor?: number;
+        maxBytes?: number;
+    }): Promise<ProcessOutputChunk>;
+    input(data: string | Uint8Array): Promise<void>;
+    wait(options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<ProcessExitResult>;
+    signal(name: "SIGTERM" | "SIGINT" | "SIGHUP"): Promise<void>;
+    kill(): Promise<void>;
+    release(): Promise<void>;
+}
+export type CodingProcessEvent = {
+    readonly type: "process_started" | "process_exited" | "process_killed" | "process_released" | "process_expired" | "process_unknown";
+    readonly sessionId: string;
+    readonly processId: string;
+    readonly owner: string;
+    readonly exitCode?: number | null;
+    readonly at: string;
+};
+export interface ProcessSessions {
+    start(request: ProcessStartRequest): Promise<ProcessSession>;
+    get(sessionId: string, owner?: string): ProcessSession;
+    /** Kill (default) or release all sessions for `owner`. */
+    cancelOwned(owner: string, options?: {
+        release?: boolean;
+    }): Promise<void>;
+    /** Mark a running session unknown (backend loss); never fabricates exitCode. */
+    markUnknown(sessionId: string, owner?: string): Promise<void>;
+    /**
+     * Host resume / sandbox-loss reconciliation: mark every running/starting session unknown.
+     * Never fabricates exitCode. O(owned sessions).
+     */
+    reconcile(): Promise<{
+        readonly markedUnknown: number;
+    }>;
+    dispose(): Promise<void>;
+}
+export interface CreateProcessSessionsOptions {
+    readonly cwd: string;
+    readonly policy?: ExecutionPolicy;
+    readonly limits?: ProcessSessionLimits;
+    readonly onEvent?: (event: CodingProcessEvent) => void;
+    readonly ownership?: OwnershipScope;
+    /** Host-verified identity; projects onto default owner when ownership omitted. */
+    readonly identity?: AgentIdentity;
+    /**
+     * When set: use `startProcess` if present; otherwise start() fails closed
+     * (`ERR_PRISM_PROCESS_UNSUPPORTED`). Native spawn only when sandbox omitted.
+     */
+    readonly sandbox?: ProcessSandboxBackend;
+}

package/dist/process/types.js

@@ -0,0 +1,19 @@
+import { DEFAULT_MAX_PROCESS_INPUT_BYTES, DEFAULT_MAX_PROCESS_LIFETIME_MS, DEFAULT_MAX_PROCESS_OUTPUT_CHUNK_BYTES, DEFAULT_MAX_PROCESS_SESSIONS, DEFAULT_MAX_PROCESS_TOTAL_OUTPUT_BYTES, HARD_MAX_PROCESS_INPUT_BYTES, HARD_MAX_PROCESS_LIFETIME_MS, HARD_MAX_PROCESS_OUTPUT_CHUNK_BYTES, HARD_MAX_PROCESS_SESSIONS, HARD_MAX_PROCESS_TOTAL_OUTPUT_BYTES, validateCodingLimit, } from "../limits.js";
+export class ProcessSessionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ProcessSessionError";
+        this.code = code;
+    }
+}
+export function resolveProcessSessionLimits(limits) {
+    return {
+        maxSessions: validateCodingLimit("maxSessions", limits?.maxSessions ?? DEFAULT_MAX_PROCESS_SESSIONS, HARD_MAX_PROCESS_SESSIONS),
+        maxInputBytes: validateCodingLimit("maxInputBytes", limits?.maxInputBytes ?? DEFAULT_MAX_PROCESS_INPUT_BYTES, HARD_MAX_PROCESS_INPUT_BYTES),
+        maxLifetimeMs: validateCodingLimit("maxLifetimeMs", limits?.maxLifetimeMs ?? DEFAULT_MAX_PROCESS_LIFETIME_MS, HARD_MAX_PROCESS_LIFETIME_MS),
+        maxOutputChunkBytes: validateCodingLimit("maxOutputChunkBytes", limits?.maxOutputChunkBytes ?? DEFAULT_MAX_PROCESS_OUTPUT_CHUNK_BYTES, HARD_MAX_PROCESS_OUTPUT_CHUNK_BYTES),
+        maxTotalOutputBytes: validateCodingLimit("maxTotalOutputBytes", limits?.maxTotalOutputBytes ?? DEFAULT_MAX_PROCESS_TOTAL_OUTPUT_BYTES, HARD_MAX_PROCESS_TOTAL_OUTPUT_BYTES),
+    };
+}
+//# sourceMappingURL=types.js.map

package/dist/read-path-set.d.ts

@@ -0,0 +1,14 @@
+/** Session-scoped paths successfully read via the read tool (host-owned, not checkpointed). */
+export interface ReadPathSet {
+    has(path: string): boolean;
+    add(path: string): void;
+    list(): readonly string[];
+    clear(): void;
+}
+export declare function createReadPathSet(): ReadPathSet;
+export interface ReadBeforeWriteOptions {
+    requireReadBeforeWrite?: boolean;
+    readPathSet?: ReadPathSet;
+}
+/** Returns refusal message, or null when the mutation may proceed. */
+export declare function refuseReadBeforeWrite(operation: "write" | "edit", displayPath: string, absolutePath: string, options: ReadBeforeWriteOptions | undefined, force: boolean): string | null;

package/dist/read-path-set.js

@@ -0,0 +1,26 @@
+export function createReadPathSet() {
+    const paths = new Set();
+    return {
+        has(path) {
+            return paths.has(path);
+        },
+        add(path) {
+            paths.add(path);
+        },
+        list() {
+            return [...paths];
+        },
+        clear() {
+            paths.clear();
+        },
+    };
+}
+/** Returns refusal message, or null when the mutation may proceed. */
+export function refuseReadBeforeWrite(operation, displayPath, absolutePath, options, force) {
+    if (!options?.requireReadBeforeWrite || force)
+        return null;
+    if (options.readPathSet?.has(absolutePath))
+        return null;
+    return `Refusing ${operation} to ${displayPath}: not read in this session. Read first or pass force=true.`;
+}
+//# sourceMappingURL=read-path-set.js.map

package/dist/read.d.ts

@@ -21,6 +21,7 @@
  */
 import { Buffer } from "node:buffer";
 import type { ExecutionPolicy, ToolDefinition } from "@arnilo/prism";
+import type { ReadPathSet } from "./read-path-set.js";
 import { type TruncationResult } from "./truncate.js";
 /** Detect a supported image MIME type from a buffer's leading bytes. Returns null for non-images. */
 export declare function detectSupportedImageMimeType(buffer: Buffer): string | null;
@@ -100,6 +101,8 @@ export interface ReadToolOptions {
     maxLines?: number;
     /** Max bytes kept from the head (default 50KB). */
     maxBytes?: number;
+    /** When set, successful reads record the resolved absolute path for read-before-write guards. */
+    readPathSet?: ReadPathSet;
 }
 export declare function createReadTool(cwd: string, options?: ReadToolOptions): ToolDefinition;
 /** Re-exported for hosts building custom read tools or analyzing truncation metadata. */

package/dist/read.js

@@ -21,11 +21,12 @@
  */
 import { Buffer } from "node:buffer";
 import { constants } from "node:fs";
-import { access as fsAccess, open, stat as fsStat } from "node:fs/promises";
+import { access as fsAccess, stat as fsStat, open } from "node:fs/promises";
 import { readFileBounded } from "./bounded-file.js";
+import { CODING_OBSERVATION_EFFECT } from "./effects.js";
 import { enforceExecutionPolicy } from "./execution-policy.js";
-import { resolveReadPathAsync } from "./path-utils.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_IMAGE_BYTES, DEFAULT_MAX_LINES, DEFAULT_MAX_TEXT_SCAN_BYTES, HARD_MAX_BYTES, HARD_MAX_IMAGE_BYTES, HARD_MAX_LINES, HARD_MAX_TEXT_SCAN_BYTES, validateCodingLimit, } from "./limits.js";
+import { resolveReadPathAsync } from "./path-utils.js";
 import { formatSize } from "./truncate.js";
 // --- magic-byte image MIME detection (faithful port of pi utils/mime.js, pure JS, no deps) ---
 const IMAGE_TYPE_SNIFF_BYTES = 4100;
@@ -64,9 +65,7 @@ export async function detectSupportedImageMimeTypeFromFile(filePath) {
 }
 function isPng(buffer) {
     // First chunk after the 8-byte signature must be a 13-byte IHDR.
-    return (buffer.length >= 16 &&
-        readUint32BE(buffer, PNG_SIGNATURE.length) === 13 &&
-        startsWithAscii(buffer, 12, "IHDR"));
+    return buffer.length >= 16 && readUint32BE(buffer, PNG_SIGNATURE.length) === 13 && startsWithAscii(buffer, 12, "IHDR");
 }
 function isAnimatedPng(buffer) {
     // Walk PNG chunks; an acTL chunk before the first IDAT marks an animated (APNG) image.
@@ -118,16 +117,10 @@ function readUint16LE(buffer, offset) {
     return (buffer[offset] ?? 0) + ((buffer[offset + 1] ?? 0) << 8);
 }
 function readUint32BE(buffer, offset) {
-    return ((buffer[offset] ?? 0) * 0x1000000 +
-        ((buffer[offset + 1] ?? 0) << 16) +
-        ((buffer[offset + 2] ?? 0) << 8) +
-        (buffer[offset + 3] ?? 0));
+    return ((buffer[offset] ?? 0) * 0x1000000 + ((buffer[offset + 1] ?? 0) << 16) + ((buffer[offset + 2] ?? 0) << 8) + (buffer[offset + 3] ?? 0));
 }
 function readUint32LE(buffer, offset) {
-    return ((buffer[offset] ?? 0) +
-        ((buffer[offset + 1] ?? 0) << 8) +
-        ((buffer[offset + 2] ?? 0) << 16) +
-        (buffer[offset + 3] ?? 0) * 0x1000000);
+    return ((buffer[offset] ?? 0) + ((buffer[offset + 1] ?? 0) << 8) + ((buffer[offset + 2] ?? 0) << 16) + (buffer[offset + 3] ?? 0) * 0x1000000);
 }
 function startsWith(buffer, bytes) {
     if (buffer.length < bytes.length)
@@ -315,7 +308,8 @@ export function createReadTool(cwd, options) {
     const maxScanBytes = validateCodingLimit("maxScanBytes", options?.maxScanBytes ?? DEFAULT_MAX_TEXT_SCAN_BYTES, HARD_MAX_TEXT_SCAN_BYTES);
     return {
         name: "read",
-        description: `Read the contents of a file. Supports text files and images (jpg, png, gif, webp, bmp); images are returned as image content. For text files, output is truncated to ${maxLines} lines or ${maxBytes / 1024}KB (whichever is hit first). Use offset/limit for large files. When you need the full file, continue with offset until complete.`,
+        effect: CODING_OBSERVATION_EFFECT,
+        description: `Read the contents of a file. Supports text files and images (jpg, png, gif, webp, bmp); images are returned as image content. For text files, output is truncated to ${maxLines} lines or ${maxBytes / 1024}KB (whichever is hit first). When truncated, continue with the suggested offset until complete. Prefer repo_search to find text across many files.`,
         parameters: {
             type: "object",
             properties: {
@@ -339,9 +333,7 @@ export function createReadTool(cwd, options) {
             }
             try {
                 const startLine = validateCodingLimit("offset", offset ?? 1, Number.MAX_SAFE_INTEGER);
-                const requestedLines = limit === undefined
-                    ? undefined
-                    : validateCodingLimit("limit", limit, HARD_MAX_LINES);
+                const requestedLines = limit === undefined ? undefined : validateCodingLimit("limit", limit, HARD_MAX_LINES);
                 const absolutePath = await resolveReadPathAsync(path, cwd);
                 const policyCheck = await enforceExecutionPolicy(options?.executionPolicy, {
                     kind: "read",
@@ -362,6 +354,7 @@ export function createReadTool(cwd, options) {
                         autoResizeImages: options?.autoResizeImages,
                         signal: context.signal,
                     });
+                    options?.readPathSet?.add(allowedPath);
                     return {
                         toolCallId,
                         name: "read",
@@ -416,6 +409,7 @@ export function createReadTool(cwd, options) {
                         outputText += `\n\n[Showing lines ${page.startLine}-${endLine}${page.truncatedBy === "bytes" ? ` (${formatSize(maxBytes)} limit)` : ""}. Use offset=${page.nextOffset} to continue.]`;
                     }
                 }
+                options?.readPathSet?.add(allowedPath);
                 return {
                     toolCallId,
                     name: "read",

package/dist/repository.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Bounded repository walk primitives for list/search tools.
+ *
+ * Streams the tree with Node `opendir` / `lstat`; never follows symlink escapes,
+ * rejects devices/FIFOs/sockets for descent, and charges finite depth/entry/file
+ * limits before retaining the next result. No glob/index/watcher dependency.
+ */
 export type RepoEntryKind = "file" | "directory" | "symlink" | "other";
 export interface RepoListEntry {
     readonly path: string;
@@ -13,6 +20,16 @@ export interface RepositoryListResult {
     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;
@@ -78,7 +95,8 @@ export interface RepositorySearchRequest {
     readonly root: string;
     readonly query: string;
     readonly path?: string;
-    readonly mode?: "literal" | "regex";
+    readonly mode?: "literal";
+    readonly outputMode?: RepoSearchOutputMode;
     readonly caseSensitive?: boolean;
     readonly includeHidden?: boolean;
     readonly exclude?: readonly string[];
@@ -87,9 +105,22 @@ export interface RepositorySearchRequest {
     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;
+    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 {
@@ -109,11 +140,31 @@ export declare function resolveRepoPath(root: string, inputPath: string | undefi
     rootReal: string;
 }>;
 export declare function isBinaryBuffer(buffer: Buffer): boolean;
-export declare function compileSearchPattern(query: string, mode: "literal" | "regex", caseSensitive: boolean, maxPatternBytes: number): {
+export declare function compileSearchPattern(query: string, caseSensitive: boolean, maxPatternBytes: number): {
     testLine: (line: string) => {
         column: number;
     } | null;
     patternBytes: number;
 };
+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>;
 /** Local filesystem repository operations (default backend). */
-export declare function createLocalRepositoryOperations(limits?: RepositoryLimitOptions): RepositoryOperations;
+export declare function createLocalRepositoryOperations(limits?: RepositoryLimitOptions, walk?: RepositoryWalk): RepositoryOperations;

package/dist/repository.js

@@ -5,9 +5,10 @@
  * rejects devices/FIFOs/sockets for descent, and charges finite depth/entry/file
  * limits before retaining the next result. No glob/index/watcher dependency.
  */
-import { open, opendir, lstat, realpath } from "node:fs/promises";
+import { lstat, open, opendir, realpath } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 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";
+import { matchGlobPattern, validateGlobPattern } from "./glob-match.js";
 import { resolveToCwd } from "./path-utils.js";
 export const DEFAULT_REPO_EXCLUDE = Object.freeze([".git", "node_modules", "dist"]);
 export class RepositoryError extends Error {
@@ -119,46 +120,28 @@ export function isBinaryBuffer(buffer) {
     }
     return false;
 }
-export function compileSearchPattern(query, mode, caseSensitive, maxPatternBytes) {
+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 (mode === "literal") {
-        if (caseSensitive) {
-            return {
-                patternBytes,
-                testLine: (line) => {
-                    const column = line.indexOf(query);
-                    return column >= 0 ? { column: column + 1 } : null;
-                },
-            };
-        }
-        const needle = query.toLowerCase();
+    if (caseSensitive) {
         return {
             patternBytes,
             testLine: (line) => {
-                const column = line.toLowerCase().indexOf(needle);
+                const column = line.indexOf(query);
                 return column >= 0 ? { column: column + 1 } : null;
             },
         };
     }
-    let regex;
-    try {
-        regex = new RegExp(query, caseSensitive ? "u" : "iu");
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new RepositoryError(`invalid regular expression: ${message}`);
-    }
+    const needle = query.toLowerCase();
     return {
         patternBytes,
         testLine: (line) => {
-            regex.lastIndex = 0;
-            const match = regex.exec(line);
-            return match && match.index !== undefined ? { column: match.index + 1 } : null;
+            const column = line.toLowerCase().indexOf(needle);
+            return column >= 0 ? { column: column + 1 } : null;
         },
     };
 }
@@ -256,7 +239,7 @@ async function* walkRepository(rootReal, startAbsolute, limits) {
         }
     }
 }
-async function listLocal(request, defaults) {
+async function listLocal(request, defaults, walk) {
     const resolved = await resolveRepoPath(request.root, request.path);
     const maxResults = validateCodingLimit("maxResults", request.maxResults ?? defaults.maxResults, HARD_MAX_REPO_RESULTS);
     const offset = validateCodingLimitAllowZero("offset", request.offset ?? 0, HARD_MAX_REPO_ENTRIES);
@@ -278,9 +261,7 @@ async function listLocal(request, defaults) {
                 kind = "symlink";
             else if (startStat.isFile())
                 kind = "file";
-            const entry = kind === "file"
-                ? { path: resolved.relative, kind, size: startStat.size }
-                : { path: resolved.relative, kind };
+            const entry = kind === "file" ? { path: resolved.relative, kind, size: startStat.size } : { path: resolved.relative, kind };
             scannedEntries = 1;
             scannedFiles = kind === "file" ? 1 : 0;
             if (offset === 0 && maxResults > 0)
@@ -305,7 +286,7 @@ async function listLocal(request, defaults) {
         throw new RepositoryError(`cannot open path: ${message}`);
     }
     try {
-        for await (const event of walkRepository(resolved.rootReal, resolved.absolute, {
+        for await (const event of walk(resolved.rootReal, resolved.absolute, {
             maxDepth,
             maxEntries: defaults.maxEntries,
             maxFiles: defaults.maxFiles,
@@ -477,13 +458,13 @@ async function searchFileLines(absolutePath, relativePath, testLine, options) {
         await handle.close();
     }
 }
-async function searchLocal(request, defaults) {
+async function searchLocal(request, defaults, walk) {
     const mode = request.mode ?? "literal";
-    if (mode !== "literal" && mode !== "regex") {
-        throw new RepositoryError(`unsupported search mode: ${String(mode)}`);
+    if (mode !== "literal") {
+        throw new RepositoryError(`unsupported search mode: ${String(mode)} (literal only)`);
     }
     const caseSensitive = request.caseSensitive === true;
-    const { testLine } = compileSearchPattern(request.query, mode, caseSensitive, defaults.maxPatternBytes);
+    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);
@@ -538,7 +519,7 @@ async function searchLocal(request, defaults) {
             await runFile(resolved.absolute, resolved.relative);
         }
         else if (startStat.isDirectory()) {
-            for await (const event of walkRepository(resolved.rootReal, resolved.absolute, {
+            for await (const event of walk(resolved.rootReal, resolved.absolute, {
                 maxDepth: defaults.maxDepth,
                 maxEntries: defaults.maxEntries,
                 maxFiles: defaults.maxFiles,
@@ -622,12 +603,137 @@ async function searchLocal(request, defaults) {
         filesSkippedOversize,
     };
 }
+async function globLocal(request, defaults, walk) {
+    try {
+        validateGlobPattern(request.pattern, defaults.maxPatternBytes);
+    }
+    catch (error) {
+        throw new RepositoryError(error instanceof Error ? error.message : String(error));
+    }
+    const resolved = await resolveRepoPath(request.root, request.path);
+    const maxResults = validateCodingLimit("maxResults", request.maxResults ?? defaults.maxResults, HARD_MAX_REPO_RESULTS);
+    const offset = validateCodingLimitAllowZero("offset", request.offset ?? 0, HARD_MAX_REPO_ENTRIES);
+    const maxDepth = validateCodingLimit("maxDepth", request.maxDepth ?? defaults.maxDepth, HARD_MAX_REPO_DEPTH);
+    const exclude = new Set(request.exclude ?? defaults.exclude);
+    const deadlineAt = request.deadlineMs !== undefined ? Date.now() + request.deadlineMs : Date.now() + defaults.maxTimeMs;
+    const collected = [];
+    let scannedEntries = 0;
+    let scannedFiles = 0;
+    let seen = 0;
+    let truncated = false;
+    let truncatedBy = null;
+    const maybeCollect = (relativePath) => {
+        if (!matchGlobPattern(request.pattern, relativePath))
+            return false;
+        if (seen < offset) {
+            seen++;
+            return false;
+        }
+        if (collected.length >= maxResults) {
+            truncated = true;
+            truncatedBy = "results";
+            return true;
+        }
+        collected.push(relativePath);
+        seen++;
+        return truncated;
+    };
+    try {
+        const startStat = await lstat(resolved.absolute);
+        if (!startStat.isDirectory()) {
+            scannedEntries = 1;
+            if (startStat.isFile()) {
+                scannedFiles = 1;
+                if (matchGlobPattern(request.pattern, resolved.relative)) {
+                    if (offset === 0 && maxResults > 0)
+                        collected.push(resolved.relative);
+                    else if (offset === 0 && maxResults === 0) {
+                        truncated = true;
+                        truncatedBy = "results";
+                    }
+                }
+            }
+            return {
+                paths: collected,
+                truncated,
+                truncatedBy,
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: undefined,
+            };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new RepositoryError(`cannot open path: ${message}`);
+    }
+    try {
+        for await (const event of walk(resolved.rootReal, resolved.absolute, {
+            maxDepth,
+            maxEntries: defaults.maxEntries,
+            maxFiles: defaults.maxFiles,
+            exclude,
+            includeHidden: request.includeHidden === true,
+            signal: request.signal,
+            deadlineAt,
+        })) {
+            if (event.type === "limit") {
+                truncated = true;
+                truncatedBy = event.truncatedBy;
+                break;
+            }
+            scannedEntries++;
+            if (event.entry.kind === "file")
+                scannedFiles++;
+            if (event.entry.kind !== "file")
+                continue;
+            if (maybeCollect(event.entry.path))
+                break;
+        }
+    }
+    catch (error) {
+        if (error instanceof RepositoryError && error.message === "Operation aborted") {
+            return {
+                paths: collected,
+                truncated: true,
+                truncatedBy: "abort",
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: collected.length > 0 || offset > 0 ? offset + collected.length : undefined,
+            };
+        }
+        if (error instanceof RepositoryError && error.message === "Repository operation exceeded time limit") {
+            return {
+                paths: collected,
+                truncated: true,
+                truncatedBy: "time",
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: offset + collected.length,
+            };
+        }
+        throw error;
+    }
+    return {
+        paths: collected,
+        truncated,
+        truncatedBy,
+        scannedEntries,
+        scannedFiles,
+        offset,
+        nextOffset: truncated ? offset + collected.length : undefined,
+    };
+}
 /** Local filesystem repository operations (default backend). */
-export function createLocalRepositoryOperations(limits) {
+export function createLocalRepositoryOperations(limits, walk = walkRepository) {
     const resolved = resolveRepositoryLimits(limits);
     return {
-        list: (request) => listLocal(request, resolved),
-        search: (request) => searchLocal(request, resolved),
+        list: (request) => listLocal(request, resolved, walk),
+        search: (request) => searchLocal(request, resolved, walk),
+        glob: (request) => globLocal(request, resolved, walk),
     };
 }
 //# sourceMappingURL=repository.js.map

package/dist/search.d.ts

@@ -1,5 +1,5 @@
 /**
- * `repo_search` tool: bounded native literal/regex repository text search.
+ * `repo_search` tool: bounded native literal repository text search.
  */
 import type { ExecutionPolicy, ToolDefinition } from "@arnilo/prism";
 import { type RepositoryLimitOptions, type RepositoryOperations } from "./repository.js";