vibe-weaver 1.0.0

package/src/tools/files.ts

@@ -0,0 +1,279 @@
+/**
+ * File Tools for Vibe-Weaver CLI
+ * Real file operations against local filesystem
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import { generateDiff } from '../lib/code-parser.js';
+
+export interface FileOperationResult {
+  success: boolean;
+  path: string;
+  content?: string;
+  error?: string;
+  diff?: string;
+}
+
+/**
+ * Read a file from the local filesystem
+ */
+export async function readFile(filePath: string, baseDir: string = process.cwd()): Promise<FileOperationResult> {
+  try {
+    const fullPath = path.isAbsolute(filePath) ? filePath : path.join(baseDir, filePath);
+    const content = await fs.readFile(fullPath, 'utf-8');
+    return { success: true, path: filePath, content };
+  } catch (error) {
+    return {
+      success: false,
+      path: filePath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * Write content to a file
+ */
+export async function writeFile(
+  filePath: string,
+  content: string,
+  baseDir: string = process.cwd(),
+  options: { dryRun?: boolean; showDiff?: boolean } = {}
+): Promise<FileOperationResult> {
+  try {
+    const fullPath = path.isAbsolute(filePath) ? filePath : path.join(baseDir, filePath);
+    const dir = path.dirname(fullPath);
+    
+    // Check if file exists for diff
+    let oldContent = '';
+    try {
+      oldContent = await fs.readFile(fullPath, 'utf-8');
+    } catch {
+      // File doesn't exist, that's fine
+    }
+    
+    // Generate diff if requested and file exists
+    const diff = options.showDiff && oldContent ? generateDiff(oldContent, content, filePath) : undefined;
+    
+    if (options.dryRun) {
+      return { success: true, path: filePath, diff };
+    }
+    
+    // Create directory if needed
+    await fs.mkdir(dir, { recursive: true });
+    
+    // Write file
+    await fs.writeFile(fullPath, content, 'utf-8');
+    
+    return { success: true, path: filePath, diff };
+  } catch (error) {
+    return {
+      success: false,
+      path: filePath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * Edit a file using search/replace
+ */
+export async function editFile(
+  filePath: string,
+  search: string,
+  replace: string,
+  baseDir: string = process.cwd(),
+  options: { dryRun?: boolean; showDiff?: boolean } = {}
+): Promise<FileOperationResult> {
+  try {
+    const fullPath = path.isAbsolute(filePath) ? filePath : path.join(baseDir, filePath);
+    
+    // Read current content
+    const content = await fs.readFile(fullPath, 'utf-8');
+    
+    // Check if search string exists
+    if (!content.includes(search)) {
+      return {
+        success: false,
+        path: filePath,
+        error: `Search string not found in file`
+      };
+    }
+    
+    // Generate diff
+    const newContent = content.replace(search, replace);
+    const diff = options.showDiff ? generateDiff(content, newContent, filePath) : undefined;
+    
+    if (options.dryRun) {
+      return { success: true, path: filePath, diff };
+    }
+    
+    // Write updated content
+    await fs.writeFile(fullPath, newContent, 'utf-8');
+    
+    return { success: true, path: filePath, diff };
+  } catch (error) {
+    return {
+      success: false,
+      path: filePath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * List files in a directory
+ */
+export async function listDir(dirPath: string = '.', baseDir: string = process.cwd()): Promise<{ path: string; isDirectory: boolean }[]> {
+  const fullPath = path.isAbsolute(dirPath) ? dirPath : path.join(baseDir, dirPath);
+  
+  try {
+    const entries = await fs.readdir(fullPath, { withFileTypes: true });
+    return entries.map(entry => ({
+      path: entry.name,
+      isDirectory: entry.isDirectory()
+    }));
+  } catch (error) {
+    throw new Error(`Failed to list directory: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * Search for a pattern in files
+ */
+export async function grep(
+  pattern: string,
+  baseDir: string = process.cwd(),
+  options: { filePattern?: string; recursive?: boolean } = {}
+): Promise<{ file: string; line: number; content: string }[]> {
+  const results: { file: string; line: number; content: string }[] = [];
+  const fs = await import('fs/promises');
+  
+  async function searchDir(dir: string) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      
+      // Skip node_modules, .git, etc.
+      if (entry.name === 'node_modules' || entry.name === '.git' || entry.name.startsWith('.')) {
+        continue;
+      }
+      
+      if (entry.isDirectory() && options.recursive !== false) {
+        await searchDir(fullPath);
+      } else if (entry.isFile()) {
+        // Check file pattern
+        if (options.filePattern && !new RegExp(options.filePattern).test(entry.name)) {
+          continue;
+        }
+        
+        // Search in file
+        try {
+          const content = await fs.readFile(fullPath, 'utf-8');
+          const lines = content.split('\n');
+          
+          for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes(pattern)) {
+              results.push({
+                file: path.relative(baseDir, fullPath),
+                line: i + 1,
+                content: lines[i].trim()
+              });
+            }
+          }
+        } catch {
+          // Skip binary files or unreadable files
+        }
+      }
+    }
+  }
+  
+  await searchDir(baseDir);
+  return results;
+}
+
+/**
+ * Find files matching a glob pattern
+ */
+export async function glob(
+  pattern: string,
+  baseDir: string = process.cwd()
+): Promise<string[]> {
+  const results: string[] = [];
+  const patternParts = pattern.split('/');
+  const regexPattern = patternParts.map(part => {
+    if (part === '**') return '.*';
+    if (part === '*') return '[^/]*';
+    return part.replace(/\./g, '\\.').replace(/\*/g, '.*');
+  }).join('/');
+  
+  const regex = new RegExp(`^${regexPattern}$`);
+  
+  async function searchDir(dir: string) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(baseDir, fullPath);
+      
+      // Skip node_modules, .git, etc.
+      if (entry.name === 'node_modules' || entry.name === '.git' || entry.name.startsWith('.')) {
+        continue;
+      }
+      
+      if (entry.isDirectory()) {
+        await searchDir(fullPath);
+      } else if (entry.isFile()) {
+        if (regex.test(relativePath) || regex.test(entry.name)) {
+          results.push(relativePath);
+        }
+      }
+    }
+  }
+  
+  await searchDir(baseDir);
+  return results;
+}
+
+/**
+ * Check if a file exists
+ */
+export async function fileExists(filePath: string, baseDir: string = process.cwd()): Promise<boolean> {
+  const fullPath = path.isAbsolute(filePath) ? filePath : path.join(baseDir, filePath);
+  try {
+    await fs.access(fullPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get file stats
+ */
+export async function getFileStats(filePath: string, baseDir: string = process.cwd()): Promise<{ size: number; modified: Date } | null> {
+  const fullPath = path.isAbsolute(filePath) ? filePath : path.join(baseDir, filePath);
+  try {
+    const stats = await fs.stat(fullPath);
+    return {
+      size: stats.size,
+      modified: stats.mtime
+    };
+  } catch {
+    return null;
+  }
+}
+
+export default {
+  readFile,
+  writeFile,
+  editFile,
+  listDir,
+  grep,
+  glob,
+  fileExists,
+  getFileStats
+};