@takara-ai/miru-code 1.8.2 → 1.10.0

package/src/installer/benchmark-mode.ts

@@ -1,4 +1,9 @@
-import { AGENT_TARGETS, type AgentTarget, type InstallAction } from "./agents.ts";
+import {
+  AGENT_TARGETS,
+  type AgentTarget,
+  type InstallAction,
+  MIRU_BUNX_PACKAGE,
+} from "./agents.ts";
 import { removeTomlBlock, stripJsonComments } from "./config.ts";
 
 export const MCP_BENCHMARK_FLAG = "--benchmark";
@@ -7,9 +12,25 @@ const CODEX_MCP_HEADER = "[mcp_servers.miru]";
 
 function codexMcpBlock(enabled: boolean): string {
   const args = enabled
-    ? `["@takara-ai/miru-code", "${MCP_BENCHMARK_FLAG}"]`
-    : '["@takara-ai/miru-code"]';
-  return `${CODEX_MCP_HEADER}\ncommand = "bunx"\nargs = ${args}\n`;
+    ? `["${MIRU_BUNX_PACKAGE}", "mcp", "${MCP_BENCHMARK_FLAG}"]`
+    : `["${MIRU_BUNX_PACKAGE}", "mcp"]`;
+  return `${CODEX_MCP_HEADER}\ncommand = "bunx"\nargs = ${args}\nstartup_timeout_sec = 60\n`;
+}
+
+function withMcpSubcommand(list: string[], command: unknown): string[] {
+  if (list.includes("mcp")) return list;
+  if (command === "miru") return ["mcp", ...list];
+
+  const packageIndex = list.findIndex((item) => /^@takara-ai\/miru-code(?:@.+)?$/.test(item));
+  if (packageIndex >= 0) {
+    return [...list.slice(0, packageIndex + 1), "mcp", ...list.slice(packageIndex + 1)];
+  }
+
+  const miruIndex = list.indexOf("miru");
+  if (miruIndex >= 0) {
+    return [...list.slice(0, miruIndex + 1), "mcp", ...list.slice(miruIndex + 1)];
+  }
+  return list;
 }
 
 export function withBenchmarkFlag(list: string[], enabled: boolean): string[] {
@@ -31,7 +52,7 @@ export function applyBenchmarkFlagToMcpEntry(
 
   if (Array.isArray(next.args)) {
     const args = next.args.filter((item): item is string => typeof item === "string");
-    const updated = withBenchmarkFlag(args, enabled);
+    const updated = withBenchmarkFlag(withMcpSubcommand(args, next.command), enabled);
     if (JSON.stringify(updated) !== JSON.stringify(args)) {
       next.args = updated;
       changed = true;
@@ -40,7 +61,7 @@ export function applyBenchmarkFlagToMcpEntry(
 
   if (Array.isArray(next.command)) {
     const command = next.command.filter((item): item is string => typeof item === "string");
-    const updated = withBenchmarkFlag(command, enabled);
+    const updated = withBenchmarkFlag(withMcpSubcommand(command, next.command), enabled);
     if (JSON.stringify(updated) !== JSON.stringify(command)) {
       next.command = updated;
       changed = true;
@@ -122,7 +143,10 @@ async function setTomlBenchmark(
     return "missing";
   }
   const current = await statusForToml(path);
-  if (current === enabled) {
+  const section =
+    text.slice(text.indexOf(CODEX_MCP_HEADER) + CODEX_MCP_HEADER.length).split(/^\[/m)[0] ?? "";
+  const hasMcpArg = /^args\s*=\s*\[[^\n]*["']mcp["']/m.test(section);
+  if (current === enabled && hasMcpArg) {
     return "unchanged";
   }
 
@@ -190,9 +214,11 @@ async function setJsonBenchmark(
 }
 
 /** Inspect installed Miru MCP configs for `--benchmark`. */
-export async function getBenchmarkModeStatus(): Promise<BenchmarkModeTargetResult[]> {
+export async function getBenchmarkModeStatus(
+  targets: readonly AgentTarget[] = AGENT_TARGETS,
+): Promise<BenchmarkModeTargetResult[]> {
   const results: BenchmarkModeTargetResult[] = [];
-  for (const agent of AGENT_TARGETS) {
+  for (const agent of targets) {
     const mcp = agent.mcp;
     if (!mcp) {
       continue;
@@ -219,9 +245,12 @@ export async function getBenchmarkModeStatus(): Promise<BenchmarkModeTargetResul
 }
 
 /** Enable or disable `--benchmark` on every installed Miru MCP entry. */
-export async function setBenchmarkMode(enabled: boolean): Promise<BenchmarkModeTargetResult[]> {
+export async function setBenchmarkMode(
+  enabled: boolean,
+  targets: readonly AgentTarget[] = AGENT_TARGETS,
+): Promise<BenchmarkModeTargetResult[]> {
   const results: BenchmarkModeTargetResult[] = [];
-  for (const agent of AGENT_TARGETS) {
+  for (const agent of targets) {
     const mcp = agent.mcp;
     if (!mcp) {
       continue;

package/src/installer/config.ts

@@ -1,15 +1,17 @@
 import { unlink } from "node:fs/promises";
-import { type InstallAction, MIRU_END, MIRU_START } from "./agents.ts";
+import { type InstallAction, MIRU_BUNX_PACKAGE, MIRU_END, MIRU_START } from "./agents.ts";
 
 const CODEX_MCP_HEADER = "[mcp_servers.miru]";
 const CODEX_MCP_BLOCK = `[mcp_servers.miru]
 command = "bunx"
-args = ["@takara-ai/miru-code"]
+args = ["${MIRU_BUNX_PACKAGE}", "mcp"]
+startup_timeout_sec = 60
 `;
 /** Same Codex block with `--benchmark` preserved across reinstall. */
 const CODEX_MCP_BLOCK_BENCHMARK = `[mcp_servers.miru]
 command = "bunx"
-args = ["@takara-ai/miru-code", "--benchmark"]
+args = ["${MIRU_BUNX_PACKAGE}", "mcp", "--benchmark"]
+startup_timeout_sec = 60
 `;
 
 /** Strip line and block comments so JSONC configs can be parsed. */
@@ -81,14 +83,16 @@ function sectionObject(
   root: Record<string, unknown>,
   sectionKey: string,
 ): Record<string, unknown> | "error" {
-  const section = root[sectionKey];
-  if (section === undefined) {
-    return {};
-  }
-  if (!section || typeof section !== "object" || Array.isArray(section)) {
-    return "error";
-  }
-  return section as Record<string, unknown>;
+  let section: unknown = root;
+  for (const key of sectionKey.split(".")) {
+    if (!section || typeof section !== "object" || Array.isArray(section)) return "error";
+    const child = (section as Record<string, unknown>)[key];
+    if (child === undefined) return {};
+    section = child;
+  }
+  return section && typeof section === "object" && !Array.isArray(section)
+    ? (section as Record<string, unknown>)
+    : "error";
 }
 
 export async function mergeJsonMember(
@@ -143,11 +147,12 @@ export async function removeJsonMember(
   }
   const nextText = removeJsonMemberText(text, sectionKey, memberKey);
   const nextObject = withRemovedMember(parsed, sectionKey, memberKey);
-  const next = nextText ?? JSON.stringify(nextObject, null, 2);
-  if (ensureTrailingNewline(next) === ensureTrailingNewline(text)) {
-    return "not-found";
+  let next = nextText ?? JSON.stringify(nextObject, null, 2);
+  let nextParsed = parseJsonObject(next);
+  if (nextParsed === "error") {
+    next = JSON.stringify(nextObject, null, 2);
+    nextParsed = parseJsonObject(next);
   }
-  const nextParsed = parseJsonObject(next);
   if (!nextParsed || typeof nextParsed !== "object" || Object.keys(nextParsed).length === 0) {
     await unlink(path);
     return "removed";
@@ -162,14 +167,24 @@ function withMergedMember(
   memberKey: string,
   value: Record<string, unknown>,
 ): Record<string, unknown> {
-  const next = { ...root };
-  const section =
-    next[sectionKey] && typeof next[sectionKey] === "object" && !Array.isArray(next[sectionKey])
-      ? { ...(next[sectionKey] as Record<string, unknown>) }
-      : {};
-  section[memberKey] = value;
-  next[sectionKey] = section;
-  return next;
+  const keys = sectionKey.split(".");
+  const update = (object: Record<string, unknown>, depth: number): Record<string, unknown> => {
+    const next = { ...object };
+    if (depth === keys.length) {
+      next[memberKey] = value;
+      return next;
+    }
+    const key = keys[depth];
+    if (!key) return next;
+    const child = next[key];
+    const section =
+      child && typeof child === "object" && !Array.isArray(child)
+        ? (child as Record<string, unknown>)
+        : {};
+    next[key] = update(section, depth + 1);
+    return next;
+  };
+  return update(root, 0);
 }
 
 function withRemovedMember(
@@ -177,21 +192,29 @@ function withRemovedMember(
   sectionKey: string,
   memberKey: string,
 ): Record<string, unknown> {
-  const next = { ...root };
-  const section =
-    next[sectionKey] && typeof next[sectionKey] === "object" && !Array.isArray(next[sectionKey])
-      ? { ...(next[sectionKey] as Record<string, unknown>) }
-      : null;
-  if (!section || !(memberKey in section)) {
-    return next;
-  }
-  delete section[memberKey];
-  if (Object.keys(section).length === 0) {
-    delete next[sectionKey];
-  } else {
-    next[sectionKey] = section;
-  }
-  return next;
+  const keys = sectionKey.split(".");
+  const remove = (
+    object: Record<string, unknown>,
+    depth: number,
+  ): { value: Record<string, unknown>; changed: boolean } => {
+    const next = { ...object };
+    if (depth === keys.length) {
+      if (!(memberKey in next)) return { value: next, changed: false };
+      delete next[memberKey];
+      return { value: next, changed: true };
+    }
+    const key = keys[depth];
+    const child = key ? next[key] : undefined;
+    if (!key || !child || typeof child !== "object" || Array.isArray(child)) {
+      return { value: next, changed: false };
+    }
+    const result = remove(child as Record<string, unknown>, depth + 1);
+    if (!result.changed) return { value: next, changed: false };
+    if (Object.keys(result.value).length === 0) delete next[key];
+    else next[key] = result.value;
+    return { value: next, changed: true };
+  };
+  return remove(root, 0).value;
 }
 
 function upsertJsonMemberText(
@@ -292,13 +315,38 @@ function hasJsoncSyntax(text: string): boolean {
   return false;
 }
 
-/**
- * Locate a section object at the document root only.
- * Nested keys with the same name (e.g. Claude Code projects.*.mcpServers) are ignored.
- */
+/** Locate an object section by dotted path, matching each key among direct children. */
 function findSectionRange(
   text: string,
   sectionKey: string,
+): { openBrace: number; closeBrace: number; indent: string } | null {
+  const keys = sectionKey.split(".");
+  let container = text;
+  let offset = 0;
+  let result: { openBrace: number; closeBrace: number; indent: string } | null = null;
+  for (let index = 0; index < keys.length; index++) {
+    const key = keys[index];
+    if (!key) return null;
+    result = findDirectSectionRange(container, key);
+    if (!result) return null;
+    if (index < keys.length - 1) {
+      offset += result.openBrace;
+      container = container.slice(result.openBrace, result.closeBrace + 1);
+    }
+  }
+  return result
+    ? {
+        ...result,
+        openBrace: offset + result.openBrace,
+        closeBrace: offset + result.closeBrace,
+      }
+    : null;
+}
+
+/** Locate a single child object in a root object, ignoring similarly named nested keys. */
+function findDirectSectionRange(
+  text: string,
+  sectionKey: string,
 ): { openBrace: number; closeBrace: number; indent: string } | null {
   const keyPrefix = new RegExp(`^"${escapeRegExp(sectionKey)}"\\s*:\\s*\\{`);
   let depth = 0;
@@ -501,6 +549,21 @@ function ensureTrailingNewline(text: string): string {
   return text.endsWith("\n") ? text : `${text}\n`;
 }
 
+/** Internal parser helpers exposed for focused edge-case tests. */
+export const jsoncTestUtils = {
+  hasJsoncSyntax,
+  findSectionRange,
+  findMatchingBrace,
+  parseJsonValueEnd,
+  findMatchingBracket,
+  findStringEnd,
+  skipWhitespace,
+  findLeadingComma,
+  withRemovedMember,
+  upsertJsonMemberText,
+  removeJsonMemberText,
+};
+
 export async function replaceOrAppendMarked(path: string, content: string): Promise<InstallAction> {
   const existed = await Bun.file(path).exists();
   const existing = existed ? await Bun.file(path).text() : "";

package/src/installer/installer.ts

@@ -30,7 +30,7 @@ import {
   replaceOrAppendMarked,
   stripJsonComments,
 } from "./config.ts";
-import { mergeHooks, removeHooks } from "./hooks/install.ts";
+import { removeLegacySearchHooks } from "./legacy-hooks.ts";
 import { promptConfirm, promptMultiSelect, requireInteractiveTerminal } from "./prompt.ts";
 import { CURSOR_RULES_MDC } from "./search-policy.ts";
 import {
@@ -56,7 +56,7 @@ export type IntegrationId =
   | "mcp"
   | "instructions"
   | "subagent"
-  | "hooks"
+  | "legacy-hooks"
   | "rules"
   | "caveman"
   | "ste";
@@ -72,6 +72,21 @@ export interface ApplyCtx {
   isDetected?: (agent: AgentTarget) => Promise<boolean>;
 }
 
+type InstallerMultiSelect = <T>(
+  title: string,
+  items: Array<{ label: string; value: T; checked: boolean }>,
+) => Promise<T[] | null>;
+
+export interface RunInstallerDependencies {
+  requireInteractiveTerminal?: (command: string) => void;
+  ensureCredentials?: typeof ensureCredentials;
+  agents?: AgentTarget[];
+  isAgentDetected?: (agent: AgentTarget) => Promise<boolean>;
+  promptMultiSelect?: InstallerMultiSelect;
+  promptConfirm?: typeof promptConfirm;
+  removeUninstallLocalData?: typeof removeUninstallLocalData;
+}
+
 interface Integration {
   id: IntegrationId;
   label: string;
@@ -110,10 +125,12 @@ async function readExistingJsonMcpEntry(
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
     }
-    const section = (parsed as Record<string, unknown>)[sectionKey];
-    if (!section || typeof section !== "object" || Array.isArray(section)) {
-      return null;
+    let section: unknown = parsed;
+    for (const key of sectionKey.split(".")) {
+      if (!section || typeof section !== "object" || Array.isArray(section)) return null;
+      section = (section as Record<string, unknown>)[key];
     }
+    if (!section || typeof section !== "object" || Array.isArray(section)) return null;
     const entry = (section as Record<string, unknown>)[memberKey];
     if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
       return null;
@@ -161,18 +178,13 @@ async function applyInstructions(
   return { path, action };
 }
 
-async function applyHooks(agent: AgentTarget, mode: InstallMode): Promise<WriteResult | null> {
-  const path = agent.hooksPath;
-  const format = agent.hooksFormat;
+async function removeLegacyHooks(agent: AgentTarget): Promise<WriteResult | null> {
+  const path = agent.legacyHooksPath;
+  const format = agent.legacyHooksFormat;
   if (!path || !format) {
     return null;
   }
-
-  const action =
-    mode === "install"
-      ? await mergeHooks(format, path, agent.id)
-      : await removeHooks(format, path, agent.id);
-
+  const action = await removeLegacySearchHooks(format, path, agent.id);
   return { path, action };
 }
 
@@ -311,9 +323,6 @@ async function applyCaveman(
 
 async function stePackMatches(skillDir: string): Promise<boolean> {
   const skillPath = join(skillDir, "SKILL.md");
-  if (!(await Bun.file(skillPath).exists())) {
-    return false;
-  }
   if ((await Bun.file(skillPath).text()) !== STE_SKILL_MD) {
     return false;
   }
@@ -449,13 +458,12 @@ const INTEGRATIONS: Integration[] = [
     apply: applyCursorRules,
   },
   {
-    id: "hooks",
-    label: "Search hooks",
-    description: "blocks built-in search; routes to Miru MCP",
-    experimental: true,
-    defaultChecked: false,
-    planPath: (agent) => agent.hooksPath,
-    apply: applyHooks,
+    id: "legacy-hooks",
+    label: "Remove old Miru hooks",
+    description: "clean up stale search hooks from older releases",
+    defaultChecked: true,
+    planPath: (agent) => agent.legacyHooksPath,
+    apply: removeLegacyHooks,
   },
   {
     id: "caveman",
@@ -593,12 +601,25 @@ export async function removeUninstallLocalData(): Promise<{
   };
 }
 
-export async function runInstaller(mode: InstallMode): Promise<void> {
+export async function runInstaller(
+  mode: InstallMode,
+  dependencies: RunInstallerDependencies = {},
+): Promise<void> {
+  const deps = {
+    requireInteractiveTerminal,
+    ensureCredentials,
+    agents: AGENT_TARGETS,
+    isAgentDetected,
+    promptMultiSelect,
+    promptConfirm,
+    removeUninstallLocalData,
+    ...dependencies,
+  };
   const install = mode === "install";
-  requireInteractiveTerminal(`miru ${mode}`);
+  deps.requireInteractiveTerminal(`miru ${mode}`);
 
   if (install) {
-    await ensureCredentials({ interactive: true });
+    await deps.ensureCredentials({ interactive: true });
   }
 
   writeStdout("");
@@ -607,9 +628,9 @@ export async function runInstaller(mode: InstallMode): Promise<void> {
   hint("↑↓ move  space select  enter confirm");
 
   const detected = await Promise.all(
-    AGENT_TARGETS.map(async (agent) => ({
+    deps.agents.map(async (agent) => ({
       agent,
-      detected: await isAgentDetected(agent),
+      detected: await deps.isAgentDetected(agent),
     })),
   );
 
@@ -619,7 +640,7 @@ export async function runInstaller(mode: InstallMode): Promise<void> {
     checked: isDetected && install,
   }));
 
-  const chosenAgents = await promptMultiSelect(
+  const chosenAgents = await deps.promptMultiSelect(
     `Agents to ${install ? "configure" : "clean up"}`,
     agentItems,
   );
@@ -641,7 +662,7 @@ export async function runInstaller(mode: InstallMode): Promise<void> {
     checked: install ? (integration.defaultChecked ?? true) : true,
   }));
 
-  const chosenIntegrations = await promptMultiSelect(
+  const chosenIntegrations = await deps.promptMultiSelect(
     `Integrations to ${install ? "enable" : "remove"}`,
     integrationItems,
   );
@@ -653,7 +674,10 @@ export async function runInstaller(mode: InstallMode): Promise<void> {
 
   await printPlan(mode, chosenAgents, chosenIntegrations);
 
-  const proceed = await promptConfirm(install ? "Proceed?" : "Remove miru configuration?", install);
+  const proceed = await deps.promptConfirm(
+    install ? "Proceed?" : "Remove miru configuration?",
+    install,
+  );
   if (!proceed) {
     hint("Cancelled.");
     return;
@@ -662,7 +686,7 @@ export async function runInstaller(mode: InstallMode): Promise<void> {
   await apply(mode, chosenAgents, chosenIntegrations);
 
   if (!install) {
-    const local = await removeUninstallLocalData();
+    const local = await deps.removeUninstallLocalData();
     if (local.benchmarkHistoryCleared) {
       info(`Removed benchmark report ${local.benchmarkHistoryPath}`);
     }
@@ -674,7 +698,6 @@ export async function runInstaller(mode: InstallMode): Promise<void> {
 
 export {
   applyCaveman,
-  applyHooks,
   applyInstructions,
   applyMcp,
   applySte,
@@ -684,3 +707,5 @@ export {
   mergeJsonMember as mergeMcpJson,
   removeJsonMember as removeMcpJson,
 };
+
+export const installerTestUtils = { applyCursorRules, printPlan };

package/src/installer/legacy-hooks.ts

@@ -0,0 +1,131 @@
+import { unlink } from "node:fs/promises";
+import type { InstallAction, LegacyHooksFormat } from "./agents.ts";
+import { stripJsonComments } from "./config.ts";
+import { isCopilotFamilyId } from "./copilot-family.ts";
+
+const LEGACY_MARKERS = ["hook-guard", "miru-search"];
+const VSCODE_OWNERS_KEY = "miruOwners";
+
+function isLegacyCommand(value: unknown): boolean {
+  return typeof value === "string" && LEGACY_MARKERS.some((marker) => value.includes(marker));
+}
+
+function parseObject(text: string): Record<string, unknown> | null {
+  try {
+    const value: unknown = JSON.parse(stripJsonComments(text));
+    return value && typeof value === "object" && !Array.isArray(value)
+      ? (value as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function object(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function hasOnlyMiruConfig(data: Record<string, unknown>): boolean {
+  const keys = Object.keys(data);
+  if (keys.length === 0 || keys.every((key) => key === "version")) return true;
+  const hooks = object(data.hooks);
+  return (
+    !!hooks &&
+    Object.keys(data).every((key) => key === "version" || key === "hooks") &&
+    Object.keys(hooks).length === 0
+  );
+}
+
+async function writeResult(path: string, data: Record<string, unknown>): Promise<void> {
+  if (hasOnlyMiruConfig(data)) {
+    await unlink(path);
+  } else {
+    await Bun.write(path, `${JSON.stringify(data, null, 2)}\n`);
+  }
+}
+
+function isMiruEntry(format: LegacyHooksFormat, entry: Record<string, unknown>): boolean {
+  if (format === "claude") {
+    const nested = Array.isArray(entry.hooks) ? entry.hooks : [];
+    return nested.some((hook) => isLegacyCommand(object(hook)?.command));
+  }
+  return isLegacyCommand(entry.command);
+}
+
+/** Remove search hooks installed by older Miru releases; Miru no longer installs hooks. */
+export async function removeLegacySearchHooks(
+  format: LegacyHooksFormat,
+  path: string,
+  owner?: string,
+): Promise<InstallAction> {
+  if (!(await Bun.file(path).exists())) return "not-found";
+
+  if (format === "opencode") {
+    await unlink(path);
+    return "removed";
+  }
+
+  const text = await Bun.file(path).text();
+  const data = parseObject(text);
+  if (!data) return "error";
+
+  const hooks = object(data.hooks);
+
+  let ownerChanged = false;
+  if (format === "vscode") {
+    const owners = Array.isArray(data[VSCODE_OWNERS_KEY])
+      ? (data[VSCODE_OWNERS_KEY] as unknown[]).filter(
+          (value): value is string => typeof value === "string" && isCopilotFamilyId(value),
+        )
+      : null;
+    if (owners && owner) {
+      const remaining = owners.filter((value) => value !== owner);
+      if (remaining.length > 0) {
+        data[VSCODE_OWNERS_KEY] = remaining;
+        await Bun.write(path, `${JSON.stringify(data, null, 2)}\n`);
+        return "updated";
+      }
+      delete data[VSCODE_OWNERS_KEY];
+      ownerChanged = true;
+    }
+  }
+
+  if (!hooks) {
+    if (!ownerChanged) return "not-found";
+    await writeResult(path, data);
+    return "removed";
+  }
+
+  const eventKey = {
+    claude: "PreToolUse",
+    cursor: "preToolUse",
+    gemini: "BeforeTool",
+    vscode: "PreToolUse",
+    kiro: "preToolUse",
+    windsurf: "pre_run_command",
+    opencode: "",
+  }[format];
+  const entries = Array.isArray(hooks[eventKey]) ? (hooks[eventKey] as unknown[]) : null;
+  if (!entries) {
+    if (!ownerChanged) return "not-found";
+    await writeResult(path, data);
+    return "removed";
+  }
+
+  const retained = entries.filter((entry) => {
+    const record = object(entry);
+    return !record || !isMiruEntry(format, record);
+  });
+  if (retained.length === entries.length) {
+    if (!ownerChanged) return "not-found";
+    await writeResult(path, data);
+    return "removed";
+  }
+  if (retained.length === 0) delete hooks[eventKey];
+  else hooks[eventKey] = retained;
+  if (Object.keys(hooks).length === 0) delete data.hooks;
+  await writeResult(path, data);
+  return "removed";
+}