opencode-swarm 7.119.0 → 7.121.0

package/dist/cli/index-0e1v02hq.js

@@ -0,0 +1,343 @@
+// @bun
+import {
+  readKnowledge,
+  transactKnowledge
+} from "./index-rywkdacj.js";
+import {
+  resolveKnowledgeStoreDir
+} from "./index-3jvqw5hy.js";
+import {
+  isActiveStatus
+} from "./index-4rhcth7a.js";
+import {
+  init_logger,
+  log
+} from "./index-zgwm4ryv.js";
+import {
+  __require,
+  __toESM
+} from "./index-a76rekgs.js";
+
+// src/knowledge/scan-cursor.ts
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import * as path2 from "path";
+init_logger();
+
+// src/knowledge/cohort-identity.ts
+import { execFile } from "child_process";
+import { createHash } from "crypto";
+import { realpathSync } from "fs";
+import * as path from "path";
+var GIT_TIMEOUT_MS = 1500;
+var CASE_INSENSITIVE_HOSTS = new Set([
+  "github.com",
+  "gitlab.com",
+  "bitbucket.org",
+  "azure.com",
+  "visualstudio.com"
+]);
+function normalizeGitRemote(rawUrl) {
+  if (typeof rawUrl !== "string")
+    return null;
+  let url = rawUrl.trim();
+  if (url.length === 0)
+    return null;
+  url = url.normalize("NFC");
+  url = url.replace(/\\/g, "/");
+  let host = "";
+  let pathPart = "";
+  const lowerForScheme = url.toLowerCase();
+  if (lowerForScheme.startsWith("ssh://")) {
+    const rest = url.slice("ssh://".length);
+    const atIdx = rest.indexOf("@");
+    const hostStart = atIdx === -1 ? 0 : atIdx + 1;
+    const slashIdx = rest.indexOf("/", hostStart);
+    if (slashIdx === -1)
+      return null;
+    host = rest.slice(hostStart, slashIdx);
+    pathPart = rest.slice(slashIdx + 1);
+  } else if (/^[a-zA-Z0-9_.-]+@[a-zA-Z0-9_.-]+:/.test(url)) {
+    const atIdx = url.indexOf("@");
+    const colonIdx = url.indexOf(":", atIdx);
+    host = url.slice(atIdx + 1, colonIdx);
+    pathPart = url.slice(colonIdx + 1);
+  } else if (lowerForScheme.startsWith("https://") || lowerForScheme.startsWith("http://")) {
+    const schemeEnd = url.indexOf("://");
+    const rest = url.slice(schemeEnd + 3);
+    const atIdx = rest.indexOf("@");
+    const hostStart = atIdx === -1 ? 0 : atIdx + 1;
+    const slashIdx = rest.indexOf("/", hostStart);
+    if (slashIdx === -1)
+      return null;
+    host = rest.slice(hostStart, slashIdx);
+    pathPart = rest.slice(slashIdx + 1);
+  } else if (/^[a-zA-Z0-9_.-]+:[^/]/.test(url) && !url.includes("://")) {
+    const colonIdx = url.indexOf(":");
+    host = url.slice(0, colonIdx);
+    pathPart = url.slice(colonIdx + 1);
+  } else if (lowerForScheme.startsWith("git://")) {
+    const rest = url.slice("git://".length);
+    const slashIdx = rest.indexOf("/");
+    if (slashIdx === -1)
+      return null;
+    host = rest.slice(0, slashIdx);
+    pathPart = rest.slice(slashIdx + 1);
+  } else {
+    return null;
+  }
+  host = host.toLowerCase();
+  host = host.replace(/:443$/, "").replace(/:22$/, "").replace(/:80$/, "");
+  pathPart = pathPart.replace(/\.git$/, "").replace(/\/+$/, "");
+  try {
+    pathPart = pathPart.split("/").map((seg) => {
+      try {
+        return decodeURIComponent(seg);
+      } catch {
+        return seg;
+      }
+    }).join("/");
+  } catch {}
+  pathPart = pathPart.split("/").filter((seg, idx) => !(seg === "" && idx !== 0)).join("/");
+  pathPart = pathPart.replace(/^\/+/, "");
+  if (CASE_INSENSITIVE_HOSTS.has(host)) {
+    pathPart = pathPart.toLowerCase();
+  }
+  if (host.length === 0 || pathPart.length === 0)
+    return null;
+  if (!pathPart.includes("/"))
+    return null;
+  return `${host}/${pathPart}`;
+}
+function runGit(directory, args) {
+  return new Promise((resolve2) => {
+    try {
+      const child = execFile("git", ["-C", directory, ...args], {
+        timeout: GIT_TIMEOUT_MS,
+        windowsHide: true,
+        encoding: "utf-8",
+        maxBuffer: 1024 * 64
+      }, (err, stdout) => {
+        if (err || typeof stdout !== "string") {
+          resolve2(null);
+          return;
+        }
+        resolve2(stdout.trim());
+      });
+      try {
+        child.stdin?.end();
+      } catch {}
+      child.on("error", () => resolve2(null));
+    } catch {
+      resolve2(null);
+    }
+  });
+}
+function cohortHash(input) {
+  return createHash("sha256").update(input).digest("hex").slice(0, 12);
+}
+function stabilizePath(input) {
+  return input.replace(/\\/g, "/").replace(/^\/\/\?\//, "").replace(/\/+$/, "").toLowerCase();
+}
+async function resolveCohortId(directory) {
+  const remoteUrl = await _internals.runGit(directory, [
+    "remote",
+    "get-url",
+    "origin"
+  ]);
+  if (remoteUrl && remoteUrl.length > 0) {
+    const normalized = normalizeGitRemote(remoteUrl);
+    if (normalized) {
+      return {
+        cohortId: cohortHash(normalized),
+        source: "remote",
+        normalizedRemote: normalized,
+        degraded: false
+      };
+    }
+  }
+  let commonDirRaw = await _internals.runGit(directory, [
+    "rev-parse",
+    "--path-format=absolute",
+    "--git-common-dir"
+  ]);
+  if (!commonDirRaw || commonDirRaw.length === 0) {
+    commonDirRaw = await _internals.runGit(directory, [
+      "rev-parse",
+      "--git-common-dir"
+    ]);
+  }
+  if (commonDirRaw && commonDirRaw.length > 0) {
+    try {
+      const resolved = path.resolve(directory, commonDirRaw);
+      const canonical = realpathSync(resolved);
+      return {
+        cohortId: cohortHash(stabilizePath(canonical)),
+        source: "git-common-dir",
+        degraded: true
+      };
+    } catch {}
+  }
+  let canonicalPath;
+  try {
+    canonicalPath = realpathSync(path.resolve(directory));
+  } catch {
+    canonicalPath = path.resolve(directory);
+  }
+  return {
+    cohortId: cohortHash(stabilizePath(canonicalPath)),
+    source: "path",
+    degraded: true
+  };
+}
+var _internals = {
+  normalizeGitRemote,
+  runGit,
+  cohortHash,
+  stabilizePath,
+  GIT_TIMEOUT_MS
+};
+
+// src/knowledge/scan-cursor.ts
+var CURSOR_FILENAME = "curation-cursor.json";
+var DEFAULT_BATCH_SIZE = 500;
+var _internals2 = {
+  readFile,
+  writeFile,
+  existsSync,
+  mkdir,
+  readKnowledge,
+  transactKnowledge,
+  resolveCohortId,
+  resolveKnowledgeStoreDir
+};
+function resolveCursorPath(directory) {
+  const storeDir = _internals2.resolveKnowledgeStoreDir(directory);
+  return path2.join(storeDir, CURSOR_FILENAME);
+}
+function entrySortKey(entry) {
+  return `${entry.created_at ?? ""}|${entry.id}`;
+}
+async function readCursor(directory) {
+  const cursorPath = resolveCursorPath(directory);
+  try {
+    if (!_internals2.existsSync(cursorPath))
+      return null;
+    const raw = await _internals2.readFile(cursorPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeCursor(directory, state) {
+  const cursorPath = resolveCursorPath(directory);
+  const storeDir = path2.dirname(cursorPath);
+  try {
+    await _internals2.mkdir(storeDir, { recursive: true });
+    await _internals2.writeFile(cursorPath, JSON.stringify(state, null, 2), "utf-8");
+  } catch (err) {
+    log(`[scan-cursor] writeCursor failed (non-blocking): ${String(err)}`);
+  }
+}
+async function claimNextScanBatch(directory, batchSize = DEFAULT_BATCH_SIZE) {
+  const knowledgePath = path2.join(_internals2.resolveKnowledgeStoreDir(directory), "knowledge.jsonl");
+  const allEntries = await _internals2.readKnowledge(knowledgePath);
+  const eligible = allEntries.filter((e) => isActiveStatus(e.status)).sort((a, b) => {
+    const ka = entrySortKey(a);
+    const kb = entrySortKey(b);
+    return ka < kb ? -1 : ka > kb ? 1 : 0;
+  });
+  let cohortId = "unknown";
+  try {
+    cohortId = (await _internals2.resolveCohortId(directory)).cohortId;
+  } catch {}
+  const lockfile = (await import("./index-89s4mhmw.js").then((m)=>__toESM(m.default,1))).default;
+  const storeDir = _internals2.resolveKnowledgeStoreDir(directory);
+  let batch = [];
+  let generation = 1;
+  let sweepCompleted = false;
+  let remainingAfter = 0;
+  let release;
+  try {
+    release = await lockfile.lock(storeDir, {
+      retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
+      stale: 5000
+    });
+    const now = new Date().toISOString();
+    let cursor = await readCursor(directory);
+    if (!cursor) {
+      cursor = {
+        cohort_id: cohortId,
+        last_visited_sort_key: "",
+        generation: 1,
+        completed: false,
+        remaining_estimate: eligible.length,
+        updated_at: now
+      };
+    } else if (cursor.completed) {
+      cursor = {
+        ...cursor,
+        cohort_id: cohortId,
+        last_visited_sort_key: "",
+        generation: cursor.generation + 1,
+        completed: false,
+        remaining_estimate: eligible.length,
+        updated_at: now
+      };
+    }
+    const cursorKey = cursor.last_visited_sort_key;
+    const pending = eligible.filter((e) => entrySortKey(e) > cursorKey);
+    batch = pending.slice(0, batchSize);
+    remainingAfter = pending.length - batch.length;
+    const sweepDone = remainingAfter === 0;
+    const lastVisited = batch.length > 0 ? entrySortKey(batch[batch.length - 1]) : cursorKey;
+    const nextCursor = {
+      ...cursor,
+      last_visited_sort_key: lastVisited,
+      completed: sweepDone,
+      remaining_estimate: remainingAfter,
+      updated_at: now
+    };
+    generation = nextCursor.generation;
+    sweepCompleted = sweepDone;
+    await writeCursor(directory, nextCursor);
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+  return {
+    entries: batch,
+    generation,
+    sweepCompleted,
+    remaining_estimate: remainingAfter
+  };
+}
+async function getScanStatus(directory) {
+  let cohortId = "unknown";
+  try {
+    cohortId = (await _internals2.resolveCohortId(directory)).cohortId;
+  } catch {}
+  const cursor = await readCursor(directory);
+  if (!cursor) {
+    return {
+      generation: 0,
+      completed: false,
+      remaining_estimate: 0,
+      cohort_id: cohortId
+    };
+  }
+  return {
+    generation: cursor.generation,
+    completed: cursor.completed,
+    remaining_estimate: cursor.remaining_estimate,
+    cohort_id: cursor.cohort_id
+  };
+}
+function alreadyCuratedThisGeneration(entry, generation) {
+  return entry.last_curated_generation === generation;
+}
+
+export { resolveCohortId, _internals2 as _internals, claimNextScanBatch, getScanStatus, alreadyCuratedThisGeneration };

package/dist/cli/{index-jbdgpqpj.js → index-0k4r8111.js}

@@ -1,10 +1,4 @@
 // @bun
-import {
-  countEntryContradictionsInWindow,
-  countEntryViolationsInWindow,
-  readKnowledgeEvents,
-  recordKnowledgeEvent
-} from "./index-5hze8ztj.js";
 import {
   jaccardBigram,
   readKnowledge,
@@ -12,10 +6,16 @@ import {
   resolveSwarmKnowledgePath,
   transactKnowledge,
   wordBigrams
-} from "./index-qx5z58a7.js";
+} from "./index-rywkdacj.js";
+import {
+  countEntryContradictionsInWindow,
+  countEntryViolationsInWindow,
+  readKnowledgeEvents,
+  recordKnowledgeEvent
+} from "./index-nhgw7de8.js";
 import {
   isActiveStatus
-} from "./index-bfwt3abw.js";
+} from "./index-4rhcth7a.js";
 import {
   __require
 } from "./index-a76rekgs.js";
@@ -188,8 +188,26 @@ async function maybeQuarantineOnContradiction(directory, entryId, threshold, win
         alreadyInactive: true
       };
     }
-    const { quarantineEntry } = await import("./knowledge-validator-91kx3eqv.js");
-    await quarantineEntry(directory, entryId, `repeat_contradiction: ${count} contradicted events in ${windowDays}d`, "auto");
+    const { quarantineEntry } = await import("./knowledge-validator-1f4mkzmc.js");
+    let policyConfig;
+    try {
+      const { KnowledgeConfigSchema } = await import("./schema-vwxpsk6j.js");
+      const { loadPluginConfigWithMeta } = await import("./index-fndvr7fr.js");
+      const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
+      policyConfig = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
+    } catch {
+      policyConfig = undefined;
+    }
+    await quarantineEntry(directory, entryId, `repeat_contradiction: ${count} contradicted events in ${windowDays}d`, "auto", {
+      input: {
+        directory,
+        action: "quarantine",
+        entryId,
+        reason: `repeat_contradiction: ${count} in ${windowDays}d`,
+        evidenceScope: "cohort-wide"
+      },
+      context: { config: policyConfig, entry }
+    });
     return { quarantined: true, entryId, contradictionsInWindow: count };
   } catch {
     return { quarantined: false, entryId };