myagentmemory 0.5.2 → 0.5.3

package/src/hooks.ts

@@ -1,8 +1,22 @@
+import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
-import { type HookMode, writeHookMode } from "./core.js";
+import { getMemoryDir, type HookMode, writeHookMode } from "./core.js";
+
+type ExecFileSyncFn = typeof execFileSync;
+let execFileSyncFn: ExecFileSyncFn = execFileSync;
+
+/** Override the execFileSync implementation used by hook installers (for testing). */
+export function _setHookExecForTest(fn: ExecFileSyncFn): void {
+	execFileSyncFn = fn;
+}
+
+/** Reset the execFileSync implementation to the real one. */
+export function _resetHookExecForTest(): void {
+	execFileSyncFn = execFileSync;
+}
 
 let homeDirOverride: string | null = null;
 
@@ -38,7 +52,7 @@ function commandExists(command: string): boolean {
 // Hook installers (SessionStart auto-injection)
 // ---------------------------------------------------------------------------
 
-export type HookAgentKey = "claude" | "codex" | "cursor" | "opencode" | "pi";
+export type HookAgentKey = "claude" | "codex" | "cursor" | "opencode" | "pi" | "qoder";
 
 export interface HookTargetInfo {
 	key: HookAgentKey;
@@ -109,12 +123,22 @@ function hookTargets(homeDir: string): HookTargetInfo[] {
 		},
 		{
 			key: "pi",
-			label: "pi",
+			label: "pi (via pi-memory)",
 			homeMarker: path.join(homeDir, ".pi"),
 			detectFiles: [],
 			detectCommand: "pi",
-			supported: false,
-			unsupportedReason: "no documented SessionStart hook mechanism",
+			supported: true,
+		},
+		{
+			key: "qoder",
+			label: "Qoder",
+			homeMarker: path.join(homeDir, ".qoder"),
+			detectFiles: [
+				path.join(homeDir, ".qoder", "settings.json"),
+				path.join(homeDir, ".qoder", "settings.local.json"),
+			],
+			detectCommand: "qoder",
+			supported: true,
 		},
 	];
 }
@@ -166,6 +190,14 @@ export function isHookInstalled(homeDir: string, key: HookAgentKey): boolean {
 			const instructionsPath = path.join(homeDir, ".agent-memory", "hooks", "opencode.md");
 			return list.includes(instructionsPath);
 		}
+		if (key === "pi") {
+			// Live filesystem state is authoritative — pi-memory can be installed or
+			// removed outside agent-memory (manually, or via `pi uninstall`) at any
+			// time, so a recorded delegate attempt must never override what's
+			// actually on disk. The state file is diagnostic-only (surfaced
+			// separately in `doctor`'s detail text), not a substitute for this check.
+			return fs.existsSync(path.join(homeDir, ".pi", "agent", "memory"));
+		}
 	} catch {
 		return false;
 	}
@@ -269,6 +301,81 @@ function writeJson(filePath: string, data: unknown) {
 	fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
 }
 
