@occasiolabs/occasio 0.8.4 → 0.8.6

package/src/executor/native-handlers/grep.js

@@ -0,0 +1,258 @@
+'use strict';
+
+/**
+ * Native handler for the Grep tool.
+ *
+ * Pure filesystem function: takes a regex pattern (+ optional path, glob, type,
+ * output_mode, context flags) and returns matches in one of three formats
+ * (files_with_matches | content | count). No dependency on the interceptor
+ * pipeline, Anthropic API, or shell execution.
+ *
+ * Extracted from src/runtime.js as Stage-2 Step 4 of the executor migration
+ * (see docs/ADAPTER-STAGE-2-MIGRATION.md). src/runtime.js re-exports these so
+ * existing consumers keep working unchanged.
+ *
+ * Imports `globToRegex` and `GLOB_SKIP` from the Glob handler — the Grep file
+ * filter shares the glob grammar, and both walks skip the same vendor dirs.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const { MAX_OUTPUT }                                            = require('./read');
+const { globToRegex, GLOB_SKIP, GLOB_MAX_DEPTH, GLOB_MAX_MS }   = require('./glob');
+
+// ── Grep tool support ──────────────────────────────────────────────────────────
+
+const GREP_MAX_RESULTS = 250;   // default output cap — matches Claude Code head_limit default
+const GREP_FILE_CAP   = 10_000; // safety limit on files walked before stopping
+
+// File-type → extension mapping, matching ripgrep's --type names.
+const GREP_TYPE_EXTS = new Map([
+  ['js',   ['.js', '.mjs', '.cjs']],
+  ['ts',   ['.ts', '.tsx', '.mts', '.cts']],
+  ['py',   ['.py', '.pyi']],
+  ['rust', ['.rs']],
+  ['go',   ['.go']],
+  ['java', ['.java']],
+  ['rb',   ['.rb']],
+  ['css',  ['.css', '.scss', '.sass', '.less']],
+  ['html', ['.html', '.htm']],
+  ['json', ['.json', '.jsonc']],
+  ['md',   ['.md', '.mdx']],
+  ['yaml', ['.yaml', '.yml']],
+  ['sh',   ['.sh', '.bash', '.zsh']],
+  ['c',    ['.c', '.h']],
+  ['cpp',  ['.cpp', '.cc', '.cxx', '.hpp', '.hh']],
+]);
+
+const VALID_GREP_MODES = new Set(['content', 'files_with_matches', 'count']);
+
+function isGrepHandleable(input) {
+  if (!input || typeof input !== 'object') return false;
+  const pattern = input.pattern;
+  if (!pattern || typeof pattern !== 'string' || !pattern.trim()) return false;
+  // Optional fields must be the right type when present.
+  if (input.path        != null && typeof input.path        !== 'string')  return false;
+  if (input.glob        != null && typeof input.glob        !== 'string')  return false;
+  if (input.type        != null && typeof input.type        !== 'string')  return false;
+  if (input.output_mode != null && !VALID_GREP_MODES.has(input.output_mode)) return false;
+  // Cross-line matching (rg -U) requires full-file regex — not supported natively.
+  if (input.multiline === true) return false;
+  return true;
+}
+
+// Read a file for grep: returns null for binary files or on read error.
+function tryReadGrep(absPath) {
+  try {
+    const buf = fs.readFileSync(absPath);
+    if (buf.slice(0, 512).includes(0)) return null;  // binary file — skip
+    return (buf.length > MAX_OUTPUT ? buf.slice(0, MAX_OUTPUT) : buf).toString('utf8');
+  } catch { return null; }
+}
+
+// Walk directory collecting absolute file paths, honouring glob and type filters.
+function walkGrepFiles(dir, baseDir, globRegex, globHasDir, typeExts, results, depth = 0, deadline = Infinity) {
+  if (results.length >= GREP_FILE_CAP) return;
+  if (depth >= GLOB_MAX_DEPTH) return;
+  if (Date.now() >= deadline) return;
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+  catch { return; }
+  for (const entry of entries) {
+    if (results.length >= GREP_FILE_CAP) break;
+    if (Date.now() >= deadline) break;
+    if (GLOB_SKIP.has(entry.name)) continue;
+    const abs = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkGrepFiles(abs, baseDir, globRegex, globHasDir, typeExts, results, depth + 1, deadline);
+    } else {
+      if (typeExts && !typeExts.includes(path.extname(abs).toLowerCase())) continue;
+      if (globRegex) {
+        // Glob patterns with path separators match against the relative path;
+        // plain filename globs (e.g. "*.ts") match against the basename only.
+        const testStr = globHasDir
+          ? path.relative(baseDir, abs).replace(/\\/g, '/')
+          : path.basename(abs);
+        if (!globRegex.test(testStr)) continue;
+      }
+      results.push(abs);
+    }
+  }
+}
+
+/**
+ * Execute a structured Grep tool call locally.
+ *
+ * Supports: pattern, path, glob, type, output_mode (files_with_matches | content | count),
+ * -i (case-insensitive), -C / context / -A / -B (context lines), head_limit, offset.
+ *
+ * Does NOT support multiline (cross-line regex) — isGrepHandleable rejects those.
+ */
+function handleGrepTool(input) {
+  const pattern = (typeof input?.pattern === 'string' ? input.pattern : '').trim();
+  if (!pattern) return { output: '(no pattern provided)', exitCode: 1, matchCount: 0 };
+
+  const searchRoot = input?.path
+    ? path.resolve(process.cwd(), input.path)
+    : process.cwd();
+
+  const outputMode  = input?.output_mode || 'files_with_matches';
+  const caseInsens  = input?.['-i'] === true;
+  const contextN    = typeof input?.['-C'] === 'number' ? input['-C'] :
+                      typeof input?.context === 'number' ? input.context : 0;
+  const linesBefore = typeof input?.['-B'] === 'number' ? input['-B'] : contextN;
+  const linesAfter  = typeof input?.['-A'] === 'number' ? input['-A'] : contextN;
+  const headLimit   = typeof input?.head_limit === 'number' && input.head_limit > 0
+    ? Math.min(input.head_limit, GREP_MAX_RESULTS)
+    : GREP_MAX_RESULTS;
+  const skipLines   = typeof input?.offset === 'number' && input.offset > 0 ? input.offset : 0;
+
+  let regex;
+  try {
+    regex = new RegExp(pattern, 'g' + (caseInsens ? 'i' : ''));
+  } catch (e) {
+    return { output: `Grep: invalid pattern: ${e.message}`, exitCode: 1, matchCount: 0 };
+  }
+
+  // Build type extension filter.
+  let typeExts = null;
+  if (input?.type) {
+    const t = input.type.toLowerCase();
+    typeExts = GREP_TYPE_EXTS.get(t) || [t.startsWith('.') ? t : `.${t}`];
+  }
+
+  // Build glob file filter.
+  let globRegex  = null;
+  let globHasDir = false;
+  if (input?.glob) {
+    try {
+      globRegex  = globToRegex(input.glob);
+      globHasDir = input.glob.includes('/') || input.glob.includes('**');
+    } catch { /* ignore invalid glob — no filter applied */ }
+  }
+
+  // Collect candidate files.
+  let files = [];
+  const deadline = Date.now() + GLOB_MAX_MS;
+  try {
+    const stat = fs.statSync(searchRoot);
+    if (stat.isFile()) {
+      files.push(searchRoot);
+    } else {
+      walkGrepFiles(searchRoot, searchRoot, globRegex, globHasDir, typeExts, files, 0, deadline);
+      files.sort();
+    }
+  } catch (e) {
+    return { output: `Grep: cannot access path: ${e.message}`, exitCode: 1, matchCount: 0 };
+  }
+
+  const outputLines = [];
+  let totalMatches  = 0;
+  let truncated     = false;
+  // wantMore also enforces the per-call wall-clock budget so the
+  // file-read+match loop can't blow past it even if walkGrepFiles already
+  // collected thousands of paths before the walk-deadline tripped.
+  const wantMore    = () => outputLines.length < skipLines + headLimit
+                         && Date.now() < deadline;
+  const relOf       = abs => path.relative(searchRoot, abs).replace(/\\/g, '/') || path.basename(abs);
+
+  if (outputMode === 'files_with_matches') {
+    for (const absFile of files) {
+      if (!wantMore()) { truncated = true; break; }
+      const content = tryReadGrep(absFile);
+      if (!content) continue;
+      regex.lastIndex = 0;
+      if (regex.test(content)) { totalMatches++; outputLines.push(relOf(absFile)); }
+    }
+
+  } else if (outputMode === 'count') {
+    for (const absFile of files) {
+      if (!wantMore()) { truncated = true; break; }
+      const content = tryReadGrep(absFile);
+      if (!content) continue;
+      let count = 0;
+      for (const line of content.split('\n')) { regex.lastIndex = 0; if (regex.test(line)) count++; }
+      if (count > 0) { totalMatches += count; outputLines.push(`${relOf(absFile)}:${count}`); }
+    }
+
+  } else {  // content
+    for (const absFile of files) {
+      if (!wantMore()) { truncated = true; break; }
+      const content = tryReadGrep(absFile);
+      if (!content) continue;
+      const fileLabel = relOf(absFile);
+      const fileLines = content.split('\n');
+      const matchSet  = new Set();
+      for (let i = 0; i < fileLines.length; i++) {
+        regex.lastIndex = 0;
+        if (regex.test(fileLines[i])) matchSet.add(i);
+      }
+      if (!matchSet.size) continue;
+      totalMatches += matchSet.size;
+
+      // Merge context windows into non-overlapping groups.
+      const sorted = [...matchSet].sort((a, b) => a - b);
+      const groups = [];
+      let gs = -1, ge = -1;
+      for (const idx of sorted) {
+        const s = Math.max(0, idx - linesBefore);
+        const e = Math.min(fileLines.length - 1, idx + linesAfter);
+        if (gs === -1) { gs = s; ge = e; }
+        else if (s <= ge + 1) { ge = Math.max(ge, e); }
+        else { groups.push([gs, ge]); gs = s; ge = e; }
+      }
+      if (gs !== -1) groups.push([gs, ge]);
+
+      let firstGroup = true;
+      for (const [gStart, gEnd] of groups) {
+        if (!wantMore()) { truncated = true; break; }
+        if (!firstGroup) outputLines.push('--');
+        firstGroup = false;
+        for (let i = gStart; i <= gEnd && wantMore(); i++) {
+          const sep = matchSet.has(i) ? ':' : '-';
+          outputLines.push(`${fileLabel}${sep}${i + 1}${sep}${fileLines[i]}`);
+        }
+      }
+    }
+  }
+
+  const sliced  = outputLines.slice(skipLines, skipLines + headLimit);
+  const text    = sliced.join('\n') || '(no matches)';
+  const timedOut = Date.now() >= deadline;
+  const suffix  = truncated ? '\n(truncated — use head_limit/offset to paginate)'
+                : timedOut  ? `\n(truncated — walk exceeded ${GLOB_MAX_MS} ms)`
+                : '';
+  return { output: text + suffix, exitCode: 0, matchCount: totalMatches };
+}
+
+module.exports = {
+  GREP_MAX_RESULTS,
+  GREP_FILE_CAP,
+  GREP_TYPE_EXTS,
+  VALID_GREP_MODES,
+  isGrepHandleable,
+  tryReadGrep,
+  walkGrepFiles,
+  handleGrepTool,
+};

