@umang-boss/claudemon 1.0.0 → 1.1.0

package/dist/cli/doctor.js

@@ -0,0 +1,280 @@
+/**
+ * Claudemon Doctor — diagnostic tool.
+ * Checks the health of the Claudemon installation.
+ *
+ * Usage: bun run cli/doctor.ts
+ */
+import { access, stat, unlink, readdir, readFile } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+import { StateManager } from "../src/state/state-manager.js";
+import { PlayerStateSchema } from "../src/state/schemas.js";
+import { readJson, info, CLAUDE_CONFIG, CLAUDE_SETTINGS, STATE_DIR, SKILL_DEST, HOOK_SCRIPT, } from "./shared.js";
+// ── Local Constants ─────────────────────────────────────────
+const STATE_FILE = `${STATE_DIR}/state.json`;
+const LOCK_FILE = `${STATE_DIR}/state.lock`;
+const LOCK_MAX_AGE_MS = 5000;
+const EXPECTED_SPRITE_COUNT = 151;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const COLORSCRIPT_DIR = resolve(dirname(__dirname), "sprites/colorscripts/small");
+function formatCheck(result) {
+    const icon = result.passed ? "\u2713" : "\u2717";
+    return `[${icon}] ${result.label}: ${result.detail}`;
+}
+// ── Check 1: Bun Version ─────────────────────────────────────
+async function checkBun() {
+    try {
+        const result = spawnSync("bun", ["--version"], { stdio: "pipe" });
+        if (result.error)
+            throw result.error;
+        const output = result.stdout?.toString().trim();
+        return { label: "Bun runtime", passed: true, detail: `v${output}` };
+    }
+    catch {
+        return { label: "Bun runtime", passed: false, detail: "not found" };
+    }
+}
+// ── Check 2: State Directory ─────────────────────────────────
+async function checkStateDir() {
+    try {
+        await access(STATE_DIR, fsConstants.F_OK);
+        return { label: "State directory", passed: true, detail: "~/.claudemon/" };
+    }
+    catch {
+        return {
+            label: "State directory",
+            passed: false,
+            detail: "~/.claudemon/ not found (run installer)",
+        };
+    }
+}
+// ── Check 3: State File ──────────────────────────────────────
+async function checkStateFile() {
+    try {
+        await access(STATE_FILE, fsConstants.F_OK);
+    }
+    catch {
+        return { label: "State file", passed: false, detail: "not found (run /buddy starter first)" };
+    }
+    try {
+        const text = await readFile(STATE_FILE, "utf-8");
+        const data = JSON.parse(text);
+        // Check for active pokemon
+        const party = data["party"];
+        if (Array.isArray(party) && party.length > 0) {
+            const active = party.find((p) => typeof p === "object" &&
+                p !== null &&
+                "isActive" in p &&
+                p["isActive"] === true);
+            if (active && typeof active === "object" && "pokemonId" in active) {
+                return {
+                    label: "State file",
+                    passed: true,
+                    detail: `valid, active Pokemon #${active["pokemonId"]}`,
+                };
+            }
+            return { label: "State file", passed: true, detail: "valid, but no active Pokemon set" };
+        }
+        return { label: "State file", passed: true, detail: "valid JSON, no party members yet" };
+    }
+    catch {
+        return { label: "State file", passed: false, detail: "exists but invalid JSON" };
+    }
+}
+// ── Check 4: MCP Server Registration ─────────────────────────
+async function checkMcpServer() {
+    const config = await readJson(CLAUDE_CONFIG);
+    if (!config) {
+        return { label: "MCP server", passed: false, detail: "~/.claude.json not found" };
+    }
+    if (config.mcpServers && config.mcpServers["claudemon"]) {
+        return { label: "MCP server", passed: true, detail: "registered in ~/.claude.json" };
+    }
+    return { label: "MCP server", passed: false, detail: "not registered in ~/.claude.json" };
+}
+// ── Check 5: Hooks ───────────────────────────────────────────
+async function checkHooks() {
+    const settings = await readJson(CLAUDE_SETTINGS);
+    if (!settings) {
+        return { label: "Hooks", passed: false, detail: "~/.claude/settings.json not found" };
+    }
+    if (!settings.hooks || !settings.hooks["PostToolUse"]) {
+        return { label: "Hooks", passed: false, detail: "no PostToolUse hooks configured" };
+    }
+    const hasOurHook = settings.hooks["PostToolUse"].some((m) => m.hooks.some((h) => h.command.includes("post-tool-use.sh")));
+    if (hasOurHook) {
+        return { label: "Hooks", passed: true, detail: "PostToolUse configured" };
+    }
+    return { label: "Hooks", passed: false, detail: "PostToolUse exists but missing Claudemon hook" };
+}
+// ── Check 6: Skill ───────────────────────────────────────────
+async function checkSkill() {
+    try {
+        await access(SKILL_DEST, fsConstants.F_OK);
+        return { label: "Skill", passed: true, detail: "/buddy command installed" };
+    }
+    catch {
+        return { label: "Skill", passed: false, detail: "~/.claude/skills/buddy/SKILL.md not found" };
+    }
+}
+// ── Check 7: Hook Script Executable ──────────────────────────
+async function checkHookScript() {
+    try {
+        await access(HOOK_SCRIPT, fsConstants.X_OK);
+        return { label: "Hook script", passed: true, detail: "executable" };
+    }
+    catch {
+        try {
+            await access(HOOK_SCRIPT, fsConstants.F_OK);
+            return {
+                label: "Hook script",
+                passed: false,
+                detail: "exists but not executable (run chmod +x)",
+            };
+        }
+        catch {
+            return { label: "Hook script", passed: false, detail: "not found" };
+        }
+    }
+}
+// ── Check 8: State Manager Load ──────────────────────────────
+async function checkStateManager() {
+    try {
+        StateManager.resetInstance();
+        const manager = StateManager.getInstance();
+        const state = await manager.load();
+        StateManager.resetInstance();
+        if (state) {
+            return { label: "State manager", passed: true, detail: "loaded successfully" };
+        }
+        return { label: "State manager", passed: true, detail: "no state file yet (first run)" };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        StateManager.resetInstance();
+        return { label: "State manager", passed: false, detail: `load failed: ${message}` };
+    }
+}
+// ── Check 9: Stale Lock File ────────────────────────────────
+async function checkStaleLock() {
+    try {
+        const lockStat = await stat(LOCK_FILE);
+        const lockAge = Date.now() - lockStat.mtimeMs;
+        if (lockAge > LOCK_MAX_AGE_MS) {
+            // Offer cleanup
+            info(`Stale lock file found (${Math.round(lockAge / 1000)}s old). Cleaning up...`);
+            try {
+                await unlink(LOCK_FILE);
+                return { label: "Lock file", passed: true, detail: "stale lock cleaned up" };
+            }
+            catch {
+                return { label: "Lock file", passed: false, detail: "stale lock found, cleanup failed" };
+            }
+        }
+        return {
+            label: "Lock file",
+            passed: true,
+            detail: `active (${Math.round(lockAge / 1000)}s old)`,
+        };
+    }
+    catch {
+        // No lock file — this is the normal case
+        return { label: "Lock file", passed: true, detail: "no lock (clean)" };
+    }
+}
+// ── Check 10: Sprite Count ──────────────────────────────────
+async function checkSpriteCount() {
+    try {
+        await access(COLORSCRIPT_DIR, fsConstants.F_OK);
+        const entries = await readdir(COLORSCRIPT_DIR);
+        const spriteFiles = entries.filter((f) => f.endsWith(".txt"));
+        const count = spriteFiles.length;
+        if (count >= EXPECTED_SPRITE_COUNT) {
+            return {
+                label: "Sprites",
+                passed: true,
+                detail: `${count}/${EXPECTED_SPRITE_COUNT} sprite files`,
+            };
+        }
+        return {
+            label: "Sprites",
+            passed: false,
+            detail: `only ${count}/${EXPECTED_SPRITE_COUNT} sprite files (some sprites missing)`,
+        };
+    }
+    catch {
+        return { label: "Sprites", passed: false, detail: "colorscripts directory not found" };
+    }
+}
+// ── Check 11: State File Validity (Zod) ─────────────────────
+async function checkStateValidity() {
+    try {
+        await access(STATE_FILE, fsConstants.F_OK);
+    }
+    catch {
+        return { label: "State validity", passed: true, detail: "no state file yet" };
+    }
+    try {
+        const text = await readFile(STATE_FILE, "utf-8");
+        if (!text.trim()) {
+            return { label: "State validity", passed: false, detail: "state file is empty" };
+        }
+        const data = JSON.parse(text);
+        const result = PlayerStateSchema.safeParse(data);
+        if (result.success) {
+            return { label: "State validity", passed: true, detail: "schema valid" };
+        }
+        // Report first few issues
+        const issues = result.error.issues.slice(0, 3);
+        const details = issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+        return {
+            label: "State validity",
+            passed: false,
+            detail: `schema errors: ${details}`,
+        };
+    }
+    catch {
+        return { label: "State validity", passed: false, detail: "invalid JSON" };
+    }
+}
+// ── Main ─────────────────────────────────────────────────────
+export async function doctor() {
+    console.log("");
+    console.log("Claudemon Doctor");
+    console.log("================");
+    console.log("");
+    const checks = [
+        await checkBun(),
+        await checkStateDir(),
+        await checkStateFile(),
+        await checkMcpServer(),
+        await checkHooks(),
+        await checkSkill(),
+        await checkHookScript(),
+        await checkStateManager(),
+        await checkStaleLock(),
+        await checkSpriteCount(),
+        await checkStateValidity(),
+    ];
+    for (const check of checks) {
+        console.log(formatCheck(check));
+    }
+    const passed = checks.filter((c) => c.passed).length;
+    const total = checks.length;
+    console.log("");
+    console.log(`Result: ${passed}/${total} checks passed`);
+    if (passed < total) {
+        console.log("");
+        console.log("Run 'bun run cli/install.ts' to fix missing components.");
+    }
+    console.log("");
+}
+// Run if executed directly
+doctor().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`\nDoctor failed: ${message}`);
+    process.exit(1);
+});

