monomind 1.9.16 → 1.10.0

package/packages/@monomind/cli/dist/src/suggest.js

@@ -1,209 +0,0 @@
-/**
- * CLI Smart Error Suggestions
- * Levenshtein distance and command suggestions
- *
- * github.com/nokhodian/monomind
- */
-/**
- * Calculate Levenshtein distance between two strings
- */
-export function levenshteinDistance(a, b) {
-    const m = a.length;
-    const n = b.length;
-    // Early termination for empty strings
-    if (m === 0)
-        return n;
-    if (n === 0)
-        return m;
-    // Bound input length — the Wagner-Fischer matrix is O(m × n) memory.
-    // Without this cap, any caller that passes a long stdin-derived string
-    // (shell completion of a malformed command, untrusted CLI arg) can OOM
-    // the process. For ranking purposes the worst-case distance is `max(m,n)`,
-    // so returning that is safe.
-    const MAX_LEN = 256;
-    if (m > MAX_LEN || n > MAX_LEN || Math.abs(m - n) > 64) {
-        return Math.max(m, n);
-    }
-    // Create distance matrix
-    const d = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
-    // Initialize first column
-    for (let i = 0; i <= m; i++) {
-        d[i][0] = i;
-    }
-    // Initialize first row
-    for (let j = 0; j <= n; j++) {
-        d[0][j] = j;
-    }
-    // Fill in the rest of the matrix
-    for (let j = 1; j <= n; j++) {
-        for (let i = 1; i <= m; i++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            d[i][j] = Math.min(d[i - 1][j] + 1, // deletion
-            d[i][j - 1] + 1, // insertion
-            d[i - 1][j - 1] + cost // substitution
-            );
-        }
-    }
-    return d[m][n];
-}
-/**
- * Calculate similarity score (0-1) between two strings
- */
-export function similarityScore(a, b) {
-    const maxLen = Math.max(a.length, b.length);
-    if (maxLen === 0)
-        return 1;
-    const distance = levenshteinDistance(a.toLowerCase(), b.toLowerCase());
-    return 1 - distance / maxLen;
-}
-/**
- * Find similar strings from a list
- */
-export function findSimilar(input, candidates, options = {}) {
-    const { maxSuggestions = 3, minSimilarity = 0.4, maxDistance = 3 } = options;
-    const inputLower = input.toLowerCase();
-    // Score all candidates
-    const scored = candidates
-        .map(candidate => ({
-        candidate,
-        distance: levenshteinDistance(inputLower, candidate.toLowerCase()),
-        similarity: similarityScore(inputLower, candidate),
-        // Boost prefix matches
-        prefixBoost: candidate.toLowerCase().startsWith(inputLower) ? 0.3 : 0
-    }))
-        .filter(s => s.distance <= maxDistance || s.similarity >= minSimilarity)
-        .map(s => ({
-        ...s,
-        score: s.similarity + s.prefixBoost
-    }))
-        .sort((a, b) => b.score - a.score)
-        .slice(0, maxSuggestions);
-    return scored.map(s => s.candidate);
-}
-/**
- * Format suggestion message for CLI errors
- */
-export function formatSuggestion(invalidInput, suggestions, context = 'command') {
-    if (suggestions.length === 0) {
-        return '';
-    }
-    const contextMap = {
-        command: 'Did you mean',
-        subcommand: 'Available subcommands',
-        option: 'Did you mean',
-        value: 'Valid values'
-    };
-    const prefix = contextMap[context];
-    if (suggestions.length === 1) {
-        return `\n  ${prefix}: ${suggestions[0]}`;
-    }
-    return `\n  ${prefix}:\n${suggestions.map(s => `    - ${s}`).join('\n')}`;
-}
-/**
- * Common typos and their corrections
- */
-export const COMMON_TYPOS = {
-    'init': 'init',
-    'initi': 'init',
-    'inizialize': 'init',
-    'staus': 'status',
-    'stauts': 'status',
-    'stats': 'stats',
-    'stat': 'status',
-    'swarrm': 'swarm',
-    'swarn': 'swarm',
-    'agnet': 'agent',
-    'agen': 'agent',
-    'memroy': 'memory',
-    'mem': 'memory',
-    'memmory': 'memory',
-    'confg': 'config',
-    'conf': 'config',
-    'configu': 'config',
-    'hook': 'hooks',
-    'hoks': 'hooks',
-    'hive': 'hive-mind',
-    'hivemind': 'hive-mind',
-    'hive_mind': 'hive-mind',
-    'neurl': 'neural',
-    'nueral': 'neural',
-    'securty': 'security',
-    'sec': 'security',
-    'perf': 'performance',
-    'performace': 'performance',
-    'provider': 'providers',
-    'plugin': 'plugins',
-    'dep': 'deployment',
-    'depoly': 'deployment',
-    'deploy': 'deployment',
-    'claim': 'claims',
-    'embed': 'embeddings',
-    'embeding': 'embeddings',
-    'daemon': 'daemon',
-    'deamon': 'daemon',
-    'doc': 'doctor',
-    'docter': 'doctor',
-    'complete': 'completions',
-    'completion': 'completions',
-    'comp': 'completions',
-    'task': 'task',
-    'taks': 'task',
-    'sessio': 'session',
-    'sess': 'session',
-    'sesssion': 'session',
-    'workflow': 'workflow',
-    'wf': 'workflow',
-    'wokflow': 'workflow'
-};
-/**
- * Get corrected command if it's a common typo
- */
-export function getTypoCorrection(input) {
-    return COMMON_TYPOS[input.toLowerCase()];
-}
-/**
- * Smart command suggestion for unknown commands
- */
-export function suggestCommand(unknownCommand, availableCommands) {
-    // Check for common typo first
-    const correction = getTypoCorrection(unknownCommand);
-    if (correction && availableCommands.includes(correction)) {
-        return {
-            correction,
-            suggestions: [correction],
-            message: `Did you mean "${correction}"?`
-        };
-    }
-    // Find similar commands
-    const suggestions = findSimilar(unknownCommand, availableCommands, {
-        maxSuggestions: 3,
-        minSimilarity: 0.3,
-        maxDistance: 4
-    });
-    if (suggestions.length === 0) {
-        return {
-            suggestions: [],
-            message: 'Run "monomind --help" to see available commands.'
-        };
-    }
-    if (suggestions.length === 1) {
-        return {
-            suggestions,
-            message: `Did you mean "${suggestions[0]}"?`
-        };
-    }
-    return {
-        suggestions,
-        message: `Did you mean one of these?\n${suggestions.map(s => `  - ${s}`).join('\n')}`
-    };
-}
-export default {
-    levenshteinDistance,
-    similarityScore,
-    findSimilar,
-    formatSuggestion,
-    suggestCommand,
-    getTypoCorrection,
-    COMMON_TYPOS
-};
-//# sourceMappingURL=suggest.js.map

