@causyne/agent 0.0.0-stage → 1.10.0

package/src/tools/fsEdit.js

@@ -0,0 +1,105 @@
+import fs from 'fs/promises';
+import os from 'os';
+
+// Phase 3 AGI Upgrade: Fast Levenshtein Distance for Fuzzy Matching
+function getLevenshteinDistance(a, b) {
+  const matrix = Array(a.length + 1).fill(null).map(() => Array(b.length + 1).fill(null));
+
+  for (let i = 0; i <= a.length; i++) matrix[i][0] = i;
+  for (let j = 0; j <= b.length; j++) matrix[0][j] = j;
+
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const indicator = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1, // deletion
+        matrix[i][j - 1] + 1, // insertion
+        matrix[i - 1][j - 1] + indicator // substitution
+      );
+    }
+  }
+  return matrix[a.length][b.length];
+}
+
+function calculateConfidence(original, match) {
+  const dist = getLevenshteinDistance(original, match);
+  const maxLen = Math.max(original.length, match.length);
+  if (maxLen === 0) return 100;
+  return ((maxLen - dist) / maxLen) * 100;
+}
+
+export const fsEdit = {
+  schema: {
+    name: 'fs.edit',
+    description: 'Surgically edit specific lines/blocks in a file. Employs 90% confidence Levenshtein fuzzy matching if exact match fails.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string' },
+        edits: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              searchContent: { type: 'string' },
+              replaceContent: { type: 'string' }
+            },
+            required: ['searchContent', 'replaceContent']
+          }
+        }
+      },
+      required: ['path', 'edits']
+    }
+  },
+  async execute(args) {
+    try {
+      const target = args.path.replace(/^~\//, os.homedir() + '/');
+      let originalContent = await fs.readFile(target, 'utf8');
+      let workingContent = originalContent; // Phase 3 AGI Upgrade: Atomic Rollback prep
+      
+      let replacements = 0;
+      for (let i = 0; i < args.edits.length; i++) {
+        const edit = args.edits[i];
+        
+        // Try exact match first
+        if (workingContent.includes(edit.searchContent)) {
+          workingContent = workingContent.replace(edit.searchContent, edit.replaceContent);
+          replacements++;
+          continue;
+        }
+        
+        // Phase 3 AGI Upgrade: Fuzzy Match Fallback
+        const lines = workingContent.split('\n');
+        const oldLines = edit.searchContent.split('\n');
+        let bestMatch = null;
+        let highestConfidence = 0;
+        
+        for (let j = 0; j <= lines.length - oldLines.length; j++) {
+          const chunk = lines.slice(j, j + oldLines.length).join('\n');
+          const conf = calculateConfidence(edit.searchContent, chunk);
+          if (conf > highestConfidence) {
+            highestConfidence = conf;
+            bestMatch = chunk;
+          }
+        }
+
+        if (highestConfidence >= 90 && bestMatch) {
+          workingContent = workingContent.replace(bestMatch, edit.replaceContent);
+          replacements++;
+        } else {
+          // Atomic Rollback
+          return { 
+            success: false, 
+            error: `ATOMIC ROLLBACK: Edit index ${i} failed. Exact match not found, and fuzzy match confidence was too low (${highestConfidence.toFixed(2)}% < 90%). Previous edits in this batch were rolled back.` 
+          };
+        }
+      }
+      
+      // Commit the transaction
+      await fs.writeFile(target, workingContent, 'utf8');
+      return { success: true, output: `Transaction Success: ${replacements} replacement(s) safely applied to ${args.path}` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/fsFind.js

@@ -0,0 +1,128 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+// Phase 6 AGI Upgrade: Pure JS Levenshtein Distance for native fuzzy searching
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1, // substitution
+          matrix[i][j - 1] + 1,     // insertion
+          matrix[i - 1][j] + 1      // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+
+function isMatch(filename, keywords, extensions, fuzzyMatch) {
+  const lowerFilename = filename.toLowerCase();
+  
+  if (extensions && extensions.length > 0) {
+    const extMatch = extensions.some(ext => lowerFilename.endsWith(ext.toLowerCase()));
+    if (!extMatch) return false;
+  }
+  
+  if (!keywords || keywords.length === 0) return true;
+
+  for (const kw of keywords) {
+    const lowerKw = kw.toLowerCase();
+    if (lowerFilename.includes(lowerKw)) return true;
+    
+    // Fuzzy matching for typos (only applied if keyword is >= 4 chars)
+    if (fuzzyMatch && lowerKw.length >= 4) {
+      for (let i = 0; i <= lowerFilename.length - lowerKw.length + 1; i++) {
+        const chunk = lowerFilename.substr(i, lowerKw.length + 1); 
+        const distance = levenshteinDistance(chunk, lowerKw);
+        const maxDistance = Math.floor(lowerKw.length / 4);
+        if (distance <= maxDistance) return true;
+      }
+    }
+  }
+  return false;
+}
+
+export const fsFind = {
+  schema: {
+    name: 'fs.find',
+    description: 'Blazing fast semantic and fuzzy file search by name. Non-blocking Async Indexer.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Root directory to start the search.' },
+        keywords: { type: 'array', items: { type: 'string' } },
+        extensions: { type: 'array', items: { type: 'string' } },
+        fuzzyMatch: { type: 'boolean', description: 'Set to true to enable typo tolerance.' }
+      }
+    }
+  },
+  
+  async execute(args) {
+    try {
+      const targetDir = (args.path || process.cwd()).replace(/^~\//, os.homedir() + '/');
+      const keywords = args.keywords || [];
+      const extensions = args.extensions || [];
+      const fuzzyMatch = args.fuzzyMatch === true;
+      
+      const EXCLUDE_DIRS = new Set(['node_modules', '.git', '.gradle', 'build', 'dist', '.idea', '.causyne_trash']);
+      
+      const matches = [];
+      let scanned = 0;
+      const MAX_MATCHES = 50;
+
+      // Phase 6 AGI Upgrade: Asynchronous Non-Blocking Traversal to prevent Event Loop freezing
+      async function walkAsync(dir) {
+        if (matches.length >= MAX_MATCHES) return;
+        
+        let dirents;
+        try {
+          dirents = await fs.readdir(dir, { withFileTypes: true });
+        } catch (err) {
+          return; // Ignore permission/missing errors gracefully
+        }
+
+        const promises = [];
+        for (const dirent of dirents) {
+          if (matches.length >= MAX_MATCHES) break;
+          
+          if (dirent.isDirectory()) {
+            if (!EXCLUDE_DIRS.has(dirent.name)) {
+              promises.push(walkAsync(path.join(dir, dirent.name)));
+            }
+          } else if (dirent.isFile()) {
+            scanned++;
+            if (isMatch(dirent.name, keywords, extensions, fuzzyMatch)) {
+              matches.push(path.join(dir, dirent.name));
+            }
+          }
+        }
+        await Promise.all(promises);
+      }
+
+      await walkAsync(targetDir);
+      
+      return { 
+        success: true, 
+        output: JSON.stringify({
+          scanned_files: scanned,
+          total_matches: matches.length,
+          matches: matches.length > 0 ? matches : "No files matched your semantic parameters."
+        }, null, 2)
+      };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/fsList.js

@@ -0,0 +1,77 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+// Phase 2 AGI Upgrade: Tree-Map Algorithm with Depth Limiting
+async function generateTree(dirPath, currentDepth, maxDepth, prefix = '') {
+  if (currentDepth > maxDepth) return '';
+
+  let treeStr = '';
+  try {
+    const items = await fs.readdir(dirPath, { withFileTypes: true });
+    
+    // Sort directories first
+    items.sort((a, b) => {
+      if (a.isDirectory() === b.isDirectory()) return a.name.localeCompare(b.name);
+      return a.isDirectory() ? -1 : 1;
+    });
+
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      // AGI Optimization: Aggressively ignore massive hidden folders
+      if (item.name === 'node_modules' || item.name === '.git' || item.name === '.gradle') {
+        continue; 
+      }
+
+      const isLast = i === items.length - 1;
+      const marker = isLast ? '└── ' : '├── ';
+      const newPrefix = prefix + (isLast ? '    ' : '│   ');
+      
+      let metadata = '';
+      if (!item.isDirectory()) {
+        try {
+          const stats = await fs.stat(path.join(dirPath, item.name));
+          const sizeKb = Math.round(stats.size / 1024);
+          metadata = ` (${sizeKb}KB)`;
+        } catch (e) {}
+      }
+
+      treeStr += `${prefix}${marker}${item.name}${item.isDirectory() ? '/' : ''}${metadata}\n`;
+
+      if (item.isDirectory()) {
+        treeStr += await generateTree(path.join(dirPath, item.name), currentDepth + 1, maxDepth, newPrefix);
+      }
+    }
+  } catch (e) {
+    treeStr += `${prefix}└── [Access Denied]\n`;
+  }
+  return treeStr;
+}
+
+export const fsList = {
+  schema: {
+    name: 'fs.list',
+    description: 'List directory contents as an interactive Tree-Map. Gives spatial awareness of a project layout.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Directory to list' },
+        depth: { type: 'number', description: 'Recursion depth (default 2)' }
+      },
+      required: ['path']
+    }
+  },
+  async execute(args) {
+    try {
+      const target = args.path.replace(/^~\//, os.homedir() + '/');
+      const maxDepth = args.depth || 2;
+      
+      const tree = await generateTree(target, 1, maxDepth);
+      const header = `📁 ${target}\n`;
+      
+      return { success: true, output: header + (tree || '  (Empty or access denied)') };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/fsMove.js

@@ -0,0 +1,57 @@
+import fs from 'fs/promises';
+import { createReadStream, createWriteStream } from 'fs';
+import { pipeline } from 'stream/promises';
+import os from 'os';
+
+export const fsMove = {
+  schema: {
+    name: 'fs.move',
+    description: 'Move or rename a file/directory atomically. Safely handles cross-partition (EXDEV) moves without crashing.',
+    parameters: {
+      type: 'object',
+      properties: {
+        source: { type: 'string' },
+        destination: { type: 'string' },
+        overwrite: { type: 'boolean' }
+      },
+      required: ['source', 'destination']
+    }
+  },
+  async execute(args) {
+    try {
+      const src = args.source.replace(/^~\//, os.homedir() + '/');
+      const dest = args.destination.replace(/^~\//, os.homedir() + '/');
+      
+      if (!args.overwrite) {
+        try {
+          await fs.access(dest);
+          return { success: false, error: 'Destination already exists and overwrite is false.' };
+        } catch (e) { /* dest does not exist, safe */ }
+      }
+      
+      // Phase 4 AGI Upgrade: EXDEV Safe Rename
+      try {
+        await fs.rename(src, dest);
+      } catch (err) {
+        if (err.code === 'EXDEV') {
+          // Cross-device link error (different partitions) - Use stream copy then unlink
+          const stat = await fs.stat(src);
+          if (stat.isDirectory()) {
+            return { success: false, error: "Cannot atomically move entire directories across partitions yet. Please compress, move, and extract." };
+          }
+          await pipeline(
+            createReadStream(src),
+            createWriteStream(dest)
+          );
+          await fs.unlink(src);
+        } else {
+          throw err;
+        }
+      }
+      
+      return { success: true, output: `Atomically moved ${args.source} to ${args.destination}` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/fsRead.js

@@ -0,0 +1,87 @@
+import fs from 'fs';
+import readline from 'readline';
+import path from 'path';
+import os from 'os';
+
+// Phase 3 AGI Upgrade: Fast Binary Detection
+async function isBinary(filePath) {
+  try {
+    const fd = await fs.promises.open(filePath, 'r');
+    const buffer = Buffer.alloc(1024);
+    const { bytesRead } = await fd.read(buffer, 0, 1024, 0);
+    await fd.close();
+
+    for (let i = 0; i < bytesRead; i++) {
+      if (buffer[i] === 0) return true; // Null byte indicates binary
+    }
+    return false;
+  } catch (e) {
+    return false;
+  }
+}
+
+export const fsRead = {
+  schema: {
+    name: 'fs.read',
+    description: 'Read file contents intelligently. Automatically pages large files to protect Context Window.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string' },
+        startLine: { type: 'number' },
+        endLine: { type: 'number' }
+      },
+      required: ['path']
+    }
+  },
+  async execute(args) {
+    try {
+      const target = args.path.replace(/^~\//, os.homedir() + '/');
+
+      if (!fs.existsSync(target)) {
+        return { success: false, error: "File does not exist." };
+      }
+
+      // Phase 3 AGI Upgrade: Binary Rejection
+      if (await isBinary(target)) {
+        return { success: false, error: "Cannot read binary file as text. Use viewImage or OCR tools instead." };
+      }
+
+      const start = args.startLine ? Math.max(1, args.startLine) : 1;
+      let end = args.endLine ? args.endLine : start + 799;
+
+      // Phase 3 AGI Upgrade: Mandatory Paging Limit (800)
+      if (end - start + 1 > 800) {
+        end = start + 799;
+      }
+
+      let currentLine = 1;
+      let outputLines = [];
+      let totalLines = 0;
+
+      // Phase 3 AGI Upgrade: Stream (no full buffering)
+      const rl = readline.createInterface({
+        input: fs.createReadStream(target),
+        crlfDelay: Infinity
+      });
+
+      for await (const line of rl) {
+        totalLines++;
+        if (currentLine >= start && currentLine <= end) {
+          outputLines.push(line);
+        }
+        currentLine++;
+      }
+
+      let finalOutput = outputLines.join('\n');
+
+      if (totalLines > end) {
+        finalOutput += `\n\n[WARNING: File truncated at line ${end} out of ${totalLines}. Use { startLine: ${end + 1}, endLine: ${end + 800} } to read more.]`;
+      }
+
+      return { success: true, output: finalOutput };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/fsSearch.js

@@ -0,0 +1,198 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+// Text search across a directory tree.
+//
+// The previous implementation had four problems that only show up on a real
+// repository (finding D-13):
+//
+//   1. It recursed without tracking realpaths, so a symlink pointing at an
+//      ancestor sent it round forever.
+//   2. It read every candidate file whole into memory with no size cap — one
+
+//   3. It decided "binary" from a fixed list of nine extensions, so `.woff2`,
+//      `.mp4`, `.class`, `.pdf` and every unknown format were parsed as text.
+//   4. It excluded exactly five directory names, ignoring `.gitignore`, so it
+//      spent most of its time inside build output the user never wanted.
+//
+// And when it found nothing it said "No matches found. (Semantic Search module
+// pending activation)" — advertising a module that was two comment lines. That
+// sentence is gone: the tool now reports only what it actually did.
+
+const DEFAULT_EXCLUDES = [
+  'node_modules', '.git', '.hg', '.svn', 'dist', 'build', 'out', 'target',
+  '.gradle', '.idea', '.vscode', '.next', '.nuxt', '.cache', '__pycache__',
+  'venv', '.venv', 'vendor', 'Pods', 'DerivedData', 'coverage', '.terraform'
+];
+
+// Above this, a file is treated as data rather than source. Large minified
+// bundles and lockfiles are the common case and are rarely what a search is for.
+const MAX_FILE_BYTES = 2 * 1024 * 1024;
+
+// A NUL byte in the first block is the standard binary heuristic — the same one
+// grep uses. It is content-based, so it works for formats nobody listed.
+const SNIFF_BYTES = 8192;
+
+const DEFAULT_MAX_RESULTS = 100;
+
+/** Turn a .gitignore into a matcher. Deliberately simple: names and globs. */
+async function loadIgnorePatterns(root) {
+  const patterns = [];
+  try {
+    const raw = await fs.readFile(path.join(root, '.gitignore'), 'utf8');
+    for (const line of raw.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('!')) continue;
+      patterns.push(trimmed.replace(/^\/+|\/+$/g, ''));
+    }
+  } catch (e) { /* no .gitignore is the normal case outside a repo */ }
+  return patterns;
+}
+
+function isIgnored(name, patterns) {
+  for (const pattern of patterns) {
+    if (pattern === name) return true;
+    // Only the two glob shapes that actually appear in most .gitignore files.
+    if (pattern.startsWith('*') && name.endsWith(pattern.slice(1))) return true;
+    if (pattern.endsWith('*') && name.startsWith(pattern.slice(0, -1))) return true;
+  }
+  return false;
+}
+
+/**
+ * Walk a tree, yielding file paths.
+ *
+ * `seen` holds the realpath of every directory already entered, which is what
+ * stops a symlink cycle: `a/link -> ..` resolves to a directory already in the
+ * set and is skipped rather than followed forever.
+ */
+async function* walk(dir, excludes, ignorePatterns, seen) {
+  let real;
+  try {
+    real = await fs.realpath(dir);
+  } catch (e) {
+    return;
+  }
+  if (seen.has(real)) return;
+  seen.add(real);
+
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch (e) {
+    return; // unreadable directory: skip it, do not fail the whole search
+  }
+
+  for (const entry of entries) {
+    if (excludes.includes(entry.name) || isIgnored(entry.name, ignorePatterns)) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      yield* walk(full, excludes, ignorePatterns, seen);
+    } else if (entry.isFile()) {
+      yield full;
+    } else if (entry.isSymbolicLink()) {
+      // Resolve once and classify; the `seen` set handles a directory cycle.
+      try {
+        const stat = await fs.stat(full);
+        if (stat.isDirectory()) yield* walk(full, excludes, ignorePatterns, seen);
+        else if (stat.isFile()) yield full;
+      } catch (e) { /* broken link */ }
+    }
+  }
+}
+
+/** True when the first block contains a NUL byte. */
+async function looksBinary(filePath) {
+  let handle;
+  try {
+    handle = await fs.open(filePath, 'r');
+    const buffer = Buffer.alloc(SNIFF_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, SNIFF_BYTES, 0);
+    return buffer.subarray(0, bytesRead).includes(0);
+  } catch (e) {
+    return true; // unreadable: treat as not searchable
+  } finally {
+    if (handle) await handle.close().catch(() => {});
+  }
+}
+
+export const fsSearch = {
+  schema: {
+    name: 'fs.search',
+    description: 'Search for text across files in a directory tree. Skips ignored and build directories, binary files, and files larger than 2 MB.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Text or regular expression to find.' },
+        path: { type: 'string', description: 'Directory to search in. Defaults to the working directory.' },
+        isRegex: { type: 'boolean', description: 'Treat the query as a regular expression.' },
+        maxResults: { type: 'integer', description: `Stop after this many matching lines. Defaults to ${DEFAULT_MAX_RESULTS}.` }
+      },
+      required: ['query']
+    }
+  },
+
+  async execute(args) {
+    try {
+      const searchPath = args.path || process.cwd();
+      const maxResults = Number.isInteger(args.maxResults) && args.maxResults > 0
+        ? Math.min(args.maxResults, 1000)
+        : DEFAULT_MAX_RESULTS;
+
+      let regex;
+      try {
+        regex = args.isRegex
+          ? new RegExp(args.query)
+          : new RegExp(args.query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+      } catch (e) {
+        return { success: false, error: 'Invalid regular expression: ' + e.message };
+      }
+
+      const ignorePatterns = await loadIgnorePatterns(searchPath);
+      const results = [];
+      let filesScanned = 0;
+      let filesSkipped = 0;
+      let truncated = false;
+
+      for await (const file of walk(searchPath, DEFAULT_EXCLUDES, ignorePatterns, new Set())) {
+        if (results.length >= maxResults) { truncated = true; break; }
+
+        let stat;
+        try {
+          stat = await fs.stat(file);
+        } catch (e) { continue; }
+        if (stat.size > MAX_FILE_BYTES) { filesSkipped++; continue; }
+        if (await looksBinary(file)) { filesSkipped++; continue; }
+
+        let content;
+        try {
+          content = await fs.readFile(file, 'utf8');
+        } catch (e) { continue; }
+        filesScanned++;
+
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+          if (!regex.test(lines[i])) continue;
+          results.push(`${file}:${i + 1}:${lines[i].trim().slice(0, 300)}`);
+          if (results.length >= maxResults) { truncated = true; break; }
+        }
+      }
+
+      if (results.length === 0) {
+        return {
+          success: true,
+          output: `No matches found. Scanned ${filesScanned} files under ${searchPath}` +
+                  (filesSkipped > 0 ? `; skipped ${filesSkipped} binary or oversized files.` : '.')
+        };
+      }
+
+      return {
+        success: true,
+        output: results.join('\n') +
+                (truncated ? `\n\n[stopped at ${maxResults} matches — narrow the query or raise maxResults]` : '')
+      };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/fsWrite.js

@@ -0,0 +1,41 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+export const fsWrite = {
+  schema: {
+    name: 'fs.write',
+    description: 'Create or overwrite a file with content using Zero-Corruption Atomic Swap. Guarantees safe file writing.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string' },
+        content: { type: 'string' },
+        createDirectories: { type: 'boolean' }
+      },
+      required: ['path', 'content']
+    }
+  },
+  async execute(args) {
+    try {
+      const target = args.path.replace(/^~\//, os.homedir() + '/');
+      
+      if (args.createDirectories !== false) {
+        await fs.mkdir(path.dirname(target), { recursive: true });
+      }
+
+      // Phase 4 AGI Upgrade: Atomic File Swap
+      // Prevent zero-byte file corruption if Node crashes during a huge write.
+      const tempPath = `${target}.causyne_tmp_${Date.now()}`;
+      
+      await fs.writeFile(tempPath, args.content, 'utf8');
+      
+      // Atomic rename (POSIX standard guarantee)
+      await fs.rename(tempPath, target);
+      
+      return { success: true, output: `Atomically wrote ${Buffer.byteLength(args.content, 'utf8')} bytes to ${args.path}` };
+    } catch (e) {
+      return { success: false, error: `Atomic Write Failed: ${e.message}` };
+    }
+  }
+};