@yasserkhanorg/impact-gate 2.0.0

package/dist/progress.js

@@ -0,0 +1,116 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressReporter = void 0;
+const events_1 = require("events");
+class ProgressReporter extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.isTTY = options?.isTTY ?? (process.stdout.isTTY === true);
+        this.silent = (options?.quiet ?? false) || (options?.jsonMode ?? false);
+        this.completedAgents = 0;
+        this.totalAgents = 0;
+        this.currentPhase = '';
+    }
+    phaseStart(phase, agentCount) {
+        const payload = { phase, agentCount };
+        this.emit('phase-start', payload);
+        if (this.silent) {
+            return;
+        }
+        this.currentPhase = phase;
+        this.completedAgents = 0;
+        this.totalAgents = agentCount;
+        const message = `--- Phase: ${phase} (${agentCount} agent${agentCount !== 1 ? 's' : ''}) ---`;
+        this.writeLine(message);
+    }
+    agentStart(agent, family) {
+        const payload = { agent, family };
+        this.emit('agent-start', payload);
+        if (this.silent) {
+            return;
+        }
+        const familyLabel = family ? ` processing ${family}` : '';
+        if (this.isTTY) {
+            const progress = `[${this.completedAgents}/${this.totalAgents} agents]`;
+            const message = `${progress} ${this.currentPhase}: ${agent}${familyLabel}...`;
+            process.stdout.write(`\r${clearLine()}${message}`);
+        }
+        else {
+            const message = `[${this.currentPhase}] ${agent} started${familyLabel ? ':' + familyLabel : ''}`;
+            this.writeLine(message);
+        }
+    }
+    agentComplete(agent, family, tokens, cost, durationMs) {
+        const payload = { agent, family, tokens, cost, durationMs };
+        this.emit('agent-complete', payload);
+        if (this.silent) {
+            return;
+        }
+        this.completedAgents++;
+        const costStr = formatCost(cost);
+        const durationStr = formatDuration(durationMs);
+        const tokensStr = formatTokens(tokens);
+        const familyLabel = family ? ` ${family}` : '';
+        if (this.isTTY) {
+            const progress = `[${this.completedAgents}/${this.totalAgents} agents]`;
+            const message = `${progress} ${this.currentPhase}: ${agent} complete${familyLabel} (${tokensStr}, ${costStr}, ${durationStr})`;
+            process.stdout.write(`\r${clearLine()}${message}\n`);
+        }
+        else {
+            const message = `[${this.currentPhase}] ${agent} complete:${familyLabel} (${tokensStr}, ${costStr}, ${durationStr})`;
+            this.writeLine(message);
+        }
+    }
+    phaseComplete(phase, elapsedMs) {
+        const payload = { phase, elapsedMs };
+        this.emit('phase-complete', payload);
+        if (this.silent) {
+            return;
+        }
+        const durationStr = formatDuration(elapsedMs);
+        const message = `--- Phase ${phase} complete (${durationStr}) ---`;
+        this.writeLine(message);
+    }
+    workflowComplete(totalCost, totalTokens, elapsedMs) {
+        const payload = { totalCost, totalTokens, elapsedMs };
+        this.emit('workflow-complete', payload);
+        if (this.silent) {
+            return;
+        }
+        const costStr = formatCost(totalCost);
+        const tokensStr = formatTokens(totalTokens);
+        const durationStr = formatDuration(elapsedMs);
+        const message = `=== Workflow complete: ${tokensStr}, ${costStr}, ${durationStr} ===`;
+        this.writeLine(message);
+    }
+    writeLine(message) {
+        process.stdout.write(message + '\n');
+    }
+}
+exports.ProgressReporter = ProgressReporter;
+function clearLine() {
+    return '\x1B[2K';
+}
+function formatCost(cost) {
+    return `$${cost.toFixed(2)}`;
+}
+function formatTokens(tokens) {
+    if (tokens >= 1000000) {
+        return `${(tokens / 1000000).toFixed(1)}M tokens`;
+    }
+    if (tokens >= 1000) {
+        return `${(tokens / 1000).toFixed(0).replace(/\B(?=(\d{3})+(?!\d))/g, ',')} tokens`;
+    }
+    return `${tokens} tokens`;
+}
+function formatDuration(ms) {
+    const seconds = Math.round(ms / 1000);
+    if (seconds >= 60) {
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = seconds % 60;
+        return remainingSeconds > 0 ? `${minutes}m${remainingSeconds}s` : `${minutes}m`;
+    }
+    return `${seconds}s`;
+}

