monomind 1.10.0 → 1.10.2

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

@@ -0,0 +1,209 @@
+/**
+ * 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

@@ -0,0 +1,25 @@
+/**
+ * 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

@@ -0,0 +1,77 @@
+/**
+ * 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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,61 @@
+/**
+ * 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

@@ -0,0 +1,19 @@
+/**
+ * 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

@@ -0,0 +1,68 @@
+/**
+ * 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

@@ -0,0 +1,25 @@
+/**
+ * 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