vaspera 2.10.0 → 2.10.1

package/dist/index.js

@@ -4593,6 +4593,880 @@ Calculates escalated severity based on chain impact.`,
     }
 });
 // ---------------------------------------------------------------------------
+// Runtime Verification Tools (M7)
+// ---------------------------------------------------------------------------
+import { detectFramework, launchApp, stopApp, runRuntimeVerification, quickHealthCheck, discoverFlows, generateSampleFlow, } from "./scanners/runtime/index.js";
+server.registerTool("runtime_launch", {
+    description: `Launch a development server for runtime verification.
+
+Automatically detects the framework (Next.js, Vite, Express, FastAPI, etc.)
+and starts the appropriate dev server. Returns when the app is healthy.
+
+Supported frameworks:
+- Next.js (next dev)
+- Vite (vite)
+- Create React App (react-scripts start)
+- Express (npm run dev)
+- FastAPI (uvicorn)
+- Flask (flask run)
+- Django (manage.py runserver)
+- Rails (rails server)`,
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        port: z.number().optional().describe("Port to run on (auto-detected if not specified)"),
+        timeout: z.number().optional().describe("Startup timeout in ms (default: 60000)"),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+}, async ({ project_path, port, timeout }) => {
+    try {
+        const detection = await detectFramework(project_path);
+        const result = await launchApp({
+            projectPath: project_path,
+            framework: detection.framework,
+            port,
+            timeout,
+        });
+        return jsonResponse({
+            success: result.success,
+            framework: result.framework,
+            url: result.url,
+            port: result.port,
+            pid: result.pid,
+            healthStatus: result.healthStatus,
+            startupTime: result.startupTime,
+            error: result.error,
+            detection: {
+                confidence: detection.confidence,
+                indicators: detection.indicators,
+            },
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("runtime_stop", {
+    description: "Stop a running development server.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        port: z.number().optional().describe("Port to stop (if multiple running)"),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path, port }) => {
+    try {
+        const stopped = await stopApp(project_path, port);
+        return jsonResponse({ stopped, projectPath: project_path, port });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("runtime_verify", {
+    description: `Run full runtime verification on a project.
+
+This tool:
+1. Detects the framework
+2. Launches the dev server
+3. Runs golden path flows from .vaspera/flows/*.yaml
+4. Calculates a runtime verification score
+5. Stops the server
+
+Returns a score from 0-100 indicating runtime verification success.
+Score >= 70 is considered passing.`,
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        port: z.number().optional().describe("Port to run on"),
+        timeout: z.number().optional().describe("Startup timeout in ms"),
+        priority: z.enum(["critical", "high", "medium", "low"]).optional()
+            .describe("Only run flows at this priority or higher"),
+        stop_after: z.boolean().optional().describe("Stop server after verification (default: true)"),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+}, async ({ project_path, port, timeout, priority, stop_after }) => {
+    try {
+        const result = await runRuntimeVerification(project_path, {
+            port,
+            timeout,
+            priority,
+            stopAfter: stop_after ?? true,
+        });
+        return jsonResponse({
+            success: result.success,
+            framework: result.framework,
+            appUrl: result.appUrl,
+            duration: result.duration,
+            score: result.score,
+            goldenPaths: result.goldenPaths.map(gp => ({
+                name: gp.flowName,
+                success: gp.success,
+                passedSteps: gp.passedSteps,
+                totalSteps: gp.totalSteps,
+                duration: gp.duration,
+            })),
+            error: result.error,
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("runtime_health", {
+    description: "Quick health check - launch app, verify it starts, and stop.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        port: z.number().optional().describe("Port to run on"),
+        timeout: z.number().optional().describe("Timeout in ms (default: 30000)"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+}, async ({ project_path, port, timeout }) => {
+    try {
+        const result = await quickHealthCheck(project_path, { port, timeout });
+        return jsonResponse(result);
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("runtime_flows_list", {
+    description: "List all golden path flows defined in a project.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path }) => {
+    try {
+        const flows = await discoverFlows(project_path);
+        return jsonResponse({
+            total: flows.length,
+            flows: flows.map(f => ({
+                path: f.path,
+                name: f.flow.name,
+                description: f.flow.description,
+                priority: f.flow.priority,
+                steps: f.flow.steps.length,
+                tags: f.flow.tags,
+            })),
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("runtime_flow_generate", {
+    description: "Generate a sample golden path flow file.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        name: z.string().optional().describe("Flow name (default: sample)"),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+    },
+}, async ({ project_path, name }) => {
+    try {
+        const flowPath = await generateSampleFlow(project_path, name);
+        return jsonResponse({
+            created: true,
+            path: flowPath,
+            message: `Sample flow created at ${flowPath}. Edit to define your golden paths.`,
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("runtime_detect", {
+    description: "Detect the framework used in a project without launching.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path }) => {
+    try {
+        const detection = await detectFramework(project_path);
+        return jsonResponse({
+            framework: detection.framework,
+            version: detection.version,
+            confidence: detection.confidence,
+            devCommand: detection.devCommand,
+            buildCommand: detection.buildCommand,
+            port: detection.port,
+            healthEndpoint: detection.healthEndpoint,
+            indicators: detection.indicators,
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+// ---------------------------------------------------------------------------
+// Scale Assessment Tools (M8)
+// ---------------------------------------------------------------------------
+import { runScaleAssessment, quickBottleneckScan, discoverProfiles as discoverLoadProfiles, generateSampleProfile, detectLoadTool, isK6Available, } from "./scanners/scale/index.js";
+server.registerTool("scale_assess", {
+    description: `Run full scale assessment on a project.
+
+This tool:
+1. Detects load testing tool (k6, Artillery)
+2. Discovers and runs load profiles from .vaspera/load/*.yaml
+3. Detects performance bottlenecks in code
+4. Estimates capacity and breakpoint
+5. Calculates a scale readiness score
+
+Returns a score from 0-100 indicating scale readiness.
+Score >= 70 is considered passing.`,
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        base_url: z.string().describe("Base URL of running app"),
+        profile_name: z.string().optional().describe("Specific profile to run"),
+        skip_load_test: z.boolean().optional().describe("Skip load testing, only scan for bottlenecks"),
+        target_concurrent: z.number().optional().describe("Target concurrent users for scoring"),
+        timeout: z.number().optional().describe("Load test timeout in ms"),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+}, async ({ project_path, base_url, profile_name, skip_load_test, target_concurrent, timeout }) => {
+    try {
+        const result = await runScaleAssessment(project_path, base_url, {
+            profileName: profile_name,
+            skipLoadTest: skip_load_test,
+            targetConcurrent: target_concurrent,
+            timeout,
+        });
+        return jsonResponse({
+            success: result.success,
+            score: result.score,
+            loadTest: result.loadTest ? {
+                profile: result.loadTest.profile,
+                passed: result.loadTest.passed,
+                totalRequests: result.loadTest.summary.totalRequests,
+                errorRate: result.loadTest.summary.errorRate,
+                latencyP95: result.loadTest.summary.latency.p95,
+                throughput: result.loadTest.summary.avgThroughput,
+            } : null,
+            bottlenecks: result.bottlenecks.slice(0, 10).map((b) => ({
+                type: b.type,
+                location: b.location,
+                severity: b.severity,
+                description: b.description,
+            })),
+            capacity: {
+                maxConcurrent: result.capacity.maxConcurrentUsers,
+                maxRPS: result.capacity.maxRequestsPerSecond,
+                breakpoint: result.capacity.estimatedBreakpoint,
+            },
+            recommendations: result.capacity.recommendations,
+            duration: result.duration,
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("scale_bottlenecks", {
+    description: "Scan for performance bottlenecks without running load tests.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path }) => {
+    try {
+        const result = await quickBottleneckScan(project_path);
+        return jsonResponse({
+            score: result.score,
+            total: result.bottlenecks.length,
+            bottlenecks: result.bottlenecks.map((b) => ({
+                type: b.type,
+                location: b.location,
+                severity: b.severity,
+                description: b.description,
+                recommendation: b.recommendation,
+            })),
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("scale_profiles_list", {
+    description: "List available load testing profiles in a project.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path }) => {
+    try {
+        const profiles = await discoverLoadProfiles(project_path);
+        return jsonResponse({
+            total: profiles.length,
+            profiles: profiles.map((p) => ({
+                name: p.profile.name,
+                path: p.path,
+                tool: p.profile.tool,
+                scenarios: p.profile.scenarios.map((s) => s.name),
+                endpoints: p.profile.endpoints?.length || 0,
+            })),
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("scale_profile_generate", {
+    description: "Generate a sample load testing profile.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        name: z.string().optional().describe("Profile name (default: 'production')"),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path, name }) => {
+    try {
+        const profilePath = await generateSampleProfile(project_path, name);
+        return jsonResponse({
+            created: true,
+            path: profilePath,
+            message: `Load profile created. Edit ${profilePath} to define your endpoints and scenarios.`,
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("scale_tools_check", {
+    description: "Check which load testing tools are available.",
+    inputSchema: {},
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async () => {
+    try {
+        const k6 = await isK6Available();
+        const tool = await detectLoadTool();
+        return jsonResponse({
+            k6Available: k6,
+            recommendedTool: tool,
+            installInstructions: !tool ? {
+                k6: "brew install k6  # macOS\nchoco install k6  # Windows\nsudo apt install k6  # Linux",
+                artillery: "npm install -g artillery",
+            } : null,
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+// ---------------------------------------------------------------------------
+// Deployment Verification Tools (M9)
+// ---------------------------------------------------------------------------
+import { runDeployVerification, quickDeployCheck, detectProvider as detectDeployProvider, loadDeployConfig, generateDeployConfig, isVercelAvailable, listDeployments, promoteToProduction, rollback as vercelRollback, } from "./scanners/deploy/index.js";
+server.registerTool("deploy_verify", {
+    description: `Run deployment verification against a deployed app.
+
+This tool:
+1. Detects the deployment provider (Vercel, AWS, etc.)
+2. Runs health checks against configured endpoints
+3. Executes smoke tests from .vaspera/deploy.yaml
+4. Optionally runs canary analysis
+5. Calculates a deploy readiness score
+
+Returns a score from 0-100 indicating deployment health.
+Score >= 70 is considered passing.`,
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        deployment_url: z.string().describe("URL of the deployed app"),
+        skip_health_check: z.boolean().optional().describe("Skip health checks"),
+        skip_smoke_tests: z.boolean().optional().describe("Skip smoke tests"),
+        run_canary: z.boolean().optional().describe("Run canary analysis"),
+        canary_duration: z.number().optional().describe("Canary duration in ms"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+}, async ({ project_path, deployment_url, skip_health_check, skip_smoke_tests, run_canary, canary_duration }) => {
+    try {
+        const result = await runDeployVerification(project_path, deployment_url, {
+            skipHealthCheck: skip_health_check,
+            skipSmokeTests: skip_smoke_tests,
+            runCanary: run_canary,
+            canaryDuration: canary_duration,
+        });
+        return jsonResponse({
+            success: result.success,
+            provider: result.provider,
+            score: result.score,
+            deployment: result.deployment ? {
+                id: result.deployment.id,
+                environment: result.deployment.environment,
+                status: result.deployment.status,
+                url: result.deployment.url,
+            } : null,
+            healthChecks: result.healthChecks.map((h) => ({
+                endpoint: h.endpoint,
+                status: h.status,
+                responseTime: h.responseTime,
+            })),
+            smokeTests: result.smokeTests.map((t) => ({
+                name: t.name,
+                passed: t.passed,
+                responseTime: t.responseTime,
+            })),
+            canary: result.canary ? {
+                phase: result.canary.phase,
+                recommendation: result.canary.recommendation,
+                errorRate: result.canary.metrics.errorRate,
+                p95Latency: result.canary.metrics.p95Latency,
+            } : null,
+            duration: result.duration,
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("deploy_health", {
+    description: "Quick health check against a deployed app.",
+    inputSchema: {
+        deployment_url: z.string().describe("URL of the deployed app"),
+        endpoints: z.array(z.string()).optional().describe("Endpoints to check"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+}, async ({ deployment_url, endpoints }) => {
+    try {
+        const result = await quickDeployCheck(deployment_url, endpoints);
+        return jsonResponse({
+            healthy: result.healthy,
+            score: result.score,
+            checks: result.checks.map((c) => ({
+                endpoint: c.endpoint,
+                status: c.status,
+                statusCode: c.statusCode,
+                responseTime: c.responseTime,
+                error: c.error,
+            })),
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("deploy_detect", {
+    description: "Detect the deployment provider for a project.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path }) => {
+    try {
+        const detection = await detectDeployProvider(project_path);
+        const config = await loadDeployConfig(project_path);
+        return jsonResponse({
+            provider: detection.provider,
+            confidence: detection.confidence,
+            indicators: detection.indicators,
+            projectId: detection.projectId,
+            hasConfig: !!config,
+            vercelAvailable: isVercelAvailable(),
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("deploy_config_generate", {
+    description: "Generate a deployment verification config file.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        provider: z.enum(["vercel", "aws", "gcp", "railway", "render", "fly"]).optional()
+            .describe("Deployment provider"),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path, provider }) => {
+    try {
+        const configPath = await generateDeployConfig(project_path, provider);
+        return jsonResponse({
+            created: true,
+            path: configPath,
+            message: `Deploy config created. Edit ${configPath} to customize health checks and smoke tests.`,
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("deploy_vercel_list", {
+    description: "List recent Vercel deployments for a project.",
+    inputSchema: {
+        project_id: z.string().describe("Vercel project ID"),
+        limit: z.number().optional().describe("Number of deployments to list"),
+        target: z.enum(["production", "preview"]).optional().describe("Filter by target"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+}, async ({ project_id, limit, target }) => {
+    try {
+        if (!isVercelAvailable()) {
+            return errorResponse("VERCEL_TOKEN not configured");
+        }
+        const deployments = await listDeployments(project_id, { limit, target });
+        return jsonResponse({
+            total: deployments.length,
+            deployments: deployments.map((d) => ({
+                id: d.id,
+                environment: d.environment,
+                status: d.status,
+                url: d.url,
+                createdAt: d.createdAt,
+                commit: d.meta?.commit,
+                branch: d.meta?.branch,
+            })),
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("deploy_vercel_promote", {
+    description: "Promote a Vercel preview deployment to production.",
+    inputSchema: {
+        project_id: z.string().describe("Vercel project ID"),
+        deployment_id: z.string().describe("Deployment ID to promote"),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+}, async ({ project_id, deployment_id }) => {
+    try {
+        if (!isVercelAvailable()) {
+            return errorResponse("VERCEL_TOKEN not configured");
+        }
+        const result = await promoteToProduction(deployment_id, project_id);
+        return jsonResponse({
+            success: result.success,
+            error: result.error,
+            message: result.success
+                ? `Deployment ${deployment_id} promoted to production`
+                : `Promotion failed: ${result.error}`,
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("deploy_vercel_rollback", {
+    description: "Rollback to a previous Vercel deployment.",
+    inputSchema: {
+        project_id: z.string().describe("Vercel project ID"),
+        deployment_id: z.string().describe("Deployment ID to rollback to"),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+}, async ({ project_id, deployment_id }) => {
+    try {
+        if (!isVercelAvailable()) {
+            return errorResponse("VERCEL_TOKEN not configured");
+        }
+        const result = await vercelRollback(project_id, deployment_id);
+        return jsonResponse({
+            success: result.success,
+            error: result.error,
+            message: result.success
+                ? `Rolled back to deployment ${deployment_id}`
+                : `Rollback failed: ${result.error}`,
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+// ---------------------------------------------------------------------------
+// M10: AI Code Verification Tools
+// ---------------------------------------------------------------------------
+import { runAIVerification, quickAICheck, generateAIVerifyConfig, scanDirectoryForAIPatterns, scanDirectoryForHallucinations, } from "./scanners/ai-code/index.js";
+server.registerTool("ai_code_verify", {
+    description: `Run full AI code verification on a project.
+
+This tool:
+1. Scans for AI-generated code patterns
+2. Checks for hallucinated imports and APIs
+3. Scores each file for AI likelihood
+4. Identifies changes requiring human review
+
+Returns a comprehensive verification result with scores:
+- Detection Score: Lower AI likelihood = better
+- Hallucination Score: Fewer hallucinations = better
+- Review Score: Fewer reviews needed = better
+- Overall Score: Weighted average (0-100)`,
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        extensions: z.array(z.string()).optional().describe("File extensions to analyze"),
+        exclude: z.array(z.string()).optional().describe("Patterns to exclude"),
+        files: z.array(z.string()).optional().describe("Specific files to analyze"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path, extensions, exclude, files }) => {
+    try {
+        const result = await runAIVerification(project_path, {
+            extensions,
+            exclude,
+            files,
+        });
+        return jsonResponse({
+            success: result.success,
+            filesAnalyzed: result.filesAnalyzed,
+            summary: result.summary,
+            score: result.score,
+            duration: result.duration,
+            hallucinations: result.hallucinations.slice(0, 20),
+            changesRequiringReview: result.changesScored
+                .filter((c) => c.requiresReview)
+                .slice(0, 20)
+                .map((c) => ({
+                file: c.file,
+                aiLikelihood: c.aiLikelihood,
+                confidence: c.confidence,
+                reason: c.reviewReason,
+            })),
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("ai_code_quick", {
+    description: `Quick AI code check for a single file.
+
+Returns AI likelihood, hallucination count, and whether review is required.
+Use this for fast feedback on individual files.`,
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        file_path: z.string().describe("Path to the file to check"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path, file_path }) => {
+    try {
+        const fullPath = file_path.startsWith("/") ? file_path : join(project_path, file_path);
+        const result = await quickAICheck(fullPath, project_path);
+        return jsonResponse({
+            file: file_path,
+            aiLikelihood: result.aiLikelihood,
+            hallucinations: result.hallucinations,
+            requiresReview: result.requiresReview,
+            indicatorCount: result.indicators.length,
+            indicators: result.indicators.slice(0, 10).map((i) => ({
+                type: i.type,
+                line: i.location.line,
+                description: i.description,
+                confidence: i.confidence,
+            })),
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("ai_code_config_generate", {
+    description: "Generate a sample AI code verification config file.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path }) => {
+    try {
+        const configPath = await generateAIVerifyConfig(project_path);
+        return jsonResponse({
+            success: true,
+            configPath,
+            message: `AI verification config created at ${configPath}`,
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("ai_code_patterns", {
+    description: "Scan a directory for AI code generation patterns.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        extensions: z.array(z.string()).optional().describe("File extensions to scan"),
+        exclude: z.array(z.string()).optional().describe("Patterns to exclude"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path, extensions, exclude }) => {
+    try {
+        const result = await scanDirectoryForAIPatterns(project_path, {
+            extensions,
+            exclude,
+        });
+        const byFile = new Map();
+        for (const match of result.matches) {
+            byFile.set(match.file, (byFile.get(match.file) ?? 0) + 1);
+        }
+        return jsonResponse({
+            filesScanned: result.files,
+            totalMatches: result.matches.length,
+            byConfidence: {
+                high: result.indicators.filter((i) => i.confidence === "high").length,
+                medium: result.indicators.filter((i) => i.confidence === "medium").length,
+                low: result.indicators.filter((i) => i.confidence === "low").length,
+            },
+            topFiles: Array.from(byFile.entries())
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 10)
+                .map(([file, count]) => ({ file, matches: count })),
+            recentMatches: result.matches.slice(0, 20).map((m) => ({
+                pattern: m.pattern,
+                file: m.file,
+                line: m.line,
+                confidence: m.confidence,
+            })),
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+server.registerTool("ai_code_hallucinations", {
+    description: "Scan for hallucinated imports, APIs, and deprecated patterns.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project"),
+        extensions: z.array(z.string()).optional().describe("File extensions to scan"),
+        exclude: z.array(z.string()).optional().describe("Patterns to exclude"),
+    },
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ project_path, extensions, exclude }) => {
+    try {
+        const result = await scanDirectoryForHallucinations(project_path, {
+            extensions,
+            exclude,
+        });
+        return jsonResponse({
+            filesScanned: result.files,
+            totalFindings: result.findings.length,
+            byType: result.summary.byType,
+            bySeverity: result.summary.bySeverity,
+            findings: result.findings.slice(0, 30).map((f) => ({
+                type: f.type,
+                severity: f.severity,
+                file: f.location.file,
+                line: f.location.line,
+                description: f.description,
+                suggestion: f.suggestion,
+            })),
+        });
+    }
+    catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error));
+    }
+});
+// ---------------------------------------------------------------------------
 // Exports (for HTTP server and client integration)
 // ---------------------------------------------------------------------------
 export { server, textResponse, jsonResponse, errorResponse };