in2-agent-server 0.20260821.185429

package/dist/core/writebackManifest.js

@@ -0,0 +1,92 @@
+// PER-REQUIREMENT WRITEBACK STATE, on disk, while the writeback runs.
+//
+// `campfire_write_config_items` already knows, per Configuration Item row, which requirement owns
+// it and whether Campfire confirmed the write on read-back — but that knowledge only ever left the
+// tool as prose in one result, at the end. The session viewer polls the session directory, so a
+// ten-minute writeback showed as one undifferentiated "in progress" for every requirement and then
+// jumped to done. This file is the projection that closes that gap.
+//
+// WHY TWO WRITES RATHER THAN A LIVE PER-ROW FEED. The write loop upserts rows CONCURRENTLY
+// (`WRITE_CONCURRENCY`), and a successful upsert is only a claim until the batched read-back
+// confirms every field — so no requirement can honestly be called `written` before that read-back
+// completes. A per-row feed would either lie early or need a second "unconfirmed" state that means
+// nothing to an operator. So: one write BEFORE the loop (`writing`, with the row count each
+// requirement is about to get) and one AFTER the read-back (`written` / `failed`). Requirements
+// whose rows are all held or skipped never enter the loop and stay `pending` in both.
+//
+// Written through `writeJsonAtomic` (tmp+rename), like every other artifact the viewer reads, so a
+// 2s poll can never catch a torn file.
+//
+// FAIL-OPEN throughout, like `readsLog`: a writeback that refused to write to Campfire because its
+// progress file would not save would trade a real capability for a cosmetic one.
+import { log } from "./result.js";
+import { readJson, writeJsonAtomic, writebackDir } from "./workspace.js";
+import path from "node:path";
+export function writebackManifestPath(sessionId) {
+    return path.join(writebackDir(sessionId), "manifest.json");
+}
+/**
+ * Fold Configuration Item rows into one row per requirement.
+ *
+ * Pure, so the state machine is testable without an org: the tool supplies the same three sets it
+ * already computes for its own report (held, skipped, failed) and this decides what each
+ * requirement's row says.
+ */
+export function writebackManifestRows(input) {
+    const held = new Set(input.held ?? []);
+    const skipped = new Set(input.skipped ?? []);
+    const failed = new Set(input.failedRequirements ?? []);
+    // Insertion order preserves the derivation's own sort (requirement, then type/name), so the
+    // manifest reads in the same order as the tool's report.
+    const counts = new Map();
+    for (const row of input.rows) {
+        const extId = row.requirement;
+        if (!extId)
+            continue; // an unowned row belongs to no requirement; the tool refuses on those anyway
+        const writable = !held.has(row.metadataKey) && !skipped.has(row.metadataKey);
+        counts.set(extId, (counts.get(extId) ?? 0) + (writable ? 1 : 0));
+    }
+    return [...counts].map(([extId, ciCount]) => {
+        // Nothing to write for this requirement (every row held or skipped) — it is not in flight and
+        // it did not fail; it is waiting on the operator's reconcile-and-rerun.
+        if (ciCount === 0)
+            return { extId, status: "pending", ciCount, writtenAt: null };
+        if (!input.done)
+            return { extId, status: "writing", ciCount, writtenAt: null };
+        return {
+            extId,
+            status: failed.has(extId) ? "failed" : "written",
+            ciCount,
+            writtenAt: input.at
+        };
+    });
+}
+/**
+ * Write (or merge into) the session's writeback manifest. Never throws.
+ *
+ * MERGES rather than replaces, because the tool is DESIGNED to be called once per wave — its own
+ * `waves` argument exists so the incremental case does not re-derive the whole session and inflate
+ * Campfire's per-requirement Configuration Item counter. A replacing write would erase wave 1's
+ * `written` rows the moment wave 2 started, which is exactly the state the viewer is here to show.
+ * Rows named by this call win; rows only in the file survive untouched.
+ */
+export async function writeWritebackManifest(sessionId, rows) {
+    try {
+        const file = writebackManifestPath(sessionId);
+        let existing = [];
+        try {
+            const prior = await readJson(file);
+            if (Array.isArray(prior?.requirements))
+                existing = prior.requirements;
+        }
+        catch {
+            // No manifest yet, or one we cannot parse. Either way this call's rows are the truth.
+        }
+        const incoming = new Set(rows.map((row) => row.extId));
+        const merged = [...existing.filter((row) => row && !incoming.has(row.extId)), ...rows];
+        await writeJsonAtomic(file, { requirements: merged });
+    }
+    catch (error) {
+        log("writeback manifest not being recorded:", error instanceof Error ? error.message : String(error));
+    }
+}