@debugai/mcp 1.1.0 → 2.1.0

package/dist/tools/authGate.js

@@ -0,0 +1,29 @@
+export async function resolveAuth(config) {
+    if (!config.auth) {
+        return { ok: true, config }; // tests and direct embedders pass a fixed key
+    }
+    const state = await config.auth.ensure();
+    if (state.ok) {
+        return {
+            ok: true,
+            config: state.apiKey === config.apiKey ? config : { ...config, apiKey: state.apiKey },
+        };
+    }
+    return {
+        ok: false,
+        result: {
+            isError: true,
+            content: [{ type: 'text', text: state.text }],
+            structuredContent: state.reason === 'link_pending'
+                ? {
+                    error_type: 'not_linked',
+                    user_code: state.userCode,
+                    verification_uri: state.verificationUri,
+                    // Retryable on purpose: the SAME call succeeds once the human
+                    // confirms. Agents should retry after telling the user, not give up.
+                    retryable: true,
+                }
+                : { error_type: 'not_linked', retryable: true },
+        },
+    };
+}

package/dist/tools/debugError.d.ts

@@ -1,4 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { BackendConfig, DebugFix } from '../backend.js';
+export declare function formatVerification(fix: DebugFix): string;
 export declare function formatFix(fix: DebugFix, index: number): string;
 export declare function registerDebugError(server: McpServer, config: BackendConfig): void;

package/dist/tools/debugError.js

@@ -1,9 +1,23 @@
 import { z } from 'zod';
 import { callDebugBackend } from '../backend.js';
 import { mapBackendErrorToToolResult } from '../errors.js';
