@monoes/monomindcli 1.11.12 → 1.11.13

package/dist/src/eval/trace-collector.d.ts

@@ -0,0 +1,40 @@
+import type { EvalTrace } from '../../../shared/src/types/eval.js';
+export interface RecordTraceInput {
+    agentSlug: string;
+    agentVersion: string;
+    taskDescription: string;
+    taskInput: string;
+    agentOutput: string;
+    retryCount: number;
+    qualityScore?: number;
+    outcome: 'success' | 'failure' | 'timeout';
+    latencyMs: number;
+    tokenCount?: number;
+    costUsd?: number;
+    correctedOutput?: string;
+}
+export declare class TraceCollector {
+    private filePath;
+    constructor(filePath: string);
+    /**
+     * Determine auto review status based on trace quality signals.
+     */
+    autoReviewStatus(input: RecordTraceInput): 'pending' | 'approved';
+    /**
+     * Auto-generate tags based on trace characteristics.
+     */
+    autoTag(input: RecordTraceInput): string[];
+    /**
+     * Record a trace, auto-generating traceId, capturedAt, reviewStatus, and tags.
+     */
+    record(input: RecordTraceInput): EvalTrace;
+    /**
+     * Read all traces from the JSONL file.
+     */
+    readAll(): EvalTrace[];
+    /**
+     * Get traces pending review, with optional limit.
+     */
+    getTracesPendingReview(limit?: number): EvalTrace[];
+}
+//# sourceMappingURL=trace-collector.d.ts.map

package/dist/src/eval/trace-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-collector.d.ts","sourceRoot":"","sources":["../../../src/eval/trace-collector.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAGnE,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,EAAE,MAAM;IAI5B;;OAEG;IACH,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,GAAG,SAAS,GAAG,UAAU;IAOjE;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,EAAE;IAQ1C;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,gBAAgB,GAAG,SAAS;IAsC1C;;OAEG;IACH,OAAO,IAAI,SAAS,EAAE;IAWtB;;OAEG;IACH,sBAAsB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,EAAE;CAKpD"}

package/dist/src/eval/trace-collector.js

@@ -0,0 +1,102 @@
+/**
+ * TraceCollector - JSONL-based production trace collection (Task 33)
+ */
+import { randomUUID } from 'crypto';
+import { appendFileSync, readFileSync, existsSync, statSync } from 'fs';
+import { parseJsonl } from '../utils/parse-jsonl.js';
+export class TraceCollector {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    /**
+     * Determine auto review status based on trace quality signals.
+     */
+    autoReviewStatus(input) {
+        if (input.retryCount > 1)
+            return 'pending';
+        if (input.qualityScore !== undefined && input.qualityScore < 0.6)
+            return 'pending';
+        if (input.outcome === 'failure')
+            return 'pending';
+        return 'approved';
+    }
+    /**
+     * Auto-generate tags based on trace characteristics.
+     */
+    autoTag(input) {
+        const tags = [];
+        if (input.retryCount > 1)
+            tags.push('high-retry');
+        if (input.outcome === 'failure')
+            tags.push('failure');
+        if (input.outcome === 'timeout')
+            tags.push('timeout');
+        return tags;
+    }
+    /**
+     * Record a trace, auto-generating traceId, capturedAt, reviewStatus, and tags.
+     */
+    record(input) {
+        const trace = {
+            traceId: randomUUID(),
+            agentSlug: input.agentSlug,
+            agentVersion: input.agentVersion,
+            taskDescription: input.taskDescription,
+            taskInput: input.taskInput,
+            agentOutput: input.agentOutput,
+            retryCount: input.retryCount,
+            qualityScore: input.qualityScore,
+            outcome: input.outcome,
+            latencyMs: input.latencyMs,
+            tokenCount: input.tokenCount,
+            costUsd: input.costUsd,
+            capturedAt: new Date().toISOString(),
+            reviewStatus: this.autoReviewStatus(input),
+            correctedOutput: input.correctedOutput,
+            tags: this.autoTag(input),
+        };
+        // Defensive serialization — agent outputs may contain circular references
+        // or BigInt; without this guard the writer crashes mid-trace.
+        let serialized;
+        try {
+            serialized = JSON.stringify(trace);
+        }
+        catch {
+            serialized = JSON.stringify({
+                traceId: trace.traceId,
+                agentSlug: trace.agentSlug,
+                capturedAt: trace.capturedAt,
+                reviewStatus: trace.reviewStatus,
+                outcome: 'serialize_failed',
+            });
+        }
+        appendFileSync(this.filePath, serialized + '\n', 'utf-8');
+        return trace;
+    }
+    /**
+     * Read all traces from the JSONL file.
+     */
+    readAll() {
+        if (!existsSync(this.filePath))
+            return [];
+        const stat = statSync(this.filePath);
+        if (stat.size > 256 * 1024 * 1024) {
+            throw new Error(`Trace file exceeds 256MB (${stat.size} bytes). Run rotation/cleanup.`);
+        }
+        const content = readFileSync(this.filePath, 'utf-8').trim();
+        if (!content)
+            return [];
+        return parseJsonl(content);
+    }
+    /**
+     * Get traces pending review, with optional limit.
+     */
+    getTracesPendingReview(limit) {
+        const all = this.readAll().filter((t) => t.reviewStatus === 'pending');
+        if (limit !== undefined)
+            return all.slice(0, limit);
+        return all;
+    }
+}
+//# sourceMappingURL=trace-collector.js.map

