gcf-board 0.2.17 → 0.2.19

package/README.md

@@ -52,6 +52,7 @@ It puts **GCF Board** on the desktop (Windows: a shortcut whose server console s
 - **Lessons** (core 0.7.10, harness 0.9.2): what got in an agent's way, asked at the end of each session, lands in the inbox with its kind (`tool`, `rules`, `framework`, `template`, `other`) and its item. The inbox filters them; a card shows `N lessons`, and the drawer lists the item's lessons with the inbox's buttons. A run's report line ends with `, N lessons`, and with `— code written outside aif-implement` when a session skipped that skill.
 - **Playtest**: `gcf playtest session` with the checklist grouped by subsystem; keep, tune or kill each item from the list. **Build** runs `dod.build`. A note goes to the inbox as `--source playtest`.
 - **Ended**: history (accepted) and graveyard (killed, dropped, won't-fix).
+- **Metrics**: `gcf-harness metrics --json` of the project — how many runs reached submit or close, what they cost, handoffs, plan checks, DoD attempts, guard firings, block reasons — and, with harness 0.9.5, the cost per item over all its runs and per week and day.
 
 The page updates by itself: the server watches each project's `gcf/` and `.gcf-session/runs/`.
 

package/dist/server/app.js

@@ -1,5 +1,6 @@
 // The board's HTTP server: the page, and an API that is a thin layer over `ai-factory gcf`.
-// Reads: projects, the board, a shown file, a run log, the playtest session. Writes: a project
+// Reads: projects, the board, a shown file, a run log, the playtest session, the run metrics
+// (`ai-factory gcf-harness metrics`). Writes: a project
 // on the board, a move, a run. Every write is a command of the framework.
 import { randomBytes } from 'node:crypto';
 import { createServer } from 'node:http';
@@ -143,7 +144,7 @@ export function createApp(o) {
                 const p = await projectOf(m[1]);
                 // The board's own runs ride along: what it started and what waits in its queue; and the
                 // count of plan writes, which tells the page an open plan's text changed.
-                const own = { runs: runsOf(p.name), plans_rev: planRev(p.name) };
+                const own = { runs: runsOf(p.name), plans_rev: planRev(p.name), board_version: o.version };
                 const board = await boardOf(p);
                 // A running item's last log write tells a working session from a stuck one; a run's
                 // lock is this board's run or a console's.
@@ -185,6 +186,14 @@ export function createApp(o) {
                 send(res, 200, jsonOf(r, 'gcf playtest session'));
             },
         ],
+        [
+            'GET',
+            /^\/api\/p\/([^/]+)\/metrics$/,
+            async (_req, res, m) => {
+                const r = await cli(await projectOf(m[1]), ['gcf-harness', 'metrics', '--json']);
+                send(res, 200, jsonOf(r, 'gcf-harness metrics'));
+            },
+        ],
         [
             // A build runs the project's own command: a write, so a POST with its Origin checked.
             'POST',

package/dist/server/cli.js

@@ -43,11 +43,13 @@ function globalRoots() {
     return roots;
 }
 /**
- * The line of a refusal an operator reads: the core throws, and node prints the stack under
- * an `Error: <message>` line. Anything else is shown as it came.
+ * The refusal an operator reads: the core throws, and node prints the stack under an
+ * `Error: <message>` header, every line of the message (a git failure's cause comes after its
+ * first line). Anything else is shown as it came.
  */
 export function briefError(err) {
-    return err.match(/^\w*Error: (.+)$/m)?.[1].trim() ?? err.trim();
+    const m = err.match(/^\w*Error: ([\s\S]*?)\r?\n {4}at /m) ?? err.match(/^\w*Error: (.+)$/m);
+    return (m?.[1] ?? err).replace(/\r/g, '').trim();
 }
 /** Run `ai-factory <args>` in a project; a move can wait up to a minute on gcf's main lock. */
 export function runCli(entry, cwd, args, timeoutMs = 120_000) {

package/dist/server/main.js

@@ -68,7 +68,13 @@ async function main() {
     const token = await boardToken();
     const url = `http://127.0.0.1:${port}/?t=${token}`;
     const open = () => !values['no-open'] && openInBrowser(url);
-    const app = createApp({ entry: aiFactoryEntry(), token, port, web: webDir() });
+    const app = createApp({
+        entry: aiFactoryEntry(),
+        token,
+        port,
+        web: webDir(),
+        version: version(),
+    });
     app.on('error', async (e) => {
         if (e.code !== 'EADDRINUSE') {
             console.error(`gcf-board: cannot listen on port ${port}: ${e.message}`);

package/dist/server/moves.js

@@ -41,6 +41,19 @@ const many = (b, key) => {
         throw new HttpError(400, `${key} must be a list of text`);
     return v.filter(Boolean).map((x) => `--${key}=${x}`);
 };
+// The core limits a tag to 40 characters too.
+const TAG = /^[a-z0-9][a-z0-9:-]{0,39}$/;
+/** A list as one comma-separated `--flag=` (a repeated option keeps only its last). */
+const list = (b, key, re, what, flag = key) => {
+    const v = b[key];
+    if (v === undefined)
+        return [];
+    if (!Array.isArray(v) || v.some((x) => typeof x !== 'string' || !re.test(x)))
+        throw new HttpError(400, `${key} must be a list of ${what}`);
+    return v.length ? [`--${flag}=${v.join(',')}`] : [];
+};
+const idList = (b, key) => list(b, key, SLUG, 'ids');
+const tagList = (b, key, flag = key) => list(b, key, TAG, 'tags', flag);
 /** `--remove` / `--no-remove` when the operator chose; the command's default otherwise. */
 const remove = (b) => b.remove === true ? ['--remove'] : b.remove === false ? ['--no-remove'] : [];
 const NEW_ITEM_OPTIONS = [
@@ -102,13 +115,24 @@ const MOVES = {
         'inbox',
         'add',
         ...opt(b, 'source'),
+        ...tagList(b, 'tags'),
         '--commit',
         `--text=${required(b, 'text')}`,
     ],
     'inbox-drop': (b) => ['inbox', 'drop', id(b), '--commit'],
+    'inbox-tag': (b) => [
+        'inbox',
+        'tag',
+        id(b),
+        ...tagList(b, 'add'),
+        ...tagList(b, 'remove'),
+        '--commit',
+    ],
     'phase-next': (b) => ['phase', 'next', ...opt(b, 'reason')],
     // A column's new order after a drag: ranks 1, 2, 3… in one commit.
     prioritize: (b) => ['prioritize', ...runIds(b)],
+    // The ids an item waits for, added and removed; the core refuses an unknown id and a cycle.
+    depends: (b) => ['depends', id(b), ...idList(b, 'add'), ...idList(b, 'remove')],
     'question-answer': (b) => ['question', 'answer', id(b), `--text=${required(b, 'text')}`],
     // One setting of gcf/config.yml; the core checks the key and the value. An empty value takes
     // a number back to its default.