@gamaze/hicortex 0.7.0 → 0.10.0

package/dist/features.js

@@ -1,19 +1,20 @@
 "use strict";
 /**
- * Centralized feature gating — single source of truth for tier-dependent values.
+ * Feature gating — all gates removed as of 0.10.0.
  *
- * Why this exists:
- *   - getFeatures() in license.ts was sync but validateLicense was async, creating
- *     a race where Pro users got free-tier features during the validation window.
- *   - License checks were scattered across 8+ call sites with subtly different
- *     handling (e.g., consolidate.ts:308 had a dynamic import in a hot loop to
- *     dodge a circular import).
+ * Personal and noncommercial use is fully featured under the
+ * PolyForm Noncommercial License. Commercial use requires a per-seat
+ * license (see COMMERCIAL.md). There is no technical feature gating;
+ * the license key's only remaining role is the "licensed to <org>"
+ * display in `hicortex status`.
  *
- * All feature decisions now flow through this module. Call initFeatures() once at
- * process boot before serving any requests; sync getters become deterministic.
+ * The functions below are kept as trivial wrappers so call sites
+ * compile without churn. They will be removed entirely in a future
+ * cleanup pass once callers have been audited.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initFeatures = initFeatures;
+exports.getValidatedLicense = getValidatedLicense;
 exports.isPro = isPro;
 exports.maxMemoriesAllowed = maxMemoriesAllowed;
 exports.memoryCapReached = memoryCapReached;
@@ -25,117 +26,80 @@ const node_os_1 = require("node:os");
 const license_js_1 = require("./license.js");
 const state_js_1 = require("./state.js");
 const DEFAULT_STATE_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
-const FREE_FEATURES = {
+// A single canonical "full" feature set — no tiers.
+const FULL_FEATURES = {
     reflection: true,
     vectorSearch: true,
-    maxMemories: 250,
+    maxMemories: -1,
     crossAgent: true,
     remoteIngest: true,
 };
-let currentFeatures = FREE_FEATURES;
+let currentFeatures = FULL_FEATURES;
 let initialized = false;
+// Validated license info for display purposes only (no feature gating).
+let validatedLicenseInfo = null;
 function persistTier(stateDir, info) {
     (0, state_js_1.updateState)((s) => {
         s.tier = {
             tier: info.tier,
             validatedAt: new Date().toISOString(),
-            features: info.features,
+            features: FULL_FEATURES,
         };
         return s;
     }, stateDir);
 }
 /**
- * Initialize the feature cache. Call ONCE at process boot before any feature
- * gating queries. Race fix:
- *   1. Synchronously load persisted tier from disk (instant, deterministic)
- *   2. If no persisted tier and we have a key, AWAIT first validation
- *   3. If persisted tier exists, kick off background re-validation
- *
- * After this returns, sync getters (isPro, lessonsLimit, etc.) are deterministic
- * and reflect the user's actual tier — no more "free during validation window".
+ * Initialize license display. Call ONCE at process boot.
+ * No feature gates are applied regardless of the validation result.
  */
