mini-coder 0.0.20 → 0.0.22

package/.claude/settings.local.json

@@ -0,0 +1,31 @@
+{
+  "permissions": {
+    "allow": [
+      "WebSearch",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:dev.to)",
+      "WebFetch(domain:mariozechner.at)",
+      "WebFetch(domain:lobste.rs)",
+      "WebFetch(domain:reading.sh)",
+      "WebFetch(domain:daveswift.com)",
+      "Bash(grep:*)",
+      "Bash(ls:*)",
+      "Bash(bun run:*)",
+      "Bash(git stash:*)",
+      "Bash(gh pr:*)",
+      "Bash(git status:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(sqlite3:*)",
+      "Bash(git branch:*)",
+      "Bash(git checkout:*)",
+      "Bash(npm info:*)",
+      "Bash(npm install:*)",
+      "Bash(find:*)",
+      "Bash(git log:*)",
+      "Bash(npm ls:*)",
+      "Bash(gh api:*)",
+      "Bash(bun:*)"
+    ]
+  }
+}

package/README.md

@@ -26,20 +26,18 @@ I was built with a simple philosophy: **dev flow first**. No slow startup. No cl
 
 My toolkit is lean on purpose — every tool earns its spot, no passengers:
 
-| Tool            | What it does                                                |
-| --------------- | ----------------------------------------------------------- |
-| 🔍 `glob`       | Find files by pattern across your project                   |
-| 🧲 `grep`       | Search file contents with regex                             |
-| 📖 `read`       | Read files (with line-range support)                        |
-| 📝 `create`     | Create a new file or fully overwrite an existing file       |
-| ✏️ `replace`    | Replace or delete lines using hashline anchors              |
-| ➕ `insert`     | Insert lines before/after an anchor without replacing       |
-| 🐚 `shell`      | Run shell commands and see their output                     |
-| 🤖 `subagent`   | Spawn a focused mini-me for parallel subtasks               |
-| 🌐 `webSearch`  | Search the web when `EXA_API_KEY` is set                    |
-| 📄 `webContent` | Fetch full page content from URLs when `EXA_API_KEY` is set |
-
-Need more firepower? I connect to **MCP servers** over HTTP or stdio — bolt on external tools whenever the job calls for it.
+| Tool            | What it does                                                               |
+| --------------- | -------------------------------------------------------------------------- |
+| 🐚 `shell`      | Run shell commands, inspect the repo, and use `mc-edit` for targeted edits |
+| 🤖 `subagent`   | Spawn a focused mini-me for parallel subtasks                              |
+| 🧰 `listSkills` | List discovered skills without loading full skill bodies                   |
+| 📘 `readSkill`  | Load one `SKILL.md` on demand                                              |
+| 🌐 `webSearch`  | Search the web when `EXA_API_KEY` is set                                   |
+| 📄 `webContent` | Fetch full page content from URLs when `EXA_API_KEY` is set                |
+
+mini-coder is intentionally **shell-first**: inspect with shell, edit with `mc-edit`, verify with shell.
+
+Need more firepower? I also connect to **MCP servers** over HTTP or stdio — attached MCP tools show up dynamically whenever the job calls for them.
 
 ---
 
@@ -49,13 +47,12 @@ Need more firepower? I connect to **MCP servers** over HTTP or stdio — bolt on
 - **Built-in web search** — set `EXA_API_KEY` and I expose `webSearch` + `webContent` tools.
 - **Session memory** — conversations are saved in a local SQLite database. Resume where you left off with `-c` or pick a specific session with `-r <id>`.
 - **Shell integration** — prefix with `!` to run shell commands inline. Use `@` to reference files in your prompt (with Tab completion).
-- **Slash commands** — `/model` or `/models` to list/switch models, `/model effort <low|medium|high|xhigh|off>` for reasoning effort, `/reasoning [on|off]` to toggle reasoning display, `/context` to inspect or tune pruning/tool-result caps, `/plan` for read-only thinking mode, `/ralph` for autonomous looping, `/review` for a code review (global custom command, auto-created at `~/.agents/commands/review.md`), `/agent [name]` to set or clear an active primary agent, `/undo` to roll back a turn, `/new` for a clean session, `/mcp list|add|remove` to manage MCP servers, and `/exit` (`/quit`, `/q`) to leave. See all with `/help`.
+- **Slash commands** — `/model` or `/models` to list/switch models, `/model effort <low|medium|high|xhigh|off>` for reasoning effort, `/reasoning [on|off]` to toggle reasoning display, `/context` to inspect or tune pruning/tool-result caps, `/cache` to configure prompt caching, `/review` for a code review (global custom command, auto-created at `~/.agents/commands/review.md`), `/agent [name]` to set or clear an active primary agent, `/undo` to remove the last conversation turn (it does not revert filesystem changes), `/new` for a clean session, `/mcp list|add|remove` to manage MCP servers, and `/exit` (`/quit`, `/q`) to leave. See all with `/help`.
 
 - **Custom commands** — drop a `.md` file in `.agents/commands/` and it becomes a `/command`. Claude-compatible `.claude/commands/` works too. Supports argument placeholders (`$ARGUMENTS`, `$1`…`$9`) and shell interpolation (`` !`cmd` ``). Global commands live in `~/.agents/commands/` and `~/.claude/commands/`. Custom commands take precedence over built-ins. → [docs/custom-commands.md](docs/custom-commands.md)