package/dist/cli/index.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env bun
+/**
+ * Claudemon CLI entry point.
+ * Routes to install, uninstall, update, or doctor based on first argument.
+ *
+ * Usage:
+ *   npx claudemon install
+ *   npx claudemon uninstall
+ *   npx claudemon update
+ *   npx claudemon doctor
+ */
+const command = process.argv[2];
+switch (command) {
+    case "install":
+        await import("./install.js");
+        break;
+    case "uninstall":
+        await import("./uninstall.js");
+        break;
+    case "update":
+        await import("./update.js");
+        break;
+    case "doctor":
+        await import("./doctor.js");
+        break;
+    default:
+        console.log(`
+Claudemon — Pokemon Gen 1 coding companion for Claude Code
+
+Usage:
+  claudemon install     Set up Claudemon (MCP server, hooks, skill, status line)
+  claudemon uninstall   Remove Claudemon from Claude Code
+  claudemon update      Re-register everything (preserves save data)
+  claudemon doctor      Run diagnostics
+
+After install, start a new Claude Code session and type /buddy
+`);
+        break;
+}
+export {};

package/dist/cli/install.js

@@ -0,0 +1,190 @@
+/**
+ * Claudemon CLI Installer.
+ * Registers MCP server, hooks, and skill into Claude Code.
+ *
+ * Usage: bun run cli/install.ts
+ */
+import { mkdir, copyFile, chmod, access } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { ok, fail, readJson, writeJson, CLAUDE_DIR, CLAUDE_CONFIG, CLAUDE_SETTINGS, STATE_DIR, SKILL_SRC, SKILL_DEST_DIR, SKILL_DEST, HOOK_SCRIPT, STOP_HOOK_SCRIPT, USER_PROMPT_HOOK_SCRIPT, STATUSLINE_SCRIPT, getRuntime, } from "./shared.js";
+// ── Step 1: Check Prerequisites ──────────────────────────────
+async function checkPrerequisites() {
+    let allGood = true;
+    // Check bun (sanity)
+    try {
+        const result = spawnSync("bun", ["--version"], { stdio: "pipe" });
+        if (result.error)
+            throw result.error;
+        const output = result.stdout?.toString().trim();
+        ok(`Bun runtime: v${output}`);
+    }
+    catch {
+        fail("Bun runtime not found. Install from https://bun.sh");
+        allGood = false;
+    }
+    // Check Claude Code directory
+    try {
+        await access(CLAUDE_DIR, fsConstants.F_OK);
+        ok("Claude Code directory: ~/.claude/");
+    }
+    catch {
+        fail("Claude Code not found. Install Claude Code first: https://claude.ai/download");
+        console.error("    Expected directory: ~/.claude/");
+        allGood = false;
+    }
+    return allGood;
+}
+// ── Step 2: Create State Directory ───────────────────────────
+async function createStateDirectory() {
+    await mkdir(STATE_DIR, { recursive: true });
+    ok(`State directory: ${STATE_DIR}/`);
+}
+// ── Step 3: Register MCP Server ──────────────────────────────
+async function registerMcpServer() {
+    const existing = await readJson(CLAUDE_CONFIG);
+    const config = existing ?? {};
+    if (!config.mcpServers) {
+        config.mcpServers = {};
+    }
+    config.mcpServers["claudemon"] = {
+        command: getRuntime().command,
+        args: [getRuntime().serverEntry],
+        env: {},
+    };
+    await writeJson(CLAUDE_CONFIG, config);
+    ok("MCP server: registered in ~/.claude.json");
+}
+// ── Step 4: Install Hooks ────────────────────────────────────
+async function installHooks() {
+    const existing = await readJson(CLAUDE_SETTINGS);
+    const settings = existing ?? {};
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    const ourHook = {
+        type: "command",
+        command: HOOK_SCRIPT,
+        timeout: 5000,
+    };
+    const ourMatcher = {
+        matcher: "Bash|Write|Edit|Read|Grep|Glob",
+        hooks: [ourHook],
+    };
+    // Check if PostToolUse already has our matcher
+    const postToolUse = settings.hooks["PostToolUse"];
+    if (postToolUse) {
+        // Remove any existing claudemon matcher (idempotent reinstall)
+        const filtered = postToolUse.filter((m) => !m.hooks.some((h) => h.command.includes("post-tool-use.sh")));
+        filtered.push(ourMatcher);
+        settings.hooks["PostToolUse"] = filtered;
+    }
+    else {
+        settings.hooks["PostToolUse"] = [ourMatcher];
+    }
+    // ── Stop hook (extracts buddy comments from responses) ────
+    const stopHook = {
+        type: "command",
+        command: STOP_HOOK_SCRIPT,
+        timeout: 3000,
+    };
+    const stopEntry = {
+        hooks: [stopHook],
+    };
+    const stopHooks = settings.hooks["Stop"];
+    if (stopHooks) {
+        const filtered = stopHooks.filter((m) => !m.hooks.some((h) => h.command.includes("stop.sh")));
+        filtered.push(stopEntry);
+        settings.hooks["Stop"] = filtered;
+    }
+    else {
+        settings.hooks["Stop"] = [stopEntry];
+    }
+    // ── UserPromptSubmit hook (reacts to Pokemon name mentions) ─
+    const userPromptHook = {
+        type: "command",
+        command: USER_PROMPT_HOOK_SCRIPT,
+        timeout: 3000,
+    };
+    const userPromptEntry = {
+        hooks: [userPromptHook],
+    };
+    const userPromptHooks = settings.hooks["UserPromptSubmit"];
+    if (userPromptHooks) {
+        const filtered = userPromptHooks.filter((m) => !m.hooks.some((h) => h.command.includes("user-prompt-submit.sh")));
+        filtered.push(userPromptEntry);
+        settings.hooks["UserPromptSubmit"] = filtered;
+    }
+    else {
+        settings.hooks["UserPromptSubmit"] = [userPromptEntry];
+    }
+    await writeJson(CLAUDE_SETTINGS, settings);
+    ok("Hooks: PostToolUse, Stop, UserPromptSubmit configured in ~/.claude/settings.json");
+}
+// ── Step 5: Register Status Line ─────────────────────────────
+async function registerStatusLine() {
+    const existing = await readJson(CLAUDE_SETTINGS);
+    const settings = existing ?? {};
+    // Merge status line config without overwriting other settings
+    settings.statusLine = {
+        type: "command",
+        command: STATUSLINE_SCRIPT,
+        refreshInterval: 1,
+    };
+    await writeJson(CLAUDE_SETTINGS, settings);
+    ok("Status line: registered in ~/.claude/settings.json");
+}
+// ── Step 6: Install Skill ─────────────────────────────────────
+async function installSkill() {
+    await mkdir(SKILL_DEST_DIR, { recursive: true });
+    await copyFile(SKILL_SRC, SKILL_DEST);
+    ok("Skill: /buddy command installed to ~/.claude/skills/buddy/");
+}
+// ── Step 7: Set Script Permissions ───────────────────────────
+async function setScriptPermissions() {
+    await chmod(HOOK_SCRIPT, 0o755);
+    ok("Hook script: post-tool-use.sh set executable");
+    await chmod(STOP_HOOK_SCRIPT, 0o755);
+    ok("Hook script: stop.sh set executable");
+    await chmod(USER_PROMPT_HOOK_SCRIPT, 0o755);
+    ok("Hook script: user-prompt-submit.sh set executable");
+    await chmod(STATUSLINE_SCRIPT, 0o755);
+    ok("Status line script: set executable");
+}
+// ── Main ─────────────────────────────────────────────────────
+export async function install() {
+    console.log("");
+    console.log("Claudemon Installer");
+    console.log("===================");
+    console.log("");
+    console.log("Checking prerequisites...");
+    const prereqOk = await checkPrerequisites();
+    if (!prereqOk) {
+        console.log("");
+        fail("Prerequisites not met. Fix the issues above and try again.");
+        process.exit(1);
+    }
+    console.log("");
+    console.log("Installing...");
+    await createStateDirectory();
+    await registerMcpServer();
+    await installHooks();
+    await registerStatusLine();
+    await installSkill();
+    await setScriptPermissions();
+    console.log("");
+    console.log("\u2713 Claudemon installed successfully!");
+    console.log("");
+    console.log("Next steps:");
+    console.log("  1. Start a new Claude Code session");
+    console.log("  2. Type /buddy starter to pick your first Pokemon!");
+    console.log("");
+    console.log("Run 'bun run cli/doctor.ts' to verify installation.");
+    console.log("");
+}
+// Run if executed directly
+install().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`\nInstallation failed: ${message}`);
+    process.exit(1);
+});

