myagentmemory 0.5.2 → 0.5.4

package/dist/completions.d.ts

@@ -5,9 +5,21 @@ export interface CompletionInstallResult {
     profilePath?: string;
     profileUpdated: boolean;
 }
+export interface CompletionUninstallResult {
+    shell: CompletionShell;
+    completionPath: string;
+    removed: boolean;
+    profilePath?: string;
+    profileUpdated: boolean;
+}
 export declare function generateCompletion(shell: CompletionShell): string;
 export declare function detectCompletionShell(environment?: Record<string, string | undefined>, platform?: NodeJS.Platform): CompletionShell | null;
 export declare function installCompletion(shell: CompletionShell, options?: {
     homeDir?: string;
     platform?: NodeJS.Platform;
 }): CompletionInstallResult;
+/** Reverse of {@link installCompletion} across every supported shell. */
+export declare function uninstallCompletion(options?: {
+    homeDir?: string;
+    platform?: NodeJS.Platform;
+}): CompletionUninstallResult[];

package/dist/completions.js

@@ -395,6 +395,29 @@ function ensureProfileBlock(filePath, lines) {
     fs.writeFileSync(filePath, updated, { mode: 0o600 });
     return true;
 }
+/** Reverse of {@link ensureProfileBlock}: strips the marker block, if present, from the given file. */
+function removeProfileBlock(filePath) {
+    const start = "# >>> agent-memory completion >>>";
+    const end = "# <<< agent-memory completion <<<";
+    if (!fs.existsSync(filePath))
+        return false;
+    const current = fs.readFileSync(filePath, "utf8");
+    const startIndex = current.indexOf(start);
+    const endIndex = startIndex === -1 ? -1 : current.indexOf(end, startIndex);
+    if (startIndex === -1 || endIndex === -1)
+        return false;
+    const updated = (current.slice(0, startIndex) + current.slice(endIndex + end.length)).replace(/\n{3,}/g, "\n\n");
+    if (updated === current)
+        return false;
+    fs.writeFileSync(filePath, updated, { mode: 0o600 });
+    return true;
+}
+function removeCompletionFile(filePath) {
+    if (!fs.existsSync(filePath))
+        return false;
+    fs.unlinkSync(filePath);
+    return true;
+}
 export function installCompletion(shell, options = {}) {
     const homeDir = options.homeDir ?? os.homedir();
     const platform = options.platform ?? process.platform;
@@ -433,3 +456,31 @@ export function installCompletion(shell, options = {}) {
     ]);
     return { shell, completionPath, profilePath, profileUpdated };
 }
