@hncode/hncode 0.3.1 → 0.3.3

package/src/plan.js

@@ -0,0 +1,127 @@
+// Plan review helpers — turning a model's <plan> block into something the user
+// can actually review before any file is touched.
+//
+// Plan mode already asks the model for a <plan>…</plan> block and prompts to
+// approve it. What this module adds is the review material and the persistence:
+//
+//   * filesReferenced(plan)  — which paths the plan says it will touch, so the
+//                              user sees the blast radius instead of prose.
+//   * planStats(plan)        — step/line counts for a compact summary line.
+//   * savePlan()             — write the approved plan to
+//                              <workspace>/.hncode/plans/<timestamp>.md so it
+//                              survives the session and can be handed to a
+//                              subagent or pasted into an issue.
+//
+// Everything here is pure except savePlan(). The parsing is deliberately
+// tolerant: a plan is free-form Markdown, so a missed file reference degrades to
+// "fewer files listed", never to an error.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+// Paths that appear in a plan: backticked spans, and bare tokens that look like
+// a path (contains a slash and a file-ish extension, or a well-known filename).
+// Ordered by first appearance, de-duplicated, and filtered to plausible files.
+const PATH_EXT = /\.(?:[a-z0-9]{1,8})$/i;
+const KNOWN_FILES = /^(?:AGENTS\.md|README(?:\.[a-z]+)?|package\.json|pyproject\.toml|Cargo\.toml|go\.mod|Makefile|Dockerfile|\.gitignore|tsconfig\.json)$/i;
+
+export function filesReferenced(plan) {
+  const text = String(plan || '');
+  const found = [];
+  const seen = new Set();
+  const push = (raw) => {
+    let p = String(raw || '').trim();
+    // Strip trailing punctuation the prose adds around a path.
+    p = p.replace(/^[`'"(\[]+/, '').replace(/[`'")\],.;:]+$/, '');
+    if (!p || p.length > 200) return;
+    if (/\s/.test(p)) return;
+    if (p.includes('://')) return;                 // a URL, not a path
+    if (/^[-*#>]/.test(p)) return;
+    // A token is a plausible path when it has a separator, a file-ish extension,
+    // or is a well-known project filename. This keeps a bare word like "config"
+    // from being reported as a file.
+    const looksPath = p.includes('/') || p.includes('\\') || PATH_EXT.test(p) || KNOWN_FILES.test(p);
+    if (!looksPath) return;
+    const key = p.replace(/\\/g, '/');
+    if (seen.has(key)) return;
+    seen.add(key);
+    found.push(p);
+  };
+
+  // 1. backticked spans (the prompt asks for files in backticks)
+  for (const m of text.matchAll(/`([^`\n]+)`/g)) push(m[1]);
+  // 2. bare tokens that look like paths (covers un-backticked mentions)
+  for (const m of text.matchAll(/(?:^|[\s(])((?:[\w.@-]+\/)+[\w.@-]+|\b[\w.-]+\.[a-z0-9]{1,8}\b)/gi)) push(m[1]);
+  return found;
+}
+
+// Compact summary for the review box: how many steps and how many lines.
+export function planStats(plan) {
+  const text = String(plan || '');
+  const lines = text.split('\n');
+  const nonEmpty = lines.filter((l) => l.trim()).length;
+  // A "step" is a heading (## / ###) or a top-level numbered item.
+  const steps = lines.filter((l) => /^\s*(?:#{1,6}\s+\S|\d+[.)]\s+\S)/.test(l)).length;
+  const words = text.split(/\s+/).filter(Boolean).length;
+  return { lines: nonEmpty, steps, words, files: filesReferenced(text).length };
+}
+
+// Where a saved plan goes: <workspace>/.hncode/plans/<id>.md. Kept inside the
+// project (not ~/.hncode) so it can be committed or reviewed with the change.
+export function plansDir(workspace) {
+  return path.join(workspace || process.cwd(), '.hncode', 'plans');
+}
+
+// Persist a plan. `id` defaults to a timestamp slug. Returns
+// { ok, path, error }. Never throws.
+export function savePlan(plan, workspace, id) {
+  const text = String(plan || '').trim();
+  if (!text) return { ok: false, path: '', error: 'empty plan' };
+  const dir = plansDir(workspace);
+  const slug = id || new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, 19);
+  const file = path.join(dir, `${slug}.md`);
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, `# Plan (${new Date().toISOString()})\n\n${text}\n`, 'utf8');
+  } catch (e) {
+    return { ok: false, path: file, error: e.message };
+  }
+  return { ok: true, path: file, error: null };
+}
+
+export function listPlans(workspace) {
+  const dir = plansDir(workspace);
+  let names;
+  try { names = fs.readdirSync(dir); } catch { return []; }
+  const out = [];
+  for (const n of names) {
+    if (!n.endsWith('.md')) continue;
+    const full = path.join(dir, n);
+    try { const st = fs.statSync(full); if (st.isFile()) out.push({ name: n, path: full, mtimeMs: st.mtimeMs }); }
+    catch { /* unreadable: skip */ }
+  }
+  // Newest first. Tie-break by name DESCENDING so that two plans written in the
+  // same millisecond still come back in a deterministic (and, for the
+  // timestamp-slug naming, newest-looking) order.
+  out.sort((a, b) => (b.mtimeMs - a.mtimeMs) || (a.name < b.name ? 1 : a.name > b.name ? -1 : 0));
+  return out;
+}
+
+// The review panel's lines. Kept here (not the TUI) so it can be unit-tested.
+export function reviewLines(plan, workspace) {
+  const stats = planStats(plan);
+  const files = filesReferenced(plan);
+  const lines = [];
+  lines.push(`Steps: ${stats.steps}   Lines: ${stats.lines}   Files mentioned: ${files.length}`);
+  lines.push('');
+  if (files.length) {
+    lines.push('Files this plan will touch:');
+    for (const f of files.slice(0, 40)) lines.push(`  ${f}`);
+    if (files.length > 40) lines.push(`  … and ${files.length - 40} more`);
+  } else {
+    lines.push('No specific files named in the plan.');
+  }
+  lines.push('');
+  lines.push('Enter = approve & execute   e = edit the plan   Esc = keep planning');
+  return lines;
+}

package/src/skills.js

@@ -0,0 +1,150 @@
+// Skills — user-supplied reusable prompt packages.
+//
+// A skill is a Markdown file under ~/.hncode/skills/<name>.md. Its body is
+// text that gets injected into the conversation when the user activates it, so
+// a skill is essentially a saved prompt fragment ("review this PR for security
+// issues", "write tests in this project's style", …).
+//
+// Two ways a skill comes into being:
+//   * /import-skill <file.md>  — copies (or overwrites) an external .md into the
+//     skills directory. A duplicate name is REPLACED, not rejected.
+//   * hand-authoring a file in the skills directory.
+//
+// Activation is /skill:<name>. The file body is what gets sent; an optional YAML
+// front-matter block (--- … ---) is stripped from the body and only used for the
+// display name / description, so a skill file can stay self-describing without
+// leaking its metadata into the prompt.
+//
+// Everything here is filesystem-only and side-effect free apart from the
+// explicit import/write helpers.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const SKILL_PREFIX = 'skill:';
+
+// The skills directory. Kept next to the other hncode state (~/.hncode/…), and
+// overridable through the environment for tests.
+export function skillsDir() {
+  return process.env.HNCODE_SKILLS_DIR || path.join(os.homedir(), '.hncode', 'skills');
+}
+
+// A skill name is the file's basename without extension. Normalise what the
+// user typed ("Skill:Review", "/skill:review", "review.md") to a bare name.
+export function normalizeSkillName(name) {
+  let n = String(name == null ? '' : name).trim();
+  n = n.replace(/^\/+/, '');                  // leading slash
+  if (n.toLowerCase().startsWith(SKILL_PREFIX)) n = n.slice(SKILL_PREFIX.length);
+  n = n.replace(/\.md$/i, '');                // trailing .md
+  return n.trim();
+}
+
+// Parse an optional leading `---\n…\n---` front-matter block. Returns the body
+// with the block removed, plus whatever fields were found. Tolerates a missing
+// or malformed block (then body === text and meta is empty).
+export function parseFrontMatter(text) {
+  const src = String(text == null ? '' : text);
+  const m = /^\uFEFF?---\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n?/.exec(src);
+  if (!m) return { meta: {}, body: src };
+  const meta = {};
+  for (const line of m[1].split(/\r?\n/)) {
+    const kv = /^\s*([A-Za-z0-9_-]+)\s*:\s*(.*?)\s*$/.exec(line);
+    if (!kv) continue;
+    let v = kv[2];
+    // Strip a single layer of matching quotes.
+    if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) v = v.slice(1, -1);
+    meta[kv[1].toLowerCase()] = v;
+  }
+  return { meta, body: src.slice(m[0].length) };
+}
+
+// All skills, sorted by name. Each entry: { name, description, path, size }.
+// Unreadable files are skipped rather than failing the whole listing.
+export function listSkills() {
+  const dir = skillsDir();
+  let files;
+  try { files = fs.readdirSync(dir); } catch { return []; }
+  const out = [];
+  for (const f of files) {
+    if (!f.toLowerCase().endsWith('.md')) continue;
+    const full = path.join(dir, f);
+    let st;
+    try { st = fs.statSync(full); } catch { continue; }
+    if (!st.isFile()) continue;
+    const name = f.replace(/\.md$/i, '');
+    let description = '';
+    try {
+      const { meta } = parseFrontMatter(fs.readFileSync(full, 'utf8'));
+      description = meta.description || meta.title || '';
+    } catch { /* unreadable: keep it listed with no description */ }
+    out.push({ name, description, path: full, size: st.size });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  return out;
+}
+
+// Read a skill's body (front-matter stripped). Returns null when not found.
+export function readSkill(name) {
+  const n = normalizeSkillName(name);
+  if (!n) return null;
+  const full = path.join(skillsDir(), `${n}.md`);
+  let text;
+  try { text = fs.readFileSync(full, 'utf8'); } catch { return null; }
+  const { meta, body } = parseFrontMatter(text);
+  return { name: n, description: meta.description || meta.title || '', body: body.trim(), path: full };
+}
+
+// Import (copy or overwrite) an external Markdown file as a skill.
+// `name` overrides the derived name when given. Returns
+// { ok: true, name, path, replaced } or { ok: false, error }.
+export function importSkill(file, name) {
+  const srcPath = path.resolve(String(file == null ? '' : file));
+  let text;
+  try {
+    const st = fs.statSync(srcPath);
+    if (!st.isFile()) return { ok: false, error: `Not a file: ${srcPath}` };
+    text = fs.readFileSync(srcPath, 'utf8');
+  } catch (e) {
+    return { ok: false, error: `Cannot read ${srcPath}: ${e.message}` };
+  }
+  // Name precedence: explicit argument, else front-matter `name`, else filename.
+  const { meta } = parseFrontMatter(text);
+  const derived = name || meta.name || path.basename(srcPath).replace(/\.md$/i, '');
+  const skillName = normalizeSkillName(derived);
+  if (!skillName) return { ok: false, error: 'Could not derive a skill name (pass one explicitly).' };
+  if (/[\\/]/.test(skillName)) return { ok: false, error: `Invalid skill name: ${skillName}` };
+
+  const dir = skillsDir();
+  const dest = path.join(dir, `${skillName}.md`);
+  const replaced = fs.existsSync(dest);
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(dest, text, 'utf8');
+  } catch (e) {
+    return { ok: false, error: `Cannot write ${dest}: ${e.message}` };
+  }
+  return { ok: true, name: skillName, path: dest, replaced };
+}
+
+export function deleteSkill(name) {
+  const n = normalizeSkillName(name);
+  if (!n) return false;
+  try { fs.unlinkSync(path.join(skillsDir(), `${n}.md`)); return true; } catch { return false; }
+}
+
+// Completion candidates for the composer: names prefixed with the marker the
+// user must type, so accepting a candidate yields `/skill:<name>`.
+export function skillCompletions(prefix = '') {
+  const p = normalizeSkillName(prefix).toLowerCase();
+  return listSkills()
+    .filter((s) => !p || s.name.toLowerCase().startsWith(p))
+    .map((s) => ({ name: s.name, description: s.description, insert: SKILL_PREFIX + s.name }));
+}
+
+// Build the text a skill contributes to the conversation. A short header keeps
+// the model from treating the body as the user's own words.
+export function skillPrompt(skill) {
+  if (!skill || !skill.body) return '';
+  return `[skill: ${skill.name}]\n\n${skill.body}`;
+}

package/src/subagent-types.js

@@ -41,7 +41,7 @@ export const SUBAGENT_TYPES = {
     // An explicit allowlist (not `null` = everything) so Agent/AgentSwarm are
     // excluded. Mirrors kimi's CODER_TOOLS.
     tools: [
-      'Read', 'Write', 'Edit', 'Glob', 'Grep', 'FileLines', 'Bash',
+      'Read', 'Write', 'Edit', 'Glob', 'Grep', 'FileLines', 'Bash', 'Git',
       'TodoList', 'FetchURL', 'WebSearch', 'ReadMediaFile',
       'TaskList', 'TaskOutput', 'TaskStop', 'TaskWait',
     ],

package/src/tools/edit.js

@@ -13,7 +13,7 @@ import { hashRegion as hashLines } from './read.js';
 
 export const spec = {
   name: 'Edit',
-description: 'Edit a file. PREFERRED: line-range mode (path + start_line/end_line/new_content) — replace by line numbers when you have Read the file and know the positions. Use line-range mode whenever possible; fall back to exact-substring mode (path + old_string/new_string) only when the exact text is known and a line range is not convenient.',
+  description: 'Edit a file. THE TWO MODES ARE MUTUALLY EXCLUSIVE — NEVER combine them:\n  - LINE-RANGE mode: path + start_line + end_line + new_content. Replaces lines [start_line, end_line] with new_content. PREFERRED — use it whenever you have Read the file and know the line numbers.\n  - EXACT-SUBSTRING mode: path + old_string + new_string. Replaces text exactly matching old_string. Use ONLY when the exact text is known and a line range is not convenient.\nDo NOT pass start_line/end_line together with old_string/new_string in one call, and do NOT pass any of these four keys when you are not using that mode. Omitting new_content or new_string is an error, not an empty replacement.',
   parameters: {
     type: 'object',
     properties: {
@@ -21,13 +21,13 @@ description: 'Edit a file. PREFERRED: line-range mode (path + start_line/end_lin
       old_string: { type: 'string', description: 'Exact text to replace, including whitespace and newlines. Omit when using start_line/end_line.' },
       new_string: { type: 'string', description: 'Replacement text for old_string.' },
       replace_all: { type: 'boolean', default: false, description: 'Replace all occurrences of old_string.' },
-start_line: { type: 'integer', minimum: 1, description: 'PREFERRED MODE. 1-based first line to replace (requires end_line and new_content). Use this line-range mode first.' },
+      start_line: { type: 'integer', minimum: 1, description: 'PREFERRED MODE. 1-based first line to replace (requires end_line and new_content). Use this line-range mode first.' },
       end_line: { type: 'integer', minimum: 1, description: 'PREFERRED MODE. 1-based last line to replace (inclusive; requires start_line).' },
       new_content: { type: 'string', description: 'PREFERRED MODE. Replacement text for the line range [start_line, end_line]. Requires start_line and end_line.' },
     },
-// Either line-range mode (start_line+end_line+new_content) OR exact-substring
-    // mode (old_string+new_string). Line-range is the preferred route — see the
-    // tool description and the PREFERRED MODE notes on the params.
+    // Either line-range mode (start_line+end_line+new_content) OR exact-substring
+    // mode (old_string+new_string).
+    // Line-range is the preferred route.
     anyOf: [
       { required: ['path', 'start_line', 'end_line', 'new_content'] },
       { required: ['path', 'old_string', 'new_string'] },
@@ -39,6 +39,14 @@ start_line: { type: 'integer', minimum: 1, description: 'PREFERRED MODE. 1-based
     let content;
     try { content = fs.readFileSync(p, 'utf8'); } catch (e) { return `Error reading ${args.path}: ${e.message}`; }
     const { start_line, end_line, new_content } = args;
+    // The two modes are MUTUALLY EXCLUSIVE: sending line-range AND substring
+    // parameters together is ambiguous — reject it rather than guessing which
+    // one the caller meant. Only one family may be present in `args`.
+    const hasRangeKeys = args.start_line != null || args.end_line != null || args.new_content != null;
+    const hasSubKeys = args.old_string != null || args.new_string != null;
+    if (hasRangeKeys && hasSubKeys) {
+      return `Error: do not mix line-range mode and substring mode. Use EITHER (start_line/end_line/new_content) OR (old_string/new_string), never both.`;
+    }
 
     // ---- LINE-RANGE mode ---------------------------------------------------
     // `start_line`..`end_line` replace the lines at those 1-based positions,
@@ -47,6 +55,9 @@ start_line: { type: 'integer', minimum: 1, description: 'PREFERRED MODE. 1-based
     // self-contained: validate -> check the Read cache -> splice -> write ->
     // refresh the cache -> return.
     if (start_line != null && end_line != null) {
+      // Neither start/end alone is a valid range, and new_content is required —
+      // a missing one would put the literal string "undefined" in the file.
+      if (new_content == null) return `Error: new_content is required for line-range mode.`;
       const start = Number(start_line) | 0, end = Number(end_line) | 0;
       if (start < 1 || end < start) {
         return `Error: invalid line range ${start_line}-${end_line} (expected 1-based, start <= end).`;
@@ -90,6 +101,7 @@ start_line: { type: 'integer', minimum: 1, description: 'PREFERRED MODE. 1-based
     // ---- SUBSTRING mode (old_string -> new_string) --------------------------
     let { old_string, new_string, replace_all = false } = args;
     if (old_string === '' || old_string == null) return `Error: old_string must not be empty.`;
+    if (new_string == null) return `Error: new_string is required for substring mode.`;
 
     // --- Newline normalization (Windows CRLF) ---
     // The Read tool normalizes \r\n -> \n, so an agent builds old_string/new_string

package/src/tools/git.js

@@ -0,0 +1,155 @@
+// Git tool — structured access to the operations a coding agent performs
+// constantly, so it does not have to hand-write shell pipelines for status,
+// staging, committing, branching and worktrees.
+//
+// Destructive operations are deliberately NOT exposed (no reset --hard, no
+// checkout --, no branch -D): a mistake through this tool would be unrecoverable.
+// The agent can still run those through Bash when the user explicitly asks.
+
+import * as git from '../git.js';
+
+const ACTIONS = ['status', 'diff', 'stage', 'unstage', 'commit', 'log', 'branch', 'switch', 'worktree'];
+
+export const spec = {
+  name: 'Git',
+  description: `Run a git operation and return its result. Actions:
+- status: branch, staged/unstaged/untracked files.
+- diff: show changes. \`staged: true\` shows the index; \`path\` limits to one file.
+- stage: add files to the index (omit \`paths\` to stage everything).
+- unstage: remove files from the index.
+- commit: commit the staged index with \`message\` (multi-line allowed). Stages everything first if nothing is staged.
+- log: recent commits (use \`count\`, default 10).
+- branch: list branches, or create one with \`create: "<name>"\`.
+- switch: check out an existing branch named \`branch\`.
+- worktree: list worktrees, or add/remove one for parallel work.
+
+Use this instead of writing \`git\` shell pipelines. Destructive resets are not exposed; run those with Bash only if the user asked for it.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: ACTIONS, description: 'Which git operation to run.' },
+      paths: { type: 'array', items: { type: 'string' }, description: 'File paths (stage/unstage/diff).' },
+      message: { type: 'string', description: 'Commit message (commit). May be multi-line.' },
+      branch: { type: 'string', description: 'Branch name (switch/branch/worktree).' },
+      create: { type: 'string', description: 'Create a branch with this name (branch action).' },
+      from: { type: 'string', description: 'Base ref for a new branch (branch action).' },
+      staged: { type: 'boolean', default: false, description: 'Show the staged diff (diff action).' },
+      count: { type: 'integer', minimum: 1, description: 'Number of commits to show (log action; default 10).' },
+      dir: { type: 'string', description: 'Worktree directory (worktree action).' },
+      remove: { type: 'boolean', default: false, description: 'Remove the worktree instead of adding it (worktree action).' },
+      force: { type: 'boolean', default: false, description: 'Force worktree removal (worktree action).' },
+    },
+    required: ['action'],
+  },
+
+  async execute(args, ctx) {
+    const cwd = (ctx && (ctx.cwd || ctx.workspace)) || process.cwd();
+    const action = String(args.action || '').trim();
+    if (!ACTIONS.includes(action)) return `Error: unknown action "${action}". Use one of: ${ACTIONS.join(', ')}.`;
+    if (!git.isRepo(cwd)) return `Error: not a git repository: ${cwd}`;
+
+    switch (action) {
+      case 'status': {
+        const branch = git.currentBranch(cwd);
+        const s = git.status(cwd);
+        if (!s.ok) return `Error: ${s.error}`;
+        const lines = [`branch: ${branch}`, `head: ${git.headSha(cwd)}`, ''];
+        if (!s.entries.length) lines.push('Working tree clean.');
+        else {
+          lines.push(`Changes (${s.entries.length}):`);
+          for (const e of s.entries) {
+            const code = (e.x + e.y).trim() || '?';
+            lines.push(`  [${code}] ${e.path}${e.origPath ? ` (from ${e.origPath})` : ''}`);
+          }
+        }
+        return lines.join('\n');
+      }
+
+      case 'diff': {
+        const a = ['diff'];
+        if (args.staged) a.push('--cached');
+        a.push('--stat');
+        // paths after --
+        const paths = Array.isArray(args.paths) ? args.paths.filter(Boolean) : [];
+        const statR = git.runGit(a.concat(paths.length ? ['--', ...paths] : []), cwd);
+        if (!statR.ok) return `Error: ${statR.stderr.trim() || statR.error}`;
+        if (!statR.stdout.trim()) return args.staged ? 'No staged changes.' : 'No changes.';
+        // Also include the full diff, bounded so a huge change cannot flood context.
+        const full = git.runGit(['diff'].concat(args.staged ? ['--cached'] : []).concat(paths.length ? ['--', ...paths] : []), cwd);
+        const MAX = 60 * 1024;
+        let body = full.stdout || '';
+        let note = '';
+        if (body.length > MAX) { body = body.slice(0, MAX); note = `\n... [diff truncated at ${MAX} chars]`; }
+        return `${statR.stdout.trim()}\n\n${body}${note}`;
+      }
+
+      case 'stage': {
+        const paths = Array.isArray(args.paths) ? args.paths.filter(Boolean) : [];
+        const r = git.stage(paths, cwd);
+        if (!r.ok) return `Error: ${r.error}`;
+        const staged = git.stagedFiles(cwd);
+        return `Staged ${paths.length || 'all'} path(s). Index now holds ${staged.length} file(s):\n${staged.join('\n')}`;
+      }
+
+      case 'unstage': {
+        const paths = Array.isArray(args.paths) ? args.paths.filter(Boolean) : [];
+        const r = git.unstage(paths, cwd);
+        return r.ok ? `Unstaged ${paths.length || 'all'} path(s).` : `Error: ${r.error}`;
+      }
+
+      case 'commit': {
+        const message = String(args.message || '').trim();
+        if (!message) return 'Error: `message` is required for a commit.';
+        // Stage everything when the index is empty — "commit my changes" is the
+        // common request and an empty-index commit is almost never intended.
+        let autoStaged = false;
+        if (!git.hasStagedChanges(cwd)) {
+          const st = git.stage([], cwd);
+          if (!st.ok) return `Error staging: ${st.error}`;
+          autoStaged = true;
+        }
+        const r = git.commit(message, cwd);
+        if (!r.ok) return `Error: ${r.error}`;
+        return `${autoStaged ? 'Staged all changes.\n' : ''}Committed ${r.sha}.\n${r.stdout}`;
+      }
+
+      case 'log': {
+        const n = Math.max(1, Math.min(200, Number(args.count) || 10));
+        const r = git.runGit(['log', `-${n}`, '--pretty=format:%h %ad %s', '--date=short'], cwd);
+        return r.ok ? (r.stdout.trim() || 'No commits yet.') : `Error: ${r.stderr.trim() || r.error}`;
+      }
+
+      case 'branch': {
+        if (args.create) {
+          const r = git.createBranch(args.create, cwd, args.from);
+          return r.ok ? `Created and switched to branch ${args.create}.` : `Error: ${r.error}`;
+        }
+        const cur = git.currentBranch(cwd);
+        const list = git.listBranches(cwd);
+        return `Branches (current: ${cur}):\n` + list.map((b) => `  ${b === cur ? '* ' : '  '}${b}`).join('\n');
+      }
+
+      case 'switch': {
+        const r = git.switchBranch(args.branch, cwd);
+        return r.ok ? `Switched to ${args.branch}.` : `Error: ${r.error}`;
+      }
+
+      case 'worktree': {
+        if (!args.dir) {
+          const list = git.listWorktrees(cwd);
+          return `Worktrees (${list.length}):\n` + list.map((w) => `  ${w.path} ${w.branch ? '[' + w.branch + ']' : ''}`).join('\n');
+        }
+        if (args.remove) {
+          const r = git.removeWorktree(args.dir, cwd, { force: !!args.force });
+          return r.ok ? `Removed worktree ${args.dir}.` : `Error: ${r.error}`;
+        }
+        const r = git.addWorktree(args.dir, args.branch, cwd);
+        if (!r.ok) return `Error: ${r.error}`;
+        return r.reused ? `Worktree already present: ${r.path}` : `Worktree created at ${r.path}${r.branch ? ` on ${r.branch}` : ''}.`;
+      }
+
+      default:
+        return `Error: unhandled action "${action}".`;
+    }
+  },
+};

package/src/tools/index.js

@@ -12,6 +12,7 @@ import * as fetchUrlMod from './fetch-url.js';
 import * as webSearchMod from './web-search.js';
 import * as readMediaFileMod from './read-media-file.js';
 import * as fileLinesMod from './file-lines.js';
+import * as gitMod from './git.js';
 import * as askUserQuestionMod from './ask-user-question.js';
 import { spec as agentSpec } from './agent.js';
 import { spec as agentSwarmSpec } from './agent-swarm.js';
@@ -31,6 +32,7 @@ const builtinTools = [
   webSearchMod.spec,
   readMediaFileMod.spec,
   fileLinesMod.spec,
+  gitMod.spec,
   askUserQuestionMod.spec,
   agentSpec,
   agentSwarmSpec,