freeharness 0.4.1 → 0.4.2

package/dist/adapters/memory/paths.js

@@ -0,0 +1,85 @@
+// The CLI cannot import the engine: a copy of engine/shared/data-dir.ts and paths.ts resolveDbPath.
+import fs from "node:fs";
+import path from "node:path";
+export const FREE_DIR_NAME = ".free-mem";
+export const LEGACY_DIR_NAME = ".claude-mem";
+export const DB_FILENAME = "free-mem.db";
+export const LEGACY_DB_FILENAME = "claude-mem.db";
+const DATA_DIR_KEYS = ["FREE_MEM_DATA_DIR", "CLAUDE_MEM_DATA_DIR"];
+function expandHome(p, home) {
+    if (p === "~")
+        return home;
+    if (p.startsWith("~/"))
+        return path.join(home, p.slice(2));
+    return p;
+}
+function isDirectory(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** A settings file's keys as the engine reads them (BOM dropped, `env` first); null when unreadable. */
+export function readMemorySettings(settingsPath) {
+    try {
+        if (!fs.existsSync(settingsPath))
+            return null;
+        const raw = JSON.parse(fs.readFileSync(settingsPath, "utf8").replace(/^/, ""));
+        const settings = raw.env ?? raw;
+        return settings !== null && typeof settings === "object" ? settings : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Either default directory is a seeded value, not a redirect; honoring it pins later starts.
+function settingsDataDir(settingsPath, home, defaultDirs) {
+    const settings = readMemorySettings(settingsPath);
+    if (!settings)
+        return undefined;
+    for (const key of DATA_DIR_KEYS) {
+        const value = settings[key];
+        if (typeof value !== "string" || !value)
+            continue;
+        const dir = expandHome(value, home);
+        if (!defaultDirs.includes(path.resolve(dir)))
+            return dir;
+    }
+    return undefined;
+}
+function dbFileIn(dataDir) {
+    const current = path.join(dataDir, DB_FILENAME);
+    const legacy = path.join(dataDir, LEGACY_DB_FILENAME);
+    return !fs.existsSync(current) && fs.existsSync(legacy) ? legacy : current;
+}
+/**
+ * Resolves the memory data directory and database from `env` and `home` alone, never from
+ * process globals, so callers and tests can pass fake values.
+ * @param env Environment to read `FREE_MEM_DATA_DIR` and `CLAUDE_MEM_DATA_DIR` from.
+ * @param home Home directory that holds `.free-mem` and `.claude-mem` and expands `~`.
+ */
+export function resolveMemoryPaths(env, home) {
+    const freeDir = path.join(home, FREE_DIR_NAME);
+    const legacyDir = path.join(home, LEGACY_DIR_NAME);
+    const defaultDirs = [path.resolve(freeDir), path.resolve(legacyDir)];
+    const result = (dataDir, source) => ({
+        dataDir,
+        dbFile: dbFileIn(dataDir),
+        legacy: path.resolve(dataDir) === defaultDirs[1],
+        source,
+    });
+    for (const key of DATA_DIR_KEYS) {
+        const value = env[key];
+        if (value)
+            return result(expandHome(value, home), key);
+    }
+    for (const dir of [freeDir, legacyDir]) {
+        const redirect = settingsDataDir(path.join(dir, "settings.json"), home, defaultDirs);
+        if (redirect)
+            return result(redirect, "settings");
+    }
+    // An unmigrated install keeps serving its legacy directory until the copy creates ~/.free-mem.
+    return isDirectory(freeDir) || !isDirectory(legacyDir) ? result(freeDir, "default") : result(legacyDir, "fallback");
+}

package/dist/adapters/memory/vendored.d.ts

@@ -16,7 +16,7 @@ export declare const UPSTREAM_PLUGIN_KEY = "claude-mem@thedotmack";
  *   canonicalDir: The resolved FreeHarness canonical directory (packages/cli/canonical).
  *
  * Returns:
- *   Absolute engine path, or null when the vendored tree is absent (npx bridge).
+ *   Absolute engine path, or null when the vendored tree is absent (memory is then skipped).
  */
 export declare function vendoredMemoryEngineDir(canonicalDir: string): string | null;
 /**
@@ -49,19 +49,44 @@ export interface ClaudePluginPaths {
  *   The path set mirrored from upstream utils/paths.ts.
  */
 export declare function claudePluginPaths(version: string): ClaudePluginPaths;
+/** Built bundles a plugin dir needs before it may replace a cached build. */
+export declare const PLUGIN_BUNDLES: readonly ["bun-runner.js", "worker-service.cjs", "mcp-server.cjs"];
 /**
- * Content digest of a plugin bundle: every file's relative posix path and bytes, in
- * path order, so a same-version rebuild whose output is byte-identical digests the
- * same as the previous run. Skips `node_modules` (matches the copy filter) and the
- * marker file itself, so re-staging never invalidates its own guard.
+ * Digest of a plugin bundle over every entry's relpath, type, mode and content or link target,
+ * in path order. Walks with lstat and never follows a symlink. Skips `node_modules` and the
+ * unstaged entries, so the vendored plugin and its staged copy digest alike.
  *
  * Args:
  *   dir: Directory to digest recursively (absent dir digests as empty).
  *
  * Returns:
- *   Lowercase hex SHA-256 over `path + NUL + content + NUL` per file.
+ *   Lowercase hex SHA-256.
  */
 export declare function bundleDigest(dir: string): string;
+export interface StageResult {
+    staged: boolean;
+    digest: string;
+    notes: string[];
+}
+/**
+ * Stage a plugin dir into a cache dir unless the marker and the cache's own digest both equal
+ * the plugin digest and the declared deps resolve; `staged` is true for a (would-be) re-stage.
+ */
+export declare function stagePluginCache(pluginDir: string, cacheDir: string, opts: {
+    dryRun: boolean;
+}): StageResult;
+/** Identity of the cache marker file (absent: null); every re-stage writes a new one. */
+export declare function stageStamp(cacheDir: string): string | null;
+export declare function missingPluginBundles(pluginDir: string): string[];
+/** Whether a plugin dir's package.json declares runtime deps, which only Bun installs. */
+export declare function declaresPluginDeps(dir: string): boolean;
+/**
+ * Declared plugin deps that do not resolve from `<dir>/node_modules` (upstream
+ * verifyCriticalModules), plus the zod subpaths the worker requires when zod is declared.
+ */
+export declare function missingPluginDeps(dir: string): string[];
+/** Install a staged cache's runtime deps (the hooks run from there); throws when one stays missing. */
+export declare function installPluginDeps(dir: string, bunPath: string): void;
 /** Probe result for one runtime tool. */
 export interface ToolProbe {
     path: string | null;
@@ -74,31 +99,39 @@ export interface ToolProbe {
  *   Path + version, or nulls when absent.
  */
 export declare function probeBun(): ToolProbe;
-/**
- * Probe uv (Chroma vector store runtime; upstream setup-runtime getUvPath).
- *
- * Returns:
- *   Path + version, or nulls when absent.
- */
-export declare function probeUv(): ToolProbe;
 /**
  * Whether an upstream registration (UPSTREAM_PLUGIN_KEY) is still live: present in
- * installed_plugins.json, or enabledPlugins carries it at a value other than `false`. Once a
- * migration sets it to `false`, later `registerHooks` runs see it as already migrated and skip
- * the backup/disable branch (idempotent on re-run).
+ * installed_plugins.json, or enabledPlugins carries it at a value other than `false`. Read-only:
+ * doctor warns on it and the data copy refuses while it is live.
  *
  * Args:
  *   installed: Parsed installed_plugins.json (or `{}` when absent).
  *   settings: Parsed settings.json (or `{}` when absent).
  *
  * Returns:
- *   True when the upstream key still needs disabling.
+ *   True when the upstream plugin may still load beside free-mem.
  */
 export declare function isUpstreamRegistered(installed: {
     plugins?: Record<string, unknown>;
 }, settings: {
     enabledPlugins?: Record<string, boolean>;
 }): boolean;
+/** Write the `.install-version` marker that tells our build apart; never writes through a symlink. `uv` stays for readers of the old shape. */
+export declare function writeInstallMarker(dir: string, version: string, bun: string): string;
+/**
+ * Version from a plugin dir's manifest ("0.0.0" when absent). The version names a cache
+ * directory that staging removes, so an empty or path-like value must never reach a path.
+ *
+ * Args:
+ *   pluginDir: Plugin directory holding `.claude-plugin/plugin.json`.
+ *
+ * Returns:
+ *   The semver version.
+ *
+ * Raises:
+ *   Error: When the manifest version is not a semver version.
+ */
+export declare function pluginVersion(pluginDir: string): string;
 /** MemoryPort implementation backed by the vendored claude-mem plugin build. */
 export declare class VendoredMemory implements MemoryPort {
     readonly engineDir: string;
@@ -115,7 +148,7 @@ export declare class VendoredMemory implements MemoryPort {
     version(): string;
     private result;
     /**
-     * Probe Bun and uv; instruct when missing. Never installs them (user's machine).
+     * Probe Bun; instruct when missing. Never installs it (user's machine).
      *
      * Returns:
      *   Notes only. A missing Bun is reported as "MISSING" and blocks install().
@@ -131,20 +164,14 @@ export declare class VendoredMemory implements MemoryPort {
      * Register the plugin with Claude Code (upstream registerMarketplace / registerPlugin /
      * enablePluginInClaudeSettings). All three writes are additive merges: other
      * marketplaces, plugins, hooks and settings keys are preserved byte-for-byte in shape.
-     *
-     * When an upstream registration (UPSTREAM_PLUGIN_KEY) is found (installed_plugins.json
-     * or a still-true enabledPlugins entry), this also backs up the three files below with a
-     * shared timestamp before the first write and disables (never deletes) the old key; the
-     * old cache directory is left in place for `freeharness cleanup` to offer later.
+     * An upstream registration (UPSTREAM_PLUGIN_KEY) is never written: doctor warns about it.
      */
     registerHooks(_scope: Scope, ctx: InstallContext): Promise<AdapterResult>;
     /**
-     * Keep an existing ~/.claude-mem data directory from a delegated install. The
-     * plugin resolves it by convention (CLAUDE_MEM_DATA_DIR or ~/.claude-mem), so no
-     * write is needed and nothing is deleted.
+     * Copy a legacy ~/.claude-mem forward into ~/.free-mem: pass 1 prints the plan, pass 2 applies
+     * it. A worker it stops is restarted by `update` once the bundle is staged, else at SessionStart.
+     * The copy is never recorded in `written`, since uninstall removes what the manifest lists.
      */
-    migrateExisting(_ctx: InstallContext): Promise<AdapterResult>;
+    migrateExisting(ctx: InstallContext): Promise<AdapterResult>;
     private run;
-    private missingPluginDeps;
-    private verifyPluginDeps;
 }