@taodigital/agents 0.0.0-stage → 1.2.1

package/dist/orchestrator.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwarmOrchestrator = exports.DualContextOrchestrator = void 0;
+const app_brain_1 = require("@taodigital/app-brain");
+const test_case_agent_js_1 = require("./test-case-agent.js");
+const llm_config_js_1 = require("./llm-config.js");
+const core_1 = require("@taodigital/core");
+const flow_agent_js_1 = require("./flow-agent.js");
+/**
+ * Dual-Context Orchestrator — routes test generation to the right agent.
+ *
+ * ROUTE 1: targetScreenId  → Pure CAG  → generateTestCases() (21-pass)
+ * ROUTE 2: targetFlowStart + targetFlowEnd → KAG BFS + CAG → generateFlowTestCases()
+ */
+class DualContextOrchestrator {
+    static async execute(req) {
+        if (req.targetScreenId) {
+            console.log(`[Orchestrator] CAG — screen: ${req.targetScreenId}`);
+            const [tenantCfg, fastCfg, dbGlobalRules] = await Promise.all([
+                (0, llm_config_js_1.getTaskAgentLLMConfig)(req.tenantId, 'testGeneration'),
+                (0, llm_config_js_1.getFastPassLLMConfig)(req.tenantId),
+                (0, core_1.getAgentPrompt)('test-case-global-rules'),
+            ]);
+            const globalRules = dbGlobalRules ?? test_case_agent_js_1.GLOBAL_RULES_FALLBACK;
+            return (0, llm_config_js_1.tryWithPlatformFallback)(tenantCfg, (cfg) => (0, test_case_agent_js_1.generateTestCases)({
+                tenantId: req.tenantId,
+                projectId: req.projectId,
+                screenId: req.targetScreenId,
+                jobId: req.jobId,
+                viewport: req.viewport,
+                suiteNameOverride: req.suiteNameOverride,
+                force: req.force,
+                mode: req.mode,
+                kinds: req.kinds,
+                llmCfg: cfg,
+                fastPassLlmCfg: fastCfg,
+                globalRules,
+            }));
+        }
+        if (req.targetFlowStartScreenId && req.targetFlowEndScreenId) {
+            console.log(`[Orchestrator] KAG+CAG — flow: ${req.targetFlowStartScreenId} → ${req.targetFlowEndScreenId}`);
+            const path = await app_brain_1.AppBrain.getScreenTransitionGraph(req.tenantId, req.projectId, req.targetFlowStartScreenId, req.targetFlowEndScreenId);
+            if (!path || path.length === 0) {
+                console.warn(`[Orchestrator] No KAG path found — falling back to CAG for start screen.`);
+                const [tenantCfg, fastCfg] = await Promise.all([
+                    (0, llm_config_js_1.getTaskAgentLLMConfig)(req.tenantId, 'testGeneration'),
+                    (0, llm_config_js_1.getFastPassLLMConfig)(req.tenantId),
+                ]);
+                return (0, llm_config_js_1.tryWithPlatformFallback)(tenantCfg, (cfg) => (0, test_case_agent_js_1.generateTestCases)({
+                    tenantId: req.tenantId,
+                    projectId: req.projectId,
+                    screenId: req.targetFlowStartScreenId,
+                    viewport: req.viewport,
+                    force: req.force,
+                    mode: req.mode,
+                    kinds: req.kinds,
+                    llmCfg: cfg,
+                    fastPassLlmCfg: fastCfg,
+                }));
+            }
+            console.log(`[Orchestrator] KAG path: ${path.length} hops`);
+            return (0, flow_agent_js_1.generateFlowTestCases)({
+                tenantId: req.tenantId,
+                projectId: req.projectId,
+                startScreenId: req.targetFlowStartScreenId,
+                endScreenId: req.targetFlowEndScreenId,
+                path,
+            });
+        }
+        throw new Error('[Orchestrator] Must provide targetScreenId OR (targetFlowStartScreenId AND targetFlowEndScreenId).');
+    }
+}
+exports.DualContextOrchestrator = DualContextOrchestrator;
+/**
+ * Swarm Orchestrator — runs multiple test-generation agents in parallel.
+ *
+ * Each agent reads shared skill files before generating (so they all share
+ * the same application knowledge). After all agents complete, COVERAGE_MATRIX
+ * skill file is updated with aggregated counts.
+ *
+ * Skill files act as the shared memory bus — any knowledge learned from
+ * artifacts (via learnFromArtifact) or from crawls (via skill-file-agent)
+ * is automatically available to every agent in the swarm.
+ */
+class SwarmOrchestrator {
+    static async execute(req) {
+        const { tenantId, projectId, screenIds, concurrency = parseInt(process.env.SWARM_CONCURRENCY_DEFAULT ?? '') || 8 } = req;
+        const result = { succeeded: [], failed: [], totalGenerated: 0 };
+        console.log(`[Swarm] Starting ${screenIds.length} agents (concurrency=${concurrency})`);
+        const tokenBudgetPerScreen = parseInt(process.env.AGENT_TOKEN_BUDGET_PER_SCREEN ?? '') || 50_000;
+        await (0, app_brain_1.enforceTokenBudget)(tenantId, screenIds.length * tokenBudgetPerScreen);
+        const [swarmLlmCfg, swarmFastCfg, dbGlobalRules] = await Promise.all([
+            (0, llm_config_js_1.getTaskAgentLLMConfig)(tenantId, 'testGeneration'),
+            (0, llm_config_js_1.getFastPassLLMConfig)(tenantId),
+            (0, core_1.getAgentPrompt)('test-case-global-rules'),
+        ]);
+        // Pre-fetch once — all agents in this swarm share the same prompt version.
+        const globalRules = dbGlobalRules ?? test_case_agent_js_1.GLOBAL_RULES_FALLBACK;
+        // Process in batches to respect concurrency limit
+        for (let i = 0; i < screenIds.length; i += concurrency) {
+            const batch = screenIds.slice(i, i + concurrency);
+            console.log(`[Swarm] Batch ${Math.floor(i / concurrency) + 1}: screens ${batch.join(', ')}`);
+            const outcomes = await Promise.allSettled(batch.map((screenId) => (0, test_case_agent_js_1.generateTestCases)({
+                tenantId,
+                projectId,
+                screenId,
+                jobId: req.jobId,
+                llmCfg: swarmLlmCfg,
+                fastPassLlmCfg: swarmFastCfg,
+                globalRules,
+            })));
+            for (let j = 0; j < batch.length; j++) {
+                const screenId = batch[j];
+                const outcome = outcomes[j];
+                if (outcome.status === 'fulfilled') {
+                    const generated = Array.isArray(outcome.value) ? outcome.value.length : 0;
+                    result.succeeded.push(screenId);
+                    result.totalGenerated += generated;
+                    console.log(`[Swarm] ✓ Screen ${screenId}: ${generated} test cases`);
+                }
+                else {
+                    result.failed.push({ screenId, error: String(outcome.reason?.message ?? outcome.reason) });
+                    console.error(`[Swarm] ✗ Screen ${screenId}:`, outcome.reason?.message);
+                }
+            }
+        }
+        console.log(`[Swarm] Done — ${result.succeeded.length} succeeded, ${result.failed.length} failed, ${result.totalGenerated} total TCs`);
+        return result;
+    }
+    /** Run swarm over ALL crawled screens in a project */
+    static async executeForProject(req) {
+        const graph = await app_brain_1.AppBrain.getCoverageGraph(req.tenantId, req.projectId);
+        const screenIds = (graph?.nodes ?? []).map((s) => s.id);
+        if (screenIds.length === 0) {
+            console.warn('[Swarm] No screens found — run a crawl first.');
+            return { succeeded: [], failed: [], totalGenerated: 0 };
+        }
+        return SwarmOrchestrator.execute({ ...req, screenIds });
+    }
+}
+exports.SwarmOrchestrator = SwarmOrchestrator;

