@arnilo/prism-coding-agent 0.0.19 → 0.0.22

package/dist/repository.js

@@ -8,6 +8,7 @@
 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 {
@@ -602,12 +603,137 @@ async function searchLocal(request, defaults) {
         filesSkippedOversize,
     };
 }
+async function globLocal(request, defaults) {
+    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 walkRepository(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) {
     const resolved = resolveRepositoryLimits(limits);
     return {
         list: (request) => listLocal(request, resolved),
         search: (request) => searchLocal(request, resolved),
+        glob: (request) => globLocal(request, resolved),
     };
 }
 //# sourceMappingURL=repository.js.map

package/dist/search.js

@@ -33,6 +33,64 @@ function formatSearchText(result) {
         return body;
     return `${body}\n[truncated by ${result.truncatedBy ?? "limit"}]`;
 }
+function uniqueMatchPaths(matches) {
+    return [...new Set(matches.map((m) => m.path))].sort();
+}
+function formatFilesWithMatches(result) {
+    if (result.matches.length === 0) {
+        return result.truncated ? `[truncated by ${result.truncatedBy ?? "limit"} before any matches]` : "(no matches)";
+    }
+    const body = uniqueMatchPaths(result.matches).join("\n");
+    if (!result.truncated)
+        return body;
+    return `${body}\n[truncated by ${result.truncatedBy ?? "limit"}]`;
+}
+function formatCount(result) {
+    const matchCount = result.matches.length;
+    const fileCount = uniqueMatchPaths(result.matches).length;
+    if (matchCount === 0) {
+        return result.truncated ? `[truncated by ${result.truncatedBy ?? "limit"} before any matches]` : "0 matches in 0 files";
+    }
+    const noun = fileCount === 1 ? "file" : "files";
+    const body = `${matchCount} matches in ${fileCount} ${noun}`;
+    if (!result.truncated)
+        return body;
+    return `${body}\n[truncated by ${result.truncatedBy ?? "limit"}]`;
+}
+function formatSearchResult(result, outputMode) {
+    switch (outputMode) {
+        case "files_with_matches":
+            return formatFilesWithMatches(result);
+        case "count":
+            return formatCount(result);
+        default:
+            return formatSearchText(result);
+    }
+}
+function parseOutputMode(value) {
+    if (value === undefined || value === "content")
+        return "content";
+    if (value === "files_with_matches" || value === "count")
+        return value;
+    throw new Error(`unsupported outputMode: ${String(value)}`);
+}
+function buildSearchMetadata(result, outputMode) {
+    const base = {
+        outputMode,
+        truncated: result.truncated,
+        truncatedBy: result.truncatedBy,
+        matchCount: result.matches.length,
+        scannedBytes: result.scannedBytes,
+        scannedFiles: result.scannedFiles,
+        scannedEntries: result.scannedEntries,
+        filesSkippedBinary: result.filesSkippedBinary,
+        filesSkippedOversize: result.filesSkippedOversize,
+    };
+    if (outputMode === "content") {
+        return { ...base, matches: result.matches };
+    }
+    return { ...base, fileCount: uniqueMatchPaths(result.matches).length };
+}
 export function createRepoSearchTool(cwd, options) {
     const limits = resolveRepositoryLimits({
         ...options?.repository,
@@ -43,7 +101,7 @@ export function createRepoSearchTool(cwd, options) {
     const ops = options?.operations ?? createLocalRepositoryOperations(limits);
     return {
         name: "repo_search",
-        description: `Search text files under the workspace using literal substring match. Skips binary files, excluded basenames (default: ${limits.exclude.join(", ")}), and hidden names unless includeHidden is true. Does not follow symlinks. Caps matches/scanned bytes/time.`,
+        description: `Search text files under the workspace using literal substring match. Use outputMode "files_with_matches" for paths only or "count" for totals without line bodies. Skips binary files, excluded basenames (default: ${limits.exclude.join(", ")}), and hidden names unless includeHidden is true. Does not follow symlinks. Caps matches/scanned bytes/time.`,
         parameters: {
             type: "object",
             properties: {
@@ -73,6 +131,11 @@ export function createRepoSearchTool(cwd, options) {
                     type: "number",
                     description: `Maximum matches to retain (default ${limits.maxMatches}, hard ${HARD_MAX_SEARCH_MATCHES})`,
                 },
+                outputMode: {
+                    type: "string",
+                    description: 'Result shape: "content" (default, line bodies), "files_with_matches" (unique paths), or "count" (match/file totals)',
+                    enum: ["content", "files_with_matches", "count"],
+                },
             },
             required: ["query"],
             additionalProperties: false,
@@ -92,6 +155,13 @@ export function createRepoSearchTool(cwd, options) {
                 return errorResult(toolCallId, `unsupported search mode: ${String(args.mode)}`);
             }
             const mode = "literal";
+            let outputMode;
+            try {
+                outputMode = parseOutputMode(args.outputMode);
+            }
+            catch (error) {
+                return errorResult(toolCallId, error instanceof Error ? error.message : String(error));
+            }
             const caseSensitive = args.caseSensitive === true;
             const includeHidden = args.includeHidden === true;
             let contextLines;
@@ -114,6 +184,7 @@ export function createRepoSearchTool(cwd, options) {
                 risk: "low",
                 metadata: {
                     mode,
+                    outputMode,
                     caseSensitive,
                     includeHidden,
                     context: contextLines,
@@ -131,6 +202,7 @@ export function createRepoSearchTool(cwd, options) {
                     query,
                     path,
                     mode,
+                    outputMode,
                     caseSensitive,
                     includeHidden,
                     exclude: limits.exclude,
@@ -142,18 +214,8 @@ export function createRepoSearchTool(cwd, options) {
                 return {
                     toolCallId,
                     name: "repo_search",
-                    content: [{ type: "text", text: formatSearchText(result) }],
-                    metadata: {
-                        truncated: result.truncated,
-                        truncatedBy: result.truncatedBy,
-                        matchCount: result.matches.length,
-                        scannedBytes: result.scannedBytes,
-                        scannedFiles: result.scannedFiles,
-                        scannedEntries: result.scannedEntries,
-                        filesSkippedBinary: result.filesSkippedBinary,
-                        filesSkippedOversize: result.filesSkippedOversize,
-                        matches: result.matches,
-                    },
+                    content: [{ type: "text", text: formatSearchResult(result, outputMode) }],
+                    metadata: buildSearchMetadata(result, outputMode),
                 };
             }
             catch (error) {

package/dist/shell.js

@@ -265,7 +265,7 @@ export function createShellTool(cwd, options) {
     return {
         name: "shell",
         exclusive: true,
-        description: `Execute a shell command in the current working directory. Returns combined stdout and stderr. Output is truncated to the last ${maxLines} lines or ${maxBytes / 1024}KB and capped at ${formatSize(maxTotalOutputBytes)} total. Truncated successful output is saved to a temp file. Timeout defaults to ${defaultTimeout} seconds.`,
+        description: `Execute a shell command in the current working directory. Returns combined stdout and stderr. Prefer repo_list, repo_search, glob, read, write, edit, delete, or move for those jobs — use shell only when no dedicated tool fits. Output is truncated to the last ${maxLines} lines or ${maxBytes / 1024}KB and capped at ${formatSize(maxTotalOutputBytes)} total. Truncated successful output is saved to a temp file. Timeout defaults to ${defaultTimeout} seconds.`,
         parameters: {
             type: "object",
             properties: {

package/dist/write.d.ts

@@ -1,4 +1,5 @@
 import type { ExecutionPolicy, ToolDefinition } from "@arnilo/prism";
+import { type ReadBeforeWriteOptions } from "./read-path-set.js";
 /**
  * Pluggable operations for the write tool. Override to delegate file writing to remote systems
  * (e.g. SSH) while keeping the tool's directory-creation + per-path serialization behavior.
@@ -14,7 +15,7 @@ export interface WriteOperations {
         signal?: AbortSignal;
     }) => Promise<void>;
 }
-export interface WriteToolOptions {
+export interface WriteToolOptions extends ReadBeforeWriteOptions {
     /** Structured pre-execution policy checked before filesystem writes. */
     executionPolicy?: ExecutionPolicy;
     /** Custom operations backend (default: local filesystem). */

package/dist/write.js

@@ -22,6 +22,7 @@ import { enforceExecutionPolicy } from "./execution-policy.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { DEFAULT_MAX_WRITE_BYTES, HARD_MAX_WRITE_BYTES, validateCodingLimit } from "./limits.js";
 import { resolveToCwd } from "./path-utils.js";
+import { refuseReadBeforeWrite } from "./read-path-set.js";
 const defaultWriteOperations = {
     writeFile: (path, content, options) => atomicWriteUtf8File(path, content, { signal: options?.signal }),
     mkdir: (dir) => fsMkdir(dir, { recursive: true }).then(() => { }),
@@ -44,12 +45,16 @@ export function createWriteTool(cwd, options) {
     const maxInputBytes = validateCodingLimit("maxInputBytes", options?.maxInputBytes ?? DEFAULT_MAX_WRITE_BYTES, HARD_MAX_WRITE_BYTES);
     return {
         name: "write",
-        description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
+        description: "Create or overwrite a file (full replace). Creates parent directories. Prefer edit for targeted changes. When the host enabled requireReadBeforeWrite, read the path first or pass force=true to override.",
         parameters: {
             type: "object",
             properties: {
                 path: { type: "string", description: "Path to the file to write (relative or absolute)" },
                 content: { type: "string", description: "Content to write to the file" },
+                force: {
+                    type: "boolean",
+                    description: "Bypass read-before-write guard when the host enabled requireReadBeforeWrite.",
+                },
             },
             required: ["path", "content"],
             additionalProperties: false,
@@ -58,6 +63,7 @@ export function createWriteTool(cwd, options) {
             const toolCallId = context.toolCallId;
             const path = typeof args.path === "string" ? args.path : "";
             const content = typeof args.content === "string" ? args.content : undefined;
+            const force = args.force === true;
             if (path.length === 0) {
                 return errorResult(toolCallId, "path is required and must be a non-empty string.");
             }
@@ -80,6 +86,9 @@ export function createWriteTool(cwd, options) {
                 if (!policyCheck.allowed)
                     return policyCheck.result;
                 const allowedPath = policyCheck.action.paths?.[0] ?? absolutePath;
+                const rbwRefusal = refuseReadBeforeWrite("write", path, allowedPath, options, force);
+                if (rbwRefusal)
+                    return errorResult(toolCallId, rbwRefusal);
                 const dir = dirname(allowedPath);
                 return await withFileMutationQueue(allowedPath, async () => {
                     // Check abort before each fs op — do not start a new operation once aborted. We intentionally

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arnilo/prism-coding-agent",
-  "version": "0.0.19",
-  "description": "Optional coding-agent tools (shell, read, write, edit, repo_list, repo_search, opt-in Git/check/ask-user-decision, and durable plan/checkpoint helpers) package for Prism.",
+  "version": "0.0.22",
+  "description": "Optional coding-agent tools (shell, read, write, edit, repo_list, repo_search, glob, delete, move, opt-in Git/check/ask-user-decision, and durable plan/checkpoint helpers) package for Prism.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -28,8 +28,8 @@
     "diff": "^9.0.0"
   },
   "peerDependencies": {
-    "@arnilo/prism": "0.0.19",
-    "@arnilo/prism-workflows": "0.0.19"
+    "@arnilo/prism": "0.0.22",
+    "@arnilo/prism-workflows": "0.0.22"
   },
   "devDependencies": {
     "@arnilo/prism": "file:../..",