@entelligentsia/forgecli 0.11.2 → 0.15.0

package/dist/forge-payload/tools/queue-drain.cjs

@@ -0,0 +1,152 @@
+'use strict';
+// FORGE-S24-T07 — queue drain at sprint close (per-task curator → batched review).
+//
+// Paper §3.2.1 grouped reward: one batched review at sprint close, not one
+// prompt per task. Per-task curators (T10) append proposals to a project-local
+// queue as they encounter friction during the sprint; Phase 2 drains the queue,
+// dedupes by {op, target_path, body-hash}, and feeds a single batch into the
+// downstream pipeline (compression gate T06 → replay scoring T04 → judge T03).
+//
+// Queue layout (canonical):
+//   .forge/enhancement-proposals/queue/<sprintId>/<taskId>-<ts>.json
+//
+//   - One file per per-task curator run.
+//   - The `<ts>` suffix (ISO compact timestamp) means concurrent or repeated
+//     curator runs on the same task never collide; each run produces a fresh
+//     file. Files are append-only — once written, never overwritten. The drain
+//     is a read-only pass that does NOT delete the queue (operators triage
+//     queue files for retrospective debugging).
+//
+// Dedup key: `<op>|<target_path>|sha256(diff_body)`.
+//   - `op` and `target_path` together identify "what artifact and how" (insert
+//     vs update vs delete).
+//   - `sha256(diff_body)` makes two proposals with byte-identical diff bodies
+//     collapse to one even if their rationales or sourceFrictionIds differ.
+//     Different bodies → different proposals (a smaller surgical patch and a
+//     full-file rewrite are distinct decisions for the judge).
+//
+// Pure helpers (`bodyHash`, `dedupeKey`, `dedupeProposals`, `queuePathFor`) are
+// fs-free. `appendToQueue` and `drainQueue` touch the filesystem.
+//
+// Exports:
+//   bodyHash(body)                    → sha256 hex digest of body (UTF-8).
+//   dedupeKey(proposal)               → composite key string.
+//   dedupeProposals(proposals)        → first-seen-wins deduped array.
+//   queuePathFor({ queueRoot, sprintId, taskId, ts })
+//                                     → canonical file path (string).
+//   appendToQueue({ queueRoot, sprintId, taskId, ts, proposals })
+//                                     → absolute path written; throws if path
+//                                       already exists (append-only invariant).
+//   drainQueue({ queueRoot, sprintId })
+//                                     → { proposals: [...deduped], files: [...],
+//                                         errors: [...] } — fs read, never write.
+
+const fs     = require('node:fs');
+const path   = require('node:path');
+const crypto = require('node:crypto');
+
+function bodyHash(body) {
+  if (typeof body !== 'string') {
+    throw new TypeError('bodyHash: body must be a string');
+  }
+  return crypto.createHash('sha256').update(body, 'utf8').digest('hex');
+}
+
+function dedupeKey(proposal) {
+  if (!proposal || typeof proposal !== 'object') {
+    throw new TypeError('dedupeKey: proposal must be an object');
+  }
+  const op          = String(proposal.op          ?? '');
+  const target_path = String(proposal.target_path ?? '');
+  const diff_body   = String(proposal.diff_body   ?? '');
+  return `${op}|${target_path}|${bodyHash(diff_body)}`;
+}
+
+function dedupeProposals(proposals) {
+  if (!Array.isArray(proposals)) {
+    throw new TypeError('dedupeProposals: proposals must be an array');
+  }
+  const seen = new Set();
+  const out  = [];
+  for (const p of proposals) {
+    const k = dedupeKey(p);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(p);
+  }
+  return out;
+}
+
+function queuePathFor({ queueRoot, sprintId, taskId, ts } = {}) {
+  if (typeof sprintId !== 'string' || !sprintId) {
+    throw new TypeError('queuePathFor: sprintId is required');
+  }
+  if (typeof taskId !== 'string' || !taskId) {
+    throw new TypeError('queuePathFor: taskId is required');
+  }
+  if (typeof ts !== 'string' || !ts) {
+    throw new TypeError('queuePathFor: ts is required');
+  }
+  const root = queueRoot ?? '.forge/enhancement-proposals/queue';
+  return path.join(root, sprintId, `${taskId}-${ts}.json`);
+}
+
+function appendToQueue({ queueRoot, sprintId, taskId, ts, proposals } = {}) {
+  if (!Array.isArray(proposals)) {
+    throw new TypeError('appendToQueue: proposals must be an array');
+  }
+  const target = queuePathFor({ queueRoot, sprintId, taskId, ts });
+  if (fs.existsSync(target)) {
+    throw new Error(
+      `appendToQueue: queue file already exists at ${target} ` +
+      `(queue is append-only; choose a fresh ts).`,
+    );
+  }
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.writeFileSync(target, JSON.stringify(proposals, null, 2), 'utf8');
+  return target;
+}
+
+function drainQueue({ queueRoot, sprintId } = {}) {
+  if (typeof sprintId !== 'string' || !sprintId) {
+    throw new TypeError('drainQueue: sprintId is required');
+  }
+  if (typeof queueRoot !== 'string' || !queueRoot) {
+    throw new TypeError('drainQueue: queueRoot is required');
+  }
+  const sprintDir = path.join(queueRoot, sprintId);
+  const result = { proposals: [], files: [], errors: [] };
+  if (!fs.existsSync(sprintDir)) return result;
+
+  const entries = fs.readdirSync(sprintDir)
+    .filter((name) => name.endsWith('.json'))
+    .sort(); // deterministic order: lexicographic ⇒ chronological because of ts suffix
+  const merged = [];
+  for (const name of entries) {
+    const abs = path.join(sprintDir, name);
+    result.files.push(abs);
+    let parsed;
+    try {
+      parsed = JSON.parse(fs.readFileSync(abs, 'utf8'));
+    } catch (err) {
+      result.errors.push({ file: abs, error: err.message });
+      continue;
+    }
+    if (!Array.isArray(parsed)) {
+      result.errors.push({ file: abs, error: 'expected JSON array of proposals' });
+      continue;
+    }
+    for (const p of parsed) merged.push(p);
+  }
+  result.proposals = dedupeProposals(merged);
+  return result;
+}
+
+module.exports = {
+  bodyHash,
+  dedupeKey,
+  dedupeProposals,
+  queuePathFor,
+  appendToQueue,
+  drainQueue,
+};

