codeply-cli 0.1.1 → 0.2.0

package/bin/codeply.js

@@ -73,6 +73,7 @@ async function runApply(instruction, opts) {
     const limit = await applyLimit.checkApplyLimit();
     if (!limit.allowed) {
       console.error(limit.error || `Daily apply limit reached (${limit.count}/${limit.limit}). This is shared with the Codeply desktop app and resets at midnight UTC.`);
+      console.error(c.muted(config.byokHint()));
       process.exitCode = 1;
       return;
     }
@@ -116,7 +117,11 @@ async function runApply(instruction, opts) {
   }
 
   fs.writeFileSync(filePath, applied.content);
-  if (usingCodeply) await applyLimit.recordApplyEvent(filePath);
+  if (usingCodeply) {
+    const linesAdded = result.edits.reduce((n, e) => n + e.replace.split('\n').length, 0);
+    const linesRemoved = result.edits.reduce((n, e) => n + e.search.split('\n').length, 0);
+    await applyLimit.recordApplyEvent(filePath, linesAdded, linesRemoved);
+  }
   console.log(c.green(`✓ Applied to ${filePath}`));
 }
 
@@ -198,10 +203,10 @@ program
 
 program
   .command('provider [name]')
-  .description('Show or set the model backend (codeply | ollama).')
-  .option('--key <key>', 'Ollama API key (cloud only; omit for a local daemon)')
-  .option('--model <model>', 'Ollama model, e.g. gemma4:31b')
-  .option('--host <url>', 'Ollama host (default https://ollama.com; local: http://localhost:11434)')
+  .description('Show or set the model backend (codeply | ollama | openrouter | groq | anthropic | openai).')
+  .option('--key <key>', 'API key for ollama (cloud only), openrouter, groq, anthropic, or openai')
+  .option('--model <model>', 'model name for the selected provider')
+  .option('--host <url>', 'ollama host only (default https://ollama.com; local: http://localhost:11434)')
   .action(async (name, opts) => {
     const config = require('../lib/config');
 
@@ -212,25 +217,41 @@ program
         console.log(`Host      ${cfg.ollama.host}`);
         console.log(`Model     ${cfg.ollama.model}`);
         console.log(`Key       ${config.maskKey(cfg.ollama.apiKey)}`);
+      } else if (config.BYOK_PROVIDERS.includes(cfg.provider)) {
+        console.log(`Model     ${cfg[cfg.provider].model}`);
+        console.log(`Key       ${config.maskKey(cfg[cfg.provider].apiKey)}`);
+      }
+      console.log(c.muted(`\nConfig      ${config.configPath}`));
+      console.log(c.muted('Providers   codeply, ollama, openrouter, groq, anthropic, openai'));
+      console.log(c.muted('Set with    codeply provider openrouter --key <key> [--model <model>]'));
+      if (cfg.provider === 'codeply') {
+        console.log(c.muted(`\n${config.byokHint()}`));
       }
-      console.log(c.muted(`\nConfig    ${config.configPath}`));
-      console.log(c.muted('Set with  codeply provider ollama --key <key> --model gemma4:31b'));
       return;
     }
 
