monomind 2.7.11 → 2.7.13

package/packages/@monomind/cli/dist/src/commands/tokens.js

@@ -1,206 +0,0 @@
-/**
- * Monomind Tokens Command
- * Token usage tracking and visualization — powered by token-tracker.cjs
- */
-import { output } from '../output.js';
-import { createRequire } from 'module';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { existsSync } from 'fs';
-function getTrackerPath() {
-    const __dirname = dirname(fileURLToPath(import.meta.url));
-    // The CLI package ships its own copy of token-tracker.cjs at the package
-    // root: from dist/src/commands/tokens.js, that's 3 levels up
-    // (dist/src/commands -> dist/src -> dist -> package root), then
-    // .claude/helpers/token-tracker.cjs. Verified empirically — do not "fix"
-    // this by guessing a different depth without re-checking the build output.
-    const bundled = join(__dirname, '..', '..', '..', '.claude', 'helpers', 'token-tracker.cjs');
-    if (existsSync(bundled))
-        return bundled;
-    // Fall back to a copy in the user's own project (e.g. a stripped install
-    // that dropped .claude/helpers, or a monorepo checkout like this one where
-    // the user's cwd has its own tracker copy).
-    const cwdCopy = join(process.cwd(), '.claude', 'helpers', 'token-tracker.cjs');
-    if (existsSync(cwdCopy))
-        return cwdCopy;
-    return null;
-}
-function loadTracker() {
-    const trackerPath = getTrackerPath();
-    if (!trackerPath) {
-        throw new Error('token-tracker.cjs not found (checked bundled package copy and cwd/.claude/helpers)');
-    }
-    const require = createRequire(import.meta.url);
-    return require(trackerPath);
-}
-const VALID_PERIODS = new Set(['today', 'week', '30days', 'month']);
-function validatePeriod(raw) {
-    const s = typeof raw === 'string' ? raw : 'today';
-    return VALID_PERIODS.has(s) ? s : 'today';
-}
-const dashboardSubcommand = {
-    name: 'dashboard',
-    description: 'Launch interactive token usage dashboard',
-    options: [
-        { name: 'period', short: 'p', type: 'string', description: 'Time period: today|week|30days|month', default: 'today' },
-        { name: 'no-interactive', type: 'boolean', description: 'Render once and exit', default: false },
-    ],
-    action: async (ctx) => {
-        const period = validatePeriod(ctx.flags['period']);
-        const noInteractive = ctx.flags['no-interactive'];
-        try {
-            const tracker = loadTracker();
-            if (noInteractive) {
-                tracker.renderDashboard(period);
-            }
-            else {
-                tracker.runInteractive();
-            }
-            return { success: true };
-        }
-        catch (err) {
-            output.error('Token tracker not available: ' + (err instanceof Error ? err.message : String(err)));
-            return { success: false, message: 'Token tracker unavailable' };
-        }
-    },
-};
-const summarySubcommand = {
-    name: 'summary',
-    description: 'Show token usage summary for a period',
-    options: [
-        { name: 'period', short: 'p', type: 'string', description: 'Time period: today|week|30days|month', default: 'today' },
-        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
-    ],
-    action: async (ctx) => {
-        const period = validatePeriod(ctx.flags['period']);
-        const asJson = ctx.flags['json'];
-        try {
-            const tracker = loadTracker();
-            const range = tracker.getDateRange(period);
-            const projects = tracker.parseAllSessions(range.start, range.end);
-            if (asJson) {
-                output.writeln(JSON.stringify(projects, null, 2));
-                return { success: true, data: projects };
-            }
-            const totalCost = projects.reduce((s, p) => s + p.totalCost, 0);
-            const totalCalls = projects.reduce((s, p) => s + p.totalApiCalls, 0);
-            output.writeln('');
-            output.writeln(`Token Usage — ${period}`);
-            output.writeln('─'.repeat(50));
-            output.writeln(`Total Cost:  ${tracker.fmt$(totalCost)}`);
-            output.writeln(`API Calls:   ${totalCalls}`);
-            output.writeln(`Projects:    ${projects.length}`);
-            output.writeln('');
-            for (const p of projects.slice(0, 10)) {
-                const name = p.projectPath.split('/').pop() || p.projectPath;
-                output.writeln(`  ${name.padEnd(30)} ${tracker.fmt$(p.totalCost).padStart(10)}  ${p.totalApiCalls} calls`);
-            }
-            output.writeln('');
-            return { success: true, data: { totalCost, totalCalls, projects } };
-        }
-        catch (err) {
-            output.error('Token tracker not available: ' + (err instanceof Error ? err.message : String(err)));
-            return { success: false, message: 'Token tracker unavailable' };
-        }
-    },
-};
-const todaySubcommand = {
-    name: 'today',
-    description: 'Quick today/month token usage summary',
-    options: [],
-    action: async (_ctx) => {
-        try {
-            const tracker = loadTracker();
-            const summary = tracker.quickSummary();
-            output.writeln(summary || 'No token data available for today.');
-            return { success: true };
-        }
-        catch (err) {
-            output.error('Token tracker not available: ' + (err instanceof Error ? err.message : String(err)));
-            return { success: false };
-        }
-    },
-};
-const leanDeltaSubcommand = {
-    name: 'lean-delta',
-    description: 'Compare token cost: sessions with monolean active vs without',
-    options: [],
-    action: async (_ctx) => {
-        try {
-            const { join: pathJoin, dirname: pathDirname } = await import('path');
-            const { fileURLToPath } = await import('url');
-            const { readdirSync, readFileSync } = await import('fs');
-            // Locate capture directory
-            const __dirname = pathDirname(fileURLToPath(import.meta.url));
-            const projectRoot = pathJoin(__dirname, '..', '..', '..', '..', '..', '..');
-            const captureDir = pathJoin(projectRoot, '.monomind', 'capture');
-            // Load all run capture logs
-            let snapshots = [];
-            try {
-                const orgsDir = pathJoin(projectRoot, '.monomind', 'orgs');
-                const orgEntries = readdirSync(orgsDir, { withFileTypes: true });
-                for (const org of orgEntries) {
-                    if (!org.isDirectory())
-                        continue;
-                    const runsDir = pathJoin(orgsDir, org.name, 'runs');
-                    try {
-                        const runFiles = readdirSync(runsDir).filter(f => f.endsWith('-captures.jsonl'));
-                        for (const rf of runFiles) {
-                            const lines = readFileSync(pathJoin(runsDir, rf), 'utf8').split('\n').filter(Boolean);
-                            for (const line of lines) {
-                                try {
-                                    snapshots.push(JSON.parse(line));
-                                }
-                                catch { /* skip */ }
-                            }
-                        }
-                    }
-                    catch { /* no runs dir */ }
-                }
-            }
-            catch { /* no orgs dir */ }
-            // Also check snap files in capture dir for leanMode field
-            try {
-                const snapFiles = readdirSync(captureDir).filter(f => f.startsWith('snap-') && f.endsWith('.json'));
-                for (const sf of snapFiles) {
-                    try {
-                        snapshots.push(JSON.parse(readFileSync(pathJoin(captureDir, sf), 'utf8')));
-                    }
-                    catch { /* skip */ }
-                }
-            }
-            catch { /* no capture dir */ }
-            const lean = snapshots.filter(s => s.leanMode && s.leanMode !== 'off' && s.cost_usd != null);
-            const normal = snapshots.filter(s => (!s.leanMode || s.leanMode === 'off') && s.cost_usd != null);
-            if (lean.length < 3 || normal.length < 3) {
-                output.writeln('Not enough data yet. Need 3+ sessions in each group.');
-                output.writeln(`Current: ${lean.length} lean sessions, ${normal.length} normal sessions.`);
-                return { success: true };
-            }
-            const avg = (arr) => arr.reduce((s, x) => s + (x.cost_usd || 0), 0) / arr.length;
-            const leanAvg = avg(lean);
-            const normalAvg = avg(normal);
-            const delta = ((leanAvg - normalAvg) / normalAvg * 100).toFixed(1);
-            const sign = leanAvg <= normalAvg ? '' : '+';
-            output.writeln('');
-            output.writeln('Monolean Token Delta');
-            output.writeln('─'.repeat(50));
-            output.writeln(`Sessions with monolean: ${lean.length.toString().padStart(4)}   avg cost: $${leanAvg.toFixed(4)}`);
-            output.writeln(`Sessions without:       ${normal.length.toString().padStart(4)}   avg cost: $${normalAvg.toFixed(4)}`);
-            output.writeln(`delta: ${sign}${delta}%`);
-            output.writeln('');
-            return { success: true, data: { leanSessions: lean.length, normalSessions: normal.length, leanAvg, normalAvg, deltaPct: parseFloat(delta) } };
-        }
-        catch (err) {
-            output.error('lean-delta error: ' + (err instanceof Error ? err.message : String(err)));
-            return { success: false };
-        }
-    },
-};
-export const tokensCommand = {
-    name: 'tokens',
-    description: 'Token usage tracking and cost visualization',
-    subcommands: [dashboardSubcommand, summarySubcommand, todaySubcommand, leanDeltaSubcommand],
-};
-export default tokensCommand;
-//# sourceMappingURL=tokens.js.map