+function uninstallShellCompletion(shell, homeDir, platform) {
+    const completionDir = path.join(homeDir, ".config", "agent-memory", "completions");
+    if (shell === "fish") {
+        const completionPath = path.join(homeDir, ".config", "fish", "completions", "agent-memory.fish");
+        return { shell, completionPath, removed: removeCompletionFile(completionPath), profileUpdated: false };
+    }
+    const extension = shell === "powershell" ? "ps1" : shell;
+    const completionPath = path.join(completionDir, `agent-memory.${extension}`);
+    const removed = removeCompletionFile(completionPath);
+    if (shell === "bash") {
+        const profilePath = path.join(homeDir, ".bashrc");
+        return { shell, completionPath, removed, profilePath, profileUpdated: removeProfileBlock(profilePath) };
+    }
+    if (shell === "zsh") {
+        const profilePath = path.join(homeDir, ".zshrc");
+        return { shell, completionPath, removed, profilePath, profileUpdated: removeProfileBlock(profilePath) };
+    }
+    const profilePath = platform === "win32"
+        ? path.join(homeDir, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1")
+        : path.join(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1");
+    return { shell, completionPath, removed, profilePath, profileUpdated: removeProfileBlock(profilePath) };
+}
+/** Reverse of {@link installCompletion} across every supported shell. */
+export function uninstallCompletion(options = {}) {
+    const homeDir = options.homeDir ?? os.homedir();
+    const platform = options.platform ?? process.platform;
+    return ["bash", "zsh", "fish", "powershell"].map((shell) => uninstallShellCompletion(shell, homeDir, platform));
+}

package/dist/core.js

@@ -872,6 +872,17 @@ export function installSkills() {
             destDir: path.join(homeDir, ".cursor", "skills", "agent-memory"),
             homeMarker: path.join(homeDir, ".cursor"),
         },
+        {
+            label: "Qoder skill",
+            srcDir: path.join(skillsDir, "qoder"),
+            destDir: path.join(homeDir, ".qoder", "skills", "agent-memory"),
+            homeMarker: path.join(homeDir, ".qoder"),
+            detectFiles: [
+                path.join(homeDir, ".qoder", "settings.json"),
+                path.join(homeDir, ".qoder", "settings.local.json"),
+            ],
+            detectCommand: "qoder",
+        },
         {
             label: "Agent CLI skill",
             srcDir: path.join(skillsDir, "agent"),

package/dist/hooks.d.ts

@@ -1,7 +1,13 @@
+import { execFileSync } from "node:child_process";
 import { type HookMode } from "./core.js";
+type ExecFileSyncFn = typeof execFileSync;
+/** Override the execFileSync implementation used by hook installers (for testing). */
+export declare function _setHookExecForTest(fn: ExecFileSyncFn): void;
+/** Reset the execFileSync implementation to the real one. */
+export declare function _resetHookExecForTest(): void;
 /** Override the detected home directory in deterministic tests. */
 export declare function _setHookHomeDirForTest(directory: string | null): void;
-export type HookAgentKey = "claude" | "codex" | "cursor" | "opencode" | "pi";
+export type HookAgentKey = "claude" | "codex" | "cursor" | "opencode" | "pi" | "qoder";
 export interface HookTargetInfo {
     key: HookAgentKey;
     label: string;
@@ -52,6 +58,13 @@ export interface InstallHooksReport {
     results: HookInstallResult[];
     error?: string;
 }
+export interface PiMemoryState {
+    lastAttemptAt: string;
+    ok: boolean;
+    detail: string;
+}
+/** Read the last recorded `pi install npm:pi-memory` attempt, if any. Never throws. */
+export declare function getPiMemoryState(): PiMemoryState | null;
 export declare function installHooks(agents: Set<HookAgentKey>, mode?: HookMode): InstallHooksReport;
 export interface UninstallHooksReport {
     ok: boolean;
@@ -60,3 +73,4 @@ export interface UninstallHooksReport {
     error?: string;
 }
 export declare function uninstallHooks(agents?: Set<HookAgentKey>): UninstallHooksReport;
+export {};

package/dist/hooks.js

@@ -1,7 +1,17 @@
+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 { writeHookMode } from "./core.js";
+import { getMemoryDir, writeHookMode } from "./core.js";
+let execFileSyncFn = execFileSync;
+/** Override the execFileSync implementation used by hook installers (for testing). */
+export function _setHookExecForTest(fn) {
+    execFileSyncFn = fn;
+}
+/** Reset the execFileSync implementation to the real one. */
+export function _resetHookExecForTest() {
+    execFileSyncFn = execFileSync;
+}
 let homeDirOverride = null;
 /** Override the detected home directory in deterministic tests. */
 export function _setHookHomeDirForTest(directory) {
@@ -80,12 +90,22 @@ function hookTargets(homeDir) {
         },
         {
             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,
         },
     ];
 }
@@ -143,6 +163,14 @@ export function isHookInstalled(homeDir, key) {
             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;
@@ -232,6 +260,68 @@ function writeJson(filePath, data) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
 }
+function piMemoryStatePath() {
+    return path.join(getMemoryDir(), "pi-memory-state.json");
+}
+function writePiMemoryState(ok, detail) {
+    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() {
+    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) {
+    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) {
+    // 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,
@@ -524,6 +614,93 @@ function installOpencodeInstructions(homeDir) {
     writeJson(configPath, config);
     return { key: "opencode", label: "opencode", installed: true, path: configPath, backup };
 }
+function installQoderHook(homeDir) {
+    const settingsPath = path.join(homeDir, ".qoder", "settings.json");
+    const backup = backupOnce(settingsPath);
+    const settings = readJsonConfig(settingsPath);
+    const hooks = settings.hooks ?? {};
+    const sessionStart = Array.isArray(hooks.SessionStart) ? [...hooks.SessionStart] : [];
+    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;
+        const list = Array.isArray(g.hooks) ? g.hooks : [];
+        for (const hook of list) {
+            if (!hook || typeof hook !== "object")
+                continue;
+            const managedHook = hook;
+            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) {
+    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 ?? {};
+    const sessionStart = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+    let removed = 0;
+    const filtered = sessionStart
+        .map((group) => {
+        if (!group || typeof group !== "object")
+            return group;
+        const g = { ...group };
+        const list = Array.isArray(g.hooks) ? g.hooks : [];
+        const kept = list.filter((h) => {
+            const isOurs = h && typeof h === "object" && h[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;
+        return Array.isArray(g.hooks) && g.hooks.length > 0;
+    });
+    if (removed === 0) {
+        return { key: "qoder", label: "Qoder", installed: false, reason: "not installed" };
+    }
+    hooks.SessionStart = filtered;
+    if (filtered.length === 0)
+        delete hooks.SessionStart;
+    if (Object.keys(hooks).length === 0)
+        delete settings.hooks;
+    else
+        settings.hooks = hooks;
+    writeJson(settingsPath, settings);
+    return { key: "qoder", label: "Qoder", installed: true, path: settingsPath };
+}
 export function installHooks(agents, mode = "per-turn") {
     const { homeDir, targets } = detectHookAgents();
     if (!homeDir) {
@@ -566,6 +743,10 @@ export function installHooks(agents, mode = "per-turn") {
                 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);
@@ -711,7 +892,7 @@ export function uninstallHooks(agents) {
             error: "Home directory not found. Set HOME (or USERPROFILE on Windows) and retry.",
         };
     }
-    const keys = ["claude", "codex", "cursor", "opencode"];
+    const keys = ["claude", "codex", "cursor", "opencode", "pi", "qoder"];
     const results = [];
     for (const key of keys) {
         if (agents && !agents.has(key))
@@ -725,6 +906,10 @@ export function uninstallHooks(agents) {
                 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({

package/dist/mcp-server.d.ts

@@ -17,9 +17,11 @@ export declare class StdioMcpServer {
     private readonly version;
     private readonly tools;
     private readonly startupHooks;
+    private readonly shutdownHooks;
     constructor(version?: string);
     addTool(definition: McpToolDefinition, handler: McpToolHandler): void;
     addStartupHook(fn: () => void | Promise<void>): void;
+    addShutdownHook(fn: () => void | Promise<void>): void;
     start(): Promise<void>;
     private handleMessage;
     private respond;

package/dist/mcp-server.js

@@ -9,6 +9,7 @@ export class StdioMcpServer {
     version;
     tools = new Map();
     startupHooks = [];
+    shutdownHooks = [];
     constructor(version = "0.0.0") {
         this.version = version;
     }
@@ -18,6 +19,9 @@ export class StdioMcpServer {
     addStartupHook(fn) {
         this.startupHooks.push(fn);
     }
+    addShutdownHook(fn) {
+        this.shutdownHooks.push(fn);
+    }
     async start() {
         // Run all startup hooks before entering the message loop.
         for (const hook of this.startupHooks)
@@ -40,6 +44,17 @@ export class StdioMcpServer {
             rl.on("close", resolve);
             process.stdin.on("end", resolve);
         });
+        // A hook may hold resources (e.g. fs.watch handles) that keep the event
+        // loop alive past stdin close — run them, but don't let one broken hook
+        // block the others or block process exit.
+        for (const hook of this.shutdownHooks) {
+            try {
+                await hook();
+            }
+            catch {
+                // Non-fatal — the caller still hard-exits after start() returns.
+            }
+        }
     }
     handleMessage(msg) {
         const id = msg.id;

package/dist/plugin-host.d.ts

@@ -147,7 +147,12 @@ export interface PluginMcpToolInputSchema {
 export interface PluginMcpToolV1 {
     name: string;
     description: string;
-    requiredCapability: string;
+    /**
+     * Capability checked on every invocation. Optional only to keep plugin API 1
+     * source-compatible with bundles built before capability-gated MCP tools
+     * were introduced; legacy tools load but are denied until updated.
+     */
+    requiredCapability?: string;
     inputSchema: PluginMcpToolInputSchema;
     run(input: Record<string, unknown>): unknown | Promise<unknown>;
 }
@@ -160,6 +165,7 @@ export interface AgentMemoryPluginHostV1 {
     registerContextProvider?(provider: PluginContextProviderV1): void;
     registerMcpTool?(tool: PluginMcpToolV1): void;
     registerMcpStartup?(fn: () => void | Promise<void>): void;
+    registerMcpShutdown?(fn: () => void | Promise<void>): void;
     getStateDirectory(): string;
     getMemoryDirectory(): string;
     getEntitlement(): Promise<PluginEntitlementStatusV1>;

package/dist/plugin-runtime.d.ts

@@ -15,6 +15,7 @@ export declare class InstalledPluginRuntimeV1 {
     private readonly contextProviders;
     private readonly mcpTools;
     private readonly mcpStartupHooks;
+    private readonly mcpShutdownHooks;
     private loaded;
     constructor(options: PluginRuntimeOptionsV1);
     load(): Promise<boolean>;
@@ -44,6 +45,7 @@ export declare class InstalledPluginRuntimeV1 {
      */
     runMcpTool(name: string, input: Record<string, unknown>): Promise<unknown>;
     runMcpStartup(): Promise<void>;
+    runMcpShutdown(): Promise<void>;
     private createHost;
     private refreshEntitlement;
 }

package/dist/plugin-runtime.js

@@ -65,6 +65,7 @@ export class InstalledPluginRuntimeV1 {
     contextProviders = [];
     mcpTools = [];
     mcpStartupHooks = [];
+    mcpShutdownHooks = [];
     loaded = false;
     constructor(options) {
         this.options = options;
@@ -200,6 +201,10 @@ export class InstalledPluginRuntimeV1 {
         const tool = this.mcpTools.find((candidate) => candidate.name === name);
         if (!tool)
             return { error: `Unknown MCP tool: ${name}` };
+        if (!tool.requiredCapability)
+            return {
+                error: `The ${name} tool was built for an older plugin API and must be updated before it can run`,
+            };
         const entitlement = await this.refreshEntitlement();
         if (!isPluginCapabilityEnabled(entitlement, tool.requiredCapability))
             return { error: `Capability ${tool.requiredCapability} is not enabled for the ${name} tool` };
@@ -209,6 +214,10 @@ export class InstalledPluginRuntimeV1 {
         for (const hook of this.mcpStartupHooks)
             await hook();
     }
+    async runMcpShutdown() {
+        for (const hook of this.mcpShutdownHooks)
+            await hook();
+    }
     createHost(manifest) {
         const descriptors = new Map(manifest.commands.map((command) => [command.name, command]));
         const stateRoot = path.join(this.store.root, "state");
@@ -257,7 +266,7 @@ export class InstalledPluginRuntimeV1 {
                 this.contextProviders.push({ provider, pluginId: manifest.id });
             },
             registerMcpTool: (tool) => {
-                if (!(manifest.capabilities ?? []).includes(tool.requiredCapability))
+                if (tool.requiredCapability && !(manifest.capabilities ?? []).includes(tool.requiredCapability))
                     throw new PluginBootstrapFailure("plugin_mcp_tool_invalid", `Plugin ${manifest.id} registered an MCP tool with an undeclared capability`);
                 if (!tool.name || this.mcpTools.some((existing) => existing.name === tool.name))
                     throw new PluginBootstrapFailure("plugin_mcp_tool_invalid", `Plugin MCP tool ${tool.name || "(unnamed)"} is invalid or already registered`);
@@ -266,6 +275,9 @@ export class InstalledPluginRuntimeV1 {
             registerMcpStartup: (fn) => {
                 this.mcpStartupHooks.push(fn);
             },
+            registerMcpShutdown: (fn) => {
+                this.mcpShutdownHooks.push(fn);
+            },
             getStateDirectory: () => stateDirectory,
             getMemoryDirectory: () => {
                 assertPermission(manifest, "memory:read");

package/dist/plugin-service.d.ts

@@ -1,4 +1,4 @@
-import { type PluginAccessDecisionV1, type PluginBootstrapBackendV1, type PluginNextActionV1, type PluginSessionUsageDecisionV1, type SignedPluginReleaseV1 } from "./plugin-bootstrap.js";
+import { type PluginAccessDecisionV1, type PluginBootstrapBackendV1, type PluginNextActionV1, type SignedPluginReleaseV1 } from "./plugin-bootstrap.js";
 import { type PluginEntitlementStatusV1 } from "./plugin-host.js";
 interface AgentMemoryServiceBackendOptions {
     root?: string;
@@ -27,9 +27,6 @@ export declare class AgentMemoryServiceBackend implements PluginBootstrapBackend
         channel: string;
         allowAuthentication: boolean;
     }): Promise<PluginAccessDecisionV1>;
-    reserveSession(operationId: string): Promise<PluginSessionUsageDecisionV1>;
-    commitSession(operationId: string): Promise<PluginSessionUsageDecisionV1>;
-    releaseSession(operationId: string): Promise<PluginSessionUsageDecisionV1>;
     listReleases(request: {
         bundleId: string;
         channel: string;
@@ -43,7 +40,6 @@ export declare class AgentMemoryServiceBackend implements PluginBootstrapBackend
     private activationPath;
     private readActivation;
     private writeActivation;
-    private sessionUsage;
     private request;
 }
 export declare class TemporaryPluginBackend extends AgentMemoryServiceBackend {