project-tiny-context-harness 0.8.6 → 0.8.8

package/dist/lib/modularity-capability-migration.js

@@ -0,0 +1,165 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { pathExists, readText, writeTextIfChanged } from "./fs.js";
+import { harnessConfigPath } from "./harness-root.js";
+import { DEFAULT_MODULARITY_LINE_LIMIT, hasLegacyHeuristicOnlyWaiverRisk, isLifecycleCompleteModularityWaiverConfig, isLikelyGeneratedSourceContent, } from "./modularity.js";
+import { toPosix } from "./source-files.js";
+import { parseYaml, stringifyYaml } from "./yaml.js";
+const MIGRATION_ID = "modularity-capability-waiver-cleanup";
+const INTRODUCED_IN = "0.8.8";
+const DESCRIPTION = "Remove scoped modularity waivers that existed only for unsupported cross-language heuristic metrics.";
+const SCOPE = "<harnessRoot>/config.yaml modularity.waivers";
+export const modularityCapabilityWaiverMigration = {
+    id: MIGRATION_ID,
+    introducedIn: INTRODUCED_IN,
+    description: DESCRIPTION,
+    scope: SCOPE,
+    risk: "safe",
+    manualMessage: "Remove only the waiver identified as legacy-heuristic-only; retain any waiver that still covers physical-line or supported language metrics.",
+    detect: detectModularityCapabilityWaivers,
+    apply: migrateModularityCapabilityWaivers,
+    verify: verifyModularityCapabilityWaivers,
+};
+async function detectModularityCapabilityWaivers(projectRoot) {
+    const config = await readRawConfig(projectRoot);
+    if (!config) {
+        return [];
+    }
+    const candidates = await obsoleteWaiverIndexes(projectRoot, config.value);
+    return candidates.map(({ index, relativePath }) => ({
+        id: MIGRATION_ID,
+        introducedIn: INTRODUCED_IN,
+        description: DESCRIPTION,
+        scope: SCOPE,
+        status: "safe_pending",
+        path: `${config.relativePath}#modularity.waivers[${index}]`,
+        message: `${relativePath} exceeded only metrics from the retired cross-language JS heuristic; upgrade can remove this now-inapplicable waiver without changing supported line-risk coverage.`,
+    }));
+}
+async function migrateModularityCapabilityWaivers(projectRoot, _root, report) {
+    const config = await readRawConfig(projectRoot);
+    if (!config) {
+        report.skipped.push(MIGRATION_ID);
+        return;
+    }
+    const candidates = await obsoleteWaiverIndexes(projectRoot, config.value);
+    if (candidates.length === 0) {
+        report.skipped.push(MIGRATION_ID);
+        return;
+    }
+    const modularity = row(config.value.modularity);
+    const waivers = Array.isArray(modularity?.waivers) ? modularity.waivers : [];
+    const removed = new Set(candidates.map((candidate) => candidate.index));
+    const retained = waivers.filter((_waiver, index) => !removed.has(index));
+    if (retained.length > 0) {
+        modularity.waivers = retained;
+    }
+    else {
+        delete modularity.waivers;
+    }
+    if (await writeTextIfChanged(config.absolutePath, stringifyYaml(config.value))) {
+        report.changed.push(`${config.relativePath}#modularity.waivers removed=${removed.size}`);
+    }
+    else {
+        report.skipped.push(MIGRATION_ID);
+    }
+}
+async function verifyModularityCapabilityWaivers(projectRoot) {
+    const remaining = await detectModularityCapabilityWaivers(projectRoot);
+    if (remaining.length > 0) {
+        throw new Error("modularity capability waiver cleanup migration verification failed");
+    }
+}
+async function obsoleteWaiverIndexes(projectRoot, config) {
+    const modularity = row(config.modularity);
+    if (!modularity ||
+        (modularity.policy ?? "scoped_waivers") !== "scoped_waivers") {
+        return [];
+    }
+    if (modularity.limit !== undefined &&
+        (typeof modularity.limit !== "number" ||
+            !Number.isInteger(modularity.limit) ||
+            modularity.limit <= 0)) {
+        return [];
+    }
+    const lineLimit = typeof modularity.limit === "number"
+        ? modularity.limit
+        : DEFAULT_MODULARITY_LINE_LIMIT;
+    if (!Array.isArray(modularity.waivers)) {
+        return [];
+    }
+    const targets = modularity.waivers.map((value) => {
+        const waiver = row(value);
+        return safeProjectTarget(projectRoot, waiver?.path);
+    });
+    const targetCounts = new Map();
+    for (const target of targets) {
+        if (target) {
+            const identity = targetIdentity(target.relativePath);
+            targetCounts.set(identity, (targetCounts.get(identity) ?? 0) + 1);
+        }
+    }
+    const candidates = [];
+    for (const [index, value] of modularity.waivers.entries()) {
+        if (!isLifecycleCompleteModularityWaiverConfig(value)) {
+            continue;
+        }
+        const target = targets[index];
+        if (!target ||
+            targetCounts.get(targetIdentity(target.relativePath)) !== 1) {
+            continue;
+        }
+        let content;
+        try {
+            const stat = await fs.stat(target.absolutePath);
+            if (!stat.isFile()) {
+                continue;
+            }
+            content = await fs.readFile(target.absolutePath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (isLikelyGeneratedSourceContent(content)) {
+            continue;
+        }
+        if (hasLegacyHeuristicOnlyWaiverRisk(content, target.relativePath, lineLimit)) {
+            candidates.push({ index, relativePath: target.relativePath });
+        }
+    }
+    return candidates;
+}
+async function readRawConfig(projectRoot) {
+    const relativePath = await harnessConfigPath(projectRoot);
+    const absolutePath = path.join(projectRoot, relativePath);
+    if (!(await pathExists(absolutePath))) {
+        return undefined;
+    }
+    const value = row(parseYaml(await readText(absolutePath)));
+    return value
+        ? { absolutePath, relativePath: toPosix(relativePath), value }
+        : undefined;
+}
+function safeProjectTarget(projectRoot, value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return undefined;
+    }
+    const absolutePath = path.resolve(projectRoot, value);
+    const relativePath = toPosix(path.relative(projectRoot, absolutePath));
+    if (relativePath === ".." ||
+        relativePath.startsWith("../") ||
+        path.isAbsolute(relativePath)) {
+        return undefined;
+    }
+    return { absolutePath, relativePath };
+}
+function row(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function targetIdentity(relativePath) {
+    return process.platform === "win32"
+        ? relativePath.toLowerCase()
+        : relativePath;
+}

package/dist/lib/modularity-python.d.ts

@@ -0,0 +1,7 @@
+export interface PythonFunctionMetric {
+    symbol: string;
+    line: number;
+    statements: number;
+    branches: number;
+}
+export declare function analyzePythonFunctions(content: string): PythonFunctionMetric[];

package/dist/lib/modularity-python.js

@@ -0,0 +1,191 @@
+export function analyzePythonFunctions(content) {
+    const code = sanitizePython(content);
+    return pythonFunctionBodies(code).map((body) => ({
+        symbol: body.symbol,
+        line: body.line,
+        statements: pythonStatementCount(body.body),
+        branches: pythonBranchComplexity(body.body),
+    }));
+}
+function sanitizePython(content) {
+    let result = "";
+    let quote;
+    for (let index = 0; index < content.length; index += 1) {
+        const character = content[index];
+        if (quote) {
+            if (character === "\\") {
+                result += " ";
+                if (index + 1 < content.length) {
+                    index += 1;
+                    result += isLineBreak(content[index]) ? content[index] : " ";
+                }
+                continue;
+            }
+            if (content.startsWith(quote, index)) {
+                result += " ".repeat(quote.length);
+                index += quote.length - 1;
+                quote = undefined;
+                continue;
+            }
+            result += isLineBreak(character) ? character : " ";
+            continue;
+        }
+        if (character === "#") {
+            while (index < content.length && !isLineBreak(content[index])) {
+                result += " ";
+                index += 1;
+            }
+            if (index < content.length) {
+                result += content[index];
+            }
+            continue;
+        }
+        if (content.startsWith("'''", index) || content.startsWith('"""', index)) {
+            quote = content.slice(index, index + 3);
+            result += "   ";
+            index += 2;
+            continue;
+        }
+        if (character === "'" || character === '"') {
+            quote = character;
+            result += " ";
+            continue;
+        }
+        result += character;
+    }
+    return result;
+}
+function pythonFunctionBodies(code) {
+    const lines = code.split(/\r\n|\n|\r/u);
+    const bodies = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const match = /^(\s*)(?:async\s+)?def\s+([A-Za-z_][A-Za-z0-9_]*)\b/u.exec(lines[index]);
+        if (!match) {
+            continue;
+        }
+        const indentation = indentationWidth(match[1]);
+        const header = findHeaderEnd(lines, index);
+        if (!header) {
+            continue;
+        }
+        const bodyLines = [];
+        const inlineBody = lines[header.line].slice(header.colon + 1).trim();
+        if (inlineBody) {
+            bodyLines.push(inlineBody);
+        }
+        for (let cursor = header.line + 1; cursor < lines.length; cursor += 1) {
+            const line = lines[cursor];
+            if (!line.trim()) {
+                bodyLines.push(line);
+                continue;
+            }
+            const leading = /^\s*/u.exec(line)?.[0] ?? "";
+            if (indentationWidth(leading) <= indentation) {
+                break;
+            }
+            bodyLines.push(line);
+        }
+        bodies.push({
+            symbol: match[2],
+            line: index + 1,
+            body: bodyLines.join("\n"),
+        });
+    }
+    return bodies;
+}
+function findHeaderEnd(lines, start) {
+    let delimiterDepth = 0;
+    for (let line = start; line < lines.length; line += 1) {
+        for (let column = 0; column < lines[line].length; column += 1) {
+            const character = lines[line][column];
+            if (character === "(" || character === "[" || character === "{") {
+                delimiterDepth += 1;
+            }
+            else if (character === ")" || character === "]" || character === "}") {
+                delimiterDepth = Math.max(0, delimiterDepth - 1);
+            }
+            else if (character === ":" && delimiterDepth === 0) {
+                return { line, colon: column };
+            }
+        }
+    }
+    return undefined;
+}
+function pythonStatementCount(body) {
+    let statements = 0;
+    let delimiterDepth = 0;
+    let explicitContinuation = false;
+    for (const line of body.split(/\r\n|\n|\r/u)) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const startsLogicalStatement = delimiterDepth === 0 && !explicitContinuation;
+        if (startsLogicalStatement) {
+            statements += 1 + topLevelSemicolonCount(line);
+            if (hasInlineSuite(line)) {
+                statements += 1;
+            }
+        }
+        delimiterDepth = delimiterDepthAfter(line, delimiterDepth);
+        explicitContinuation = delimiterDepth === 0 && /\\\s*$/u.test(line);
+    }
+    return statements;
+}
+function pythonBranchComplexity(body) {
+    const branches = body.match(/\b(?:if|elif|for|while|except|case|and|or)\b/gu)?.length ?? 0;
+    return 1 + branches;
+}
+function topLevelSemicolonCount(line) {
+    let count = 0;
+    let depth = 0;
+    for (const character of line) {
+        if (character === "(" || character === "[" || character === "{") {
+            depth += 1;
+        }
+        else if (character === ")" || character === "]" || character === "}") {
+            depth = Math.max(0, depth - 1);
+        }
+        else if (character === ";" && depth === 0) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function hasInlineSuite(line) {
+    if (!/^\s*(?:async\s+)?(?:if|elif|else|for|while|try|except|finally|with|match|case)\b/u.test(line)) {
+        return false;
+    }
+    let depth = 0;
+    for (let index = 0; index < line.length; index += 1) {
+        const character = line[index];
+        if (character === "(" || character === "[" || character === "{") {
+            depth += 1;
+        }
+        else if (character === ")" || character === "]" || character === "}") {
+            depth = Math.max(0, depth - 1);
+        }
+        else if (character === ":" && depth === 0) {
+            return line.slice(index + 1).trim().length > 0;
+        }
+    }
+    return false;
+}
+function delimiterDepthAfter(line, initialDepth) {
+    let depth = initialDepth;
+    for (const character of line) {
+        if (character === "(" || character === "[" || character === "{") {
+            depth += 1;
+        }
+        else if (character === ")" || character === "]" || character === "}") {
+            depth = Math.max(0, depth - 1);
+        }
+    }
+    return depth;
+}
+function indentationWidth(value) {
+    return [...value].reduce((width, character) => width + (character === "\t" ? 4 : 1), 0);
+}
+function isLineBreak(character) {
+    return character === "\n" || character === "\r";
+}

package/dist/lib/modularity.d.ts

@@ -1,3 +1,6 @@
+import { type ModularityAnalysisCapability } from "./source-files.js";
+import type { ModularityWaiverConfig } from "./types.js";
+export declare const DEFAULT_MODULARITY_LINE_LIMIT = 300;
 export interface ModularityCheckOptions {
     touched?: boolean;
     base?: string;
@@ -24,13 +27,14 @@ export interface ModularityMetricLocation {
     line: number;
 }
 export interface ModularityMetrics {
-    maxFunctionStatements: number;
+    analysis: ModularityAnalysisCapability;
+    maxFunctionStatements: number | null;
     maxFunctionStatementsLocation?: ModularityMetricLocation;
-    maxBranchComplexity: number;
+    maxBranchComplexity: number | null;
     maxBranchComplexityLocation?: ModularityMetricLocation;
-    exports: number;
-    stateTransitions: number;
-    responsibilities: string[];
+    exports: number | null;
+    stateTransitions: number | null;
+    responsibilities: string[] | null;
 }
 export interface ModularityCheckReport {
     limit: number;
@@ -48,6 +52,9 @@ export interface ModularityWaiver {
     trackingIssue: string;
     expiryCondition: string;
 }
+export declare function isLifecycleCompleteModularityWaiverConfig(value: unknown): value is ModularityWaiverConfig;
 export declare function runModularityCheck(projectRoot: string, options: ModularityCheckOptions): Promise<ModularityCheckReport>;
 export declare function analyzeModularity(content: string, relativePath?: string): ModularityMetrics;
+export declare function hasLegacyHeuristicOnlyWaiverRisk(content: string, relativePath: string, lineLimit: number): boolean;
 export declare function countPhysicalLines(content: string): number;
+export declare function isLikelyGeneratedSourceContent(content: string): boolean;

package/dist/lib/modularity.js

@@ -3,10 +3,11 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { promisify } from "node:util";
 import { readConfig } from "./config.js";
-import { shouldIncludeCodeFile, toPosix } from "./source-files.js";
+import { analyzePythonFunctions } from "./modularity-python.js";
+import { modularityAnalysisCapability, shouldIncludeCodeFile, toPosix, } from "./source-files.js";
 const execFileAsync = promisify(execFile);
 const GIT_MAX_BUFFER = 16 * 1024 * 1024;
-const DEFAULT_LINE_LIMIT = 300;
+export const DEFAULT_MODULARITY_LINE_LIMIT = 300;
 const DEFAULT_MODULARITY_POLICY = "scoped_waivers";
 const MODULARITY_POLICIES = new Set([
     DEFAULT_MODULARITY_POLICY,
@@ -34,11 +35,32 @@ const WAIVER_CATEGORIES = new Set([
     "aggregate_styles",
     "fixture_snapshot",
 ]);
+const MODULARITY_WAIVER_REQUIRED_FIELDS = [
+    "path",
+    "category",
+    "owner",
+    "introduced_at",
+    "reason",
+    "tracking_issue",
+    "expiry_condition",
+];
+export function isLifecycleCompleteModularityWaiverConfig(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const waiver = value;
+    if (MODULARITY_WAIVER_REQUIRED_FIELDS.some((field) => typeof waiver[field] !== "string" || waiver[field].trim().length === 0)) {
+        return false;
+    }
+    return (WAIVER_CATEGORIES.has(waiver.category.trim()) &&
+        /^\d{4}-\d{2}-\d{2}$/u.test(waiver.introduced_at.trim()) &&
+        !Number.isNaN(Date.parse(`${waiver.introduced_at.trim()}T00:00:00Z`)));
+}
 export async function runModularityCheck(projectRoot, options) {
     const config = await readConfig(projectRoot);
     const { limit: configuredLimit, waiverValues, errors: configErrors, } = validateModularityConfig(config.modularity);
     const { waivers, errors: waiverErrors } = validateWaivers(projectRoot, waiverValues);
-    const limit = options.limit ?? configuredLimit ?? DEFAULT_LINE_LIMIT;
+    const limit = options.limit ?? configuredLimit ?? DEFAULT_MODULARITY_LINE_LIMIT;
     const waiverTargetErrors = await validateWaiverTargets(projectRoot, waivers, limit);
     const candidates = new Set();
     const baselineRef = options.base ?? (options.touched ? "HEAD" : undefined);
@@ -144,21 +166,71 @@ function modularityRegressions(current, baseline) {
             message: `${current.metrics.stateTransitions} state transitions exceeds limit ${COMPLEXITY_LIMITS.stateTransitions}`,
         },
         {
-            current: current.metrics.responsibilities.length,
-            baseline: baseline.metrics.responsibilities.length,
+            current: current.metrics.responsibilities?.length ?? null,
+            baseline: baseline.metrics.responsibilities?.length ?? null,
             limit: COMPLEXITY_LIMITS.responsibilities,
-            message: `${current.metrics.responsibilities.length} module responsibilities exceeds limit ${COMPLEXITY_LIMITS.responsibilities}`,
+            message: `${current.metrics.responsibilities?.length ?? 0} module responsibilities exceeds limit ${COMPLEXITY_LIMITS.responsibilities}`,
         },
     ];
     return checks
-        .filter((check) => check.current > check.limit && check.current > check.baseline)
+        .filter((check) => check.current !== null &&
+        check.baseline !== null &&
+        check.current > check.limit &&
+        check.current > check.baseline)
         .map((check) => check.message);
 }
 export function analyzeModularity(content, relativePath = "") {
+    const analysis = (relativePath
+        ? modularityAnalysisCapability(relativePath)
+        : "js-ts-heuristic") ?? "line-only";
+    if (analysis === "line-only") {
+        return unavailableMetrics(analysis);
+    }
+    if (analysis === "python-heuristic") {
+        const bodies = analyzePythonFunctions(content);
+        const statementPeak = maxMetricBody(bodies, "statements");
+        const branchPeak = maxMetricBody(bodies, "branches");
+        return {
+            analysis,
+            maxFunctionStatements: statementPeak?.statements ?? 0,
+            ...(statementPeak
+                ? {
+                    maxFunctionStatementsLocation: {
+                        symbol: statementPeak.symbol,
+                        line: statementPeak.line,
+                    },
+                }
+                : {}),
+            maxBranchComplexity: branchPeak?.branches ?? 0,
+            ...(branchPeak
+                ? {
+                    maxBranchComplexityLocation: {
+                        symbol: branchPeak.symbol,
+                        line: branchPeak.line,
+                    },
+                }
+                : {}),
+            exports: null,
+            stateTransitions: null,
+            responsibilities: null,
+        };
+    }
+    return analyzeJsTsModularity(content);
+}
+export function hasLegacyHeuristicOnlyWaiverRisk(content, relativePath, lineLimit) {
+    if (modularityAnalysisCapability(relativePath) !== "line-only") {
+        return false;
+    }
+    const lines = countPhysicalLines(content);
+    if (modularityRisks(lines, lineLimit, analyzeModularity(content, relativePath))
+        .length > 0) {
+        return false;
+    }
+    return (modularityRisks(lines, lineLimit, analyzeJsTsModularity(content)).length > 0);
+}
+function analyzeJsTsModularity(content) {
     const code = sanitizeCode(content);
-    const bodies = relativePath.toLowerCase().endsWith(".py")
-        ? pythonFunctionBodies(code)
-        : functionBodies(code);
+    const bodies = functionBodies(code);
     const analyzedBodies = bodies.map((body) => ({
         ...body,
         statements: statementCount(body.body),
@@ -167,6 +239,7 @@ export function analyzeModularity(content, relativePath = "") {
     const statementPeak = maxMetricBody(analyzedBodies, "statements");
     const branchPeak = maxMetricBody(analyzedBodies, "branches");
     return {
+        analysis: "js-ts-heuristic",
         maxFunctionStatements: statementPeak?.statements ?? 0,
         ...(statementPeak
             ? {
@@ -190,23 +263,37 @@ export function analyzeModularity(content, relativePath = "") {
         responsibilities: inferResponsibilities(code),
     };
 }
+function unavailableMetrics(analysis) {
+    return {
+        analysis,
+        maxFunctionStatements: null,
+        maxBranchComplexity: null,
+        exports: null,
+        stateTransitions: null,
+        responsibilities: null,
+    };
+}
 function modularityRisks(lines, lineLimit, metrics) {
     const risks = [];
     if (lines > lineLimit)
         risks.push(`${lines} physical lines exceeds limit ${lineLimit}`);
-    if (metrics.maxFunctionStatements > COMPLEXITY_LIMITS.functionStatements) {
+    if (metrics.maxFunctionStatements !== null &&
+        metrics.maxFunctionStatements > COMPLEXITY_LIMITS.functionStatements) {
         risks.push(`${metrics.maxFunctionStatements} statements in one function exceeds limit ${COMPLEXITY_LIMITS.functionStatements}${formatMetricLocation(metrics.maxFunctionStatementsLocation)}`);
     }
-    if (metrics.maxBranchComplexity > COMPLEXITY_LIMITS.branchComplexity) {
+    if (metrics.maxBranchComplexity !== null &&
+        metrics.maxBranchComplexity > COMPLEXITY_LIMITS.branchComplexity) {
         risks.push(`${metrics.maxBranchComplexity} branch complexity exceeds limit ${COMPLEXITY_LIMITS.branchComplexity}${formatMetricLocation(metrics.maxBranchComplexityLocation)}`);
     }
-    if (metrics.exports > COMPLEXITY_LIMITS.exports) {
+    if (metrics.exports !== null && metrics.exports > COMPLEXITY_LIMITS.exports) {
         risks.push(`${metrics.exports} exports exceeds limit ${COMPLEXITY_LIMITS.exports}`);
     }
-    if (metrics.stateTransitions > COMPLEXITY_LIMITS.stateTransitions) {
+    if (metrics.stateTransitions !== null &&
+        metrics.stateTransitions > COMPLEXITY_LIMITS.stateTransitions) {
         risks.push(`${metrics.stateTransitions} state transitions exceeds limit ${COMPLEXITY_LIMITS.stateTransitions}`);
     }
-    if (metrics.responsibilities.length > COMPLEXITY_LIMITS.responsibilities) {
+    if (metrics.responsibilities !== null &&
+        metrics.responsibilities.length > COMPLEXITY_LIMITS.responsibilities) {
         risks.push(`${metrics.responsibilities.length} module responsibilities exceeds limit ${COMPLEXITY_LIMITS.responsibilities}`);
     }
     return risks;
@@ -372,30 +459,6 @@ function functionBodies(code) {
     })
         .filter((body) => body !== undefined);
 }
-function pythonFunctionBodies(code) {
-    const lines = code.split(/\r\n|\n|\r/u);
-    const bodies = [];
-    for (let index = 0; index < lines.length; index += 1) {
-        const match = /^(\s*)(?:async\s+)?def\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/u.exec(lines[index]);
-        if (!match)
-            continue;
-        const indentation = indentationWidth(match[1]);
-        const body = [];
-        for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
-            const line = lines[cursor];
-            if (!line.trim()) {
-                body.push(line);
-                continue;
-            }
-            const leading = /^\s*/u.exec(line)?.[0] ?? "";
-            if (indentationWidth(leading) <= indentation)
-                break;
-            body.push(line);
-        }
-        bodies.push({ body: body.join("\n"), symbol: match[2], line: index + 1 });
-    }
-    return bodies;
-}
 function inferArrowSymbol(code, arrowIndex) {
     const prefix = code.slice(Math.max(0, arrowIndex - 240), arrowIndex);
     const assignment = /(?:\b(?:const|let|var)\s+|\b)([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*$/u.exec(prefix);
@@ -420,9 +483,6 @@ function formatMetricLocation(location) {
         ? ` in function ${location.symbol} at line ${location.line}`
         : "";
 }
-function indentationWidth(value) {
-    return [...value].reduce((width, character) => width + (character === "\t" ? 4 : 1), 0);
-}
 function balancedBody(code, openingBrace) {
     let depth = 0;
     for (let index = openingBrace; index < code.length; index += 1) {
@@ -685,9 +745,12 @@ async function validateWaiverTargets(projectRoot, waivers, limit) {
             errors.push(`${label} is unnecessary because generated files are excluded`);
             continue;
         }
-        const analyzed = analyzeFile(await fs.readFile(target, "utf8"), limit, waiver.relativePath);
+        const content = await fs.readFile(target, "utf8");
+        const analyzed = analyzeFile(content, limit, waiver.relativePath);
         if (analyzed.risks.length === 0) {
-            errors.push(`${label} is unnecessary because the source does not currently exceed a modularity threshold`);
+            errors.push(hasLegacyHeuristicOnlyWaiverRisk(content, waiver.relativePath, limit)
+                ? `${label} is obsolete because this target now has line-only analysis and exceeded only unsupported legacy heuristic metrics; run ty-context upgrade to remove the waiver`
+                : `${label} is unnecessary because the source does not currently exceed a modularity threshold`);
         }
     }
     return errors;
@@ -710,6 +773,9 @@ async function isRegularFile(target) {
 }
 async function isLikelyGeneratedFile(target) {
     const content = await fs.readFile(target, "utf8");
+    return isLikelyGeneratedSourceContent(content);
+}
+export function isLikelyGeneratedSourceContent(content) {
     const sample = content.slice(0, 8192);
     return GENERATED_FILE_PATTERNS.some((pattern) => pattern.test(sample));
 }

package/dist/lib/source-files.d.ts

@@ -1,4 +1,6 @@
 export declare const SAFE_EXAMPLE_FILE_NAMES: Set<string>;
+export type ModularityAnalysisCapability = "js-ts-heuristic" | "python-heuristic" | "line-only";
 export declare function shouldIncludeCodeFile(relative: string): boolean;
+export declare function modularityAnalysisCapability(relative: string): ModularityAnalysisCapability | undefined;
 export declare function shouldExcludeRelativePath(relative: string): boolean;
 export declare function toPosix(value: string): string;

package/dist/lib/source-files.js

@@ -90,6 +90,14 @@ const CONFIG_JSON_NAMES = new Set([
     "tsconfig.json",
     "vite.config.json",
 ]);
+const JS_TS_HEURISTIC_EXTENSIONS = new Set([
+    ".cjs",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".ts",
+    ".tsx",
+]);
 export function shouldIncludeCodeFile(relative) {
     if (shouldExcludeRelativePath(relative)) {
         return false;
@@ -108,6 +116,19 @@ export function shouldIncludeCodeFile(relative) {
     }
     return CODE_FILE_EXTENSIONS.some((extension) => lower.endsWith(extension));
 }
+export function modularityAnalysisCapability(relative) {
+    if (!shouldIncludeCodeFile(relative)) {
+        return undefined;
+    }
+    const extension = path.posix.extname(toPosix(relative).toLowerCase());
+    if (JS_TS_HEURISTIC_EXTENSIONS.has(extension)) {
+        return "js-ts-heuristic";
+    }
+    if (extension === ".py") {
+        return "python-heuristic";
+    }
+    return "line-only";
+}
 export function shouldExcludeRelativePath(relative) {
     const normalized = toPosix(relative);
     const segments = normalized.split("/");