@takara-ai/miru-code 0.2.0 → 0.4.0

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/prompt.ts

@@ -0,0 +1,111 @@
+import { stdin as input, stdout as output } from "node:process";
+
+export interface HiddenPromptState {
+  value: string;
+  escapeBuffer: string;
+}
+
+export function createHiddenPromptState(): HiddenPromptState {
+  return { value: "", escapeBuffer: "" };
+}
+
+/** Apply one UTF-16 code unit from raw stdin; returns terminal echo bytes (may be empty). */
+export function applyHiddenPromptChar(
+  state: HiddenPromptState,
+  char: string,
+): { state: HiddenPromptState; echo: string; submit?: boolean; cancel?: boolean } {
+  if (char === "\x1b") {
+    return { state: { ...state, escapeBuffer: "\x1b" }, echo: "" };
+  }
+
+  if (state.escapeBuffer.length > 0) {
+    const escapeBuffer = state.escapeBuffer + char;
+    let done = false;
+    if (escapeBuffer.startsWith("\x1b[")) {
+      done = escapeBuffer.length > 2 && char >= "@" && char <= "~";
+    } else if (escapeBuffer.startsWith("\x1b")) {
+      done = escapeBuffer.length >= 2;
+    }
+    return {
+      state: { ...state, escapeBuffer: done ? "" : escapeBuffer },
+      echo: "",
+    };
+  }
+
+  if (char === "\n" || char === "\r" || char === "\u0004") {
+    return { state, echo: "", submit: true };
+  }
+
+  if (char === "\u0003") {
+    return { state, echo: "", cancel: true };
+  }
+
+  if (char === "\u007f" || char === "\b") {
+    if (state.value.length === 0) {
+      return { state, echo: "" };
+    }
+    return {
+      state: { ...state, value: state.value.slice(0, -1) },
+      echo: "\b \b",
+    };
+  }
+
+  if (char < " " || char === "\x7f") {
+    return { state, echo: "" };
+  }
+
+  return {
+    state: { ...state, value: state.value + char },
+    echo: "*",
+  };
+}
+
+export async function promptHidden(message: string): Promise<string> {
+  if (!input.isTTY) {
+    throw new Error(
+      "Cannot prompt for API key: stdin is not a TTY. Run `miru setup --key YOUR_KEY` or set TAKARA_API_KEY.",
+    );
+  }
+
+  return new Promise((resolve, reject) => {
+    output.write(message);
+    input.setRawMode?.(true);
+    input.resume();
+    input.setEncoding("utf8");
+
+    let state = createHiddenPromptState();
+
+    const onData = (chunk: string) => {
+      for (const char of chunk) {
+        const result = applyHiddenPromptChar(state, char);
+        state = result.state;
+
+        if (result.cancel) {
+          cleanup();
+          output.write("\n");
+          reject(new Error("Setup cancelled."));
+          process.exit(130);
+        }
+
+        if (result.submit) {
+          cleanup();
+          output.write("\n");
+          resolve(state.value.trim());
+          return;
+        }
+
+        if (result.echo) {
+          output.write(result.echo);
+        }
+      }
+    };
+
+    const cleanup = () => {
+      input.setRawMode?.(false);
+      input.pause();
+      input.removeListener("data", onData);
+    };
+
+    input.on("data", onData);
+  });
+}

package/src/setup.ts

@@ -1,71 +1,22 @@
-import { stdin as input, stdout as output } from "node:process";
+import { brandTitle, divider, fail, hint, info, success, writeStderr } from "./cli-ui.ts";
 import {
   clearStoredCredentials,
-  hasEmbeddingApiKeyInEnv,
   loadStoredCredentials,
   readStoredCredentials,
   resolveCredentialsPath,
   saveStoredCredentials,
 } from "./credentials.ts";
 import { validateEmbeddingApiKey } from "./embeddings/validate.ts";
-import { resolveEmbeddingApiKey } from "./env.ts";
+import { hasTakaraApiKeyInEnv, resolveEmbeddingApiKey } from "./env.ts";
+import { promptHidden } from "./prompt.ts";
 import { Spinner } from "./spinner.ts";
 
-async function promptHidden(message: string): Promise<string> {
-  if (!input.isTTY) {
-    throw new Error(
-      "Cannot prompt for API key: stdin is not a TTY. Run `miru setup --key YOUR_KEY` or set TAKARA_API_KEY.",
-    );
-  }
-
-  return new Promise((resolve, reject) => {
-    output.write(message);
-    input.setRawMode?.(true);
-    input.resume();
-    input.setEncoding("utf8");
-
-    let value = "";
-    const onData = (chunk: string) => {
-      const char = chunk[0];
-      if (char === "\n" || char === "\r" || char === "\u0004") {
-        cleanup();
-        output.write("\n");
-        resolve(value.trim());
-        return;
-      }
-      if (char === "\u0003") {
-        cleanup();
-        output.write("\n");
-        reject(new Error("Setup cancelled."));
-        process.exit(130);
-      }
-      if (char === "\u007f" || char === "\b") {
-        if (value.length > 0) {
-          value = value.slice(0, -1);
-          output.write("\b \b");
-        }
-        return;
-      }
-      value += chunk;
-      output.write("*");
-    };
-
-    const cleanup = () => {
-      input.setRawMode?.(false);
-      input.pause();
-      input.removeListener("data", onData);
-    };
-
-    input.on("data", onData);
-  });
-}
-
 async function promptApiKey(): Promise<string> {
   let key = "";
   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;
@@ -78,37 +29,32 @@ export interface RunSetupOptions {
 }
 
 export async function runSetup(options: RunSetupOptions = {}): Promise<string> {
-  if (!options.force && hasEmbeddingApiKeyInEnv()) {
+  if (!options.force && hasTakaraApiKeyInEnv()) {
     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());
 
@@ -125,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> {

package/src/spinner.ts

@@ -1,3 +1,5 @@
+import { dim, green, red } from "./cli-ui.ts";
+
 const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
 export class Spinner {
@@ -13,7 +15,7 @@ export class Spinner {
     }
     this.timer = setInterval(() => {
       const glyph = FRAMES[this.frame++ % FRAMES.length];
-      process.stderr.write(`\r${glyph} ${this.message}`);
+      process.stderr.write(`\r${dim(glyph)} ${this.message}`);
     }, 80);
   }
 
@@ -31,11 +33,15 @@ export class Spinner {
   }
 
   succeed(message?: string): void {
-    this.stop(message ?? `${this.message} — ok`);
+    if (message === "") {
+      this.stop();
+      return;
+    }
+    this.stop(green("✓ ") + (message ?? this.message));
   }
 
   fail(message?: string): void {
-    this.stop(message ?? `${this.message} — failed`);
+    this.stop(red("✗ ") + (message ?? this.message));
   }
 }
 
@@ -48,7 +54,7 @@ export async function withSpinner<T>(
   spinner.start();
   try {
     const result = await fn();
-    spinner.succeed(options?.successMessage);
+    spinner.succeed(options?.successMessage ?? "");
     return result;
   } catch (err) {
     spinner.fail(options?.failMessage);