acdev 1.0.10 → 1.0.11

package/src/openrouter-tools.js

@@ -0,0 +1,291 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { tool } from '@openrouter/agent';
+import { z } from 'zod';
+
+const execFileAsync = promisify(execFile);
+
+const SKIP_DIR_NAMES = new Set([
+  '.git',
+  'node_modules',
+  '.acdev',
+  '.acdev-worktrees',
+  '.codepilot',
+  '.codepilot-worktrees',
+  '.agent-mcp',
+  '.agent-mcp-worktrees',
+]);
+
+/**
+ * Convert a glob (with `*` / `**` / `?`) to a RegExp.
+ * @param {string} pattern
+ */
+export function globToRegExp(pattern) {
+  const src = String(pattern || '').replace(/\\/g, '/');
+  let i = 0;
+  let out = '^';
+  while (i < src.length) {
+    if (src[i] === '*' && src[i + 1] === '*') {
+      if (src[i + 2] === '/') {
+        out += '(?:.*/)?';
+        i += 3;
+      } else {
+        out += '.*';
+        i += 2;
+      }
+    } else if (src[i] === '*') {
+      out += '[^/]*';
+      i += 1;
+    } else if (src[i] === '?') {
+      out += '[^/]';
+      i += 1;
+    } else {
+      out += src[i].replace(/[.+^${}()|[\]\\]/g, '\\$&');
+      i += 1;
+    }
+  }
+  return new RegExp(`${out}$`);
+}
+
+/**
+ * Resolve a user path inside the worktree. Rejects escapes.
+ * @param {string} worktreePath
+ * @param {string} rel
+ */
+export function resolveInWorktree(worktreePath, rel) {
+  const root = path.resolve(worktreePath);
+  const target = path.resolve(root, String(rel || '.'));
+  if (target !== root && !target.startsWith(root + path.sep)) {
+    throw new Error(`Path escapes worktree: ${rel}`);
+  }
+  return target;
+}
+
+/**
+ * @param {string} root
+ * @param {string} [sub]
+ * @returns {string[]} absolute file paths
+ */
+export function listWorktreeFiles(root, sub) {
+  const start = sub ? resolveInWorktree(root, sub) : path.resolve(root);
+  /** @type {string[]} */
+  const files = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      if (SKIP_DIR_NAMES.has(ent.name)) continue;
+      const full = path.join(dir, ent.name);
+      if (ent.isDirectory()) walk(full);
+      else if (ent.isFile() || ent.isSymbolicLink()) files.push(full);
+    }
+  };
+  if (fs.existsSync(start) && fs.statSync(start).isDirectory()) walk(start);
+  else if (fs.existsSync(start)) files.push(start);
+  return files;
+}
+
+function relToRoot(root, abs) {
+  return path.relative(root, abs).replace(/\\/g, '/');
+}
+
+/**
+ * @param {string} worktreePath
+ * @param {string[]} allowedTools
+ */
+export function buildOpenRouterCodingTools(worktreePath, allowedTools) {
+  const allowed = new Set(allowedTools || []);
+  const root = path.resolve(worktreePath);
+  /** @type {ReturnType<typeof tool>[]} */
+  const tools = [];
+
+  if (allowed.has('Read')) {
+    tools.push(
+      tool({
+        name: 'Read',
+        description: 'Read a file from the worktree. Optional 1-based offset/limit for line slices.',
+        inputSchema: z.object({
+          path: z.string().describe('Path relative to the worktree root'),
+          offset: z.number().int().positive().optional(),
+          limit: z.number().int().positive().optional(),
+        }),
+        execute: async ({ path: rel, offset, limit }) => {
+          const full = resolveInWorktree(root, rel);
+          const text = fs.readFileSync(full, 'utf8');
+          const lines = text.split('\n');
+          const start = offset ? Math.max(0, offset - 1) : 0;
+          const slice = limit ? lines.slice(start, start + limit) : lines.slice(start);
+          const numbered = slice.map((line, i) => `${String(start + i + 1).padStart(6)}\t${line}`);
+          return numbered.join('\n') || '(empty file)';
+        },
+      })
+    );
+  }
+
+  if (allowed.has('Write')) {
+    tools.push(
+      tool({
+        name: 'Write',
+        description: 'Write a file in the worktree, creating parent directories as needed.',
+        inputSchema: z.object({
+          path: z.string().describe('Path relative to the worktree root'),
+          content: z.string().describe('Full file contents'),
+        }),
+        execute: async ({ path: rel, content }) => {
+          const full = resolveInWorktree(root, rel);
+          fs.mkdirSync(path.dirname(full), { recursive: true });
+          fs.writeFileSync(full, content, 'utf8');
+          return `Wrote ${relToRoot(root, full)} (${Buffer.byteLength(content, 'utf8')} bytes)`;
+        },
+      })
+    );
+  }
+
+  if (allowed.has('Edit')) {
+    tools.push(
+      tool({
+        name: 'Edit',
+        description:
+          'Replace exact text in a file. old_string must match uniquely unless replace_all is true.',
+        inputSchema: z.object({
+          path: z.string(),
+          old_string: z.string(),
+          new_string: z.string(),
+          replace_all: z.boolean().optional(),
+        }),
+        execute: async ({ path: rel, old_string, new_string, replace_all }) => {
+          const full = resolveInWorktree(root, rel);
+          const before = fs.readFileSync(full, 'utf8');
+          const count = before.split(old_string).length - 1;
+          if (count === 0) {
+            throw new Error(`old_string not found in ${rel}`);
+          }
+          if (count > 1 && !replace_all) {
+            throw new Error(
+              `old_string found ${count} times in ${rel}. Pass replace_all true or include more context.`
+            );
+          }
+          const after = replace_all
+            ? before.split(old_string).join(new_string)
+            : before.replace(old_string, new_string);
+          fs.writeFileSync(full, after, 'utf8');
+          return `Edited ${relToRoot(root, full)} (${count} replacement${count === 1 ? '' : 's'})`;
+        },
+      })
+    );
+  }
+
+  if (allowed.has('Glob')) {
+    tools.push(
+      tool({
+        name: 'Glob',
+        description: 'Find files in the worktree matching a glob pattern (e.g. **/*.js).',
+        inputSchema: z.object({
+          pattern: z.string(),
+          path: z.string().optional().describe('Subdirectory to search from'),
+        }),
+        execute: async ({ pattern, path: sub }) => {
+          const re = globToRegExp(pattern);
+          const files = listWorktreeFiles(root, sub)
+            .map((abs) => relToRoot(root, abs))
+            .filter((rel) => re.test(rel) || re.test(rel.split('/').pop() || rel));
+          if (files.length === 0) return '(no matches)';
+          return files.sort().join('\n');
+        },
+      })
+    );
+  }
+
+  if (allowed.has('Grep')) {
+    tools.push(
+      tool({
+        name: 'Grep',
+        description: 'Search file contents in the worktree with a regular expression.',
+        inputSchema: z.object({
+          pattern: z.string(),
+          path: z.string().optional(),
+          glob: z.string().optional(),
+        }),
+        execute: async ({ pattern, path: sub, glob }) => {
+          let re;
+          try {
+            re = new RegExp(pattern);
+          } catch (err) {
+            throw new Error(`Invalid regex: ${err instanceof Error ? err.message : String(err)}`);
+          }
+          const globRe = glob ? globToRegExp(glob) : null;
+          /** @type {string[]} */
+          const hits = [];
+          for (const abs of listWorktreeFiles(root, sub)) {
+            const rel = relToRoot(root, abs);
+            if (globRe && !globRe.test(rel) && !globRe.test(path.basename(rel))) continue;
+            let text;
+            try {
+              text = fs.readFileSync(abs, 'utf8');
+            } catch {
+              continue;
+            }
+            const lines = text.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+              if (re.test(lines[i])) {
+                hits.push(`${rel}:${i + 1}:${lines[i]}`);
+                if (hits.length >= 200) {
+                  hits.push('… truncated at 200 matches');
+                  return hits.join('\n');
+                }
+              }
+            }
+          }
+          return hits.length ? hits.join('\n') : '(no matches)';
+        },
+      })
+    );
+  }
+
+  if (allowed.has('Bash')) {
+    tools.push(
+      tool({
+        name: 'Bash',
+        description: 'Run a shell command in the worktree. Returns stdout and stderr.',
+        inputSchema: z.object({
+          command: z.string(),
+        }),
+        execute: async ({ command }) => {
+          const cmd = String(command || '').trim();
+          if (!cmd) throw new Error('command is required');
+          const shell = process.env.SHELL || '/bin/bash';
+          try {
+            const { stdout, stderr } = await execFileAsync(shell, ['-lc', cmd], {
+              cwd: root,
+              timeout: 120_000,
+              maxBuffer: 4 * 1024 * 1024,
+              env: { ...process.env },
+            });
+            const out = [stdout, stderr].filter((s) => String(s || '').trim()).join('\n');
+            return out.trim() || '(no output)';
+          } catch (err) {
+            const e = /** @type {NodeJS.ErrnoException & { stdout?: string, stderr?: string }} */ (
+              err
+            );
+            const bits = [
+              e.stderr,
+              e.stdout,
+              e.message,
+            ]
+              .map((s) => String(s || '').trim())
+              .filter(Boolean);
+            throw new Error(bits.join('\n') || 'Command failed');
+          }
+        },
+      })
+    );
+  }
+
+  return tools;
+}

