@kernlang/review-python 4.1.1-canary.228.1.41c150f2 → 4.5.0

package/dist/mapper/extractors/error.js

@@ -1,4 +1,5 @@
 import { conceptId } from '@kernlang/core';
+import { PYTHON_BUILTIN_EXCEPTIONS } from '@kernlang/review';
 import { getContainerId, nodeSpan, nodeText, walkNodes } from '../helpers/ast.js';
 import { PY_API_ERROR_STATUS_CODES } from '../signatures.js';
 export function extractErrorRaise(root, source, filePath, nodes) {
@@ -49,24 +50,18 @@ function classifyPythonDisposition(exceptNode, block, source) {
     const children = block.namedChildren;
     // except: pass → ignored
     if (children.length === 1 && children[0].type === 'pass_statement') {
-        if (isIntentionalNoopExcept(exceptNode, source))
-            return { type: 'wrapped', confidence: 0.55 };
-        return { type: 'ignored', confidence: 1.0 };
+        return noopDisposition(exceptNode, block, source);
     }
     // except: ... (ellipsis) → ignored
     if (children.length === 1 && children[0].type === 'expression_statement') {
         const text = source.substring(children[0].startIndex, children[0].endIndex).trim();
         if (text === '...') {
-            if (isIntentionalNoopExcept(exceptNode, source))
-                return { type: 'wrapped', confidence: 0.55 };
-            return { type: 'ignored', confidence: 1.0 };
+            return noopDisposition(exceptNode, block, source);
         }
     }
     // Empty block
     if (children.length === 0) {
-        if (isIntentionalNoopExcept(exceptNode, source))
-            return { type: 'wrapped', confidence: 0.55 };
-        return { type: 'ignored', confidence: 1.0 };
+        return noopDisposition(exceptNode, block, source);
     }
     const bodyText = source.substring(block.startIndex, block.endIndex);
     // raise → rethrown or wrapped
@@ -89,6 +84,39 @@ function classifyPythonDisposition(exceptNode, block, source) {
     }
     return { type: 'wrapped', confidence: 0.5 };
 }
+// A silent swallow (`pass` / `...` / empty block) reads as a genuine "ignored"
+// error ONLY when the catch is broad/bare AND undocumented. Two shapes are
+// expected patterns, not oversights, and downgrade to 'wrapped':
+//   • a narrow, NON-builtin (domain/library) exception — `except IntegrityError:
+//     pass` (dedupe on a unique constraint), `except ProgressDataNotFoundException:
+//     pass` (optional section). Builtin exceptions stay flaggable because they
+//     are broad enough to hide an UNRELATED failure (`except OSError: pass`
+//     around mixed I/O).
+//   • an explanatory comment in the except header or block — a conscious
+//     decision ("# instrumentation must never break a chat turn").
+// This closed 4 correct-swallow false positives kern-guard raised on fitvt PR #16.
+function noopDisposition(exceptNode, block, source) {
+    const intentional = isIntentionalNoopExcept(exceptNode, source) ||
+        isNarrowNonBuiltinExcept(exceptNode, block, source) ||
+        hasExplanatoryComment(exceptNode, block, source);
+    return intentional ? { type: 'wrapped', confidence: 0.55 } : { type: 'ignored', confidence: 1.0 };
+}
+// True when EVERY caught type is a narrow, non-builtin exception. Bare `except:`
+// (no types) and any builtin / `Exception` / `BaseException` disqualify it, so a
+// mixed `except (IntegrityError, Exception):` stays flaggable.
+function isNarrowNonBuiltinExcept(exceptNode, block, source) {
+    const types = parseExceptTypes(source.substring(exceptNode.startIndex, block.startIndex));
+    if (types.length === 0)
+        return false;
+    return types.every((t) => !PYTHON_BUILTIN_EXCEPTIONS.has(t));
+}
+// True when the except header or its (pass/…/empty) block carries a `#` comment.
+// The block body here is only pass/…/empty, and an except header holds no string
+// literals, so any `#` in this contiguous source range is a comment — the scan
+// is safe without string-stripping.
+function hasExplanatoryComment(exceptNode, block, source) {
+    return source.substring(exceptNode.startIndex, block.endIndex).includes('#');
+}
 function isIntentionalNoopExcept(exceptNode, source) {
     const block = exceptNode.children.find((child) => child.type === 'block');
     const headerEnd = block?.startIndex ?? exceptNode.endIndex;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kernlang/review-python",
-  "version": "4.1.1-canary.228.1.41c150f2",
+  "version": "4.5.0",
   "description": "Python concept mapper for kern review — tree-sitter based",
   "type": "module",
   "main": "dist/index.js",
@@ -8,8 +8,8 @@
   "dependencies": {
     "tree-sitter": "^0.25.0",
     "tree-sitter-python": "^0.25.0",
-    "@kernlang/core": "4.1.1-canary.228.1.41c150f2",
-    "@kernlang/review": "4.1.1-canary.228.1.41c150f2"
+    "@kernlang/core": "4.5.0",
+    "@kernlang/review": "4.5.0"
   },
   "devDependencies": {
     "ts-morph": "^28.0.0",

package/src/mapper/extractors/error.ts

@@ -1,5 +1,6 @@
 import type { ConceptNode, ErrorHandlePayload } from '@kernlang/core';
 import { conceptId } from '@kernlang/core';
+import { PYTHON_BUILTIN_EXCEPTIONS } from '@kernlang/review';
 import type Parser from 'tree-sitter';
 import { getContainerId, nodeSpan, nodeText, walkNodes } from '../helpers/ast.js';
 import { PY_API_ERROR_STATUS_CODES } from '../signatures.js';
@@ -70,23 +71,20 @@ function classifyPythonDisposition(
 
   // except: pass → ignored
   if (children.length === 1 && children[0].type === 'pass_statement') {
-    if (isIntentionalNoopExcept(exceptNode, source)) return { type: 'wrapped', confidence: 0.55 };
-    return { type: 'ignored', confidence: 1.0 };
+    return noopDisposition(exceptNode, block, source);
   }
 
   // except: ... (ellipsis) → ignored
   if (children.length === 1 && children[0].type === 'expression_statement') {
     const text = source.substring(children[0].startIndex, children[0].endIndex).trim();
     if (text === '...') {
-      if (isIntentionalNoopExcept(exceptNode, source)) return { type: 'wrapped', confidence: 0.55 };
-      return { type: 'ignored', confidence: 1.0 };
+      return noopDisposition(exceptNode, block, source);
     }
   }
 
   // Empty block
   if (children.length === 0) {
-    if (isIntentionalNoopExcept(exceptNode, source)) return { type: 'wrapped', confidence: 0.55 };
-    return { type: 'ignored', confidence: 1.0 };
+    return noopDisposition(exceptNode, block, source);
   }
 
   const bodyText = source.substring(block.startIndex, block.endIndex);
@@ -114,6 +112,46 @@ function classifyPythonDisposition(
   return { type: 'wrapped', confidence: 0.5 };
 }
 
+// A silent swallow (`pass` / `...` / empty block) reads as a genuine "ignored"
+// error ONLY when the catch is broad/bare AND undocumented. Two shapes are
+// expected patterns, not oversights, and downgrade to 'wrapped':
+//   • a narrow, NON-builtin (domain/library) exception — `except IntegrityError:
+//     pass` (dedupe on a unique constraint), `except ProgressDataNotFoundException:
+//     pass` (optional section). Builtin exceptions stay flaggable because they
+//     are broad enough to hide an UNRELATED failure (`except OSError: pass`
+//     around mixed I/O).
+//   • an explanatory comment in the except header or block — a conscious
+//     decision ("# instrumentation must never break a chat turn").
+// This closed 4 correct-swallow false positives kern-guard raised on fitvt PR #16.
+function noopDisposition(
+  exceptNode: Parser.SyntaxNode,
+  block: Parser.SyntaxNode,
+  source: string,
+): { type: ErrorHandlePayload['disposition']; confidence: number } {
+  const intentional =
+    isIntentionalNoopExcept(exceptNode, source) ||
+    isNarrowNonBuiltinExcept(exceptNode, block, source) ||
+    hasExplanatoryComment(exceptNode, block, source);
+  return intentional ? { type: 'wrapped', confidence: 0.55 } : { type: 'ignored', confidence: 1.0 };
+}
+
+// True when EVERY caught type is a narrow, non-builtin exception. Bare `except:`
+// (no types) and any builtin / `Exception` / `BaseException` disqualify it, so a
+// mixed `except (IntegrityError, Exception):` stays flaggable.
+function isNarrowNonBuiltinExcept(exceptNode: Parser.SyntaxNode, block: Parser.SyntaxNode, source: string): boolean {
+  const types = parseExceptTypes(source.substring(exceptNode.startIndex, block.startIndex));
+  if (types.length === 0) return false;
+  return types.every((t) => !PYTHON_BUILTIN_EXCEPTIONS.has(t));
+}
+
+// True when the except header or its (pass/…/empty) block carries a `#` comment.
+// The block body here is only pass/…/empty, and an except header holds no string
+// literals, so any `#` in this contiguous source range is a comment — the scan
+// is safe without string-stripping.
+function hasExplanatoryComment(exceptNode: Parser.SyntaxNode, block: Parser.SyntaxNode, source: string): boolean {
+  return source.substring(exceptNode.startIndex, block.endIndex).includes('#');
+}
+
 function isIntentionalNoopExcept(exceptNode: Parser.SyntaxNode, source: string): boolean {
   const block = exceptNode.children.find((child) => child.type === 'block');
   const headerEnd = block?.startIndex ?? exceptNode.endIndex;

package/tests/ignored-error-precision.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Precision tests for the Python ignored-error classifier.
+ *
+ * kern-guard on fitvt PR #16 flagged four CORRECT swallows as ignored-error
+ * false positives. A silent swallow (`pass`/`...`/empty) should read as
+ * "ignored" ONLY when the catch is broad/bare AND undocumented; a narrow
+ * non-builtin (domain/library) exception, or any explanatory comment, is an
+ * intentional decision. Builtin exceptions stay flaggable because they are
+ * broad enough to hide an unrelated failure.
+ */
+
+import { runConceptRules } from '@kernlang/review';
+import { extractPythonConcepts } from '../src/mapper.js';
+
+function fires(source: string): boolean {
+  const concepts = extractPythonConcepts(source, 'test.py');
+  const findings = runConceptRules(concepts, 'test.py');
+  return Boolean(findings.find((f) => f.ruleId === 'ignored-error'));
+}
+
+describe('Python ignored-error precision (fitvt PR #16)', () => {
+  it('does NOT fire on a narrow non-builtin exception swallow (dedupe pattern)', () => {
+    expect(
+      fires(`
+try:
+    async with db.begin_nested():
+        db.add(CustomFoodReport(custom_food_id=cid))
+except IntegrityError:
+    pass
+`),
+    ).toBe(false);
+  });
+
+  it('does NOT fire on a narrow domain-exception swallow (optional section)', () => {
+    expect(
+      fires(`
+try:
+    weight = get_weight_progress(user_id)
+    summary["weight"] = weight
+except ProgressDataNotFoundException:
+    pass
+`),
+    ).toBe(false);
+  });
+
+  it('does NOT fire on a broad catch with an inline explanatory comment', () => {
+    expect(
+      fires(`
+try:
+    logger.info("metric %d", n)
+except Exception:  # instrumentation must never break a chat turn
+    pass
+`),
+    ).toBe(false);
+  });
+
+  it('does NOT fire on a broad catch with a standalone explanatory comment', () => {
+    expect(
+      fires(`
+try:
+    return verify_token(header).get("sub")
+except Exception:
+    # Never let token-parsing errors block or crash the limiter.
+    pass
+`),
+    ).toBe(false);
+  });
+
+  it('STILL fires on a broad, undocumented Exception swallow', () => {
+    expect(
+      fires(`
+try:
+    analytics["body_fat"] = get_average_body_fat(user_id)
+except Exception:
+    pass
+`),
+    ).toBe(true);
+  });
+
+  it('STILL fires on a bare except: pass', () => {
+    expect(
+      fires(`
+try:
+    do_work()
+except:
+    pass
+`),
+    ).toBe(true);
+  });
+
+  it('STILL fires on a narrow BUILTIN exception mixed with real work (can hide unrelated failure)', () => {
+    expect(
+      fires(`
+try:
+    os.close(fd)
+    open(path).read()
+except OSError:
+    pass
+`),
+    ).toBe(true);
+  });
+
+  it('STILL fires when a non-builtin is mixed with a broad Exception', () => {
+    expect(
+      fires(`
+try:
+    db.add(row)
+except (IntegrityError, Exception):
+    pass
+`),
+    ).toBe(true);
+  });
+
+  it('STILL fires on the 3.11 broad builtins ExceptionGroup / BaseExceptionGroup', () => {
+    expect(fires(`\ntry:\n    do_work()\nexcept ExceptionGroup:\n    pass\n`)).toBe(true);
+    expect(fires(`\ntry:\n    do_work()\nexcept BaseExceptionGroup:\n    pass\n`)).toBe(true);
+  });
+
+  it('STILL fires on builtin Warning subclasses (e.g. DeprecationWarning)', () => {
+    expect(fires(`\ntry:\n    do_work()\nexcept DeprecationWarning:\n    pass\n`)).toBe(true);
+    expect(fires(`\ntry:\n    do_work()\nexcept ResourceWarning:\n    pass\n`)).toBe(true);
+  });
+
+  it('does NOT fire on a narrow non-builtin in a MULTI-LINE tuple header', () => {
+    // The tree-sitter header span covers all lines; the fallback joins them.
+    expect(
+      fires(`
+try:
+    db.add(row)
+except (
+    IntegrityError,
+):
+    pass
+`),
+    ).toBe(false);
+  });
+});