coding-agent-adapters 0.2.19 → 0.4.0

package/dist/index.js

@@ -1,7 +1,365 @@
-import { mkdir, appendFile, writeFile } from 'fs/promises';
+import { mkdir, writeFile, appendFile } from 'fs/promises';
 import { join, dirname } from 'path';
 import { BaseCLIAdapter } from '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 BaseCLIAdapter {
   /**
@@ -112,6 +470,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 = join(workspacePath, file.relativePath);
+      await mkdir(dirname(fullPath), { recursive: true });
+      await 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.
@@ -246,6 +638,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) {
@@ -351,6 +747,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)) {
@@ -478,6 +897,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) {
@@ -604,6 +1027,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)) {
@@ -782,6 +1225,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) {
@@ -910,6 +1357,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)) {
@@ -1217,6 +1690,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) {
@@ -1310,6 +1787,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)) {
@@ -1572,6 +2074,6 @@ async function printMissingAdapters(types) {
   }
 }
 
-export { ADAPTER_TYPES, AiderAdapter, BaseCodingAdapter, ClaudeAdapter, CodexAdapter, GeminiAdapter, checkAdapters, checkAllAdapters, clearPatternCache, createAdapter, createAllAdapters, getBaselinePatterns, hasDynamicPatterns, loadPatterns, loadPatternsSync, preloadAllPatterns, printMissingAdapters };
+export { ADAPTER_TYPES, AIDER_COMMAND_CATEGORIES, AiderAdapter, BaseCodingAdapter, CLAUDE_TOOL_CATEGORIES, CODEX_TOOL_CATEGORIES, ClaudeAdapter, CodexAdapter, GEMINI_TOOL_CATEGORIES, GeminiAdapter, PRESET_DEFINITIONS, TOOL_CATEGORIES, checkAdapters, checkAllAdapters, clearPatternCache, createAdapter, createAllAdapters, generateAiderApprovalConfig, generateApprovalConfig, generateClaudeApprovalConfig, generateCodexApprovalConfig, generateGeminiApprovalConfig, getBaselinePatterns, getPresetDefinition, hasDynamicPatterns, listPresets, loadPatterns, loadPatternsSync, preloadAllPatterns, printMissingAdapters };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map