@skyramp/mcp 0.3.8 → 0.4.0-rc.1

package/build/utils/changedRoutes.d.ts

@@ -1,29 +0,0 @@
-import { ScenarioStep } from "../types/RepositoryAnalysis.js";
-/** A method+path pair extracted from an actually-changed (`+`/`-`) diff line. */
-export interface ChangedRoute {
-    method: string;
-    path: string;
-}
-/**
- * Extract method+path from every changed (`+`/`-`, non-header) line of a raw
- * unified diff. Reuses `parseRouteLine`, which already strips the leading
- * `+`/`-` marker and matches the same route-decorator patterns the endpoint
- * scanner does.
- */
-export declare function collectChangedRouteLines(diffText: string): ChangedRoute[];
-/**
- * The first step of `steps` that targets a method+path on the changed hunk, or
- * undefined. Returns the STEP, not a boolean, because two callers need
- * different things from the same comparison: the ranker asks whether any step
- * matches, and the subject resolver needs which ones do.
- *
- * Diff-extracted paths are local to the file's own router declaration (e.g.
- * "/suggestions"); scenario step paths are fully mounted (e.g.
- * "/api/recipes/suggestions"). A local path matches when the step path ends
- * with it at a segment boundary (`pathSuffixMatches`), so the cross-file mount
- * prefix difference (see recoverRemovedEndpointsFromBase, SKYR-4026) does not
- * prevent the match — while a plain `endsWith` would also wrongly match an
- * unrelated path that merely shares a trailing substring (e.g. "/preorders"
- * against "orders").
- */
-export declare function findStepOnChangedRoute(steps: ScenarioStep[] | undefined, changedRoutes: ChangedRoute[]): ScenarioStep | undefined;

package/build/utils/changedRoutes.js

@@ -1,87 +0,0 @@
-import { parseRouteLine, normalizeDiffPath } from "./routeParsers.js";
-import { isBareIdPath, pathSuffixMatches } from "./pathMatching.js";
-/**
- * Extract method+path from every changed (`+`/`-`, non-header) line of a raw
- * unified diff. Reuses `parseRouteLine`, which already strips the leading
- * `+`/`-` marker and matches the same route-decorator patterns the endpoint
- * scanner does.
- */
-export function collectChangedRouteLines(diffText) {
-    const routes = [];
-    let currentFile = "";
-    let removedFile = "";
-    for (const line of diffText.split("\n")) {
-        // Track the current file from the unified-diff header so parseRouteLine
-        // gets the real path — its UI-component guard (UI_COMPONENT_EXT) depends
-        // on it, or a route-shaped line inside a .tsx/.jsx file (e.g. a client
-        // router registration) gets misparsed as a changed backend route.
-        // A deleted file has "+++ /dev/null", so the old side is the only name it
-        // has. Without it parseRouteLine gets an empty path and every
-        // extension-gated framework (Go, Rails, PHP) rejects the line, losing the
-        // routes the deletion removed.
-        if (line.startsWith("--- ")) {
-            const spec = line.slice(4).trim().split("\t")[0];
-            removedFile = spec === "/dev/null" ? "" : normalizeDiffPath(spec);
-            continue;
-        }
-        if (line.startsWith("+++ ")) {
-            const spec = line.slice(4).trim().split("\t")[0];
-            currentFile = spec === "/dev/null" ? removedFile : normalizeDiffPath(spec);
-            continue;
-        }
-        if (line.startsWith("diff --git") || line.startsWith("index "))
-            continue;
-        if (!(line.startsWith("+") || line.startsWith("-")))
-            continue;
-        const parsed = parseRouteLine(line, currentFile);
-        if (parsed)
-            routes.push({ method: parsed.method, path: parsed.path });
-    }
-    return routes;
-}
-/**
- * The first step of `steps` that targets a method+path on the changed hunk, or
- * undefined. Returns the STEP, not a boolean, because two callers need
- * different things from the same comparison: the ranker asks whether any step
- * matches, and the subject resolver needs which ones do.
- *
- * Diff-extracted paths are local to the file's own router declaration (e.g.
- * "/suggestions"); scenario step paths are fully mounted (e.g.
- * "/api/recipes/suggestions"). A local path matches when the step path ends
- * with it at a segment boundary (`pathSuffixMatches`), so the cross-file mount
- * prefix difference (see recoverRemovedEndpointsFromBase, SKYR-4026) does not
- * prevent the match — while a plain `endsWith` would also wrongly match an
- * unrelated path that merely shares a trailing substring (e.g. "/preorders"
- * against "orders").
- */
-export function findStepOnChangedRoute(steps, changedRoutes) {
-    if (changedRoutes.length === 0)
-        return undefined;
-    for (const step of steps ?? []) {
-        const stepMethod = (step.method ?? "").toUpperCase();
-        const stepPath = (step.path ?? "").replace(/\/+$/, "");
-        for (const route of changedRoutes) {
-            if (route.method.toUpperCase() !== stepMethod)
-                continue;
-            const routePath = route.path.replace(/\/+$/, "");
-            // A diff line declaring nothing but a bare id — `router.delete("/:id")`
-            // from a mounted Express router, `@Delete(":id")` from NestJS — names no
-            // resource, so it suffix-matches every `DELETE …/{id}` step. Both callers
-            // ask "does this changed route touch this step", and the answer there is
-            // no: for the ranker it lifted an unrelated candidate over a business-rule
-            // one, and for subject resolution it would make every step a subject.
-            // A NAMED parameter (`/:order_id`) still matches only its own resource,
-            // because the helper unifies a parameter's spelling and not its name.
-            if (isBareIdPath(routePath))
-                continue;
-            if (routePath === "") {
-                if (stepPath === "" || stepPath === "/")
-                    return step;
-                continue;
-            }
-            if (pathSuffixMatches(stepPath, routePath))
-                return step;
-        }
-    }
-    return undefined;
-}

