myagentmemory 0.4.13 → 0.4.15

package/src/cli.ts

@@ -12,14 +12,21 @@
  *   search     — Search via qmd
  *   init       — Create dirs, detect qmd, setup collection
  *   status     — Show config, qmd status, file counts
+ *   completion — Install or print shell completion
+ *   install-hooks — Install managed session-start hooks
+ *   uninstall-hooks — Remove managed session-start hooks
+ *   plugin     — Discover and bootstrap optional official plugins
  *
  * Global flags:
  *   --dir <path>   Override memory directory
  *   --json         Machine-readable JSON output
  */
 
+import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 
+import { type CompletionShell, detectCompletionShell, generateCompletion, installCompletion } from "./completions.js";
+
 import {
 	_setBaseDir,
 	buildMemoryContext,
@@ -60,6 +67,13 @@ import {
 	topicPath,
 	uninstallSkills,
 } from "./core.js";
+import { detectHookAgents, type HookAgentKey, installHooks, uninstallHooks } from "./hooks.js";
+import {
+	createDefaultPluginBootstrap,
+	PluginBootstrapFailure,
+	type PluginBootstrapResultV1,
+} from "./plugin-bootstrap.js";
+import { InstalledPluginRuntimeV1 } from "./plugin-runtime.js";
 
 declare const __VERSION__: string;
 
@@ -148,6 +162,112 @@ function exitError(message: string, json: boolean): never {
 	process.exit(1);
 }
 
+function openExternalUrl(url: string): boolean {
+	let parsed: URL;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return false;
+	}
+	if (parsed.protocol !== "https:") return false;
+	try {
+		const child =
+			process.platform === "darwin"
+				? spawn("open", [parsed.toString()], { detached: true, stdio: "ignore" })
+				: process.platform === "win32"
+					? spawn("explorer.exe", [parsed.toString()], { detached: true, stdio: "ignore" })
+					: spawn("xdg-open", [parsed.toString()], { detached: true, stdio: "ignore" });
+		child.unref();
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function printProOverview(installed: boolean): void {
+	console.log("");
+	console.log("AgentMemory Pro includes:");
+	console.log("  Session Intelligence  Recall decisions and context across Pi, Codex, and Claude Code sessions.");
+	console.log("  Guided Learning       Turn repeated corrections into reviewable, reversible memory.");
+	console.log("  Local Web Console     Inspect memories, activity, health, and settings in your browser.");
+	console.log("");
+	console.log("Your session content stays on this device.");
+	console.log("");
+	if (installed) {
+		console.log("Try it:");
+		console.log('  agent-memory recall "what did we decide about authentication?"');
+		console.log("  agent-memory learn");
+		console.log("  agent-memory web");
+	} else {
+		console.log("Start your Pro beta:");
+		console.log("  agent-memory plugin install");
+	}
+}
+
+function printPluginResult(result: PluginBootstrapResultV1, json: boolean, allowBrowser: boolean): void {
+	if (json) {
+		output(result, true);
+	} else if (result.command === "plugin.list" && result.plugins) {
+		for (const plugin of result.plugins) {
+			const state = plugin.available ? "available" : plugin.installed ? plugin.entitlement : "not installed";
+			console.log(`${plugin.name}: ${state}`);
+		}
+		printProOverview(Boolean(result.bundle));
+	} else {
+		const version = result.bundle?.version ? ` ${result.bundle.version}` : "";
+		let showOverview = false;
+		switch (result.result) {
+			case "installed":
+				console.log(`AgentMemory Pro${version} installed.`);
+				showOverview = true;
+				break;
+			case "upgraded":
+				console.log(`AgentMemory Pro upgraded to${version}.`);
+				showOverview = true;
+				break;
+			case "current":
+				console.log(
+					result.bundle
+						? `AgentMemory Pro${version} is installed and ready.`
+						: "AgentMemory Pro is not installed.",
+				);
+				showOverview = Boolean(result.bundle);
+				break;
+			case "update_available":
+				console.log(`AgentMemory Pro${version} has an update available.`);
+				break;
+			case "uninstalled":
+				console.log("AgentMemory Pro executable components were removed. Memory and billing state were preserved.");
+				break;
+			case "not_installed":
+				console.log("AgentMemory Pro is not installed.");
+				console.log("Run: agent-memory plugin install");
+				break;
+			case "auth_required":
+				console.log(
+					"Run this command in an interactive terminal to enter an email and activate free daily access.",
+				);
+				break;
+			case "renewal_required":
+				console.log("Renew AgentMemory Pro to continue using paid capabilities.");
+				break;
+			default:
+				console.log(result.error?.message ?? "AgentMemory Pro is currently unavailable.");
+		}
+		if (showOverview) printProOverview(true);
+	}
+
+	if (result.nextAction) {
+		if (allowBrowser && openExternalUrl(result.nextAction.url)) {
+			if (!json) console.log("Opened the AgentMemory account website.");
+		} else if (!json) {
+			console.log(`Open: ${result.nextAction.url}`);
+		}
+		if (!json && result.nextAction.userCode) console.log(`Code: ${result.nextAction.userCode}`);
+	}
+	if (!result.ok) process.exitCode = 1;
+}
+
 // ---------------------------------------------------------------------------
 // Commands
 // ---------------------------------------------------------------------------
@@ -508,6 +628,90 @@ function cmdInstallSkills(flags: Record<string, string | boolean>) {
 	}
 }
 
+async function promptYesNo(question: string, defaultYes: boolean): Promise<boolean> {
+	const readline = await import("node:readline/promises");
+	const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+	try {
+		const answer = (await rl.question(`${question} ${defaultYes ? "[Y/n]" : "[y/N]"} `)).trim().toLowerCase();
+		if (!answer) return defaultYes;
+		return answer === "y" || answer === "yes";
+	} finally {
+		rl.close();
+	}
+}
+
+async function cmdInstallHooks(flags: Record<string, string | boolean>): Promise<void> {
+	const json = hasFlag(flags, "json");
+	const requested = getFlag(flags, "only");
+	const requestedKeys = requested ? new Set(requested.split(",").map((value) => value.trim())) : null;
+	const { homeDir, targets } = detectHookAgents();
+	if (!homeDir) exitError("Home directory not found.", json);
+	const eligible = targets.filter(
+		(target) => target.supported && target.detected && (!requestedKeys || requestedKeys.has(target.key)),
+	);
+	const selected = new Set<HookAgentKey>();
+	const applyAll = hasFlag(flags, "yes") || hasFlag(flags, "all") || !process.stdin.isTTY;
+	for (const target of eligible) {
+		if (applyAll || (await promptYesNo(`Install SessionStart hook for ${target.label}?`, true)))
+			selected.add(target.key);
+	}
+	const report = installHooks(selected);
+	if (!report.ok) exitError(report.error ?? "install failed", json);
+	if (json) return output(report, true);
+	if (!report.results.length) return output("No eligible agents. Nothing to install.", false);
+	for (const result of report.results) {
+		console.log(
+			result.installed
+				? `Installed ${result.label} hook: ${result.path}`
+				: `Skipped ${result.label} (${result.reason ?? "unknown"})`,
+		);
+	}
+}
+
+function cmdUninstallHooks(flags: Record<string, string | boolean>): void {
+	const json = hasFlag(flags, "json");
+	const only = getFlag(flags, "only");
+	const agents = only ? new Set(only.split(",").map((value) => value.trim()) as HookAgentKey[]) : undefined;
+	const report = uninstallHooks(agents);
+	if (!report.ok) exitError(report.error ?? "uninstall failed", json);
+	if (json) {
+		output(report, true);
+		return;
+	}
+	for (const result of report.results) {
+		console.log(
+			result.installed
+				? `Uninstalled ${result.label}: ${result.path}`
+				: `Skipped ${result.label} (${result.reason ?? "unknown"})`,
+		);
+	}
+}
+
+function cmdCompletion(flags: Record<string, string | boolean>, positional: string[]): void {
+	const requestedShell = positional[0];
+	const shells: CompletionShell[] = ["bash", "zsh", "fish", "powershell"];
+	if (requestedShell && !shells.includes(requestedShell as CompletionShell))
+		exitError(
+			`Unsupported shell '${requestedShell}'. Choose bash, zsh, fish, or powershell.`,
+			hasFlag(flags, "json"),
+		);
+	const shell = (requestedShell as CompletionShell | undefined) ?? detectCompletionShell();
+	if (!shell)
+		exitError("Could not detect your shell. Specify bash, zsh, fish, or powershell.", hasFlag(flags, "json"));
+	if (hasFlag(flags, "stdout")) {
+		process.stdout.write(generateCompletion(shell));
+		return;
+	}
+	const result = installCompletion(shell);
+	if (hasFlag(flags, "json")) {
+		output(result, true);
+		return;
+	}
+	console.log(`Installed ${shell} completion: ${result.completionPath}`);
+	if (result.profilePath)
+		console.log(`${result.profileUpdated ? "Configured" : "Already configured"}: ${result.profilePath}`);
+}
+
 async function cmdSync(flags: Record<string, string | boolean>) {
 	const json = hasFlag(flags, "json");
 
@@ -602,6 +806,18 @@ async function cmdInit(flags: Record<string, string | boolean>) {
 			console.log(`  qmd not found — search features unavailable.`);
 			console.log(`  Install: bun install -g https://github.com/tobi/qmd`);
 		}
+		if (process.stdout.isTTY) {
+			try {
+				const plugin = await createDefaultPluginBootstrap(VERSION).list();
+				if (plugin.result === "not_installed") {
+					console.log("");
+					console.log("Optional: AgentMemory Pro adds session recall and a local Web Console.");
+					console.log("Run: agent-memory plugin install");
+				}
+			} catch {
+				// Commercial discovery must never make core initialization fail.
+			}
+		}
 	}
 }
 
