shoud-cli 1.0.11 → 3.0.2

package/src/security/riskClassifier.js

@@ -0,0 +1,127 @@
+const { parseShell } = require('./shellParser');
+
+const Risk = Object.freeze({
+  READ: 0,
+  PROJECT_LOCAL: 1,
+  LOCAL_MODIFICATION: 2,
+  EXTERNAL: 3,
+  DESTRUCTIVE: 4,
+});
+
+const READ_BINARIES = new Set([
+  'cat','ls','pwd','find','grep','rg','head','tail','wc','file','stat',
+  'git','npm','pnpm','yarn','node','python','python3','which','echo','env','printenv',
+]);
+const PROJECT_BINARIES = new Set([
+  'eslint','tsc','vitest','jest','mocha','pytest','cargo','go','make','gradle','mvn',
+]);
+
+const DESTRUCTIVE_PATTERNS = [
+  /\brm\s+(-[a-zA-Z]*[rf][a-zA-Z]*\s+)?\//,       // rm -rf /
+  /\bsudo\b/,
+  /\bchmod\s+777\b/,
+  /\bchown\s+-R\b/,
+  /\bgit\s+reset\s+--hard\b/,
+  /\bgit\s+clean\s+-[a-z]*f/,
+  /\bgit\s+push\s+--force\b/,
+  /\bgit\s+push\s+-f\b/,
+  /DROP\s+(TABLE|DATABASE)/i,
+  /TRUNCATE\s+TABLE/i,
+  /\bterraform\s+destroy\b/,
+  /\bkubectl\s+delete\b/,
+  /:\(\)\s*\{.*\};:/,                              // fork bomb
+  /\bmkfs\b/,
+  /\bdd\s+if=/,
+  />\s*\/dev\/sd[a-z]/,
+];
+
+const EXTERNAL_PATTERNS = [
+  /\bcurl\b/, /\bwget\b/, /\bnc\b/, /\bssh\b/, /\bscp\b/,
+  /\bgit\s+(commit|push|pull|fetch|clone|remote)\b/,
+  /\bnpm\s+publish\b/, /\bdocker\b/, /\bkubectl\b/, /\bterraform\b/,
+  /\baws\b/, /\bgcloud\b/, /\baz\b/,
+  /\|\s*(sh|bash|zsh)\b/,        // pipe to shell — very dangerous
+];
+
+const LOCAL_MOD_PATTERNS = [
+  /\bnpm\s+(install|i|uninstall)\b/,
+  /\bpnpm\s+(add|install|remove)\b/,
+  /\byarn\s+(add|remove)\b/,
+  /\bgit\s+(add|rm|mv|checkout|switch|stash)\b/,
+  /\bmv\b/, /\bcp\b/, /\bmkdir\b/, /\btouch\b/,
+];
+
+function classifyCommand(commandStr) {
+  const parsed = parseShell(commandStr);
+  let maxRisk = Risk.READ;
+  const reasons = [];
+
+  for (const seg of parsed.segments) {
+    const cmd = seg.command;
+    const first = (cmd.match(/^[\w./-]+/) || [''])[0];
+    const binary = first.split('/').pop();
+
+    // 1. Destructive
+    if (DESTRUCTIVE_PATTERNS.some(re => re.test(cmd))) {
+      maxRisk = Math.max(maxRisk, Risk.DESTRUCTIVE);
+      reasons.push(`destructive pattern: ${cmd.slice(0, 60)}`);
+      continue;
+    }
+
+    // 2. External
+    if (EXTERNAL_PATTERNS.some(re => re.test(cmd))) {
+      maxRisk = Math.max(maxRisk, Risk.EXTERNAL);
+      reasons.push(`external effect: ${cmd.slice(0, 60)}`);
+      continue;
+    }
+
+    // 3. Local modification
+    if (LOCAL_MOD_PATTERNS.some(re => re.test(cmd))) {
+      maxRisk = Math.max(maxRisk, Risk.LOCAL_MODIFICATION);
+      reasons.push(`local modification: ${cmd.slice(0, 60)}`);
+      continue;
+    }
+
+    // 4. Project-local tools
+    if (PROJECT_BINARIES.has(binary)) {
+      maxRisk = Math.max(maxRisk, Risk.PROJECT_LOCAL);
+      continue;
+    }
+
+    // 5. Read-only binaries
+    if (READ_BINARIES.has(binary)) {
+      maxRisk = Math.max(maxRisk, Risk.READ);
+      continue;
+    }
+
+    // 6. Unknown → treat as project-local at minimum
+    maxRisk = Math.max(maxRisk, Risk.PROJECT_LOCAL);
+    reasons.push(`unknown binary: ${binary}`);
+  }
+
+  // Elevate risk for structural hazards
+  if (parsed.hasSubshell) {
+    maxRisk = Math.max(maxRisk, Risk.LOCAL_MODIFICATION);
+    reasons.push('subshell detected');
+  }
+  if (parsed.hasRedirect) {
+    maxRisk = Math.max(maxRisk, Risk.LOCAL_MODIFICATION);
+    reasons.push('output redirection');
+  }
+  if (parsed.segments.length > 1) {
+    // Compound commands: take the max, already done, but flag
+    reasons.push(`compound command (${parsed.segments.length} segments)`);
+  }
+
+  return { risk: maxRisk, reasons, segments: parsed.segments.length };
+}
+
+const RiskLabel = {
+  [Risk.READ]: 'READ',
+  [Risk.PROJECT_LOCAL]: 'PROJECT',
+  [Risk.LOCAL_MODIFICATION]: 'MODIFY',
+  [Risk.EXTERNAL]: 'EXTERNAL',
+  [Risk.DESTRUCTIVE]: 'DESTRUCTIVE',
+};
+
+module.exports = { Risk, RiskLabel, classifyCommand };

