api-tests-coverage 1.0.0

package/dist/src/languages/python/index.js

@@ -0,0 +1,293 @@
+"use strict";
+/**
+ * Python language analyzer using tree-sitter-python.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythonAnalyzer = void 0;
+const parserRegistry_1 = require("../../ast/parserRegistry");
+const treeSitterUtils_1 = require("../shared/treeSitterUtils");
+const resolvePaths_1 = require("../../coverage/deep-analysis/resolvePaths");
+// ─── Parser ───────────────────────────────────────────────────────────────────
+let cachedParser = undefined;
+let parserLoaded = false;
+function getPythonParser() {
+    if (!parserLoaded) {
+        parserLoaded = true;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const grammar = require('tree-sitter-python');
+            cachedParser = (0, treeSitterUtils_1.createParser)(grammar);
+        }
+        catch {
+            cachedParser = null;
+        }
+    }
+    return cachedParser;
+}
+// ─── Analyzer ─────────────────────────────────────────────────────────────────
+class PythonAnalyzer {
+    constructor() {
+        this.language = 'python';
+    }
+    parse(filePath, content) {
+        const parser = getPythonParser();
+        if (!parser) {
+            return { filePath, language: 'python', ast: null, content, parseError: new Error('tree-sitter-python not available') };
+        }
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const tree = parser.parse(content);
+            return { filePath, language: 'python', ast: tree, content };
+        }
+        catch (err) {
+            return { filePath, language: 'python', ast: null, content, parseError: err instanceof Error ? err : new Error(String(err)) };
+        }
+    }
+    buildSemanticModel(parsed, _context) {
+        var _a, _b;
+        const root = (_b = (_a = parsed.ast) === null || _a === void 0 ? void 0 : _a.rootNode) !== null && _b !== void 0 ? _b : parsed.ast;
+        if (!root)
+            return emptyModel(parsed.filePath);
+        const constants = extractPythonConstants(root);
+        const functions = extractPythonFunctions(root, constants);
+        const assertions = extractPythonAssertions(root);
+        const businessRuleRefs = extractPythonBusinessRefs(root);
+        return {
+            filePath: parsed.filePath,
+            language: 'python',
+            localVariables: new Map(),
+            constants,
+            enums: new Map(),
+            functions,
+            httpInteractions: [],
+            assertions,
+            businessRuleRefs,
+            flowRefs: [],
+        };
+    }
+    extractHttpInteractions(model, _ctx) {
+        var _a;
+        const results = [];
+        const seen = new Set();
+        for (const fn of model.functions.values()) {
+            for (const c of fn.bodyHttpCalls) {
+                const path = (_a = c.resolvedPath) !== null && _a !== void 0 ? _a : c.rawPathArg;
+                if (!path)
+                    continue;
+                const key = `${c.method}:${path}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                results.push({
+                    method: c.method,
+                    path,
+                    normalizedPath: path.startsWith('/') ? (0, resolvePaths_1.normalizePathToTemplate)(path) : undefined,
+                    sourceFile: model.filePath,
+                    sourceLanguage: 'python',
+                    resolutionType: c.resolutionType,
+                    confidence: c.confidence,
+                });
+            }
+        }
+        return results;
+    }
+    extractAssertions(model) {
+        return model.assertions;
+    }
+    extractBusinessRuleRefs(model) {
+        return model.businessRuleRefs;
+    }
+    extractFlowRefs(_model) {
+        return [];
+    }
+}
+exports.PythonAnalyzer = PythonAnalyzer;
+// ─── Symbol extraction ────────────────────────────────────────────────────────
+function extractPythonConstants(root) {
+    var _a, _b, _c, _d;
+    const map = new Map();
+    // Module-level assignments: USERS = '/users' or USERS: str = '/users'
+    const assignments = (0, treeSitterUtils_1.findNodes)(root, ['assignment', 'augmented_assignment']);
+    for (const assign of assignments) {
+        const nameNode = (_b = (_a = assign.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(assign, 'left')) !== null && _b !== void 0 ? _b : (0, treeSitterUtils_1.firstChildOfType)(assign, 'identifier');
+        if (!nameNode)
+            continue;
+        const name = (_c = nameNode.text) !== null && _c !== void 0 ? _c : '';
+        // Only module-level UPPER_CASE constants
+        if (name === name.toUpperCase() && name.length > 1) {
+            const valueNode = (_d = assign.childForFieldName) === null || _d === void 0 ? void 0 : _d.call(assign, 'right');
+            const strValue = extractPythonString(valueNode);
+            if (strValue !== undefined) {
+                map.set(name, { name, kind: 'const', value: strValue, resolvedValue: strValue });
+            }
+        }
+    }
+    return map;
+}
+function extractPythonFunctions(root, constants) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const graph = new Map();
+    const fnDefs = (0, treeSitterUtils_1.findNodes)(root, ['function_definition']);
+    for (const fn of fnDefs) {
+        const nameNode = (_b = (_a = fn.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(fn, 'name')) !== null && _b !== void 0 ? _b : (0, treeSitterUtils_1.firstChildOfType)(fn, 'identifier');
+        const name = (_c = nameNode === null || nameNode === void 0 ? void 0 : nameNode.text) !== null && _c !== void 0 ? _c : '';
+        if (!name)
+            continue;
+        const decorators = extractPythonDecorators(fn);
+        const body = (_e = (_d = fn.childForFieldName) === null || _d === void 0 ? void 0 : _d.call(fn, 'body')) !== null && _e !== void 0 ? _e : (0, treeSitterUtils_1.firstChildOfType)(fn, 'block');
+        const bodyHttpCalls = [];
+        const calledFunctions = [];
+        if (body) {
+            extractPythonHttpCalls(body, constants, bodyHttpCalls);
+            extractPythonCalls(body, calledFunctions);
+        }
+        graph.set(name, {
+            name,
+            parameters: [],
+            bodyHttpCalls,
+            calledFunctions,
+            annotations: decorators,
+        });
+    }
+    // Also check class methods
+    const classDefs = (0, treeSitterUtils_1.findNodes)(root, ['class_definition']);
+    for (const cls of classDefs) {
+        const clsBody = (_g = (_f = cls.childForFieldName) === null || _f === void 0 ? void 0 : _f.call(cls, 'body')) !== null && _g !== void 0 ? _g : (0, treeSitterUtils_1.firstChildOfType)(cls, 'block');
+        if (!clsBody)
+            continue;
+        const methods = (0, treeSitterUtils_1.findNodes)(clsBody, ['function_definition']);
+        for (const method of methods) {
+            const nameNode = (_j = (_h = method.childForFieldName) === null || _h === void 0 ? void 0 : _h.call(method, 'name')) !== null && _j !== void 0 ? _j : (0, treeSitterUtils_1.firstChildOfType)(method, 'identifier');
+            const name = (_k = nameNode === null || nameNode === void 0 ? void 0 : nameNode.text) !== null && _k !== void 0 ? _k : '';
+            if (!name || name === '__init__')
+                continue;
+            const methodBody = (_m = (_l = method.childForFieldName) === null || _l === void 0 ? void 0 : _l.call(method, 'body')) !== null && _m !== void 0 ? _m : (0, treeSitterUtils_1.firstChildOfType)(method, 'block');
+            const bodyHttpCalls = [];
+            if (methodBody)
+                extractPythonHttpCalls(methodBody, constants, bodyHttpCalls);
+            graph.set(name, { name, parameters: [], bodyHttpCalls, calledFunctions: [] });
+        }
+    }
+    return graph;
+}
+function extractPythonHttpCalls(body, constants, out) {
+    var _a, _b, _c, _d, _e, _f;
+    // requests.get(url), httpx.post(url), self.client.get(url), client.get(url)
+    const calls = (0, treeSitterUtils_1.findNodes)(body, ['call']);
+    for (const call of calls) {
+        const funcNode = (_b = (_a = call.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(call, 'function')) !== null && _b !== void 0 ? _b : (0, treeSitterUtils_1.firstChildOfType)(call, 'attribute');
+        if (!funcNode)
+            continue;
+        const funcText = (_c = funcNode.text) !== null && _c !== void 0 ? _c : '';
+        const match = funcText.match(/(?:requests|httpx|self\.client|client|self\.app|app)\.(get|post|put|patch|delete|head|options)/i);
+        if (!match)
+            continue;
+        const [, methodName] = match;
+        const argList = (_e = (_d = call.childForFieldName) === null || _d === void 0 ? void 0 : _d.call(call, 'arguments')) !== null && _e !== void 0 ? _e : (0, treeSitterUtils_1.firstChildOfType)(call, 'argument_list');
+        if (!argList)
+            continue;
+        const pathArg = (_f = (0, treeSitterUtils_1.firstChildOfType)(argList, 'string')) !== null && _f !== void 0 ? _f : (0, treeSitterUtils_1.firstChildOfType)(argList, 'concatenated_string');
+        if (!pathArg)
+            continue;
+        const rawPath = extractPythonString(pathArg);
+        if (!rawPath)
+            continue;
+        // Resolve f-string variables against constants
+        const resolvedPath = rawPath.includes('{') ? resolveFString(rawPath, constants) : rawPath;
+        out.push({
+            method: methodName.toUpperCase(),
+            rawPathArg: rawPath,
+            resolvedPath,
+            normalizedPath: resolvedPath.startsWith('/') ? (0, resolvePaths_1.normalizePathToTemplate)(resolvedPath) : undefined,
+            resolutionType: rawPath === resolvedPath ? 'direct' : 'interpolated-path',
+            confidence: rawPath === resolvedPath ? 'high' : 'medium',
+        });
+    }
+}
+function extractPythonAssertions(root) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const assertions = [];
+    const assertStmts = (0, treeSitterUtils_1.findNodes)(root, ['assert_statement']);
+    for (const stmt of assertStmts) {
+        const text = (_a = stmt.text) !== null && _a !== void 0 ? _a : '';
+        const type = text.includes('status_code') || text.includes('status') ? 'status-code' : 'body-field';
+        const varMatch = text.match(/assert\s+(\w+)\./);
+        assertions.push({ assertionType: type, subjectVariable: varMatch === null || varMatch === void 0 ? void 0 : varMatch[1] });
+    }
+    // self.assertEqual(response.status_code, 200)
+    const calls = (0, treeSitterUtils_1.findNodes)(root, ['call']);
+    for (const call of calls) {
+        const funcText = (_d = (_c = (_b = call.childForFieldName) === null || _b === void 0 ? void 0 : _b.call(call, 'function')) === null || _c === void 0 ? void 0 : _c.text) !== null && _d !== void 0 ? _d : '';
+        if (funcText.includes('assertEqual') || funcText.includes('assertStatus')) {
+            const argText = (_g = (_f = (_e = call.childForFieldName) === null || _e === void 0 ? void 0 : _e.call(call, 'arguments')) === null || _f === void 0 ? void 0 : _f.text) !== null && _g !== void 0 ? _g : '';
+            const varMatch = argText.match(/(\w+)\.status/);
+            assertions.push({
+                assertionType: 'status-code',
+                subjectVariable: varMatch === null || varMatch === void 0 ? void 0 : varMatch[1],
+            });
+        }
+    }
+    return assertions;
+}
+function extractPythonBusinessRefs(root) {
+    var _a;
+    const refs = [];
+    const decorators = (0, treeSitterUtils_1.findNodes)(root, ['decorator']);
+    for (const dec of decorators) {
+        const text = (_a = dec.text) !== null && _a !== void 0 ? _a : '';
+        const match = text.match(/@(?:pytest\.mark\.|mark\.)?(?:businessRule|business_rule)\s*\(\s*["']([^"']+)/);
+        if (match)
+            refs.push({ ruleId: match[1], source: 'decorator' });
+    }
+    return refs;
+}
+function extractPythonDecorators(fn) {
+    var _a, _b;
+    const decorators = [];
+    for (let i = 0; i < ((_a = fn === null || fn === void 0 ? void 0 : fn.childCount) !== null && _a !== void 0 ? _a : 0); i++) {
+        const child = fn.child(i);
+        if ((child === null || child === void 0 ? void 0 : child.type) === 'decorator')
+            decorators.push((_b = child.text) !== null && _b !== void 0 ? _b : '');
+    }
+    return decorators;
+}
+function extractPythonCalls(body, out) {
+    var _a, _b, _c;
+    const calls = (0, treeSitterUtils_1.findNodes)(body, ['call']);
+    for (const call of calls) {
+        const func = (_c = (_b = (_a = call.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(call, 'function')) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : '';
+        if (func && !out.includes(func))
+            out.push(func);
+    }
+}
+function extractPythonString(node) {
+    var _a;
+    if (!node)
+        return undefined;
+    const raw = (_a = node.text) !== null && _a !== void 0 ? _a : '';
+    if ((raw.startsWith('"') || raw.startsWith("'") || raw.startsWith('f"') || raw.startsWith("f'"))) {
+        return raw.replace(/^f?["']|["']$/g, '');
+    }
+    return undefined;
+}
+function resolveFString(template, constants) {
+    return template.replace(/\{(\w+)\}/g, (_match, name) => {
+        var _a, _b;
+        return (_b = (_a = constants.get(name)) === null || _a === void 0 ? void 0 : _a.resolvedValue) !== null && _b !== void 0 ? _b : `{${name}}`;
+    });
+}
+function emptyModel(filePath) {
+    return {
+        filePath,
+        language: 'python',
+        localVariables: new Map(),
+        constants: new Map(),
+        enums: new Map(),
+        functions: new Map(),
+        httpInteractions: [],
+        assertions: [],
+        businessRuleRefs: [],
+        flowRefs: [],
+    };
+}
+(0, parserRegistry_1.registerAnalyzer)('python', () => new PythonAnalyzer());

package/dist/src/languages/ruby/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Ruby language analyzer using tree-sitter-ruby.
+ */
+import type { LanguageAnalyzer } from '../../ast/languageAnalyzer';
+import type { SupportedLanguage, ParsedSourceFile, SemanticModel, ResolvedHttpInteraction, SemanticAssertion, BusinessRuleRef, FlowRef, AnalysisContext } from '../../ast/astTypes';
+export declare class RubyAnalyzer implements LanguageAnalyzer {
+    readonly language: SupportedLanguage;
+    parse(filePath: string, content: string): ParsedSourceFile;
+    buildSemanticModel(parsed: ParsedSourceFile, _context: AnalysisContext): SemanticModel;
+    extractHttpInteractions(model: SemanticModel, _ctx: AnalysisContext): ResolvedHttpInteraction[];
+    extractAssertions(model: SemanticModel): SemanticAssertion[];
+    extractBusinessRuleRefs(_model: SemanticModel): BusinessRuleRef[];
+    extractFlowRefs(_model: SemanticModel): FlowRef[];
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/languages/ruby/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/languages/ruby/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EAIb,uBAAuB,EACvB,iBAAiB,EACjB,eAAe,EACf,OAAO,EACP,eAAe,EAChB,MAAM,oBAAoB,CAAC;AA8B5B,qBAAa,YAAa,YAAW,gBAAgB;IACnD,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAU;IAE9C,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB;IAc1D,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,EAAE,QAAQ,EAAE,eAAe,GAAG,aAAa;IAsBtF,uBAAuB,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,eAAe,GAAG,uBAAuB,EAAE;IAyB/F,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,iBAAiB,EAAE;IAG5D,uBAAuB,CAAC,MAAM,EAAE,aAAa,GAAG,eAAe,EAAE;IAGjE,eAAe,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,EAAE;CAGlD"}

package/dist/src/languages/ruby/index.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * Ruby language analyzer using tree-sitter-ruby.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RubyAnalyzer = void 0;
+const parserRegistry_1 = require("../../ast/parserRegistry");
+const treeSitterUtils_1 = require("../shared/treeSitterUtils");
+const resolvePaths_1 = require("../../coverage/deep-analysis/resolvePaths");
+// ─── Parser ───────────────────────────────────────────────────────────────────
+let cachedParser = undefined;
+let parserLoaded = false;
+function getRubyParser() {
+    if (!parserLoaded) {
+        parserLoaded = true;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const grammar = require('tree-sitter-ruby');
+            cachedParser = (0, treeSitterUtils_1.createParser)(grammar);
+        }
+        catch {
+            cachedParser = null;
+        }
+    }
+    return cachedParser;
+}
+// ─── Analyzer ─────────────────────────────────────────────────────────────────
+class RubyAnalyzer {
+    constructor() {
+        this.language = 'ruby';
+    }
+    parse(filePath, content) {
+        const parser = getRubyParser();
+        if (!parser) {
+            return { filePath, language: 'ruby', ast: null, content, parseError: new Error('tree-sitter-ruby not available') };
+        }
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const tree = parser.parse(content);
+            return { filePath, language: 'ruby', ast: tree, content };
+        }
+        catch (err) {
+            return { filePath, language: 'ruby', ast: null, content, parseError: err instanceof Error ? err : new Error(String(err)) };
+        }
+    }
+    buildSemanticModel(parsed, _context) {
+        var _a, _b;
+        const root = (_b = (_a = parsed.ast) === null || _a === void 0 ? void 0 : _a.rootNode) !== null && _b !== void 0 ? _b : parsed.ast;
+        if (!root)
+            return emptyModel(parsed.filePath);
+        const constants = extractRubyConstants(root);
+        const functions = extractRubyFunctions(root, constants);
+        const assertions = extractRubyAssertions(root);
+        return {
+            filePath: parsed.filePath,
+            language: 'ruby',
+            localVariables: new Map(),
+            constants,
+            enums: new Map(),
+            functions,
+            httpInteractions: [],
+            assertions,
+            businessRuleRefs: [],
+            flowRefs: [],
+        };
+    }
+    extractHttpInteractions(model, _ctx) {
+        var _a;
+        const results = [];
+        const seen = new Set();
+        for (const fn of model.functions.values()) {
+            for (const c of fn.bodyHttpCalls) {
+                const path = (_a = c.resolvedPath) !== null && _a !== void 0 ? _a : c.rawPathArg;
+                if (!path)
+                    continue;
+                const key = `${c.method}:${path}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                results.push({
+                    method: c.method,
+                    path,
+                    normalizedPath: path.startsWith('/') ? (0, resolvePaths_1.normalizePathToTemplate)(path) : undefined,
+                    sourceFile: model.filePath,
+                    sourceLanguage: 'ruby',
+                    resolutionType: fn.cucumberPattern ? 'cucumber-step' : c.resolutionType,
+                    confidence: c.confidence,
+                });
+            }
+        }
+        return results;
+    }
+    extractAssertions(model) {
+        return model.assertions;
+    }
+    extractBusinessRuleRefs(_model) {
+        return [];
+    }
+    extractFlowRefs(_model) {
+        return [];
+    }
+}
+exports.RubyAnalyzer = RubyAnalyzer;
+// ─── Symbol extraction ────────────────────────────────────────────────────────
+function extractRubyConstants(root) {
+    var _a, _b, _c, _d, _e, _f;
+    const map = new Map();
+    // Ruby constants: USERS = '/users'
+    const assigns = (0, treeSitterUtils_1.findNodes)(root, ['assignment']);
+    for (const assign of assigns) {
+        const left = (_b = (_a = assign.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(assign, 'left')) !== null && _b !== void 0 ? _b : (0, treeSitterUtils_1.firstChildOfType)(assign, 'constant');
+        const right = (_c = assign.childForFieldName) === null || _c === void 0 ? void 0 : _c.call(assign, 'right');
+        if (!left || !right)
+            continue;
+        const name = (_d = left.text) !== null && _d !== void 0 ? _d : '';
+        if (!name || name !== name.toUpperCase())
+            continue;
+        const value = (_e = (0, treeSitterUtils_1.extractStringValue)(right)) !== null && _e !== void 0 ? _e : (_f = right.text) === null || _f === void 0 ? void 0 : _f.replace(/^["']|["']$/g, '');
+        if (value) {
+            map.set(name, { name, kind: 'const', value, resolvedValue: value });
+        }
+    }
+    return map;
+}
+function extractRubyFunctions(root, constants) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const graph = new Map();
+    // Regular method definitions: def method_name; end
+    const methodDefs = (0, treeSitterUtils_1.findNodes)(root, ['method', 'singleton_method']);
+    for (const method of methodDefs) {
+        const nameNode = (_b = (_a = method.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(method, 'name')) !== null && _b !== void 0 ? _b : (0, treeSitterUtils_1.firstChildOfType)(method, 'identifier');
+        const name = (_c = nameNode === null || nameNode === void 0 ? void 0 : nameNode.text) !== null && _c !== void 0 ? _c : '';
+        if (!name)
+            continue;
+        const bodyHttpCalls = [];
+        extractRubyHttpCalls(method, constants, bodyHttpCalls);
+        graph.set(name, { name, parameters: [], bodyHttpCalls, calledFunctions: [] });
+    }
+    // RSpec blocks: it 'does something' do ... end
+    const calls = (0, treeSitterUtils_1.findNodes)(root, ['call']);
+    for (const call of calls) {
+        const methodName = (_f = (_e = (_d = call.childForFieldName) === null || _d === void 0 ? void 0 : _d.call(call, 'method')) === null || _e === void 0 ? void 0 : _e.text) !== null && _f !== void 0 ? _f : '';
+        const isCucumber = ['Given', 'When', 'Then', 'And', 'But'].includes(methodName);
+        const isRSpec = ['it', 'specify', 'example', 'before', 'after', 'context', 'describe', 'scenario'].includes(methodName);
+        if (!isCucumber && !isRSpec)
+            continue;
+        const blockNode = (_g = (0, treeSitterUtils_1.firstChildOfType)(call, 'do_block')) !== null && _g !== void 0 ? _g : (0, treeSitterUtils_1.firstChildOfType)(call, 'block');
+        if (!blockNode)
+            continue;
+        // Extract label for Cucumber (first string arg)
+        let blockName = methodName;
+        let cucumberPattern;
+        if (call.arguments) {
+            const firstArg = (_h = (0, treeSitterUtils_1.firstChildOfType)(call.arguments, 'string')) !== null && _h !== void 0 ? _h : (0, treeSitterUtils_1.firstChildOfType)(call.arguments, 'regex');
+            if (firstArg) {
+                const label = (_k = (_j = (0, treeSitterUtils_1.extractStringValue)(firstArg)) !== null && _j !== void 0 ? _j : firstArg.text) !== null && _k !== void 0 ? _k : '';
+                blockName = `${methodName}:${label}`;
+                if (isCucumber)
+                    cucumberPattern = label;
+            }
+        }
+        const bodyHttpCalls = [];
+        extractRubyHttpCalls(blockNode, constants, bodyHttpCalls);
+        graph.set(blockName, {
+            name: blockName,
+            parameters: [],
+            bodyHttpCalls,
+            calledFunctions: [],
+            cucumberPattern,
+        });
+    }
+    return graph;
+}
+function extractRubyHttpCalls(node, constants, out) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    const calls = (0, treeSitterUtils_1.findNodes)(node, ['call']);
+    for (const call of calls) {
+        const methodName = (_c = (_b = (_a = call.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(call, 'method')) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : '';
+        const lowerMethod = methodName.toLowerCase();
+        const HTTP_METHODS = new Set(['get', 'post', 'put', 'patch', 'delete', 'head', 'options']);
+        if (!HTTP_METHODS.has(lowerMethod))
+            continue;
+        // Get the args — first arg is path
+        const args = (_d = call.childForFieldName) === null || _d === void 0 ? void 0 : _d.call(call, 'arguments');
+        if (!args) {
+            // Rails style: just `get '/path'` with no explicit parentheses
+            // Try: call text is "get '/path'"
+            const callText = (_e = call.text) !== null && _e !== void 0 ? _e : '';
+            const railsMatch = callText.match(/^(?:get|post|put|patch|delete)\s+["'`]([^"'`]+)["'`]/);
+            if (railsMatch) {
+                const path = railsMatch[1];
+                out.push({
+                    method: lowerMethod.toUpperCase(),
+                    rawPathArg: path,
+                    resolvedPath: path,
+                    normalizedPath: path.startsWith('/') ? (0, resolvePaths_1.normalizePathToTemplate)(path) : undefined,
+                    resolutionType: 'direct',
+                    confidence: 'high',
+                });
+            }
+            continue;
+        }
+        const firstArg = (_g = (_f = (0, treeSitterUtils_1.firstChildOfType)(args, 'string')) !== null && _f !== void 0 ? _f : (0, treeSitterUtils_1.firstChildOfType)(args, 'simple_string')) !== null && _g !== void 0 ? _g : (0, treeSitterUtils_1.firstChildOfType)(args, 'constant');
+        if (!firstArg)
+            continue;
+        let rawPath = (_j = (_h = (0, treeSitterUtils_1.extractStringValue)(firstArg)) !== null && _h !== void 0 ? _h : firstArg.text) !== null && _j !== void 0 ? _j : '';
+        rawPath = rawPath.replace(/^["'`]|["'`]$/g, '');
+        // Resolve Ruby constants
+        if (firstArg.type === 'constant') {
+            const resolved = (_l = (_k = constants.get(rawPath)) === null || _k === void 0 ? void 0 : _k.resolvedValue) !== null && _l !== void 0 ? _l : rawPath;
+            out.push({
+                method: lowerMethod.toUpperCase(),
+                rawPathArg: rawPath,
+                resolvedPath: resolved,
+                normalizedPath: resolved.startsWith('/') ? (0, resolvePaths_1.normalizePathToTemplate)(resolved) : undefined,
+                resolutionType: rawPath === resolved ? 'direct' : 'constant',
+                confidence: rawPath === resolved ? 'high' : 'medium',
+            });
+            continue;
+        }
+        // Resolve Ruby string interpolation: "/users/#{user.id}"
+        const resolvedPath = resolveRubyInterpolation(rawPath, constants);
+        out.push({
+            method: lowerMethod.toUpperCase(),
+            rawPathArg: rawPath,
+            resolvedPath,
+            normalizedPath: resolvedPath.startsWith('/') ? (0, resolvePaths_1.normalizePathToTemplate)(resolvedPath) : undefined,
+            resolutionType: rawPath.includes('#{') ? 'interpolated-path' : 'direct',
+            confidence: 'high',
+        });
+    }
+}
+function extractRubyAssertions(root) {
+    var _a;
+    const assertions = [];
+    // expect(response.status).to eq(200) or expect(response.code).to eq('200')
+    const calls = (0, treeSitterUtils_1.findNodes)(root, ['call']);
+    for (const call of calls) {
+        const text = (_a = call.text) !== null && _a !== void 0 ? _a : '';
+        if (text.includes('expect(') && (text.includes('.status') || text.includes('.code'))) {
+            const varMatch = text.match(/expect\((\w+)\./);
+            assertions.push({
+                assertionType: 'status-code',
+                subjectVariable: varMatch === null || varMatch === void 0 ? void 0 : varMatch[1],
+            });
+        }
+        if (text.includes('should have_http_status') || text.includes('have_http_status')) {
+            assertions.push({ assertionType: 'status-code' });
+        }
+    }
+    return assertions;
+}
+function resolveRubyInterpolation(template, constants) {
+    return template.replace(/#\{([^}]+)\}/g, (_match, expr) => {
+        var _a, _b;
+        const trimmed = expr.trim();
+        return (_b = (_a = constants.get(trimmed)) === null || _a === void 0 ? void 0 : _a.resolvedValue) !== null && _b !== void 0 ? _b : `{${trimmed}}`;
+    });
+}
+function emptyModel(filePath) {
+    return {
+        filePath,
+        language: 'ruby',
+        localVariables: new Map(),
+        constants: new Map(),
+        enums: new Map(),
+        functions: new Map(),
+        httpInteractions: [],
+        assertions: [],
+        businessRuleRefs: [],
+        flowRefs: [],
+    };
+}
+(0, parserRegistry_1.registerAnalyzer)('ruby', () => new RubyAnalyzer());

package/dist/src/languages/shared/treeSitterUtils.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared tree-sitter utilities.
+ *
+ * Wraps the tree-sitter native module with lazy loading and graceful
+ * fallback. Every tree-sitter language module calls `createParser()` and
+ * treats a null return as "fall back to regex analysis".
+ */
+export type TsNode = any;
+export type TsTree = any;
+export type TsParser = any;
+/**
+ * Create a tree-sitter parser for the given language grammar.
+ *
+ * @param grammarModule The `require()`-resolved grammar object from tree-sitter-*
+ * @returns A configured Parser instance, or null if native loading fails.
+ */
+export declare function createParser(grammarModule: unknown): TsParser | null;
+/**
+ * Recursively walk a tree-sitter node tree, calling `visitor` on each node.
+ * Pass `nodeTypes` to filter — visitor is only called when node.type matches.
+ */
+export declare function walkTree(node: TsNode, visitor: (n: TsNode) => void, nodeTypes?: Set<string>): void;
+/**
+ * Collect all descendant nodes whose type is in `nodeTypes`.
+ */
+export declare function findNodes(root: TsNode, nodeTypes: string[]): TsNode[];
+/**
+ * Get the text of a named child field, or undefined.
+ */
+export declare function fieldText(node: TsNode, fieldName: string): string | undefined;
+/**
+ * Get the first child of a given type.
+ */
+export declare function firstChildOfType(node: TsNode, type: string): TsNode | undefined;
+/**
+ * Check if a node has a child of the given type.
+ */
+export declare function hasChildOfType(node: TsNode, type: string): boolean;
+/**
+ * Extract an unquoted string value from a string_literal / string node.
+ */
+export declare function extractStringValue(node: TsNode): string | undefined;
+//# sourceMappingURL=treeSitterUtils.d.ts.map

package/dist/src/languages/shared/treeSitterUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeSitterUtils.d.ts","sourceRoot":"","sources":["../../../../src/languages/shared/treeSitterUtils.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,MAAM,MAAM,MAAM,GAAG,GAAG,CAAC;AAEzB,MAAM,MAAM,MAAM,GAAG,GAAG,CAAC;AAEzB,MAAM,MAAM,QAAQ,GAAG,GAAG,CAAC;AAE3B;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,aAAa,EAAE,OAAO,GAAG,QAAQ,GAAG,IAAI,CAUpE;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,EAC5B,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACtB,IAAI,CAQN;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAKrE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG7E;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAM/E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAElE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAYnE"}