package/packages/@monomind/cli/dist/src/swarm/communication-graph.d.ts

@@ -1,25 +0,0 @@
-/**
- * CommunicationGraph (Task 40)
- *
- * Directed graph of allowed agent-to-agent communication flows.
- * Empty flows = unrestricted (backward compatible).
- */
-import type { FlowEdge } from '../../../shared/src/types/communication-flow.js';
-export declare class CommunicationGraph {
-    private readonly adjacency;
-    private readonly reverse;
-    private readonly edges;
-    private readonly unrestricted;
-    constructor(flows: FlowEdge[]);
-    /** Check whether fromSlug is allowed to send to toSlug */
-    isAuthorized(fromSlug: string, toSlug: string): boolean;
-    /** Outbound targets for a given sender */
-    getTargets(fromSlug: string): string[];
-    /** Inbound sources for a given receiver */
-    getSources(toSlug: string): string[];
-    /** All declared edges */
-    allEdges(): FlowEdge[];
-    /** Detect cycles via DFS (returns true if at least one cycle exists) */
-    hasCycles(): boolean;
-}
-//# sourceMappingURL=communication-graph.d.ts.map

package/packages/@monomind/cli/dist/src/swarm/communication-graph.js

@@ -1,77 +0,0 @@
-/**
- * CommunicationGraph (Task 40)
- *
- * Directed graph of allowed agent-to-agent communication flows.
- * Empty flows = unrestricted (backward compatible).
- */
-export class CommunicationGraph {
-    adjacency = new Map();
-    reverse = new Map();
-    edges;
-    unrestricted;
-    constructor(flows) {
-        this.edges = [...flows];
-        this.unrestricted = flows.length === 0;
-        for (const [from, to] of flows) {
-            if (!this.adjacency.has(from))
-                this.adjacency.set(from, new Set());
-            this.adjacency.get(from).add(to);
-            if (!this.reverse.has(to))
-                this.reverse.set(to, new Set());
-            this.reverse.get(to).add(from);
-        }
-    }
-    /** Check whether fromSlug is allowed to send to toSlug */
-    isAuthorized(fromSlug, toSlug) {
-        if (this.unrestricted)
-            return true;
-        return this.adjacency.get(fromSlug)?.has(toSlug) === true;
-    }
-    /** Outbound targets for a given sender */
-    getTargets(fromSlug) {
-        if (this.unrestricted)
-            return [];
-        return Array.from(this.adjacency.get(fromSlug) ?? []);
-    }
-    /** Inbound sources for a given receiver */
-    getSources(toSlug) {
-        if (this.unrestricted)
-            return [];
-        return Array.from(this.reverse.get(toSlug) ?? []);
-    }
-    /** All declared edges */
-    allEdges() {
-        return [...this.edges];
-    }
-    /** Detect cycles via DFS (returns true if at least one cycle exists) */
-    hasCycles() {
-        const WHITE = 0, GREY = 1, BLACK = 2;
-        const color = new Map();
-        // Collect all nodes
-        const nodes = new Set();
-        for (const [from, to] of this.edges) {
-            nodes.add(from);
-            nodes.add(to);
-        }
-        for (const n of nodes)
-            color.set(n, WHITE);
-        const dfs = (node) => {
-            color.set(node, GREY);
-            for (const neighbor of this.adjacency.get(node) ?? []) {
-                const c = color.get(neighbor) ?? WHITE;
-                if (c === GREY)
-                    return true;
-                if (c === WHITE && dfs(neighbor))
-                    return true;
-            }
-            color.set(node, BLACK);
-            return false;
-        };
-        for (const n of nodes) {
-            if (color.get(n) === WHITE && dfs(n))
-                return true;
-        }
-        return false;
-    }
-}
-//# sourceMappingURL=communication-graph.js.map

