@deeplake/hivemind 0.7.79 → 0.7.80

package/hermes/bundle/pre-tool-use.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. */
@@ -1128,8 +1128,8 @@ function formatToolCall(obj) {
 input: ${formatToolInput(obj?.tool_input)}
 response: ${formatToolResponse(obj?.tool_response, obj?.tool_input, obj?.tool_name)}`;
 }
-function normalizeContent(path, raw) {
-  if (!path.includes("/sessions/"))
+function normalizeContent(path2, raw) {
+  if (!path2.includes("/sessions/"))
     return raw;
   if (!raw || raw[0] !== "{")
     return raw;
@@ -1856,13 +1856,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 {
@@ -1873,13 +1873,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;
 }
@@ -2350,18 +2350,18 @@ function lastBuildPath(baseDir, worktreeId) {
   return join11(baseDir, ".last-build.json");
 }
 function readLastBuild(baseDir, worktreeId) {
-  let path = lastBuildPath(baseDir, worktreeId);
-  if (!existsSync5(path)) {
+  let path2 = lastBuildPath(baseDir, worktreeId);
+  if (!existsSync5(path2)) {
     if (worktreeId === void 0)
       return null;
     const legacy = lastBuildPath(baseDir, void 0);
     if (!existsSync5(legacy))
       return null;
-    path = legacy;
+    path2 = legacy;
   }
   let raw;
   try {
-    raw = readFileSync7(path, "utf8");
+    raw = readFileSync7(path2, "utf8");
   } catch {
     return null;
   }
@@ -2970,18 +2970,18 @@ function workTreeIdFor(cwd) {
   return createHash3("sha256").update(cwd).digest("hex").slice(0, 16);
 }
 function handleGraphVfs(subpath, cwd) {
-  const path = subpath.replace(/^\/+/, "");
-  if (path === "" || path === "/") {
+  const path2 = subpath.replace(/^\/+/, "");
+  if (path2 === "" || path2 === "/") {
     return { kind: "ok", body: dirListing() };
   }
-  if (path === "index.md" || path === "index") {
+  if (path2 === "index.md" || path2 === "index") {
     return loadSnapshotOrError(cwd, (snap, baseDir) => ({
       kind: "ok",
       body: renderIndex(snap, baseDir, cwd)
     }));
   }
-  if (path.startsWith("find/")) {
-    const pattern = path.slice("find/".length);
+  if (path2.startsWith("find/")) {
+    const pattern = path2.slice("find/".length);
     if (pattern === "") {
       return { kind: "not-found", message: "find/ requires a pattern: cat memory/graph/find/<keyword>" };
     }
@@ -2990,8 +2990,8 @@ function handleGraphVfs(subpath, cwd) {
       body: renderFind(snap, pattern, baseDir, workTreeIdFor(cwd))
     }));
   }
-  if (path.startsWith("show/")) {
-    const key = path.slice("show/".length);
+  if (path2.startsWith("show/")) {
+    const key = path2.slice("show/".length);
     if (key === "") {
       return { kind: "not-found", message: "show/ requires a handle or pattern" };
     }
@@ -3000,8 +3000,8 @@ function handleGraphVfs(subpath, cwd) {
       body: renderShow(snap, key, baseDir, workTreeIdFor(cwd))
     }));
   }
-  if (path.startsWith("query/")) {
-    const pattern = path.slice("query/".length);
+  if (path2.startsWith("query/")) {
+    const pattern = path2.slice("query/".length);
     if (pattern === "") {
       return { kind: "not-found", message: "query/ requires a pattern: cat memory/graph/query/<keyword>" };
     }
@@ -3010,28 +3010,28 @@ function handleGraphVfs(subpath, cwd) {
       body: renderQuery(snap, pattern, baseDir, workTreeIdFor(cwd))
     }));
   }
-  if (path.startsWith("impact/")) {
-    const pattern = path.slice("impact/".length);
+  if (path2.startsWith("impact/")) {
+    const pattern = path2.slice("impact/".length);
     if (pattern === "") {
       return { kind: "not-found", message: "impact/ requires a pattern: cat memory/graph/impact/<symbol>" };
     }
     return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderImpact(snap, pattern) }));
   }
-  if (path.startsWith("neighborhood/")) {
-    const file = path.slice("neighborhood/".length);
+  if (path2.startsWith("neighborhood/")) {
+    const file = path2.slice("neighborhood/".length);
     if (file === "") {
       return { kind: "not-found", message: "neighborhood/ requires a file path: cat memory/graph/neighborhood/<file>" };
     }
     return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderNeighborhood(snap, file) }));
   }
-  if (path === "layers" || path === "layers/" || path === "layers/index.md") {
+  if (path2 === "layers" || path2 === "layers/" || path2 === "layers/index.md") {
     return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderLayers(snap) }));
   }
-  if (path === "tour" || path === "tour/" || path === "tour/index.md") {
+  if (path2 === "tour" || path2 === "tour/" || path2 === "tour/index.md") {
     return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderTour(snap) }));
   }
-  if (path.startsWith("path/")) {
-    const rest = path.slice("path/".length);
+  if (path2.startsWith("path/")) {
+    const rest = path2.slice("path/".length);
     const slash = rest.indexOf("/");
     if (slash <= 0 || slash === rest.length - 1) {
       return { kind: "not-found", message: "path/ needs two patterns: cat memory/graph/path/<from>/<to> (each a symbol-name substring, no slash)" };
@@ -3042,7 +3042,7 @@ function handleGraphVfs(subpath, cwd) {
   }
   return {
     kind: "not-found",
-    message: `Unknown endpoint: graph/${path}
+    message: `Unknown endpoint: graph/${path2}
 Available: index.md, find/<pattern>, query/<pattern>, show/<handle-or-pattern>, impact/<pattern>, neighborhood/<file>, layers, tour, path/<from>/<to>`
   };
 }
