monomind 1.11.13 → 1.12.0

package/packages/@monomind/cli/dist/src/eval/dataset-manager.js

@@ -0,0 +1,107 @@
+/**
+ * DatasetManager - JSONL-based eval dataset management (Task 33)
+ */
+import { randomUUID } from 'crypto';
+import { appendFileSync, readFileSync, writeFileSync, renameSync, existsSync, statSync } from 'fs';
+import { resolve, sep } from 'path';
+import { parseJsonl } from '../utils/parse-jsonl.js';
+export class DatasetManager {
+    datasetsPath;
+    entriesPath;
+    constructor(datasetsPath, entriesPath) {
+        this.datasetsPath = datasetsPath;
+        this.entriesPath = entriesPath;
+    }
+    /**
+     * Create a dataset from a set of filtered traces.
+     */
+    createFromTraces(opts) {
+        const now = new Date().toISOString();
+        const agentSlugs = opts.agentSlugs ?? [...new Set(opts.traces.map((t) => t.agentSlug))];
+        const dataset = {
+            datasetId: randomUUID(),
+            name: opts.name,
+            description: opts.description,
+            agentSlugs,
+            createdAt: now,
+            updatedAt: now,
+            entryCount: opts.traces.length,
+        };
+        appendFileSync(this.datasetsPath, JSON.stringify(dataset) + '\n', 'utf-8');
+        for (const trace of opts.traces) {
+            const entry = {
+                entryId: randomUUID(),
+                datasetId: dataset.datasetId,
+                traceId: trace.traceId,
+                addedAt: now,
+            };
+            appendFileSync(this.entriesPath, JSON.stringify(entry) + '\n', 'utf-8');
+        }
+        return dataset;
+    }
+    /**
+     * List all datasets.
+     */
+    listDatasets() {
+        if (!existsSync(this.datasetsPath))
+            return [];
+        if (statSync(this.datasetsPath).size > 50 * 1024 * 1024) {
+            throw new Error('Dataset file exceeds 50MB — run cleanup');
+        }
+        const content = readFileSync(this.datasetsPath, 'utf-8');
+        return parseJsonl(content);
+    }
+    /**
+     * Get entries for a specific dataset.
+     */
+    getEntries(datasetId) {
+        if (!existsSync(this.entriesPath))
+            return [];
+        if (statSync(this.entriesPath).size > 50 * 1024 * 1024) {
+            throw new Error('Entries file exceeds 50MB — run cleanup');
+        }
+        const content = readFileSync(this.entriesPath, 'utf-8');
+        return parseJsonl(content).filter((e) => e.datasetId === datasetId);
+    }
+    /**
+     * Add a single trace to an existing dataset.
+     */
+    addTraceToDataset(datasetId, traceId) {
+        const entry = {
+            entryId: randomUUID(),
+            datasetId,
+            traceId,
+            addedAt: new Date().toISOString(),
+        };
+        appendFileSync(this.entriesPath, JSON.stringify(entry) + '\n', 'utf-8');
+        // Update dataset entryCount via atomic write
+        const datasets = this.listDatasets();
+        const updated = datasets.map((d) => {
+            if (d.datasetId === datasetId) {
+                return { ...d, entryCount: d.entryCount + 1, updatedAt: new Date().toISOString() };
+            }
+            return d;
+        });
+        const tmp = `${this.datasetsPath}.${randomUUID()}.tmp`;
+        writeFileSync(tmp, updated.map((d) => JSON.stringify(d)).join('\n') + '\n', 'utf-8');
+        renameSync(tmp, this.datasetsPath);
+        return entry;
+    }
+    /**
+     * Export a dataset to a JSON file. Output path must be within `allowedRoot`.
+     */
+    exportToFile(datasetId, outputPath, allowedRoot) {
+        if (allowedRoot) {
+            const resolvedOut = resolve(outputPath);
+            const resolvedRoot = resolve(allowedRoot);
+            if (!resolvedOut.startsWith(resolvedRoot + sep) && resolvedOut !== resolvedRoot) {
+                throw new Error(`Export path escapes allowed root: ${resolvedOut}`);
+            }
+        }
+        const datasets = this.listDatasets();
+        const dataset = datasets.find((d) => d.datasetId === datasetId);
+        const entries = this.getEntries(datasetId);
+        writeFileSync(outputPath, JSON.stringify({ dataset, entries }, null, 2), 'utf-8');
+    }
+}
+//# sourceMappingURL=dataset-manager.js.map

package/packages/@monomind/cli/dist/src/eval/dataset-runner.d.ts

@@ -0,0 +1,23 @@
+import type { EvalRunResult, EvalTrace } from '../../../shared/src/types/eval.js';
+export interface AgentRunnerResult {
+    agentOutput: string;
+    outcome: 'success' | 'failure' | 'timeout';
+    qualityScore: number;
+    latencyMs: number;
+}
+export interface DatasetRunOpts {
+    datasetId: string;
+    agentVersion: string;
+    traces: EvalTrace[];
+    agentRunner: (trace: EvalTrace) => Promise<AgentRunnerResult>;
+    baselineResult?: EvalRunResult;
+    regressionThreshold?: number;
+}
+export declare class DatasetRunner {
+    /**
+     * Run all traces through the agent runner and compute stats.
+     * Optionally compare against a baseline to detect regressions.
+     */
+    run(opts: DatasetRunOpts): Promise<EvalRunResult>;
+}
+//# sourceMappingURL=dataset-runner.d.ts.map

