opencode-swarm 7.83.0 → 7.85.0

package/dist/cli/index-e8pk68cc.js

@@ -0,0 +1,540 @@
+// @bun
+import {
+  atomicWriteFile
+} from "./index-fjwwrwr5.js";
+import {
+  readCachedParsedFile
+} from "./index-jtqkh8jf.js";
+import {
+  require_proper_lockfile
+} from "./index-bcp79s17.js";
+import {
+  __toESM
+} from "./index-a76rekgs.js";
+
+// src/hooks/knowledge-store.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { existsSync } from "fs";
+import { appendFile, mkdir, readFile } from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+var KNOWLEDGE_JSONL_CACHE_NAMESPACE = "knowledge-jsonl:normalized:v1";
+function getPlatformConfigDir() {
+  const platform = process.platform;
+  const home = process.env.HOME || os.homedir();
+  if (platform === "win32") {
+    return path.join(process.env.LOCALAPPDATA || path.join(home, "AppData", "Local"), "opencode-swarm", "config");
+  } else if (platform === "darwin") {
+    return path.join(home, "Library", "Application Support", "opencode-swarm");
+  } else {
+    return path.join(process.env.XDG_CONFIG_HOME || path.join(home, ".config"), "opencode-swarm");
+  }
+}
+function resolveSwarmKnowledgePath(directory) {
+  return path.join(directory, ".swarm", "knowledge.jsonl");
+}
+function resolveSwarmRejectedPath(directory) {
+  return path.join(directory, ".swarm", "knowledge-rejected.jsonl");
+}
+function resolveSwarmRetractionsPath(directory) {
+  return path.join(directory, ".swarm", "knowledge-retractions.jsonl");
+}
+function resolveHiveKnowledgePath() {
+  const platform = process.platform;
+  const home = process.env.HOME || os.homedir();
+  let dataDir;
+  if (platform === "win32") {
+    dataDir = path.join(process.env.LOCALAPPDATA || path.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+  } else if (platform === "darwin") {
+    dataDir = path.join(home, "Library", "Application Support", "opencode-swarm");
+  } else {
+    dataDir = path.join(process.env.XDG_DATA_HOME || path.join(home, ".local", "share"), "opencode-swarm");
+  }
+  return path.join(dataDir, "shared-learnings.jsonl");
+}
+function resolveHiveRejectedPath() {
+  const hivePath = resolveHiveKnowledgePath();
+  return path.join(path.dirname(hivePath), "shared-learnings-rejected.jsonl");
+}
+function resolveHiveEventsPath() {
+  const hivePath = resolveHiveKnowledgePath();
+  return path.join(path.dirname(hivePath), "shared-knowledge-events.jsonl");
+}
+function parseKnowledgeContent(content, max) {
+  const results = [];
+  for (const line of content.split(`
+`)) {
+    if (Number.isFinite(max) && results.length >= max)
+      break;
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      results.push(normalizeEntry(JSON.parse(trimmed)));
+    } catch {
+      console.warn(`[knowledge-store] Skipping corrupted JSONL line: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return results;
+}
+async function readKnowledge(filePath, maxEntries) {
+  const resolvedPath = path.resolve(filePath);
+  const cap = maxEntries !== undefined && maxEntries > 0 ? maxEntries : undefined;
+  if (cap !== undefined) {
+    if (!existsSync(resolvedPath))
+      return [];
+    const content = await readFile(resolvedPath, "utf-8");
+    return parseKnowledgeContent(content, cap);
+  }
+  const entries = await readCachedParsedFile(resolvedPath, KNOWLEDGE_JSONL_CACHE_NAMESPACE, async () => {
+    if (!existsSync(resolvedPath))
+      return null;
+    return await readFile(resolvedPath, "utf-8");
+  }, (content) => parseKnowledgeContent(content, Infinity));
+  return entries ?? [];
+}
+function normalizeEntry(raw) {
+  if (!raw || typeof raw !== "object")
+    return raw;
+  const obj = raw;
+  if (!("retrieval_outcomes" in obj))
+    return raw;
+  let ro = obj.retrieval_outcomes;
+  if (!ro || typeof ro !== "object") {
+    ro = {};
+    obj.retrieval_outcomes = ro;
+  }
+  if (typeof ro.shown_count !== "number") {
+    ro.shown_count = typeof ro.applied_count === "number" ? ro.applied_count : 0;
+  }
+  if (typeof ro.acknowledged_count !== "number")
+    ro.acknowledged_count = 0;
+  if (typeof ro.applied_explicit_count !== "number") {
+    ro.applied_explicit_count = 0;
+  }
+  if (typeof ro.ignored_count !== "number")
+    ro.ignored_count = 0;
+  if (typeof ro.violated_count !== "number")
+    ro.violated_count = 0;
+  if (typeof ro.contradicted_count !== "number")
+    ro.contradicted_count = 0;
+  if (typeof ro.succeeded_after_shown_count !== "number") {
+    ro.succeeded_after_shown_count = typeof ro.succeeded_after_count === "number" ? ro.succeeded_after_count : 0;
+  }
+  if (typeof ro.failed_after_shown_count !== "number") {
+    ro.failed_after_shown_count = typeof ro.failed_after_count === "number" ? ro.failed_after_count : 0;
+  }
+  try {
+    if (typeof obj.encounter_score !== "number" || Number.isNaN(obj.encounter_score)) {
+      obj.encounter_score = 0;
+    }
+  } catch {
+    try {
+      Object.defineProperty(obj, "encounter_score", {
+        value: 0,
+        writable: true,
+        configurable: true,
+        enumerable: true
+      });
+    } catch {}
+  }
+  const arrayFields = [
+    "triggers",
+    "required_actions",
+    "forbidden_actions",
+    "applies_to_agents",
+    "applies_to_tools",
+    "verification_checks",
+    "source_refs",
+    "source_knowledge_ids"
+  ];
+  for (const f of arrayFields) {
+    const v = obj[f];
+    if (v !== undefined && !Array.isArray(v)) {
+      delete obj[f];
+    }
+  }
+  if (!Array.isArray(obj.tags)) {
+    obj.tags = [];
+  }
+  return raw;
+}
+async function readRejectedLessons(directory) {
+  return readKnowledge(resolveSwarmRejectedPath(directory));
+}
+async function readRetractionRecords(directory) {
+  return readKnowledge(resolveSwarmRetractionsPath(directory));
+}
+async function appendRetractionRecord(directory, record) {
+  await appendKnowledge(resolveSwarmRetractionsPath(directory), record);
+}
+async function appendKnowledge(filePath, entry) {
+  const dir = path.dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  let release = null;
+  try {
+    release = await import_proper_lockfile.default.lock(dir, {
+      retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
+      stale: 5000
+    });
+    await appendFile(filePath, `${JSON.stringify(entry)}
+`, "utf-8");
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+}
+async function rewriteKnowledge(filePath, entries) {
+  const dir = path.dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  let release = null;
+  try {
+    release = await import_proper_lockfile.default.lock(dir, {
+      retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
+      stale: 5000
+    });
+    const content = entries.map((e) => JSON.stringify(e)).join(`
+`) + (entries.length > 0 ? `
+` : "");
+    await atomicWriteFile(filePath, content);
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+}
+async function transactFile(filePath, read, write, mutate) {
+  const dir = path.dirname(filePath);
+  try {
+    await mkdir(dir, { recursive: true });
+  } catch {
+    return false;
+  }
+  let release = null;
+  try {
+    release = await import_proper_lockfile.default.lock(dir, {
+      retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
+      stale: 5000
+    });
+    const data = await read(filePath);
+    const result = mutate(data);
+    if (result === null)
+      return false;
+    await write(filePath, result);
+    return true;
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+}
+async function transactKnowledge(filePath, mutate) {
+  return transactFile(filePath, readKnowledge, async (fp, entries) => {
+    const content = entries.map((e) => JSON.stringify(e)).join(`
+`) + (entries.length > 0 ? `
+` : "");
+    await atomicWriteFile(fp, content);
+  }, mutate);
+}
+async function appendKnowledgeWithCapEnforcement(filePath, entry, maxEntries) {
+  return transactKnowledge(filePath, (entries) => {
+    const updated = [...entries, entry];
+    if (updated.length > maxEntries) {
+      return selectKnowledgeCapSurvivors(updated, maxEntries);
+    }
+    return updated;
+  });
+}
+async function enforceKnowledgeCap(filePath, maxEntries) {
+  await transactKnowledge(filePath, (entries) => {
+    if (entries.length <= maxEntries)
+      return null;
+    return selectKnowledgeCapSurvivors(entries, maxEntries);
+  });
+}
+function selectKnowledgeCapSurvivors(entries, maxEntries) {
+  if (entries.length <= maxEntries)
+    return entries;
+  if (maxEntries <= 0)
+    return [];
+  const candidates = entries.map((entry, index) => {
+    const maybeKnowledge = entry;
+    return {
+      entry,
+      index,
+      status: maybeKnowledge.status,
+      outcomeSignal: computeOutcomeSignal(maybeKnowledge.retrieval_outcomes)
+    };
+  });
+  const allPromoted = candidates.every((c) => c.status === "promoted");
+  const evictable = allPromoted ? candidates : candidates.filter((c) => c.status !== "promoted");
+  const targetDropCount = entries.length - maxEntries;
+  const dropCount = Math.min(targetDropCount, evictable.length);
+  if (dropCount <= 0)
+    return entries;
+  const drop = new Set([...evictable].sort((a, b) => {
+    const inactiveDelta = getKnowledgeCapStatusPriority(a.status) - getKnowledgeCapStatusPriority(b.status);
+    if (inactiveDelta !== 0)
+      return inactiveDelta;
+    const signalDelta = a.outcomeSignal - b.outcomeSignal;
+    if (signalDelta !== 0)
+      return signalDelta;
+    return a.index - b.index;
+  }).slice(0, dropCount).map((c) => c.index));
+  return candidates.filter((c) => !drop.has(c.index)).map((c) => c.entry);
+}
+function getKnowledgeCapStatusPriority(status) {
+  if (status === "archived" || status === "quarantined" || status === "quarantined_unactionable") {
+    return 0;
+  }
+  return 1;
+}
+async function sweepAgedEntries(filePath, defaultMaxPhases) {
+  const result = {
+    scanned: 0,
+    aged: 0,
+    archived: 0,
+    removed: 0,
+    skipped_promoted: 0
+  };
+  await transactKnowledge(filePath, (entries) => {
+    result.scanned = entries.length;
+    if (entries.length === 0)
+      return null;
+    const now = new Date().toISOString();
+    let mutated = false;
+    for (const entry of entries) {
+      if (entry.status === "archived")
+        continue;
+      if (entry.status === "promoted") {
+        result.skipped_promoted++;
+        continue;
+      }
+      entry.phases_alive = (entry.phases_alive ?? 0) + 1;
+      result.aged++;
+      mutated = true;
+      const ttl = entry.max_phases ?? defaultMaxPhases;
+      if (entry.phases_alive > ttl) {
+        entry.status = "archived";
+        entry.updated_at = now;
+        result.archived++;
+      }
+    }
+    return mutated ? entries : null;
+  });
+  return result;
+}
+async function sweepStaleTodos(filePath, todoMaxPhases) {
+  const result = {
+    scanned: 0,
+    aged: 0,
+    archived: 0,
+    removed: 0,
+    skipped_promoted: 0
+  };
+  await transactKnowledge(filePath, (entries) => {
+    result.scanned = entries.length;
+    if (entries.length === 0)
+      return null;
+    const kept = entries.filter((e) => {
+      if (e.category !== "todo" || e.status === "promoted")
+        return true;
+      const age = e.phases_alive ?? 0;
+      if (age > todoMaxPhases) {
+        result.removed++;
+        return false;
+      }
+      return true;
+    });
+    return result.removed > 0 ? kept : null;
+  });
+  return result;
+}
+async function appendRejectedLesson(directory, lesson, maxEntries = 20) {
+  const filePath = resolveSwarmRejectedPath(directory);
+  await transactKnowledge(filePath, (existing) => {
+    const updated = [...existing, lesson];
+    if (updated.length > maxEntries) {
+      return updated.slice(updated.length - maxEntries);
+    }
+    return updated;
+  });
+}
+function normalize(text) {
+  const s = typeof text === "string" ? text : String(text ?? "");
+  return s.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+function wordBigrams(text) {
+  const words = normalize(text).split(" ").filter(Boolean);
+  const bigrams = new Set;
+  for (let i = 0;i < words.length - 1; i++) {
+    bigrams.add(`${words[i]} ${words[i + 1]}`);
+  }
+  return bigrams;
+}
+function jaccardBigram(a, b) {
+  if (a.size === 0 && b.size === 0)
+    return 1;
+  const aArr = Array.from(a);
+  const intersection = new Set(aArr.filter((x) => b.has(x)));
+  const union = new Set([...aArr, ...Array.from(b)]);
+  return intersection.size / union.size;
+}
+function findNearDuplicate(candidate, entries, threshold = 0.6) {
+  const candidateBigrams = wordBigrams(candidate);
+  return entries.find((entry) => {
+    const entryBigrams = wordBigrams(entry.lesson);
+    return jaccardBigram(candidateBigrams, entryBigrams) >= threshold;
+  });
+}
+function computeConfidence(confirmedByCount, autoGenerated) {
+  let score = 0.5;
+  score += Math.min(confirmedByCount, 3) * 0.1;
+  if (!autoGenerated)
+    score += 0.1;
+  return Math.min(score, 1);
+}
+var OUTCOME_SIGNAL_SMOOTHING = 4;
+function computeOutcomeSignal(outcomes) {
+  if (!outcomes)
+    return 0;
+  const positives = (outcomes.applied_explicit_count ?? 0) + (outcomes.succeeded_after_shown_count ?? 0);
+  const negatives = (outcomes.ignored_count ?? 0) + (outcomes.violated_count ?? 0) + (outcomes.contradicted_count ?? 0) + (outcomes.failed_after_shown_count ?? 0);
+  const total = positives + negatives;
+  if (total === 0)
+    return 0;
+  return (positives - negatives) / (total + OUTCOME_SIGNAL_SMOOTHING);
+}
+function inferTags(lesson) {
+  const lower = lesson.toLowerCase();
+  const tags = [];
+  if (/(^|\s)(?:todo|remember|don't?(?:\s+)?forget)(?:\s|:|,|$)/i.test(lesson))
+    tags.push("todo");
+  if (/\b(?:typescript|ts)\b/.test(lower))
+    tags.push("typescript");
+  if (/\b(?:javascript|js)\b/.test(lower))
+    tags.push("javascript");
+  if (/\b(?:python)\b/.test(lower))
+    tags.push("python");
+  if (/\b(?:bun|node|deno)\b/.test(lower))
+    tags.push("runtime");
+  if (/\b(?:react|vue|svelte|angular)\b/.test(lower))
+    tags.push("frontend");
+  if (/\b(?:git|github|gitlab)\b/.test(lower))
+    tags.push("git");
+  if (/\b(?:docker|kubernetes|k8s)\b/.test(lower))
+    tags.push("container");
+  if (/\b(?:sql|postgres|mysql|sqlite)\b/.test(lower))
+    tags.push("database");
+  if (/\b(?:test|spec|vitest|jest|mocha)\b/.test(lower))
+    tags.push("testing");
+  if (/\b(?:ci|cd|pipeline|workflow|action)\b/.test(lower))
+    tags.push("ci-cd");
+  if (/\b(?:security|auth|token|password|encrypt)\b/.test(lower))
+    tags.push("security");
+  if (/\b(?:performance|latency|throughput|cache)\b/.test(lower))
+    tags.push("performance");
+  if (/\b(?:api|rest|graphql|grpc|endpoint)\b/.test(lower))
+    tags.push("api");
+  if (/\b(?:swarm|architect|agent|hook|plan)\b/.test(lower))
+    tags.push("opencode-swarm");
+  return Array.from(new Set(tags));
+}
+var CONFIDENCE_FLOOR = 0.1;
+var CONFIDENCE_CEILING = 1;
+async function bumpKnowledgeConfidenceBatch(directory, deltas) {
+  if (deltas.length === 0)
+    return;
+  const swarmPath = resolveSwarmKnowledgePath(directory);
+  const hivePath = resolveHiveKnowledgePath();
+  try {
+    await applyConfidenceDeltas(swarmPath, deltas);
+    const swarmEntries = await readKnowledge(swarmPath);
+    const swarmIds = new Set(swarmEntries.map((e) => e.id));
+    const hiveOnly = deltas.filter((d) => !swarmIds.has(d.id));
+    if (hiveOnly.length > 0) {
+      await applyConfidenceDeltas(hivePath, hiveOnly);
+    }
+  } catch (err) {
+    console.warn("[knowledge-store] bumpKnowledgeConfidenceBatch failed (fail-open):", err instanceof Error ? err.message : String(err));
+  }
+}
+async function applyConfidenceDeltas(filePath, deltas) {
+  const idDeltaMap = new Map;
+  for (const d of deltas) {
+    const existing = idDeltaMap.get(d.id);
+    idDeltaMap.set(d.id, existing !== undefined ? existing + d.delta : d.delta);
+  }
+  let release = null;
+  try {
+    const dir = path.dirname(filePath);
+    await mkdir(dir, { recursive: true });
+    release = await import_proper_lockfile.default.lock(dir, {
+      retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
+      stale: 5000
+    });
+    const entries = await readKnowledge(filePath);
+    if (entries.length === 0)
+      return;
+    const now = new Date().toISOString();
+    let mutated = false;
+    for (const entry of entries) {
+      const delta = idDeltaMap.get(entry.id);
+      if (delta === undefined)
+        continue;
+      entry.confidence = Math.max(CONFIDENCE_FLOOR, Math.min(CONFIDENCE_CEILING, entry.confidence + delta));
+      entry.updated_at = now;
+      mutated = true;
+    }
+    if (mutated) {
+      const content = entries.map((e) => JSON.stringify(e)).join(`
+`) + (entries.length > 0 ? `
+` : "");
+      await atomicWriteFile(filePath, content);
+    }
+  } catch (err) {
+    console.warn(`[knowledge-store] applyConfidenceDeltas failed on ${filePath} (fail-open):`, err instanceof Error ? err.message : String(err));
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+}
+var _internals = {
+  getPlatformConfigDir,
+  resolveSwarmKnowledgePath,
+  resolveSwarmRejectedPath,
+  resolveHiveKnowledgePath,
+  resolveHiveRejectedPath,
+  resolveHiveEventsPath,
+  readKnowledge,
+  parseKnowledgeContent,
+  readRejectedLessons,
+  appendKnowledge,
+  rewriteKnowledge,
+  transactKnowledge,
+  enforceKnowledgeCap,
+  sweepAgedEntries,
+  sweepStaleTodos,
+  appendRejectedLesson,
+  normalize,
+  wordBigrams,
+  jaccardBigram,
+  findNearDuplicate,
+  computeConfidence,
+  computeOutcomeSignal,
+  selectKnowledgeCapSurvivors,
+  inferTags,
+  bumpKnowledgeConfidenceBatch
+};
+
+export { getPlatformConfigDir, resolveSwarmKnowledgePath, resolveSwarmRejectedPath, resolveSwarmRetractionsPath, resolveHiveKnowledgePath, resolveHiveRejectedPath, resolveHiveEventsPath, readKnowledge, normalizeEntry, readRejectedLessons, readRetractionRecords, appendRetractionRecord, appendKnowledge, rewriteKnowledge, transactFile, transactKnowledge, appendKnowledgeWithCapEnforcement, enforceKnowledgeCap, sweepAgedEntries, sweepStaleTodos, appendRejectedLesson, normalize, wordBigrams, jaccardBigram, findNearDuplicate, computeConfidence, OUTCOME_SIGNAL_SMOOTHING, computeOutcomeSignal, inferTags, bumpKnowledgeConfidenceBatch, _internals };