package/packages/@monomind/cli/dist/src/swarm/flow-enforcer.d.ts

@@ -1,31 +0,0 @@
-/**
- * FlowEnforcer (Task 40)
- *
- * Checks messages against the communication graph and records violations.
- * No database dependency — violations stored in memory.
- */
-import type { FlowViolation } from '../../../shared/src/types/communication-flow.js';
-import type { CommunicationGraph } from './communication-graph.js';
-export declare class FlowEnforcer {
-    private readonly graph;
-    private readonly swarmId;
-    private readonly enforce;
-    private readonly violations;
-    private static readonly MAX_VIOLATIONS;
-    constructor(graph: CommunicationGraph, swarmId: string, enforceMode: boolean);
-    /**
-     * Check whether a message is authorized and record any violation.
-     *
-     * Returns BOTH `authorized` (the policy decision) and `enforced` (whether the
-     * decision is actually applied). Callers must read both — taking action based
-     * solely on `authorized` would let `enforce=false` silently bypass the policy.
-     */
-    checkAndRecord(fromSlug: string, toSlug: string, messageContent: string): {
-        authorized: boolean;
-        enforced: boolean;
-        violation?: FlowViolation;
-    };
-    /** Return all recorded violations */
-    getViolations(): FlowViolation[];
-}
-//# sourceMappingURL=flow-enforcer.d.ts.map

package/packages/@monomind/cli/dist/src/swarm/flow-enforcer.js

@@ -1,61 +0,0 @@
-/**
- * FlowEnforcer (Task 40)
- *
- * Checks messages against the communication graph and records violations.
- * No database dependency — violations stored in memory.
- */
-import { randomUUID } from 'crypto';
-export class FlowEnforcer {
-    graph;
-    swarmId;
-    enforce;
-    violations = [];
-    static MAX_VIOLATIONS = 1000;
-    constructor(graph, swarmId, enforceMode) {
-        this.graph = graph;
-        this.swarmId = swarmId;
-        this.enforce = enforceMode;
-    }
-    /**
-     * Check whether a message is authorized and record any violation.
-     *
-     * Returns BOTH `authorized` (the policy decision) and `enforced` (whether the
-     * decision is actually applied). Callers must read both — taking action based
-     * solely on `authorized` would let `enforce=false` silently bypass the policy.
-     */
-    checkAndRecord(fromSlug, toSlug, messageContent) {
-        if (this.graph.isAuthorized(fromSlug, toSlug)) {
-            return { authorized: true, enforced: this.enforce };
-        }
-        const violation = {
-            violationId: randomUUID(),
-            swarmId: this.swarmId,
-            fromAgentSlug: fromSlug,
-            toAgentSlug: toSlug,
-            // Truncated preview only; for sensitive traffic, redact via a hook before
-            // it reaches this enforcer. Cap means an attacker can't fill memory with
-            // long messages either.
-            messagePreview: messageContent.slice(0, 120),
-            detectedAt: new Date().toISOString(),
-            action: this.enforce ? 'blocked' : 'logged',
-        };
-        // FIFO eviction so a sustained attack can't grow violations to GB-scale.
-        if (this.violations.length >= FlowEnforcer.MAX_VIOLATIONS) {
-            this.violations.shift();
-        }
-        this.violations.push(violation);
-        return {
-            // Policy decision: NOT authorized. Whether the caller blocks the send is
-            // governed by `enforced`, which is exposed separately so callers cannot
-            // accidentally treat audit-mode as "permitted".
-            authorized: false,
-            enforced: this.enforce,
-            violation,
-        };
-    }
-    /** Return all recorded violations */
-    getViolations() {
-        return [...this.violations];
-    }
-}
-//# sourceMappingURL=flow-enforcer.js.map