package/packages/@monomind/cli/dist/src/eval/dataset-runner.js

@@ -0,0 +1,59 @@
+/**
+ * DatasetRunner - Run eval datasets against agents and detect regressions (Task 33)
+ */
+import { randomUUID } from 'crypto';
+export class DatasetRunner {
+    /**
+     * Run all traces through the agent runner and compute stats.
+     * Optionally compare against a baseline to detect regressions.
+     */
+    async run(opts) {
+        const { datasetId, agentVersion, traces, agentRunner, baselineResult, regressionThreshold = 0.1, } = opts;
+        const results = [];
+        for (const trace of traces) {
+            const result = await agentRunner(trace);
+            results.push({ trace, result });
+        }
+        const passCount = results.filter((r) => r.result.outcome === 'success').length;
+        const failCount = results.length - passCount;
+        const totalQuality = results.reduce((sum, r) => sum + r.result.qualityScore, 0);
+        const totalLatency = results.reduce((sum, r) => sum + r.result.latencyMs, 0);
+        const avgQualityScore = results.length > 0 ? totalQuality / results.length : 0;
+        const avgLatencyMs = results.length > 0 ? totalLatency / results.length : 0;
+        // Regression detection
+        const regressionDetails = [];
+        let regressionDetected = false;
+        if (baselineResult) {
+            const delta = baselineResult.avgQualityScore - avgQualityScore;
+            if (delta > regressionThreshold) {
+                regressionDetected = true;
+                // Report per-trace regressions for traces with quality below baseline average
+                for (const { trace, result } of results) {
+                    if (result.qualityScore < baselineResult.avgQualityScore) {
+                        regressionDetails.push({
+                            traceId: trace.traceId,
+                            agentSlug: trace.agentSlug,
+                            baselineScore: baselineResult.avgQualityScore,
+                            currentScore: result.qualityScore,
+                            delta: baselineResult.avgQualityScore - result.qualityScore,
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            runId: randomUUID(),
+            datasetId,
+            runAt: new Date().toISOString(),
+            agentVersion,
+            entriesTested: results.length,
+            passCount,
+            failCount,
+            avgQualityScore,
+            avgLatencyMs,
+            regressionDetected,
+            regressionDetails,
+        };
+    }
+}
+//# sourceMappingURL=dataset-runner.js.map

package/packages/@monomind/cli/dist/src/eval/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Eval Module - Automated eval dataset from production traces (Task 33)
+ */
+export { TraceCollector } from './trace-collector.js';
+export type { RecordTraceInput } from './trace-collector.js';
+export { DatasetManager } from './dataset-manager.js';
+export type { CreateFromTracesOpts } from './dataset-manager.js';
+export { DatasetRunner } from './dataset-runner.js';
+export type { AgentRunnerResult, DatasetRunOpts } from './dataset-runner.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/eval/index.js

@@ -0,0 +1,7 @@
+/**
+ * Eval Module - Automated eval dataset from production traces (Task 33)
+ */
+export { TraceCollector } from './trace-collector.js';
+export { DatasetManager } from './dataset-manager.js';
+export { DatasetRunner } from './dataset-runner.js';
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/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/packages/@monomind/cli/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/packages/@monomind/cli/dist/src/index.js

@@ -4,7 +4,7 @@
  *
  * github.com/monoes/monomind
  */
-import { readFileSync } from 'fs';
+import { readFileSync, statSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { commandParser } from './parser.js';
@@ -19,6 +19,9 @@ function getPackageVersion() {
         const __dirname = dirname(__filename);
         // Navigate from dist/src to package root
         const pkgPath = join(__dirname, '..', '..', 'package.json');
+        // Guard: skip if package.json is unexpectedly large (> 1 MB)
+        if (statSync(pkgPath).size > 1024 * 1024)
+            return '3.0.0';
         const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
         return pkg.version || '3.0.0';
     }
@@ -458,10 +461,11 @@ export class CLI {
         catch { /* optional — registry build failures must never block startup */ }
         // Task 04: CapabilityMetadata — validate agent registry at startup
         try {
-            const { readFileSync, existsSync } = await import('fs');
+            const { readFileSync, existsSync, statSync: statSyncReg } = await import('fs');
             const { join: pathJoin } = await import('path');
             const registryPath = pathJoin(process.cwd(), '.monomind', 'registry.json');
-            if (existsSync(registryPath)) {
+            const MAX_REGISTRY_BYTES = 10 * 1024 * 1024; // 10 MB
+            if (existsSync(registryPath) && statSyncReg(registryPath).size <= MAX_REGISTRY_BYTES) {
                 const registry = JSON.parse(readFileSync(registryPath, 'utf-8'));
                 const entries = registry.agents ?? [];
                 const issues = [];

package/packages/@monomind/cli/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