@debugai/mcp 2.4.0 → 2.4.2

package/README.md

@@ -133,6 +133,8 @@ call report_outcome so the project's error memory stays accurate.
 
 You do not need this package. The [DebugAI extension](https://marketplace.visualstudio.com/items?itemName=debugai.debugai) registers the MCP server automatically (VS Code 1.101+) and adds one-click fix apply, proactive scan, and codebase indexing on top. It is on [Open VSX](https://open-vsx.org/extension/debugai/debugai) too, for Cursor, Windsurf, and VSCodium.
 
+The two servers are the same protocol surface and are kept in step by a test that reads both copies as text, because a comment saying "keep these in sync" has failed here before. From extension 2.8.1 the bundled server also does local source resolution, which this package has had since 2.2.0. Until then, an agent on the bundled server that pasted a traceback into a workspace nobody had indexed still got "Insufficient context for specific fix" at 20% confidence, which is the exact answer this feature exists to remove.
+
 ## Manual setup
 
 `setup` covers this, and `install --client=<id>` covers the case where a client is installed somewhere unusual. If you would still rather edit the file yourself, the entry is the same everywhere:
@@ -197,6 +199,7 @@ Then run `npx -y @debugai/mcp login` once to store your key. If you would rather
 - Simple errors route to a fast model. Ugly cross-file ones route to a stronger one on paid tiers. The `Model:` badge in each response tells you which one answered.
 - Analyses run on DebugAI's servers. The error text, any snippet you pass, and — since 2.2 — the project source files the stack trace names are sent there, and Claude (Anthropic) does the analysis. The response lists every file that was read. Scope and limits are spelled out under [`debug_error`](#it-reads-the-source-the-trace-names-22). Privacy policy: [debugai.io/privacy](https://debugai.io/privacy?src=npm).
 - Errors are remembered per project so a repeat hit starts from a fix that was already confirmed. The project identity is a hash of your repo root path; the path itself is never sent.
+- The VS Code extension reads the project's `requirements.txt`, `pyproject.toml` and `package.json` and the interpreter the editor has selected, which is what lets it tell "not installed" apart from "installed under a different interpreter". This server sends none of that, so on a missing-module error you get the general answer and the check to run, not a verdict. You have a shell and it does not, so the honest division is that you run the check. Reporting those facts back through this server is planned.
 
 ## Troubleshooting
 
@@ -211,9 +214,36 @@ Run `npx -y @debugai/mcp doctor` first. It checks your Node version, whether a k
 
 **Note on updates**: the analysis runs on DebugAI's servers, so improvements to
 error parsing, retrieval and root-cause quality reach you without upgrading this
-package. Recent server-side work: pytest, unittest, jest, vitest and mocha output
-now yields real file paths, so a failing test gets cross-file context instead of
-none. Client releases are only for things that change on your machine.
+package. Client releases are only for things that change on your machine.
+
+Recent server-side work, all of it live for agents already:
+
+- `ModuleNotFoundError` no longer opens with an install command. A read of every
+  one we had answered found five of eight rejected by the agent that received
+  them, for three different causes needing three different fixes: the package
+  was installed under another interpreter, the name was a local file, or the
+  import line was malformed. Rank 1 is now the check that tells those apart.
+- A Python `SyntaxError` is no longer diagnosed as a JavaScript one, and the
+  framework is read from the error text rather than from what the repository
+  contains.
+- Operating-system errors (`Access is denied.`, `No space left on device`) are
+  recognised as errors. Thirty were probed and twenty-eight had been refused.
+- Credentials in the text you send are replaced before anything is stored or
+  reaches a model.
+- pytest, unittest, jest, vitest and mocha output yields real file paths, so a
+  failing test gets cross-file context instead of none.
+
+**2.4.0**: `report_outcome` gains `unused`. An agent that solved the problem its
+own way had to report `failed`, which marks a fix as tried and beaten when
+nothing of ours was ever run. Both tool surfaces, the npm server and the one
+bundled in the VS Code extension, now take the same fields.
+
+**2.3.0**: agents get the same four memory states the editor panel does.
+`debug_error` had two branches, and a fix that had been tried and kept failing
+read identically to one nobody had tried. To an agent those are the same
+sentence, so the natural next move is to propose the fix that already did not
+work. The four states now match the panel: confirmed and verified, confirmed,
+unproven, and anti-pattern.
 
 **2.2.0**: two things that were advertised but not delivered.
 

package/dist/memorySection.d.ts

@@ -0,0 +1,39 @@
+/**
+ * What this project already knows about this exact error.
+ *
+ * ## Why it is its own module
+ *
+ * This section was the headline of npm 2.4.0 and **never reached the bundled
+ * server** — the zero-config one VS Code registers automatically, with no
+ * install and no config, and therefore the copy an agent is most likely to be
+ * on. For weeks the most-used MCP server advertised memory in its own
+ * instructions and never printed a word of it. That is the third time a
+ * decision duplicated across this boundary has drifted in the same direction.
+ *
+ * Inlined in two `debugError.ts` files it drifted silently, because
+ * `drift.test.ts` pinned tool SIGNATURES and the signatures were identical.
+ * As a module it is byte-comparable, and that comparison now ships as a test.
+ *
+ * Mirror: apps/extension/src/mcp/memorySection.ts
+ * The two are identical below this header. Change one, change the other, on
+ * the same commit (Rule 15b).
+ */
+/** The fields the engine sends about a remembered error. Every one optional:
+ *  an older engine sends none, and absence must read as "nothing remembered"
+ *  rather than as "nothing happened". */
+export interface MemoryFields {
+    memory_hit?: boolean;
+    memory_times_seen?: number;
+    memory_fix_confirmed?: boolean;
+    memory_fix_state?: string;
+    memory_verified_count?: number;
+}
+/**
+ * The "Seen before" section, or null when there is nothing remembered.
+ *
+ * Returns null rather than an empty string so a caller cannot push a blank
+ * heading into the response and leave an agent reading "## Seen before"
+ * followed by nothing, which is worse than no section: it looks like a lookup
+ * that ran and found the error is new.
+ */
+export declare function memorySection(result: MemoryFields | null | undefined): string | null;

package/dist/memorySection.js

@@ -0,0 +1,62 @@
+/**
+ * The "Seen before" section, or null when there is nothing remembered.
+ *
+ * Returns null rather than an empty string so a caller cannot push a blank
+ * heading into the response and leave an agent reading "## Seen before"
+ * followed by nothing, which is worse than no section: it looks like a lookup
+ * that ran and found the error is new.
+ */
+export function memorySection(result) {
+    if (!result?.memory_hit) {
+        return null;
+    }
+    const seen = typeof result.memory_times_seen === 'number'
+        ? `${result.memory_times_seen}x before in this project`
+        : 'before in this project';
+    // Four states, not two. Until 2026-08-21 this said "a fix was confirmed
+    // working" on the strength of somebody clicking Apply, and a fix that had
+    // been tried and FAILED was indistinguishable from one nobody had ever
+    // tried — both fell into the else branch and read "no fix has been confirmed
+    // yet". An agent reading that will happily re-propose the fix that already
+    // did not work, which is the loop this exists to break.
+    //
+    // memory_fix_state is what the engine sends now. When it is absent (older
+    // engine) the boolean still decides, exactly as before.
+    const state = typeof result.memory_fix_state === 'string'
+        ? result.memory_fix_state
+        : (result.memory_fix_confirmed ? 'confirmed' : 'none');
+    const verified = typeof result.memory_verified_count === 'number'
+        ? result.memory_verified_count
+        : 0;
+    let body;
+    if (state === 'confirmed' && verified > 0) {
+        body =
+            `This error has been seen ${seen}. A fix for it was VERIFIED BY ` +
+                `OBSERVATION ${verified}x: a live session watched the error stop ` +
+                `after that fix was applied. It led the analysis above.`;
+    }
+    else if (state === 'confirmed') {
+        body =
+            `This error has been seen ${seen}. A fix for it was applied and ` +
+                `accepted by a developer, though nothing has observed it working. ` +
+                `It led the analysis above. Treat it as a strong lead, not proof.`;
+    }
+    else if (state === 'unproven') {
+        body =
+            `This error has been seen ${seen}. A fix was applied for it and ` +
+                `THE ERROR HAS RECURRED ONCE SINCE, so that fix is unproven. The ` +
+                `analysis above was told not to lead with it.`;
+    }
+    else if (state === 'anti_pattern') {
+        body =
+            `This error has been seen ${seen}. A fix was applied for it and ` +
+                `THE ERROR KEPT HAPPENING. That fix did not work and the analysis ` +
+                `above was told not to propose it again. If you are about to ` +
+                `suggest something equivalent, the cause is somewhere it does not ` +
+                `touch.`;
+    }
+    else {
+        body = `This error has been seen ${seen}. No fix has been confirmed for it yet.`;
+    }
+    return `\n## Seen before\n${body}`;
+}

package/dist/tools/debugError.js

@@ -3,6 +3,7 @@ import { callDebugBackend } from '../backend.js';
 import { mapBackendErrorToToolResult } from '../errors.js';
 import { resolveAuth } from './authGate.js';
 import { getProjectId, getProjectRoot } from '../project.js';
+import { memorySection } from '../memorySection.js';
 import { resolveSourceContext } from '../sourceContext.js';
 // Tri-state verification labeling (docs/plan-v2-contract-phase1.md §1).
 // The null case is rendered ON PURPOSE: a confidence number nothing checked
@@ -121,58 +122,12 @@ export function registerDebugError(server, config) {
             // Memory first, above the badges: "this project has hit this exact
             // error before, and a fix was confirmed" is the one thing here the
             // agent cannot derive from the code in front of it, so it should not
-            // be buried in a metadata footer.
-            if (result.memory_hit) {
-                const seen = typeof result.memory_times_seen === 'number'
-                    ? `${result.memory_times_seen}x before in this project`
-                    : 'before in this project';
-                // Four states, not two. Until 2026-08-21 this said "a fix was
-                // confirmed working" on the strength of somebody clicking Apply,
-                // and a fix that had been tried and FAILED was indistinguishable
-                // from one nobody had ever tried — both fell into the else branch
-                // and read "no fix has been confirmed yet". An agent reading that
-                // will happily re-propose the fix that already did not work, which
-                // is the loop this whole change exists to break.
-                //
-                // memory_fix_state is what the engine sends now. When it is absent
-                // (older engine) the boolean still decides, exactly as before.
-                const state = typeof result.memory_fix_state === 'string'
-                    ? result.memory_fix_state
-                    : (result.memory_fix_confirmed ? 'confirmed' : 'none');
-                const verified = typeof result.memory_verified_count === 'number'
-                    ? result.memory_verified_count
-                    : 0;
-                let memoryBody;
-                if (state === 'confirmed' && verified > 0) {
-                    memoryBody =
-                        `This error has been seen ${seen}. A fix for it was VERIFIED BY ` +
-                            `OBSERVATION ${verified}x: a live session watched the error stop ` +
-                            `after that fix was applied. It led the analysis above.`;
-                }
-                else if (state === 'confirmed') {
-                    memoryBody =
-                        `This error has been seen ${seen}. A fix for it was applied and ` +
-                            `accepted by a developer, though nothing has observed it working. ` +
-                            `It led the analysis above. Treat it as a strong lead, not proof.`;
-                }
-                else if (state === 'unproven') {
-                    memoryBody =
-                        `This error has been seen ${seen}. A fix was applied for it and ` +
-                            `THE ERROR HAS RECURRED ONCE SINCE, so that fix is unproven. The ` +
-                            `analysis above was told not to lead with it.`;
-                }
-                else if (state === 'anti_pattern') {
-                    memoryBody =
-                        `This error has been seen ${seen}. A fix was applied for it and ` +
-                            `THE ERROR KEPT HAPPENING. That fix did not work and the analysis ` +
-                            `above was told not to propose it again. If you are about to ` +
-                            `suggest something equivalent, the cause is somewhere it does not ` +
-                            `touch.`;
-                }
-                else {
-                    memoryBody = `This error has been seen ${seen}. No fix has been confirmed for it yet.`;
-                }
-                sections.push(`\n## Seen before\n${memoryBody}`);
+            // be buried in a metadata footer. The wording lives in
+            // ../memorySection.ts, byte-identical with the bundled server, because
+            // inlined here it drifted out of that copy entirely.
+            const memory = memorySection(result);
+            if (memory) {
+                sections.push(memory);
             }
             const badges = [];
             // Named, not counted. "Read 2 files" is unverifiable; "read src/api.ts,

package/dist/tools/reportOutcome.js

@@ -41,7 +41,7 @@ import { resolveAuth } from './authGate.js';
 export function registerReportOutcome(server, config) {
     server.registerTool('report_outcome', {
         title: 'Report Fix Outcome',
-        description: 'Report what happened after DebugAI answered — including when you did not use its fix. ' +
+        description: 'Report what happened after DebugAI answered, including when you did not use its fix. ' +
             'Call this ONCE per debug_error response, passing the debug_log_id from it. ' +
             'If you solved the problem another way, say so with result "unused" and put the real ' +
             'fix in actualFix: a case DebugAI got wrong is worth more to it than one it got right. ' +
@@ -58,8 +58,8 @@ export function registerReportOutcome(server, config) {
                 .describe('"worked" = you applied a DebugAI fix and the error stopped. ' +
                 '"failed" = you applied one and it did not help (or made things worse). ' +
                 '"unused" = you did not apply any of them and resolved it another way. ' +
-                'Use "unused" rather than "failed" when nothing of ours was actually run — ' +
-                'they are different facts and reporting the wrong one buries a fix nobody tried.'),
+                'Use "unused" rather than "failed" when nothing of ours was actually run. ' +
+                'They are different facts and reporting the wrong one buries a fix nobody tried.'),
             fixRank: z
                 .number()
                 .int()
@@ -77,7 +77,7 @@ export function registerReportOutcome(server, config) {
                 .max(4000)
                 .optional()
                 .describe('What actually resolved the error, when it was not the fix DebugAI suggested. ' +
-                'Free text. Say what the real cause turned out to be and what you changed — ' +
+                'Free text. Say what the real cause turned out to be and what you changed, ' +
                 'especially if the cause was in a different layer than the answer addressed ' +
                 '(the shell, the runtime version, the environment, a missing package).'),
             toolFeedback: z

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@debugai/mcp",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "mcpName": "io.github.1shizaan/debugai-mcp",
   "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",