myagentmemory 0.4.4 → 0.4.6

package/README.md

@@ -23,8 +23,7 @@ bun run build:cli
 agent-memory init
 
 # Install skill files for Claude Code, Codex, Cursor, and Agent
-bash scripts/install-skills.sh
-pwsh -File scripts/install-skills.ps1
+agent-memory install-skills
 ```
 
 This installs:
@@ -84,6 +83,7 @@ The memory directory defaults to `~/.agent-memory/`. Override with `AGENT_MEMORY
 | `agent-memory read --target <long_term\|scratchpad\|daily\|list> [--date YYYY-MM-DD]` | Read memory files |
 | `agent-memory scratchpad <add\|done\|undo\|clear_done\|list> [--text <text>]` | Manage checklist |
 | `agent-memory search --query <text> [--mode keyword\|semantic\|deep] [--limit N]` | Search via qmd |
+| `agent-memory install-skills` | Install bundled SKILL.md files into local agent directories |
 | `agent-memory init` | Create dirs, detect qmd, setup collection |
 | `agent-memory status` | Show config, qmd status, file counts |
 
@@ -186,8 +186,7 @@ bun run build:cli
 agent-memory write --target long_term --content "test" && agent-memory read --target long_term
 
 # Install skills
-bash scripts/install-skills.sh
-pwsh -File scripts/install-skills.ps1
+agent-memory install-skills
 ```
 
 ## Publishing (maintainers)

package/dist/cli.d.ts

@@ -3,6 +3,8 @@
  * agent-memory CLI
  *
  * Subcommands:
+ *   version    — Print binary version
+ *   install-skills — Install SKILL.md files into local agent directories
  *   context    — Build & print context injection string to stdout
  *   write      — Write to memory files
  *   read       — Read memory files

package/dist/cli.js

@@ -3,6 +3,8 @@
  * agent-memory CLI
  *
  * Subcommands:
+ *   version    — Print binary version
+ *   install-skills — Install SKILL.md files into local agent directories
  *   context    — Build & print context injection string to stdout
  *   write      — Write to memory files
  *   read       — Read memory files
@@ -16,7 +18,8 @@
  *   --json         Machine-readable JSON output
  */
 import * as fs from "node:fs";
-import { _setBaseDir, buildMemoryContext, checkCollection, dailyPath, detectQmd, ensureDirs, ensureQmdAvailableForUpdate, getCollectionName, getDailyDir, getMemoryDir, getMemoryFile, getQmdResultPath, getQmdResultText, getScratchpadFile, nowTimestamp, parseScratchpad, readFileSafe, runQmdSearch, scheduleQmdUpdate, searchRelevantMemories, serializeScratchpad, setupQmdCollection, todayStr, } from "./core.js";
+const VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "dev";
+import { _setBaseDir, buildMemoryContext, checkCollection, dailyPath, detectQmd, ensureDirs, ensureQmdAvailableForSync, ensureQmdAvailableForUpdate, getCollectionName, getDailyDir, getMemoryDir, getMemoryFile, getQmdEmbedMode, getQmdHealth, getQmdResultPath, getQmdResultText, getScratchpadFile, installSkills, nowTimestamp, parseScratchpad, readFileSafe, runQmdEmbedDetached, runQmdSearch, runQmdSync, runQmdUpdateNow, scheduleQmdUpdate, searchRelevantMemories, serializeScratchpad, setupQmdCollection, todayStr, } from "./core.js";
 function parseArgs(argv) {
     const flags = {};
     const positional = [];
@@ -319,18 +322,91 @@ async function cmdSearch(flags) {
         exitError(`Search failed: ${err instanceof Error ? err.message : String(err)}`, json);
     }
 }
+function cmdInstallSkills(flags) {
+    const json = hasFlag(flags, "json");
+    const report = installSkills();
+    if (!report.ok) {
+        exitError(report.error ?? "Failed to install skills.", json);
+    }
+    if (json) {
+        output(report, true);
+        return;
+    }
+    if (report.detected.length === 0) {
+        console.log("No supported agent installations detected.");
+    }
+    else {
+        const detectedLabels = report.detected.map((item) => item.label).join(", ");
+        console.log(`Detected: ${detectedLabels}`);
+    }
+    if (report.installed.length === 0) {
+        console.log("No skills installed.");
+    }
+    else {
+        for (const item of report.installed) {
+            console.log(`Installed ${item.label}: ${item.path}`);
+        }
+    }
+    if (report.skipped.length > 0) {
+        for (const item of report.skipped) {
+            console.log(`Skipped ${item.label} (${item.reason})`);
+        }
+    }
+}
+async function cmdSync(flags) {
+    const json = hasFlag(flags, "json");
+    ensureDirs();
+    const qmdFound = await ensureQmdAvailableForSync();
+    if (!qmdFound) {
+        exitError("qmd is not installed. Install: bun install -g https://github.com/tobi/qmd", json);
+    }
+    const collName = getCollectionName();
+    const hasCollection = await checkCollection(collName);
+    if (!hasCollection) {
+        exitError(`qmd collection '${collName}' not found. Run: agent-memory init`, json);
+    }
+    const result = await runQmdSync();
+    if (json) {
+        output({ ok: result.updateOk && result.embedOk, updateOk: result.updateOk, embedOk: result.embedOk }, true);
+    }
+    else {
+        if (result.updateOk) {
+            console.log("qmd update: ok");
+        }
+        else {
+            console.log("qmd update: failed");
+        }
+        if (result.embedOk) {
+            console.log("qmd embed: ok");
+        }
+        else {
+            console.log("qmd embed: failed");
+        }
+        if (result.updateOk && result.embedOk) {
+            console.log("\nIndex fully synced.");
+        }
+    }
+}
 async function cmdInit(flags) {
     const json = hasFlag(flags, "json");
     ensureDirs();
     const dir = getMemoryDir();
     const qmdFound = await detectQmd();
     let collectionCreated = false;
+    let indexUpdated = false;
+    let embedStarted = false;
     if (qmdFound) {
         const collName = getCollectionName();
         const hasCollection = await checkCollection(collName);
         if (!hasCollection) {
             collectionCreated = await setupQmdCollection();
         }
+        // Run initial index update + start background embed
+        await ensureQmdAvailableForUpdate();
+        await runQmdUpdateNow();
+        indexUpdated = true;
+        const child = runQmdEmbedDetached();
+        embedStarted = child !== null;
     }
     if (json) {
         output({
@@ -338,6 +414,8 @@ async function cmdInit(flags) {
             directory: dir,
             qmd: qmdFound,
             collectionCreated,
+            indexUpdated,
+            embedStarted,
         }, true);
     }
     else {
@@ -350,6 +428,12 @@ async function cmdInit(flags) {
             else {
                 console.log(`  qmd collection '${getCollectionName()}' already exists.`);
             }
+            if (indexUpdated) {
+                console.log(`  Index updated.`);
+            }
+            if (embedStarted) {
+                console.log(`  Embedding started in background.`);
+            }
         }
         else {
             console.log(`  qmd not found — search features unavailable.`);
@@ -375,9 +459,15 @@ async function cmdStatus(flags) {
     }
     const qmdFound = await detectQmd();
     let hasCollection = false;
+    let health = null;
     if (qmdFound) {
         hasCollection = await checkCollection();
+        if (hasCollection) {
+            await ensureQmdAvailableForSync();
+            health = await getQmdHealth();
+        }
     }
+    const embedMode = getQmdEmbedMode();
     if (json) {
         output({
             directory: dir,
@@ -395,7 +485,9 @@ async function cmdStatus(flags) {
             qmd: {
                 available: qmdFound,
                 collection: hasCollection ? getCollectionName() : null,
+                health,
             },
+            embedMode,
         }, true);
     }
     else {
@@ -421,6 +513,19 @@ async function cmdStatus(flags) {
         if (qmdFound) {
             console.log(`qmd: available`);
             console.log(`Collection '${getCollectionName()}': ${hasCollection ? "configured" : "not configured — run: agent-memory init"}`);
+            console.log(`Embed mode: ${embedMode}`);
+            if (health) {
+                if (health.totalFiles !== null)
+                    console.log(`Files indexed: ${health.totalFiles}`);
+                if (health.vectorsEmbedded !== null)
+                    console.log(`Vectors embedded: ${health.vectorsEmbedded}`);
+                if (health.pendingEmbed !== null && health.pendingEmbed > 0) {
+                    console.log(`Pending embeds: ${health.pendingEmbed}`);
+                    console.log(`  run: agent-memory sync`);
+                }
+                if (health.lastUpdated)
+                    console.log(`Last updated: ${health.lastUpdated}`);
+            }
         }
         else {
             console.log("qmd: not installed");
@@ -437,11 +542,14 @@ Usage:
   agent-memory <command> [options]
 
 Commands:
+  version     Show binary version
+  install-skills  Install bundled skills into local agent directories
   context     Build & print context injection string
   write       Write to memory files
   read        Read memory files
   scratchpad  Manage checklist items
   search      Search across memory files (requires qmd)
+  sync        Re-index and embed all files (requires qmd)
   init        Initialize memory directory and qmd collection
   status      Show configuration and status
 
@@ -461,6 +569,7 @@ Examples:
   agent-memory scratchpad done --text "PR #42"
   agent-memory search --query "database choice" --mode keyword
   agent-memory context --no-search
+  agent-memory sync
   agent-memory status --json`);
 }
 // ---------------------------------------------------------------------------
