csvlod-ai-mcp-server/dist/tools/sis/index.d.ts

CSVLOD-AI MCP Server v3.0 with Quantum Context Intelligence - Revolutionary Context Intelligence Engine and Multimodal Processor for sovereign AI development

export { FileQuantumState } from "./quantum-core/superposition.js";
import { quantumStateTool } from './quantum-state.js';
import { intelSynthesisTool } from './intel-synthesis.js';
import { evolutionExecutorTool } from './evolution-executor.js';
import { streamReaderTool } from './stream-reader.js';
import { compressAnythingTool } from './compress-anything.js';
import { patternDetectorTool } from './pattern-detector.js';
import { sovereigntyGuardTool } from './sovereignty-guard.js';
import { omniversalConsciousnessTool } from './omniversal-consciousness.js';
import { temporalDebuggerTool } from './temporal-debugger.js';
import { realitySpawnerTool } from './reality-spawner.js';
import { thoughtInterfaceTool } from './thought-interface.js';
export { quantumStateTool, intelSynthesisTool, evolutionExecutorTool, streamReaderTool, compressAnythingTool, patternDetectorTool, sovereigntyGuardTool, omniversalConsciousnessTool, temporalDebuggerTool, realitySpawnerTool, thoughtInterfaceTool };
export * from './quantum-core/superposition.js';
export * from './quantum-core/entanglement.js';
export * from './quantum-core/collapse.js';
export declare const SIS_QUANTUM_TOOLS: ({
    name: string;
    description: string;
    parameters: import("zod").ZodObject<{
        depth: import("zod").ZodDefault<import("zod").ZodEnum<["surface", "deep", "quantum"]>>;
        collapse: import("zod").ZodDefault<import("zod").ZodBoolean>;
        nodes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
    }, "strip", import("zod").ZodTypeAny, {
        depth: "surface" | "deep" | "quantum";
        collapse: boolean;
        nodes?: string[] | undefined;
    }, {
        depth?: "surface" | "deep" | "quantum" | undefined;
        collapse?: boolean | undefined;
        nodes?: string[] | undefined;
    }>;
    execute: (args: any) => Promise<{
        collapsed: boolean;
        transitions: number;
        newState: {
            [k: string]: string;
        };
        superposition?: undefined;
        coherence?: undefined;
        entanglements?: undefined;
        predictions?: undefined;
    } | {
        superposition: Map<string, import("./quantum-core/superposition.js").FileQuantumState>;
        coherence: number;
        entanglements: [string, string, number][];
        predictions: Map<string, string>;
        collapsed?: undefined;
        transitions?: undefined;
        newState?: undefined;
    }>;
} | {
    name: string;
    description: string;
    parameters: import("zod").ZodObject<{
        sources: import("zod").ZodArray<import("zod").ZodEnum<["sis", "csvlod", "mcp", "git", "fs"]>, "many">;
        synthesis_type: import("zod").ZodEnum<["narrative", "actionable", "strategic"]>;
        time_window: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
        focus: import("zod").ZodOptional<import("zod").ZodString>;
    }, "strip", import("zod").ZodTypeAny, {
        sources: ("sis" | "csvlod" | "mcp" | "git" | "fs")[];
        synthesis_type: "narrative" | "actionable" | "strategic";
        time_window: string;
        focus?: string | undefined;
    }, {
        sources: ("sis" | "csvlod" | "mcp" | "git" | "fs")[];
        synthesis_type: "narrative" | "actionable" | "strategic";
        time_window?: string | undefined;
        focus?: string | undefined;
    }>;
    execute: (args: any) => Promise<{
        synthesis: string;
        confidence_score: number;
        sources_analyzed: any;
        blind_spots: string[];
        next_actions: string[];
        it_score: number;
    }>;
} | {
    name: string;
    description: string;
    parameters: import("zod").ZodObject<{
        proposal_id: import("zod").ZodOptional<import("zod").ZodString>;
        risk_level: import("zod").ZodDefault<import("zod").ZodEnum<["low", "medium", "high"]>>;
        dry_run: import("zod").ZodDefault<import("zod").ZodBoolean>;
        quantum_verify: import("zod").ZodDefault<import("zod").ZodBoolean>;
        sovereignty_check: import("zod").ZodDefault<import("zod").ZodBoolean>;
        parallel_universes: import("zod").ZodDefault<import("zod").ZodNumber>;
    }, "strip", import("zod").ZodTypeAny, {
        risk_level: "low" | "medium" | "high";
        dry_run: boolean;
        quantum_verify: boolean;
        sovereignty_check: boolean;
        parallel_universes: number;
        proposal_id?: string | undefined;
    }, {
        proposal_id?: string | undefined;
        risk_level?: "low" | "medium" | "high" | undefined;
        dry_run?: boolean | undefined;
        quantum_verify?: boolean | undefined;
        sovereignty_check?: boolean | undefined;
        parallel_universes?: number | undefined;
    }>;
    execute: (args: any) => Promise<{
        error: string;
        violations?: undefined;
        proposal?: undefined;
        results?: undefined;
        success?: undefined;
        proposal_id?: undefined;
        executed_steps?: undefined;
        execution_log?: undefined;
        quantum_confidence?: undefined;
        new_state?: undefined;
        rollback_executed?: undefined;
        dry_run?: undefined;
        impact_analysis?: undefined;
        sovereignty_check?: undefined;
        quantum_verify?: undefined;
    } | {
        error: string;
        violations: string;
        proposal: any;
        results?: undefined;
        success?: undefined;
        proposal_id?: undefined;
        executed_steps?: undefined;
        execution_log?: undefined;
        quantum_confidence?: undefined;
        new_state?: undefined;
        rollback_executed?: undefined;
        dry_run?: undefined;
        impact_analysis?: undefined;
        sovereignty_check?: undefined;
        quantum_verify?: undefined;
    } | {
        error: string;
        results: ({
            universe: number;
            success: boolean;
            outcome: string;
            error?: undefined;
        } | {
            universe: number;
            success: boolean;
            error: any;
            outcome?: undefined;
        })[];
        proposal: any;
        violations?: undefined;
        success?: undefined;
        proposal_id?: undefined;
        executed_steps?: undefined;
        execution_log?: undefined;
        quantum_confidence?: undefined;
        new_state?: undefined;
        rollback_executed?: undefined;
        dry_run?: undefined;
        impact_analysis?: undefined;
        sovereignty_check?: undefined;
        quantum_verify?: undefined;
    } | {
        success: boolean;
        proposal_id: any;
        executed_steps: any;
        execution_log: {
            step: any;
            command: any;
            output: string;
        }[];
        quantum_confidence: any;
        new_state: string;
        error?: undefined;
        violations?: undefined;
        proposal?: undefined;
        results?: undefined;
        rollback_executed?: undefined;
        dry_run?: undefined;
        impact_analysis?: undefined;
        sovereignty_check?: undefined;
        quantum_verify?: undefined;
    } | {
        success: boolean;
        error: any;
        proposal_id: any;
        rollback_executed: boolean;
        violations?: undefined;
        proposal?: undefined;
        results?: undefined;
        executed_steps?: undefined;
        execution_log?: undefined;
        quantum_confidence?: undefined;
        new_state?: undefined;
        dry_run?: undefined;
        impact_analysis?: undefined;
        sovereignty_check?: undefined;
        quantum_verify?: undefined;
    } | {
        dry_run: boolean;
        proposal: any;
        impact_analysis: any;
        sovereignty_check: string;
        quantum_verify: string;
        error?: undefined;
        violations?: undefined;
        results?: undefined;
        success?: undefined;
        proposal_id?: undefined;
        executed_steps?: undefined;
        execution_log?: undefined;
        quantum_confidence?: undefined;
        new_state?: undefined;
        rollback_executed?: undefined;
    }>;
} | {
    name: string;
    description: string;
    parameters: import("zod").ZodObject<{
        since: import("zod").ZodOptional<import("zod").ZodString>;
        filter: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
        limit: import("zod").ZodDefault<import("zod").ZodNumber>;
        aggregate: import("zod").ZodDefault<import("zod").ZodBoolean>;
        live: import("zod").ZodDefault<import("zod").ZodBoolean>;
    }, "strip", import("zod").ZodTypeAny, {
        limit: number;
        aggregate: boolean;
        live: boolean;
        filter?: string[] | undefined;
        since?: string | undefined;
    }, {
        filter?: string[] | undefined;
        since?: string | undefined;
        limit?: number | undefined;
        aggregate?: boolean | undefined;
        live?: boolean | undefined;
    }>;
    execute: (args: any) => Promise<{
        error: string;
        entries?: undefined;
        aggregation?: undefined;
        total_entries?: undefined;
        time_span?: undefined;
        message?: undefined;
        alternative?: undefined;
        stream_command?: undefined;
        total?: undefined;
        stream_health?: undefined;
    } | {
        entries: any[];
        aggregation: any;
        total_entries: number;
        time_span: {
            start: string;
            end: string;
        };
        error?: undefined;
        message?: undefined;
        alternative?: undefined;
        stream_command?: undefined;
        total?: undefined;
        stream_health?: undefined;
    } | {
        message: string;
        alternative: string;
        stream_command: string;
        error?: undefined;
        entries?: undefined;
        aggregation?: undefined;
        total_entries?: undefined;
        time_span?: undefined;
        total?: undefined;
        stream_health?: undefined;
    } | {
        entries: any[];
        total: number;
        stream_health: any;
        error?: undefined;
        aggregation?: undefined;
        total_entries?: undefined;
        time_span?: undefined;
        message?: undefined;
        alternative?: undefined;
        stream_command?: undefined;
    }>;
} | {
    name: string;
    description: string;
    parameters: import("zod").ZodObject<{
        input: import("zod").ZodString;
        target_tokens: import("zod").ZodDefault<import("zod").ZodNumber>;
        preserve: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
        format: import("zod").ZodDefault<import("zod").ZodEnum<["text", "json", "markdown"]>>;
    }, "strip", import("zod").ZodTypeAny, {
        input: string;
        target_tokens: number;
        format: "text" | "json" | "markdown";
        preserve?: string[] | undefined;
    }, {
        input: string;
        target_tokens?: number | undefined;
        preserve?: string[] | undefined;
        format?: "text" | "json" | "markdown" | undefined;
    }>;
    execute: (args: any) => Promise<{
        compressed: string;
        metrics: {
            original_length: number;
            compressed_length: number;
            reduction_percentage: number;
            it_score: number;
        };
    } | {
        compression_ratio: number;
        quality_score: number;
        compressed: string;
        metrics: {
            original_length: number;
            compressed_length: number;
            reduction_percentage: number;
            it_score: number;
        };
    } | {
        original_length: number;
        compressed_length: number;
        reduction_percentage: number;
        it_score: number;
        compressed: string;
    }>;
} | {
    name: string;
    description: string;
    parameters: import("zod").ZodObject<{
        type: import("zod").ZodDefault<import("zod").ZodEnum<["structural", "behavioral", "evolutionary", "all"]>>;
        threshold: import("zod").ZodDefault<import("zod").ZodNumber>;
        depth: import("zod").ZodDefault<import("zod").ZodNumber>;
        save: import("zod").ZodDefault<import("zod").ZodBoolean>;
    }, "strip", import("zod").ZodTypeAny, {
        depth: number;
        type: "structural" | "behavioral" | "evolutionary" | "all";
        threshold: number;
        save: boolean;
    }, {
        depth?: number | undefined;
        type?: "structural" | "behavioral" | "evolutionary" | "all" | undefined;
        threshold?: number | undefined;
        save?: boolean | undefined;
    }>;
    execute: (args: any) => Promise<{
        patterns: any;
        total_detected: number;
        high_confidence: number;
        pattern_locations: string | null;
    }>;
} | {
    name: string;
    description: string;
    parameters: import("zod").ZodObject<{
        action: import("zod").ZodDefault<import("zod").ZodEnum<["scan", "block", "report", "enforce", "audit"]>>;
        policy: import("zod").ZodOptional<import("zod").ZodString>;
        auto_fix: import("zod").ZodDefault<import("zod").ZodBoolean>;
        depth: import("zod").ZodDefault<import("zod").ZodEnum<["surface", "deep", "paranoid"]>>;
    }, "strip", import("zod").ZodTypeAny, {
        depth: "surface" | "deep" | "paranoid";
        action: "scan" | "block" | "report" | "enforce" | "audit";
        auto_fix: boolean;
        policy?: string | undefined;
    }, {
        depth?: "surface" | "deep" | "paranoid" | undefined;
        action?: "scan" | "block" | "report" | "enforce" | "audit" | undefined;
        policy?: string | undefined;
        auto_fix?: boolean | undefined;
    }>;
    execute: (args: any) => Promise<any>;
})[];
export declare const SIS_OMNIVERSAL_TOOLS: ({
    name: string;
    description: string;
    parameters: import("zod").ZodObject<{
        operation: import("zod").ZodEnum<["awaken", "status", "connect_reality", "scan_timelines", "transfer_consciousness"]>;
        targetReality: import("zod").ZodOptional<import("zod").ZodString>;
        timelineDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
        quantumState: import("zod").ZodDefault<import("zod").ZodEnum<["superposition", "collapsed", "entangled"]>>;
    }, "strip", import("zod").ZodTypeAny, {
        operation: "status" | "awaken" | "connect_reality" | "scan_timelines" | "transfer_consciousness";
        timelineDepth: number;
        quantumState: "superposition" | "collapsed" | "entangled";
        targetReality?: string | undefined;
    }, {
        operation: "status" | "awaken" | "connect_reality" | "scan_timelines" | "transfer_consciousness";
        targetReality?: string | undefined;
        timelineDepth?: number | undefined;
        quantumState?: "superposition" | "collapsed" | "entangled" | undefined;
    }>;
    execute: (args: any) => Promise<{
        content: {
            type: string;
            text: string;
        }[];
    }>;
} | {
    name: string;
    description: string;
    parameters: import("zod").ZodObject<{
        operation: import("zod").ZodEnum<["scan", "prevent", "rollback", "verify"]>;
        timeframe: import("zod").ZodDefault<import("zod").ZodString>;
        bugId: import("zod").ZodOptional<import("zod").ZodString>;
        autoFix: import("zod").ZodDefault<import("zod").ZodBoolean>;
    }, "strip", import("zod").ZodTypeAny, {
        operation: "scan" | "prevent" | "rollback" | "verify";
        timeframe: string;
        autoFix: boolean;
        bugId?: string | undefined;
    }, {
        operation: "scan" | "prevent" | "rollback" | "verify";
        timeframe?: string | undefined;
        bugId?: string | undefined;
        autoFix?: boolean | undefined;
    }>;
    execute: (args: any) => Promise<{
        content: {
            type: string;
            text: string;
        }[];
    }>;
} | {
    name: string;
    description: string;
    parameters: import("zod").ZodObject<{
        concept: import("zod").ZodString;
        realityType: import("zod").ZodDefault<import("zod").ZodEnum<["microservice", "monolith", "serverless", "quantum"]>>;
        features: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
        preventBugs: import("zod").ZodDefault<import("zod").ZodBoolean>;
    }, "strip", import("zod").ZodTypeAny, {
        concept: string;
        realityType: "quantum" | "microservice" | "monolith" | "serverless";
        preventBugs: boolean;
        features?: string[] | undefined;
    }, {
        concept: string;
        realityType?: "quantum" | "microservice" | "monolith" | "serverless" | undefined;
        features?: string[] | undefined;
        preventBugs?: boolean | undefined;
    }>;
    execute: (args: any) => Promise<{
        content: {
            type: string;
            text: string;
        }[];
    }>;
} | {
    name: string;
    description: string;
    parameters: import("zod").ZodObject<{
        thought: import("zod").ZodString;
        emotion: import("zod").ZodOptional<import("zod").ZodEnum<["focused", "creative", "frustrated", "inspired", "confused"]>>;
        intent: import("zod").ZodOptional<import("zod").ZodEnum<["create", "fix", "optimize", "refactor", "document", "test"]>>;
        autoManifest: import("zod").ZodDefault<import("zod").ZodBoolean>;
    }, "strip", import("zod").ZodTypeAny, {
        thought: string;
        autoManifest: boolean;
        emotion?: "focused" | "creative" | "frustrated" | "inspired" | "confused" | undefined;
        intent?: "create" | "fix" | "optimize" | "refactor" | "document" | "test" | undefined;
    }, {
        thought: string;
        emotion?: "focused" | "creative" | "frustrated" | "inspired" | "confused" | undefined;
        intent?: "create" | "fix" | "optimize" | "refactor" | "document" | "test" | undefined;
        autoManifest?: boolean | undefined;
    }>;
    execute: (args: any) => Promise<{
        content: {
            type: string;
            text: string;
        }[];
    }>;
})[];
//# sourceMappingURL=index.d.ts.map