@stagewise/agent-runtime-node 0.2.0

package/dist/__tests__/fixtures/sample-project/src/components/Input.d.ts

@@ -0,0 +1,9 @@
+interface InputProps {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    type?: 'text' | 'email' | 'password';
+}
+export declare const Input: ({ value, onChange, placeholder, type, }: InputProps) => any;
+export {};
+//# sourceMappingURL=Input.d.ts.map

package/dist/__tests__/fixtures/sample-project/src/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Main entry point
+ */
+export declare function main(): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/__tests__/fixtures/sample-project/src/lib/helpers.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Capitalizes the first letter of a string
+ */
+export declare function capitalize(str: string): string;
+/**
+ * Truncates a string to a specified length
+ */
+export declare function truncate(str: string, maxLength: number): string;
+/**
+ * Formats a date to a readable string
+ */
+export declare function formatDate(date: Date): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/__tests__/fixtures/sample-project/src/lib/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Validates an email address
+ */
+export declare function isValidEmail(email: string): boolean;
+/**
+ * Validates a URL
+ */
+export declare function isValidURL(url: string): boolean;
+/**
+ * Error handling utility
+ */
+export declare function handleError(error: unknown): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/__tests__/fixtures/sample-project/src/types.d.ts

@@ -0,0 +1,20 @@
+export interface User {
+    id: number;
+    name: string;
+    email: string;
+    createdAt: Date;
+}
+export interface Post {
+    id: number;
+    title: string;
+    content: string;
+    authorId: number;
+}
+export type UserRole = 'admin' | 'user' | 'guest';
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}
+export declare class NotFoundError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/__tests__/fixtures/sample-project/tests/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/__tests__/glob-node-fallback.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=glob-node-fallback.test.d.ts.map

package/dist/__tests__/glob-ripgrep.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=glob-ripgrep.test.d.ts.map

package/dist/__tests__/glob-searchreplace.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=glob-searchreplace.test.d.ts.map

package/dist/__tests__/grep-fallback.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=grep-fallback.test.d.ts.map

package/dist/__tests__/grep-node-fallback.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=grep-node-fallback.test.d.ts.map

package/dist/__tests__/grep-ripgrep.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=grep-ripgrep.test.d.ts.map

package/dist/__tests__/grep.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=grep.test.d.ts.map

package/dist/__tests__/search-replace.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=search-replace.test.d.ts.map

package/dist/__tests__/shared/glob-test-suite.d.ts

@@ -0,0 +1,10 @@
+import type { NodeFileSystemProvider } from '../../index.js';
+/**
+ * Shared glob test suite that can be run with different file system providers.
+ * This allows testing both ripgrep and Node.js fallback implementations with the same test cases.
+ *
+ * @param getFileSystem - Function that returns a configured NodeFileSystemProvider instance
+ * @param getTestDir - Function that returns the current test directory
+ */
+export declare function runGlobTestSuite(getFileSystem: () => NodeFileSystemProvider, getTestDir: () => string): void;
+//# sourceMappingURL=glob-test-suite.d.ts.map

package/dist/__tests__/shared/grep-test-suite.d.ts

@@ -0,0 +1,10 @@
+import type { NodeFileSystemProvider } from '../../index.js';
+/**
+ * Shared grep test suite that can be run with different file system providers.
+ * This allows testing both ripgrep and Node.js fallback implementations with the same test cases.
+ *
+ * @param getFileSystem - Function that returns a configured NodeFileSystemProvider instance
+ * @param getTestDir - Function that returns the current test directory
+ */
+export declare function runGrepTestSuite(getFileSystem: () => NodeFileSystemProvider, getTestDir: () => string): void;
+//# sourceMappingURL=grep-test-suite.d.ts.map

package/dist/__tests__/utils/assertions.d.ts

