monomind 1.6.0 → 1.6.1

package/packages/@monomind/cli/dist/src/ruvector/agent-wasm.js

@@ -1,316 +0,0 @@
-/**
- * RuVector Agent WASM Integration
- *
- * Wraps @ruvector/rvagent-wasm for sandboxed AI agent execution.
- * Provides WasmAgent lifecycle, gallery templates, RVF container building,
- * and MCP server bridge — all running in WASM without OS access.
- *
- * Published API (v0.1.0): WasmAgent, WasmGallery, WasmMcpServer,
- * WasmRvfBuilder, JsModelProvider, initSync.
- *
- * @module @monoes/cli/ruvector/agent-wasm
- */
-import { readFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-// ── WASM Module Detection & Init ─────────────────────────────
-let _wasmReady = false;
-/**
- * Check if @ruvector/rvagent-wasm is installed and loadable.
- */
-export async function isAgentWasmAvailable() {
-    try {
-        const mod = await import('@ruvector/rvagent-wasm');
-        return typeof mod.WasmAgent === 'function';
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Initialize the WASM module for Node.js. Safe to call multiple times.
- * Uses initSync with file-loaded WASM bytes (browser fetch doesn't work in Node).
- */
-export async function initAgentWasm() {
-    if (_wasmReady)
-        return;
-    try {
-        const mod = await import('@ruvector/rvagent-wasm');
-        // In Node.js, load WASM bytes from disk and use initSync
-        const require_ = createRequire(import.meta.url);
-        const wasmPath = require_.resolve('@ruvector/rvagent-wasm/rvagent_wasm_bg.wasm');
-        const wasmBytes = readFileSync(wasmPath);
-        mod.initSync(wasmBytes);
-        _wasmReady = true;
-    }
-    catch (err) {
-        throw new Error(`Failed to initialize @ruvector/rvagent-wasm: ${err}`);
-    }
-}
-// ── Agent Registry ───────────────────────────────────────────
-const agents = new Map();
-let nextId = 1;
-function generateId() {
-    return `wasm-agent-${nextId++}-${Date.now().toString(36)}`;
-}
-// ── Agent Lifecycle ──────────────────────────────────────────
-/**
- * Create a new sandboxed WASM agent.
- */
-export async function createWasmAgent(config = {}) {
-    await initAgentWasm();
-    const mod = await import('@ruvector/rvagent-wasm');
-    const configJson = JSON.stringify({
-        model: config.model ?? 'anthropic:claude-sonnet-4-20250514',
-        instructions: config.instructions ?? 'You are a helpful coding assistant.',
-        max_turns: config.maxTurns ?? 50,
-    });
-    const agent = new mod.WasmAgent(configJson);
-    const id = generateId();
-    const info = {
-        id,
-        state: 'idle',
-        config,
-        model: agent.model(),
-        turnCount: agent.turn_count(),
-        fileCount: agent.file_count(),
-        isStopped: agent.is_stopped(),
-        createdAt: new Date().toISOString(),
-    };
-    agents.set(id, { agent, info });
-    return info;
-}
-/**
- * Send a prompt to a WASM agent. Requires a model provider to be set.
- */
-export async function promptWasmAgent(agentId, input) {
-    const entry = agents.get(agentId);
-    if (!entry)
-        throw new Error(`WASM agent not found: ${agentId}`);
-    entry.info.state = 'running';
-    try {
-        const result = await entry.agent.prompt(input);
-        entry.info.state = 'idle';
-        syncAgentInfo(entry);
-        return result;
-    }
-    catch (err) {
-        entry.info.state = 'error';
-        throw err;
-    }
-}
-/**
- * Execute a tool directly on a WASM agent's sandbox.
- * Tool format: {tool: 'write_file', path: '...', content: '...'} (flat, snake_case).
- * Available tools: read_file, write_file, edit_file, write_todos, list_files.
- */
-const VALID_WASM_TOOLS = ['read_file', 'write_file', 'edit_file', 'write_todos', 'list_files'];
-export async function executeWasmTool(agentId, toolCall) {
-    const entry = agents.get(agentId);
-    if (!entry)
-        throw new Error(`WASM agent not found: ${agentId}`);
-    // Validate tool name to prevent WASM panics on unknown tools
-    const toolName = toolCall.tool;
-    if (toolName && !VALID_WASM_TOOLS.includes(toolName)) {
-        return { success: false, output: `Unknown tool: ${toolName}. Available: ${VALID_WASM_TOOLS.join(', ')}` };
-    }
-    const result = await entry.agent.execute_tool(JSON.stringify(toolCall));
-    syncAgentInfo(entry);
-    return result;
-}
-function syncAgentInfo(entry) {
-    try {
-        entry.info.turnCount = entry.agent.turn_count();
-        entry.info.fileCount = entry.agent.file_count();
-        entry.info.isStopped = entry.agent.is_stopped();
-    }
-    catch { /* best-effort */ }
-}
-/**
- * Get agent info.
- */
-export function getWasmAgent(agentId) {
-    const entry = agents.get(agentId);
-    if (!entry)
-        return null;
-    syncAgentInfo(entry);
-    return entry.info;
-}
-/**
- * List all active WASM agents.
- */
-export function listWasmAgents() {
-    return Array.from(agents.values()).map(e => {
-        syncAgentInfo(e);
-        return e.info;
-    });
-}
-/**
- * Terminate a WASM agent and free resources.
- */
-export function terminateWasmAgent(agentId) {
-    const entry = agents.get(agentId);
-    if (!entry)
-        return false;
-    try {
-        entry.agent.free();
-    }
-    catch { /* already freed */ }
-    agents.delete(agentId);
-    return true;
-}
-/**
- * Get agent state (messages, turn count, etc.)
- */
-export function getWasmAgentState(agentId) {
-    const entry = agents.get(agentId);
-    if (!entry)
-        throw new Error(`WASM agent not found: ${agentId}`);
-    return entry.agent.get_state();
-}
-/**
- * Get agent tools list.
- */
-export function getWasmAgentTools(agentId) {
-    const entry = agents.get(agentId);
-    if (!entry)
-        throw new Error(`WASM agent not found: ${agentId}`);
-    return entry.agent.get_tools();
-}
-/**
- * Get agent todos.
- */
-export function getWasmAgentTodos(agentId) {
-    const entry = agents.get(agentId);
-    if (!entry)
-        throw new Error(`WASM agent not found: ${agentId}`);
-    return entry.agent.get_todos();
-}
-/**
- * Export the full agent state as JSON (for persistence).
- */
-export function exportWasmState(agentId) {
-    const entry = agents.get(agentId);
-    if (!entry)
-        throw new Error(`WASM agent not found: ${agentId}`);
-    return JSON.stringify({
-        agentState: entry.agent.get_state(),
-        tools: entry.agent.get_tools(),
-        todos: entry.agent.get_todos(),
-        info: entry.info,
-    });
-}
-// ── MCP Server Bridge ────────────────────────────────────────
-/**
- * Create a WASM-based MCP server for an agent.
- * Returns a handler function for JSON-RPC requests.
- *
- * Note: WasmMcpServer may have stability issues in v0.1.0 for
- * certain agent configurations. Use with a fully configured agent.
- */
-export async function createWasmMcpServer(agentId) {
-    const entry = agents.get(agentId);
-    if (!entry)
-        throw new Error(`WASM agent not found: ${agentId}`);
-    const mod = await import('@ruvector/rvagent-wasm');
-    const server = new mod.WasmMcpServer(entry.agent);
-    return (jsonRpc) => server.handle_request(jsonRpc);
-}
-// ── Gallery Templates ────────────────────────────────────────
-let _gallery = null;
-async function getGallery() {
-    if (_gallery)
-        return _gallery;
-    await initAgentWasm();
-    const mod = await import('@ruvector/rvagent-wasm');
-    _gallery = new mod.WasmGallery();
-    return _gallery;
-}
-/**
- * List all available gallery templates.
- * Returns objects directly (Gallery.list() returns parsed objects in v0.1.0).
- */
-export async function listGalleryTemplates() {
-    const gallery = await getGallery();
-    return gallery.list();
-}
-/**
- * Get gallery template count.
- */
-export async function getGalleryCount() {
-    const gallery = await getGallery();
-    return gallery.count();
-}
-/**
- * Get gallery categories with counts.
- */
-export async function getGalleryCategories() {
-    const gallery = await getGallery();
-    return gallery.getCategories();
-}
-/**
- * Search gallery templates by query. Returns results with relevance scores.
- */
-export async function searchGalleryTemplates(query) {
-    const gallery = await getGallery();
-    return gallery.search(query);
-}
-/**
- * Get a gallery template by id.
- * Wraps in try/catch because WasmGallery.get() panics on unknown IDs in v0.1.0.
- */
-export async function getGalleryTemplate(id) {
-    const gallery = await getGallery();
-    try {
-        return gallery.get(id) ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Create an agent from a gallery template.
- */
-export async function createAgentFromTemplate(templateId) {
-    const template = await getGalleryTemplate(templateId);
-    if (!template)
-        throw new Error(`Gallery template not found: ${templateId}`);
-    const systemPrompt = template.prompts?.[0]?.system_prompt;
-    return createWasmAgent({
-        instructions: systemPrompt ?? `You are a ${template.name}.`,
-        model: undefined, // Use default
-    });
-}
-// ── RVF Container Operations ─────────────────────────────────
-/**
- * Build an RVF container with prompts, tools, and skills.
- * Uses the high-level RVF builder API (addPrompt, addTool, addSkill).
- */
-export async function buildRvfContainer(opts) {
-    await initAgentWasm();
-    const mod = await import('@ruvector/rvagent-wasm');
-    const builder = new mod.WasmRvfBuilder();
-    for (const p of opts.prompts ?? []) {
-        builder.addPrompt(JSON.stringify(p));
-    }
-    for (const t of opts.tools ?? []) {
-        builder.addTool(JSON.stringify(t));
-    }
-    for (const s of opts.skills ?? []) {
-        builder.addSkill(JSON.stringify(s));
-    }
-    return builder.build();
-}
-/**
- * Build an RVF container from a gallery template.
- */
-export async function buildRvfFromTemplate(templateId) {
-    const template = await getGalleryTemplate(templateId);
-    if (!template)
-        throw new Error(`Gallery template not found: ${templateId}`);
-    return buildRvfContainer({
-        prompts: template.prompts,
-        tools: template.tools,
-        skills: template.skills,
-    });
-}
-//# sourceMappingURL=agent-wasm.js.map

package/packages/@monomind/cli/dist/src/ruvector/ast-analyzer.d.ts

@@ -1,67 +0,0 @@
-/**
- * AST Analyzer for Code Analysis
- *
- * Analyzes Abstract Syntax Trees for code understanding
- * and intelligent routing decisions.
- *
- * @module ast-analyzer
- */
-export interface ASTAnalyzerConfig {
-    maxFileSize: number;
-    languages: string[];
-    includeComments: boolean;
-    extractTypes: boolean;
-    maxDepth: number;
-}
-export interface ASTNode {
-    type: string;
-    name: string;
-    startLine: number;
-    endLine: number;
-    children: ASTNode[];
-    metadata?: Record<string, unknown>;
-}
-export interface ASTAnalysis {
-    filePath: string;
-    language: string;
-    root: ASTNode;
-    functions: ASTNode[];
-    classes: ASTNode[];
-    imports: string[];
-    exports: string[];
-    complexity: {
-        cyclomatic: number;
-        cognitive: number;
-        loc: number;
-        commentDensity: number;
-    };
-    timestamp: number;
-    durationMs: number;
-}
-export declare class ASTAnalyzer {
-    private config;
-    private ruvectorEngine;
-    private useNative;
-    private analysisCache;
-    constructor(config?: Partial<ASTAnalyzerConfig>);
-    initialize(): Promise<void>;
-    analyze(code: string, filePath?: string): ASTAnalysis;
-    getFunctionAtLine(analysis: ASTAnalysis, line: number): ASTNode | null;
-    getClassAtLine(analysis: ASTAnalysis, line: number): ASTNode | null;
-    getSymbols(analysis: ASTAnalysis): string[];
-    getStats(): Record<string, number>;
-    clearCache(): void;
-    private getCacheKey;
-    private detectLanguage;
-    private parseAST;
-    private matchFunction;
-    private matchClass;
-    private findBlockEnd;
-    private extractFunctions;
-    private extractClasses;
-    private extractImports;
-    private extractExports;
-    private calculateComplexity;
-}
-export declare function createASTAnalyzer(config?: Partial<ASTAnalyzerConfig>): ASTAnalyzer;
-//# sourceMappingURL=ast-analyzer.d.ts.map

package/packages/@monomind/cli/dist/src/ruvector/ast-analyzer.js

@@ -1,277 +0,0 @@
-/**
- * AST Analyzer for Code Analysis
- *
- * Analyzes Abstract Syntax Trees for code understanding
- * and intelligent routing decisions.
- *
- * @module ast-analyzer
- */
-const DEFAULT_CONFIG = {
-    maxFileSize: 1024 * 1024,
-    languages: ['typescript', 'javascript', 'python', 'rust', 'go'],
-    includeComments: true,
-    extractTypes: true,
-    maxDepth: 20,
-};
-const LANGUAGE_PATTERNS = {
-    typescript: [/\.tsx?$/, /^import\s+.*from\s+['"]/, /:\s*(string|number|boolean|void)/],
-    javascript: [/\.jsx?$/, /^(const|let|var)\s+\w+\s*=/, /module\.exports/],
-    python: [/\.py$/, /^(def|class|import|from)\s+/, /^#!/],
-    rust: [/\.rs$/, /^(fn|struct|impl|use)\s+/, /^(pub\s+)?mod\s+/],
-    go: [/\.go$/, /^package\s+/, /^func\s+/],
-};
-export class ASTAnalyzer {
-    config;
-    ruvectorEngine = null;
-    useNative = false;
-    analysisCache = new Map();
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    async initialize() {
-        try {
-            // @ruvector/ast is optional - gracefully fallback if not installed
-            const ruvector = await import('@ruvector/ast').catch(() => null);
-            if (ruvector) {
-                this.ruvectorEngine = ruvector.createASTAnalyzer?.(this.config);
-                this.useNative = !!this.ruvectorEngine;
-            }
-        }
-        catch {
-            this.useNative = false;
-        }
-    }
-    analyze(code, filePath = 'unknown') {
-        const startTime = performance.now();
-        if (code.length > this.config.maxFileSize) {
-            throw new Error(`File too large: ${code.length} bytes exceeds ${this.config.maxFileSize}`);
-        }
-        const cacheKey = this.getCacheKey(code, filePath);
-        const cached = this.analysisCache.get(cacheKey);
-        if (cached)
-            return cached;
-        const language = this.detectLanguage(code, filePath);
-        const root = this.parseAST(code, language);
-        const functions = this.extractFunctions(root);
-        const classes = this.extractClasses(root);
-        const imports = this.extractImports(code, language);
-        const exports = this.extractExports(code, language);
-        const complexity = this.calculateComplexity(code, root);
-        const durationMs = performance.now() - startTime;
-        const analysis = {
-            filePath, language, root, functions, classes, imports, exports,
-            complexity, timestamp: Date.now(), durationMs,
-        };
-        this.analysisCache.set(cacheKey, analysis);
-        return analysis;
-    }
-    getFunctionAtLine(analysis, line) {
-        for (const func of analysis.functions) {
-            if (line >= func.startLine && line <= func.endLine)
-                return func;
-        }
-        return null;
-    }
-    getClassAtLine(analysis, line) {
-        for (const cls of analysis.classes) {
-            if (line >= cls.startLine && line <= cls.endLine)
-                return cls;
-        }
-        return null;
-    }
-    getSymbols(analysis) {
-        const symbols = [];
-        for (const func of analysis.functions)
-            symbols.push(func.name);
-        for (const cls of analysis.classes)
-            symbols.push(cls.name);
-        return symbols;
-    }
-    getStats() {
-        return { cacheSize: this.analysisCache.size, useNative: this.useNative ? 1 : 0 };
-    }
-    clearCache() { this.analysisCache.clear(); }
-    getCacheKey(code, filePath) {
-        let hash = 0;
-        const str = filePath + code.substring(0, 1000);
-        for (let i = 0; i < str.length; i++) {
-            const char = str.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash = hash & hash;
-        }
-        return `ast_${hash}_${code.length}`;
-    }
-    detectLanguage(code, filePath) {
-        for (const [lang, patterns] of Object.entries(LANGUAGE_PATTERNS)) {
-            for (const pattern of patterns) {
-                if (pattern.test(filePath) || pattern.test(code))
-                    return lang;
-            }
-        }
-        return 'unknown';
-    }
-    parseAST(code, language) {
-        const lines = code.split('\n');
-        const root = { type: 'program', name: 'root', startLine: 1, endLine: lines.length, children: [] };
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const lineNum = i + 1;
-            const funcMatch = this.matchFunction(line, language);
-            if (funcMatch) {
-                const funcNode = {
-                    type: 'function', name: funcMatch.name, startLine: lineNum,
-                    endLine: lineNum + this.findBlockEnd(lines, i), children: [],
-                    metadata: { params: funcMatch.params },
-                };
-                root.children.push(funcNode);
-                continue;
-            }
-            const classMatch = this.matchClass(line, language);
-            if (classMatch) {
-                const classNode = {
-                    type: 'class', name: classMatch.name, startLine: lineNum,
-                    endLine: lineNum + this.findBlockEnd(lines, i), children: [],
-                    metadata: { extends: classMatch.extends },
-                };
-                root.children.push(classNode);
-            }
-        }
-        return root;
-    }
-    matchFunction(line, language) {
-        const patterns = {
-            typescript: /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/,
-            javascript: /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/,
-            python: /def\s+(\w+)\s*\(([^)]*)\)/,
-            rust: /(?:pub\s+)?(?:async\s+)?fn\s+(\w+)\s*\(([^)]*)\)/,
-            go: /func\s+(?:\([^)]*\)\s+)?(\w+)\s*\(([^)]*)\)/,
-        };
-        const pattern = patterns[language];
-        if (!pattern)
-            return null;
-        const match = line.match(pattern);
-        if (match)
-            return { name: match[1], params: match[2] || '' };
-        const arrowMatch = line.match(/(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>/);
-        if (arrowMatch)
-            return { name: arrowMatch[1], params: '' };
-        const methodMatch = line.match(/^\s*(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+)?\s*\{/);
-        if (methodMatch && methodMatch[1] !== 'if' && methodMatch[1] !== 'while' && methodMatch[1] !== 'for') {
-            return { name: methodMatch[1], params: '' };
-        }
-        return null;
-    }
-    matchClass(line, language) {
-        const patterns = {
-            typescript: /(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/,
-            javascript: /(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/,
-            python: /class\s+(\w+)(?:\((\w+)\))?/,
-            rust: /(?:pub\s+)?struct\s+(\w+)/,
-            go: /type\s+(\w+)\s+struct/,
-        };
-        const pattern = patterns[language];
-        if (!pattern)
-            return null;
-        const match = line.match(pattern);
-        if (match)
-            return { name: match[1], extends: match[2] };
-        return null;
-    }
-    findBlockEnd(lines, startIdx) {
-        let depth = 0;
-        let inBlock = false;
-        for (let i = startIdx; i < lines.length; i++) {
-            const line = lines[i];
-            const opens = (line.match(/[\{]/g) || []).length;
-            const closes = (line.match(/[\}]/g) || []).length;
-            if (opens > 0)
-                inBlock = true;
-            depth += opens - closes;
-            if (inBlock && depth <= 0)
-                return i - startIdx;
-        }
-        return Math.min(50, lines.length - startIdx);
-    }
-    extractFunctions(root) {
-        const functions = [];
-        const visit = (node) => {
-            if (node.type === 'function')
-                functions.push(node);
-            for (const child of node.children)
-                visit(child);
-        };
-        visit(root);
-        return functions;
-    }
-    extractClasses(root) {
-        const classes = [];
-        const visit = (node) => {
-            if (node.type === 'class')
-                classes.push(node);
-            for (const child of node.children)
-                visit(child);
-        };
-        visit(root);
-        return classes;
-    }
-    extractImports(code, language) {
-        const imports = [];
-        const lines = code.split('\n');
-        const patterns = {
-            typescript: /import\s+(?:.*\s+from\s+)?['"]([^'"]+)['"]/,
-            javascript: /(?:import\s+.*from\s+|require\s*\(\s*)['"]([^'"]+)['"]/,
-            python: /(?:from\s+(\S+)\s+import|import\s+(\S+))/,
-            rust: /use\s+(\S+)/,
-            go: /import\s+(?:\(\s*)?["']([^"']+)["']/,
-        };
-        const pattern = patterns[language];
-        if (!pattern)
-            return imports;
-        for (const line of lines) {
-            const match = line.match(pattern);
-            if (match)
-                imports.push(match[1] || match[2]);
-        }
-        return imports;
-    }
-    extractExports(code, language) {
-        const exports = [];
-        const lines = code.split('\n');
-        for (const line of lines) {
-            const exportMatch = line.match(/export\s+(?:default\s+)?(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/);
-            if (exportMatch)
-                exports.push(exportMatch[1]);
-            const namedExportMatch = line.match(/export\s*\{\s*([^}]+)\s*\}/);
-            if (namedExportMatch) {
-                const names = namedExportMatch[1].split(',').map(n => n.trim().split(/\s+as\s+/)[0]);
-                exports.push(...names);
-            }
-        }
-        return exports;
-    }
-    calculateComplexity(code, root) {
-        const lines = code.split('\n');
-        const nonEmptyLines = lines.filter(l => l.trim().length > 0);
-        const commentLines = lines.filter(l => /^\s*(\/\/|\/\*|\*|#)/.test(l));
-        const decisionPoints = (code.match(/\b(if|else|for|while|switch|case|catch|&&|\|\||\?)\b/g) || []).length;
-        const cyclomatic = decisionPoints + 1;
-        let cognitive = 0;
-        let nestingLevel = 0;
-        for (const line of lines) {
-            const opens = (line.match(/[\{]/g) || []).length;
-            const closes = (line.match(/[\}]/g) || []).length;
-            if (/\b(if|for|while|switch)\b/.test(line))
-                cognitive += 1 + nestingLevel;
-            nestingLevel += opens - closes;
-            nestingLevel = Math.max(0, nestingLevel);
-        }
-        return {
-            cyclomatic, cognitive, loc: nonEmptyLines.length,
-            commentDensity: lines.length > 0 ? commentLines.length / lines.length : 0,
-        };
-    }
-}
-export function createASTAnalyzer(config) {
-    return new ASTAnalyzer(config);
-}
-//# sourceMappingURL=ast-analyzer.js.map