package/packages/@monomind/cli/dist/src/commands/update.d.ts

@@ -1,8 +0,0 @@
-/**
- * CLI Update Command
- * Auto-update system for @monomind packages (ADR-025)
- */
-import type { Command } from '../types.js';
-declare const updateCommand: Command;
-export default updateCommand;
-//# sourceMappingURL=update.d.ts.map

package/packages/@monomind/cli/dist/src/commands/update.js

@@ -1,288 +0,0 @@
-/**
- * CLI Update Command
- * Auto-update system for @monomind packages (ADR-025)
- */
-import { output } from '../output.js';
-import { checkForUpdates, getInstalledVersion, DEFAULT_CONFIG, } from '../update/checker.js';
-import { executeMultipleUpdates, rollbackUpdate, getUpdateHistory, clearHistory, } from '../update/executor.js';
-import { clearCache } from '../update/rate-limiter.js';
-// Helper functions
-function formatUpdateType(type) {
-    switch (type) {
-        case 'major':
-            return output.error('MAJOR');
-        case 'minor':
-            return output.warning('minor');
-        case 'patch':
-            return output.success('patch');
-        default:
-            return type;
-    }
-}
-function formatPriority(priority) {
-    switch (priority) {
-        case 'critical':
-            return output.error('CRITICAL');
-        case 'high':
-            return output.warning('high');
-        case 'normal':
-            return output.info('normal');
-        case 'low':
-            return output.dim('low');
-        default:
-            return priority;
-    }
-}
-// Subcommand: check
-const checkCommand = {
-    name: 'check',
-    description: 'Check for available @monomind package updates',
-    options: [
-        { name: 'force', description: 'Force check (ignore rate limit)', type: 'boolean' },
-        { name: 'json', description: 'Output as JSON', type: 'boolean' },
-    ],
-    async action(ctx) {
-        const { flags } = ctx;
-        if (flags.force) {
-            process.env.MONOMIND_FORCE_UPDATE = 'true';
-        }
-        try {
-            const { results, skipped, reason } = await checkForUpdates(DEFAULT_CONFIG);
-            if (skipped) {
-                output.printInfo(`Update check skipped: ${reason}`);
-                output.writeln('Use --force to check anyway');
-                return { success: true };
-            }
-            if (flags.json) {
-                console.log(JSON.stringify(results, null, 2));
-                return { success: true };
-            }
-            if (results.length === 0) {
-                output.printSuccess('All @monomind packages are up to date!');
-                return { success: true };
-            }
-            output.writeln();
-            output.writeln(output.highlight('═══ Available Updates ═══'));
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'package', header: 'Package' },
-                    { key: 'current', header: 'Current' },
-                    { key: 'latest', header: 'Latest' },
-                    { key: 'type', header: 'Type' },
-                    { key: 'priority', header: 'Priority' },
-                    { key: 'auto', header: 'Auto' },
-                ],
-                data: results.map((r) => ({
-                    package: r.package,
-                    current: r.currentVersion,
-                    latest: output.highlight(r.latestVersion),
-                    type: formatUpdateType(r.updateType),
-                    priority: formatPriority(r.priority),
-                    auto: r.shouldAutoUpdate ? output.success('yes') : output.dim('no'),
-                })),
-            });
-            output.writeln();
-            const autoUpdates = results.filter((r) => r.shouldAutoUpdate);
-            const manualUpdates = results.filter((r) => !r.shouldAutoUpdate);
-            if (autoUpdates.length > 0) {
-                output.printInfo(`${autoUpdates.length} update(s) will be applied automatically on next startup`);
-            }
-            if (manualUpdates.length > 0) {
-                output.writeln();
-                output.printInfo('To update manually, run:');
-                output.writeln('  monomind update all');
-            }
-            return { success: true };
-        }
-        finally {
-            delete process.env.MONOMIND_FORCE_UPDATE;
-        }
-    },
-};
-// Subcommand: all
-const allCommand = {
-    name: 'all',
-    description: 'Update all @monomind packages',
-    options: [
-        { name: 'dry-run', description: 'Show what would be updated', type: 'boolean' },
-        { name: 'include-major', description: 'Include major version updates', type: 'boolean' },
-    ],
-    async action(ctx) {
-        const { flags } = ctx;
-        process.env.MONOMIND_FORCE_UPDATE = 'true';
-        try {
-            output.printInfo('Checking for updates...');
-            const config = {
-                ...DEFAULT_CONFIG,
-                autoUpdate: {
-                    patch: true,
-                    minor: true,
-                    major: flags['include-major'] || false,
-                },
-            };
-            const { results } = await checkForUpdates(config);
-            if (results.length === 0) {
-                output.printSuccess('All packages are up to date!');
-                return { success: true };
-            }
-            // Get installed packages
-            const installedPackages = {};
-            for (const update of results) {
-                const version = getInstalledVersion(update.package);
-                if (version) {
-                    installedPackages[update.package] = version;
-                }
-            }
-            output.printInfo(`Updating ${results.length} package(s)...`);
-            const updateResults = await executeMultipleUpdates(results, installedPackages, flags['dry-run']);
-            const successful = updateResults.filter((r) => r.success);
-            const failed = updateResults.filter((r) => !r.success);
-            output.writeln();
-            output.writeln(output.highlight(flags['dry-run'] ? '═══ Dry Run - Would Update ═══' : '═══ Update Results ═══'));
-            output.writeln();
-            if (successful.length > 0) {
-                output.printSuccess(`${successful.length} package(s) ${flags['dry-run'] ? 'would be ' : ''}updated:`);
-                for (const r of successful) {
-                    output.writeln(`  ${output.success('✓')} ${r.package}@${r.version}`);
-                }
-            }
-            if (failed.length > 0) {
-                output.writeln();
-                output.printError(`${failed.length} package(s) failed:`);
-                for (const r of failed) {
-                    // Sanitize error: strip filesystem paths and cap length before display
-                    const safeErr = typeof r.error === 'string'
-                        ? r.error.replace(/\/[^\s:]+(\/|(?=\s|:|$))/g, '<path>/').slice(0, 200)
-                        : 'update failed';
-                    output.writeln(`  ${output.error('✗')} ${r.package}: ${safeErr}`);
-                }
-            }
-            return { success: failed.length === 0 };
-        }
-        finally {
-            delete process.env.MONOMIND_FORCE_UPDATE;
-        }
-    },
-};
-// Subcommand: history
-const historyCommand = {
-    name: 'history',
-    description: 'View update history',
-    options: [
-        { name: 'limit', short: 'n', description: 'Number of entries', type: 'string', default: '20' },
-        { name: 'json', description: 'Output as JSON', type: 'boolean' },
-        { name: 'clear', description: 'Clear history', type: 'boolean' },
-    ],
-    async action(ctx) {
-        const { flags } = ctx;
-        if (flags.clear) {
-            clearHistory();
-            output.printSuccess('Update history cleared');
-            return { success: true };
-        }
-        const rawLimit = parseInt(flags.limit || '20', 10);
-        // Cap to prevent unbounded history reads
-        const limit = Number.isFinite(rawLimit) ? Math.max(1, Math.min(rawLimit, 1000)) : 20;
-        const history = getUpdateHistory(limit);
-        if (history.length === 0) {
-            output.printInfo('No update history available');
-            return { success: true };
-        }
-        if (flags.json) {
-            console.log(JSON.stringify(history, null, 2));
-            return { success: true };
-        }
-        output.writeln();
-        output.writeln(output.highlight('═══ Update History ═══'));
-        output.writeln();
-        output.printTable({
-            columns: [
-                { key: 'time', header: 'Time' },
-                { key: 'package', header: 'Package' },
-                { key: 'from', header: 'From' },
-                { key: 'to', header: 'To' },
-                { key: 'status', header: 'Status' },
-            ],
-            data: history.map((h) => ({
-                time: new Date(h.timestamp).toLocaleString(),
-                package: h.package,
-                from: h.fromVersion,
-                to: h.toVersion,
-                status: h.success ? output.success('success') : output.error('failed'),
-            })),
-        });
-        return { success: true };
-    },
-};
-// Subcommand: rollback
-const rollbackCommand = {
-    name: 'rollback',
-    description: 'Rollback last update',
-    options: [
-        { name: 'package', short: 'p', description: 'Specific package to rollback', type: 'string' },
-    ],
-    async action(ctx) {
-        const { flags } = ctx;
-        // Cap packageName to 200 chars — npm package names are at most 214 chars
-        // (npm spec), but a malicious value could otherwise flow into rollbackUpdate
-        // which may reflect it in error messages or use it to key lookup tables.
-        const rawPackageName = flags.package;
-        const packageName = typeof rawPackageName === 'string'
-            ? rawPackageName.slice(0, 200)
-            : undefined;
-        output.printInfo(packageName ? `Rolling back ${packageName}...` : 'Rolling back last update...');
-        const result = await rollbackUpdate(packageName);
-        if (result.success) {
-            output.printSuccess(result.message);
-        }
-        else {
-            output.printError(result.message);
-        }
-        return { success: result.success };
-    },
-};
-// Subcommand: clear-cache
-const clearCacheCommand = {
-    name: 'clear-cache',
-    description: 'Clear update check cache',
-    async action() {
-        clearCache();
-        output.printSuccess('Update cache cleared');
-        output.printInfo('Next startup will check for updates');
-        return { success: true };
-    },
-};
-// Main update command
-const updateCommand = {
-    name: 'update',
-    description: 'Manage @monomind package updates (ADR-025)',
-    subcommands: [checkCommand, allCommand, historyCommand, rollbackCommand, clearCacheCommand],
-    async action() {
-        // Show help if no subcommand
-        output.writeln();
-        output.writeln(output.highlight('═══ Update Command ═══'));
-        output.writeln();
-        output.writeln('Manage @monomind package updates with auto-update support.');
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            `${output.highlight('check')}       - Check for available updates`,
-            `${output.highlight('all')}         - Update all packages`,
-            `${output.highlight('history')}     - View update history`,
-            `${output.highlight('rollback')}    - Rollback last update`,
-            `${output.highlight('clear-cache')} - Clear update check cache`,
-        ]);
-        output.writeln();
-        output.writeln('Environment Variables:');
-        output.printList([
-            `${output.dim('MONOMIND_AUTO_UPDATE=false')}  - Disable auto-update`,
-            `${output.dim('MONOMIND_FORCE_UPDATE=true')} - Force update check`,
-        ]);
-        output.writeln();
-        output.writeln('Run "monomind update <subcommand> --help" for subcommand help');
-        return { success: true };
-    },
-};
-export default updateCommand;
-//# sourceMappingURL=update.js.map

