opencode-swarm 7.107.3 → 7.107.4

package/dist/cli/index-kxm3bdjh.js

@@ -0,0 +1,631 @@
+// @bun
+import {
+  resolveKnowledgeStoreDir
+} from "./index-n1sptn1w.js";
+import {
+  atomicWriteFile
+} from "./index-9b7qp18e.js";
+import {
+  init_logger,
+  warn
+} from "./index-zgwm4ryv.js";
+import {
+  require_proper_lockfile
+} from "./index-3naa2ajc.js";
+import {
+  __require,
+  __toESM
+} from "./index-a76rekgs.js";
+
+// src/hooks/knowledge-events.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { randomUUID } from "crypto";
+import { existsSync } from "fs";
+import { appendFile, mkdir, readFile, stat } from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+init_logger();
+var KNOWLEDGE_EVENT_SCHEMA_VERSION = 1;
+var MAX_EVENT_LOG_ENTRIES = 5000;
+var counterRollupCache = new Map;
+var MAX_COUNTER_ROLLUP_CACHE_DIRS = 32;
+var RECEIPT_EVENT_TYPES = new Set([
+  "acknowledged",
+  "applied",
+  "ignored",
+  "contradicted",
+  "violated",
+  "n_a",
+  "override"
+]);
+function resolveKnowledgeEventsPath(directory) {
+  return path.join(resolveKnowledgeStoreDir(directory), "knowledge-events.jsonl");
+}
+function resolveKnowledgeCounterBaselinePath(directory) {
+  return path.join(resolveKnowledgeStoreDir(directory), "knowledge-counter-baseline.json");
+}
+function resolveHiveEventsPath() {
+  const platform = process.platform;
+  const home = process.env.HOME || os.homedir();
+  let dir;
+  if (platform === "win32") {
+    dir = path.join(process.env.LOCALAPPDATA || path.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+  } else if (platform === "darwin") {
+    dir = path.join(home, "Library", "Application Support", "opencode-swarm");
+  } else {
+    dir = path.join(process.env.XDG_DATA_HOME || path.join(home, ".local", "share"), "opencode-swarm");
+  }
+  return path.join(dir, "shared-knowledge-events.jsonl");
+}
+function resolveLegacyApplicationLogPath(directory) {
+  return path.join(resolveKnowledgeStoreDir(directory), "knowledge-application.jsonl");
+}
+function newTraceId() {
+  return randomUUID();
+}
+function newEventId() {
+  return randomUUID();
+}
+function withDefaults(event) {
+  return {
+    schema_version: KNOWLEDGE_EVENT_SCHEMA_VERSION,
+    ...event,
+    event_id: event.event_id || newEventId(),
+    timestamp: event.timestamp || new Date().toISOString()
+  };
+}
+async function appendKnowledgeEvent(directory, event) {
+  const populated = withDefaults(event);
+  const filePath = resolveKnowledgeEventsPath(directory);
+  const dirPath = path.dirname(filePath);
+  await mkdir(dirPath, { recursive: true });
+  let release;
+  try {
+    release = await import_proper_lockfile.default.lock(dirPath, {
+      retries: { retries: 200, minTimeout: 10, maxTimeout: 100 }
+    });
+    await appendFile(filePath, `${JSON.stringify(populated)}
+`, "utf-8");
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const lines = content.split(`
+`).filter((line) => line.trim().length > 0);
+      if (lines.length > MAX_EVENT_LOG_ENTRIES) {
+        const evicted = lines.slice(0, lines.length - MAX_EVENT_LOG_ENTRIES);
+        const trimmed = lines.slice(lines.length - MAX_EVENT_LOG_ENTRIES);
+        await foldEvictedEventsIntoBaseline(directory, evicted, filePath);
+        await atomicWriteFile(filePath, `${trimmed.join(`
+`)}
+`);
+      }
+    } catch (err) {
+      warn(`[knowledge-events] local cap trim failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  } finally {
+    if (release)
+      await release().catch(() => {});
+  }
+  return populated;
+}
+async function recordKnowledgeEvent(directory, event) {
+  try {
+    return await appendKnowledgeEvent(directory, event);
+  } catch (err) {
+    warn(`[knowledge-events] recordKnowledgeEvent failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+async function appendHiveKnowledgeEvent(event) {
+  const populated = withDefaults(event);
+  const filePath = resolveHiveEventsPath();
+  const dirPath = path.dirname(filePath);
+  await mkdir(dirPath, { recursive: true });
+  let release;
+  try {
+    release = await import_proper_lockfile.default.lock(dirPath, {
+      retries: { retries: 200, minTimeout: 10, maxTimeout: 100 }
+    });
+    await appendFile(filePath, `${JSON.stringify(populated)}
+`, "utf-8");
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const lines = content.split(`
+`).filter((line) => line.trim().length > 0);
+      if (lines.length > MAX_EVENT_LOG_ENTRIES) {
+        const trimmed = lines.slice(lines.length - MAX_EVENT_LOG_ENTRIES);
+        await atomicWriteFile(filePath, `${trimmed.join(`
+`)}
+`);
+      }
+    } catch (err) {
+      warn(`[knowledge-events] hive cap trim failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  } finally {
+    if (release)
+      await release().catch(() => {});
+  }
+  return populated;
+}
+async function recordHiveKnowledgeEvent(event) {
+  try {
+    return await appendHiveKnowledgeEvent(event);
+  } catch (err) {
+    warn(`[knowledge-events] recordHiveKnowledgeEvent failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+async function readKnowledgeEvents(directory, maxEvents) {
+  const filePath = resolveKnowledgeEventsPath(directory);
+  if (!existsSync(filePath))
+    return [];
+  const content = await readFile(filePath, "utf-8");
+  const out = [];
+  const max = maxEvents !== undefined && maxEvents > 0 ? maxEvents : Infinity;
+  for (const line of content.split(`
+`)) {
+    if (out.length >= max)
+      break;
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return out;
+}
+async function readHiveKnowledgeEvents() {
+  const filePath = resolveHiveEventsPath();
+  if (!existsSync(filePath))
+    return [];
+  const content = await readFile(filePath, "utf-8");
+  return parseEventLines(content.split(`
+`), filePath);
+}
+async function readLegacyApplicationRecords(directory) {
+  const filePath = resolveLegacyApplicationLogPath(directory);
+  if (!existsSync(filePath))
+    return [];
+  const content = await readFile(filePath, "utf-8");
+  const out = [];
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return out;
+}
+var MAX_VIOLATION_TIMESTAMPS = 10;
+function emptyRollup() {
+  return {
+    shown_count: 0,
+    acknowledged_count: 0,
+    applied_explicit_count: 0,
+    ignored_count: 0,
+    violated_count: 0,
+    contradicted_count: 0,
+    n_a_count: 0,
+    succeeded_after_shown_count: 0,
+    failed_after_shown_count: 0,
+    partial_after_shown_count: 0,
+    violation_timestamps: []
+  };
+}
+function cloneRollup(input) {
+  return {
+    ...emptyRollup(),
+    ...input,
+    violation_timestamps: [...input.violation_timestamps ?? []]
+  };
+}
+function cloneRollupMap(input) {
+  const out = new Map;
+  for (const [id, rollup] of input) {
+    out.set(id, cloneRollup(rollup));
+  }
+  return out;
+}
+function normalizeRollupTimestamps(rollup) {
+  if (rollup.violation_timestamps.length > 1) {
+    rollup.violation_timestamps.sort((a, b) => a < b ? 1 : a > b ? -1 : 0);
+  }
+  if (rollup.violation_timestamps.length > MAX_VIOLATION_TIMESTAMPS) {
+    rollup.violation_timestamps = rollup.violation_timestamps.slice(0, MAX_VIOLATION_TIMESTAMPS);
+  }
+  return rollup;
+}
+function mergeRollupInto(target, source) {
+  target.shown_count += source.shown_count ?? 0;
+  target.acknowledged_count += source.acknowledged_count ?? 0;
+  target.applied_explicit_count += source.applied_explicit_count ?? 0;
+  target.ignored_count += source.ignored_count ?? 0;
+  target.violated_count += source.violated_count ?? 0;
+  target.contradicted_count += source.contradicted_count ?? 0;
+  target.n_a_count += source.n_a_count ?? 0;
+  target.succeeded_after_shown_count += source.succeeded_after_shown_count ?? 0;
+  target.failed_after_shown_count += source.failed_after_shown_count ?? 0;
+  target.partial_after_shown_count += source.partial_after_shown_count ?? 0;
+  if (source.last_applied_at) {
+    target.last_applied_at = maxIso(target.last_applied_at, source.last_applied_at);
+  }
+  if (source.last_acknowledged_at) {
+    target.last_acknowledged_at = maxIso(target.last_acknowledged_at, source.last_acknowledged_at);
+  }
+  target.violation_timestamps.push(...source.violation_timestamps ?? []);
+  normalizeRollupTimestamps(target);
+}
+function get(map, id) {
+  let r = map.get(id);
+  if (!r) {
+    r = emptyRollup();
+    map.set(id, r);
+  }
+  return r;
+}
+function maxIso(current, candidate) {
+  if (!current)
+    return candidate;
+  return candidate > current ? candidate : current;
+}
+async function readCounterBaseline(directory) {
+  const filePath = resolveKnowledgeCounterBaselinePath(directory);
+  if (!existsSync(filePath))
+    return new Map;
+  let raw;
+  try {
+    raw = JSON.parse(await readFile(filePath, "utf-8"));
+  } catch (err) {
+    warn(`[knowledge-events] corrupted counter baseline at ${filePath}; ignoring folded baseline and replaying live events only: ${err instanceof Error ? err.message : String(err)}`);
+    return new Map;
+  }
+  const map = new Map;
+  for (const [id, rollup] of Object.entries(raw)) {
+    map.set(id, normalizeRollupTimestamps(cloneRollup(rollup)));
+  }
+  return map;
+}
+async function writeCounterBaseline(directory, baseline) {
+  const filePath = resolveKnowledgeCounterBaselinePath(directory);
+  const out = {};
+  for (const [id, rollup] of [...baseline.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    out[id] = normalizeRollupTimestamps(cloneRollup(rollup));
+  }
+  await atomicWriteFile(filePath, `${JSON.stringify(out, null, 2)}
+`);
+}
+async function statCacheKey(filePath) {
+  try {
+    const fileStat = await stat(filePath);
+    return `${fileStat.mtimeMs}:${fileStat.ctimeMs}:${fileStat.size}`;
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return "missing";
+    throw err;
+  }
+}
+async function buildCounterRollupCacheKey(directory) {
+  const [eventsKey, legacyKey, baselineKey] = await Promise.all([
+    statCacheKey(resolveKnowledgeEventsPath(directory)),
+    statCacheKey(resolveLegacyApplicationLogPath(directory)),
+    statCacheKey(resolveKnowledgeCounterBaselinePath(directory))
+  ]);
+  return `${eventsKey}|${legacyKey}|${baselineKey}`;
+}
+function setCounterRollupCache(directory, key, rollups) {
+  if (counterRollupCache.has(directory)) {
+    counterRollupCache.delete(directory);
+  }
+  counterRollupCache.set(directory, {
+    key,
+    rollups: cloneRollupMap(rollups)
+  });
+  while (counterRollupCache.size > MAX_COUNTER_ROLLUP_CACHE_DIRS) {
+    const oldestKey = counterRollupCache.keys().next().value;
+    if (oldestKey === undefined)
+      break;
+    counterRollupCache.delete(oldestKey);
+  }
+}
+function parseEventLines(lines, filePath) {
+  const out = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return out;
+}
+async function foldEvictedEventsIntoBaseline(directory, evictedLines, filePath) {
+  const evictedEvents = parseEventLines(evictedLines, filePath);
+  if (evictedEvents.length === 0)
+    return;
+  const baseline = await readCounterBaseline(directory);
+  for (const [id, rollup] of recomputeCounters(evictedEvents)) {
+    mergeRollupInto(get(baseline, id), rollup);
+  }
+  await writeCounterBaseline(directory, baseline);
+}
+function recomputeCounters(events, legacyRecords = [], baseline = new Map) {
+  const map = new Map;
+  const retrievedIds = new Set;
+  for (const [id, rollup] of baseline) {
+    map.set(id, cloneRollup(rollup));
+    if ((rollup.shown_count ?? 0) > 0)
+      retrievedIds.add(id);
+  }
+  for (const e of events) {
+    switch (e.type) {
+      case "retrieved": {
+        for (const id of e.result_ids) {
+          retrievedIds.add(id);
+          get(map, id).shown_count += 1;
+        }
+        break;
+      }
+      case "acknowledged": {
+        const r = get(map, e.knowledge_id);
+        r.acknowledged_count += 1;
+        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, e.timestamp);
+        break;
+      }
+      case "applied": {
+        const r = get(map, e.knowledge_id);
+        r.applied_explicit_count += 1;
+        r.last_applied_at = maxIso(r.last_applied_at, e.timestamp);
+        break;
+      }
+      case "ignored":
+        get(map, e.knowledge_id).ignored_count += 1;
+        break;
+      case "violated": {
+        const r = get(map, e.knowledge_id);
+        r.violated_count += 1;
+        r.violation_timestamps.push(e.timestamp);
+        break;
+      }
+      case "contradicted":
+        get(map, e.knowledge_id).contradicted_count += 1;
+        break;
+      case "n_a":
+        get(map, e.knowledge_id).n_a_count += 1;
+        break;
+      case "outcome": {
+        if (!e.knowledge_id)
+          break;
+        const r = get(map, e.knowledge_id);
+        if (e.outcome === "success")
+          r.succeeded_after_shown_count += 1;
+        else if (e.outcome === "failure")
+          r.failed_after_shown_count += 1;
+        else if (e.outcome === "partial")
+          r.partial_after_shown_count += 1;
+        break;
+      }
+    }
+  }
+  for (const rec of legacyRecords) {
+    const r = get(map, rec.knowledgeId);
+    switch (rec.result) {
+      case "shown":
+        if (!retrievedIds.has(rec.knowledgeId))
+          r.shown_count += 1;
+        break;
+      case "acknowledged":
+        r.acknowledged_count += 1;
+        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, rec.timestamp);
+        break;
+      case "applied":
+        r.applied_explicit_count += 1;
+        r.last_applied_at = maxIso(r.last_applied_at, rec.timestamp);
+        break;
+      case "ignored":
+        r.ignored_count += 1;
+        break;
+      case "violated":
+        r.violated_count += 1;
+        r.violation_timestamps.push(rec.timestamp);
+        break;
+    }
+  }
+  for (const r of map.values()) {
+    normalizeRollupTimestamps(r);
+  }
+  return map;
+}
+function countViolationsInWindow(timestamps, windowDays, now = new Date) {
+  const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
+  let count = 0;
+  for (const ts of timestamps) {
+    const t = Date.parse(ts);
+    if (!Number.isNaN(t) && t >= cutoff)
+      count += 1;
+  }
+  return count;
+}
+async function countEntryViolationsInWindow(directory, entryId, windowDays, now = new Date) {
+  try {
+    const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
+    const [events, legacyRecords] = await Promise.all([
+      readKnowledgeEvents(directory),
+      readLegacyApplicationRecords(directory)
+    ]);
+    let count = 0;
+    for (const e of events) {
+      if (e.type !== "violated" || e.knowledge_id !== entryId)
+        continue;
+      const t = Date.parse(e.timestamp);
+      if (!Number.isNaN(t) && t >= cutoff)
+        count += 1;
+    }
+    for (const rec of legacyRecords) {
+      if (rec.result !== "violated" || rec.knowledgeId !== entryId)
+        continue;
+      const t = Date.parse(rec.timestamp);
+      if (!Number.isNaN(t) && t >= cutoff)
+        count += 1;
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+async function countEntryContradictionsInWindow(directory, entryId, windowDays, now = new Date) {
+  try {
+    const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
+    const events = await readKnowledgeEvents(directory);
+    let count = 0;
+    for (const e of events) {
+      if (e.type !== "contradicted" || e.knowledge_id !== entryId)
+        continue;
+      const t = Date.parse(e.timestamp);
+      if (!Number.isNaN(t) && t >= cutoff)
+        count += 1;
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+async function readKnowledgeCounterRollups(directory) {
+  try {
+    const cacheKey = await buildCounterRollupCacheKey(directory);
+    const cached = counterRollupCache.get(directory);
+    if (cached?.key === cacheKey) {
+      counterRollupCache.delete(directory);
+      counterRollupCache.set(directory, cached);
+      return cloneRollupMap(cached.rollups);
+    }
+    const [events, legacyRecords, baseline] = await Promise.all([
+      readKnowledgeEvents(directory),
+      readLegacyApplicationRecords(directory),
+      readCounterBaseline(directory)
+    ]);
+    const rollups = recomputeCounters(events, legacyRecords, baseline);
+    setCounterRollupCache(directory, cacheKey, rollups);
+    return cloneRollupMap(rollups);
+  } catch (err) {
+    warn(`[knowledge-events] readKnowledgeCounterRollups failed: ${err instanceof Error ? err.message : String(err)}`);
+    return new Map;
+  }
+}
+function effectiveRetrievalOutcomes(stored, rollup) {
+  const base = stored ?? {
+    applied_count: 0,
+    succeeded_after_count: 0,
+    failed_after_count: 0
+  };
+  if (!rollup)
+    return base;
+  const { n_a_count: _na, ...rollupWithoutNa } = rollup;
+  return {
+    ...base,
+    ...rollupWithoutNa,
+    succeeded_after_shown_count: (base.succeeded_after_shown_count ?? 0) + (rollup.succeeded_after_shown_count ?? 0),
+    failed_after_shown_count: (base.failed_after_shown_count ?? 0) + (rollup.failed_after_shown_count ?? 0)
+  };
+}
+var VERDICT_CONFIDENCE_BOOST = 0.03;
+var VERDICT_CONFIDENCE_DECAY = 0.05;
+async function applyKnowledgeVerdictFeedback(directory, options) {
+  try {
+    const events = await readKnowledgeEvents(directory);
+    const markerIndex = options?.sinceTimestamp && options.sinceEventId ? events.findIndex((e) => e.timestamp === options.sinceTimestamp && e.event_id === options.sinceEventId) : -1;
+    const actionable = events.filter((e, index) => {
+      if (e.type !== "applied" && e.type !== "violated" && e.type !== "ignored") {
+        return false;
+      }
+      if (options?.sinceTimestamp && e.timestamp < options.sinceTimestamp) {
+        return false;
+      }
+      if (options?.sinceTimestamp && e.timestamp === options.sinceTimestamp) {
+        if (!options.sinceEventId) {
+          return false;
+        }
+        if (markerIndex < 0) {
+          return false;
+        }
+        return index > markerIndex;
+      }
+      return true;
+    });
+    if (actionable.length === 0) {
+      return { processed: 0, bumps: 0 };
+    }
+    const groups = new Map;
+    let lastProcessedTimestamp;
+    let lastProcessedEventId;
+    for (const event of actionable) {
+      if (typeof event.timestamp === "string" && (!lastProcessedTimestamp || event.timestamp >= lastProcessedTimestamp)) {
+        lastProcessedTimestamp = event.timestamp;
+        lastProcessedEventId = event.event_id;
+      }
+      const kid = event.knowledge_id;
+      if (!kid)
+        continue;
+      const g = groups.get(kid) ?? { applied: 0, violated: 0, ignored: 0 };
+      if (event.type === "applied")
+        g.applied++;
+      else if (event.type === "violated")
+        g.violated++;
+      else if (event.type === "ignored")
+        g.ignored++;
+      groups.set(kid, g);
+    }
+    const deltas = [];
+    for (const [id, counts] of groups) {
+      const positives = counts.applied;
+      const negatives = counts.violated + counts.ignored;
+      if (positives === 0 && negatives === 0)
+        continue;
+      const delta = positives > negatives ? VERDICT_CONFIDENCE_BOOST : -VERDICT_CONFIDENCE_DECAY;
+      deltas.push({ id, delta });
+    }
+    if (deltas.length > 0) {
+      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-kyacem71.js");
+      await bumpKnowledgeConfidenceBatch(directory, deltas, options?.floorOptions);
+    }
+    return {
+      processed: groups.size,
+      bumps: deltas.length,
+      lastProcessedTimestamp,
+      lastProcessedEventId
+    };
+  } catch (err) {
+    warn(`[knowledge-events] applyKnowledgeVerdictFeedback failed (fail-open): ${err instanceof Error ? err.message : String(err)}`);
+    return { processed: 0, bumps: 0 };
+  }
+}
+var _internals = {
+  resolveKnowledgeEventsPath,
+  resolveKnowledgeCounterBaselinePath,
+  appendKnowledgeEvent,
+  recordKnowledgeEvent,
+  readKnowledgeEvents,
+  readCounterBaseline,
+  readLegacyApplicationRecords,
+  readKnowledgeCounterRollups,
+  effectiveRetrievalOutcomes,
+  recomputeCounters,
+  applyKnowledgeVerdictFeedback,
+  newTraceId,
+  newEventId,
+  resolveHiveEventsPath,
+  appendHiveKnowledgeEvent,
+  recordHiveKnowledgeEvent,
+  readHiveKnowledgeEvents
+};
+
+export { KNOWLEDGE_EVENT_SCHEMA_VERSION, MAX_EVENT_LOG_ENTRIES, RECEIPT_EVENT_TYPES, resolveKnowledgeEventsPath, resolveKnowledgeCounterBaselinePath, resolveHiveEventsPath, resolveLegacyApplicationLogPath, newTraceId, newEventId, appendKnowledgeEvent, recordKnowledgeEvent, appendHiveKnowledgeEvent, recordHiveKnowledgeEvent, readKnowledgeEvents, readHiveKnowledgeEvents, readLegacyApplicationRecords, MAX_VIOLATION_TIMESTAMPS, recomputeCounters, countViolationsInWindow, countEntryViolationsInWindow, countEntryContradictionsInWindow, readKnowledgeCounterRollups, effectiveRetrievalOutcomes, applyKnowledgeVerdictFeedback, _internals };