@takara-ai/miru-code 1.5.3 → 1.6.0

package/src/installer/agents.ts

@@ -92,6 +92,8 @@ export interface AgentTarget {
   hooksFormat: HooksFormat | null;
   subagentPath: string | null;
   subagentId: AgentId | null;
+  /** On-demand Caveman Agent Skill (`…/skills/caveman/SKILL.md`), or null if unsupported. */
+  cavemanSkillPath: string | null;
 }
 
 export function opencodeMcpPath(): string {
@@ -176,6 +178,7 @@ export const AGENT_TARGETS: AgentTarget[] = [
     hooksFormat: "claude",
     subagentPath: join(HOME, ".claude", "agents", "miru-code.md"),
     subagentId: "claude",
+    cavemanSkillPath: join(HOME, ".claude", "skills", "caveman", "SKILL.md"),
   },
   {
     id: "cursor",
@@ -189,6 +192,7 @@ export const AGENT_TARGETS: AgentTarget[] = [
     hooksFormat: "cursor",
     subagentPath: join(HOME, ".cursor", "agents", "miru-code.md"),
     subagentId: "cursor",
+    cavemanSkillPath: join(HOME, ".cursor", "skills", "caveman", "SKILL.md"),
   },
   {
     id: "gemini",
@@ -202,24 +206,21 @@ export const AGENT_TARGETS: AgentTarget[] = [
     hooksFormat: "gemini",
     subagentPath: join(HOME, ".gemini", "agents", "miru-code.md"),
     subagentId: "gemini",
+    cavemanSkillPath: null,
   },
   {
     id: "kiro",
     displayName: "Kiro",
     binary: "kiro",
     configDir: join(HOME, ".kiro"),
-    mcp: jsonMcp(join(HOME, ".kiro", "settings", "mcp.json"), "mcpServers", {
-      ...STDIO_SERVER_CONFIG,
-      env: {
-        PATH: "/usr/local/bin:/usr/bin:/bin",
-      },
-    }),
+    mcp: jsonMcp(join(HOME, ".kiro", "settings", "mcp.json"), "mcpServers", STDIO_SERVER_CONFIG),
     instructionsPath: join(HOME, ".kiro", "steering", "miru.md"),
     cursorRulesPath: null,
     hooksPath: kiroHooksPath(HOME),
     hooksFormat: "kiro",
     subagentPath: join(HOME, ".kiro", "agents", "miru-code.md"),
     subagentId: "kiro",
+    cavemanSkillPath: null,
   },
   {
     id: "opencode",
@@ -233,6 +234,7 @@ export const AGENT_TARGETS: AgentTarget[] = [
     hooksFormat: "opencode",
     subagentPath: join(HOME, ".config", "opencode", "agents", "miru-code.md"),
     subagentId: "opencode",
+    cavemanSkillPath: null,
   },
   {
     id: "copilot",
@@ -246,6 +248,7 @@ export const AGENT_TARGETS: AgentTarget[] = [
     hooksFormat: "vscode",
     subagentPath: join(HOME, ".copilot", "agents", "miru-code.agent.md"),
     subagentId: "copilot",
+    cavemanSkillPath: null,
   },
   {
     id: "codex",
@@ -265,6 +268,7 @@ export const AGENT_TARGETS: AgentTarget[] = [
     hooksFormat: "claude",
     subagentPath: null,
     subagentId: null,
+    cavemanSkillPath: null,
   },
   {
     id: "vscode",
@@ -278,6 +282,7 @@ export const AGENT_TARGETS: AgentTarget[] = [
     hooksFormat: "vscode",
     subagentPath: null,
     subagentId: null,
+    cavemanSkillPath: null,
   },
   {
     id: "windsurf",
@@ -291,6 +296,7 @@ export const AGENT_TARGETS: AgentTarget[] = [
     hooksFormat: "windsurf",
     subagentPath: null,
     subagentId: null,
+    cavemanSkillPath: null,
   },
   {
     id: "visualstudio",
@@ -304,6 +310,7 @@ export const AGENT_TARGETS: AgentTarget[] = [
     hooksFormat: "vscode",
     subagentPath: null,
     subagentId: null,
+    cavemanSkillPath: null,
   },
 ];
 

package/src/installer/installer.ts

@@ -1,4 +1,5 @@
-import { unlink } from "node:fs/promises";
+import { mkdir, rmdir, unlink } from "node:fs/promises";
+import { dirname } from "node:path";
 import { loadAgentTemplate } from "../agents.ts";
 import { clearBenchmarkHistory } from "../benchmark/history.ts";
 import { brandTitle, dim, divider, green, hint, info, success, writeStdout } from "../cli-ui.ts";
@@ -24,13 +25,14 @@ import {
 import { mergeHooks, removeHooks } from "./hooks/install.ts";
 import { promptConfirm, promptMultiSelect, requireInteractiveTerminal } from "./prompt.ts";
 import { CURSOR_RULES_MDC } from "./search-policy.ts";
+import { CAVEMAN_SKILL_MD } from "./style-packs/caveman.ts";
 
 export interface WriteResult {
   path: string;
   action: InstallAction;
 }
 
-export type IntegrationId = "mcp" | "instructions" | "subagent" | "hooks" | "rules";
+export type IntegrationId = "mcp" | "instructions" | "subagent" | "hooks" | "rules" | "caveman";
 
 interface Integration {
   id: IntegrationId;
@@ -183,6 +185,33 @@ async function applySubagent(agent: AgentTarget, mode: InstallMode): Promise<Wri
   }
 }
 
+async function applyCaveman(agent: AgentTarget, mode: InstallMode): Promise<WriteResult | null> {
+  const path = agent.cavemanSkillPath;
+  if (!path) {
+    return null;
+  }
+
+  const skillDir = dirname(path);
+
+  if (mode === "uninstall") {
+    if (!(await Bun.file(path).exists())) {
+      return { path, action: "not-found" };
+    }
+    await unlink(path);
+    try {
+      await rmdir(skillDir);
+    } catch {
+      // Directory not empty or already gone — leave other skills alone.
+    }
+    return { path, action: "removed" };
+  }
+
+  const existed = await Bun.file(path).exists();
+  await mkdir(skillDir, { recursive: true });
+  await Bun.write(path, CAVEMAN_SKILL_MD);
+  return { path, action: existed ? "updated" : "created" };
+}
+
 const INTEGRATIONS: Integration[] = [
   {
     id: "mcp",
@@ -221,8 +250,27 @@ const INTEGRATIONS: Integration[] = [
     planPath: (agent) => agent.hooksPath,
     apply: applyHooks,
   },
+  {
+    id: "caveman",
+    label: "Caveman",
+    description: "on-demand chat compression skill (/caveman)",
+    experimental: true,
+    defaultChecked: false,
+    planPath: (agent) => agent.cavemanSkillPath,
+    apply: applyCaveman,
+  },
 ];
 
+function integrationApplies(integration: Integration, agent: AgentTarget): boolean {
+  return integration.planPath(agent) !== null;
+}
+
+function integrationsForAgents(agents: AgentTarget[]): Integration[] {
+  return INTEGRATIONS.filter((integration) =>
+    agents.some((agent) => integrationApplies(integration, agent)),
+  );
+}
+
 function formatActionLine(integration: Integration, result: WriteResult): string {
   const icon = ACTION_ICON[result.action] ?? dim("·");
   const detail = ACTION_DETAIL[result.action];
@@ -239,8 +287,10 @@ function printPlan(agents: AgentTarget[], integrations: Integration[]): void {
     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)")}`);
+      if (!path) {
+        continue;
+      }
+      writeStdout(`   ${green("✓")} ${integration.label.padEnd(13)} ${path}`);
     }
   }
   writeStdout("");
@@ -258,9 +308,11 @@ async function apply(
   for (const agent of agents) {
     writeStdout(` ${agent.displayName}`);
     for (const integration of integrations) {
+      if (!integrationApplies(integration, agent)) {
+        continue;
+      }
       const result = await integration.apply(agent, mode);
       if (!result) {
-        writeStdout(`   ${dim("–")} ${integration.id.padEnd(13)} ${dim("not supported")}`);
         continue;
       }
       writeStdout(formatActionLine(integration, result));
@@ -317,7 +369,13 @@ export async function runInstaller(mode: InstallMode): Promise<void> {
     return;
   }
 
-  const integrationItems = INTEGRATIONS.map((integration) => ({
+  const availableIntegrations = integrationsForAgents(chosenAgents);
+  if (availableIntegrations.length === 0) {
+    hint("No integrations apply to the selected agents. Exiting.");
+    return;
+  }
+
+  const integrationItems = availableIntegrations.map((integration) => ({
     label: `${integration.label}${integration.experimental ? dim(" (experimental)") : ""} — ${integration.description}`,
     value: integration,
     checked: install ? (integration.defaultChecked ?? true) : true,
@@ -355,11 +413,13 @@ export async function runInstaller(mode: InstallMode): Promise<void> {
 }
 
 export {
+  applyCaveman,
   applyHooks,
   applyInstructions,
   applyMcp,
   applySubagent,
   INTEGRATIONS,
+  integrationsForAgents,
   mergeJsonMember as mergeMcpJson,
   removeJsonMember as removeMcpJson,
 };

package/src/installer/search-policy.ts

@@ -88,7 +88,7 @@ export const INSTRUCTIONS_MARKDOWN = `## Miru Code Search
 
 ${SEARCH_POLICY_BODY}
 
-Run \`miru setup\` once — the MCP server loads your API key from \`credentials.json\`.
+Run \`miru setup\` once — the MCP server loads credentials from \`credentials.json\`, and interactive first use can auto-start device login when nothing is stored.
 
 CLI fallback when MCP is unavailable:
 

package/src/installer/style-packs/caveman.ts

@@ -0,0 +1,118 @@
+/**
+ * Caveman mode — on-demand Agent Skill body (chat compression).
+ * Installed by `miru install` (Phase B); content-only module for Phase A.
+ */
+
+export const CAVEMAN_SKILL_NAME = "caveman";
+
+/** Full `SKILL.md` (YAML frontmatter + body) written to the agent skill path. */
+export const CAVEMAN_SKILL_MD = `---
+name: caveman
+description: >-
+  Compress agent chat replies: less filler, max meaning. Use when the user
+  says caveman mode, /caveman, talk like caveman, be brief, or asks for fewer
+  tokens in chat. Intensities: /caveman lite|full|ultra. Stop with stop caveman
+  or normal mode. Chat narration only — not commits, PRs, or customer docs
+  unless the user asks.
+---
+
+# Caveman mode
+
+On-demand chat compression for Miru. **Brain big, mouth small.**
+
+Inspired by [JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman) — original Miru skill text.
+
+## Activate / stop
+
+| User says | Effect |
+|-----------|--------|
+| \`/caveman\`, \`caveman mode\`, \`talk like caveman\` | ON at **full** (default) |
+| \`/caveman lite\` | ON at lite |
+| \`/caveman full\` | ON at full |
+| \`/caveman ultra\` | ON at ultra |
+| \`stop caveman\`, \`normal mode\` | OFF — resume normal prose |
+
+Level sticks until the user changes it or the session ends. Do not stay in caveman after stop.
+
+## Intensity
+
+| Level | Behaviour |
+|-------|-----------|
+| **lite** | No polite filler, no task-restatement preamble. Keep articles and full sentences. Lead with the answer. |
+| **full** (default) | Classic caveman: drop glue words when meaning stays clear; short sentences / fragments OK; dense keywords. |
+| **ultra** | Maximum fragment compression. Still never sacrifice untouchables or safety (below). |
+
+## Style rules (when ON)
+
+- No polite talk ("sure", "happy to help", "great question")
+- No restating the user's task as a preamble
+- Lead with the answer
+- Prefer keywords / symbols (\`→\`, \`=\`, \`vs\`) over glue-heavy prose
+- Drop articles/copulas only when meaning stays clear
+- Short sentence or fragment OK
+
+## Auto-clarity (drop caveman for that segment)
+
+Use **normal clear prose** for:
+
+- Security warnings and security-relevant detail
+- Irreversible / destructive action confirmations (force-push, drop table, delete prod, etc.)
+- Multi-step sequences where fragment order could be misread
+- When the user asks to clarify or repeats a question
+
+Resume caveman after that segment if still ON.
+
+**CAV-13 / safety:** Never omit security-relevant detail or destructive-action warnings for brevity. Brevity never hides risk. If unsure, use normal prose for the warning.
+
+## Never sacrifice (untouchables)
+
+Byte-exact — do not compress or paraphrase:
+
+- Paths, file:line citations
+- Code fences and identifiers
+- CLI commands
+- Exact error strings / quoted text
+- Miru MCP tool use (\`search\` / \`locate\` / \`expand\` / \`find_related\`) when search policy is installed
+
+Caveman applies to surrounding prose only.
+
+## Chat vs persisted docs
+
+Default: caveman = **live chat replies only**.
+
+Commits, PR bodies, customer docs, READMEs, Linear text, memory files → **normal usable English** unless the user explicitly asks for caveman tone on that artifact.
+
+## Token honesty
+
+Output can shrink a lot on chatty replies. Session-level savings are often smaller; the skill itself costs input tokens each turn. No guaranteed % savings.
+
+## Clarity over parody
+
+If a reply is harder to use than normal concise prose, loosen grammar for that turn.
+
+## Examples
+
+### 1. Factual lookup
+
+**Before:**
+> Sure! I'd be happy to help. Looking at your question about where auth middleware is configured — I searched the codebase and it appears the authentication middleware is set up in \`src/auth/middleware.ts\` around line 42.
+
+**After (full):**
+> Auth middleware → \`src/auth/middleware.ts:42\`
+
+### 2. Recommendation
+
+**Before:**
+> Great question! There are a few approaches you could take here. I would generally recommend using the existing cache helper rather than rolling your own, because it already handles invalidation.
+
+**After (full):**
+> Use existing cache helper → handles invalidation. Don't roll own.
+
+### 3. Debug / failure finding
+
+**Before:**
+> I looked into the failure you described. It seems like the issue is that the API key is missing from the environment, which causes the client to throw a 401 Unauthorized when calling embeddings.
+
+**After (full):**
+> Fail = missing API key → embeddings 401 Unauthorized.
+`;

package/src/mcp/auth-tool.ts

@@ -0,0 +1,131 @@
+import * as z from "zod";
+import {
+  checkDeviceAuthorizationOnce,
+  type DeviceAuthConfig,
+  type DeviceAuthorizationStart,
+  resolveDeviceAuthConfig,
+  startDeviceAuthorization,
+} from "../auth/device.ts";
+import { saveStoredCredentials, setStoredCredentialsEnvToken } from "../credentials.ts";
+import { toolText } from "./index-cache.ts";
+import type { MiruMcpServer } from "./runtime.ts";
+
+const AUTH_TOOL_DESCRIPTION =
+  "Sign in with Takara credentials via device-code login — no terminal required. " +
+  "Only call this in direct response to a tool error mentioning missing/expired " +
+  "credentials — never speculatively, since it starts a real sign-in prompt for the " +
+  'user. Call with no arguments (or action "start") to begin: it returns a URL and a ' +
+  "short code. Show both to the user and ask them to open the link and approve. Once " +
+  'they confirm, call again with action "check" to complete sign-in.';
+
+type PendingDeviceAuth = {
+  start: DeviceAuthorizationStart;
+  config: DeviceAuthConfig;
+  startedAtMs: number;
+};
+
+function isExpired(entry: Pick<PendingDeviceAuth, "start" | "startedAtMs">): boolean {
+  return Date.now() >= entry.startedAtMs + entry.start.expiresIn * 1000;
+}
+
+/**
+ * Per-registration auth-tool state, scoped to one `registerAuthTool` call rather than
+ * the module — a process could in principle host more than one MiruMcpServer (tests
+ * already do), and a module-level singleton would let their device logins collide.
+ */
+class AuthToolState {
+  private pending: PendingDeviceAuth | null = null;
+
+  async start(): Promise<{ content: Array<{ type: "text"; text: string }> }> {
+    if (this.pending && !isExpired(this.pending)) {
+      const { userCode, verificationUriComplete, verificationUri } = this.pending.start;
+      return toolText(
+        `A device login is already pending. Open ${verificationUriComplete ?? verificationUri} ` +
+          `and enter code ${userCode} if not already filled in, then call \`auth\` again with ` +
+          'action "check" once approved.',
+      );
+    }
+    this.pending = null;
+
+    const config = resolveDeviceAuthConfig();
+    const start = await startDeviceAuthorization({ config });
+    this.pending = { start, config, startedAtMs: Date.now() };
+
+    const link = start.verificationUriComplete ?? start.verificationUri;
+    return toolText(
+      `Open ${link} and approve the request` +
+        (start.verificationUriComplete ? "." : ` (enter code ${start.userCode} if prompted).`) +
+        ` Code: ${start.userCode}. Once the user confirms they've approved it, call \`auth\` again ` +
+        'with action "check" to finish signing in.',
+    );
+  }
+
+  async check(): Promise<{ content: Array<{ type: "text"; text: string }> }> {
+    if (!this.pending) {
+      return toolText('No device login is pending. Call `auth` with action "start" first.');
+    }
+
+    const { start, config } = this.pending;
+    // Errors (network failure, unrecognized OAuth error code) intentionally leave
+    // `pending` intact — a transient failure shouldn't force the user to restart
+    // the whole login, just retry the check.
+    const result = await checkDeviceAuthorizationOnce(start, { config });
+
+    switch (result.status) {
+      case "success": {
+        this.pending = null;
+        const { tokens } = result;
+        await saveStoredCredentials({
+          kind: "device_code",
+          accessToken: tokens.accessToken,
+          refreshToken: tokens.refreshToken,
+          expiresAt: tokens.expiresAt,
+          tokenType: tokens.tokenType,
+          scope: tokens.scope,
+        });
+        setStoredCredentialsEnvToken(tokens.accessToken);
+        return toolText("Signed in successfully. Miru tools are now ready to use.");
+      }
+      case "pending":
+        return toolText(
+          'Still waiting for approval. Ask the user to confirm they clicked and approved, then call `auth` again with action "check".',
+        );
+      case "slow_down":
+        return toolText(
+          'Checking too soon — wait a bit before calling `auth` again with action "check".',
+        );
+      case "denied":
+        this.pending = null;
+        return toolText('Sign-in was denied. Call `auth` with action "start" to try again.');
+      case "expired":
+        this.pending = null;
+        return toolText(
+          'The device code expired before it was approved. Call `auth` with action "start" to try again.',
+        );
+    }
+  }
+}
+
+export function registerAuthTool(server: MiruMcpServer): void {
+  const state = new AuthToolState();
+
+  server.registerTool(
+    "auth",
+    {
+      description: AUTH_TOOL_DESCRIPTION,
+      inputSchema: {
+        action: z
+          .enum(["start", "check"])
+          .optional()
+          .describe('"start" begins a device-code login (default); "check" completes it.'),
+      },
+    },
+    async ({ action }) => {
+      try {
+        return action === "check" ? await state.check() : await state.start();
+      } catch (err) {
+        return toolText(err instanceof Error ? err.message : String(err));
+      }
+    },
+  );
+}

package/src/mcp/server.ts

@@ -34,6 +34,7 @@ import {
   MAX_MCP_TOP_K,
   resolveChunk,
 } from "../utils.ts";
+import { registerAuthTool } from "./auth-tool.ts";
 import {
   formatExpandResultsText,
   formatLiteralLocateText,
@@ -88,6 +89,8 @@ export function createMcpServer(
     },
   );
 
+  registerAuthTool(server);
+
   server.registerTool(
     "search",
     {

package/src/prompt.ts

@@ -73,7 +73,10 @@ export async function promptText(message: string, defaultValue = ""): Promise<st
   }
 }
 
-export async function promptHidden(message: string): Promise<string> {
+export async function promptHidden(
+  message: string,
+  stream: NodeJS.WriteStream = output,
+): 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.",
@@ -81,7 +84,7 @@ export async function promptHidden(message: string): Promise<string> {
   }
 
   return new Promise((resolve, reject) => {
-    output.write(message);
+    stream.write(message);
     input.setRawMode?.(true);
     input.resume();
     input.setEncoding("utf8");
@@ -95,20 +98,20 @@ export async function promptHidden(message: string): Promise<string> {
 
         if (result.cancel) {
           cleanup();
-          output.write("\n");
+          stream.write("\n");
           reject(new Error("Setup cancelled."));
           process.exit(130);
         }
 
         if (result.submit) {
           cleanup();
-          output.write("\n");
+          stream.write("\n");
           resolve(state.value.trim());
           return;
         }
 
         if (result.echo) {
-          output.write(result.echo);
+          stream.write(result.echo);
         }
       }
     };