acdev 1.0.9 → 1.0.11

package/src/openrouter-agent.js

@@ -0,0 +1,142 @@
+import { OpenRouter, stepCountIs } from '@openrouter/agent';
+import { extractUsageFromOpenRouter } from './usage.js';
+import { checkOpenRouterAuth, openRouterApiKey } from './openrouter-auth.js';
+import { buildOpenRouterCodingTools } from './openrouter-tools.js';
+
+/**
+ * @param {{
+ *   name?: string,
+ *   arguments?: unknown,
+ *   input?: unknown,
+ * }} call
+ */
+function toolUseEvent(call) {
+  const name = call?.name || 'tool';
+  const input = call?.arguments ?? call?.input ?? {};
+  return {
+    type: 'assistant',
+    message: {
+      content: [{ type: 'tool_use', name, input }],
+    },
+  };
+}
+
+/**
+ * Run the OpenRouter Agent SDK against a worktree with the same coding tools
+ * Claude Agent SDK exposes (Read/Glob/Grep/Edit/Write/Bash).
+ *
+ * @param {{
+ *   prompt: string,
+ *   worktreePath: string,
+ *   config: object,
+ *   onEvent: (message: unknown) => void,
+ *   callModelFn?: (args: object) => object,
+ * }} params
+ */
+export async function runOpenRouterQuery({
+  prompt,
+  worktreePath,
+  config,
+  onEvent,
+  callModelFn,
+}) {
+  const auth = checkOpenRouterAuth();
+  if (!auth.ok && !callModelFn) {
+    throw new Error(
+      'OpenRouter is not authenticated. Add OPENROUTER_API_KEY in Settings → Authentication.'
+    );
+  }
+
+  const timeoutMs = config.agentTimeoutMs ?? 900_000;
+  const maxTurns = Math.max(1, Number(config.maxAgentTurns) || 30);
+  const model = String(config.model || '').trim();
+  if (!model) {
+    throw new Error('No OpenRouter model selected');
+  }
+
+  const tools = buildOpenRouterCodingTools(worktreePath, config.allowedTools || []);
+  const abortController = new AbortController();
+  const started = Date.now();
+
+  const run = async () => {
+    let result;
+    if (callModelFn) {
+      result = callModelFn({
+        model,
+        input: prompt,
+        tools,
+        stopWhen: stepCountIs(maxTurns),
+        signal: abortController.signal,
+      });
+    } else {
+      const client = new OpenRouter({ apiKey: openRouterApiKey() });
+      result = client.callModel({
+        model,
+        input: prompt,
+        tools,
+        stopWhen: stepCountIs(maxTurns),
+        signal: abortController.signal,
+      });
+    }
+
+    if (result?.getToolCallsStream) {
+      void (async () => {
+        try {
+          for await (const call of result.getToolCallsStream()) {
+            onEvent(toolUseEvent(call));
+          }
+        } catch {
+          // stream may abort after success
+        }
+      })();
+    }
+
+    const resultText =
+      typeof result?.getText === 'function' ? await result.getText() : String(result ?? '');
+    let usageRaw = null;
+    if (typeof result?.getUsage === 'function') {
+      try {
+        usageRaw = await result.getUsage();
+      } catch {
+        usageRaw = null;
+      }
+    }
+
+    const usage = extractUsageFromOpenRouter(usageRaw, {
+      durationMs: Date.now() - started,
+      numTurns: usageRaw?.modelCalls,
+    });
+
+    const fakeResult = {
+      type: 'result',
+      subtype: 'success',
+      result: resultText,
+      num_turns: usage?.numTurns,
+      duration_ms: usage?.durationMs,
+      total_cost_usd: usage?.totalCostUsd,
+      usage: {
+        input_tokens: usage?.inputTokens,
+        output_tokens: usage?.outputTokens,
+        cache_read_input_tokens: usage?.cacheReadInputTokens,
+      },
+    };
+    onEvent(fakeResult);
+
+    return { resultText, usage };
+  };
+
+  let timeoutId;
+  try {
+    return await Promise.race([
+      run(),
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          abortController.abort();
+          reject(new Error(`Agent timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}

package/src/openrouter-auth.js

@@ -0,0 +1,41 @@
+/** @typedef {{ ok: true } | { ok: false, reason: 'missing' }} OpenRouterAuthResult */
+
+/** @type {() => NodeJS.ProcessEnv} */
+let envResolver = () => process.env;
+
+/** @param {() => NodeJS.ProcessEnv} fn */
+export function _setEnvResolver(fn) {
+  envResolver = fn;
+}
+
+export function _resetEnvResolver() {
+  envResolver = () => process.env;
+}
+
+/**
+ * OpenRouter API key from env (Settings writes OPENROUTER_API_KEY).
+ * @returns {string}
+ */
+export function openRouterApiKey() {
+  return String(envResolver().OPENROUTER_API_KEY || '').trim();
+}
+
+/**
+ * @returns {OpenRouterAuthResult}
+ */
+export function checkOpenRouterAuth() {
+  if (openRouterApiKey()) return { ok: true };
+  return { ok: false, reason: 'missing' };
+}
+
+/**
+ * @param {OpenRouterAuthResult} [_result]
+ */
+export function formatOpenRouterAuthError(_result) {
+  return [
+    '⚠ OpenRouter is not authenticated — server will still start.',
+    '  Open Settings → Authentication to add an OpenRouter API key',
+    '  (or set OPENROUTER_API_KEY in `.acdev/.env`).',
+    '  For UI-only testing without auth: pass `--stub-agent`.',
+  ].join('\n');
+}

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

@@ -1,4 +1,5 @@
 import express from 'express';
+import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Store } from './store.js';
@@ -18,7 +19,8 @@ import {
   getDiff,
   pushBranch,
   detectIssueType,
-  buildBranchName,
+  parsePreferredBranchName,
+  resolveDesiredBranchName,
   sanitizeBranchCommits,
   listChangedFiles,
   applyFileExclusions,
@@ -31,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));
 
@@ -231,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;
@@ -341,7 +368,11 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
         issueType = detectIssueType(issueDetails);
       }
 
-      const desiredBranchName = buildBranchName(issueType, issueTitle);
+      const desiredBranchName = resolveDesiredBranchName(
+        job.preferredBranchName,
+        issueType,
+        issueTitle
+      );
       const worktreeId = worktreeIdForJob(job);
       if (worktreeId == null) {
         throw new Error('Job is missing issueNumber / jiraKey for worktree path');
@@ -570,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 });
@@ -594,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();
@@ -611,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);
@@ -657,6 +701,12 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
         });
       }
 
+      const preferredParsed = parsePreferredBranchName(req.body?.branchName);
+      if (!preferredParsed.ok) {
+        return res.status(400).json({ error: preferredParsed.error });
+      }
+      const preferredBranchName = preferredParsed.value;
+
       const ticketSource =
         req.body?.ticketSource === 'jira' || req.body?.ticketSource === 'github'
           ? req.body.ticketSource
@@ -751,6 +801,7 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
           issueNumber: item.number,
           ticketSource: item.ticketSource,
           jiraKey: item.jiraKey,
+          ...(preferredBranchName ? { preferredBranchName } : {}),
         });
         created.push(job);
       }

package/src/store.js

@@ -55,6 +55,7 @@ export class Store {
    *   issueNumber?: number,
    *   ticketSource?: 'github' | 'jira',
    *   jiraKey?: string,
+   *   preferredBranchName?: string,
    * }} data
    * @returns {Job}
    */
@@ -68,6 +69,7 @@ export class Store {
       issueNumber: data.issueNumber,
       ticketSource,
       ...(data.jiraKey ? { jiraKey: data.jiraKey } : {}),
+      ...(data.preferredBranchName ? { preferredBranchName: data.preferredBranchName } : {}),
       status: 'queued',
       createdAt: now,
       updatedAt: now,

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.