@toon-protocol/rig 4.5.0 → 4.6.0

package/README.md

@@ -212,7 +212,7 @@ rig pr status <event-id> applied
 | `rig issue list` / `rig issue show <id>` | free | the repo's issues + comments from the terminal |
 | `rig pr list` / `rig pr show <id>` | free | the repo's patches/PRs; `show` prints the full patch text (pipe to `git am`) |
 | `rig issue create` | **paid** | file an issue (kind:1621) |
-| `rig comment <root-event-id>` | **paid** | comment (kind:1622) on an issue/patch |
+| `rig comment <target-event-id>` | **paid** | comment (NIP-22 kind:1111) on an issue/patch, or reply to a comment |
 | `rig pr create` | **paid** | publish a patch (kind:1617) from real `git format-patch` |
 | `rig pr status <event-id> <state>` | **paid** | set issue/patch status (kind:1630–1633) |
 | `rig site publish [ref]` | **paid** | deploy a pushed repo as a permaweb site: build the ar.io path manifest (repo paths → Arweave txids) and upload it as one paid store write; prints the gateway URL |
@@ -744,7 +744,12 @@ per-event fee is quoted and confirmed before publishing; `--yes` skips, `--json`
 without `--yes` is a free estimate:
 
 - `rig issue create --title <t> [--body <b> | --body-file <f> | stdin] [--label <l>]…` — kind:1621.
-- `rig comment <root-event-id> --body <b> [--parent-author <pubkey>] [--marker root|reply]` — kind:1622.
+- `rig comment <target-event-id> --body <b>` — NIP-22 kind:1111. The target is the
+  kind:1621 issue / kind:1617 patch (a top-level comment) or an existing kind:1111
+  comment (a reply). rig reads the target off the relay first, for free, so the
+  thread root's kind and author come from the wire: root scope is uppercase
+  `E`/`K`/`P`, the parent lowercase `e`/`k`/`p`, plus the repo `a` tag. Comments
+  published this way are invisible to rig releases older than 4.6.
 - `rig pr create --title <t> (--range <A..B> | --patch-file <f>) [--body <b> | --body-file <f>] [--branch <name>]` —
   kind:1617; `--range` runs real `git format-patch --stdout` locally and derives the
   `commit`/`parent-commit` tags. A multi-commit range publishes ONE event carrying