package/dist/prompts/coverage.d.ts

@@ -0,0 +1,39 @@
+import type { GenerationProfile } from './generation_profile.js';
+export interface CoveragePromptFlow {
+    flowId: string;
+    flowName: string;
+    route: string;
+    userActions: string[];
+    evidence: string;
+    priority: string;
+}
+export interface CoveragePromptContext {
+    flows: CoveragePromptFlow[];
+    specs: Array<{
+        relativePath: string;
+        content: string;
+        testTitles: string[];
+    }>;
+    contextBlock: string;
+    profile?: GenerationProfile;
+}
+export declare function buildCoveragePrompt(ctx: CoveragePromptContext): string;
+export interface CoverageAgentResponse {
+    coverage: Array<{
+        flowId: string;
+        action: string;
+        existingSpecs?: Array<{
+            path: string;
+            testTitles?: string[];
+            coverageLevel?: string;
+            missingScenarios?: string[];
+        }>;
+        scenariosToAdd?: string[];
+        targetSpec?: string;
+        newSpecPath?: string;
+        blockingReason?: string;
+        confidence?: number;
+    }>;
+}
+export declare function parseCoverageResponse(text: string): CoverageAgentResponse | null;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/prompts/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/prompts/coverage.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC;AAE/D,MAAM,WAAW,kBAAkB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IAClC,KAAK,EAAE,kBAAkB,EAAE,CAAC;IAC5B,KAAK,EAAE,KAAK,CAAC;QACT,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,EAAE,CAAC;KACxB,CAAC,CAAC;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC/B;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,qBAAqB,GAAG,MAAM,CAmDtE;AAED,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,KAAK,CAAC;QACZ,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,aAAa,CAAC,EAAE,KAAK,CAAC;YAClB,IAAI,EAAE,MAAM,CAAC;YACb,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;YACtB,aAAa,CAAC,EAAE,MAAM,CAAC;YACvB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;SAC/B,CAAC,CAAC;QACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;QAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,UAAU,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC,CAAC;CACN;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAMhF"}

package/dist/prompts/coverage.js

