opencode-swarm 7.179.1 → 7.180.0

package/dist/cli/index-b9z9gvx0.js

@@ -0,0 +1,339 @@
+// @bun
+import {
+  tryAcquireLock
+} from "./index-ejhxgyvm.js";
+import {
+  atomicWriteFileAnyRoot,
+  atomicWriteSwarmFileSync
+} from "./index-989v83pb.js";
+import {
+  init_loader,
+  loadPluginConfig
+} from "./index-zptq8mp1.js";
+import {
+  init_logger,
+  log,
+  warn
+} from "./index-zgwm4ryv.js";
+
+// src/sdd/speckit-checkoff.ts
+init_loader();
+import { createHash } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+init_logger();
+var SPECKIT_CHECKOFF_LEDGER_REL = path.join(".swarm", "speckit-checkoff-ledger.json");
+var TASK_LINE_REGEX = /^\s*-\s+\[[ xX]\]\s+(T\d+)/;
+var FR_REF_REGEX = /(?:[A-Za-z0-9][A-Za-z0-9._-]*\/)?FR-\d{3}/g;
+var MAX_TASKS_FILE_BYTES = 512 * 1024;
+var FR_BARE_SUFFIX = /FR-\d{3}$/;
+function refsMatch(a, b) {
+  if (a === b)
+    return true;
+  const aBare = !a.includes("/");
+  const bBare = !b.includes("/");
+  if (aBare && !bBare && FR_BARE_SUFFIX.test(b) && b.endsWith(`/${a}`))
+    return true;
+  if (bBare && !aBare && FR_BARE_SUFFIX.test(a) && a.endsWith(`/${b}`))
+    return true;
+  return false;
+}
+function sha256(text) {
+  return createHash("sha256").update(text, "utf-8").digest("hex");
+}
+function readBounded(filePath) {
+  try {
+    const stat = fs.lstatSync(filePath);
+    if (!stat.isFile() || stat.size > MAX_TASKS_FILE_BYTES)
+      return null;
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function parseSpeckitTasksContent(content, namespaced, featureId) {
+  const tasks = [];
+  const taskLines = [];
+  for (const rawLine of content.replace(/\r\n/g, `
+`).split(`
+`)) {
+    const match = rawLine.match(TASK_LINE_REGEX);
+    if (!match)
+      continue;
+    const snapshot = rawLine.trim();
+    taskLines.push(snapshot.replace(/\[[xX]\]/g, "[ ]"));
+    const refs = [...snapshot.matchAll(FR_REF_REGEX)].map((m) => m[0]);
+    const frRefs = refs.map((ref) => namespaced && !ref.includes("/") ? `${featureId}/${ref}` : ref);
+    tasks.push({
+      taskId: match[1],
+      frRefs,
+      lineSnapshot: snapshot,
+      initiallyChecked: /\[x\]/i.test(snapshot)
+    });
+  }
+  return { tasks, taskLinesDigest: sha256(taskLines.join(`
+`)) };
+}
+function writeSpeckitCheckoffLedger(root, resolution) {
+  const features = [];
+  resolution.features.forEach((featureId, index) => {
+    const specRel = resolution.spec.sourcePaths[index] ?? `specs/${featureId}/spec.md`;
+    const tasksRelPath = `${path.dirname(specRel).split(path.sep).join("/")}/tasks.md`;
+    const content = readBounded(path.join(root, tasksRelPath));
+    if (content === null)
+      return;
+    const parsed = parseSpeckitTasksContent(content, resolution.namespaced, featureId);
+    if (parsed.tasks.length === 0)
+      return;
+    const requirementIds = resolution.featureRequirementIds[index] ?? [];
+    for (const task of parsed.tasks) {
+      const refs = new Set(task.frRefs);
+      for (const storyMatch of task.lineSnapshot.matchAll(/\[US(\d+)\]/gi)) {
+        const storyIndex = Number(storyMatch[1]) - 1;
+        const mapped = requirementIds[storyIndex];
+        if (mapped)
+          refs.add(mapped);
+      }
+      task.frRefs = [...refs];
+    }
+    features.push({
+      featureId,
+      tasksRelPath,
+      taskLinesDigest: parsed.taskLinesDigest,
+      tasks: parsed.tasks
+    });
+  });
+  const ledger = {
+    version: 1,
+    namespaced: resolution.namespaced,
+    projectedAt: new Date().toISOString(),
+    features
+  };
+  atomicWriteSwarmFileSync(path.join(root, SPECKIT_CHECKOFF_LEDGER_REL), `${JSON.stringify(ledger, null, 2)}
+`);
+}
+function readLedger(root) {
+  const raw = readBounded(path.join(root, SPECKIT_CHECKOFF_LEDGER_REL));
+  if (raw === null)
+    return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || !Array.isArray(parsed.features))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeLedger(root, ledger) {
+  atomicWriteSwarmFileSync(path.join(root, SPECKIT_CHECKOFF_LEDGER_REL), `${JSON.stringify(ledger, null, 2)}
+`);
+}
+function normalizeCheckboxState(line) {
+  return line.replace(/\[[xX]\]/g, "[ ]");
+}
+function applyCheckoffEdit(taskEntry, _baselineContent, currentContent) {
+  const lines = currentContent.split(/(?=\r?\n)/);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const lineTrimmed = line.trim();
+    if (normalizeCheckboxState(lineTrimmed) !== normalizeCheckboxState(taskEntry.lineSnapshot)) {
+      const idMatch = line.match(TASK_LINE_REGEX);
+      if (idMatch && idMatch[1] === taskEntry.taskId) {
+        return {
+          applied: false,
+          content: currentContent,
+          reason: "task-line-changed"
+        };
+      }
+      continue;
+    }
+    if (/\[x\]/i.test(lineTrimmed)) {
+      return {
+        applied: false,
+        content: currentContent,
+        reason: "already-checked"
+      };
+    }
+    const boxIndex = line.indexOf("[ ]");
+    if (boxIndex === -1) {
+      return {
+        applied: false,
+        content: currentContent,
+        reason: "task-line-changed"
+      };
+    }
+    lines[i] = `${line.slice(0, boxIndex)}[x]${line.slice(boxIndex + 3)}`;
+    return { applied: true, content: lines.join(""), reason: "ok" };
+  }
+  return {
+    applied: false,
+    content: currentContent,
+    reason: "task-line-not-found"
+  };
+}
+function extractFrRefsFromText(text) {
+  return [...text.matchAll(FR_REF_REGEX)].map((m) => m[0]);
+}
+async function propagateSpeckitCheckoff(directory, completed, options) {
+  if (!options.enabled) {
+    return { ran: false, reason: "disabled", features: [] };
+  }
+  const root = path.resolve(directory);
+  const ledger = readLedger(root);
+  if (!ledger) {
+    return { ran: false, reason: "no-ledger", features: [] };
+  }
+  const completedRefs = [
+    ...completed.frRefs,
+    ...extractFrRefsFromText(`${completed.text ?? ""}`)
+  ];
+  const results = [];
+  let anyMatch = false;
+  let ledgerDirty = false;
+  const checkedAt = new Date().toISOString();
+  for (const feature of ledger.features) {
+    const result = {
+      featureId: feature.featureId,
+      tasksRelPath: feature.tasksRelPath,
+      checked: [],
+      reopenedSkipped: [],
+      stale: false,
+      refused: []
+    };
+    const matchedTasks = feature.tasks.filter((task) => task.frRefs.some((taskRef) => completedRefs.some((completedRef) => refsMatch(completedRef, taskRef))));
+    const hasSwarmChecked = feature.tasks.some((t) => t.swarmCheckedAt);
+    if (matchedTasks.length === 0 && !hasSwarmChecked) {
+      results.push(result);
+      continue;
+    }
+    if (matchedTasks.length > 0)
+      anyMatch = true;
+    const tasksAbs = path.join(root, feature.tasksRelPath);
+    let current = readBounded(tasksAbs);
+    if (current === null) {
+      result.stale = true;
+      result.refused.push(...matchedTasks.map((t) => t.taskId));
+      results.push(result);
+      continue;
+    }
+    const currentDigest = parseSpeckitTasksContent(current, ledger.namespaced, feature.featureId).taskLinesDigest;
+    if (currentDigest !== feature.taskLinesDigest) {
+      result.stale = true;
+      result.refused.push(...matchedTasks.map((t) => t.taskId));
+      results.push(result);
+      continue;
+    }
+    for (const task of feature.tasks) {
+      if (!task.swarmCheckedAt)
+        continue;
+      const line = current.replace(/\r\n/g, `
+`).split(`
+`).find((l) => normalizeCheckboxState(l.trim()) === normalizeCheckboxState(task.lineSnapshot));
+      if (line !== undefined && /\[ \]/.test(line)) {
+        result.reopenedSkipped.push(task.taskId);
+      }
+    }
+    let contentChanged = false;
+    for (const task of matchedTasks) {
+      if (task.swarmCheckedAt && result.reopenedSkipped.includes(task.taskId)) {
+        continue;
+      }
+      const outcome = applyCheckoffEdit(task, current, current);
+      if (outcome.applied) {
+        current = outcome.content;
+        contentChanged = true;
+        task.swarmCheckedAt = checkedAt;
+        ledgerDirty = true;
+        result.checked.push(task.taskId);
+      } else if (outcome.reason === "already-checked") {
+        if (!task.swarmCheckedAt) {
+          task.swarmCheckedAt = checkedAt;
+          ledgerDirty = true;
+        }
+      } else {
+        result.refused.push(task.taskId);
+      }
+    }
+    if (contentChanged && current !== null) {
+      const lock = await tryAcquireLock(root, feature.tasksRelPath, "speckit-checkoff", completed.taskId);
+      if (!lock.acquired) {
+        result.refused.push(...result.checked);
+        result.checked = [];
+        results.push(result);
+        continue;
+      }
+      try {
+        const latest = readBounded(tasksAbs);
+        if (latest === null || latest !== current) {
+          if (latest !== null) {
+            let reconciled = latest;
+            let ok = true;
+            for (const taskId of [...result.checked]) {
+              const task = feature.tasks.find((t) => t.taskId === taskId);
+              const outcome = applyCheckoffEdit(task, latest, reconciled);
+              if (outcome.applied) {
+                reconciled = outcome.content;
+              } else if (outcome.reason !== "already-checked") {
+                ok = false;
+                result.checked = result.checked.filter((id) => id !== taskId);
+                result.refused.push(taskId);
+              }
+            }
+            if (ok && result.checked.length > 0) {
+              await atomicWriteFileAnyRoot(tasksAbs, reconciled);
+              current = reconciled;
+            } else {
+              current = latest;
+            }
+          } else {
+            result.refused.push(...result.checked);
+            result.checked = [];
+          }
+        } else {
+          await atomicWriteFileAnyRoot(tasksAbs, current);
+        }
+      } finally {
+        if (lock.lock._release) {
+          await lock.lock._release().catch(() => {});
+        }
+      }
+    }
+    results.push(result);
+  }
+  if (ledgerDirty) {
+    try {
+      writeLedger(root, ledger);
+    } catch (err) {
+      warn(`[speckit-checkoff] ledger update failed after check-off: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return {
+    ran: true,
+    features: results,
+    unmatched: !anyMatch || undefined
+  };
+}
+async function maybePropagateSpeckitCheckoff(directory, completed) {
+  try {
+    const config = loadPluginConfig(directory);
+    if (config?.speckit_checkoff?.enabled !== true)
+      return;
+    const result = await propagateSpeckitCheckoff(directory, completed, {
+      enabled: true
+    });
+    if (result.ran && result.features.some((f) => f.checked.length > 0)) {
+      log(`[speckit-checkoff] task ${completed.taskId} checked off: ${result.features.map((f) => `${f.featureId}:[${f.checked.join(", ")}]`).join(" ")}`);
+    }
+  } catch (err) {
+    warn(`[speckit-checkoff] propagation for ${completed.taskId} failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+var _internals = {
+  applyCheckoffEdit,
+  parseSpeckitTasksContent,
+  readBounded,
+  sha256
+};
+
+export { SPECKIT_CHECKOFF_LEDGER_REL, parseSpeckitTasksContent, writeSpeckitCheckoffLedger, applyCheckoffEdit, propagateSpeckitCheckoff, maybePropagateSpeckitCheckoff, _internals };

package/dist/cli/{index-2b0ktpbf.js → index-bdpgfep1.js}

@@ -1,21 +1,21 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-s4bkey0q.js";
+} from "./index-gc6h1fmf.js";
 import {
   bunSpawn
 } from "./index-2s7dvzff.js";
-import {
-  atomicWriteSwarmFile
-} from "./index-ne9zamcs.js";
 import {
   canonicalRootKey,
   sameProjectRoot
 } from "./index-1xnse449.js";
+import {
+  atomicWriteSwarmFile
+} from "./index-989v83pb.js";
 import {
   init_git_executable,
   resolveGitExecutable
-} from "./index-zz7gzw57.js";
+} from "./index-zxdawwc7.js";
 
 // src/background/workspace-snapshot.ts
 import * as child_process from "child_process";

package/dist/cli/{index-nzekzzs2.js → index-bv4b8tpa.js}

@@ -1,17 +1,17 @@
 // @bun
-import {
-  canonicalExistingFilesystemPath
-} from "./index-ry16d01s.js";
 import {
   loadDatabaseCtor
 } from "./index-rdm3px0g.js";
 import {
-  atomicWriteSwarmFileSync
-} from "./index-ne9zamcs.js";
+  canonicalExistingFilesystemPath
+} from "./index-ry16d01s.js";
 import {
   canonicalRootKeyFresh,
   lexicalRootAliasKey
 } from "./index-1xnse449.js";
+import {
+  atomicWriteSwarmFileSync
+} from "./index-989v83pb.js";
 
 // src/db/project-db.ts
 import { existsSync, mkdirSync, unlinkSync } from "fs";