@@ -3441,22 +3441,22 @@ function handlesPath(baseDir, worktreeId) {
   return join14(baseDir, "worktrees", worktreeId, ".find-handles.json");
 }
 function saveHandles(baseDir, worktreeId, ids, pattern) {
-  const path = handlesPath(baseDir, worktreeId);
+  const path2 = handlesPath(baseDir, worktreeId);
   const payload = { pattern, ts: Date.now(), ids };
   try {
-    mkdirSync8(dirname6(path), { recursive: true });
-    const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
+    mkdirSync8(dirname6(path2), { recursive: true });
+    const tmp = `${path2}.tmp.${process.pid}.${Date.now()}`;
     writeFileSync7(tmp, JSON.stringify(payload));
-    renameSync5(tmp, path);
+    renameSync5(tmp, path2);
   } catch {
   }
 }
 function loadHandles(baseDir, worktreeId) {
-  const path = handlesPath(baseDir, worktreeId);
-  if (!existsSync7(path))
+  const path2 = handlesPath(baseDir, worktreeId);
+  if (!existsSync7(path2))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync9(path, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path2, "utf8"));
     if (parsed === null || typeof parsed !== "object")
       return null;
     const o = parsed;
@@ -3546,10 +3546,230 @@ function tryGraphRead(rewrittenCommand, cwd) {
   return result.kind === "ok" ? result.body : `(${result.kind}) ${result.message}`;
 }
 
