project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-workspace-snapshot.d.ts

@@ -1,8 +0,0 @@
-import type { WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export interface WorkspaceSnapshotV2 {
-    root: string;
-    manifest: WorkspaceManifestV2;
-    preparation_ms: number;
-    dispose(): Promise<void>;
-}
-export declare function createWorkspaceSnapshot(rootInput: string, workdirInput: string, label: string, additionalExcludedWorkdirs?: string[]): Promise<WorkspaceSnapshotV2>;

package/dist/lib/long-task-workspace-snapshot.js

@@ -1,176 +0,0 @@
-import { copyFile, mkdir, mkdtemp, readdir, rm, stat, symlink, } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { GitCommandError, gitBuffer, gitEffectiveConfigGet, gitVoid, repoRelative, splitGitZero, } from "./long-task-git.js";
-import { captureWorkspaceFingerprint, captureWorkspaceManifest, workspaceFingerprintExcludedPrefixes, workspacePathExcluded, workspaceSnapshotExcludedPrefixes, } from "./long-task-workspace-manifest.js";
-const MAX_CHECKOUT_INDEX_ATTEMPTS = 2;
-export async function createWorkspaceSnapshot(rootInput, workdirInput, label, additionalExcludedWorkdirs = []) {
-    const started = performance.now();
-    const root = path.resolve(rootInput);
-    const workdir = path.resolve(workdirInput);
-    const fingerprintExcluded = workspaceFingerprintExcludedPrefixes(root, [
-        workdir,
-        ...additionalExcludedWorkdirs,
-    ]);
-    const snapshotExcluded = workspaceSnapshotExcludedPrefixes(root, [
-        workdir,
-        ...additionalExcludedWorkdirs,
-    ]);
-    const manifest = await captureWorkspaceManifest(root, workdir, undefined, additionalExcludedWorkdirs);
-    const before = manifest.fingerprint;
-    const temporary = await checkoutIndexIntoFreshRoot(root, label, before.identity, fingerprintExcluded);
-    try {
-        await overlayTrackedEolDifferences(root, temporary);
-        const [modified, untracked] = await Promise.all([
-            gitBuffer(root, ["diff", "--name-only", "-z"]),
-            gitBuffer(root, ["ls-files", "--others", "--exclude-standard", "-z"]),
-        ]);
-        for (const raw of new Set([
-            ...splitGitZero(modified),
-            ...splitGitZero(untracked),
-        ])) {
-            const relative = raw.replace(/\\/gu, "/");
-            if (workspacePathExcluded(relative, snapshotExcluded))
-                continue;
-            const source = path.join(root, ...relative.split("/"));
-            const target = path.join(temporary, ...relative.split("/"));
-            const info = await stat(source).catch(() => null);
-            if (!info?.isFile()) {
-                await rm(target, { recursive: true, force: true });
-                continue;
-            }
-            await mkdir(path.dirname(target), { recursive: true });
-            await copyFile(source, target);
-        }
-        await removeExcludedSnapshotPaths(temporary, snapshotExcluded);
-        await linkDependencyTrees(root, temporary, [
-            workdir,
-            ...additionalExcludedWorkdirs,
-        ]);
-        const after = await captureWorkspaceFingerprint(root, fingerprintExcluded);
-        if (after.identity !== before.identity)
-            throw new Error("workspace_changed_during_snapshot");
-        return {
-            root: temporary,
-            manifest,
-            preparation_ms: performance.now() - started,
-            dispose: () => rm(temporary, { recursive: true, force: true }),
-        };
-    }
-    catch (error) {
-        await rm(temporary, { recursive: true, force: true });
-        throw error;
-    }
-}
-async function checkoutIndexIntoFreshRoot(root, label, expectedFingerprint, fingerprintExcluded) {
-    for (let attempt = 1; attempt <= MAX_CHECKOUT_INDEX_ATTEMPTS; attempt += 1) {
-        const temporary = await mkdtemp(path.join(os.tmpdir(), `ty-context-${safe(label)}-`));
-        try {
-            await gitVoid(root, [
-                "checkout-index",
-                "--all",
-                "--force",
-                "--ignore-skip-worktree-bits",
-                `--prefix=${temporary.replace(/\\/gu, "/")}/`,
-            ]);
-            return temporary;
-        }
-        catch (error) {
-            await rm(temporary, { recursive: true, force: true });
-            if (!retryableUnclassifiedCheckout(error) ||
-                attempt === MAX_CHECKOUT_INDEX_ATTEMPTS)
-                throw error;
-            const current = await captureWorkspaceFingerprint(root, fingerprintExcluded);
-            if (current.identity !== expectedFingerprint)
-                throw new Error("workspace_changed_during_snapshot");
-        }
-    }
-    throw new Error("workspace_snapshot_checkout_attempts_exhausted");
-}
-function retryableUnclassifiedCheckout(error) {
-    return (error instanceof GitCommandError &&
-        error.exitCode === 1 &&
-        error.signal === null &&
-        error.stdoutBytes === 0 &&
-        error.stderrBytes === 0);
-}
-async function removeExcludedSnapshotPaths(snapshotRoot, excluded) {
-    for (const relative of excluded)
-        await rm(path.join(snapshotRoot, ...relative.split("/")), {
-            recursive: true,
-            force: true,
-        });
-    async function visit(directory) {
-        for (const entry of await readdir(directory, { withFileTypes: true })) {
-            const target = path.join(directory, entry.name);
-            if (entry.isDirectory() && entry.name === "node_modules") {
-                await rm(target, { recursive: true, force: true });
-            }
-            else if (entry.isDirectory())
-                await visit(target);
-        }
-    }
-    await visit(snapshotRoot);
-}
-async function overlayTrackedEolDifferences(sourceRoot, snapshotRoot) {
-    const [raw, autocrlf] = await Promise.all([
-        gitBuffer(sourceRoot, ["ls-files", "--eol", "-z"]),
-        gitEffectiveConfigGet(sourceRoot, "core.autocrlf"),
-    ]);
-    for (const record of splitGitZero(raw)) {
-        const tab = record.indexOf("\t");
-        if (tab < 0)
-            continue;
-        const metadata = record.slice(0, tab);
-        const relative = record.slice(tab + 1).replace(/\\/gu, "/");
-        const match = metadata.match(/^i\/(\S+)\s+w\/(\S+)\s+attr\/(.*)$/u);
-        if (!match)
-            continue;
-        const [, indexEol, worktreeEol, attributesRaw] = match;
-        const expected = checkoutEol(indexEol, attributesRaw.trim(), autocrlf);
-        if (worktreeEol === expected)
-            continue;
-        const source = path.join(sourceRoot, ...relative.split("/"));
-        const target = path.join(snapshotRoot, ...relative.split("/"));
-        const info = await stat(source).catch(() => null);
-        if (!info?.isFile())
-            continue;
-        await mkdir(path.dirname(target), { recursive: true });
-        await copyFile(source, target);
-    }
-}
-function checkoutEol(indexEol, attributes, autocrlf) {
-    const explicit = attributes.match(/(?:^|\s)eol=(lf|crlf)(?:\s|$)/u)?.[1];
-    if (explicit)
-        return explicit;
-    if (/(?:^|\s)-text(?:\s|$)/u.test(attributes))
-        return indexEol;
-    if (indexEol === "-text" || indexEol === "none")
-        return indexEol;
-    return autocrlf?.toLowerCase() === "true" ? "crlf" : indexEol;
-}
-async function linkDependencyTrees(sourceRoot, snapshotRoot, workdirs) {
-    const protectedWorkdirs = workdirs.map((workdir) => repoRelative(sourceRoot, workdir));
-    async function visit(directory, relative = "") {
-        for (const entry of await readdir(directory, { withFileTypes: true })) {
-            const next = relative ? `${relative}/${entry.name}` : entry.name;
-            if (protectedWorkdirs.some((protectedWorkdir) => next === protectedWorkdir ||
-                next.startsWith(`${protectedWorkdir}/`)) ||
-                entry.name === ".git")
-                continue;
-            const source = path.join(directory, entry.name);
-            if (entry.isDirectory() && entry.name === "node_modules") {
-                const target = path.join(snapshotRoot, ...next.split("/"));
-                await mkdir(path.dirname(target), { recursive: true });
-                await rm(target, { recursive: true, force: true });
-                await symlink(source, target, process.platform === "win32" ? "junction" : "dir");
-            }
-            else if (entry.isDirectory())
-                await visit(source, next);
-        }
-    }
-    await visit(sourceRoot);
-}
-function safe(value) {
-    return value.replace(/[^A-Za-z0-9._-]/gu, "-").slice(0, 80);
-}

package/dist/lib/long-task-workspace.d.ts

@@ -1,6 +0,0 @@
-export { resolveInsideRepository } from "./repository-path-safety.js";
-export { currentGitState, currentGitTree, gitCommonDir, gitConfigGet, gitConfigSet, gitConfigUnset, gitPath, repoRelative, repositoryRoot, } from "./long-task-git.js";
-export { captureWorkspaceFingerprint, captureWorkspaceManifest, changedWorkspacePaths, changedWorkspacePathsFromHead, } from "./long-task-workspace-manifest.js";
-export { createWorkspaceSnapshot } from "./long-task-workspace-snapshot.js";
-export type { WorkspaceSnapshotV2 } from "./long-task-workspace-snapshot.js";
-export declare function canonicalExistingLongTaskWorkdir(repository: string, workdirInput: string): Promise<string>;

package/dist/lib/long-task-workspace.js

@@ -1,14 +0,0 @@
-import { realpath } from "node:fs/promises";
-import path from "node:path";
-import { assertProtectedRepositoryDirectory as assertProtectedDirectory } from "./repository-path-safety.js";
-export { resolveInsideRepository } from "./repository-path-safety.js";
-export { currentGitState, currentGitTree, gitCommonDir, gitConfigGet, gitConfigSet, gitConfigUnset, gitPath, repoRelative, repositoryRoot, } from "./long-task-git.js";
-export { captureWorkspaceFingerprint, captureWorkspaceManifest, changedWorkspacePaths, changedWorkspacePathsFromHead, } from "./long-task-workspace-manifest.js";
-export { createWorkspaceSnapshot } from "./long-task-workspace-snapshot.js";
-export async function canonicalExistingLongTaskWorkdir(repository, workdirInput) {
-    const [canonicalRepository, physical] = await Promise.all([
-        realpath(path.resolve(repository)),
-        realpath(path.resolve(workdirInput)),
-    ]);
-    return assertProtectedDirectory(canonicalRepository, physical, "long_task_workdir");
-}

package/dist/lib/modularity-capability-migration.d.ts

@@ -1,2 +0,0 @@
-import type { Migration } from "./migrations.js";
-export declare const modularityCapabilityWaiverMigration: Migration;

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

@@ -1,165 +0,0 @@
-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

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

package/dist/lib/modularity-python.js

@@ -1,191 +0,0 @@
-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,60 +0,0 @@
-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;
-    files?: string[];
-    limit?: number;
-}
-export interface ModularityFileReport {
-    relativePath: string;
-    lines: number;
-    metrics: ModularityMetrics;
-    risks: string[];
-    regressions: string[];
-    overLimit: boolean;
-    regressed: boolean;
-    baseline?: {
-        lines: number;
-        metrics: ModularityMetrics;
-        risks: string[];
-    };
-    waived?: ModularityWaiver;
-}
-export interface ModularityMetricLocation {
-    symbol: string;
-    line: number;
-}
-export interface ModularityMetrics {
-    analysis: ModularityAnalysisCapability;
-    maxFunctionStatements: number | null;
-    maxFunctionStatementsLocation?: ModularityMetricLocation;
-    maxBranchComplexity: number | null;
-    maxBranchComplexityLocation?: ModularityMetricLocation;
-    exports: number | null;
-    stateTransitions: number | null;
-    responsibilities: string[] | null;
-}
-export interface ModularityCheckReport {
-    limit: number;
-    files: ModularityFileReport[];
-    warnings: string[];
-    waivedWarnings: string[];
-    errors: string[];
-}
-export interface ModularityWaiver {
-    relativePath: string;
-    category: string;
-    owner: string;
-    introducedAt: string;
-    reason: string;
-    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;