-async function initFeatures(licenseKey, stateDir = DEFAULT_STATE_DIR, hostVersion = "0.0.0") {
+async function initFeatures(licenseKey, stateDir = DEFAULT_STATE_DIR, _hostVersion = "0.0.0") {
     if (initialized)
         return;
     initialized = true;
-    // Step 1: Load persisted tier from state.json (instant)
-    const persisted = (0, state_js_1.loadState)(stateDir).tier;
-    if (persisted) {
-        currentFeatures = persisted.features;
-    }
-    else {
-        currentFeatures = FREE_FEATURES;
-    }
-    // Step 2: No key → free tier, done. Pro loader is only run for paid tiers.
+    currentFeatures = FULL_FEATURES;
     if (!licenseKey)
         return;
-    // Step 3: Validate
-    if (!persisted) {
-        // First-time: AWAIT validation so the very first request sees the right tier
-        try {
-            const info = await (0, license_js_1.validateLicense)(licenseKey, stateDir);
-            currentFeatures = info.features;
-            if (info.valid) {
-                persistTier(stateDir, info);
-            }
-        }
-        catch {
-            // Validation failed (network, etc.) — stay on free
+    // Validate the key for display purposes only — a failure keeps the server
+    // fully functional.
+    try {
+        const info = await (0, license_js_1.validateLicense)(licenseKey, stateDir);
+        validatedLicenseInfo = info;
+        if (info.valid) {
+            persistTier(stateDir, info);
         }
     }
-    else {
-        // Already have a persisted tier; re-validate in background
-        (0, license_js_1.validateLicense)(licenseKey, stateDir)
-            .then((info) => {
-            currentFeatures = info.features;
-            if (info.valid) {
-                persistTier(stateDir, info);
-            }
-        })
-            .catch(() => {
-            // Keep persisted features
-        });
-    }
-    // Step 4: If the current tier is paid, try to load the Pro extension bundle.
-    // This is best-effort — if loading fails (network, missing tarball, bad
-    // extraction, Pro package throws on activate), OSS defaults remain in effect
-    // and the host keeps running. No user-visible crash.
-    if (isPro()) {
-        try {
-            const { loadPro } = await import("./pro-loader.js");
-            await loadPro(licenseKey, stateDir, hostVersion);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[hicortex][pro] Pro loader failed to import: ${msg}`);
-        }
+    catch {
+        // Non-fatal — continue fully functional without a validated display tier
     }
 }
+/** Returns the validated license info if a key was supplied and validated. */
+function getValidatedLicense() {
+    return validatedLicenseInfo;
+}
 // ---------------------------------------------------------------------------
-// Public API — sync getters used everywhere in the codebase
+// Public API — kept for call-site compatibility; all return "fully unlocked"
 // ---------------------------------------------------------------------------
-/** Are we on a paid tier (Pro, Team, Lifetime)? */
+/** Always false — no memory cap. */
 function isPro() {
-    return currentFeatures.maxMemories === -1;
+    return true;
 }
-/** Memory count cap. -1 = unlimited (paid). */
+/** Always -1 (unlimited). */
 function maxMemoriesAllowed() {
-    return currentFeatures.maxMemories;
+    return -1;
 }
-/** Has the memory cap been hit? Pass current count from caller. */
-function memoryCapReached(currentCount) {
-    const max = maxMemoriesAllowed();
-    return max > 0 && currentCount >= max;
+/** Always false — no cap is ever reached. */
+function memoryCapReached(_currentCount) {
+    return false;
 }
-/** Number of lessons to inject into CLAUDE.md / before_agent_start. */
+/** Always 20. */
 function lessonsLimit() {
-    return isPro() ? 20 : 10;
+    return 20;
 }
-/** Is remote /ingest allowed? Free + Team yes, Pro (single-machine) no. */
+/** Always true — remote ingest is always allowed. */
 function remoteIngestAllowed() {
-    return currentFeatures.remoteIngest !== false;
+    return true;
 }
-/** Direct read of the underlying features (for callers that need the full record). */
+/** Direct read of the underlying features record. */
 function getCurrentFeatures() {
     return currentFeatures;
 }

package/dist/graph.d.ts

@@ -50,5 +50,5 @@ export interface GraphNeighbor {
     content: string;
     project: string | null;
 }
-export declare function getNeighbors(db: Database.Database, memoryId: string, limit?: number): GraphNeighbor[];
+export declare function getNeighbors(db: Database.Database, memoryId: string, limit?: number, relationship?: string): GraphNeighbor[];
 export declare function shortestPath(db: Database.Database, fromId: string, toId: string, maxDepth?: number): string[] | null;

package/dist/graph.js

@@ -175,14 +175,20 @@ function detectHubs(db, thresholdMultiplier = 2, minLinks = 3) {
     }
     return hubs;
 }
-function getNeighbors(db, memoryId, limit = 10) {
-    const rows = db
-        .prepare(`SELECT source_id, target_id, relationship, strength
+function getNeighbors(db, memoryId, limit = 10, relationship) {
+    let sql = `SELECT source_id, target_id, relationship, strength
        FROM memory_links
-       WHERE source_id = ? OR target_id = ?
-       ORDER BY strength DESC
-       LIMIT ?`)
-        .all(memoryId, memoryId, limit);
+       WHERE (source_id = ? OR target_id = ?)`;
+    const params = [memoryId, memoryId];
+    if (relationship) {
+        sql += ` AND relationship = ?`;
+        params.push(relationship);
+    }
+    sql += ` ORDER BY strength DESC LIMIT ?`;
+    params.push(limit);
+    const rows = db
+        .prepare(sql)
+        .all(...params);
     const results = [];
     for (const row of rows) {
         const isOutgoing = row.source_id === memoryId;

package/dist/hermes-transcript-reader.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Hermes transcript reader — the nightly capture path for Nous Research Hermes.
+ *
+ * Hermes stores conversation in a SQLite state DB, one per profile:
+ *   ~/.hermes/profiles/<profile>/state.db   (per-profile agents: lenny, raider, nano)
+ *   ~/.hermes/state.db                       (global, non-profile setups)
+ *
+ * Schema (relevant columns):
+ *   sessions(id TEXT PK, started_at REAL, ended_at REAL, ...)
+ *   messages(session_id TEXT, role TEXT, content TEXT, tool_name TEXT, timestamp REAL, active INT, ...)
+ *
+ * Compaction is NON-DESTRUCTIVE (compacted-out turns kept with active=0) and
+ * sessions are retained ~90 days — so the full history of any ended session is
+ * readable here nightly. No runtime plugin capture is needed; the Hermes plugin
+ * is recall-only.
+ *
+ * We process only ENDED sessions (ended_at set) that ended since the last run.
+ * A live session is distilled after it ends — this avoids partial-session
+ * distillation and keeps per-session dedup clean (chunks are stored as
+ * `<sessionId>#<chunkIndex>`; see nightly.ts).
+ */
+import type { TranscriptBatch } from "./transcript-reader.js";
+/**
+ * Read Hermes sessions that ended since `since`, across all profiles.
+ * Returns one batch per session, parallel to readCcTranscripts().
+ */
+export declare function readHermesSessions(since: Date, hermesHome?: string): TranscriptBatch[];

package/dist/hermes-transcript-reader.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * Hermes transcript reader — the nightly capture path for Nous Research Hermes.
+ *
+ * Hermes stores conversation in a SQLite state DB, one per profile:
+ *   ~/.hermes/profiles/<profile>/state.db   (per-profile agents: lenny, raider, nano)
+ *   ~/.hermes/state.db                       (global, non-profile setups)
+ *
+ * Schema (relevant columns):
+ *   sessions(id TEXT PK, started_at REAL, ended_at REAL, ...)
+ *   messages(session_id TEXT, role TEXT, content TEXT, tool_name TEXT, timestamp REAL, active INT, ...)
+ *
+ * Compaction is NON-DESTRUCTIVE (compacted-out turns kept with active=0) and
+ * sessions are retained ~90 days — so the full history of any ended session is
+ * readable here nightly. No runtime plugin capture is needed; the Hermes plugin
+ * is recall-only.
+ *
+ * We process only ENDED sessions (ended_at set) that ended since the last run.
+ * A live session is distilled after it ends — this avoids partial-session
+ * distillation and keeps per-session dedup clean (chunks are stored as
+ * `<sessionId>#<chunkIndex>`; see nightly.ts).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readHermesSessions = readHermesSessions;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const HERMES_HOME = process.env.HERMES_HOME || (0, node_path_1.join)((0, node_os_1.homedir)(), ".hermes");
+/**
+ * Session `source` values that are NOT primary conversations and must not be
+ * captured — capturing them would pollute long-term memory with automated,
+ * non-conversational runs. `cron` is Hermes' scheduled-task source (garmin
+ * syncs, daily scans, self-reflection loops). This mirrors the MemoryProvider
+ * contract's own guidance to skip non-primary `agent_context` (e.g. "cron").
+ * Everything else (cli, discord, telegram, slack, …) is a real conversation.
+ */
+const NON_PRIMARY_SOURCES = new Set(["cron"]);
+/**
+ * Message roles that are metadata/noise, not conversation — mapped so the
+ * distiller's extractConversationText drops them (it skips "tool_result").
+ */
+const NOISE_ROLES = new Set(["tool", "session_meta"]);
+/**
+ * Read Hermes sessions that ended since `since`, across all profiles.
+ * Returns one batch per session, parallel to readCcTranscripts().
+ */
+function readHermesSessions(since, hermesHome = HERMES_HOME) {
+    const batches = [];
+    const sinceEpoch = since.getTime() / 1000; // Hermes timestamps are unix seconds (REAL)
+    for (const { profile, dbPath } of discoverProfileDbs(hermesHome)) {
+        let db;
+        try {
+            db = new better_sqlite3_1.default(dbPath, { readonly: true, fileMustExist: true });
+        }
+        catch {
+            continue; // locked / unreadable / wrong owner — skip, retry next run
+        }
+        try {
+            const sessions = db
+                .prepare("SELECT id, ended_at, source FROM sessions WHERE ended_at IS NOT NULL AND ended_at > ? ORDER BY ended_at")
+                .all(sinceEpoch);
+            const msgStmt = db.prepare("SELECT role, content, tool_name, timestamp FROM messages WHERE session_id = ? ORDER BY timestamp, id");
+            for (const s of sessions) {
+                // Skip automated (non-primary) sessions — cron runs are not
+                // conversations and would pollute memory. Checked before pulling
+                // messages so we don't even read them.
+                if (NON_PRIMARY_SOURCES.has(s.source))
+                    continue;
+                const rows = msgStmt.all(s.id);
+                // Skip only genuinely empty sessions. Do NOT gate on message count —
+                // a short 2-message exchange can carry a real decision. Meaningful-
+                // content is gated downstream by the post-denoise 200-char check in
+                // nightly.ts, so short-but-dense sessions aren't dropped here.
+                if (rows.length === 0)
+                    continue;
+                // Map Hermes rows to the shape extractConversationText() understands
+                // (it reads m.role + m.content). Metadata/noise roles (tool results,
+                // session_meta) are relabelled "tool_result" so the distiller drops them.
+                const entries = rows.map((r) => ({
+                    role: NOISE_ROLES.has(r.role) ? "tool_result" : r.role,
+                    content: r.content ?? "",
+                }));
+                const endTs = s.ended_at ?? rows[rows.length - 1].timestamp;
+                batches.push({
+                    sessionId: s.id,
+                    projectName: profile,
+                    sourceAgent: `hermes/${profile}`,
+                    date: new Date(endTs * 1000).toISOString().slice(0, 10),
+                    entries,
+                });
+            }
+        }
+        catch {
+            // Query failed (schema drift on a Hermes upgrade) — skip this DB, don't crash the run.
+        }
+        finally {
+            db.close();
+        }
+    }
+    return batches;
+}
+/**
+ * Find every Hermes state DB: one per profile, plus the global DB for
+ * non-profile installs. The profile name becomes the provenance label.
+ */
+function discoverProfileDbs(hermesHome) {
+    const out = [];
+    const profilesDir = (0, node_path_1.join)(hermesHome, "profiles");
+    try {
+        for (const entry of (0, node_fs_1.readdirSync)(profilesDir)) {
+            if (entry.startsWith(".") || entry.startsWith("_"))
+                continue;
+            const dbPath = (0, node_path_1.join)(profilesDir, entry, "state.db");
+            try {
+                if ((0, node_fs_1.statSync)(dbPath).isFile())
+                    out.push({ profile: entry, dbPath });
+            }
+            catch {
+                // no state.db for this profile
+            }
+        }
+    }
+    catch {
+        // no profiles dir
+    }
+    const globalDb = (0, node_path_1.join)(hermesHome, "state.db");
+    if ((0, node_fs_1.existsSync)(globalDb))
+        out.push({ profile: "default", dbPath: globalDb });
+    return out;
+}

package/dist/index.d.ts

@@ -1,9 +1,21 @@
 /**
- * Hicortex OpenClaw Plugin — Long-term Memory That Learns.
+ * Hicortex OpenClaw Plugin — Long-term Memory That Learns. (0.10.0)
  *
- * Pure in-process plugin: no sidecar, no HTTP. Uses better-sqlite3 + sqlite-vec
- * for storage, @huggingface/transformers for embeddings, and multi-provider LLM
- * for distillation and consolidation.
+ * Thin-client model: the plugin requires a Hicortex server (co-located at
+ * http://127.0.0.1:8787 by default, or a remote URL via `serverUrl` config).
+ * No local database, no local LLM, no embedder, no consolidation scheduler.
+ *
+ * Install once: `openclaw plugins install @gamaze/hicortex`
+ * Run server:   `npx @gamaze/hicortex init`
+ *
+ * Responsibilities (recall-only adapter, like the Hermes plugin):
+ *   - before_agent_start  → GET /lessons (fail-soft, 3s timeout) → inject context
+ *   - Tools               → HTTP proxies to /search, /context, /ingest, /lessons
+ *
+ * CAPTURE IS NOT THIS PLUGIN'S JOB. OpenClaw persists sessions at
+ * ~/.openclaw/agents/<agentId>/sessions/*.jsonl in the Pi v3 format; the
+ * machine's Hicortex nightly reads them via oc-transcript-reader.ts —
+ * canonical nightly-from-logs, same as CC JSONL and Hermes state.db.
  */
 declare const _default: {
     id: string;