@getripple/core 1.0.4

package/dist/staged-check.js

@@ -0,0 +1,853 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.highestStagedRisk = exports.buildStagedCheckSummary = exports.listGitChangedDiff = exports.listGitChangedFiles = exports.listGitStagedDiff = exports.listGitStagedFiles = exports.isRippleSourceFile = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ts_morph_1 = require("ts-morph");
+const SOURCE_FILE_RE = /\.(ts|tsx|js|jsx|py)$/i;
+const DEFAULT_STAGED_CHECK_TASK = "Review staged change before commit";
+const RISK_RANK = {
+    safe: 1,
+    caution: 2,
+    dangerous: 3,
+};
+const TEST_FILE_RE = /(^|[\\/])(__tests__|tests?|specs?)([\\/])|(\.test|\.spec)\.(ts|tsx|js|jsx|py)$/i;
+function isRippleSourceFile(filePath) {
+    return SOURCE_FILE_RE.test(filePath) && !filePath.endsWith(".d.ts");
+}
+exports.isRippleSourceFile = isRippleSourceFile;
+function listGitStagedFiles(workspaceRoot) {
+    try {
+        const output = (0, child_process_1.execFileSync)("git", ["diff", "--name-only", "--cached", "--diff-filter=ACMR"], {
+            cwd: workspaceRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return output
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Could not read staged files with git diff --cached: ${message}`);
+    }
+}
+exports.listGitStagedFiles = listGitStagedFiles;
+function listGitStagedDiff(workspaceRoot) {
+    try {
+        return (0, child_process_1.execFileSync)("git", ["diff", "--cached", "--unified=0", "--no-ext-diff"], {
+            cwd: workspaceRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Could not read staged diff with git diff --cached: ${message}`);
+    }
+}
+exports.listGitStagedDiff = listGitStagedDiff;
+function listGitChangedFiles(workspaceRoot, baseRef) {
+    try {
+        const output = (0, child_process_1.execFileSync)("git", ["diff", "--name-only", "--diff-filter=ACMR", baseRef, "--"], {
+            cwd: workspaceRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return output
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .concat(listGitUntrackedSourceFiles(workspaceRoot))
+            .filter(uniqueString);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Could not read changed files with git diff ${baseRef}: ${message}`);
+    }
+}
+exports.listGitChangedFiles = listGitChangedFiles;
+function listGitUntrackedSourceFiles(workspaceRoot) {
+    try {
+        const output = (0, child_process_1.execFileSync)("git", ["ls-files", "--others", "--exclude-standard"], {
+            cwd: workspaceRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return output
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && isRippleSourceFile(line));
+    }
+    catch {
+        return [];
+    }
+}
+function uniqueString(value, index, values) {
+    return values.indexOf(value) === index;
+}
+function listGitChangedDiff(workspaceRoot, baseRef) {
+    try {
+        return (0, child_process_1.execFileSync)("git", ["diff", "--unified=0", "--no-ext-diff", baseRef, "--"], {
+            cwd: workspaceRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Could not read changed diff with git diff ${baseRef}: ${message}`);
+    }
+}
+exports.listGitChangedDiff = listGitChangedDiff;
+function adapterSignalFor(adapterSupport, capability) {
+    const profile = adapterSupport.primaryAdapter.capabilityProfile.find((item) => item.capability === capability);
+    if (!profile) {
+        return null;
+    }
+    return {
+        capability,
+        confidence: profile.confidence,
+        agentUse: profile.agentUse,
+        reason: profile.reason,
+    };
+}
+function uniqueAdapterSignals(signals) {
+    const byCapability = new Map();
+    signals.forEach((signal) => {
+        if (!signal) {
+            return;
+        }
+        const existing = byCapability.get(signal.capability);
+        if (!existing || signal.confidence > existing.confidence) {
+            byCapability.set(signal.capability, signal);
+        }
+    });
+    return Array.from(byCapability.values()).sort((a, b) => a.capability.localeCompare(b.capability));
+}
+function adapterSignalsForChangedSymbol(adapterSupport, symbol) {
+    return uniqueAdapterSignals([
+        adapterSignalFor(adapterSupport, "symbols"),
+        symbol.callers > 0 || symbol.calls > 0
+            ? adapterSignalFor(adapterSupport, "call-edges")
+            : null,
+    ]);
+}
+function adapterSignalsForContractRisk(adapterSupport, symbol, verificationTargets) {
+    return uniqueAdapterSignals([
+        ...symbol.adapterSignals,
+        verificationTargets.some((target) => TEST_FILE_RE.test(target))
+            ? adapterSignalFor(adapterSupport, "tests")
+            : null,
+    ]);
+}
+function adapterSignalsFromPlan(plan) {
+    if (!plan) {
+        return [];
+    }
+    return uniqueAdapterSignals([
+        ...plan.readFirst.flatMap((file) => file.adapterSignals ?? []),
+        ...plan.readIfNeeded.flatMap((file) => file.adapterSignals ?? []),
+    ]);
+}
+function adapterSignalLabel(signal) {
+    return `${signal.capability} ${signal.agentUse}/${Math.round(signal.confidence * 100)}%`;
+}
+function findAdapterSignal(signals, capability) {
+    return signals.find((signal) => signal.capability === capability);
+}
+function uniqueItems(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        if (seen.has(item)) {
+            return false;
+        }
+        seen.add(item);
+        return true;
+    });
+}
+function buildStagedCheckAgentActions(files, missingFiles, adapterSupport) {
+    const trustedFindings = [];
+    const verifyBeforeCommit = [];
+    const manualReviewRequired = [];
+    files.forEach((file) => {
+        const fileSignal = findAdapterSignal(file.adapterSignals, "files");
+        const dependencySignal = findAdapterSignal(file.adapterSignals, "dependencies") ??
+            findAdapterSignal(file.adapterSignals, "reverse-dependencies");
+        if (fileSignal?.agentUse === "trust") {
+            trustedFindings.push(`${file.file}: changed source file detection is trusted (${adapterSignalLabel(fileSignal)}).`);
+        }
+        if (dependencySignal?.agentUse === "trust") {
+            trustedFindings.push(`${file.file}: import/read-first neighborhood is trusted (${adapterSignalLabel(dependencySignal)}).`);
+        }
+        file.changedSymbols.forEach((symbol) => {
+            const symbolSignal = findAdapterSignal(symbol.adapterSignals, "symbols");
+            const callSignal = findAdapterSignal(symbol.adapterSignals, "call-edges");
+            if (symbolSignal?.agentUse === "trust") {
+                trustedFindings.push(`${symbol.symbol}: symbol/export detection is trusted (${adapterSignalLabel(symbolSignal)}).`);
+            }
+            if (callSignal?.agentUse === "verify") {
+                verifyBeforeCommit.push(`${symbol.symbol}: verify callers manually because call edges are partial (${adapterSignalLabel(callSignal)}).`);
+            }
+        });
+        file.verificationTargets.forEach((target) => {
+            const testSignal = TEST_FILE_RE.test(target)
+                ? findAdapterSignal(file.adapterSignals, "tests")
+                : undefined;
+            if (testSignal?.agentUse === "verify") {
+                verifyBeforeCommit.push(`${target}: run or inspect this verification target; test mapping is verify-only (${adapterSignalLabel(testSignal)}).`);
+            }
+            else {
+                verifyBeforeCommit.push(`${target}: verify this target before commit.`);
+            }
+        });
+        file.contractRisks.forEach((risk) => {
+            manualReviewRequired.push(`${risk.symbol}: ${risk.risk} contract risk; review public contract and callers before commit.`);
+        });
+    });
+    missingFiles.forEach((file) => {
+        manualReviewRequired.push(`${file}: missing from graph; inspect manually before commit.`);
+    });
+    adapterSupport.primaryAdapter.capabilityProfile
+        .filter((capability) => capability.agentUse === "manual")
+        .forEach((capability) => {
+        manualReviewRequired.push(`${capability.capability}: adapter cannot provide this signal; inspect manually.`);
+    });
+    return {
+        trustedFindings: uniqueItems(trustedFindings).slice(0, 24),
+        verifyBeforeCommit: uniqueItems(verifyBeforeCommit).slice(0, 24),
+        manualReviewRequired: uniqueItems(manualReviewRequired).slice(0, 24),
+    };
+}
+function buildStagedCheckSummary(engine, options) {
+    const mode = options.mode ?? "staged";
+    const baseRef = mode === "changed" ? options.baseRef ?? "HEAD" : undefined;
+    const sourceFiles = options.stagedFiles.filter(isRippleSourceFile);
+    const skippedFiles = options.stagedFiles.filter((file) => !isRippleSourceFile(file));
+    const stagedDiff = parseStagedDiff(options.stagedDiff ??
+        (mode === "changed"
+            ? listGitChangedDiff(options.workspaceRoot, baseRef ?? "HEAD")
+            : listGitStagedDiff(options.workspaceRoot)));
+    const files = [];
+    const missingFiles = [];
+    const task = options.task ?? DEFAULT_STAGED_CHECK_TASK;
+    const tokenBudget = options.tokenBudget ?? 4000;
+    const adapterSupport = engine.getAdapterSupport();
+    sourceFiles.forEach((filePath) => {
+        const focus = engine.getFileFocusSummary(filePath);
+        if (!focus) {
+            missingFiles.push(filePath);
+            return;
+        }
+        const plan = engine.planContext(task, filePath, tokenBudget);
+        const projectPath = focus.projectPath;
+        const fileDiff = stagedDiff.get(projectPath) ?? emptyFileDiff(projectPath);
+        const changedSymbols = getChangedSymbolsForFile(engine, options.workspaceRoot, projectPath, fileDiff, mode, baseRef).map((symbol) => ({
+            ...symbol,
+            adapterSignals: adapterSignalsForChangedSymbol(adapterSupport, symbol),
+        }));
+        const contractRisks = changedSymbols
+            .filter((symbol) => symbol.contractRisk !== "none")
+            .map((symbol) => {
+            const verificationTargets = plan?.verificationTargets.slice(0, 8) ?? [];
+            return {
+                file: symbol.file,
+                symbol: symbol.symbol,
+                risk: symbol.contractRisk,
+                reason: symbol.reason,
+                callers: symbol.callers,
+                exported: symbol.exported,
+                verificationTargets,
+                adapterSignals: adapterSignalsForContractRisk(adapterSupport, symbol, verificationTargets),
+            };
+        });
+        files.push({
+            file: projectPath,
+            focus: focus.focusPath,
+            modificationRisk: focus.modificationRisk,
+            importerCount: focus.importedBy.length,
+            symbolCount: focus.symbols.length,
+            changedLineRanges: fileDiff.changedLineRanges,
+            changedSymbols,
+            contractRisks,
+            readFirst: plan?.readFirst.map((item) => item.file).slice(0, 6) ?? [],
+            symbolFocus: plan?.symbolFocus.map((symbol) => symbol.symbol).slice(0, 6) ?? [],
+            verificationTargets: plan?.verificationTargets.slice(0, 8) ?? [],
+            adapterSignals: uniqueAdapterSignals([
+                ...adapterSignalsFromPlan(plan),
+                ...changedSymbols.flatMap((symbol) => symbol.adapterSignals),
+                ...contractRisks.flatMap((risk) => risk.adapterSignals),
+            ]),
+        });
+    });
+    files.sort((a, b) => {
+        const riskDelta = RISK_RANK[b.modificationRisk] - RISK_RANK[a.modificationRisk];
+        return riskDelta || a.file.localeCompare(b.file);
+    });
+    const risk = highestStagedRisk(files);
+    const changedSymbols = files.flatMap((file) => file.changedSymbols);
+    const contractRisks = files.flatMap((file) => file.contractRisks);
+    const agentActions = buildStagedCheckAgentActions(files, missingFiles, adapterSupport);
+    return {
+        workspace: path.resolve(options.workspaceRoot),
+        mode,
+        baseRef,
+        stagedFiles: sourceFiles.length,
+        checkedFiles: files.length,
+        skippedFiles,
+        missingFiles,
+        highestRisk: risk,
+        requiresAttention: risk === "dangerous" ||
+            risk === "caution" ||
+            missingFiles.length > 0 ||
+            contractRisks.length > 0,
+        adapterSupport,
+        agentActions,
+        changedSymbols,
+        contractRisks,
+        files,
+    };
+}
+exports.buildStagedCheckSummary = buildStagedCheckSummary;
+function highestStagedRisk(files) {
+    let result = "none";
+    files.forEach((file) => {
+        if (result === "none" || RISK_RANK[file.modificationRisk] > RISK_RANK[result]) {
+            result = file.modificationRisk;
+        }
+    });
+    return result;
+}
+exports.highestStagedRisk = highestStagedRisk;
+function parseStagedDiff(diff) {
+    const result = new Map();
+    let current;
+    let currentRange;
+    let currentNewLine = 0;
+    diff.split(/\r?\n/).forEach((line) => {
+        if (line.startsWith("diff --git ")) {
+            current = undefined;
+            currentRange = undefined;
+            currentNewLine = 0;
+            return;
+        }
+        if (line === "new file mode" || line.startsWith("new file mode ")) {
+            if (current) {
+                current.isNewFile = true;
+            }
+            return;
+        }
+        if (line === "deleted file mode" || line.startsWith("deleted file mode ")) {
+            if (current) {
+                current.isDeletedFile = true;
+            }
+            return;
+        }
+        if (line.startsWith("+++ ")) {
+            const file = parseDiffFilePath(line.slice(4));
+            if (!file) {
+                current = undefined;
+                return;
+            }
+            current = ensureParsedDiffFile(result, file);
+            return;
+        }
+        if (!current) {
+            return;
+        }
+        const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/.exec(line);
+        if (hunk) {
+            const start = Number(hunk[1]);
+            const count = hunk[2] === undefined ? 1 : Number(hunk[2]);
+            currentNewLine = start;
+            currentRange = {
+                start,
+                end: count > 0 ? start + count - 1 : start,
+                lineCount: count,
+            };
+            current.changedLineRanges.push(currentRange);
+            return;
+        }
+        if (!currentRange) {
+            return;
+        }
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            current.changedLines.push({
+                line: currentNewLine,
+                text: line.slice(1),
+                kind: "added",
+            });
+            currentNewLine++;
+            return;
+        }
+        if (line.startsWith("-") && !line.startsWith("---")) {
+            current.changedLines.push({
+                line: currentRange.start,
+                text: line.slice(1),
+                kind: "removed",
+            });
+            return;
+        }
+        if (line.startsWith(" ")) {
+            currentNewLine++;
+        }
+    });
+    return result;
+}
+function parseDiffFilePath(rawPath) {
+    if (rawPath === "/dev/null") {
+        return null;
+    }
+    const withoutPrefix = rawPath.startsWith("b/") ? rawPath.slice(2) : rawPath;
+    return withoutPrefix.replace(/\\/g, "/");
+}
+function ensureParsedDiffFile(files, file) {
+    const existing = files.get(file);
+    if (existing) {
+        return existing;
+    }
+    const created = {
+        file,
+        isNewFile: false,
+        isDeletedFile: false,
+        changedLineRanges: [],
+        changedLines: [],
+    };
+    files.set(file, created);
+    return created;
+}
+function emptyFileDiff(file) {
+    return {
+        file,
+        isNewFile: false,
+        isDeletedFile: false,
+        changedLineRanges: [],
+        changedLines: [],
+    };
+}
+function getChangedSymbolsForFile(engine, workspaceRoot, projectPath, diff, mode, baseRef) {
+    if (diff.changedLineRanges.length === 0) {
+        return [];
+    }
+    const content = mode === "changed"
+        ? readWorkingTreeFileContent(workspaceRoot, projectPath)
+        : readStagedFileContent(workspaceRoot, projectPath);
+    if (content === null) {
+        return [];
+    }
+    const symbols = parseSymbolRanges(engine, workspaceRoot, projectPath, content);
+    const previousContent = mode === "changed" && baseRef
+        ? readGitRefFileContent(workspaceRoot, baseRef, projectPath)
+        : readHeadFileContent(workspaceRoot, projectPath);
+    const previousSymbols = previousContent === null
+        ? new Map()
+        : symbolsByName(parseSymbolRanges(engine, workspaceRoot, projectPath, previousContent));
+    return symbols
+        .filter((symbol) => rangesIntersectSymbol(diff.changedLineRanges, symbol))
+        .map((symbol) => buildChangedSymbol(symbol, diff, previousSymbols.get(symbol.name)))
+        .sort((a, b) => {
+        const riskDelta = contractRiskRank(b.contractRisk) - contractRiskRank(a.contractRisk);
+        return riskDelta || a.symbol.localeCompare(b.symbol);
+    });
+}
+function readWorkingTreeFileContent(workspaceRoot, projectPath) {
+    const absolutePath = path.resolve(workspaceRoot, projectPath);
+    try {
+        return fs.readFileSync(absolutePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function readStagedFileContent(workspaceRoot, projectPath) {
+    try {
+        return (0, child_process_1.execFileSync)("git", ["show", `:${projectPath}`], {
+            cwd: workspaceRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch {
+        const absolutePath = path.resolve(workspaceRoot, projectPath);
+        try {
+            return fs.readFileSync(absolutePath, "utf8");
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function readGitRefFileContent(workspaceRoot, ref, projectPath) {
+    try {
+        return (0, child_process_1.execFileSync)("git", ["show", `${ref}:${projectPath}`], {
+            cwd: workspaceRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function readHeadFileContent(workspaceRoot, projectPath) {
+    return readGitRefFileContent(workspaceRoot, "HEAD", projectPath);
+}
+function parseSymbolRanges(engine, workspaceRoot, projectPath, content) {
+    if (projectPath.toLowerCase().endsWith(".py")) {
+        return parsePythonSymbolRanges(engine, workspaceRoot, projectPath, content);
+    }
+    const project = new ts_morph_1.Project({
+        compilerOptions: {
+            allowJs: true,
+            jsx: 4,
+            allowSyntheticDefaultImports: true,
+            esModuleInterop: true,
+            moduleResolution: 2,
+            target: 99,
+            strict: false,
+        },
+        skipAddingFilesFromTsConfig: true,
+        skipFileDependencyResolution: true,
+    });
+    const sourceFile = project.createSourceFile(projectPath, content, { overwrite: true });
+    const exportedNames = exportedSymbolNames(sourceFile);
+    const graphSymbols = graphSymbolsByName(engine, workspaceRoot, projectPath);
+    const ranges = [];
+    const seen = new Set();
+    const addRange = (name, kind, node) => {
+        if (!name || name.includes("{") || name.includes("[")) {
+            return;
+        }
+        const key = `${name}:${kind}:${node.getStart()}`;
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        const graphSymbol = graphSymbols.get(name);
+        const nodeRange = lineRangeForNode(node);
+        ranges.push({
+            symbol: `${projectPath}::${name}`,
+            file: projectPath,
+            name,
+            kind: graphSymbol?.kind ?? kind,
+            layer: graphSymbol?.layer,
+            exported: exportedNames.has(name),
+            callers: graphSymbol?.calledBy.size ?? 0,
+            calls: graphSymbol?.calls.size ?? 0,
+            startLine: nodeRange.start,
+            endLine: nodeRange.end,
+            signatureStartLine: nodeRange.signatureStart,
+            signatureEndLine: nodeRange.signatureEnd,
+            signatureText: signatureTextForNode(node),
+        });
+    };
+    sourceFile.getFunctions().forEach((funcDecl) => {
+        addRange(funcDecl.getName(), "function", funcDecl);
+    });
+    sourceFile.getClasses().forEach((classDecl) => {
+        addRange(classDecl.getName(), "class", classDecl);
+        classDecl.getMethods().forEach((methodDecl) => {
+            addRange(methodDecl.getName(), "method", methodDecl);
+        });
+    });
+    sourceFile.getVariableDeclarations().forEach((varDecl) => {
+        const initializer = varDecl.getInitializer();
+        const kind = initializer &&
+            (initializer.getKind() === ts_morph_1.SyntaxKind.ArrowFunction ||
+                initializer.getKind() === ts_morph_1.SyntaxKind.FunctionExpression)
+            ? "function"
+            : "variable";
+        addRange(varDecl.getName(), kind, varDecl);
+    });
+    return ranges;
+}
+function parsePythonSymbolRanges(engine, workspaceRoot, projectPath, content) {
+    const graphSymbols = graphSymbolsByName(engine, workspaceRoot, projectPath);
+    const lines = content.split(/\r?\n/);
+    const ranges = [];
+    const seen = new Set();
+    lines.forEach((line, index) => {
+        const functionMatch = /^(\s*)(?:async\s+def|def)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/.exec(line);
+        const classMatch = /^(\s*)class\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:\(|:)/.exec(line);
+        const match = functionMatch ?? classMatch;
+        if (!match) {
+            return;
+        }
+        const indent = pythonIndent(match[1]);
+        const name = match[2];
+        const kind = classMatch
+            ? "class"
+            : indent > 0
+                ? "method"
+                : "function";
+        const key = `${name}:${kind}:${index}`;
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        const graphSymbol = graphSymbols.get(name);
+        const startLine = index + 1;
+        const endLine = pythonBlockEndLine(lines, index, indent);
+        ranges.push({
+            symbol: `${projectPath}::${name}`,
+            file: projectPath,
+            name,
+            kind: graphSymbol?.kind ?? kind,
+            layer: graphSymbol?.layer,
+            exported: indent === 0 && !name.startsWith("_"),
+            callers: graphSymbol?.calledBy.size ?? 0,
+            calls: graphSymbol?.calls.size ?? 0,
+            startLine,
+            endLine,
+            signatureStartLine: startLine,
+            signatureEndLine: startLine,
+            signatureText: normalizeSignatureText(line.trim()),
+        });
+    });
+    return ranges;
+}
+function pythonBlockEndLine(lines, startIndex, indent) {
+    for (let i = startIndex + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trim() || line.trimStart().startsWith("#") || line.trimStart().startsWith("@")) {
+            continue;
+        }
+        const lineIndent = pythonIndent(line.match(/^\s*/)?.[0] ?? "");
+        if (lineIndent <= indent) {
+            return i;
+        }
+    }
+    return lines.length;
+}
+function pythonIndent(value) {
+    return value.replace(/\t/g, "    ").length;
+}
+function symbolsByName(symbols) {
+    const result = new Map();
+    symbols.forEach((symbol) => {
+        result.set(symbol.name, symbol);
+    });
+    return result;
+}
+function exportedSymbolNames(sourceFile) {
+    const exported = new Set();
+    sourceFile.getExportedDeclarations().forEach((declarations, exportName) => {
+        declarations.forEach((decl) => {
+            const declaredName = decl.getName?.();
+            exported.add(declaredName ?? exportName);
+        });
+    });
+    return exported;
+}
+function graphSymbolsByName(engine, workspaceRoot, projectPath) {
+    const symbols = new Map();
+    engine.graph.symbols.forEach((symbol) => {
+        if (toProjectPath(workspaceRoot, symbol.file) === projectPath) {
+            symbols.set(symbol.name, symbol);
+        }
+    });
+    return symbols;
+}
+function lineRangeForNode(node) {
+    const sourceFile = node.getSourceFile();
+    const start = sourceFile.getLineAndColumnAtPos(node.getStart()).line;
+    const end = sourceFile.getLineAndColumnAtPos(node.getEnd()).line;
+    const body = bodyNodeFor(node);
+    const bodyStart = body
+        ? sourceFile.getLineAndColumnAtPos(body.getStart()).line
+        : start;
+    return {
+        start,
+        end,
+        signatureStart: start,
+        signatureEnd: Math.max(start, Math.min(bodyStart, end)),
+    };
+}
+function bodyNodeFor(node) {
+    if (ts_morph_1.Node.isFunctionDeclaration(node) ||
+        ts_morph_1.Node.isMethodDeclaration(node) ||
+        ts_morph_1.Node.isFunctionExpression(node) ||
+        ts_morph_1.Node.isArrowFunction(node)) {
+        return node.getBody();
+    }
+    if (ts_morph_1.Node.isClassDeclaration(node)) {
+        return node;
+    }
+    if (ts_morph_1.Node.isVariableDeclaration(node)) {
+        const initializer = node.getInitializer();
+        if (initializer &&
+            (ts_morph_1.Node.isArrowFunction(initializer) || ts_morph_1.Node.isFunctionExpression(initializer))) {
+            return initializer.getBody();
+        }
+    }
+    return undefined;
+}
+function signatureTextForNode(node) {
+    const sourceFile = node.getSourceFile();
+    const fullText = sourceFile.getFullText();
+    const body = bodyNodeFor(node);
+    if (body && !ts_morph_1.Node.isClassDeclaration(node)) {
+        const start = node.getStart();
+        const bodyStart = body.getStart();
+        if (bodyStart > start) {
+            return normalizeSignatureText(fullText.slice(start, bodyStart));
+        }
+    }
+    const text = node.getText();
+    if (ts_morph_1.Node.isClassDeclaration(node)) {
+        const braceIndex = text.indexOf("{");
+        if (braceIndex >= 0) {
+            return normalizeSignatureText(text.slice(0, braceIndex));
+        }
+    }
+    return normalizeSignatureText(text);
+}
+function normalizeSignatureText(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function rangesIntersectSymbol(ranges, symbol) {
+    return ranges.some((range) => {
+        return range.start <= symbol.endLine && range.end >= symbol.startLine;
+    });
+}
+function buildChangedSymbol(symbol, diff, previousSymbol) {
+    const changedLines = uniqueSortedNumbers(diff.changedLines
+        .filter((line) => line.line >= symbol.startLine && line.line <= symbol.endLine)
+        .map((line) => line.line));
+    const symbolStatus = previousSymbol ? "modified" : "created";
+    const signatureTouched = diff.changedLineRanges.some((range) => {
+        return range.start <= symbol.signatureEndLine && range.end >= symbol.signatureStartLine;
+    });
+    const signatureChanged = previousSymbol
+        ? previousSymbol.signatureText !== symbol.signatureText
+        : false;
+    const contractChanged = previousSymbol
+        ? signatureChanged ||
+            previousSymbol.kind !== symbol.kind ||
+            previousSymbol.exported !== symbol.exported
+        : symbolStatus === "created" && (symbol.exported || symbol.callers > 0);
+    const returnLineChanged = diff.changedLines.some((line) => {
+        return (line.line >= symbol.startLine &&
+            line.line <= symbol.endLine &&
+            /\breturn\b/.test(line.text));
+    });
+    const contractRisk = contractRiskForSymbol(symbol, symbolStatus, contractChanged, returnLineChanged);
+    const changeKind = contractChanged
+        ? "signature-or-contract"
+        : returnLineChanged
+            ? "return-shape-review"
+            : "implementation";
+    return {
+        symbol: symbol.symbol,
+        file: symbol.file,
+        name: symbol.name,
+        kind: symbol.kind,
+        layer: symbol.layer,
+        exported: symbol.exported,
+        callers: symbol.callers,
+        calls: symbol.calls,
+        symbolStatus,
+        changeKind,
+        contractRisk,
+        signatureTouched,
+        signatureChanged,
+        contractChanged,
+        returnLineChanged,
+        changedLines,
+        lineRange: {
+            start: symbol.startLine,
+            end: symbol.endLine,
+        },
+        reason: changedSymbolReason(symbol, symbolStatus, signatureTouched, signatureChanged, contractChanged, returnLineChanged, contractRisk),
+        adapterSignals: [],
+    };
+}
+function contractRiskForSymbol(symbol, symbolStatus, contractChanged, returnLineChanged) {
+    if (symbolStatus === "created" && (symbol.exported || symbol.callers > 0)) {
+        return "review";
+    }
+    if (contractChanged && symbol.exported && symbol.callers > 0) {
+        return "high";
+    }
+    if (contractChanged && (symbol.exported || symbol.callers > 0)) {
+        return "review";
+    }
+    if (returnLineChanged && symbol.exported) {
+        return "review";
+    }
+    return "none";
+}
+function changedSymbolReason(symbol, symbolStatus, signatureTouched, signatureChanged, contractChanged, returnLineChanged, contractRisk) {
+    const signals = [];
+    if (symbolStatus === "created") {
+        signals.push("new symbol in staged changes");
+    }
+    if (signatureChanged) {
+        signals.push("signature changed compared with HEAD");
+    }
+    else if (contractChanged) {
+        signals.push("public contract changed compared with HEAD");
+    }
+    else if (signatureTouched) {
+        signals.push("declaration/signature lines touched without signature change");
+    }
+    if (returnLineChanged) {
+        signals.push("changed return line");
+    }
+    if (symbol.exported) {
+        signals.push("exported symbol");
+    }
+    if (symbol.callers > 0) {
+        signals.push(`${symbol.callers} caller(s)`);
+    }
+    if (signals.length === 0) {
+        signals.push("implementation lines changed");
+    }
+    return contractRisk === "none"
+        ? signals.join("; ")
+        : `${signals.join("; ")}; contract review recommended`;
+}
+function contractRiskRank(risk) {
+    if (risk === "high") {
+        return 2;
+    }
+    if (risk === "review") {
+        return 1;
+    }
+    return 0;
+}
+function uniqueSortedNumbers(values) {
+    return Array.from(new Set(values)).sort((a, b) => a - b);
+}
+function toProjectPath(workspaceRoot, filePath) {
+    const relativePath = path.isAbsolute(filePath)
+        ? path.relative(workspaceRoot, filePath)
+        : filePath;
+    return relativePath.split(path.sep).join("/");
+}
+//# sourceMappingURL=staged-check.js.map