package/src/server.js

@@ -33,14 +33,15 @@ import {
   runAgentOnReviewFeedback,
   stripAiAttribution,
 } from './agent.js';
-import { publicConfig, updateConfig } from './config.js';
+import { publicConfig, updateConfig, normalizeLlmProvider } from './config.js';
 import { upsertEnvVars } from './env.js';
 import { listModels } from './models.js';
 import { splitIssueUrls } from './urls.js';
 import { usageFromLogs, withJobUsage } from './usage.js';
 import { checkGhAuth } from './gh-auth.js';
 import { checkClaudeAuth } from './claude-auth.js';
-import { isValidModelId, isNoModel, NO_MODEL } from './models.js';
+import { checkOpenRouterAuth } from './openrouter-auth.js';
+import { isValidModelId, isNoModel, NO_MODEL, isModelIdForProvider } from './models.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -233,15 +234,39 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
         };
       }
 
-      const claude = doCheckClaudeAuth();
-      if (!claude.ok) {
+      const provider = normalizeLlmProvider(config.llmProvider);
+      if (!isModelIdForProvider(model, provider)) {
         return {
           status: 400,
           error:
-            'Claude is not authenticated. Add an API key or OAuth token in Settings → Authentication, run claude auth login, or start with --stub-agent.',
-          code: 'claude_auth_required',
+            provider === 'openrouter'
+              ? 'Invalid OpenRouter model. Choose a model from the OpenRouter catalog in Settings → Configuration.'
+              : 'Invalid Claude model. Choose a model in Settings → Configuration.',
+          code: 'model_invalid',
         };
       }
+
+      if (provider === 'openrouter') {
+        const orAuth = checkOpenRouterAuth();
+        if (!orAuth.ok) {
+          return {
+            status: 400,
+            error:
+              'OpenRouter is not authenticated. Add an API key in Settings → Authentication, or start with --stub-agent.',
+            code: 'openrouter_auth_required',
+          };
+        }
+      } else {
+        const claude = doCheckClaudeAuth();
+        if (!claude.ok) {
+          return {
+            status: 400,
+            error:
+              'Claude is not authenticated. Add an API key or OAuth token in Settings → Authentication, run claude auth login, or start with --stub-agent.',
+            code: 'claude_auth_required',
+          };
+        }
+      }
     }
 
     return null;