@@ -770,8 +775,9 @@ delta: only locally-missing objects are downloaded, and `refs/remotes/<remote>/*
 (tags → `refs/tags/*`) move with a `git fetch`-style report.
 
 `rig issue list|show` and `rig pr list|show` are pure relay reads (kind:1621/1617 by
-the repo `#a` tag; state from kind:1630-1633, latest wins; kind:1622 comments under
-`show`).
+the repo `#a` tag; state from kind:1630-1633, latest wins; comments under `show` —
+NIP-22 kind:1111 matched on the uppercase `E` root tag, merged with legacy kind:1622
+by `created_at`).
 
 ## Library
 
@@ -784,7 +790,9 @@ it — that stays behind the `Publisher` seam:
   a deprecated alias; it is no longer a cap).
 - `nip34-events.ts` — NIP-34 event builders returning `UnsignedEvent`:
   `buildRepoAnnouncement` (30617), `buildRepoRefs` (30618), `buildIssue` (1621),
-  `buildComment` (1622), `buildPatch` (1617), `buildStatus` (1630–1633).
+  `buildComment` (NIP-22 1111; `LEGACY_COMMENT_KIND` = 1622 stays exported for
+  READING old threads and is never written), `buildPatch` (1617),
+  `buildStatus` (1630–1633).
 - `repo-reader.ts` — `GitRepoReader`, read-only local-repo access via injection-safe
   `execFile` git plumbing.
 - `remote-state.ts` — `fetchRemoteState`, the "what does the remote have?" reader.

package/dist/{chunk-S2BMLXAD.js → chunk-DCGV6ALH.js}

@@ -1,15 +1,18 @@
 import {
   ARWEAVE_FETCH_TIMEOUT_MS,
   ARWEAVE_GATEWAYS,
+  MAINTAINERS_TAG,
+  MAX_ARWEAVE_TAGS_PER_EVENT,
   MissingIdentityError,
+  PAYOUT_TAG,
   authorizedStatusAuthors,
-  buildRepoAnnouncement,
   buildRepoRefs,
   defaultWebSocketFactory,
   isValidArweaveTxId,
+  parseMaintainers,
   queryRelay,
   resolveIdentity
-} from "./chunk-HMED76GU.js";
+} from "./chunk-JBFBD7HV.js";
 import {
   defaultDaemonPort,
   standaloneForced,
@@ -65,6 +68,203 @@ function createGitTag(opts) {
   return hashGitObject("tag", Buffer.from(lines.join("\n"), "utf-8"));
 }
 
+// src/repo-announcement.ts
+import { REPOSITORY_ANNOUNCEMENT_KIND } from "@toon-protocol/core/nip34";
+var RELAYS_TAG = "relays";
+var WEB_TAG = "web";
+var EARLIEST_UNIQUE_COMMIT_MARKER = "euc";
+function multiValueTag(name, values2) {
+  const kept = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values2) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0 || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    kept.push(trimmed);
+  }
+  return kept.length > 0 ? [[name, ...kept]] : [];
+}
+var named = (name) => (tag) => tag[0] === name;
+var SLOTS = /* @__PURE__ */ new Map([
+  ["d", { matches: named("d"), rewrite: (e) => [["d", e.repoId]] }],
+  [
+    "name",
+    {
+      matches: named("name"),
+      rewrite: (e) => e.name === void 0 ? null : [["name", e.name]]
+    }
+  ],
+  [
+    "description",
+    {
+      matches: named("description"),
+      rewrite: (e) => e.description === void 0 ? null : [["description", e.description]]
+    }
+  ],
+  [
+    "maintainers",
+    {
+      matches: named(MAINTAINERS_TAG),
+      rewrite: (e) => {
+        if (e.maintainers === void 0) return null;
+        const declared = parseMaintainers([
+          [MAINTAINERS_TAG, ...e.maintainers]
+        ]);
+        return declared.length > 0 ? [[MAINTAINERS_TAG, ...declared]] : [];
+      }
+    }
+  ],
+  [
+    "payout",
+    {
+      matches: named(PAYOUT_TAG),
+      rewrite: (e) => e.payout === void 0 ? null : e.payout ? [[PAYOUT_TAG, e.payout.chain, e.payout.address]] : []
+    }
+  ],
+  [
+    "relays",
+    {
+      matches: named(RELAYS_TAG),
+      rewrite: (e) => e.relays === void 0 ? null : e.relays ? multiValueTag(RELAYS_TAG, e.relays) : []
+    }
+  ],
+  [
+    "web",
+    {
+      matches: named(WEB_TAG),
+      rewrite: (e) => e.web === void 0 ? null : e.web ? multiValueTag(WEB_TAG, e.web) : []
+    }
+  ],
+  [
+    "euc",
+    {
+      // Only the euc marker is ours. Every other `r` tag is someone else's.
+      matches: (tag) => tag[0] === "r" && tag[2] === EARLIEST_UNIQUE_COMMIT_MARKER,
+      rewrite: (e) => e.earliestUniqueCommit === void 0 ? null : e.earliestUniqueCommit ? [["r", e.earliestUniqueCommit, EARLIEST_UNIQUE_COMMIT_MARKER]] : []
+    }
+  ]
+]);
+function slotOf(tag) {
+  for (const [slot, spec] of SLOTS) {
+    if (spec.matches(tag)) return slot;
+  }
+  return null;
+}
+function rewrittenSlots(edits) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [slot, spec] of SLOTS) {
+    const next = spec.rewrite(edits);
+    if (next !== null) out.set(slot, next);
+  }
+  return out;
+}
+function amendRepoAnnouncement(current, edits) {
+  const rewritten = rewrittenSlots(edits);
+  const tags = [["d", edits.repoId]];
+  const emitted = /* @__PURE__ */ new Set(["d"]);
+  for (const tag of current?.tags ?? []) {
+    const slot = slotOf(tag);
+    const replacement = slot === null ? void 0 : rewritten.get(slot);
+    if (slot === null || replacement === void 0) {
+      tags.push([...tag]);
+      continue;
+    }
+    if (emitted.has(slot)) continue;
+    for (const next of replacement) tags.push([...next]);
+    emitted.add(slot);
+  }
+  for (const [slot, replacement] of rewritten) {
+    if (emitted.has(slot)) continue;
+    for (const next of replacement) tags.push([...next]);
+    emitted.add(slot);
+  }
+  return {
+    kind: REPOSITORY_ANNOUNCEMENT_KIND,
+    content: current?.content ?? "",
+    tags,
+    created_at: Math.floor(Date.now() / 1e3)
+  };
+}
+function buildRepoAnnouncement(repoId, name, description, maintainers = [], payout) {
+  return amendRepoAnnouncement(null, {
+    repoId,
+    name,
+    description,
+    maintainers,
+    payout: payout ?? null
+  });
+}
+async function earliestUniqueCommit(reader) {
+  const all = await reader.rootCommits();
+  if (all.length === 0) return null;
+  if (all.length === 1) return all[0] ?? null;
+  const onDefaultBranch = await reader.rootCommits("HEAD");
+  const candidates = onDefaultBranch.length > 0 ? onDefaultBranch : all;
+  return [...candidates].sort()[0] ?? null;
+}
+function announcedEuc(current) {
+  for (const tag of current?.tags ?? []) {
+    if (tag[0] === "r" && tag[2] === EARLIEST_UNIQUE_COMMIT_MARKER) {
+      const sha = tag[1];
+      if (sha !== void 0 && sha.length > 0) return sha;
+    }
+  }
+  return null;
+}
+function unionValues(current, name, additions) {
+  const existing = [];
+  for (const tag of current?.tags ?? []) {
+    if (tag[0] === name) existing.push(...tag.slice(1));
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of [...existing, ...additions]) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0 || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    out.push(trimmed);
+  }
+  return out;
+}
+function conformanceEdits(current, facts) {
+  const edits = {};
+  const relays = unionValues(current, RELAYS_TAG, facts.relays);
+  if (relays.length > 0) edits.relays = relays;
+  const web = unionValues(current, WEB_TAG, facts.web === null ? [] : [facts.web]);
+  if (web.length > 0) edits.web = web;
+  if (announcedEuc(current) === null && facts.earliestUniqueCommit !== null) {
+    edits.earliestUniqueCommit = facts.earliestUniqueCommit;
+  }
+  return edits;
+}
+function tagKey(tag) {
+  return JSON.stringify(tag);
+}
+function diffAnnouncementTags(current, next) {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const tag of current?.tags ?? []) {
+    remaining.set(tagKey(tag), (remaining.get(tagKey(tag)) ?? 0) + 1);
+  }
+  const added = [];
+  for (const tag of next.tags) {
+    const key = tagKey(tag);
+    const count = remaining.get(key) ?? 0;
+    if (count > 0) remaining.set(key, count - 1);
+    else added.push([...tag]);
+  }
+  const removed = [];
+  for (const [key, count] of remaining) {
+    for (let i = 0; i < count; i += 1) {
+      removed.push(JSON.parse(key));
+    }
+  }
+  return {
+    added,
+    removed,
+    unchanged: added.length === 0 && removed.length === 0
+  };
+}
+
 // src/repo-reader.ts
 import { execFile, spawn } from "child_process";
 import { promisify } from "util";
