@claude-flow/cli 3.11.0 → 3.12.1

package/plugins/ruflo-metaharness/scripts/_similarity.mjs

@@ -0,0 +1,161 @@
+// _similarity.mjs — ADR-152 production similarity module.
+//
+// Graduated from `_spike-similarity.mjs` (iter 35) after both invariants
+// passed on the LEGAL/SUPPORT/DEVOPS fixtures. The spike file STAYS as
+// the regression-suite anchor; this file is what production callers
+// (`similarity.mjs` skill, `metaharness_similarity` MCP tool) import.
+//
+// ADR-150 ARCHITECTURAL CONSTRAINTS PRESERVED
+//   Removable ✓  pure-TS — no `@metaharness/*` import path
+//   Optional  ✓  no new dep on `@metaharness/*`
+//   Graceful  ✓  malformed input → low-confidence output, never throws
+//   CI-gate   ✓  standalone unit-importable; no `npx` needed
+//
+// CONTRACT (PUBLIC)
+//   projectToVec(input)            → 9-dim numerical feature vector
+//   cosine(a, b)                   → [0,1]
+//   categoricalAgreement(a, b)     → [0,1] over 4 enum fields
+//   jaccard(a, b)                  → [0,1] over agent_topology[]
+//   similarity(a, b, opts?)        → { overall, components, perDimension? }
+//
+// WEIGHT DEFAULTS (from ADR-152 §Decision)
+//   overall = 0.60·cosine + 0.25·categorical + 0.15·jaccard
+//
+// ADR-152 reserves a future per-org weight override; for §3.1 the defaults
+// are global. The opts.weights hook is here so consumers can experiment
+// without forking the module — it is NOT a stable public API.
+
+const DEFAULT_WEIGHTS = Object.freeze({ cosine: 0.6, categorical: 0.25, jaccard: 0.15 });
+
+const CATEGORICAL_FIELDS = Object.freeze(['repo_type', 'archetype', 'template', 'recommendedMode']);
+
+// ─────────────────────────────────────────────────────────────────────
+// 9-dim feature vector. The mapping mirrors ADR-152 §Decision Table 1.
+// Missing fields default to 0 — that's the graceful-degradation path.
+// ─────────────────────────────────────────────────────────────────────
+
+export function projectToVec(input) {
+  const s = input?.score ?? {};
+  const g = input?.genome ?? {};
+  return [
+    (s.harnessFit ?? 0) / 100,
+    (s.compileConfidence ?? 0) / 100,
+    (s.taskCoverage ?? 0) / 100,
+    (s.toolSafety ?? 0) / 100,
+    (s.memoryUsefulness ?? 0) / 100,
+    g.risk_score ?? 0,
+    g.test_confidence ?? 0,
+    g.publish_readiness ?? 0,
+    Math.max(0, Math.min(1, Math.log10((s.estCostPerRunUsd ?? 0) + 0.001) / Math.log10(10))),
+  ];
+}
+
+export function cosine(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return 0;
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb);
+  if (denom === 0) return 0;
+  return Math.max(0, Math.min(1, dot / denom));
+}
+
+export function categoricalAgreement(a, b) {
+  let matches = 0;
+  for (const f of CATEGORICAL_FIELDS) {
+    const av = a?.genome?.[f] ?? a?.score?.[f];
+    const bv = b?.genome?.[f] ?? b?.score?.[f];
+    if (av && bv && av === bv) matches++;
+  }
+  return matches / CATEGORICAL_FIELDS.length;
+}
+
+export function jaccard(a, b) {
+  const A = new Set(a?.genome?.agent_topology ?? []);
+  const B = new Set(b?.genome?.agent_topology ?? []);
+  if (A.size === 0 && B.size === 0) return 1;
+  const intersection = [...A].filter((x) => B.has(x)).length;
+  const union = new Set([...A, ...B]).size;
+  return union === 0 ? 0 : intersection / union;
+}
+
+// ─────────────────────────────────────────────────────────────────────
+// Composite similarity with optional per-dimension breakdown.
+// Returns the ADR-152 §"return shape": overall + components + per-dim.
+// ─────────────────────────────────────────────────────────────────────
+
+export function similarity(a, b, opts = {}) {
+  const weights = { ...DEFAULT_WEIGHTS, ...(opts.weights ?? {}) };
+  const va = projectToVec(a);
+  const vb = projectToVec(b);
+  const cos = cosine(va, vb);
+  const cat = categoricalAgreement(a, b);
+  const jac = jaccard(a, b);
+
+  const overall = weights.cosine * cos + weights.categorical * cat + weights.jaccard * jac;
+
+  const result = {
+    overall: round4(overall),
+    components: {
+      cosine: round4(cos),
+      categorical: round4(cat),
+      jaccard: round4(jac),
+    },
+    weights,
+  };
+
+  if (opts.perDimension) {
+    result.perDimension = perDimensionBreakdown(a, b, va, vb, weights);
+  }
+  return result;
+}
+
+function round4(x) {
+  return Math.round(x * 10000) / 10000;
+}
+
+function perDimensionBreakdown(a, b, va, vb, weights) {
+  // Per-dimension contribution = squared-error-normalized cosine slice + categorical/jaccard direct.
+  // We surface raw a/b values + a contribution sign so callers can explain
+  // why two harnesses scored as they did (used by Recommendation Engine
+  // §3.2 confidence calc + Drift Detection §3.3 alert reason).
+  const out = {};
+
+  const numericKeys = [
+    ['harnessFit', 'score', 100], ['compileConfidence', 'score', 100],
+    ['taskCoverage', 'score', 100], ['toolSafety', 'score', 100],
+    ['memoryUsefulness', 'score', 100],
+    ['risk_score', 'genome', 1], ['test_confidence', 'genome', 1],
+    ['publish_readiness', 'genome', 1],
+    ['estCostPerRunUsd', 'score', 1],
+  ];
+  for (let i = 0; i < numericKeys.length; i++) {
+    const [k, src] = numericKeys[i];
+    const av = a?.[src]?.[k];
+    const bv = b?.[src]?.[k];
+    out[`numeric.${k}`] = {
+      a: av ?? null, b: bv ?? null,
+      contribution: round4(va[i] * vb[i] * weights.cosine / 9),
+    };
+  }
+  for (const f of CATEGORICAL_FIELDS) {
+    const av = a?.genome?.[f] ?? a?.score?.[f];
+    const bv = b?.genome?.[f] ?? b?.score?.[f];
+    out[`categorical.${f}`] = {
+      a: av ?? null, b: bv ?? null,
+      contribution: av && bv && av === bv ? round4(weights.categorical / 4) : 0,
+    };
+  }
+  const A = new Set(a?.genome?.agent_topology ?? []);
+  const B = new Set(b?.genome?.agent_topology ?? []);
+  const overlap = [...A].filter((x) => B.has(x));
+  const union = new Set([...A, ...B]);
+  out['set.agent_topology'] = {
+    a: [...A], b: [...B],
+    contribution: union.size === 0 ? 0 : round4((overlap.length / union.size) * weights.jaccard),
+  };
+  return out;
+}