-- **Custom agents** — drop a `.md` file in `.agents/agents/` or `.claude/agents/` (or `~/.agents/agents/` / `~/.claude/agents/` globally) and activate it with `/agent [name]`. Agent definitions are also exposed to subagent delegation unless `mode: primary`. `@agent-name` is supported for completion and is a useful prompt convention. → [docs/custom-agents.md](docs/custom-agents.md)
+- **Custom agents** — drop a `.md` file in `.agents/agents/` or `.claude/agents/` (or `~/.agents/agents/` / `~/.claude/agents/` globally) and activate it with `/agent [name]`. Agent definitions are also exposed to subagent delegation unless `mode: primary`. → [docs/custom-agents.md](docs/custom-agents.md)
 - **Skills** — place a `SKILL.md` in `.agents/skills/<name>/` and inject it into any prompt with `@skill-name`. Claude-compatible `.claude/skills/<name>/SKILL.md` works too. Skills are _never_ auto-loaded — always explicit. → [docs/skills.md](docs/skills.md)
-- **Post-tool hooks** — drop an executable at `.agents/hooks/post-<tool>` (or `~/.agents/hooks/post-<tool>` globally) and I'll run it after matching built-in tool calls. → [docs/tool-hooks.md](docs/tool-hooks.md)
-- **Beautiful, minimal output** — diffs for edits, formatted trees for file searches, a live status bar with model, git branch, and token counts.
+- **Beautiful, minimal output** — compact tool output, formatted trees for file searches, a live status bar with model, git branch, and token counts.
 - **16 ANSI colors only** — my output inherits _your_ terminal theme. Dark mode, light mode, Solarized, Gruvbox — I fit right in.
 
 ---
@@ -64,7 +61,7 @@ Need more firepower? I connect to **MCP servers** over HTTP or stdio — bolt on
 
 - **I eat my own dog food.** I was built _by_ a mini-coder agent. It's agents all the way down. 🐢
 - **I'm tiny but mighty.** The whole runtime is [Bun.js](https://bun.com) — fast startup, native TypeScript, and a built-in SQLite driver.