package/packages/@monomind/cli/dist/src/swarm/flow-visualizer.d.ts

@@ -1,19 +0,0 @@
-/**
- * Flow Visualizer (Task 40)
- *
- * ASCII and DOT (Graphviz) renderers for communication flow edges.
- */
-import type { FlowEdge } from '../../../shared/src/types/communication-flow.js';
-/**
- * Render edges as human-readable ASCII art.
- * Empty edges produce a single-line "unrestricted" notice.
- */
-export declare function toAscii(edges: FlowEdge[], title?: string): string;
-/**
- * Render edges as a DOT language digraph (Graphviz compatible).
- * Slugs are escaped so a malicious slug cannot inject DOT attributes
- * (e.g., URL="javascript:..." would be rendered as a clickable link
- * by Graphviz's SVG output without escaping).
- */
-export declare function toDOT(edges: FlowEdge[], graphName?: string): string;
-//# sourceMappingURL=flow-visualizer.d.ts.map

package/packages/@monomind/cli/dist/src/swarm/flow-visualizer.js

@@ -1,68 +0,0 @@
-/**
- * Flow Visualizer (Task 40)
- *
- * ASCII and DOT (Graphviz) renderers for communication flow edges.
- */
-/** Escape a slug for safe DOT identifier interpolation. */
-function dotEscape(s) {
-    return String(s ?? '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-}
-/** Strip newlines/CR for safe ASCII line emission (log-injection defense). */
-function asciiSafe(s) {
-    return String(s ?? '').replace(/[\r\n\x00-\x1f\x7f]/g, '?');
-}
-/** Restrict graph names to a safe DOT identifier — graph_name must be an ID. */
-function safeGraphName(name) {
-    return /^[a-zA-Z_][a-zA-Z0-9_]{0,63}$/.test(name) ? name : 'swarm_flow';
-}
-const MAX_DISPLAY_EDGES = 500;
-/**
- * Render edges as human-readable ASCII art.
- * Empty edges produce a single-line "unrestricted" notice.
- */
-export function toAscii(edges, title) {
-    const lines = [];
-    if (title) {
-        lines.push(`=== ${asciiSafe(title)} ===`);
-        lines.push('');
-    }
-    if (edges.length === 0) {
-        lines.push('(unrestricted — all agents may communicate freely)');
-        return lines.join('\n');
-    }
-    const capped = edges.slice(0, MAX_DISPLAY_EDGES);
-    for (const [from, to] of capped) {
-        lines.push(`  ${asciiSafe(from)} --> ${asciiSafe(to)}`);
-    }
-    if (edges.length > MAX_DISPLAY_EDGES) {
-        lines.push(`  ... (${edges.length - MAX_DISPLAY_EDGES} more edges omitted)`);
-    }
-    return lines.join('\n');
-}
-/**
- * Render edges as a DOT language digraph (Graphviz compatible).
- * Slugs are escaped so a malicious slug cannot inject DOT attributes
- * (e.g., URL="javascript:..." would be rendered as a clickable link
- * by Graphviz's SVG output without escaping).
- */
-export function toDOT(edges, graphName) {
-    const name = safeGraphName(graphName ?? 'swarm_flow');
-    const lines = [];
-    lines.push(`digraph ${name} {`);
-    lines.push('  rankdir=LR;');
-    if (edges.length === 0) {
-        lines.push('  // unrestricted — no explicit edges');
-    }
-    else {
-        const capped = edges.slice(0, MAX_DISPLAY_EDGES);
-        for (const [from, to] of capped) {
-            lines.push(`  "${dotEscape(from)}" -> "${dotEscape(to)}";`);
-        }
-        if (edges.length > MAX_DISPLAY_EDGES) {
-            lines.push(`  // ... (${edges.length - MAX_DISPLAY_EDGES} more edges omitted)`);
-        }
-    }
-    lines.push('}');
-    return lines.join('\n');
-}
-//# sourceMappingURL=flow-visualizer.js.map

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

@@ -1,25 +0,0 @@
-/**
- * Anonymization Pipeline
- * PII detection and redaction for pattern export
- */
-import type { CFPFormat, AnonymizationLevel, PIIDetectionResult } from '../types.js';
-/**
- * Detect PII in a string
- */
-export declare function detectPII(content: string): PIIDetectionResult;
-/**
- * Redact PII from a string
- */
-export declare function redactPII(content: string): string;
-/**
- * Apply anonymization to CFP document
- */
-export declare function anonymizeCFP(cfp: CFPFormat, level: AnonymizationLevel): {
-    cfp: CFPFormat;
-    transforms: string[];
-};
-/**
- * Scan CFP for PII without modification
- */
-export declare function scanCFPForPII(cfp: CFPFormat): PIIDetectionResult;
-//# sourceMappingURL=index.d.ts.map