brains-cli 0.1.0 → 1.0.2

package/src/utils/files.js

@@ -0,0 +1,239 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Extensions to include when scanning for review
+const SOURCE_EXTENSIONS = new Set([
+  '.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs',
+  '.py', '.rb', '.go', '.rs', '.java', '.kt',
+  '.c', '.cpp', '.h', '.hpp', '.cs',
+  '.php', '.swift', '.dart',
+  '.vue', '.svelte', '.astro',
+  '.css', '.scss', '.less',
+  '.html', '.htm',
+  '.json', '.yaml', '.yml', '.toml',
+  '.sql', '.graphql', '.gql',
+  '.sh', '.bash', '.zsh',
+  '.md', '.mdx',
+  '.prisma', '.proto',
+  '.env.example', '.env.local.example',
+  'Dockerfile', 'docker-compose.yml',
+]);
+
+// Directories to always skip
+const IGNORE_DIRS = new Set([
+  'node_modules', '.git', '.next', '.nuxt', '.svelte-kit',
+  'dist', 'build', 'out', '.output',
+  'coverage', '.nyc_output',
+  '__pycache__', '.pytest_cache', 'venv', '.venv',
+  'vendor', 'target',
+  '.cache', '.parcel-cache', '.turbo',
+  '.brains',
+]);
+
+// Files to always skip
+const IGNORE_FILES = new Set([
+  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
+  '.DS_Store', 'Thumbs.db',
+]);
+
+const MAX_FILE_SIZE = 100 * 1024; // 100KB per file
+const MAX_TOTAL_SIZE = 500 * 1024; // 500KB total to send to Claude
+
+/**
+ * Recursively scan a directory for source files.
+ * Respects .gitignore patterns (basic) and built-in ignore lists.
+ */
+function scanSourceFiles(dir, maxFiles = 50) {
+  const files = [];
+
+  function walk(currentDir, depth) {
+    if (depth > 8 || files.length >= maxFiles) return;
+
+    let entries;
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch (e) {
+      return; // permission denied, etc.
+    }
+
+    for (const entry of entries) {
+      if (files.length >= maxFiles) break;
+
+      if (entry.isDirectory()) {
+        if (!IGNORE_DIRS.has(entry.name) && !entry.name.startsWith('.')) {
+          walk(path.join(currentDir, entry.name), depth + 1);
+        }
+      } else if (entry.isFile()) {
+        if (IGNORE_FILES.has(entry.name)) continue;
+
+        const ext = path.extname(entry.name);
+        const isSourceFile = SOURCE_EXTENSIONS.has(ext) ||
+          SOURCE_EXTENSIONS.has(entry.name) ||
+          (!ext && entry.name === 'Makefile') ||
+          (!ext && entry.name === 'Dockerfile');
+
+        if (isSourceFile) {
+          const fullPath = path.join(currentDir, entry.name);
+          try {
+            const stat = fs.statSync(fullPath);
+            if (stat.size <= MAX_FILE_SIZE && stat.size > 0) {
+              files.push({
+                path: path.relative(dir, fullPath).replace(/\\/g, '/'),
+                fullPath,
+                size: stat.size,
+              });
+            }
+          } catch (e) {
+            // skip unreadable files
+          }
+        }
+      }
+    }
+  }
+
+  walk(dir, 0);
+  return files;
+}
+
+/**
+ * Read scanned files and format them for Claude review.
+ * Returns { content: string, fileCount: number, totalSize: number }
+ */
+function readFilesForReview(dir, maxFiles = 50) {
+  const files = scanSourceFiles(dir, maxFiles);
+
+  let totalSize = 0;
+  const parts = [];
+
+  for (const file of files) {
+    if (totalSize >= MAX_TOTAL_SIZE) break;
+
+    try {
+      const content = fs.readFileSync(file.fullPath, 'utf-8');
+      totalSize += content.length;
+      parts.push(`### ${file.path}\n\`\`\`\n${content}\n\`\`\``);
+    } catch (e) {
+      // skip unreadable
+    }
+  }
+
+  return {
+    content: parts.join('\n\n'),
+    fileCount: parts.length,
+    totalSize,
+    files: files.map((f) => f.path),
+  };
+}
+
+/**
+ * Parse Claude's response for FILE: blocks and extract file contents.
+ * Supports formats:
+ *   FILE: path/to/file.ext
+ *   ```lang
+ *   content
+ *   ```
+ *
+ * Returns array of { filePath, content, language }
+ */
+function parseFileBlocks(response) {
+  const files = [];
+  const regex = /FILE:\s*(.+?)\s*\n```(\w*)\n([\s\S]*?)```/g;
+
+  let match;
+  while ((match = regex.exec(response)) !== null) {
+    files.push({
+      filePath: match[1].trim(),
+      language: match[2] || '',
+      content: match[3],
+    });
+  }
+
+  // Fallback: try to find ```lang:filepath patterns
+  if (files.length === 0) {
+    const altRegex = /```(\w+):(.+?)\n([\s\S]*?)```/g;
+    while ((match = altRegex.exec(response)) !== null) {
+      files.push({
+        filePath: match[2].trim(),
+        language: match[1] || '',
+        content: match[3],
+      });
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Write parsed file blocks to disk.
+ * Creates directories as needed.
+ * Returns { written: string[], errors: string[] }
+ */
+function writeFileBlocks(baseDir, fileBlocks) {
+  const written = [];
+  const errors = [];
+
+  for (const block of fileBlocks) {
+    const fullPath = path.join(baseDir, block.filePath);
+    const dir = path.dirname(fullPath);
+
+    try {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(fullPath, block.content);
+      written.push(block.filePath);
+    } catch (e) {
+      errors.push(`${block.filePath}: ${e.message}`);
+    }
+  }
+
+  return { written, errors };
+}
+
+/**
+ * Generate a tree view of written files.
+ */
+function generateTreeView(files, rootName) {
+  if (files.length === 0) return '';
+
+  const lines = [`${rootName}/`];
+
+  // Build a tree structure
+  const tree = {};
+  for (const file of files) {
+    const parts = file.split('/');
+    let current = tree;
+    for (const part of parts) {
+      if (!current[part]) current[part] = {};
+      current = current[part];
+    }
+  }
+
+  function render(node, prefix, isLast) {
+    const entries = Object.entries(node);
+    entries.forEach(([name, children], i) => {
+      const last = i === entries.length - 1;
+      const connector = last ? '└── ' : '├── ';
+      const childPrefix = last ? '    ' : '│   ';
+      const isDir = Object.keys(children).length > 0;
+
+      lines.push(`${prefix}${connector}${name}${isDir ? '/' : ''}`);
+      if (isDir) {
+        render(children, prefix + childPrefix, last);
+      }
+    });
+  }
+
+  render(tree, '', false);
+  return lines.join('\n');
+}
+
+module.exports = {
+  scanSourceFiles,
+  readFilesForReview,
+  parseFileBlocks,
+  writeFileBlocks,
+  generateTreeView,
+};