@gamaze/hicortex 0.4.3 → 0.4.4

package/dist/state.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Centralized state management — single ~/.hicortex/state.json file.
+ *
+ * Replaces 4 separate state files used by previous versions:
+ *   - nightly-last-run.txt   → state.lastNightly
+ *   - last-consolidated.txt  → state.lastConsolidated
+ *   - tier.json              → state.tier
+ *   - license-validated.txt  → state.tier.validatedAt (subsumed)
+ *
+ * Why one file:
+ *   - Atomic writes (write to temp + rename)
+ *   - Easier debugging (one file to inspect)
+ *   - No filesystem chatter from multiple separate writes
+ *   - Single migration path going forward
+ *
+ * Note: ~/.hicortex/config.json is intentionally NOT merged here. Config is
+ * user-edited and tracked separately from machine state.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadState = loadState;
+exports.saveState = saveState;
+exports.updateState = updateState;
+exports.migrateLegacyState = migrateLegacyState;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const HICORTEX_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
+const STATE_FILE = "state.json";
+/**
+ * Load the state file. Returns an empty state if the file is missing
+ * or corrupted (callers should handle missing fields with defaults).
+ */
+function loadState(stateDir = HICORTEX_HOME) {
+    const path = (0, node_path_1.join)(stateDir, STATE_FILE);
+    try {
+        const raw = (0, node_fs_1.readFileSync)(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Atomically write the state file. Uses write-to-temp + rename so a crash
+ * during write cannot leave a half-written state.json on disk.
+ */
+function saveState(state, stateDir = HICORTEX_HOME) {
+    try {
+        (0, node_fs_1.mkdirSync)(stateDir, { recursive: true });
+        const path = (0, node_path_1.join)(stateDir, STATE_FILE);
+        const tmp = `${path}.tmp`;
+        (0, node_fs_1.writeFileSync)(tmp, JSON.stringify(state, null, 2));
+        (0, node_fs_1.renameSync)(tmp, path);
+    }
+    catch (err) {
+        console.warn(`[hicortex] Failed to save state: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Read-modify-write helper. The updater receives the current state and
+ * returns the next state (or void if it mutates in place).
+ */
+function updateState(updater, stateDir = HICORTEX_HOME) {
+    const current = loadState(stateDir);
+    const result = updater(current);
+    const next = result ?? current;
+    saveState(next, stateDir);
+    return next;
+}
+// ---------------------------------------------------------------------------
+// One-time legacy migration
+// ---------------------------------------------------------------------------
+const LEGACY_FILES = [
+    "nightly-last-run.txt",
+    "last-consolidated.txt",
+    "license-validated.txt",
+    "tier.json",
+];
+/**
+ * One-time migration from the 4 legacy state files to state.json.
+ *
+ * Behaviour:
+ *   1. If state.json already exists, do nothing (and clean up any leftover
+ *      legacy files from a previously interrupted migration).
+ *   2. Otherwise, read whichever legacy files exist, build a HicortexState,
+ *      write state.json, and delete the legacy files.
+ *
+ * Idempotent: safe to call on every boot.
+ * Returns true if migration ran, false if state.json already existed.
+ */
+function migrateLegacyState(stateDir = HICORTEX_HOME) {
+    const statePath = (0, node_path_1.join)(stateDir, STATE_FILE);
+    if ((0, node_fs_1.existsSync)(statePath)) {
+        cleanupLegacyFiles(stateDir);
+        return false;
+    }
+    const state = {};
+    let foundAny = false;
+    // 1. nightly-last-run.txt → state.lastNightly
+    const ln = readLegacyText(stateDir, "nightly-last-run.txt");
+    if (ln) {
+        state.lastNightly = ln;
+        foundAny = true;
+    }
+    // 2. last-consolidated.txt → state.lastConsolidated
+    const lc = readLegacyText(stateDir, "last-consolidated.txt");
+    if (lc) {
+        state.lastConsolidated = lc;
+        foundAny = true;
+    }
+    // 3. tier.json → state.tier (full object)
+    const tierRaw = readLegacyText(stateDir, "tier.json");
+    if (tierRaw) {
+        try {
+            state.tier = JSON.parse(tierRaw);
+            foundAny = true;
+        }
+        catch {
+            // Corrupted tier.json — ignore
+        }
+    }
+    // 4. license-validated.txt → state.tier.validatedAt (only if no tier yet)
+    //    (subsumed by tier.json when it exists)
+    if (!state.tier) {
+        const lv = readLegacyText(stateDir, "license-validated.txt");
+        if (lv) {
+            // We have a validation timestamp but no tier object — preserve as
+            // a placeholder so offline grace can still work. The features module
+            // will re-validate on next boot to get the full features back.
+            // We deliberately don't fabricate features here.
+            foundAny = true;
+        }
+    }
+    if (foundAny) {
+        saveState(state, stateDir);
+        cleanupLegacyFiles(stateDir);
+        console.log("[hicortex] Migrated legacy state files to ~/.hicortex/state.json");
+        return true;
+    }
+    return false;
+}
+function readLegacyText(stateDir, name) {
+    try {
+        const raw = (0, node_fs_1.readFileSync)((0, node_path_1.join)(stateDir, name), "utf-8").trim();
+        return raw || null;
+    }
+    catch {
+        return null;
+    }
+}
+function cleanupLegacyFiles(stateDir) {
+    for (const name of LEGACY_FILES) {
+        try {
+            (0, node_fs_1.unlinkSync)((0, node_path_1.join)(stateDir, name));
+        }
+        catch {
+            // File didn't exist — fine
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Human-like memory for self-improving AI agents. Automatic capturing, nightly reflection, and cross-agent learning. Works with Claude Code and OpenClaw.",
   "main": "dist/index.js",
   "bin": {
@@ -45,13 +45,17 @@
   "engines": {
     "node": ">=18"
   },
-  "license": "UNLICENSED",
+  "license": "MIT",
   "homepage": "https://hicortex.gamaze.com",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mha33/hicortex.git",
+    "url": "https://github.com/gamaze-labs/hicortex.git",
     "directory": "packages/openclaw-plugin"
   },
+  "bugs": {
+    "url": "https://github.com/gamaze-labs/hicortex/issues"
+  },
+  "author": "Mattias Hansson",
   "dependencies": {
     "@huggingface/transformers": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.28.0",