@deeplake/hivemind 0.7.78 → 0.7.80

package/hermes/bundle/capture.js

@@ -366,38 +366,38 @@ function readQueue() {
     return { queue: [] };
   }
 }
-function _isQueuePathInsideHome(path, home) {
-  const r = resolve(path);
+function _isQueuePathInsideHome(path2, home) {
+  const r = resolve(path2);
   const h = resolve(home);
   return r.startsWith(h + "/") || r === h;
 }
 function writeQueue(q) {
-  const path = queuePath();
+  const path2 = queuePath();
   const home = resolve(homedir3());
-  if (!_isQueuePathInsideHome(path, home)) {
-    throw new Error(`notifications-queue write blocked: ${path} is outside ${home}`);
+  if (!_isQueuePathInsideHome(path2, home)) {
+    throw new Error(`notifications-queue write blocked: ${path2} is outside ${home}`);
   }
   mkdirSync(join3(home, ".deeplake"), { recursive: true, mode: 448 });
-  const tmp = `${path}.${process.pid}.tmp`;
+  const tmp = `${path2}.${process.pid}.tmp`;
   writeFileSync(tmp, JSON.stringify(q, null, 2), { mode: 384 });
-  renameSync(tmp, path);
+  renameSync(tmp, path2);
 }
 async function withQueueLock(fn) {
-  const path = lockPath();
+  const path2 = lockPath();
   mkdirSync(join3(homedir3(), ".deeplake"), { recursive: true, mode: 448 });
   let fd = null;
   for (let attempt = 0; attempt < LOCK_RETRY_MAX; attempt++) {
     try {
-      fd = openSync(path, "wx", 384);
+      fd = openSync(path2, "wx", 384);
       break;
     } catch (e) {
       const code = e.code;
       if (code !== "EEXIST")
         throw e;
       try {
-        const age = Date.now() - statSync(path).mtimeMs;
+        const age = Date.now() - statSync(path2).mtimeMs;
         if (age > LOCK_STALE_MS) {
-          unlinkSync(path);
+          unlinkSync(path2);
           continue;
         }
       } catch {
@@ -418,7 +418,7 @@ async function withQueueLock(fn) {
     } catch {
     }
     try {
-      unlinkSync(path);
+      unlinkSync(path2);
     } catch {
     }
   }
@@ -694,9 +694,9 @@ var DeeplakeApi = class {
     }
   }
   /** Update specific columns on a row by path. */
-  async updateColumns(path, columns) {
+  async updateColumns(path2, columns) {
     const setClauses = Object.entries(columns).map(([col, val]) => typeof val === "number" ? `${col} = ${val}` : `${col} = '${sqlStr(String(val))}'`).join(", ");
-    await this.query(`UPDATE "${this.tableName}" SET ${setClauses} WHERE path = '${sqlStr(path)}'`);
+    await this.query(`UPDATE "${this.tableName}" SET ${setClauses} WHERE path = '${sqlStr(path2)}'`);
   }
   // ── Convenience ─────────────────────────────────────────────────────────────
   /** Create a BM25 search index on a column. */
@@ -1402,13 +1402,13 @@ var _migrated = false;
 function readUserConfig() {
   if (_cache !== null)
     return _cache;
-  const path = _configPath();
-  if (!existsSync4(path)) {
+  const path2 = _configPath();
+  if (!existsSync4(path2)) {
     _cache = {};
     return _cache;
   }
   try {
-    const raw = readFileSync6(path, "utf-8");
+    const raw = readFileSync6(path2, "utf-8");
     const parsed = JSON.parse(raw);
     _cache = isPlainObject(parsed) ? parsed : {};
   } catch {
@@ -1419,13 +1419,13 @@ function readUserConfig() {
 function writeUserConfig(patch) {
   const current = readUserConfig();
   const merged = deepMerge(current, patch);
-  const path = _configPath();
-  const dir = dirname(path);
+  const path2 = _configPath();
+  const dir = dirname(path2);
   if (!existsSync4(dir))
     mkdirSync4(dir, { recursive: true });
-  const tmp = `${path}.tmp.${process.pid}`;
+  const tmp = `${path2}.tmp.${process.pid}`;
   writeFileSync4(tmp, JSON.stringify(merged, null, 2) + "\n", "utf-8");
-  renameSync2(tmp, path);
+  renameSync2(tmp, path2);
   _cache = merged;
   return merged;
 }
@@ -1570,8 +1570,8 @@ function createSymlinkAtomic(target, link) {
 }
 
 // dist/src/hooks/hermes/capture.js
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { dirname as dirname7, join as join20 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { dirname as dirname8, join as join21 } from "node:path";
 
 // dist/src/hooks/summary-state.js
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, writeSync as writeSync2, mkdirSync as mkdirSync6, renameSync as renameSync4, existsSync as existsSync6, unlinkSync as unlinkSync4, openSync as openSync3, closeSync as closeSync3, statSync as statSync3 } from "node:fs";
@@ -1718,13 +1718,13 @@ import { homedir as homedir10, tmpdir as tmpdir2 } from "node:os";
 import { mkdirSync as mkdirSync7, appendFileSync as appendFileSync2 } from "node:fs";
 import { join as join11 } from "node:path";
 function makeWikiLogger(hooksDir, filename = "deeplake-wiki.log") {
-  const path = join11(hooksDir, filename);
+  const path2 = join11(hooksDir, filename);
   return {
-    path,
+    path: path2,
     log(msg) {
       try {
         mkdirSync7(hooksDir, { recursive: true });
-        appendFileSync2(path, `[${utcTimestamp()}] ${msg}
+        appendFileSync2(path2, `[${utcTimestamp()}] ${msg}
 `);
       } catch {
       }
@@ -1777,10 +1777,10 @@ function getInstalledVersion(bundleDir, pluginManifestDir) {
 // dist/src/utils/spawn-detached.js
 import { spawn as nodeSpawn } from "node:child_process";
 function spawnDetachedNodeWorker(workerPath, args = [], deps = {}) {
-  const spawn2 = deps.spawn ?? nodeSpawn;
+  const spawn3 = deps.spawn ?? nodeSpawn;
   const execPath = deps.execPath ?? process.execPath;
   try {
-    const child = spawn2(execPath, [workerPath, ...args], {
+    const child = spawn3(execPath, [workerPath, ...args], {
       detached: true,
       stdio: ["ignore", "ignore", "ignore"],
       // Suppress the transient console window Windows would otherwise pop for
@@ -2317,12 +2317,132 @@ function tryStopCounterTrigger(opts) {
   }
 }
 
+// dist/src/skillify/skillopt-trigger.js
+import { spawn as spawn2 } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
+// dist/src/skillify/manifest.js
+import { existsSync as existsSync11, lstatSync as lstatSync3, mkdirSync as mkdirSync12, readFileSync as readFileSync11, renameSync as renameSync7, unlinkSync as unlinkSync6, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname7, join as join20 } from "node:path";
+
+// dist/src/skillify/skillopt-env.js
+var SKILLOPT_ENV = {
+  /** User-set kill switch: "1" disables the whole trigger. */
+  DISABLED: "HIVEMIND_SKILLOPT_DISABLED",
+  /** Recursion guard the trigger sets on the spawned worker so the worker can't re-arm. */
+  WORKER: "HIVEMIND_SKILLOPT_WORKER",
+  /** Worker inputs, handed trigger → worker via the child env. */
+  SESSION: "HIVEMIND_SKILLOPT_SESSION",
+  SKILL: "HIVEMIND_SKILLOPT_SKILL",
+  REACTION: "HIVEMIND_SKILLOPT_REACTION",
+  TOOL_USE_ID: "HIVEMIND_SKILLOPT_TOOL_USE_ID",
+  /** Which agent's CLI runs the judge/proposer (claude_code/codex/hermes/cursor/pi). */
+  AGENT: "HIVEMIND_SKILLOPT_AGENT",
+  /** K-message judgment-window size override. */
+  JUDGE_WINDOW: "HIVEMIND_SKILLOPT_JUDGE_WINDOW"
+};
+
+// dist/src/skillify/skillopt-trigger.js
+var log5 = (m) => log("skillopt-trigger", m);
+function defaultHasCreds() {
+  try {
+    return Boolean(loadConfig()?.token);
+  } catch {
+    return false;
+  }
+}
+var MAX_REACTION = 8e3;
+function pendingFile(sessionId) {
+  const safe = sessionId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 200);
+  return path.join(getStateDir(), "skillopt", "pending", `${safe}.json`);
+}
+var fileStore = {
+  load(sessionId) {
+    try {
+      return JSON.parse(fs.readFileSync(pendingFile(sessionId), "utf8"));
+    } catch {
+      return null;
+    }
+  },
+  save(sessionId, p) {
+    try {
+      const f = pendingFile(sessionId);
+      if (p === null) {
+        try {
+          fs.unlinkSync(f);
+        } catch {
+        }
+        return;
+      }
+      fs.mkdirSync(path.dirname(f), { recursive: true });
+      const tmp = `${f}.${process.pid}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify(p));
+      fs.renameSync(tmp, f);
+    } catch {
+    }
+  }
+};
+function runEventTrigger(sessionId, reaction, opts = {}) {
+  const deps = opts.deps ?? {};
+  const env = deps.env ?? process.env;
+  if (env[SKILLOPT_ENV.DISABLED] === "1")
+    return { fired: false, reason: "disabled" };
+  if (env[SKILLOPT_ENV.WORKER] === "1")
+    return { fired: false, reason: "in-worker" };
+  if (!sessionId)
+    return { fired: false, reason: "no-skill" };
+  const store = deps.store ?? fileStore;
+  const p = store.load(sessionId);
+  if (!p)
+    return { fired: false, reason: "no-skill" };
+  if (!(deps.canFire ?? defaultHasCreds)())
+    return { fired: false, reason: "no-creds" };
+  store.save(sessionId, p.budget - 1 <= 0 ? null : { ...p, budget: p.budget - 1 });
+  (deps.spawnWorker ?? spawnWorker)(sessionId, p.skill, reaction ?? "", p.toolUseId, opts.agent);
+  return { fired: true, reason: "spawned" };
+}
+function spawnWorker(sessionId, skill, reaction, toolUseId, agent) {
+  try {
+    const here = path.dirname(fileURLToPath3(import.meta.url));
+    const entry = path.join(here, "skillopt-worker.js");
+    const child = spawn2(process.execPath, [entry], {
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        [SKILLOPT_ENV.WORKER]: "1",
+        [SKILLOPT_ENV.SESSION]: sessionId,
+        [SKILLOPT_ENV.SKILL]: skill,
+        [SKILLOPT_ENV.REACTION]: (reaction ?? "").slice(0, MAX_REACTION),
+        ...toolUseId ? { [SKILLOPT_ENV.TOOL_USE_ID]: toolUseId } : {},
+        ...agent ? { [SKILLOPT_ENV.AGENT]: agent } : {}
+      }
+    });
+    child.unref();
+    log5(`spawned skillopt worker for ${skill} in ${sessionId}${agent ? ` (agent=${agent})` : ""}`);
+  } catch (e) {
+    log5(`spawn failed (swallowed): ${e?.message ?? e}`);
+  }
+}
+
+// dist/src/hooks/shared/skillopt-hook.js
+function reactSkillOpt(sessionId, prompt, agent) {
+  try {
+    if (prompt === void 0 || prompt.trim() === "" || process.env.HIVEMIND_WIKI_WORKER === "1")
+      return;
+    runEventTrigger(sessionId, prompt, { agent });
+  } catch {
+  }
+}
+
 // dist/src/hooks/hermes/capture.js
-var log5 = (msg) => log("hermes-capture", msg);
+var log6 = (msg) => log("hermes-capture", msg);
 function resolveEmbedDaemonPath() {
-  return join20(dirname7(fileURLToPath3(import.meta.url)), "embeddings", "embed-daemon.js");
+  return join21(dirname8(fileURLToPath4(import.meta.url)), "embeddings", "embed-daemon.js");
 }
-var __bundleDir = dirname7(fileURLToPath3(import.meta.url));
+var __bundleDir = dirname8(fileURLToPath4(import.meta.url));
 var PLUGIN_VERSION = getInstalledVersion(__bundleDir, ".claude-plugin") ?? "";
 if (!embeddingsDisabled()) {
   try {
@@ -2344,7 +2464,7 @@ async function main() {
   const input = await readStdin();
   const config = loadConfig();
   if (!config) {
-    log5("no config");
+    log6("no config");
     return;
   }
   const sessionId = input.session_id ?? `hermes-${Date.now()}`;
@@ -2361,17 +2481,19 @@ async function main() {
     timestamp: ts
   };
   let entry = null;
+  let reactPrompt;
   if (event === "pre_llm_call") {
     const prompt = pickString(extra.prompt, extra.user_message, extra.message?.content);
     if (!prompt) {
-      log5(`pre_llm_call: no prompt found in extra`);
+      log6(`pre_llm_call: no prompt found in extra`);
       return;
     }
-    log5(`user session=${sessionId}`);
+    log6(`user session=${sessionId}`);
     entry = { id: crypto.randomUUID(), ...meta, type: "user_message", content: prompt };
+    reactPrompt = prompt;
   } else if (event === "post_tool_call" && typeof input.tool_name === "string") {
     const toolResponse = extra.tool_result ?? extra.tool_output ?? extra.result ?? extra.output;
-    log5(`tool=${input.tool_name} session=${sessionId}`);
+    log6(`tool=${input.tool_name} session=${sessionId}`);
     entry = {
       id: crypto.randomUUID(),
       ...meta,
@@ -2383,18 +2505,18 @@ async function main() {
   } else if (event === "post_llm_call") {
     const text = pickString(extra.response, extra.assistant_message, extra.message?.content);
     if (!text) {
-      log5(`post_llm_call: no response found in extra`);
+      log6(`post_llm_call: no response found in extra`);
       return;
     }
-    log5(`assistant session=${sessionId}`);
+    log6(`assistant session=${sessionId}`);
     entry = { id: crypto.randomUUID(), ...meta, type: "assistant_message", content: text };
   } else {
-    log5(`unknown/unhandled event: ${event}, skipping`);
+    log6(`unknown/unhandled event: ${event}, skipping`);
     return;
   }
   const sessionPath = buildSessionPath(config, sessionId);
   const line = JSON.stringify(entry);
-  log5(`writing to ${sessionPath}`);
+  log6(`writing to ${sessionPath}`);
   const projectName = projectNameFromCwd(cwd);
   const filename = sessionPath.split("/").pop() ?? "";
   const jsonForSql = line.replace(/'/g, "''");
@@ -2405,14 +2527,15 @@ async function main() {
     await api.query(insertSql);
   } catch (e) {
     if (e.message?.includes("permission denied") || e.message?.includes("does not exist")) {
-      log5("table missing, creating and retrying");
+      log6("table missing, creating and retrying");
       await api.ensureSessionsTable(sessionsTable);
       await api.query(insertSql);
     } else {
       throw e;
     }
   }
-  log5("capture ok \u2192 cloud");
+  log6("capture ok \u2192 cloud");
+  reactSkillOpt(sessionId, reactPrompt, "hermes");
   maybeTriggerPeriodicSummary(sessionId, cwd, config);
   if (event === "post_llm_call" && process.env.HIVEMIND_WIKI_WORKER !== "1" && process.env.HIVEMIND_SKILLIFY_WORKER !== "1") {
     tryStopCounterTrigger({
@@ -2433,7 +2556,7 @@ function maybeTriggerPeriodicSummary(sessionId, cwd, config) {
     if (!shouldTrigger(state, cfg))
       return;
     if (!tryAcquireLock(sessionId)) {
-      log5(`periodic trigger suppressed (lock held) session=${sessionId}`);
+      log6(`periodic trigger suppressed (lock held) session=${sessionId}`);
       return;
     }
     wikiLog(`Periodic: threshold hit (total=${state.totalCount}, since=${state.totalCount - state.lastSummaryCount}, N=${cfg.everyNMessages}, hours=${cfg.everyHours})`);
@@ -2446,17 +2569,17 @@ function maybeTriggerPeriodicSummary(sessionId, cwd, config) {
         reason: "Periodic"
       });
     } catch (e) {
-      log5(`periodic spawn failed: ${e.message}`);
+      log6(`periodic spawn failed: ${e.message}`);
       try {
         releaseLock(sessionId);
       } catch {
       }
     }
   } catch (e) {
-    log5(`periodic trigger error: ${e.message}`);
+    log6(`periodic trigger error: ${e.message}`);
   }
 }
 main().catch((e) => {
-  log5(`fatal: ${e.message}`);
+  log6(`fatal: ${e.message}`);
   process.exit(0);
 });