@gamaze/hicortex 0.4.2 → 0.4.3

package/dist/cli.d.ts

@@ -6,6 +6,7 @@
  *   server     Start the MCP HTTP/SSE server (persistent daemon)
  *   init       Detect existing setup and configure for CC/OC
  *   nightly    Run distill + consolidate + inject lessons (manual trigger)
+ *              nightly --status  Show nightly pipeline health check
  *   status     Show config, DB stats, adapter status
  *   uninstall  Clean removal of CC integration
  */

package/dist/cli.js

@@ -7,6 +7,7 @@
  *   server     Start the MCP HTTP/SSE server (persistent daemon)
  *   init       Detect existing setup and configure for CC/OC
  *   nightly    Run distill + consolidate + inject lessons (manual trigger)
+ *              nightly --status  Show nightly pipeline health check
  *   status     Show config, DB stats, adapter status
  *   uninstall  Clean removal of CC integration
  */
@@ -38,13 +39,24 @@ switch (command) {
         break;
     }
     case "nightly": {
-        const dryRun = process.argv.includes("--dry-run");
-        import("./nightly.js").then(({ runNightly }) => {
-            runNightly({ dryRun }).catch((err) => {
-                console.error("[hicortex] Nightly pipeline failed:", err);
-                process.exit(1);
+        const args = process.argv.slice(3);
+        if (args.includes("--status")) {
+            import("./nightly-status.js").then(({ showNightlyStatus }) => {
+                showNightlyStatus().catch((err) => {
+                    console.error("[hicortex] Status check failed:", err);
+                    process.exit(1);
+                });
             });
-        });
+        }
+        else {
+            const dryRun = args.includes("--dry-run");
+            import("./nightly.js").then(({ runNightly }) => {
+                runNightly({ dryRun }).catch((err) => {
+                    console.error("[hicortex] Nightly pipeline failed:", err);
+                    process.exit(1);
+                });
+            });
+        }
         break;
     }
     case "status":
@@ -77,13 +89,15 @@ Commands:
   uninstall  Remove CC integration (preserves DB)
 
 Options:
-  server --port <n>   Port (default: 8787)
-  server --host <h>   Host (default: 127.0.0.1)
-  nightly --dry-run   Preview without changes
+  server --port <n>    Port (default: 8787)
+  server --host <h>    Host (default: 127.0.0.1)
+  nightly --dry-run    Preview without changes
+  nightly --status     Show nightly pipeline health
 
 Examples:
   npx @gamaze/hicortex server
   npx @gamaze/hicortex init
+  npx @gamaze/hicortex nightly --status
   npx @gamaze/hicortex init --server https://myserver.example.com
   npx @gamaze/hicortex status`);
         process.exit(command ? 1 : 0);

package/dist/distiller.d.ts

@@ -7,8 +7,10 @@ import type { LlmClient } from "./llm.js";
 /**
  * Estimate a safe chunk size in chars based on the LLM provider and model.
  * - API providers (Anthropic, OpenAI, claude-cli): no chunking needed (large context windows)
- * - Ollama: query /api/show for context_length, use ~60% for chunks (leaving room for prompt + generation)
- * - Fallback: 20K chars (~5K tokens) — safe for 4B models with 32K context
+ * - Ollama: query /api/show for context_length AND parameter_count, cap based on both
+ * - Small models (<8B params): max 20K chars (~5K tokens) — keeps CPU inference under ~60s
+ * - Larger models: up to 60K chars (~15K tokens)
+ * - Fallback: 20K chars
  */
 export declare function detectChunkSize(provider: string, model: string, baseUrl?: string): Promise<number>;
 /**

package/dist/distiller.js

@@ -11,11 +11,18 @@ exports.distillSession = distillSession;
 const prompts_js_1 = require("./prompts.js");
 const MAX_TRANSCRIPT_CHARS = 80_000;
 const MIN_CONVERSATION_CHARS = 200;
+// Chunk size limits by model parameter count (for local/CPU inference)
+// Small models are slow on CPU — cap input size to keep inference under ~60s
+const SMALL_MODEL_PARAMS = 8_000_000_000; // 8B — threshold for "small"
+const SMALL_MODEL_MAX_CHUNK_CHARS = 20_000; // ~5K tokens — safe for 4-8B on CPU
+const LARGE_MODEL_MAX_CHUNK_CHARS = 60_000; // ~15K tokens — ok for 8B+ on GPU or API
 /**
  * Estimate a safe chunk size in chars based on the LLM provider and model.
  * - API providers (Anthropic, OpenAI, claude-cli): no chunking needed (large context windows)
- * - Ollama: query /api/show for context_length, use ~60% for chunks (leaving room for prompt + generation)
- * - Fallback: 20K chars (~5K tokens) — safe for 4B models with 32K context
+ * - Ollama: query /api/show for context_length AND parameter_count, cap based on both
+ * - Small models (<8B params): max 20K chars (~5K tokens) — keeps CPU inference under ~60s
+ * - Larger models: up to 60K chars (~15K tokens)
+ * - Fallback: 20K chars
  */
 async function detectChunkSize(provider, model, baseUrl) {
     // API-based providers handle large contexts natively — no chunking needed
@@ -33,16 +40,30 @@ async function detectChunkSize(provider, model, baseUrl) {
             });
             if (resp.ok) {
                 const data = await resp.json();
-                // Try to extract context length from model_info
                 const info = data.model_info ?? {};
+                // Extract parameter count for speed-aware capping
+                const paramKey = Object.keys(info).find((k) => k.endsWith("parameter_count"));
+                const paramCount = paramKey && typeof info[paramKey] === "number"
+                    ? info[paramKey]
+                    : 0;
+                const isSmallModel = paramCount > 0 && paramCount < SMALL_MODEL_PARAMS;
+                // Extract context length for context-aware capping
                 const ctxKey = Object.keys(info).find((k) => k.endsWith("context_length") || k.endsWith("context_window"));
-                if (ctxKey && typeof info[ctxKey] === "number") {
-                    const contextTokens = info[ctxKey];
-                    // Use 60% of context for chunk input (~4 chars/token)
-                    const chunkChars = Math.floor(contextTokens * 0.6 * 4);
-                    console.log(`[hicortex]     Model context: ${contextTokens} tokens, chunk size: ${chunkChars} chars`);
-                    return Math.min(chunkChars, MAX_TRANSCRIPT_CHARS);
-                }
+                const contextTokens = ctxKey && typeof info[ctxKey] === "number"
+                    ? info[ctxKey]
+                    : 0;
+                // Determine max chunk size based on model size (speed constraint)
+                // Unknown param count defaults to conservative (small model) — safe for any hardware
+                const maxBySpeed = !isSmallModel && paramCount > 0 ? LARGE_MODEL_MAX_CHUNK_CHARS : SMALL_MODEL_MAX_CHUNK_CHARS;
+                // Determine max chunk size based on context window (fits-in-context constraint)
+                const maxByContext = contextTokens > 0
+                    ? Math.floor(contextTokens * 0.6 * 4) // 60% of context, ~4 chars/token
+                    : MAX_TRANSCRIPT_CHARS;
+                const chunkChars = Math.min(maxBySpeed, maxByContext);
+                console.log(`[hicortex]     Model: ${paramCount > 0 ? `${(paramCount / 1e9).toFixed(1)}B params` : "unknown size"}, ` +
+                    `context: ${contextTokens > 0 ? `${contextTokens} tokens` : "unknown"}, ` +
+                    `chunk size: ${chunkChars} chars${isSmallModel ? " (small model cap)" : ""}`);
+                return chunkChars;
             }
         }
         catch {

package/dist/mcp-server.js

@@ -368,6 +368,40 @@ async function startServer(options = {}) {
             llm: `${llmConfig.provider}/${llmConfig.model}`,
         });
     });
+    // REST /lessons — return lessons + memory index for client CLAUDE.md injection
+    app.get("/lessons", (_req, res) => {
+        if (!db) {
+            res.status(503).json({ error: "Server not initialized" });
+            return;
+        }
+        try {
+            const lessons = storage.getLessons(db, 30);
+            const totalCount = storage.countMemories(db);
+            // Project index
+            const projects = db
+                .prepare("SELECT project, COUNT(*) as cnt FROM memories WHERE project IS NOT NULL GROUP BY project ORDER BY cnt DESC LIMIT 10")
+                .all();
+            const sourceCount = db.prepare("SELECT COUNT(DISTINCT source_agent) as cnt FROM memories").get().cnt;
+            const lessonCount = lessons.length;
+            res.json({
+                lessons: lessons.map(l => ({
+                    content: l.content,
+                    created_at: l.created_at,
+                    base_strength: l.base_strength,
+                    access_count: l.access_count,
+                })),
+                index: {
+                    total: totalCount,
+                    lessonCount,
+                    sourceCount,
+                    projects: projects.map(p => ({ name: p.project, count: p.cnt })),
+                },
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
     // REST /ingest — accept pre-distilled memories from remote clients
     app.post("/ingest", async (req, res) => {
         if (!db) {

package/dist/nightly-status.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Nightly pipeline status — lightweight check without running the pipeline.
+ *
+ * Shows:
+ *   - Last run timestamp + age
+ *   - Timer/schedule status (systemd/launchd)
+ *   - DB memory count
+ *   - Distillation source breakdown
+ *   - Staleness warnings
+ */
+export declare function showNightlyStatus(): Promise<void>;

package/dist/nightly-status.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Nightly pipeline status — lightweight check without running the pipeline.
+ *
+ * Shows:
+ *   - Last run timestamp + age
+ *   - Timer/schedule status (systemd/launchd)
+ *   - DB memory count
+ *   - Distillation source breakdown
+ *   - Staleness warnings
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showNightlyStatus = showNightlyStatus;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const node_child_process_1 = require("node:child_process");
+const db_js_1 = require("./db.js");
+const HICORTEX_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
+const LAST_RUN_PATH = (0, node_path_1.join)(HICORTEX_HOME, "nightly-last-run.txt");
+const CONFIG_PATH = (0, node_path_1.join)(HICORTEX_HOME, "config.json");
+const STALE_THRESHOLD_HOURS = 30;
+async function showNightlyStatus() {
+    console.log("Hicortex Nightly Pipeline Status");
+    console.log("─".repeat(40));
+    // Last run
+    let lastRun = null;
+    let lastRunStr = "never";
+    try {
+        const ts = (0, node_fs_1.readFileSync)(LAST_RUN_PATH, "utf-8").trim();
+        const d = new Date(ts);
+        if (!isNaN(d.getTime())) {
+            lastRun = d;
+            lastRunStr = ts;
+        }
+        else {
+            lastRunStr = `${ts} (invalid)`;
+        }
+    }
+    catch {
+        // No file
+    }
+    if (lastRun) {
+        const ageMs = Date.now() - lastRun.getTime();
+        const ageHours = Math.round(ageMs / (60 * 60 * 1000));
+        const ageStr = ageHours < 1 ? "just now" :
+            ageHours < 24 ? `${ageHours}h ago` :
+                `${Math.round(ageHours / 24)}d ago`;
+        const isStale = ageHours > STALE_THRESHOLD_HOURS;
+        console.log(`Last run:    ${lastRunStr} (${ageStr})${isStale ? " ⚠ STALE" : ""}`);
+    }
+    else {
+        console.log(`Last run:    ${lastRunStr}`);
+    }
+    // LLM config
+    try {
+        const config = JSON.parse((0, node_fs_1.readFileSync)(CONFIG_PATH, "utf-8"));
+        const backend = config.llmBackend ?? "auto-detect";
+        const model = config.llmModel ?? "default";
+        const mode = config.mode === "client" ? "client → " + (config.serverUrl ?? "?") : "server (local)";
+        console.log(`Mode:        ${mode}`);
+        console.log(`LLM backend: ${backend}${backend !== "auto-detect" ? ` (${model})` : ""}`);
+    }
+    catch {
+        console.log("Config:      not configured (run: hicortex init)");
+    }
+    // Timer/schedule
+    const os = (0, node_os_1.platform)();
+    let timerActive = false;
+    let timerInfo = "not installed";
+    if (os === "darwin") {
+        try {
+            const out = (0, node_child_process_1.execSync)("launchctl list 2>/dev/null | grep hicortex-nightly", {
+                encoding: "utf-8",
+                timeout: 3000,
+            });
+            if (out.trim()) {
+                timerActive = true;
+                timerInfo = "launchd (loaded)";
+            }
+        }
+        catch { /* not installed */ }
+    }
+    else if (os === "linux") {
+        try {
+            const active = (0, node_child_process_1.execSync)("systemctl --user is-active hicortex-nightly.timer 2>/dev/null", {
+                encoding: "utf-8",
+                timeout: 3000,
+            }).trim();
+            if (active === "active" || active === "waiting") {
+                timerActive = true;
+                try {
+                    const next = (0, node_child_process_1.execSync)("systemctl --user show hicortex-nightly.timer --property=NextElapseUSecRealtime 2>/dev/null", {
+                        encoding: "utf-8",
+                        timeout: 3000,
+                    }).trim();
+                    const match = next.match(/=(\d+)/);
+                    if (match) {
+                        const nextDate = new Date(Number(match[1]) / 1000);
+                        timerInfo = `systemd (active, next: ${nextDate.toISOString()})`;
+                    }
+                    else {
+                        timerInfo = `systemd (${active})`;
+                    }
+                }
+                catch {
+                    timerInfo = `systemd (${active})`;
+                }
+            }
+        }
+        catch { /* not installed */ }
+    }
+    console.log(`Timer:       ${timerInfo}${!timerActive ? " ⚠ Pipeline will NOT run automatically" : ""}`);
+    // DB stats
+    const dbPath = (0, db_js_1.resolveDbPath)();
+    if ((0, node_fs_1.existsSync)(dbPath)) {
+        try {
+            const { initDb } = await import("./db.js");
+            const db = initDb(dbPath);
+            const count = db.prepare("SELECT COUNT(*) as c FROM memories").get().c;
+            let linkCount = 0;
+            try {
+                linkCount = db.prepare("SELECT COUNT(*) as c FROM memory_links").get().c;
+            }
+            catch {
+                // memory_links table may not exist in older DBs
+            }
+            // Source breakdown (top 5)
+            const sources = db.prepare("SELECT source_agent, COUNT(*) as cnt FROM memories GROUP BY source_agent ORDER BY cnt DESC LIMIT 5").all();
+            console.log(`\nMemories:    ${count} (${linkCount} links)`);
+            if (sources.length > 0) {
+                console.log("Sources:");
+                for (const s of sources) {
+                    console.log(`  ${s.source_agent || "unknown"}: ${s.cnt}`);
+                }
+            }
+            db.close();
+        }
+        catch (err) {
+            console.log(`\nDB:          error (${err instanceof Error ? err.message : String(err)})`);
+        }
+    }
+    else {
+        console.log(`\nDB:          not found (run: hicortex init)`);
+    }
+    // Health assessment
+    console.log("\n" + "─".repeat(40));
+    const issues = [];
+    if (!lastRun)
+        issues.push("Pipeline has never run. Run: hicortex nightly");
+    else if (lastRun && (Date.now() - lastRun.getTime()) > STALE_THRESHOLD_HOURS * 60 * 60 * 1000) {
+        issues.push(`Pipeline hasn't run in ${STALE_THRESHOLD_HOURS}+ hours. Check timer.`);
+    }
+    if (!timerActive)
+        issues.push("No timer installed. Nightly pipeline won't run automatically.");
+    if (!(0, node_fs_1.existsSync)(dbPath))
+        issues.push("No database found. Run: hicortex init");
+    if (issues.length === 0) {
+        console.log("✓ Nightly pipeline healthy");
+    }
+    else {
+        console.log("Issues:");
+        for (const issue of issues) {
+            console.log(`  ⚠ ${issue}`);
+        }
+    }
+}

