@kernlang/review-python 0.2.0

package/tests/bilingual-v2.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Bilingual Tests v2 — new concepts: entrypoint, guard, state_mutation, dependency
+ *
+ * Same concept, two languages, same shape.
+ */
+
+import { extractPythonConcepts } from '../src/mapper.js';
+import { extractTsConcepts } from '@kernlang/review';
+import { Project } from 'ts-morph';
+
+function tsSourceFile(source: string, filePath = 'test.ts') {
+  const project = new Project({ useInMemoryFileSystem: true, compilerOptions: { strict: true } });
+  return project.createSourceFile(filePath, source);
+}
+
+describe('Bilingual: entrypoint', () => {
+  it('TS app.get route → entrypoint(route)', () => {
+    const sf = tsSourceFile(`
+      app.get('/users', (req, res) => { res.json([]); });
+    `);
+    const concepts = extractTsConcepts(sf, 'test.ts');
+    const ep = concepts.nodes.find(n => n.kind === 'entrypoint');
+    expect(ep).toBeDefined();
+    expect(ep!.payload.kind).toBe('entrypoint');
+    if (ep!.payload.kind === 'entrypoint') {
+      expect(ep!.payload.subtype).toBe('route');
+    }
+  });
+
+  it('Python @app.route → same entrypoint(route)', () => {
+    const source = `
+from flask import Flask
+app = Flask(__name__)
+
+@app.route('/users')
+def get_users():
+    return []
+`;
+    const concepts = extractPythonConcepts(source, 'test.py');
+    const ep = concepts.nodes.find(n => n.kind === 'entrypoint');
+    expect(ep).toBeDefined();
+    expect(ep!.payload.kind).toBe('entrypoint');
+    if (ep!.payload.kind === 'entrypoint') {
+      expect(ep!.payload.subtype).toBe('route');
+    }
+  });
+});
+
+describe('Bilingual: guard', () => {
+  it('TS auth early-return → guard(auth)', () => {
+    const sf = tsSourceFile(`
+      function handler(req, res) {
+        if (!req.user) return res.status(401).send('Unauthorized');
+        doWork();
+      }
+    `);
+    const concepts = extractTsConcepts(sf, 'test.ts');
+    const guard = concepts.nodes.find(n => n.kind === 'guard');
+    expect(guard).toBeDefined();
+    expect(guard!.payload.kind).toBe('guard');
+    if (guard!.payload.kind === 'guard') {
+      expect(guard!.payload.subtype).toBe('auth');
+    }
+  });
+
+  it('Python @login_required → same guard(auth)', () => {
+    const source = `
+from django.contrib.auth.decorators import login_required
+
+@login_required
+def dashboard(request):
+    return render(request, 'dashboard.html')
+`;
+    const concepts = extractPythonConcepts(source, 'test.py');
+    const guard = concepts.nodes.find(n => n.kind === 'guard');
+    expect(guard).toBeDefined();
+    expect(guard!.payload.kind).toBe('guard');
+    if (guard!.payload.kind === 'guard') {
+      expect(guard!.payload.subtype).toBe('auth');
+    }
+  });
+});
+
+describe('Bilingual: state_mutation', () => {
+  it('TS this.count++ → state_mutation(module)', () => {
+    const sf = tsSourceFile(`
+      class Counter {
+        count = 0;
+        increment() { this.count++; }
+      }
+    `);
+    const concepts = extractTsConcepts(sf, 'test.ts');
+    const mut = concepts.nodes.find(n => n.kind === 'state_mutation');
+    expect(mut).toBeDefined();
+    if (mut!.payload.kind === 'state_mutation') {
+      expect(mut!.payload.scope).toBe('module');
+    }
+  });
+
+  it('Python self.count += 1 → same state_mutation(module)', () => {
+    const source = `
+class Counter:
+    def __init__(self):
+        self.count = 0
+    def increment(self):
+        self.count += 1
+`;
+    const concepts = extractPythonConcepts(source, 'test.py');
+    const mut = concepts.nodes.find(n => n.kind === 'state_mutation');
+    expect(mut).toBeDefined();
+    if (mut!.payload.kind === 'state_mutation') {
+      expect(mut!.payload.scope).toBe('module');
+    }
+  });
+});
+
+describe('Bilingual: dependency edges', () => {
+  it('TS import → dependency edge', () => {
+    const sf = tsSourceFile(`
+      import express from 'express';
+      import { readFile } from 'fs';
+      import { helper } from './utils.js';
+    `);
+    const concepts = extractTsConcepts(sf, 'test.ts');
+    expect(concepts.edges.length).toBeGreaterThanOrEqual(3);
+
+    const external = concepts.edges.find(e => e.payload.kind === 'dependency' && e.payload.subtype === 'external');
+    const stdlib = concepts.edges.find(e => e.payload.kind === 'dependency' && e.payload.subtype === 'stdlib');
+    const internal = concepts.edges.find(e => e.payload.kind === 'dependency' && e.payload.subtype === 'internal');
+
+    expect(external).toBeDefined();
+    expect(stdlib).toBeDefined();
+    expect(internal).toBeDefined();
+  });
+
+  it('Python import → same dependency edge shape', () => {
+    const source = `
+import os
+import requests
+from .utils import helper
+`;
+    const concepts = extractPythonConcepts(source, 'test.py');
+    expect(concepts.edges.length).toBeGreaterThanOrEqual(3);
+
+    const external = concepts.edges.find(e => e.payload.kind === 'dependency' && e.payload.subtype === 'external');
+    const stdlib = concepts.edges.find(e => e.payload.kind === 'dependency' && e.payload.subtype === 'stdlib');
+    const internal = concepts.edges.find(e => e.payload.kind === 'dependency' && e.payload.subtype === 'internal');
+
+    expect(external).toBeDefined();
+    expect(stdlib).toBeDefined();
+    expect(internal).toBeDefined();
+  });
+});

