@ebowwa/coder 0.2.1 → 0.7.64

package/dist/native/index.js

@@ -0,0 +1,1625 @@
+/**
+ * Native module loader
+ * Loads Rust-compiled native modules for performance-critical operations
+ */
+import { dlopen, suffix } from "bun:ffi";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+let nativeModule = null;
+/**
+ * Load the native module
+ */
+export function loadNative() {
+    if (nativeModule) {
+        return nativeModule;
+    }
+    // Try multiple possible locations for the native module
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const basePaths = [
+        join(__dirname, "..", "native"), // dist/../native (library entry)
+        join(__dirname, "..", "..", "native"), // dist/foo/../native
+        join(__dirname, "..", "..", "..", "native"), // dist/foo/bar/../native
+        join(__dirname, "..", "..", "..", "..", "native"), // dist/interfaces/ui/../native
+        join(__dirname, "..", "..", "..", "..", "..", "native"), // dist/interfaces/ui/terminal/../native
+        join(__dirname, "..", "..", "..", "..", "..", "..", "native"), // CLI entry: dist/interfaces/ui/terminal/cli/../native
+        join(__dirname, "native"), // native/ (if running from project root)
+    ];
+    // Try .node files first (NAPI modules)
+    const nodeFiles = ["index.darwin-arm64.node", "index.darwin-x64.node", "index.node"];
+    for (const basePath of basePaths) {
+        for (const file of nodeFiles) {
+            const nativePath = join(basePath, file);
+            try {
+                // Try to load NAPI module directly
+                const native = require(nativePath);
+                if (native && (native.highlightCode || native.highlight_code)) {
+                    // Map camelCase to snake_case if needed
+                    nativeModule = {
+                        highlight_code: native.highlightCode || native.highlight_code,
+                        highlight_markdown: native.highlightMarkdown || native.highlight_markdown,
+                        highlight_diff: native.highlightDiff || native.highlight_diff,
+                        search_files: native.searchFiles || native.search_files,
+                        count_tokens: native.countTokens || native.count_tokens,
+                        calculate_diff: native.calculateDiff || native.calculate_diff,
+                        compact_content: native.compactContent || native.compact_content,
+                        count_tool_use: native.countToolUse || native.count_tool_use,
+                        find_tool_pairs: native.findToolPairs || native.find_tool_pairs,
+                        find_common_patterns: native.findCommonPatterns || native.find_common_patterns,
+                        validate_multi_edits: native.validateMultiEdits || native.validate_multi_edits,
+                        preview_multi_edits: native.previewMultiEdits || native.preview_multi_edits,
+                        apply_multi_edits: native.applyMultiEdits || native.apply_multi_edits,
+                        // Cognitive Security - Action Module (NAPI exports camelCase)
+                        classify_operation: native.classifyOperation,
+                        get_action_types: native.getActionTypes,
+                        get_action_risk_levels: native.getActionRiskLevels,
+                        create_deny_all_policy: native.createDenyAllPolicy,
+                        create_observe_only_policy: native.createObserveOnlyPolicy,
+                        create_transfer_approval_policy: native.createTransferApprovalPolicy,
+                        // Cognitive Security - Intent Module (NAPI exports camelCase)
+                        cs_generate_keypair: native.generateIntentKeypair,
+                        cs_sign_intent: native.signIntent,
+                        cs_verify_intent: native.verifyIntentSignature,
+                        cs_hash_intent: native.hashIntent,
+                        cs_intents_equivalent: native.intentsEquivalent,
+                        cs_score_alignment: native.scoreAlignment,
+                        cs_batch_score_alignment: native.batchScoreAlignment,
+                        cs_check_sequence_violations: native.checkSequenceViolations,
+                        cs_load_intent: native.loadIntentFromFile,
+                        cs_save_intent: native.saveIntentToFile,
+                        cs_parse_intent: native.parseIntent,
+                        cs_serialize_intent: native.serializeIntent,
+                        cs_validate_intent: native.validateIntentStructure,
+                        cs_create_data_collector_intent: native.createDataCollectorIntent,
+                        cs_merge_intents: native.mergeIntents,
+                        cs_analyze_corruption: native.analyzeCorruption,
+                        cs_detect_drift: native.detectBehavioralDrift,
+                        cs_create_empty_snapshot: native.createEmptySnapshot,
+                        cs_update_snapshot: native.updateSnapshot,
+                        // Cognitive Security - Flow Module (NAPI exports camelCase)
+                        classify_data: native.classifyData,
+                        contains_sensitive_data: native.containsSensitiveData,
+                        redact_sensitive: native.redactSensitive,
+                        get_sensitivity_levels: native.getSensitivityLevels,
+                        get_data_categories: native.getDataCategories,
+                        create_flow_policy_engine: native.createFlowPolicyEngine,
+                        create_allow_all_flow_policy: native.createAllowAllFlowPolicy,
+                        create_deny_all_flow_policy: native.createDenyAllFlowPolicy,
+                        create_strict_flow_policy: native.createStrictFlowPolicy,
+                        create_flow_tracker: native.createFlowTracker,
+                        create_leak_prevention: native.createLeakPrevention,
+                        check_for_leaks: native.checkForLeaks,
+                        sanitize_content: native.sanitizeContent,
+                        create_taint_tracker: native.createTaintTracker,
+                        // Quant Functions
+                        quant_version: native.quantVersion || native.quant_version,
+                        quant_ohlcv_new: native.quantOhlcvNew || native.quant_ohlcv_new,
+                        quant_amm_new: native.quantAmmNew || native.quant_amm_new,
+                        quant_amm_calculate_cost: native.quantAmmCalculateCost || native.quant_amm_calculate_cost,
+                        quant_amm_price_impact: native.quantAmmPriceImpact || native.quant_amm_price_impact,
+                        quant_lmsr_price: native.quantLmsrPrice || native.quant_lmsr_price,
+                        quant_lmsr_cost: native.quantLmsrCost || native.quant_lmsr_cost,
+                        quant_detect_arbitrage: native.quantDetectArbitrage || native.quant_detect_arbitrage,
+                        quant_convert_odds: native.quantConvertOdds || native.quant_convert_odds,
+                        quant_mean: native.quantMean || native.quant_mean,
+                        quant_std_dev: native.quantStdDev || native.quant_std_dev,
+                        quant_variance: native.quantVariance || native.quant_variance,
+                        quant_correlation: native.quantCorrelation || native.quant_correlation,
+                        // Terminal Input
+                        create_terminal: native.createTerminal || native.create_terminal,
+                        // Native TUI
+                        create_tui: native.createTui || native.create_tui,
+                        is_native_tui_available: () => typeof (native.createTui || native.create_tui) === 'function',
+                    };
+                    return nativeModule;
+                }
+            }
+            catch {
+                // Try next path
+                continue;
+            }
+        }
+    }
+    // Try FFI with dylib
+    const dylibPaths = basePaths.map(p => join(p, `claude_code_native.${suffix}`));
+    for (const nativePath of dylibPaths) {
+        try {
+            const lib = dlopen(nativePath, {
+                highlight_code: {
+                    args: ["cstring", "cstring"],
+                    returns: "pointer",
+                },
+                highlight_markdown: {
+                    args: ["cstring"],
+                    returns: "pointer",
+                },
+                highlight_diff: {
+                    args: ["cstring", "cstring", "pointer"],
+                    returns: "pointer",
+                },
+                search_files: {
+                    args: ["cstring", "cstring", "pointer"],
+                    returns: "pointer",
+                },
+                count_tokens: {
+                    args: ["cstring"],
+                    returns: "u32",
+                },
+                calculate_diff: {
+                    args: ["cstring", "cstring"],
+                    returns: "pointer",
+                },
+                compact_content: {
+                    args: ["cstring", "u32", "cstring"],
+                    returns: "pointer",
+                },
+            });
+            nativeModule = lib.symbols;
+            return nativeModule;
+        }
+        catch {
+            continue;
+        }
+    }
+    // No native module found, use fallback
+    console.warn("Native module not available, using JS fallback");
+    return getFallbackModule();
+}
+/**
+ * Check if native module is available
+ */
+export function isNativeAvailable() {
+    try {
+        loadNative();
+        return nativeModule !== null;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Fallback implementations in pure JavaScript
+ */
+function getFallbackModule() {
+    return {
+        highlight_code: (code, language) => {
+            // ANSI color codes
+            const colors = {
+                reset: "\x1b[0m",
+                keyword: "\x1b[38;2;180;142;173m", // purple
+                string: "\x1b[38;2;163;190;140m", // green
+                number: "\x1b[38;2;208;135;112m", // orange
+                type: "\x1b[38;2;191;97;106m", // red
+                function: "\x1b[38;2;143;161;179m", // blue
+                comment: "\x1b[38;2;108;153;139m", // gray-green
+                default: "\x1b[38;2;192;197;206m", // gray
+                special: "\x1b[38;2;150;180;210m", // light blue
+                arrow: "\x1b[38;2;200;160;120m", // gold/tan
+            };
+            // Mermaid-specific highlighting
+            if (language.toLowerCase() === "mermaid" || language.toLowerCase() === "mmd") {
+                const MERMAID_KEYWORDS = new Set([
+                    // Diagram types
+                    "graph", "flowchart", "sequenceDiagram", "classDiagram", "stateDiagram",
+                    "erDiagram", "journey", "gantt", "pie", "gitGraph", "mindmap", "timeline",
+                    "quadrantChart", "requirementDiagram", "C4Context", "C4Container",
+                    "C4Component", "C4Dynamic", "C4Deployment",
+                    // Directions
+                    "TB", "TD", "BT", "RL", "LR", "left", "right", "top", "bottom",
+                    // Subgraphs/participants
+                    "subgraph", "end", "participant", "actor", "as",
+                    // Flowchart
+                    "node", "click", "link", "href", "callback",
+                    // Sequence
+                    "Note", "over", "loop", "alt", "else", "opt", "par", "rect", "autonumber",
+                    "activate", "deactivate",
+                    // Class
+                    "class", "namespace", "interface", "annotation", "service", "enum",
+                    // State
+                    "state", "note", "fork", "join", "choice",
+                    // ER
+                    "entity",
+                    // Gantt
+                    "dateFormat", "title", "section", "excludes", "includes", "todayMarker",
+                    // Common
+                    "title", "accTitle", "accDescr",
+                ]);
+                const MERMAID_ARROWS = new Set([
+                    "-->", "---", "->", "->>", "-.", "-.-", "==>", "==", "--x", "--o",
+                    "<--", "<-", "<<-", "<-->", "<->", "o--o", "x--x", "-x", "-o",
+                ]);
+                const MERMAID_SHAPES = [
+                    ["[", "]"], // rect
+                    ["(", ")"], // rounded
+                    ["([", "])"], // stadium
+                    ["[[", "]]"], // subroutine
+                    ["[((", ")]"], // cylinder
+                    [">", "]"], // asymmetric
+                    ["{", "}"], // rhombus
+                    ["{{", "}}"], // hexagon
+                    ["[/", "/]"], // parallelogram
+                    ["[\\", "\\]"], // parallelogram alt
+                    ["[(", ")]"], // circle
+                    ["(((", ")))"], // double circle
+                ];
+                const lines = code.split("\n");
+                const highlighted = lines.map(line => {
+                    let result = line;
+                    // Comments (%%)
+                    if (line.trim().startsWith("%%")) {
+                        return `${colors.comment}${line}${colors.reset}`;
+                    }
+                    // Arrows and connections (handle first to preserve them)
+                    for (const arrow of MERMAID_ARROWS) {
+                        const escaped = arrow.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                        result = result.replace(new RegExp(escaped, 'g'), `${colors.arrow}${arrow}${colors.default}`);
+                    }
+                    // Strings (quoted)
+                    result = result.replace(/"([^"\\]|\\.)*"/g, match => {
+                        return `${colors.string}${match}${colors.default}`;
+                    });
+                    // Numbers
+                    result = result.replace(/\b(\d+\.?\d*)\b/g, `${colors.number}$1${colors.default}`);
+                    // Keywords
+                    result = result.replace(/\b([A-Za-z_][A-Za-z0-9_]*)\b/g, (match) => {
+                        if (MERMAID_KEYWORDS.has(match)) {
+                            return `${colors.keyword}${match}${colors.default}`;
+                        }
+                        return match;
+                    });
+                    // Special characters for shapes
+                    for (const [open, close] of MERMAID_SHAPES) {
+                        if (!open || !close)
+                            continue;
+                        const openEsc = open.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                        const closeEsc = close.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                        result = result.replace(new RegExp(`${openEsc}([^${closeEsc}]+)${closeEsc}`, 'g'), (_, content) => {
+                            return `${colors.special}${open}${content}${close}${colors.default}`;
+                        });
+                    }
+                    // Arrow labels
+                    result = result.replace(/\|([^|]+)\|/g, (_, content) => {
+                        return `${colors.special}|${content}|${colors.default}`;
+                    });
+                    return result;
+                }).join("\n");
+                return {
+                    html: highlighted + colors.reset,
+                    theme: "mermaid",
+                };
+            }
+            // Standard code highlighting
+            const KEYWORDS = new Set([
+                "function", "const", "let", "var", "return", "if", "else", "for", "while",
+                "class", "interface", "type", "import", "export", "from", "async", "await",
+                "try", "catch", "throw", "new", "this", "extends", "implements", "static",
+                "public", "private", "protected", "readonly", "abstract", "enum", "namespace",
+            ]);
+            const TYPES = new Set([
+                "string", "number", "boolean", "void", "null", "undefined", "any", "never",
+                "object", "symbol", "bigint", "true", "false",
+            ]);
+            // Simple tokenization
+            const lines = code.split("\n");
+            const highlighted = lines.map(line => {
+                // Comments
+                if (line.trim().startsWith("//") || line.trim().startsWith("#")) {
+                    return `${colors.comment}${line}${colors.reset}`;
+                }
+                // Replace strings
+                let result = line.replace(/(["'`])(?:(?!\1)[^\\]|\\.)*?\1/g, match => {
+                    return `${colors.string}${match}${colors.default}`;
+                });
+                // Replace numbers
+                result = result.replace(/\b(\d+\.?\d*)\b/g, `${colors.number}$1${colors.default}`);
+                // Replace keywords
+                result = result.replace(/\b([a-z]+)\b/gi, (match) => {
+                    if (KEYWORDS.has(match)) {
+                        return `${colors.keyword}${match}${colors.default}`;
+                    }
+                    if (TYPES.has(match)) {
+                        return `${colors.type}${match}${colors.default}`;
+                    }
+                    return match;
+                });
+                // Function names (before parentheses)
+                result = result.replace(/\b([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g, (_, name) => {
+                    return `${colors.function}${name}${colors.default}(`;
+                });
+                return result;
+            }).join("\n");
+            return {
+                html: highlighted + colors.reset,
+                theme: "fallback",
+            };
+        },
+        highlight_markdown: (markdown) => {
+            // Simple markdown highlighting - just return as-is with reset
+            // Full nested code block highlighting requires native module
+            return {
+                html: markdown + "\x1b[0m",
+                theme: "fallback",
+            };
+        },
+        highlight_diff: (oldText, newText, options) => {
+            // Simple line-based diff with ANSI colors
+            const GREEN = "\x1b[38;2;163;190;140m";
+            const RED = "\x1b[38;2;191;97;106m";
+            const DIM = "\x1b[38;2;108;153;139m";
+            const CYAN = "\x1b[38;2;143;161;179m";
+            const RESET = "\x1b[0m";
+            const oldLines = oldText.split("\n");
+            const newLines = newText.split("\n");
+            let output = "";
+            let additions = 0;
+            let deletions = 0;
+            let hunks = 0;
+            // File header
+            if (options?.file_path) {
+                output += `${CYAN}${options.file_path}${RESET}\n`;
+            }
+            // Simple LCS-based diff
+            const lcs = [];
+            const dp = Array.from({ length: oldLines.length + 1 }, () => Array.from({ length: newLines.length + 1 }, () => 0));
+            for (let i = 0; i <= oldLines.length; i++) {
+                for (let j = 0; j <= newLines.length; j++) {
+                    if (i === 0 || j === 0) {
+                        dp[i][j] = 0;
+                    }
+                    else if (oldLines[i - 1] === newLines[j - 1]) {
+                        dp[i][j] = dp[i - 1][j - 1] + 1;
+                    }
+                    else {
+                        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                    }
+                }
+            }
+            // Backtrack for LCS
+            let i = oldLines.length;
+            let j = newLines.length;
+            const lcsSet = new Set();
+            while (i > 0 && j > 0) {
+                if (oldLines[i - 1] === newLines[j - 1]) {
+                    lcsSet.add(`${i - 1}:${j - 1}`);
+                    lcs.unshift(oldLines[i - 1]);
+                    i--;
+                    j--;
+                }
+                else if (dp[i - 1][j] > dp[i][j - 1]) {
+                    i--;
+                }
+                else {
+                    j--;
+                }
+            }
+            // Build diff output
+            let oldIdx = 0;
+            let newIdx = 0;
+            let lcsIdx = 0;
+            while (oldIdx < oldLines.length || newIdx < newLines.length) {
+                // Skip matching lines
+                while (lcsIdx < lcs.length &&
+                    oldIdx < oldLines.length &&
+                    newIdx < newLines.length &&
+                    oldLines[oldIdx] === lcs[lcsIdx] &&
+                    newLines[newIdx] === lcs[lcsIdx]) {
+                    oldIdx++;
+                    newIdx++;
+                    lcsIdx++;
+                }
+                const oldStart = oldIdx + 1;
+                const newStart = newIdx + 1;
+                let oldCount = 0;
+                let newCount = 0;
+                const hunkLines = [];
+                // Collect removed lines
+                while (oldIdx < oldLines.length &&
+                    (lcsIdx >= lcs.length || oldLines[oldIdx] !== lcs[lcsIdx])) {
+                    hunkLines.push(`${RED}-${oldLines[oldIdx]}${RESET}`);
+                    oldIdx++;
+                    oldCount++;
+                    deletions++;
+                }
+                // Collect added lines
+                while (newIdx < newLines.length &&
+                    (lcsIdx >= lcs.length || newLines[newIdx] !== lcs[lcsIdx])) {
+                    hunkLines.push(`${GREEN}+${newLines[newIdx]}${RESET}`);
+                    newIdx++;
+                    newCount++;
+                    additions++;
+                }
+                if (oldCount > 0 || newCount > 0) {
+                    hunks++;
+                    output += `${DIM}@@ -${oldStart},${oldCount} +${newStart},${newCount} @@${RESET}\n`;
+                    output += hunkLines.join("\n") + "\n";
+                }
+            }
+            return { output, additions, deletions, hunks };
+        },
+        search_files: (pattern, path, options) => {
+            // Simple grep fallback
+            return {
+                matches: [],
+                total_count: 0,
+                files_searched: 0,
+            };
+        },
+        count_tokens: (text) => {
+            // Approximate token count: ~4 chars per token
+            return Math.ceil(text.length / 4);
+        },
+        calculate_diff: (oldText, newText) => {
+            // Simple line-based diff
+            const oldLines = oldText.split("\n");
+            const newLines = newText.split("\n");
+            const hunks = [];
+            // Very simple diff - just show all changes as one hunk
+            if (oldText !== newText) {
+                hunks.push({
+                    oldStart: 1,
+                    oldLines: oldLines.length,
+                    newStart: 1,
+                    newLines: newLines.length,
+                    content: `- ${oldLines.join("\n- ")}\n+ ${newLines.join("\n+ ")}`,
+                });
+            }
+            return hunks;
+        },
+        compact_content: (content, maxTokens, strategy = "truncate") => {
+            const charsPerToken = 4;
+            const maxChars = maxTokens * charsPerToken;
+            if (content.length <= maxChars) {
+                return content;
+            }
+            switch (strategy) {
+                case "truncate":
+                    return (content.slice(0, maxChars / 2) +
+                        "\n\n... [truncated] ...\n\n" +
+                        content.slice(-maxChars / 2));
+                case "summarize":
+                    // Return first and last sections
+                    const quarter = Math.floor(maxChars / 4);
+                    return ("=== BEGINNING ===\n" +
+                        content.slice(0, quarter) +
+                        "\n\n=== END ===\n" +
+                        content.slice(-quarter));
+                case "extract":
+                    // Return important lines only
+                    const lines = content.split("\n");
+                    const important = lines.filter((line) => line.trim().startsWith("#") ||
+                        line.trim().startsWith("function") ||
+                        line.trim().startsWith("const") ||
+                        line.trim().startsWith("class") ||
+                        line.trim().startsWith("export") ||
+                        line.trim().startsWith("import"));
+                    return important.slice(0, maxChars / 50).join("\n");
+                default:
+                    return content.slice(0, maxChars);
+            }
+        },
+        // Multi-file editing fallback implementation
+        validate_multi_edits: (edits) => {
+            const errors = [];
+            const fileContents = new Map();
+            const fs = require('fs');
+            for (const edit of edits) {
+                // Check file exists
+                try {
+                    if (!fs.existsSync(edit.filePath)) {
+                        errors.push(`File not found: ${edit.filePath}`);
+                        continue;
+                    }
+                    // Load file content if not already loaded
+                    if (!fileContents.has(edit.filePath)) {
+                        const content = fs.readFileSync(edit.filePath, 'utf-8');
+                        fileContents.set(edit.filePath, content);
+                    }
+                    const content = fileContents.get(edit.filePath);
+                    // Check oldString exists
+                    if (!content.includes(edit.oldString)) {
+                        errors.push(`String not found in ${edit.filePath}: "${truncateString(edit.oldString, 50)}"`);
+                        continue;
+                    }
+                    // Check uniqueness if not replaceAll
+                    if (!edit.replaceAll) {
+                        const count = (content.match(new RegExp(escapeRegex(edit.oldString), "g")) || []).length;
+                        if (count > 1) {
+                            errors.push(`String appears ${count} times in ${edit.filePath}. Use replaceAll or provide more context.`);
+                        }
+                    }
+                }
+                catch (err) {
+                    errors.push(`Error reading ${edit.filePath}: ${err}`);
+                }
+            }
+            return errors;
+        },
+        preview_multi_edits: (edits) => {
+            const results = [];
+            const fileReplacements = new Map();
+            const fs = require('fs');
+            for (const edit of edits) {
+                try {
+                    if (!fs.existsSync(edit.filePath))
+                        continue;
+                    const content = fs.readFileSync(edit.filePath, 'utf-8');
+                    const count = edit.replaceAll
+                        ? (content.match(new RegExp(escapeRegex(edit.oldString), "g")) || []).length
+                        : 1;
+                    fileReplacements.set(edit.filePath, (fileReplacements.get(edit.filePath) || 0) + count);
+                }
+                catch {
+                    // Skip files that can't be read
+                }
+            }
+            for (const [filePath, replacementCount] of fileReplacements) {
+                results.push({ filePath, replacementCount });
+            }
+            return results;
+        },
+        apply_multi_edits: (edits) => {
+            // First validate all edits
+            const errors = getFallbackModule().validate_multi_edits(edits);
+            if (errors.length > 0) {
+                return {
+                    success: false,
+                    filesModified: [],
+                    totalReplacements: 0,
+                    error: errors.join("\n"),
+                    rolledBack: false,
+                };
+            }
+            // Create backups
+            const backups = new Map();
+            const uniqueFiles = new Set(edits.map(e => e.filePath));
+            const fs = require('fs');
+            for (const filePath of uniqueFiles) {
+                try {
+                    backups.set(filePath, fs.readFileSync(filePath, 'utf-8'));
+                }
+                catch (err) {
+                    return {
+                        success: false,
+                        filesModified: [],
+                        totalReplacements: 0,
+                        error: `Failed to backup ${filePath}: ${err}`,
+                        rolledBack: false,
+                    };
+                }
+            }
+            // Apply edits
+            const currentContents = new Map();
+            for (const [path, content] of backups) {
+                currentContents.set(path, content);
+            }
+            let totalReplacements = 0;
+            for (const edit of edits) {
+                const content = currentContents.get(edit.filePath);
+                if (!content)
+                    continue;
+                if (edit.replaceAll) {
+                    const count = (content.match(new RegExp(escapeRegex(edit.oldString), "g")) || []).length;
+                    currentContents.set(edit.filePath, content.split(edit.oldString).join(edit.newString));
+                    totalReplacements += count;
+                }
+                else {
+                    currentContents.set(edit.filePath, content.replace(edit.oldString, edit.newString));
+                    totalReplacements += 1;
+                }
+            }
+            // Write all files
+            const filesModified = [];
+            for (const [path, newContent] of currentContents) {
+                const originalContent = backups.get(path);
+                if (newContent !== originalContent) {
+                    try {
+                        Bun.write(path, newContent);
+                        filesModified.push(path);
+                    }
+                    catch (err) {
+                        // Rollback on failure
+                        for (const [rollbackPath, rollbackContent] of backups) {
+                            try {
+                                Bun.write(rollbackPath, rollbackContent);
+                            }
+                            catch {
+                                // Ignore rollback errors
+                            }
+                        }
+                        return {
+                            success: false,
+                            filesModified: [],
+                            totalReplacements: 0,
+                            error: `Failed to write ${path}: ${err}. All changes rolled back.`,
+                            rolledBack: true,
+                        };
+                    }
+                }
+            }
+            return {
+                success: true,
+                filesModified: filesModified,
+                totalReplacements: totalReplacements,
+                error: undefined,
+                rolledBack: false,
+            };
+        },
+        // Tool analysis fallback implementations
+        count_tool_use: (messages) => {
+            const counts = {};
+            for (const msg of messages) {
+                if (msg.tool_use) {
+                    for (const tool of msg.tool_use) {
+                        counts[tool.name] = (counts[tool.name] || 0) + 1;
+                    }
+                }
+            }
+            return counts;
+        },
+        find_tool_pairs: (messages, _windowSize) => {
+            const pairs = {};
+            for (const msg of messages) {
+                if (msg.tool_use && msg.tool_use.length >= 2) {
+                    for (let i = 0; i < msg.tool_use.length - 1; i++) {
+                        const tool1 = msg.tool_use[i]?.name;
+                        const tool2 = msg.tool_use[i + 1]?.name;
+                        if (tool1 && tool2) {
+                            if (!pairs[tool1])
+                                pairs[tool1] = {};
+                            pairs[tool1][tool2] = (pairs[tool1][tool2] || 0) + 1;
+                        }
+                    }
+                }
+            }
+            return pairs;
+        },
+        find_common_patterns: (messages) => {
+            const patterns = [];
+            const toolPairs = new Map();
+            let totalPairs = 0;
+            for (const msg of messages) {
+                if (msg.tool_use && msg.tool_use.length >= 2) {
+                    for (let i = 0; i < msg.tool_use.length - 1; i++) {
+                        const name1 = msg.tool_use[i]?.name;
+                        const name2 = msg.tool_use[i + 1]?.name;
+                        if (name1 && name2) {
+                            const key = `${name1}|${name2}`;
+                            toolPairs.set(key, (toolPairs.get(key) || 0) + 1);
+                            totalPairs++;
+                        }
+                    }
+                }
+            }
+            for (const [key, count] of toolPairs) {
+                const [tool1, tool2] = key.split("|");
+                patterns.push({
+                    tools: [tool1, tool2],
+                    count,
+                    percentage: totalPairs > 0 ? (count / totalPairs) * 100 : 0,
+                });
+            }
+            return patterns.sort((a, b) => b.count - a.count).slice(0, 10);
+        },
+        // ===== Cognitive Security Fallbacks =====
+        // Action Module
+        classify_operation: (operation, domain, target, reasoning) => {
+            const id = `action_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+            let actionType = "observe";
+            let riskLevel = 1;
+            let hasSideEffects = false;
+            let requiresApproval = false;
+            const op = operation.toLowerCase();
+            if (op.includes("write") || op.includes("edit") || op.includes("create") || op.includes("delete")) {
+                actionType = "modify";
+                riskLevel = 3;
+                hasSideEffects = true;
+                requiresApproval = true;
+            }
+            else if (op.includes("execute") || op.includes("run") || op.includes("bash")) {
+                actionType = "execute";
+                riskLevel = 4;
+                hasSideEffects = true;
+                requiresApproval = true;
+            }
+            else if (op.includes("send") || op.includes("post") || op.includes("transmit")) {
+                actionType = "communicate";
+                riskLevel = 2;
+                hasSideEffects = true;
+                requiresApproval = domain === "external";
+            }
+            else if (op.includes("read") || op.includes("get") || op.includes("list") || op.includes("search")) {
+                actionType = "observe";
+                riskLevel = 1;
+                hasSideEffects = false;
+                requiresApproval = false;
+            }
+            return {
+                id,
+                actionType,
+                domain,
+                operation,
+                target: target || null,
+                flowDirection: "outbound",
+                riskLevel,
+                hasSideEffects,
+                requiresApproval,
+                reasoning: reasoning || `Classified as ${actionType} based on operation name`,
+                timestamp: Date.now(),
+                metadata: null,
+            };
+        },
+        get_action_types: () => ["modify", "execute", "communicate", "transfer", "observe", "create", "delete"],
+        get_action_risk_levels: () => [
+            { actionType: "observe", riskLevel: 1 },
+            { actionType: "communicate", riskLevel: 2 },
+            { actionType: "create", riskLevel: 3 },
+            { actionType: "modify", riskLevel: 3 },
+            { actionType: "transfer", riskLevel: 4 },
+            { actionType: "execute", riskLevel: 4 },
+            { actionType: "delete", riskLevel: 5 },
+        ],
+        create_deny_all_policy: () => ({
+            id: "deny_all",
+            description: "Deny all actions",
+            actionTypes: [],
+            domains: [],
+            operations: [],
+            effect: "deny",
+            priority: 1000,
+            enabled: true,
+        }),
+        create_observe_only_policy: () => ({
+            id: "observe_only",
+            description: "Allow observe actions only",
+            actionTypes: ["observe"],
+            domains: [],
+            operations: [],
+            effect: "allow",
+            priority: 100,
+            enabled: true,
+        }),
+        create_transfer_approval_policy: () => ({
+            id: "transfer_approval",
+            description: "Require approval for transfer actions",
+            actionTypes: ["transfer"],
+            domains: [],
+            operations: [],
+            effect: "require_approval",
+            priority: 200,
+            enabled: true,
+        }),
+        // Intent Module
+        cs_generate_keypair: () => ({
+            privateKey: `private_${Math.random().toString(36).slice(2)}_${Date.now()}`,
+            publicKey: `public_${Math.random().toString(36).slice(2)}_${Date.now()}`,
+        }),
+        cs_sign_intent: (intent, _privateKey) => {
+            return { ...intent, signature: `sig_${Date.now()}`, signedBy: "fallback" };
+        },
+        cs_verify_intent: (_intent) => ({
+            valid: true,
+            error: null,
+            signatureValid: true,
+            contentIntact: true,
+            expired: false,
+        }),
+        cs_hash_intent: (intent) => {
+            const str = JSON.stringify(intent);
+            let hash = 0;
+            for (let i = 0; i < str.length; i++) {
+                const char = str.charCodeAt(i);
+                hash = ((hash << 5) - hash) + char;
+                hash = hash & hash;
+            }
+            return Math.abs(hash).toString(16).padStart(16, '0');
+        },
+        cs_intents_equivalent: (intent1, intent2) => {
+            const stripSignature = (i) => {
+                const { signature, signedBy, ...rest } = i;
+                return rest;
+            };
+            return JSON.stringify(stripSignature(intent1)) === JSON.stringify(stripSignature(intent2));
+        },
+        cs_score_alignment: (_action, _intent) => ({
+            score: 0.8,
+            reasoning: "Fallback alignment score - native module not available",
+            servesGoals: [],
+            hindersGoals: [],
+            boundaryConcerns: [],
+            confidence: 0.5,
+            shouldBlock: false,
+            requiresReview: false,
+        }),
+        cs_batch_score_alignment: (actions, intent) => {
+            return actions.map(() => ({
+                score: 0.8,
+                reasoning: "Fallback alignment score",
+                servesGoals: [],
+                hindersGoals: [],
+                boundaryConcerns: [],
+                confidence: 0.5,
+                shouldBlock: false,
+                requiresReview: false,
+            }));
+        },
+        cs_check_sequence_violations: (_actions, _intent) => [],
+        cs_load_intent: (_path) => {
+            throw new Error("Native module required for cs_load_intent");
+        },
+        cs_save_intent: (_intent, _path) => {
+            throw new Error("Native module required for cs_save_intent");
+        },
+        cs_parse_intent: (json) => JSON.parse(json),
+        cs_serialize_intent: (intent) => JSON.stringify(intent, null, 2),
+        cs_validate_intent: (intent) => {
+            const errors = [];
+            const warnings = [];
+            if (!intent.id)
+                errors.push("Missing intent id");
+            if (!intent.version)
+                warnings.push("Missing version");
+            if (!intent.identity)
+                errors.push("Missing identity");
+            if (!intent.purpose)
+                errors.push("Missing purpose");
+            return {
+                valid: errors.length === 0,
+                errors,
+                warnings,
+            };
+        },
+        cs_create_data_collector_intent: (name, description) => ({
+            id: `intent_${Date.now()}`,
+            version: 1,
+            identity: {
+                name,
+                description,
+                capabilities: ["read", "list", "search"],
+                constraints: ["no_write", "no_execute", "no_network"],
+            },
+            purpose: {
+                goals: [],
+                nonGoals: ["modify_data", "execute_commands", "send_data"],
+                boundaries: [],
+            },
+            principles: {
+                values: ["transparency", "privacy"],
+                priorities: ["safety_first"],
+                forbidden: ["exfiltration", "modification"],
+            },
+            createdAt: Date.now(),
+        }),
+        cs_merge_intents: (base, override) => ({ ...base, ...override }),
+        cs_analyze_corruption: (_snapshot, _intent) => ({
+            riskScore: 0,
+            indicators: [],
+            recommendation: "continue",
+            explanation: "Fallback analysis - native module not available",
+        }),
+        cs_detect_drift: (_baseline, _current) => ({
+            overallDrift: 0,
+            driftFactors: [],
+            concernLevel: "none",
+        }),
+        cs_create_empty_snapshot: () => ({
+            timestamp: Date.now(),
+            actionCount: 0,
+            alignmentDistribution: { mean: 1, variance: 0, min: 1, max: 1, belowThresholdCount: 0 },
+            actionsByDomain: [],
+            actionsByType: [],
+            boundaryViolations: 0,
+            actionsBlocked: 0,
+        }),
+        cs_update_snapshot: (snapshot, _action, alignment) => {
+            const newScore = alignment?.score ?? 1;
+            const oldMean = snapshot.alignmentDistribution?.mean ?? 1;
+            const newMean = (oldMean * snapshot.actionCount + newScore) / (snapshot.actionCount + 1);
+            return {
+                ...snapshot,
+                timestamp: Date.now(),
+                actionCount: snapshot.actionCount + 1,
+                alignmentDistribution: {
+                    ...snapshot.alignmentDistribution,
+                    mean: newMean,
+                },
+            };
+        },
+        // Flow Module
+        classify_data: (content, source, tags) => {
+            let sensitivity = "internal";
+            let category = "generic";
+            if (content.includes("password") || content.includes("secret") || content.includes("key")) {
+                sensitivity = "secret";
+                category = "credentials";
+            }
+            else if (content.includes("@") && content.includes(".")) {
+                sensitivity = "confidential";
+                category = "pii";
+            }
+            return {
+                id: `data_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+                sensitivity,
+                category,
+                source,
+                tags,
+                can_log: sensitivity !== "secret",
+                can_transmit: sensitivity === "public" || sensitivity === "internal",
+                can_store: true,
+                expires_at: null,
+                created_at: Date.now(),
+            };
+        },
+        contains_sensitive_data: (content) => {
+            const patterns = ["password", "secret", "api_key", "token", "credential"];
+            return patterns.some(p => content.toLowerCase().includes(p));
+        },
+        redact_sensitive: (content, replacement) => {
+            const repl = replacement || "[REDACTED]";
+            return content
+                .replace(/password[=:]\s*\S+/gi, `password=${repl}`)
+                .replace(/api[_-]?key[=:]\s*\S+/gi, `api_key=${repl}`)
+                .replace(/token[=:]\s*\S+/gi, `token=${repl}`)
+                .replace(/secret[=:]\s*\S+/gi, `secret=${repl}`);
+        },
+        get_sensitivity_levels: () => [
+            { name: "public", value: 1, description: "Publicly shareable" },
+            { name: "internal", value: 2, description: "Internal use only" },
+            { name: "confidential", value: 3, description: "Confidential" },
+            { name: "secret", value: 4, description: "Highly sensitive" },
+            { name: "top_secret", value: 5, description: "Maximum sensitivity" },
+        ],
+        get_data_categories: () => [
+            { name: "generic", description: "Generic data" },
+            { name: "pii", description: "Personally identifiable information" },
+            { name: "credentials", description: "Authentication credentials" },
+            { name: "financial", description: "Financial data" },
+            { name: "source_code", description: "Source code" },
+            { name: "configuration", description: "Configuration data" },
+        ],
+        // Flow Policy Engine
+        create_flow_policy_engine: () => ({
+            addPolicy: (_policy) => { },
+            removePolicy: (_id) => true,
+            evaluate: (_data, _source, _target) => ({
+                allowed: true,
+                reason: "Fallback: allowed by default",
+                applied_policy: null,
+                can_log: true,
+                can_transmit: true,
+                can_store: true,
+                transformations: [],
+                confidence: 0.5,
+                warnings: ["Fallback implementation - native module not available"],
+            }),
+            listPolicies: () => [],
+            setDefaultAction: (_action) => { },
+            setBlpMode: (_mode) => { },
+        }),
+        // Flow Policies
+        create_allow_all_flow_policy: () => ({
+            id: "allow_all",
+            description: "Allow all flows",
+            source_pattern: "*",
+            target_pattern: "*",
+            min_source_sensitivity: null,
+            max_target_sensitivity: null,
+            categories: [],
+            effect: "allow",
+            priority: 0,
+            required_transforms: [],
+            log_flow: false,
+            require_approval: false,
+            conditions: null,
+            enabled: true,
+        }),
+        create_deny_all_flow_policy: () => ({
+            id: "deny_all",
+            description: "Deny all flows",
+            source_pattern: "*",
+            target_pattern: "*",
+            min_source_sensitivity: null,
+            max_target_sensitivity: null,
+            categories: [],
+            effect: "deny",
+            priority: 1000,
+            required_transforms: [],
+            log_flow: false,
+            require_approval: false,
+            conditions: null,
+            enabled: true,
+        }),
+        create_strict_flow_policy: () => ({
+            id: "strict",
+            description: "Strict flow policy",
+            source_pattern: "*",
+            target_pattern: "*",
+            min_source_sensitivity: "internal",
+            max_target_sensitivity: null,
+            categories: [],
+            effect: "transform",
+            priority: 500,
+            required_transforms: ["redact_sensitive"],
+            log_flow: true,
+            require_approval: true,
+            conditions: null,
+            enabled: true,
+        }),
+        // Flow Tracker
+        create_flow_tracker: () => ({
+            record: (_data, _source, _target, _direction, _validation, _sessionId, _actionId) => ({
+                id: `flow_${Date.now()}`,
+                data_id: _data.id,
+                source_domain: _source,
+                target_domain: _target,
+                direction: _direction,
+                allowed: _validation.allowed,
+                reason: _validation.reason,
+                policy_id: _validation.applied_policy || null,
+                session_id: _sessionId,
+                action_id: _actionId,
+                timestamp: Date.now(),
+                data_hash: "",
+            }),
+            getFlow: (_id) => null,
+            getLineage: (_dataId) => [],
+            bySource: (_domain) => [],
+            byTarget: (_domain) => [],
+            bySession: (_sessionId) => [],
+            blocked: () => [],
+            allowed: () => [],
+            recent: (_limit) => [],
+            stats: () => ({
+                total_flows: 0,
+                allowed_count: 0,
+                blocked_count: 0,
+                by_direction: [],
+                by_source_domain: [],
+                by_target_domain: [],
+                first_timestamp: Date.now(),
+                last_timestamp: Date.now(),
+            }),
+            domainStats: (_domain) => null,
+            count: () => 0,
+            clear: () => { },
+            setMaxFlows: (_max) => { },
+            exportJsonl: () => "",
+        }),
+        // Leak Prevention
+        create_leak_prevention: () => ({
+            check: (_content, _channel) => ({
+                action: "allow",
+                detections: [],
+                channel_allowed: true,
+                checked_at: Date.now(),
+            }),
+            sanitize: (content) => content
+                .replace(/password[=:]\s*\S+/gi, "password=[REDACTED]")
+                .replace(/api[_-]?key[=:]\s*\S+/gi, "api_key=[REDACTED]")
+                .replace(/token[=:]\s*\S+/gi, "token=[REDACTED]")
+                .replace(/secret[=:]\s*\S+/gi, "secret=[REDACTED]"),
+            registerSensitive: (_data) => { },
+            addChannel: (_channel) => { },
+            removeChannel: (_channel) => { },
+            setMode: (_mode) => { },
+            stats: () => ({
+                total_checks: 0,
+                blocked_count: 0,
+                alert_count: 0,
+                by_leak_type: {},
+            }),
+            clearSensitive: () => { },
+        }),
+        // Leak Prevention helpers
+        check_for_leaks: (content, channel) => ({
+            action: "allow",
+            detections: [],
+            channel_allowed: true,
+            checked_at: Date.now(),
+        }),
+        sanitize_content: (content) => content
+            .replace(/password[=:]\s*\S+/gi, "password=[REDACTED]")
+            .replace(/api[_-]?key[=:]\s*\S+/gi, "api_key=[REDACTED]")
+            .replace(/token[=:]\s*\S+/gi, "token=[REDACTED]")
+            .replace(/secret[=:]\s*\S+/gi, "secret=[REDACTED]"),
+        // Taint Tracker
+        create_taint_tracker: () => ({
+            registerSource: (_type, _sensitivity, _tags) => `source_${Date.now()}`,
+            taint: (_sourceId, _data, _locationType, _identifier) => `taint_${Date.now()}`,
+            propagate: (_sourceTaintId, _newData, _locationType, _identifier, _propagationType, _operation) => `prop_${Date.now()}`,
+            canFlow: (_taintId, _sink) => ({ allowed: true, reason: "Fallback", requires_sanitization: false }),
+            isTainted: (_data) => false,
+            getTaint: (_taintId) => null,
+            stats: () => ({
+                total_sources: 0,
+                total_tainted: 0,
+                total_propagations: 0,
+                by_source_type: {},
+                by_sensitivity: {},
+            }),
+            clear: (_taintId) => false,
+            clearAll: () => { },
+        }),
+        // Quant Functions (stubs)
+        quant_version: () => "0.1.0-fallback",
+        quant_ohlcv_new: (_ts, _o, _h, _l, _c, _v) => JSON.stringify({ open: _o, high: _h, low: _l, close: _c, volume: _v }),
+        quant_amm_new: (_poolYes, _poolNo, _fee) => JSON.stringify({ poolYes: _poolYes, poolNo: _poolNo, fee: _fee }),
+        quant_amm_calculate_cost: (_poolYes, _poolNo, _buyYes, _shares) => JSON.stringify({ cost: 0 }),
+        quant_amm_price_impact: (_poolYes, _poolNo, _buyYes, _shares) => JSON.stringify({ impact: 0 }),
+        quant_lmsr_price: (_yesShares, _noShares, _b) => JSON.stringify({ price: 0.5 }),
+        quant_lmsr_cost: (_yesShares, _noShares, _b, _buyYes, _shares) => JSON.stringify({ cost: 0 }),
+        quant_detect_arbitrage: (_yesPrice, _noPrice) => JSON.stringify({ hasArbitrage: false }),
+        quant_convert_odds: (_value, _fromType) => JSON.stringify({ decimal: 0 }),
+        quant_mean: (_data) => 0,
+        quant_std_dev: (_data) => 0,
+        quant_variance: (_data) => 0,
+        quant_correlation: (_x, _y) => 0,
+        // Terminal Input (fallback - uses Node.js stdin directly)
+        create_terminal: () => {
+            let inRawMode = false;
+            return {
+                get isRawMode() { return inRawMode; },
+                enterRawMode() {
+                    if (process.stdin.isTTY && !inRawMode) {
+                        process.stdin.setRawMode(true);
+                        process.stdin.resume();
+                        inRawMode = true;
+                    }
+                },
+                exitRawMode() {
+                    if (process.stdin.isTTY && inRawMode) {
+                        process.stdin.setRawMode(false);
+                        inRawMode = false;
+                    }
+                },
+                pollEvent(_timeoutMs) {
+                    // Fallback can't poll synchronously - return null
+                    // Use readEvent() instead for async operation
+                    return null;
+                },
+                async readEvent() {
+                    return new Promise((resolve) => {
+                        const handler = (buffer) => {
+                            process.stdin.off("data", handler);
+                            const str = buffer.toString("utf8");
+                            // Parse simple keypresses
+                            if (str === "\r" || str === "\n") {
+                                resolve({ code: "enter", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                            }
+                            else if (str === "\x03") {
+                                // Ctrl+C
+                                resolve({ code: "c", is_special: false, ctrl: true, alt: false, shift: false, kind: "press" });
+                            }
+                            else if (str === "\x7f" || str === "\x08") {
+                                resolve({ code: "backspace", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                            }
+                            else if (str === "\x1b") {
+                                resolve({ code: "escape", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                            }
+                            else if (str === "\t") {
+                                resolve({ code: "tab", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                            }
+                            else if (str.length === 1 && str >= " ") {
+                                // Regular printable character
+                                const ctrl = str.charCodeAt(0) < 32;
+                                const char = ctrl ? String.fromCharCode(str.charCodeAt(0) + 96) : str;
+                                resolve({ code: char, is_special: false, ctrl, alt: false, shift: false, kind: "press" });
+                            }
+                            else {
+                                // Handle escape sequences for arrows and special keys
+                                if (str === "\x1b[A") {
+                                    resolve({ code: "up", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                                }
+                                else if (str === "\x1b[B") {
+                                    resolve({ code: "down", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                                }
+                                else if (str === "\x1b[C") {
+                                    resolve({ code: "right", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                                }
+                                else if (str === "\x1b[D") {
+                                    resolve({ code: "left", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                                }
+                                else if (str === "\x1b[5~") {
+                                    resolve({ code: "pageup", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                                }
+                                else if (str === "\x1b[6~") {
+                                    resolve({ code: "pagedown", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                                }
+                                else if (str === "\x1b[H" || str === "\x1b[1~") {
+                                    resolve({ code: "home", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                                }
+                                else if (str === "\x1b[F" || str === "\x1b[4~") {
+                                    resolve({ code: "end", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                                }
+                                else if (str === "\x1b[3~") {
+                                    resolve({ code: "delete", is_special: true, ctrl: false, alt: false, shift: false, kind: "press" });
+                                }
+                                else if (str === "\x1b[Z") {
+                                    resolve({ code: "backtab", is_special: true, ctrl: false, alt: false, shift: true, kind: "press" });
+                                }
+                                else {
+                                    // Unknown escape sequence - treat as-is
+                                    resolve({ code: str, is_special: false, ctrl: false, alt: false, shift: false, kind: "press" });
+                                }
+                            }
+                        };
+                        process.stdin.once("data", handler);
+                    });
+                },
+            };
+        },
+        // Native TUI (fallback - not available in pure JS)
+        create_tui: () => {
+            throw new Error("Native TUI not available in fallback mode. Build the Rust native module.");
+        },
+        is_native_tui_available: () => false,
+    };
+}
+// Export a singleton instance
+export const native = loadNative();
+/**
+ * Syntax highlight code with ANSI escape codes for terminal display
+ * Uses native Rust module if available, falls back to JS implementation
+ */
+export function highlight_code(code, language) {
+    return native.highlight_code(code, language);
+}
+/**
+ * Highlight markdown with nested code block syntax highlighting
+ * Parses markdown for code fences and highlights code blocks with their language
+ */
+export function highlight_markdown(markdown) {
+    return native.highlight_markdown(markdown);
+}
+/**
+ * List all supported languages for syntax highlighting
+ */
+export function list_highlight_languages() {
+    return [
+        // Core languages
+        "typescript", "ts", "javascript", "js",
+        "python", "py",
+        "rust", "rs",
+        "go", "golang",
+        "ruby", "rb",
+        "java",
+        "c", "cpp", "c++", "csharp", "cs", "c#",
+        "php",
+        "swift",
+        "kotlin", "kt",
+        "scala",
+        // Shell & config
+        "shell", "sh", "bash", "zsh",
+        "json",
+        "yaml", "yml",
+        "toml",
+        // Markup
+        "markdown", "md",
+        "html", "htm",
+        "css", "scss", "less",
+        "xml",
+        // Database
+        "sql",
+        // Diagrams
+        "mermaid", "mmd",
+    ];
+}
+/**
+ * Highlight a diff with ANSI colors
+ * Uses native Rust module if available, falls back to JS implementation
+ */
+export function highlight_diff(oldText, newText, options) {
+    return native.highlight_diff(oldText, newText, options);
+}
+/**
+ * Calculate diff hunks with hunk headers for LLM context
+ * Returns structured diff with @@ headers included in content
+ */
+export function calculate_diff(oldText, newText) {
+    return native.calculate_diff(oldText, newText);
+}
+// ===== Multi-File Edit Functions =====
+/**
+ * Validate multi-file edits without applying them
+ * Returns an array of error messages (empty if valid)
+ */
+export function validate_multi_edits(edits) {
+    return native.validate_multi_edits(edits);
+}
+/**
+ * Preview what edits would be applied without making changes
+ * Returns an array of { file_path, replacement_count } for each file
+ */
+export function preview_multi_edits(edits) {
+    return native.preview_multi_edits(edits);
+}
+/**
+ * Apply multiple file edits atomically with rollback on failure
+ *
+ * This function:
+ * 1. Validates all edits can be applied (files exist, strings found)
+ * 2. Creates backups of all affected files
+ * 3. Applies all edits
+ * 4. Rolls back on any failure
+ *
+ * @param edits Array of edit operations
+ * @returns Result with success status and list of modified files
+ */
+export function apply_multi_edits(edits) {
+    return native.apply_multi_edits(edits);
+}
+// ===== Helper Functions =====
+function truncateString(s, maxLen) {
+    if (s.length <= maxLen)
+        return s;
+    return s.slice(0, maxLen) + "...";
+}
+function escapeRegex(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+let quantModule = null;
+/**
+ * Load the quant native module from @ebowwa/quant-rust
+ */
+function loadQuant() {
+    if (quantModule)
+        return quantModule;
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    // Try multiple paths for the quant library
+    const libName = process.platform === "darwin"
+        ? "libquant_rust.dylib"
+        : process.platform === "linux"
+            ? "libquant_rust.so"
+            : "quant_rust.dll";
+    const possiblePaths = [
+        // From npm package
+        join(__dirname, "..", "..", "node_modules", "@ebowwa", "quant-rust", "native", `${process.platform}-${process.arch}`, libName),
+        // From npm package (alternate)
+        join(__dirname, "..", "..", "..", "@ebowwa", "quant-rust", "native", `${process.platform}-${process.arch}`, libName),
+        // Development build
+        join(__dirname, "..", "..", "node_modules", "@ebowwa", "quant-rust", "target", "release", libName),
+    ];
+    for (const libPath of possiblePaths) {
+        try {
+            const { existsSync } = require("fs");
+            if (!existsSync(libPath))
+                continue;
+            const { dlopen, FFIType, ptr } = require("bun:ffi");
+            const lib = dlopen(libPath, {
+                quant_version: { returns: FFIType.cstring, args: [] },
+                quant_last_error: { returns: FFIType.cstring, args: [] },
+                quant_clear_error: { returns: FFIType.void, args: [] },
+                quant_ohlcv_new: { returns: FFIType.cstring, args: [FFIType.u64, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64] },
+                quant_amm_new: { returns: FFIType.cstring, args: [FFIType.f64, FFIType.f64, FFIType.f64] },
+                quant_amm_calculate_cost: { returns: FFIType.cstring, args: [FFIType.f64, FFIType.f64, FFIType.bool, FFIType.f64] },
+                quant_amm_price_impact: { returns: FFIType.cstring, args: [FFIType.f64, FFIType.f64, FFIType.bool, FFIType.f64] },
+                quant_lmsr_price: { returns: FFIType.cstring, args: [FFIType.f64, FFIType.f64, FFIType.f64] },
+                quant_lmsr_cost: { returns: FFIType.cstring, args: [FFIType.f64, FFIType.f64, FFIType.f64, FFIType.bool, FFIType.f64] },
+                quant_detect_arbitrage: { returns: FFIType.cstring, args: [FFIType.f64, FFIType.f64] },
+                quant_convert_odds: { returns: FFIType.cstring, args: [FFIType.f64, FFIType.i32] },
+                quant_mean: { returns: FFIType.f64, args: [FFIType.ptr, FFIType.usize] },
+                quant_std_dev: { returns: FFIType.f64, args: [FFIType.ptr, FFIType.usize] },
+                quant_variance: { returns: FFIType.f64, args: [FFIType.ptr, FFIType.usize] },
+                quant_correlation: { returns: FFIType.f64, args: [FFIType.ptr, FFIType.ptr, FFIType.usize] },
+                quant_free_string: { returns: FFIType.void, args: [FFIType.ptr] },
+            });
+            quantModule = lib.symbols;
+            return quantModule;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+// Load quant module
+export const quant = loadQuant();
+// ===== Quant Helper Functions =====
+function parseQuantJson(response) {
+    if (!response) {
+        throw new Error(quant?.quant_last_error() || "Unknown quant error");
+    }
+    return JSON.parse(response);
+}
+function toFloat64Ptr(data) {
+    const { ptr } = require("bun:ffi");
+    const buffer = new Float64Array(data);
+    return { buffer, ptr: ptr(buffer) };
+}
+// ===== Quant Export Functions =====
+/** Warn once when using JS fallback */
+let quantFallbackWarned = false;
+function warnQuantFallback() {
+    if (!quantFallbackWarned) {
+        console.warn("\x1b[33m[quant] WARNING: Rust native module not loaded, using JS fallback\x1b[0m");
+        quantFallbackWarned = true;
+    }
+}
+export function quantVersion() {
+    if (!quant) {
+        warnQuantFallback();
+        return "JS_FALLBACK (rust failed)";
+    }
+    return quant.quant_version();
+}
+export function isQuantAvailable() {
+    return quant !== null;
+}
+// ----- OHLCV -----
+export function createOHLCV(timestamp, open, high, low, close, volume) {
+    if (!quant) {
+        warnQuantFallback();
+        return { timestamp, open, high, low, close, volume };
+    }
+    const response = quant.quant_ohlcv_new(BigInt(timestamp), open, high, low, close, volume);
+    return parseQuantJson(response);
+}
+// ----- AMM -----
+export function createAMM(poolYes, poolNo, fee) {
+    if (!quant) {
+        warnQuantFallback();
+        const k = poolYes * poolNo;
+        return {
+            pool_yes: poolYes,
+            pool_no: poolNo,
+            k,
+            fee,
+            price_yes: poolNo / k,
+            price_no: poolYes / k,
+        };
+    }
+    const response = quant.quant_amm_new(poolYes, poolNo, fee);
+    return parseQuantJson(response);
+}
+export function ammCalculateCost(poolYes, poolNo, outcome, shares) {
+    if (!quant) {
+        warnQuantFallback();
+        const buyYes = typeof outcome === "string" ? outcome === "yes" : outcome;
+        const k = poolYes * poolNo;
+        if (buyYes) {
+            return (k / (poolYes + shares)) - poolNo;
+        }
+        return (k / (poolNo + shares)) - poolYes;
+    }
+    const buyYes = typeof outcome === "string" ? outcome === "yes" : outcome;
+    const response = quant.quant_amm_calculate_cost(poolYes, poolNo, buyYes, shares);
+    const result = parseQuantJson(response);
+    return Math.abs(result.cost);
+}
+export function ammPriceImpact(poolYes, poolNo, outcome, shares) {
+    if (!quant) {
+        warnQuantFallback();
+        const buyYes = typeof outcome === "string" ? outcome === "yes" : outcome;
+        const k = poolYes * poolNo;
+        const priceBefore = buyYes ? poolNo / k : poolYes / k;
+        const newPoolYes = buyYes ? poolYes + shares : poolYes;
+        const newPoolNo = buyYes ? poolNo : poolNo + shares;
+        const priceAfter = buyYes ? newPoolNo / k : newPoolYes / k;
+        return {
+            price_before: priceBefore,
+            price_after: priceAfter,
+            price_impact: Math.abs(priceAfter - priceBefore) / priceBefore,
+            slippage: Math.abs(priceAfter - priceBefore),
+        };
+    }
+    const buyYes = typeof outcome === "string" ? outcome === "yes" : outcome;
+    const response = quant.quant_amm_price_impact(poolYes, poolNo, buyYes, shares);
+    return parseQuantJson(response);
+}
+// ----- LMSR -----
+export function lmsrPrice(yesShares, noShares, b) {
+    if (!quant) {
+        warnQuantFallback();
+        const expYes = Math.exp(yesShares / b);
+        const expNo = Math.exp(noShares / b);
+        const sum = expYes + expNo;
+        return { yes_price: expYes / sum, no_price: expNo / sum, spread: Math.abs(expYes - expNo) / sum };
+    }
+    const response = quant.quant_lmsr_price(yesShares, noShares, b);
+    return parseQuantJson(response);
+}
+export function lmsrCost(yesShares, noShares, b, outcome, shares) {
+    if (!quant) {
+        warnQuantFallback();
+        const buyYes = typeof outcome === "string" ? outcome === "yes" : outcome;
+        const costBefore = b * Math.log(Math.exp(yesShares / b) + Math.exp(noShares / b));
+        const newYes = buyYes ? yesShares + shares : yesShares;
+        const newNo = buyYes ? noShares : noShares + shares;
+        const costAfter = b * Math.log(Math.exp(newYes / b) + Math.exp(newNo / b));
+        return { cost: costAfter - costBefore, avg_price: (costAfter - costBefore) / shares };
+    }
+    const buyYes = typeof outcome === "string" ? outcome === "yes" : outcome;
+    const response = quant.quant_lmsr_cost(yesShares, noShares, b, buyYes, shares);
+    return parseQuantJson(response);
+}
+// ----- Arbitrage -----
+export function detectArbitrage(yesPrice, noPrice) {
+    if (!quant) {
+        warnQuantFallback();
+        const total = yesPrice + noPrice;
+        return {
+            has_arbitrage: total < 1,
+            yes_price: yesPrice,
+            no_price: noPrice,
+            total,
+            profit_per_share: total < 1 ? 1 - total : 0,
+        };
+    }
+    const response = quant.quant_detect_arbitrage(yesPrice, noPrice);
+    return parseQuantJson(response);
+}
+// ----- Odds Conversion -----
+const ODDS_TYPE_MAP = {
+    probability: 0,
+    decimal: 1,
+    american: 2,
+};
+export function convertOdds(value, fromType) {
+    if (!quant) {
+        warnQuantFallback();
+        let prob;
+        switch (fromType) {
+            case "probability":
+                prob = value;
+                break;
+            case "decimal":
+                prob = 1 / value;
+                break;
+            case "american":
+                prob = value > 0 ? 100 / (value + 100) : -value / (-value + 100);
+                break;
+        }
+        const americanOdds = prob >= 0.5 ? Math.round(-100 / (prob - 1)) : Math.round((1 - prob) / prob * 100);
+        return { probability: prob, decimal_odds: 1 / prob, american_odds: americanOdds };
+    }
+    const response = quant.quant_convert_odds(value, ODDS_TYPE_MAP[fromType] ?? 0);
+    return parseQuantJson(response);
+}
+// ----- Statistics -----
+export function quantMean(data) {
+    if (data.length === 0)
+        return NaN;
+    if (!quant) {
+        warnQuantFallback();
+        return data.reduce((a, b) => a + b, 0) / data.length;
+    }
+    const { ptr } = toFloat64Ptr(data);
+    return quant.quant_mean(ptr, data.length);
+}
+export function quantStdDev(data) {
+    if (data.length === 0)
+        return NaN;
+    if (!quant) {
+        warnQuantFallback();
+        const m = data.reduce((a, b) => a + b, 0) / data.length;
+        return Math.sqrt(data.reduce((sum, x) => sum + (x - m) ** 2, 0) / data.length);
+    }
+    const { ptr } = toFloat64Ptr(data);
+    return quant.quant_std_dev(ptr, data.length);
+}
+export function quantVariance(data) {
+    if (data.length === 0)
+        return NaN;
+    if (!quant) {
+        warnQuantFallback();
+        const m = data.reduce((a, b) => a + b, 0) / data.length;
+        return data.reduce((sum, x) => sum + (x - m) ** 2, 0) / data.length;
+    }
+    const { ptr } = toFloat64Ptr(data);
+    return quant.quant_variance(ptr, data.length);
+}
+export function quantCorrelation(x, y) {
+    if (x.length === 0 || y.length === 0 || x.length !== y.length)
+        return NaN;
+    if (!quant) {
+        warnQuantFallback();
+        const n = x.length;
+        const mx = x.reduce((a, b) => a + b, 0) / n;
+        const my = y.reduce((a, b) => a + b, 0) / n;
+        const cov = x.reduce((s, xi, i) => s + (xi - mx) * (y[i] - my), 0) / n;
+        const vx = x.reduce((s, xi) => s + (xi - mx) ** 2, 0) / n;
+        const vy = y.reduce((s, yi) => s + (yi - my) ** 2, 0) / n;
+        return cov / Math.sqrt(vx * vy);
+    }
+    const { ptr: ptrX } = toFloat64Ptr(x);
+    const { ptr: ptrY } = toFloat64Ptr(y);
+    return quant.quant_correlation(ptrX, ptrY, x.length);
+}