interference-agent 0.1.0 → 0.2.3

package/README.md

@@ -3,7 +3,7 @@
 <p align="center"><strong>The open-source coding agent that lives in your terminal.</strong></p>
 
 <p align="center">
-  TypeScript + Bun · Plan / Build modes · 9 tools · permissions · sessions with undo · 38 skills · subagents · TUI
+  TypeScript + Bun · Plan / Build modes · 11 tools · permissions · sessions with undo · extensible skills · subagents · TUI
 </p>
 
 ---
@@ -14,10 +14,10 @@ permissions and a read-only **Plan** mode so nothing happens without your say-so
 
 ## Features
 
-- **9 tools**: `read` · `ls` · `glob` · `grep` · `webfetch` · `write` · `edit` · `bash` · `task` (subagent)
+- **11 tools**: `read` · `ls` · `glob` · `grep` · `webfetch` · `write` · `edit` · `bash` · `todowrite` · `question` · `task` (subagent)
 - **Plan & Build** modes — explore read-only, switch to full access when ready
 - **Permissioned by design** — allow / ask / deny enforced in code, not in the prompt; dangerous commands auto-blocked (`rm -rf`, `sudo`, `curl | sh`)
-- **38 skills** — auto-detected by keyword matching, or invoked explicitly via `/skill-name`; full Agent Skills format support
+- **Extensible skills** — Agent Skills format (SKILL.md); auto-detected by keyword matching, or invoked via `/skill-name`; 3 skills bundled, user-extensible
 - **Subagents** — delegate complex tasks to isolated agents (`explore` for read-only, `general` for full access)
 - **Atomic edit** — unique-match string replacement with `replaceAll` support
 - **Safe bash** — timeout, output truncation, exit code, dangerous-command deny list
@@ -51,13 +51,34 @@ permissions and a read-only **Plan** mode so nothing happens without your say-so
 ## Quickstart
 
 ```bash
-bun install
-# Set API key in .env (Bun auto-loads it)
-echo 'DEEPSEEK_API_KEY=sk-...' > .env
-bun run interference
+bun install -g interference-agent
+interference
 ```
 
-> Requires **Bun 1.3+** (Node ≥22 / React ≥19.2 for the Ink TUI).
+On first run, use `/provider` to add your API keys. They're saved in `~/.interference/auth.json`.
+
+interference stores its state in `~/.interference/` — sessions, skills, snapshots, and auth — just like Claude Code uses `~/.claude/`.
+
+> Requires **Bun 1.3+**.
+
+## Updating
+
+```bash
+bun install -g interference-agent@latest   # or: npm i -g interference-agent@latest
+```
+
+interference checks npm for new versions and shows a discreet notice when one is available; run `/update` from inside the app to upgrade.
+
+## Releasing (maintainers)
+
+Releases publish to npm automatically on tag push:
+
+```bash
+npm version minor        # runs typecheck+test, bumps, tags
+git push --follow-tags   # the `publish` GitHub Action publishes to npm
+```
+
+Requires the `NPM_TOKEN` repo secret. See `CHANGELOG.md`.
 
 ## Screenshot
 

package/package.json