@@ -650,6 +866,21 @@ async function cmdStatus(flags: Record<string, string | boolean>) {
 	}
 
 	const embedMode = getQmdEmbedMode();
+	let officialPlugin: { installed: boolean; result: string; entitlement: string } = {
+		installed: false,
+		result: "unavailable",
+		entitlement: "missing",
+	};
+	try {
+		const plugin = await createDefaultPluginBootstrap(VERSION).status();
+		officialPlugin = {
+			installed: Boolean(plugin.bundle),
+			result: plugin.result,
+			entitlement: plugin.entitlement.state,
+		};
+	} catch {
+		// Commercial status must never make core status fail.
+	}
 
 	if (json) {
 		output(
@@ -674,6 +905,7 @@ async function cmdStatus(flags: Record<string, string | boolean>) {
 					embeddings,
 				},
 				embedMode,
+				officialPlugin,
 			},
 			true,
 		);
@@ -723,6 +955,11 @@ async function cmdStatus(flags: Record<string, string | boolean>) {
 		} else {
 			console.log("qmd: not installed");
 		}
+		if (!officialPlugin.installed) {
+			console.log("");
+			console.log("Optional official plugins: not installed");
+			console.log("  run: agent-memory plugin install");
+		}
 	}
 }
 
@@ -753,6 +990,116 @@ async function cmdDistil(flags: Record<string, string | boolean>) {
 	}
 }
 
