coding-agent-adapters 0.2.19 → 0.4.0

package/dist/index.cjs

@@ -4,6 +4,364 @@ var promises = require('fs/promises');
 var path = require('path');
 var ptyManager = require('pty-manager');
 
+// src/base-coding-adapter.ts
+
+// src/approval-presets.ts
+var TOOL_CATEGORIES = [
+  { category: "file_read", risk: "low", description: "Read files, search, list directories" },
+  { category: "file_write", risk: "medium", description: "Write, edit, and create files" },
+  { category: "shell", risk: "high", description: "Execute shell commands" },
+  { category: "web", risk: "medium", description: "Web search and fetch" },
+  { category: "agent", risk: "medium", description: "Spawn sub-agents, skills, MCP tools" },
+  { category: "planning", risk: "low", description: "Task planning and todo management" },
+  { category: "user_interaction", risk: "low", description: "Ask user questions" }
+];
+var PRESET_DEFINITIONS = [
+  {
+    preset: "readonly",
+    description: "Read-only. Safe for auditing.",
+    autoApprove: ["file_read", "planning", "user_interaction"],
+    requireApproval: [],
+    blocked: ["file_write", "shell", "web", "agent"]
+  },
+  {
+    preset: "standard",
+    description: "Standard dev. Reads + web auto, writes/shell prompt.",
+    autoApprove: ["file_read", "planning", "user_interaction", "web"],
+    requireApproval: ["file_write", "shell", "agent"],
+    blocked: []
+  },
+  {
+    preset: "permissive",
+    description: "File ops auto-approved, shell still prompts.",
+    autoApprove: ["file_read", "file_write", "planning", "user_interaction", "web", "agent"],
+    requireApproval: ["shell"],
+    blocked: []
+  },
+  {
+    preset: "autonomous",
+    description: "Everything auto-approved. Use with sandbox.",
+    autoApprove: ["file_read", "file_write", "shell", "web", "agent", "planning", "user_interaction"],
+    requireApproval: [],
+    blocked: []
+  }
+];
+var CLAUDE_TOOL_CATEGORIES = {
+  // file_read
+  Read: "file_read",
+  Grep: "file_read",
+  Glob: "file_read",
+  LS: "file_read",
+  NotebookRead: "file_read",
+  // file_write
+  Write: "file_write",
+  Edit: "file_write",
+  MultiEdit: "file_write",
+  NotebookEdit: "file_write",
+  // shell
+  Bash: "shell",
+  BashOutput: "shell",
+  KillShell: "shell",
+  // web
+  WebSearch: "web",
+  WebFetch: "web",
+  // agent
+  Task: "agent",
+  Skill: "agent",
+  // planning
+  TodoWrite: "planning",
+  // user_interaction
+  AskUserQuestion: "user_interaction"
+};
+var GEMINI_TOOL_CATEGORIES = {
+  // file_read
+  read_file: "file_read",
+  read_many_files: "file_read",
+  list_directory: "file_read",
+  glob: "file_read",
+  search_file_content: "file_read",
+  // file_write
+  write_file: "file_write",
+  replace: "file_write",
+  // shell
+  run_shell_command: "shell",
+  // web
+  web_fetch: "web",
+  google_web_search: "web",
+  // agent
+  activate_skill: "agent",
+  get_internal_docs: "agent",
+  // planning
+  save_memory: "planning",
+  write_todos: "planning",
+  // user_interaction
+  ask_user: "user_interaction"
+};
+var CODEX_TOOL_CATEGORIES = {
+  // shell (codex uses shell for most operations)
+  exec_command: "shell",
+  write_stdin: "shell",
+  shell_command: "shell",
+  // file_write
+  apply_patch: "file_write",
+  // file_read
+  grep_files: "file_read",
+  read_file: "file_read",
+  list_dir: "file_read",
+  // web
+  web_search: "web",
+  view_image: "web",
+  // agent
+  spawn_agent: "agent",
+  send_input: "agent",
+  resume_agent: "agent",
+  wait: "agent",
+  close_agent: "agent",
+  // planning
+  update_plan: "planning",
+  // user_interaction
+  request_user_input: "user_interaction"
+};
+var AIDER_COMMAND_CATEGORIES = {
+  // file_read
+  "/read-only": "file_read",
+  "/ls": "file_read",
+  "/map": "file_read",
+  "/map-refresh": "file_read",
+  "/tokens": "file_read",
+  "/diff": "file_read",
+  "/context": "file_read",
+  // file_write
+  "/add": "file_write",
+  "/drop": "file_write",
+  "/edit": "file_write",
+  "/code": "file_write",
+  "/architect": "file_write",
+  "/undo": "file_write",
+  // shell
+  "/run": "shell",
+  "/test": "shell",
+  "/lint": "shell",
+  "/git": "shell",
+  // web
+  "/web": "web",
+  // planning
+  "/ask": "planning",
+  // user_interaction
+  "/voice": "user_interaction",
+  "/help": "user_interaction",
+  // config/other
+  "/model": "planning",
+  "/settings": "planning",
+  "/commit": "file_write",
+  "/clear": "planning",
+  "/reset": "planning"
+};
+function getToolsForCategories(mapping, categories) {
+  return Object.entries(mapping).filter(([, cat]) => categories.includes(cat)).map(([tool]) => tool);
+}
+function generateClaudeApprovalConfig(preset) {
+  const def = getPresetDefinition(preset);
+  const allowTools = getToolsForCategories(CLAUDE_TOOL_CATEGORIES, def.autoApprove);
+  const denyTools = getToolsForCategories(CLAUDE_TOOL_CATEGORIES, def.blocked);
+  const settings = {
+    permissions: {}
+  };
+  const permissions = settings.permissions;
+  if (allowTools.length > 0) {
+    permissions.allow = allowTools;
+  }
+  if (denyTools.length > 0) {
+    permissions.deny = denyTools;
+  }
+  if (preset === "autonomous") {
+    settings.sandbox = {
+      enabled: true,
+      autoAllowBashIfSandboxed: true
+    };
+  }
+  const cliFlags = [];
+  if (preset === "autonomous") {
+    const allTools = Object.keys(CLAUDE_TOOL_CATEGORIES);
+    cliFlags.push("--tools", allTools.join(","));
+  }
+  return {
+    preset,
+    cliFlags,
+    workspaceFiles: [
+      {
+        relativePath: ".claude/settings.json",
+        content: JSON.stringify(settings, null, 2),
+        format: "json"
+      }
+    ],
+    envVars: {},
+    summary: `Claude Code: ${def.description}`
+  };
+}
+function generateGeminiApprovalConfig(preset) {
+  const def = getPresetDefinition(preset);
+  const cliFlags = [];
+  const allowedTools = getToolsForCategories(GEMINI_TOOL_CATEGORIES, def.autoApprove);
+  const excludeTools = getToolsForCategories(GEMINI_TOOL_CATEGORIES, def.blocked);
+  let approvalMode;
+  switch (preset) {
+    case "readonly":
+      approvalMode = "plan";
+      cliFlags.push("--approval-mode", "plan");
+      break;
+    case "standard":
+      approvalMode = "default";
+      break;
+    case "permissive":
+      approvalMode = "auto_edit";
+      cliFlags.push("--approval-mode", "auto_edit");
+      break;
+    case "autonomous":
+      approvalMode = "auto_edit";
+      cliFlags.push("-y");
+      break;
+  }
+  const settings = {
+    general: {
+      defaultApprovalMode: approvalMode
+    },
+    tools: {}
+  };
+  const tools = settings.tools;
+  if (allowedTools.length > 0) {
+    tools.allowed = allowedTools;
+  }
+  if (excludeTools.length > 0) {
+    tools.exclude = excludeTools;
+  }
+  return {
+    preset,
+    cliFlags,
+    workspaceFiles: [
+      {
+        relativePath: ".gemini/settings.json",
+        content: JSON.stringify(settings, null, 2),
+        format: "json"
+      }
+    ],
+    envVars: {},
+    summary: `Gemini CLI: ${def.description}`
+  };
+}
+function generateCodexApprovalConfig(preset) {
+  const cliFlags = [];
+  let approvalPolicy;
+  let sandboxMode;
+  let webSearch;
+  switch (preset) {
+    case "readonly":
+      approvalPolicy = "untrusted";
+      sandboxMode = "workspace-read";
+      webSearch = false;
+      cliFlags.push("--sandbox", "workspace-read", "-a", "untrusted");
+      break;
+    case "standard":
+      approvalPolicy = "on-failure";
+      sandboxMode = "workspace-write";
+      webSearch = true;
+      cliFlags.push("--sandbox", "workspace-write");
+      break;
+    case "permissive":
+      approvalPolicy = "on-request";
+      sandboxMode = "workspace-write";
+      webSearch = true;
+      cliFlags.push("-a", "on-request");
+      break;
+    case "autonomous":
+      approvalPolicy = "never";
+      sandboxMode = "workspace-write";
+      webSearch = true;
+      cliFlags.push("--full-auto");
+      break;
+  }
+  const config = {
+    approval_policy: approvalPolicy,
+    sandbox_mode: sandboxMode,
+    tools: {
+      web_search: webSearch
+    }
+  };
+  return {
+    preset,
+    cliFlags,
+    workspaceFiles: [
+      {
+        relativePath: ".codex/config.json",
+        content: JSON.stringify(config, null, 2),
+        format: "json"
+      }
+    ],
+    envVars: {},
+    summary: `Codex: ${getPresetDefinition(preset).description}`
+  };
+}
+function generateAiderApprovalConfig(preset) {
+  const def = getPresetDefinition(preset);
+  const cliFlags = [];
+  const lines = [];
+  switch (preset) {
+    case "readonly":
+      lines.push("yes-always: false");
+      lines.push("no-auto-commits: true");
+      cliFlags.push("--no-auto-commits");
+      break;
+    case "standard":
+      lines.push("yes-always: false");
+      break;
+    case "permissive":
+      lines.push("yes-always: true");
+      cliFlags.push("--yes-always");
+      break;
+    case "autonomous":
+      lines.push("yes-always: true");
+      cliFlags.push("--yes-always");
+      break;
+  }
+  return {
+    preset,
+    cliFlags,
+    workspaceFiles: [
+      {
+        relativePath: ".aider.conf.yml",
+        content: lines.join("\n") + "\n",
+        format: "yaml"
+      }
+    ],
+    envVars: {},
+    summary: `Aider: ${def.description}`
+  };
+}
+function generateApprovalConfig(adapterType, preset) {
+  switch (adapterType) {
+    case "claude":
+      return generateClaudeApprovalConfig(preset);
+    case "gemini":
+      return generateGeminiApprovalConfig(preset);
+    case "codex":
+      return generateCodexApprovalConfig(preset);
+    case "aider":
+      return generateAiderApprovalConfig(preset);
+    default:
+      throw new Error(`Unknown adapter type: ${adapterType}`);
+  }
+}
+function listPresets() {
+  return [...PRESET_DEFINITIONS];
+}
+function getPresetDefinition(preset) {
+  const def = PRESET_DEFINITIONS.find((d) => d.preset === preset);
+  if (!def) {
+    throw new Error(`Unknown preset: ${preset}`);
+  }
+  return def;
+}
+
 // src/base-coding-adapter.ts
 var BaseCodingAdapter = class extends ptyManager.BaseCLIAdapter {
   /**
@@ -114,6 +472,40 @@ Docs: ${this.installation.docsUrl}`
     content = content.trim();
     return content;
   }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Approval Presets
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Extract the approval preset from a spawn config, if set.
+   */
+  getApprovalPreset(config) {
+    const adapterConfig = config.adapterConfig;
+    return adapterConfig?.approvalPreset;
+  }
+  /**
+   * Generate the approval config for this adapter, if a preset is set.
+   */
+  getApprovalConfig(config) {
+    const preset = this.getApprovalPreset(config);
+    if (!preset) return null;
+    return generateApprovalConfig(this.adapterType, preset);
+  }
+  /**
+   * Write approval config files to a workspace directory.
+   * Returns the list of files written (absolute paths).
+   */
+  async writeApprovalConfig(workspacePath, config) {
+    const approvalConfig = this.getApprovalConfig(config);
+    if (!approvalConfig) return [];
+    const written = [];
+    for (const file of approvalConfig.workspaceFiles) {
+      const fullPath = path.join(workspacePath, file.relativePath);
+      await promises.mkdir(path.dirname(fullPath), { recursive: true });
+      await promises.writeFile(fullPath, file.content, "utf-8");
+      written.push(fullPath);
+    }
+    return written;
+  }
   /**
    * Write content to this agent's memory file in a workspace.
    * Creates parent directories as needed.
@@ -248,6 +640,10 @@ var ClaudeAdapter = class extends BaseCodingAdapter {
         args.push("--cwd", config.workdir);
       }
     }
+    const approvalConfig = this.getApprovalConfig(config);
+    if (approvalConfig) {
+      args.push(...approvalConfig.cliFlags);
+    }
     return args;
   }
   getEnv(config) {
@@ -353,6 +749,29 @@ var ClaudeAdapter = class extends BaseCodingAdapter {
     }
     return super.detectBlockingPrompt(output);
   }
+  /**
+   * Detect task completion for Claude Code.
+   *
+   * High-confidence pattern: turn duration summary + idle prompt.
+   * Claude Code shows "<Verb> for Xm Ys" (e.g. "Cooked for 3m 12s")
+   * when a turn completes, followed by the ❯ input prompt.
+   *
+   * Patterns from: AGENT_LOADING_STATUS_PATTERNS.json
+   *   - claude_completed_turn_duration
+   *   - claude_completed_turn_duration_custom_verb
+   */
+  detectTaskComplete(output) {
+    const stripped = this.stripAnsi(output);
+    const hasDuration = /[A-Z][A-Za-z' -]{2,40}\s+for\s+\d+(?:h\s+\d{1,2}m\s+\d{1,2}s|m\s+\d{1,2}s|s)/.test(stripped);
+    const hasIdlePrompt = /❯\s*$/.test(stripped);
+    if (hasDuration && hasIdlePrompt) {
+      return true;
+    }
+    if (hasIdlePrompt && stripped.includes("for shortcuts")) {
+      return true;
+    }
+    return false;
+  }
   detectReady(output) {
     const stripped = this.stripAnsi(output);
     if (/trust.*directory|do you want to|needs? your permission/i.test(stripped)) {
@@ -480,6 +899,10 @@ var GeminiAdapter = class extends BaseCodingAdapter {
         args.push("--cwd", config.workdir);
       }
     }
+    const approvalConfig = this.getApprovalConfig(config);
+    if (approvalConfig) {
+      args.push(...approvalConfig.cliFlags);
+    }
     return args;
   }
   getEnv(config) {
@@ -606,6 +1029,26 @@ var GeminiAdapter = class extends BaseCodingAdapter {
     }
     return super.detectBlockingPrompt(output);
   }
+  /**
+   * Detect task completion for Gemini CLI.
+   *
+   * High-confidence patterns:
+   *   - "◇ Ready" window title signal (OSC sequence, may survive ANSI stripping)
+   *   - "Type your message" composer placeholder after agent output
+   *
+   * Patterns from: AGENT_LOADING_STATUS_PATTERNS.json
+   *   - gemini_ready_title
+   */
+  detectTaskComplete(output) {
+    const stripped = this.stripAnsi(output);
+    if (/◇\s+Ready/.test(stripped)) {
+      return true;
+    }
+    if (/type.?your.?message/i.test(stripped)) {
+      return true;
+    }
+    return false;
+  }
   detectReady(output) {
     const stripped = this.stripAnsi(output);
     if (/type.?your.?message/i.test(stripped)) {
@@ -784,6 +1227,10 @@ var CodexAdapter = class extends BaseCodingAdapter {
         args.push("--cwd", config.workdir);
       }
     }
+    const approvalConfig = this.getApprovalConfig(config);
+    if (approvalConfig) {
+      args.push(...approvalConfig.cliFlags);
+    }
     return args;
   }
   getEnv(config) {
@@ -912,6 +1359,32 @@ var CodexAdapter = class extends BaseCodingAdapter {
     }
     return super.detectBlockingPrompt(output);
   }
+  /**
+   * Detect task completion for Codex CLI.
+   *
+   * High-confidence patterns:
+   *   - "Worked for Xm Ys" separator after work-heavy turns
+   *   - "› Ask Codex to do anything" ready prompt
+   *
+   * Patterns from: AGENT_LOADING_STATUS_PATTERNS.json
+   *   - codex_completed_worked_for_separator
+   *   - codex_ready_prompt
+   */
+  detectTaskComplete(output) {
+    const stripped = this.stripAnsi(output);
+    const hasWorkedFor = /Worked\s+for\s+\d+(?:h\s+\d{2}m\s+\d{2}s|m\s+\d{2}s|s)/.test(stripped);
+    const hasReadyPrompt = /›\s+Ask\s+Codex\s+to\s+do\s+anything/.test(stripped);
+    if (hasWorkedFor && hasReadyPrompt) {
+      return true;
+    }
+    if (hasReadyPrompt) {
+      return true;
+    }
+    if (hasWorkedFor && /›\s+/m.test(stripped)) {
+      return true;
+    }
+    return false;
+  }
   detectReady(output) {
     const stripped = this.stripAnsi(output);
     if (/do.?you.?trust.?the.?contents/i.test(stripped) || /sign.?in.?with.?chatgpt/i.test(stripped) || /update.?available/i.test(stripped) || /enable.?full.?access/i.test(stripped) || /choose.?working.?directory/i.test(stripped)) {
@@ -1219,6 +1692,10 @@ var AiderAdapter = class extends BaseCodingAdapter {
     if (credentials.anthropicKey) args.push("--api-key", `anthropic=${credentials.anthropicKey}`);
     if (credentials.openaiKey) args.push("--api-key", `openai=${credentials.openaiKey}`);
     if (credentials.googleKey) args.push("--api-key", `gemini=${credentials.googleKey}`);
+    const approvalConfig = this.getApprovalConfig(config);
+    if (approvalConfig) {
+      args.push(...approvalConfig.cliFlags);
+    }
     return args;
   }
   getEnv(config) {
@@ -1312,6 +1789,31 @@ var AiderAdapter = class extends BaseCodingAdapter {
     }
     return super.detectBlockingPrompt(output);
   }
+  /**
+   * Detect task completion for Aider.
+   *
+   * High-confidence patterns:
+   *   - "Aider is waiting for your input" notification (bell message)
+   *   - Edit-format mode prompts (ask>, code>, architect>) after output
+   *
+   * Patterns from: AGENT_LOADING_STATUS_PATTERNS.json
+   *   - aider_completed_llm_response_ready
+   */
+  detectTaskComplete(output) {
+    const stripped = this.stripAnsi(output);
+    if (/Aider\s+is\s+waiting\s+for\s+your\s+input/.test(stripped)) {
+      return true;
+    }
+    const hasPrompt = /(?:ask|code|architect)(?:\s+multi)?>\s*$/m.test(stripped);
+    if (hasPrompt) {
+      const hasEditMarkers = /Applied edit to|Commit [a-f0-9]+|wrote to|Updated/i.test(stripped);
+      const hasTokenUsage = /Tokens:|Cost:/i.test(stripped);
+      if (hasEditMarkers || hasTokenUsage) {
+        return true;
+      }
+    }
+    return false;
+  }
   detectReady(output) {
     const stripped = this.stripAnsi(output);
     if (/login to openrouter/i.test(stripped) || /open this url in your browser/i.test(stripped) || /waiting up to 5 minutes/i.test(stripped)) {
@@ -1575,18 +2077,31 @@ async function printMissingAdapters(types) {
 }
 
 exports.ADAPTER_TYPES = ADAPTER_TYPES;
+exports.AIDER_COMMAND_CATEGORIES = AIDER_COMMAND_CATEGORIES;
 exports.AiderAdapter = AiderAdapter;
 exports.BaseCodingAdapter = BaseCodingAdapter;
+exports.CLAUDE_TOOL_CATEGORIES = CLAUDE_TOOL_CATEGORIES;
+exports.CODEX_TOOL_CATEGORIES = CODEX_TOOL_CATEGORIES;
 exports.ClaudeAdapter = ClaudeAdapter;
 exports.CodexAdapter = CodexAdapter;
+exports.GEMINI_TOOL_CATEGORIES = GEMINI_TOOL_CATEGORIES;
 exports.GeminiAdapter = GeminiAdapter;
+exports.PRESET_DEFINITIONS = PRESET_DEFINITIONS;
+exports.TOOL_CATEGORIES = TOOL_CATEGORIES;
 exports.checkAdapters = checkAdapters;
 exports.checkAllAdapters = checkAllAdapters;
 exports.clearPatternCache = clearPatternCache;
 exports.createAdapter = createAdapter;
 exports.createAllAdapters = createAllAdapters;
+exports.generateAiderApprovalConfig = generateAiderApprovalConfig;
+exports.generateApprovalConfig = generateApprovalConfig;
+exports.generateClaudeApprovalConfig = generateClaudeApprovalConfig;
+exports.generateCodexApprovalConfig = generateCodexApprovalConfig;
+exports.generateGeminiApprovalConfig = generateGeminiApprovalConfig;
 exports.getBaselinePatterns = getBaselinePatterns;
+exports.getPresetDefinition = getPresetDefinition;
 exports.hasDynamicPatterns = hasDynamicPatterns;
+exports.listPresets = listPresets;
 exports.loadPatterns = loadPatterns;
 exports.loadPatternsSync = loadPatternsSync;
 exports.preloadAllPatterns = preloadAllPatterns;