kadai 0.3.0 → 0.4.1

package/README.md

@@ -1,13 +1,14 @@
-<img width="1024" height="1024" alt="image" src="https://github.com/user-attachments/assets/daa548e6-5984-4cde-93d3-7c4684de639a" />
+<img width="919" height="228" alt="image" src="https://github.com/user-attachments/assets/2c1fca9f-3484-409f-b3b4-214edc0387a4" />
 
 # kadai
 
-A terminal UI for discovering and running project scripts. Drop scripts into `.kadai/actions/`, and kadai gives you a fuzzy-searchable menu to run them.
+1. Drop scripts into `.kadai/actions/`.
+2. Run with `bunx kadai`.
+3. Share them with your team in the repo.
+4. Automatically make them discoverable by AI.
 
 ## Getting Started
 
-<img width="950" height="205" alt="image" src="https://github.com/user-attachments/assets/b694bfaa-146b-41c7-a44c-d197c7cea08e" />
-
 ```bash
 bunx kadai
 # OR
@@ -70,11 +71,6 @@ For JS/TS, use `//` comments:
 | `confirm`     | boolean | Require confirmation before running        |
 | `hidden`      | boolean | Hide from menu (still runnable via CLI)    |
 | `fullscreen`  | boolean | Use alternate screen buffer (`.tsx` only)  |
-| `interactive` | boolean | Hand over the full terminal to the script  |
-
-### Interactive Scripts
-
-Scripts marked `interactive` get full terminal control — kadai exits its UI, runs the script with inherited stdio, then returns to the menu. Use this for scripts that need user input (readline prompts, password entry, etc.).
 
 ### Ink TUI Actions
 
@@ -148,13 +144,29 @@ kadai                    # Interactive menu
 kadai list --json        # List actions as JSON
 kadai list --json --all  # Include hidden actions
 kadai run <action-id>    # Run an action directly
