@membank/cli 0.1.1 → 0.3.0

package/README.md

@@ -0,0 +1,154 @@
+# @membank/cli
+
+CLI and npx entrypoint for membank. Manages memories from the terminal and starts the MCP server for LLM harnesses.
+
+## Install
+
+```bash
+npm install -g @membank/cli
+```
+
+Or use without installing:
+
+```bash
+npx @membank/cli <command>
+```
+
+## Setup
+
+Run once to configure your LLM harness:
+
+```bash
+membank setup
+```
+
+This auto-detects installed harnesses (Claude Code, GitHub Copilot CLI, Codex, OpenCode), writes MCP server config, installs session hooks, and downloads the embedding model (~33 MB).
+
+Options:
+
+```
+--harness <name>   Target a specific harness instead of auto-detecting
+--yes              Skip confirmation prompts
+--dry-run          Preview changes without writing files
+--json             Machine-readable output
+```
+
+Supported harnesses: `claude-code`, `copilot`, `codex`, `opencode`
+
+## Commands
+
+### `membank query <text>`
+
+Semantic search over stored memories.
+
+```bash
+membank query "how to run pnpm in one package"
+membank query "auth decisions" --type decision --limit 5
+```
+
+Options: `--type <type>`, `--limit <n>` (default 10)
+
+### `membank add <content>`
+
+Save a new memory.
+
+```bash
+membank add "Use --filter flag for scoped pnpm commands" --type preference --tags "pnpm,monorepo"
+```
+
+Required: `--type <type>`  
+Options: `--tags <a,b,c>`, `--scope <scope>`
+
+### `membank list`
+
+List stored memories.
+
+```bash
+membank list
+membank list --type correction
+membank list --pinned
+```
+
+Options: `--type <type>`, `--pinned`
+
+### `membank stats`
+
+Show memory counts by type.
+
+```bash
+membank stats
+```
+
+### `membank pin <id>` / `membank unpin <id>`
+
+Pin a memory so it's always injected at session start.
+
+```bash
+membank pin abc123
+membank unpin abc123
+```
+
+### `membank delete <id>`
+
+Delete a memory. Prompts for confirmation unless `--yes` is passed.
+
+```bash
+membank delete abc123
+membank delete abc123 --yes
+```
+
+### `membank export`
+
+Export all memories to a JSON file.
+
+```bash
+membank export
+membank export --output my-backup.json
+```
+
+Default filename: `membank-export-<timestamp>.json`
+
+### `membank import <file>`
+
+Import memories from an export file.
+
+```bash
+membank import membank-export-2025-01-01.json
+membank import membank-export-2025-01-01.json --yes
+```
+
+### `membank inject`
+
+Output session context formatted for a harness. Called automatically by session hooks — you don't normally run this directly.
+
+```bash
+membank inject --harness claude-code --scope <project-scope>
+```
+
+## Global flags
+
+```
+--json     Output machine-readable JSON
+--yes, -y  Skip confirmation prompts
+--mcp      Start MCP stdio server (used by harness config)
+```
+
+## MCP server mode
+
+```bash
+membank --mcp
+```
+
+Starts the stdio MCP server. This is what harnesses connect to — `setup` writes this command into harness configs automatically.
+
+## Session hooks
+
+`setup` installs two hooks:
+
+**Session start** — calls `membank inject` to prepend pinned memories into the LLM context at the beginning of every session.
+
+**Session stop (Claude Code only)** — prompts the LLM to review the session and call `save_memory` for any notable corrections, preferences, or decisions.
+
+## Requirements
+
+- Node.js >=24

package/dist/index.mjs

@@ -2,6 +2,7 @@
 import { DatabaseManager, EmbeddingService, MEMORY_TYPE_VALUES, MemoryRepository, QueryEngine, SessionContextBuilder, resolveScope } from "@membank/core";
 import { startServer } from "@membank/mcp";
 import { Command } from "commander";
+import { startDashboard } from "@membank/dashboard";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import * as readline from "node:readline";
@@ -30,6 +31,11 @@ async function addCommand(content, options, formatter, db, embeddingService) {
 	}
 }
 //#endregion
