byterover-cli 0.2.1 → 0.3.0

package/dist/infra/cipher/file-system/file-system-service.js

@@ -0,0 +1,641 @@
+import { glob } from 'glob';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import { EOL } from 'node:os';
+import path from 'node:path';
+import { DirectoryNotFoundError, EditOperationError, FileNotFoundError, FileTooLargeError, GlobOperationError, InvalidExtensionError, InvalidPathError, InvalidPatternError, PathBlockedError, PathNotAllowedError, PathTraversalError, ReadOperationError, SearchOperationError, ServiceNotInitializedError, StringNotFoundError, StringNotUniqueError, WriteOperationError, } from '../../../core/domain/cipher/errors/file-system-error.js';
+import { getErrorMessage } from '../../../utils/error-helpers.js';
+import { createGitignoreFilter } from './gitignore-filter.js';
+import { collectFileMetadata, escapeIfExactMatch, extractPaths, sortFilesByRecency } from './glob-utils.js';
+import { PathValidator } from './path-validator.js';
+/**
+ * File system service implementation.
+ * Provides secure, validated file system operations with comprehensive
+ * path validation, size limits, and allow/block list enforcement.
+ */
+export class FileSystemService {
+    config;
+    initialized = false;
+    pathValidator;
+    /**
+     * Creates a new file system service
+     * @param config - File system configuration (optional, uses defaults)
+     */
+    constructor(config = {}) {
+        // Merge with defaults
+        this.config = {
+            allowedPaths: config.allowedPaths ?? ['.'],
+            blockedExtensions: config.blockedExtensions ?? ['.exe', '.dll', '.so', '.dylib'],
+            blockedPaths: config.blockedPaths ?? ['.git', 'node_modules/.bin', '.env', '.byterover'],
+            maxFileSize: config.maxFileSize ?? 10 * 1024 * 1024, // 10MB
+            workingDirectory: config.workingDirectory ?? process.cwd(),
+        };
+        this.pathValidator = new PathValidator(this.config);
+    }
+    /**
+     * Edit a file by replacing strings.
+     */
+    async editFile(filePath, operation, options = {}) {
+        this.ensureInitialized();
+        // Validate path
+        const validation = this.pathValidator.validate(filePath, 'read');
+        if (!validation.valid) {
+            this.throwValidationError(filePath, validation.error);
+        }
+        const { normalizedPath } = validation;
+        try {
+            // Read current content
+            const fileContent = await this.readFile(filePath, options);
+            let { content } = fileContent;
+            // Escape regex special characters for literal string matching
+            const escapedOldString = operation.oldString.replaceAll(/[$()*+.?[\u005C\]^{|}]/g, String.raw `\$&`);
+            // Count occurrences
+            const occurrences = (content.match(new RegExp(escapedOldString, 'g')) || []).length;
+            // Check if string exists
+            if (occurrences === 0) {
+                throw new StringNotFoundError(normalizedPath, operation.oldString);
+            }
+            // Check if string is unique (if replaceAll is false)
+            if (!operation.replaceAll && occurrences > 1) {
+                throw new StringNotUniqueError(normalizedPath, operation.oldString, occurrences);
+            }
+            // Perform replacement
+            content = operation.replaceAll
+                ? content.replaceAll(operation.oldString, operation.newString)
+                : content.replace(operation.oldString, operation.newString);
+            // Write back
+            const writeResult = await this.writeFile(filePath, content, options);
+            return {
+                bytesWritten: writeResult.bytesWritten,
+                path: normalizedPath,
+                replacements: operation.replaceAll ? occurrences : 1,
+                success: true,
+            };
+        }
+        catch (error) {
+            // Re-throw known errors
+            if (error instanceof FileNotFoundError ||
+                error instanceof StringNotFoundError ||
+                error instanceof StringNotUniqueError ||
+                error instanceof PathNotAllowedError ||
+                error instanceof PathTraversalError ||
+                error instanceof PathBlockedError) {
+                throw error;
+            }
+            // Wrap other errors
+            throw new EditOperationError(normalizedPath, getErrorMessage(error));
+        }
+    }
+    /**
+     * Find files matching a glob pattern.
+     *
+     * Features:
+     * - Case sensitivity control via `caseSensitive` option
+     * - Gitignore filtering via `respectGitignore` option
+     * - Smart sorting: recent files (within 24h) first, then alphabetical
+     * - Special character handling for paths with glob syntax
+     */
+    async globFiles(pattern, options = {}) {
+        this.ensureInitialized();
+        const cwd = options.cwd ?? this.config.workingDirectory;
+        const maxResults = options.maxResults ?? 1000;
+        const includeMetadata = options.includeMetadata ?? true;
+        const caseSensitive = options.caseSensitive ?? true;
+        const respectGitignore = options.respectGitignore ?? true;
+        try {
+            // Handle special characters - escape pattern if it matches an existing file
+            const escapedPattern = await escapeIfExactMatch(pattern, cwd);
+            // Execute glob with case sensitivity option
+            const files = await glob(escapedPattern, {
+                absolute: true,
+                cwd,
+                follow: false, // Don't follow symlinks
+                nocase: !caseSensitive, // Case insensitive if caseSensitive is false
+                nodir: true, // Only files
+            });
+            // Initialize gitignore filter if requested
+            let gitignoreFilter = null;
+            if (respectGitignore) {
+                gitignoreFilter = await createGitignoreFilter(cwd);
+            }
+            // Validate paths and apply gitignore filtering
+            const validPaths = [];
+            let ignoredCount = 0;
+            for (const file of files) {
+                // Validate path
+                const validation = this.pathValidator.validate(file, 'read');
+                if (!validation.valid || !validation.normalizedPath) {
+                    // Skip invalid paths
+                    continue;
+                }
+                // Apply gitignore filter if enabled
+                if (gitignoreFilter) {
+                    const relativePath = path.relative(cwd, validation.normalizedPath);
+                    if (gitignoreFilter.isIgnored(relativePath)) {
+                        ignoredCount++;
+                        continue;
+                    }
+                }
+                validPaths.push(validation.normalizedPath);
+            }
+            const totalFound = validPaths.length;
+            // Collect metadata for all valid paths
+            const filesWithMetadata = await collectFileMetadata(validPaths, cwd);
+            // Sort files: recent files first (within 24h), then alphabetical
+            const sortedFiles = sortFilesByRecency(filesWithMetadata);
+            // Apply maxResults limit after sorting
+            const truncated = sortedFiles.length > maxResults;
+            const limitedFiles = sortedFiles.slice(0, maxResults);
+            // Convert to FileMetadata format
+            const resultFiles = includeMetadata
+                ? limitedFiles.map((f) => ({
+                    isDirectory: false,
+                    modified: f.modifiedTime,
+                    path: f.path,
+                    size: f.size,
+                }))
+                : extractPaths(limitedFiles).map((p) => ({
+                    isDirectory: false,
+                    modified: new Date(),
+                    path: p,
+                    size: 0,
+                }));
+            // Build result message
+            const message = this.buildGlobMessage(resultFiles.length, totalFound, ignoredCount, truncated);
+            return {
+                files: resultFiles,
+                ignoredCount,
+                message,
+                totalFound,
+                truncated,
+            };
+        }
+        catch (error) {
+            // Check for pattern errors
+            if (getErrorMessage(error).includes('Invalid glob pattern')) {
+                throw new InvalidPatternError(pattern, getErrorMessage(error));
+            }
+            throw new GlobOperationError(pattern, getErrorMessage(error));
+        }
+    }
+    /**
+     * Initialize the file system service.
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        // Verify working directory exists
+        try {
+            const stats = await fs.stat(this.config.workingDirectory);
+            if (!stats.isDirectory()) {
+                throw new DirectoryNotFoundError(this.config.workingDirectory);
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new DirectoryNotFoundError(this.config.workingDirectory);
+            }
+            throw error;
+        }
+        this.initialized = true;
+    }
+    /**
+     * Read the contents of a file.
+     */
+    async readFile(filePath, options = {}) {
+        this.ensureInitialized();
+        // Validate path
+        const validation = this.pathValidator.validate(filePath, 'read');
+        if (!validation.valid) {
+            this.throwValidationError(filePath, validation.error);
+        }
+        const { normalizedPath } = validation;
+        try {
+            // Check if file exists
+            let stats;
+            try {
+                stats = await fs.stat(normalizedPath);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    throw new FileNotFoundError(normalizedPath);
+                }
+                throw error;
+            }
+            // Check file size
+            if (stats.size > this.config.maxFileSize) {
+                throw new FileTooLargeError(normalizedPath, stats.size, this.config.maxFileSize);
+            }
+            // Read file
+            const encoding = (options.encoding ?? 'utf8');
+            const content = await fs.readFile(normalizedPath, encoding);
+            // Handle pagination
+            const lines = content.split('\n');
+            let selectedLines;
+            let truncated = false;
+            // Apply offset (1-based, like text editors)
+            const { limit, offset: offset1 } = options;
+            if (offset1 !== undefined || limit !== undefined) {
+                const start = offset1 !== undefined && offset1 > 0 ? Math.max(0, offset1 - 1) : 0;
+                const end = limit === undefined ? lines.length : start + limit;
+                selectedLines = lines.slice(start, end);
+                truncated = end < lines.length;
+            }
+            else {
+                selectedLines = lines;
+            }
+            const selectedContent = selectedLines.join('\n');
+            return {
+                content: selectedContent,
+                encoding,
+                lines: selectedLines.length,
+                size: stats.size,
+                truncated,
+            };
+        }
+        catch (error) {
+            // Re-throw known errors
+            if (error instanceof FileNotFoundError ||
+                error instanceof FileTooLargeError ||
+                error instanceof PathNotAllowedError ||
+                error instanceof PathTraversalError ||
+                error instanceof PathBlockedError) {
+                throw error;
+            }
+            // Wrap other errors
+            throw new ReadOperationError(normalizedPath, getErrorMessage(error));
+        }
+    }
+    /**
+     * Search file contents for a pattern.
+     * Uses native grep commands (ripgrep, system grep) when available for better performance,
+     * falling back to JavaScript implementation when needed.
+     */
+    async searchContent(pattern, options = {}) {
+        this.ensureInitialized();
+        const cwd = options.cwd ?? this.config.workingDirectory;
+        const maxResults = options.maxResults ?? 100;
+        const contextLines = options.contextLines ?? 0;
+        // If context lines requested, use JS fallback directly (native grep context parsing is complex)
+        if (contextLines > 0) {
+            return this.searchContentJS(pattern, options);
+        }
+        try {
+            // Try native strategies in order: ripgrep → system grep → JS fallback
+            let matches = null;
+            matches = await this.executeRipgrep(pattern, cwd, options);
+            if (matches === null) {
+                matches = await this.executeSystemGrep(pattern, cwd, options);
+            }
+            if (matches === null) {
+                return this.searchContentJS(pattern, options);
+            }
+            // Apply maxResults limit
+            const truncated = matches.length > maxResults;
+            return {
+                filesSearched: new Set(matches.map((m) => m.file)).size,
+                matches: matches.slice(0, maxResults),
+                totalMatches: matches.length,
+                truncated,
+            };
+        }
+        catch (error) {
+            // Re-throw known errors
+            if (error instanceof InvalidPatternError || error instanceof GlobOperationError) {
+                throw error;
+            }
+            throw new SearchOperationError(pattern, getErrorMessage(error));
+        }
+    }
+    /**
+     * Write content to a file.
+     */
+    async writeFile(filePath, content, options = {}) {
+        this.ensureInitialized();
+        // Validate path
+        const validation = this.pathValidator.validate(filePath, 'write');
+        if (!validation.valid) {
+            this.throwValidationError(filePath, validation.error);
+        }
+        const { normalizedPath } = validation;
+        try {
+            // Create parent directories if requested
+            if (options.createDirs) {
+                const dirname = path.dirname(normalizedPath);
+                await fs.mkdir(dirname, { recursive: true });
+            }
+            // Write file
+            const encoding = (options.encoding ?? 'utf8');
+            await fs.writeFile(normalizedPath, content, encoding);
+            // Get file size
+            const stats = await fs.stat(normalizedPath);
+            return {
+                bytesWritten: stats.size,
+                path: normalizedPath,
+                success: true,
+            };
+        }
+        catch (error) {
+            // Re-throw known errors
+            if (error instanceof InvalidExtensionError ||
+                error instanceof PathNotAllowedError ||
+                error instanceof PathTraversalError ||
+                error instanceof PathBlockedError) {
+                throw error;
+            }
+            // Wrap other errors
+            throw new WriteOperationError(normalizedPath, getErrorMessage(error));
+        }
+    }
+    /**
+     * Builds a human-readable message for glob results.
+     */
+    buildGlobMessage(returned, total, ignored, truncated) {
+        const parts = [];
+        if (truncated) {
+            parts.push(`Found ${total} files, showing first ${returned}`);
+        }
+        else {
+            parts.push(`Found ${returned} file${returned === 1 ? '' : 's'}`);
+        }
+        if (ignored > 0) {
+            parts.push(`(${ignored} ignored by .gitignore)`);
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Collects context lines before and after a match.
+     */
+    collectContextLines(lines, lineIndex, contextLines) {
+        const before = [];
+        const after = [];
+        if (contextLines > 0) {
+            // Lines before
+            for (let j = Math.max(0, lineIndex - contextLines); j < lineIndex; j++) {
+                before.push(lines[j]);
+            }
+            // Lines after
+            for (let j = lineIndex + 1; j < Math.min(lines.length, lineIndex + 1 + contextLines); j++) {
+                after.push(lines[j]);
+            }
+        }
+        return { after, before };
+    }
+    /**
+     * Creates a regex from a pattern string.
+     */
+    createSearchRegex(pattern, caseInsensitive) {
+        const flags = caseInsensitive ? 'i' : '';
+        try {
+            return new RegExp(pattern, flags);
+        }
+        catch (error) {
+            throw new InvalidPatternError(pattern, getErrorMessage(error));
+        }
+    }
+    /**
+     * Ensures the service is initialized.
+     * @throws ServiceNotInitializedError if not initialized
+     */
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new ServiceNotInitializedError();
+        }
+    }
+    /**
+     * Executes ripgrep (rg) for content search.
+     * Returns null if rg is not available or fails.
+     */
+    async executeRipgrep(pattern, cwd, options) {
+        if (!(await this.isCommandAvailable('rg')))
+            return null;
+        const args = ['-n', '--no-heading', '--with-filename'];
+        if (options.caseInsensitive)
+            args.push('-i');
+        // Add exclusions for blocked paths
+        for (const blocked of this.config.blockedPaths) {
+            args.push('--glob', `!${blocked}`);
+        }
+        if (options.globPattern)
+            args.push('--glob', options.globPattern);
+        args.push(pattern, '.'); // Add search path to prevent reading from stdin
+        try {
+            const output = await this.spawnCommand('rg', args, cwd, options.abortSignal);
+            return this.parseGrepOutput(output, cwd);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Executes system grep for content search.
+     * Returns null if grep is not available or fails.
+     */
+    async executeSystemGrep(pattern, cwd, options) {
+        if (!(await this.isCommandAvailable('grep')))
+            return null;
+        const args = ['-r', '-n', '-H', '-E', '-I'];
+        if (options.caseInsensitive)
+            args.push('-i');
+        // Add exclusions for blocked paths
+        for (const blocked of this.config.blockedPaths) {
+            args.push(`--exclude-dir=${blocked}`);
+        }
+        if (options.globPattern)
+            args.push(`--include=${options.globPattern}`);
+        args.push(pattern, '.');
+        try {
+            const output = await this.spawnCommand('grep', args, cwd, options.abortSignal);
+            return this.parseGrepOutput(output, cwd);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Checks if a command is available in the system's PATH.
+     */
+    isCommandAvailable(command) {
+        return new Promise((resolve) => {
+            const checkCmd = process.platform === 'win32' ? 'where' : 'command';
+            const checkArgs = process.platform === 'win32' ? [command] : ['-v', command];
+            try {
+                const child = spawn(checkCmd, checkArgs, { shell: true, stdio: 'ignore' });
+                child.on('close', (code) => resolve(code === 0));
+                child.on('error', () => resolve(false));
+            }
+            catch {
+                resolve(false);
+            }
+        });
+    }
+    /**
+     * Parses output from grep-like commands (filepath:lineNumber:content format).
+     */
+    parseGrepOutput(output, basePath) {
+        const results = [];
+        if (!output)
+            return results;
+        for (const line of output.split(EOL)) {
+            if (!line.trim())
+                continue;
+            // Format: filepath:lineNumber:content
+            const firstColon = line.indexOf(':');
+            if (firstColon === -1)
+                continue;
+            const secondColon = line.indexOf(':', firstColon + 1);
+            if (secondColon === -1)
+                continue;
+            const filePath = line.slice(0, firstColon);
+            const lineNumber = Number.parseInt(line.slice(firstColon + 1, secondColon), 10);
+            const content = line.slice(secondColon + 1);
+            if (!Number.isNaN(lineNumber)) {
+                results.push({
+                    file: path.resolve(basePath, filePath),
+                    line: content,
+                    lineNumber,
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * JavaScript-based content search implementation.
+     * Used as fallback when native grep commands are unavailable or when context lines are needed.
+     */
+    async searchContentJS(pattern, options = {}) {
+        const globPattern = options.globPattern ?? '**/*';
+        const cwd = options.cwd ?? this.config.workingDirectory;
+        const maxResults = options.maxResults ?? 100;
+        const contextLines = options.contextLines ?? 0;
+        const caseInsensitive = options.caseInsensitive ?? false;
+        try {
+            // Create regex
+            const regex = this.createSearchRegex(pattern, caseInsensitive);
+            // Find files to search
+            const globResult = await this.globFiles(globPattern, {
+                cwd,
+                includeMetadata: false,
+                maxResults: 10_000, // Search more files, but limit results
+            });
+            return await this.searchFiles(globResult.files, regex, maxResults, contextLines);
+        }
+        catch (error) {
+            // Re-throw known errors
+            if (error instanceof InvalidPatternError || error instanceof GlobOperationError) {
+                throw error;
+            }
+            throw new SearchOperationError(pattern, getErrorMessage(error));
+        }
+    }
+    /**
+     * Searches a single file for a regex pattern.
+     */
+    async searchFile(filePath, regex, maxMatches, contextLines) {
+        const fileContent = await this.readFile(filePath);
+        const lines = fileContent.content.split('\n');
+        const matches = [];
+        let totalMatches = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (regex.test(line)) {
+                totalMatches++;
+                if (matches.length >= maxMatches) {
+                    break;
+                }
+                const context = this.collectContextLines(lines, i, contextLines);
+                matches.push({
+                    context: contextLines > 0 ? context : undefined,
+                    file: filePath,
+                    line,
+                    lineNumber: i + 1, // 1-based line numbers
+                });
+            }
+        }
+        return { matches, totalMatches };
+    }
+    /**
+     * Searches multiple files for a regex pattern.
+     */
+    async searchFiles(files, regex, maxResults, contextLines) {
+        const matches = [];
+        let totalMatches = 0;
+        let filesSearched = 0;
+        for (const fileInfo of files) {
+            filesSearched++;
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                const fileMatches = await this.searchFile(fileInfo.path, regex, maxResults - matches.length, contextLines);
+                totalMatches += fileMatches.totalMatches;
+                for (const match of fileMatches.matches) {
+                    matches.push(match);
+                    if (matches.length >= maxResults) {
+                        return {
+                            filesSearched,
+                            matches,
+                            totalMatches,
+                            truncated: true,
+                        };
+                    }
+                }
+            }
+            catch {
+                // Skip files that can't be read
+                continue;
+            }
+        }
+        return {
+            filesSearched,
+            matches,
+            totalMatches,
+            truncated: false,
+        };
+    }
+    /**
+     * Spawns a command and returns its stdout.
+     */
+    spawnCommand(cmd, args, cwd, signal) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(cmd, args, { cwd, windowsHide: true });
+            const chunks = [];
+            if (signal) {
+                signal.addEventListener('abort', () => child.kill());
+            }
+            child.stdout.on('data', (chunk) => chunks.push(chunk));
+            child.on('error', reject);
+            child.on('close', (code) => {
+                if (code === 0 || code === 1) {
+                    // 1 = no matches found (not an error)
+                    resolve(Buffer.concat(chunks).toString('utf8'));
+                }
+                else {
+                    reject(new Error(`Command exited with code ${code}`));
+                }
+            });
+        });
+    }
+    /**
+     * Throws the appropriate error based on validation error message.
+     */
+    throwValidationError(path, error) {
+        if (error.includes('empty')) {
+            throw new InvalidPathError(path, error);
+        }
+        if (error.includes('traversal')) {
+            throw new PathTraversalError(path);
+        }
+        if (error.includes('not in allowed paths')) {
+            throw new PathNotAllowedError(path, this.config.allowedPaths);
+        }
+        if (error.includes('blocked')) {
+            throw new PathBlockedError(path, error);
+        }
+        if (error.includes('extension')) {
+            const ext = path.split('.').pop() ?? '';
+            throw new InvalidExtensionError(path, ext);
+        }
+        // Fallback
+        throw new InvalidPathError(path, error);
+    }
+}