package/src/security/secrets.js

@@ -0,0 +1,57 @@
+/**
+ * Scans text for likely secrets and returns redacted version.
+ * Conservative — better to over-redact than leak.
+ */
+const PATTERNS = [
+  // OpenAI / Anthropic / generic API keys
+  { re: /\b(sk-[A-Za-z0-9_-]{20,})\b/g, sub: 'sk-[REDACTED]' },
+  { re: /\b(sk-ant-[A-Za-z0-9_-]{20,})\b/g, sub: 'sk-ant-[REDACTED]' },
+  // AWS
+  { re: /\b(AKIA[0-9A-Z]{16})\b/g, sub: 'AKIA[REDACTED]' },
+  { re: /(aws_secret_access_key\s*[=:]\s*)([A-Za-z0-9+/=]{40})/gi, sub: '$1[REDACTED]' },
+  // GitHub
+  { re: /\b(gh[pousr]_[A-Za-z0-9]{36,})\b/g, sub: 'gh[REDACTED]' },
+  // JWTs (standalone)
+  { re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, sub: '[JWT REDACTED]' },
+  // Private keys
+  { re: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, sub: '[PRIVATE KEY REDACTED]' },
+  // Generic key=value for suspicious names
+  { re: /((?:api[_-]?key|secret|token|password|passwd|pwd)\s*[=:]\s*)(["']?)([^\s"'#]{6,})\2/gi, sub: '$1$2[REDACTED]$2' },
+  // .env-style
+  { re: /^([A-Z0-9_]*(?:KEY|SECRET|TOKEN|PASSWORD|PWD)[A-Z0-9_]*=)(.+)$/gm, sub: '$1[REDACTED]' },
+  // DB URLs
+  { re: /(postgres|mysql|mongodb|redis):\/\/[^\s]+/gi, sub: '$1://[REDACTED]' },
+];
+
+function redact(text) {
+  if (typeof text !== 'string') return text;
+  let out = text;
+  let redactions = 0;
+  for (const { re, sub } of PATTERNS) {
+    out = out.replace(re, (...args) => {
+      redactions++;
+      return typeof sub === 'function' ? sub(...args) : sub;
+    });
+  }
+  return { text: out, redactions };
+}
+
+function redactDeep(value) {
+  if (typeof value === 'string') return redact(value).text;
+  if (Array.isArray(value)) return value.map(redactDeep);
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      // Redact by key name too
+      if (/key|secret|token|password|pwd/i.test(k) && typeof v === 'string') {
+        out[k] = '[REDACTED]';
+      } else {
+        out[k] = redactDeep(v);
+      }
+    }
+    return out;
+  }
+  return value;
+}
+
+module.exports = { redact, redactDeep };

package/src/security/shellParser.js

@@ -0,0 +1,56 @@
+/**
+ * Splits a shell command line into "segments" that would each be executed.
+ * Detects compound operators: && || ; | $(...) `...` > >> < 
+ *
+ * Returns { segments: [{command, operator}], hasSubshell, hasRedirect }
+ */
+function parseShell(input) {
+  const segments = [];
+  let current = '';
+  let depth = 0;         // inside $( ) or ``
+  let quote = null;      // ' or "
+  let hasSubshell = false;
+  let hasRedirect = false;
+
+  const push = (op) => {
+    const trimmed = current.trim();
+    if (trimmed) segments.push({ command: trimmed, operator: op });
+    current = '';
+  };
+
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+    const next = input[i + 1];
+
+    if (quote) {
+      current += c;
+      if (c === quote) quote = null;
+      continue;
+    }
+    if (c === '"' || c === "'") { quote = c; current += c; continue; }
+    if (c === '$' && next === '(') { depth++; hasSubshell = true; current += c; continue; }
+    if (c === '`') { hasSubshell = true; current += c; continue; }
+    if (c === ')' && depth > 0) { depth--; current += c; continue; }
+
+    if (depth === 0) {
+      if (c === '&' && next === '&') { push('&&'); i++; continue; }
+      if (c === '|' && next === '|') { push('||'); i++; continue; }
+      if (c === ';') { push(';'); continue; }
+      if (c === '|') { push('|'); continue; }
+      if (c === '>' || c === '<') {
+        hasRedirect = true;
+        // collect redirect target
+        let redir = c;
+        while (input[i + 1] === '>' || input[i + 1] === '&') { redir += input[i + 1]; i++; }
+        push(redir);
+        continue;
+      }
+    }
+    current += c;
+  }
+  push(null);
+
+  return { segments, hasSubshell, hasRedirect };
+}
+
+module.exports = { parseShell };