@@ -261,6 +461,140 @@ var GitRepoReader = class {
     }
     return objects;
   }
+  /**
+   * Run git and hand each stdout line to `visit` as it arrives, never holding
+   * the whole output in memory. Returning `false` from `visit` ends the walk:
+   * the child is killed and the promise resolves with what was seen.
+   *
+   * Every other git call here buffers into one `execFile` string, which is
+   * fine for bounded output. These object walks are not bounded — they grow
+   * with the size of the repository — so on a repo big enough to need the
+   * object-map cap they would be the thing that breaks (#162).
+   */
+  streamLines(args, visit) {
+    return new Promise((resolve, reject) => {
+      const child = spawn("git", args, {
+        cwd: this.repoPath,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let pending = "";
+      let stderr = "";
+      let settled = false;
+      const finish = (err) => {
+        if (settled) return;
+        settled = true;
+        if (err) reject(err);
+        else resolve();
+      };
+      child.stdout.setEncoding("utf-8");
+      child.stdout.on("data", (chunk) => {
+        if (settled) return;
+        pending += chunk;
+        let idx = pending.indexOf("\n");
+        while (idx !== -1) {
+          const line = pending.slice(0, idx);
+          pending = pending.slice(idx + 1);
+          if (line && !visit(line)) {
+            child.kill("SIGTERM");
+            return finish();
+          }
+          idx = pending.indexOf("\n");
+        }
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.on("error", (err) => {
+        finish(
+          new GitError(
+            `failed to spawn git ${args[0]}: ${err.message}`,
+            void 0,
+            ""
+          )
+        );
+      });
+      child.on("close", (code) => {
+        if (settled) return;
+        if (code !== 0) {
+          return finish(
+            new GitError(
+              `git ${args[0]} failed (exit ${code}): ${stderr.trim()}`,
+              code ?? void 0,
+              stderr.trim()
+            )
+          );
+        }
+        if (pending) visit(pending);
+        finish();
+      });
+    });
+  }
+  /**
+   * Every object SHA in the local object database, in no particular order
+   * (`git cat-file --batch-all-objects --batch-check`, no bodies read).
+   *
+   * This is the honest answer to "what does this repository already have",
+   * which `rig fetch` needs to compute its delta. It deliberately does NOT
+   * consult the remote's kind:30618 `arweave` map: that map is capped (#162)
+   * and is a hint cache, never an index of local presence.
+   *
+   * Streamed, so the listing never has to fit in one buffer.
+   */
+  async listAllObjectShas() {
+    const shas = [];
+    await this.streamLines(
+      [
+        "cat-file",
+        "--batch-check=%(objectname)",
+        "--batch-all-objects",
+        "--unordered"
+      ],
+      (line) => {
+        shas.push(line);
+        return true;
+      }
+    );
+    return shas;
+  }
+  /**
+   * SHAs of every object reachable from `tips`, newest first: commits in
+   * reverse-chronological order, each commit immediately followed by the
+   * trees and blobs it is the first to reference
+   * (`git rev-list --objects --in-commit-order`).
+   *
+   * Used to rank the kind:30618 object map when it exceeds
+   * `MAX_ARWEAVE_TAGS_PER_EVENT` (#162): the entries most likely to be wanted
+   * by the next clone or fetch are the ones nearest the tips. Tips that do
+   * not resolve locally (a remote ref we never fetched) are dropped rather
+   * than failing the walk.
+   *
+   * `limit` stops the walk once that many SHAs have been seen — the ranking
+   * caller never needs more than the cap, and a full walk of a repository big
+   * enough to hit the cap is exactly the work worth not doing. The walk is
+   * streamed, so neither its output nor this array is ever bigger than that.
+   */
+  async reachableObjectsNewestFirst(tips, limit = Infinity) {
+    for (const tip of tips) assertRevision(tip, "tip");
+    const known = await this.filterExisting([...new Set(tips)]);
+    if (known.length === 0 || limit < 1) return [];
+    const shas = [];
+    await this.streamLines(
+      [
+        "rev-list",
+        "--objects",
+        "--in-commit-order",
+        ...known,
+        "--"
+        // nothing user-supplied can become a pathspec
+      ],
+      (line) => {
+        const spaceIdx = line.indexOf(" ");
+        shas.push(spaceIdx === -1 ? line : line.slice(0, spaceIdx));
+        return shas.length < limit;
+      }
+    );
+    return shas;
+  }
   /**
    * List every blob (file) reachable from a ref's root tree, recursively,
    * with the path it is served at (#368: the ar.io site manifest join key).
@@ -485,6 +819,46 @@ var GitRepoReader = class {
     }
     return parents;
   }
+  /**
+   * SHAs of the repo's ROOT commits — the parentless commits a history starts
+   * from — via `git rev-list --max-parents=0`.
+   *
+   * The repo's *earliest unique commit* (NIP-34's `euc` fork-identity tag) is
+   * chosen from these; the choosing rule lives in `repo-announcement.ts`.
+   *
+   * @param rev - Consider only roots reachable from this revision. Omit for
+   *   every root in the repository (`--all`).
+   * @returns The roots in `rev-list` order, or `[]` when the revision does not
+   *   resolve — an unborn `HEAD` in a repo with no commits is not an error.
+   */
+  async rootCommits(rev) {
+    const args = ["rev-list", "--max-parents=0"];
+    if (rev === void 0) {
+      args.push("--all");
+    } else {
+      assertRevision(rev, "rev");
+      args.push(rev);
+    }
+    args.push("--");
+    const { stdout, exitCode } = await this.git(args, {
+      allowExitCodes: [128]
+    });
+    if (exitCode !== 0) return [];
+    const roots = [];
+    for (const line of stdout.split("\n")) {
+      const sha = line.trim();
+      if (!sha) continue;
+      if (!FULL_SHA_RE.test(sha)) {
+        throw new GitError(
+          `unexpected rev-list --max-parents=0 line: ${JSON.stringify(line)}`,
+          void 0,
+          ""
+        );
+      }
+      roots.push(sha);
+    }
+    return roots;
+  }
   /**
    * Resolve a ref/revision to a full SHA via `git rev-parse --verify`.
    * Throws {@link GitError} when the name doesn't resolve.
@@ -1140,6 +1514,7 @@ async function planPush(options) {
     if (refname !== headSymref) newRefs[refname] = sha;
   }
   const announceNeeded = !remoteState.announced;
+  const euc = announceNeeded ? await earliestUniqueCommit(repoReader) : null;
   const totalObjectBytes = objects.reduce((sum, o) => sum + o.size, 0);
   const uploadFee = objects.reduce(
     (sum, o) => sum + uploadChargeFor(feeRates, o.size),
@@ -1158,7 +1533,9 @@ async function planPush(options) {
     announceNeeded,
     announcement: {
       name: options.announcement?.name ?? repoId,
-      description: options.announcement?.description ?? ""
+      description: options.announcement?.description ?? "",
+      ...options.announcement?.web ? { web: options.announcement.web } : {},
+      ...euc ? { earliestUniqueCommit: euc } : {}
     },
     estimate: {
       objectCount: objects.length,
@@ -1172,6 +1549,32 @@ async function planPush(options) {
   };
 }
 var READ_BATCH_SIZE = 100;
+async function boundObjectMap(merged, plan, repoReader) {
+  if (merged.size <= MAX_ARWEAVE_TAGS_PER_EVENT) return merged;
+  const kept = /* @__PURE__ */ new Map();
+  const take = (sha) => {
+    if (kept.size >= MAX_ARWEAVE_TAGS_PER_EVENT || kept.has(sha)) return;
+    const txId = merged.get(sha);
+    if (txId !== void 0) kept.set(sha, txId);
+  };
+  for (const object of plan.objects) take(object.sha);
+  if (kept.size < MAX_ARWEAVE_TAGS_PER_EVENT) {
+    const tips = [...new Set(Object.values(plan.newRefs))];
+    const reachable = await repoReader.reachableObjectsNewestFirst(
+      tips,
+      MAX_ARWEAVE_TAGS_PER_EVENT
+    );
+    for (const sha of reachable) {
+      if (kept.size >= MAX_ARWEAVE_TAGS_PER_EVENT) break;
+      take(sha);
+    }
+  }
+  for (const [sha, txId] of merged) {
+    if (kept.size >= MAX_ARWEAVE_TAGS_PER_EVENT) break;
+    if (!kept.has(sha)) kept.set(sha, txId);
+  }
+  return kept;
+}
 async function executePush(options) {
   const { plan, publisher, remoteState, repoReader, relayUrls } = options;
   const merged = new Map([...remoteState.shaToTxId, ...plan.knownShaToTxId]);
@@ -1230,18 +1633,22 @@ async function executePush(options) {
   }
   let announceReceipt = null;
   if (plan.announceNeeded && !remoteState.announced) {
-    const announceEvent = buildRepoAnnouncement(
-      plan.repoId,
-      plan.announcement.name,
-      plan.announcement.description
-    );
+    const announceEvent = amendRepoAnnouncement(null, {
+      repoId: plan.repoId,
+      name: plan.announcement.name,
+      description: plan.announcement.description,
+      relays: relayUrls,
+      ...plan.announcement.web ? { web: [plan.announcement.web] } : {},
+      ...plan.announcement.earliestUniqueCommit ? { earliestUniqueCommit: plan.announcement.earliestUniqueCommit } : {}
+    });
     announceReceipt = await publisher.publishEvent(announceEvent, relayUrls);
     totalFeePaid += announceReceipt.feePaid;
   }
+  const published = await boundObjectMap(merged, plan, repoReader);
   const refsEvent = buildRepoRefs(
     plan.repoId,
     plan.newRefs,
-    Object.fromEntries(merged)
+    Object.fromEntries(published)
   );
   const refsReceipt = await publisher.publishEvent(refsEvent, relayUrls);
   totalFeePaid += refsReceipt.feePaid;
@@ -1256,7 +1663,7 @@ async function executePush(options) {
     uploads,
     announceReceipt,
     refsReceipt,
-    arweaveMap: merged,
+    arweaveMap: published,
     totalFeePaid
   };
 }
@@ -2886,7 +3293,7 @@ function emitCliError(io, json, command, err) {
 
 // src/cli/ci-status.ts
 import { parseArgs as parseArgs2 } from "util";
-import { REPOSITORY_ANNOUNCEMENT_KIND } from "@toon-protocol/core/nip34";
+import { REPOSITORY_ANNOUNCEMENT_KIND as REPOSITORY_ANNOUNCEMENT_KIND2 } from "@toon-protocol/core/nip34";
 
 // src/cli/git-config.ts
 import { execFile as execFile3 } from "child_process";
@@ -3541,7 +3948,7 @@ async function runCiStatus(args, deps) {
           "#a": [repoAddr]
         },
         {
-          kinds: [REPOSITORY_ANNOUNCEMENT_KIND],
+          kinds: [REPOSITORY_ANNOUNCEMENT_KIND2],
           authors: [owner],
           "#d": [repoId]
         }
@@ -3550,7 +3957,7 @@ async function runCiStatus(args, deps) {
     );
     let announce = null;
     for (const ev of events) {
-      if (ev.kind !== REPOSITORY_ANNOUNCEMENT_KIND || ev.pubkey.toLowerCase() !== owner)
+      if (ev.kind !== REPOSITORY_ANNOUNCEMENT_KIND2 || ev.pubkey.toLowerCase() !== owner)
         continue;
       if (!ev.tags.some((t) => t[0] === "d" && t[1] === repoId)) continue;
       if (announce === null || ev.created_at > announce.created_at || ev.created_at === announce.created_at && ev.id < announce.id) {
@@ -3646,6 +4053,14 @@ export {
   createGitTree,
   createGitCommit,
   createGitTag,
+  RELAYS_TAG,
+  WEB_TAG,
+  EARLIEST_UNIQUE_COMMIT_MARKER,
+  amendRepoAnnouncement,
+  buildRepoAnnouncement,
+  earliestUniqueCommit,
+  conformanceEdits,
+  diffAnnouncementTags,
   GitError,
   GitRepoReader,
   DEFAULT_CONCURRENCY,
@@ -3759,4 +4174,4 @@ export {
   assembleCiStatus,
   runCiStatus
 };
-//# sourceMappingURL=chunk-S2BMLXAD.js.map
+//# sourceMappingURL=chunk-DCGV6ALH.js.map