+function printPluginUsage(): void {
+	console.log(`agent-memory plugin — optional official plugins
+
+Usage:
+  agent-memory plugin [list]
+  agent-memory plugin status
+  agent-memory plugin install [--channel stable] [--no-browser]
+  agent-memory plugin update [--channel stable]
+  agent-memory plugin uninstall --yes
+  agent-memory plugin manage [--no-browser]
+
+The public core remains fully usable without AgentMemory Pro. Interactive install
+opens a loopback website for email activation and a configurable free daily
+agent-session allowance. Memory and session content stay on this device.`);
+}
+
+function pluginCommandFailure(command: string, error: unknown): PluginBootstrapResultV1 {
+	return {
+		schemaVersion: 1,
+		command: `plugin.${command}`,
+		ok: false,
+		result: "unavailable",
+		bundle: null,
+		entitlement: {
+			plan: null,
+			state: "missing",
+			features: [],
+			capabilities: {},
+		},
+		nextAction: null,
+		error: {
+			code: error instanceof PluginBootstrapFailure ? error.code : "plugin_command_failed",
+			message: error instanceof Error ? error.message : String(error),
+			...(error instanceof PluginBootstrapFailure && error.retryable ? { retryable: true } : {}),
+		},
+	};
+}
+
+async function cmdPlugin(flags: Record<string, string | boolean>, positional: string[]): Promise<void> {
+	const json = hasFlag(flags, "json");
+	const subcommand = positional[0] ?? "list";
+	if (subcommand === "help" || hasFlag(flags, "help")) {
+		printPluginUsage();
+		return;
+	}
+	const channel = getFlag(flags, "channel") ?? "stable";
+	if (channel !== "stable") {
+		printPluginResult(
+			pluginCommandFailure(
+				subcommand,
+				new PluginBootstrapFailure("channel_invalid", "--channel supports only 'stable'"),
+			),
+			json,
+			false,
+		);
+		return;
+	}
+	const allowBrowser = !json && !hasFlag(flags, "no-browser") && Boolean(process.stdin.isTTY && process.stdout.isTTY);
+	const manager = createDefaultPluginBootstrap(VERSION);
+
+	let result: PluginBootstrapResultV1;
+	try {
+		switch (subcommand) {
+			case "list":
+				result = await manager.list();
+				break;
+			case "status":
+				result = await manager.status(channel);
+				break;
+			case "install":
+				result = await manager.install({ channel, allowAuthentication: allowBrowser });
+				break;
+			case "update":
+				result = await manager.update({ channel, allowAuthentication: false });
+				break;
+			case "uninstall":
+				if (!hasFlag(flags, "yes")) {
+					const status = await manager.status(channel);
+					result = {
+						...status,
+						command: "plugin.uninstall",
+						ok: false,
+						result: "unavailable",
+						error: {
+							code: "confirmation_required",
+							message: "Re-run with --yes to remove AgentMemory Pro executable components",
+						},
+					};
+					break;
+				}
+				result = await manager.uninstall();
+				break;
+			case "manage":
+				result = await manager.manage();
+				break;
+			default:
+				result = pluginCommandFailure(
+					subcommand,
+					new PluginBootstrapFailure(
+						"unknown_plugin_command",
+						`Unknown plugin command: ${subcommand}. Available bootstrap commands: list, status, install, update, uninstall, manage.`,
+					),
+				);
+		}
+	} catch (error) {
+		result = pluginCommandFailure(subcommand, error);
+	}
+	printPluginResult(result, json, allowBrowser && (subcommand === "install" || subcommand === "manage"));
+}
+
 // ---------------------------------------------------------------------------
 // Usage
 // ---------------------------------------------------------------------------
