@takara-ai/miru-code 0.3.0 → 0.4.1

package/src/installer/config.ts

@@ -0,0 +1,273 @@
+import { mkdir, unlink, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { type InstallAction, 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"]
+env = { TAKARA_API_KEY = "\${TAKARA_API_KEY}" }
+`;
+
+/** Strip line and block comments so JSONC configs can be parsed. */
+export function stripJsonComments(text: string): string {
+  let out = "";
+  let i = 0;
+  let inString = false;
+  let stringQuote = '"';
+  while (i < text.length) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (inString) {
+      out += ch;
+      if (ch === "\\" && next !== undefined) {
+        out += next;
+        i += 2;
+        continue;
+      }
+      if (ch === stringQuote) {
+        inString = false;
+      }
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = true;
+      stringQuote = ch;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      while (i < text.length && text[i] !== "\n") {
+        i++;
+      }
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) {
+        i++;
+      }
+      i += 2;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+
+function parseJsonObject(text: string): Record<string, unknown> | "error" {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return {};
+  }
+  try {
+    const parsed: unknown = JSON.parse(stripJsonComments(trimmed));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return "error";
+    }
+    return parsed as Record<string, unknown>;
+  } catch {
+    return "error";
+  }
+}
+
+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>;
+}
+
+export async function mergeJsonMember(
+  path: string,
+  sectionKey: string,
+  memberKey: string,
+  value: Record<string, unknown>,
+): Promise<InstallAction> {
+  const existed = await Bun.file(path).exists();
+  const text = existed ? await Bun.file(path).text() : "";
+  const parsed = parseJsonObject(text);
+  if (parsed === "error") {
+    return "error";
+  }
+
+  const section = sectionObject(parsed, sectionKey);
+  if (section === "error") {
+    return "error";
+  }
+
+  if (JSON.stringify(section[memberKey]) === JSON.stringify(value)) {
+    return "unchanged";
+  }
+
+  section[memberKey] = value;
+  parsed[sectionKey] = section;
+
+  const next = `${JSON.stringify(parsed, null, 2)}\n`;
+
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, next, "utf-8");
+  return existed ? "updated" : "created";
+}
+
+export async function removeJsonMember(
+  path: string,
+  sectionKey: string,
+  memberKey: string,
+): Promise<InstallAction> {
+  if (!(await Bun.file(path).exists())) {
+    return "not-found";
+  }
+
+  const text = await Bun.file(path).text();
+  const parsed = parseJsonObject(text);
+  if (parsed === "error") {
+    return "error";
+  }
+
+  const section = sectionObject(parsed, sectionKey);
+  if (section === "error" || !(memberKey in section)) {
+    return "not-found";
+  }
+
+  delete section[memberKey];
+  if (Object.keys(section).length === 0) {
+    delete parsed[sectionKey];
+  } else {
+    parsed[sectionKey] = section;
+  }
+
+  const next = `${JSON.stringify(parsed, null, 2)}\n`;
+  if (next === `${text.endsWith("\n") ? text : `${text}\n`}`) {
+    return "not-found";
+  }
+
+  if (Object.keys(parsed).length === 0) {
+    await unlink(path);
+    return "removed";
+  }
+
+  await writeFile(path, next, "utf-8");
+  return "removed";
+}
+
+export async function replaceOrAppendMarked(path: string, content: string): Promise<InstallAction> {
+  await mkdir(dirname(path), { recursive: true });
+  const existed = await Bun.file(path).exists();
+  const existing = existed ? await Bun.file(path).text() : "";
+
+  const startIdx = existing.indexOf(MIRU_START);
+  const endIdx = existing.indexOf(MIRU_END);
+
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const before = existing.slice(0, startIdx);
+    const after = existing.slice(endIdx + MIRU_END.length);
+    const updated = `${before}${content.trim()}\n${after.replace(/^\n+/, "")}`;
+    if (updated === existing) {
+      return "unchanged";
+    }
+    await writeFile(path, updated, "utf-8");
+    return "updated";
+  }
+
+  const separator =
+    existing && !existing.endsWith("\n\n") ? (existing.endsWith("\n") ? "\n" : "\n\n") : "";
+  await writeFile(path, `${existing}${separator}${content}`, "utf-8");
+  return existed ? "updated" : "created";
+}
+
+export async function removeMarked(path: string): Promise<InstallAction> {
+  if (!(await Bun.file(path).exists())) {
+    return "not-found";
+  }
+
+  const existing = await Bun.file(path).text();
+  const startIdx = existing.indexOf(MIRU_START);
+  const endIdx = existing.indexOf(MIRU_END);
+
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
+    return "not-found";
+  }
+
+  const before = existing.slice(0, startIdx).replace(/\n+$/, "");
+  const after = existing.slice(endIdx + MIRU_END.length).replace(/^\n+/, "");
+  const updated = [before, after].filter((part) => part.length > 0).join("\n");
+  const withNewline = updated.length > 0 ? `${updated}\n` : "";
+
+  if (withNewline.trim().length === 0) {
+    await unlink(path);
+    return "removed";
+  }
+
+  await writeFile(path, withNewline, "utf-8");
+  return "removed";
+}
+
+function stripTomlSection(text: string, header: string): string {
+  const prefix = header.trim().slice(1, -1);
+  const lines = text.split("\n");
+  const result: string[] = [];
+  let skipping = false;
+
+  for (const line of lines) {
+    const tableKey = line.split("#")[0]?.trim() ?? "";
+    if (tableKey.startsWith("[") && tableKey.endsWith("]")) {
+      const tableName = tableKey.slice(1, -1);
+      if (tableName === prefix || tableName.startsWith(`${prefix}.`)) {
+        skipping = true;
+        continue;
+      }
+      skipping = false;
+    }
+    if (!skipping) {
+      result.push(line);
+    }
+  }
+
+  return result.join("\n");
+}
+
+export async function mergeTomlBlock(path: string): Promise<InstallAction> {
+  await mkdir(dirname(path), { recursive: true });
+  const existed = await Bun.file(path).exists();
+  const existing = existed ? await Bun.file(path).text() : "";
+
+  if (existing.includes(CODEX_MCP_BLOCK.trim())) {
+    return "unchanged";
+  }
+
+  const base = stripTomlSection(existing, CODEX_MCP_HEADER).replace(/\n+$/, "");
+  const next = base.length > 0 ? `${base}\n\n${CODEX_MCP_BLOCK}` : CODEX_MCP_BLOCK;
+  await writeFile(path, next.endsWith("\n") ? next : `${next}\n`, "utf-8");
+  return existed ? "updated" : "created";
+}
+
+export async function removeTomlBlock(path: string): Promise<InstallAction> {
+  if (!(await Bun.file(path).exists())) {
+    return "not-found";
+  }
+
+  const existing = await Bun.file(path).text();
+  if (!existing.includes(CODEX_MCP_HEADER)) {
+    return "not-found";
+  }
+
+  const remaining = stripTomlSection(existing, CODEX_MCP_HEADER).trim();
+  if (remaining.length === 0) {
+    await unlink(path);
+    return "removed";
+  }
+
+  await writeFile(path, `${remaining}\n`, "utf-8");
+  return "removed";
+}

package/src/installer/installer.ts

@@ -0,0 +1,256 @@
+import { mkdir, unlink, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { loadAgentTemplate } from "../agents.ts";
+import { brandTitle, dim, divider, green, hint, success, writeStdout } from "../cli-ui.ts";
+import {
+  AGENT_TARGETS,
+  type AgentTarget,
+  INSTRUCTIONS,
+  type InstallAction,
+  type InstallMode,
+  isAgentDetected,
+} from "./agents.ts";
+import {
+  mergeJsonMember,
+  mergeTomlBlock,
+  removeJsonMember,
+  removeMarked,
+  removeTomlBlock,
+  replaceOrAppendMarked,
+} from "./config.ts";
+import { promptConfirm, promptMultiSelect, requireInteractiveTerminal } from "./prompt.ts";
+
+export interface WriteResult {
+  path: string;
+  action: InstallAction;
+}
+
+export type IntegrationId = "mcp" | "instructions" | "subagent";
+
+interface Integration {
+  id: IntegrationId;
+  label: string;
+  description: string;
+  planPath: (agent: AgentTarget) => string | null;
+  apply: (agent: AgentTarget, mode: InstallMode) => Promise<WriteResult | null>;
+}
+
+const ACTION_DETAIL: Partial<Record<InstallAction, string>> = {
+  skipped: "config uses comments or invalid JSON — add manually (see README)",
+  error: "could not parse or edit config",
+};
+
+const ACTION_ICON: Partial<Record<InstallAction, string>> = {
+  created: green("✓"),
+  updated: green("✓"),
+  removed: green("✓"),
+  unchanged: dim("·"),
+  "not-found": dim("–"),
+  skipped: dim("!"),
+  error: dim("✗"),
+};
+
+async function applyMcp(agent: AgentTarget, mode: InstallMode): Promise<WriteResult | null> {
+  const mcp = agent.mcp;
+  if (!mcp) {
+    return null;
+  }
+
+  if (mcp.format === "toml") {
+    const action =
+      mode === "install" ? await mergeTomlBlock(mcp.path) : await removeTomlBlock(mcp.path);
+    return { path: mcp.path, action };
+  }
+
+  const action =
+    mode === "install"
+      ? await mergeJsonMember(mcp.path, mcp.key, mcp.memberKey, mcp.entry)
+      : await removeJsonMember(mcp.path, mcp.key, mcp.memberKey);
+  return { path: mcp.path, action };
+}
+
+async function applyInstructions(
+  agent: AgentTarget,
+  mode: InstallMode,
+): Promise<WriteResult | null> {
+  const path = agent.instructionsPath;
+  if (!path) {
+    return null;
+  }
+
+  const action =
+    mode === "install" ? await replaceOrAppendMarked(path, INSTRUCTIONS) : await removeMarked(path);
+  return { path, action };
+}
+
+async function applySubagent(agent: AgentTarget, mode: InstallMode): Promise<WriteResult | null> {
+  const dest = agent.subagentPath;
+  const templateId = agent.subagentId;
+  if (!dest || !templateId) {
+    return null;
+  }
+
+  if (mode === "uninstall") {
+    if (!(await Bun.file(dest).exists())) {
+      return { path: dest, action: "not-found" };
+    }
+    await unlink(dest);
+    return { path: dest, action: "removed" };
+  }
+
+  try {
+    const content = await loadAgentTemplate(templateId);
+    const existed = await Bun.file(dest).exists();
+    await mkdir(dirname(dest), { recursive: true });
+    await writeFile(dest, content, "utf-8");
+    return { path: dest, action: existed ? "updated" : "created" };
+  } catch {
+    return { path: dest, action: "error" };
+  }
+}
+
+const INTEGRATIONS: Integration[] = [
+  {
+    id: "mcp",
+    label: "MCP server",
+    description: "lets the agent call miru directly as a tool",
+    planPath: (agent) => agent.mcp?.path ?? null,
+    apply: applyMcp,
+  },
+  {
+    id: "instructions",
+    label: "Instructions",
+    description: "adds CLI usage guidance to CLAUDE.md / AGENTS.md",
+    planPath: (agent) => agent.instructionsPath,
+    apply: applyInstructions,
+  },
+  {
+    id: "subagent",
+    label: "Sub-agent",
+    description: "installs a dedicated miru-code sub-agent",
+    planPath: (agent) => agent.subagentPath,
+    apply: applySubagent,
+  },
+];
+
+function formatActionLine(integration: Integration, result: WriteResult): string {
+  const icon = ACTION_ICON[result.action] ?? dim("·");
+  const detail = ACTION_DETAIL[result.action];
+  const suffix = detail ? dim(` — ${detail}`) : "";
+  return `   ${icon} ${integration.label.padEnd(13)} ${dim(result.action)}${suffix}\n      ${dim(result.path)}`;
+}
+
+function printPlan(agents: AgentTarget[], integrations: Integration[]): void {
+  writeStdout("");
+  writeStdout(dim("Plan"));
+  divider();
+
+  for (const agent of agents) {
+    writeStdout(` ${agent.displayName}`);
+    for (const integration of integrations) {
+      const path = integration.planPath(agent);
+      const icon = path ? green("✓") : dim("–");
+      writeStdout(`   ${icon} ${integration.label.padEnd(13)} ${path ?? dim("(not supported)")}`);
+    }
+  }
+  writeStdout("");
+}
+
+async function apply(
+  mode: InstallMode,
+  agents: AgentTarget[],
+  integrations: Integration[],
+): Promise<void> {
+  writeStdout("");
+  writeStdout(dim(mode === "install" ? "Installing" : "Removing"));
+  divider();
+
+  for (const agent of agents) {
+    writeStdout(` ${agent.displayName}`);
+    for (const integration of integrations) {
+      const result = await integration.apply(agent, mode);
+      if (!result) {
+        writeStdout(`   ${dim("–")} ${integration.id.padEnd(13)} ${dim("not supported")}`);
+        continue;
+      }
+      writeStdout(formatActionLine(integration, result));
+    }
+  }
+  writeStdout("");
+}
+
+export async function runInstaller(mode: InstallMode): Promise<void> {
+  const install = mode === "install";
+  requireInteractiveTerminal(`miru ${mode}`);
+
+  writeStdout("");
+  writeStdout(`${brandTitle()}${install ? " installer" : " uninstaller"}`);
+  divider();
+  hint("Select agents and integrations to configure.");
+
+  const detected = await Promise.all(
+    AGENT_TARGETS.map(async (agent) => ({
+      agent,
+      detected: await isAgentDetected(agent),
+    })),
+  );
+
+  const agentItems = detected.map(({ agent, detected: isDetected }) => ({
+    label: `${agent.displayName}${isDetected ? dim(" (detected)") : ""}`,
+    value: agent,
+    checked: isDetected && install,
+  }));
+
+  const chosenAgents = await promptMultiSelect(
+    `Agents to ${install ? "configure" : "clean up"}`,
+    agentItems,
+  );
+
+  if (!chosenAgents || chosenAgents.length === 0) {
+    hint("Nothing selected. Exiting.");
+    return;
+  }
+
+  const integrationItems = INTEGRATIONS.map((integration) => ({
+    label: `${integration.label} — ${integration.description}`,
+    value: integration,
+    checked: true,
+  }));
+
+  const chosenIntegrations = await promptMultiSelect(
+    `Integrations to ${install ? "enable" : "remove"}`,
+    integrationItems,
+  );
+
+  if (!chosenIntegrations || chosenIntegrations.length === 0) {
+    hint("Nothing selected. Exiting.");
+    return;
+  }
+
+  printPlan(chosenAgents, chosenIntegrations);
+
+  const proceed = await promptConfirm(install ? "Proceed?" : "Remove miru configuration?", install);
+  if (!proceed) {
+    hint("Cancelled.");
+    return;
+  }
+
+  await apply(mode, chosenAgents, chosenIntegrations);
+
+  success(
+    install ? "Done! Restart your agents to pick up changes." : "Done! Configuration removed.",
+  );
+  if (install) {
+    hint("Run miru setup or export TAKARA_API_KEY for MCP env expansion.");
+  }
+  writeStdout("");
+}
+
+export {
+  applyInstructions,
+  applyMcp,
+  applySubagent,
+  INTEGRATIONS,
+  mergeJsonMember as mergeMcpJson,
+  removeJsonMember as removeMcpJson,
+};

package/src/installer/prompt.ts

@@ -0,0 +1,77 @@
+import { stdin as input, stdout as output } from "node:process";
+import * as readline from "node:readline/promises";
+import { bold, cyan, dim, divider, hint, warn } from "../cli-ui.ts";
+
+export function requireInteractiveTerminal(command: string): void {
+  if (!input.isTTY) {
+    throw new Error(
+      `${command} requires an interactive terminal. Configure agents manually (see README) ` +
+        "or run from a TTY.",
+    );
+  }
+}
+
+async function readLine(prompt: string): Promise<string> {
+  const rl = readline.createInterface({ input, output });
+  try {
+    return (await rl.question(prompt)).trim();
+  } finally {
+    rl.close();
+  }
+}
+
+export async function promptConfirm(question: string, defaultYes = true): Promise<boolean> {
+  const hintText = defaultYes ? dim("[Y/n]") : dim("[y/N]");
+  const answer = (await readLine(`${question} ${hintText} `)).toLowerCase();
+  if (!answer) {
+    return defaultYes;
+  }
+  return answer === "y" || answer === "yes";
+}
+
+export async function promptMultiSelect<T>(
+  title: string,
+  items: Array<{ label: string; value: T; checked: boolean }>,
+): Promise<T[] | null> {
+  output.write("\n");
+  output.write(`${bold(title)}\n`);
+  divider("─", 48, output);
+
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (!item) {
+      continue;
+    }
+    const mark = item.checked ? cyan("[x]") : dim("[ ]");
+    output.write(`  ${dim(String(i + 1).padStart(2))}. ${mark} ${item.label}\n`);
+  }
+
+  output.write("\n");
+  hint("Enter numbers (1,3), 'all', or press Enter for defaults", output);
+
+  const answer = (await readLine(`${dim("> ")}`)).toLowerCase();
+  if (!answer) {
+    return items.filter((item) => item.checked).map((item) => item.value);
+  }
+  if (answer === "all" || answer === "a") {
+    return items.map((item) => item.value);
+  }
+
+  const indices = new Set<number>();
+  for (const part of answer.split(/[,\s]+/)) {
+    const n = Number(part);
+    if (Number.isInteger(n) && n >= 1 && n <= items.length) {
+      indices.add(n - 1);
+    }
+  }
+
+  if (indices.size === 0) {
+    warn("No valid selection.", output);
+    return null;
+  }
+
+  return [...indices]
+    .sort((a, b) => a - b)
+    .map((i) => items[i]?.value)
+    .filter((value): value is T => value !== undefined);
+}

package/src/setup.ts

@@ -1,4 +1,4 @@
-import { stdout as output } from "node:process";
+import { brandTitle, divider, fail, hint, info, success, writeStderr } from "./cli-ui.ts";
 import {
   clearStoredCredentials,
   loadStoredCredentials,
@@ -16,7 +16,7 @@ async function promptApiKey(): Promise<string> {
   while (!key) {
     key = await promptHidden("Takara API key (input hidden): ");
     if (!key) {
-      output.write("API key cannot be empty.\n");
+      fail("API key cannot be empty.");
     }
   }
   return key;
@@ -33,33 +33,28 @@ export async function runSetup(options: RunSetupOptions = {}): Promise<string> {
     const path = resolveCredentialsPath();
     const stored = await readStoredCredentials();
     if (stored) {
-      process.stderr.write(
-        `API key already configured (env var and ${path}). Use --force to replace the stored key.\n`,
-      );
+      info(`API key already configured (env + ${path}). Use --force to replace stored key.`);
       return path;
     }
-    process.stderr.write(
-      "API key already set via environment variable. Stored credentials were not changed.\n",
-    );
+    info("API key already set via environment variable. Stored credentials unchanged.");
     return resolveCredentialsPath();
   }
 
   if (!options.force) {
     const stored = await readStoredCredentials();
     if (stored && !options.apiKey) {
-      process.stderr.write(
-        `API key already stored at ${resolveCredentialsPath()}. Use --force to replace it.\n`,
-      );
+      info(`API key already stored at ${resolveCredentialsPath()}. Use --force to replace.`);
       process.env.TAKARA_API_KEY = stored.takara_api_key;
       return resolveCredentialsPath();
     }
   }
 
-  process.stderr.write("\nMiru (見る) — first-time setup\n\n");
-  process.stderr.write(
-    "Miru needs a Takara API key for code embeddings.\n" +
-      "Get a bearer token from Takara, then enter it below.\n\n",
-  );
+  writeStderr("");
+  writeStderr(`${brandTitle()} setup`);
+  divider("─", 48, process.stderr);
+  writeStderr("Miru needs a Takara API key for code embeddings.");
+  hint("Get a bearer token from Takara, then enter it below.");
+  writeStderr("");
 
   const apiKey = options.apiKey ?? (await promptApiKey());
 
@@ -76,18 +71,20 @@ export async function runSetup(options: RunSetupOptions = {}): Promise<string> {
 
   const path = await saveStoredCredentials(apiKey);
   process.env.TAKARA_API_KEY = apiKey;
-  process.stderr.write(`\nSaved credentials to ${path} (readable only by your user account).\n`);
-  process.stderr.write("You can also set TAKARA_API_KEY in MCP config for IDE integrations.\n\n");
+  writeStderr("");
+  success(`Saved credentials to ${path}`);
+  hint("Set TAKARA_API_KEY in MCP config for IDE integrations.");
+  writeStderr("");
   return path;
 }
 
 export async function runClearCredentials(): Promise<void> {
   const { cleared, path } = await clearStoredCredentials();
   if (cleared) {
-    process.stderr.write(`Removed stored API key from ${path}.\n`);
+    success(`Removed stored API key from ${path}`);
     return;
   }
-  process.stderr.write(`No stored API key at ${path}.\n`);
+  info(`No stored API key at ${path}`);
 }
 
 export async function ensureCredentials(options?: { interactive?: boolean }): Promise<void> {