genesis-ai-cli 7.4.5

package/dist/src/tools/edit.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Genesis Diff-Based File Editor
+ *
+ * File editing capabilities:
+ * - old_string -> new_string replacement
+ * - Unique match verification
+ * - replace_all for global replacements
+ * - Atomic writes with backup
+ * - Indentation preservation
+ */
+export interface EditParams {
+    /** Absolute path to the file */
+    file_path: string;
+    /** Text to find and replace */
+    old_string: string;
+    /** Text to replace with */
+    new_string: string;
+    /** Replace all occurrences (default: false) */
+    replace_all?: boolean;
+}
+export interface EditResult {
+    success: boolean;
+    /** Number of replacements made */
+    replacements: number;
+    /** Error message if failed */
+    error?: string;
+    /** Diff preview (before/after context) */
+    diff?: string;
+    /** Backup file path if created */
+    backup?: string;
+}
+export interface WriteParams {
+    /** Absolute path to the file */
+    file_path: string;
+    /** Content to write */
+    content: string;
+    /** Create backup of existing file */
+    backup?: boolean;
+}
+export interface WriteResult {
+    success: boolean;
+    error?: string;
+    backup?: string;
+    bytes_written: number;
+}
+export interface EditToolConfig {
+    /** Create backups before editing */
+    createBackups: boolean;
+    /** Backup file suffix */
+    backupSuffix: string;
+    /** Maximum file size to edit (bytes) */
+    maxFileSize: number;
+    /** Allowed file extensions (empty = all) */
+    allowedExtensions: string[];
+    /** Blocked paths */
+    blockedPaths: RegExp[];
+}
+export declare const DEFAULT_EDIT_CONFIG: EditToolConfig;
+export declare class EditTool {
+    private config;
+    constructor(config?: Partial<EditToolConfig>);
+    /**
+     * Validate file path for editing
+     */
+    validatePath(filePath: string): {
+        valid: boolean;
+        reason?: string;
+    };
+    /**
+     * Edit a file by replacing old_string with new_string
+     */
+    edit(params: EditParams): Promise<EditResult>;
+    /**
+     * Write content to a file
+     */
+    write(params: WriteParams): Promise<WriteResult>;
+    /**
+     * Count occurrences of a string in content
+     */
+    private countOccurrences;
+    /**
+     * Generate a simple diff preview
+     */
+    private generateDiff;
+    /**
+     * Check if a string occurs exactly once in content
+     */
+    isUnique(content: string, search: string): boolean;
+    /**
+     * Find all occurrences with line numbers
+     */
+    findOccurrences(content: string, search: string): Array<{
+        line: number;
+        column: number;
+    }>;
+    /**
+     * Get configuration
+     */
+    getConfig(): EditToolConfig;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<EditToolConfig>): void;
+}
+export declare function getEditTool(config?: Partial<EditToolConfig>): EditTool;
+export declare function resetEditTool(): void;
+/**
+ * Edit a file with default settings
+ */
+export declare function edit(params: EditParams): Promise<EditResult>;
+/**
+ * Write a file with default settings
+ */
+export declare function writeFile(params: WriteParams): Promise<WriteResult>;
+/**
+ * Check if old_string is unique in file
+ */
+export declare function isUnique(filePath: string, search: string): boolean;
+/**
+ * Validate a file path for editing
+ */
+export declare function validatePath(filePath: string): {
+    valid: boolean;
+    reason?: string;
+};

package/dist/src/tools/edit.js