package/dist/nightly.js

@@ -400,7 +400,91 @@ async function runClientNightly(config, dryRun) {
             console.error(`[hicortex]     Failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    // Inject lessons from server into CLAUDE.md
+    if (!dryRun) {
+        try {
+            await injectLessonsFromServer(serverUrl, authToken);
+        }
+        catch (err) {
+            console.error(`[hicortex] CLAUDE.md injection failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     if (!dryRun)
         writeLastRun();
     console.log(`[hicortex] Client nightly complete: ${memoriesIngested} memories from ${sessionsSent} sessions → ${serverUrl}`);
 }
+/**
+ * Fetch lessons + memory index from server and inject into CLAUDE.md.
+ * Client mode equivalent of the server's injectLessons(db, ...).
+ */
+async function injectLessonsFromServer(serverUrl, authToken) {
+    const resp = await fetch(`${serverUrl}/lessons`, {
+        headers: authToken ? { "Authorization": `Bearer ${authToken}` } : {},
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!resp.ok) {
+        console.log(`[hicortex] Could not fetch lessons from server (${resp.status})`);
+        return;
+    }
+    const data = await resp.json();
+    const maxLessons = 10;
+    const selected = data.lessons.slice(0, maxLessons);
+    // Format lessons
+    const lessonLines = selected.map((l) => {
+        const titleMatch = l.content.match(/## Lesson: (.+)/);
+        const typeMatch = l.content.match(/\*\*Type:\*\* (\w+)/);
+        const severityMatch = l.content.match(/\*\*Severity:\*\* (\w+)/);
+        const title = titleMatch ? titleMatch[1] : l.content.slice(0, 150);
+        const meta = [severityMatch?.[1], typeMatch?.[1]].filter(Boolean).join(", ");
+        return `- ${title}${meta ? ` (${meta})` : ""}`;
+    });
+    // Format project index
+    const projectIndex = data.index.projects.map(p => `${p.name}: ${p.count}`);
+    // Build block
+    const START_MARKER = "<!-- HICORTEX-LEARNINGS:START -->";
+    const END_MARKER = "<!-- HICORTEX-LEARNINGS:END -->";
+    const blockParts = [START_MARKER, "## Hicortex Memory"];
+    blockParts.push("", "You have access to shared long-term memory across all agents and sessions.", "BEFORE making decisions, search memory: `hicortex_search` for prior decisions on the same topic.", "Use `hicortex_context` at session start for recent project state.");
+    if (lessonLines.length > 0) {
+        blockParts.push("", "### Lessons (updated nightly)");
+        blockParts.push(...lessonLines);
+    }
+    else {
+        blockParts.push("", "### Getting Started");
+        blockParts.push("- Search past decisions with `hicortex_search` before starting work");
+        blockParts.push("- Save important decisions with `hicortex_ingest`");
+        blockParts.push("- Lessons will appear here after the first nightly run");
+    }
+    if (projectIndex.length > 0) {
+        blockParts.push("", "### Memory Index");
+        blockParts.push(projectIndex.join(" | "));
+        blockParts.push(`${data.index.total} memories, ${data.index.lessonCount} lessons, ${data.index.sourceCount} agents. Search with \`hicortex_search\`.`);
+    }
+    blockParts.push(END_MARKER);
+    const block = blockParts.join("\n");
+    // Write to CLAUDE.md
+    const { readFileSync, writeFileSync, mkdirSync } = await import("node:fs");
+    const { join, dirname } = await import("node:path");
+    const { homedir } = await import("node:os");
+    const claudeMdPath = join(homedir(), ".claude", "CLAUDE.md");
+    let content = "";
+    try {
+        content = readFileSync(claudeMdPath, "utf-8");
+    }
+    catch { }
+    const startIdx = content.indexOf(START_MARKER);
+    const endIdx = content.indexOf(END_MARKER);
+    if (startIdx !== -1 && endIdx !== -1) {
+        content = content.slice(0, startIdx) + block + content.slice(endIdx + END_MARKER.length);
+    }
+    else {
+        if (content.length > 0 && !content.endsWith("\n"))
+            content += "\n";
+        if (content.length > 0)
+            content += "\n";
+        content += block + "\n";
+    }
+    mkdirSync(dirname(claudeMdPath), { recursive: true });
+    writeFileSync(claudeMdPath, content);
+    console.log(`[hicortex] CLAUDE.md updated: ${lessonLines.length} lessons, ${data.index.total} memories indexed`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "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": {