praxis-agent 0.57.0 → 0.58.0

package/README.md

@@ -27,7 +27,7 @@ sessions, configuration, or compatibility directories.
 
 - macOS or Linux
 - Node.js 24 or newer
-- [`ripgrep`](https://github.com/BurntSushi/ripgrep) (`rg`) for the Grep tool
+- [`ripgrep`](https://github.com/BurntSushi/ripgrep) (`rg`) for the Grep and Glob tools
 - an API key and model ID for an Anthropic, OpenAI-compatible, or OpenAI
   Responses provider (the stable setup), or the explicitly enabled experimental
   ChatGPT-backed Codex subscription integration

package/dist/tools/glob.d.ts

@@ -1,9 +1,37 @@
-export interface GlobFilesOptions {
+import { type ProcessResult } from '../platform/bounded-process-runner.js';
+export interface GlobSearchRequest {
     root: string;
     displayRoot: string;
     absoluteRoot: string;
     pattern: string;
     signal?: AbortSignal;
 }
-export declare function globFiles(options: GlobFilesOptions): Promise<string>;
+export interface GlobSearchResult {
+    content: string;
+    isError: boolean;
+}
+export interface GlobSearch {
+    search(request: GlobSearchRequest): Promise<GlobSearchResult>;
+}
+export interface RipgrepGlobSearchOptions {
+    cwd: string;
+    timeoutMs: number;
+    environment?: Readonly<Record<string, string>>;
+    runner?: {
+        run(options: {
+            command: string;
+            args: readonly string[];
+            cwd?: string;
+            timeoutMs: number;
+            signal?: AbortSignal;
+            env?: Readonly<Record<string, string>>;
+        }): Promise<ProcessResult>;
+    };
+}
+export declare class RipgrepGlobSearch implements GlobSearch {
+    private readonly options;
+    private readonly runner;
+    constructor(options: RipgrepGlobSearchOptions);
+    search(request: GlobSearchRequest): Promise<GlobSearchResult>;
+}
 //# sourceMappingURL=glob.d.ts.map

package/dist/tools/glob.js

@@ -1,88 +1,97 @@
-import { lstat, opendir } from 'node:fs/promises';
 import { isAbsolute, join, resolve, sep } from 'node:path';
 import { minimatch } from 'minimatch';
+import { BoundedProcessRunner, joinedProcessOutput, } from '../platform/bounded-process-runner.js';
 const MAX_RESULTS = 100;
+const MAX_ENUMERATION_BYTES = 2 * 1024 * 1024;
+function portable(value) {
+    return sep === '/' ? value : value.split(sep).join('/');
+}
 function abortError() {
     return new DOMException('Tool execution aborted', 'AbortError');
 }
-function portablePath(path) {
-    return sep === '/' ? path : path.split(sep).join('/');
-}
-function compareMatches(left, right) {
-    return left.mtimeMs - right.mtimeMs || left.order - right.order;
-}
-function insertOldest(matches, candidate) {
-    let low = 0;
-    let high = matches.length;
-    while (low < high) {
-        const middle = Math.floor((low + high) / 2);
-        const current = matches[middle];
-        if (current && compareMatches(current, candidate) <= 0)
-            low = middle + 1;
-        else
-            high = middle;
+export class RipgrepGlobSearch {
+    options;
+    runner;
+    constructor(options) {
+        this.options = options;
+        this.runner =
+            options.runner ??
+                new BoundedProcessRunner({
+                    cwd: options.cwd,
+                    maxOutputBytes: MAX_ENUMERATION_BYTES,
+                });
     }
-    matches.splice(low, 0, candidate);
-    if (matches.length > MAX_RESULTS)
-        matches.pop();
-}
-export async function globFiles(options) {
-    const pattern = portablePath(options.pattern);
-    const absolutePattern = isAbsolute(options.pattern);
-    const matchBase = !absolutePattern && !pattern.includes('/');
-    const matches = [];
-    const directories = [''];
-    let matchCount = 0;
-    let order = 0;
-    while (directories.length > 0) {
-        if (options.signal?.aborted)
+    async search(request) {
+        if (request.signal?.aborted)
             throw abortError();
-        const relativeDirectory = directories.pop() ?? '';
-        const directory = await opendir(join(options.root, relativeDirectory));
-        for await (const entry of directory) {
-            if (options.signal?.aborted)
-                throw abortError();
-            const relativePath = join(relativeDirectory, entry.name);
-            if (entry.isDirectory()) {
-                directories.push(relativePath);
-                continue;
-            }
-            if (!entry.isFile())
-                continue;
-            const portableRelativePath = portablePath(relativePath);
-            const absolutePath = portablePath(resolve(options.absoluteRoot, relativePath));
-            if (pattern !== '' &&
-                !minimatch(absolutePattern ? absolutePath : portableRelativePath, pattern, { dot: true, matchBase, noext: true })) {
-                continue;
-            }
-            let metadata;
-            try {
-                metadata = await lstat(join(options.root, relativePath));
-            }
-            catch (error) {
-                if (error.code === 'ENOENT')
-                    continue;
-                throw error;
-            }
-            if (!metadata.isFile())
-                continue;
-            const displayPath = absolutePattern
-                ? absolutePath
-                : portablePath(join(options.displayRoot, relativePath));
-            insertOldest(matches, {
-                path: displayPath,
-                mtimeMs: metadata.mtimeMs,
-                order,
+        const hidden = this.options.environment?.CLAUDE_CODE_GLOB_HIDDEN !== 'false';
+        const noIgnore = this.options.environment?.CLAUDE_CODE_GLOB_NO_IGNORE !== 'false';
+        let result;
+        try {
+            result = await this.runner.run({
+                command: 'rg',
+                args: [
+                    '--files',
+                    '--null',
+                    '--sort',
+                    'modified',
+                    ...(hidden ? ['--hidden'] : []),
+                    ...(noIgnore ? ['--no-ignore'] : []),
+                ],
+                cwd: request.root,
+                timeoutMs: this.options.timeoutMs,
+                ...(request.signal ? { signal: request.signal } : {}),
+                ...(this.options.environment ? { env: this.options.environment } : {}),
             });
-            matchCount += 1;
-            order += 1;
         }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError')
+                throw error;
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Glob enumeration failed: ${message}`);
+        }
+        if (result.timedOut)
+            return {
+                content: `Search timed out after ${this.options.timeoutMs}ms`,
+                isError: true,
+            };
+        if (result.truncated)
+            throw new Error('Glob enumeration failed: output truncated');
+        if (result.code !== 0) {
+            if (result.code === 1 && !result.stdout && !result.stderr)
+                return { content: 'No files found', isError: false };
+            const output = joinedProcessOutput(result);
+            throw new Error(`Glob enumeration failed with exit code ${result.code}${output ? `: ${output}` : ''}`);
+        }
+        const pattern = portable(request.pattern);
+        const absolutePattern = isAbsolute(request.pattern);
+        const matchBase = !absolutePattern && !pattern.includes('/');
+        const paths = result.stdout.split('\0').filter(Boolean);
+        const matched = paths.filter((path) => {
+            const relativePath = portable(path);
+            const absolutePath = portable(resolve(request.absoluteRoot, relativePath));
+            return (pattern === '' ||
+                minimatch(absolutePattern ? absolutePath : relativePath, pattern, {
+                    dot: true,
+                    matchBase,
+                    noext: true,
+                }));
+        });
+        if (matched.length === 0)
+            return { content: 'No files found', isError: false };
+        const display = matched.slice(0, MAX_RESULTS).map((path) => {
+            const relativePath = portable(path);
+            if (absolutePattern)
+                return portable(resolve(request.absoluteRoot, relativePath));
+            return portable(join(request.displayRoot, relativePath));
+        });
+        const content = display.join('\n');
+        return {
+            content: matched.length > MAX_RESULTS
+                ? `${content}\n(Showing 100 of ${matched.length} matching files; ${matched.length - 100} more are not listed. Narrow the pattern or path to see the rest.)`
+                : content,
+            isError: false,
+        };
     }
-    if (matchCount === 0)
-        return 'No files found';
-    const content = matches.map((match) => match.path).join('\n');
-    return matchCount > MAX_RESULTS
-        ? `${content}\n(Showing ${MAX_RESULTS} of ${matchCount} matching files; ${matchCount - MAX_RESULTS} more are not listed. Narrow the pattern or path to see the rest.)`
-        : content;
 }
 //# sourceMappingURL=glob.js.map

package/dist/tools/local-tools.d.ts

@@ -1,4 +1,5 @@
 import type { ModelToolCall, ModelToolDefinition, ToolExecutionContext, ToolExecutionResult, ToolRegistry } from '../core/runtime.js';
+import { type GlobSearch } from './glob.js';
 import type { DataPlane } from '../persistence/data-plane.js';
 export interface LocalToolRegistryOptions {
     cwd: string;
@@ -17,6 +18,7 @@ export interface LocalToolRegistryOptions {
     sandbox?: BashSandboxRuntime;
     homeDirectory?: string;
     configRoot?: string;
+    globSearch?: GlobSearch;
 }
 export interface BashSandboxRuntime {
     shouldUseSandbox(input: {
@@ -46,6 +48,7 @@ export declare class LocalToolRegistry implements ToolRegistry {
     private readonly maxShellTimeoutMs;
     private readonly maxSearchTimeoutMs;
     private readonly processRunner;
+    private readonly globSearch;
     private readonly enableReportFindings;
     private readonly environment;
     private readonly sessionEnvironment;
@@ -55,6 +58,7 @@ export declare class LocalToolRegistry implements ToolRegistry {
     private readonly sessionCwds;
     private readonly protectedWriteReason;
     private readonly mutationTargetExisted;
+    private readonly preparedGlobRoots;
     constructor(options: LocalToolRegistryOptions);
     private assertProtectedWritePath;
     private assertProtectedBashCommand;

package/dist/tools/local-tools.js

@@ -7,7 +7,7 @@ import sharp from 'sharp';
 import { countTokens } from '@anthropic-ai/tokenizer';
 import { commandShell, commandShellArguments, } from '../platform/command-shell.js';
 import { BoundedProcessRunner, joinedProcessOutput, } from '../platform/bounded-process-runner.js';
-import { globFiles } from './glob.js';
+import { RipgrepGlobSearch } from './glob.js';
 import { countLineChanges } from './line-changes.js';
 import { editNotebook, formatNotebookForRead } from './notebook.js';
 import { openPdf } from './pdf.js';
@@ -537,6 +537,7 @@ export class LocalToolRegistry {
     maxShellTimeoutMs;
     maxSearchTimeoutMs;
     processRunner;
+    globSearch;
     enableReportFindings;
     environment;
     sessionEnvironment;
@@ -546,6 +547,7 @@ export class LocalToolRegistry {
     sessionCwds = new Map();
     protectedWriteReason;
     mutationTargetExisted = new WeakMap();
+    preparedGlobRoots = new WeakMap();
     constructor(options) {
         this.cwd = resolve(options.cwd);
         this.cwdProvider = options.cwdProvider;
@@ -576,6 +578,13 @@ export class LocalToolRegistry {
             cwd: this.cwd,
             maxOutputBytes: this.maxOutputBytes,
         });
+        this.globSearch =
+            options.globSearch ??
+                new RipgrepGlobSearch({
+                    cwd: this.cwd,
+                    timeoutMs: this.maxSearchTimeoutMs,
+                    ...(this.environment ? { environment: this.environment } : {}),
+                });
     }
     assertProtectedWritePath(filePath) {
         const reason = this.protectedWriteReason(filePath);
@@ -805,14 +814,16 @@ export class LocalToolRegistry {
             case 'Glob': {
                 const pathInput = call.input.path;
                 const requestedPath = pathInput === undefined ? '.' : stringInput(call.input, 'path');
-                await this.globRoot(requestedPath, context);
-                return {
+                const root = await this.globRoot(requestedPath, context);
+                const prepared = {
                     ...call,
                     input: {
                         pattern: stringInput(call.input, 'pattern', true),
                         ...(pathInput === undefined ? {} : { path: requestedPath }),
                     },
                 };
+                this.preparedGlobRoots.set(prepared, root);
+                return prepared;
             }
             case 'Grep': {
                 const glob = optionalString(call.input, 'glob');
@@ -857,6 +868,11 @@ export class LocalToolRegistry {
         if (JSON.stringify(prepared.input) !== JSON.stringify(call.input)) {
             throw new Error('Tool input changed after permission approval');
         }
+        const approvedGlobRoot = this.preparedGlobRoots.get(call);
+        if (approvedGlobRoot !== undefined &&
+            this.preparedGlobRoots.get(prepared) !== approvedGlobRoot) {
+            throw new Error('Tool input changed after permission approval');
+        }
         const executionTargetExisted = this.mutationTargetExisted.get(prepared);
         if (approvedTargetExisted !== undefined &&
             executionTargetExisted !== approvedTargetExisted) {
@@ -1466,37 +1482,21 @@ export class LocalToolRegistry {
     }
     async glob(call, context) {
         const requestedPath = call.input.path === undefined ? '.' : stringInput(call.input, 'path');
-        const root = await this.globRoot(requestedPath, context);
-        const timeoutSignal = AbortSignal.timeout(this.maxSearchTimeoutMs);
-        const searchSignal = context.signal
-            ? AbortSignal.any([context.signal, timeoutSignal])
-            : timeoutSignal;
-        try {
-            const content = await globFiles({
-                root,
-                displayRoot: call.input.path === undefined ? '.' : requestedPath,
-                absoluteRoot: isAbsolute(requestedPath)
-                    ? resolve(requestedPath)
-                    : resolve(this.currentCwd(context), requestedPath),
-                pattern: stringInput(call.input, 'pattern', true),
-                signal: searchSignal,
-            });
-            return {
-                content: truncateOutput(content, this.maxOutputBytes),
-                isError: false,
-            };
-        }
-        catch (error) {
-            if (context.signal?.aborted)
-                throw abortError();
-            if (timeoutSignal.aborted) {
-                return {
-                    content: `Search timed out after ${this.maxSearchTimeoutMs}ms`,
-                    isError: true,
-                };
-            }
-            throw error;
-        }
+        const root = this.preparedGlobRoots.get(call) ??
+            (await this.globRoot(requestedPath, context));
+        const result = await this.globSearch.search({
+            root,
+            displayRoot: call.input.path === undefined ? '.' : requestedPath,
+            absoluteRoot: isAbsolute(requestedPath)
+                ? resolve(requestedPath)
+                : resolve(this.currentCwd(context), requestedPath),
+            pattern: stringInput(call.input, 'pattern', true),
+            ...(context.signal ? { signal: context.signal } : {}),
+        });
+        return {
+            content: truncateOutput(result.content, this.maxOutputBytes),
+            isError: result.isError,
+        };
     }
     async grep(call, context) {
         const workspaceRoot = await realpath(this.currentCwd(context));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.57.0",
+  "version": "0.58.0",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",
@@ -62,7 +62,7 @@
     "verify:ci-coverage": "node scripts/verify-ci-coverage.mjs",
     "verify:fixture-contracts": "node scripts/verify-fixture-contracts.mjs",
     "test:fixtures": "node scripts/run-fixture-contracts.mjs",
-    "test:eval:baseline": "vitest run src/evals/coding-baseline.test.ts src/evals/project-eval-comparison.test.ts src/evals/apply-patch-admission.test.ts src/evals/lsp-diagnostics-admission.test.ts"
+    "test:eval:baseline": "vitest run src/evals/coding-baseline.test.ts src/evals/project-eval-comparison.test.ts src/evals/apply-patch-admission.test.ts src/evals/lsp-diagnostics-admission.test.ts src/evals/glob-ripgrep-admission.test.ts"
   },
   "engines": {
     "node": ">=24"