package/plugins/ruflo-metaharness/scripts/_spike-similarity.mjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+// _spike-similarity.mjs — ADR-152 §"Smallest demonstrable spike" gate.
+//
+// This file is the implementation gate for ADR-152 (Genome Similarity Search).
+// Per ADR-151's scope-only constraint, ADR-152 cannot graduate to "Accepted"
+// until the two invariants below are proven by running this script.
+//
+// THE TWO INVARIANTS (from ADR-152 §"Smallest demonstrable spike")
+//   1. similarity(X, X) === 1                        (self-match exact)
+//   2. similarity(legal, devops) < similarity(legal, support)
+//                                                    (vertical-affinity correct)
+//
+// USAGE
+//   node scripts/_spike-similarity.mjs               (run + assert)
+//   node scripts/_spike-similarity.mjs --format json (CI-consumable)
+//
+// EXIT CODES
+//   0  both invariants hold
+//   1  at least one invariant fails (ADR-152 cannot graduate)
+//
+// LIFECYCLE
+// Once ADR-152 is Accepted, the full similarity implementation lands in
+// `_similarity.mjs` (production module). This file (`_spike-similarity.mjs`)
+// remains as the regression-suite anchor for the two invariants.
+
+const ARGS = (() => {
+  const a = { format: 'table' };
+  for (let i = 2; i < process.argv.length; i++) {
+    if (process.argv[i] === '--format') a.format = process.argv[++i];
+  }
+  return a;
+})();
+
+// ──────────────────────────────────────────────────────────────────────
+// THE PROPOSED IMPLEMENTATION (ADR-152 §"Decision")
+//
+// Pure-TS. Takes two {genome, score} JSON shapes; emits {overall,
+// components: {cosine, categorical, jaccard}}. The 9 numerical features +
+// 4 categorical fields + 1 set field per ADR-152.
+// ──────────────────────────────────────────────────────────────────────
+
+function projectToVec(input) {
+  const s = input.score || {};
+  const g = input.genome || {};
+  return [
+    (s.harnessFit ?? 0) / 100,
+    (s.compileConfidence ?? 0) / 100,
+    (s.taskCoverage ?? 0) / 100,
+    (s.toolSafety ?? 0) / 100,
+    (s.memoryUsefulness ?? 0) / 100,
+    g.risk_score ?? 0,
+    g.test_confidence ?? 0,
+    g.publish_readiness ?? 0,
+    // estCostPerRunUsd: log10 transform, clamped to [0, 1]
+    Math.max(0, Math.min(1, Math.log10((s.estCostPerRunUsd ?? 0) + 0.001) / Math.log10(10))),
+  ];
+}
+
+function cosine(a, b) {
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb);
+  if (denom === 0) return 0;
+  // Map cosine from [-1, 1] to [0, 1] for nonnegative vectors it's [0, 1] already
+  return Math.max(0, Math.min(1, dot / denom));
+}
+
+function categoricalAgreement(a, b) {
+  const fields = ['repo_type', 'archetype', 'template', 'recommendedMode'];
+  let matches = 0;
+  for (const f of fields) {
+    const av = a.genome?.[f] ?? a.score?.[f];
+    const bv = b.genome?.[f] ?? b.score?.[f];
+    if (av && bv && av === bv) matches++;
+  }
+  return matches / fields.length;
+}
+
+function jaccard(a, b) {
+  const A = new Set(a.genome?.agent_topology ?? []);
+  const B = new Set(b.genome?.agent_topology ?? []);
+  if (A.size === 0 && B.size === 0) return 1;
+  const intersection = [...A].filter((x) => B.has(x)).length;
+  const union = new Set([...A, ...B]).size;
+  return union === 0 ? 0 : intersection / union;
+}
+
+function similarity(a, b) {
+  const cos = cosine(projectToVec(a), projectToVec(b));
+  const cat = categoricalAgreement(a, b);
+  const jac = jaccard(a, b);
+  const overall = 0.6 * cos + 0.25 * cat + 0.15 * jac;
+  return {
+    overall: Math.round(overall * 10000) / 10000,
+    components: {
+      cosine: Math.round(cos * 10000) / 10000,
+      categorical: Math.round(cat * 10000) / 10000,
+      jaccard: Math.round(jac * 10000) / 10000,
+    },
+  };
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// THREE SYNTHETIC FIXTURES designed to exercise the invariants. These
+// mirror the JSON shapes `harness genome` + `harness score` emit (verified
+// against metaharness@0.1.14 via iter-26 test-with-openrouter.mjs).
+// ──────────────────────────────────────────────────────────────────────
+
+const LEGAL = {
+  score: {
+    harnessFit: 78, compileConfidence: 92, taskCoverage: 65,
+    toolSafety: 88, memoryUsefulness: 70, estCostPerRunUsd: 0.04,
+    recommendedMode: 'CLI + MCP', archetype: 'compliance-harness',
+    template: 'vertical:legal', scaffoldReady: true,
+  },
+  genome: {
+    repo_type: 'node_mcp_ci',
+    agent_topology: ['contract-analyst', 'redline-reviewer', 'risk-rater', 'compliance-officer'],
+    risk_score: 0.45,
+    mcp_surface: 'remote',
+    test_confidence: 0.7,
+    publish_readiness: 0.6,
+  },
+};
+
+const SUPPORT = {
+  score: {
+    harnessFit: 75, compileConfidence: 90, taskCoverage: 70,
+    toolSafety: 90, memoryUsefulness: 72, estCostPerRunUsd: 0.05,
+    recommendedMode: 'CLI + MCP', archetype: 'compliance-harness',
+    template: 'vertical:support', scaffoldReady: true,
+  },
+  genome: {
+    repo_type: 'node_mcp_ci',
+    agent_topology: ['triager', 'kb-searcher', 'responder', 'risk-rater', 'compliance-officer'],
+    risk_score: 0.40,
+    mcp_surface: 'remote',
+    test_confidence: 0.75,
+    publish_readiness: 0.65,
+  },
+};
+
+const DEVOPS = {
+  score: {
+    harnessFit: 88, compileConfidence: 95, taskCoverage: 85,
+    toolSafety: 70, memoryUsefulness: 55, estCostPerRunUsd: 0.08,
+    recommendedMode: 'CLI', archetype: 'cli-operator-harness',
+    template: 'vertical:devops', scaffoldReady: true,
+  },
+  genome: {
+    repo_type: 'python_ops',
+    agent_topology: ['incident-commander', 'deployer', 'rollback', 'oncall-pager'],
+    risk_score: 0.25,
+    mcp_surface: 'local',
+    test_confidence: 0.85,
+    publish_readiness: 0.9,
+  },
+};
+
+// ──────────────────────────────────────────────────────────────────────
+// INVARIANT VERIFICATION (the gate)
+// ──────────────────────────────────────────────────────────────────────
+
+const self = similarity(LEGAL, LEGAL);
+const legalVsSupport = similarity(LEGAL, SUPPORT);
+const legalVsDevops = similarity(LEGAL, DEVOPS);
+
+const inv1Pass = self.overall === 1;
+const inv2Pass = legalVsDevops.overall < legalVsSupport.overall;
+
+const payload = {
+  adr: 'ADR-152',
+  spike: '_spike-similarity.mjs',
+  invariants: {
+    selfMatch: { pass: inv1Pass, value: self.overall, expected: 1 },
+    verticalAffinity: {
+      pass: inv2Pass,
+      legalVsDevops: legalVsDevops.overall,
+      legalVsSupport: legalVsSupport.overall,
+      reason: inv2Pass
+        ? `legal:devops (${legalVsDevops.overall}) < legal:support (${legalVsSupport.overall}) — vertical affinity correct`
+        : `INVARIANT VIOLATED: legal:devops (${legalVsDevops.overall}) ≥ legal:support (${legalVsSupport.overall})`,
+    },
+  },
+  detail: {
+    'similarity(LEGAL, LEGAL)': self,
+    'similarity(LEGAL, SUPPORT)': legalVsSupport,
+    'similarity(LEGAL, DEVOPS)': legalVsDevops,
+  },
+  graduates: inv1Pass && inv2Pass,
+  generatedAt: new Date().toISOString(),
+};
+
+if (ARGS.format === 'json') {
+  console.log(JSON.stringify(payload, null, 2));
+} else {
+  console.log(`# ADR-152 §Spike — Genome Similarity Search\n`);
+  console.log(`Invariant 1 — selfMatch:`);
+  console.log(`  similarity(LEGAL, LEGAL).overall = ${self.overall}`);
+  console.log(`  expected: 1`);
+  console.log(`  ${inv1Pass ? '✓ PASS' : '✗ FAIL'}`);
+  console.log('');
+  console.log(`Invariant 2 — verticalAffinity (legal closer to support than to devops):`);
+  console.log(`  similarity(LEGAL, SUPPORT).overall = ${legalVsSupport.overall}`);
+  console.log(`  similarity(LEGAL, DEVOPS).overall  = ${legalVsDevops.overall}`);
+  console.log(`  ${inv2Pass ? '✓ PASS' : '✗ FAIL'} — ${payload.invariants.verticalAffinity.reason}`);
+  console.log('');
+  console.log(`Per-component breakdown:`);
+  console.log(`  LEGAL vs SUPPORT — cosine=${legalVsSupport.components.cosine}  categorical=${legalVsSupport.components.categorical}  jaccard=${legalVsSupport.components.jaccard}`);
+  console.log(`  LEGAL vs DEVOPS  — cosine=${legalVsDevops.components.cosine}  categorical=${legalVsDevops.components.categorical}  jaccard=${legalVsDevops.components.jaccard}`);
+  console.log('');
+  if (payload.graduates) {
+    console.log(`✓ Both invariants hold. ADR-152 may graduate Proposed → Accepted.`);
+  } else {
+    console.log(`✗ Invariant violation. ADR-152 stays Proposed.`);
+  }
+}
+
+if (!payload.graduates) process.exit(1);

package/plugins/ruflo-metaharness/scripts/audit-list.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+// audit-list.mjs — list timestamped oia-audit records from the
+// `metaharness-audit` memory namespace.
+//
+// The iter-7 oia-audit worker writes one record per run (keyed by ISO
+// timestamp). This script enumerates them so operators can see audit
+// cadence, spot gaps, and pick keys to feed into audit-trend.mjs.
+//
+// USAGE
+//   node scripts/audit-list.mjs                       # most recent 20
+//   node scripts/audit-list.mjs --limit 50
+//   node scripts/audit-list.mjs --format json
+//   node scripts/audit-list.mjs --since 30d           # last N days
+//
+// EXIT CODES
+//   0  ok
+//   2  config error
+
+import { spawnSync } from 'node:child_process';
+
+const NS = process.env.AUDIT_LIST_NAMESPACE || 'metaharness-audit';
+const CLI_PKG = process.env.CLI_CORE === '1'
+  ? '@claude-flow/cli-core@alpha'
+  : '@claude-flow/cli@latest';
+
+const ARGS = (() => {
+  const a = { limit: 20, since: null, format: 'table' };
+  for (let i = 2; i < process.argv.length; i++) {
+    const v = process.argv[i];
+    if (v === '--limit') a.limit = parseInt(process.argv[++i], 10);
+    else if (v === '--since') a.since = process.argv[++i];
+    else if (v === '--format') a.format = process.argv[++i];
+  }
+  return a;
+})();
+
+function parseDurationMs(spec) {
+  const m = /^(\d+)([hdwm])$/.exec(spec);
+  if (!m) return null;
+  const n = parseInt(m[1], 10);
+  const unit = { h: 3600_000, d: 86400_000, w: 7 * 86400_000, m: 30 * 86400_000 }[m[2]];
+  return unit ? n * unit : null;
+}
+
+function memList() {
+  const r = spawnSync('npx', [
+    CLI_PKG, 'memory', 'list',
+    '--namespace', NS, '--format', 'json',
+  ], { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8', shell: process.platform === 'win32' });
+  if (r.status !== 0) return [];
+  const m = /\[[\s\S]*\]/.exec(r.stdout || '');
+  if (!m) return [];
+  try { return JSON.parse(m[0]); } catch { return []; }
+}
+
+function memRetrieve(key) {
+  const r = spawnSync('npx', [
+    CLI_PKG, 'memory', 'retrieve',
+    '--namespace', NS, '--key', key,
+  ], { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8', shell: process.platform === 'win32' });
+  if (r.status !== 0) return null;
+  const m = /\{[\s\S]*\}/.exec(r.stdout || '');
+  if (!m) return null;
+  try { return JSON.parse(m[0]); } catch { return null; }
+}
+
+function main() {
+  if (!Number.isInteger(ARGS.limit) || ARGS.limit < 1) {
+    console.error(`audit-list: --limit must be a positive integer`);
+    process.exit(2);
+  }
+  let cutoffMs = null;
+  if (ARGS.since) {
+    const ms = parseDurationMs(ARGS.since);
+    if (!ms) {
+      console.error(`audit-list: --since must be N(h|d|w|m); got ${ARGS.since}`);
+      process.exit(2);
+    }
+    cutoffMs = Date.now() - ms;
+  }
+
+  const entries = memList()
+    .map((e) => e.key)
+    .filter((k) => typeof k === 'string' && k.startsWith('audit-'))
+    .sort()
+    .reverse();  // newest first (ISO keys sort lexicographically by time)
+
+  // Apply --since by parsing the timestamp out of the key.
+  const filtered = entries.filter((k) => {
+    if (!cutoffMs) return true;
+    // key shape: audit-2026-06-16T15-30-00-000Z
+    const m = /^audit-(.+)$/.exec(k);
+    if (!m) return true;
+    const isoLike = m[1].replace(/-/g, ':').replace(/^(\d{4}):(\d{2}):(\d{2})/, '$1-$2-$3');
+    const ts = Date.parse(isoLike);
+    return Number.isFinite(ts) && ts >= cutoffMs;
+  });
+
+  const slice = filtered.slice(0, ARGS.limit);
+
+  // Pull just enough fields from each record to render a compact line.
+  const rows = [];
+  for (const key of slice) {
+    const rec = memRetrieve(key);
+    if (!rec) continue;
+    rows.push({
+      key,
+      startedAt: rec.startedAt || null,
+      finishedAt: rec.finishedAt || null,
+      worst: rec.composite?.worst || null,
+      tmWorst: rec.composite?.threatModelWorst || null,
+      mcpWorst: rec.composite?.mcpScanWorst || null,
+      degraded: !!(rec.components?.oiaManifest?.degraded
+                || rec.components?.threatModel?.degraded
+                || rec.components?.mcpScan?.degraded),
+    });
+  }
+
+  const payload = {
+    namespace: NS,
+    filters: { limit: ARGS.limit, since: ARGS.since },
+    totalInNamespace: entries.length,
+    matchedSinceFilter: filtered.length,
+    returned: rows.length,
+    records: rows,
+    generatedAt: new Date().toISOString(),
+  };
+
+  if (ARGS.format === 'json') {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+
+  console.log(`# audit-list`);
+  console.log('');
+  console.log(`| Field | Value |`);
+  console.log(`|---|---:|`);
+  console.log(`| Namespace | \`${NS}\` |`);
+  console.log(`| Total records | ${entries.length} |`);
+  console.log(`| Matched filter | ${filtered.length} |`);
+  console.log(`| Showing | ${rows.length} (newest first) |`);
+  console.log('');
+  if (rows.length === 0) {
+    console.log(`_No audit records found. Run \`harness oia-audit\` to create one._`);
+    return;
+  }
+  console.log(`| Key | Started | Composite worst | Threat | MCP | Degraded |`);
+  console.log(`|---|---|:---:|:---:|:---:|:---:|`);
+  for (const r of rows) {
+    const shortKey = r.key.slice(0, 32) + (r.key.length > 32 ? '…' : '');
+    const started = r.startedAt ? r.startedAt.slice(0, 19).replace('T', ' ') : '—';
+    console.log(`| \`${shortKey}\` | ${started} | ${r.worst || '—'} | ${r.tmWorst || '—'} | ${r.mcpWorst || '—'} | ${r.degraded ? '⚠' : '✓'} |`);
+  }
+  console.log('');
+  console.log(`_Use \`audit-trend --baseline-key <a> --current-key <b>\` to diff two records._`);
+}
+
+main();