package/packages/@monomind/cli/dist/src/consensus/audit-writer.d.ts

@@ -1,77 +0,0 @@
-/** Supported consensus protocols. */
-export type ConsensusProtocol = 'byzantine' | 'raft' | 'gossip' | 'crdt' | 'quorum';
-/** A single signed vote cast by an agent. */
-export interface VoteRecord {
-    agentId: string;
-    agentSlug: string;
-    vote: unknown;
-    signature: string;
-    votedAt: string;
-}
-/** Proof that quorum was (or was not) achieved. */
-export interface QuorumProof {
-    required: number;
-    achieved: number;
-    threshold: number;
-    satisfied: boolean;
-}
-/** Full audit record for a consensus decision. */
-export interface ConsensusAuditRecord {
-    decisionId: string;
-    swarmId: string;
-    protocol: ConsensusProtocol;
-    topic: string;
-    decision: unknown;
-    votes: VoteRecord[];
-    quorumProof: QuorumProof;
-    quorumAchieved: boolean;
-    round: number;
-    startedAt: string;
-    completedAt: string;
-    durationMs: number | null;
-    /** HMAC-SHA256 over the full record (all fields above), keyed by the session secret. */
-    recordSignature?: string;
-}
-/** An unsigned vote supplied to {@link AuditWriter.record}. */
-export type UnsignedVote = Omit<VoteRecord, 'signature'>;
-/** Input to {@link AuditWriter.record}. */
-export interface RecordInput {
-    decisionId: string;
-    swarmId: string;
-    protocol: ConsensusProtocol;
-    topic: string;
-    decision: unknown;
-    votes: UnsignedVote[];
-    quorumRequired: number;
-    quorumThreshold: number;
-    round: number;
-    startedAt: string;
-    completedAt: string;
-    sessionSecret: string;
-}
-/** Result of re-verifying a stored consensus decision. */
-export interface VerifyResult {
-    valid: boolean;
-    invalidVotes: string[];
-}
-export declare class AuditWriter {
-    private readonly auditPath;
-    private readonly votesPath;
-    constructor(dataDir: string);
-    /**
-     * Record a consensus decision: sign all votes, compute quorum proof,
-     * and persist both the audit record and individual votes to JSONL.
-     */
-    record(input: RecordInput): ConsensusAuditRecord;
-    /**
-     * List consensus decisions, optionally filtered by swarmId.
-     */
-    listDecisions(swarmId?: string, limit?: number): ConsensusAuditRecord[];
-    /**
-     * Re-verify all vote signatures in a decision.
-     */
-    verifyDecision(decisionId: string, sessionSecret: string): VerifyResult;
-    private appendLine;
-    private readLines;
-}
-//# sourceMappingURL=audit-writer.d.ts.map