@dojocho/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,1020 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import {
+  CLI,
+  DOJOS_DIR,
+  ManifestValidationError,
+  validateManifest,
+  parseManifest,
+  defineConfig,
+  resolveConfig,
+  loadConfig,
+  validateDojoRc,
+  findProjectRoot,
+  readDojoRc,
+  writeDojoRc,
+  readCatalog,
+  dojoDir,
+  readDojoMd,
+  katasPath,
+  resolveKata,
+  resolveAllKatas,
+  listDojos
+} from "@dojocho/config";
+
+// src/commands/root.ts
+import { existsSync as existsSync2, lstatSync, mkdirSync, unlinkSync, writeFileSync } from "fs";
+import { execSync } from "child_process";
+import { resolve, relative } from "path";
+
+// src/state.ts
+import { existsSync } from "fs";
+function kataState(kata2, progress) {
+  if (progress?.completed.includes(kata2.name)) return "completed";
+  return existsSync(kata2.workspacePath) ? "ongoing" : "not-started";
+}
+function findCurrentKata(katas, current) {
+  if (current) {
+    const found = katas.find((k) => k.name === current);
+    if (found && existsSync(found.workspacePath)) return found;
+  }
+  return katas.find((k) => existsSync(k.workspacePath)) ?? null;
+}
+function findNextKata(katas, progress) {
+  return katas.find((k) => {
+    if (progress?.completed.includes(k.name)) return false;
+    return !existsSync(k.workspacePath);
+  }) ?? null;
+}
+function completedCount(katas, progress) {
+  if (progress) {
+    return katas.filter((k) => progress.completed.includes(k.name)).length;
+  }
+  return 0;
+}
+function findKataByIdOrName(katas, query) {
+  const byName = katas.find((k) => k.name === query);
+  if (byName) return byName;
+  const padded = query.padStart(3, "0");
+  return katas.find((k) => k.name.startsWith(padded + "-")) ?? null;
+}
+
+// src/commands/root.ts
+var USAGE = `Usage: ${CLI} <command> [flags]
+
+Commands:
+  (none)              Project-level actions (use flags below)
+  kata                Kata-level actions (sensei, check, scaffold)
+  add <source>        Add a dojo (training pack)
+  remove <name>       Remove a dojo
+
+Flags:
+  --start             Initialize a new dojo project
+  --test/--check      Show overall progress
+  --list              List installed dojos
+  --open              Print the active DOJO.md
+  --change <dojo>     Switch active dojo`;
+var ROOT_DOJO_MD = `# Welcome to Dojocho
+
+Your dojo is set up and ready. You just need a dojo (training pack) to start practicing.
+
+## Add a dojo
+
+\`\`\`bash
+dojo add <source>
+\`\`\`
+
+Source can be:
+- A local path: \`dojo add ./path/to/dojo\`
+- A git repo: \`dojo add org/repo\`
+- Official dojos: \`dojo add effect-ts\`
+
+## Start practicing
+
+Once a dojo is added, use \`/kata\` in your coding agent to begin.
+`;
+var DOJO_CONFIG = `import { defineConfig } from "@dojocho/config"
+
+export default defineConfig()
+`;
+var CLAUDE_SETTINGS = {
+  permissions: {
+    allow: [
+      "Bash(dojo *)",
+      "Bash(dojo)",
+      "AskUserQuestion"
+    ],
+    deny: [
+      "Read(.dojos/**)",
+      "Glob(.dojos/**)",
+      "Grep(.dojos/**)"
+    ]
+  }
+};
+var DEFAULT_KATA_MD = `!\`dojo kata\`
+`;
+var DEFAULT_RC = {
+  currentDojo: "",
+  currentKata: null,
+  editor: "code",
+  progress: {}
+};
+function root(rootDir, args2) {
+  const flag = args2.find((a) => a.startsWith("--"));
+  if (!flag) {
+    console.log(USAGE);
+    return;
+  }
+  switch (flag) {
+    case "--start":
+      start(rootDir);
+      break;
+    case "--check":
+    case "--test":
+      check(rootDir);
+      break;
+    case "--list":
+      list(rootDir);
+      break;
+    case "--open":
+      open(rootDir);
+      break;
+    case "--change": {
+      const name = args2[args2.indexOf("--change") + 1];
+      if (!name) throw new Error("Usage: dojo --change <dojo>");
+      change(rootDir, name);
+      break;
+    }
+    case "--help":
+    case "-h":
+      console.log(USAGE);
+      break;
+    default:
+      throw new Error(`Unknown flag: ${flag}
+
+${USAGE}`);
+  }
+}
+function start(root2) {
+  const rcPath = resolve(root2, ".dojorc");
+  if (!existsSync2(rcPath)) {
+    writeDojoRc(root2, DEFAULT_RC);
+  }
+  mkdirSync(resolve(root2, DOJOS_DIR), { recursive: true });
+  const dojoMdPath = resolve(root2, DOJOS_DIR, "DOJO.md");
+  if (!existsSync2(dojoMdPath)) {
+    writeFileSync(dojoMdPath, ROOT_DOJO_MD);
+  }
+  const configPath = resolve(root2, "dojo.config.ts");
+  if (!existsSync2(configPath)) {
+    writeFileSync(configPath, DOJO_CONFIG);
+  }
+  const tsconfigPath = resolve(root2, "tsconfig.json");
+  if (!existsSync2(tsconfigPath)) {
+    writeFileSync(
+      tsconfigPath,
+      JSON.stringify(
+        {
+          compilerOptions: {
+            target: "ES2022",
+            module: "ES2022",
+            moduleResolution: "bundler",
+            strict: true,
+            noEmit: true
+          },
+          include: ["katas/**/*.ts"]
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  }
+  const pkgPath = resolve(root2, "package.json");
+  if (!existsSync2(pkgPath)) {
+    writeFileSync(
+      pkgPath,
+      JSON.stringify({ type: "module", private: true }, null, 2) + "\n"
+    );
+  }
+  console.log("Installing @dojocho/config...");
+  try {
+    execSync("pnpm add @dojocho/config", { cwd: root2, stdio: "pipe" });
+  } catch {
+    console.log(
+      "  Could not install @dojocho/config from registry.\n  If not yet published, link it manually:\n    pnpm link <path-to-dojocho>/packages/config"
+    );
+  }
+  const agentDirs = [".claude", ".opencode", ".codex"];
+  for (const dir of agentDirs) {
+    mkdirSync(resolve(root2, dir, "commands"), { recursive: true });
+    mkdirSync(resolve(root2, dir, "skills"), { recursive: true });
+    const kataMd = resolve(root2, dir, "commands", "kata.md");
+    try {
+      if (lstatSync(kataMd).isSymbolicLink()) unlinkSync(kataMd);
+    } catch {
+    }
+    if (!existsSync2(kataMd)) {
+      writeFileSync(kataMd, DEFAULT_KATA_MD);
+    }
+    if (dir === ".claude") {
+      const settingsPath = resolve(root2, dir, "settings.json");
+      writeFileSync(settingsPath, JSON.stringify(CLAUDE_SETTINGS, null, 2) + "\n");
+    }
+  }
+  console.log(`Dojo ready.
+
+  Add a dojo with: dojo add <source>
+  Then use:        /kata`);
+}
+function check(root2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const progress = rc.progress?.[rc.currentDojo];
+  const current = findCurrentKata(katas, rc.currentKata);
+  const completed = completedCount(katas, progress);
+  const total = katas.length;
+  if (!current) {
+    const next = findNextKata(katas, progress);
+    if (next) {
+      console.log(`${completed}/${total} katas complete. No kata in progress.
+
+Invoke AskUserQuestion (or similar tool) to ask the student:
+- "Start next kata" (Begin the next kata in sequence) \u2192 run: ${CLI} kata --start
+- "Pick a kata" (Browse and choose a specific kata) \u2192 run: ${CLI} kata --list`);
+    } else {
+      console.log(`All ${total} katas complete. The dojo is finished.`);
+    }
+    return;
+  }
+  const workspaceRel = relative(root2, current.workspacePath);
+  console.log(`Kata: ${current.name} (in progress)
+${completed}/${total} complete | Workspace: ${workspaceRel}
+
+Invoke AskUserQuestion (or similar tool) to ask the student:
+- "Check progress" \u2192 run: ${CLI} kata --check
+- "Keep working" \u2192 encourage them
+- "Switch kata" \u2192 run: ${CLI} kata --list`);
+}
+function list(root2) {
+  const rc = readDojoRc(root2);
+  const dojos = listDojos(root2);
+  if (dojos.length === 0) {
+    console.log(`No dojos installed. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  console.log("Dojos:\n");
+  for (const name of dojos) {
+    const marker = name === rc.currentDojo ? "[*]" : "[ ]";
+    console.log(`  ${marker} ${name}`);
+  }
+}
+function open(root2) {
+  const rc = readDojoRc(root2);
+  const md = readDojoMd(root2, rc.currentDojo);
+  if (md) {
+    console.log(md);
+  } else {
+    console.log("No DOJO.md found. Run `dojo --start` first.");
+  }
+}
+function change(root2, name) {
+  const dojos = listDojos(root2);
+  if (!dojos.includes(name)) {
+    throw new Error(`Dojo "${name}" not found. Available: ${dojos.join(", ") || "(none)"}`);
+  }
+  const rc = readDojoRc(root2);
+  rc.currentDojo = name;
+  rc.currentKata = null;
+  writeDojoRc(root2, rc);
+  const dojoTsconfigPath = resolve(root2, DOJOS_DIR, name, "tsconfig.json");
+  if (existsSync2(dojoTsconfigPath)) {
+    const config = loadConfig(root2);
+    const katasInclude = `${relative(root2, config.katasPath)}/**/*.ts`;
+    const tsconfigPath = resolve(root2, "tsconfig.json");
+    const extendsPath = `./${relative(root2, dojoTsconfigPath)}`;
+    writeFileSync(
+      tsconfigPath,
+      JSON.stringify(
+        {
+          extends: extendsPath,
+          compilerOptions: { noEmit: true },
+          include: [katasInclude]
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  }
+  console.log(`Switched to dojo "${name}".`);
+}
+
+// src/commands/kata.ts
+import { existsSync as existsSync3, readFileSync, mkdirSync as mkdirSync2, copyFileSync } from "fs";
+import { execSync as execSync3 } from "child_process";
+import { dirname, resolve as resolve2, relative as relative3 } from "path";
+
+// src/runner.ts
+import { execSync as execSync2 } from "child_process";
+import { relative as relative2 } from "path";
+function parseVitestJson(raw) {
+  const json = JSON.parse(raw);
+  const tests = [];
+  for (const suite of json.testResults) {
+    for (const t of suite.assertionResults) {
+      tests.push({
+        title: t.title,
+        status: t.status === "passed" ? "passed" : "failed",
+        failureMessages: t.failureMessages
+      });
+    }
+  }
+  return {
+    total: json.numTotalTests,
+    passed: json.numPassedTests,
+    failed: json.numFailedTests,
+    tests,
+    error: null
+  };
+}
+var vitestAdapter = {
+  prepareCommand(cmd) {
+    return `${cmd} --reporter=json`;
+  },
+  parseOutput(stdout, _stderr, exitCode) {
+    try {
+      return parseVitestJson(stdout);
+    } catch {
+      if (exitCode !== 0) {
+        return {
+          total: 0,
+          passed: 0,
+          failed: 0,
+          tests: [],
+          error: _stderr || "Test execution failed"
+        };
+      }
+      return { total: 0, passed: 0, failed: 0, tests: [], error: "Failed to parse vitest output" };
+    }
+  }
+};
+var exitCodeAdapter = {
+  prepareCommand(cmd) {
+    return cmd;
+  },
+  parseOutput(stdout, stderr, exitCode) {
+    if (exitCode === 0) {
+      return {
+        total: 1,
+        passed: 1,
+        failed: 0,
+        tests: [{ title: "all tests", status: "passed", failureMessages: [] }],
+        error: null
+      };
+    }
+    return {
+      total: 1,
+      passed: 0,
+      failed: 1,
+      tests: [{ title: "all tests", status: "failed", failureMessages: [stderr || stdout || "Tests failed"] }],
+      error: null
+    };
+  }
+};
+function getAdapter(manifest) {
+  const adapterName = manifest.runner?.adapter ?? "vitest";
+  return adapterName === "exit-code" ? exitCodeAdapter : vitestAdapter;
+}
+function runTests(kata2, catalog, dojoDir2) {
+  const adapter = getAdapter(catalog);
+  const testRelPath = relative2(dojoDir2, kata2.testPath);
+  const testTemplate = kata2.test ?? catalog.test;
+  const testCmd = testTemplate.replace("{template}", testRelPath);
+  const cmd = adapter.prepareCommand(testCmd);
+  try {
+    const output = execSync2(cmd, {
+      cwd: dojoDir2,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 6e4
+    });
+    return adapter.parseOutput(output.toString(), "", 0);
+  } catch (err) {
+    const e = err;
+    const stdout = e.stdout?.toString() ?? "";
+    const stderr = e.stderr?.toString() ?? "";
+    const exitCode = e.status ?? 1;
+    const result = adapter.parseOutput(stdout, stderr, exitCode);
+    if (result.error === null && result.total === 0 && stdout === "" && stderr !== "") {
+      return { total: 0, passed: 0, failed: 0, tests: [], error: stderr || "Test execution failed" };
+    }
+    return result;
+  }
+}
+
+// src/commands/kata.ts
+var USAGE2 = `Usage: ${CLI} kata [flags]
+
+Flags:
+  (none)              Show SENSEI.md for current kata (smart fallback)
+  --start             Scaffold next kata
+  --test/--check      Run tests for current kata
+  --list              List all katas with state
+  --change <name>     Switch to a specific kata + scaffold
+  --open              Open kata in editor`;
+function getProgress(rc) {
+  return rc.progress?.[rc.currentDojo];
+}
+function recordCompletion(rc, kataName) {
+  rc.progress ??= {};
+  rc.progress[rc.currentDojo] ??= { completed: [], lastActive: null };
+  const progress = rc.progress[rc.currentDojo];
+  if (!progress.completed.includes(kataName)) {
+    progress.completed.push(kataName);
+  }
+  progress.lastActive = kataName;
+}
+function kata(root2, args2) {
+  const flag = args2.find((a) => a.startsWith("--"));
+  if (!flag) {
+    smart(root2, args2);
+    return;
+  }
+  switch (flag) {
+    case "--start":
+      start2(root2);
+      break;
+    case "--check":
+    case "--test":
+      check2(root2, args2);
+      break;
+    case "--list":
+      list2(root2);
+      break;
+    case "--change": {
+      const name = args2[args2.indexOf("--change") + 1];
+      if (!name) throw new Error("Usage: dojo kata --change <name>");
+      change2(root2, name);
+      break;
+    }
+    case "--open":
+      open2(root2);
+      break;
+    case "--help":
+    case "-h":
+      console.log(USAGE2);
+      break;
+    default:
+      throw new Error(`Unknown flag: ${flag}
+
+${USAGE2}`);
+  }
+}
+function smart(root2, args2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    const md = readDojoMd(root2, "");
+    if (md) {
+      console.log(md);
+    } else {
+      console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    }
+    return;
+  }
+  let catalog;
+  try {
+    catalog = readCatalog(root2, rc.currentDojo);
+  } catch {
+    const md = readDojoMd(root2, rc.currentDojo);
+    if (md) {
+      console.log(md);
+    } else {
+      console.log(`Dojo "${rc.currentDojo}" has no dojo.json or DOJO.md.`);
+    }
+    return;
+  }
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const progress = getProgress(rc);
+  const query = args2.find((a) => !a.startsWith("--"));
+  const target = query ? findKataByIdOrName(katas, query) : findCurrentKata(katas, rc.currentKata);
+  if (target) {
+    if (existsSync3(target.senseiPath)) {
+      console.log(readFileSync(target.senseiPath, "utf8"));
+    } else {
+      console.log(`No SENSEI.md found for ${target.name}.`);
+    }
+    return;
+  }
+  const next = findNextKata(katas, progress);
+  if (next) {
+    console.log(`No kata in progress.
+
+Invoke AskUserQuestion (or similar tool) to ask the student:
+- "Start next kata" (Begin the next kata in sequence) \u2192 run: ${CLI} kata --start
+- "Pick a kata" (Browse and choose a specific kata) \u2192 run: ${CLI} kata --list`);
+  } else {
+    const md = readDojoMd(root2, rc.currentDojo);
+    if (md) console.log(md);
+    else console.log("All katas complete. The dojo is finished.");
+  }
+}
+function start2(root2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const dojoPath = dojoDir(root2, rc.currentDojo);
+  const progress = getProgress(rc);
+  const target = findNextKata(katas, progress);
+  if (!target) {
+    console.log("All katas are scaffolded. The dojo is complete.");
+    return;
+  }
+  scaffold(root2, rc, dojoPath, target);
+}
+function check2(root2, args2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const dojoPath = dojoDir(root2, rc.currentDojo);
+  const progress = getProgress(rc);
+  const query = args2.find((a) => !a.startsWith("--"));
+  const target = query ? findKataByIdOrName(katas, query) : findCurrentKata(katas, rc.currentKata);
+  if (!target) {
+    const next = findNextKata(katas, progress);
+    if (next) {
+      console.log(`No kata in progress.
+
+Invoke AskUserQuestion (or similar tool) to ask the student:
+- "Start next kata" (Begin the next kata in sequence) \u2192 run: ${CLI} kata --start
+- "Pick a kata" (Browse and choose a specific kata) \u2192 run: ${CLI} kata --list`);
+    } else {
+      console.log(`All ${katas.length} katas complete. The dojo is finished.`);
+    }
+    return;
+  }
+  const result = runTests(target, catalog, dojoPath);
+  const workspaceRel = relative3(root2, target.workspacePath);
+  if (result.error) {
+    throw new Error(`${target.name}: error
+
+${result.error}`);
+  }
+  const lines = result.tests.map(
+    (t) => `  [${t.status === "passed" ? "x" : " "}] ${t.title}`
+  );
+  if (result.passed === result.total && result.total > 0) {
+    recordCompletion(rc, target.name);
+    writeDojoRc(root2, rc);
+    console.log(`${target.name}: ${result.total}/${result.total} \u2014 complete!
+
+${lines.join("\n")}
+
+Invoke AskUserQuestion (or similar tool) to ask the student:
+- "Review" (Get feedback on idiomatic patterns and potential improvements) \u2192 read ${workspaceRel} and run: ${CLI} kata, suggest improvements (Socratic only)
+- "Move on" (Wrap up with key insight, then start next kata) \u2192 run: ${CLI} kata, follow On Completion (insight + bridge), then run: ${CLI} kata --start
+- "Pause" (Take a break, come back anytime) \u2192 give a friendly sign-off and remind them to run /kata when ready to continue`);
+    return;
+  }
+  console.log(`${target.name}: ${result.passed}/${result.total} passing
+
+${lines.join("\n")}
+
+Invoke AskUserQuestion (or similar tool) to ask the student:
+- "Help me" (Get hints based on failing tests) \u2192 run: ${CLI} kata, use the Test Map
+- "Keep working" (Continue on your own) \u2192 encourage them
+- "Pause" (Take a break, come back anytime) \u2192 give a friendly sign-off and remind them to run /kata when ready to continue`);
+}
+function list2(root2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const progress = getProgress(rc);
+  const completed = completedCount(katas, progress);
+  console.log(`Katas (${completed}/${katas.length} complete):
+`);
+  for (const k of katas) {
+    const state = kataState(k, progress);
+    const marker = state === "completed" ? "[x]" : state === "ongoing" ? "[~]" : "[ ]";
+    const current = k.name === rc.currentKata ? "    (current)" : "";
+    console.log(`  ${marker} ${k.name}${current}`);
+  }
+}
+function change2(root2, name) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentDojo) {
+    console.log(`No dojo active. Add one with:
+  ${CLI} add <source>`);
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const dojoPath = dojoDir(root2, rc.currentDojo);
+  const target = findKataByIdOrName(katas, name);
+  if (!target) throw new Error(`Kata not found: ${name}`);
+  if (existsSync3(target.workspacePath)) {
+    rc.currentKata = target.name;
+    writeDojoRc(root2, rc);
+    const workspaceRel = relative3(root2, target.workspacePath);
+    console.log(`Switched to ${target.name}.
+Workspace: ${workspaceRel}
+
+Invoke AskUserQuestion (or similar tool) to ask the student:
+- "Check progress" \u2192 run: ${CLI} kata --check
+- "Keep working" \u2192 encourage them`);
+    return;
+  }
+  scaffold(root2, rc, dojoPath, target);
+}
+function open2(root2) {
+  const rc = readDojoRc(root2);
+  if (!rc.currentKata || !rc.currentDojo) {
+    console.log("No kata in progress.");
+    return;
+  }
+  const catalog = readCatalog(root2, rc.currentDojo);
+  const katas = resolveAllKatas(root2, rc, catalog);
+  const target = findCurrentKata(katas, rc.currentKata);
+  if (!target) {
+    console.log("No kata in progress.");
+    return;
+  }
+  const editor = rc.editor ?? "code";
+  const absPath = target.workspacePath;
+  console.log(`Opening ${target.name}...`);
+  try {
+    execSync3(`${editor} ${absPath}`, { stdio: "inherit" });
+  } catch {
+    console.log(`Could not open with "${editor}". File: ${absPath}`);
+  }
+}
+function scaffold(root2, rc, dojoPath, target) {
+  const templateSrc = resolve2(dojoPath, target.template);
+  if (!existsSync3(templateSrc)) {
+    throw new Error(`Template not found: ${target.template}`);
+  }
+  mkdirSync2(dirname(target.workspacePath), { recursive: true });
+  copyFileSync(templateSrc, target.workspacePath);
+  rc.currentKata = target.name;
+  writeDojoRc(root2, rc);
+  const workspaceRel = relative3(root2, target.workspacePath);
+  const absPath = target.workspacePath;
+  let output = `Kata ${target.name} scaffolded.
+Workspace: ${workspaceRel}`;
+  if (rc.editor) {
+    output += `
+Open command: ${rc.editor} ${absPath}`;
+  }
+  output += `
+
+run: ${CLI} kata
+Present the briefing from SENSEI.
+
+Invoke AskUserQuestion (or similar tool) to ask the student:
+- "Open the file" \u2192 run: ${CLI} kata --open
+- "I have questions" \u2192 answer using SENSEI guidance`;
+  console.log(output);
+}
+
+// src/commands/add.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, cpSync, unlinkSync as unlinkSync3, symlinkSync, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, realpathSync, rmSync as rmSync2 } from "fs";
+import { execSync as execSync4, execFileSync } from "child_process";
+import { resolve as resolve4, basename, relative as relative4 } from "path";
+import { tmpdir } from "os";
+
+// src/commands/remove.ts
+import { existsSync as existsSync4, rmSync, readdirSync, lstatSync as lstatSync2, readlinkSync, unlinkSync as unlinkSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+function remove(root2, args2) {
+  const name = args2.find((a) => !a.startsWith("--"));
+  if (!name) throw new Error("Usage: dojo remove <name>");
+  const dojoPath = resolve3(root2, DOJOS_DIR, name);
+  if (!existsSync4(dojoPath)) {
+    throw new Error(`Dojo "${name}" not found at ${DOJOS_DIR}/${name}`);
+  }
+  rmSync(dojoPath, { recursive: true, force: true });
+  const agentDirs = [".claude", ".opencode", ".codex"];
+  for (const dir of agentDirs) {
+    for (const sub of ["commands", "skills"]) {
+      const subDir = resolve3(root2, dir, sub);
+      if (!existsSync4(subDir)) continue;
+      for (const entry of readdirSync(subDir)) {
+        const link = resolve3(subDir, entry);
+        try {
+          if (!lstatSync2(link).isSymbolicLink()) continue;
+          const target = readlinkSync(link);
+          if (target.includes(`${DOJOS_DIR}/${name}/`) || target.includes(`${DOJOS_DIR}/${name}\\`)) {
+            unlinkSync2(link);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  try {
+    const rc = readDojoRc(root2);
+    if (rc.currentDojo === name) {
+      rc.currentDojo = "";
+      rc.currentKata = null;
+      writeDojoRc(root2, rc);
+    }
+  } catch {
+  }
+  console.log(`Dojo "${name}" removed.`);
+}
+
+// src/commands/add.ts
+async function add(root2, args2) {
+  const source = args2.find((a) => !a.startsWith("--"));
+  const force = args2.includes("--force");
+  if (!source) {
+    throw new Error(`Usage: dojo add <source>
+
+Source can be:
+  Local path:   dojo add ./path/to/dojo
+  npm package:  dojo add @dojocho/effect-ts
+  Registry:     dojo add effect-ts
+  URL:          dojo add https://example.com/dojo.tgz
+
+Flags:
+  --force       Overwrite existing dojo`);
+  }
+  const sourceType = classifySource(source);
+  switch (sourceType) {
+    case "local":
+      addLocal(root2, source, force);
+      break;
+    case "npm":
+      addNpm(root2, source, force);
+      break;
+    case "url":
+      addUrl(root2, source, force);
+      break;
+    case "registry":
+      await addFromRegistry(root2, source, force);
+      break;
+  }
+}
+function classifySource(source) {
+  if (source.startsWith(".") || source.startsWith("/")) return "local";
+  if (source.startsWith("https://") || source.startsWith("http://")) return "url";
+  if (source.startsWith("@") || source.includes("/")) return "npm";
+  return "registry";
+}
+function safeExtract(tarball, cwd) {
+  const listing = execFileSync("tar", ["-tzf", tarball], { cwd, encoding: "utf8" });
+  const unsafe = listing.split("\n").some((e) => e.startsWith("/") || e.includes(".."));
+  if (unsafe) {
+    throw new Error("Refusing to extract: tarball contains unsafe paths (absolute or ../)");
+  }
+  execFileSync("tar", ["xzf", tarball], { cwd, stdio: "pipe" });
+}
+function handleExisting(root2, name, force) {
+  const targetPath = dojoDir(root2, name);
+  if (!existsSync5(targetPath)) return;
+  if (!force) {
+    throw new Error(`Dojo "${name}" already exists at ${DOJOS_DIR}/${name}
+
+To update:  dojo add ${name} --force
+To remove:  dojo remove ${name}`);
+  }
+  remove(root2, [name]);
+}
+function addLocal(root2, source, force) {
+  const sourcePath = resolve4(source);
+  if (!existsSync5(sourcePath)) {
+    throw new Error(`Source not found: ${sourcePath}`);
+  }
+  const name = basename(sourcePath);
+  handleExisting(root2, name, force);
+  const targetPath = dojoDir(root2, name);
+  mkdirSync3(resolve4(root2, DOJOS_DIR), { recursive: true });
+  cpSync(sourcePath, targetPath, {
+    recursive: true,
+    filter: (src) => !src.includes("node_modules")
+  });
+  const pkgPath = resolve4(targetPath, "package.json");
+  if (existsSync5(pkgPath)) {
+    const linked = linkWorkspaceDeps(root2, sourcePath, pkgPath);
+    console.log(`Installing ${name} dependencies...`);
+    execSync4("pnpm install --ignore-workspace --silent", {
+      cwd: targetPath,
+      stdio: "pipe"
+    });
+    for (const pkgDir of linked) {
+      execSync4(`pnpm link ${pkgDir}`, { cwd: targetPath, stdio: "pipe" });
+      execSync4(`pnpm link ${pkgDir}`, { cwd: root2, stdio: "pipe" });
+    }
+  }
+  finalize(root2, name, targetPath);
+}
+function installExtracted(root2, extractedDir, source, force) {
+  const dojoJsonPath = resolve4(extractedDir, "dojo.json");
+  if (!existsSync5(dojoJsonPath)) {
+    throw new Error(`${source} is not a dojo \u2014 missing dojo.json`);
+  }
+  const manifest = parseManifest(readFileSync2(dojoJsonPath, "utf8"), dojoJsonPath);
+  const name = manifest.name.includes("/") ? manifest.name.split("/").pop() : manifest.name;
+  handleExisting(root2, name, force);
+  const targetPath = dojoDir(root2, name);
+  mkdirSync3(resolve4(root2, DOJOS_DIR), { recursive: true });
+  cpSync(extractedDir, targetPath, { recursive: true });
+  const pkgPath = resolve4(targetPath, "package.json");
+  if (existsSync5(pkgPath)) {
+    console.log(`Installing ${name} dependencies...`);
+    execSync4("pnpm install --ignore-workspace --silent", { cwd: targetPath, stdio: "pipe" });
+  }
+  finalize(root2, name, targetPath);
+}
+function addNpm(root2, source, force) {
+  const tmpDir = resolve4(tmpdir(), `dojocho-${Date.now()}`);
+  mkdirSync3(tmpDir, { recursive: true });
+  try {
+    console.log(`Fetching ${source}...`);
+    execSync4(`npm pack ${source} --pack-destination .`, { cwd: tmpDir, stdio: "pipe" });
+    const tarballs = readdirSync2(tmpDir).filter((f) => f.endsWith(".tgz"));
+    if (tarballs.length === 0) throw new Error(`Failed to download ${source}`);
+    safeExtract(tarballs[0], tmpDir);
+    installExtracted(root2, resolve4(tmpDir, "package"), source, force);
+  } finally {
+    rmSync2(tmpDir, { recursive: true, force: true });
+  }
+}
+function validateRegistryItem(data) {
+  if (typeof data !== "object" || data === null) {
+    throw new Error("Invalid registry response: expected a JSON object");
+  }
+  const obj = data;
+  if (typeof obj.name !== "string" || typeof obj.version !== "string" || typeof obj.description !== "string") {
+    throw new Error("Invalid registry item: missing name, version, or description");
+  }
+  if (typeof obj.source !== "object" || obj.source === null) {
+    throw new Error("Invalid registry item: missing source");
+  }
+  const src = obj.source;
+  if (src.type === "npm" && typeof src.package === "string") {
+    return obj;
+  }
+  if (src.type === "tarball" && typeof src.url === "string") {
+    return obj;
+  }
+  throw new Error(`Invalid registry item: source must be npm or tarball`);
+}
+async function addFromRegistry(root2, name, force) {
+  const config = loadConfig(root2, { command: "add" });
+  for (const [registryName, urlTemplate] of Object.entries(config.registries)) {
+    const url = urlTemplate.replace("{name}", name);
+    try {
+      const res = await fetch(url);
+      if (!res.ok) continue;
+      const item = validateRegistryItem(await res.json());
+      if (item.source.type === "npm") {
+        return addNpm(root2, item.source.package, force);
+      }
+      return addUrl(root2, item.source.url, force);
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith("Invalid registry")) throw err;
+      console.log(`Registry "${registryName}" unreachable: ${url}`);
+    }
+  }
+  throw new Error(`"${name}" not found in any registry.
+
+Try:
+  npm package:  dojo add @dojocho/${name}
+  Local path:   dojo add ./path/to/${name}`);
+}
+function addUrl(root2, url, force) {
+  const tmpDir = resolve4(tmpdir(), `dojocho-${Date.now()}`);
+  mkdirSync3(tmpDir, { recursive: true });
+  try {
+    console.log(`Fetching ${url}...`);
+    execFileSync("curl", ["-fsSL", "-o", "dojo.tgz", url], { cwd: tmpDir, stdio: "pipe" });
+    safeExtract("dojo.tgz", tmpDir);
+    const extractedDir = existsSync5(resolve4(tmpDir, "package", "dojo.json")) ? resolve4(tmpDir, "package") : tmpDir;
+    installExtracted(root2, extractedDir, url, force);
+  } finally {
+    rmSync2(tmpDir, { recursive: true, force: true });
+  }
+}
+function finalize(root2, name, targetPath) {
+  const rc = readDojoRc(root2);
+  rc.currentDojo = name;
+  writeDojoRc(root2, rc);
+  const dojoPkgPath = resolve4(targetPath, "package.json");
+  const dojoTsconfigPath = resolve4(targetPath, "tsconfig.json");
+  if (existsSync5(dojoPkgPath) && existsSync5(dojoTsconfigPath)) {
+    const dojoPkg = JSON.parse(readFileSync2(dojoPkgPath, "utf8"));
+    const dojoTsconfig = JSON.parse(readFileSync2(dojoTsconfigPath, "utf8"));
+    const deps = Object.keys(dojoPkg.dependencies ?? {});
+    if (deps.length > 0) {
+      dojoTsconfig.compilerOptions ??= {};
+      const paths = dojoTsconfig.compilerOptions.paths ?? {};
+      for (const dep of deps) {
+        paths[dep] = [`./node_modules/${dep}`];
+        paths[`${dep}/*`] = [`./node_modules/${dep}/*`];
+      }
+      dojoTsconfig.compilerOptions.paths = paths;
+      writeFileSync2(dojoTsconfigPath, JSON.stringify(dojoTsconfig, null, 2) + "\n");
+    }
+  }
+  const dojo = loadConfig(root2);
+  const katasInclude = `${relative4(root2, dojo.katasPath)}/**/*.ts`;
+  const tsconfigPath = resolve4(root2, "tsconfig.json");
+  const extendsPath = `./${relative4(root2, resolve4(targetPath, "tsconfig.json"))}`;
+  writeFileSync2(
+    tsconfigPath,
+    JSON.stringify(
+      {
+        extends: extendsPath,
+        compilerOptions: { noEmit: true },
+        include: [katasInclude]
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  symlinkDojo(root2, targetPath);
+  console.log(`Dojo "${name}" added.
+
+  Location:  ${DOJOS_DIR}/${name}
+  Active:    ${name}
+  Command:   /kata`);
+}
+function linkWorkspaceDeps(root2, sourcePath, pkgPath) {
+  const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+  const linked = [];
+  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+    if (!pkg[field]) continue;
+    for (const [name, version] of Object.entries(pkg[field])) {
+      if (typeof version !== "string" || !version.startsWith("workspace:")) continue;
+      const srcPkg = resolve4(sourcePath, "node_modules", ...name.split("/"));
+      if (existsSync5(srcPkg)) {
+        linked.push(realpathSync(srcPkg));
+      }
+      delete pkg[field][name];
+    }
+    if (Object.keys(pkg[field]).length === 0) delete pkg[field];
+  }
+  writeFileSync2(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  const rootPkgPath = resolve4(root2, "package.json");
+  if (!existsSync5(rootPkgPath)) {
+    writeFileSync2(rootPkgPath, JSON.stringify({ type: "module", private: true }, null, 2) + "\n");
+  }
+  return linked;
+}
+function symlinkDir(sourceDir, targetDir, filter) {
+  if (!existsSync5(sourceDir)) return;
+  mkdirSync3(targetDir, { recursive: true });
+  for (const entry of readdirSync2(sourceDir, { withFileTypes: true })) {
+    if (!filter(entry)) continue;
+    const link = resolve4(targetDir, entry.name);
+    if (existsSync5(link)) unlinkSync3(link);
+    symlinkSync(relative4(targetDir, resolve4(sourceDir, entry.name)), link);
+  }
+}
+function symlinkDojo(root2, dojoPath) {
+  for (const dir of [".claude", ".opencode", ".codex"]) {
+    symlinkDir(resolve4(dojoPath, "commands"), resolve4(root2, dir, "commands"), (e) => e.name.endsWith(".md"));
+    symlinkDir(resolve4(dojoPath, "skills"), resolve4(root2, dir, "skills"), (e) => e.isDirectory());
+  }
+}
+
+// src/index.ts
+var [command, ...args] = process.argv.slice(2);
+async function main() {
+  if (command === "kata") {
+    kata(findProjectRoot(), args);
+  } else if (command === "add") {
+    await add(process.cwd(), args);
+  } else if (command === "remove") {
+    remove(findProjectRoot(), args);
+  } else {
+    root(process.cwd(), [command, ...args].filter(Boolean));
+  }
+}
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@dojocho/cli",
+  "version": "0.0.1",
+  "type": "module",
+  "publishConfig": { "access": "public" },
+  "files": ["dist"],
+  "bin": {
+    "dojo": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup"
+  },
+  "dependencies": {
+    "@dojocho/config": "workspace:*"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  }
+}