@@ -474,6 +583,10 @@ async function main() {
     if (dir) {
         _setBaseDir(dir);
     }
+    if (command === "version" || hasFlag(flags, "version")) {
+        output(json ? { version: VERSION } : VERSION, json);
+        return;
+    }
     if (!command || command === "help" || hasFlag(flags, "help")) {
         printUsage();
         return;
@@ -494,6 +607,12 @@ async function main() {
         case "search":
             await cmdSearch(flags);
             break;
+        case "install-skills":
+            cmdInstallSkills(flags);
+            break;
+        case "sync":
+            await cmdSync(flags);
+            break;
         case "init":
             await cmdInit(flags);
             break;

package/dist/core.d.ts

@@ -4,7 +4,8 @@
  * Core logic for agent-memory CLI and skills.
  * Zero pi peer dependencies — only node:fs, node:path, node:child_process.
  */
-import { execFile } from "node:child_process";
+import type { ChildProcess } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 /** Override base directory (for testing or platform-specific defaults). */
 export declare function _setBaseDir(baseDir: string): void;
 /** Reset to default paths. */
@@ -59,10 +60,19 @@ export declare function parseScratchpad(content: string): ScratchpadItem[];
 export declare function serializeScratchpad(items: ScratchpadItem[]): string;
 export declare function buildMemoryContext(searchResults?: string): string;
 type ExecFileFn = typeof execFile;
+type SpawnFn = typeof spawn;
 /** Override execFile implementation (for testing). */
 export declare function _setExecFileForTest(fn: ExecFileFn): void;
 /** Reset execFile implementation (for testing). */
 export declare function _resetExecFileForTest(): void;
+/** Override skills root directory (for testing). */
+export declare function _setSkillsRootForTest(dir: string | null): void;
+/** Override home directory (for testing). */
+export declare function _setHomeDirForTest(dir: string | null): void;
+/** Override spawn implementation (for testing). */
+export declare function _setSpawnForTest(fn: SpawnFn): void;
+/** Reset spawn implementation (for testing). */
+export declare function _resetSpawnForTest(): void;
 /** Set qmd availability flag (for testing). */
 export declare function _setQmdAvailable(value: boolean): void;
 /** Get current qmd availability flag. */
@@ -71,6 +81,10 @@ export declare function _getQmdAvailable(): boolean;
 export declare function _getUpdateTimer(): ReturnType<typeof setTimeout> | null;
 /** Clear the update timer (for testing). */
 export declare function _clearUpdateTimer(): void;
+/** Get current embed timer (for testing). */
+export declare function _getEmbedTimer(): ReturnType<typeof setTimeout> | null;
+/** Clear the embed timer (for testing). */
+export declare function _clearEmbedTimer(): void;
 /** Get the current QMD collection name. */
 export declare function getCollectionName(): string;
 /** Set the QMD collection name (for platform-specific overrides). */
@@ -83,8 +97,47 @@ export declare function detectQmd(): Promise<boolean>;
 export declare function checkCollection(name?: string): Promise<boolean>;
 export declare function getQmdUpdateMode(): "background" | "manual" | "off";
 export declare function ensureQmdAvailableForUpdate(): Promise<boolean>;
+export declare function getQmdEmbedMode(): "background" | "manual" | "off";
+export declare function runQmdEmbedDetached(): ChildProcess | null;
+export declare function scheduleQmdEmbed(): void;
 export declare function scheduleQmdUpdate(): void;
 export declare function runQmdUpdateNow(): Promise<void>;
+export declare function runQmdEmbedNow(): Promise<boolean>;
+export declare function ensureQmdAvailableForSync(): Promise<boolean>;
+export declare function runQmdSync(): Promise<{
+    updateOk: boolean;
+    embedOk: boolean;
+}>;
+export interface InstallSkillsReport {
+    ok: boolean;
+    projectDir?: string;
+    homeDir?: string;
+    detected: Array<{
+        label: string;
+        homeMarker: string;
+    }>;
+    installed: Array<{
+        label: string;
+        path: string;
+    }>;
+    skipped: Array<{
+        label: string;
+        reason: string;
+    }>;
+    error?: string;
+}
+export declare function installSkills(): InstallSkillsReport;
+export interface QmdHealthInfo {
+    totalFiles: number | null;
+    vectorsEmbedded: number | null;
+    pendingEmbed: number | null;
+    lastUpdated: string | null;
+    collectionFiles: number | null;
+    collectionUpdated: string | null;
+    embedMode: string;
+}
+export declare function parseQmdStatus(stdout: string, collectionName: string): QmdHealthInfo;
+export declare function getQmdHealth(): Promise<QmdHealthInfo | null>;
 /** Search for memories relevant to the user's prompt. Returns formatted markdown or empty string on error. */
 export declare function searchRelevantMemories(prompt: string): Promise<string>;
 export interface QmdSearchResult {

package/dist/core.js

@@ -4,7 +4,7 @@
  * Core logic for agent-memory CLI and skills.
  * Zero pi peer dependencies — only node:fs, node:path, node:child_process.
  */
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 // ---------------------------------------------------------------------------
@@ -280,8 +280,12 @@ export function buildMemoryContext(searchResults) {
     return context;
 }
 let execFileFn = execFile;
+let spawnFn = spawn;
 let qmdAvailable = false;
 let updateTimer = null;
+let embedTimer = null;
+let skillsRootOverride = null;
+let homeDirOverride = null;
 /** QMD collection name — configurable per platform. */
 let QMD_COLLECTION_NAME = "agent-memory";
 /** Override execFile implementation (for testing). */
@@ -292,6 +296,22 @@ export function _setExecFileForTest(fn) {
 export function _resetExecFileForTest() {
     execFileFn = execFile;
 }
+/** Override skills root directory (for testing). */
+export function _setSkillsRootForTest(dir) {
+    skillsRootOverride = dir;
+}
+/** Override home directory (for testing). */
+export function _setHomeDirForTest(dir) {
+    homeDirOverride = dir;
+}
+/** Override spawn implementation (for testing). */
+export function _setSpawnForTest(fn) {
+    spawnFn = fn;
+}
+/** Reset spawn implementation (for testing). */
+export function _resetSpawnForTest() {
+    spawnFn = spawn;
+}
 /** Set qmd availability flag (for testing). */
 export function _setQmdAvailable(value) {
     qmdAvailable = value;
@@ -311,6 +331,51 @@ export function _clearUpdateTimer() {
         updateTimer = null;
     }
 }
+/** Get current embed timer (for testing). */
+export function _getEmbedTimer() {
+    return embedTimer;
+}
+/** Clear the embed timer (for testing). */
+export function _clearEmbedTimer() {
+    if (embedTimer) {
+        clearTimeout(embedTimer);
+        embedTimer = null;
+    }
+}
+function resolveHomeDir() {
+    if (homeDirOverride !== null)
+        return homeDirOverride;
+    return process.env.HOME ?? process.env.USERPROFILE ?? null;
+}
+function findSkillsRoot() {
+    const envRoot = process.env.AGENT_MEMORY_SKILLS_ROOT;
+    if (envRoot)
+        return envRoot;
+    if (skillsRootOverride)
+        return skillsRootOverride;
+    const scanUp = (startDir) => {
+        let dir = startDir;
+        while (true) {
+            if (fs.existsSync(path.join(dir, "skills")))
+                return dir;
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return null;
+            dir = parent;
+        }
+    };
+    const argvPath = process.argv[1];
+    if (argvPath) {
+        const found = scanUp(path.resolve(path.dirname(argvPath)));
+        if (found)
+            return found;
+    }
+    const execDir = path.dirname(process.execPath);
+    const found = scanUp(path.resolve(execDir));
+    if (found)
+        return found;
+    return scanUp(path.resolve(process.cwd()));
+}
 /** Get the current QMD collection name. */
 export function getCollectionName() {
     return QMD_COLLECTION_NAME;
@@ -425,6 +490,39 @@ export async function ensureQmdAvailableForUpdate() {
     qmdAvailable = await detectQmd();
     return qmdAvailable;
 }
+export function getQmdEmbedMode() {
+    const mode = (process.env.AGENT_MEMORY_QMD_EMBED ?? "background").toLowerCase();
+    if (mode === "manual" || mode === "off" || mode === "background") {
+        return mode;
+    }
+    return "background";
+}
+export function runQmdEmbedDetached() {
+    if (!qmdAvailable)
+        return null;
+    const child = spawnFn("qmd", ["embed"], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    return child;
+}
+export function scheduleQmdEmbed() {
+    if (getQmdEmbedMode() !== "background")
+        return;
+    if (!qmdAvailable)
+        return;
+    if (embedTimer)
+        clearTimeout(embedTimer);
+    embedTimer = setTimeout(() => {
+        embedTimer = null;
+        runQmdEmbedDetached();
+    }, 5_000);
+    // Don't prevent process exit while waiting to embed
+    if (embedTimer && typeof embedTimer === "object" && "unref" in embedTimer) {
+        embedTimer.unref();
+    }
+}
 export function scheduleQmdUpdate() {
     if (getQmdUpdateMode() !== "background")
         return;
@@ -434,7 +532,9 @@ export function scheduleQmdUpdate() {
         clearTimeout(updateTimer);
     updateTimer = setTimeout(() => {
         updateTimer = null;
-        execFileFn("qmd", ["update"], { timeout: 30_000 }, () => { });
+        execFileFn("qmd", ["update"], { timeout: 30_000 }, () => {
+            scheduleQmdEmbed();
+        });
     }, 500);
 }
 export async function runQmdUpdateNow() {
@@ -446,6 +546,176 @@ export async function runQmdUpdateNow() {
         execFileFn("qmd", ["update"], { timeout: 30_000 }, () => resolve());
     });
 }
+export async function runQmdEmbedNow() {
+    if (!qmdAvailable)
+        return false;
+    return new Promise((resolve) => {
+        execFileFn("qmd", ["embed"], { timeout: 120_000 }, (err) => {
+            resolve(!err);
+        });
+    });
+}
+export async function ensureQmdAvailableForSync() {
+    if (qmdAvailable)
+        return true;
+    qmdAvailable = await detectQmd();
+    return qmdAvailable;
+}
+export async function runQmdSync() {
+    if (!qmdAvailable)
+        return { updateOk: false, embedOk: false };
+    const updateOk = await new Promise((resolve) => {
+        execFileFn("qmd", ["update"], { timeout: 30_000 }, (err) => {
+            resolve(!err);
+        });
+    });
+    const embedOk = await runQmdEmbedNow();
+    return { updateOk, embedOk };
+}
+export function installSkills() {
+    const homeDir = resolveHomeDir();
+    if (!homeDir) {
+        return {
+            ok: false,
+            detected: [],
+            installed: [],
+            skipped: [],
+            error: "Home directory not found. Set HOME (or USERPROFILE on Windows) and retry.",
+        };
+    }
+    const projectDir = findSkillsRoot();
+    if (!projectDir) {
+        return {
+            ok: false,
+            homeDir,
+            detected: [],
+            installed: [],
+            skipped: [],
+            error: "Could not locate the skills directory. Ensure the package includes skills/ (reinstall if needed).",
+        };
+    }
+    const skillsDir = path.join(projectDir, "skills");
+    if (!fs.existsSync(skillsDir)) {
+        return {
+            ok: false,
+            projectDir,
+            homeDir,
+            detected: [],
+            installed: [],
+            skipped: [],
+            error: `Skills directory not found: ${skillsDir}`,
+        };
+    }
+    const targets = [
+        {
+            label: "Claude Code skill",
+            srcDir: path.join(skillsDir, "claude-code"),
+            destDir: path.join(homeDir, ".claude", "skills", "agent-memory"),
+            homeMarker: path.join(homeDir, ".claude"),
+        },
+        {
+            label: "Codex skill",
+            srcDir: path.join(skillsDir, "codex"),
+            destDir: path.join(homeDir, ".codex", "skills", "agent-memory"),
+            homeMarker: path.join(homeDir, ".codex"),
+        },
+        {
+            label: "Cursor skill",
+            srcDir: path.join(skillsDir, "cursor"),
+            destDir: path.join(homeDir, ".cursor", "skills", "agent-memory"),
+            homeMarker: path.join(homeDir, ".cursor"),
+        },
+        {
+            label: "Agent CLI skill",
+            srcDir: path.join(skillsDir, "agent"),
+            destDir: path.join(homeDir, ".agents", "skills", "agent-memory"),
+            homeMarker: path.join(homeDir, ".agents"),
+        },
+    ];
+    const detected = [];
+    const installed = [];
+    const skipped = [];
+    for (const target of targets) {
+        if (!fs.existsSync(target.homeMarker)) {
+            skipped.push({ label: target.label, reason: `${target.homeMarker} not found` });
+            continue;
+        }
+        detected.push({ label: target.label, homeMarker: target.homeMarker });
+        const skillFile = path.join(target.srcDir, "SKILL.md");
+        if (!fs.existsSync(skillFile)) {
+            skipped.push({ label: target.label, reason: `${skillFile} not found` });
+            continue;
+        }
+        fs.mkdirSync(target.destDir, { recursive: true });
+        fs.copyFileSync(skillFile, path.join(target.destDir, "SKILL.md"));
+        installed.push({ label: target.label, path: path.join(target.destDir, "SKILL.md") });
+    }
+    return {
+        ok: true,
+        projectDir,
+        homeDir,
+        detected,
+        installed,
+        skipped,
+    };
+}
+export function parseQmdStatus(stdout, collectionName) {
+    const result = {
+        totalFiles: null,
+        vectorsEmbedded: null,
+        pendingEmbed: null,
+        lastUpdated: null,
+        collectionFiles: null,
+        collectionUpdated: null,
+        embedMode: getQmdEmbedMode(),
+    };
+    if (!stdout.trim())
+        return result;
+    // Total files across all collections
+    const totalFilesMatch = stdout.match(/(\d+)\s+(?:total\s+)?files?/i);
+    if (totalFilesMatch) {
+        result.totalFiles = Number.parseInt(totalFilesMatch[1], 10);
+    }
+    // Vectors / embeddings
+    const vectorsMatch = stdout.match(/(\d+)\s+(?:vectors?|embeddings?)/i);
+    if (vectorsMatch) {
+        result.vectorsEmbedded = Number.parseInt(vectorsMatch[1], 10);
+    }
+    // Pending embed
+    const pendingMatch = stdout.match(/(\d+)\s+pending/i);
+    if (pendingMatch) {
+        result.pendingEmbed = Number.parseInt(pendingMatch[1], 10);
+    }
+    // If we have totalFiles and vectorsEmbedded but no explicit pending, infer it
+    if (result.pendingEmbed === null && result.totalFiles !== null && result.vectorsEmbedded !== null) {
+        result.pendingEmbed = Math.max(0, result.totalFiles - result.vectorsEmbedded);
+    }
+    // Last updated timestamp
+    const updatedMatch = stdout.match(/(?:last\s+)?updated:?\s+(\d{4}-\d{2}-\d{2}[\sT]\d{2}:\d{2}[:\d]*)/i);
+    if (updatedMatch) {
+        result.lastUpdated = updatedMatch[1];
+    }
+    // Collection-specific info — look for collection name section
+    const collectionPattern = new RegExp(`${collectionName}[:\\s]*(?:.*?)(\\d+)\\s+files?`, "i");
+    const collMatch = stdout.match(collectionPattern);
+    if (collMatch) {
+        result.collectionFiles = Number.parseInt(collMatch[1], 10);
+    }
+    return result;
+}
+export async function getQmdHealth() {
+    if (!qmdAvailable)
+        return null;
+    return new Promise((resolve) => {
+        execFileFn("qmd", ["status"], { timeout: 10_000 }, (err, stdout) => {
+            if (err) {
+                resolve(null);
+                return;
+            }
+            resolve(parseQmdStatus(stdout ?? "", QMD_COLLECTION_NAME));
+        });
+    });
+}
 /** Search for memories relevant to the user's prompt. Returns formatted markdown or empty string on error. */
 export async function searchRelevantMemories(prompt) {
     if (!qmdAvailable || !prompt.trim())

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "myagentmemory",
-	"version": "0.4.4",
+	"version": "0.4.6",
 	"description": "Persistent memory for coding agents (Claude Code, Codex, Cursor, Agent) with qmd-powered semantic search across daily logs, long-term memory, and scratchpad",
 	"main": "./dist/core.js",
 	"types": "./dist/core.d.ts",
@@ -52,7 +52,7 @@
 		"postinstall": "node scripts/postinstall.cjs",
 		"build": "tsc -p tsconfig.json --noEmit",
 		"build:lib": "tsc -p tsconfig.build.json",
-		"build:cli": "bun build src/cli.ts --compile --outfile dist/agent-memory",
+		"build:cli": "bun build src/cli.ts --compile --outfile dist/agent-memory --define __VERSION__=\"'$(node -p \"require('./package.json').version\")'\"",
 		"prepack": "npm run build:lib && bun run build:cli",
 		"lint": "biome check .",
 		"test": "bun test test/unit.test.ts",