acdev 1.0.10 → 1.0.12

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;
+}