-    if (name && name !== 'codeply' && name !== 'ollama') {
-      console.error(`Unknown provider "${name}". Use "codeply" or "ollama".`);
+    if (name && !config.PROVIDERS.includes(name)) {
+      console.error(`Unknown provider "${name}". Use one of: ${config.PROVIDERS.join(', ')}.`);
       process.exitCode = 1;
       return;
     }
 
     const patch = {};
     if (name) patch.provider = name;
-    const ollama = {};
-    if (opts.key) ollama.apiKey = opts.key;
-    if (opts.model) ollama.model = opts.model;
-    if (opts.host) ollama.host = opts.host;
-    if (Object.keys(ollama).length) patch.ollama = ollama;
+    const target = name || config.getConfig().provider;
+
+    if (target === 'ollama') {
+      const ollama = {};
+      if (opts.key) ollama.apiKey = opts.key;
+      if (opts.model) ollama.model = opts.model;
+      if (opts.host) ollama.host = opts.host;
+      if (Object.keys(ollama).length) patch.ollama = ollama;
+    } else if (config.BYOK_PROVIDERS.includes(target)) {
+      const byok = {};
+      if (opts.key) byok.apiKey = opts.key;
+      if (opts.model) byok.model = opts.model;
+      if (Object.keys(byok).length) patch[target] = byok;
+    }
 
     const saved = config.saveConfig(patch);
     if (!saved.ok) {
@@ -251,6 +272,96 @@ program
   .option('--dry-run', 'show the proposed edits without writing them')
   .action(runApply);
 
+const skillCmd = program
+  .command('skill')
+  .description('List, install, or remove agent skills (SKILL.md playbooks the agent can load mid-task).');
+
+skillCmd
+  .command('list', { isDefault: true })
+  .description('List every available skill.')
+  .option('-a, --all', 'include full descriptions (default shows a compact table)')
+  .action((opts) => {
+    const skills = require('../lib/skills');
+    const list = skills.listSkills();
+    if (list.length === 0) {
+      console.log('No skills installed.');
+      return;
+    }
+    const daily = list.filter((s) => s.daily);
+    const rest = list.filter((s) => !s.daily);
+    console.log(c.bold(`${list.length} skills`) + c.muted(` (${daily.length} loaded by default, ${rest.length} available via list_skills or /skill install)`));
+    console.log('');
+    for (const s of list) {
+      const tag = s.source === 'user' ? c.green('[user]') : s.daily ? c.blue('[daily]') : c.muted('[library]');
+      console.log(`${s.name.padEnd(30)} ${tag}`);
+      if (opts.all) console.log(c.muted(`  ${s.description}`));
+    }
+    console.log('');
+    console.log(c.muted(`Bundled from affaan-m/ECC — see skills/SOURCE.md.  Add your own: codeply skill install <path-or-github-url>`));
+  });
+
+skillCmd
+  .command('install <source>')
+  .description('Install a skill from a local directory (containing SKILL.md) or a GitHub URL/owner-repo.')
+  .option('-n, --name <name>', 'name to install under (single-skill sources only; ignored for a whole-repo install)')
+  .action(async (source, opts) => {
+    const skills = require('../lib/skills');
+    const isLocal = fs.existsSync(source);
+
+    if (isLocal) {
+      const result = skills.installFromLocalDir(path.resolve(process.cwd(), source), opts.name);
+      if (!result.ok) { console.error(c.red(result.error)); process.exitCode = 1; return; }
+      console.log(c.green(`✓ Installed "${result.name}"`));
+      console.log(c.muted(`  ${result.dest}`));
+      return;
+    }
+
+    console.log(c.secondary(`Fetching from ${source}…`));
+    let result;
+    try {
+      result = await skills.installFromGitHub(source, opts.name);
+    } catch (e) {
+      console.error(c.red(`Install failed: ${e.message}`));
+      process.exitCode = 1;
+      return;
+    }
+    if (!result.ok) {
+      console.error(c.red(result.error || `No skills installed from ${source}.`));
+      process.exitCode = 1;
+      return;
+    }
+    console.log(c.green(`✓ Installed ${result.installed.length} skill(s) from ${result.source}`));
+    for (const i of result.installed) console.log(c.muted(`  ${i.name}  (${i.fileCount} file(s)) → ${i.dest}`));
+    if (result.failed.length) {
+      console.log(c.yellow(`  ${result.failed.length} skipped (fetch failed):`));
+      for (const f of result.failed) console.log(c.muted(`    ${f.dir}: ${f.error}`));
+    }
+  });
+
+skillCmd
+  .command('remove <name>')
+  .description('Remove a user-installed skill. Bundled skills cannot be removed this way.')
+  .action((name) => {
+    const skills = require('../lib/skills');
+    const result = skills.removeSkill(name);
+    if (!result.ok) { console.error(c.red(result.error)); process.exitCode = 1; return; }
+    console.log(c.green(`✓ Removed "${name}"`));
+  });
+
+skillCmd
+  .command('show <name>')
+  .description('Print a skill\'s full instructions.')
+  .action((name) => {
+    const skills = require('../lib/skills');
+    const body = skills.loadSkillBody(name);
+    if (body == null) {
+      console.error(c.red(`No skill named "${name}". Run \`codeply skill list\` to see what's available.`));
+      process.exitCode = 1;
+      return;
+    }
+    console.log(body);
+  });
+
 // If no arguments provided, launch TUI
 if (process.argv.length <= 2) {
   runTUI();

package/lib/agent.mjs

@@ -14,10 +14,11 @@ 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';
+import { executeTool, TOOL_NEEDS_APPROVAL, walkFiles, resolvePath } from './tools.mjs';
 
 const require = createRequire(import.meta.url);
 const ai = require('./ai.js');
+const skills = require('./skills.js');
 
 const MAX_STEPS = 24;
 const MAX_MALFORMED_RETRIES = 3;
@@ -31,7 +32,16 @@ const FORMAT_CORRECTION =
   '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.';
+  'Valid names: list_dir, read_file, write_file, edit_file, search, run, use_skill, list_skills.';
+
+const TRUNCATION_CORRECTION =
+  '[system] That reply got cut off partway through the action block — the tag syntax was fine, it simply ran out of ' +
+  'room before the block closed. This happens when write_file or edit_file tries to carry too much content in one reply. ' +
+  "Don't re-explain or apologize for the format, just write less this time: for a new or rewritten file, write_file only " +
+  'the first section now and use edit_file to add the rest over one or two more steps; for an edit, split it into smaller ' +
+  'search/replace pairs. Try again with a smaller block.';
+
+const MAX_TRUNCATED_RETRIES = 3;
 
 // ─── Protocol ───────────────────────────────────────────────────────────────
 
@@ -88,6 +98,8 @@ const PARAMS = {
   edit_file: ['path', 'search', 'replace'],
   search: ['pattern', 'glob', 'path'],
   run: ['command'],
+  use_skill: ['name'],
+  list_skills: ['query'],
 };
 
 // Names the model actually reaches for when it paraphrases the format.
@@ -104,6 +116,8 @@ const NAME_ALIASES = {
   edit_file: 'edit_file', editfile: 'edit_file', edit: 'edit_file',
   grep: 'search', findtext: 'search',
   run: 'run', bash: 'run', shell: 'run', exec: 'run', runcommand: 'run',
+  use_skill: 'use_skill', useskill: 'use_skill', skill: 'use_skill', loadskill: 'use_skill',
+  list_skills: 'list_skills', listskills: 'list_skills', skills: 'list_skills', findskill: 'list_skills',
 };
 
 // Any tag whose name resolves to an action, with or without the codeply: prefix.
@@ -113,7 +127,21 @@ const LOOSE_NAME_TAG = new RegExp(
 
 // 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;
+  /<\/?\s*(?:codeply[:_-])?(?:tool_?call|action|function_?call|invoke)\b|<(?:path|command|pattern|content|name)>/i;
+
+/**
+ * A reply that opens an action block but never closes it almost always means
+ * the model hit its response length limit mid-write (a full-file write_file
+ * on anything but a small file is the usual trigger) rather than that it
+ * wrote a malformed tag. That distinction matters: the generic format
+ * correction tells the model its *syntax* was wrong, which it wasn't, and
+ * the model then apologizes for a mistake it didn't make and repeats the
+ * same oversized write. Detecting this case lets the correction instead say
+ * "you ran out of room, write less at once" — the thing that actually fixes it.
+ */
+function looksTruncated(text) {
+  return /<codeply:([a-z_]+)>(?![\s\S]*<\/codeply:\1>)/i.test(text);
+}
 
 /**
  * Best-effort recovery when the strict protocol did not match.
@@ -137,6 +165,8 @@ function recoverCall(text) {
     if (!name && has('command')) name = 'run';
     else if (!name && has('pattern')) name = 'search';
     else if (!name && has('path')) name = 'read_file';
+    else if (!name && has('name')) name = 'use_skill'; // only use_skill's params include <name>
+    else if (!name && has('query')) name = 'list_skills'; // only list_skills' params include <query>
   }
   if (!name || !PARAMS[name]) return null;
 
@@ -172,24 +202,32 @@ export function parseReply(text) {
   prose += text.slice(lastIndex);
 
   if (calls.length > 0) {
-    return { prose: prose.trim(), calls, recovered: false, malformed: false };
+    return { prose: prose.trim(), calls, recovered: false, malformed: false, truncated: 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 };
+  const truncated = looksTruncated(text);
+
+  // Don't let the salvage path guess at a call built from a truncated block —
+  // it would be missing content/search/replace and either fail oddly or write
+  // a partial file. Truncation gets its own, more accurate correction instead.
+  if (!truncated) {
+    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, truncated: false };
+    }
   }
 
   return {
     prose: prose.trim(),
     calls: [],
     recovered: false,
-    malformed: LOOKS_LIKE_ATTEMPT.test(text),
+    malformed: !truncated && LOOKS_LIKE_ATTEMPT.test(text),
+    truncated,
   };
 }
 
@@ -286,6 +324,14 @@ those lines with the change applied
 <command>node --check index.js</command>
 </codeply:run>
 
+<codeply:use_skill>
+<name>deep-research</name>
+</codeply:use_skill>
+
+<codeply:list_skills>
+<query>testing</query>
+</codeply:list_skills>
+
 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
@@ -298,6 +344,8 @@ RULES
 - 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.
+- If a SKILLS entry below is a clear match for the task, use_skill it before starting — its instructions take priority over your own default approach for that kind of work. Do not use_skill speculatively; only when a listed skill actually matches what you are about to do.
+- The SKILLS list below is a subset. If the task is a specific kind of specialized work (a particular framework, a particular deliverable type) that doesn't clearly match anything listed, try list_skills with a one- or two-word query before assuming there's no skill for it — there are 281 in total, not just the ones shown.
 - When the task is finished, reply with prose only and NO action block. That ends your turn.`;
 
 const VERIFY_RULES = `VERIFYING YOUR WORK
@@ -338,11 +386,30 @@ Be concise and concrete. Quote the relevant code and cite it as path:line. If th
 
 const READ_ONLY_MODES = new Set(['Plan', 'Ask']);
 
+/**
+ * Skills add capability without adding weight proportional to the whole
+ * library: only a curated subset's name + capped description goes in here —
+ * see lib/skills.js for why the bundled set (281 skills, ~3.4MB) can't be
+ * injected in full on every request without the skill library itself becoming
+ * the majority of the token cost. The rest is one list_skills query away.
+ */
+function buildSkillIndex() {
+  const all = skills.listSkills();
+  const daily = skills.formatSkillIndex(all);
+  if (!daily) return null;
+  const rest = all.length - all.filter((s) => s.daily).length;
+  return `SKILLS\nOptional playbooks for specific kinds of work. Load one with use_skill ` +
+    `when its description clearly matches the current task. This is a subset — ` +
+    `${rest} more exist; search them with list_skills if nothing here fits:\n${daily}`;
+}
+
 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.');
   }
+  const skillIndex = buildSkillIndex();
+  if (skillIndex) parts.push('', skillIndex);
   parts.push('', 'PROJECT CONTEXT', buildProjectContext(cwd));
   return parts.join('\n');
 }
@@ -424,6 +491,28 @@ export async function* runAgent({ userMessage, history, mode, cwd, approve, sign
   const ctx = { cwd, approve };
   const transcript = [{ role: 'user', content: userMessage }];
   let malformedRetries = 0;
+  let truncatedRetries = 0;
+
+  // Two mechanisms that cut the actual token COUNT sent, not just its billed
+  // price (prompt caching, elsewhere in ai.js, only does the latter):
+  //
+  //  - servedCalls: a repeat read_file/list_dir/search/use_skill/list_skills
+  //    call within one turn — same tool, same arguments — is a real, common
+  //    pattern (the model re-checks something it already has). Re-running it
+  //    would resend the exact same content a second time for zero new
+  //    information; a short pointer back to the earlier result carries the
+  //    same information in a fraction of the tokens.
+  //  - readIndexByPath: once a file is edited, any EARLIER read_file result
+  //    for that same path in the transcript no longer describes what's on
+  //    disk. Besides being a real correctness hazard (the model reasoning off
+  //    stale content), keeping it around costs tokens for information that is
+  //    now wrong. It gets collapsed to a pointer the moment the edit lands,
+  //    not deferred to trimTranscript()'s budget-driven pass.
+  const DEDUPABLE = new Set(['read_file', 'list_dir', 'search', 'use_skill', 'list_skills']);
+  const servedCalls = new Map();     // callKey -> message index of its result
+  const readIndexByPath = new Map(); // resolved path -> message index of its read_file result
+
+  const callKey = (name, args) => `${name}:${JSON.stringify(args)}`;
 
   for (let step = 0; step < MAX_STEPS; step++) {
     if (signal.aborted) { yield { type: 'aborted' }; return; }
@@ -455,7 +544,7 @@ export async function* runAgent({ userMessage, history, mode, cwd, approve, sign
     }
     messages.push({ role: 'assistant', content: reply });
 
-    const { prose, calls, recovered, malformed } = parseReply(reply);
+    const { prose, calls, recovered, malformed, truncated } = parseReply(reply);
     if (prose) {
       yield { type: 'text', text: prose };
       transcript.push({ role: 'assistant', content: prose });
@@ -465,6 +554,11 @@ export async function* runAgent({ userMessage, history, mode, cwd, approve, sign
       // 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 (truncated && truncatedRetries < MAX_TRUNCATED_RETRIES) {
+        truncatedRetries++;
+        messages.push({ role: 'user', content: TRUNCATION_CORRECTION });
+        continue;
+      }
       if (malformed && malformedRetries < MAX_MALFORMED_RETRIES) {
         malformedRetries++;
         messages.push({ role: 'user', content: FORMAT_CORRECTION });
@@ -499,6 +593,23 @@ export async function* runAgent({ userMessage, history, mode, cwd, approve, sign
       continue;
     }
 
+    // A repeat of an earlier read-only call, same tool and same arguments,
+    // carries zero new information — reuse the earlier result instead of
+    // spending tokens to resend it. This is skipped for read_file specifically
+    // when the file was edited since (see the invalidation below): the whole
+    // point there is to force a fresh read, not to serve stale content.
+    if (DEDUPABLE.has(call.name) && servedCalls.has(callKey(call.name, call.args))) {
+      messages.push({
+        role: 'user',
+        content: `[tool result: ${call.name}] Unchanged since your earlier identical call — reusing that result, not re-run. Nothing new to see; move on.`,
+      });
+      yield {
+        type: 'tool_end', name: call.name, args: call.args, ok: true,
+        meta: { deduped: true }, summary: 'unchanged — reused earlier result',
+      };
+      continue;
+    }
+
     yield { type: 'tool_start', name: call.name, args: call.args };
 
     const needsApproval = TOOL_NEEDS_APPROVAL.has(call.name);
@@ -519,6 +630,33 @@ export async function* runAgent({ userMessage, history, mode, cwd, approve, sign
 
     messages.push({ role: 'user', content: `[tool result: ${call.name}]\n${out.output}` });
 
+    if (out.ok) {
+      if (DEDUPABLE.has(call.name)) {
+        servedCalls.set(callKey(call.name, call.args), messages.length - 1);
+      }
+      if (call.name === 'read_file' && call.args.path) {
+        const abs = resolvePath(call.args.path, cwd).abs;
+        readIndexByPath.set(abs, { msgIndex: messages.length - 1, key: callKey(call.name, call.args) });
+      }
+      if ((call.name === 'edit_file' || call.name === 'write_file') && call.args.path) {
+        // The file just changed, so any earlier read_file result for it is now
+        // wrong, not just old — collapse it in place rather than leaving
+        // outdated content sitting in the transcript for the model to
+        // (mis)reason from, and drop it from the dedup cache so a genuinely
+        // fresh read_file after this point is not short-circuited by it.
+        const abs = resolvePath(call.args.path, cwd).abs;
+        const stale = readIndexByPath.get(abs);
+        if (stale) {
+          messages[stale.msgIndex] = {
+            role: 'user',
+            content: `[tool result: read_file] ${call.args.path} — superseded by the ${call.name} below; that earlier content no longer matches the file. Re-read if you need to see it again.`,
+          };
+          servedCalls.delete(stale.key);
+          readIndexByPath.delete(abs);
+        }
+      }
+    }
+
     // A declined action is the user's answer, not a retry prompt.
     if (out.meta?.rejected) {
       messages.push({