package/src/tools/files.js

@@ -0,0 +1,81 @@
+const fs = require('fs');
+const path = require('path');
+const diff = require('diff');
+const { isIgnored, loadIgnore } = require('../project/ignore');
+
+const MAX_READ_BYTES = 2 * 1024 * 1024;
+
+function sanitizePath(projectRoot, inputPath) {
+  const resolved = path.resolve(projectRoot, inputPath);
+  const rel = path.relative(projectRoot, resolved);
+  if (rel.startsWith('..') || path.isAbsolute(rel)) {
+    throw new Error(`Path escapes project root: ${inputPath}`);
+  }
+  return resolved;
+}
+
+function readFile(projectRoot, filePath, { startLine, endLine } = {}) {
+  const full = sanitizePath(projectRoot, filePath);
+  const ig = loadIgnore(projectRoot);
+  if (isIgnored(projectRoot, full, ig)) {
+    throw new Error(`Path is .shoudignore'd: ${filePath}`);
+  }
+  const stat = fs.statSync(full);
+  if (!stat.isFile()) throw new Error('Not a file.');
+
+  if (startLine || endLine) {
+    const lines = fs.readFileSync(full, 'utf-8').split('\n');
+    const s = Math.max(0, (startLine || 1) - 1);
+    const e = Math.min(lines.length, endLine || lines.length);
+    return {
+      content: lines.slice(s, e).map((l, i) => `${s + i + 1}\t${l}`).join('\n'),
+      totalLines: lines.length,
+      from: s + 1,
+      to: e,
+    };
+  }
+
+  if (stat.size > MAX_READ_BYTES) {
+    const buf = Buffer.alloc(MAX_READ_BYTES);
+    const fd = fs.openSync(full, 'r');
+    fs.readSync(fd, buf, 0, MAX_READ_BYTES, 0);
+    fs.closeSync(fd);
+    return { content: buf.toString('utf-8') + '\n... [truncated at 2MB]', truncated: true };
+  }
+  return { content: fs.readFileSync(full, 'utf-8') };
+}
+
+function writeFile(projectRoot, filePath, content) {
+  const full = sanitizePath(projectRoot, filePath);
+  const ig = loadIgnore(projectRoot);
+  if (isIgnored(projectRoot, full, ig)) {
+    throw new Error(`Path is .shoudignore'd: ${filePath}`);
+  }
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, content, 'utf-8');
+  return { ok: true, path: filePath, bytes: Buffer.byteLength(content) };
+}
+
+/**
+ * apply_patch: replace a specific old snippet with a new one.
+ * Fails if `oldText` is not found exactly once (safety).
+ */
+function applyPatch(projectRoot, filePath, oldText, newText) {
+  const full = sanitizePath(projectRoot, filePath);
+  const ig = loadIgnore(projectRoot);
+  if (isIgnored(projectRoot, full, ig)) throw new Error(`Path is .shoudignore'd: ${filePath}`);
+  if (!fs.existsSync(full)) throw new Error(`File not found: ${filePath}`);
+
+  const original = fs.readFileSync(full, 'utf-8');
+  const occurrences = original.split(oldText).length - 1;
+  if (occurrences === 0) throw new Error('old_text not found in file.');
+  if (occurrences > 1) throw new Error(`old_text is ambiguous (${occurrences} matches). Provide more context.`);
+
+  const updated = original.replace(oldText, newText);
+  fs.writeFileSync(full, updated, 'utf-8');
+
+  const patch = diff.createPatch(filePath, original, updated, 'before', 'after');
+  return { ok: true, path: filePath, patch };
+}
+
+module.exports = { readFile, writeFile, applyPatch, sanitizePath };

