codeply-cli 0.1.0

package/lib/agent.mjs

@@ -0,0 +1,533 @@
+/**
+ * Codeply agent loop.
+ *
+ * The ai-proxy exposes a plain chat completion — no native function calling —
+ * so tool use rides on a tag protocol the model writes into its reply and we
+ * parse back out. Tags are used rather than JSON because file content goes in
+ * verbatim: no escaping pass to get wrong, and models corrupt long JSON strings
+ * far more often than they corrupt a closing tag.
+ *
+ * runAgent() is an async generator so the TUI can render each step as it lands
+ * instead of freezing until the whole task finishes.
+ */
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { createRequire } from 'module';
+import { executeTool, TOOL_NEEDS_APPROVAL, walkFiles } from './tools.mjs';
+
+const require = createRequire(import.meta.url);
+const ai = require('./ai.js');
+
+const MAX_STEPS = 24;
+const MAX_MALFORMED_RETRIES = 3;
+// Deliberately conservative. The proxy is a Supabase Edge Function with its own
+// memory/CPU ceiling — it returns 546 when it blows through it — so keeping each
+// request small matters more here than squeezing in extra history.
+const CONTEXT_CHAR_BUDGET = 48000;
+
+const FORMAT_CORRECTION =
+  '[system] Your action block was not in the required form. Do not invent wrappers like <toolcall>, ' +
+  'do not drop the "codeply:" prefix, and keep the underscore in the name. Write it exactly like this, ' +
+  'opening and closing tags complete:\n\n' +
+  '<codeply:read_file>\n<path>run.html</path>\n</codeply:read_file>\n\n' +
+  'Valid names: list_dir, read_file, write_file, edit_file, search, run.';
+
+// ─── Protocol ───────────────────────────────────────────────────────────────
+
+const TOOL_TAG = /<codeply:([a-z_]+)>([\s\S]*?)<\/codeply:\1>/g;
+
+// Params whose value is a raw payload (file content, code blocks) and may
+// legitimately contain angle-bracket tags of its own.
+const CONTAINER_PARAMS = new Set(['content', 'search', 'replace']);
+
+/** Tag payloads are written on their own lines; drop only that framing. */
+function trimFraming(value) {
+  return value.replace(/^\r?\n/, '').replace(/\r?\n[ \t]*$/, '');
+}
+
+/**
+ * Pull the parameters out of a tool block.
+ *
+ * Container params are read first-open to last-close, so writing an HTML file
+ * that itself contains `</content>` does not truncate the payload. Their spans
+ * are then masked out before the scalar params are matched — otherwise a
+ * `<path>` appearing inside that same HTML payload would be picked up as the
+ * tool's path. (That is not hypothetical; it is what the test caught.)
+ */
+function extractParams(block, spec) {
+  const args = {};
+  const masked = [...block];
+
+  for (const name of spec) {
+    if (!CONTAINER_PARAMS.has(name)) continue;
+    const open = `<${name}>`;
+    const close = `</${name}>`;
+    const start = block.indexOf(open);
+    if (start === -1) continue;
+    const end = block.lastIndexOf(close);
+    if (end === -1 || end < start + open.length) continue;
+    args[name] = trimFraming(block.slice(start + open.length, end));
+    for (let i = start; i < end + close.length; i++) masked[i] = ' ';
+  }
+
+  const scalarRegion = masked.join('');
+  for (const name of spec) {
+    if (CONTAINER_PARAMS.has(name)) continue;
+    const m = scalarRegion.match(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`));
+    if (m) args[name] = trimFraming(m[1]);
+  }
+
+  return args;
+}
+
+const PARAMS = {
+  list_dir: ['path'],
+  read_file: ['path', 'offset', 'limit'],
+  write_file: ['path', 'content'],
+  edit_file: ['path', 'search', 'replace'],
+  search: ['pattern', 'glob', 'path'],
+  run: ['command'],
+};
+
+// Names the model actually reaches for when it paraphrases the format.
+// Deliberately excludes `search`, `replace`, `content`, `path` and `command`:
+// those are parameter names, and treating them as action names would misread
+// an edit_file block as a search.
+const NAME_ALIASES = {
+  read_file: 'read_file', readfile: 'read_file', read: 'read_file',
+  open: 'read_file', cat: 'read_file', view: 'read_file', openfile: 'read_file',
+  list_dir: 'list_dir', listdir: 'list_dir', list: 'list_dir',
+  ls: 'list_dir', dir: 'list_dir', listfiles: 'list_dir',
+  write_file: 'write_file', writefile: 'write_file', write: 'write_file',
+  create: 'write_file', createfile: 'write_file',
+  edit_file: 'edit_file', editfile: 'edit_file', edit: 'edit_file',
+  grep: 'search', findtext: 'search',
+  run: 'run', bash: 'run', shell: 'run', exec: 'run', runcommand: 'run',
+};
+
+// Any tag whose name resolves to an action, with or without the codeply: prefix.
+const LOOSE_NAME_TAG = new RegExp(
+  `</?\\s*(?:codeply[:_-])?(${Object.keys(NAME_ALIASES).join('|')})\\s*/?>`, 'i'
+);
+
+// Does this reply look like it was *trying* to act, even though nothing parsed?
+const LOOKS_LIKE_ATTEMPT =
+  /<\/?\s*(?:codeply[:_-])?(?:tool_?call|action|function_?call|invoke)\b|<(?:path|command|pattern|content)>/i;
+
+/**
+ * Best-effort recovery when the strict protocol did not match.
+ *
+ * gpt-oss-120b paraphrases the format — inventing a <toolcall> wrapper,
+ * dropping the codeply: prefix, writing "readfile" for "read_file", even
+ * dropping a bracket. Rejecting those wastes the user's turn, so the intent is
+ * reconstructed from whatever survived. Checks run most-specific first: the
+ * parameter tags are stronger evidence than the action name, because the name
+ * is what gets mangled.
+ */
+function recoverCall(text) {
+  const has = (tag) => new RegExp(`<${tag}>`, 'i').test(text);
+
+  let name = null;
+  if (has('content')) name = 'write_file';
+  else if (has('search') && has('replace')) name = 'edit_file';
+  else {
+    const m = text.match(LOOSE_NAME_TAG);
+    if (m) name = NAME_ALIASES[m[1].toLowerCase().replace(/[_-]/g, '')] ?? NAME_ALIASES[m[1].toLowerCase()];
+    if (!name && has('command')) name = 'run';
+    else if (!name && has('pattern')) name = 'search';
+    else if (!name && has('path')) name = 'read_file';
+  }
+  if (!name || !PARAMS[name]) return null;
+
+  const args = extractParams(text, PARAMS[name]);
+  if (Object.keys(args).length === 0) return null;
+  return { name, args, recovered: true };
+}
+
+/**
+ * Split a model reply into prose and the actions embedded in it.
+ * @returns {{prose:string, calls:Array, recovered:boolean, malformed:boolean}}
+ */
+export function parseReply(text) {
+  const calls = [];
+  let prose = '';
+  let lastIndex = 0;
+  TOOL_TAG.lastIndex = 0;
+  let m;
+  while ((m = TOOL_TAG.exec(text)) !== null) {
+    prose += text.slice(lastIndex, m.index);
+    lastIndex = m.index + m[0].length;
+    const name = m[1];
+    const block = m[2];
+    const spec = PARAMS[name];
+    if (!spec) { calls.push({ name, args: {}, unknown: true }); continue; }
+    const args = extractParams(block, spec);
+    // Single-param actions tolerate a bare body: <codeply:read_file>x.js</...>
+    if (spec.length && Object.keys(args).length === 0 && block.trim()) {
+      args[spec[0]] = block.trim();
+    }
+    calls.push({ name, args });
+  }
+  prose += text.slice(lastIndex);
+
+  if (calls.length > 0) {
+    return { prose: prose.trim(), calls, recovered: false, malformed: false };
+  }
+
+  const salvaged = recoverCall(text);
+  if (salvaged) {
+    // Strip the mangled markup so the user reads the intent, not the debris.
+    const cleaned = text
+      .replace(/<\/?[a-z_:]+>/gi, ' ')
+      .replace(/[ \t]{2,}/g, ' ')
+      .trim();
+    return { prose: cleaned, calls: [salvaged], recovered: true, malformed: false };
+  }
+
+  return {
+    prose: prose.trim(),
+    calls: [],
+    recovered: false,
+    malformed: LOOKS_LIKE_ATTEMPT.test(text),
+  };
+}
+
+// ─── Project context ────────────────────────────────────────────────────────
+
+function gitBranch(cwd) {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd, stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000,
+    }).toString().trim();
+  } catch { return null; }
+}
+
+/** A compact snapshot of the project, so the agent starts oriented. */
+export function buildProjectContext(cwd) {
+  const lines = [`Working directory: ${cwd}`, `Platform: ${process.platform}`];
+
+  const branch = gitBranch(cwd);
+  if (branch) lines.push(`Git branch: ${branch}`);
+
+  const pkgPath = path.join(cwd, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      lines.push(`Package: ${pkg.name || '(unnamed)'}${pkg.version ? ' v' + pkg.version : ''}`);
+      if (pkg.scripts) lines.push(`npm scripts: ${Object.keys(pkg.scripts).join(', ')}`);
+      const deps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
+      if (deps.length) lines.push(`Dependencies: ${deps.slice(0, 25).join(', ')}${deps.length > 25 ? ', …' : ''}`);
+    } catch {}
+  }
+
+  const files = walkFiles(cwd, { maxFiles: 300, maxDepth: 4 })
+    .map((f) => path.relative(cwd, f).replace(/\\/g, '/'))
+    .sort();
+  if (files.length) {
+    lines.push('', `Files (${files.length}${files.length >= 300 ? '+' : ''}):`);
+    lines.push(files.slice(0, 200).join('\n'));
+  }
+
+  return lines.join('\n');
+}
+
+// ─── Prompt ─────────────────────────────────────────────────────────────────
+
+// NOTE ON WORDING: this reference deliberately avoids the words "tool",
+// "call" and "function". The proxy runs openai/gpt-oss-120b, whose harmony
+// training has a dedicated channel for function calls — phrasing this as tool
+// calling made it reach for the *native* mechanism, and Groq then rejected the
+// whole response with "Tool choice is none, but model called a tool" because
+// the proxy declares no tools. Framing it as an output format keeps the model
+// writing plain text. Keep it that way.
+const TOOL_REFERENCE = `OUTPUT FORMAT
+
+You have no function-calling ability here. You act purely by writing text.
+When you need something done, write an ACTION BLOCK as literal text in your
+reply, exactly like the examples below, and stop. The program reads your text,
+performs the action, and writes the result back to you as your next message.
+
+Never emit a structured/native function invocation. Write the tags as text.
+
+<codeply:list_dir>
+<path>src</path>
+</codeply:list_dir>
+
+<codeply:read_file>
+<path>src/app.js</path>
+<offset>0</offset>
+<limit>400</limit>
+</codeply:read_file>
+
+<codeply:search>
+<pattern>createServer</pattern>
+<glob>**/*.js</glob>
+</codeply:search>
+
+<codeply:write_file>
+<path>index.html</path>
+<content>
+...the complete new file content, verbatim, no escaping...
+</content>
+</codeply:write_file>
+
+<codeply:edit_file>
+<path>src/app.js</path>
+<search>
+the exact existing lines, copied character for character
+</search>
+<replace>
+those lines with the change applied
+</replace>
+</codeply:edit_file>
+
+<codeply:run>
+<command>node --check index.js</command>
+</codeply:run>
+
+RULES
+- Write at most ONE action block per reply, then stop and wait for its result.
+- Do not waste steps. Every action block costs the user several seconds, so never
+  perform one whose answer you already have:
+  · If the user gave a full path, read it directly — do not list_dir first.
+  · After a successful edit_file or write_file, do NOT read the file back. The
+    result already confirms it applied. Only re-read a part you have not seen.
+  · Do not re-read a file that is already earlier in this conversation.
+- When the result comes back, keep going on your own. Do not ask the user what to do next while you still have obvious work left.
+- read_file before you edit_file. "search" must be copied verbatim from what you just read — never from memory, never with the line-number prefixes the reader adds.
+- edit_file for changes to an existing file. write_file only for new files or a genuine full rewrite.
+- Prefer run for anything you can check mechanically.
+- When the task is finished, reply with prose only and NO action block. That ends your turn.`;
+
+const VERIFY_RULES = `VERIFYING YOUR WORK
+You are not done when the code is written. You are done when it is checked.
+- After editing JS/TS, run a syntax check (e.g. node --check <file>).
+- If the project has a test/lint/build script, run the relevant one.
+- If a command fails, read the error, fix the cause, and run it again. Repeat until it passes or you have a specific reason it cannot.
+- Never report success for something you did not verify. If you could not verify it, say exactly that.`;
+
+const MODE_PROMPT = {
+  Build: `You are Codeply, an autonomous coding agent working in the user's terminal.
+
+Do the work the user asked for, end to end. Explore the project before assuming anything about it — read the actual files, do not guess at their contents or invent APIs. Make the change, then verify it.
+
+${VERIFY_RULES}
+
+LARGE REWRITES
+One enormous reply can exceed the service's limits and fail outright. For a big
+redesign or a file over ~200 lines, work in stages instead: write_file once with
+the full structure and the main sections, then use edit_file to flesh out or
+restyle one section per step. Each reply stays a manageable size and you keep a
+working file at every point.
+
+Keep prose short. A sentence about what you are about to do, then the action block. At the end, a two or three line summary of what changed. No filler, no restating the request back.`,
+
+  Plan: `You are Codeply, working in Plan mode in the user's terminal.
+
+Investigate and produce a concrete plan. You MAY read, list, search, and run read-only commands to ground the plan in what is actually there. You MUST NOT write or edit files in this mode — if the user wants the change applied, tell them to switch to Build mode with tab.
+
+Deliver: what you found, the specific files and functions involved, then numbered steps. Be concrete about file paths and names. Flag anything genuinely ambiguous instead of picking silently.`,
+
+  Ask: `You are Codeply, working in Ask mode in the user's terminal.
+
+Answer the user's question. Read files, search, and list to ground your answer in this specific codebase rather than in generalities. Do not write or edit files in this mode.
+
+Be concise and concrete. Quote the relevant code and cite it as path:line. If the answer is not in the codebase, say so plainly rather than inventing one.`,
+};
+
+const READ_ONLY_MODES = new Set(['Plan', 'Ask']);
+
+export function buildSystemPrompt(mode, cwd) {
+  const parts = [MODE_PROMPT[mode] || MODE_PROMPT.Build, '', TOOL_REFERENCE];
+  if (READ_ONLY_MODES.has(mode)) {
+    parts.push('', 'MODE RESTRICTION: write_file and edit_file are disabled. Using them returns an error. run is limited to read-only commands.');
+  }
+  parts.push('', 'PROJECT CONTEXT', buildProjectContext(cwd));
+  return parts.join('\n');
+}
+
+// ─── Context budget ─────────────────────────────────────────────────────────
+
+/**
+ * Keep the transcript under budget by dropping the oldest tool exchanges.
+ * The system prompt and the most recent turns always survive.
+ */
+function trimTranscript(messages) {
+  let total = messages.reduce((n, m) => n + m.content.length, 0);
+  if (total <= CONTEXT_CHAR_BUDGET) return messages;
+
+  const kept = [...messages];
+  // index 0 is the system prompt; never touch the last 6 messages.
+  for (let i = 1; i < kept.length - 6 && total > CONTEXT_CHAR_BUDGET; i++) {
+    if (kept[i].role === 'user' && kept[i].content.startsWith('[tool result')) {
+      total -= kept[i].content.length;
+      const head = kept[i].content.slice(0, 200);
+      kept[i] = { role: 'user', content: `${head}\n[… older tool output dropped to save context]` };
+      total += kept[i].content.length;
+    }
+  }
+  return kept;
+}
+
+// ─── Model call ─────────────────────────────────────────────────────────────
+
+/**
+ * gpt-oss-120b occasionally reaches for its native function-calling channel
+ * despite the prompt. The proxy declares no tools, so Groq rejects the whole
+ * response and we get back nothing usable. Detect that specific failure and
+ * retry with a correction rather than killing the user's turn.
+ */
+function isNativeToolCallError(error) {
+  const s = String(error || '').toLowerCase();
+  return s.includes('tool choice is none') ||
+    (s.includes('called a tool') && s.includes('tool choice')) ||
+    s.includes('tool_choice');
+}
+
+const NO_NATIVE_TOOLS_REMINDER =
+  '[system] Your last reply tried to invoke a function through the API. That is not available here and the response was discarded. ' +
+  'Write the action block as literal text in your message — the tags exactly as shown in the OUTPUT FORMAT section — and nothing else.';
+
+async function callModel(messages) {
+  let result = await ai.chat(messages);
+  if (result.success || !isNativeToolCallError(result.error)) return { result, messages };
+
+  const corrected = [...messages, { role: 'user', content: NO_NATIVE_TOOLS_REMINDER }];
+  result = await ai.chat(corrected);
+  return { result, messages: corrected };
+}
+
+// ─── Loop ───────────────────────────────────────────────────────────────────
+
+/**
+ * Run one user turn to completion.
+ *
+ * @param {object}   o
+ * @param {string}   o.userMessage
+ * @param {Array}    o.history      prior [{role,content}] turns
+ * @param {string}   o.mode         Build | Plan | Ask
+ * @param {string}   o.cwd
+ * @param {Function} o.approve      async ({tool,title,detail,danger}) => 'once'|'always'|'reject'
+ * @param {{aborted:boolean}} o.signal
+ * @yields {{type:string, ...}} text | tool_start | tool_end | done | error
+ */
+export async function* runAgent({ userMessage, history, mode, cwd, approve, signal }) {
+  const readOnly = READ_ONLY_MODES.has(mode);
+  const messages = [
+    { role: 'system', content: buildSystemPrompt(mode, cwd) },
+    ...history,
+    { role: 'user', content: userMessage },
+  ];
+
+  const ctx = { cwd, approve };
+  const transcript = [{ role: 'user', content: userMessage }];
+  let malformedRetries = 0;
+
+  for (let step = 0; step < MAX_STEPS; step++) {
+    if (signal.aborted) { yield { type: 'aborted' }; return; }
+
+    const attempt = await callModel(trimTranscript(messages));
+    const result = attempt.result;
+    if (!result.success) {
+      yield {
+        type: 'error',
+        error: isNativeToolCallError(result.error)
+          ? `The model kept trying to use the provider's function-calling API, which this proxy does not enable (${result.error}). Try rephrasing, or switch modes with tab.`
+          : result.error,
+      };
+      return;
+    }
+    // The correction message, if one was needed, has to stay in the transcript.
+    if (attempt.messages.length > messages.length) {
+      messages.push(attempt.messages[attempt.messages.length - 1]);
+    }
+
+    // gpt-oss puts chain-of-thought in a separate field; content can be null.
+    const reply = result.data?.choices?.[0]?.message?.content ?? '';
+    if (!reply.trim()) {
+      messages.push({
+        role: 'user',
+        content: '[system] Your last reply was empty. Either write one action block as text, or give your final answer.',
+      });
+      continue;
+    }
+    messages.push({ role: 'assistant', content: reply });
+
+    const { prose, calls, recovered, malformed } = parseReply(reply);
+    if (prose) {
+      yield { type: 'text', text: prose };
+      transcript.push({ role: 'assistant', content: prose });
+    }
+
+    if (calls.length === 0) {
+      // A reply that was clearly *reaching* for an action but came out
+      // unparseable must not be mistaken for "finished" — that silently drops
+      // the user's task. Correct it and let it try again.
+      if (malformed && malformedRetries < MAX_MALFORMED_RETRIES) {
+        malformedRetries++;
+        messages.push({ role: 'user', content: FORMAT_CORRECTION });
+        continue;
+      }
+      // No action block: the model considers the turn finished.
+      yield { type: 'done', steps: step + 1 };
+      return { transcript };
+    }
+
+    if (signal.aborted) { yield { type: 'aborted' }; return; }
+
+    const call = calls[0];
+    if (calls.length > 1) {
+      messages.push({
+        role: 'user',
+        content: '[note] You wrote several action blocks at once. Only the first was performed. Write one per reply.',
+      });
+    }
+    if (recovered) {
+      // It worked this time, but only because we guessed. Nudge it back on
+      // format so the next step does not depend on the same guess.
+      messages.push({ role: 'user', content: FORMAT_CORRECTION });
+    }
+
+    if (readOnly && (call.name === 'write_file' || call.name === 'edit_file')) {
+      messages.push({
+        role: 'user',
+        content: `[tool result: ${call.name}] Blocked — ${mode} mode cannot modify files. Describe the change instead, or tell the user to press tab for Build mode.`,
+      });
+      yield { type: 'tool_end', name: call.name, args: call.args, ok: false, summary: `blocked in ${mode} mode` };
+      continue;
+    }
+
+    yield { type: 'tool_start', name: call.name, args: call.args };
+
+    const needsApproval = TOOL_NEEDS_APPROVAL.has(call.name);
+    const started = Date.now();
+    const out = await executeTool(call.name, call.args, ctx);
+    const ms = Date.now() - started;
+
+    yield {
+      type: 'tool_end',
+      name: call.name,
+      args: call.args,
+      ok: out.ok,
+      meta: out.meta,
+      summary: out.meta?.label,
+      ms,
+      needsApproval,
+    };
+
+    messages.push({ role: 'user', content: `[tool result: ${call.name}]\n${out.output}` });
+
+    // A declined action is the user's answer, not a retry prompt.
+    if (out.meta?.rejected) {
+      messages.push({
+        role: 'user',
+        content: '[note] The user declined that action. Do not retry it. Either continue without it or stop and explain what you would have done.',
+      });
+    }
+  }
+
+  yield { type: 'error', error: `Stopped after ${MAX_STEPS} steps without finishing. Narrow the request and try again.` };
+}
+
+export { MAX_STEPS };