@@ -1,23 +1,42 @@
 {
   "name": "interference-agent",
-  "version": "0.1.0",
+  "version": "0.2.3",
   "description": "The open-source coding agent that lives in your terminal.",
   "type": "module",
   "license": "MIT",
   "author": "ricciviero",
   "repository": "github:ricciviero/interference",
   "homepage": "https://github.com/ricciviero/interference#readme",
-  "keywords": ["ai", "coding-agent", "terminal", "cli", "bun", "typescript", "llm", "open-source"],
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "terminal",
+    "cli",
+    "bun",
+    "typescript",
+    "llm",
+    "open-source"
+  ],
   "bin": {
     "interference": "./src/cli.ts"
   },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
   "scripts": {
     "interference": "bun run src/cli.ts",
     "start": "bun run src/cli.ts",
     "dev": "bun run --watch src/cli.ts",
     "typecheck": "bunx tsc --noEmit",
     "build": "bun build src/cli.ts --compile --minify --sourcemap --outfile dist/interference",
-    "test": "bun test ./src"
+    "test": "bun test ./src",
+    "preversion": "bun run typecheck && bun run test",
+    "postversion": "git push && git push --tags"
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^4.0.1",

package/src/__tests__/version.test.ts

@@ -0,0 +1,24 @@
+import { describe, test, expect } from "bun:test";
+import { isNewer, CURRENT_VERSION } from "../version.ts";
+import { dispatch } from "../commands/index.ts";
+
+describe("version / update (iter 28)", () => {
+  test("isNewer compares semver correctly", () => {
+    expect(isNewer("0.2.0", "0.1.0")).toBe(true);
+    expect(isNewer("1.0.0", "0.9.9")).toBe(true);
+    expect(isNewer("0.1.1", "0.1.0")).toBe(true);
+    expect(isNewer("0.1.0", "0.1.0")).toBe(false);
+    expect(isNewer("0.1.0", "0.2.0")).toBe(false);
+    expect(isNewer("v0.3.0", "0.2.9")).toBe(true); // tollera prefisso v
+  });
+
+  test("CURRENT_VERSION matches package.json", async () => {
+    const pkg = await Bun.file(new URL("../../package.json", import.meta.url)).json();
+    expect(CURRENT_VERSION).toBe(pkg.version);
+  });
+
+  test("/version command returns the version", async () => {
+    const out = await dispatch("/version", {});
+    expect(out).toBe(`interference v${CURRENT_VERSION}`);
+  });
+});

package/src/auth.ts

@@ -1,21 +1,19 @@
 import { readFile, writeFile, mkdir, chmod } from "node:fs/promises";
 import * as path from "node:path";
-
-const AUTH_DIR = path.join(
-  process.env.HOME ?? process.env.USERPROFILE ?? "/tmp",
-  ".interference",
-);
+import { interferenceDir } from "./paths.ts";
 
 interface ProviderAuth {
   label: string;
   envKey: string;
 }
 
-const AUTH_FILE = path.join(AUTH_DIR, "auth.json");
+// Risolti a runtime (non all'import) così INTERFERENCE_HOME isola i test.
+const authDir = (): string => interferenceDir();
+const authFile = (): string => path.join(authDir(), "auth.json");
 
 export async function loadAuth(): Promise<Record<string, string>> {
   try {
-    const raw = await readFile(AUTH_FILE, "utf-8");
+    const raw = await readFile(authFile(), "utf-8");
     return JSON.parse(raw) as Record<string, string>;
   } catch {
     return {};
@@ -23,9 +21,9 @@ export async function loadAuth(): Promise<Record<string, string>> {
 }
 
 export async function saveAuth(auth: Record<string, string>): Promise<void> {
-  await mkdir(AUTH_DIR, { recursive: true });
-  await writeFile(AUTH_FILE, JSON.stringify(auth, null, 2));
-  try { await chmod(AUTH_FILE, 0o600); } catch {}
+  await mkdir(authDir(), { recursive: true });
+  await writeFile(authFile(), JSON.stringify(auth, null, 2));
+  try { await chmod(authFile(), 0o600); } catch {}
 }
 
 export function applyAuthToEnv(auth: Record<string, string>, providers: Record<string, ProviderAuth>): void {

package/src/cli-plain.ts

@@ -226,18 +226,18 @@ async function consumeTurn(chunks: AsyncGenerator<Chunk>): Promise<void> {
   for await (const chunk of chunks) {
     switch (chunk.type) {
       case "reasoning":
-        if (!sawReasoning) { stdout.write(`${DIM}┄ thinking${RESET}\n`); sawReasoning = true; }
+        if (!sawReasoning) { stdout.write(`${YELLOW}✻ Thinking${RESET}\n`); sawReasoning = true; }
         stdout.write(`${DIM}${chunk.text}${RESET}`);
         break;
       case "text":
         if (activeTool) { stdout.write("\n"); activeTool = null; }
-        if (sawReasoning && !inText) { stdout.write(`\n${DIM}┄${RESET}\n\n`); inText = true; }
+        if (sawReasoning && !inText) { stdout.write(`\n\n`); inText = true; }
         else if (!inText) { inText = true; }
         stdout.write(chunk.text);
         break;
       case "tool-call": {
         const args = typeof chunk.input === "string" ? chunk.input : JSON.stringify(chunk.input);
-        if (sawReasoning && !inText) { stdout.write(`\n${DIM}┄${RESET}\n\n`); inText = true; }
+        if (sawReasoning && !inText) { stdout.write(`\n\n`); inText = true; }
         else if (activeTool || !inText) { stdout.write("\n"); }
         stdout.write(`${DIM}· ${chunk.toolName}${RESET}(${args})`);
         activeTool = { name: chunk.toolName, args, input: chunk.input };

package/src/cli.ts

@@ -11,8 +11,16 @@ import { loadConfig, applyConfig } from "./config-file.ts";
 import { loadAuth, applyAuthToEnv } from "./auth.ts";
 import { PROVIDERS } from "./config.ts";
 import type { Session } from "./session/store.ts";
+import { CURRENT_VERSION } from "./version.ts";
 
 async function main(): Promise<void> {
+  // --version / -v: stampa la versione ed esce (prima di tutto).
+  const cliArgs = Bun.argv.slice(2);
+  if (cliArgs.includes("--version") || cliArgs.includes("-v")) {
+    stdout.write(`${CURRENT_VERSION}\n`);
+    return;
+  }
+
   // Titolo + nome-icona della tab del terminale (come Claude Code), solo in TTY
   // (in pipe/non-TTY le sequenze OSC sporcherebbero l'output).
   // OSC 1 = icon/tab name, OSC 2 = window title.

package/src/commands/index.ts

@@ -2,6 +2,7 @@ import type { AgentMode, ThinkingLevel } from "../config.ts";
 import { currentProvider, currentThinking, setThinking, currentModel, setModel } from "../config.ts";
 import { undo, redo } from "../session/snapshot.ts";
 import { loadSkillBody, getCachedRegistry, type SkillInfo } from "../skills.ts";
+import { CURRENT_VERSION } from "../version.ts";
 
 export interface CommandInfo {
   name: string;
@@ -74,6 +75,23 @@ export function isSlashCommand(input: string): boolean {
   return /^\//.test(input);
 }
 
+register("version", "Show the interference version", () => {
+  return `interference v${CURRENT_VERSION}`;
+});
+
+register("update", "Update interference to the latest version", async () => {
+  const proc = Bun.spawn(["npm", "i", "-g", "interference-agent@latest"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const code = await proc.exited;
+  if (code === 0) {
+    return "Updated to the latest version. Restart interference to use it.";
+  }
+  const err = (await new Response(proc.stderr).text()).trim().slice(0, 300);
+  return `Update failed (exit ${code}).${err ? `\n${err}` : ""}\nTry manually: npm i -g interference-agent@latest`;
+});
+
 register("help", "Show available commands", () => {
   const lines = ["Available commands:"];
   for (const cmd of listCommands()) {

package/src/config.ts

@@ -70,6 +70,7 @@ export const PROVIDERS: Record<ProviderId, ProviderDef> = {
     thinkingLevels: ["off", "low", "medium", "high", "max"],
     defaultThinking: "high",
     models: [
+      { id: "claude-sonnet-5", label: "Claude Sonnet 5 (1M ctx)" },
       { id: "claude-opus-4-8", label: "Claude Opus 4.8 (1M ctx)" },
       { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6 (1M ctx)" },
     ],
@@ -90,14 +91,16 @@ export const PROVIDERS: Record<ProviderId, ProviderDef> = {
   kimi: {
     label: "Moonshot Kimi",
     envKey: "KIMI_API_KEY",
-    defaultModel: "kimi-k2.7",
+    defaultModel: "kimi-k2.7-code",
     kind: "openai-compatible",
     contextLimit: 1_000_000,
     baseURL: "https://api.moonshot.ai/v1",
     thinkingLevels: ["off", "max"],
     defaultThinking: "max",
     models: [
-      { id: "kimi-k2.7", label: "Kimi K2.7 (1M ctx)" },
+      { id: "kimi-k2.7-code", label: "Kimi K2.7 Code (thinking always on)" },
+      { id: "kimi-k2.6", label: "Kimi K2.6 (thinking opzionale)" },
+      { id: "kimi-k2.5", label: "Kimi K2.5" },
     ],
   },
 };
@@ -171,19 +174,13 @@ export interface ReasoningConfig {
   maxOutputTokens?: number;
 }
 
-// Anthropic: livello → budget token del thinking (maxOutputTokens deve superarlo).
-const ANTHROPIC_BUDGET: Record<Exclude<ThinkingLevel, "off">, number> = {
-  low: 8_000,
-  medium: 16_000,
-  high: 32_000,
-  max: 60_000,
-};
-
 /** Traduce il livello di thinking corrente nelle opzioni del provider attivo. */
 export function reasoningConfig(): ReasoningConfig {
   const level = currentThinking();
 
-  switch (config.provider) {
+  // Provider EFFETTIVO: rispetta l'override runtime (`/provider`, `/model`),
+  // non solo `config.provider` (statico da env all'avvio).
+  switch (_providerOverride ?? config.provider) {
     case "deepseek":
       if (level === "off") {
         return { providerOptions: { deepseek: { thinking: { type: "disabled" } } } };
@@ -193,11 +190,18 @@ export function reasoningConfig(): ReasoningConfig {
       };
 
     case "anthropic": {
-      if (level === "off") return {};
-      const budget = ANTHROPIC_BUDGET[level];
+      // Modelli Anthropic moderni (Sonnet 5, Opus 4.8/4.7, Fable 5) NON supportano
+      // `thinking.type: "enabled"` (→ HTTP 400): si usa adaptive thinking + effort.
+      // `off` → solo effort basso (niente adaptive): il modello resta veloce/economico.
+      // (Senza inviare effort, il default lato server è `high` → "off" non spegnerebbe nulla.)
+      if (level === "off") {
+        return { providerOptions: { anthropic: { effort: "low" } } };
+      }
+      // display:"summarized" rende visibile il ragionamento (di default è omesso).
       return {
-        providerOptions: { anthropic: { thinking: { type: "enabled", budgetTokens: budget } } },
-        maxOutputTokens: budget + 8_000,
+        providerOptions: {
+          anthropic: { thinking: { type: "adaptive", display: "summarized" }, effort: level },
+        },
       };
     }
 
@@ -205,8 +209,15 @@ export function reasoningConfig(): ReasoningConfig {
     case "glm":
       return { extraBody: { thinking: { type: level === "off" ? "disabled" : "enabled" } } };
 
-    case "kimi":
-      if (level === "off") return { extraBody: { thinking: { type: "disabled" } } };
-      return { extraBody: { thinking: { type: "enabled", keep: "all" } } };
+    case "kimi": {
+      // Reasoning Moonshot (campo `reasoning_content`, letto nativamente da @ai-sdk/openai-compatible).
+      // max_tokens ≥ 16000 richiesto: la somma reasoning+content non deve superare max_tokens.
+      // I modelli `*-code` hanno il thinking SEMPRE ON e NON accettano il param `thinking`.
+      const alwaysOn = currentModel().includes("k2.7-code");
+      if (alwaysOn) return { maxOutputTokens: 16_000 };
+      if (level === "off")
+        return { extraBody: { thinking: { type: "disabled" } }, maxOutputTokens: 16_000 };
+      return { extraBody: { thinking: { type: "enabled", keep: "all" } }, maxOutputTokens: 16_000 };
+    }
   }
 }

package/src/cost.ts

@@ -6,6 +6,8 @@ interface Pricing {
 }
 
 const PRICING: Record<string, Pricing> = {
+  // Sonnet 5: standard $3/$15 (intro $2/$10 fino al 2026-08-31).
+  "claude-sonnet-5": { inputPer1M: 3.0, outputPer1M: 15.0 },
   "deepseek-v4-pro": { inputPer1M: 2.0, outputPer1M: 8.0 },
   "deepseek-v4-flash": { inputPer1M: 0.27, outputPer1M: 1.10 },
   "gpt-5.5": { inputPer1M: 5.0, outputPer1M: 30.0 },

package/src/paths.ts

@@ -0,0 +1,25 @@
+import * as path from "node:path";
+
+/**
+ * Home base dei dati di interference (`~/.interference`).
+ *
+ * `INTERFERENCE_HOME` ridireziona l'intero store dell'app: usato dai test per
+ * isolarsi dalla directory reale dell'utente, così nessun test possa scrivere
+ * o cancellare dati veri (sessioni, snapshot, credenziali, skill, cache update).
+ *
+ * Tutti i consumatori di `~/.interference` DEVONO passare da qui — non
+ * ricalcolare la home a mano (vedi store/skills/auth/version).
+ */
+export function interferenceHome(): string {
+  return (
+    process.env.INTERFERENCE_HOME ??
+    process.env.HOME ??
+    process.env.USERPROFILE ??
+    "/tmp"
+  );
+}
+
+/** Path dentro `~/.interference` (o la home reindirizzata da INTERFERENCE_HOME). */
+export function interferenceDir(...segments: string[]): string {
+  return path.join(interferenceHome(), ".interference", ...segments);
+}

package/src/session/__tests__/session.test.ts

@@ -26,7 +26,14 @@ import type { ModelMessage } from "ai";
 
 const TMP = path.join(process.cwd(), ".test-tmp-session");
 
+// ISOLAMENTO STORE: reindirizza ~/.interference verso TMP così i test su
+// saveSession/cleanupSessions/deleteSession NON tocchino mai le sessioni reali
+// dell'utente. Senza questo override, `cleanupSessions(2)` cancellerebbe le
+// chat vere salvate in ~/.interference/<hash>/sessions.
+const PREV_HOME = process.env.INTERFERENCE_HOME;
+
 beforeAll(async () => {
+  process.env.INTERFERENCE_HOME = TMP;
   await rm(TMP, { recursive: true, force: true });
   await mkdir(TMP, { recursive: true });
   await writeFile(path.join(TMP, "a.txt"), "original a\n");
@@ -35,6 +42,8 @@ beforeAll(async () => {
 
 afterAll(async () => {
   await rm(TMP, { recursive: true, force: true });
+  if (PREV_HOME === undefined) delete process.env.INTERFERENCE_HOME;
+  else process.env.INTERFERENCE_HOME = PREV_HOME;
 });
 
 describe("session store", () => {

package/src/session/store.ts

@@ -3,9 +3,11 @@ import * as path from "node:path";
 import { createHash } from "node:crypto";
 import type { ModelMessage } from "ai";
 import type { Todo } from "../tools/todowrite.ts";
+import { interferenceDir } from "../paths.ts";
 
 export interface SessionMeta {
   id: string;
+  title?: string; // nome leggibile (auto dal primo messaggio o via /rename)
   workspace: string;
   startedAt: string;
   updatedAt: string;
@@ -26,11 +28,8 @@ function projectDir(): string {
     .update(process.cwd())
     .digest("hex")
     .slice(0, 12);
-  return path.join(
-    process.env.HOME ?? process.env.USERPROFILE ?? "/tmp",
-    ".interference",
-    hash,
-  );
+  // Home reindirizzabile via INTERFERENCE_HOME (isolamento test) — vedi paths.ts.
+  return interferenceDir(hash);
 }
 
 function sessionsDir(): string {

package/src/skills.ts

@@ -1,11 +1,11 @@
 import { readFile, readdir, mkdir, writeFile } from "node:fs/promises";
 import * as path from "node:path";
+import { interferenceDir } from "./paths.ts";
 
-export const SKILLS_DIR = path.join(
-  process.env.HOME ?? process.env.USERPROFILE ?? "/tmp",
-  ".interference",
-  "skills",
-);
+/** Directory delle skill (`~/.interference/skills`, reindirizzabile in test). */
+export function skillsDir(): string {
+  return interferenceDir("skills");
+}
 
 const BUNDLED_SKILLS: Record<string, string> = {
   "agents-setup": `---
@@ -90,10 +90,10 @@ export async function loadSkillRegistry(): Promise<SkillInfo[]> {
   if (registryCache) return registryCache;
   const list: SkillInfo[] = [];
   try {
-    const entries = await readdir(SKILLS_DIR, { withFileTypes: true });
+    const entries = await readdir(skillsDir(), { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillFile = path.join(SKILLS_DIR, entry.name, "SKILL.md");
+      const skillFile = path.join(skillsDir(), entry.name, "SKILL.md");
       try {
         const content = await readFile(skillFile, "utf-8");
         const info = parseSkillFrontmatter(content);
@@ -119,7 +119,7 @@ function parseSkillFrontmatter(content: string): SkillInfo | null {
 }
 
 export async function loadSkillBody(name: string): Promise<string | null> {
-  const skillFile = path.join(SKILLS_DIR, name, "SKILL.md");
+  const skillFile = path.join(skillsDir(), name, "SKILL.md");
   try {
     return await readFile(skillFile, "utf-8");
   } catch {
@@ -165,7 +165,7 @@ const STOPWORDS = new Set([
 
 export async function bootstrapSkills(): Promise<void> {
   for (const [name, content] of Object.entries(BUNDLED_SKILLS)) {
-    const dir = path.join(SKILLS_DIR, name);
+    const dir = path.join(skillsDir(), name);
     try { await mkdir(dir, { recursive: true }); } catch {}
     const fp = path.join(dir, "SKILL.md");
     try {

package/src/tools/__tests__/mutating.test.ts

@@ -311,7 +311,7 @@ describe("bash tool", () => {
   test("timeout kills process", async () => {
     setRules([{ tool: "bash", decision: "allow" }]);
     const out = await call<string>(bash, { command: "sleep 5", timeout: 500 });
-    expect(out).toContain("exit code");
+    expect(out).toContain("timed out");
   });
 
   test("ask with confirmation", async () => {

package/src/tools/bash.ts

@@ -39,16 +39,35 @@ export const bash = tool({
       cwd: process.cwd(),
       stdout: "pipe",
       stderr: "pipe",
-      timeout: ms,
-      killSignal: "SIGTERM",
     });
 
-    const [stdout, stderr] = await Promise.all([
-      readStream(proc.stdout, OUTPUT_CAP),
-      readStream(proc.stderr, OUTPUT_CAP),
+    // Esecuzione (lettura stream + exit) in gara col timeout. Allo scadere
+    // uccidiamo il processo e ritorniamo SUBITO senza aspettare l'EOF: un figlio
+    // orfano (es. `sleep`) può tenere la pipe aperta dopo la morte della shell e
+    // bloccherebbe la lettura. (L'opzione `timeout` di Bun.spawn non è affidabile
+    // su tutti i runner.)
+    const finished = (async () => {
+      const [stdout, stderr] = await Promise.all([
+        readStream(proc.stdout, OUTPUT_CAP),
+        readStream(proc.stderr, OUTPUT_CAP),
+      ]);
+      const exitCode = await proc.exited;
+      return { stdout, stderr, exitCode };
+    })().catch(() => ({ stdout: "", stderr: "", exitCode: 1 }));
+
+    const result = await Promise.race([
+      finished,
+      new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), ms)),
     ]);
 
-    const exitCode = await proc.exited;
+    if (result === "timeout") {
+      try {
+        proc.kill(9);
+      } catch {}
+      return `Command timed out after ${ms}ms and was killed.`;
+    }
+
+    const { stdout, stderr, exitCode } = result;
 
     let output = "";
     if (stdout.length > 0) output += stdout;

package/src/tools/grep.ts

@@ -58,29 +58,35 @@ async function tryRg(
   args.push("--", pattern);
   args.push(cwd);
 
-  const proc = Bun.spawn(["rg", ...args], {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  const out = await proc.stdout.text();
-  const err = await proc.stderr.text();
-  await proc.exited;
-
-  if (proc.exitCode === 0) {
-    const cwdName = path.relative(process.cwd(), cwd) || ".";
-    return formatMatches(out, pattern, cwdName);
-  }
+  // ripgrep può non essere installato: `Bun.spawn(["rg"])` lancia ENOENT prima
+  // ancora di poter leggere stderr → wrappiamo tutto e torniamo null (→ fallback JS).
+  try {
+    const proc = Bun.spawn(["rg", ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const out = await proc.stdout.text();
+    const err = await proc.stderr.text();
+    await proc.exited;
+
+    if (proc.exitCode === 0) {
+      const cwdName = path.relative(process.cwd(), cwd) || ".";
+      return formatMatches(out, pattern, cwdName);
+    }
 
-  if (proc.exitCode === 1) {
-    const cwdName = path.relative(process.cwd(), cwd) || ".";
-    return `No matches for '${pattern}' in ${cwdName}`;
-  }
+    if (proc.exitCode === 1) {
+      const cwdName = path.relative(process.cwd(), cwd) || ".";
+      return `No matches for '${pattern}' in ${cwdName}`;
+    }
 
-  if (err.includes("command not found") || err.includes("No such file")) {
-    return null; // rg not available, fallback to JS
-  }
+    if (err.includes("command not found") || err.includes("No such file")) {
+      return null; // rg non disponibile → fallback JS
+    }
 
-  return `grep error (exit ${proc.exitCode}): ${err || "unknown error"}`;
+    return `grep error (exit ${proc.exitCode}): ${err || "unknown error"}`;
+  } catch {
+    return null; // rg non installato (ENOENT) → fallback JS
+  }
 }
 
 async function jsGrep(
@@ -95,7 +101,7 @@ async function jsGrep(
   try {
     regex = new RegExp(pattern, flags);
   } catch {
-    return `Invalid regex pattern: ${pattern}`;
+    return `grep error: invalid regex pattern '${pattern}'`;
   }
 
   const matches: string[] = [];