kadai 0.4.0 → 0.5.0

package/README.md

@@ -2,7 +2,10 @@
 
 # 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
 

package/dist/cli.js

@@ -45,7 +45,8 @@ async function loadConfig(kadaiDir) {
   const userConfig = mod.default ?? mod;
   return {
     actionsDir: userConfig.actionsDir ?? DEFAULT_CONFIG.actionsDir,
-    env: userConfig.env ?? DEFAULT_CONFIG.env
+    env: userConfig.env ?? DEFAULT_CONFIG.env,
+    plugins: userConfig.plugins
   };
 }
 var DEFAULT_CONFIG;
@@ -198,14 +199,14 @@ async function getGitAddedDates(dir) {
   } catch {}
   return dates;
 }
-async function loadActions(actionsDir) {
+async function loadActions(actionsDir, origin = { type: "local" }) {
   const actions = [];
   const gitDates = await getGitAddedDates(actionsDir);
-  await scanDirectory(actionsDir, actionsDir, [], actions, 0, gitDates);
+  await scanDirectory(actionsDir, actionsDir, [], actions, 0, gitDates, origin);
   actions.sort((a, b) => a.meta.name.localeCompare(b.meta.name));
   return actions;
 }
-async function scanDirectory(baseDir, currentDir, category, actions, depth, gitDates) {
+async function scanDirectory(baseDir, currentDir, category, actions, depth, gitDates, origin = { type: "local" }) {
   if (depth > 3)
     return;
   let entries;
@@ -219,7 +220,7 @@ async function scanDirectory(baseDir, currentDir, category, actions, depth, gitD
       continue;
     const fullPath = join2(currentDir, entry.name);
     if (entry.isDirectory()) {
-      await scanDirectory(baseDir, fullPath, [...category, entry.name], actions, depth + 1, gitDates);
+      await scanDirectory(baseDir, fullPath, [...category, entry.name], actions, depth + 1, gitDates, origin);
     } else if (entry.isFile()) {
       const ext = `.${entry.name.split(".").pop()}`;
       if (!SUPPORTED_EXTENSIONS.has(ext))
@@ -237,6 +238,7 @@ async function scanDirectory(baseDir, currentDir, category, actions, depth, gitD
         category,
         runtime: runtimeFromExtension(ext),
         addedAt,
+        origin,
         ...shebang ? { shebang } : {}
       });
     }
@@ -274,12 +276,174 @@ var init_loader = __esm(() => {
   ]);
 });
 
-// src/core/runner.ts
-var exports_runner = {};
-__export(exports_runner, {
-  resolveCommand: () => resolveCommand,
-  parseShebangCommand: () => parseShebangCommand
-});
+// src/core/fetchers/github.ts
+import { mkdir, rm } from "fs/promises";
+import { join as join3 } from "path";
+async function fetchGithubPlugin(source, destDir) {
+  const ref = source.ref ?? "main";
+  const repoUrl = `https://github.com/${source.github}.git`;
+  await mkdir(destDir, { recursive: true });
+  const proc = Bun.spawn(["git", "clone", "--depth", "1", "--branch", ref, repoUrl, destDir], { stdout: "pipe", stderr: "pipe" });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`Failed to clone "${source.github}" (ref: ${ref}): ${stderr.trim()}`);
+  }
+  const shaProc = Bun.spawn(["git", "rev-parse", "HEAD"], {
+    cwd: destDir,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const sha = (await new Response(shaProc.stdout).text()).trim();
+  await shaProc.exited;
+  await rm(join3(destDir, ".git"), { recursive: true, force: true });
+  return { resolvedVersion: sha };
+}
+async function checkGithubUpdate(source, currentSha) {
+  try {
+    const ref = source.ref ?? "main";
+    const repoUrl = `https://github.com/${source.github}.git`;
+    const proc = Bun.spawn(["git", "ls-remote", repoUrl, ref], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const output = (await new Response(proc.stdout).text()).trim();
+    const exitCode = await proc.exited;
+    if (exitCode !== 0)
+      return false;
+    const remoteSha = output.split("\t")[0] ?? "";
+    if (!remoteSha)
+      return false;
+    return remoteSha !== currentSha;
+  } catch {
+    return false;
+  }
+}
+var init_github = () => {};
+
+// src/core/fetchers/npm.ts
+import { mkdir as mkdir2, unlink } from "fs/promises";
+import { join as join4 } from "path";
+function parseSemver(v) {
+  const withoutPrerelease = v.replace(/^v/, "").split("-")[0] ?? "";
+  const clean = withoutPrerelease.split("+")[0] ?? "";
+  const parts = clean.split(".");
+  if (parts.length !== 3)
+    return null;
+  const nums = parts.map(Number);
+  if (nums.some((n) => Number.isNaN(n)))
+    return null;
+  return nums;
+}
+function compareSemver(a, b) {
+  for (let i = 0;i < 3; i++) {
+    const av = a[i];
+    const bv = b[i];
+    if (av !== bv)
+      return av - bv;
+  }
+  return 0;
+}
+function satisfies(version, range) {
+  if (range === "*" || range === "x")
+    return true;
+  const parsed = parseSemver(version);
+  if (!parsed)
+    return false;
+  if (range.startsWith("^")) {
+    const min = parseSemver(range.slice(1));
+    if (!min)
+      return false;
+    if (compareSemver(parsed, min) < 0)
+      return false;
+    if (min[0] === 0) {
+      return parsed[0] === 0 && parsed[1] === min[1];
+    }
+    return parsed[0] === min[0];
+  }
+  if (range.startsWith("~")) {
+    const min = parseSemver(range.slice(1));
+    if (!min)
+      return false;
+    if (compareSemver(parsed, min) < 0)
+      return false;
+    return parsed[0] === min[0] && parsed[1] === min[1];
+  }
+  const exact = parseSemver(range);
+  if (!exact)
+    return false;
+  return compareSemver(parsed, exact) === 0;
+}
+async function resolveVersion(source) {
+  const version = source.version ?? "latest";
+  const res = await fetch(`${REGISTRY}/${encodeURIComponent(source.npm)}`);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch npm package "${source.npm}": ${res.status} ${res.statusText}`);
+  }
+  const meta = await res.json();
+  const tagVersion = meta["dist-tags"][version];
+  if (tagVersion) {
+    const versionData = meta.versions[tagVersion];
+    if (!versionData) {
+      throw new Error(`npm package "${source.npm}": version ${tagVersion} not found in registry`);
+    }
+    return { version: tagVersion, tarballUrl: versionData.dist.tarball };
+  }
+  const exactData = meta.versions[version];
+  if (exactData) {
+    return { version, tarballUrl: exactData.dist.tarball };
+  }
+  const allVersions = Object.keys(meta.versions);
+  const matching = allVersions.filter((v) => satisfies(v, version)).map((v) => ({ version: v, parsed: parseSemver(v) })).filter((v) => v.parsed !== null).sort((a, b) => compareSemver(b.parsed, a.parsed));
+  if (matching.length === 0) {
+    throw new Error(`npm package "${source.npm}": no version matching "${version}" found`);
+  }
+  const bestMatch = matching[0];
+  if (!bestMatch) {
+    throw new Error(`npm package "${source.npm}": no version matching "${version}" found`);
+  }
+  const best = bestMatch.version;
+  const bestData = meta.versions[best];
+  if (!bestData) {
+    throw new Error(`npm package "${source.npm}": version data for ${best} missing`);
+  }
+  return { version: best, tarballUrl: bestData.dist.tarball };
+}
+async function fetchNpmPlugin(source, destDir) {
+  const { version, tarballUrl } = await resolveVersion(source);
+  const tarballRes = await fetch(tarballUrl);
+  if (!tarballRes.ok || !tarballRes.body) {
+    throw new Error(`Failed to download tarball for "${source.npm}@${version}": ${tarballRes.status}`);
+  }
+  await mkdir2(destDir, { recursive: true });
+  const tarball = await tarballRes.arrayBuffer();
+  const tarballPath = join4(destDir, ".plugin.tgz");
+  await Bun.write(tarballPath, tarball);
+  const proc = Bun.spawn(["tar", "xzf", tarballPath, "--strip-components=1"], {
+    cwd: destDir,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`Failed to extract tarball: ${stderr}`);
+  }
+  await unlink(tarballPath);
+  return { resolvedVersion: version };
+}
+async function checkNpmUpdate(source, currentVersion) {
+  try {
+    const { version } = await resolveVersion(source);
+    return version !== currentVersion;
+  } catch {
+    return false;
+  }
+}
+var REGISTRY = "https://registry.npmjs.org";
+var init_npm = () => {};
+
+// src/core/which.ts
 function cachedWhich(bin) {
   if (whichCache.has(bin))
     return whichCache.get(bin) ?? null;
@@ -287,6 +451,219 @@ function cachedWhich(bin) {
   whichCache.set(bin, result ?? null);
   return result ?? null;
 }
+var whichCache;
+var init_which = __esm(() => {
+  whichCache = new Map;
+});
+
+// src/core/pm.ts
+import { join as join5 } from "path";
+async function resolvePM(dir) {
+  const pkgJsonPath = join5(dir, "package.json");
+  try {
+    const file = Bun.file(pkgJsonPath);
+    if (await file.exists()) {
+      const pkg = await file.json();
+      if (typeof pkg.packageManager === "string") {
+        const bin = pkg.packageManager.split("@")[0];
+        if (bin && cachedWhich(bin)) {
+          return { bin, install: [bin, "install"] };
+        }
+      }
+    }
+  } catch {}
+  for (const candidate of PM_CHAIN) {
+    if (cachedWhich(candidate.bin)) {
+      return candidate;
+    }
+  }
+  throw new Error(`No package manager found. Install bun or npm to use plugin dependencies.`);
+}
+var PM_CHAIN;
+var init_pm = __esm(() => {
+  init_which();
+  PM_CHAIN = [
+    { bin: "bun", install: ["bun", "install"] },
+    { bin: "npm", install: ["npm", "install"] }
+  ];
+});
+
+// src/core/plugins.ts
+import { existsSync } from "fs";
+import { mkdir as mkdir3, rm as rm2 } from "fs/promises";
+import { isAbsolute, join as join6, resolve } from "path";
+async function ensurePluginCacheDir(kadaiDir) {
+  const cacheDir = join6(kadaiDir, ".cache", "plugins");
+  await mkdir3(cacheDir, { recursive: true });
+  const gitignorePath = join6(kadaiDir, ".cache", ".gitignore");
+  const gitignoreFile = Bun.file(gitignorePath);
+  if (!await gitignoreFile.exists()) {
+    await Bun.write(gitignorePath, `*
+`);
+  }
+  return cacheDir;
+}
+function cacheKeyFor(source) {
+  if ("npm" in source) {
+    const name2 = source.npm.replace("/", "--");
+    const version = source.version ?? "latest";
+    return `npm/${name2}@${version}`;
+  }
+  const name = source.github.replace("/", "--");
+  const ref = source.ref ?? "main";
+  return `github/${name}@${ref}`;
+}
+function pluginDisplayName(source) {
+  if ("npm" in source)
+    return source.npm;
+  if ("github" in source)
+    return source.github;
+  return source.path;
+}
+async function readPluginMeta(cacheDir) {
+  try {
+    const file = Bun.file(join6(cacheDir, ".plugin-meta.json"));
+    if (!await file.exists())
+      return null;
+    return await file.json();
+  } catch {
+    return null;
+  }
+}
+async function writePluginMeta(cacheDir, meta) {
+  await Bun.write(join6(cacheDir, ".plugin-meta.json"), JSON.stringify(meta, null, 2));
+}
+async function loadCachedPlugins(kadaiDir, plugins) {
+  const allActions = [];
+  const cacheBase = join6(kadaiDir, ".cache", "plugins");
+  for (const source of plugins) {
+    if ("path" in source)
+      continue;
+    const key = cacheKeyFor(source);
+    const pluginCacheDir = join6(cacheBase, key);
+    const actionsDir = join6(pluginCacheDir, "actions");
+    if (!existsSync(actionsDir))
+      continue;
+    const name = pluginDisplayName(source);
+    const origin = { type: "plugin", pluginName: name };
+    const actions = await loadActions(actionsDir, origin);
+    for (const action of actions) {
+      action.category = [name, ...action.category];
+      action.id = `${name}/${action.id}`;
+    }
+    allActions.push(...actions);
+  }
+  return allActions;
+}
+async function installPluginDeps(pluginDir) {
+  const pkgJsonPath = join6(pluginDir, "package.json");
+  if (!existsSync(pkgJsonPath))
+    return;
+  const pm = await resolvePM(pluginDir);
+  const proc = Bun.spawn(pm.install, {
+    cwd: pluginDir,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`Failed to install plugin dependencies in ${pluginDir}: ${stderr.trim()}`);
+  }
+}
+async function syncPlugin(kadaiDir, source) {
+  const cacheBase = await ensurePluginCacheDir(kadaiDir);
+  const key = cacheKeyFor(source);
+  const pluginCacheDir = join6(cacheBase, key);
+  const meta = await readPluginMeta(pluginCacheDir);
+  if (meta) {
+    let needsUpdate = false;
+    if ("npm" in source) {
+      needsUpdate = await checkNpmUpdate(source, meta.resolvedVersion);
+    } else {
+      needsUpdate = await checkGithubUpdate(source, meta.resolvedVersion);
+    }
+    if (!needsUpdate)
+      return;
+  }
+  await rm2(pluginCacheDir, { recursive: true, force: true });
+  await mkdir3(pluginCacheDir, { recursive: true });
+  let resolvedVersion;
+  if ("npm" in source) {
+    const result = await fetchNpmPlugin(source, pluginCacheDir);
+    resolvedVersion = result.resolvedVersion;
+  } else {
+    const result = await fetchGithubPlugin(source, pluginCacheDir);
+    resolvedVersion = result.resolvedVersion;
+  }
+  await installPluginDeps(pluginCacheDir);
+  await writePluginMeta(pluginCacheDir, {
+    fetchedAt: new Date().toISOString(),
+    source,
+    resolvedVersion
+  });
+}
+async function syncPlugins(kadaiDir, plugins, callbacks) {
+  const syncable = plugins.filter((p) => !("path" in p));
+  const SYNC_TIMEOUT_MS = 60000;
+  await Promise.allSettled(syncable.map(async (source) => {
+    const name = pluginDisplayName(source);
+    callbacks.onPluginStatus(name, "syncing");
+    try {
+      await Promise.race([
+        syncPlugin(kadaiDir, source),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Sync timeout for ${name}`)), SYNC_TIMEOUT_MS))
+      ]);
+      callbacks.onPluginStatus(name, "done");
+    } catch {
+      callbacks.onPluginStatus(name, "error");
+    }
+  }));
+  const allActions = await loadCachedPlugins(kadaiDir, plugins);
+  callbacks.onUpdate(allActions);
+}
+async function loadPathPlugin(kadaiDir, source) {
+  const pluginRoot = isAbsolute(source.path) ? source.path : resolve(kadaiDir, source.path);
+  const actionsDir = join6(pluginRoot, "actions");
+  if (!existsSync(actionsDir))
+    return [];
+  const name = source.path;
+  const origin = { type: "plugin", pluginName: name };
+  const actions = await loadActions(actionsDir, origin);
+  for (const action of actions) {
+    action.category = [name, ...action.category];
+    action.id = `${name}/${action.id}`;
+  }
+  return actions;
+}
+async function loadUserGlobalActions() {
+  const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  if (!homeDir)
+    return [];
+  const actionsDir = join6(homeDir, ".kadai", "actions");
+  if (!existsSync(actionsDir))
+    return [];
+  const origin = { type: "plugin", pluginName: "~" };
+  const actions = await loadActions(actionsDir, origin);
+  for (const action of actions) {
+    action.category = ["~", ...action.category];
+    action.id = `~/${action.id}`;
+  }
+  return actions;
+}
+var init_plugins = __esm(() => {
+  init_github();
+  init_npm();
+  init_loader();
+  init_pm();
+});
+
+// src/core/runner.ts
+var exports_runner = {};
+__export(exports_runner, {
+  resolveCommand: () => resolveCommand,
+  parseShebangCommand: () => parseShebangCommand
+});
 function parseShebangCommand(shebang, filePath) {
   if (!shebang || !shebang.startsWith("#!"))
     return null;
@@ -326,9 +703,9 @@ function resolveCommand(action) {
     return chainCmd;
   return FALLBACK_COMMANDS[action.runtime](action.filePath);
 }
-var whichCache, RUNTIME_CHAINS, FALLBACK_COMMANDS;
+var RUNTIME_CHAINS, FALLBACK_COMMANDS;
 var init_runner = __esm(() => {
-  whichCache = new Map;
+  init_which();
   RUNTIME_CHAINS = {
     python: [["uv", "run"], ["python3"], ["python"]],
     bash: [["bash"]],
@@ -347,6 +724,198 @@ var init_runner = __esm(() => {
   };
 });
 
+// src/core/commands.ts
+var exports_commands = {};
+__export(exports_commands, {
+  handleSync: () => handleSync,
+  handleRun: () => handleRun,
+  handleList: () => handleList
+});
+import { join as join7 } from "path";
+async function handleList(options) {
+  const { kadaiDir, all } = options;
+  const config = await loadConfig(kadaiDir);
+  const actionsDir = join7(kadaiDir, config.actionsDir ?? "actions");
+  let actions = await loadActions(actionsDir);
+  const globalActions = await loadUserGlobalActions();
+  actions = [...actions, ...globalActions];
+  if (config.plugins) {
+    for (const source of config.plugins) {
+      if ("path" in source) {
+        const pathActions = await loadPathPlugin(kadaiDir, source);
+        actions = [...actions, ...pathActions];
+      }
+    }
+    const cachedActions = await loadCachedPlugins(kadaiDir, config.plugins);
+    actions = [...actions, ...cachedActions];
+  }
+  const filtered = all ? actions : actions.filter((a) => !a.meta.hidden);
+  const output = filtered.map((a) => ({
+    id: a.id,
+    name: a.meta.name,
+    emoji: a.meta.emoji,
+    description: a.meta.description,
+    category: a.category,
+    runtime: a.runtime,
+    confirm: a.meta.confirm ?? false,
+    fullscreen: a.meta.fullscreen ?? false,
+    origin: a.origin
+  }));
+  process.stdout.write(`${JSON.stringify(output, null, 2)}
+`);
+  process.exit(0);
+}
+async function handleRun(options) {
+  const { kadaiDir, actionId, cwd } = options;
+  const config = await loadConfig(kadaiDir);
+  const actionsDir = join7(kadaiDir, config.actionsDir ?? "actions");
+  let actions = await loadActions(actionsDir);
+  const globalActions = await loadUserGlobalActions();
+  actions = [...actions, ...globalActions];
+  if (config.plugins) {
+    for (const source of config.plugins) {
+      if ("path" in source) {
+        const pathActions = await loadPathPlugin(kadaiDir, source);
+        actions = [...actions, ...pathActions];
+      }
+    }
+    const cachedActions = await loadCachedPlugins(kadaiDir, config.plugins);
+    actions = [...actions, ...cachedActions];
+  }
+  const action = actions.find((a) => a.id === actionId);
+  if (!action) {
+    process.stderr.write(`Error: action "${actionId}" not found
+`);
+    process.exit(1);
+  }
+  if (action.runtime === "ink") {
+    const mod = await import(action.filePath);
+    if (typeof mod.default !== "function") {
+      process.stderr.write(`Error: "${action.filePath}" does not export a default function component
+`);
+      process.exit(1);
+    }
+    const cleanupFullscreen = action.meta.fullscreen ? enterFullscreen() : undefined;
+    const React = await import("react");
+    const { render } = await import("ink");
+    const instance = render(React.createElement(mod.default, {
+      cwd,
+      env: config.env ?? {},
+      args: [],
+      onExit: () => instance.unmount()
+    }));
+    await instance.waitUntilExit();
+    cleanupFullscreen?.();
+    process.exit(0);
+  }
+  const cmd = resolveCommand(action);
+  const env = {
+    ...process.env,
+    ...config.env ?? {}
+  };
+  process.stdin.removeAllListeners();
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(false);
+  }
+  process.stdin.pause();
+  process.stdin.unref();
+  const proc = Bun.spawn(cmd, {
+    cwd,
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+    env
+  });
+  const exitCode = await proc.exited;
+  process.exit(exitCode);
+}
+async function handleSync(options) {
+  const { kadaiDir } = options;
+  const config = await loadConfig(kadaiDir);
+  if (!config.plugins || config.plugins.length === 0) {
+    process.stdout.write(`No plugins configured.
+`);
+    process.exit(0);
+  }
+  process.stdout.write(`Syncing plugins...
+`);
+  const results = [];
+  await syncPlugins(kadaiDir, config.plugins, {
+    onPluginStatus: (name, status) => {
+      if (status === "syncing") {
+        process.stdout.write(`  \u27F3 ${name}
+`);
+      } else if (status === "done") {
+        results.push({ name, status: "done" });
+      } else if (status === "error") {
+        results.push({ name, status: "error" });
+      }
+    },
+    onUpdate: () => {}
+  });
+  process.stdout.write(`
+`);
+  for (const r of results) {
+    const icon = r.status === "done" ? "\u2713" : "\u2717";
+    process.stdout.write(`  ${icon} ${r.name}
+`);
+  }
+  const failed = results.filter((r) => r.status === "error").length;
+  if (failed > 0) {
+    process.stdout.write(`
+${failed} plugin(s) failed to sync.
+`);
+    process.exit(1);
+  }
+  process.stdout.write(`
+All plugins synced.
+`);
+  process.exit(0);
+}
+var init_commands = __esm(() => {
+  init_config();
+  init_loader();
+  init_plugins();
+  init_runner();
+});
+
+// package.json
+var require_package = __commonJS((exports, module) => {
+  module.exports = {
+    name: "kadai",
+    version: "0.5.0",
+    type: "module",
+    bin: {
+      kadai: "./dist/cli.js"
+    },
+    scripts: {
+      build: "bun build.ts",
+      check: "tsc --noEmit && biome check ./src ./test",
+      lint: "biome check ./src ./test",
+      "lint:fix": "biome check --write ./src ./test"
+    },
+    files: [
+      "dist/"
+    ],
+    devDependencies: {
+      "@biomejs/biome": "^2.3.14",
+      "@types/bun": "latest",
+      "ink-testing-library": "^4.0.0"
+    },
+    peerDependencies: {
+      typescript: "^5"
+    },
+    dependencies: {
+      "@inkjs/ui": "^2.0.0",
+      "@modelcontextprotocol/sdk": "^1.12.1",
+      "@types/react": "^19.2.14",
+      fuzzysort: "^3.1.0",
+      ink: "^6.7.0",
+      react: "^19.2.4"
+    }
+  };
+});
+
 // src/core/mcp.ts
 var exports_mcp = {};
 __export(exports_mcp, {
@@ -355,13 +924,13 @@ __export(exports_mcp, {
   ensureMcpConfig: () => ensureMcpConfig,
   actionIdToToolName: () => actionIdToToolName
 });
-import { join as join4, resolve } from "path";
+import { join as join8, resolve as resolve2 } 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: "bun", args: [resolve2(script), "mcp"] };
   }
   return { command: "bunx", args: ["kadai", "mcp"] };
 }
@@ -382,7 +951,7 @@ function buildToolDescription(action) {
   return parts.join(" ");
 }
 async function ensureMcpConfig(projectRoot) {
-  const mcpJsonPath = join4(projectRoot, ".mcp.json");
+  const mcpJsonPath = join8(projectRoot, ".mcp.json");
   const mcpFile = Bun.file(mcpJsonPath);
   const kadaiEntry = resolveInvocationCommand();
   if (await mcpFile.exists()) {
@@ -415,8 +984,21 @@ async function startMcpServer(kadaiDir, cwd) {
   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 actionsDir = join8(kadaiDir, config.actionsDir ?? "actions");
+    let allActions = await loadActions(actionsDir);
+    const globalActions = await loadUserGlobalActions();
+    allActions = [...allActions, ...globalActions];
+    if (config.plugins) {
+      for (const source of config.plugins) {
+        if ("path" in source) {
+          const pathActions = await loadPathPlugin(kadaiDir, source);
+          allActions = [...allActions, ...pathActions];
+        }
+      }
+      const cachedActions = await loadCachedPlugins(kadaiDir, config.plugins);
+      allActions = [...allActions, ...cachedActions];
+    }
+    visibleActions = allActions.filter((a) => !a.meta.hidden);
   }
   const server = new McpServer({ name: "kadai", version: "0.3.0" });
   const env = {
@@ -465,6 +1047,7 @@ ${stderr}`);
 var init_mcp = __esm(() => {
   init_config();
   init_loader();
+  init_plugins();
   init_runner();
 });
 
@@ -629,29 +1212,70 @@ function StatusBar() {
 var init_StatusBar = () => {};
 
 // src/hooks/useActions.ts
-import { join as join5 } from "path";
+import { join as join9 } from "path";
 import { useEffect as useEffect2, useRef, useState as useState2 } from "react";
 function useActions({ kadaiDir }) {
   const [actions, setActions] = useState2([]);
   const [config, setConfig] = useState2({});
   const [loading, setLoading] = useState2(true);
+  const [pluginSyncStatuses, setPluginSyncStatuses] = useState2(new Map);
   const actionsRef = useRef(actions);
   actionsRef.current = actions;
   useEffect2(() => {
     (async () => {
       const cfg = await loadConfig(kadaiDir);
       setConfig(cfg);
-      const actionsDir = join5(kadaiDir, cfg.actionsDir ?? "actions");
+      const actionsDir = join9(kadaiDir, cfg.actionsDir ?? "actions");
       const localActions = await loadActions(actionsDir);
-      setActions(localActions);
+      let allActions = [...localActions];
+      const globalActions = await loadUserGlobalActions();
+      allActions = [...allActions, ...globalActions];
+      if (cfg.plugins) {
+        for (const source of cfg.plugins) {
+          if ("path" in source) {
+            const pathActions = await loadPathPlugin(kadaiDir, source);
+            allActions = [...allActions, ...pathActions];
+          }
+        }
+      }
+      if (cfg.plugins) {
+        const cachedActions = await loadCachedPlugins(kadaiDir, cfg.plugins);
+        allActions = [...allActions, ...cachedActions];
+      }
+      setActions(allActions);
       setLoading(false);
+      if (cfg.plugins && cfg.plugins.length > 0) {
+        const initialStatuses = new Map;
+        for (const source of cfg.plugins) {
+          if (!("path" in source)) {
+            initialStatuses.set(pluginDisplayName(source), "syncing");
+          }
+        }
+        setPluginSyncStatuses(initialStatuses);
+        syncPlugins(kadaiDir, cfg.plugins, {
+          onPluginStatus: (name, status) => {
+            setPluginSyncStatuses((prev) => {
+              const next = new Map(prev);
+              next.set(name, status);
+              return next;
+            });
+          },
+          onUpdate: (freshPluginActions) => {
+            setActions((prev) => {
+              const nonCached = prev.filter((a) => a.origin.type === "local" || a.origin.type === "plugin" && (a.origin.pluginName === "~" || cfg.plugins?.some((p) => ("path" in p) && p.path === a.origin.pluginName)));
+              return [...nonCached, ...freshPluginActions];
+            });
+          }
+        });
+      }
     })();
   }, [kadaiDir]);
-  return { actions, actionsRef, config, loading };
+  return { actions, actionsRef, config, loading, pluginSyncStatuses };
 }
 var init_useActions = __esm(() => {
   init_config();
   init_loader();
+  init_plugins();
 });
 
 // src/hooks/useKeyboard.ts
@@ -1625,7 +2249,8 @@ import { Box as Box4, Text as Text4, useApp } from "ink";
 import { jsxDEV as jsxDEV5, Fragment as Fragment2 } from "react/jsx-dev-runtime";
 function MenuList({
   items,
-  selectedIndex
+  selectedIndex,
+  pluginSyncStatuses
 }) {
   const hasAnyNew = items.some((item) => item.isNew);
   return /* @__PURE__ */ jsxDEV5(Fragment2, {
@@ -1653,12 +2278,16 @@ function MenuList({
           /* @__PURE__ */ jsxDEV5(Text4, {
             color: selected ? "cyan" : undefined,
             children: [
-              item.type === "category" ? "\uD83D\uDCC1 " : "",
+              item.type === "category" ? item.isPlugin ? "\uD83D\uDCE6 " : "\uD83D\uDCC1 " : "",
               item.type === "action" && item.emoji ? `${item.emoji} ` : "",
               item.label,
               item.type === "category" ? " \u25B8" : ""
             ]
           }, undefined, true, undefined, this),
+          item.type === "category" && item.isPlugin && pluginSyncStatuses?.get(item.value) === "syncing" && /* @__PURE__ */ jsxDEV5(Text4, {
+            dimColor: true,
+            children: " \u27F3"
+          }, undefined, false, undefined, this),
           item.description && /* @__PURE__ */ jsxDEV5(Text4, {
             dimColor: true,
             children: [
@@ -1680,7 +2309,7 @@ function App({ kadaiDir, onRunAction }) {
   };
   const search = useSearch();
   const nav = useNavigation({ onExit: exit, onNavigate: search.resetSearch });
-  const { actions, actionsRef, config, loading } = useActions({
+  const { actions, actionsRef, config, loading, pluginSyncStatuses } = useActions({
     kadaiDir
   });
   useKeyboard({
@@ -1744,7 +2373,8 @@ function App({ kadaiDir, onRunAction }) {
           children: "No matching items"
         }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV5(MenuList, {
           items: filteredItems,
-          selectedIndex: search.selectedIndex
+          selectedIndex: search.selectedIndex,
+          pluginSyncStatuses
         }, undefined, false, undefined, this),
         /* @__PURE__ */ jsxDEV5(StatusBar, {}, undefined, false, undefined, this)
       ]
@@ -1824,6 +2454,12 @@ function buildMenuItems(actions, path) {
   const categories = new Set;
   const items = [];
   const newActionIds = new Set;
+  const pluginCategories = new Set;
+  for (const action of actions) {
+    if (action.origin.type === "plugin" && action.category.length > 0) {
+      pluginCategories.add(action.category[0]);
+    }
+  }
   for (const action of actions) {
     if (isRecentlyAdded(action)) {
       newActionIds.add(action.id);
@@ -1838,7 +2474,8 @@ function buildMenuItems(actions, path) {
           items.push({
             type: "category",
             label: topCategory,
-            value: topCategory
+            value: topCategory,
+            isPlugin: pluginCategories.has(topCategory)
           });
         }
       } else {
@@ -1882,6 +2519,18 @@ function buildMenuItems(actions, path) {
   items.sort((a, b) => {
     if (a.type !== b.type)
       return a.type === "category" ? -1 : 1;
+    if (a.type === "category" && b.type === "category") {
+      const aPlugin = a.isPlugin ?? false;
+      const bPlugin = b.isPlugin ?? false;
+      if (aPlugin !== bPlugin)
+        return aPlugin ? -1 : 1;
+      if (aPlugin && bPlugin) {
+        if (a.value === "~")
+          return -1;
+        if (b.value === "~")
+          return 1;
+      }
+    }
     return a.label.localeCompare(b.label);
   });
   return items;
@@ -1905,8 +2554,8 @@ __export(exports_init_wizard, {
   writeInitFiles: () => writeInitFiles,
   generateConfigFile: () => generateConfigFile
 });
-import { existsSync, mkdirSync } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync2, mkdirSync } from "fs";
+import { join as join10 } from "path";
 function generateConfigFile() {
   const lines = ['  // actionsDir: "actions",', "  // env: {},"];
   return `export default {
@@ -1916,10 +2565,10 @@ ${lines.join(`
 `;
 }
 async function writeInitFiles(cwd) {
-  const kadaiDir = join6(cwd, ".kadai");
-  const actionsDir = join6(kadaiDir, "actions");
+  const kadaiDir = join10(cwd, ".kadai");
+  const actionsDir = join10(kadaiDir, "actions");
   mkdirSync(actionsDir, { recursive: true });
-  const sampleAction = join6(actionsDir, "hello.sh");
+  const sampleAction = join10(actionsDir, "hello.sh");
   const sampleFile = Bun.file(sampleAction);
   let sampleCreated = false;
   if (!await sampleFile.exists()) {
@@ -1934,14 +2583,14 @@ echo "Add your own scripts to .kadai/actions/ to get started."
     sampleCreated = true;
   }
   const configContent = generateConfigFile();
-  const configPath = join6(kadaiDir, "config.ts");
+  const configPath = join10(kadaiDir, "config.ts");
   await Bun.write(configPath, configContent);
   let skillCreated = false;
-  const hasClaudeDir = existsSync(join6(cwd, ".claude"));
-  const hasClaudeMd = existsSync(join6(cwd, "CLAUDE.md"));
+  const hasClaudeDir = existsSync2(join10(cwd, ".claude"));
+  const hasClaudeMd = existsSync2(join10(cwd, "CLAUDE.md"));
   if (hasClaudeDir || hasClaudeMd) {
-    const skillDir = join6(cwd, ".claude", "skills", "kadai");
-    const skillPath = join6(skillDir, "SKILL.md");
+    const skillDir = join10(cwd, ".claude", "skills", "kadai");
+    const skillPath = join10(skillDir, "SKILL.md");
     if (!await Bun.file(skillPath).exists()) {
       mkdirSync(skillDir, { recursive: true });
       await Bun.write(skillPath, generateSkillFile());
@@ -2053,6 +2702,9 @@ function parseArgs(argv) {
     return { type: "interactive" };
   }
   const command = argv[0];
+  if (command === "--version" || command === "-v") {
+    return { type: "version" };
+  }
   switch (command) {
     case "list": {
       if (!argv.includes("--json")) {
@@ -2073,87 +2725,18 @@ function parseArgs(argv) {
     }
     case "mcp":
       return { type: "mcp" };
+    case "sync":
+      return { type: "sync" };
     default:
       return {
         type: "error",
-        message: `Unknown command: ${command}. Available commands: list, run, mcp`
+        message: `Unknown command: ${command}. Available commands: list, run, sync, mcp, --version`
       };
   }
 }
 
-// src/core/commands.ts
-init_config();
-init_loader();
-init_runner();
-import { join as join3 } from "path";
-async function handleList(options) {
-  const { kadaiDir, all } = options;
-  const config = await loadConfig(kadaiDir);
-  const actionsDir = join3(kadaiDir, config.actionsDir ?? "actions");
-  const actions = await loadActions(actionsDir);
-  const filtered = all ? actions : actions.filter((a) => !a.meta.hidden);
-  const output = filtered.map((a) => ({
-    id: a.id,
-    name: a.meta.name,
-    emoji: a.meta.emoji,
-    description: a.meta.description,
-    category: a.category,
-    runtime: a.runtime,
-    confirm: a.meta.confirm ?? false,
-    fullscreen: a.meta.fullscreen ?? false
-  }));
-  process.stdout.write(`${JSON.stringify(output, null, 2)}
-`);
-  process.exit(0);
-}
-async function handleRun(options) {
-  const { kadaiDir, actionId, cwd } = options;
-  const config = await loadConfig(kadaiDir);
-  const actionsDir = join3(kadaiDir, config.actionsDir ?? "actions");
-  const actions = await loadActions(actionsDir);
-  const action = actions.find((a) => a.id === actionId);
-  if (!action) {
-    process.stderr.write(`Error: action "${actionId}" not found
-`);
-    process.exit(1);
-  }
-  if (action.runtime === "ink") {
-    const mod = await import(action.filePath);
-    if (typeof mod.default !== "function") {
-      process.stderr.write(`Error: "${action.filePath}" does not export a default function component
-`);
-      process.exit(1);
-    }
-    const cleanupFullscreen = action.meta.fullscreen ? enterFullscreen() : undefined;
-    const React = await import("react");
-    const { render } = await import("ink");
-    const instance = render(React.createElement(mod.default, {
-      cwd,
-      env: config.env ?? {},
-      args: [],
-      onExit: () => instance.unmount()
-    }));
-    await instance.waitUntilExit();
-    cleanupFullscreen?.();
-    process.exit(0);
-  }
-  const cmd = resolveCommand(action);
-  const env = {
-    ...process.env,
-    ...config.env ?? {}
-  };
-  const proc = Bun.spawn(cmd, {
-    cwd,
-    stdout: "inherit",
-    stderr: "inherit",
-    stdin: "inherit",
-    env
-  });
-  const exitCode = await proc.exited;
-  process.exit(exitCode);
-}
-
 // src/cli.tsx
+init_commands();
 init_loader();
 var cwd = process.cwd();
 var parsed = parseArgs(process.argv.slice(2));
@@ -2162,6 +2745,11 @@ if (parsed.type === "error") {
 `);
   process.exit(1);
 }
+if (parsed.type === "version") {
+  const { version } = await Promise.resolve().then(() => __toESM(require_package(), 1));
+  console.log(version);
+  process.exit(0);
+}
 if (parsed.type === "mcp") {
   const { ensureMcpConfig: ensureMcpConfig2, startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_mcp(), exports_mcp));
   const kadaiDir = findZcliDir(cwd);
@@ -2170,7 +2758,7 @@ if (parsed.type === "mcp") {
   await startMcpServer2(kadaiDir, cwd);
   await new Promise(() => {});
 }
-if (parsed.type === "list" || parsed.type === "run") {
+if (parsed.type === "list" || parsed.type === "run" || parsed.type === "sync") {
   const kadaiDir = findZcliDir(cwd);
   if (!kadaiDir) {
     process.stderr.write(`Error: No .kadai directory found. Run kadai to initialize.
@@ -2179,8 +2767,11 @@ if (parsed.type === "list" || parsed.type === "run") {
   }
   if (parsed.type === "list") {
     await handleList({ kadaiDir, all: parsed.all });
-  } else {
+  } else if (parsed.type === "run") {
     await handleRun({ kadaiDir, actionId: parsed.actionId, cwd });
+  } else {
+    const { handleSync: handleSync2 } = await Promise.resolve().then(() => (init_commands(), exports_commands));
+    await handleSync2({ kadaiDir });
   }
 }
 var { Readable } = await import("stream");
@@ -2299,22 +2890,18 @@ var env = {
 console.log(`${action.meta.emoji ? `${action.meta.emoji} ` : ""}${action.meta.name}
 `);
 process.stdin.removeAllListeners("data");
+process.stdin.removeAllListeners("end");
+if (process.stdin.isTTY) {
+  process.stdin.setRawMode(false);
+}
+process.stdin.pause();
+process.stdin.unref();
 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.4.0",
+  "version": "0.5.0",
   "type": "module",
   "bin": {
     "kadai": "./dist/cli.js"