@taodigital/agents 0.0.0-stage → 1.2.1

package/dist/coverage-gap-agent.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ZeTa-AI Bug Identification Engine — P7
+ *
+ * Four entry points:
+ *   computeRequirementCoverage     — LLM-based AC coverage check → RequirementCoverage + BugSignal rows
+ *   analyzeTestRunFailures         — cluster failed TestResults by error type → BugSignal rows
+ *   promoteVisualRegressionToBugSignal — elevate FLAG/BLOCK VisualDiffs to BugSignals
+ *   promoteBugSignalToJira         — push a BugSignal to Jira via stored connector credentials
+ *
+ * NOTE: BugSignal and RequirementCoverage are new Prisma models (pending schema migration).
+ * prismaAdmin is cast to `any` for those two models until the migration is applied.
+ */
+export declare function computeRequirementCoverage(tenantId: string, projectId: string): Promise<{
+    requirementsChecked: number;
+    gapsFound: number;
+}>;
+export declare function analyzeTestRunFailures(tenantId: string, projectId: string, runId: string): Promise<{
+    failuresAnalyzed: number;
+    signalsCreated: number;
+}>;
+export declare function promoteVisualRegressionToBugSignal(tenantId: string, projectId: string, visualDiffId: string): Promise<any | null>;
+export declare function promoteBugSignalToJira(tenantId: string, projectId: string, signalId: string): Promise<{
+    jiraIssueKey: string;
+    jiraIssueUrl: string;
+}>;

package/dist/coverage-gap-agent.js

