@zachjxyz/moxie 0.2.4 → 0.3.0

package/lib/gateway-agent.mjs

@@ -0,0 +1,549 @@
+#!/usr/bin/env node
+// moxie/lib/gateway-agent.mjs — AI Gateway agentic client
+// Zero npm dependencies. Node 14+ compatible (uses https.request, not fetch).
+// Receives prompt as argv[2], config from env vars.
+
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, existsSync } from 'fs';
+import { resolve, dirname, basename, join, relative } from 'path';
+import { execSync } from 'child_process';
+import https from 'https';
+import http from 'http';
+
+// ---- Config ----
+
+const API_KEY = process.env.GATEWAY_API_KEY;
+const ENDPOINT = process.env.GATEWAY_ENDPOINT || 'https://ai-gateway.vercel.sh';
+const MODEL = process.env.GATEWAY_MODEL;
+const MAX_TURNS = parseInt(process.env.GATEWAY_MAX_TURNS || '50', 10);
+const IDLE_TIMEOUT_MS = parseInt(process.env.GATEWAY_IDLE_TIMEOUT || '120000', 10);
+const PHASE = process.env.GATEWAY_PHASE || 'unknown';
+const AGENT_NAME = process.env.GATEWAY_AGENT || 'unknown';
+const CWD = process.cwd();
+
+if (!API_KEY) { process.stderr.write('ERROR: GATEWAY_API_KEY not set\n'); process.exit(1); }
+if (!MODEL) { process.stderr.write('ERROR: GATEWAY_MODEL not set\n'); process.exit(1); }
+
+const prompt = process.argv[2];
+if (!prompt) { process.stderr.write('ERROR: No prompt provided\n'); process.exit(1); }
+
+// ---- Tool implementations ----
+
+function toolReadFile(args) {
+  const filepath = resolve(CWD, args.path);
+  if (!existsSync(filepath)) return `Error: File not found: ${args.path}`;
+  const content = readFileSync(filepath, 'utf8');
+  const lines = content.split('\n');
+  const offset = (args.offset || 1) - 1;
+  const limit = args.limit || lines.length;
+  const slice = lines.slice(offset, offset + limit);
+  return slice.map((line, i) => `${offset + i + 1}\t${line}`).join('\n');
+}
+
+function toolWriteFile(args) {
+  const filepath = resolve(CWD, args.path);
+  mkdirSync(dirname(filepath), { recursive: true });
+  writeFileSync(filepath, args.content, 'utf8');
+  return `Written ${args.content.length} bytes to ${args.path}`;
+}
+
+function toolEditFile(args) {
+  const filepath = resolve(CWD, args.path);
+  if (!existsSync(filepath)) return `Error: File not found: ${args.path}`;
+  const content = readFileSync(filepath, 'utf8');
+  const count = content.split(args.old_string).length - 1;
+  if (count === 0) return `Error: old_string not found in ${args.path}`;
+  if (count > 1 && !args.replace_all) return `Error: old_string found ${count} times in ${args.path}. Set replace_all to true, or provide more context to make it unique.`;
+  const updated = args.replace_all
+    ? content.split(args.old_string).join(args.new_string)
+    : content.replace(args.old_string, args.new_string);
+  writeFileSync(filepath, updated, 'utf8');
+  return `Edited ${args.path} (${count} replacement${count > 1 ? 's' : ''})`;
+}
+
+function toolRunCommand(args) {
+  const timeout = args.timeout || 60000;
+  try {
+    const output = execSync(args.command, {
+      cwd: CWD,
+      timeout,
+      maxBuffer: 1024 * 1024,
+      encoding: 'utf8',
+      shell: true,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const result = (output || '').slice(0, 102400);
+    return result || '(no output)';
+  } catch (err) {
+    const stderr = err.stderr ? err.stderr.slice(0, 51200) : '';
+    const stdout = err.stdout ? err.stdout.slice(0, 51200) : '';
+    return `Exit code: ${err.status || 1}\nstdout:\n${stdout}\nstderr:\n${stderr}`;
+  }
+}
+
+function toolListDirectory(args) {
+  const dirpath = resolve(CWD, args.path || '.');
+  if (!existsSync(dirpath)) return `Error: Directory not found: ${args.path}`;
+  const entries = readdirSync(dirpath, { withFileTypes: true });
+  return entries.map(e => {
+    const suffix = e.isDirectory() ? '/' : e.isSymbolicLink() ? '@' : '';
+    return `${e.name}${suffix}`;
+  }).join('\n');
+}
+
+function toolGlob(args) {
+  const base = resolve(CWD, args.path || '.');
+  const regex = globToRegex(args.pattern);
+  const matches = [];
+  walkDir(base, base, regex, matches, 0);
+  return matches.slice(0, 500).join('\n') || '(no matches)';
+}
+
+function walkDir(root, dir, regex, matches, depth) {
+  if (depth > 20) return;
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    if (e.name.startsWith('.') || e.name === 'node_modules' || e.name === '__pycache__') continue;
+    const full = join(dir, e.name);
+    const rel = relative(root, full);
+    if (e.isDirectory()) {
+      walkDir(root, full, regex, matches, depth + 1);
+    }
+    if (regex.test(rel)) matches.push(rel);
+  }
+}
+
+function globToRegex(pattern) {
+  let re = '';
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === '*' && pattern[i + 1] === '*') {
+      re += '.*';
+      i += pattern[i + 2] === '/' ? 3 : 2;
+    } else if (c === '*') {
+      re += '[^/]*';
+      i++;
+    } else if (c === '?') {
+      re += '[^/]';
+      i++;
+    } else if (c === '.') {
+      re += '\\.';
+      i++;
+    } else {
+      re += c;
+      i++;
+    }
+  }
+  return new RegExp('^' + re + '$');
+}
+
+function toolGrep(args) {
+  const searchPath = resolve(CWD, args.path || '.');
+  const includeFlag = args.include ? `--include="${args.include}"` : '';
+  try {
+    const cmd = `grep -rn ${includeFlag} -- ${JSON.stringify(args.pattern)} ${JSON.stringify(searchPath)} 2>/dev/null | head -200`;
+    const output = execSync(cmd, { encoding: 'utf8', maxBuffer: 512 * 1024, timeout: 30000 });
+    return (output || '').slice(0, 51200) || '(no matches)';
+  } catch (err) {
+    if (err.status === 1) return '(no matches)';
+    return `Error: ${err.message}`;
+  }
+}
+
+function executeTool(name, args) {
+  try {
+    switch (name) {
+      case 'read_file': return toolReadFile(args);
+      case 'write_file': return toolWriteFile(args);
+      case 'edit_file': return toolEditFile(args);
+      case 'run_command': return toolRunCommand(args);
+      case 'list_directory': return toolListDirectory(args);
+      case 'glob': return toolGlob(args);
+      case 'grep': return toolGrep(args);
+      default: return `Error: Unknown tool: ${name}`;
+    }
+  } catch (err) {
+    return `Error executing ${name}: ${err.message}`;
+  }
+}
+
+// ---- Tool definitions (OpenAI format) ----
+
+const TOOL_DEFINITIONS = [
+  {
+    type: 'function',
+    function: {
+      name: 'read_file',
+      description: 'Read the contents of a file. Returns lines with line numbers.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path relative to project root' },
+          offset: { type: 'integer', description: 'Start reading from this line number (1-based)' },
+          limit: { type: 'integer', description: 'Maximum number of lines to read' },
+        },
+        required: ['path'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'write_file',
+      description: 'Write content to a file. Creates parent directories if needed.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path relative to project root' },
+          content: { type: 'string', description: 'Content to write' },
+        },
+        required: ['path', 'content'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'edit_file',
+      description: 'Replace a string in a file. Fails if old_string is not found or is ambiguous.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path relative to project root' },
+          old_string: { type: 'string', description: 'Text to find and replace' },
+          new_string: { type: 'string', description: 'Replacement text' },
+          replace_all: { type: 'boolean', description: 'Replace all occurrences (default false)' },
+        },
+        required: ['path', 'old_string', 'new_string'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_command',
+      description: 'Execute a shell command and return its output.',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'Shell command to execute' },
+          timeout: { type: 'integer', description: 'Timeout in milliseconds (default 60000)' },
+        },
+        required: ['command'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'list_directory',
+      description: 'List files and directories. Directories have / suffix, symlinks have @ suffix.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Directory path relative to project root' },
+        },
+        required: ['path'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'glob',
+      description: 'Find files matching a glob pattern (supports *, **, ?).',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: { type: 'string', description: 'Glob pattern (e.g., "**/*.ts", "src/*.js")' },
+          path: { type: 'string', description: 'Base directory (default: project root)' },
+        },
+        required: ['pattern'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'grep',
+      description: 'Search file contents using regex. Returns matching lines with file paths and line numbers.',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: { type: 'string', description: 'Regex pattern to search for' },
+          path: { type: 'string', description: 'File or directory to search (default: project root)' },
+          include: { type: 'string', description: 'File pattern filter (e.g., "*.ts")' },
+        },
+        required: ['pattern'],
+      },
+    },
+  },
+];
+
+// ---- System prompt ----
+
+const SYSTEM_PROMPT = `You are a coding agent working in the directory: ${CWD}
+
+You have access to tools for reading, writing, and editing files, running shell commands, listing directories, and searching code. Use these tools to accomplish the task given to you.
+
+Rules:
+- Always use tools to read files before modifying them.
+- Use tools to verify your work (e.g., read a file after editing to confirm the change).
+- When editing files, provide enough surrounding context in old_string to make the match unique.
+- Be thorough and complete the task fully.`;
+
+// ---- SSE streaming API client ----
+
+function chatCompletion(messages) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(`${ENDPOINT}/v1/chat/completions`);
+    const isHttps = url.protocol === 'https:';
+    const mod = isHttps ? https : http;
+
+    const body = JSON.stringify({
+      model: MODEL,
+      messages,
+      tools: TOOL_DEFINITIONS,
+      tool_choice: 'auto',
+      stream: true,
+      stream_options: { include_usage: true },
+      providerOptions: {
+        gateway: {
+          tags: [`project:moxie`, `phase:${PHASE}`, `agent:${AGENT_NAME}`],
+          user: 'moxie',
+        },
+      },
+    });
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${API_KEY}`,
+        'Content-Length': Buffer.byteLength(body),
+      },
+    };
+
+    const req = mod.request(options, (res) => {
+      if (res.statusCode !== 200) {
+        let errBody = '';
+        res.on('data', (chunk) => { errBody += chunk; });
+        res.on('end', () => {
+          process.stderr.write(`API error ${res.statusCode}: ${errBody.slice(0, 2000)}\n`);
+          reject(new Error(`API error ${res.statusCode}`));
+        });
+        return;
+      }
+
+      let buffer = '';
+      let content = '';
+      const toolCalls = new Map(); // index -> { id, name, arguments }
+      let usage = null;
+      let idleTimer = null;
+
+      const resetIdle = () => {
+        if (idleTimer) clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+          process.stderr.write(`Idle timeout (${IDLE_TIMEOUT_MS}ms) — no SSE events received\n`);
+          req.destroy();
+          reject(new Error('Idle timeout'));
+        }, IDLE_TIMEOUT_MS);
+      };
+
+      resetIdle();
+
+      res.on('data', (chunk) => {
+        resetIdle();
+        buffer += chunk.toString();
+
+        const lines = buffer.split('\n');
+        buffer = lines.pop(); // keep incomplete line in buffer
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith(':')) continue;
+          if (!trimmed.startsWith('data: ')) continue;
+
+          const data = trimmed.slice(6);
+          if (data === '[DONE]') continue;
+
+          let parsed;
+          try { parsed = JSON.parse(data); } catch { continue; }
+
+          // Usage comes in a separate chunk (stream_options.include_usage)
+          if (parsed.usage) {
+            usage = parsed.usage;
+          }
+
+          const choice = parsed.choices && parsed.choices[0];
+          if (!choice) continue;
+
+          const delta = choice.delta;
+          if (!delta) continue;
+
+          // Stream text content
+          if (delta.content) {
+            content += delta.content;
+            process.stdout.write(delta.content);
+          }
+
+          // Accumulate tool calls
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index;
+              if (!toolCalls.has(idx)) {
+                toolCalls.set(idx, { id: tc.id || '', name: '', arguments: '' });
+              }
+              const entry = toolCalls.get(idx);
+              if (tc.id) entry.id = tc.id;
+              if (tc.function) {
+                if (tc.function.name) entry.name = tc.function.name;
+                if (tc.function.arguments) entry.arguments += tc.function.arguments;
+              }
+            }
+          }
+        }
+      });
+
+      res.on('end', () => {
+        if (idleTimer) clearTimeout(idleTimer);
+
+        // Convert Map to sorted array
+        const sortedTools = [];
+        const indices = Array.from(toolCalls.keys()).sort((a, b) => a - b);
+        for (const idx of indices) {
+          const tc = toolCalls.get(idx);
+          sortedTools.push({
+            id: tc.id,
+            type: 'function',
+            function: { name: tc.name, arguments: tc.arguments },
+          });
+        }
+
+        resolve({ content, toolCalls: sortedTools, usage });
+      });
+
+      res.on('error', (err) => {
+        if (idleTimer) clearTimeout(idleTimer);
+        reject(err);
+      });
+    });
+
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+// ---- Agentic loop ----
+
+async function agentLoop() {
+  const messages = [
+    { role: 'system', content: SYSTEM_PROMPT },
+    { role: 'user', content: prompt },
+  ];
+
+  const totalUsage = { input_tokens: 0, output_tokens: 0 };
+
+  for (let turn = 0; turn < MAX_TURNS; turn++) {
+    let response;
+    try {
+      response = await chatCompletion(messages);
+    } catch (err) {
+      process.stderr.write(`\nAPI call failed on turn ${turn + 1}: ${err.message}\n`);
+      // Retry once
+      if (turn === 0 || err.message.includes('Idle timeout')) {
+        process.stderr.write('Retrying...\n');
+        await new Promise(r => setTimeout(r, 2000));
+        try {
+          response = await chatCompletion(messages);
+        } catch (retryErr) {
+          process.stderr.write(`Retry failed: ${retryErr.message}\n`);
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+
+    // Accumulate usage
+    if (response.usage) {
+      totalUsage.input_tokens += response.usage.prompt_tokens || 0;
+      totalUsage.output_tokens += response.usage.completion_tokens || 0;
+    }
+
+    // No tool calls = final response
+    if (!response.toolCalls || response.toolCalls.length === 0) {
+      break;
+    }
+
+    // Add assistant message with tool calls
+    messages.push({
+      role: 'assistant',
+      content: response.content || null,
+      tool_calls: response.toolCalls,
+    });
+
+    // Execute each tool
+    for (const tc of response.toolCalls) {
+      let args;
+      try {
+        args = JSON.parse(tc.function.arguments);
+      } catch {
+        args = {};
+        process.stderr.write(`Failed to parse tool args for ${tc.function.name}\n`);
+      }
+
+      // Log tool call summary
+      const summary = Object.entries(args)
+        .filter(([, v]) => typeof v === 'string' && v.length < 80)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(', ');
+      process.stdout.write(`\n[tool: ${tc.function.name}] ${summary}\n`);
+
+      const result = executeTool(tc.function.name, args);
+
+      messages.push({
+        role: 'tool',
+        tool_call_id: tc.id,
+        content: typeof result === 'string' ? result : JSON.stringify(result),
+      });
+    }
+  }
+
+  return totalUsage;
+}
+
+// ---- Main ----
+
+try {
+  const usage = await agentLoop();
+
+  // Emit final result line for moxie's token extraction (Strategy 2)
+  process.stdout.write('\n');
+  process.stdout.write(JSON.stringify({
+    type: 'result',
+    subtype: 'success',
+    usage: {
+      input_tokens: usage.input_tokens,
+      output_tokens: usage.output_tokens,
+    },
+  }) + '\n');
+
+  process.exit(0);
+} catch (err) {
+  process.stderr.write(`\nFatal error: ${err.message}\n`);
+  // Still emit a result line so token extraction doesn't fail
+  process.stdout.write('\n');
+  process.stdout.write(JSON.stringify({
+    type: 'result',
+    subtype: 'error',
+    is_error: true,
+    usage: { input_tokens: 0, output_tokens: 0 },
+  }) + '\n');
+  process.exit(1);
+}

package/lib/gateway-cost.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+// moxie/lib/gateway-cost.mjs — Fetch cost data from Vercel AI Gateway Reporting API
+// Zero npm dependencies. Node 14+ compatible.
+// Usage: GATEWAY_API_KEY=xxx node gateway-cost.mjs <endpoint> <start_date> <end_date>
+
+import https from 'https';
+import http from 'http';
+
+const API_KEY = process.env.GATEWAY_API_KEY;
+const endpoint = process.argv[2] || 'https://ai-gateway.vercel.sh';
+const startDate = process.argv[3];
+const endDate = process.argv[4];
+
+if (!API_KEY) { process.stderr.write('ERROR: GATEWAY_API_KEY not set\n'); process.exit(1); }
+if (!startDate || !endDate) { process.stderr.write('ERROR: start_date and end_date required\n'); process.exit(1); }
+
+const url = new URL(`${endpoint}/v1/report`);
+url.searchParams.set('start_date', startDate);
+url.searchParams.set('end_date', endDate);
+url.searchParams.set('group_by', 'tag');
+url.searchParams.set('filter_tag', 'project:moxie');
+
+const isHttps = url.protocol === 'https:';
+const mod = isHttps ? https : http;
+
+const options = {
+  hostname: url.hostname,
+  port: url.port || (isHttps ? 443 : 80),
+  path: url.pathname + url.search,
+  method: 'GET',
+  headers: {
+    'Authorization': `Bearer ${API_KEY}`,
+    'Accept': 'application/json',
+  },
+};
+
+const req = mod.request(options, (res) => {
+  let body = '';
+  res.on('data', (chunk) => { body += chunk; });
+  res.on('end', () => {
+    if (res.statusCode !== 200) {
+      process.stderr.write(`API error ${res.statusCode}: ${body.slice(0, 500)}\n`);
+      process.exit(1);
+    }
+
+    try {
+      const data = JSON.parse(body);
+      const rows = data.results || data.data || data || [];
+
+      // Normalize into a flat cost array filtered to agent: tags
+      const costs = [];
+      for (const row of (Array.isArray(rows) ? rows : [])) {
+        const tag = row.tag || row.group || '';
+        if (!tag.startsWith('agent:')) continue;
+        costs.push({
+          agent: tag.replace('agent:', ''),
+          total_cost: parseFloat(row.total_cost || 0),
+          market_cost: parseFloat(row.market_cost || 0),
+          input_tokens: parseInt(row.input_tokens || 0, 10),
+          output_tokens: parseInt(row.output_tokens || 0, 10),
+          request_count: parseInt(row.request_count || 0, 10),
+        });
+      }
+
+      process.stdout.write(JSON.stringify({ costs }) + '\n');
+    } catch (err) {
+      process.stderr.write(`Failed to parse response: ${err.message}\n`);
+      process.exit(1);
+    }
+  });
+});
+
+req.on('error', (err) => {
+  process.stderr.write(`Network error: ${err.message}\n`);
+  process.exit(1);
+});
+
+req.end();