@hncode/hncode 0.3.2 → 0.3.4

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,