package/dist/forge-payload/tools/replay-scoring.cjs

@@ -0,0 +1,117 @@
+'use strict';
+// FORGE-S24-T04 — cross-task replay scoring (recurrence boost).
+//
+// For each enhancement proposal synthesised from a friction event at task `t`,
+// scan friction events in tasks `t+1..N` (within the same sprint) for the
+// same `(subkind, evidence.skillId)` pair. Surface the count + task list on
+// the proposal so the T03 judge sees "this friction happened 3 times" rather
+// than "this friction happened once".
+//
+// Pure module; consumed by Phase 2 step 5/6 of meta-enhance.md after the
+// dedup pass and before the proposal artifact is written.
+//
+// Exports:
+//   computeRecurrence({ events, subkind, skillId, fromTaskId, taskOrder })
+//     -> { recurrence_count, recurrence_task_ids }
+//   annotateProposals(proposals, frictionEvents, taskOrder)
+//     -> new array of proposals, each carrying recurrence_count +
+//        recurrence_task_ids.
+
+function computeRecurrence({ events, subkind, skillId, fromTaskId, taskOrder }) {
+  if (!Array.isArray(events))    throw new TypeError('events must be an array');
+  if (!Array.isArray(taskOrder)) throw new TypeError('taskOrder must be an array');
+  if (typeof subkind    !== 'string' || subkind    === '') throw new TypeError('subkind required');
+  if (typeof skillId    !== 'string' || skillId    === '') throw new TypeError('skillId required');
+  if (typeof fromTaskId !== 'string' || fromTaskId === '') throw new TypeError('fromTaskId required');
+
+  const originIdx = taskOrder.indexOf(fromTaskId);
+
+  // Distinct taskIds with a matching friction event.
+  const matchingTaskIds = new Set();
+
+  for (const evt of events) {
+    if (!evt || evt.type !== 'friction') continue;
+    if (evt.subkind !== subkind) continue;
+    const evtSkillId = evt.evidence && evt.evidence.skillId;
+    if (evtSkillId !== skillId) continue;
+    if (!evt.taskId) continue;
+
+    if (originIdx === -1) {
+      // fromTaskId not in taskOrder: only count the origin task itself.
+      if (evt.taskId === fromTaskId) matchingTaskIds.add(evt.taskId);
+      continue;
+    }
+
+    const evtIdx = taskOrder.indexOf(evt.taskId);
+    // Forward-only: include origin task (evtIdx === originIdx) and later
+    // (evtIdx > originIdx). Skip earlier and unknown tasks.
+    if (evtIdx >= originIdx) matchingTaskIds.add(evt.taskId);
+  }
+
+  // Always include the origin task so recurrence_count >= 1.
+  matchingTaskIds.add(fromTaskId);
+
+  // Sort by taskOrder position; tasks not in taskOrder go last in insertion order.
+  const ordered = [...matchingTaskIds].sort((a, b) => {
+    const ai = taskOrder.indexOf(a);
+    const bi = taskOrder.indexOf(b);
+    if (ai === -1 && bi === -1) return 0;
+    if (ai === -1) return 1;
+    if (bi === -1) return -1;
+    return ai - bi;
+  });
+
+  return {
+    recurrence_count:    ordered.length,
+    recurrence_task_ids: ordered,
+  };
+}
+
+function annotateProposals(proposals, frictionEvents, taskOrder) {
+  if (!Array.isArray(proposals))      throw new TypeError('proposals must be an array');
+  if (!Array.isArray(frictionEvents)) throw new TypeError('frictionEvents must be an array');
+  if (!Array.isArray(taskOrder))      throw new TypeError('taskOrder must be an array');
+
+  // Index friction events by eventId for O(1) sourceFrictionIds resolution.
+  const byEventId = new Map();
+  for (const evt of frictionEvents) {
+    if (evt && evt.eventId) byEventId.set(evt.eventId, evt);
+  }
+
+  return proposals.map((proposal) => {
+    const sourceIds = Array.isArray(proposal.sourceFrictionIds)
+      ? proposal.sourceFrictionIds
+      : [];
+
+    // Resolve the first sourceFrictionId that points at a known friction event
+    // with subkind + evidence.skillId. The originating event determines
+    // (subkind, skillId, fromTaskId) for the recurrence scan.
+    let originEvent = null;
+    for (const id of sourceIds) {
+      const evt = byEventId.get(id);
+      if (evt && evt.subkind && evt.evidence && evt.evidence.skillId && evt.taskId) {
+        originEvent = evt;
+        break;
+      }
+    }
+
+    if (!originEvent) {
+      // No resolvable provenance: neutral annotation. recurrence_count=1
+      // keeps the schema invariant; recurrence_task_ids is empty so the
+      // judge can distinguish "single observation" from "unresolved origin".
+      return { ...proposal, recurrence_count: 1, recurrence_task_ids: [] };
+    }
+
+    const { recurrence_count, recurrence_task_ids } = computeRecurrence({
+      events:     frictionEvents,
+      subkind:    originEvent.subkind,
+      skillId:    originEvent.evidence.skillId,
+      fromTaskId: originEvent.taskId,
+      taskOrder,
+    });
+
+    return { ...proposal, recurrence_count, recurrence_task_ids };
+  });
+}
+
+module.exports = { computeRecurrence, annotateProposals };