@@ -348,29 +373,6 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
         issueType,
         issueTitle
       );
-      // #region agent log
-      try {
-        fs.appendFileSync(
-          '/Users/giancarlogarcia/Documents/Personal/Projects-2026/agent-mcp/.cursor/debug-473a78.log',
-          `${JSON.stringify({
-            sessionId: '473a78',
-            runId: 'pre-fix',
-            hypothesisId: 'C',
-            location: 'src/server.js:resolveDesiredBranchName',
-            message: 'resolved worktree branch name',
-            data: {
-              preferred: job.preferredBranchName ?? null,
-              issueType,
-              usedCustom: Boolean(job.preferredBranchName),
-              desiredBranchName,
-            },
-            timestamp: Date.now(),
-          })}\n`
-        );
-      } catch {
-        // ignore debug log failures
-      }
-      // #endregion
       const worktreeId = worktreeIdForJob(job);
       if (worktreeId == null) {
         throw new Error('Job is missing issueNumber / jiraKey for worktree path');
@@ -599,7 +601,18 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
         req.query.refresh === '1' ||
         req.query.refresh === 'true' ||
         req.query.force === '1';
-      const result = await listModels({ selected: config.model, force });
+      const provider = normalizeLlmProvider(
+        typeof req.query.provider === 'string' ? req.query.provider : config.llmProvider
+      );
+      const selected =
+        provider === normalizeLlmProvider(config.llmProvider)
+          ? config.model
+          : config.lastModelsByProvider?.[provider];
+      const result = await listModels({
+        selected,
+        force,
+        provider,
+      });
       res.json(result);
     } catch (err) {
       res.status(500).json({ error: err.message });
@@ -623,6 +636,7 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
       applySecretField(envPatch, 'GH_TOKEN', patch.ghToken);
       applySecretField(envPatch, 'ANTHROPIC_API_KEY', patch.anthropicApiKey);
       applySecretField(envPatch, 'CLAUDE_CODE_OAUTH_TOKEN', patch.claudeOauthToken);
+      applySecretField(envPatch, 'OPENROUTER_API_KEY', patch.openrouterApiKey);
       if (patch.jiraBaseUrl !== undefined && typeof patch.jiraBaseUrl === 'string') {
         // Also mirror base URL into env for convenience when set via Settings
         const trimmed = patch.jiraBaseUrl.trim();
@@ -640,6 +654,7 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
         ghToken: _gh,
         anthropicApiKey: _ak,
         claudeOauthToken: _oa,
+        openrouterApiKey: _or,
         ...configPatch
       } = patch;
       updateConfig(repoRoot, config, configPatch);
@@ -691,29 +706,6 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
         return res.status(400).json({ error: preferredParsed.error });
       }
       const preferredBranchName = preferredParsed.value;