@@ -776,6 +1123,10 @@ Commands:
   sync        Re-index and embed all files (requires qmd)
   init        Initialize memory directory and qmd collection
   status      Show configuration and status (--probe for a live embeddings check)
+  completion  Install or print shell completion
+  install-hooks  Install managed SessionStart hooks
+  uninstall-hooks  Remove only managed SessionStart hooks
+  plugin      Discover, install, update, or remove optional official plugins
 
 Global flags:
   --dir <path>   Override memory directory
@@ -798,7 +1149,11 @@ Examples:
   agent-memory distil --dry-run
   agent-memory context --query "database choice"
   agent-memory sync
-  agent-memory status --json`);
+  agent-memory status --json
+  agent-memory completion zsh
+  agent-memory install-hooks --yes
+  agent-memory plugin status
+  agent-memory plugin install`);
 }
 
 // ---------------------------------------------------------------------------
@@ -820,7 +1175,7 @@ async function main() {
 		return;
 	}
 
-	if (!command || command === "help" || hasFlag(flags, "help")) {
+	if (!command || command === "help" || (hasFlag(flags, "help") && command !== "plugin")) {
 		printUsage();
 		return;
 	}
@@ -860,8 +1215,53 @@ async function main() {
 		case "status":
 			await cmdStatus(flags);
 			break;
-		default:
-			exitError(`Unknown command: ${command}. Run 'agent-memory help' for usage.`, json);
+		case "completion":
+			cmdCompletion(flags, positional);
+			break;
+		case "install-hooks":
+			await cmdInstallHooks(flags);
+			break;
+		case "uninstall-hooks":
+			cmdUninstallHooks(flags);
+			break;
+		case "hook": {
+			if (positional[0] !== "session-start") exitError("hook requires 'session-start'", json);
+			const agent = getFlag(flags, "agent");
+			if (!agent) exitError("hook session-start requires --agent", json);
+			await cmdContext({ "no-search": true });
+			try {
+				const decision = await new InstalledPluginRuntimeV1({ coreVersion: VERSION }).runSessionStart({
+					host: agent,
+					cwd: process.cwd(),
+					signal: new AbortController().signal,
+				});
+				if (decision?.state === "exhausted")
+					console.error(`AgentMemory free session allowance resets at ${decision.resetAt}`);
+			} catch {
+				// Paid SessionStart work must never make public-core context unavailable.
+			}
+			break;
+		}
+		case "plugin":
+			await cmdPlugin(flags, positional);
+			break;
+		default: {
+			const controller = new AbortController();
+			const abort = () => controller.abort();
+			process.once("SIGINT", abort);
+			try {
+				const result = await new InstalledPluginRuntimeV1({ coreVersion: VERSION }).run(command, {
+					args: positional,
+					flags,
+					signal: controller.signal,
+				});
+				if (!result) exitError(`Unknown command: ${command}. Run 'agent-memory help' for usage.`, json);
+				if (!result.ok) exitError(result.error?.message ?? `Plugin command ${command} failed`, json);
+				output(result.data ?? { ok: true }, json);
+			} finally {
+				process.removeListener("SIGINT", abort);
+			}
+		}
 	}
 }