@@ -0,0 +1,61 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCoveragePrompt = buildCoveragePrompt;
+exports.parseCoverageResponse = parseCoverageResponse;
+const json_extract_js_1 = require("./json_extract.js");
+const sanitize_js_1 = require("../crew/sanitize.js");
+function buildCoveragePrompt(ctx) {
+    const flowsBlock = ctx.flows
+        .map((f) => {
+        const actions = f.userActions.length > 0 ? f.userActions.map((a) => (0, sanitize_js_1.sanitizeForPrompt)(a)).join('; ') : 'unknown';
+        return `- ${f.flowId} (${f.priority}): ${f.flowName}\n  Route: ${f.route}\n  User actions: ${actions}\n  Evidence: ${(0, sanitize_js_1.sanitizeForPrompt)(f.evidence)}`;
+    })
+        .join('\n\n');
+    const specsBlock = ctx.specs
+        .map((s) => {
+        return `### ${s.relativePath}\nTest titles: ${s.testTitles.join(', ')}\n\`\`\`typescript\n${s.content}\n\`\`\``;
+    })
+        .join('\n\n');
+    return [
+        `You are evaluating whether existing ${ctx.profile?.projectName || 'the project'} ${ctx.profile?.testFramework || 'Playwright'} E2E tests cover the impacted flows.`,
+        '',
+        `IMPACTED FLOWS (${ctx.flows.length}):`,
+        flowsBlock,
+        '',
+        `EXISTING SPEC FILES (${ctx.specs.length}):`,
+        specsBlock,
+        '',
+        ctx.contextBlock,
+        '',
+        'For each flow, determine coverage.',
+        '',
+        'Return strict JSON only with this shape:',
+        '{"coverage":[{"flowId":"<flow_id>","action":"run_existing|add_scenarios|create_spec|cannot_determine","existingSpecs":[{"path":"<relative path>","testTitles":["<exact test title>"],"coverageLevel":"full|partial|none","missingScenarios":["<specific scenario>"]}],"scenariosToAdd":["<scenario description>"],"targetSpec":"<path to extend>","newSpecPath":"<path for new spec>","blockingReason":"<why cannot_determine>","confidence":0-100}]}',
+        '',
+        'Rules:',
+        '- When claiming coverage exists, you MUST quote the exact test title from the spec file.',
+        '- If a spec tests a related but different flow, mark as "partial" not "full".',
+        '- Do NOT claim coverage exists if you cannot cite the exact test.',
+        '- Scenario gaps must be stated as user actions, not code changes.',
+        '  Wrong: "test the new isEditing state"',
+        '  Right: "test editing a scheduled message while it is in pending state"',
+        '- For add_scenarios, specify which existing spec file to extend in targetSpec.',
+        `- For create_spec, suggest a path following ${ctx.profile?.projectName || 'the project'} conventions.`,
+        '- Prefer adding scenarios to existing specs over creating new spec files.',
+        '',
+        'SEMANTIC MATCHING RULES (critical for accuracy):',
+        '- A happy-path test does NOT cover the negative/error path of the same feature.',
+        '  "user can edit post" does NOT cover "user without permission cannot edit post".',
+        '- A test for one user role does NOT cover a different role.',
+        '  "admin can delete channel" does NOT cover "member cannot delete channel".',
+        '- A test for creation does NOT cover editing or deletion of the same entity.',
+        '- "partial" means: same feature area but different specific scenario.',
+        '- "full" means: the exact user action sequence and outcome is tested.',
+        '- When in doubt between "full" and "partial", choose "partial".',
+    ].join('\n');
+}
+function parseCoverageResponse(text) {
+    return (0, json_extract_js_1.extractJsonFromResponse)(text, (obj) => obj != null && typeof obj === 'object' && Array.isArray(obj.coverage));
+}

package/dist/prompts/cross-impact.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Cross-Impact Analyst prompt — finds ripple effects across route families.
+ */
+import type { RouteFamily } from '../knowledge/route_families.js';
+export interface CrossImpactPromptContext {
+    changedFiles: string[];
+    families: RouteFamily[];
+    /** The families directly impacted by changed files */
+    directlyImpactedFamilyIds: string[];
+    projectName?: string;
+}
+export declare function buildCrossImpactPrompt(ctx: CrossImpactPromptContext): string;
+export interface CrossImpactAgentResponse {
+    crossImpacts: Array<{
+        sourceFamily: string;
+        affectedFamily: string;
+        sharedDependency: string;
+        riskLevel: 'high' | 'medium' | 'low' | string;
+        evidence: string;
+    }>;
+}
+export declare function parseCrossImpactResponse(text: string): CrossImpactAgentResponse | null;
+//# sourceMappingURL=cross-impact.d.ts.map

package/dist/prompts/cross-impact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-impact.d.ts","sourceRoot":"","sources":["../../src/prompts/cross-impact.ts"],"names":[],"mappings":"AAGA;;GAEG;AAEH,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gCAAgC,CAAC;AAKhE,MAAM,WAAW,wBAAwB;IACrC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,sDAAsD;IACtD,yBAAyB,EAAE,MAAM,EAAE,CAAC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,wBAAwB,GAAG,MAAM,CA+C5E;AAED,MAAM,WAAW,wBAAwB;IACrC,YAAY,EAAE,KAAK,CAAC;QAChB,YAAY,EAAE,MAAM,CAAC;QACrB,cAAc,EAAE,MAAM,CAAC;QACvB,gBAAgB,EAAE,MAAM,CAAC;QACzB,SAAS,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;QAC9C,QAAQ,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;CACN;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,wBAAwB,GAAG,IAAI,CAMtF"}

package/dist/prompts/cross-impact.js

