couchloop-eq-mcp 1.1.4 → 1.2.0

package/dist/tools/primary-tools.d.ts

@@ -0,0 +1,615 @@
+/**
+ * MCP Tools - Public API
+ *
+ * This module exports only the PRIMARY tools that users should see.
+ * All granular tools are internal engines used by these primary tools.
+ *
+ * PUBLIC TOOLS (8):
+ * 0. couchloop        - Intent router (discoverability layer for loose commands)
+ * 1. verify           - Pre-delivery verification (catches AI hallucinations, validates packages)
+ * 2. status           - Dashboard (session progress, history, context, protection)
+ * 3. conversation     - Therapeutic AI conversation with governance
+ * 4. code_review      - Complete code analysis (security, quality, AI errors)
+ * 5. package_audit    - Complete dependency audit (validation, versions, upgrades)
+ * 6. remember         - Smart context capture (checkpoints, insights, decisions)
+ * 7. protect          - File protection and safety features
+ */
+import { handleComprehensiveCodeReview } from './comprehensive-code-review.js';
+import { handleComprehensivePackageAudit } from './comprehensive-package-audit.js';
+import { handleSmartContext } from './smart-context.js';
+export declare function setupTools(): Promise<({
+    definition: {
+        name: string;
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            type: string;
+            properties: {
+                intent: {
+                    type: string;
+                    description: string;
+                };
+                context: {
+                    type: string;
+                    description: string;
+                };
+                session_id: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    handler: (args: Record<string, unknown>) => Promise<{
+        error: string;
+        hint: string;
+        routed_to?: undefined;
+        message?: undefined;
+        tools?: undefined;
+        examples?: undefined;
+        classification?: undefined;
+        registeredTools?: undefined;
+        action?: undefined;
+        confidence?: undefined;
+        result?: undefined;
+        args_passed?: undefined;
+    } | {
+        routed_to: string;
+        message: string;
+        tools: {
+            couchloop: string;
+            verify: string;
+            status: string;
+            conversation: string;
+            brainstorm: string;
+            remember: string;
+            code_review: string;
+            package_audit: string;
+            protect: string;
+        };
+        examples: string[];
+        hint: string;
+        error?: undefined;
+        classification?: undefined;
+        registeredTools?: undefined;
+        action?: undefined;
+        confidence?: undefined;
+        result?: undefined;
+        args_passed?: undefined;
+    } | {
+        error: string;
+        classification: import("./intent-router.js").ClassificationResult;
+        registeredTools: string[];
+        hint?: undefined;
+        routed_to?: undefined;
+        message?: undefined;
+        tools?: undefined;
+        examples?: undefined;
+        action?: undefined;
+        confidence?: undefined;
+        result?: undefined;
+        args_passed?: undefined;
+    } | {
+        routed_to: string;
+        message: string;
+        hint: string;
+        error?: undefined;
+        tools?: undefined;
+        examples?: undefined;
+        classification?: undefined;
+        registeredTools?: undefined;
+        action?: undefined;
+        confidence?: undefined;
+        result?: undefined;
+        args_passed?: undefined;
+    } | {
+        routed_to: string;
+        action: string | undefined;
+        confidence: number;
+        result: unknown;
+        error?: undefined;
+        hint?: undefined;
+        message?: undefined;
+        tools?: undefined;
+        examples?: undefined;
+        classification?: undefined;
+        registeredTools?: undefined;
+        args_passed?: undefined;
+    } | {
+        routed_to: string;
+        error: string;
+        classification: import("./intent-router.js").ClassificationResult;
+        args_passed: Record<string, unknown>;
+        hint?: undefined;
+        message?: undefined;
+        tools?: undefined;
+        examples?: undefined;
+        registeredTools?: undefined;
+        action?: undefined;
+        confidence?: undefined;
+        result?: undefined;
+    }>;
+} | {
+    definition: {
+        name: string;
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            type: string;
+            properties: {
+                type: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                content: {
+                    type: string;
+                    description: string;
+                };
+                language: {
+                    type: string;
+                    description: string;
+                };
+                registry: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                context: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    handler: typeof import("./verify.js").handleVerify;
+} | {
+    definition: {
+        name: string;
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            type: string;
+            properties: {
+                check: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                session_id: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    handler: typeof import("./status.js").handleStatus;
+} | {
+    definition: {
+        name: string;
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            type: string;
+            properties: {
+                message: {
+                    type: string;
+                    description: string;
+                };
+                action: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                journey: {
+                    type: string;
+                    description: string;
+                };
+                session_id: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    handler: (args: Record<string, unknown>) => Promise<unknown>;
+} | {
+    definition: {
+        name: string;
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            type: string;
+            properties: {
+                code: {
+                    type: string;
+                    description: string;
+                };
+                language: {
+                    type: string;
+                    description: string;
+                };
+                auto_fix: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    handler: typeof handleComprehensiveCodeReview;
+} | {
+    definition: {
+        name: string;
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            type: string;
+            properties: {
+                packages: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    description: string;
+                };
+                registry: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    handler: typeof handleComprehensivePackageAudit;
+} | {
+    definition: {
+        name: string;
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            type: string;
+            properties: {
+                content: {
+                    type: string;
+                    description: string;
+                };
+                type: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                tags: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    description: string;
+                };
+                action: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                session_id: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    handler: (args: Record<string, unknown>) => Promise<{
+        error: string;
+        details?: any;
+    } | {
+        insights: {
+            content: string;
+            id: string;
+            createdAt: Date;
+            tags: string[];
+            userId: string;
+            sessionId: string | null;
+        }[];
+        count: number;
+    } | {
+        success: boolean;
+        type: "conversation" | "checkpoint" | "pattern" | "insight" | "decision" | "requirement" | "constraint";
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        type?: undefined;
+        message?: undefined;
+    } | {
+        checkpoints: {
+            error: string;
+            details?: any;
+        } | {
+            session_id: string;
+            session_created: boolean;
+            checkpoints: {
+                id: string;
+                createdAt: Date;
+                sessionId: string;
+                stepId: string;
+                key: string;
+                value: unknown;
+            }[];
+            count: number;
+        };
+        insights: {
+            error: string;
+            details?: any;
+        } | {
+            insights: {
+                content: string;
+                id: string;
+                createdAt: Date;
+                tags: string[];
+                userId: string;
+                sessionId: string | null;
+            }[];
+            count: number;
+        };
+        user_context: {
+            error: string;
+            details?: any;
+        } | {
+            user: {
+                preferences: {
+                    timezone?: string;
+                    preferredJourneyLength?: "short" | "medium" | "long";
+                } | null;
+                id: string;
+                externalId: string;
+                isTestAccount: boolean;
+                createdAt: Date;
+                updatedAt: Date;
+            } | undefined;
+            recent_insights: never[];
+            recent_sessions: never[];
+            active_session: null;
+        } | {
+            user: {
+                id: string;
+                preferences: {
+                    timezone?: string;
+                    preferredJourneyLength?: "short" | "medium" | "long";
+                } | null;
+                created_at: Date;
+            };
+            recent_insights: {
+                content: string;
+                id: string;
+                createdAt: Date;
+                tags: string[];
+                userId: string;
+                sessionId: string | null;
+            }[];
+            recent_sessions: import("./insight.js").RecentSession[];
+            active_session: {
+                status: "active" | "paused" | "completed" | "abandoned";
+                id: string;
+                updatedAt: Date;
+                userId: string;
+                journeyId: string | null;
+                currentStep: number;
+                startedAt: Date;
+                lastActiveAt: Date;
+                completedAt: Date | null;
+                metadata: unknown;
+                threadId: string | null;
+                lastSyncedAt: Date | null;
+            } | undefined;
+        };
+    }>;
+} | {
+    definition: {
+        name: string;
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            type: string;
+            properties: {
+                action: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                path: {
+                    type: string;
+                    description: string;
+                };
+                operation: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                backup_id: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    handler: (args: Record<string, unknown>) => Promise<{
+        error: string;
+        details?: any;
+    } | {
+        success: boolean;
+        operation_id: string;
+        allowed: boolean;
+        message: string;
+        violations: import("../types/file-protection.js").ProtectionViolation[];
+        recommendation: string;
+        action_required: string;
+        requires_approval?: undefined;
+        severity?: undefined;
+        suggested_backup?: undefined;
+        reason?: undefined;
+        status?: undefined;
+        operation_details?: undefined;
+        next_steps?: undefined;
+        safety_measures?: undefined;
+        error?: undefined;
+        details?: undefined;
+    } | {
+        success: boolean;
+        operation_id: string;
+        allowed: boolean;
+        requires_approval: boolean;
+        message: string;
+        violations: import("../types/file-protection.js").ProtectionViolation[];
+        severity: "medium" | "low" | "high" | "critical";
+        recommendation: string;
+        suggested_backup: string;
+        action_required?: undefined;
+        reason?: undefined;
+        status?: undefined;
+        operation_details?: undefined;
+        next_steps?: undefined;
+        safety_measures?: undefined;
+        error?: undefined;
+        details?: undefined;
+    } | {
+        success: boolean;
+        operation_id: string;
+        message: string;
+        reason: string;
+        allowed?: undefined;
+        violations?: undefined;
+        recommendation?: undefined;
+        action_required?: undefined;
+        requires_approval?: undefined;
+        severity?: undefined;
+        suggested_backup?: undefined;
+        status?: undefined;
+        operation_details?: undefined;
+        next_steps?: undefined;
+        safety_measures?: undefined;
+        error?: undefined;
+        details?: undefined;
+    } | {
+        success: boolean;
+        operation_id: string;
+        allowed: boolean;
+        status: string;
+        message: string;
+        operation_details: {
+            type: "delete" | "overwrite" | "move";
+            path: string;
+            target_path: string | null;
+            backup_path: string | null;
+        };
+        next_steps: string[];
+        safety_measures: {
+            backup_created: boolean;
+            backup_location: string;
+            rollback_available: boolean;
+            operation_logged: boolean;
+        };
+        violations?: undefined;
+        recommendation?: undefined;
+        action_required?: undefined;
+        requires_approval?: undefined;
+        severity?: undefined;
+        suggested_backup?: undefined;
+        reason?: undefined;
+        error?: undefined;
+        details?: undefined;
+    } | {
+        success: boolean;
+        protection_status: {
+            code_freeze_mode: boolean;
+            protected_patterns: string[];
+            forbidden_paths: string[];
+            critical_system_files: string[];
+        };
+        backup_stats: {
+            total_backups: number;
+            total_size_mb: number;
+            oldest_backup: Date | undefined;
+            newest_backup: Date | undefined;
+            disk_usage_percent: number;
+        };
+        protection_report: {
+            code_freeze_enabled: boolean;
+            operations_logged: number;
+            protected_items_count: number;
+            recent_violations_count: number;
+        };
+    } | {
+        success: boolean;
+        backup_count: number;
+        backups: {
+            id: string;
+            original_path: string;
+            backup_path: string;
+            timestamp: Date;
+            file_size_kb: number;
+            operation: "delete" | "overwrite" | "move";
+            reason: string | null;
+        }[];
+    } | {
+        success: boolean;
+        message: string;
+        backup_id: any;
+        restored_path?: undefined;
+        backup_path?: undefined;
+        timestamp?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        restored_path: string;
+        backup_id: any;
+        backup_path: string;
+        timestamp: Date;
+    } | {
+        success: boolean;
+        message: string;
+        status: string;
+        effect: string;
+    }>;
+})[]>;
+export { handleComprehensiveCodeReview, handleComprehensivePackageAudit, handleSmartContext, };
+//# sourceMappingURL=primary-tools.d.ts.map

package/dist/tools/primary-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primary-tools.d.ts","sourceRoot":"","sources":["../../src/tools/primary-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAMH,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAAE,+BAA+B,EAAE,MAAM,kCAAkC,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAwUxD,wBAAsB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA7OR,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA0IvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgEvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA0D9C;AAGD,OAAO,EACL,6BAA6B,EAC7B,+BAA+B,EAC/B,kBAAkB,GACnB,CAAC"}