@@ -0,0 +1,50 @@
+import type { GrepMatch, GrepResult } from '../../types.js';
+/**
+ * Asserts that a grep result is successful
+ */
+export declare function expectGrepSuccess(result: GrepResult): asserts result is GrepResult & {
+    success: true;
+};
+/**
+ * Asserts that a grep result has failed
+ */
+export declare function expectGrepFailure(result: GrepResult): void;
+/**
+ * Asserts that a grep result contains a specific number of matches
+ */
+export declare function expectGrepMatchCount(result: GrepResult, count: number): void;
+/**
+ * Asserts that a grep match has the expected properties
+ */
+export declare function expectGrepMatch(match: GrepMatch, expected: {
+    relativePath?: string;
+    line?: number;
+    column?: number;
+    match?: string;
+    preview?: string | RegExp;
+}): void;
+/**
+ * Asserts that a grep result contains a match in a specific file
+ */
+export declare function expectGrepMatchInFile(result: GrepResult, relativePath: string): void;
+/**
+ * Asserts that a grep result does NOT contain a match in a specific file
+ */
+export declare function expectNoGrepMatchInFile(result: GrepResult, relativePath: string): void;
+/**
+ * Asserts that all grep matches are in the allowed files
+ */
+export declare function expectOnlyMatchesInFiles(result: GrepResult, allowedFiles: string[]): void;
+/**
+ * Asserts that file content matches the expected content
+ */
+export declare function expectFileContent(actualContent: string, expectedContent: string): void;
+/**
+ * Asserts that file content contains the expected substring
+ */
+export declare function expectFileContains(actualContent: string, expectedSubstring: string): void;
+/**
+ * Asserts that file content matches a regex
+ */
+export declare function expectFileMatches(actualContent: string, pattern: RegExp): void;
+//# sourceMappingURL=assertions.d.ts.map

package/dist/__tests__/utils/cleanup.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Cleans up a test directory and all its contents
+ */
+export declare function cleanupTestDir(dir: string): void;
+/**
+ * Creates a cleanup handler that can be registered with afterEach
+ */
+export declare function createCleanupHandler(): {
+    register: (dir: string) => void;
+    cleanup: () => void;
+};
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/__tests__/utils/test-fixtures.d.ts

@@ -0,0 +1,47 @@
+import * as fs from 'node:fs';
+/**
+ * Creates a temporary test directory with a unique name
+ */
+export declare function createTempDir(prefix?: string): string;
+/**
+ * Creates a file with the given content
+ */
+export declare function createFile(basePath: string, relativePath: string, content: string): string;
+/**
+ * Creates a directory structure from a nested object
+ * Example: { 'src': { 'index.ts': 'content', 'lib': { 'utils.ts': 'content' } } }
+ */
+export declare function createFileTree(basePath: string, structure: Record<string, string | Record<string, unknown>>): void;
+/**
+ * Creates a binary file (with NUL bytes)
+ */
+export declare function createBinaryFile(basePath: string, relativePath: string, sizeInBytes?: number): string;
+/**
+ * Creates a large file with the specified number of lines
+ */
+export declare function createLargeFile(basePath: string, relativePath: string, numLines: number, lineTemplate?: string): string;
+/**
+ * Creates a .gitignore file with the given patterns
+ */
+export declare function createGitignore(basePath: string, patterns: string[]): string;
+/**
+ * Creates a realistic project structure with common patterns
+ */
+export declare function createRealisticProject(basePath: string): void;
+/**
+ * Removes a directory and all its contents recursively
+ */
+export declare function removeDir(dir: string): void;
+/**
+ * Reads the contents of a file
+ */
+export declare function readFile(filePath: string): string;
+/**
+ * Checks if a file exists
+ */
+export declare function fileExists(filePath: string): boolean;
+/**
+ * Gets the file stats
+ */
+export declare function getFileStats(filePath: string): fs.Stats | null;
+//# sourceMappingURL=test-fixtures.d.ts.map

package/dist/glob/glob-node-fallback.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystemOperations, GlobOptions, GlobResult } from '../types.js';
+export declare function globNodeFallback(pattern: string, fileSystem: FileSystemOperations, options?: GlobOptions): Promise<GlobResult>;
+//# sourceMappingURL=glob-node-fallback.d.ts.map

package/dist/glob/glob-ripgrep.d.ts

@@ -0,0 +1,17 @@
+import type { FileSystemOperations, GlobResult, GlobOptions } from '../types.js';
+/**
+ * Executes glob using ripgrep binary for improved performance.
+ * Follows VS Code's pattern: uses `rg --files` with glob filters.
+ *
+ * This function attempts to use the platform-specific ripgrep binary for
+ * file enumeration. If ripgrep is not available or fails, it returns null to
+ * allow fallback to the Node.js implementation.
+ *
+ * @param fileSystem - File system provider for path resolution
+ * @param pattern - Glob pattern (e.g., "src/*.ts" or recursive patterns)
+ * @param rgBinaryBasePath - Base directory where ripgrep binary is installed
+ * @param options - Glob options
+ * @returns GlobResult if successful, null if ripgrep unavailable/failed
+ */
+export declare function globWithRipgrep(fileSystem: FileSystemOperations, pattern: string, rgBinaryBasePath: string, options?: GlobOptions, onError?: (error: Error) => void): Promise<GlobResult | null>;
+//# sourceMappingURL=glob-ripgrep.d.ts.map