package/src/tools/git.js

@@ -0,0 +1,32 @@
+const { execSync } = require('child_process');
+
+function run(cwd, cmd) {
+  try { return { ok: true, out: execSync(cmd, { cwd, encoding: 'utf-8', stdio: 'pipe' }).trim() }; }
+  catch (err) { return { ok: false, out: (err.stdout || '').toString().trim(), err: (err.stderr || '').toString().trim() }; }
+}
+
+function gitStatus(cwd) {
+  const s = run(cwd, 'git status --porcelain');
+  const branch = run(cwd, 'git rev-parse --abbrev-ref HEAD');
+  return {
+    branch: branch.ok ? branch.out : null,
+    dirty: s.ok && s.out.length > 0,
+    entries: s.ok ? s.out.split('\n').filter(Boolean).map(l => ({
+      status: l.slice(0, 2).trim(),
+      path: l.slice(3),
+    })) : [],
+  };
+}
+
+function gitDiff(cwd, { staged = false, path: p } = {}) {
+  const cmd = `git diff ${staged ? '--staged' : ''} ${p || ''}`.trim();
+  const r = run(cwd, cmd);
+  return { diff: r.out };
+}
+
+function gitLog(cwd, { limit = 10 } = {}) {
+  const r = run(cwd, `git log --oneline -n ${limit}`);
+  return { log: r.out };
+}
+
+module.exports = { gitStatus, gitDiff, gitLog };

package/src/tools/index.js

@@ -1,171 +1,107 @@
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
+const { runShell } = require('./shell');
+const { readFile, writeFile, applyPatch } = require('./files');
+const { listDirectory, searchFiles, searchText } = require('./search');
+const { gitStatus, gitDiff, gitLog } = require('./git');
+const { projectInfo } = require('./project');
 
