@gamaze/hicortex 0.3.8 → 0.3.10

package/dist/init.js

@@ -229,11 +229,59 @@ Tell them: "Get a license key at https://hicortex.gamaze.com/ — after purchase
     console.log(`  ✓ Installed /learn and /hicortex-activate commands in ${CC_COMMANDS_DIR}`);
 }
 /**
- * Detect LLM API key from current shell environment and persist to
- * ~/.hicortex/config.json so the daemon can use it (launchd/systemd
- * don't inherit shell env vars).
+ * Read LLM config from OC's openclaw.json + auth-profiles.json.
+ * Used as fallback when no env vars are set (e.g. Claude Max subscription users).
  */
-function persistLlmConfig() {
+function readOcLlmConfig() {
+    try {
+        // Read primary model from openclaw.json
+        const ocRaw = (0, node_fs_1.readFileSync)(OC_CONFIG, "utf-8");
+        const oc = JSON.parse(ocRaw);
+        const primary = oc?.agents?.defaults?.model?.primary;
+        if (!primary || typeof primary !== "string")
+            return null;
+        const [providerHint, ...rest] = primary.includes("/") ? primary.split("/") : primary.split(":");
+        const model = rest.join("/") || undefined;
+        // Read base URL from providers config
+        const baseUrl = oc?.models?.providers?.[providerHint]?.baseUrl;
+        // Read API key from auth-profiles
+        const { readdirSync } = require("node:fs");
+        const agentsDir = (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw", "agents");
+        let apiKey;
+        try {
+            for (const agentId of readdirSync(agentsDir)) {
+                try {
+                    const authPath = (0, node_path_1.join)(agentsDir, agentId, "agent", "auth-profiles.json");
+                    const auth = JSON.parse((0, node_fs_1.readFileSync)(authPath, "utf-8"));
+                    for (const [profileId, profile] of Object.entries(auth?.profiles ?? {})) {
+                        const p = profile;
+                        if (p?.provider === providerHint || profileId.startsWith(`${providerHint}:`)) {
+                            if (p?.key) {
+                                apiKey = p.key;
+                                break;
+                            }
+                        }
+                    }
+                    if (apiKey)
+                        break;
+                }
+                catch { /* skip */ }
+            }
+        }
+        catch { /* no agents dir */ }
+        if (!apiKey || !baseUrl)
+            return null;
+        return { apiKey, baseUrl, provider: providerHint, model };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Detect or ask for LLM config and persist to ~/.hicortex/config.json.
+ * The daemon can't inherit shell env vars, so we persist here.
+ */
+async function persistLlmConfig() {
     const configPath = (0, node_path_1.join)(HICORTEX_HOME, "config.json");
     // Read existing config (may have licenseKey)
     let config = {};
@@ -242,43 +290,76 @@ function persistLlmConfig() {
     }
     catch { /* new file */ }
     // Don't overwrite if LLM config already persisted
-    if (config.llmApiKey && config.llmBaseUrl) {
-        console.log(`  ✓ LLM config already in ${configPath}`);
+    if (config.llmBackend || (config.llmApiKey && config.llmBaseUrl)) {
+        console.log(`  ✓ LLM config already configured`);
         return;
     }
-    // Detect from environment (same priority as resolveLlmConfigForCC)
+    // Try auto-detect from environment
     const hcKey = process.env.HICORTEX_LLM_API_KEY;
     const hcUrl = process.env.HICORTEX_LLM_BASE_URL;
-    const hcModel = process.env.HICORTEX_LLM_MODEL;
     if (hcKey && hcUrl) {
         config.llmApiKey = hcKey;
         config.llmBaseUrl = hcUrl;
-        if (hcModel)
-            config.llmModel = hcModel;
+        if (process.env.HICORTEX_LLM_MODEL)
+            config.llmModel = process.env.HICORTEX_LLM_MODEL;
+        saveConfig(configPath, config);
+        console.log(`  ✓ LLM config auto-detected from HICORTEX_LLM_* env vars`);
+        return;
     }
-    else if (process.env.ANTHROPIC_API_KEY) {
+    if (process.env.ANTHROPIC_API_KEY) {
         config.llmApiKey = process.env.ANTHROPIC_API_KEY;
         config.llmBaseUrl = process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com";
         config.llmProvider = "anthropic";
+        saveConfig(configPath, config);
+        console.log(`  ✓ LLM config auto-detected from ANTHROPIC_API_KEY`);
+        return;
     }
-    else if (process.env.OPENAI_API_KEY) {
-        config.llmApiKey = process.env.OPENAI_API_KEY;
-        config.llmBaseUrl = process.env.OPENAI_BASE_URL ?? "https://api.openai.com";
-        config.llmProvider = "openai";
+    // Try OC auth-profiles
+    const ocLlm = readOcLlmConfig();
+    if (ocLlm) {
+        config.llmApiKey = ocLlm.apiKey;
+        config.llmBaseUrl = ocLlm.baseUrl;
+        config.llmProvider = ocLlm.provider;
+        if (ocLlm.model)
+            config.llmModel = ocLlm.model;
+        saveConfig(configPath, config);
+        console.log(`  ✓ LLM config auto-detected from OpenClaw (${ocLlm.provider})`);
+        return;
     }
-    else if (process.env.GOOGLE_API_KEY) {
-        config.llmApiKey = process.env.GOOGLE_API_KEY;
-        config.llmBaseUrl = "https://generativelanguage.googleapis.com/v1beta";
-        config.llmProvider = "google";
+    // Not auto-detected — ask the user
+    console.log("\n  LLM config not auto-detected. Hicortex needs an LLM for nightly learning.\n");
+    console.log("  How should Hicortex access an LLM?\n");
+    console.log("    1. Use Claude subscription via CLI (Haiku model, no API key needed)");
+    console.log("    2. Enter an API key manually (Anthropic, OpenAI, or other)");
+    console.log("    3. Skip for now (can configure later in ~/.hicortex/config.json)\n");
+    const choice = await ask("  Choice [1]: ");
+    const selected = choice === "2" ? 2 : choice === "3" ? 3 : 1;
+    if (selected === 1) {
+        config.llmBackend = "claude-cli";
+        saveConfig(configPath, config);
+        console.log(`  ✓ Configured to use Claude CLI (Haiku model via subscription)`);
+    }
+    else if (selected === 2) {
+        const apiKey = await ask("  API key: ");
+        if (!apiKey) {
+            console.log("  ⚠ No key entered. Skipping.");
+            return;
+        }
+        const baseUrl = await ask("  Base URL [https://api.anthropic.com]: ");
+        config.llmApiKey = apiKey;
+        config.llmBaseUrl = baseUrl || "https://api.anthropic.com";
+        config.llmProvider = "anthropic";
+        saveConfig(configPath, config);
+        console.log(`  ✓ API key saved`);
     }
     else {
-        console.log("  ⚠ No LLM API key found in environment. Server will use Ollama fallback.");
-        console.log("    Set ANTHROPIC_API_KEY and re-run init, or edit ~/.hicortex/config.json");
+        console.log("  ⚠ Skipped. Nightly learning won't work until LLM is configured.");
         return;
     }
+}
+function saveConfig(configPath, config) {
     (0, node_fs_1.mkdirSync)(HICORTEX_HOME, { recursive: true });
     (0, node_fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2));
-    console.log(`  ✓ LLM config saved to ${configPath}`);
 }
 /**
  * Determine the npm package specifier for the daemon.
@@ -480,8 +561,8 @@ async function runInit() {
     }
     console.log();
     // Phase 3: Execute
-    // Persist LLM config from current environment for the daemon
-    persistLlmConfig();
+    // Persist LLM config for the daemon
+    await persistLlmConfig();
     // Install daemon if needed
     if (!d.localServer && !d.remoteServer) {
         installDaemon();

package/dist/llm.d.ts

@@ -44,6 +44,15 @@ export declare function resolveLlmConfigForCC(overrides?: {
     llmModel?: string;
     reflectModel?: string;
 }): LlmConfig;
+/**
+ * Find the claude CLI binary. Returns the full path or null.
+ */
+export declare function findClaudeBinary(): string | null;
+/**
+ * Create an LlmConfig that uses the claude CLI as backend.
+ * baseUrl field stores the path to the claude binary.
+ */
+export declare function claudeCliConfig(claudePath: string): LlmConfig;
 export declare class RateLimitError extends Error {
     retryAfterMs: number;
     constructor(retryAfterMs: number);
@@ -68,6 +77,11 @@ export declare class LlmClient {
      */
     completeDistill(prompt: string, maxTokens?: number): Promise<string>;
     private complete;
+    /**
+     * Claude CLI: shell out to `claude -p` for subscription users.
+     * No API key needed — uses CC's authenticated session.
+     */
+    private completeClaude;
     /**
      * Ollama: use /api/generate with think:false (important for qwen3.5 models).
      */

package/dist/llm.js

@@ -22,6 +22,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LlmClient = exports.RateLimitError = void 0;
 exports.resolveLlmConfig = resolveLlmConfig;
 exports.resolveLlmConfigForCC = resolveLlmConfigForCC;
+exports.findClaudeBinary = findClaudeBinary;
+exports.claudeCliConfig = claudeCliConfig;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const node_os_1 = require("node:os");
@@ -122,7 +124,12 @@ function resolveLlmConfigForCC(overrides) {
             provider: "google",
         };
     }
-    // 4. Ollama fallback
+    // 4. Claude CLI fallback (subscription users)
+    const claudePath = findClaudeBinary();
+    if (claudePath) {
+        return claudeCliConfig(claudePath);
+    }
+    // 5. Ollama fallback (truly last resort)
     return {
         baseUrl: "http://localhost:11434",
         apiKey: "",
@@ -333,6 +340,45 @@ function getDefaultUrlForProvider(provider) {
 function getEnvKeyForZai() {
     return process.env.ZAI_API_KEY ?? process.env.LLM_API_KEY;
 }
+/**
+ * Find the claude CLI binary. Returns the full path or null.
+ */
+function findClaudeBinary() {
+    const { execSync } = require("node:child_process");
+    const { existsSync } = require("node:fs");
+    const { join } = require("node:path");
+    const { homedir } = require("node:os");
+    // Check common paths
+    const candidates = [
+        join(homedir(), ".local", "bin", "claude"),
+        "/usr/local/bin/claude",
+        "/opt/homebrew/bin/claude",
+    ];
+    for (const p of candidates) {
+        if (existsSync(p))
+            return p;
+    }
+    // Fall back to which
+    try {
+        return execSync("which claude 2>/dev/null", { encoding: "utf-8" }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Create an LlmConfig that uses the claude CLI as backend.
+ * baseUrl field stores the path to the claude binary.
+ */
+function claudeCliConfig(claudePath) {
+    return {
+        baseUrl: claudePath,
+        apiKey: "",
+        model: "haiku",
+        reflectModel: "haiku",
+        provider: "claude-cli",
+    };
+}
 // ---------------------------------------------------------------------------
 // LLM Client class
 // ---------------------------------------------------------------------------
@@ -390,6 +436,9 @@ class LlmClient {
         if (this.isRateLimited) {
             throw new RateLimitError(this.rateLimitedUntil - Date.now());
         }
+        if (this.config.provider === "claude-cli") {
+            return this.completeClaude(model, prompt, timeoutMs);
+        }
         if (this.config.provider === "ollama") {
             return this.completeOllama(model, prompt, maxTokens, timeoutMs);
         }
@@ -398,6 +447,29 @@ class LlmClient {
         }
         return this.completeOpenAiCompat(model, prompt, maxTokens, timeoutMs);
     }
+    /**
+     * Claude CLI: shell out to `claude -p` for subscription users.
+     * No API key needed — uses CC's authenticated session.
+     */
+    async completeClaude(model, prompt, timeoutMs) {
+        const { execSync } = require("node:child_process");
+        const claudePath = this.config.baseUrl; // baseUrl stores the claude binary path
+        try {
+            const raw = execSync(`${claudePath} -p ${JSON.stringify(prompt)} --model ${model} --max-turns 1 --output-format json --no-session-persistence < /dev/null`, { encoding: "utf-8", timeout: timeoutMs, maxBuffer: 10 * 1024 * 1024 });
+            const data = JSON.parse(raw);
+            if (data.is_error) {
+                throw new Error(`Claude CLI error: ${data.result}`);
+            }
+            return (data.result ?? "").trim();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes("rate") || msg.includes("429") || msg.includes("overloaded")) {
+                this.handleRateLimit({ headers: { get: () => null } });
+            }
+            throw new Error(`Claude CLI failed: ${msg}`);
+        }
+    }
     /**
      * Ollama: use /api/generate with think:false (important for qwen3.5 models).
      */

package/dist/mcp-server.js

@@ -179,13 +179,26 @@ async function startServer(options = {}) {
     console.log(`[hicortex] Initializing database at ${dbPath}`);
     db = (0, db_js_1.initDb)(dbPath);
     stateDir = dbPath.replace(/\/hicortex\.db$/, "");
-    // LLM config: read from config.json first (persisted by init), then env vars
+    // LLM config: check config.json first, then env vars, then claude CLI
     const savedConfig = readConfigFile(stateDir);
-    const llmConfig = (0, llm_js_1.resolveLlmConfigForCC)({
-        llmBaseUrl: savedConfig?.llmBaseUrl,
-        llmApiKey: savedConfig?.llmApiKey,
-        llmModel: savedConfig?.llmModel,
-    });
+    let llmConfig;
+    if (savedConfig?.llmBackend === "claude-cli") {
+        const claudePath = (0, llm_js_1.findClaudeBinary)();
+        if (claudePath) {
+            llmConfig = (0, llm_js_1.claudeCliConfig)(claudePath);
+        }
+        else {
+            console.warn("[hicortex] claude-cli configured but claude binary not found, falling back");
+            llmConfig = (0, llm_js_1.resolveLlmConfigForCC)();
+        }
+    }
+    else {
+        llmConfig = (0, llm_js_1.resolveLlmConfigForCC)({
+            llmBaseUrl: savedConfig?.llmBaseUrl,
+            llmApiKey: savedConfig?.llmApiKey,
+            llmModel: savedConfig?.llmModel,
+        });
+    }
     llm = new llm_js_1.LlmClient(llmConfig);
     console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model} (reflect: ${llmConfig.reflectModel})`);
     // License: read from options, config file, or env var

package/dist/nightly.js

@@ -58,6 +58,15 @@ const claude_md_js_1 = require("./claude-md.js");
 const license_js_1 = require("./license.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");
+function readNightlyConfig(stateDir) {
+    try {
+        const configPath = (0, node_path_1.join)(stateDir, "config.json");
+        return JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
 function readConfigLicenseKey(stateDir) {
     try {
         const configPath = (0, node_path_1.join)(stateDir, "config.json");
@@ -97,8 +106,26 @@ async function runNightly(options = {}) {
         // License: read from config file or env var
         const licenseKey = readConfigLicenseKey(stateDir) ?? process.env.HICORTEX_LICENSE_KEY;
         await (0, license_js_1.validateLicense)(licenseKey, stateDir);
-        // Init LLM
-        const llmConfig = (0, llm_js_1.resolveLlmConfigForCC)();
+        // Init LLM: check config.json first, then auto-detect
+        let llmConfig;
+        const savedConfig = readNightlyConfig(stateDir);
+        if (savedConfig?.llmBackend === "claude-cli") {
+            const claudePath = (0, llm_js_1.findClaudeBinary)();
+            if (claudePath) {
+                llmConfig = (0, llm_js_1.claudeCliConfig)(claudePath);
+            }
+            else {
+                console.warn("[hicortex] claude-cli configured but binary not found, falling back");
+                llmConfig = (0, llm_js_1.resolveLlmConfigForCC)();
+            }
+        }
+        else {
+            llmConfig = (0, llm_js_1.resolveLlmConfigForCC)({
+                llmBaseUrl: savedConfig?.llmBaseUrl,
+                llmApiKey: savedConfig?.llmApiKey,
+                llmModel: savedConfig?.llmModel,
+            });
+        }
         const llm = new llm_js_1.LlmClient(llmConfig);
         console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model}`);
         // Step 1: Read new CC transcripts

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hicortex",
   "name": "Hicortex — Long-term Memory That Learns",
   "description": "Your agents remember past decisions, avoid repeated mistakes, and get smarter every day. Nightly reflection generates actionable lessons that automatically update agent behavior.",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "kind": "lifecycle",
   "skills": ["./skills/hicortex-memory", "./skills/hicortex-learn", "./skills/hicortex-activate"],
   "configSchema": {

package/package.json

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