package/dist/glob/index.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystemOperations, GlobResult, GlobOptions } from '../types.js';
+export declare function glob(fileSystem: FileSystemOperations, pattern: string, rgBinaryBasePath: string, options?: GlobOptions): Promise<GlobResult>;
+//# sourceMappingURL=index.d.ts.map

package/dist/glob/utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Normalizes a file path to always use POSIX forward slashes.
+ * On Unix this is a no-op; on Windows it converts backslashes.
+ */
+export declare function toPosixPath(p: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/glob.d.ts

@@ -0,0 +1,26 @@
+import type { BaseFileSystemProvider, GlobResult } from '@stagewise/agent-runtime-interface';
+/**
+ * Options for executing ripgrep glob, matching the glob function's options
+ */
+export interface RipgrepGlobOptions {
+    cwd?: string;
+    absolute?: boolean;
+    includeDirectories?: boolean;
+    excludePatterns?: string[];
+    respectGitignore?: boolean;
+}
+/**
+ * Executes glob using ripgrep binary for improved performance.
+ * Follows VS Code's pattern: uses `rg --files` with glob filters.
+ *
+ * This function attempts to use the platform-specific ripgrep binary for
+ * file enumeration. If ripgrep is not available or fails, it returns null to
+ * allow fallback to the Node.js implementation.
+ *
+ * @param fileSystem - File system provider for path resolution
+ * @param pattern - Glob pattern (e.g., "src/*.ts" or recursive patterns)
+ * @param options - Glob options
+ * @returns GlobResult if successful, null if ripgrep unavailable/failed
+ */
+export declare function globWithRipgrep(fileSystem: BaseFileSystemProvider, pattern: string, options?: RipgrepGlobOptions): Promise<GlobResult | null>;
+//# sourceMappingURL=glob.d.ts.map

package/dist/grep/grep-node-fallback.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystemOperations, GrepResult, GrepOptions } from '../types.js';
+export declare function grepNodeFallback(fileSystem: FileSystemOperations, pattern: string, options?: GrepOptions): Promise<GrepResult>;
+//# sourceMappingURL=grep-node-fallback.d.ts.map

package/dist/grep/grep-ripgrep.d.ts

@@ -0,0 +1,32 @@
+import type { FileSystemOperations, GrepResult, GrepOptions } from '../types.js';
+/**
+ * Options for executing ripgrep, matching the grep function's options
+ */
+export interface RipgrepGrepOptions {
+    recursive?: boolean;
+    maxDepth?: number;
+    filePattern?: string;
+    absoluteSearchPath?: string;
+    caseSensitive?: boolean;
+    maxMatches?: number;
+    excludePatterns?: string[];
+    respectGitignore?: boolean;
+    searchBinaryFiles?: boolean;
+    absoluteSearchResults?: boolean;
+}
+/**
+ * Executes grep using ripgrep binary for improved performance.
+ *
+ * This function attempts to use the platform-specific ripgrep binary for
+ * searching. If ripgrep is not available or fails, it returns null to
+ * allow fallback to the Node.js implementation.
+ *
+ * @param fileSystem - File system provider for path resolution
+ * @param searchPath - Path to search (file or directory)
+ * @param pattern - Search pattern (regex)
+ * @param rgBinaryBasePath - Base directory where ripgrep binary is installed
+ * @param options - Search options
+ * @returns GrepResult if successful, null if ripgrep unavailable/failed
+ */
+export declare function grepWithRipgrep(fileSystem: FileSystemOperations, pattern: string, rgBinaryBasePath: string, options?: GrepOptions, onError?: (error: Error) => void): Promise<GrepResult | null>;
+//# sourceMappingURL=grep-ripgrep.d.ts.map

package/dist/grep/index.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystemOperations, GrepOptions, GrepResult } from '../types.js';
+export declare function grep(fileSystem: FileSystemOperations, pattern: string, rgBinaryBasePath: string, options?: GrepOptions): Promise<GrepResult>;
+//# sourceMappingURL=index.d.ts.map

package/dist/grep.d.ts