+kadai mcp                # Start MCP server (creates .mcp.json)
 ```
 
 ## AI
 
 kadai is designed to work well with AI coding agents like Claude Code.
 
-### How It Works
+### MCP Server
+
+kadai includes a built-in [MCP](https://modelcontextprotocol.io/) server that exposes your actions as tools. Any MCP-compatible client (Claude Code, Claude Desktop, etc.) can auto-discover and run your project's actions.
+
+kadai will automatically configure a `.mcp.json` file in your project root so Claude can automatically discover any `kadai` actions you define.
+
+```bash
+kadai mcp
+```
+
+This creates the `.mcp.json` in your project root if it doesn't already exist (so `claude` will autodiscover it.)
+It then starts the `mcp` server (this is the command `claude` uses to invoke `kadai` MCP.)
+
+Each action becomes an MCP tool. Nested action IDs use `--` as a separator (e.g. `database/reset` becomes the tool `database--reset`) since MCP tool names don't allow slashes.
+
+### JSON API
 
 - `kadai list --json` gives agents a machine-readable list of available project actions
 - `kadai run <action-id>` runs actions non-interactively (confirmation prompts auto-skip in non-TTY)

package/dist/cli.js

@@ -347,6 +347,127 @@ var init_runner = __esm(() => {
   };
 });
 
+// src/core/mcp.ts
+var exports_mcp = {};
+__export(exports_mcp, {
+  toolNameToActionId: () => toolNameToActionId,
+  startMcpServer: () => startMcpServer,
+  ensureMcpConfig: () => ensureMcpConfig,
+  actionIdToToolName: () => actionIdToToolName
+});
+import { join as join4, resolve } from "path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+function resolveInvocationCommand() {
+  const script = process.argv[1] ?? "";
+  if (script.endsWith(".ts") || script.endsWith(".tsx")) {
+    return { command: "bun", args: [resolve(script), "mcp"] };
+  }
+  return { command: "bunx", args: ["kadai", "mcp"] };
+}
+function actionIdToToolName(id) {
+  return id.replace(/\//g, "--");
+}
+function toolNameToActionId(name) {
+  return name.replace(/--/g, "/");
+}
+function buildToolDescription(action) {
+  const parts = [];
+  if (action.meta.emoji)
+    parts.push(action.meta.emoji);
+  parts.push(action.meta.name);
+  if (action.meta.description) {
+    parts.push(`\u2014 ${action.meta.description}`);
+  }
+  return parts.join(" ");
+}
+async function ensureMcpConfig(projectRoot) {
+  const mcpJsonPath = join4(projectRoot, ".mcp.json");
+  const mcpFile = Bun.file(mcpJsonPath);
+  const kadaiEntry = resolveInvocationCommand();
+  if (await mcpFile.exists()) {
+    const existing = await mcpFile.json();
+    if (existing.mcpServers?.kadai) {
+      process.stderr.write(`kadai MCP server already configured in .mcp.json
+`);
+      return;
+    }
+    existing.mcpServers = existing.mcpServers ?? {};
+    existing.mcpServers.kadai = kadaiEntry;
+    await Bun.write(mcpJsonPath, `${JSON.stringify(existing, null, 2)}
+`);
+    process.stderr.write(`Added kadai entry to existing .mcp.json
+`);
+  } else {
+    const config = {
+      mcpServers: {
+        kadai: kadaiEntry
+      }
+    };
+    await Bun.write(mcpJsonPath, `${JSON.stringify(config, null, 2)}
+`);
+    process.stderr.write(`Created .mcp.json with kadai MCP server config
+`);
+  }
+}
+async function startMcpServer(kadaiDir, cwd) {
+  let visibleActions = [];
+  let config = {};
+  if (kadaiDir) {
+    config = await loadConfig(kadaiDir);
+    const actionsDir = join4(kadaiDir, config.actionsDir ?? "actions");
+    visibleActions = (await loadActions(actionsDir)).filter((a) => !a.meta.hidden);
+  }
+  const server = new McpServer({ name: "kadai", version: "0.3.0" });
+  const env = {
+    ...process.env,
+    ...config.env ?? {}
+  };
+  for (const action of visibleActions) {
+    const toolName = actionIdToToolName(action.id);
+    const description = buildToolDescription(action);
+    server.registerTool(toolName, { description }, async () => {
+      const cmd = resolveCommand(action);
+      const proc = Bun.spawn(cmd, {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+        stdin: "ignore",
+        env
+      });
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text()
+      ]);
+      const exitCode = await proc.exited;
+      const parts = [];
+      if (stdout)
+        parts.push(stdout);
+      if (stderr)
+        parts.push(`[stderr]
+${stderr}`);
+      if (exitCode !== 0)
+        parts.push(`[exit code: ${exitCode}]`);
+      return {
+        content: [
+          { type: "text", text: parts.join(`
+`) || "(no output)" }
+        ],
+        isError: exitCode !== 0
+      };
+    });
+  }
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+  process.stderr.write(`kadai MCP server running (${visibleActions.length} tools)
+`);
+}
+var init_mcp = __esm(() => {
+  init_config();
+  init_loader();
+  init_runner();
+});
+
 // src/components/Breadcrumbs.tsx
 import { Box, Text } from "ink";
 import { jsxDEV } from "react/jsx-dev-runtime";
@@ -508,7 +629,7 @@ function StatusBar() {
 var init_StatusBar = () => {};
 
 // src/hooks/useActions.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { useEffect as useEffect2, useRef, useState as useState2 } from "react";
 function useActions({ kadaiDir }) {
   const [actions, setActions] = useState2([]);
@@ -520,7 +641,7 @@ function useActions({ kadaiDir }) {
     (async () => {
       const cfg = await loadConfig(kadaiDir);
       setConfig(cfg);
-      const actionsDir = join4(kadaiDir, cfg.actionsDir ?? "actions");
+      const actionsDir = join5(kadaiDir, cfg.actionsDir ?? "actions");
       const localActions = await loadActions(actionsDir);
       setActions(localActions);
       setLoading(false);
@@ -1785,7 +1906,7 @@ __export(exports_init_wizard, {
   generateConfigFile: () => generateConfigFile
 });
 import { existsSync, mkdirSync } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function generateConfigFile() {
   const lines = ['  // actionsDir: "actions",', "  // env: {},"];
   return `export default {
@@ -1795,10 +1916,10 @@ ${lines.join(`
 `;
 }
 async function writeInitFiles(cwd) {
-  const kadaiDir = join5(cwd, ".kadai");
-  const actionsDir = join5(kadaiDir, "actions");
+  const kadaiDir = join6(cwd, ".kadai");
+  const actionsDir = join6(kadaiDir, "actions");
   mkdirSync(actionsDir, { recursive: true });
-  const sampleAction = join5(actionsDir, "hello.sh");
+  const sampleAction = join6(actionsDir, "hello.sh");
   const sampleFile = Bun.file(sampleAction);
   let sampleCreated = false;
   if (!await sampleFile.exists()) {
@@ -1813,14 +1934,14 @@ echo "Add your own scripts to .kadai/actions/ to get started."
     sampleCreated = true;
   }
   const configContent = generateConfigFile();
-  const configPath = join5(kadaiDir, "config.ts");
+  const configPath = join6(kadaiDir, "config.ts");
   await Bun.write(configPath, configContent);
   let skillCreated = false;
-  const hasClaudeDir = existsSync(join5(cwd, ".claude"));
-  const hasClaudeMd = existsSync(join5(cwd, "CLAUDE.md"));
+  const hasClaudeDir = existsSync(join6(cwd, ".claude"));
+  const hasClaudeMd = existsSync(join6(cwd, "CLAUDE.md"));
   if (hasClaudeDir || hasClaudeMd) {
-    const skillDir = join5(cwd, ".claude", "skills", "kadai");
-    const skillPath = join5(skillDir, "SKILL.md");
+    const skillDir = join6(cwd, ".claude", "skills", "kadai");
+    const skillPath = join6(skillDir, "SKILL.md");
     if (!await Bun.file(skillPath).exists()) {
       mkdirSync(skillDir, { recursive: true });
       await Bun.write(skillPath, generateSkillFile());
@@ -1950,10 +2071,12 @@ function parseArgs(argv) {
       }
       return { type: "run", actionId };
     }
+    case "mcp":
+      return { type: "mcp" };
     default:
       return {
         type: "error",
-        message: `Unknown command: ${command}. Available commands: list, run`
+        message: `Unknown command: ${command}. Available commands: list, run, mcp`
       };
   }
 }
@@ -2039,6 +2162,14 @@ if (parsed.type === "error") {
 `);
   process.exit(1);
 }
+if (parsed.type === "mcp") {
+  const { ensureMcpConfig: ensureMcpConfig2, startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_mcp(), exports_mcp));
+  const kadaiDir = findZcliDir(cwd);
+  const projectRoot = kadaiDir ? (await import("path")).dirname(kadaiDir) : cwd;
+  await ensureMcpConfig2(projectRoot);
+  await startMcpServer2(kadaiDir, cwd);
+  await new Promise(() => {});
+}
 if (parsed.type === "list" || parsed.type === "run") {
   const kadaiDir = findZcliDir(cwd);
   if (!kadaiDir) {
@@ -2168,22 +2299,16 @@ var env = {
 console.log(`${action.meta.emoji ? `${action.meta.emoji} ` : ""}${action.meta.name}
 `);
 process.stdin.removeAllListeners("data");
+if (process.stdin.isTTY) {
+  process.stdin.setRawMode(false);
+}
+process.stdin.resume();
 var proc = Bun.spawn(cmd, {
   cwd,
   stdout: "inherit",
   stderr: "inherit",
-  stdin: "pipe",
+  stdin: "inherit",
   env
 });
-var forwardStdin = (data) => {
-  try {
-    const converted = Buffer.from(data.toString().replace(/\r/g, `
-`));
-    proc.stdin.write(converted);
-    proc.stdin.flush();
-  } catch {}
-};
-process.stdin.on("data", forwardStdin);
-process.stdin.resume();
 var exitCode = await proc.exited;
 process.exit(exitCode);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kadai",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "type": "module",
   "bin": {
     "kadai": "./dist/cli.js"
@@ -24,6 +24,7 @@
   },
   "dependencies": {
     "@inkjs/ui": "^2.0.0",
+    "@modelcontextprotocol/sdk": "^1.12.1",
     "@types/react": "^19.2.14",
     "fuzzysort": "^3.1.0",
     "ink": "^6.7.0",