@kungfu-tech/buildchain 4.1.3-alpha.0 → 4.1.3-alpha.1

package/packages/core/release/discussion/store.js

@@ -1,3 +1,5 @@
+import { readDiscussionThreads, eventParent } from "./threads.js";
+import { renderIntent, renderEvent } from "./presentation.js";
 import { collectDiscussionPages } from "../../providers/github/discussions/transport.js";
 import {
   canonicalJson,
@@ -95,11 +97,10 @@ export function releaseDiscussionStore(
         discussion = await transport.create({
           repositoryId: repository.id,
           categoryId: selected[0].id,
-          title: `Buildchain release: ${intent.key}`,
-          body: encodeRecord(
-            intent,
-            `Release transaction for ${intent.key}. Expected nodes: ${intent.expectedNodes.join(", ")}.`,
-          ),
+          title: intent.source?.qualification
+            ? `Buildchain qualification: ${intent.source.qualification}`
+            : `Buildchain release: ${intent.key}`,
+          body: encodeRecord(intent, renderIntent(intent)),
         });
       } catch (error) {
         discussion = await observeAfterUnknown(find, error);
@@ -110,39 +111,30 @@ export function releaseDiscussionStore(
   }
   async function read(session) {
     const discussion = await transport.get(session.discussion.id);
-    assertDiscussion(discussion, session.intent, session.writerId);
-    const comments = await collectDiscussionPages((after) =>
-      transport.comments(discussion.id, after),
-    );
-    const trusted = comments.filter(
-      (comment) => comment.author?.id === session.writerId,
+    const intent = assertDiscussion(
+      discussion,
+      session.intent,
+      session.writerId,
     );
-    if (
-      trusted.some(
-        (comment) => comment.lastEditedAt && decodeRecord(comment.body),
-      )
-    )
-      throw new Error(
-        "A transaction record was edited; historical facts are no longer intact",
-      );
-    const records = trusted
-      .map((comment) => decodeRecord(comment.body))
-      .filter(Boolean);
+    const threads = await readDiscussionThreads(transport, {
+      ...session,
+      intent,
+      discussion,
+    });
     return {
       discussion,
-      comments: trusted,
-      records,
-      ...readReleaseDiscussion({ body: discussion.body, records }),
+      ...threads,
+      ...readReleaseDiscussion({
+        body: discussion.body,
+        records: threads.records,
+      }),
     };
   }
   async function append(session, record) {
     if (session.dryRun) return { dryRun: true };
-    const body = encodeRecord(
-      record,
-      `${record.node}: ${record.status} (attempt ${record.attempt})`,
-    );
+    let observed;
     const find = async () => {
-      const observed = await read(session);
+      observed = await read(session);
       const existing = observed.comments.find(
         (comment) => decodeRecord(comment.body)?.id === record.id,
       );
@@ -155,8 +147,13 @@ export function releaseDiscussionStore(
     };
     const existing = await find();
     if (existing) return existing;
+    const parent = eventParent(observed, record);
+    const body = encodeRecord(
+      record,
+      renderEvent(record, session.intent, observed),
+    );
     try {
-      await transport.append(session.discussion.id, body);
+      await transport.append(session.discussion.id, body, parent);
     } catch (error) {
       return observeAfterUnknown(find, error);
     }

package/packages/core/release/discussion/threads.js

@@ -0,0 +1,83 @@
+import { decodeRecord } from "./envelope.js";
+import { collectDiscussionPages } from "../../providers/github/discussions/transport.js";
+
+export function isAttemptRoot(record) {
+  return (
+    record?.node === "attempt" &&
+    record.kind === "progress" &&
+    record.status === "running" &&
+    record.sequence === 0
+  );
+}
+
+// Provider placement is checked before the pure reader reduces event semantics.
+// Historical flat records retain their original representation; new writes always
+// use roots and replies. An explicit intent organization makes placement strict.
+export async function readDiscussionThreads(transport, session) {
+  const top = await collectDiscussionPages((after) =>
+    transport.comments(session.discussion.id, after),
+  );
+  const comments = [...top];
+  for (const root of top) {
+    if (root.replies?.totalCount === 0) continue;
+    const replies = await collectDiscussionPages((after) =>
+      transport.replies(root.id, after),
+    );
+    for (const reply of replies) {
+      if (reply.replyTo?.id !== root.id)
+        throw new Error(
+          "Discussion reply parent differs from its queried thread",
+        );
+    }
+    comments.push(...replies);
+    if (Buffer.byteLength(JSON.stringify(comments)) > 32 * 1024 * 1024)
+      throw new Error("Discussion threads exceed the complete-view byte bound");
+  }
+  const trusted = comments.filter(
+    (comment) => comment.author?.id === session.writerId,
+  );
+  const records = new Map();
+  for (const comment of trusted) {
+    const record = decodeRecord(comment.body);
+    if (!record) continue;
+    if (comment.lastEditedAt)
+      throw new Error(
+        "A transaction record was edited; historical facts are no longer intact",
+      );
+    records.set(comment.id, record);
+  }
+  const roots = new Map();
+  for (const comment of trusted) {
+    const record = records.get(comment.id);
+    if (!isAttemptRoot(record)) continue;
+    if (comment.replyTo || roots.has(record.attempt))
+      throw new Error("Ambiguous or nested Discussion attempt root");
+    roots.set(record.attempt, comment);
+  }
+  for (const comment of trusted) {
+    const record = records.get(comment.id);
+    if (!record || isAttemptRoot(record)) continue;
+    const root = roots.get(record.attempt);
+    if (comment.replyTo) {
+      if (!root || comment.replyTo.id !== root.id)
+        throw new Error(
+          "Transaction event is attached to a different attempt root",
+        );
+    } else if (session.intent.organization === "attempt-threads/v1") {
+      throw new Error("Transaction event requires its attempt root reply");
+    }
+  }
+  return { comments: trusted, records: [...records.values()], roots };
+}
+
+export function eventParent(state, record) {
+  const root = state.roots.get(record.attempt);
+  if (isAttemptRoot(record)) {
+    if (root)
+      throw new Error("Attempt root already exists with different content");
+    return null;
+  }
+  if (!root)
+    throw new Error("Open the attempt root before appending its events");
+  return root.id;
+}