package/dist/plan-agent.d.ts

@@ -0,0 +1,4 @@
+export declare function generateTestPlan(opts: {
+    tenantId: string;
+    projectId: string;
+}): Promise<string>;

package/dist/plan-agent.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTestPlan = generateTestPlan;
+const app_brain_1 = require("@taodigital/app-brain");
+const core_1 = require("@taodigital/core");
+const llm_js_1 = require("./llm.js");
+const llm_config_js_1 = require("./llm-config.js");
+const requirements_agent_js_1 = require("./requirements-agent.js");
+/**
+ * The Plan Agent — ISO/IEC/IEEE 29119-3 Edition.
+ *
+ * Generates an ISO/IEC/IEEE 29119-3 structured test plan in Markdown format.
+ * Key upgrades over the original IEEE-829 implementation:
+ *
+ *   1. Per-section RAG — each of the 6 plan sections retrieves its own top-k
+ *      knowledge chunks rather than a single fixed query (higher relevance per section).
+ *   2. Requirements-driven — loads project requirements and coverage gap analysis
+ *      so §3 has a Traceability column and §7 leads with unbuilt requirements.
+ *   3. Standard corrected — ISO/IEC/IEEE 29119-3:2021.
+ *   4. Cache invalidation awareness — stale plan hint surface in comments.
+ *   5. Honest reranker comment — LLM-based rerank, not a cross-encoder model.
+ */
+// ─── Per-section RAG query map ───────────────────────────────────────────────
+// Each section of the plan retrieves its own top-k skill-file chunks.
+// This raises relevance far more than a single fixed query ever could.
+const SECTION_QUERIES = {
+    scope: 'business domain user roles core journeys scope functional nonfunctional',
+    features: 'navigation map screens flows interaction patterns user journeys',
+    approach: 'tech stack framework api contracts locator strategy test automation tools',
+    criteria: 'coverage matrix error catalogue data model constraints pass fail threshold',
+    environment: 'tech stack browsers auth session test data strategy environments',
+    risk: 'error catalogue auth session security api contracts business rules risks',
+    suspension: 'blocker defect threshold build environment failure conditions resume criteria',
+};
+async function generateTestPlan(opts) {
+    const { tenantId, projectId } = opts;
+    // ── Parallel data fetch — project map + coverage + requirements + per-section RAG ──
+    const sectionEntries = Object.entries(SECTION_QUERIES);
+    const [projectMap, coverage, requirements, gapReport, ...sectionResults] = await Promise.all([
+        app_brain_1.AppBrain.getProjectMap(tenantId, projectId),
+        app_brain_1.AppBrain.getCoverageReport(tenantId, projectId),
+        app_brain_1.AppBrain.listRequirements(tenantId, projectId).catch(() => []),
+        (0, requirements_agent_js_1.generateCoverageGapReport)({ tenantId, projectId }).catch(() => null),
+        ...sectionEntries.map(([, query]) => app_brain_1.AppBrain.searchKnowledge(tenantId, projectId, query, 4, 1200).catch(() => [])),
+    ]);
+    if (!projectMap) {
+        throw new Error(`Project ${projectId} not found for tenant ${tenantId}.`);
+    }
+    // Build per-section knowledge map
+    const knowledgeBySec = {};
+    sectionEntries.forEach(([section], idx) => {
+        const chunks = sectionResults[idx];
+        knowledgeBySec[section] = chunks.length > 0
+            ? chunks.map(k => `#### ${k.label}\n${k.content}`).join('\n\n')
+            : '(no relevant skill files yet)';
+    });
+    const projectName = projectMap.name;
+    const now = new Date();
+    const yyyymm = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}`;
+    const planId = `TP-${yyyymm}-${projectName.replace(/\s+/g, '-').toUpperCase()}-v1.0`;
+    // Screen names only — never element data (causes 258k+ token overflow in prod)
+    const allScreens = projectMap.screens ?? [];
+    const screensSummary = allScreens.map((s) => `- ${s.name}`).join('\n') || '(none crawled yet)';
+    const flowsSummary = (projectMap.flows ?? []).map((f) => `- ${f.name}`).join('\n') || '(none mapped yet)';
+    // Requirements summary (compact: reqId, title, priority, status only to avoid overflow)
+    const reqList = requirements.slice(0, 40);
+    const requirementsSummary = reqList.length > 0
+        ? reqList.map((r) => `  ${r.reqId} [${r.priority}/${r.status}] ${r.title}`).join('\n')
+        : '(no requirements extracted yet — upload a PRD to enable traceability)';
+    // Coverage gap data for §7
+    const untestedReqs = coverage.untestedRequirements ?? gapReport?.untested?.map((id) => ({ reqId: id })) ?? [];
+    const unbuiltReqs = coverage.unbuiltRequirements ?? gapReport?.unbuilt?.map((id) => ({ reqId: id })) ?? [];
+    const topGaps = gapReport?.topGaps ?? coverage.gaps ?? [];
+    const SYSTEM_DEFAULT = [
+        'You are a senior QA architect writing a formal ISO/IEC/IEEE 29119-3 test plan in Markdown.',
+        'Reference ISO/IEC/IEEE 29119-3:2021 only.',
+        'The plan must be professional, concise, lightweight, and tailorable — avoid ceremony.',
+        'Use only the data provided. Do not invent screens, requirements, or metrics.',
+        'Every section must be present. Tables must be valid Markdown.',
+        'Deterministic language only — no hedging words (possibly, may, might, could, should probably).',
+    ].join(' ');
+    const system = await (0, core_1.getAgentPrompt)('test-plan', undefined, tenantId) ?? SYSTEM_DEFAULT;
+    const user = [
+        `Generate a full ISO/IEC/IEEE 29119-3 test plan for the project "${projectName}".`,
+        `Plan ID: ${planId}`,
+        `Standard: ISO/IEC/IEEE 29119-3:2021`,
+        '',
+        '## Project Screens',
+        `Total: ${allScreens.length}`,
+        screensSummary,
+        '',
+        '## Flows',
+        flowsSummary,
+        '',
+        '## Coverage Stats',
+        `- Screen coverage: ${coverage.coveragePercent}% (${coverage.screensWithTests}/${coverage.totalScreens} screens)`,
+        `- Total test cases: ${coverage.totalTestCases} (${coverage.approvedTestCases} approved, ${coverage.pendingReviewCases} pending)`,
+        `- Status: ${coverage.status}`,
+        ...((coverage.requirementsTotal ?? 0) > 0 ? [
+            `- Requirements coverage: ${coverage.requirementCoveragePercent}% (${coverage.requirementsCovered}/${coverage.requirementsTotal} requirements)`,
+            `- Risk-weighted coverage: ${coverage.riskWeightedCoverage}%`,
+        ] : []),
+        '',
+        '## Requirements (for traceability in §3 and risk assessment in §7)',
+        requirementsSummary,
+        ...(untestedReqs.length > 0 ? [
+            '',
+            `UNTESTED REQUIREMENTS (${untestedReqs.length}) — include in §3 as coverage debt:`,
+            untestedReqs.slice(0, 10).map((r) => `  ${r.reqId} ${r.title ?? ''} [${r.priority ?? ''}]`).join('\n'),
+        ] : []),
+        ...(unbuiltReqs.length > 0 ? [
+            '',
+            `UNBUILT REQUIREMENTS (${unbuiltReqs.length}) — lead §7 Risk Areas with these:`,
+            unbuiltReqs.slice(0, 10).map((r) => `  ${r.reqId} ${r.title ?? ''} [${r.priority ?? ''}]`).join('\n'),
+        ] : []),
+        ...(topGaps.length > 0 ? [
+            '',
+            'TOP COVERAGE GAPS (priority order — use in §7):',
+            topGaps.slice(0, 5).map((g) => `  - ${g}`).join('\n'),
+        ] : []),
+        '',
+        '## Section Knowledge (per-section retrieved context)',
+        `### For §1 Scope:\n${knowledgeBySec.scope}`,
+        '',
+        `### For §3 Features:\n${knowledgeBySec.features}`,
+        '',
+        `### For §4 Approach:\n${knowledgeBySec.approach}`,
+        '',
+        `### For §5 Criteria:\n${knowledgeBySec.criteria}`,
+        '',
+        `### For §6 Environment:\n${knowledgeBySec.environment}`,
+        '',
+        `### For §7 Risk:\n${knowledgeBySec.risk}`,
+        '',
+        `### For §8 Suspension Criteria:\n${knowledgeBySec.suspension}`,
+        '',
+        'Return ONLY the Markdown test plan using this exact structure:',
+        '',
+        `# Test Plan · ${planId}`,
+        `*Standard: ISO/IEC/IEEE 29119-3*`,
+        '',
+        '## 1. Scope',
+        '(what is in scope and out of scope — ground in business domain and crawled screens)',
+        '',
+        '## 2. Test Items',
+        '(what software artifacts are being tested)',
+        '',
+        '## 3. Features to Test',
+        '| Feature | Screens | Approach | Priority | Requirements (traceTo) |',
+        '|---|---|---|---|---|',
+        '(one row per feature/flow; Requirements column = reqIds from the requirements list that this feature covers)',
+        ...(untestedReqs.length > 0 ? [
+            '',
+            '### Coverage Debt',
+            '(list untestedRequirements here as rows with no test case — these are explicit coverage gaps)',
+        ] : []),
+        '',
+        '## 4. Approach',
+        '(testing strategy: types, tools, automation vs manual split, techniques — ground in tech stack knowledge)',
+        '',
+        '## 5. Entry / Exit & Pass / Fail Criteria',
+        '(entry conditions, exit conditions, pass/fail thresholds — ground in coverage stats above)',
+        '',
+        '## 6. Environment & Test Data Strategy',
+        '(browsers, devices, CI/CD pipeline, test data approach — ground in tech stack and auth session knowledge)',
+        '',
+        '## 7. Risk Areas',
+        ...(unbuiltReqs.length > 0 ? [
+            '(LEAD with unbuiltRequirements — "Promised but not found in crawl" risks — THEN technical risks)',
+        ] : [
+            '(identified risks and mitigations — lead with CRITICAL/HIGH requirement gaps if any)',
+        ]),
+        '',
+        '## 8. Suspension Criteria and Resumption Requirements',
+        '(conditions under which testing is suspended — e.g. >30% CRITICAL failures in a single run, build environment unavailable, blocker defect density exceeds threshold — and the criteria required to resume)',
+        '',
+        '## 9. Schedule',
+        '(milestones and timeline)',
+        '',
+        '## 10. Approvals',
+        '(sign-off table with roles)',
+    ]
+        .filter(line => line !== undefined)
+        .join('\n');
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(tenantId, 'testPlan');
+    if (!llmCfg) {
+        throw new Error('LLM provider not configured. Add an AI provider in Workspace → Settings → AI Provider.');
+    }
+    // LLM-based rerank (not a cross-encoder model — uses the same LLM context for semantic scoring)
+    const reqIds = requirements.map((r) => r.reqId ?? r.id ?? '').filter(Boolean);
+    const casesKey = [...reqIds].sort().join(',').slice(0, 500);
+    const planSeed = (0, llm_js_1.deterministicSeed)(`${tenantId}:${projectId}:test-plan:${casesKey}`);
+    const planMaxTokens = parseInt(process.env.PLAN_MAX_TOKENS ?? '') || 16000;
+    let { text: markdown } = await (0, llm_js_1.askTracked)(system, user, llmCfg, planMaxTokens, undefined, { temperature: 0, seed: planSeed });
+    // Strip ```markdown ... ``` fences if present
+    markdown = markdown.trim()
+        .replace(/^```(?:markdown|md)?\s*\n/, '')
+        .replace(/\n```\s*$/, '');
+    return markdown.trim();
+}