+//#region src/commands/dashboard.ts
+async function dashboardCommand(opts) {
+	await startDashboard({ port: opts.port !== void 0 ? parseInt(opts.port, 10) : void 0 });
+}
+//#endregion
 //#region src/commands/delete.ts
 async function deleteCommand(id, db, formatter, prompt) {
 	if (db.db.prepare(`SELECT id FROM memories WHERE id = ?`).get(id) === void 0) {
@@ -140,7 +146,66 @@ function formatContext(ctx) {
 	lines.push(MEMORY_GUIDANCE);
 	return lines.join("\n");
 }
-async function injectCommand(opts) {
+function outputAdditionalContext(text, harness, eventName) {
+	if (harness === "claude-code") {
+		process.stdout.write(JSON.stringify({ hookSpecificOutput: {
+			hookEventName: eventName,
+			additionalContext: text
+		} }));
+		return;
+	}
+	if (harness === "copilot-cli") {
+		process.stdout.write(JSON.stringify({ additionalContext: text }));
+		return;
+	}
+	process.stdout.write(`${text}\n`);
+}
+async function readStdin() {
+	if (process.stdin.isTTY) return "";
+	return new Promise((resolve) => {
+		const chunks = [];
+		const timeout = setTimeout(() => resolve(""), 1e3);
+		process.stdin.on("data", (chunk) => chunks.push(chunk));
+		process.stdin.on("end", () => {
+			clearTimeout(timeout);
+			resolve(Buffer.concat(chunks).toString("utf8"));
+		});
+		process.stdin.on("error", () => {
+			clearTimeout(timeout);
+			resolve("");
+		});
+	});
+}
+const FEEDBACK_PATTERNS = [
+	/\bdon'?t\b/i,
+	/\bstop\b/i,
+	/\bnever\b/i,
+	/\balways\b/i,
+	/\bremember\b/i,
+	/\bprefer\b/i,
+	/\bi (like|want|hate|dislike)\b/i,
+	/\bfrom now on\b/i,
+	/\bkeep in mind\b/i,
+	/\bnote that\b/i,
+	/\bstop doing\b/i,
+	/\bstop using\b/i,
+	/\bthat'?s wrong\b/i,
+	/\bno,?\s+(actually|that'?s)\b/i,
+	/\bplease (don'?t|stop|always|never)\b/i
+];
+function looksLikeFeedback(prompt) {
+	return FEEDBACK_PATTERNS.some((p) => p.test(prompt));
+}
+function isToolFailure(data) {
+	if (data.hook_event_name === "PostToolUseFailure") return true;
+	if (typeof data.error_message === "string" && data.error_message.length > 0) return true;
+	const response = data.tool_result ?? data.tool_response;
+	if (typeof response === "object" && response !== null) {
+		if (response.is_error === true) return true;
+	}
+	return false;
+}
+async function handleSessionStart(opts) {
 	const projectScope = opts.scope ?? await resolveScope();
 	const db = DatabaseManager.open();
 	let text;
@@ -151,18 +216,44 @@ async function injectCommand(opts) {
 	}
 	if (!text) process.exit(0);
 	const harness = opts.harness;
-	if (harness === "claude-code") {
-		process.stdout.write(JSON.stringify({ hookSpecificOutput: {
-			hookEventName: "SessionStart",
-			additionalContext: text
-		} }));
+	outputAdditionalContext(text, harness, "SessionStart");
+}
+async function handleUserPrompt(harness) {
+	const raw = await readStdin();
+	if (!raw) process.exit(0);
+	let data;
+	try {
+		data = JSON.parse(raw);
+	} catch {
+		process.exit(0);
+	}
+	if (!looksLikeFeedback(typeof data.prompt === "string" ? data.prompt : "")) process.exit(0);
+	outputAdditionalContext("User prompt may contain a correction, preference, or decision worth saving. After responding, evaluate: should this be saved as a memory? If yes, call save_memory with the appropriate type (correction/preference/decision/learning) and scope (global or project).", harness, "UserPromptSubmit");
+}
+async function handleToolFailure(harness) {
+	const raw = await readStdin();
+	if (!raw) process.exit(0);
+	let data;
+	try {
+		data = JSON.parse(raw);
+	} catch {
+		process.exit(0);
+	}
+	if (!isToolFailure(data)) process.exit(0);
+	outputAdditionalContext(`Tool "${typeof data.tool_name === "string" ? data.tool_name : "unknown"}" failed. If this reveals a non-obvious constraint, environment issue, or repeatable failure pattern, call save_memory with type "learning" to prevent repeating it.`, harness, "PostToolUseFailure");
+}
+async function injectCommand(opts) {
+	const harness = opts.harness;
+	const event = opts.event ?? "session-start";
+	if (event === "user-prompt") {
+		await handleUserPrompt(harness);
 		return;
 	}
-	if (harness === "copilot-cli") {
-		process.stdout.write(JSON.stringify({ additionalContext: text }));
+	if (event === "tool-failure") {
+		await handleToolFailure(harness);
 		return;
 	}
-	process.stdout.write(`${text}\n`);
+	await handleSessionStart(opts);
 }
 //#endregion
 //#region src/commands/list.ts
@@ -527,105 +618,217 @@ function writeJsonAtomic(path, data) {
 	writeFileSync(tmp, JSON.stringify(data, null, 2));
 	renameSync(tmp, path);
 }
+function getHooksArray(group) {
+	if (typeof group !== "object" || group === null) return [];
+	const h = group.hooks;
+	return Array.isArray(h) ? h : [];
+}
+function findMembankHookCommand(hooks, pattern) {
+	for (const h of hooks) {
+		if (typeof h !== "object" || h === null) continue;
+		if ("command" in h && typeof h.command === "string" && h.command.includes(pattern)) return h.command;
+		if ("bash" in h && typeof h.bash === "string" && h.bash.includes(pattern)) return h.bash;
+	}
+	return "";
+}
 function containsMembankInject(hooks) {
-	if (!Array.isArray(hooks)) return false;
-	return hooks.some((h) => typeof h === "object" && h !== null && ("command" in h && typeof h.command === "string" && h.command.includes("@membank/cli inject") || "bash" in h && typeof h.bash === "string" && h.bash.includes("@membank/cli inject")));
+	return findMembankHookCommand(hooks, "@membank/cli inject") !== "";
+}
+function extractInjectCommand(hooks) {
+	return findMembankHookCommand(hooks, "@membank/cli inject");
+}
+function filterOutMembank(groups) {
+	return groups.filter((g) => !containsMembankInject(getHooksArray(g)));
+}
+function filterOutMembankFlat(hooks) {
+	return hooks.filter((h) => !containsMembankInject([h]));
 }
 const writers = {
-	"claude-code": { write(resolver) {
-		const cfgPath = join(resolver.home(), ".claude", "settings.json");
-		const cfg = readJson(cfgPath);
-		const hooks = cfg.hooks;
-		const sessionStart = hooks?.SessionStart;
-		if (Array.isArray(sessionStart) && containsMembankInject(sessionStart.flatMap((g) => Array.isArray(g.hooks) ? g.hooks : []))) return { status: "already-configured" };
-		const existingSessionStart = Array.isArray(sessionStart) ? sessionStart : [];
-		writeJsonAtomic(cfgPath, {
-			...cfg,
-			hooks: {
-				...hooks ?? {},
-				SessionStart: [...existingSessionStart, {
-					matcher: "",
-					hooks: [{
-						type: "command",
-						command: "npx @membank/cli inject --harness claude-code"
+	"claude-code": {
+		replacement: "npx @membank/cli inject --harness claude-code",
+		write(resolver, overwrite = false) {
+			const cfgPath = join(resolver.home(), ".claude", "settings.json");
+			const cfg = readJson(cfgPath);
+			const hooks = cfg.hooks;
+			const existingSessionStart = Array.isArray(hooks?.SessionStart) ? hooks.SessionStart : [];
+			const innerHooks = existingSessionStart.flatMap(getHooksArray);
+			if (!overwrite && containsMembankInject(innerHooks)) return {
+				status: "already-configured",
+				existing: extractInjectCommand(innerHooks),
+				replacement: this.replacement
+			};
+			const filteredSessionStart = overwrite ? filterOutMembank(existingSessionStart) : existingSessionStart;
+			const existingUserPrompt = Array.isArray(hooks?.UserPromptSubmit) ? hooks.UserPromptSubmit : [];
+			const existingToolFailure = Array.isArray(hooks?.PostToolUseFailure) ? hooks.PostToolUseFailure : [];
+			writeJsonAtomic(cfgPath, {
+				...cfg,
+				hooks: {
+					...hooks ?? {},
+					SessionStart: [...filteredSessionStart, {
+						matcher: "",
+						hooks: [{
+							type: "command",
+							command: "npx @membank/cli inject --harness claude-code"
+						}]
+					}],
+					UserPromptSubmit: [...filterOutMembank(existingUserPrompt), {
+						matcher: "",
+						hooks: [{
+							type: "command",
+							command: "npx @membank/cli inject --event user-prompt --harness claude-code"
+						}]
+					}],
+					PostToolUseFailure: [...filterOutMembank(existingToolFailure), {
+						matcher: "",
+						hooks: [{
+							type: "command",
+							command: "npx @membank/cli inject --event tool-failure --harness claude-code"
+						}]
 					}]
-				}]
-			}
-		});
-		return { status: "written" };
-	} },
-	"copilot-cli": { write(resolver) {
-		const cfgPath = join(resolver.home(), ".copilot", "settings.json");
-		const cfg = readJson(cfgPath);
-		const hooks = cfg.hooks;
-		const sessionStart = hooks?.sessionStart;
-		if (Array.isArray(sessionStart) && containsMembankInject(sessionStart)) return { status: "already-configured" };
-		const existingSessionStart = Array.isArray(sessionStart) ? sessionStart : [];
-		writeJsonAtomic(cfgPath, {
-			version: cfg.version ?? 1,
-			...cfg,
-			hooks: {
-				...hooks ?? {},
-				sessionStart: [...existingSessionStart, {
-					type: "command",
-					bash: "npx @membank/cli inject --harness copilot-cli",
-					timeoutSec: 30
-				}]
-			}
-		});
-		return { status: "written" };
-	} },
-	codex: { write(resolver) {
-		const cfgPath = join(resolver.home(), ".codex", "hooks.json");
-		const cfg = readJson(cfgPath);
-		const hooks = cfg.hooks;
-		const sessionStart = hooks?.SessionStart;
-		if (Array.isArray(sessionStart) && containsMembankInject(sessionStart.flatMap((g) => Array.isArray(g.hooks) ? g.hooks : []))) return { status: "already-configured" };
-		const existingSessionStart = Array.isArray(sessionStart) ? sessionStart : [];
-		writeJsonAtomic(cfgPath, {
-			...cfg,
-			hooks: {
-				...hooks ?? {},
-				SessionStart: [...existingSessionStart, {
-					matcher: "",
-					hooks: [{
+				}
+			});
+			return { status: "written" };
+		}
+	},
+	"copilot-cli": {
+		replacement: "npx @membank/cli inject --harness copilot-cli",
+		write(resolver, overwrite = false) {
+			const cfgPath = join(resolver.home(), ".copilot", "settings.json");
+			const cfg = readJson(cfgPath);
+			const hooks = cfg.hooks;
+			const existingSessionStart = Array.isArray(hooks?.sessionStart) ? hooks.sessionStart : [];
+			if (!overwrite && containsMembankInject(existingSessionStart)) return {
+				status: "already-configured",
+				existing: extractInjectCommand(existingSessionStart),
+				replacement: this.replacement
+			};
+			const filteredSessionStart = overwrite ? filterOutMembankFlat(existingSessionStart) : existingSessionStart;
+			const existingUserPrompt = Array.isArray(hooks?.userPromptSubmitted) ? hooks.userPromptSubmitted : [];
+			const existingToolFailure = Array.isArray(hooks?.postToolUseFailure) ? hooks.postToolUseFailure : [];
+			writeJsonAtomic(cfgPath, {
+				version: cfg.version ?? 1,
+				...cfg,
+				hooks: {
+					...hooks ?? {},
+					sessionStart: [...filteredSessionStart, {
+						type: "command",
+						bash: "npx @membank/cli inject --harness copilot-cli",
+						timeoutSec: 30
+					}],
+					userPromptSubmitted: [...filterOutMembankFlat(existingUserPrompt), {
 						type: "command",
-						command: "npx @membank/cli inject --harness codex",
-						timeout: 30
+						bash: "npx @membank/cli inject --event user-prompt --harness copilot-cli",
+						timeoutSec: 30
+					}],
+					postToolUseFailure: [...filterOutMembankFlat(existingToolFailure), {
+						type: "command",
+						bash: "npx @membank/cli inject --event tool-failure --harness copilot-cli",
+						timeoutSec: 30
+					}]
+				}
+			});
+			return { status: "written" };
+		}
+	},
+	codex: {
+		replacement: "npx @membank/cli inject --harness codex",
+		write(resolver, overwrite = false) {
+			const cfgPath = join(resolver.home(), ".codex", "hooks.json");
+			const cfg = readJson(cfgPath);
+			const hooks = cfg.hooks;
+			const existingSessionStart = Array.isArray(hooks?.SessionStart) ? hooks.SessionStart : [];
+			const innerHooks = existingSessionStart.flatMap(getHooksArray);
+			if (!overwrite && containsMembankInject(innerHooks)) return {
+				status: "already-configured",
+				existing: extractInjectCommand(innerHooks),
+				replacement: this.replacement
+			};
+			const filteredSessionStart = overwrite ? filterOutMembank(existingSessionStart) : existingSessionStart;
+			const existingUserPrompt = Array.isArray(hooks?.UserPromptSubmit) ? hooks.UserPromptSubmit : [];
+			const existingToolFailure = Array.isArray(hooks?.PostToolUse) ? hooks.PostToolUse : [];
+			writeJsonAtomic(cfgPath, {
+				...cfg,
+				hooks: {
+					...hooks ?? {},
+					SessionStart: [...filteredSessionStart, {
+						matcher: "",
+						hooks: [{
+							type: "command",
+							command: "npx @membank/cli inject --harness codex",
+							timeout: 30
+						}]
+					}],
+					UserPromptSubmit: [...filterOutMembank(existingUserPrompt), {
+						matcher: "",
+						hooks: [{
+							type: "command",
+							command: "npx @membank/cli inject --event user-prompt --harness codex",
+							timeout: 30
+						}]
+					}],
+					PostToolUse: [...filterOutMembank(existingToolFailure), {
+						matcher: "",
+						hooks: [{
+							type: "command",
+							command: "npx @membank/cli inject --event tool-failure --harness codex",
+							timeout: 30
+						}]
 					}]
-				}]
+				}
+			});
+			return { status: "written" };
+		}
+	},
+	opencode: {
+		replacement: "npx @membank/cli inject",
+		write(resolver, overwrite = false) {
+			const pluginPath = join(resolver.home(), ".config", "opencode", "plugins", "membank.js");
+			if (!overwrite && existsSync(pluginPath)) {
+				const existing = readFileSync(pluginPath, "utf8");
+				if (existing.includes("@membank/cli inject")) return {
+					status: "already-configured",
+					existing: existing.trim(),
+					replacement: newOpencodePlugin()
+				};
 			}
-		});
-		return { status: "written" };
-	} },
-	opencode: { write(resolver) {
-		const pluginPath = join(resolver.home(), ".config", "opencode", "plugins", "membank.js");
-		if (existsSync(pluginPath)) {
-			if (readFileSync(pluginPath, "utf8").includes("@membank/cli inject")) return { status: "already-configured" };
+			mkdirSync(dirname(pluginPath), { recursive: true });
+			writeFileSync(pluginPath, `${newOpencodePlugin()}\n`, "utf8");
+			return { status: "written" };
 		}
-		mkdirSync(dirname(pluginPath), { recursive: true });
-		writeFileSync(pluginPath, [
-			"export default {",
-			"  hooks: {",
-			"    \"session.start\": async ({ $ }) => {",
-			"      return await $`npx @membank/cli inject`.text();",
-			"    },",
-			"  },",
-			"};",
-			""
-		].join("\n"), "utf8");
-		return { status: "written" };
-	} }
+	}
 };
+function newOpencodePlugin() {
+	return [
+		"export default {",
+		"  hooks: {",
+		"    \"session.start\": async ({ $ }) => {",
+		"      return await $`npx @membank/cli inject`.text();",
+		"    },",
+		"    \"chat.message\": async ({ $, message }) => {",
+		"      const input = JSON.stringify({ prompt: message?.content ?? \"\" });",
+		"      return await $`npx @membank/cli inject --event user-prompt`.stdin(input).text();",
+		"    },",
+		"    \"tool.execute.after\": async ({ $, result }) => {",
+		"      if (!result?.exitCode && !result?.error) return;",
+		"      const payload = JSON.stringify({",
+		"        tool_name: result.tool ?? \"unknown\",",
+		"        error_message: result.error ?? (\"exit code \" + result.exitCode),",
+		"      });",
+		"      return await $`npx @membank/cli inject --event tool-failure`.stdin(payload).text();",
+		"    },",
+		"  },",
+		"};"
+	].join("\n");
+}
 var InjectionHookWriter = class {
 	#resolver;
 	constructor(resolver = defaultPathResolver) {
 		this.#resolver = resolver;
 	}
-	write(harness) {
+	write(harness, overwrite) {
 		const writer = writers[harness];
 		if (!writer) return { status: "not-supported" };
-		return writer.write(this.#resolver);
+		return writer.write(this.#resolver, overwrite);
 	}
 };
 //#endregion
@@ -859,17 +1062,8 @@ var SetupOrchestrator = class {
 		out("");
 		const injectionHooksConfigured = [];
 		if (this.#hookWriter) {
-			for (const h of detected) try {
-				const hookResult = this.#hookWriter.write(h.name);
-				if (hookResult.status === "not-supported") continue;
-				if (hookResult.status === "written") {
-					out(`  ✓ ${h.name}: injection hook written`);
-					injectionHooksConfigured.push(h.name);
-				} else out(`  ⚠ ${h.name}: injection hook already configured`);
-			} catch (err) {
-				const msg = err instanceof Error ? err.message : String(err);
-				out(`  ✗ ${h.name} injection hook: ${msg}`);
-			}
+			const w = this.#hookWriter;
+			injectionHooksConfigured.push(...await this.#runHookLoop(detected, "injection hook", (h, ow) => w.write(h, ow), yes, out));
 			out("");
 		}
 		let modelDownloaded = false;
@@ -892,6 +1086,31 @@ var SetupOrchestrator = class {
 		}
 		return results;
 	}
+	async #runHookLoop(detected, label, write, yes, out) {
+		const configured = [];
+		for (const h of detected) try {
+			const result = write(h.name);
+			if (result.status === "not-supported") continue;
+			if (result.status === "written") {
+				out(`  ✓ ${h.name}: ${label} written`);
+				configured.push(h.name);
+			} else {
+				out(`  ⚠ ${h.name}: ${label} already configured`);
+				out(`    Current: ${result.existing}`);
+				out(`    New:     ${result.replacement}`);
+				if (yes || await this.#prompter(`  Replace ${label} for ${h.name}?`)) {
+					if (write(h.name, true).status === "written") {
+						out(`  ✓ ${h.name}: ${label} replaced`);
+						configured.push(h.name);
+					}
+				}
+			}
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			out(`  ✗ ${h.name} ${label}: ${msg}`);
+		}
+		return configured;
+	}
 	async #runModelDownload(downloader, out) {
 		out("Downloading embedding model (bge-small-en-v1.5, ~33 MB)...");
 		downloader.on?.("progress", (p) => {
@@ -1022,7 +1241,7 @@ program.command("import <file>").description("import memories from a JSON export
 		db.close();
 	}
 });
-program.command("inject").description("output session context for harness injection (used by setup hooks)").option("--harness <name>", "format output for a specific harness (claude-code|copilot-cli|codex|opencode)").option("--scope <scope>", "project scope override (default: auto-detect from git remote)").action(async (cmdOptions) => {
+program.command("inject").description("output session context for harness injection (used by setup hooks)").option("--harness <name>", "format output for a specific harness (claude-code|copilot-cli|codex|opencode)").option("--scope <scope>", "project scope override (default: auto-detect from git remote)").option("--event <event>", "hook event type (session-start|user-prompt|tool-failure)", "session-start").action(async (cmdOptions) => {
 	try {
 		await injectCommand(cmdOptions);
 	} catch (err) {
@@ -1061,6 +1280,14 @@ program.command("setup").description("detect installed harnesses and write MCP c
 		process.exit(2);
 	}
 });
+program.command("dashboard").description("open the memory management dashboard in the browser").option("--port <port>", "port to listen on (default: 3847, fallback to random)").action(async (cmdOptions) => {
+	try {
+		await dashboardCommand(cmdOptions);
+	} catch (err) {
+		process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+		process.exit(2);
+	}
+});
 program.on("command:*", () => {
 	program.outputHelp();
 	process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@membank/cli",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -17,8 +17,9 @@
     "@huggingface/transformers": "^4.2.0",
     "commander": "^14.0.3",
     "ora": "^9.4.0",
-    "@membank/core": "0.1.1",
-    "@membank/mcp": "0.1.1"
+    "@membank/dashboard": "0.1.0",
+    "@membank/mcp": "0.3.0",
+    "@membank/core": "0.3.0"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",