@@ -0,0 +1,12 @@
+import type { BaseFileSystemProvider, GrepResult } from '@stagewise/agent-runtime-interface';
+export declare function grep(fileSystem: BaseFileSystemProvider, relativePath: string, pattern: string, options?: {
+    recursive?: boolean;
+    maxDepth?: number;
+    filePattern?: string;
+    caseSensitive?: boolean;
+    maxMatches?: number;
+    excludePatterns?: string[];
+    respectGitignore?: boolean;
+    searchBinaryFiles?: boolean;
+}): Promise<GrepResult>;
+//# sourceMappingURL=grep.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,155 @@
+import type { FileSystemProviderConfig, FileChangeEvent, GrepResult, GlobResult, GrepOptions, GlobOptions, SearchReplaceResult } from './types.js';
+export type { FileSystemProviderConfig, FileSystemOperations, FileChangeEvent, FileOperationResult, FileContentResult, DirectoryEntry, DirectoryListResult, GrepOptions, GrepMatch, GrepResult, GlobOptions, GlobResult, SearchReplaceMatch, SearchReplaceResult, } from './types.js';
+export declare class NodeFileSystemProvider {
+    private config;
+    private gitignoreMap;
+    private gitignoreInitialized;
+    /** Hot-path cache: gitignore entries sorted by directory depth (deep → shallow) */
+    private sortedGitignoreEntries;
+    constructor(config: FileSystemProviderConfig);
+    getCurrentWorkingDirectory(): string;
+    setCurrentWorkingDirectory(dir: string): void;
+    readFile(relativePath: string, options?: {
+        startLine?: number;
+        endLine?: number;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error: string;
+        content?: undefined;
+        totalLines?: undefined;
+    } | {
+        success: boolean;
+        content: string;
+        totalLines: number;
+        message?: undefined;
+        error?: undefined;
+    }>;
+    writeFile(relativePath: string, content: string): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        error: string;
+    }>;
+    editFile(relativePath: string, content: string, startLine: number, endLine: number): Promise<{
+        success: boolean;
+        message: string;
+        error: string;
+    } | {
+        success: boolean;
+        message: string;
+        error?: undefined;
+    }>;
+    createDirectory(relativePath: string): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        error: string;
+    }>;
+    listDirectory(relativePath: string, options?: {
+        recursive?: boolean;
+        maxDepth?: number;
+        pattern?: string;
+        includeDirectories?: boolean;
+        includeFiles?: boolean;
+        respectGitignore?: boolean;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        files: {
+            relativePath: string;
+            name: string;
+            type: "file" | "directory";
+            size?: number;
+            depth: number;
+        }[];
+        totalFiles: number;
+        totalDirectories: number;
+        error?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        error: string;
+        files?: undefined;
+        totalFiles?: undefined;
+        totalDirectories?: undefined;
+    }>;
+    grep(pattern: string, options?: GrepOptions): Promise<GrepResult>;
+    glob(pattern: string, options?: GlobOptions): Promise<GlobResult>;
+    searchAndReplace(relativePath: string, searchString: string, replaceString: string, options?: {
+        caseSensitive?: boolean;
+        wholeWord?: boolean;
+        regex?: boolean;
+        preserveCase?: boolean;
+        maxReplacements?: number;
+        dryRun?: boolean;
+    }): Promise<SearchReplaceResult>;
+    private preserveCase;
+    deleteFile(relativePath: string): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        error: string;
+    }>;
+    copyFile(source: string, destination: string): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        error: string;
+    }>;
+    moveFile(source: string, destination: string): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        error: string;
+    }>;
+    fileExists(relativePath: string): Promise<boolean>;
+    isDirectory(relativePath: string): Promise<boolean>;
+    getFileStats(relativePath: string): Promise<{
+        size: number;
+        modifiedTime: Date;
+    }>;
+    resolvePath(relativePath: string): string;
+    getDirectoryName(relativePath: string): string;
+    joinPaths(...relativePaths: string[]): string;
+    getRelativePath(from: string, to: string): string;
+    getFileExtension(relativePath: string): string;
+    getGitignorePatterns(): Promise<string[]>;
+    isIgnored(relativePath: string): Promise<boolean>;
+    /**
+     * Synchronous ignore check using a pre-sorted array (deepest → shallowest).
+     */
+    isIgnoredSync(relativePath: string): boolean;
+    isBinary(relativePath: string): Promise<boolean>;
+    private ensureGitignoreInitialized;
+    private findAndLoadGitignoreFiles;
+    private isDirectoryIgnoredByParent;
+    watchFiles(relativePath: string, onFileChange: (event: FileChangeEvent) => void): Promise<() => Promise<void>>;
+}
+export interface ClientRuntimeNodeConfig {
+    workingDirectory: string;
+    rgBinaryBasePath: string;
+}
+export declare class ClientRuntimeNode {
+    readonly fileSystem: NodeFileSystemProvider;
+    constructor(config: ClientRuntimeNodeConfig);
+}
+export { ensureRipgrepInstalled } from './vscode-ripgrep/ensure-ripgrep.js';
+export type { EnsureRipgrepResult, EnsureRipgrepOptions, } from './vscode-ripgrep/ensure-ripgrep.js';
+export { getRipgrepPath, getRipgrepBinDir } from './vscode-ripgrep/get-path.js';
+//# sourceMappingURL=index.d.ts.map