package/dist/repo-scan-agent.d.ts

@@ -0,0 +1,189 @@
+/**
+ * GitHub repo scanning agent for Framework Modernization.
+ *
+ * Handles: GitHub API calls (raw fetch), framework detection from config file paths,
+ * test ID extraction from test file content, and style extraction from sample files.
+ */
+export interface DetectedFramework {
+    framework: 'playwright-ts' | 'playwright-js' | 'playwright-py' | 'playwright-java' | 'cypress-ts' | 'cypress-js' | 'pytest' | 'junit' | 'selenium-java' | 'selenium-py' | 'jest-ts' | 'jest-js' | 'cucumber' | 'gherkin' | 'webdriverio' | 'unknown';
+    language: 'typescript' | 'javascript' | 'python' | 'java';
+    testGlob: string;
+    configPath: string;
+    confidence: 'HIGH' | 'MEDIUM' | 'LOW';
+}
+export interface ExtractedTest {
+    name: string;
+    normalizedName: string;
+    filePath: string;
+    lineNumber: number;
+    describeBlock?: string;
+    framework: string;
+    dynamic: boolean;
+}
+export interface StyleProfile {
+    framework: string;
+    language: string;
+    importLines: string[];
+    describePattern: string;
+    beforeEachPattern: string;
+    pageObjectPattern: string;
+    conventions: string;
+    folderPattern: string;
+    namingPattern: string;
+    /** Package/module root derived by LLM from repo paths. For Java: dot-separated (e.g. "tests", "com.crm.qa"). For TS/JS: directory. For Python: module. Overrides io.zeta default. */
+    javaBasePackage?: string;
+    /** Java source root directory derived by LLM (e.g. "src/test/java"). Used by assembler to place files correctly without hardcoding. */
+    javaRoot?: string;
+    /**
+     * How the repo organises its test code — detected by LLM from actual paths and content:
+     * - "flat": single test class per feature, no page object separation
+     * - "two-tier": page objects in one location + test classes in another (separate src/main vs src/test)
+     * - "zeta-v2": already uses Zeta v2 6-layer structure (locators/pages/actions/assertions/testdata/smoke)
+     * - "custom": multi-layer but different names — see testLayers
+     */
+    testStructurePattern?: 'flat' | 'two-tier' | 'zeta-v2' | 'custom';
+    /** Layer subdirectory names found in the repo (e.g. ["pages","tests"] or ["locators","pages","actions","assertions","testdata"]). Empty for flat. */
+    testLayers?: string[];
+    /** Where page/component objects live, relative to repo root (e.g. "src/main/java/pages"). */
+    pageObjectLocation?: string;
+    /** Where test runner classes live, relative to repo root (e.g. "src/test/java/tests"). */
+    testLocation?: string;
+    /** Repo's base class for page objects (e.g. "Page", "BasePage"). */
+    basePageClass?: string;
+    /** Repo's driver/browser factory class (e.g. "Browser", "DriverFactory"). */
+    driverClass?: string;
+    /** Detected directory for test data / data provider files (e.g. "testdata/", "test-data/", "data/"). Null = repo has none. */
+    testDataDir?: string | null;
+    /** Detected directory for fixture files (e.g. "fixtures/", "tests/fixtures/", "cypress/fixtures/"). Null = repo has none. */
+    fixtureDir?: string | null;
+    /** Detected directory for locator/selector files (e.g. "locators/", "src/locators/", "selectors/"). Undefined = repo has none. */
+    locatorsDir?: string;
+    /** testDir extracted from playwright.config.ts / cypress.config.ts — highest-priority ground truth for test file location. */
+    configTestDir?: string;
+    /** fixturesFolder from cypress.config.ts. */
+    configFixturesFolder?: string;
+    /** TypeScript path aliases from tsconfig.json compilerOptions.paths (e.g. {"@pages/*": ["src/pages/*"]}). */
+    tsconfigPaths?: Record<string, string[]>;
+    /** baseUrl from tsconfig.json compilerOptions (e.g. "."). */
+    tsconfigBaseUrl?: string;
+    /** Distinct test subdirectories when repo splits tests by type (e.g. ["tests/ui", "tests/api"]). */
+    testSubDirs?: string[];
+    /** Component object directory when separate from pageObjectLocation (e.g. "src/components"). */
+    componentDir?: string;
+    /** True when fixtureDir points to a TypeScript fixture module (Playwright test.extend), not static data. */
+    isTestFixtureModule?: boolean;
+    /** Detected directory for utility/helper files (e.g. "utils/", "helpers/", "shared/"). Null = repo has none. */
+    utilsDir?: string | null;
+    /** Detected config directory (e.g. "config/", "src/config/"). Null = repo has none. */
+    configDir?: string | null;
+    /** File naming stem for page objects (e.g. "{PascalCase}Page.ts", "{camelCase}.page.ts"). */
+    pageFileStem?: string;
+    /** File naming stem for locator files (e.g. "{camelCase}Locators.ts"). */
+    locatorFileStem?: string;
+    /** File naming stem for test data files (e.g. "{camelCase}TestData.ts"). */
+    testDataFileStem?: string;
+    /** File naming stem for fixture files (e.g. "{camelCase}.fixture.ts"). */
+    fixtureFileStem?: string;
+}
+export declare function validateGitHubRepo(token: string, repoFullName: string): Promise<{
+    ok: boolean;
+    defaultBranch: string;
+    private: boolean;
+    error?: string;
+}>;
+export declare function fetchRepoTree(token: string, repoFullName: string, branch?: string): Promise<{
+    paths: string[];
+    sha: string;
+    truncated: boolean;
+}>;
+export declare function fetchFileContent(token: string, repoFullName: string, filePath: string): Promise<string | null>;
+export declare function detectFramework(paths: string[]): DetectedFramework[];
+/**
+ * G-07: Multi-file fixture tracing.
+ * For relative imports where specifier name does NOT match the name heuristic,
+ * fetch the imported file and check if it exports a test.extend() result.
+ * Returns confirmed alias names to merge into detectTestAliases.
+ * Max 3 fixture files fetched per spec file to stay within rate limits.
+ */
+export declare function resolveFixtureAliasesFromImports(content: string, token: string, repoFullName: string, specFilePath: string): Promise<Set<string>>;
+export declare function extractTestIds(content: string, filePath: string, framework: string, extraAliases?: Set<string>): ExtractedTest[];
+export declare function extractStyleProfile(sampleFiles: Array<{
+    path: string;
+    content: string;
+}>, framework: string, language: string, tenantId: string, projectId?: string, jobId?: string, 
+/** Filtered code paths (test + source files) — used by LLM for convention/structure analysis */
+allPaths?: string[], 
+/**
+ * Full repo tree paths (unfiltered) — used ONLY by heuristic detectDataDirs() so that
+ * testdata/*.json, fixtures/*.yaml, locators/ etc. are visible even when they contain no .ts files.
+ * When omitted, falls back to allPaths (same behaviour as before).
+ */
+fullTreePaths?: string[]): Promise<StyleProfile>;
+/**
+ * Extract Java base package from folder pattern or file paths.
+ * e.g. "src/test/java/com/crm/qa/testc/{feature}Test.java" → "com.crm.qa"
+ */
+export declare function deriveJavaBasePackage(folderPattern: string, filePaths?: string[]): string | null;
+export interface PageObjectMethod {
+    name: string;
+    params: string;
+    returnType: string;
+}
+export interface PageObjectSummary {
+    filePath: string;
+    className: string;
+    methods: PageObjectMethod[];
+    importPath: string;
+}
+/**
+ * Build the page object inventory from all non-test repo files.
+ * Pass up to 60 candidate files for efficiency.
+ */
+export declare function buildPageObjectInventory(token: string, repoFullName: string, allPaths: string[], framework: string): Promise<PageObjectSummary[]>;
+/**
+ * Format page object inventory as a prompt-friendly string for LLM injection.
+ */
+export declare function formatPageObjectInventoryForPrompt(inventory: PageObjectSummary[], urlHint?: string): string;
+/**
+ * Given a screen URL and the repo's detected style profile, derive
+ * the canonical path where a new test script for this screen should live.
+ *
+ * Example:
+ *   url: https://app.acme.com/reports/export
+ *   folderPattern: tests/e2e/
+ *   framework: playwright-ts
+ *   → tests/e2e/reports-export.spec.ts
+ */
+export declare function deriveRepoTargetPath(screenUrl: string, styleProfile: StyleProfile, framework: string): string;
+export interface FrameworkConfigPaths {
+    /** testDir — authoritative test directory from framework config */
+    testDir?: string;
+    /** fixturesFolder from cypress.config / wdio.conf */
+    fixturesFolder?: string;
+    /** baseURL from playwright.config / wdio.conf / cypress.config */
+    baseURL?: string;
+    /** TypeScript path aliases from tsconfig.json compilerOptions.paths */
+    tsconfigPaths?: Record<string, string[]>;
+    /** baseUrl from tsconfig.json compilerOptions */
+    tsconfigBaseUrl?: string;
+    /** Jest moduleNameMapper — alias map for import resolution */
+    jestModuleNameMapper?: Record<string, string>;
+    /** Java testSourceDirectory from pom.xml / build.gradle */
+    javaTestSourceDir?: string;
+}
+export type ConfigFileType = 'playwright' | 'cypress' | 'tsconfig' | 'jest' | 'package-json' | 'pytest-ini' | 'pyproject-toml' | 'setup-cfg' | 'pom-xml' | 'build-gradle' | 'testng-xml' | 'wdio' | 'cucumber';
+/**
+ * Extract path-relevant settings from framework config files using regex/JSON.
+ * No LLM — these files have predictable, well-documented structure.
+ */
+export declare function parseFrameworkConfig(configType: ConfigFileType, content: string): FrameworkConfigPaths;
+/**
+ * Given a repo's file tree paths and detected framework, return which config
+ * files to fetch and what parser to use for each.
+ * Covers all supported frameworks: playwright, cypress, jest, pytest, junit,
+ * selenium-java/py, webdriverio, cucumber.
+ */
+export declare function detectConfigFilesToFetch(paths: string[], framework: string): Array<{
+    path: string;
+    type: ConfigFileType;
+}>;