package/node_modules/@mariozechner/clipboard/package.json

@@ -42,6 +42,7 @@
     "version": "napi version"
   },
   "optionalDependencies": {
-    "@mariozechner/clipboard-linux-x64-gnu": "0.3.6"
+    "@mariozechner/clipboard-linux-x64-gnu": "0.3.6",
+    "@mariozechner/clipboard-linux-x64-musl": "0.3.6"
   }
 }

package/node_modules/@mariozechner/clipboard-linux-x64-musl/README.md

@@ -0,0 +1,3 @@
+# `@mariozechner/clipboard-linux-x64-musl`
+
+This is the **x86_64-unknown-linux-musl** binary for `@mariozechner/clipboard`

package/node_modules/@mariozechner/clipboard-linux-x64-musl/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@mariozechner/clipboard-linux-x64-musl",
+  "version": "0.3.6",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "main": "clipboard.linux-x64-musl.node",
+  "files": [
+    "clipboard.linux-x64-musl.node"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">= 10"
+  },
+  "libc": [
+    "musl"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/badlogic/clipboard.git"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entelligentsia/forgecli",
-  "version": "0.11.2",
+  "version": "0.15.0",
   "description": "Forge SDLC ported onto @earendil-works/pi-coding-agent — production launcher with three bin aliases (forge/forgecli/4ge). Bundles a curated fork of pi-coding-agent vendored under earendil-works names.",
   "license": "MIT",
   "author": "Entelligentsia",
@@ -49,7 +49,7 @@
     ]
   },
   "forge": {
-    "bundledVersion": "0.44.6",
+    "bundledVersion": "0.45.0",
     "forgeRoot": "../forge/forge"
   },
   "scripts": {
@@ -76,6 +76,7 @@
     "@earendil-works/pi-tui": "file:./vendor-pi/earendil-works-pi-tui-0.75.3.tgz",
     "ajv": "^8.20.0",
     "js-yaml": "^4.1.0",
+    "lunr": "2.3.9",
     "typebox": "^1.1.24"
   },
   "peerDependencies": {
@@ -84,6 +85,7 @@
   "devDependencies": {
     "@biomejs/biome": "^2.3.5",
     "@types/js-yaml": "^4.0.9",
+    "@types/lunr": "2.3.7",
     "@types/node": "^24.3.0",
     "typescript": "^5.7.3",
     "vitest": "^3.2.4"