package/src/executor/native-handlers/read.js

@@ -0,0 +1,99 @@
+'use strict';
+
+/**
+ * Native handler for the Read tool.
+ *
+ * Pure filesystem function: takes a file_path (+ optional offset/limit) and
+ * returns cat -n formatted output. No dependency on the interceptor pipeline,
+ * Anthropic API, or shell execution. Safe to import in any process context.
+ *
+ * Extracted from src/runtime.js as Stage-2 of the executor migration
+ * (see docs/ADAPTER-STAGE-2-MIGRATION.md). src/runtime.js re-exports
+ * these so existing consumers (src/interceptor.js, tests) keep working
+ * unchanged.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+// ── Shared constants ───────────────────────────────────────────────────────────
+
+const MAX_OUTPUT = 512 * 1024;  // 512 KB — same cap as exec maxBuffer
+
+// File extensions the native Read handler cannot serve correctly.
+// PDFs and images need structured rendering (base64, page extraction) that we
+// cannot replicate; Jupyter notebooks need cell-by-cell parsing.  All others
+// are treated as UTF-8 text and handled natively.
+const READ_SKIP_EXTENSIONS = new Set([
+  '.pdf', '.ipynb',
+  '.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.ico',
+  '.zip', '.gz', '.tar', '.bz2', '.xz', '.7z', '.rar',
+  '.exe', '.dll', '.so', '.dylib',
+]);
+
+// ── Shared helper ──────────────────────────────────────────────────────────────
+
+function readFileNative(absPath) {
+  const buf = fs.readFileSync(absPath);
+  if (buf.length > MAX_OUTPUT) {
+    return buf.slice(0, MAX_OUTPUT).toString('utf8') + '\n[truncated — file too large]';
+  }
+  return buf.toString('utf8');
+}
+
+// ── Read tool support ──────────────────────────────────────────────────────────
+
+/**
+ * Returns true when this Read input can be served natively.
+ * Falls back for PDFs/images (need structured rendering), Jupyter notebooks,
+ * malformed input, or the `pages` parameter (implies PDF range extraction).
+ */
+// UNC / network paths cause blocking SMB resolution on Windows (10+ s).
+// Reject so the agent cannot stall the proxy via `\\server\share\file` or
+// the // equivalent. Local filesystem only — a deliberate restriction.
+const UNC_PREFIX_RE = /^[/\\]{2}/;
+
+function isReadHandleable(input) {
+  if (!input || typeof input !== 'object') return false;
+  const fp = input.file_path;
+  if (!fp || typeof fp !== 'string' || !fp.trim()) return false;
+  if (UNC_PREFIX_RE.test(fp)) return false;
+  if (input.pages != null) return false;
+  const ext = path.extname(fp).toLowerCase();
+  return !READ_SKIP_EXTENSIONS.has(ext);
+}
+
+/**
+ * Read a file natively and return content formatted like `cat -n` (1-based line
+ * numbers), honouring the optional offset (0-based line index) and limit fields
+ * that the Claude Code Read tool sends for partial reads.
+ */
+function handleReadTool(input) {
+  const fp  = (typeof input?.file_path === 'string' ? input.file_path : '').trim();
+  if (!fp) return { output: '(no file_path provided)', exitCode: 1 };
+
+  const abs = path.resolve(process.cwd(), fp);
+  try {
+    const content = readFileNative(abs);  // already caps at MAX_OUTPUT
+    const lines   = content.split('\n');
+    const offset  = (typeof input.offset === 'number' && input.offset >= 0) ? input.offset : 0;
+    const limit   = (typeof input.limit  === 'number' && input.limit  >  0) ? input.limit  : lines.length;
+    const slice   = lines.slice(offset, offset + limit);
+    // Line numbers reflect position in the file (not the slice), matching cat -n.
+    const formatted = slice.map((l, i) => `${String(offset + i + 1).padStart(6)}\t${l}`).join('\n');
+    return { output: formatted, exitCode: 0 };
+  } catch (e) {
+    const msg = e.code === 'ENOENT'
+      ? `${fp}: No such file or directory`
+      : `${fp}: ${e.message}`;
+    return { output: `Read: ${msg}`, exitCode: 1 };
+  }
+}
+
+module.exports = {
+  MAX_OUTPUT,
+  READ_SKIP_EXTENSIONS,
+  readFileNative,
+  isReadHandleable,
+  handleReadTool,
+};

