cohorte 2.8.0 → 2.10.0

package/dashboard/server/kanban.js

@@ -1,169 +0,0 @@
-'use strict';
-// Read a project's linked Obsidian Kanban board (from ~/.claude/cohorte.config.yaml) and
-// parse it into columns + cards. The board is a plain markdown file in the user's vault, so this
-// stays local + dependency-free. The kanban mirror is Obsidian-only by design.
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-const { parse, parseProfileBlock } = require('./yaml');
-
-// owner/repo from the project's GitHub origin remote (SSH or HTTPS form), or null.
-function githubRepo(projectRoot) {
-  try {
-    const r = spawnSync('git', ['-C', projectRoot, 'remote', 'get-url', 'origin'],
-      { encoding: 'utf8', timeout: 3000 });
-    if (r.status !== 0 || !r.stdout) return null;
-    const m = r.stdout.trim().match(/github\.com[:/]([^/]+)\/(.+?)(?:\.git)?$/);
-    return m ? `${m[1]}/${m[2]}` : null;
-  } catch { return null; }
-}
-
-// PR metadata (state, draft, dates) for the repo, keyed by number. Uses the user's authenticated
-// `gh` CLI; cached 60s so the dashboard poll doesn't hammer the API. Empty map if gh is absent/fails.
-let _prCache = { repo: null, at: 0, map: {} };
-function fetchPRs(repo) {
-  if (!repo) return {};
-  if (_prCache.repo === repo && Date.now() - _prCache.at < 60000) return _prCache.map;
-  try {
-    const r = spawnSync('gh', ['pr', 'list', '--repo', repo, '--state', 'all', '--limit', '200',
-      '--json', 'number,state,isDraft,createdAt,mergedAt,url,headRefName'], { encoding: 'utf8', timeout: 8000 });
-    if (r.status !== 0 || !r.stdout) return _prCache.repo === repo ? _prCache.map : {};
-    const map = {};
-    for (const pr of JSON.parse(r.stdout)) map[String(pr.number)] = pr;
-    _prCache = { repo, at: Date.now(), map };
-    return map;
-  } catch { return {}; }
-}
-
-function readConfig(globalDir) {
-  // cohorte.config.yaml under the Claude global dir first, then `~/.cohorte/` — where the
-  // installer seeds it for every non-Claude runtime (the shipped scripts probe the same two,
-  // in the same order) — then the pre-rename legacy name (read-only fallback).
-  const candidates = [
-    path.join(globalDir, 'cohorte.config.yaml'),
-    path.join(os.homedir(), '.cohorte', 'cohorte.config.yaml'),
-    path.join(globalDir, 'thebidouille.config.yaml'),
-  ];
-  for (const p of candidates) {
-    try { return parse(fs.readFileSync(p, 'utf8')); } catch { /* try next */ }
-  }
-  return null;
-}
-
-// The project's PIPELINE.md `name`, or the directory basename as a fallback (a purged project
-// has no profile, but its board is still keyed by the old name — match case-insensitively).
-function projectName(projectRoot) {
-  const md = (() => { try { return fs.readFileSync(path.join(projectRoot, 'PIPELINE.md'), 'utf8'); } catch { return null; } })();
-  const profile = md ? parseProfileBlock(md) : null;
-  return (profile && profile.name) || path.basename(projectRoot);
-}
-
-// Resolve the board key for this project: exact name, else case-insensitive basename match.
-function boardEntry(boards, name, projectRoot) {
-  if (!boards || typeof boards !== 'object') return null;
-  if (boards[name]) return boards[name];
-  const base = path.basename(projectRoot).toLowerCase();
-  const key = Object.keys(boards).find(k => k.toLowerCase() === name.toLowerCase() || k.toLowerCase() === base);
-  return key ? boards[key] : null;
-}
-
-// Parse an Obsidian Kanban markdown file into columns of cards. `repo` (owner/repo) turns
-// bare `#123` PR references into links.
-function parseBoard(md, repo) {
-  const cols = [];
-  let cur = null;
-  for (const raw of md.split(/\r?\n/)) {
-    const line = raw.replace(/\s+$/, '');
-    if (/^%%/.test(line)) break; // the `%% kanban:settings %%` trailer ends the board
-    const h = line.match(/^##\s+(.+?)\s*$/);
-    if (h) { cur = { name: h[1], cards: [] }; cols.push(cur); continue; }
-    const c = line.match(/^\s*-\s*\[([ xX])\]\s+(.+?)\s*$/);
-    if (c && cur) {
-      const src = c[2];
-      // `#123` = PR reference; `#word` (letter-first) = a feature tag.
-      const prs = [...src.matchAll(/#(\d+)\b/g)].map(m => ({
-        num: m[1], url: repo ? `https://github.com/${repo}/pull/${m[1]}` : null,
-      }));
-      // A tag is any #-word that is not a bare number (`#123` = PR ref) — feature ids
-      // may start with a digit (`#2fa-login`), which a letter-first pattern dropped
-      // from tags while the text-strip below still removed it: the card lost its join key.
-      const tags = [...src.matchAll(/#(?!\d+\b)([\wÀ-ɏ][\wÀ-ɏ/-]*)/g)].map(m => m[1]);
-      const text = src
-        .replace(/#[\wÀ-ɏ/-]+/g, '')   // strip tags + PR refs
-        .replace(/\bPR\b/g, '')         // and the leftover "PR" label
-        .replace(/[—–-]\s*$/, '')       // trailing dash
-        .replace(/\s{2,}/g, ' ').trim();
-      cur.cards.push({ text, done: c[1].toLowerCase() === 'x', tags, prs });
-    }
-  }
-  return cols;
-}
-
-function kanban({ projectRoot, globalDir }) {
-  const cfg = readConfig(globalDir);
-  if (!cfg) return { enabled: false, reason: 'no cohorte.config.yaml' };
-  const k = cfg.kanban;
-  if (!k || k.enabled !== true) return { enabled: false, reason: 'kanban disabled in config' };
-  const vault = cfg.obsidian && cfg.obsidian.vault_path;
-  if (!vault) return { enabled: false, reason: 'no obsidian.vault_path configured' };
-
-  const name = projectName(projectRoot);
-  const entry = boardEntry(k.boards, name, projectRoot);
-  if (!entry || !entry.board) return { enabled: false, reason: `no board linked for "${name}"` };
-
-  const boardPath = path.join(vault, entry.board);
-  let md;
-  try { md = fs.readFileSync(boardPath, 'utf8'); }
-  catch { return { enabled: false, reason: `board file unreadable: ${entry.board}` }; }
-
-  const repo = githubRepo(projectRoot);
-  const columns = parseBoard(md, repo);
-
-  // Enrich PR refs with live status (state/draft/dates) from gh, and compute each card's ship date.
-  const prMap = fetchPRs(repo);
-  const byBranch = {};
-  for (const pr of Object.values(prMap)) if (pr.headRefName) byBranch[pr.headRefName] = pr;
-  const applyMeta = (pr, meta) => {
-    pr.state = meta.state; pr.draft = meta.isDraft; pr.mergedAt = meta.mergedAt; pr.createdAt = meta.createdAt;
-    pr.url = pr.url || meta.url; pr.num = pr.num || String(meta.number);
-  };
-  // A card with a `#<feature_id>` tag but no explicit `#<num>`: infer its PR from the branch
-  // `<...>/<feature_id>` (the old cards predate "always write the PR number"). Marked inferred.
-  const inferPR = tags => {
-    for (const t of tags) {
-      const hit = byBranch[`feature/${t}`] || Object.values(prMap).find(p => p.headRefName && p.headRefName.endsWith(`/${t}`));
-      if (hit) return { num: String(hit.number), inferred: true };
-    }
-    return null;
-  };
-
-  for (const col of columns) {
-    for (const card of col.cards) {
-      if (card.prs.length === 0) {
-        const inf = inferPR(card.tags);
-        if (inf) card.prs.push(inf);
-      }
-      let latest = null;
-      for (const pr of card.prs) {
-        const meta = prMap[pr.num];
-        if (meta) {
-          applyMeta(pr, meta);
-          const d = meta.mergedAt || meta.createdAt;
-          if (d && (!latest || d > latest)) latest = d;
-        }
-      }
-      card.shipDate = latest; // ISO string of the newest merge/creation among the card's PRs
-    }
-    // Shipped column: most-recently-shipped first (cards without a date sink to the bottom).
-    if (/shipped/i.test(col.name)) {
-      col.cards.sort((a, b) => (b.shipDate || '').localeCompare(a.shipDate || ''));
-    }
-  }
-
-  const total = columns.reduce((n, c) => n + c.cards.length, 0);
-  return { enabled: true, name, boardRel: entry.board, prSource: Object.keys(prMap).length ? 'gh' : 'none', columns, total };
-}
-
-module.exports = { kanban };

package/dashboard/server/metrics.js

@@ -1,113 +0,0 @@
-'use strict';
-// Read a project's `pipeline-metrics.jsonl` (one line per phase batch, appended by
-// /cohorte-build, /cohorte-review and /cohorte-fix) and aggregate it per feature: wall-clock per phase, fix
-// rounds, and per-surface results. Dependency-free; a missing file is simply "no data yet".
-//
-// Two line formats coexist in the file:
-//   new    {"ts","feature","phase","seconds",surfaces:{"<key>":"ok|error"|"<verdict>:<count>"}}
-//   legacy {"ts","feature","phase","surface","seconds","result"}  — one line PER surface;
-//          legacy lines are grouped by ts+feature+phase into one batch (wall-clock = max).
-
-const fs = require('fs');
-const path = require('path');
-const { layouts, stateDirs } = require('./runtime.js');
-
-// `smoke` and `cycle` are RETIRED phases, kept so metrics files written before their removal
-// still render. Without them in this list their per-surface results parse fine but land in no
-// column — the surface table showed rows with every cell empty.
-const PHASES = ['build', 'review', 'fix', 'smoke', 'cycle'];
-
-// Parse the raw JSONL into normalized batches ({ts, feature, phase, seconds, surfaces}),
-// skipping malformed lines. Legacy per-surface lines are folded into their batch.
-function parseBatches(raw) {
-  const batches = [];
-  const legacy = new Map(); // "ts|feature|phase" → batch (legacy lines share the key)
-  for (const line of raw.split(/\r?\n/)) {
-    if (!line.trim()) continue;
-    let e;
-    try { e = JSON.parse(line); } catch { continue; }
-    if (!e || typeof e !== 'object' || !e.feature || !e.phase) continue;
-    const seconds = Number(e.seconds) || 0;
-    if (e.surfaces && typeof e.surfaces === 'object') {
-      // `rounds` / `smoke` are run-level facts the cycle workflow reports alongside
-      // (never inside) `surfaces` — carry them through for the aggregate.
-      batches.push({
-        ts: e.ts || '', feature: String(e.feature), phase: String(e.phase), seconds,
-        surfaces: e.surfaces, rounds: e.rounds, smoke: e.smoke,
-      });
-    } else if (e.surface) {
-      const key = `${e.ts}|${e.feature}|${e.phase}`;
-      let b = legacy.get(key);
-      if (!b) {
-        b = { ts: e.ts || '', feature: String(e.feature), phase: String(e.phase), seconds: 0, surfaces: {} };
-        legacy.set(key, b);
-        batches.push(b);
-      }
-      b.surfaces[String(e.surface)] = e.result == null ? '' : String(e.result);
-      b.seconds = Math.max(b.seconds, seconds); // batch wall-clock = the slowest surface
-    }
-    // lines with neither `surfaces` nor `surface` are malformed → skipped
-  }
-  return batches;
-}
-
-// A surface result string counts as a failure when it is "error" or a BLOCK/REVISE verdict
-// (verdict lines look like "REVISE:2"), or a non-ok/pass word. "skipped" is neutral —
-// the cycle workflow reports smoke:SKIPPED when the human opted out, not a failure.
-function isFailure(result) {
-  const head = String(result).split(':')[0].trim().toLowerCase();
-  return head !== '' && head !== 'ok' && head !== 'ship' && head !== 'pass' && head !== 'skipped';
-}
-
-// Aggregate batches per feature (newest feature first).
-function aggregate(batches) {
-  const byFeature = new Map();
-  for (const b of batches) {
-    let f = byFeature.get(b.feature);
-    if (!f) {
-      f = {
-        feature: b.feature,
-        firstTs: b.ts, lastTs: b.ts,
-        totalSeconds: 0,
-        fixRounds: 0,
-        phases: {}, // phase → { seconds, rounds }
-        surfaces: {}, // surface → { phase → latest result }, plus failure count
-      };
-      byFeature.set(b.feature, f);
-    }
-    // The retired cycle phase reported its round count outside `surfaces` (that map is for
-    // surfaces); historical files still carry it.
-    if (b.phase === 'cycle' && Number(b.rounds) > 0) f.cycleRounds = Number(b.rounds);
-    if (b.ts && (!f.firstTs || b.ts < f.firstTs)) f.firstTs = b.ts;
-    if (b.ts && b.ts > f.lastTs) f.lastTs = b.ts;
-    f.totalSeconds += b.seconds;
-    const ph = f.phases[b.phase] || (f.phases[b.phase] = { seconds: 0, rounds: 0 });
-    ph.seconds += b.seconds;
-    ph.rounds += 1;
-    if (b.phase === 'fix') f.fixRounds += 1;
-    for (const [key, result] of Object.entries(b.surfaces)) {
-      const s = f.surfaces[key] || (f.surfaces[key] = { results: {}, failures: 0 });
-      s.results[b.phase] = result; // batches are appended in order → last write is the latest
-      if (isFailure(result)) s.failures += 1;
-    }
-  }
-  return [...byFeature.values()].sort((a, b) => (b.lastTs || '').localeCompare(a.lastTs || ''));
-}
-
-function metrics({ projectRoot, globalDir }) {
-  // The sink lives in `<state>`, which is `.claude` on a Claude install and `.cohorte` on the
-  // others. A repo driven from both has two, and the phases genuinely split across them — read
-  // every one rather than silently reporting half the spend.
-  const dirs = stateDirs(layouts({ projectRoot, globalDir }), projectRoot);
-  let raw = '';
-  for (const d of dirs) {
-    try { raw += fs.readFileSync(path.join(d, 'pipeline-metrics.jsonl'), 'utf8'); }
-    catch { /* absent in this layout */ }
-  }
-  if (!raw) return { present: false, phases: PHASES, features: [], batches: 0 };
-
-  const batches = parseBatches(raw);
-  return { present: true, phases: PHASES, features: aggregate(batches), batches: batches.length };
-}
-
-module.exports = { metrics };

package/dashboard/server/usage.js

@@ -1,61 +0,0 @@
-'use strict';
-// Serve the metrics collector's rollup (scripts/metrics/collect.mjs) to the dashboard:
-// real cost and runtime per command, read from Claude Code's own transcripts.
-//
-// This is the SECOND metrics source in the cockpit, and the two answer different questions.
-// `metrics.js` reads `.claude/pipeline-metrics.jsonl` — written by the model itself, so it
-// carries per-surface verdicts (ok / REVISE:2 / error) that only the model knows, but it
-// misses any run that ended early and can never report tokens. This one is derived from the
-// transcripts, so it is complete and exact on cost and time but knows nothing about verdicts.
-// Verdicts from one, money from the other; neither is a replacement for the other.
-//
-// The collector is ESM and this server is CommonJS, so it runs as a child process — the same
-// bridge `bin/cli.js` uses. A spawn is ~1-2s on a large history, which is why the result is
-// cached: the panel polls, and re-parsing tens of MB of transcripts on every poll would make
-// the whole cockpit feel broken.
-
-const path = require('path');
-const { spawnSync } = require('child_process');
-
-const COLLECT = path.join(__dirname, '..', '..', 'scripts', 'metrics', 'collect.mjs');
-
-// Transcripts only grow, and nobody needs sub-minute freshness on a spend figure.
-const CACHE_MS = 60_000;
-const cache = new Map(); // projectRoot → { at, value }
-
-function usage({ projectRoot, days = null, force = false }) {
-  const key = `${projectRoot}|${days || ''}`;
-  const hit = cache.get(key);
-  if (!force && hit && Date.now() - hit.at < CACHE_MS) return hit.value;
-
-  const args = [COLLECT, projectRoot, '--json'];
-  if (days) args.push(`--days=${days}`);
-
-  let value;
-  try {
-    const r = spawnSync(process.execPath, args, {
-      encoding: 'utf8',
-      // A pathological history must not wedge the cockpit's event loop forever.
-      timeout: 60_000,
-      maxBuffer: 64 * 1024 * 1024,
-    });
-    if (r.status !== 0 || !r.stdout) {
-      value = { present: false, error: (r.stderr || '').trim().split('\n').slice(-1)[0] || 'collector failed' };
-    } else {
-      const parsed = JSON.parse(r.stdout);
-      // No transcripts for this project is a normal state (a fresh checkout, or a project
-      // driven from another machine), not an error — say so rather than rendering zeros
-      // that look like "this pipeline is free".
-      value = parsed.totals && parsed.totals.sessions
-        ? { present: true, ...parsed }
-        : { present: false, error: 'no Claude Code transcripts found for this project' };
-    }
-  } catch (e) {
-    value = { present: false, error: String((e && e.message) || e) };
-  }
-
-  cache.set(key, { at: Date.now(), value });
-  return value;
-}
-
-module.exports = { usage };