package/build/utils/frontendIntegration.d.ts

@@ -1,9 +0,0 @@
-import { FrontendFileIntegration } from "../types/FrontendIntegration.js";
-export type { FrontendFileIntegration } from "../types/FrontendIntegration.js";
-/**
- * Checks each changed frontend file for a production importer — the
- * deterministic version of the grep the testbot prompt used to ask the
- * agent to run mid-task. See module doc for the signature-based approach
- * and the fail-open rationale.
- */
-export declare function checkFrontendFileIntegration(repositoryPath: string, changedFrontendFiles: string[]): FrontendFileIntegration[];

package/build/utils/frontendIntegration.js

@@ -1,243 +0,0 @@
-/**
- * Server-side "frontend component integration check" — SKYR-3855.
- *
- * Deterministically answers the question the testbot prompt previously asked
- * the agent to answer via a mid-run grep: "is this changed frontend file
- * actually rendered anywhere in the running app, or is it dead/orphaned
- * code?" Computed here so the skip decision for UI test generation consumes
- * a server fact instead of an LLM judgment call made under budget pressure.
- *
- * Detection greps for the module's PATH-REFERENCE SIGNATURE — the basename
- * preceded by a slash and followed by a quote (`/Foo'`, `/Foo"`, `/Foo\``) —
- * rather than the bare component name. Imports always reference the module
- * path in quotes (`from './Foo'`, `require("components/Foo")`,
- * `import('./Foo')`), so the signature carries import-context precision
- * lexically: no per-line verification, no file reads in Node, and `git grep
- * -l -F` returns only matching paths (bounded output regardless of file
- * sizes). Named imports that go through a barrel resolve one hop: the
- * barrel's `export { Foo } from './Foo'` contains the signature, and the
- * barrel counts as the importer. Known miss: extensionless root-level
- * imports with no slash (`from 'Foo'`) — root files are route/entrypoint
- * short-circuited in practice.
- *
- * Fail-open by design: any scan failure reports `integrated: true` so a bug
- * in this heuristic can never wrongly suppress UI test generation.
- */
-import { execFileSync } from "child_process";
-import * as fs from "fs";
-import * as path from "path";
-import { isTestFile, isI18nLocaleFile } from "../prompts/test-recommendation/scopeAssessment.js";
-import { logger } from "./logger.js";
-import { walkDir } from "./fileWalk.js";
-import { buildPathSignatures, importsIndexModule, isIndexModule } from "./pathSignatures.js";
-import { IntegrationReason } from "../types/FrontendIntegration.js";
-const MAX_IMPORTERS = 10;
-const MAX_FILES_WALKED = 3000;
-const MAX_FILE_SIZE_BYTES = 512 * 1024;
-// Framework route/page/entrypoint conventions — mirrors the testbot prompt's
-// "Never apply the unintegrated heuristic to framework route/entrypoint files"
-// rule. These are reachable by convention, so the grep is skipped entirely.
-// `app` is deliberately NOT in the dir pattern: it is a common generic
-// monorepo directory (e.g. appsmith's top-level app/), and matching it made
-// the check inert for every file in such repos (eval run 28618761653).
-// Next.js App Router route files are still short-circuited via their
-// basenames (page.*, layout.*); non-route components under app/ resolve
-// through the importer grep like any other file.
-const ROUTE_DIR_PATTERN = /(^|\/)(pages|routes)(\/|$)/i;
-// Generic entrypoint basenames (index/main/app/_app) are only reachable-by-
-// convention at the repo root or directly under `src/` — e.g. Vite's
-// `src/main.tsx`, CRA's `src/index.tsx`, Pages Router's root `_app.tsx`.
-// Deeper in the tree these are ordinary component filenames (folder-per-
-// component layouts commonly name the component file `index.tsx`), so
-// matching them anywhere would short-circuit real, checkable components —
-// the same class of bug as the `app/` dir match (see module doc).
-const ROOT_ENTRYPOINT_BASENAME_PATTERN = /^(src\/)?(index|main|app|_app)\.[^/]+$/i;
-// `page`/`layout` are App Router-specific and only meaningful under an
-// `app/` segment; outside of one, a file named `page.tsx` or `layout.tsx`
-// has no special framework meaning and should go through the normal check.
-const APP_ROUTER_BASENAME_PATTERN = /(^|\/)app\/(.*\/)?(page|layout)\.[^/]+$/i;
-// Frontend-importer file types only. Deliberately NOT shared with
-// analyzeChangesTool's SOURCE_EXTS (backend-inclusive: py|java|go|…) or
-// repoScanner's ROUTE_FILE_PATTERN — those detect backend route handlers;
-// this detects files that can render a frontend component. The domains must
-// stay independently tunable (see the `app/` route-dir lesson above).
-const FRONTEND_SOURCE_EXT_PATTERN = /\.(ts|tsx|js|jsx|mjs|cjs|vue|svelte)$/i;
-const STORY_FILE_PATTERN = /\.stories\.[^/]+$/i;
-const EXCLUDED_DIR_PATTERN = /(^|\/)(node_modules|dist|build|\.git)(\/|$)/;
-function isRouteOrEntrypoint(file) {
-    return (ROUTE_DIR_PATTERN.test(file) ||
-        ROOT_ENTRYPOINT_BASENAME_PATTERN.test(file) ||
-        APP_ROUTER_BASENAME_PATTERN.test(file));
-}
-function isExcludedImporterPath(relPath) {
-    return (EXCLUDED_DIR_PATTERN.test(relPath) ||
-        isTestFile(relPath) ||
-        STORY_FILE_PATTERN.test(relPath) ||
-        !FRONTEND_SOURCE_EXT_PATTERN.test(relPath));
-}
-/**
- * Runs `git grep -l -F` for the given fixed-string signatures (OR'd
- * together) scoped to the repository's tracked files. Returns file paths
- * relative to `repositoryPath` — only paths, never matched lines, so output
- * stays bounded no matter how large the matching files are. An exit code of
- * 1 means "no matches" — a normal outcome, not an error. Throws on real
- * failures (not a git repo, git not installed) so the caller can fall back
- * to a manual walk.
- */
-function gitGrepFiles(repositoryPath, signatures) {
-    const args = ["grep", "-l", "-F", "-I"];
-    for (const signature of signatures)
-        args.push("-e", signature);
-    try {
-        const stdout = execFileSync("git", args, {
-            cwd: repositoryPath,
-            encoding: "utf8",
-            maxBuffer: 20 * 1024 * 1024,
-        });
-        return stdout.split("\n").filter(Boolean);
-    }
-    catch (err) {
-        if (err && err.status === 1)
-            return []; // no matches — not an error
-        throw err;
-    }
-}
-/**
- * Bounded manual directory walk used only when `git grep` itself fails
- * (e.g. not a git repository). Caps the number and size of files scanned so
- * a huge repo can't turn a fallback path into a multi-minute scan or a
- * large allocation.
- *
- * If the walk is cut off by `MAX_FILES_WALKED` before finding any importer,
- * the "no importer" result can't be trusted — an importer may exist in the
- * unscanned remainder. Per the module's fail-open contract, that ambiguity
- * throws so the caller reports `scan-error` (`integrated: true`) instead of
- * a false "no-importers".
- */
-function manualWalkGrep(repositoryPath, signatures) {
-    const results = [];
-    let filesScanned = 0;
-    let truncated = false;
-    const shouldSkipDir = (_entry, full) => {
-        // EXCLUDED_DIR_PATTERN matches on the "/"-normalized relative path.
-        const rel = path.relative(repositoryPath, full).replace(/\\/g, "/");
-        return EXCLUDED_DIR_PATTERN.test(rel + "/");
-    };
-    for (const [entry, abs] of walkDir(repositoryPath, { shouldSkipDir })) {
-        if (!FRONTEND_SOURCE_EXT_PATTERN.test(entry.name))
-            continue;
-        if (filesScanned >= MAX_FILES_WALKED) {
-            truncated = true;
-            break; // stop the entire walk
-        }
-        filesScanned++;
-        // Normalize to forward slashes: on Windows, path.relative() returns
-        // "\\"-separated paths, but isTestFile assumes "/".
-        const rel = path.relative(repositoryPath, abs).replace(/\\/g, "/");
-        try {
-            if (fs.statSync(abs).size > MAX_FILE_SIZE_BYTES)
-                continue;
-            const content = fs.readFileSync(abs, "utf-8");
-            if (signatures.some((s) => content.includes(s)))
-                results.push(rel);
-        }
-        catch {
-            // Unreadable/vanished file — skip it, keep scanning.
-        }
-    }
-    if (truncated && results.length === 0) {
-        throw new Error(`manual-walk fallback truncated at ${MAX_FILES_WALKED} files with no importer found`);
-    }
-    return results;
-}
-function searchProductionImporters(repositoryPath, signatures) {
-    try {
-        return gitGrepFiles(repositoryPath, signatures);
-    }
-    catch (err) {
-        logger.warning("git grep failed for integration check — falling back to bounded manual walk", {
-            repositoryPath,
-            error: err instanceof Error ? err.message : String(err),
-        });
-        return manualWalkGrep(repositoryPath, signatures);
-    }
-}
-function checkOneFile(repositoryPath, file) {
-    if (isRouteOrEntrypoint(file)) {
-        return { file, integrated: true, importers: [], reason: IntegrationReason.RouteOrEntrypoint };
-    }
-    // i18n/locale content is commonly loaded via a runtime-templated path (e.g.
-    // i18next-http-backend's `loadPath: '/locales/{{lng}}/{{ns}}.json'`) rather
-    // than a static quoted import — the signature grep below would never find
-    // that reference and would misreport a real, live locale file as dead code.
-    if (isI18nLocaleFile(file)) {
-        return { file, integrated: true, importers: [], reason: IntegrationReason.I18nLocaleContent };
-    }
-    // A missing changed file (e.g. deleted, or an unexpected diff shape) means
-    // the classification can't be trusted — fail open rather than risk wrongly
-    // suppressing UI test generation.
-    if (!fs.existsSync(path.join(repositoryPath, file))) {
-        logger.warning("Integration check: changed file not found on disk — reporting integrated (fail-open)", {
-            file,
-        });
-        return { file, integrated: true, importers: [], reason: IntegrationReason.ScanError };
-    }
-    try {
-        const signatures = buildPathSignatures(file);
-        const candidates = searchProductionImporters(repositoryPath, signatures)
-            .filter((candidate) => candidate !== file && !isExcludedImporterPath(candidate));
-        const importers = isIndexModule(file)
-            ? selectIndexModuleImporters(repositoryPath, file, candidates)
-            : candidates.slice(0, MAX_IMPORTERS);
-        return {
-            file,
-            integrated: importers.length > 0,
-            importers,
-            reason: importers.length > 0 ? IntegrationReason.Imported : IntegrationReason.NoImporters,
-        };
-    }
-    catch (err) {
-        logger.warning("Integration check scan failed — reporting integrated (fail-open)", {
-            file,
-            error: err instanceof Error ? err.message : String(err),
-        });
-        return { file, integrated: true, importers: [], reason: IntegrationReason.ScanError };
-    }
-}
-/**
- * An index module's directory stem (`/_constants'`) is a plain string match, so a
- * file importing its own unrelated `./_constants` also hits. Keep only candidates
- * whose specifier resolves to this module's directory. Reads stop once
- * MAX_IMPORTERS are accepted; files over MAX_FILE_SIZE_BYTES are skipped like in
- * manualWalkGrep; an unreadable candidate is kept (fail-open, like the module).
- */
-function selectIndexModuleImporters(repositoryPath, file, candidates) {
-    const accepted = [];
-    for (const candidate of candidates) {
-        if (accepted.length >= MAX_IMPORTERS)
-            break;
-        const abs = path.join(repositoryPath, candidate);
-        let content;
-        try {
-            if (fs.statSync(abs).size > MAX_FILE_SIZE_BYTES)
-                continue;
-            content = fs.readFileSync(abs, "utf8");
-        }
-        catch {
-            accepted.push(candidate);
-            continue;
-        }
-        if (importsIndexModule(candidate, content, file))
-            accepted.push(candidate);
-    }
-    return accepted;
-}
-/**
- * Checks each changed frontend file for a production importer — the
- * deterministic version of the grep the testbot prompt used to ask the
- * agent to run mid-task. See module doc for the signature-based approach
- * and the fail-open rationale.
- */
-export function checkFrontendFileIntegration(repositoryPath, changedFrontendFiles) {
-    return changedFrontendFiles.map((file) => checkOneFile(repositoryPath, file));
-}