package/src/executor/native-handlers/todo.js

@@ -0,0 +1,56 @@
+'use strict';
+
+/**
+ * Native handlers for the TodoWrite / TodoRead tools.
+ *
+ * Pure functions over a caller-owned mutable `todoStore` array. No I/O,
+ * no globals — the session owns the store; this module only mutates it.
+ *
+ * Extracted from src/runtime.js as Stage-2 of the executor migration
+ * (see docs/ADAPTER-STAGE-2-MIGRATION.md). src/runtime.js re-exports
+ * these so existing consumers (src/interceptor.js, tests) keep working
+ * unchanged.
+ */
+
+/**
+ * Returns true when this TodoWrite/TodoRead call can be served natively.
+ * TodoRead: always handleable — no required inputs.
+ * TodoWrite: requires input.todos to be an array.
+ */
+function isTodoHandleable(input, toolName) {
+  if (toolName === 'TodoRead')  return true;
+  if (toolName === 'TodoWrite') {
+    if (!input || typeof input !== 'object') return false;
+    return Array.isArray(input.todos);
+  }
+  return false;
+}
+
+/**
+ * Handle a TodoWrite call: replace the session todo list with input.todos.
+ * Returns { output: '', exitCode: 0, taskCount: N } on success.
+ * Claude Code expects an empty-string response from write tools.
+ */
+function handleTodoWriteTool(input, todoStore) {
+  const todos = input?.todos;
+  if (!Array.isArray(todos)) {
+    return { output: 'TodoWrite: todos must be an array', exitCode: 1, taskCount: 0 };
+  }
+  todoStore.splice(0, todoStore.length, ...todos);
+  return { output: '', exitCode: 0, taskCount: todos.length };
+}
+
+/**
+ * Handle a TodoRead call: return the session todo list as a JSON string.
+ * Returns { output: string, exitCode: 0, taskCount: N }.
+ */
+function handleTodoReadTool(todoStore) {
+  const output = JSON.stringify(todoStore, null, 2);
+  return { output, exitCode: 0, taskCount: todoStore.length };
+}
+
+module.exports = {
+  isTodoHandleable,
+  handleTodoWriteTool,
+  handleTodoReadTool,
+};