@@ -0,0 +1,57 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCrossImpactPrompt = buildCrossImpactPrompt;
+exports.parseCrossImpactResponse = parseCrossImpactResponse;
+const sanitize_js_1 = require("../crew/sanitize.js");
+const json_extract_js_1 = require("./json_extract.js");
+function buildCrossImpactPrompt(ctx) {
+    const familiesBlock = ctx.families
+        .map((f) => {
+        const paths = [
+            ...(f.webappPaths || []),
+            ...(f.serverPaths || []),
+            ...(f.components || []),
+        ];
+        return `- ${f.id}: routes=[${f.routes.join(', ')}] paths=[${paths.join(', ')}] pageObjects=[${(f.pageObjects || []).join(', ')}]`;
+    })
+        .join('\n');
+    const changedBlock = ctx.changedFiles.map((f) => (0, sanitize_js_1.sanitizeForPrompt)(f)).join('\n');
+    return [
+        `You are analyzing code changes in ${ctx.projectName || 'the project'} to identify cross-family ripple effects.`,
+        'When a change in one route family could affect another family through shared dependencies,',
+        'that is a cross-impact.',
+        '',
+        `CHANGED FILES (${ctx.changedFiles.length}):`,
+        changedBlock,
+        '',
+        `DIRECTLY IMPACTED FAMILIES: ${ctx.directlyImpactedFamilyIds.join(', ')}`,
+        '',
+        `ALL ROUTE FAMILIES (${ctx.families.length}):`,
+        familiesBlock,
+        '',
+        'TASK: Identify cross-family impacts. For each pair, explain the shared dependency.',
+        '',
+        'Look for:',
+        '1. Shared webapp paths (same component used by multiple families)',
+        '2. Shared page objects (same PO class referenced by multiple families)',
+        '3. Shared API endpoints (changes affecting data used by multiple families)',
+        '4. Shared components (React components imported across family boundaries)',
+        '5. Shared state management (Redux stores, contexts used across families)',
+        '',
+        'Return strict JSON only with this shape:',
+        '{"crossImpacts":[{"sourceFamily":"<directly impacted family>","affectedFamily":"<indirectly affected family>","sharedDependency":"<what connects them>","riskLevel":"high|medium|low","evidence":"<specific file/component/API that creates the dependency>"}]}',
+        '',
+        'Rules:',
+        '- Only report cross-impacts where both families are in the manifest.',
+        '- sourceFamily must be one of the directly impacted families.',
+        '- affectedFamily must be DIFFERENT from sourceFamily.',
+        '- Risk levels: high = shared data model/state, medium = shared UI component, low = shared utility.',
+        '- Evidence must cite specific files, components, or API paths.',
+        '- Return empty array if no cross-impacts are found.',
+    ].join('\n');
+}
+function parseCrossImpactResponse(text) {
+    return (0, json_extract_js_1.extractJsonFromResponse)(text, (obj) => obj != null && typeof obj === 'object' && Array.isArray(obj.crossImpacts));
+}

package/dist/prompts/generation.d.ts

@@ -0,0 +1,25 @@
+import type { FlowDecision } from '../validation/output_schema.js';
+import type { ApiSurfaceCatalog } from '../knowledge/api_surface.js';
+import type { GenerationProfile } from './generation_profile.js';
+export interface GenerationPromptContext {
+    decision: FlowDecision;
+    apiSurface: ApiSurfaceCatalog;
+    existingSpecContent?: string;
+    specPath: string;
+    mode: 'create_spec' | 'add_scenarios';
+    profile?: GenerationProfile;
+}
+export declare function buildGenerationPrompt(ctx: GenerationPromptContext): string;
+export interface GenerationAgentResponse {
+    specPath: string;
+    code: string;
+    mode: 'create_spec' | 'add_scenarios';
+    flowId: string;
+}
+export declare function parseGenerationResponse(text: string, expectedPath: string, mode: 'create_spec' | 'add_scenarios', flowId: string, profile?: GenerationProfile): GenerationAgentResponse | null;
+/**
+ * Returns method names that appear in generated code but do not exist in the API surface.
+ * Detects all call patterns: await X.Y(), X.Y(), const z = X.Y(), chained calls.
+ */
+export declare function detectHallucinatedMethods(code: string, apiSurface: ApiSurfaceCatalog): string[];
+//# sourceMappingURL=generation.d.ts.map