package/dist/cli/shared.js

@@ -0,0 +1,72 @@
+/**
+ * Shared types and utilities for Claudemon CLI commands.
+ * Centralizes Claude Code config interfaces and common helpers.
+ */
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+// ── Constants ────────────────────────────────────────────────
+const HOME = process.env["HOME"];
+if (!HOME) {
+    console.error("Error: HOME environment variable is not set.");
+    process.exit(1);
+}
+export const CLI_HOME = HOME;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const PROJECT_DIR = resolve(dirname(__dirname));
+export const CLAUDE_DIR = `${HOME}/.claude`;
+export const CLAUDE_CONFIG = `${HOME}/.claude.json`;
+export const CLAUDE_SETTINGS = `${CLAUDE_DIR}/settings.json`;
+export const STATE_DIR = `${HOME}/.claudemon`;
+export const SKILL_SRC = `${PROJECT_DIR}/skills/buddy/SKILL.md`;
+export const SKILL_DEST_DIR = `${CLAUDE_DIR}/skills/buddy`;
+export const SKILL_DEST = `${SKILL_DEST_DIR}/SKILL.md`;
+export const HOOK_SCRIPT = `${PROJECT_DIR}/hooks/post-tool-use.sh`;
+export const STOP_HOOK_SCRIPT = `${PROJECT_DIR}/hooks/stop.sh`;
+export const USER_PROMPT_HOOK_SCRIPT = `${PROJECT_DIR}/hooks/user-prompt-submit.sh`;
+export const STATUSLINE_SCRIPT = `${PROJECT_DIR}/statusline/buddy-status.sh`;
+export const SERVER_ENTRY_TS = `${PROJECT_DIR}/src/server/index.ts`;
+export const SERVER_ENTRY_JS = `${PROJECT_DIR}/dist/src/server/index.js`;
+/** Find the best runtime and server entry — prefers bun (fast), falls back to node (compiled JS) */
+export function getRuntime() {
+    const { existsSync } = require("node:fs");
+    // Check for bun (can run .ts directly)
+    const bunCandidates = [`${HOME}/.bun/bin/bun`, "/usr/local/bin/bun", "/usr/bin/bun"];
+    for (const p of bunCandidates) {
+        if (existsSync(p)) {
+            return { command: p, serverEntry: SERVER_ENTRY_TS };
+        }
+    }
+    // Fall back to node (needs compiled .js from dist/)
+    if (existsSync(SERVER_ENTRY_JS)) {
+        return { command: "node", serverEntry: SERVER_ENTRY_JS };
+    }
+    // Last resort: assume bun in PATH
+    return { command: "bun", serverEntry: SERVER_ENTRY_TS };
+}
+// ── Helpers ──────────────────────────────────────────────────
+export function ok(msg) {
+    console.log(`  \u2713 ${msg}`);
+}
+export function fail(msg) {
+    console.error(`  \u2717 ${msg}`);
+}
+export function info(msg) {
+    console.log(`  - ${msg}`);
+}
+export async function readJson(path) {
+    const { readFile, access } = await import("node:fs/promises");
+    const { constants } = await import("node:fs");
+    try {
+        await access(path, constants.F_OK);
+        const text = await readFile(path, "utf-8");
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeJson(path, data) {
+    const { writeFile } = await import("node:fs/promises");
+    await writeFile(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}