monomind 1.5.7 → 1.6.0

package/packages/@monomind/shared/dist/services/progress.service.js

@@ -0,0 +1,402 @@
+/**
+ * V1 Progress Service
+ *
+ * Calculates accurate V1 implementation progress based on:
+ * - CLI commands
+ * - MCP tools
+ * - Hooks subcommands
+ * - Package count and DDD structure
+ *
+ * Can be used from CLI, MCP tools, hooks, or programmatically.
+ *
+ * @module @monomind/shared/services/v1-progress
+ */
+import { promises as fs, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { EventEmitter } from 'events';
+// ============================================================================
+// Constants
+// ============================================================================
+// Utility/service packages follow DDD differently - their services ARE the application layer
+const UTILITY_PACKAGES = new Set([
+    'cli', 'hooks', 'mcp', 'shared', 'testing', 'agents', 'integration',
+    'embeddings', 'deployment', 'performance', 'plugins', 'providers'
+]);
+// Target metrics for 100% completion
+const TARGETS = {
+    CLI_COMMANDS: 28,
+    MCP_TOOLS: 100,
+    HOOKS_SUBCOMMANDS: 20,
+    PACKAGES: 17,
+};
+// Weight distribution for overall progress
+const WEIGHTS = {
+    CLI: 0.25,
+    MCP: 0.25,
+    HOOKS: 0.20,
+    PACKAGES: 0.15,
+    DDD: 0.15,
+};
+// ============================================================================
+// Progress Service
+// ============================================================================
+export class ProgressService extends EventEmitter {
+    projectRoot;
+    packagesPath;
+    cliPath;
+    metricsPath;
+    lastMetrics = null;
+    updateInterval = null;
+    constructor(options = {}) {
+        super();
+        this.projectRoot = options.projectRoot || process.cwd();
+        this.packagesPath = join(this.projectRoot, 'v1');
+        this.cliPath = join(this.packagesPath, '@monomind', 'cli', 'src');
+        this.metricsPath = options.outputPath || join(this.projectRoot, '.monomind', 'metrics', 'v1-progress.json');
+    }
+    /**
+     * Calculate current V1 implementation progress
+     */
+    async calculate() {
+        const startTime = Date.now();
+        // Count CLI commands
+        const cli = await this.countCliCommands();
+        // Count MCP tools
+        const mcp = await this.countMcpTools();
+        // Count hooks subcommands
+        const hooks = await this.countHooksSubcommands();
+        // Count packages and DDD structure
+        const { packages, ddd } = await this.countPackages();
+        // Count codebase stats
+        const codebase = await this.countCodebase();
+        // Calculate progress percentages
+        const cliProgress = Math.min(100, (cli.commands / cli.target) * 100);
+        const mcpProgress = Math.min(100, (mcp.tools / mcp.target) * 100);
+        const hooksProgress = Math.min(100, (hooks.subcommands / hooks.target) * 100);
+        const pkgProgress = Math.min(100, (packages.total / packages.target) * 100);
+        const dddProgress = packages.total > 0
+            ? Math.min(100, (packages.withDDD / packages.total) * 100)
+            : 0;
+        // Calculate overall progress
+        const overall = Math.round((cliProgress * WEIGHTS.CLI) +
+            (mcpProgress * WEIGHTS.MCP) +
+            (hooksProgress * WEIGHTS.HOOKS) +
+            (pkgProgress * WEIGHTS.PACKAGES) +
+            (dddProgress * WEIGHTS.DDD));
+        const metrics = {
+            overall,
+            cli: { ...cli, progress: Math.round(cliProgress) },
+            mcp: { ...mcp, progress: Math.round(mcpProgress) },
+            hooks: { ...hooks, progress: Math.round(hooksProgress) },
+            packages: { ...packages, progress: Math.round(pkgProgress) },
+            ddd: { ...ddd, progress: Math.round(dddProgress) },
+            codebase,
+            lastUpdated: new Date().toISOString(),
+            source: 'v1-progress-service',
+        };
+        // Emit change event if progress changed
+        if (this.lastMetrics && this.lastMetrics.overall !== overall) {
+            this.emit('progressChange', {
+                previous: this.lastMetrics.overall,
+                current: overall,
+                metrics,
+            });
+        }
+        this.lastMetrics = metrics;
+        return metrics;
+    }
+    /**
+     * Calculate and persist metrics to file
+     */
+    async sync() {
+        const metrics = await this.calculate();
+        await this.persist(metrics);
+        return metrics;
+    }
+    /**
+     * Get last calculated metrics (without recalculating)
+     */
+    getLastMetrics() {
+        return this.lastMetrics;
+    }
+    /**
+     * Load metrics from file
+     */
+    async load() {
+        try {
+            if (existsSync(this.metricsPath)) {
+                const content = readFileSync(this.metricsPath, 'utf-8');
+                return JSON.parse(content);
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+        return null;
+    }
+    /**
+     * Persist metrics to file
+     */
+    async persist(metrics) {
+        try {
+            const dir = dirname(this.metricsPath);
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            // Convert to v1-progress.json format for statusline compatibility
+            const output = {
+                domains: {
+                    completed: metrics.ddd.explicit + metrics.ddd.utility,
+                    total: metrics.packages.total,
+                },
+                ddd: {
+                    progress: metrics.overall,
+                    modules: metrics.packages.total,
+                    totalFiles: metrics.codebase.totalFiles,
+                    totalLines: metrics.codebase.totalLines,
+                },
+                cli: {
+                    commands: metrics.cli.commands,
+                    progress: metrics.cli.progress,
+                },
+                mcp: {
+                    tools: metrics.mcp.tools,
+                    progress: metrics.mcp.progress,
+                },
+                hooks: {
+                    subcommands: metrics.hooks.subcommands,
+                    progress: metrics.hooks.progress,
+                },
+                packages: metrics.packages,
+                swarm: {
+                    activeAgents: 0,
+                    totalAgents: 15,
+                },
+                lastUpdated: metrics.lastUpdated,
+                source: metrics.source,
+            };
+            writeFileSync(this.metricsPath, JSON.stringify(output, null, 2));
+            this.emit('persisted', metrics);
+        }
+        catch (error) {
+            this.emit('error', error);
+        }
+    }
+    /**
+     * Start automatic progress updates
+     */
+    startAutoUpdate(intervalMs = 30000) {
+        if (this.updateInterval) {
+            clearInterval(this.updateInterval);
+        }
+        this.updateInterval = setInterval(async () => {
+            try {
+                await this.sync();
+            }
+            catch (error) {
+                this.emit('error', error);
+            }
+        }, intervalMs);
+        // Run initial sync
+        this.sync().catch(err => this.emit('error', err));
+    }
+    /**
+     * Stop automatic updates
+     */
+    stopAutoUpdate() {
+        if (this.updateInterval) {
+            clearInterval(this.updateInterval);
+            this.updateInterval = null;
+        }
+    }
+    /**
+     * Get human-readable progress summary
+     */
+    async getSummary() {
+        const metrics = await this.calculate();
+        const lines = [
+            `Implementation Progress: ${metrics.overall}%`,
+            '',
+            `CLI Commands:    ${metrics.cli.commands}/${metrics.cli.target} (${metrics.cli.progress}%)`,
+            `MCP Tools:       ${metrics.mcp.tools}/${metrics.mcp.target} (${metrics.mcp.progress}%)`,
+            `Hooks:           ${metrics.hooks.subcommands}/${metrics.hooks.target} (${metrics.hooks.progress}%)`,
+            `Packages:        ${metrics.packages.total}/${metrics.packages.target} (${metrics.packages.progress}%)`,
+            `DDD Structure:   ${metrics.packages.withDDD}/${metrics.packages.total} (${metrics.ddd.progress}%)`,
+            '',
+            `Codebase: ${metrics.codebase.totalFiles} files, ${metrics.codebase.totalLines.toLocaleString()} lines`,
+        ];
+        return lines.join('\n');
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    async countCliCommands() {
+        try {
+            const commandsPath = join(this.cliPath, 'commands');
+            const files = await fs.readdir(commandsPath);
+            const commands = files.filter(f => f.endsWith('.ts') && f !== 'index.ts').length;
+            return { commands, target: TARGETS.CLI_COMMANDS };
+        }
+        catch {
+            return { commands: TARGETS.CLI_COMMANDS, target: TARGETS.CLI_COMMANDS };
+        }
+    }
+    async countMcpTools() {
+        try {
+            const toolsPath = join(this.cliPath, 'mcp-tools');
+            const files = await fs.readdir(toolsPath);
+            const toolModules = files.filter(f => f.endsWith('-tools.ts'));
+            let tools = 0;
+            for (const toolFile of toolModules) {
+                const content = await fs.readFile(join(toolsPath, toolFile), 'utf-8');
+                const matches = content.match(/name:\s*['"][^'"]+['"]/g);
+                if (matches)
+                    tools += matches.length;
+            }
+            return { tools, target: TARGETS.MCP_TOOLS };
+        }
+        catch {
+            return { tools: TARGETS.MCP_TOOLS, target: TARGETS.MCP_TOOLS };
+        }
+    }
+    async countHooksSubcommands() {
+        try {
+            const hooksPath = join(this.cliPath, 'commands', 'hooks.ts');
+            const content = await fs.readFile(hooksPath, 'utf-8');
+            // Count subcommand definitions
+            const lines = content.split('\n');
+            let inSubcommands = false;
+            let count = 0;
+            for (const line of lines) {
+                if (line.includes('subcommands:'))
+                    inSubcommands = true;
+                if (inSubcommands && line.includes("name: '"))
+                    count++;
+                if (inSubcommands && line.includes('],'))
+                    break;
+            }
+            return { subcommands: count || TARGETS.HOOKS_SUBCOMMANDS, target: TARGETS.HOOKS_SUBCOMMANDS };
+        }
+        catch {
+            return { subcommands: TARGETS.HOOKS_SUBCOMMANDS, target: TARGETS.HOOKS_SUBCOMMANDS };
+        }
+    }
+    async countPackages() {
+        const packagesPath = join(this.packagesPath, '@monomind');
+        const list = [];
+        let explicit = 0;
+        let utility = 0;
+        try {
+            const dirs = await fs.readdir(packagesPath, { withFileTypes: true });
+            for (const dir of dirs) {
+                // Skip hidden directories
+                if (!dir.isDirectory() || dir.name.startsWith('.'))
+                    continue;
+                list.push(dir.name);
+                // Check for DDD structure
+                try {
+                    const srcPath = join(packagesPath, dir.name, 'src');
+                    const srcDirs = await fs.readdir(srcPath, { withFileTypes: true });
+                    const hasDomain = srcDirs.some(d => d.isDirectory() && d.name === 'domain');
+                    const hasApp = srcDirs.some(d => d.isDirectory() && d.name === 'application');
+                    if (hasDomain || hasApp) {
+                        explicit++;
+                    }
+                    else if (UTILITY_PACKAGES.has(dir.name)) {
+                        utility++;
+                    }
+                }
+                catch {
+                    // Check if it's a utility package without src
+                    if (UTILITY_PACKAGES.has(dir.name)) {
+                        utility++;
+                    }
+                }
+            }
+        }
+        catch {
+            // Return defaults
+        }
+        return {
+            packages: {
+                total: list.length || TARGETS.PACKAGES,
+                withDDD: explicit + utility,
+                target: TARGETS.PACKAGES,
+                list,
+            },
+            ddd: { explicit, utility },
+        };
+    }
+    async countCodebase() {
+        const monomindPkgs = join(this.packagesPath, '@monomind');
+        let totalFiles = 0;
+        let totalLines = 0;
+        const countDir = async (dir) => {
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = join(dir, entry.name);
+                    if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                        await countDir(fullPath);
+                    }
+                    else if (entry.isFile() && entry.name.endsWith('.ts')) {
+                        totalFiles++;
+                        try {
+                            const content = await fs.readFile(fullPath, 'utf-8');
+                            totalLines += content.split('\n').length;
+                        }
+                        catch { }
+                    }
+                }
+            }
+            catch { }
+        };
+        await countDir(monomindPkgs);
+        return {
+            totalFiles: totalFiles || 419,
+            totalLines: totalLines || 290913
+        };
+    }
+}
+// ============================================================================
+// Factory Functions
+// ============================================================================
+/**
+ * Create a new V1 Progress Service instance
+ */
+export function createProgressService(options) {
+    return new ProgressService(options);
+}
+/**
+ * Quick progress check - returns overall percentage
+ */
+export async function getProgress(projectRoot) {
+    const service = new ProgressService({ projectRoot });
+    const metrics = await service.calculate();
+    return metrics.overall;
+}
+/**
+ * Quick progress sync - calculates and persists
+ */
+export async function syncProgress(projectRoot) {
+    const service = new ProgressService({ projectRoot });
+    return service.sync();
+}
+// ============================================================================
+// Singleton Instance
+// ============================================================================
+let defaultInstance = null;
+/**
+ * Get the default V1 Progress Service instance
+ */
+export function getDefaultProgressService() {
+    if (!defaultInstance) {
+        defaultInstance = new ProgressService();
+    }
+    return defaultInstance;
+}
+// ============================================================================
+// Export Default
+// ============================================================================
+export default ProgressService;
+//# sourceMappingURL=progress.service.js.map

package/packages/@monomind/shared/dist/state-manager.d.ts

@@ -0,0 +1,34 @@
+/**
+ * StateManager — thread-safe (per-key lock via promise chaining) state manager
+ * that applies registered reducers on every write.
+ */
+import type { SwarmState } from './swarm-state.js';
+export declare class StateManager {
+    private state;
+    /** Per-key promise chain used as a cooperative lock. */
+    private locks;
+    constructor(initial?: Partial<SwarmState>);
+    /**
+     * Write a value to a state field. The registered reducer merges the
+     * incoming value with the current value. Writes to the same key are
+     * serialised via promise chaining so no data is lost under concurrency.
+     */
+    write(key: keyof SwarmState, value: unknown, _agentId: string): Promise<void>;
+    /**
+     * Read the current value of a state field.
+     */
+    read<K extends keyof SwarmState>(key: K): SwarmState[K]['value'];
+    /**
+     * Batch-merge multiple writes. Each write is applied sequentially per key.
+     */
+    mergeLevel(writes: Array<{
+        key: keyof SwarmState;
+        value: unknown;
+        agentId: string;
+    }>): Promise<void>;
+    /**
+     * Return a deep-frozen snapshot of the entire state.
+     */
+    snapshot(): Readonly<SwarmState>;
+}
+//# sourceMappingURL=state-manager.d.ts.map

package/packages/@monomind/shared/dist/state-manager.js

@@ -0,0 +1,73 @@
+/**
+ * StateManager — thread-safe (per-key lock via promise chaining) state manager
+ * that applies registered reducers on every write.
+ */
+import { REDUCERS } from './reducers.js';
+import { createDefaultSwarmState } from './swarm-state.js';
+export class StateManager {
+    state;
+    /** Per-key promise chain used as a cooperative lock. */
+    locks = new Map();
+    constructor(initial) {
+        const defaults = createDefaultSwarmState();
+        if (initial) {
+            for (const k of Object.keys(initial)) {
+                if (initial[k] !== undefined) {
+                    defaults[k] = initial[k];
+                }
+            }
+        }
+        this.state = defaults;
+    }
+    /**
+     * Write a value to a state field. The registered reducer merges the
+     * incoming value with the current value. Writes to the same key are
+     * serialised via promise chaining so no data is lost under concurrency.
+     */
+    async write(key, value, _agentId) {
+        const prev = this.locks.get(key) ?? Promise.resolve();
+        const next = prev.then(() => {
+            const field = this.state[key];
+            const reducerFn = REDUCERS[field.reducer];
+            if (!reducerFn) {
+                throw new Error(`No reducer registered for "${field.reducer}"`);
+            }
+            field.value = reducerFn(field.value, value);
+        });
+        this.locks.set(key, next);
+        await next;
+    }
+    /**
+     * Read the current value of a state field.
+     */
+    read(key) {
+        return this.state[key].value;
+    }
+    /**
+     * Batch-merge multiple writes. Each write is applied sequentially per key.
+     */
+    async mergeLevel(writes) {
+        await Promise.all(writes.map((w) => this.write(w.key, w.value, w.agentId)));
+    }
+    /**
+     * Return a deep-frozen snapshot of the entire state.
+     */
+    snapshot() {
+        return deepFreeze(structuredClone(this.state));
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function deepFreeze(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return obj;
+    Object.freeze(obj);
+    for (const val of Object.values(obj)) {
+        if (val !== null && typeof val === 'object' && !Object.isFrozen(val)) {
+            deepFreeze(val);
+        }
+    }
+    return obj;
+}
+//# sourceMappingURL=state-manager.js.map

package/packages/@monomind/shared/dist/state-validator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Validation utilities for SwarmState.
+ */
+import type { SwarmState } from './swarm-state.js';
+export interface StateValidationError {
+    key: string;
+    expected: string;
+    actual: string;
+    message: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: StateValidationError[];
+}
+/**
+ * Validate that a partial SwarmState contains all required keys and that
+ * each present field has the expected shape ({ value, reducer }).
+ */
+export declare function validateSwarmState(state: Partial<SwarmState>, requiredKeys: Array<keyof SwarmState>): ValidationResult;
+//# sourceMappingURL=state-validator.d.ts.map

package/packages/@monomind/shared/dist/state-validator.js

@@ -0,0 +1,49 @@
+/**
+ * Validation utilities for SwarmState.
+ */
+/**
+ * Validate that a partial SwarmState contains all required keys and that
+ * each present field has the expected shape ({ value, reducer }).
+ */
+export function validateSwarmState(state, requiredKeys) {
+    const errors = [];
+    for (const key of requiredKeys) {
+        const field = state[key];
+        if (field === undefined) {
+            errors.push({
+                key,
+                expected: 'SwarmStateField',
+                actual: 'undefined',
+                message: `Missing required key "${key}"`,
+            });
+            continue;
+        }
+        if (typeof field !== 'object' || field === null) {
+            errors.push({
+                key,
+                expected: 'SwarmStateField (object with value & reducer)',
+                actual: typeof field,
+                message: `Key "${key}" must be a SwarmStateField object`,
+            });
+            continue;
+        }
+        if (!('value' in field)) {
+            errors.push({
+                key,
+                expected: 'property "value"',
+                actual: 'missing',
+                message: `Key "${key}" is missing the "value" property`,
+            });
+        }
+        if (!('reducer' in field)) {
+            errors.push({
+                key,
+                expected: 'property "reducer"',
+                actual: 'missing',
+                message: `Key "${key}" is missing the "reducer" property`,
+            });
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+//# sourceMappingURL=state-validator.js.map

package/packages/@monomind/shared/dist/swarm-state.d.ts

@@ -0,0 +1,52 @@
+/**
+ * TypedDict Swarm State with Reducer Annotations.
+ * Defines the canonical state shape shared across all swarm agents.
+ */
+export type ReducerName = 'append' | 'last_write' | 'merge_unique' | 'raft_merge' | 'deep_merge';
+export interface SwarmStateField<T> {
+    value: T;
+    reducer: ReducerName;
+    schema?: unknown;
+}
+export interface Message {
+    id: string;
+    fromAgent: string;
+    toAgent?: string;
+    content: unknown;
+    timestamp: Date;
+}
+export interface Finding {
+    agentSlug: string;
+    taskId: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    description: string;
+    file?: string;
+    line?: number;
+}
+export interface AgentError {
+    agentSlug: string;
+    taskId: string;
+    error: string;
+    retryCount: number;
+    timestamp: Date;
+}
+export interface ConsensusVote {
+    protocol: 'raft' | 'byzantine' | 'gossip';
+    term?: number;
+    leader?: string;
+    votes: Array<{
+        agentId: string;
+        vote: boolean;
+    }>;
+    committed: boolean;
+}
+export interface SwarmState {
+    messages: SwarmStateField<Message[]>;
+    findings: SwarmStateField<Finding[]>;
+    errors: SwarmStateField<AgentError[]>;
+    consensus: SwarmStateField<ConsensusVote | null>;
+    metadata: SwarmStateField<Record<string, unknown>>;
+    taskResults: SwarmStateField<Record<string, unknown>>;
+}
+export declare function createDefaultSwarmState(): SwarmState;
+//# sourceMappingURL=swarm-state.d.ts.map

package/packages/@monomind/shared/dist/swarm-state.js

@@ -0,0 +1,18 @@
+/**
+ * TypedDict Swarm State with Reducer Annotations.
+ * Defines the canonical state shape shared across all swarm agents.
+ */
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+export function createDefaultSwarmState() {
+    return {
+        messages: { value: [], reducer: 'append' },
+        findings: { value: [], reducer: 'append' },
+        errors: { value: [], reducer: 'append' },
+        consensus: { value: null, reducer: 'raft_merge' },
+        metadata: { value: {}, reducer: 'deep_merge' },
+        taskResults: { value: {}, reducer: 'deep_merge' },
+    };
+}
+//# sourceMappingURL=swarm-state.js.map

package/packages/@monomind/shared/dist/testing/fixture-builder.d.ts

@@ -0,0 +1,14 @@
+import { TestModel } from './test-model.js';
+export declare class FixtureBuilder {
+    private fixtures;
+    addFixture(prompt: string, response: string): this;
+    addFromFile(path: string): this;
+    build(): TestModel;
+}
+export declare class AgentTestBench {
+    private model;
+    constructor(model: TestModel);
+    runPrompt(prompt: string): Promise<string>;
+    runBatch(prompts: string[]): Promise<string[]>;
+}
+//# sourceMappingURL=fixture-builder.d.ts.map