package/tests/bilingual.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Bilingual Tests — same concept rule, two languages, same findings.
+ *
+ * This is the proof that KERN concepts are universal.
+ */
+
+import { extractPythonConcepts } from '../src/mapper.js';
+import { extractTsConcepts, runConceptRules } from '@kernlang/review';
+import { Project } from 'ts-morph';
+
+function tsSourceFile(source: string, filePath = 'test.ts') {
+  const project = new Project({ useInMemoryFileSystem: true, compilerOptions: { strict: true } });
+  return project.createSourceFile(filePath, source);
+}
+
+describe('Bilingual: ignored-error', () => {
+  it('TS empty catch → ignored-error finding', () => {
+    const sf = tsSourceFile('try { doWork(); } catch (e) {}');
+    const concepts = extractTsConcepts(sf, 'test.ts');
+    const findings = runConceptRules(concepts, 'test.ts');
+    const f = findings.find(f => f.ruleId === 'ignored-error');
+    expect(f).toBeDefined();
+    expect(f!.severity).toBe('error');
+  });
+
+  it('Python except:pass → same ignored-error finding', () => {
+    const source = `
+try:
+    do_work()
+except:
+    pass
+`;
+    const concepts = extractPythonConcepts(source, 'test.py');
+    const findings = runConceptRules(concepts, 'test.py');
+    const f = findings.find(f => f.ruleId === 'ignored-error');
+    expect(f).toBeDefined();
+    expect(f!.severity).toBe('error');
+  });
+
+  it('Python except Exception as e: ... → same ignored-error finding', () => {
+    const source = `
+try:
+    do_work()
+except Exception as e:
+    ...
+`;
+    const concepts = extractPythonConcepts(source, 'test.py');
+    const findings = runConceptRules(concepts, 'test.py');
+    const f = findings.find(f => f.ruleId === 'ignored-error');
+    expect(f).toBeDefined();
+  });
+
+  it('TS catch with handler → NO finding', () => {
+    const sf = tsSourceFile('try { doWork(); } catch (e) { throw new AppError(e); }');
+    const concepts = extractTsConcepts(sf, 'test.ts');
+    const findings = runConceptRules(concepts, 'test.ts');
+    const f = findings.find(f => f.ruleId === 'ignored-error');
+    expect(f).toBeUndefined();
+  });
+
+  it('Python except with raise → NO finding', () => {
+    const source = `
+try:
+    do_work()
+except Exception as e:
+    raise AppError(e)
+`;
+    const concepts = extractPythonConcepts(source, 'test.py');
+    const findings = runConceptRules(concepts, 'test.py');
+    const f = findings.find(f => f.ruleId === 'ignored-error');
+    expect(f).toBeUndefined();
+  });
+});
+
+describe('Bilingual: concept parity', () => {
+  it('TS throw and Python raise produce same concept shape', () => {
+    const tsSf = tsSourceFile('function fail() { throw new Error("boom"); }');
+    const tsConcepts = extractTsConcepts(tsSf, 'test.ts');
+
+    const pyConcepts = extractPythonConcepts('def fail():\n    raise ValueError("boom")', 'test.py');
+
+    const tsRaise = tsConcepts.nodes.find(n => n.kind === 'error_raise');
+    const pyRaise = pyConcepts.nodes.find(n => n.kind === 'error_raise');
+
+    expect(tsRaise).toBeDefined();
+    expect(pyRaise).toBeDefined();
+    expect(tsRaise!.kind).toBe(pyRaise!.kind);
+    expect(tsRaise!.payload.kind).toBe(pyRaise!.payload.kind);
+    if (tsRaise!.payload.kind === 'error_raise' && pyRaise!.payload.kind === 'error_raise') {
+      expect(tsRaise!.payload.subtype).toBe('throw');
+      expect(pyRaise!.payload.subtype).toBe('throw');
+    }
+  });
+
+  it('TS fetch and Python requests.get produce same effect concept', () => {
+    const tsSf = tsSourceFile('async function getData() { await fetch("/api"); }');
+    const tsConcepts = extractTsConcepts(tsSf, 'test.ts');
+
+    const pyConcepts = extractPythonConcepts('def get_data():\n    requests.get("/api")', 'test.py');
+
+    const tsEffect = tsConcepts.nodes.find(n => n.kind === 'effect');
+    const pyEffect = pyConcepts.nodes.find(n => n.kind === 'effect');
+
+    expect(tsEffect).toBeDefined();
+    expect(pyEffect).toBeDefined();
+    expect(tsEffect!.kind).toBe(pyEffect!.kind);
+    if (tsEffect!.payload.kind === 'effect' && pyEffect!.payload.kind === 'effect') {
+      expect(tsEffect!.payload.subtype).toBe('network');
+      expect(pyEffect!.payload.subtype).toBe('network');
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src"],
+  "references": [
+    { "path": "../core" },
+    { "path": "../review" }
+  ]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/index.ts","./src/mapper.ts"],"version":"5.9.3"}