+// ---------------------------------------------------------------------------
+// pi hook support (delegates to the pi-memory extension rather than editing
+// a JSON/TOML hook config — pi's extensibility model is a registered .ts
+// extension, installed via its own package manager).
+// ---------------------------------------------------------------------------
+
+export interface PiMemoryState {
+	lastAttemptAt: string;
+	ok: boolean;
+	detail: string;
+}
+
+function piMemoryStatePath(): string {
+	return path.join(getMemoryDir(), "pi-memory-state.json");
+}
+
+function writePiMemoryState(ok: boolean, detail: string): void {
+	try {
+		writeJson(piMemoryStatePath(), { lastAttemptAt: new Date().toISOString(), ok, detail });
+	} catch {
+		// best-effort bookkeeping only — never block the actual install/uninstall result on this.
+	}
+}
+
+/** Read the last recorded `pi install npm:pi-memory` attempt, if any. Never throws. */
+export function getPiMemoryState(): PiMemoryState | null {
+	try {
+		const filePath = piMemoryStatePath();
+		if (!fs.existsSync(filePath)) return null;
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+		if (typeof parsed?.lastAttemptAt !== "string" || typeof parsed?.ok !== "boolean") return null;
+		return { lastAttemptAt: parsed.lastAttemptAt, ok: parsed.ok, detail: String(parsed.detail ?? "") };
+	} catch {
+		return null;
+	}
+}
+
+function installPiMemoryDelegate(homeDir: string): HookInstallResult {
+	const memoryPath = path.join(homeDir, ".pi", "agent", "memory");
+	try {
+		const stdout = execFileSyncFn("pi", ["install", "npm:pi-memory"], {
+			encoding: "utf-8",
+			timeout: 30_000,
+		});
+		const detail = typeof stdout === "string" ? stdout.trim() : "";
+		writePiMemoryState(true, detail);
+		return { key: "pi", label: "pi (via pi-memory)", installed: true, path: memoryPath, reason: detail || undefined };
+	} catch (err) {
+		const detail =
+			err && typeof err === "object" && "stderr" in err && err.stderr
+				? String(err.stderr).trim()
+				: err instanceof Error
+					? err.message
+					: String(err);
+		writePiMemoryState(false, detail);
+		return { key: "pi", label: "pi (via pi-memory)", installed: false, reason: detail };
+	}
+}
+
+function uninstallPiMemoryDelegate(homeDir: string): HookInstallResult {
+	// agent-memory never owns this install, so it never runs `pi uninstall pi-memory` — but
+	// silently doing nothing would let an `agent-memory uninstall` report read as "fully cleaned
+	// up" while pi-memory keeps running. Phrase the reason distinctly when it's actually still
+	// active so callers (and cmdUninstall's step detail) can surface that honestly.
+	const stillActive = fs.existsSync(path.join(homeDir, ".pi", "agent", "memory"));
+	return {
+		key: "pi",
+		label: "pi (via pi-memory)",
+		installed: false,
+		reason: stillActive
+			? "pi-memory left installed (not managed by agent-memory) — run `pi uninstall pi-memory` to remove it"
+			: "not installed",
+	};
+}
+
 /**
  * Idempotently upsert the agent-memory-managed hook group for `eventKey`
  * (SessionStart or UserPromptSubmit) with `command`. Returns `{ changed,
@@ -581,6 +688,88 @@ function installOpencodeInstructions(homeDir: string): HookInstallResult {
 	return { key: "opencode", label: "opencode", installed: true, path: configPath, backup };
 }
 
+function installQoderHook(homeDir: string): HookInstallResult {
+	const settingsPath = path.join(homeDir, ".qoder", "settings.json");
+	const backup = backupOnce(settingsPath);
+	const settings = readJsonConfig(settingsPath);
+	const hooks = (settings.hooks as Record<string, unknown>) ?? {};
+	const sessionStart = Array.isArray(hooks.SessionStart) ? [...(hooks.SessionStart as unknown[])] : [];
+
+	const command = "agent-memory context";
+	let managed = 0;
+	let updated = 0;
+	for (const group of sessionStart) {
+		if (!group || typeof group !== "object") continue;
+		const g = group as Record<string, unknown>;
+		const list = Array.isArray(g.hooks) ? (g.hooks as unknown[]) : [];
+		for (const hook of list) {
+			if (!hook || typeof hook !== "object") continue;
+			const managedHook = hook as Record<string, unknown>;
+			if (managedHook[HOOK_MARKER_JSON] !== true) continue;
+			managed++;
+			if (managedHook.command !== command) {
+				managedHook.command = command;
+				updated++;
+			}
+		}
+	}
+	if (managed && !updated) {
+		return { key: "qoder", label: "Qoder", installed: false, path: settingsPath, reason: "already installed" };
+	}
+	if (updated) {
+		hooks.SessionStart = sessionStart;
+		settings.hooks = hooks;
+		writeJson(settingsPath, settings);
+		return { key: "qoder", label: "Qoder", installed: true, path: settingsPath, backup, reason: "updated" };
+	}
+
+	sessionStart.push({
+		hooks: [{ type: "command", command, [HOOK_MARKER_JSON]: true }],
+	});
+	hooks.SessionStart = sessionStart;
+	settings.hooks = hooks;
+	writeJson(settingsPath, settings);
+	return { key: "qoder", label: "Qoder", installed: true, path: settingsPath, backup };
+}
+
+function uninstallQoderHook(homeDir: string): HookInstallResult {
+	const settingsPath = path.join(homeDir, ".qoder", "settings.json");
+	if (!fs.existsSync(settingsPath)) {
+		return { key: "qoder", label: "Qoder", installed: false, reason: "not installed" };
+	}
+	const settings = readJsonConfig(settingsPath);
+	const hooks = (settings.hooks as Record<string, unknown>) ?? {};
+	const sessionStart = Array.isArray(hooks.SessionStart) ? (hooks.SessionStart as unknown[]) : [];
+	let removed = 0;
+	const filtered = sessionStart
+		.map((group) => {
+			if (!group || typeof group !== "object") return group;
+			const g = { ...(group as Record<string, unknown>) };
+			const list = Array.isArray(g.hooks) ? (g.hooks as unknown[]) : [];
+			const kept = list.filter((h) => {
+				const isOurs = h && typeof h === "object" && (h as Record<string, unknown>)[HOOK_MARKER_JSON] === true;
+				if (isOurs) removed++;
+				return !isOurs;
+			});
+			g.hooks = kept;
+			return g;
+		})
+		.filter((group) => {
+			if (!group || typeof group !== "object") return true;
+			const g = group as Record<string, unknown>;
+			return Array.isArray(g.hooks) && (g.hooks as unknown[]).length > 0;
+		});
+	if (removed === 0) {
+		return { key: "qoder", label: "Qoder", installed: false, reason: "not installed" };
+	}
+	hooks.SessionStart = filtered;
+	if (filtered.length === 0) delete (hooks as Record<string, unknown>).SessionStart;
+	if (Object.keys(hooks).length === 0) delete (settings as Record<string, unknown>).hooks;
+	else settings.hooks = hooks;
+	writeJson(settingsPath, settings);
+	return { key: "qoder", label: "Qoder", installed: true, path: settingsPath };
+}
+
 export function installHooks(agents: Set<HookAgentKey>, mode: HookMode = "per-turn"): InstallHooksReport {
 	const { homeDir, targets } = detectHookAgents();
 	if (!homeDir) {
@@ -619,6 +808,8 @@ export function installHooks(agents: Set<HookAgentKey>, mode: HookMode = "per-tu
 			else if (target.key === "codex") result = installCodexHook(homeDir, mode);
 			else if (target.key === "cursor") result = installCursorHook(homeDir);
 			else if (target.key === "opencode") result = installOpencodeInstructions(homeDir);
+			else if (target.key === "pi") result = installPiMemoryDelegate(homeDir);
+			else if (target.key === "qoder") result = installQoderHook(homeDir);
 			else continue;
 			results.push(result);
 			if (result.installed) anyInstalled = true;
@@ -773,7 +964,7 @@ export function uninstallHooks(agents?: Set<HookAgentKey>): UninstallHooksReport
 			error: "Home directory not found. Set HOME (or USERPROFILE on Windows) and retry.",
 		};
 	}
-	const keys: HookAgentKey[] = ["claude", "codex", "cursor", "opencode"];
+	const keys: HookAgentKey[] = ["claude", "codex", "cursor", "opencode", "pi", "qoder"];
 	const results: HookInstallResult[] = [];
 	for (const key of keys) {
 		if (agents && !agents.has(key)) continue;
@@ -782,6 +973,8 @@ export function uninstallHooks(agents?: Set<HookAgentKey>): UninstallHooksReport
 			else if (key === "codex") results.push(uninstallCodexHook(homeDir));
 			else if (key === "cursor") results.push(uninstallCursorHook(homeDir));
 			else if (key === "opencode") results.push(uninstallOpencodeInstructions(homeDir));
+			else if (key === "pi") results.push(uninstallPiMemoryDelegate(homeDir));
+			else if (key === "qoder") results.push(uninstallQoderHook(homeDir));
 		} catch (err) {
 			results.push({
 				key,