package/dist/src/eval/trace-collector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-collector.js","sourceRoot":"","sources":["../../../src/eval/trace-collector.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AAExE,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAiBrD,MAAM,OAAO,cAAc;IACjB,QAAQ,CAAS;IAEzB,YAAY,QAAgB;QAC1B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,gBAAgB,CAAC,KAAuB;QACtC,IAAI,KAAK,CAAC,UAAU,GAAG,CAAC;YAAE,OAAO,SAAS,CAAC;QAC3C,IAAI,KAAK,CAAC,YAAY,KAAK,SAAS,IAAI,KAAK,CAAC,YAAY,GAAG,GAAG;YAAE,OAAO,SAAS,CAAC;QACnF,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QAClD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,KAAuB;QAC7B,MAAM,IAAI,GAAa,EAAE,CAAC;QAC1B,IAAI,KAAK,CAAC,UAAU,GAAG,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAClD,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACtD,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACtD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAuB;QAC5B,MAAM,KAAK,GAAc;YACvB,OAAO,EAAE,UAAU,EAAE;YACrB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,YAAY,EAAE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC;YAC1C,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;SAC1B,CAAC;QAEF,0EAA0E;QAC1E,8DAA8D;QAC9D,IAAI,UAAkB,CAAC;QACvB,IAAI,CAAC;YACH,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACrC,CAAC;QAAC,MAAM,CAAC;YACP,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC;gBAC1B,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,OAAO,EAAE,kBAAkB;aAC5B,CAAC,CAAC;QACL,CAAC;QACD,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,IAAI,EAAE,OAAO,CAAC,CAAC;QAC1D,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,OAAO;QACL,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC;YAAE,OAAO,EAAE,CAAC;QAC1C,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACrC,IAAI,IAAI,CAAC,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,6BAA6B,IAAI,CAAC,IAAI,gCAAgC,CAAC,CAAC;QAC1F,CAAC;QACD,MAAM,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC;QAC5D,IAAI,CAAC,OAAO;YAAE,OAAO,EAAE,CAAC;QACxB,OAAO,UAAU,CAAY,OAAO,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,sBAAsB,CAAC,KAAc;QACnC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC;QACvE,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QACpD,OAAO,GAAG,CAAC;IACb,CAAC;CACF"}

package/dist/src/graph/enrich.mjs