-const MAX_OUTPUT_SIZE = 1024 * 1024;
-const PROJECT_ROOT = process.cwd();
+/**
+ * Tool registry. Each entry:
+ *   { name, description, input_schema, handler(ctx, input) }
+ * `ctx` = { projectRoot, onOutput, timeout }
+ */
+const TOOLS = {
+  execute_shell: {
+    description: 'Run a shell command in the project directory.',
+    input: { command: 'string', timeout_ms: 'optional number' },
+    async handler(ctx, input) {
+      const timeout = input.timeout_ms || ctx.timeout || 60000;
+      return await runShell(input.command, {
+        cwd: ctx.projectRoot,
+        timeout,
+        onOutput: ctx.onOutput,
+      });
+    },
+  },
 
-function getShell() {
-  if (os.platform() === 'win32') {
-    return 'powershell.exe';
-  }
-  return '/bin/bash';
-}
+  read_file: {
+    description: 'Read a file. Optionally specify a line range.',
+    input: { path: 'string', start_line: 'optional number', end_line: 'optional number' },
+    async handler(ctx, input) {
+      return readFile(ctx.projectRoot, input.path, {
+        startLine: input.start_line, endLine: input.end_line,
+      });
+    },
+  },
 
-function sanitizePath(inputPath) {
-  const resolved = path.resolve(PROJECT_ROOT, inputPath);
-  if (!resolved.startsWith(PROJECT_ROOT)) {
-    throw new Error('Path is outside the project directory.');
-  }
-  return resolved;
-}
+  write_file: {
+    description: 'Write or overwrite a file with the given content.',
+    input: { path: 'string', content: 'string' },
+    async handler(ctx, input) { return writeFile(ctx.projectRoot, input.path, input.content); },
+  },
 
-/**
- * Execute a shell command and return plain text output.
- * On Windows, we use PowerShell with `Out-String` to get text.
- */
-function executeShell(commandString) {
-  if (!commandString || commandString.trim().length === 0) {
-    throw new Error('Empty command.');
-  }
+  apply_patch: {
+    description: 'Replace a specific old snippet with new content in a file. Fails if old_text is not unique.',
+    input: { path: 'string', old_text: 'string', new_text: 'string' },
+    async handler(ctx, input) {
+      return applyPatch(ctx.projectRoot, input.path, input.old_text, input.new_text);
+    },
+  },
 
-  let finalCommand = commandString;
-  if (os.platform() === 'win32') {
-    // ✅ Force PowerShell to output plain text
-    // Escape double quotes in the command
-    const escaped = commandString.replace(/"/g, '`"');
-    // Wrap in a PowerShell script block and pipe to Out-String
-    finalCommand = `& { ${escaped} } | Out-String -Width 4096`;
-  }
+  list_directory: {
+    description: 'List files in a directory.',
+    input: { path: 'optional string' },
+    async handler(ctx, input) { return listDirectory(ctx.projectRoot, input.path || '.'); },
+  },
 
-  try {
-    const output = execSync(finalCommand, {
-      cwd: PROJECT_ROOT,
-      encoding: 'utf-8',
-      shell: getShell(),
-      timeout: 30000,
-      maxBuffer: MAX_OUTPUT_SIZE,
-      stdio: 'pipe',
-    });
-    const trimmed = output.trim();
-    return trimmed || 'Command executed successfully with no output.';
-  } catch (err) {
-    // If the command fails, return the error message
-    if (err.stderr) {
-      return `Error: ${err.stderr.trim()}`;
-    }
-    if (err.stdout) {
-      // Some commands output to stdout even on failure (e.g., `dir`)
-      return err.stdout.trim();
-    }
-    throw new Error(`Command execution failed: ${err.message}`);
-  }
-}
+  search_files: {
+    description: 'Find files matching a glob pattern.',
+    input: { pattern: 'string' },
+    async handler(ctx, input) { return searchFiles(ctx.projectRoot, input.pattern); },
+  },
 
-function readFile(filePath) {
-  const safePath = sanitizePath(filePath);
-  try {
-    const stats = fs.statSync(safePath);
-    if (!stats.isFile()) throw new Error('Path is not a file.');
-    if (stats.size > MAX_OUTPUT_SIZE) {
-      const buffer = Buffer.alloc(MAX_OUTPUT_SIZE);
-      const fd = fs.openSync(safePath, 'r');
-      fs.readSync(fd, buffer, 0, MAX_OUTPUT_SIZE, 0);
-      fs.closeSync(fd);
-      return buffer.toString('utf-8') + '\n... (file truncated)';
-    }
-    return fs.readFileSync(safePath, 'utf-8');
-  } catch (err) {
-    throw new Error(`Failed to read file: ${err.message}`);
-  }
-}
+  search_text: {
+    description: 'Search file contents for a substring.',
+    input: { query: 'string', glob: 'optional string' },
+    async handler(ctx, input) { return searchText(ctx.projectRoot, input.query, { glob: input.glob }); },
+  },
 
-function writeFile(filePath, content) {
-  const safePath = sanitizePath(filePath);
-  try {
-    const dir = path.dirname(safePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(safePath, content, 'utf-8');
-    return `File written successfully: ${filePath}`;
-  } catch (err) {
-    throw new Error(`Failed to write file: ${err.message}`);
-  }
-}
+  git_status: {
+    description: 'Show git status.',
+    input: {},
+    async handler(ctx) { return gitStatus(ctx.projectRoot); },
+  },
 
-function executeTool(toolName, input) {
-  try {
-    switch (toolName) {
-      case 'execute_shell':
-        return executeShell(input.command);
-      case 'read_file':
-        return readFile(input.path);
-      case 'write_file':
-        return writeFile(input.path, input.content);
-      default:
-        throw new Error(`Tool "${toolName}" is not supported.`);
-    }
-  } catch (error) {
-    return `Tool execution failed: ${error.message}`;
-  }
-}
+  git_diff: {
+    description: 'Show git diff.',
+    input: { staged: 'optional boolean', path: 'optional string' },
+    async handler(ctx, input) { return gitDiff(ctx.projectRoot, input); },
+  },
 
-/**
- * Read an image/video file and return a data URL for Gemini.
- */
-function readImage(filePath) {
-  const safePath = sanitizePath(filePath);
-  try {
-    const stats = fs.statSync(safePath);
-    if (!stats.isFile()) throw new Error('Path is not a file.');
-    const buffer = fs.readFileSync(safePath);
-    const base64 = buffer.toString('base64');
-    const mimeType = getMimeType(safePath); // you need to define this helper
-    return `data:${mimeType};base64,${base64}`;
-  } catch (err) {
-    throw new Error(`Failed to read image: ${err.message}`);
-  }
-}
+  git_log: {
+    description: 'Show recent git commits.',
+    input: { limit: 'optional number' },
+    async handler(ctx, input) { return gitLog(ctx.projectRoot, input); },
+  },
+
+  project_info: {
+    description: 'Describe the project (language, framework, package manager, verification commands).',
+    input: {},
+    async handler(ctx) { return projectInfo(ctx.projectRoot); },
+  },
+};
 
-// Helper: determine MIME type from file extension
-function getMimeType(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  const map = {
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.png': 'image/png',
-    '.gif': 'image/gif',
-    '.webp': 'image/webp',
-    '.mp4': 'video/mp4',
-    '.mov': 'video/quicktime',
-    '.avi': 'video/x-msvideo',
-    '.webm': 'video/webm',
-    '.mkv': 'video/x-matroska',
-    '.pdf': 'application/pdf',
-  };
-  return map[ext] || 'application/octet-stream';
+function toolList() {
+  return Object.entries(TOOLS).map(([name, t]) => ({
+    name,
+    description: t.description,
+    input: t.input,
+  }));
 }
 
-// In executeTool, add:
-function executeTool(toolName, input) {
-  try {
-    switch (toolName) {
-      case 'execute_shell':
-        return executeShell(input.command);
-      case 'read_file':
-        return readFile(input.path);
-      case 'write_file':
-        return writeFile(input.path, input.content);
-      case 'read_image':   // new
-        return readImage(input.path);
-      default:
-        throw new Error(`Tool "${toolName}" is not supported.`);
-    }
-  } catch (error) {
-    return `Tool execution failed: ${error.message}`;
-  }
+async function executeTool(name, ctx, input) {
+  const tool = TOOLS[name];
+  if (!tool) throw new Error(`Unknown tool: ${name}`);
+  return await tool.handler(ctx, input);
 }
 
-module.exports = { executeTool };
+module.exports = { TOOLS, toolList, executeTool };

package/src/tools/project.js

@@ -0,0 +1,7 @@
+const { discoverProject } = require('../project/discovery');
+
+function projectInfo(root) {
+  return discoverProject(root);
+}
+
+module.exports = { projectInfo };

package/src/tools/search.js

@@ -0,0 +1,49 @@
+const fs = require('fs');
+const path = require('path');
+const fg = require('fast-glob');
+const { loadIgnore } = require('../project/ignore');
+
+async function listDirectory(projectRoot, dirPath = '.') {
+  const target = path.resolve(projectRoot, dirPath);
+  const entries = fs.readdirSync(target, { withFileTypes: true });
+  return entries.map(e => ({
+    name: e.name,
+    type: e.isDirectory() ? 'dir' : 'file',
+    path: path.relative(projectRoot, path.join(target, e.name)),
+  }));
+}
+
+async function searchFiles(projectRoot, pattern) {
+  const ig = loadIgnore(projectRoot);
+  const matches = await fg(pattern, {
+    cwd: projectRoot,
+    dot: false,
+    onlyFiles: true,
+    ignore: ['**/node_modules/**', '**/.git/**'],
+  });
+  return matches.filter(m => !ig.ignores(m)).slice(0, 500);
+}
+
+async function searchText(projectRoot, query, { glob = '**/*' } = {}) {
+  const ig = loadIgnore(projectRoot);
+  const files = await fg(glob, {
+    cwd: projectRoot, onlyFiles: true, dot: false,
+    ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**'],
+  });
+  const results = [];
+  const re = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+  for (const f of files) {
+    if (ig.ignores(f)) continue;
+    let content;
+    try { content = fs.readFileSync(path.join(projectRoot, f), 'utf-8'); } catch { continue; }
+    if (content.length > 500_000) continue;
+    const lines = content.split('\n');
+    lines.forEach((line, i) => {
+      if (re.test(line)) results.push({ file: f, line: i + 1, text: line.trim().slice(0, 200) });
+    });
+    if (results.length >= 200) break;
+  }
+  return results.slice(0, 200);
+}
+
+module.exports = { listDirectory, searchFiles, searchText };