-      // #region agent log
-      try {
-        fs.appendFileSync(
-          '/Users/giancarlogarcia/Documents/Personal/Projects-2026/agent-mcp/.cursor/debug-473a78.log',
-          `${JSON.stringify({
-            sessionId: '473a78',
-            runId: 'pre-fix',
-            hypothesisId: 'A',
-            location: 'src/server.js:POST /api/issues',
-            message: 'enqueue preferred branch parse',
-            data: {
-              rawProvided: req.body?.branchName != null,
-              rawType: typeof req.body?.branchName,
-              preferredBranchName: preferredBranchName ?? null,
-              urlCount: urls.length,
-            },
-            timestamp: Date.now(),
-          })}\n`
-        );
-      } catch {
-        // ignore debug log failures
-      }
-      // #endregion
 
       const ticketSource =
         req.body?.ticketSource === 'jira' || req.body?.ticketSource === 'github'

package/src/usage.js

@@ -70,6 +70,41 @@ export function extractUsageFromResult(message) {
   return out;
 }
 
+/**
+ * Map OpenRouter Agent SDK getUsage() totals onto JobUsage.
+ * @param {object | null | undefined} totals
+ * @param {{ durationMs?: number, numTurns?: number }} [extra]
+ * @returns {JobUsage | null}
+ */
+export function extractUsageFromOpenRouter(totals, extra = {}) {
+  if (!totals || typeof totals !== 'object') return null;
+  const totalCostUsd = asFiniteNumber(totals.cost);
+  const inputTokens = asFiniteNumber(totals.inputTokens);
+  const outputTokens = asFiniteNumber(totals.outputTokens);
+  const cacheReadInputTokens = asFiniteNumber(totals.cachedTokens);
+  const numTurns = asFiniteNumber(extra.numTurns ?? totals.modelCalls);
+  const durationMs = asFiniteNumber(extra.durationMs);
+
+  const hasSignal =
+    totalCostUsd !== undefined ||
+    inputTokens !== undefined ||
+    outputTokens !== undefined ||
+    cacheReadInputTokens !== undefined ||
+    numTurns !== undefined;
+
+  if (!hasSignal) return null;
+
+  /** @type {JobUsage} */
+  const out = {};
+  if (totalCostUsd !== undefined) out.totalCostUsd = totalCostUsd;
+  if (inputTokens !== undefined) out.inputTokens = inputTokens;
+  if (outputTokens !== undefined) out.outputTokens = outputTokens;
+  if (cacheReadInputTokens !== undefined) out.cacheReadInputTokens = cacheReadInputTokens;
+  if (numTurns !== undefined) out.numTurns = numTurns;
+  if (durationMs !== undefined) out.durationMs = durationMs;
+  return out;
+}
+
 /**
  * Scan job logs for the last `agent_event` whose payload is a `result` message
  * that carries usage/cost fields. Used to backfill older jobs.