api-tests-coverage 1.0.0

package/dist/action/src/prComment.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * PR comment helper for the API Test Coverage Analyzer action.
+ *
+ * Detects when the action is running in a pull-request context and either
+ * creates or updates a single "coverage report" comment, keeping the PR
+ * timeline clean.  The comment is identified by a hidden sentinel marker so
+ * subsequent runs update the same comment instead of appending new ones.
+ *
+ * Public API:
+ *   postPrComment(token, body)
+ *   isPrContext()
+ */
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrContext = isPrContext;
+exports.readPrNumber = readPrNumber;
+exports.postPrComment = postPrComment;
+const fs = __importStar(require("fs"));
+const core = __importStar(require("@actions/core"));
+const github_1 = require("@actions/github");
+/** Sentinel appended to every coverage comment so we can find + update it. */
+const COMMENT_MARKER = '<!-- api-coverage-analyzer-comment -->';
+/**
+ * Return true when the current workflow run is triggered by a pull-request
+ * event and all required env vars are present.
+ */
+function isPrContext() {
+    var _a;
+    const event = (_a = process.env['GITHUB_EVENT_NAME']) !== null && _a !== void 0 ? _a : '';
+    // pull_request and pull_request_target both carry a PR number
+    return ((event === 'pull_request' || event === 'pull_request_target') &&
+        Boolean(process.env['GITHUB_EVENT_PATH']) &&
+        Boolean(process.env['GITHUB_REPOSITORY']));
+}
+/**
+ * Read the PR number from the GitHub event payload JSON file.
+ * Returns undefined when the file cannot be read or the number is absent.
+ */
+function readPrNumber() {
+    var _a;
+    const eventPath = process.env['GITHUB_EVENT_PATH'];
+    if (!eventPath)
+        return undefined;
+    try {
+        const raw = fs.readFileSync(eventPath, 'utf-8');
+        const payload = JSON.parse(raw);
+        return (_a = payload.pull_request) === null || _a === void 0 ? void 0 : _a.number;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Post or update a single PR comment containing `body`.
+ *
+ * If a previous coverage comment (identified by COMMENT_MARKER) already
+ * exists it is updated in place; otherwise a new comment is created.
+ * Requires a token with `pull-requests: write` permission.
+ *
+ * @param token  GitHub token (e.g. `${{ secrets.GITHUB_TOKEN }}`).
+ * @param body   Markdown body to post.
+ */
+async function postPrComment(token, body) {
+    var _a;
+    if (!isPrContext()) {
+        core.debug('Not a pull-request event – skipping PR comment.');
+        return;
+    }
+    const prNumber = readPrNumber();
+    if (!prNumber) {
+        core.warning('Could not determine PR number from event payload – skipping PR comment.');
+        return;
+    }
+    const repo = (_a = process.env['GITHUB_REPOSITORY']) !== null && _a !== void 0 ? _a : '';
+    const [owner, repoName] = repo.split('/');
+    if (!owner || !repoName) {
+        core.warning('GITHUB_REPOSITORY env var is not in "owner/repo" format – skipping PR comment.');
+        return;
+    }
+    const markedBody = `${body}\n\n${COMMENT_MARKER}`;
+    const octokit = (0, github_1.getOctokit)(token);
+    try {
+        // Search for an existing comment from this action
+        const { data: comments } = await octokit.rest.issues.listComments({
+            owner,
+            repo: repoName,
+            issue_number: prNumber,
+        });
+        const existing = comments.find((c) => { var _a; return (_a = c.body) === null || _a === void 0 ? void 0 : _a.includes(COMMENT_MARKER); });
+        if (existing) {
+            await octokit.rest.issues.updateComment({
+                owner,
+                repo: repoName,
+                comment_id: existing.id,
+                body: markedBody,
+            });
+            core.info(`Updated PR comment #${existing.id} on PR #${prNumber}`);
+        }
+        else {
+            const { data: created } = await octokit.rest.issues.createComment({
+                owner,
+                repo: repoName,
+                issue_number: prNumber,
+                body: markedBody,
+            });
+            core.info(`Created PR comment #${created.id} on PR #${prNumber}`);
+        }
+    }
+    catch (err) {
+        // Non-fatal: a missing permission or API error should not fail the build
+        core.warning(`Failed to post PR comment: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/src/ast/astAnalysisOrchestrator.d.ts

@@ -0,0 +1,36 @@
+/**
+ * AST Analysis Orchestrator — primary entry point for per-file analysis.
+ *
+ * Three-tier cascade:
+ *   Tier 1: AST parse + semantic model → confidence: high/medium
+ *           AST yields ≥1 interactions → return them verbatim (authoritative)
+ *   Tier 2: AST parse succeeds but yields 0 interactions AND fallbackHeuristics is true
+ *           → run deepResolveFile(), tag all results resolutionType:'heuristic' + confidence:'low'
+ *   Tier 3: AST disabled or parse error → existing deepResolveFile(), unchanged confidence
+ *
+ * All language modules must be imported (side-effect) before this is called
+ * so their analyzers are registered. Use `registerAllAnalyzers()` at startup.
+ */
+import type { ResolvedHttpInteraction, SupportedLanguage, AnalysisContext } from './astTypes';
+import type { AstAnalysisConfig } from '../config/types';
+/**
+ * Analyze a single source file. Returns fully-resolved HTTP interactions.
+ *
+ * @param content       Raw source text
+ * @param filePath      Absolute path (used for error messages, deduplication)
+ * @param language      Detected language (or 'auto')
+ * @param context       Combined AST + deep-analysis config
+ */
+export declare function analyzeFile(content: string, filePath: string, language: SupportedLanguage, context: AnalysisContext): ResolvedHttpInteraction[];
+/**
+ * Bootstrap function — import all language analyzer modules so they
+ * register themselves in the parser registry. Must be called once at
+ * CLI/library startup before any `analyzeFile()` call.
+ */
+export declare function registerAllAnalyzers(): void;
+/**
+ * Build a default AnalysisContext from partial config.
+ * Useful for call sites that don't yet pass a full context.
+ */
+export declare function buildAnalysisContext(astConfig?: AstAnalysisConfig, deepConfig?: any): AnalysisContext;
+//# sourceMappingURL=astAnalysisOrchestrator.d.ts.map

package/dist/src/ast/astAnalysisOrchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astAnalysisOrchestrator.d.ts","sourceRoot":"","sources":["../../../src/ast/astAnalysisOrchestrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC9F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAGzD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,eAAe,GACvB,uBAAuB,EAAE,CAwC3B;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAO3C;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,CAAC,EAAE,iBAAiB,EAE7B,UAAU,CAAC,EAAE,GAAG,GACf,eAAe,CAoBjB"}

package/dist/src/ast/astAnalysisOrchestrator.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * AST Analysis Orchestrator — primary entry point for per-file analysis.
+ *
+ * Three-tier cascade:
+ *   Tier 1: AST parse + semantic model → confidence: high/medium
+ *           AST yields ≥1 interactions → return them verbatim (authoritative)
+ *   Tier 2: AST parse succeeds but yields 0 interactions AND fallbackHeuristics is true
+ *           → run deepResolveFile(), tag all results resolutionType:'heuristic' + confidence:'low'
+ *   Tier 3: AST disabled or parse error → existing deepResolveFile(), unchanged confidence
+ *
+ * All language modules must be imported (side-effect) before this is called
+ * so their analyzers are registered. Use `registerAllAnalyzers()` at startup.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeFile = analyzeFile;
+exports.registerAllAnalyzers = registerAllAnalyzers;
+exports.buildAnalysisContext = buildAnalysisContext;
+const parseFile_1 = require("./parseFile");
+const deepEndpointResolver_1 = require("../coverage/deep-analysis/deepEndpointResolver");
+const types_1 = require("../coverage/deep-analysis/types");
+/**
+ * Analyze a single source file. Returns fully-resolved HTTP interactions.
+ *
+ * @param content       Raw source text
+ * @param filePath      Absolute path (used for error messages, deduplication)
+ * @param language      Detected language (or 'auto')
+ * @param context       Combined AST + deep-analysis config
+ */
+function analyzeFile(content, filePath, language, context) {
+    const { astConfig, deepConfig } = context;
+    const fallbackEnabled = astConfig.fallbackHeuristics !== false;
+    // ── Tier 1: AST path ──────────────────────────────────────────────────────
+    if (astConfig.enabled !== false) {
+        const astResults = (0, parseFile_1.analyzeFileWithAst)(filePath, content, language, context);
+        if (astResults !== null) {
+            // AST parsed successfully
+            if (astResults.length > 0) {
+                // Non-empty AST result — return verbatim (authoritative)
+                return astResults;
+            }
+            // ── Tier 2: AST found nothing — optionally run regex fallback ────────
+            if (fallbackEnabled && deepConfig.enabled) {
+                const regexLang = language === 'auto' ? 'typescript' : language;
+                const heuristicResults = (0, deepEndpointResolver_1.deepResolveFile)(content, filePath, regexLang, deepConfig);
+                // Tag all fallback results as heuristic / low confidence
+                return heuristicResults.map((interaction) => ({
+                    ...interaction,
+                    resolutionType: 'heuristic',
+                    confidence: 'low',
+                }));
+            }
+            // fallbackHeuristics: false — return the empty AST result verbatim
+            return astResults;
+        }
+        // null = parse error or no analyzer registered for this language.
+        // Fall through to Tier 3 so the file is still analysed.
+    }
+    // ── Tier 3: regex fallback ────────────────────────────────────────────────
+    // Only reached when AST is disabled or could not parse the file.
+    if (!deepConfig.enabled)
+        return [];
+    const regexLang = language === 'auto' ? 'typescript' : language;
+    return (0, deepEndpointResolver_1.deepResolveFile)(content, filePath, regexLang, deepConfig);
+}
+/**
+ * Bootstrap function — import all language analyzer modules so they
+ * register themselves in the parser registry. Must be called once at
+ * CLI/library startup before any `analyzeFile()` call.
+ */
+function registerAllAnalyzers() {
+    try {
+        require('../languages/javascript/index');
+    }
+    catch { /* not available */ }
+    try {
+        require('../languages/typescript/index');
+    }
+    catch { /* not available */ }
+    try {
+        require('../languages/java/index');
+    }
+    catch { /* not available */ }
+    try {
+        require('../languages/kotlin/index');
+    }
+    catch { /* not available */ }
+    try {
+        require('../languages/python/index');
+    }
+    catch { /* not available */ }
+    try {
+        require('../languages/ruby/index');
+    }
+    catch { /* not available */ }
+}
+/**
+ * Build a default AnalysisContext from partial config.
+ * Useful for call sites that don't yet pass a full context.
+ */
+function buildAnalysisContext(astConfig, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+deepConfig) {
+    return {
+        astConfig: {
+            enabled: true,
+            fallbackHeuristics: true,
+            maxCallDepth: 4,
+            assertionAware: true,
+            languages: {
+                java: { enabled: true },
+                kotlin: { enabled: true },
+                python: { enabled: true },
+                ruby: { enabled: true },
+                javascript: { enabled: true },
+                typescript: { enabled: true },
+                cucumber: { enabled: true },
+            },
+            ...astConfig,
+        },
+        deepConfig: deepConfig !== null && deepConfig !== void 0 ? deepConfig : types_1.DEFAULT_DEEP_ANALYSIS_CONFIG,
+    };
+}

package/dist/src/ast/astTypes.d.ts

@@ -0,0 +1,105 @@
+/**
+ * AST-layer canonical types.
+ *
+ * These types define the normalized representation produced by language-specific
+ * parsers and consumed by the coverage engine. They are a strict superset of the
+ * deep-analysis layer types so all existing consumers continue to work unmodified.
+ */
+import type { ResolutionType, ConfidenceLevel, ResolvedHttpCall, DeepAnalysisConfig } from '../coverage/deep-analysis/types';
+import type { AstAnalysisConfig } from '../config/types';
+export type { ResolutionType, ConfidenceLevel };
+export type SupportedLanguage = 'typescript' | 'javascript' | 'java' | 'kotlin' | 'python' | 'ruby' | 'cucumber' | 'auto';
+export type AssertionType = 'status-code' | 'body-field' | 'fluent-chain' | 'exception-catch' | 'none';
+export interface BusinessRuleRef {
+    ruleId: string;
+    source: 'annotation' | 'decorator' | 'comment' | 'tag';
+    line?: number;
+}
+export interface FlowRef {
+    flowId: string;
+    source: 'tag' | 'comment' | 'annotation';
+    line?: number;
+}
+export interface SemanticSymbol {
+    name: string;
+    kind: 'const' | 'let' | 'var' | 'parameter' | 'field' | 'enum-member';
+    /** Value as written in source (may reference another symbol) */
+    value?: string;
+    /** Value after constant propagation */
+    resolvedValue?: string;
+    line?: number;
+}
+export interface SemanticHttpCall {
+    method: string;
+    /** Path argument as written in source — may be a variable name */
+    rawPathArg: string;
+    /** After constant/template resolution */
+    resolvedPath?: string;
+    /** After normalization to OpenAPI template form */
+    normalizedPath?: string;
+    resolutionType: ResolutionType;
+    confidence: ConfidenceLevel;
+    /** Variable name the response is assigned to, for assertion linking */
+    responseVariable?: string;
+    line?: number;
+}
+export interface SemanticAssertion {
+    assertionType: AssertionType;
+    /** Subject variable e.g. "response" in expect(response) */
+    subjectVariable?: string;
+    line?: number;
+}
+export interface SemanticFunction {
+    name: string;
+    parameters: string[];
+    bodyHttpCalls: SemanticHttpCall[];
+    calledFunctions: string[];
+    returnValue?: string;
+    /** Java/Python/TS/Kotlin decorator or annotation names */
+    annotations?: string[];
+    /** For Cucumber step definitions — the Gherkin pattern string */
+    cucumberPattern?: string;
+}
+export interface ParsedSourceFile {
+    filePath: string;
+    language: SupportedLanguage;
+    /** Raw AST node from the parser — shape differs per backend */
+    ast: any;
+    content: string;
+    parseError?: Error;
+}
+export interface SemanticModel {
+    filePath: string;
+    language: SupportedLanguage;
+    /** Per-file constants and variables keyed by their identifier name */
+    localVariables: Map<string, SemanticSymbol>;
+    constants: Map<string, SemanticSymbol>;
+    /** enumName → (memberName → value) */
+    enums: Map<string, Map<string, string>>;
+    /** functionName → definition */
+    functions: Map<string, SemanticFunction>;
+    /** HTTP interactions found directly in the file body (outside functions) */
+    httpInteractions: SemanticHttpCall[];
+    assertions: SemanticAssertion[];
+    businessRuleRefs: BusinessRuleRef[];
+    flowRefs: FlowRef[];
+}
+export interface ResolvedHttpInteraction extends ResolvedHttpCall {
+    assertionType?: AssertionType;
+    businessRuleRefs?: BusinessRuleRef[];
+    flowRefs?: FlowRef[];
+    /** Semantic parameter-test scenarios detected from builder patterns, etc. */
+    parameterScenarios?: string[];
+    /** Feature file path when resolutionType is 'cucumber-step' */
+    cucumberFeatureFile?: string;
+    /** Scenario name when resolutionType is 'cucumber-step' */
+    cucumberScenario?: string;
+    /** Response variable name for assertion linking (internal — not serialized to reports) */
+    responseVariable?: string;
+}
+export interface AnalysisContext {
+    deepConfig: DeepAnalysisConfig;
+    astConfig: AstAnalysisConfig;
+    projectRoot?: string;
+}
+//# sourceMappingURL=astTypes.d.ts.map

package/dist/src/ast/astTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astTypes.d.ts","sourceRoot":"","sources":["../../../src/ast/astTypes.ts"],"names":[],"mappings":"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"}

package/dist/src/ast/astTypes.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * AST-layer canonical types.
+ *
+ * These types define the normalized representation produced by language-specific
+ * parsers and consumed by the coverage engine. They are a strict superset of the
+ * deep-analysis layer types so all existing consumers continue to work unmodified.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/ast/languageAnalyzer.d.ts

@@ -0,0 +1,46 @@
+/**
+ * LanguageAnalyzer contract.
+ *
+ * Every supported language must implement this interface, either directly or
+ * through layered composition. The interface is intentionally minimal — each
+ * method is pure (no side effects) and returns well-typed data.
+ */
+import type { SupportedLanguage, ParsedSourceFile, SemanticModel, ResolvedHttpInteraction, SemanticAssertion, BusinessRuleRef, FlowRef, AnalysisContext } from './astTypes';
+export interface LanguageAnalyzer {
+    readonly language: SupportedLanguage;
+    /**
+     * Parse a source file to a raw AST.
+     *
+     * Must never throw. Returns a `ParsedSourceFile` with `parseError` set if
+     * parsing fails — the orchestrator will fall back to regex analysis.
+     */
+    parse(filePath: string, content: string): ParsedSourceFile;
+    /**
+     * Walk the AST and produce a rich semantic model: symbols, call graph,
+     * enum values, HTTP call sites, assertion nodes.
+     */
+    buildSemanticModel(parsed: ParsedSourceFile, context: AnalysisContext): SemanticModel;
+    /**
+     * Extract fully-resolved HTTP interactions from the semantic model.
+     * Resolution includes constant propagation, wrapper tracing, and template
+     * literal expansion up to `context.astConfig.maxCallDepth` levels.
+     */
+    extractHttpInteractions(model: SemanticModel, context: AnalysisContext): ResolvedHttpInteraction[];
+    /**
+     * Extract assertion nodes from the semantic model.
+     * Used by the orchestrator to link assertions to HTTP interactions by
+     * matching `assertion.subjectVariable` against `interaction.responseVariable`.
+     */
+    extractAssertions(model: SemanticModel): SemanticAssertion[];
+    /**
+     * Extract business rule references from annotations, decorators, tags,
+     * or structured comments. Optional — only implement if the language supports it.
+     */
+    extractBusinessRuleRefs?(model: SemanticModel): BusinessRuleRef[];
+    /**
+     * Extract integration flow references from annotations, tags, or comments.
+     * Optional — only implement if the language supports it.
+     */
+    extractFlowRefs?(model: SemanticModel): FlowRef[];
+}
+//# sourceMappingURL=languageAnalyzer.d.ts.map

package/dist/src/ast/languageAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languageAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/ast/languageAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,uBAAuB,EACvB,iBAAiB,EACjB,eAAe,EACf,OAAO,EACP,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IAErC;;;;;OAKG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAAC;IAE3D;;;OAGG;IACH,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,EAAE,OAAO,EAAE,eAAe,GAAG,aAAa,CAAC;IAEtF;;;;OAIG;IACH,uBAAuB,CACrB,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,eAAe,GACvB,uBAAuB,EAAE,CAAC;IAE7B;;;;OAIG;IACH,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,iBAAiB,EAAE,CAAC;IAE7D;;;OAGG;IACH,uBAAuB,CAAC,CAAC,KAAK,EAAE,aAAa,GAAG,eAAe,EAAE,CAAC;IAElE;;;OAGG;IACH,eAAe,CAAC,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,EAAE,CAAC;CACnD"}

package/dist/src/ast/languageAnalyzer.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * LanguageAnalyzer contract.
+ *
+ * Every supported language must implement this interface, either directly or
+ * through layered composition. The interface is intentionally minimal — each
+ * method is pure (no side effects) and returns well-typed data.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/ast/languageCapabilities.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AST-layer language capability registry.
+ *
+ * Describes what each language analyzer can do and which parser backend it uses.
+ * Used by the orchestrator to decide whether to attempt AST analysis for a given
+ * language and whether to expect assertion linking, enum resolution, etc.
+ */
+import type { SupportedLanguage } from './astTypes';
+export type ParserBackend = 'typescript-estree' | 'tree-sitter' | 'regex-fallback';
+export interface LanguageCapabilities {
+    language: SupportedLanguage;
+    parserBackend: ParserBackend;
+    supportsSymbolResolution: boolean;
+    supportsCallGraph: boolean;
+    supportsEnumResolution: boolean;
+    supportsStringInterpolation: boolean;
+    supportsAssertionLinking: boolean;
+    supportsRequestBuilders: boolean;
+    supportsCucumber: boolean;
+    /** Which step-definition languages this analyzer can trace (Cucumber only) */
+    cucumberStepLanguages?: SupportedLanguage[];
+}
+export declare const LANGUAGE_CAPABILITIES: Record<string, LanguageCapabilities>;
+//# sourceMappingURL=languageCapabilities.d.ts.map

package/dist/src/ast/languageCapabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languageCapabilities.d.ts","sourceRoot":"","sources":["../../../src/ast/languageCapabilities.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,MAAM,aAAa,GAAG,mBAAmB,GAAG,aAAa,GAAG,gBAAgB,CAAC;AAEnF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,aAAa,EAAE,aAAa,CAAC;IAC7B,wBAAwB,EAAE,OAAO,CAAC;IAClC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,sBAAsB,EAAE,OAAO,CAAC;IAChC,2BAA2B,EAAE,OAAO,CAAC;IACrC,wBAAwB,EAAE,OAAO,CAAC;IAClC,uBAAuB,EAAE,OAAO,CAAC;IACjC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,8EAA8E;IAC9E,qBAAqB,CAAC,EAAE,iBAAiB,EAAE,CAAC;CAC7C;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAiFtE,CAAC"}

package/dist/src/ast/languageCapabilities.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * AST-layer language capability registry.
+ *
+ * Describes what each language analyzer can do and which parser backend it uses.
+ * Used by the orchestrator to decide whether to attempt AST analysis for a given
+ * language and whether to expect assertion linking, enum resolution, etc.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LANGUAGE_CAPABILITIES = void 0;
+exports.LANGUAGE_CAPABILITIES = {
+    typescript: {
+        language: 'typescript',
+        parserBackend: 'typescript-estree',
+        supportsSymbolResolution: true,
+        supportsCallGraph: true,
+        supportsEnumResolution: true,
+        supportsStringInterpolation: true,
+        supportsAssertionLinking: true,
+        supportsRequestBuilders: true,
+        supportsCucumber: false,
+    },
+    javascript: {
+        language: 'javascript',
+        parserBackend: 'typescript-estree',
+        supportsSymbolResolution: true,
+        supportsCallGraph: true,
+        supportsEnumResolution: false,
+        supportsStringInterpolation: true,
+        supportsAssertionLinking: true,
+        supportsRequestBuilders: true,
+        supportsCucumber: false,
+    },
+    java: {
+        language: 'java',
+        parserBackend: 'tree-sitter',
+        supportsSymbolResolution: true,
+        supportsCallGraph: true,
+        supportsEnumResolution: true,
+        supportsStringInterpolation: false,
+        supportsAssertionLinking: true,
+        supportsRequestBuilders: true,
+        supportsCucumber: true,
+        cucumberStepLanguages: ['java'],
+    },
+    kotlin: {
+        language: 'kotlin',
+        parserBackend: 'tree-sitter',
+        supportsSymbolResolution: true,
+        supportsCallGraph: true,
+        supportsEnumResolution: true,
+        supportsStringInterpolation: true,
+        supportsAssertionLinking: true,
+        supportsRequestBuilders: true,
+        supportsCucumber: true,
+        cucumberStepLanguages: ['kotlin'],
+    },
+    python: {
+        language: 'python',
+        parserBackend: 'tree-sitter',
+        supportsSymbolResolution: true,
+        supportsCallGraph: true,
+        supportsEnumResolution: true,
+        supportsStringInterpolation: true,
+        supportsAssertionLinking: true,
+        supportsRequestBuilders: false,
+        supportsCucumber: false,
+    },
+    ruby: {
+        language: 'ruby',
+        parserBackend: 'tree-sitter',
+        supportsSymbolResolution: true,
+        supportsCallGraph: true,
+        supportsEnumResolution: false,
+        supportsStringInterpolation: true,
+        supportsAssertionLinking: true,
+        supportsRequestBuilders: false,
+        supportsCucumber: true,
+        cucumberStepLanguages: ['ruby'],
+    },
+    cucumber: {
+        language: 'cucumber',
+        parserBackend: 'regex-fallback',
+        supportsSymbolResolution: false,
+        supportsCallGraph: false,
+        supportsEnumResolution: false,
+        supportsStringInterpolation: false,
+        supportsAssertionLinking: false,
+        supportsRequestBuilders: false,
+        supportsCucumber: true,
+    },
+};

package/dist/src/ast/parseFile.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Per-file AST analysis entry point.
+ *
+ * Attempts to parse and analyze a single source file using the registered
+ * LanguageAnalyzer for its language. Links assertions to HTTP interactions.
+ * Returns null when no analyzer is available or when parsing fails — the
+ * caller (astAnalysisOrchestrator) then falls back to regex analysis.
+ */
+import type { SupportedLanguage, ResolvedHttpInteraction, AnalysisContext } from './astTypes';
+/**
+ * Parse and semantically analyze a single source file using the AST layer.
+ *
+ * @returns `ResolvedHttpInteraction[]` on success, `null` to signal fallback.
+ */
+export declare function analyzeFileWithAst(filePath: string, content: string, language: SupportedLanguage, context: AnalysisContext): ResolvedHttpInteraction[] | null;
+//# sourceMappingURL=parseFile.d.ts.map

package/dist/src/ast/parseFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseFile.d.ts","sourceRoot":"","sources":["../../../src/ast/parseFile.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE9F;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,eAAe,GACvB,uBAAuB,EAAE,GAAG,IAAI,CAoDlC"}