@@ -0,0 +1,362 @@
+// post-build knowledge graph enrichment engine
+// Reads graph.json, enriches nodes with TypeScript AST data, resolves
+// cross-module calls, computes PageRank + eigenvector centrality,
+// then writes graph.enriched.json.
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// packages/@monomind/cli/dist/src/graph/ → 6 levels up → project root
+const projectRoot = path.resolve(__dirname, '../../../../../..');
+const _require = createRequire(path.join(projectRoot, 'package.json'));
+
+// ── dependencies ──────────────────────────────────────────────────────────
+
+let ts;
+try { ts = _require('typescript'); }
+catch { ts = _require(path.join(projectRoot, 'node_modules/typescript/lib/typescript.js')); }
+
+function findPnpmPkg(name) {
+  const pnpmDir = path.join(projectRoot, 'node_modules', '.pnpm');
+  if (!fs.existsSync(pnpmDir)) return null;
+  const prefix = name.replace('/', '+') + '@';
+  const entries = fs.readdirSync(pnpmDir).filter(e => e.startsWith(prefix)).sort().reverse();
+  return entries.length ? path.join(pnpmDir, entries[0], 'node_modules', name) : null;
+}
+
+function loadGraphology() {
+  for (const fn of [() => _require('graphology'), () => _require(findPnpmPkg('graphology'))]) {
+    try { const m = fn(); return m.default ?? m; } catch {}
+  }
+  throw new Error('graphology not found');
+}
+
+function loadGraphologyMetrics() {
+  const base = findPnpmPkg('graphology-metrics') ?? path.join(projectRoot, 'node_modules/graphology-metrics');
+  return {
+    assignPageRank: _require(path.join(base, 'centrality/pagerank')).assign,
+    assignEigen: _require(path.join(base, 'centrality/eigenvector')).assign,
+  };
+}
+
+// ── cache ─────────────────────────────────────────────────────────────────
+
+const sha256 = str => crypto.createHash('sha256').update(str).digest('hex');
+const cacheFileFor = (fp, dir) => path.join(dir, sha256(fp) + '.json');
+
+function readFromCache(filePath, cacheDir) {
+  try {
+    const cf = cacheFileFor(filePath, cacheDir);
+    if (fs.statSync(cf).mtimeMs >= fs.statSync(filePath).mtimeMs)
+      return JSON.parse(fs.readFileSync(cf, 'utf8'));
+  } catch {}
+  return null;
+}
+
+function writeToCache(filePath, data, cacheDir) {
+  try {
+    fs.mkdirSync(cacheDir, { recursive: true });
+    fs.writeFileSync(cacheFileFor(filePath, cacheDir), JSON.stringify(data));
+  } catch {}
+}
+
+// ── TypeScript AST extraction ─────────────────────────────────────────────
+
+function getJsDoc(node, sf) {
+  try {
+    return (ts.getJSDocCommentsAndTags(node) ?? [])
+      .filter(t => ts.isJSDoc(t))
+      .map(t => typeof t.comment === 'string' ? t.comment : '')
+      .join('\n').trim();
+  } catch { return ''; }
+}
+
+const getParams = (node, sf) => (node.parameters ?? []).map(p => ({
+  name: p.name?.getText(sf) ?? '', type: p.type?.getText(sf) ?? 'any', optional: !!p.questionToken,
+}));
+
+const buildSig = (params, ret) => {
+  const ps = params.map(p => `${p.name}${p.optional ? '?' : ''}: ${p.type}`).join(', ');
+  return `(${ps})${ret ? ': ' + ret : ''}`;
+};
+
+const isExported = node => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export);
+const lineOf = (node, sf) => sf.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+
+function extractSymbolsFromAst(filePath, content) {
+  const sf = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+  const symbols = new Map();
+
+  function visit(node) {
+    try {
+      if (ts.isFunctionDeclaration(node) && node.name) {
+        const params = getParams(node, sf); const ret = node.type?.getText(sf) ?? '';
+        symbols.set(node.name.getText(sf), { kind: 'function', signature: buildSig(params, ret),
+          parameters: params, returnType: ret, isExported: isExported(node),
+          documentation: getJsDoc(node, sf), lineStart: lineOf(node, sf) });
+      } else if (ts.isClassDeclaration(node) && node.name) {
+        const name = node.name.getText(sf);
+        const heritage = (node.heritageClauses ?? []).flatMap(c => c.types.map(t => t.expression.getText(sf)));
+        const methods = (node.members ?? []).filter(m => ts.isMethodDeclaration(m) && m.name).map(m => {
+          const mp = getParams(m, sf); const mr = m.type?.getText(sf) ?? '';
+          return { name: m.name.getText(sf), signature: buildSig(mp, mr), documentation: getJsDoc(m, sf) };
+        });
+        symbols.set(name, { kind: 'class', signature: name + (heritage.length ? ' extends ' + heritage[0] : ''),
+          parameters: [], returnType: '', isExported: isExported(node),
+          documentation: getJsDoc(node, sf), lineStart: lineOf(node, sf), heritage, methods });
+      } else if (ts.isInterfaceDeclaration(node) && node.name) {
+        const name = node.name.getText(sf);
+        symbols.set(name, { kind: 'interface', signature: name, parameters: [], returnType: '',
+          isExported: isExported(node), documentation: getJsDoc(node, sf), lineStart: lineOf(node, sf) });
+      } else if (ts.isTypeAliasDeclaration(node) && node.name) {
+        const name = node.name.getText(sf);
+        symbols.set(name, { kind: 'type', signature: name, parameters: [], returnType: '',
+          isExported: isExported(node), documentation: getJsDoc(node, sf), lineStart: lineOf(node, sf) });
+      } else if (ts.isVariableStatement(node)) {
+        const exp = isExported(node);
+        for (const decl of node.declarationList.declarations) {
+          if (decl.name && decl.initializer &&
+              (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+            const params = getParams(decl.initializer, sf); const ret = decl.initializer.type?.getText(sf) ?? '';
+            symbols.set(decl.name.getText(sf), { kind: 'variable', signature: buildSig(params, ret),
+              parameters: params, returnType: ret, isExported: exp,
+              documentation: getJsDoc(node, sf), lineStart: lineOf(node, sf) });
+          }
+        }
+      }
+    } catch {}
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sf, visit);
+  return symbols;
+}
+
+function extractImportMap(filePath, content) {
+  const sf = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+  const importMap = new Map();
+  function visit(node) {
+    if (ts.isImportDeclaration(node)) {
+      try {
+        const spec = node.moduleSpecifier.getText(sf).replace(/^['"]|['"]$/g, '');
+        if (!spec.startsWith('.')) return; // skip node_modules
+        const resolved = resolveRelativeImport(spec, filePath);
+        if (!resolved) return;
+        const clause = node.importClause;
+        if (!clause) return;
+        if (clause.name) importMap.set(clause.name.getText(sf), resolved);
+        const b = clause.namedBindings;
+        if (b) {
+          if (ts.isNamespaceImport(b)) importMap.set(b.name.getText(sf), resolved);
+          else if (ts.isNamedImports(b)) for (const el of b.elements) importMap.set(el.name.getText(sf), resolved);
+        }
+      } catch {}
+    }
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sf, visit);
+  return importMap;
+}
+
+function resolveRelativeImport(spec, fromFile) {
+  const base = path.resolve(path.dirname(fromFile), spec);
+  const exts = ['.ts', '.tsx', '.js', '.mjs', '.cjs'];
+  if (fs.existsSync(base) && fs.statSync(base).isFile()) return base;
+  for (const ext of exts) if (fs.existsSync(base + ext)) return base + ext;
+  for (const ext of exts) { const c = path.join(base, 'index' + ext); if (fs.existsSync(c)) return c; }
+  return null;
+}
+
+// ── regex fallback ────────────────────────────────────────────────────────
+
+function extractSymbolsRegex(content) {
+  const symbols = new Map(); let m;
+  const fn = /export\s+(async\s+)?function\s+(\w+)\(([^)]*)\)/g;
+  while ((m = fn.exec(content)) !== null) {
+    const params = m[3].trim() ? m[3].trim().split(',').map(p => ({ name: p.trim(), type: 'any', optional: false })) : [];
+    symbols.set(m[2], { kind: 'function', signature: buildSig(params, ''), parameters: params,
+      returnType: '', isExported: true, documentation: '', lineStart: 0 });
+  }
+  const cl = /export\s+class\s+(\w+)/g;
+  while ((m = cl.exec(content)) !== null)
+    symbols.set(m[1], { kind: 'class', signature: m[1], parameters: [], returnType: '',
+      isExported: true, documentation: '', lineStart: 0 });
+  return symbols;
+}
+
+// ── per-file extraction ───────────────────────────────────────────────────
+
+const MAX_TS_SIZE = 500 * 1024;
+
+function extractFile(filePath, cacheDir) {
+  const cached = readFromCache(filePath, cacheDir);
+  if (cached) return { symbols: new Map(Object.entries(cached.symbols)), importMap: new Map(Object.entries(cached.importMap)) };
+
+  let content;
+  try { content = fs.readFileSync(filePath, 'utf8'); } catch { return { symbols: new Map(), importMap: new Map() }; }
+
+  const isTs = /\.[cm]?ts$|\.tsx$/.test(filePath);
+  let symbols, importMap = new Map();
+  if (isTs && content.length <= MAX_TS_SIZE) {
+    try { symbols = extractSymbolsFromAst(filePath, content); importMap = extractImportMap(filePath, content); }
+    catch { symbols = extractSymbolsRegex(content); }
+  } else {
+    symbols = extractSymbolsRegex(content);
+  }
+  writeToCache(filePath, { symbols: Object.fromEntries(symbols), importMap: Object.fromEntries(importMap) }, cacheDir);
+  return { symbols, importMap };
+}
+
+// ── main ──────────────────────────────────────────────────────────────────
+
+export async function enrichGraph(projectDir, options = {}) {
+  const graphDir = options.graphDir ?? path.join(projectDir, '.monomind', 'graph');
+  const verbose = options.verbose ?? false;
+  const forceRebuild = options.forceRebuild ?? false;
+  const cacheDir = path.join(graphDir, 'cache', 'symbols');
+
+  const graphPath = path.join(graphDir, 'graph.json');
+  if (!fs.existsSync(graphPath)) throw new Error(`graph.json not found at ${graphPath}`);
+  const rawGraph = JSON.parse(fs.readFileSync(graphPath, 'utf8'));
+  const nodes = rawGraph.nodes ?? [];
+  const links = rawGraph.links ?? rawGraph.edges ?? [];
+
+  // Phase 1+2: extract symbols + import maps per unique source file
+  const uniqueFiles = [...new Set(nodes.map(n => n.sourceFile).filter(Boolean))];
+  const symbolCache = new Map(), importCache = new Map();
+  let filesProcessed = 0;
+  for (const fp of uniqueFiles) {
+    if (forceRebuild) { try { fs.unlinkSync(cacheFileFor(fp, cacheDir)); } catch {} }
+    const { symbols, importMap } = extractFile(fp, cacheDir);
+    symbolCache.set(fp, symbols); importCache.set(fp, importMap);
+    filesProcessed++;
+    if (filesProcessed % 100 === 0 || verbose) {
+      console.log(`[enrich] processed ${filesProcessed}/${uniqueFiles.length} files (${Math.round(filesProcessed / uniqueFiles.length * 100)}%)`);
+    }
+  }
+
+  // Phase 3: enrich nodes
+  let enrichedCount = 0;
+  const enrichedNodes = nodes.map(node => {
+    const n = { ...node, inDegree: 0, outDegree: 0 };
+    const info = symbolCache.get(n.sourceFile)?.get(n.label) ?? symbolCache.get(n.sourceFile)?.get(n.id);
+    if (info) {
+      Object.assign(n, { kind: info.kind, signature: info.signature, parameters: info.parameters,
+        returnType: info.returnType, isExported: info.isExported, documentation: info.documentation });
+      enrichedCount++;
+    }
+    return n;
+  });
+
+  // Phase 4: resolve call/import edges to cross-module links
+  const nodeById = new Map(enrichedNodes.map(n => [n.id, n]));
+  const nodesByFile = new Map();
+  for (const n of enrichedNodes) {
+    if (!n.sourceFile) continue;
+    if (!nodesByFile.has(n.sourceFile)) nodesByFile.set(n.sourceFile, []);
+    nodesByFile.get(n.sourceFile).push(n);
+  }
+
+  // Walk importCache directly: sourceFile → (importedSymbol → resolvedAbsolutePath).
+  // This avoids the graph.json edge format mismatch where link.source is a short filename/path
+  // rather than a symbol-name node ID, which caused resolvedCallEdges: 0 when iterating links.
+  //
+  // One edge per (sourceFile → target node) — not one per source symbol. Fanning out to all
+  // N nodes in a file per import inflates edge counts by O(N) and corrupts PageRank.
+  // We use the first node in the file as a stable representative for the file-level dependency.
+  const resolvedLinks = []; const seenEdgeKeys = new Set();
+  for (const [sourceFile, symbolMap] of importCache) {
+    const fileNodes = nodesByFile.get(sourceFile) ?? [];
+    if (!fileNodes.length) continue;
+    const repNode = fileNodes[0]; // representative node for this source file
+    for (const [symbolName, resolvedPath] of symbolMap) {
+      const candidates = nodesByFile.get(resolvedPath) ?? [];
+      // Prefer a node in the target file whose label/id matches the imported symbol name
+      const tgt = candidates.find(n => n.label === symbolName || n.id === symbolName) ?? candidates[0];
+      if (!tgt) continue;
+      if (repNode.id === tgt.id) continue; // skip self-edges
+      // Deduplicate by (sourceFile, tgt.id) — one edge per file-level import relationship
+      const key = `${sourceFile}:${tgt.id}`;
+      if (seenEdgeKeys.has(key)) continue;
+      seenEdgeKeys.add(key);
+      resolvedLinks.push({ source: repNode.id, target: tgt.id, relation: 'calls_module',
+        confidence: 'INFERRED', weight: 1, resolvedFrom: symbolName });
+    }
+  }
+
+  // Phase 5: degree counts.
+  // Raw graph.json links use filename paths as link.source, not symbol IDs, so nodeById
+  // lookups on raw links return undefined. Only resolvedLinks have symbol-name IDs on both
+  // ends and reliably hit nodeById.
+  const allEdges = [...links, ...resolvedLinks];
+  for (const link of resolvedLinks) {
+    const s = nodeById.get(link.source); const t = nodeById.get(link.target);
+    if (s) s.outDegree++; if (t) t.inDegree++;
+  }
+
+  // Phase 6: PageRank + eigenvector centrality
+  const Graph = loadGraphology();
+  const { assignPageRank, assignEigen } = loadGraphologyMetrics();
+  const G = new Graph({ type: 'directed', multi: false });
+  for (const n of enrichedNodes) G.addNode(n.id, { ...n });
+  // Guard both endpoints: raw links have filename paths as source which are not graph nodes.
+  for (const link of allEdges) {
+    try {
+      if (G.hasNode(link.source) && G.hasNode(link.target))
+        G.addEdge(link.source, link.target, { weight: link.weight ?? 1 });
+    } catch {}
+  }
+
+  let pageRankComputed = false, centralityComputed = false;
+  try { assignPageRank(G, { alpha: 0.85, maxIterations: 100, tolerance: 1e-6 }); pageRankComputed = true; }
+  catch (e) { console.warn('[enrich] PageRank failed:', e.message); }
+  try { assignEigen(G, { maxIterations: 500, tolerance: 1e-4, normalize: true }); centralityComputed = true; }
+  catch (e) { console.warn('[enrich] Eigenvector centrality skipped (disconnected graph):', e.message); }
+
+  // Map graphology attr names (pagerank, eigenvectorCentrality) to output (pageRank, centrality)
+  G.forEachNode((id, attrs) => {
+    const n = nodeById.get(id); if (!n) return;
+    n.pageRank = attrs.pagerank ?? 0; n.centrality = attrs.eigenvectorCentrality ?? 0;
+  });
+
+  // Phase 7: write graph.enriched.json
+  const metrics = { totalNodes: enrichedNodes.length, enrichedNodes: enrichedCount,
+    totalEdges: allEdges.length, analyzedEdges: G.size,
+    resolvedCallEdges: resolvedLinks.length, pageRankComputed, centralityComputed };
+  const output = { version: '1.0.0', builtAt: rawGraph.builtAt ?? 0, projectPath: projectDir,
+    enrichedAt: Date.now(), nodes: enrichedNodes, links: allEdges, metrics };
+  const outputPath = path.join(graphDir, 'graph.enriched.json');
+  fs.writeFileSync(outputPath, JSON.stringify(output, null, 2));
+  console.log(`[enrich] wrote ${outputPath}`);
+
+  // Update stats.json
+  const statsPath = path.join(graphDir, 'stats.json');
+  try {
+    const stats = fs.existsSync(statsPath) ? JSON.parse(fs.readFileSync(statsPath, 'utf8')) : {};
+    stats.enrichedAt = Date.now(); stats.enrichedNodes = enrichedCount;
+    fs.writeFileSync(statsPath, JSON.stringify(stats, null, 2));
+  } catch {}
+
+  return { enrichedNodes, resolvedEdges: resolvedLinks, metrics };
+}
+
+// ── CLI entrypoint ────────────────────────────────────────────────────────
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const projectDir = process.argv[2];
+  if (!projectDir) {
+    console.error('Usage: node enrich.mjs <project-dir> [--graph-dir <dir>] [--verbose] [--force]');
+    process.exit(1);
+  }
+  const args = process.argv.slice(3);
+  const opts = { verbose: args.includes('--verbose'), forceRebuild: args.includes('--force') };
+  const gdIdx = args.indexOf('--graph-dir');
+  if (gdIdx !== -1 && args[gdIdx + 1]) opts.graphDir = args[gdIdx + 1];
+  enrichGraph(path.resolve(projectDir), opts)
+    .then(({ metrics }) => console.log('[enrich] done:', JSON.stringify(metrics, null, 2)))
+    .catch(err => { console.error('[enrich] fatal:', err.message); process.exit(1); });
+}

package/dist/src/infrastructure/in-memory-repositories.d.ts

@@ -0,0 +1,68 @@
+/**
+ * In-Memory Repositories - CLI Infrastructure
+ *
+ * Lightweight in-memory implementations for CLI use.
+ *
+ * @module v1/cli/infrastructure
+ */
+import { Agent, AgentStatus, AgentRole } from '../../../swarm/src/domain/entities/agent.js';
+import { Task, TaskStatus, TaskPriority } from '../../../swarm/src/domain/entities/task.js';
+import { IAgentRepository, AgentQueryOptions, AgentStatistics } from '../../../swarm/src/domain/repositories/agent-repository.interface.js';
+import { ITaskRepository, TaskQueryOptions, TaskStatistics } from '../../../swarm/src/domain/repositories/task-repository.interface.js';
+/**
+ * In-Memory Agent Repository
+ */
+export declare class InMemoryAgentRepository implements IAgentRepository {
+    private agents;
+    private initialized;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    clear(): Promise<void>;
+    save(agent: Agent): Promise<void>;
+    findById(id: string): Promise<Agent | null>;
+    findByName(name: string): Promise<Agent | null>;
+    delete(id: string): Promise<boolean>;
+    exists(id: string): Promise<boolean>;
+    saveMany(agents: Agent[]): Promise<void>;
+    findByIds(ids: string[]): Promise<Agent[]>;
+    deleteMany(ids: string[]): Promise<number>;
+    findAll(options?: AgentQueryOptions): Promise<Agent[]>;
+    findByStatus(status: AgentStatus): Promise<Agent[]>;
+    findByRole(role: AgentRole): Promise<Agent[]>;
+    findByDomain(domain: string): Promise<Agent[]>;
+    findByParent(parentId: string): Promise<Agent[]>;
+    findByCapability(capability: string): Promise<Agent[]>;
+    findAvailable(): Promise<Agent[]>;
+    getStatistics(): Promise<AgentStatistics>;
+    count(options?: AgentQueryOptions): Promise<number>;
+}
+/**
+ * In-Memory Task Repository
+ */
+export declare class InMemoryTaskRepository implements ITaskRepository {
+    private tasks;
+    private initialized;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    clear(): Promise<void>;
+    save(task: Task): Promise<void>;
+    findById(id: string): Promise<Task | null>;
+    delete(id: string): Promise<boolean>;
+    exists(id: string): Promise<boolean>;
+    saveMany(tasks: Task[]): Promise<void>;
+    findByIds(ids: string[]): Promise<Task[]>;
+    deleteMany(ids: string[]): Promise<number>;
+    findAll(options?: TaskQueryOptions): Promise<Task[]>;
+    findByStatus(status: TaskStatus): Promise<Task[]>;
+    findByPriority(priority: TaskPriority): Promise<Task[]>;
+    findByAgent(agentId: string): Promise<Task[]>;
+    findPending(): Promise<Task[]>;
+    findQueued(): Promise<Task[]>;
+    findRunning(): Promise<Task[]>;
+    findTimedOut(): Promise<Task[]>;
+    getNextTask(agentCapabilities?: string[]): Promise<Task | null>;
+    getTaskQueue(limit?: number): Promise<Task[]>;
+    getStatistics(): Promise<TaskStatistics>;
+    count(options?: TaskQueryOptions): Promise<number>;
+}
+//# sourceMappingURL=in-memory-repositories.d.ts.map

package/dist/src/infrastructure/in-memory-repositories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-repositories.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/in-memory-repositories.ts"],"names":[],"mappings":"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"}