codemetrics-ai 0.3.0 → 0.5.0

package/dist/react-probe.js

@@ -0,0 +1,60 @@
+import ts from "typescript";
+import { isFunction } from "./function-nodes.js";
+function isReactImport(declaration) {
+    if (ts.isImportSpecifier(declaration) && declaration.isTypeOnly)
+        return false;
+    let cursor = declaration;
+    while (cursor && !ts.isImportDeclaration(cursor))
+        cursor = cursor.parent;
+    return !!cursor && !cursor.importClause?.isTypeOnly && ts.isStringLiteral(cursor.moduleSpecifier) && cursor.moduleSpecifier.text === "react";
+}
+export function importedHookName(call, checker) {
+    const symbol = checker.getSymbolAtLocation(ts.isPropertyAccessExpression(call.expression) ? call.expression.name : call.expression);
+    const declarations = symbol?.declarations ?? [];
+    const reactHook = declarations.some(isReactImport);
+    const hookName = declarations.find(ts.isImportSpecifier);
+    const calledName = hookName ? (hookName.propertyName ?? hookName.name).text : ts.isPropertyAccessExpression(call.expression) ? call.expression.name.text : "";
+    const namespaceSymbol = ts.isPropertyAccessExpression(call.expression) ? checker.getSymbolAtLocation(call.expression.expression) : undefined;
+    const reactNamespace = namespaceSymbol?.declarations?.some(isReactImport);
+    return (reactHook || reactNamespace) && /^use[A-Z]/.test(calledName) ? calledName : undefined;
+}
+function isConditionalOrLoop(node, child) {
+    if (ts.isIfStatement(node))
+        return child !== node.expression;
+    if (ts.isConditionalExpression(node))
+        return child !== node.condition;
+    if (ts.isBinaryExpression(node))
+        return child === node.right &&
+            [ts.SyntaxKind.AmpersandAmpersandToken, ts.SyntaxKind.BarBarToken, ts.SyntaxKind.QuestionQuestionToken].includes(node.operatorToken.kind);
+    if (ts.isForStatement(node))
+        return child !== node.initializer;
+    if (ts.isForOfStatement(node) || ts.isForInStatement(node))
+        return child !== node.expression;
+    return ts.isWhileStatement(node) || ts.isDoStatement(node);
+}
+// The metric visitor supplies only calls owned by the current function. Keeping
+// traversal and identity there preserves nested-function boundaries and ordering.
+export function inspectReactCall(call, body, checker) {
+    const hook = importedHookName(call, checker);
+    if (!hook)
+        return [];
+    const findings = [];
+    let ancestor = call.parent;
+    let child = call;
+    while (ancestor && ancestor !== body) {
+        if (isConditionalOrLoop(ancestor, child)) {
+            findings.push({ category: "conditionalHook", message: `${hook} is called within a conditional or loop.`, observations: { hook }, confidence: "high" });
+            break;
+        }
+        child = ancestor;
+        ancestor = ancestor.parent;
+    }
+    if (["useEffect", "useLayoutEffect"].includes(hook)) {
+        const callback = call.arguments[0];
+        if (callback && isFunction(callback) && callback.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword))
+            findings.push({ category: "asyncEffectCallback", message: "An effect callback is async and returns a Promise instead of cleanup or undefined.", observations: { hook }, confidence: "high" });
+        if (call.arguments.length < 2)
+            findings.push({ category: "effectWithoutDependencies", message: "Effect runs after every render; verify that this is intentional.", observations: { hook }, confidence: "low" });
+    }
+    return findings;
+}

package/dist/score-arithmetic.d.ts

@@ -0,0 +1,12 @@
+export interface Fraction {
+    numerator: bigint;
+    denominator: bigint;
+}
+export declare function fraction(numerator: bigint, denominator?: bigint): Fraction;
+export declare function decimal(value: number): Fraction;
+export declare const add: (a: Fraction, b: Fraction) => Fraction;
+export declare const multiply: (a: Fraction, b: Fraction) => Fraction;
+export declare const subtract: (a: Fraction, b: Fraction) => Fraction;
+export declare const numeric: (a: Fraction) => number;
+export declare function roundScore(a: Fraction): number;
+export declare function interpolate(value: number, anchors: readonly (readonly [number, number])[]): Fraction;

package/dist/score-arithmetic.js

@@ -0,0 +1,40 @@
+export function fraction(numerator, denominator = 1n) {
+    if (denominator <= 0n)
+        throw new Error("Positive denominator required.");
+    let a = numerator < 0n ? -numerator : numerator, b = denominator;
+    while (b) {
+        const remainder = a % b;
+        a = b;
+        b = remainder;
+    }
+    return { numerator: numerator / a, denominator: denominator / a };
+}
+export function decimal(value) {
+    if (!Number.isFinite(value))
+        throw new Error("Finite score measurement required.");
+    const [mantissa, exponent = "0"] = String(value).toLowerCase().split("e");
+    const places = (mantissa.split(".")[1] ?? "").length - Number(exponent);
+    const numerator = BigInt(mantissa.replace(".", ""));
+    return places >= 0 ? fraction(numerator, 10n ** BigInt(places)) : fraction(numerator * 10n ** BigInt(-places));
+}
+export const add = (a, b) => fraction(a.numerator * b.denominator + b.numerator * a.denominator, a.denominator * b.denominator);
+export const multiply = (a, b) => fraction(a.numerator * b.numerator, a.denominator * b.denominator);
+export const subtract = (a, b) => add(a, { ...b, numerator: -b.numerator });
+export const numeric = (a) => Number(a.numerator) / Number(a.denominator);
+export function roundScore(a) {
+    if (a.numerator < 0n)
+        throw new Error("Score must be nonnegative.");
+    return Number((a.numerator * 20n + a.denominator) / (2n * a.denominator)) / 10;
+}
+export function interpolate(value, anchors) {
+    if (!Number.isFinite(value))
+        throw new Error("Finite score measurement required.");
+    if (value <= anchors[0][0])
+        return decimal(anchors[0][1]);
+    for (let index = 1; index < anchors.length; index++) {
+        const [x, y] = anchors[index], [previousX, previousY] = anchors[index - 1];
+        if (value <= x)
+            return add(decimal(previousY), multiply(subtract(decimal(value), decimal(previousX)), fraction(BigInt(y - previousY), BigInt(x - previousX))));
+    }
+    return decimal(anchors[anchors.length - 1][1]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemetrics-ai",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Deterministic code metrics and scorecard evidence for JavaScript, TypeScript, and React projects",
   "license": "MIT",
   "type": "module",
@@ -15,8 +15,9 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/copy-schema.mjs",
     "prepack": "npm run build",
-    "test": "npm run build && vitest run",
-    "test:package": "node scripts/package-smoke.mjs"
+    "test": "npm run build && vitest run --maxWorkers=2",
+    "test:package": "node scripts/package-smoke.mjs",
+    "test:architecture": "npm run build && node scripts/architecture-corpus.mjs"
   },
   "engines": {
     "node": ">=20"