@@ -0,0 +1,424 @@
+"use strict";
+/**
+ * Genesis Diff-Based File Editor
+ *
+ * File editing capabilities:
+ * - old_string -> new_string replacement
+ * - Unique match verification
+ * - replace_all for global replacements
+ * - Atomic writes with backup
+ * - Indentation preservation
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditTool = exports.DEFAULT_EDIT_CONFIG = void 0;
+exports.getEditTool = getEditTool;
+exports.resetEditTool = resetEditTool;
+exports.edit = edit;
+exports.writeFile = writeFile;
+exports.isUnique = isUnique;
+exports.validatePath = validatePath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ============================================================================
+// Default Configuration
+// ============================================================================
+exports.DEFAULT_EDIT_CONFIG = {
+    createBackups: true,
+    backupSuffix: '.bak',
+    maxFileSize: 10 * 1024 * 1024, // 10MB
+    allowedExtensions: [], // All extensions allowed
+    blockedPaths: [
+        /\/\.git\//, // .git directory
+        /\/node_modules\//, // node_modules
+        /\/\.env$/, // .env files (exact match)
+        /\/\.env\.[^/]+$/, // .env.* files
+        /\/secrets?\./i, // secrets files
+        /\/credentials?\./i, // credentials files
+        /\/\.ssh\//, // SSH directory
+        /\/\.aws\//, // AWS directory
+    ],
+};
+// ============================================================================
+// Edit Tool Class
+// ============================================================================
+class EditTool {
+    config;
+    constructor(config) {
+        this.config = { ...exports.DEFAULT_EDIT_CONFIG, ...config };
+    }
+    // --------------------------------------------------------------------------
+    // Validation
+    // --------------------------------------------------------------------------
+    /**
+     * Validate file path for editing
+     */
+    validatePath(filePath) {
+        // Must be absolute path
+        if (!path.isAbsolute(filePath)) {
+            return { valid: false, reason: 'Path must be absolute' };
+        }
+        // Check blocked paths
+        for (const pattern of this.config.blockedPaths) {
+            if (pattern.test(filePath)) {
+                return { valid: false, reason: `Path matches blocked pattern: ${pattern.toString()}` };
+            }
+        }
+        // Check file extension if restricted
+        if (this.config.allowedExtensions.length > 0) {
+            const ext = path.extname(filePath).toLowerCase();
+            if (!this.config.allowedExtensions.includes(ext)) {
+                return { valid: false, reason: `Extension not allowed: ${ext}` };
+            }
+        }
+        return { valid: true };
+    }
+    // --------------------------------------------------------------------------
+    // Edit Operations
+    // --------------------------------------------------------------------------
+    /**
+     * Edit a file by replacing old_string with new_string
+     */
+    async edit(params) {
+        const { file_path, old_string, new_string, replace_all = false } = params;
+        // Validate path
+        const pathValidation = this.validatePath(file_path);
+        if (!pathValidation.valid) {
+            return {
+                success: false,
+                replacements: 0,
+                error: pathValidation.reason,
+            };
+        }
+        // Check file exists
+        if (!fs.existsSync(file_path)) {
+            return {
+                success: false,
+                replacements: 0,
+                error: `File not found: ${file_path}`,
+            };
+        }
+        // Check file size
+        const stats = fs.statSync(file_path);
+        if (stats.size > this.config.maxFileSize) {
+            return {
+                success: false,
+                replacements: 0,
+                error: `File too large: ${stats.size} bytes (max: ${this.config.maxFileSize})`,
+            };
+        }
+        // Read file content
+        let content;
+        try {
+            content = fs.readFileSync(file_path, 'utf-8');
+        }
+        catch (err) {
+            return {
+                success: false,
+                replacements: 0,
+                error: `Failed to read file: ${err.message}`,
+            };
+        }
+        // Validate old_string and new_string are different
+        if (old_string === new_string) {
+            return {
+                success: false,
+                replacements: 0,
+                error: 'old_string and new_string must be different',
+            };
+        }
+        // Find occurrences
+        const occurrences = this.countOccurrences(content, old_string);
+        if (occurrences === 0) {
+            return {
+                success: false,
+                replacements: 0,
+                error: `old_string not found in file`,
+            };
+        }
+        // If not replace_all, ensure unique match
+        if (!replace_all && occurrences > 1) {
+            return {
+                success: false,
+                replacements: 0,
+                error: `old_string found ${occurrences} times. Use replace_all=true or provide more context to make it unique.`,
+            };
+        }
+        // Create backup if configured
+        let backupPath;
+        if (this.config.createBackups) {
+            backupPath = file_path + this.config.backupSuffix;
+            try {
+                fs.copyFileSync(file_path, backupPath);
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    replacements: 0,
+                    error: `Failed to create backup: ${err.message}`,
+                };
+            }
+        }
+        // Perform replacement
+        let newContent;
+        let replacements;
+        if (replace_all) {
+            newContent = content.split(old_string).join(new_string);
+            replacements = occurrences;
+        }
+        else {
+            // Replace only first occurrence
+            const index = content.indexOf(old_string);
+            newContent = content.slice(0, index) + new_string + content.slice(index + old_string.length);
+            replacements = 1;
+        }
+        // Write atomically
+        try {
+            const tempPath = file_path + '.tmp.' + Date.now();
+            fs.writeFileSync(tempPath, newContent, 'utf-8');
+            fs.renameSync(tempPath, file_path);
+        }
+        catch (err) {
+            // Restore from backup if available
+            if (backupPath && fs.existsSync(backupPath)) {
+                fs.copyFileSync(backupPath, file_path);
+            }
+            return {
+                success: false,
+                replacements: 0,
+                error: `Failed to write file: ${err.message}`,
+            };
+        }
+        // Generate diff preview
+        const diff = this.generateDiff(old_string, new_string, content);
+        return {
+            success: true,
+            replacements,
+            diff,
+            backup: backupPath,
+        };
+    }
+    /**
+     * Write content to a file
+     */
+    async write(params) {
+        const { file_path, content, backup = true } = params;
+        // Validate path
+        const pathValidation = this.validatePath(file_path);
+        if (!pathValidation.valid) {
+            return {
+                success: false,
+                error: pathValidation.reason,
+                bytes_written: 0,
+            };
+        }
+        // Create backup if file exists
+        let backupPath;
+        if (backup && fs.existsSync(file_path)) {
+            backupPath = file_path + this.config.backupSuffix;
+            try {
+                fs.copyFileSync(file_path, backupPath);
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: `Failed to create backup: ${err.message}`,
+                    bytes_written: 0,
+                };
+            }
+        }
+        // Ensure parent directory exists
+        const dir = path.dirname(file_path);
+        if (!fs.existsSync(dir)) {
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: `Failed to create directory: ${err.message}`,
+                    bytes_written: 0,
+                };
+            }
+        }
+        // Write atomically
+        try {
+            const tempPath = file_path + '.tmp.' + Date.now();
+            fs.writeFileSync(tempPath, content, 'utf-8');
+            fs.renameSync(tempPath, file_path);
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Failed to write file: ${err.message}`,
+                bytes_written: 0,
+            };
+        }
+        return {
+            success: true,
+            bytes_written: Buffer.byteLength(content, 'utf-8'),
+            backup: backupPath,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Helper Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Count occurrences of a string in content
+     */
+    countOccurrences(content, search) {
+        let count = 0;
+        let pos = 0;
+        while ((pos = content.indexOf(search, pos)) !== -1) {
+            count++;
+            pos += search.length;
+        }
+        return count;
+    }
+    /**
+     * Generate a simple diff preview
+     */
+    generateDiff(old_string, new_string, context) {
+        const lines = [];
+        const oldLines = old_string.split('\n');
+        const newLines = new_string.split('\n');
+        // Find line number in context
+        const beforeMatch = context.split(old_string)[0];
+        const lineNumber = beforeMatch.split('\n').length;
+        lines.push(`@@ -${lineNumber},${oldLines.length} +${lineNumber},${newLines.length} @@`);
+        for (const line of oldLines) {
+            lines.push(`- ${line}`);
+        }
+        for (const line of newLines) {
+            lines.push(`+ ${line}`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Check if a string occurs exactly once in content
+     */
+    isUnique(content, search) {
+        return this.countOccurrences(content, search) === 1;
+    }
+    /**
+     * Find all occurrences with line numbers
+     */
+    findOccurrences(content, search) {
+        const results = [];
+        const lines = content.split('\n');
+        for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+            const line = lines[lineIdx];
+            let pos = 0;
+            while ((pos = line.indexOf(search, pos)) !== -1) {
+                results.push({ line: lineIdx + 1, column: pos + 1 });
+                pos += search.length;
+            }
+        }
+        // Also check for multi-line matches
+        let globalPos = 0;
+        while ((globalPos = content.indexOf(search, globalPos)) !== -1) {
+            const beforeMatch = content.slice(0, globalPos);
+            const lineNumber = beforeMatch.split('\n').length;
+            const lastNewline = beforeMatch.lastIndexOf('\n');
+            const column = globalPos - lastNewline;
+            // Add if not already in results (multi-line match)
+            const exists = results.some(r => r.line === lineNumber && r.column === column);
+            if (!exists) {
+                results.push({ line: lineNumber, column });
+            }
+            globalPos += search.length;
+        }
+        return results;
+    }
+    /**
+     * Get configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+}
+exports.EditTool = EditTool;
+// ============================================================================
+// Singleton Instance
+// ============================================================================
+let editToolInstance = null;
+function getEditTool(config) {
+    if (!editToolInstance) {
+        editToolInstance = new EditTool(config);
+    }
+    else if (config) {
+        editToolInstance.updateConfig(config);
+    }
+    return editToolInstance;
+}
+function resetEditTool() {
+    editToolInstance = null;
+}
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+/**
+ * Edit a file with default settings
+ */
+async function edit(params) {
+    return getEditTool().edit(params);
+}
+/**
+ * Write a file with default settings
+ */
+async function writeFile(params) {
+    return getEditTool().write(params);
+}
+/**
+ * Check if old_string is unique in file
+ */
+function isUnique(filePath, search) {
+    if (!fs.existsSync(filePath))
+        return false;
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return getEditTool().isUnique(content, search);
+}
+/**
+ * Validate a file path for editing
+ */
+function validatePath(filePath) {
+    return getEditTool().validatePath(filePath);
+}