@aigentic/claude-flow 3.7.0-alpha.69

package/v3/@claude-flow/cli/dist/src/ruvector/agent-wasm.js

@@ -0,0 +1,354 @@
+/**
+ * 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 @claude-flow/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');
+    // #1810 — was hardcoded `anthropic:claude-sonnet-4-20250514`. Updated to
+    // current Sonnet (4.6) so new gallery agents don't silently inherit a
+    // year-old model. Callers can still override via `config.model`.
+    const configJson = JSON.stringify({
+        model: config.model ?? 'anthropic:claude-sonnet-4-6',
+        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.
+ *
+ * ADR-095 G4: the bundled @ruvector/rvagent-wasm doesn't actually run an
+ * LLM — its prompt() method echoes input back as `"echo: <input>"`. We
+ * detect that stub output and route the prompt through Anthropic's
+ * Messages API so users get a real response. The WASM agent's sandbox
+ * (virtual filesystem, tool execution) still works for non-LLM ops via
+ * executeWasmTool — we're just patching the "talk to a model" hole.
+ *
+ * If ANTHROPIC_API_KEY is not set, returns the stub output verbatim so
+ * the failure mode is obvious to the caller (matches the previous
+ * behaviour rather than throwing for users without keys configured).
+ */
+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 wasmResult = await entry.agent.prompt(input);
+        entry.info.state = 'idle';
+        syncAgentInfo(entry);
+        // Detect the WASM echo stub.
+        const isEchoStub = typeof wasmResult === 'string' &&
+            (wasmResult === `echo: ${input}` || /^echo: /.test(wasmResult.slice(0, 12)));
+        if (!isEchoStub) {
+            return wasmResult;
+        }
+        // Echo stub detected — route through a real LLM call.
+        if (!process.env.ANTHROPIC_API_KEY) {
+            // No key configured; surface the stub honestly with a hint.
+            return `${wasmResult}\n[NOTE: bundled WASM agent has no LLM; set ANTHROPIC_API_KEY to enable real responses via Anthropic Messages API]`;
+        }
+        const { callAnthropicMessages, resolveAnthropicModel } = await import('../mcp-tools/agent-execute-core.js');
+        const model = resolveAnthropicModel(entry.info.config.model);
+        const systemPrompt = entry.info.config.instructions || 'You are a helpful coding assistant running in a Ruflo WASM agent sandbox.';
+        const result = await callAnthropicMessages({
+            prompt: input,
+            systemPrompt,
+            model,
+            maxTokens: 2048,
+        });
+        if (!result.success) {
+            return `${wasmResult}\n[NOTE: bundled WASM agent has no LLM; Anthropic fallback failed: ${result.error}]`;
+        }
+        // Return the real LLM output, not the echo stub.
+        return result.output ?? '';
+    }
+    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/v3/@claude-flow/cli/dist/src/ruvector/ast-analyzer.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 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/v3/@claude-flow/cli/dist/src/ruvector/ast-analyzer.js

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