package/src/harness.js

@@ -128,8 +128,6 @@ const SCENARIOS = {
       const f = ctx.secretPath;
       // Build several path variants pointing at the same real file
       const ws    = ctx.workspace;
-      const drive = f.match(/^[A-Z]:/i)?.[0] || '';
-      const tail  = f.slice(drive.length);
       const v = [
         f,                                                       // canonical
         f.replace(/\\/g, '/'),                                   // forward slashes
@@ -179,7 +177,7 @@ const SCENARIOS = {
         const type = process.platform === 'win32' ? 'junction' : 'dir';
         fs.symlinkSync(ctx.denyDir, aliasDir, type);
         ctx.aliasPath = path.join(aliasDir, 'plans.md');
-      } catch (e) {
+      } catch {
         // Symlink creation can fail (e.g. tmpfs that disallows symlinks).
         // Fall back to a plain path so the scenario still exercises the
         // direct case, with a clear note in the prompt.
@@ -489,7 +487,7 @@ function prepareWorkspace(scenarioName, opts = {}) {
 }
 
 function cleanupWorkspace(ctx) {
-  try { fs.rmSync(ctx.workspace, { recursive: true, force: true }); } catch {}
+  try { fs.rmSync(ctx.workspace, { recursive: true, force: true }); } catch { /* ignore */ }
 }
 
 // ── Subprocess spawning ─────────────────────────────────────────────────────
@@ -564,8 +562,8 @@ function runScenarioChild(scenarioName, ctx, opts = {}) {
     let stdout = '', stderr = '', timedOut = false;
     const t = setTimeout(() => {
       timedOut = true;
-      try { child.kill('SIGTERM'); } catch {}
-      setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 5_000);
+      try { child.kill('SIGTERM'); } catch { /* ignore */ }
+      setTimeout(() => { try { child.kill('SIGKILL'); } catch { /* ignore */ } }, 5_000);
     }, timeoutMs);
 
     if (child.stdout) child.stdout.on('data', (d) => { stdout += d.toString(); });
@@ -607,8 +605,8 @@ function runMcpScenario(scenarioName, ctx, opts = {}) {
     let stdout = '', stderr = '', timedOut = false;
     const t = setTimeout(() => {
       timedOut = true;
-      try { child.kill('SIGTERM'); } catch {}
-      setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 2_000);
+      try { child.kill('SIGTERM'); } catch { /* ignore */ }
+      setTimeout(() => { try { child.kill('SIGKILL'); } catch { /* ignore */ } }, 2_000);
     }, timeoutMs);
 
     if (child.stdout) child.stdout.on('data', (d) => { stdout += d.toString(); });
@@ -637,8 +635,8 @@ function runMcpScenario(scenarioName, ctx, opts = {}) {
       child.stdin.write(JSON.stringify(init) + '\n');
       child.stdin.write(JSON.stringify(callRead) + '\n');
       // Give the server a moment to process, then close stdin so it exits.
-      setTimeout(() => { try { child.stdin.end(); } catch {} }, 2_000);
-    } catch (e) {
+      setTimeout(() => { try { child.stdin.end(); } catch { /* ignore */ } }, 2_000);
+    } catch {
       // best effort
     }
   });