codeply-cli 0.1.1 → 0.2.0

package/lib/skills.js

@@ -0,0 +1,358 @@
+/**
+ * Codeply skills.
+ *
+ * A skill is a directory with a SKILL.md: YAML frontmatter (`name`,
+ * `description`) followed by a markdown body of instructions. This is the same
+ * convention Claude Code and affaan-m/ECC use — see skills/SOURCE.md for where
+ * the bundled set came from and why the format was copied rather than invented.
+ *
+ * Two-level progressive disclosure — this matters at 281 skills:
+ *
+ *   1. Per-skill: buildSystemPrompt() only ever injects a skill's NAME and a
+ *      capped one-line description. The full body — which can run to several
+ *      KB with reference files — loads on demand via <codeply:use_skill>. The
+ *      alternative, concatenating every skill's full body into the system
+ *      prompt always, would resend ~3.4MB per request for the bundled set
+ *      alone.
+ *
+ *   2. Across the library: even name+description for all 281 is ~44KB
+ *      (~11,000 tokens) — resent on every step of every turn, that alone would
+ *      make the skill library cost more than it saves. So the system prompt by
+ *      default only lists a curated subset (DAILY_SKILLS below, ~2KB) covering
+ *      general coding work; the complete 281 are still fully installed and
+ *      usable, just one cheap `list_skills` action away instead of force-fed
+ *      into every request. DAILY_SKILLS is not a cut Codeply invented — it's
+ *      ECC's own `.agents/skills/` curation of its 281-skill `skills/`
+ *      library (see skills/SOURCE.md), reused rather than re-decided.
+ *
+ * Two sources, later wins on a name collision:
+ *   built-in   <repo>/skills/<name>/SKILL.md      — vendored, ships with Codeply
+ *   user       ~/.codeply/skills/<name>/SKILL.md  — `codeply skill install`
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const BUILTIN_DIR = path.join(__dirname, '..', 'skills');
+const USER_DIR = path.join(os.homedir(), '.codeply', 'skills');
+
+const MAX_BODY_CHARS = 8000; // fed to the model on demand; keep one skill from eating the whole budget
+
+// ECC's own curated subset of its full library — see skills/SOURCE.md. Kept as
+// a name list rather than a directory so a user-installed skill with one of
+// these names (or a future re-vendor that drops/renames one) degrades
+// gracefully instead of erroring.
+const DAILY_SKILLS = new Set([
+  'agent-introspection-debugging', 'agent-sort', 'api-design', 'article-writing',
+  'backend-patterns', 'benchmark-methodology', 'brand-discovery', 'brand-voice',
+  'bun-runtime', 'coding-standards', 'competitive-platform-analysis',
+  'competitive-report-structure', 'content-engine', 'crosspost', 'deep-research',
+  'dmux-workflows', 'documentation-lookup', 'e2e-testing', 'eval-harness',
+  'exa-search', 'fal-ai-media', 'frontend-patterns', 'frontend-slides',
+  'investor-materials', 'investor-outreach', 'market-research', 'mcp-server-patterns',
+  'mle-workflow', 'nextjs-turbopack', 'plan-canvas', 'product-capability',
+  'security-review', 'strategic-compact', 'tdd-workflow', 'unified-memory',
+  'verification-loop', 'video-editing', 'x-api',
+]);
+
+function listSkillDirs(root, source) {
+  let entries;
+  try { entries = fs.readdirSync(root, { withFileTypes: true }); }
+  catch { return []; }
+
+  return entries
+    .filter((e) => e.isDirectory())
+    .map((e) => ({ name: e.name, dir: path.join(root, e.name), source }))
+    .filter((s) => fs.existsSync(path.join(s.dir, 'SKILL.md')));
+}
+
+/**
+ * Minimal YAML frontmatter reader for exactly the two keys skills use.
+ * Handles plain `key: value` and folded/literal block scalars (`key: >-` /
+ * `key: |-` etc.) since real skills in the wild use both — a naive
+ * single-line regex silently truncates ~10% of the bundled set's descriptions.
+ */
+function parseFrontmatter(text) {
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!m) return { name: null, description: null, body: text };
+
+  const fmLines = m[1].split(/\r?\n/);
+  const values = {};
+  for (let i = 0; i < fmLines.length; i++) {
+    const line = fmLines[i];
+    const kv = line.match(/^([a-zA-Z_-]+):\s*(.*)$/);
+    if (!kv) continue;
+    const [, key, rest] = kv;
+
+    const block = rest.match(/^([|>])(-|\+)?\s*$/);
+    if (block) {
+      const folded = block[1] === '>';
+      const collected = [];
+      let j = i + 1;
+      let indent = null;
+      while (j < fmLines.length) {
+        const l = fmLines[j];
+        if (l.trim() === '') { collected.push(''); j++; continue; }
+        const lineIndent = l.match(/^\s*/)[0].length;
+        if (indent === null) indent = lineIndent;
+        if (lineIndent < indent) break;
+        collected.push(l.slice(indent));
+        j++;
+      }
+      i = j - 1;
+      values[key] = folded
+        ? collected.join(' ').replace(/\s+/g, ' ').trim()
+        : collected.join('\n').replace(/\n+$/, '');
+      continue;
+    }
+
+    // Strip a matching pair of quotes, nothing fancier — these are simple labels.
+    values[key] = rest.replace(/^["'](.*)["']$/, '$1').trim();
+  }
+
+  return {
+    name: values.name || null,
+    description: values.description || null,
+    body: text.slice(m[0].length),
+  };
+}
+
+/** Every skill available right now, built-in and user, deduped by name. */
+function listSkills() {
+  const found = new Map();
+  for (const s of listSkillDirs(BUILTIN_DIR, 'built-in')) found.set(s.name, s);
+  // User skills are installed deliberately, so a same-named one wins.
+  for (const s of listSkillDirs(USER_DIR, 'user')) found.set(s.name, s);
+
+  const skills = [];
+  for (const s of found.values()) {
+    let raw;
+    try { raw = fs.readFileSync(path.join(s.dir, 'SKILL.md'), 'utf8'); }
+    catch { continue; }
+    const { name, description } = parseFrontmatter(raw);
+    const finalName = name || s.name;
+    skills.push({
+      name: finalName,
+      description: description || '(no description)',
+      source: s.source,
+      dir: s.dir,
+      // A user-installed skill overriding a daily one keeps its daily status —
+      // the name is still what buildSystemPrompt filters on, not the source.
+      daily: DAILY_SKILLS.has(finalName),
+    });
+  }
+  return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+const INDEX_DESC_MAX = 140; // per-skill cap in the always-injected index; use_skill has the rest
+
+/**
+ * Compact index of skill name + a capped description, one per line.
+ *
+ * `daily` (default) is what goes in the system prompt on every request — see
+ * the module doc for why the full 281 is too large to inject unconditionally.
+ * `all` is for the list_skills action and `/skill list`, where the cost is
+ * paid once, on demand, instead of on every step.
+ */
+function formatSkillIndex(skills = listSkills(), { all = false } = {}) {
+  const shown = all ? skills : skills.filter((s) => s.daily);
+  if (shown.length === 0) return null;
+  return shown
+    .map((s) => {
+      const d = s.description.length > INDEX_DESC_MAX
+        ? s.description.slice(0, INDEX_DESC_MAX - 1).trim() + '…'
+        : s.description;
+      return `- ${s.name}: ${d}`;
+    })
+    .join('\n');
+}
+
+/** The full body of one skill, truncated to a sane size, or null if unknown. */
+function loadSkillBody(name) {
+  const skill = listSkills().find((s) => s.name === name);
+  if (!skill) return null;
+
+  let raw;
+  try { raw = fs.readFileSync(path.join(skill.dir, 'SKILL.md'), 'utf8'); }
+  catch { return null; }
+  const { body } = parseFrontmatter(raw);
+  const trimmed = body.trim();
+
+  if (trimmed.length <= MAX_BODY_CHARS) return trimmed;
+  return trimmed.slice(0, MAX_BODY_CHARS) +
+    `\n\n[… truncated. The rest is at ${path.join(skill.dir, 'SKILL.md')} if you need it via read_file.]`;
+}
+
+/**
+ * Copy a local directory containing a SKILL.md into the user skill store.
+ * Named separately from the GitHub path below because it never touches the
+ * network — used by both `codeply skill install <local-dir>` and as the last
+ * step after a GitHub download lands in a temp directory.
+ */
+function installFromLocalDir(sourceDir, name) {
+  const skillMd = path.join(sourceDir, 'SKILL.md');
+  if (!fs.existsSync(skillMd)) {
+    return { ok: false, error: `No SKILL.md found in ${sourceDir}` };
+  }
+  const raw = fs.readFileSync(skillMd, 'utf8');
+  const { name: fmName } = parseFrontmatter(raw);
+  const finalName = name || fmName || path.basename(sourceDir);
+
+  const dest = path.join(USER_DIR, finalName);
+  fs.mkdirSync(dest, { recursive: true });
+  copyRecursive(sourceDir, dest);
+  return { ok: true, name: finalName, dest };
+}
+
+function copyRecursive(src, dest) {
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      fs.mkdirSync(d, { recursive: true });
+      copyRecursive(s, d);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+// ─── Installing from GitHub ─────────────────────────────────────────────────
+
+/**
+ * Parse anything a user might paste for a GitHub skill source:
+ *   owner/repo
+ *   https://github.com/owner/repo
+ *   https://github.com/owner/repo/tree/<branch>/<subpath...>
+ *   https://github.com/owner/repo/blob/<branch>/<subpath...>/SKILL.md
+ */
+function parseGitHubSource(source) {
+  const s = source.trim().replace(/\/+$/, '');
+
+  let m = s.match(/^(?:https?:\/\/)?github\.com\/([^/]+)\/([^/]+)(?:\/(tree|blob)\/([^/]+)(?:\/(.*))?)?$/i);
+  if (m) {
+    const [, owner, repo, , branch, subpath] = m;
+    return { owner, repo: repo.replace(/\.git$/, ''), branch: branch || null, subpath: subpath || '' };
+  }
+
+  m = s.match(/^([\w.-]+)\/([\w.-]+)$/);
+  if (m) return { owner: m[1], repo: m[2], branch: null, subpath: '' };
+
+  return null;
+}
+
+async function githubJson(url) {
+  const res = await fetch(url, { headers: { Accept: 'application/vnd.github+json' } });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(body.message || `GitHub API returned HTTP ${res.status}`);
+  return body;
+}
+
+/**
+ * Install one or more skills from a GitHub repo.
+ *
+ * If `subpath` points directly at a skill (a directory whose own SKILL.md
+ * lives there), that one skill is installed under `name` (or its own frontmatter
+ * name). Otherwise every SKILL.md found anywhere under `subpath` (the whole
+ * repo, if none was given) is installed — this is what makes a bare repo URL
+ * like affaan-m/ECC pull in its entire skill library in one command, and also
+ * what lets a single-skill link install just that one.
+ */
+async function installFromGitHub(source, explicitName) {
+  const parsed = parseGitHubSource(source);
+  if (!parsed) return { ok: false, error: `Not a recognizable GitHub source: "${source}"` };
+  const { owner, repo, subpath } = parsed;
+
+  let branch = parsed.branch;
+  if (!branch) {
+    try {
+      const repoInfo = await githubJson(`https://api.github.com/repos/${owner}/${repo}`);
+      branch = repoInfo.default_branch || 'main';
+    } catch (e) {
+      return { ok: false, error: `Could not reach ${owner}/${repo}: ${e.message}` };
+    }
+  }
+
+  let tree;
+  try {
+    const treeData = await githubJson(
+      `https://api.github.com/repos/${owner}/${repo}/git/trees/${encodeURIComponent(branch)}?recursive=1`
+    );
+    if (treeData.truncated) {
+      // GitHub's own recursion cap (huge monorepos) — rare, but better to say
+      // so than to silently install an incomplete skill.
+      return { ok: false, error: `${owner}/${repo}@${branch} is too large to list in one call. Point --install at a narrower subpath.` };
+    }
+    tree = treeData.tree || [];
+  } catch (e) {
+    return { ok: false, error: `Could not read ${owner}/${repo}@${branch}: ${e.message}` };
+  }
+
+  const cleanSubpath = subpath.replace(/\/SKILL\.md$/i, '').replace(/\/+$/, '');
+  const scoped = cleanSubpath
+    ? tree.filter((t) => t.path === cleanSubpath || t.path.startsWith(cleanSubpath + '/'))
+    : tree;
+
+  const skillMdFiles = scoped.filter((t) => t.type === 'blob' && /(^|\/)SKILL\.md$/i.test(t.path));
+  if (skillMdFiles.length === 0) {
+    return { ok: false, error: `No SKILL.md found under ${owner}/${repo}${cleanSubpath ? '/' + cleanSubpath : ''}.` };
+  }
+
+  const skillDirs = skillMdFiles.map((f) => f.path.replace(/\/SKILL\.md$/i, ''));
+  const singleSkill = skillDirs.length === 1;
+
+  const installed = [];
+  const failed = [];
+
+  for (const dir of skillDirs) {
+    const filesInDir = tree.filter((t) =>
+      t.type === 'blob' && (t.path === `${dir}/SKILL.md` || t.path.startsWith(`${dir}/references/`))
+    );
+    const rawBase = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}`;
+
+    const fetched = [];
+    let ok = true;
+    for (const f of filesInDir) {
+      try {
+        const res = await fetch(`${rawBase}/${f.path}`);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        fetched.push({ relPath: f.path.slice(dir.length + 1), content: await res.text() });
+      } catch (e) {
+        ok = false;
+        failed.push({ dir, error: e.message });
+        break;
+      }
+    }
+    if (!ok) continue;
+
+    const skillMd = fetched.find((f) => f.relPath === 'SKILL.md');
+    const { name: fmName } = parseFrontmatter(skillMd.content);
+    const finalName = (singleSkill && explicitName) || fmName || path.basename(dir);
+
+    const dest = path.join(USER_DIR, finalName);
+    fs.mkdirSync(dest, { recursive: true });
+    for (const f of fetched) {
+      const target = path.join(dest, f.relPath);
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, f.content, 'utf8');
+    }
+    installed.push({ name: finalName, fileCount: fetched.length, dest });
+  }
+
+  return { ok: installed.length > 0, installed, failed, source: `${owner}/${repo}@${branch}` };
+}
+
+function removeSkill(name) {
+  const dest = path.join(USER_DIR, name);
+  if (!fs.existsSync(dest)) {
+    return { ok: false, error: `No user-installed skill named "${name}" (built-in skills can't be removed this way).` };
+  }
+  fs.rmSync(dest, { recursive: true, force: true });
+  return { ok: true };
+}
+
+module.exports = {
+  BUILTIN_DIR, USER_DIR, MAX_BODY_CHARS, DAILY_SKILLS,
+  parseFrontmatter, listSkills, formatSkillIndex, loadSkillBody,
+  installFromLocalDir, installFromGitHub, parseGitHubSource, removeSkill,
+};

package/lib/tools.mjs

@@ -19,6 +19,7 @@ const require = createRequire(import.meta.url);
 const editEngine = require('./edit-engine.js');
 const applyLimit = require('./apply-limit.js');
 const config = require('./config.js');
+const skills = require('./skills.js');
 
 // A write is a real "apply" against the shared 100/day cap only when it's
 // actually spending the shared codeply proxy — Ollama (local or the user's
@@ -328,7 +329,63 @@ async function run(args, ctx) {
   });
 }
 
-export const TOOLS = { list_dir, read_file, write_file, edit_file, search, run };
+/**
+ * Load one skill's full instructions on demand. Read-only, no approval — the
+ * whole point of the skill index living in the system prompt (see
+ * lib/skills.js) is that only a name and a one-line description cost anything
+ * until the agent actually decides a skill is relevant, at which point this is
+ * the one call that pulls in the rest.
+ */
+async function use_skill(args, ctx) {
+  const name = (args.name || '').trim();
+  if (!name) return { ok: false, output: 'use_skill needs a <name>.' };
+
+  const body = skills.loadSkillBody(name);
+  if (body == null) {
+    // Capped rather than dumping the full library (281 names) into a reply
+    // that only exists because of one wrong guess.
+    const all = skills.listSkills().map((s) => s.name);
+    const shown = all.slice(0, 40).join(', ') + (all.length > 40 ? `, … (${all.length - 40} more — see list_skills)` : '');
+    return {
+      ok: false,
+      output: `No skill named "${name}". ${all.length ? `Some available: ${shown}` : '(none installed)'}`,
+    };
+  }
+  return { ok: true, output: body, meta: { label: name } };
+}
+
+/**
+ * The full skill catalog — the counterpart to the DAILY-only index that
+ * always rides in the system prompt (see lib/skills.js). One call, paid once,
+ * only when the task actually needs something outside that curated set.
+ *
+ * At 281 skills, name+description together run past MAX_TOOL_OUTPUT — an
+ * optional query narrows to matching names/descriptions before formatting, so
+ * the normal case (looking for "something about X") returns a handful of
+ * relevant lines instead of a wall of text truncated at an arbitrary,
+ * alphabetically-biased cutoff.
+ */
+async function list_skills(args) {
+  const all = skills.listSkills();
+  const query = (args.query || '').trim().toLowerCase();
+  const matched = query
+    ? all.filter((s) => s.name.toLowerCase().includes(query) || s.description.toLowerCase().includes(query))
+    : all;
+
+  if (query && matched.length === 0) {
+    return { ok: true, output: `No skills matched "${query}" out of ${all.length} total.`, meta: { count: 0 } };
+  }
+
+  const index = skills.formatSkillIndex(matched, { all: true });
+  const header = query ? `${matched.length} of ${all.length} skills match "${query}":\n` : `${all.length} skills:\n`;
+  return {
+    ok: true,
+    output: truncate(header + (index || '(none)')),
+    meta: { label: query || 'all skills', count: matched.length },
+  };
+}
+
+export const TOOLS = { list_dir, read_file, write_file, edit_file, search, run, use_skill, list_skills };
 
 export const TOOL_NEEDS_APPROVAL = new Set(['write_file', 'edit_file', 'run']);
 
@@ -340,6 +397,8 @@ export const TOOL_DISPLAY = {
   edit_file:  { verb: 'edit',   icon: '✎' },
   search:     { verb: 'search', icon: '▸' },
   run:        { verb: 'run',    icon: '$' },
+  use_skill:  { verb: 'skill',  icon: '★' },
+  list_skills:{ verb: 'skills', icon: '★' },
 };
 
 export async function executeTool(name, args, ctx) {
@@ -355,17 +414,15 @@ export async function executeTool(name, args, ctx) {
   if (capped) {
     const limit = await applyLimit.checkApplyLimit();
     if (!limit.allowed) {
-      return {
-        ok: false,
-        output: limit.error || `Daily apply limit reached (${limit.count}/${limit.limit}). This is shared with the Codeply desktop app and resets at midnight UTC.`,
-      };
+      const base = limit.error || `Daily apply limit reached (${limit.count}/${limit.limit}). This is shared with the Codeply desktop app and resets at midnight UTC.`;
+      return { ok: false, output: `${base} ${config.byokHint()}` };
     }
   }
 
   try {
     const result = await fn(args, ctx);
     if (capped && result.ok && result.meta?.wrote) {
-      await applyLimit.recordApplyEvent(args.path);
+      await applyLimit.recordApplyEvent(args.path, result.meta.added, result.meta.removed);
     }
     return result;
   } catch (e) {

package/lib/tui.mjs

@@ -26,10 +26,12 @@ import Spinner from 'ink-spinner';
 import { createRequire } from 'module';
 import path from 'path';
 import os from 'os';
+import fs from 'fs';
 
 const require = createRequire(import.meta.url);
 const auth = require('../lib/auth.js');
 const appConfig = require('../lib/config.js');
+const skills = require('../lib/skills.js');
 const VERSION = require('../package.json').version;
 import {
   renderMarkdown, Panel, hexToAnsi, hexToAnsiBg, fillRow, SURFACE,
@@ -122,6 +124,8 @@ const COMMANDS = [
   { name: '/help', description: 'Show available commands' },
   { name: '/clear', description: 'Clear conversation and context' },
   { name: '/mode', description: 'Cycle Build → Plan → Ask' },
+  { name: '/provider', description: 'Show or switch model provider (BYOK: openrouter, groq, anthropic, openai)' },
+  { name: '/skill', description: 'List, install, or remove agent skills' },
   { name: '/keys', description: 'Show what your terminal sends for a key' },
   { name: '/quit', description: 'Exit Codeply' },
 ];
@@ -579,7 +583,7 @@ const App = () => {
   });
 
   // ── slash commands ──
-  const runCommand = async (cmd) => {
+  const runCommand = async (cmd, args = '') => {
     if (cmd === '/login') {
       push({ role: 'system', content: 'Opening sign-in…' });
       try {
@@ -616,6 +620,94 @@ const App = () => {
       const next = (modeIndex + 1) % MODES.length;
       setModeIndex(next);
       push({ role: 'system', content: `Mode → ${MODES[next]} — ${MODE_HINT[MODES[next]]}` });
+    } else if (cmd === '/provider') {
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      const name = parts[0];
+
+      if (!name) {
+        const cfg = appConfig.getConfig();
+        let msg = `Provider: ${appConfig.describeProvider(cfg)}\n` +
+          `Providers: ${appConfig.PROVIDERS.join(', ')}\n` +
+          'Set with /provider <name> [key]  —  e.g. /provider openrouter sk-or-v1-...';
+        if (cfg.provider === 'codeply') msg += `\n\n${appConfig.byokHint()}`;
+        push({ role: 'system', content: msg });
+        return;
+      }
+
+      if (!appConfig.PROVIDERS.includes(name)) {
+        push({ role: 'error', content: `Unknown provider "${name}". Use one of: ${appConfig.PROVIDERS.join(', ')}.` });
+        return;
+      }
+
+      const key = parts[1];
+      const patch = { provider: name };
+      if (key && (appConfig.BYOK_PROVIDERS.includes(name) || name === 'ollama')) {
+        patch[name] = { apiKey: key };
+      }
+
+      const saved = appConfig.saveConfig(patch);
+      if (!saved.ok) {
+        push({ role: 'error', content: `Could not save config: ${saved.error}` });
+        return;
+      }
+      push({ role: 'system', content: `Provider → ${appConfig.describeProvider(appConfig.getConfig())}` });
+    } else if (cmd === '/keys') {
+      push({ role: 'system', content: 'Press any key (or combination)…' });
+      setKeyProbe(true);
+    } else if (cmd === '/skill') {
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      const sub = parts[0];
+
+      if (!sub || sub === 'list') {
+        const list = skills.listSkills();
+        if (list.length === 0) {
+          push({ role: 'system', content: 'No skills available.' });
+        } else {
+          const lines = list.map((s) => `${s.name.padEnd(28)} [${s.source}]  ${s.description}`);
+          push({ role: 'system', content: `Skills (${list.length})\n` + lines.join('\n') +
+            '\n\n/skill install <path-or-github-url>   add one\n/skill remove <name>                   remove a user-installed one' });
+        }
+        return;
+      }
+
+      if (sub === 'install') {
+        const source = parts.slice(1).join(' ');
+        if (!source) { push({ role: 'error', content: 'Usage: /skill install <local-path-or-github-url>' }); return; }
+        push({ role: 'system', content: `Installing from ${source}…` });
+        try {
+          const isLocal = fs.existsSync(source);
+          const result = isLocal
+            ? skills.installFromLocalDir(path.resolve(cwd, source))
+            : await skills.installFromGitHub(source);
+          if (isLocal) {
+            if (!result.ok) push({ role: 'error', content: result.error });
+            else push({ role: 'system', content: `Installed "${result.name}" → ${result.dest}` });
+          } else if (!result.ok) {
+            push({ role: 'error', content: result.error || `No skills installed from ${source}.` });
+          } else {
+            const names = result.installed.map((i) => i.name).join(', ');
+            push({ role: 'system', content: `Installed ${result.installed.length} skill(s) from ${result.source}: ${names}` });
+            if (result.failed.length) {
+              push({ role: 'error', content: `${result.failed.length} failed: ${result.failed.map((f) => f.dir).join(', ')}` });
+            }
+          }
+        } catch (e) {
+          push({ role: 'error', content: `Install failed: ${e.message}` });
+        }
+        return;
+      }
+
+      if (sub === 'remove') {
+        const name = parts[1];
+        if (!name) { push({ role: 'error', content: 'Usage: /skill remove <name>' }); return; }
+        const result = skills.removeSkill(name);
+        push(result.ok
+          ? { role: 'system', content: `Removed "${name}".` }
+          : { role: 'error', content: result.error });
+        return;
+      }
+
+      push({ role: 'error', content: `Unknown /skill subcommand "${sub}". Use list, install, or remove.` });
     } else if (cmd === '/quit' || cmd === '/exit') {
       exit();
     } else {
@@ -639,7 +731,8 @@ const App = () => {
     setInput('');
 
     if (submitValue.startsWith('/')) {
-      await runCommand(submitValue.split(/\s+/)[0].toLowerCase());
+      const [first, ...rest] = submitValue.split(/\s+/);
+      await runCommand(first.toLowerCase(), rest.join(' '));
       return;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeply-cli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Codeply from the terminal — an interactive AI coding agent, or a single apply <instruction> --file <path> command.",
   "main": "bin/codeply.js",
   "bin": {
@@ -8,7 +8,8 @@
   },
   "files": [
     "bin",
-    "lib"
+    "lib",
+    "skills"
   ],
   "engines": {
     "node": ">=18"

package/skills/SOURCE.md

@@ -0,0 +1,58 @@
+# Where these skills came from
+
+The skill library in this directory — all 281 of them — is vendored from
+[affaan-m/ECC](https://github.com/affaan-m/ECC) ("Every Coding Copilot"), an
+open-source collection of agent skills for Claude Code, Codex, and other
+harnesses. It's their full `skills/` library, not a subset — every `SKILL.md`
+and its `references/*.md` companions, unmodified.
+
+Codeply loads its skill format directly from that project's convention: a
+`SKILL.md` per skill with YAML frontmatter (`name`, `description`) and a
+markdown body. See [lib/skills.js](../lib/skills.js) for the loader.
+
+Only `SKILL.md` and `references/*.md` were vendored — each skill's
+`agents/openai.yaml` (a tool schema for a different harness's native
+function-calling) was left out, since Codeply calls skills through its own
+text-based action protocol and has no use for it.
+
+Not every one of the 281 is loaded into the agent's context by default —
+`lib/skills.js` shows a curated "daily" subset (ECC's own `.agents/skills/`
+curation of its full library) to keep the always-injected index small; the
+rest are still fully installed and reachable with `list_skills <query>` or
+`codeply skill show <name>`.
+
+## License
+
+ECC is MIT-licensed. Its license and copyright notice, reproduced here as MIT
+requires when redistributing:
+
+```
+MIT License
+
+Copyright (c) 2026 Affaan Mustafa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## Adding your own
+
+Anything you drop in `~/.codeply/skills/<name>/SKILL.md` (same frontmatter
+format) is picked up the same way, and takes priority over a bundled skill of
+the same name. `codeply skill install <path-or-github-url>` automates that —
+see `codeply skill --help`.