@@ -0,0 +1,269 @@
+"use strict";
+/**
+ * ZeTa-AI Bug Identification Engine — P7
+ *
+ * Four entry points:
+ *   computeRequirementCoverage     — LLM-based AC coverage check → RequirementCoverage + BugSignal rows
+ *   analyzeTestRunFailures         — cluster failed TestResults by error type → BugSignal rows
+ *   promoteVisualRegressionToBugSignal — elevate FLAG/BLOCK VisualDiffs to BugSignals
+ *   promoteBugSignalToJira         — push a BugSignal to Jira via stored connector credentials
+ *
+ * NOTE: BugSignal and RequirementCoverage are new Prisma models (pending schema migration).
+ * prismaAdmin is cast to `any` for those two models until the migration is applied.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeRequirementCoverage = computeRequirementCoverage;
+exports.analyzeTestRunFailures = analyzeTestRunFailures;
+exports.promoteVisualRegressionToBugSignal = promoteVisualRegressionToBugSignal;
+exports.promoteBugSignalToJira = promoteBugSignalToJira;
+const database_1 = require("@taodigital/database");
+const core_1 = require("@taodigital/core");
+const llm_js_1 = require("./llm.js");
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function classifyError(msg) {
+    const m = msg?.toLowerCase() ?? '';
+    if (m.includes('locator') || m.includes('selector') || m.includes('element not found') || m.includes('waitfor'))
+        return 'LOCATOR_ERROR';
+    if (m.includes('expected') || m.includes('assert') || m.includes('to equal') || m.includes('to be'))
+        return 'ASSERTION_ERROR';
+    if (m.includes('navigation') || m.includes('net::err') || m.includes('timeout'))
+        return 'NAVIGATION_ERROR';
+    if (m.includes('network') || m.includes('404') || m.includes('500') || m.includes('fetch'))
+        return 'NETWORK_ERROR';
+    return 'UNKNOWN_ERROR';
+}
+const db = database_1.prismaAdmin;
+// ─── Function 1: computeRequirementCoverage ───────────────────────────────────
+async function computeRequirementCoverage(tenantId, projectId) {
+    const requirements = await database_1.prismaAdmin.requirement.findMany({
+        where: { tenantId, projectId },
+        take: 200,
+    });
+    let gapsFound = 0;
+    for (const req of requirements) {
+        const testCases = await database_1.prismaAdmin.testCase.findMany({
+            where: {
+                tenantId,
+                projectId,
+                OR: [
+                    { traceTo: req.id },
+                    { traceToExtra: { string_contains: req.id } },
+                ],
+            },
+            select: { id: true, steps: true, title: true },
+        });
+        const acceptanceCriteria = Array.isArray(req.acceptanceCriteria)
+            ? req.acceptanceCriteria
+            : [];
+        if (acceptanceCriteria.length === 0)
+            continue;
+        const promptText = (await (0, core_1.getAgentPrompt)('requirement-coverage-check').catch(() => undefined)) ??
+            'Given this acceptance criterion and test steps, return JSON: { covered: boolean, coverageScore: number, missingAspects: string[] }';
+        const acScores = [];
+        for (const ac of acceptanceCriteria) {
+            if (testCases.length === 0) {
+                acScores.push(0);
+                continue;
+            }
+            const steps = testCases.flatMap((tc) => Array.isArray(tc.steps) ? tc.steps : []);
+            let score = 0;
+            try {
+                const { text: raw } = await (0, llm_js_1.askTracked)(promptText, `Acceptance criterion: ${ac}\n\nTest steps: ${JSON.stringify(steps)}`);
+                const parsed = JSON.parse(raw.match(/\{[\s\S]*\}/)?.[0] ?? '{"coverageScore":0}');
+                score = typeof parsed.coverageScore === 'number' ? parsed.coverageScore : 0;
+            }
+            catch {
+                score = 0;
+            }
+            acScores.push(score);
+        }
+        const avgScore = acScores.length > 0
+            ? acScores.reduce((a, b) => a + b, 0) / acScores.length
+            : 0;
+        await db.requirementCoverage.upsert({
+            where: {
+                tenantId_requirementId: { tenantId, requirementId: req.id },
+            },
+            create: {
+                tenantId,
+                projectId,
+                requirementId: req.id,
+                testCaseIds: testCases.map((t) => t.id),
+                coverageScore: avgScore,
+                uncoveredAcIds: [],
+            },
+            update: {
+                testCaseIds: testCases.map((t) => t.id),
+                coverageScore: avgScore,
+                uncoveredAcIds: [],
+            },
+        });
+        if (avgScore < 0.5) {
+            await db.bugSignal.upsert({
+                where: {
+                    tenantId_sourceRefHash: {
+                        tenantId,
+                        sourceRefHash: `REQUIREMENT_GAP:${req.id}`,
+                    },
+                },
+                create: {
+                    tenantId,
+                    projectId,
+                    signalType: 'REQUIREMENT_GAP',
+                    severity: avgScore < 0.2 ? 'HIGH' : 'MEDIUM',
+                    title: `Requirement gap: ${req.title}`,
+                    sourceRef: { requirementId: req.id },
+                    sourceRefHash: `REQUIREMENT_GAP:${req.id}`,
+                },
+                update: {
+                    severity: avgScore < 0.2 ? 'HIGH' : 'MEDIUM',
+                },
+            });
+            gapsFound += 1;
+        }
+    }
+    return { requirementsChecked: requirements.length, gapsFound };
+}
+// ─── Function 2: analyzeTestRunFailures ──────────────────────────────────────
+async function analyzeTestRunFailures(tenantId, projectId, runId) {
+    const failedResults = await database_1.prismaAdmin.testResult.findMany({
+        where: { runId, tenantId, status: 'FAILED' },
+        include: {
+            testCase: { select: { id: true, priority: true, title: true } },
+        },
+        take: 200,
+    });
+    // Group by error type
+    const groups = new Map();
+    for (const result of failedResults) {
+        const errorType = classifyError(result.error ?? '');
+        if (!groups.has(errorType))
+            groups.set(errorType, []);
+        groups.get(errorType).push(result);
+    }
+    const priorityToSeverity = {
+        CRITICAL: 'CRITICAL',
+        HIGH: 'HIGH',
+    };
+    let signalsCreated = 0;
+    for (const [errorType, group] of groups) {
+        // Determine highest priority in the group
+        const hasCritical = group.some((r) => r.testCase?.priority === 'CRITICAL');
+        const hasHigh = group.some((r) => r.testCase?.priority === 'HIGH');
+        const severity = hasCritical
+            ? 'CRITICAL'
+            : hasHigh
+                ? 'HIGH'
+                : 'MEDIUM';
+        await db.bugSignal.create({
+            data: {
+                tenantId,
+                projectId,
+                signalType: 'RUNNER_FAILURE',
+                severity,
+                title: `${errorType} failures in run ${runId.slice(-8)}`,
+                sourceRef: {
+                    runId,
+                    testResultIds: group.map((r) => r.id),
+                },
+                affectedTestCaseIds: group.map((r) => r.testCaseId),
+            },
+        });
+        signalsCreated += 1;
+    }
+    return { failuresAnalyzed: failedResults.length, signalsCreated };
+}
+// ─── Function 3: promoteVisualRegressionToBugSignal ──────────────────────────
+async function promoteVisualRegressionToBugSignal(tenantId, projectId, visualDiffId) {
+    const visualDiff = await database_1.prismaAdmin.visualDiff.findFirst({
+        where: { id: visualDiffId, tenantId },
+    });
+    if (!visualDiff)
+        return null;
+    if (visualDiff.bugSignalVisualDiffId)
+        return null;
+    if (visualDiff.recommendation === 'FLAG' ||
+        visualDiff.recommendation === 'BLOCK') {
+        const bugReportDraft = visualDiff.bugReportDraft;
+        const signal = await db.bugSignal.create({
+            data: {
+                tenantId,
+                projectId,
+                signalType: 'VISUAL_REGRESSION',
+                severity: visualDiff.recommendation === 'BLOCK' ? 'CRITICAL' : 'HIGH',
+                title: bugReportDraft?.title ?? 'Visual regression detected',
+                description: bugReportDraft?.description ?? null,
+                sourceRef: { visualDiffId },
+            },
+        });
+        await database_1.prismaAdmin.visualDiff.update({
+            where: { id: visualDiffId },
+            data: { bugSignalVisualDiffId: signal.id },
+        });
+        return signal;
+    }
+    return null;
+}
+// ─── Function 4: promoteBugSignalToJira ──────────────────────────────────────
+const severityToJiraPriority = {
+    CRITICAL: 'Highest',
+    HIGH: 'High',
+    MEDIUM: 'Medium',
+    LOW: 'Low',
+};
+async function promoteBugSignalToJira(tenantId, projectId, signalId) {
+    const signal = await db.bugSignal.findFirstOrThrow({
+        where: { id: signalId, tenantId },
+    });
+    const connector = await database_1.prismaAdmin.connector.findFirst({
+        where: { projectId, kind: 'JIRA', tenantId },
+    });
+    if (!connector) {
+        throw new Error('No Jira connector configured for this project');
+    }
+    const cfg = (connector.config ?? {});
+    const baseUrl = (cfg.baseUrl ?? '').replace(/\/$/, '');
+    const projectKey = cfg.projectKey ?? projectId.slice(0, 8).toUpperCase();
+    const payload = {
+        fields: {
+            project: { key: projectKey },
+            summary: signal.title,
+            description: {
+                version: 1,
+                type: 'doc',
+                content: [
+                    {
+                        type: 'paragraph',
+                        content: [
+                            {
+                                type: 'text',
+                                text: signal.description ?? signal.title,
+                            },
+                        ],
+                    },
+                ],
+            },
+            issuetype: { name: 'Bug' },
+            priority: { name: severityToJiraPriority[signal.severity] ?? 'Medium' },
+        },
+    };
+    const apiToken = cfg.apiToken ?? connector.secretRef;
+    const userEmail = cfg.userEmail ?? '';
+    const res = await fetch(`${baseUrl}/rest/api/3/issue`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Basic ${Buffer.from(`${userEmail}:${apiToken}`).toString('base64')}`,
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`Jira API error ${res.status}: ${body.slice(0, 200)}`);
+    }
+    const data = (await res.json());
+    return {
+        jiraIssueKey: data.key,
+        jiraIssueUrl: `${baseUrl}/browse/${data.key}`,
+    };
+}

package/dist/coverage-map-agent.d.ts

@@ -0,0 +1,15 @@
+import type { ExtractedTest } from './repo-scan-agent.js';
+export interface MappingResult {
+    testCaseId: string;
+    status: 'MAPPED' | 'UNMAPPED' | 'AMBIGUOUS';
+    matchedFilePath?: string;
+    scriptTestName?: string;
+    lineNumber?: number;
+    confidence: number;
+    matchMethod: 'EXACT' | 'NORMALIZED' | 'FUZZY' | 'AI' | 'UNMAPPED';
+}
+export declare function buildCoverageMap(testCases: Array<{
+    id: string;
+    title: string;
+    ref?: string | null;
+}>, extractedTests: ExtractedTest[], tenantId: string): Promise<MappingResult[]>;

package/dist/coverage-map-agent.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCoverageMap = buildCoverageMap;
+const core_1 = require("@taodigital/core");
+const llm_js_1 = require("./llm.js");
+const llm_config_js_1 = require("./llm-config.js");
+const app_brain_1 = require("@taodigital/app-brain");
+function normalize(s) {
+    return s.toLowerCase().replace(/[^\w\s]/g, '').replace(/\s+/g, ' ').trim();
+}
+function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (a[i - 1] === b[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1];
+            }
+            else {
+                dp[i][j] = 1 + Math.min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    return dp[m][n];
+}
+function similarity(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return 1.0;
+    const maxLen = Math.max(a.length, b.length);
+    if (maxLen === 0)
+        return 1.0;
+    return 1 - levenshtein(a, b) / maxLen;
+}
+function assignStatus(confidence) {
+    if (confidence >= 0.95)
+        return 'MAPPED';
+    if (confidence >= 0.70)
+        return 'AMBIGUOUS';
+    return 'UNMAPPED';
+}
+function makeMapped(testCaseId, et, confidence, matchMethod) {
+    return {
+        testCaseId,
+        status: assignStatus(confidence),
+        matchedFilePath: et.filePath,
+        scriptTestName: et.name,
+        lineNumber: et.lineNumber,
+        confidence,
+        matchMethod,
+    };
+}
+function makeUnmapped(testCaseId) {
+    return {
+        testCaseId,
+        status: 'UNMAPPED',
+        confidence: 0,
+        matchMethod: 'UNMAPPED',
+    };
+}
+async function runAIPass(unmatched, pool, tenantId) {
+    const results = new Map();
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(tenantId, 'coverage_mapping');
+    const BATCH_SIZE = 20;
+    for (let i = 0; i < unmatched.length; i += BATCH_SIZE) {
+        const batch = unmatched.slice(i, i + BATCH_SIZE);
+        const testCasesText = batch
+            .map((tc) => `- id: "${tc.id}", title: "${tc.title}"`)
+            .join('\n');
+        const extractedNamesText = pool.map((et) => `- "${et.name}"`).join('\n');
+        const SYSTEM_DEFAULT = 'You are a test mapping assistant. Given a list of test case titles and extracted test names from source code, ' +
+            'find the best match for each test case. Return a JSON array only, no explanation.';
+        const system = await (0, core_1.getAgentPrompt)('coverage-map', undefined, tenantId) ?? SYSTEM_DEFAULT;
+        const user = `Test cases:\n${testCasesText}\n\nExtracted test names:\n${extractedNamesText}\n\n` +
+            'Return a JSON array where each element has: { "testCaseId": string, "matchedName": string | null, "confidence": number }. ' +
+            'confidence is 0.0–1.0. Use null for matchedName if no reasonable match exists.';
+        let parsed = [];
+        try {
+            const seed = (0, llm_js_1.deterministicSeed)(`${tenantId}:cov-map:${batch.map((tc) => tc.id).join('|')}`);
+            const res = await (0, llm_js_1.askTracked)(system, user, llmCfg, 2048, undefined, { temperature: 0, seed });
+            const raw = res.text.trim();
+            const jsonMatch = raw.match(/\[[\s\S]*\]/);
+            if (jsonMatch) {
+                parsed = JSON.parse(jsonMatch[0]);
+            }
+        }
+        catch {
+            // If AI fails, leave batch unmatched
+        }
+        for (const item of parsed) {
+            if (!item.matchedName || item.confidence < 0.70) {
+                results.set(item.testCaseId, makeUnmapped(item.testCaseId));
+                continue;
+            }
+            const et = pool.find((e) => e.name === item.matchedName);
+            if (!et) {
+                results.set(item.testCaseId, makeUnmapped(item.testCaseId));
+                continue;
+            }
+            const confidence = Math.min(item.confidence, 0.94); // AI matches cap at AMBIGUOUS
+            results.set(item.testCaseId, {
+                testCaseId: item.testCaseId,
+                status: 'AMBIGUOUS',
+                matchedFilePath: et.filePath,
+                scriptTestName: et.name,
+                lineNumber: et.lineNumber,
+                confidence,
+                matchMethod: 'AI',
+            });
+        }
+        // Mark any not returned by AI as UNMAPPED
+        for (const tc of batch) {
+            if (!results.has(tc.id)) {
+                results.set(tc.id, makeUnmapped(tc.id));
+            }
+        }
+    }
+    return results;
+}
+async function buildCoverageMap(testCases, extractedTests, tenantId) {
+    const finalResults = new Map();
+    // Separate dynamic tests — skip all passes
+    const dynamic = testCases.filter((tc) => {
+        const et = extractedTests.find((e) => e.name.trim() === tc.title.trim());
+        return et?.dynamic === true;
+    });
+    for (const tc of dynamic) {
+        finalResults.set(tc.id, makeUnmapped(tc.id));
+    }
+    let remaining = testCases.filter((tc) => !finalResults.has(tc.id));
+    // Pool is mutable — remove used extracted tests after each pass
+    const usedExtracted = new Set();
+    const availablePool = () => extractedTests.filter((et) => !usedExtracted.has(et.name) && et.dynamic !== true);
+    // Ref-based matching (before Pass 1)
+    const afterRef = [];
+    for (const tc of remaining) {
+        if (!tc.ref) {
+            afterRef.push(tc);
+            continue;
+        }
+        const pool = availablePool();
+        const match = pool.find((et) => et.name.includes(tc.ref));
+        if (match) {
+            finalResults.set(tc.id, makeMapped(tc.id, match, 1.0, 'EXACT'));
+            usedExtracted.add(match.name);
+        }
+        else {
+            afterRef.push(tc);
+        }
+    }
+    remaining = afterRef;
+    // Pass 1 — EXACT
+    const afterPass1 = [];
+    for (const tc of remaining) {
+        const pool = availablePool();
+        const match = pool.find((et) => et.name.trim() === tc.title.trim());
+        if (match) {
+            finalResults.set(tc.id, makeMapped(tc.id, match, 1.0, 'EXACT'));
+            usedExtracted.add(match.name);
+        }
+        else {
+            afterPass1.push(tc);
+        }
+    }
+    remaining = afterPass1;
+    // Pass 2 — NORMALIZED
+    const afterPass2 = [];
+    for (const tc of remaining) {
+        const normTitle = normalize(tc.title);
+        const pool = availablePool();
+        const match = pool.find((et) => et.normalizedName === normTitle);
+        if (match) {
+            finalResults.set(tc.id, makeMapped(tc.id, match, 0.90, 'NORMALIZED'));
+            usedExtracted.add(match.name);
+        }
+        else {
+            afterPass2.push(tc);
+        }
+    }
+    remaining = afterPass2;
+    // Pass 3 — FUZZY (Levenshtein, threshold ≥ 0.85)
+    const afterPass3 = [];
+    for (const tc of remaining) {
+        const normTitle = normalize(tc.title);
+        const pool = availablePool();
+        let best = null;
+        let secondBest = null;
+        for (const et of pool) {
+            const score = similarity(normTitle, et.normalizedName ?? normalize(et.name));
+            if (score >= 0.85) {
+                if (!best || score > best.score) {
+                    secondBest = best;
+                    best = { et, score };
+                }
+                else if (!secondBest || score > secondBest.score) {
+                    secondBest = { et, score };
+                }
+            }
+        }
+        if (!best) {
+            afterPass3.push(tc);
+            continue;
+        }
+        // Ambiguous if two candidates are within 0.02 of each other
+        if (secondBest && best.score - secondBest.score <= 0.02) {
+            // Neither matched — leave for AI pass
+            afterPass3.push(tc);
+            continue;
+        }
+        finalResults.set(tc.id, makeMapped(tc.id, best.et, best.score, 'FUZZY'));
+        usedExtracted.add(best.et.name);
+    }
+    remaining = afterPass3;
+    // Pass 3.5 — SEMANTIC (cross-encoder for paraphrases that Levenshtein misses)
+    if (remaining.length > 0) {
+        const semanticPool = availablePool();
+        if (semanticPool.length > 0) {
+            const poolTexts = semanticPool.map((et) => et.normalizedName ?? normalize(et.name));
+            const afterSemantic = [];
+            for (const tc of remaining) {
+                try {
+                    const ranked = await (0, app_brain_1.rerankStrings)(normalize(tc.title), poolTexts, 1, 0);
+                    const top = ranked[0];
+                    if (top && top.score >= 0.65) {
+                        const et = semanticPool[top.index];
+                        if (et && !usedExtracted.has(et.name)) {
+                            finalResults.set(tc.id, makeMapped(tc.id, et, Math.min(top.score, 0.89), 'FUZZY'));
+                            usedExtracted.add(et.name);
+                            continue;
+                        }
+                    }
+                }
+                catch {
+                    // reranker unavailable — fall through to AI pass
+                }
+                afterSemantic.push(tc);
+            }
+            remaining = afterSemantic;
+        }
+    }
+    // Pass 4 — AI
+    if (remaining.length > 0) {
+        const aiResults = await runAIPass(remaining, availablePool(), tenantId);
+        for (const [id, result] of aiResults) {
+            finalResults.set(id, result);
+        }
+    }
+    // Ensure every test case has a result
+    for (const tc of testCases) {
+        if (!finalResults.has(tc.id)) {
+            finalResults.set(tc.id, makeUnmapped(tc.id));
+        }
+    }
+    return testCases.map((tc) => finalResults.get(tc.id));
+}

package/dist/crawl-diff-agent.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ZeTa-AI Crawl Diff Agent
+ *
+ * Compares DOM elements and navigation flows across two crawl runs to detect
+ * structural UI changes. Drives the approval gate state machine that gates
+ * script generation until all diffs are reviewed.
+ *
+ * Public entry points:
+ *   computeCrawlDiffs           — diff elements + flows between two crawl jobs
+ *   createCrawlContextEnhancement — create ContextEnhancement record for a crawl job
+ *   approveCrawlDiff            — mark a diff approved, flag affected test cases suspect
+ *   recomputeApprovalGateSummary — recompute contextPhase based on pending diffs
+ *   computeCoverageGaps         — find UI elements not covered by any test case
+ */
+export declare function computeCrawlDiffs(tenantId: string, projectId: string, fromJobId: string, toJobId: string): Promise<{
+    diffCount: number;
+    criticalCount: number;
+    significantCount: number;
+}>;
+export declare function createCrawlContextEnhancement(tenantId: string, projectId: string, toJobId: string, diffs: Array<{
+    severity: string;
+}>): Promise<any>;
+export declare function approveCrawlDiff(tenantId: string, projectId: string, diffId: string, reviewedBy?: string): Promise<void>;
+export declare function recomputeApprovalGateSummary(tenantId: string, projectId: string): Promise<object>;
+export declare function computeCoverageGaps(tenantId: string, projectId: string): Promise<{
+    gapsFound: number;
+}>;