+// 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 fileURLToPath2 } from "node:url";
+
+// dist/src/skillify/state-dir.js
+import { homedir as homedir10 } from "node:os";
+import { join as join15 } from "node:path";
+function getStateDir() {
+  const override = process.env.HIVEMIND_STATE_DIR?.trim();
+  return override && override.length > 0 ? override : join15(homedir10(), ".deeplake", "state", "skillify");
+}
+
+// dist/src/skillify/skill-invocations.js
+function pathToSkillRef(s) {
+  if (typeof s !== "string")
+    return null;
+  const m = s.match(/\/skills\/(?:[^/\s"'`]+\/)*([^/\s"'`]+)\/SKILL\.md/);
+  return m ? m[1] : null;
+}
+function splitOrgSkill(skill) {
+  if (skill.includes(":"))
+    return null;
+  if (skill.includes("/") || skill.includes("\\") || skill.includes(".."))
+    return null;
+  const i = skill.lastIndexOf("--");
+  if (i <= 0 || i + 2 >= skill.length)
+    return null;
+  return { name: skill.slice(0, i), author: skill.slice(i + 2) };
+}
+
+// dist/src/skillify/manifest.js
+import { existsSync as existsSync9, lstatSync, mkdirSync as mkdirSync9, readFileSync as readFileSync10, renameSync as renameSync7, unlinkSync as unlinkSync4, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname8, join as join17 } from "node:path";
+
+// dist/src/skillify/legacy-migration.js
+import { existsSync as existsSync8, renameSync as renameSync6 } from "node:fs";
+import { dirname as dirname7, join as join16 } from "node:path";
+var dlog = (msg) => log("skillify-migrate", msg);
+var attempted = false;
+function migrateLegacyStateDir() {
+  if (process.env.HIVEMIND_STATE_DIR?.trim())
+    return;
+  if (attempted)
+    return;
+  attempted = true;
+  const current = getStateDir();
+  const legacy = join16(dirname7(current), "skilify");
+  if (!existsSync8(legacy))
+    return;
+  if (existsSync8(current))
+    return;
+  try {
+    renameSync6(legacy, current);
+    dlog(`migrated ${legacy} -> ${current}`);
+  } catch (err) {
+    const code = err.code;
+    if (code === "EXDEV" || code === "EPERM" || code === "ENOENT" || code === "EEXIST" || code === "ENOTEMPTY") {
+      dlog(`migration skipped (${code}); legacy dir left as-is or another process handled it`);
+      return;
+    }
+    throw err;
+  }
+}
+
+// dist/src/skillify/manifest.js
+function emptyManifest() {
+  return { version: 1, entries: [] };
+}
+function manifestPath() {
+  return join17(getStateDir(), "pulled.json");
+}
+function loadManifest(path2 = manifestPath()) {
+  migrateLegacyStateDir();
+  if (!existsSync9(path2))
+    return emptyManifest();
+  let raw;
+  try {
+    raw = readFileSync10(path2, "utf-8");
+  } catch {
+    return emptyManifest();
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object")
+      return emptyManifest();
+    if (parsed.version !== 1 || !Array.isArray(parsed.entries))
+      return emptyManifest();
+    const entries = [];
+    for (const e of parsed.entries) {
+      if (!e || typeof e !== "object")
+        continue;
+      if (typeof e.dirName !== "string" || !e.dirName)
+        continue;
+      if (e.dirName.includes("/") || e.dirName.includes("\\") || e.dirName.includes(".."))
+        continue;
+      if (typeof e.name !== "string" || !e.name)
+        continue;
+      if (typeof e.author !== "string")
+        continue;
+      if (typeof e.installRoot !== "string" || !e.installRoot)
+        continue;
+      if (e.install !== "global" && e.install !== "project")
+        continue;
+      const symlinks = Array.isArray(e.symlinks) ? e.symlinks.filter((p) => typeof p === "string" && p.length > 0 && (p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p)) && // absolute (POSIX or Windows)
+      !p.includes("..")) : [];
+      entries.push({
+        dirName: e.dirName,
+        name: e.name,
+        author: e.author,
+        projectKey: typeof e.projectKey === "string" ? e.projectKey : "",
+        remoteVersion: typeof e.remoteVersion === "number" ? e.remoteVersion : 1,
+        install: e.install,
+        installRoot: e.installRoot,
+        pulledAt: typeof e.pulledAt === "string" ? e.pulledAt : (/* @__PURE__ */ new Date()).toISOString(),
+        symlinks
+      });
+    }
+    return { version: 1, entries };
+  } catch {
+    return emptyManifest();
+  }
+}
+
+// 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 DEFAULT_JUDGE_WINDOW = 3;
+function judgeWindow(env = process.env) {
+  const n = Number(env[SKILLOPT_ENV.JUDGE_WINDOW]);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : DEFAULT_JUDGE_WINDOW;
+}
+function defaultIsOrgSkill(skillRef) {
+  try {
+    return loadManifest().entries.some((e) => e.dirName === skillRef);
+  } catch {
+    return false;
+  }
+}
+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 markSkillPending(sessionId, skillRef, toolUseId, deps = {}) {
+  if (!sessionId || !skillRef)
+    return false;
+  if (!splitOrgSkill(skillRef))
+    return false;
+  if (!(deps.isOrgSkill ?? defaultIsOrgSkill)(skillRef))
+    return false;
+  (deps.store ?? fileStore).save(sessionId, { skill: skillRef, budget: judgeWindow(deps.env ?? process.env), toolUseId });
+  return true;
+}
+
+// dist/src/hooks/shared/skillopt-hook.js
+function skillRefFromSkillFileRead(toolName, toolInput) {
+  if (/^read$/i.test(toolName))
+    return pathToSkillRef(toolInput?.path);
+  return pathToSkillRef(toolInput?.command);
+}
+function armSkillOptOnSkillUse(sessionId, toolName, toolInput, toolUseId) {
+  try {
+    if (process.env[SKILLOPT_ENV.DISABLED] === "1")
+      return;
+    let ref = null;
+    if (toolName === "Skill") {
+      const s = toolInput?.skill;
+      ref = typeof s === "string" ? s : null;
+    } else {
+      ref = skillRefFromSkillFileRead(toolName, toolInput);
+    }
+    if (ref)
+      markSkillPending(sessionId, ref, toolUseId);
+  } catch {
+  }
+}
+
 // dist/src/hooks/hermes/pre-tool-use.js
 var log5 = (msg) => log("hermes-pre-tool-use", msg);
 async function main() {
   const input = await readStdin();
+  armSkillOptOnSkillUse(input.session_id ?? "", input.tool_name ?? "", input.tool_input);
   if (input.tool_name !== "terminal")
     return;
   const ti = input.tool_input;