+import { resolveAuth } from './authGate.js';
+// Tri-state verification labeling (docs/plan-v2-contract-phase1.md §1).
+// The null case is rendered ON PURPOSE: a confidence number nothing checked
+// must never look the same as one that was mechanically verified.
+export function formatVerification(fix) {
+    if (fix.verified === true) {
+        return `✓ Verified — ${fix.verification_reason ?? 'mechanical check passed'}`;
+    }
+    if (fix.verified === false) {
+        return `✗ Failed mechanical check (confidence capped) — ${fix.verification_reason ?? 'check failed'}`;
+    }
+    return '· Not verified — confidence is the model\'s own estimate; nothing checked this fix.';
+}
 export function formatFix(fix, index) {
     const lines = [
         `\n**Fix ${index} (${fix.confidence}% confidence)** — ${fix.title}`,
+        formatVerification(fix),
         fix.description,
     ];
     if (fix.code) {
@@ -12,6 +26,15 @@ export function formatFix(fix, index) {
     if (fix.line_hint) {
         lines.push(`_Location: ${fix.line_hint}_`);
     }
+    if (fix.edits?.length) {
+        lines.push('_Machine-applicable edit available: `edits` on this fix in structuredContent carries the exact old/new strings (apply with your Edit/replace tool)._');
+    }
+    if (fix.unified_diff) {
+        lines.push('```diff', fix.unified_diff.trimEnd(), '```');
+    }
+    if (fix.verify_with) {
+        lines.push(`_Syntax-level check after applying: \`${fix.verify_with}\`_`);
+    }
     return lines.join('\n');
 }
 export function registerDebugError(server, config) {
@@ -22,7 +45,8 @@ export function registerDebugError(server, config) {
             '"debug this stack trace", "fix this exception", "analyze this traceback", or shows a ' +
             'Traceback / TypeError / ReferenceError / AttributeError. ' +
             'Works for Python, JavaScript, TypeScript, Go, Rust. ' +
-            'Returns root cause explanation plus up to 3 ranked fixes with code patches.',
+            'Returns root cause explanation plus up to 3 ranked fixes with machine-applicable code edits. ' +
+            'After applying a fix, report whether it worked via the report_outcome tool.',
         inputSchema: {
             errorText: z
                 .string()
@@ -46,6 +70,9 @@ export function registerDebugError(server, config) {
             title: 'Debug Error',
         },
     }, async ({ errorText, language, codeSnippet, filePath }) => {
+        const gate = await resolveAuth(config);
+        if (!gate.ok)
+            return gate.result;
         try {
             const result = await callDebugBackend({
                 error_message: errorText,
@@ -55,7 +82,7 @@ export function registerDebugError(server, config) {
                 // framework_hint deliberately omitted: a language ('python') is not a
                 // framework ('fastapi'), and sending it bypasses the engine's
                 // framework detection — FastAPI/React errors lose their expert hints.
-            }, config);
+            }, gate.config);
             const sections = ['## Root Cause', result.root_cause ?? '(no root cause returned)'];
             if (result.fixes?.length) {
                 sections.push('\n## Fixes');
@@ -79,16 +106,23 @@ export function registerDebugError(server, config) {
             if (badges.length) {
                 sections.push(`\n---\n_${badges.join(' · ')}_`);
             }
+            if (result.debug_log_id) {
+                sections.push(`\nAfter applying a fix, call report_outcome with debugLogId "${result.debug_log_id}", ` +
+                    'the fixRank you applied, and result "worked" or "failed" (include newError text if it failed).');
+            }
             const text = sections.join('\n');
             return {
                 content: [{ type: 'text', text }],
                 structuredContent: {
+                    schema_version: result.schema_version ?? '1.0',
                     root_cause: result.root_cause,
                     fixes: result.fixes,
                     framework_detected: result.framework_detected,
                     model_used: result.model_used,
                     cached: result.cached ?? false,
                     has_project_context: result.has_project_context ?? false,
+                    debug_log_id: result.debug_log_id ?? null,
+                    error_signature: result.error_signature ?? null,
                 },
             };
         }

package/dist/tools/reportOutcome.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { BackendConfig } from '../backend.js';
+export declare function registerReportOutcome(server: McpServer, config: BackendConfig): void;

package/dist/tools/reportOutcome.js

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { callOutcomeBackend } from '../backend.js';
+import { mapBackendErrorToToolResult } from '../errors.js';
+import { resolveAuth } from './authGate.js';
+export function registerReportOutcome(server, config) {
+    server.registerTool('report_outcome', {
+        title: 'Report Fix Outcome',
+        description: 'Report whether a DebugAI fix actually worked after you applied it. ' +
+            'Call this ONCE after applying (or abandoning) a fix from debug_error, passing the ' +
+            'debug_log_id from that response. If the fix failed, include the new error text — ' +
+            'failed-fix follow-ups directly improve future answers for this codebase, and ' +
+            'confirmed rank-1 fixes are remembered for the whole team.',
+        inputSchema: {
+            debugLogId: z
+                .string()
+                .min(1)
+                .describe('The debug_log_id value from the debug_error response you are reporting on.'),
+            result: z
+                .enum(['worked', 'failed'])
+                .describe('"worked" = the fix resolved the error; "failed" = it did not (or made things worse).'),
+            fixRank: z
+                .number()
+                .int()
+                .min(1)
+                .max(3)
+                .optional()
+                .describe('Which ranked fix you applied (1-3). Rank 1 outcomes feed team error memory.'),
+            newError: z
+                .string()
+                .max(4000)
+                .optional()
+                .describe('If result is "failed": the error observed AFTER applying the fix.'),
+        },
+        annotations: {
+            title: 'Report Fix Outcome',
+            // Deliberately NO readOnlyHint — this records telemetry server-side.
+            idempotentHint: true,
+        },
+    }, async ({ debugLogId, result, fixRank, newError }) => {
+        const gate = await resolveAuth(config);
+        if (!gate.ok)
+            return gate.result;
+        try {
+            await callOutcomeBackend({
+                debug_log_id: debugLogId,
+                result,
+                fix_rank: fixRank,
+                new_error: newError,
+                source: 'agent',
+            }, gate.config);
+            const ack = result === 'worked'
+                ? 'Outcome recorded: fix worked. Rank-1 confirmations are remembered for this project, so the next hit on this error starts from the confirmed fix.'
+                : 'Outcome recorded: fix failed. The follow-up error was logged and feeds directly into improving future answers. If you are still stuck, call debug_error again with the NEW error text.';
+            return {
+                content: [{ type: 'text', text: ack }],
+                structuredContent: { recorded: true, result },
+            };
+        }
+        catch (err) {
+            return mapBackendErrorToToolResult(err);
+        }
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@debugai/mcp",
-  "version": "1.1.0",
-  "description": "DebugAI MCP server — hand any error to DebugAI from Claude Desktop, Claude Code, Cursor, Zed, or any MCP client and get root cause + ranked fixes.",
+  "version": "2.1.0",
+  "description": "DebugAI MCP server. One command sets it up in Claude Desktop, Claude Code, Cursor, Zed, Windsurf, Cline or any MCP client: browser sign-in, no key pasting, no config editing.",
   "license": "MIT",
   "type": "module",
   "bin": {