package/build/utils/importerHop.d.ts

@@ -1,135 +0,0 @@
-import { sliceAddedLinesByFile } from "./branchDiff.js";
-import type { ScannedEndpoint } from "./repoScanner.js";
-/**
- * Derives a singular, lowercase "resource token" from a backend source file
- * path — e.g. "src/dtos/user.dto.ts" -> "user",
- * "modules/orders/order.service.ts" -> "order". Strips the file extension and
- * a trailing framework-layer suffix, then reuses `extractResourceFromPath`'s
- * "last meaningful path segment" rule by treating the remaining slash-joined
- * path as if it were a URL path.
- */
-export declare function deriveResourceToken(file: string): string;
-/**
- * Derives ALL plausible resource-affinity tokens for a changed file: the
- * filename-derived token from `deriveResourceToken` (when it isn't generic),
- * plus tokens split out of any class/interface/type/enum/schema symbols
- * declared on the file's ADDED diff lines (when `diffHunk` is supplied).
- *
- * This is the sharper anchor requested on PR #588: a generic multi-DTO
- * module (`schemas/actions.py` holding `class DeploymentCreate`, `class
- * FlowCreate`, ...) has no single filename->resource mapping, but the
- * declared symbol name IS the resource — `DeploymentCreate` -> "deployment".
- * Same problem exists for TS (`types/common.ts` holding many interfaces).
- *
- * `diffHunk` is expected to be the file's own added-line slice (e.g. one
- * entry's lines from `sliceAddedLinesByFile`, joined with "\n") — this
- * function does not re-slice a full multi-file diff itself, to avoid
- * duplicating that walking logic in two places.
- *
- * Deduped; capped at `MAX_RESOURCE_TOKENS` so a huge schema file with many
- * declared symbols can't explode the affinity filter into a near-match-all.
- * With no `diffHunk` (or no symbols found), the result is exactly
- * `[deriveResourceToken(file)]` (or `[]` if that's generic/unknown) —
- * identical to today's filename-only behavior.
- */
-/**
- * Declared symbol names changed in a unified diff — from added-line declarations
- * AND from the hunk-header enclosing type (so a field-only edit to an existing class,
- * e.g. `DeploymentCreate.work_pool_name` → required, still yields `DeploymentCreate`).
- * Returns raw names, used both for resource-token derivation (via `tokensFromSymbol`)
- * and for content-grep matching against test bodies (SKYR-3924).
- */
-export declare function extractChangedSymbols(diffHunk: string): string[];
-export declare function deriveResourceTokensForFile(file: string, diffHunk?: string): string[];
-/**
- * All singular resource tokens implied by an endpoint path, used for affinity
- * matching against a `deriveResourceToken` result. Shared by the importer-hop
- * and path-affinity fallbacks (SKYR-3857) — the ONLY endpoint-path to
- * resource-token derivation in the codebase, mirroring how
- * `deriveResourceTokensForFile` is the only file-side one:
- *   - the primary (first non-skip, non-param, non-version) path segment —
- *     catches literal action-style segments like "/users/me", which
- *     `extractResourceFromPath`'s "last segment" rule would otherwise resolve
- *     to "me" instead of "users". Version-like segments are excluded via
- *     `isVersionLikeSegment` — `SKIP_PATH_SEGMENTS` covers "api"/"public" but
- *     only v1-v3, so without it any endpoint versioned beyond v3 would derive
- *     a nonsense token ("v4") as its resource.
- *   - `extractResourceFromPath`'s own result, split on "_" for the sub-resource
- *     composite form ("orders_items" -> "order", "item"). That function only
- *     recognizes OpenAPI-style "{param}" segments (its dedup-key callers see
- *     normalized paths), so ":id"/"[id]"-style params can flow through as its
- *     result — filtered here rather than widening a function whose other
- *     callers don't need it.
- */
-export declare function endpointResourceTokens(endpointPath: string): Set<string>;
-export interface ImporterHopResult {
-    /** Endpoints mapped from unmatched files, deduped against `alreadyClassifiedEndpoints`. */
-    endpoints: ScannedEndpoint[];
-    /** Unmatched file -> endpoint paths newly mapped to it (for logging/drafting). */
-    byFile: Record<string, string[]>;
-}
-/**
- * Maps unmatched changed files (from `classifyEndpointsByChangedFiles`) to
- * endpoints that import them, when the import target and the endpoint share
- * the same REST resource.
- *
- * `alreadyClassifiedEndpoints` (typically `changedEndpoints` + `newEndpoints`
- * from the same classification pass) is used purely for dedup — an endpoint
- * already classified directly is not duplicated into the returned `endpoints`
- * list, though the mapping is still established (harmless to skip re-adding
- * something already present).
- *
- * `diffContent`, when supplied, is the full unified diff — used to derive
- * per-file added-line hunks for `deriveResourceTokensForFile`'s symbol-based
- * affinity anchors (see module doc, limitation 2). Without it, affinity falls
- * back to the filename-only token, identical to pre-symbol-affinity behavior.
- */
-export declare function mapUnmatchedFilesToImporterEndpoints(repositoryPath: string, unmatchedFiles: string[], scannedEndpoints: ScannedEndpoint[], alreadyClassifiedEndpoints?: ScannedEndpoint[], diffContent?: string): ImporterHopResult;
-/** Inputs for response-shape scenario drafting, derived from an {@link ImporterHopResult}. */
-export interface HopResponseShapeInputs {
-    /** Endpoints to draft response-shape scenarios for. */
-    endpoints: ScannedEndpoint[];
-    /** Added-field hints per hop-mapped file, for scenario descriptions. */
-    addedFieldsByFile: Record<string, string[]>;
-}
-/**
- * Builds the inputs `draftResponseShapeScenarios` needs from an
- * {@link ImporterHopResult}, keyed off `byFile` rather than `endpoints`.
- *
- * `hopResult.endpoints` is deduped against endpoints already present in
- * `changedEndpoints`/`newEndpoints` (see `mapUnmatchedFilesToImporterEndpoints`),
- * so it can be empty — or missing entries — even when `byFile` holds valid
- * path mappings (e.g. a controller and the DTO it imports both changed in the
- * same PR: the controller's endpoint is already classified directly, so the
- * hop drops it from `endpoints`, but `byFile` still records the mapping).
- * Response-shape drafting wants every hop-mapped endpoint regardless of
- * whether it was newly added to the change set, so this re-derives the
- * endpoint list from `scannedEndpoints` filtered to the paths `byFile` maps
- * to, instead of relying on the deduped `endpoints` array.
- */
-export declare function buildHopResponseShapeInputs(hopResult: ImporterHopResult, scannedEndpoints: ScannedEndpoint[], diffContent: string | undefined): HopResponseShapeInputs;
-/**
- * Extracts likely property/field names from an array of raw added diff lines
- * (each still prefixed with the unified-diff `+` marker). Best-effort regex,
- * not a parser — intended to give a scenario a field name to name-drop, not
- * to be exhaustive.
- */
-export declare function extractFieldNamesFromAddedLines(lines: string[]): string[];
-export { sliceAddedLinesByFile };
-/**
- * Splits a unified diff into per-file raw sections — every line after a file's
- * `diff --git` header up to the next one — keyed by the `b/` (post-change) path.
- * Unlike `sliceAddedLinesByFile` (added lines only), this preserves the `@@`
- * hunk headers, so `extractChangedSymbols`' enclosing-type extraction (which
- * reads `@@ ... class Foo`) still works when a single file's section is passed
- * to `deriveResourceTokensForFile`. Use this for per-file token derivation that
- * must not mix symbols across files in a multi-file diff (SKYR-3924).
- */
-export declare function sliceDiffByFile(diffContent: string): Map<string, string>;
-/**
- * Computes added-field names per file for the given files, from a full
- * unified diff. Files with no added-line matches are omitted from the result
- * (an empty field list is a valid, expected outcome — the caller still drafts
- * a scenario, just without field hints).
- */
-export declare function computeAddedFieldsByFile(diffContent: string, files: string[]): Record<string, string[]>;