-- **I respect existing conventions.** Hook scripts live in `.agents/hooks/`, context in `AGENTS.md` or `CLAUDE.md`, commands in `.agents/commands/`, agents in `.agents/agents/`, skills in `.agents/skills/` — I follow the ecosystem instead of inventing new standards.
+- **I respect existing conventions.** Context lives in `AGENTS.md` or `CLAUDE.md`, commands in `.agents/commands/`, agents in `.agents/agents/`, skills in `.agents/skills/` — I follow the ecosystem instead of inventing new standards.
 - **I spin while I think.** ⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏ (It's the little things.)
 - **I can clone myself.** The `subagent` tool lets me spin up parallel instances of myself to tackle independent subtasks simultaneously. Divide and conquer! (Up to 10 levels deep.)
 
@@ -82,7 +79,6 @@ I follow the [`.agents` convention](https://github.com/agentsmd/agents) — the
 | `.claude/agents/*.md`            | Alternate `.claude` path for custom agents            |
 | `.agents/skills/<name>/SKILL.md` | Reusable skill instructions (`@name`)                 |
 | `.claude/skills/<name>/SKILL.md` | Claude-compatible skills                              |
-| `.agents/hooks/post-<tool>`      | Scripts run after supported built-in tool calls       |
 | `.agents/AGENTS.md`              | Preferred local project context                       |
 | `CLAUDE.md`                      | Local fallback context if `.agents/AGENTS.md` is absent |
 | `AGENTS.md`                      | Local fallback context if `.agents/AGENTS.md` and `CLAUDE.md` are absent |
@@ -119,7 +115,7 @@ export EXA_API_KEY=your-exa-key         # enables webSearch/webContent
 mc
 ```
 
-Or drop me a prompt straight away and stay in the session:
+Or drop me a prompt straight away for one-shot mode (runs once, then exits):
 
 ```bash
 mc "Refactor the auth module to use async/await"
@@ -142,7 +138,7 @@ mc -h                           # show help
 
 Everything I remember lives in `~/.config/mini-coder/` — here's what I'm holding onto:
 
-- `sessions.db` — your full session history, `/undo` snapshots, MCP server config, and model metadata, all in one tidy SQLite file
+- `sessions.db` — your full session history, MCP server config, and model metadata, all in one tidy SQLite file
 - `api.log` — a request/response log for every provider call this run, if you want to peek under the hood
 - `errors.log` — anything that went sideways, caught and written down so you can actually debug it
 
@@ -156,7 +152,6 @@ The README hits the highlights — the docs have the full story:
 - [docs/custom-agents.md](docs/custom-agents.md)
 - [docs/skills.md](docs/skills.md)
 - [docs/configs.md](docs/configs.md)
-- [docs/tool-hooks.md](docs/tool-hooks.md)
 
 ## 🗂️ Project Structure
 
@@ -166,8 +161,9 @@ src/
   agent/            # Main REPL loop + tool registry
   cli/              # Input, output, slash commands, markdown rendering
   llm-api/          # Provider factory + streaming turn logic
-  tools/            # glob, grep, read, create, replace, insert, shell, subagent
-                    #   + webSearch, webContent, hashline anchors, diffs, hooks, snapshots
+  tools/            # shell, subagent, skill tools
+                    #   + webSearch, webContent
+  internal/         # shared internals, including the mc-edit helper implementation
   mcp/              # MCP server connections
   session/          # SQLite-backed session & history management
 ```

package/dist/mc-edit.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli/structured-output.ts
+import { createTwoFilesPatch } from "diff";
+function normalizePatchLines(patchText) {
+  const patchLines = patchText.split(`
+`);
+  while (patchLines.at(-1) === "") {
+    patchLines.pop();
+  }
+  const diffLines = patchLines.filter((line) => !line.startsWith("Index: ") && line !== "===================================================================");
+  return diffLines.map((line) => {
+    if (line.startsWith("--- ") || line.startsWith("+++ ")) {
+      return line.split("\t", 1)[0] ?? line;
+    }
+    return line;
+  });
+}
+function renderUnifiedDiff(filePath, before, after) {
+  if (before === after) {
+    return "(no changes)";
+  }
+  const patchText = createTwoFilesPatch(filePath, filePath, before, after, "", "", {
+    context: 3
+  });
+  return normalizePatchLines(patchText).join(`
+`);
+}
+function renderMetadataBlock(result) {
+  const lines = [`ok: ${result.ok}`];
+  if ("path" in result && result.path) {
+    lines.push(`path: ${result.path}`);
+  }
+  if (result.ok) {
+    lines.push(`changed: ${result.changed}`);
+  } else {
+    lines.push(`code: ${result.code}`);
+    lines.push(`message: ${result.message}`);
+  }
+  return lines.join(`
+`);
+}
+function writeFileEditResult(io, result) {
+  if (result.ok) {
+    const sections = [
+      renderUnifiedDiff(result.path, result.before, result.after),
+      renderMetadataBlock(result)
+    ];
+    io.stdout(`${sections.join(`
+
+`)}
+`);
+    return;
+  }
+  io.stderr(`${renderMetadataBlock(result)}
+`);
+}
+
+// src/internal/file-edit/path.ts
+import { homedir } from "os";
+import { join, relative } from "path";
+function stripMatchingQuotes(value) {
+  if (value.length < 2)
+    return value;
+  const first = value[0];
+  const last = value[value.length - 1];
+  if ((first === '"' || first === "'") && first === last) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function normalizePathInput(pathInput) {
+  return stripMatchingQuotes(pathInput.trim());
+}
+function resolvePath(cwdInput, pathInput) {
+  const cwd = cwdInput ?? process.cwd();
+  const normalizedInput = normalizePathInput(pathInput);
+  const expanded = normalizedInput.startsWith("~/") ? join(homedir(), normalizedInput.slice(2)) : normalizedInput === "~" ? homedir() : normalizedInput;
+  const filePath = expanded.startsWith("/") ? expanded : join(cwd, expanded);
+  const relPath = relative(cwd, filePath);
+  return { cwd, filePath, relPath };
+}
+
+// src/internal/file-edit/exact-text.ts
+class FileEditError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "FileEditError";
+  }
+}
+function findExactMatchOffsets(source, target) {
+  if (target.length === 0) {
+    throw new FileEditError("empty_old_text", "Expected text must be non-empty.");
+  }
+  const matches = [];
+  let searchStart = 0;
+  while (searchStart <= source.length - target.length) {
+    const matchIndex = source.indexOf(target, searchStart);
+    if (matchIndex === -1)
+      break;
+    matches.push(matchIndex);
+    searchStart = matchIndex + 1;
+  }
+  return matches;
+}
+function planExactTextEdit(source, oldText, newText) {
+  const matches = findExactMatchOffsets(source, oldText);
+  if (matches.length === 0) {
+    throw new FileEditError("target_not_found", "Expected text was not found in the file.");
+  }
+  if (matches.length > 1) {
+    throw new FileEditError("target_not_unique", "Expected text matched multiple locations in the file.");
+  }
+  const matchIndex = matches[0] ?? 0;
+  const updated = source.slice(0, matchIndex) + newText + source.slice(matchIndex + oldText.length);
+  return {
+    updated,
+    changed: updated !== source
+  };
+}
+async function applyExactTextEdit(input) {
+  const { filePath, relPath } = resolvePath(input.cwd, input.path);
+  const file = Bun.file(filePath);
+  if (!await file.exists()) {
+    throw new FileEditError("file_not_found", `File not found: "${relPath}".`);
+  }
+  const original = await file.text();
+  const plan = planExactTextEdit(original, input.oldText, input.newText);
+  if (plan.changed) {
+    await Bun.write(filePath, plan.updated);
+  }
+  return {
+    path: relPath,
+    changed: plan.changed,
+    before: original,
+    after: plan.updated
+  };
+}
+
+// src/internal/file-edit/cli.ts
+var HELP = `Usage: mc-edit <path> (--old <text> | --old-file <path>) [--new <text> | --new-file <path>] [--cwd <path>]
+
+Apply one safe exact-text edit to an existing file.
+- The expected old text must match exactly once.
+- Omit --new / --new-file to delete the matched text.
+- Success output is human-oriented: plain unified diff first, metadata second.`;
+async function readArgText(flag, filePath) {
+  const file = Bun.file(filePath);
+  if (!await file.exists()) {
+    throw new FileEditError("file_not_found", `${flag} file not found: "${filePath}".`);
+  }
+  return file.text();
+}
+async function parseFileEditCliArgs(argv) {
+  let cwd = process.cwd();
+  let path = null;
+  let oldText = null;
+  let oldFilePath = null;
+  let newText = null;
+  let newFilePath = null;
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i] ?? "";
+    switch (arg) {
+      case "--help":
+      case "-h":
+        return null;
+      case "--cwd":
+        cwd = argv[++i] ?? process.cwd();
+        break;
+      case "--old":
+        oldText = argv[++i] ?? "";
+        break;
+      case "--old-file":
+        oldFilePath = argv[++i] ?? null;
+        break;
+      case "--new":
+        newText = argv[++i] ?? "";
+        break;
+      case "--new-file":
+        newFilePath = argv[++i] ?? null;
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          throw new Error(`Unknown flag: ${arg}`);
+        }
+        if (path !== null) {
+          throw new Error("Expected exactly one positional <path> argument.");
+        }
+        path = arg;
+    }
+  }
+  if (path === null) {
+    throw new Error("Missing required <path> argument.");
+  }
+  if (oldText === null === (oldFilePath === null)) {
+    throw new Error("Provide exactly one of --old or --old-file.");
+  }
+  if (newText !== null && newFilePath !== null) {
+    throw new Error("Provide at most one of --new or --new-file.");
+  }
+  return {
+    cwd,
+    path,
+    oldText: oldText ?? await readArgText("--old-file", oldFilePath ?? ""),
+    newText: newText ?? (newFilePath ? await readArgText("--new-file", newFilePath) : "")
+  };
+}
+function buildCliFailure(code, message, path) {
+  return {
+    ok: false,
+    code,
+    message,
+    ...path ? { path } : {}
+  };
+}
+function normalizeCliError(error, path) {
+  if (error instanceof FileEditError) {
+    return buildCliFailure(error.code, error.message, path);
+  }
+  if (error instanceof Error) {
+    return buildCliFailure("invalid_args", error.message, path);
+  }
+  return buildCliFailure("invalid_args", "Unknown error.", path);
+}
+async function runFileEditCli(argv, io = {
+  stdout: (text) => process.stdout.write(text),
+  stderr: (text) => process.stderr.write(text)
+}) {
+  let parsed = null;
+  try {
+    parsed = await parseFileEditCliArgs(argv);
+    if (parsed === null) {
+      io.stderr(`${HELP}
+`);
+      return 0;
+    }
+    const result = await applyExactTextEdit(parsed);
+    writeFileEditResult(io, { ok: true, ...result });
+    return 0;
+  } catch (error) {
+    writeFileEditResult(io, normalizeCliError(error, parsed?.path));
+    return 1;
+  }
+}
+
+// src/mc-edit.ts
+var exitCode = await runFileEditCli(process.argv.slice(2));
+process.exit(exitCode);