package/dist/prompts/generation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generation.d.ts","sourceRoot":"","sources":["../../src/prompts/generation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,YAAY,EAAmB,MAAM,gCAAgC,CAAC;AACnF,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,6BAA6B,CAAC;AAGnE,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC;AAG/D,MAAM,WAAW,uBAAuB;IACpC,QAAQ,EAAE,YAAY,CAAC;IACvB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,aAAa,GAAG,eAAe,CAAC;IACtC,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC/B;AA0CD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,uBAAuB,GAAG,MAAM,CA0H1E;AAgFD,MAAM,WAAW,uBAAuB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,GAAG,eAAe,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,uBAAuB,CACnC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,aAAa,GAAG,eAAe,EACrC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,iBAAiB,GAC5B,uBAAuB,GAAG,IAAI,CAuBhC;AAwBD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,iBAAiB,GAAG,MAAM,EAAE,CAsC/F"}

package/dist/prompts/generation.js

@@ -0,0 +1,302 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGenerationPrompt = buildGenerationPrompt;
+exports.parseGenerationResponse = parseGenerationResponse;
+exports.detectHallucinatedMethods = detectHallucinatedMethods;
+const api_surface_js_1 = require("../knowledge/api_surface.js");
+const sanitize_js_1 = require("../crew/sanitize.js");
+const generation_profile_js_1 = require("./generation_profile.js");
+function resolveRelevantPageObjects(apiSurface, decision) {
+    const relevant = [];
+    const familyHints = [
+        decision.routeFamily,
+        decision.featureId,
+        ...decision.userActions.join(' ').toLowerCase().split(/\s+/),
+    ]
+        .filter(Boolean)
+        .map((s) => s.toLowerCase().replace(/[^a-z]/g, ''));
+    for (const po of apiSurface.pageObjects) {
+        const nameLower = po.className.toLowerCase();
+        if (nameLower.includes('channels') ||
+            nameLower.includes('page') ||
+            familyHints.some((hint) => hint.length > 3 && nameLower.includes(hint))) {
+            relevant.push(po.className);
+        }
+    }
+    return [...new Set(relevant)].slice(0, 10);
+}
+function buildAssertionPatternsBlock(patterns) {
+    if (!patterns || patterns.length === 0) {
+        return [];
+    }
+    return [
+        'REQUIRED ASSERTION PATTERNS:',
+        'Your tests MUST include assertions that verify each of these behaviors.',
+        'Do NOT just check element visibility — verify the actual business outcome.',
+        ...patterns.map((p) => `  - [${p.type}] ${p.pattern}`),
+        '',
+    ];
+}
+function buildGenerationPrompt(ctx) {
+    const profile = ctx.profile;
+    const isMM = profile ? (0, generation_profile_js_1.isMattermostProfile)(profile) : false;
+    const relevantClasses = resolveRelevantPageObjects(ctx.apiSurface, ctx.decision);
+    const apiBlock = relevantClasses.length > 0
+        ? (0, api_surface_js_1.formatApiSurfaceForPrompt)(ctx.apiSurface, relevantClasses)
+        : 'No page objects available. Use raw Playwright selectors via page.getByRole/getByTestId.';
+    const scenariosBlock = (ctx.decision.scenariosToAdd || [])
+        .map((s, i) => `  ${i + 1}. ${s}`)
+        .join('\n');
+    const existingBlock = ctx.existingSpecContent
+        ? `\nEXISTING SPEC (extend this file):\n\`\`\`typescript\n${ctx.existingSpecContent}\n\`\`\``
+        : '';
+    const modeInstruction = ctx.mode === 'create_spec'
+        ? `Create a NEW spec file at: ${ctx.specPath}`
+        : `ADD scenarios to the EXISTING spec at: ${ctx.specPath}`;
+    const routeFamilyTag = ctx.decision.routeFamily;
+    // Build prompt based on profile
+    const projectName = profile?.projectName || 'Project';
+    const testFramework = profile?.testFramework || 'Playwright';
+    const importStatement = profile?.importStatement || '@playwright/test';
+    // API test mode prompt
+    if (profile?.testMode === 'api') {
+        return buildApiTestPrompt(ctx, profile, scenariosBlock, routeFamilyTag);
+    }
+    // Build rules from profile conventions or use Mattermost defaults
+    const rules = isMM
+        ? [
+            `1. Import ONLY from "${importStatement}" — no other test framework imports.`,
+            '2. Every test must call `await pw.initSetup()` first.',
+            '3. Use `await pw.testBrowser.login(user)` to log in — never hardcode credentials.',
+            '4. Use ONLY page object methods listed above. Do NOT invent methods that are not listed.',
+            '5. If a method is not available, use `page.getByRole()` or `page.getByTestId()`.',
+            `6. Tag every test: {tag: '@${routeFamilyTag}'}`,
+            '7. Write one test per scenario with a descriptive name of what the user does and what is verified.',
+            `8. Use \`expect\` from "${importStatement}" — do NOT import from "@playwright/test".`,
+            '9. Include the copyright header for new files.',
+            '10. NEVER fabricate test IDs (MM-TXXXX). Use descriptive names only.',
+        ]
+        : [
+            ...(profile?.conventions || []).map((c, i) => `${i + 1}. ${c}`),
+            `${(profile?.conventions?.length || 0) + 1}. Use ONLY page object methods listed above. Do NOT invent methods that are not listed.`,
+            `${(profile?.conventions?.length || 0) + 2}. If a method is not available, use \`page.getByRole()\` or \`page.getByTestId()\`.`,
+            `${(profile?.conventions?.length || 0) + 3}. Tag every test: {tag: '@${routeFamilyTag}'}`,
+        ];
+    // Build example block
+    const exampleBlock = isMM
+        ? [
+            'EXAMPLE SPEC STRUCTURE:',
+            '```typescript',
+            '// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.',
+            '// See LICENSE.txt for license information.',
+            '',
+            `import {expect, test} from '${importStatement}';`,
+            '',
+            'test(',
+            "    'descriptive name of what is tested',",
+            `    {tag: '@${routeFamilyTag}'},`,
+            '    async ({pw}) => {',
+            '        const {user} = await pw.initSetup();',
+            '        const {channelsPage} = await pw.testBrowser.login(user);',
+            '        await channelsPage.goto();',
+            '        await channelsPage.toBeVisible();',
+            '        // test steps...',
+            '    },',
+            ');',
+            '```',
+        ]
+        : [
+            'EXAMPLE SPEC STRUCTURE:',
+            '```typescript',
+            ...(profile?.copyrightHeader ? [profile.copyrightHeader, ''] : []),
+            `import {test, expect} from '${importStatement}';`,
+            '',
+            'test(',
+            "    'descriptive name of what is tested',",
+            `    {tag: '@${routeFamilyTag}'},`,
+            '    async ({page}) => {',
+            '        // test steps...',
+            '    },',
+            ');',
+            '```',
+        ];
+    return [
+        `You are generating ${projectName} ${testFramework} E2E test code.`,
+        '',
+        `TASK: ${modeInstruction}`,
+        '',
+        `FLOW: ${(0, sanitize_js_1.sanitizeForPrompt)(ctx.decision.flowName)}`,
+        `Route Family: ${ctx.decision.routeFamily}${ctx.decision.featureId ? ` / ${ctx.decision.featureId}` : ''}`,
+        `Route: ${ctx.decision.specificRoute || '(not specified)'}`,
+        `Priority: ${ctx.decision.priority}`,
+        `Evidence: ${(0, sanitize_js_1.sanitizeForPrompt)(ctx.decision.evidence)}`,
+        '',
+        'SCENARIOS TO IMPLEMENT:',
+        scenariosBlock || '  (implement core user actions for this flow)',
+        '',
+        'USER ACTIONS:',
+        ctx.decision.userActions.map((a) => `  - ${(0, sanitize_js_1.sanitizeForPrompt)(a)}`).join('\n') || '  (none specified)',
+        '',
+        ...buildAssertionPatternsBlock(ctx.decision.assertionPatterns),
+        'AVAILABLE PAGE OBJECTS AND METHODS:',
+        apiBlock,
+        existingBlock,
+        '',
+        'MANDATORY RULES:',
+        ...rules,
+        '',
+        ...exampleBlock,
+        '',
+        'Return ONLY the TypeScript code. No explanations, no markdown fences.',
+    ].join('\n');
+}
+function buildApiTestPrompt(ctx, profile, scenariosBlock, routeFamilyTag) {
+    const modeInstruction = ctx.mode === 'create_spec'
+        ? `Create a NEW test file at: ${ctx.specPath}`
+        : `ADD test cases to the EXISTING file at: ${ctx.specPath}`;
+    const existingBlock = ctx.existingSpecContent
+        ? `\nEXISTING FILE (extend this):\n\`\`\`typescript\n${ctx.existingSpecContent}\n\`\`\``
+        : '';
+    return [
+        `You are generating ${profile.projectName} API test code using ${profile.testFramework}.`,
+        '',
+        `TASK: ${modeInstruction}`,
+        '',
+        `FLOW: ${(0, sanitize_js_1.sanitizeForPrompt)(ctx.decision.flowName)}`,
+        `Route Family: ${ctx.decision.routeFamily}${ctx.decision.featureId ? ` / ${ctx.decision.featureId}` : ''}`,
+        `Endpoint: ${ctx.decision.specificRoute || '(not specified)'}`,
+        `Priority: ${ctx.decision.priority}`,
+        `Evidence: ${(0, sanitize_js_1.sanitizeForPrompt)(ctx.decision.evidence)}`,
+        '',
+        'SCENARIOS TO IMPLEMENT:',
+        scenariosBlock || '  (implement core API endpoint tests)',
+        '',
+        'USER ACTIONS:',
+        ctx.decision.userActions.map((a) => `  - ${(0, sanitize_js_1.sanitizeForPrompt)(a)}`).join('\n') || '  (none specified)',
+        '',
+        ...buildAssertionPatternsBlock(ctx.decision.assertionPatterns),
+        existingBlock,
+        '',
+        'MANDATORY RULES:',
+        ...profile.conventions.map((c, i) => `${i + 1}. ${c}`),
+        `${profile.conventions.length + 1}. Tag every test: {tag: '@${routeFamilyTag}'}`,
+        '',
+        'EXAMPLE TEST STRUCTURE:',
+        ...(profile.testFramework.toLowerCase().includes('pytest')
+            ? [
+                '```python',
+                ...(profile.copyrightHeader ? [profile.copyrightHeader, ''] : []),
+                'import pytest',
+                'import requests',
+                '',
+                `BASE_URL = 'http://localhost:3000'`,
+                '',
+                '',
+                `class Test${ctx.decision.routeFamily.replace(/[^a-zA-Z0-9]/g, '')}:`,
+                "    def test_should_return_200_for_valid_request(self):",
+                `        res = requests.get(f'{BASE_URL}${ctx.decision.specificRoute || '/api/endpoint'}')`,
+                '        assert res.status_code == 200',
+                '```',
+            ]
+            : [
+                '```typescript',
+                ...(profile.copyrightHeader ? [profile.copyrightHeader, ''] : []),
+                `import {describe, it, expect} from '${profile.importStatement}';`,
+                "import supertest from 'supertest';",
+                '',
+                "const request = supertest('http://localhost:3000');",
+                '',
+                `describe('${ctx.decision.routeFamily}', () => {`,
+                "    it('should return 200 for valid request', async () => {",
+                `        const res = await request.get('${ctx.decision.specificRoute || '/api/endpoint'}');`,
+                '        expect(res.status).toBe(200);',
+                '    });',
+                '});',
+                '```',
+            ]),
+        '',
+        ...(profile.testFramework.toLowerCase().includes('pytest')
+            ? ['Return ONLY the Python code. No explanations, no markdown fences.']
+            : ['Return ONLY the TypeScript code. No explanations, no markdown fences.']),
+    ].join('\n');
+}
+function parseGenerationResponse(text, expectedPath, mode, flowId, profile) {
+    let code = text.trim();
+    const fenced = code.match(/^```(?:typescript|ts)?\s*([\s\S]*?)```\s*$/i);
+    if (fenced) {
+        code = fenced[1].trim();
+    }
+    if (!code.includes('test(') && !code.includes('it(') && !code.includes('describe(')) {
+        return null;
+    }
+    const importStatement = profile?.importStatement || '@playwright/test';
+    // Auto-add import if missing
+    if (!code.includes(importStatement)) {
+        if (profile?.testMode === 'api') {
+            code = `import {describe, it, expect} from '${importStatement}';\n\n${code}`;
+        }
+        else {
+            code = `import {expect, test} from '${importStatement}';\n\n${code}`;
+        }
+    }
+    return { specPath: expectedPath, code, mode, flowId };
+}
+const BUILT_IN_METHODS = new Set([
+    'click', 'fill', 'focus', 'hover', 'press', 'type', 'check', 'uncheck',
+    'selectOption', 'waitFor', 'waitForLoadState', 'evaluate', 'dispatchEvent',
+    'getAttribute', 'textContent', 'innerText', 'innerHTML',
+    'isVisible', 'isEnabled', 'isChecked', 'isHidden',
+    'toBeVisible', 'toBeEnabled', 'toBeChecked', 'toBeHidden',
+    'toContainText', 'toHaveText', 'toHaveURL', 'toHaveValue',
+    'not', 'nth', 'first', 'last', 'all',
+    'getByRole', 'getByText', 'getByLabel', 'getByPlaceholder',
+    'getByTestId', 'getByTitle', 'getByAltText',
+    'locator', 'frame', 'page', 'expect',
+    'goBack', 'goForward', 'reload', 'goto',
+    'keyboard', 'mouse', 'touchscreen', 'close', 'bringToFront',
+    'initSetup', 'login', 'waitUntil', 'skipIfNoLicense', 'ensureLicense',
+    'random', 'duration', 'isOutsideRemoteUserHour', 'setTimeout',
+    'skip', 'fixme', 'slow', 'fail',
+    // API testing built-ins
+    'get', 'post', 'put', 'patch', 'delete', 'send', 'set', 'query',
+    'toBe', 'toEqual', 'toBeDefined', 'toContain', 'toHaveProperty',
+    'toMatchObject', 'toHaveLength', 'toBeTruthy', 'toBeFalsy',
+]);
+/**
+ * Returns method names that appear in generated code but do not exist in the API surface.
+ * Detects all call patterns: await X.Y(), X.Y(), const z = X.Y(), chained calls.
+ */
+function detectHallucinatedMethods(code, apiSurface) {
+    const allMethods = new Set(apiSurface.pageObjects.flatMap((po) => po.methods.map((m) => m.name)));
+    const suspected = new Set();
+    const callPatterns = [
+        /\bawait\s+\w+\.([a-zA-Z_]\w*)\s*\(/g,
+        /\b(?:const|let|var)\s+\w+\s*=\s*\w+\.([a-zA-Z_]\w*)\s*\(/g,
+        /\b\w+Page\.([a-zA-Z_]\w*)\s*\(/g, // any *Page object (channelsPage, settingsPage, etc.)
+        /\b(?:pw|page|this)\.\w*\.?([a-zA-Z_]\w*)\s*\(/g,
+    ];
+    const generalCallRe = /\b[a-zA-Z_]\w*\.([a-zA-Z_]\w*)\s*\(/g;
+    for (const re of callPatterns) {
+        let match;
+        while ((match = re.exec(code)) !== null) {
+            const methodName = match[1];
+            if (!BUILT_IN_METHODS.has(methodName) && !allMethods.has(methodName) && methodName.length > 3) {
+                suspected.add(methodName);
+            }
+        }
+    }
+    let match;
+    while ((match = generalCallRe.exec(code)) !== null) {
+        const methodName = match[1];
+        if (!BUILT_IN_METHODS.has(methodName) &&
+            !allMethods.has(methodName) &&
+            methodName.length > 3 &&
+            !methodName.startsWith('to') &&
+            !methodName.startsWith('get')) {
+            suspected.add(methodName);
+        }
+    }
+    return [...suspected];
+}