@taodigital/agents 0.0.0-stage → 1.2.1

package/dist/field-detector-agent.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * ZeTa-AI Field Detector Agent
+ *
+ * Drafts an AppField catalog from one of three inputs:
+ *   (1) Rendered HTML — DOM detector reads form controls
+ *   (2) OpenAPI/Swagger JSON/YAML — schema detector reads request bodies
+ *   (3) Sample JSON payload — shape detector infers types from values
+ *
+ * Output is always FieldSchema[] in "unconfirmed" status.
+ * Persist via AppBrain.upsertAppField() after user review.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFieldsFromHtml = detectFieldsFromHtml;
+exports.detectFieldsFromApi = detectFieldsFromApi;
+exports.mergeIntoCatalog = mergeIntoCatalog;
+const app_brain_1 = require("@taodigital/app-brain");
+const llm_js_1 = require("./llm.js");
+const llm_config_js_1 = require("./llm-config.js");
+const core_1 = require("@taodigital/core");
+// ─── DOM mapping table (deterministic — no LLM needed for mapping, only for label inference) ──
+const DOM_ELEMENT_ROLE_MAP = {
+    'input:text': { elementRole: 'INPUT_TEXT', dataType: 'string', dataBearing: true },
+    'input:email': { elementRole: 'INPUT_EMAIL', dataType: 'email', dataBearing: true },
+    'input:password': { elementRole: 'INPUT_PASSWORD', dataType: 'string', dataBearing: true },
+    'input:number': { elementRole: 'INPUT_NUMBER', dataType: 'integer', dataBearing: true },
+    'input:tel': { elementRole: 'INPUT_TEXT', dataType: 'phone', dataBearing: true },
+    'input:url': { elementRole: 'INPUT_TEXT', dataType: 'url', dataBearing: true },
+    'input:date': { elementRole: 'DATE', dataType: 'date', dataBearing: true },
+    'input:datetime-local': { elementRole: 'DATE', dataType: 'datetime', dataBearing: true },
+    'input:checkbox': { elementRole: 'CHECKBOX', dataType: 'boolean', dataBearing: true },
+    'input:radio': { elementRole: 'RADIO', dataType: 'enum', dataBearing: true },
+    'input:file': { elementRole: 'FILE', dataType: 'file', dataBearing: true },
+    'input:search': { elementRole: 'INPUT_TEXT', dataType: 'string', dataBearing: true },
+    'input:color': { elementRole: 'INPUT_TEXT', dataType: 'string', dataBearing: true },
+    'textarea': { elementRole: 'TEXTAREA', dataType: 'string', dataBearing: true },
+    'select': { elementRole: 'SELECT', dataType: 'enum', dataBearing: true },
+    'button': { elementRole: 'BUTTON', dataType: 'string', dataBearing: false },
+    'a': { elementRole: 'LINK', dataType: 'string', dataBearing: false },
+    'toggle': { elementRole: 'TOGGLE', dataType: 'boolean', dataBearing: false },
+};
+function inferPiiClass(label, fieldKey) {
+    const s = (label + ' ' + fieldKey).toLowerCase();
+    if (/password|ssn|aadhaar|pan|card.?(number|num|no)|cvv|cvc|secret|token|private/.test(s))
+        return 'high';
+    if (/email|phone|mobile|name|address|dob|birth|gender|salary|income/.test(s))
+        return 'low';
+    return 'none';
+}
+const HTML_DETECTION_SYSTEM_DEFAULT = `You extract a test-data field catalog from HTML.
+
+For every form control, emit one FieldSchema JSON object.
+
+MAPPING RULES:
+- dataBearing = false for <button>, <a>, role="button", toggles/switches, submit buttons.
+  These still get a row (cases grounded on them need a catalog entry) but have NO datasets.
+- Skip hidden, disabled, and aria-hidden elements entirely.
+- Pull constraints ONLY from real HTML attributes: min, max, minlength, maxlength, pattern,
+  step, required, accept, <option> values. Never invent constraints.
+- Group <input type="radio"> sharing the same name into ONE enum field; enumValues = the radio values.
+- Derive label (priority): <label for=> text → aria-label → placeholder → name attribute.
+- Derive fieldKey: name → id → snake_case of label. Unique per form; append _2, _3 on collision.
+- piiClass: infer from name/label keywords (password/ssn/card → high; email/phone/name → low; else none).
+- exampleValue: one realistic value satisfying the constraints. For piiClass=high, use obviously-synthetic
+  (e.g. "Test User", "4111111111111111") — never real-looking sensitive data.
+- If type is uncertain, use dataType:"string" and add notes:"type inferred, confirm".
+
+OUTPUT: valid JSON only — { "fields": FieldSchema[] }. No preamble, no markdown.
+
+Each FieldSchema has: fieldKey, label, elementRole, dataBearing, dataType, required,
+and any applicable: minLength, maxLength, minValue, maxValue, precision, regex, enumValues,
+piiClass, exampleValue, relationGroup, notes.`;
+const API_DETECTION_SYSTEM_DEFAULT = `You extract a test-data field catalog from an API contract or sample payload.
+
+For OpenAPI/Swagger:
+  - type:string + format:email → dataType:email; format:date/date-time → date/datetime;
+    format:uri → url; format:phone → phone; type:integer → integer; type:number → decimal
+    (precision from multipleOf if present); type:boolean → boolean.
+  - Constraints: minLength/maxLength, minimum/maximum → minValue/maxValue, pattern → regex,
+    required[] → required:true, enum → dataType:enum + enumValues.
+  - All payload fields: dataBearing = true.
+
+For raw JSON sample:
+  - Infer dataType from the value: email-pattern → email, ISO-date → date,
+    number → integer (if no decimal) or decimal, true/false → boolean, else string.
+  - No structural constraints available → add notes:"inferred from sample — confirm constraints".
+
+Common rules:
+  - Nested objects: flatten with dot keys (e.g. "beneficiary.ifsc_code") as fieldKey.
+  - Arrays: emit the element field once, notes:"repeats in array".
+  - piiClass by keyword inference; synthetic exampleValue for piiClass=high.
+
+OUTPUT: valid JSON only — { "fields": FieldSchema[] }. No preamble, no markdown.`;
+async function detectFieldsFromHtml(opts) {
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(opts.tenantId, 'testGeneration');
+    const user = `HTML TO ANALYZE:\n\`\`\`html\n${opts.html.slice(0, 40_000)}\n\`\`\``;
+    const t0 = Date.now();
+    const seed = (0, llm_js_1.deterministicSeed)(`${opts.tenantId}:${opts.projectId}:html-fields:${opts.html.slice(0, 500)}`);
+    const htmlSystem = await (0, core_1.getAgentPrompt)('field-detector-html', undefined, opts.tenantId) ?? HTML_DETECTION_SYSTEM_DEFAULT;
+    const { text: raw, usage } = await (0, llm_js_1.askTracked)(htmlSystem, user, llmCfg, undefined, undefined, { temperature: 0, seed });
+    const latencyMs = Date.now() - t0;
+    (0, app_brain_1.recordLLMCall)({
+        tenantId: opts.tenantId,
+        projectId: opts.projectId,
+        agentType: 'data',
+        label: 'field_detection_html',
+        entityId: opts.projectId,
+        entityType: 'field_catalog',
+        usage,
+        latencyMs,
+    }).catch(console.error);
+    return parseFieldsFromLlmOutput(raw);
+}
+async function detectFieldsFromApi(opts) {
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(opts.tenantId, 'testGeneration');
+    const user = `API CONTRACT / SAMPLE PAYLOAD:\n\`\`\`\n${opts.input.slice(0, 40_000)}\n\`\`\``;
+    const t0 = Date.now();
+    const seed = (0, llm_js_1.deterministicSeed)(`${opts.tenantId}:${opts.projectId}:api-fields:${opts.input.slice(0, 500)}`);
+    const apiSystem = await (0, core_1.getAgentPrompt)('field-detector-api', undefined, opts.tenantId) ?? API_DETECTION_SYSTEM_DEFAULT;
+    const { text: raw, usage } = await (0, llm_js_1.askTracked)(apiSystem, user, llmCfg, undefined, undefined, { temperature: 0, seed });
+    const latencyMs = Date.now() - t0;
+    (0, app_brain_1.recordLLMCall)({
+        tenantId: opts.tenantId,
+        projectId: opts.projectId,
+        agentType: 'data',
+        label: 'field_detection_api',
+        entityId: opts.projectId,
+        entityType: 'field_catalog',
+        usage,
+        latencyMs,
+    }).catch(console.error);
+    return parseFieldsFromLlmOutput(raw);
+}
+function parseFieldsFromLlmOutput(raw) {
+    const jsonStart = raw.indexOf('{');
+    const jsonEnd = raw.lastIndexOf('}');
+    if (jsonStart === -1 || jsonEnd === -1)
+        return [];
+    try {
+        const parsed = JSON.parse(raw.slice(jsonStart, jsonEnd + 1));
+        const fields = (parsed.fields ?? []).map((f) => ({
+            fieldKey: String(f.fieldKey ?? '').slice(0, 80),
+            label: String(f.label ?? f.fieldKey ?? ''),
+            elementRole: f.elementRole ?? 'OTHER',
+            dataBearing: f.dataBearing !== false,
+            dataType: f.dataType ?? 'string',
+            required: f.required === true,
+            minLength: f.minLength != null ? Number(f.minLength) : undefined,
+            maxLength: f.maxLength != null ? Number(f.maxLength) : undefined,
+            minValue: f.minValue != null ? Number(f.minValue) : undefined,
+            maxValue: f.maxValue != null ? Number(f.maxValue) : undefined,
+            precision: f.precision != null ? Number(f.precision) : undefined,
+            regex: f.regex ?? undefined,
+            enumValues: Array.isArray(f.enumValues) ? f.enumValues.map(String) : undefined,
+            piiClass: f.piiClass ?? inferPiiClass(f.label ?? '', f.fieldKey ?? ''),
+            exampleValue: f.exampleValue ?? undefined,
+            relationGroup: f.relationGroup ?? undefined,
+            notes: f.notes ?? undefined,
+            status: 'unconfirmed',
+        }));
+        // Dedup by fieldKey (keep first occurrence)
+        const seen = new Set();
+        return fields.filter((f) => {
+            if (!f.fieldKey || seen.has(f.fieldKey))
+                return false;
+            seen.add(f.fieldKey);
+            return true;
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Merge auto-detected fields into the project catalog.
+ * Preserves human-edited piiClass, notes, and status on existing rows.
+ */
+async function mergeIntoCatalog(opts) {
+    const existing = await app_brain_1.AppBrain.listAppFields(opts.tenantId, opts.projectId);
+    const existingByKey = new Map(existing.map((r) => [r.fieldKey, r]));
+    let added = 0, updated = 0, unchanged = 0;
+    for (const field of opts.detected) {
+        const current = existingByKey.get(field.fieldKey);
+        if (!current) {
+            await app_brain_1.AppBrain.upsertAppField(opts.tenantId, opts.projectId, { ...field, status: 'unconfirmed' });
+            added++;
+        }
+        else {
+            // Never overwrite human-edited fields
+            const merged = {
+                ...field,
+                piiClass: current.piiClass ?? field.piiClass,
+                notes: current.notes ?? field.notes,
+                status: current.status ?? 'unconfirmed',
+            };
+            // Only update if structural fields changed
+            const changed = current.elementRole !== merged.elementRole ||
+                current.dataBearing !== merged.dataBearing ||
+                current.dataType !== merged.dataType ||
+                current.required !== merged.required ||
+                current.minLength !== (merged.minLength ?? null) ||
+                current.maxLength !== (merged.maxLength ?? null);
+            if (changed) {
+                await app_brain_1.AppBrain.upsertAppField(opts.tenantId, opts.projectId, merged);
+                updated++;
+            }
+            else {
+                unchanged++;
+            }
+        }
+    }
+    // Mark fields no longer seen in the page as stale (but do NOT delete)
+    const detectedKeys = new Set(opts.detected.map((f) => f.fieldKey));
+    for (const row of existing) {
+        if (!detectedKeys.has(row.fieldKey) && row.status !== 'stale') {
+            await app_brain_1.AppBrain.confirmAppField(opts.tenantId, opts.projectId, row.fieldKey, { status: 'stale' });
+        }
+    }
+    return { added, updated, unchanged };
+}

package/dist/flow-agent.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Flow Agent — KAG + CAG Journey Test Generator
+ *
+ * Generates cross-screen E2E journey test cases by combining:
+ *   KAG: the navigation graph path (which elements link which screens)
+ *   CAG: per-screen grounding context (elements, skill files)
+ *
+ * A journey test case spans multiple screens:
+ *   Given I am on LoginScreen
+ *   When I enter valid credentials and click "Sign in"
+ *   Then I navigate to DashboardScreen
+ *   When I click "New Project"
+ *   Then I navigate to ProjectSetupScreen
+ *   And the form shows required fields...
+ *
+ * Test kinds generated: E2E, REGRESSION, SMOKE, SANITY
+ */
+export interface FlowEdge {
+    fromScreenId: string;
+    toScreenId: string;
+    viaElementMeaning: string;
+}
+export interface FlowTestCase {
+    title: string;
+    kind: 'E2E' | 'REGRESSION' | 'SMOKE' | 'SANITY';
+    priority: 'CRITICAL' | 'HIGH' | 'MEDIUM';
+    steps: string[];
+    expectedResult: string;
+    preconditions: string;
+    groundedOn: string[];
+    tags: string[];
+}
+export declare function generateFlowTestCases(opts: {
+    tenantId: string;
+    projectId: string;
+    startScreenId: string;
+    endScreenId: string;
+    path: FlowEdge[];
+}): Promise<{
+    status: string;
+    cases: never[];
+    saved: null;
+    screenCount?: undefined;
+    suiteName?: undefined;
+} | {
+    status: string;
+    cases: never[];
+    saved: null;
+    screenCount: number;
+    suiteName?: undefined;
+} | {
+    status: string;
+    cases: FlowTestCase[];
+    saved: {
+        suite: {
+            tenantId: string;
+            id: string;
+            projectId: string;
+            name: string;
+            createdAt: Date;
+            genModel: string | null;
+            category: import(".prisma/client").$Enums.SuiteCategory | null;
+            parentId: string | null;
+            ownerUserId: string | null;
+            genTotalTokens: number | null;
+            genTotalCostUsd: number | null;
+            genAt: Date | null;
+            genScreenCount: number | null;
+            coverageReport: import("@prisma/client/runtime/library").JsonValue | null;
+        };
+        testCases: {
+            tenantId: string;
+            screenId: string | null;
+            id: string;
+            projectId: string;
+            source: string;
+            status: string;
+            createdAt: Date;
+            updatedAt: Date;
+            steps: import("@prisma/client/runtime/library").JsonValue;
+            kind: string;
+            tags: import("@prisma/client/runtime/library").JsonValue;
+            approvedBy: string | null;
+            suiteId: string;
+            ref: string | null;
+            title: string;
+            priority: string;
+            preconditions: string | null;
+            expectedResult: string | null;
+            gherkin: string | null;
+            approvedAt: Date | null;
+            groundedOn: import("@prisma/client/runtime/library").JsonValue;
+            caseRefs: import("@prisma/client/runtime/library").JsonValue;
+            viewports: import("@prisma/client/runtime/library").JsonValue;
+            viewportConstraint: string;
+            techniqueOfRecord: string | null;
+            traceTo: string | null;
+            traceToExtra: import("@prisma/client/runtime/library").JsonValue;
+            testDataInline: import("@prisma/client/runtime/library").JsonValue | null;
+            dataNote: string | null;
+            scriptNote: string | null;
+            structuredSteps: import("@prisma/client/runtime/library").JsonValue | null;
+            artifactId: string | null;
+            scenarioId: string | null;
+            suspect: boolean;
+            suspectReason: string | null;
+            flakyScore: number;
+            consecutiveFlakes: number;
+            lastFlakyAt: Date | null;
+            quarantined: boolean;
+            quarantinedAt: Date | null;
+            quarantineReason: string | null;
+            genPromptTokens: number | null;
+            genCompletionTokens: number | null;
+            genCostUsd: number | null;
+            genModel: string | null;
+            dataSetId: string | null;
+            repoTargetPath: string | null;
+            stepsKey: string | null;
+            gherkinKey: string | null;
+            contentHash: string | null;
+            groundingHash: string | null;
+            locatorsJson: import("@prisma/client/runtime/library").JsonValue | null;
+            locatorsExtractedAt: Date | null;
+            captureStepScreenshots: import("@prisma/client/runtime/library").JsonValue | null;
+        }[];
+    };
+    screenCount: number;
+    suiteName: string;
+}>;

package/dist/flow-agent.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Flow Agent — KAG + CAG Journey Test Generator
+ *
+ * Generates cross-screen E2E journey test cases by combining:
+ *   KAG: the navigation graph path (which elements link which screens)
+ *   CAG: per-screen grounding context (elements, skill files)
+ *
+ * A journey test case spans multiple screens:
+ *   Given I am on LoginScreen
+ *   When I enter valid credentials and click "Sign in"
+ *   Then I navigate to DashboardScreen
+ *   When I click "New Project"
+ *   Then I navigate to ProjectSetupScreen
+ *   And the form shows required fields...
+ *
+ * Test kinds generated: E2E, REGRESSION, SMOKE, SANITY
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFlowTestCases = generateFlowTestCases;
+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");
+async function generateFlowTestCases(opts) {
+    if (opts.path.length === 0) {
+        return { status: 'NO_PATH', cases: [], saved: null };
+    }
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(opts.tenantId, 'appBrain');
+    // Build ordered list of screen IDs in the journey
+    const screenIds = [opts.startScreenId, ...opts.path.map(e => e.toScreenId)];
+    const uniqueScreenIds = [...new Set(screenIds)];
+    // Load CAG context for each screen in the path
+    const grounding = (0, app_brain_1.groundingFor)(false);
+    const screenContexts = [];
+    for (const edge of [{ fromScreenId: '', toScreenId: opts.startScreenId, viaElementMeaning: '' }, ...opts.path]) {
+        const screenId = edge.toScreenId;
+        let ctx;
+        try {
+            const groundCtx = await grounding.ground(opts.tenantId, opts.projectId, screenId);
+            ctx = {
+                screenId,
+                screenName: groundCtx.screenName,
+                url: groundCtx.url,
+                elements: groundCtx.elements,
+                viaElement: edge.viaElementMeaning || undefined,
+            };
+        }
+        catch {
+            // Screen might not have detailed data — use minimal context
+            ctx = {
+                screenId,
+                screenName: `Screen ${screenId.slice(-6)}`,
+                elements: [],
+                viaElement: edge.viaElementMeaning || undefined,
+            };
+        }
+        screenContexts.push(ctx);
+    }
+    // Load global skill files once (not per-screen)
+    const GLOBAL_KINDS = ['TECH_STACK', 'AUTH_SESSION', 'BUSINESS_DOMAIN', 'INTERACTION_PATTERNS', 'ERROR_CATALOGUE'];
+    const globalFiles = await app_brain_1.AppBrain.listSkillFiles(opts.tenantId, opts.projectId, GLOBAL_KINDS);
+    const skillFileCtx = globalFiles.map(sf => `### ${sf.kind}\n${sf.content}`).join('\n\n');
+    // Build journey description for the LLM
+    const ELEMENT_LIMIT = parseInt(process.env.FLOW_ELEMENT_LIMIT ?? '8', 10);
+    const journeyDesc = screenContexts
+        .map((sc, i) => {
+        const nav = sc.viaElement ? `  Navigation: via "${sc.viaElement}"` : '';
+        const elList = sc.elements.slice(0, ELEMENT_LIMIT).map(e => `    - ${e.role}: "${e.meaning}"${e.expectedData ? ` (${e.expectedData})` : ''}`).join('\n');
+        return `Screen ${i + 1}: ${sc.screenName}${sc.url ? ` (${sc.url})` : ''}\n${nav}\n  Elements:\n${elList || '    (no elements extracted)'}`;
+    })
+        .join('\n\n');
+    const SYSTEM_DEFAULT = `You are an expert QA engineer generating cross-screen E2E journey test cases.
+You generate tests for user journeys that span multiple screens.
+
+GROUNDING RULES:
+- Only reference elements that exist in the listed screens
+- Each step must name the screen it's on: "On [ScreenName]: ..."
+- Preconditions must state the starting URL or state
+- Expected results must be specific and verifiable
+- Do NOT invent elements, features, or behaviors not listed
+
+OUTPUT FORMAT — return valid JSON array only, no markdown:
+[
+  {
+    "title": "string (concise journey title)",
+    "kind": "E2E|REGRESSION|SMOKE|SANITY",
+    "priority": "CRITICAL|HIGH|MEDIUM",
+    "preconditions": "string",
+    "steps": ["step1", "step2", ...],
+    "expectedResult": "string",
+    "groundedOn": ["ScreenName.ElementMeaning", ...],
+    "tags": ["journey", ...]
+  }
+]`;
+    const user = `Generate E2E journey test cases for this ${screenContexts.length}-screen user journey:
+
+${journeyDesc}
+
+SKILL FILE CONTEXT (business rules, tech stack, auth patterns):
+${skillFileCtx.slice(0, 3000)}
+
+Generate these test kinds for this journey:
+1. SMOKE (1 TC): Happy path — user completes the full journey successfully
+2. E2E (2-3 TCs): Full journey variations — valid data, edge cases, required field combos
+3. REGRESSION (1-2 TCs): Critical regression scenarios that must pass on every release
+4. SANITY (1 TC): Quick sanity — confirm navigation between screens works at all
+
+Rules:
+- Steps must reference ACTUAL screen names and ACTUAL element names from the journey above
+- Each step format: "On [ScreenName]: [action] [element] [with/to value]"
+- Never invent screen names or element names
+- groundedOn: list of "ScreenName.ElementMeaning" pairs that this test exercises`;
+    const pathKey = opts.path.map((e) => `${e.fromScreenId}->${e.toScreenId}`).join('|');
+    const seed = (0, llm_js_1.deterministicSeed)(`${opts.tenantId}:${opts.projectId}:flow:${opts.startScreenId}:${opts.endScreenId}:${pathKey}`);
+    const system = await (0, core_1.getAgentPrompt)('flow-e2e-generation', undefined, opts.tenantId) ?? SYSTEM_DEFAULT;
+    let parsed = [];
+    const t0 = Date.now();
+    try {
+        const { text: raw, usage } = await (0, llm_js_1.askTracked)(system, user, llmCfg, undefined, undefined, { temperature: 0, seed });
+        const latencyMs = Date.now() - t0;
+        (0, app_brain_1.recordLLMCall)({
+            tenantId: opts.tenantId,
+            projectId: opts.projectId,
+            agentType: 'flow',
+            label: `flow_journey_${screenContexts.length}screens`,
+            entityType: 'flow',
+            usage,
+            latencyMs,
+        }).catch(console.error);
+        const jsonMatch = raw.match(/\[[\s\S]*\]/);
+        if (jsonMatch) {
+            const items = JSON.parse(jsonMatch[0]);
+            parsed = items.filter(tc => tc.title && Array.isArray(tc.steps) && tc.steps.length >= 2).map(tc => ({
+                title: String(tc.title).slice(0, 200),
+                kind: ['E2E', 'REGRESSION', 'SMOKE', 'SANITY'].includes(tc.kind) ? tc.kind : 'E2E',
+                priority: ['CRITICAL', 'HIGH', 'MEDIUM'].includes(tc.priority) ? tc.priority : 'HIGH',
+                steps: tc.steps.map(s => String(s).slice(0, 400)),
+                expectedResult: String(tc.expectedResult || '').slice(0, 500),
+                preconditions: String(tc.preconditions || '').slice(0, 300),
+                groundedOn: Array.isArray(tc.groundedOn) ? tc.groundedOn.map(String) : [],
+                tags: ['journey', `${screenContexts.length}-screen`, ...(Array.isArray(tc.tags) ? tc.tags.map(String) : [])],
+            }));
+        }
+    }
+    catch (e) {
+        console.error('[flow-agent] LLM parse error:', e?.message);
+    }
+    if (parsed.length === 0) {
+        return { status: 'LLM_EMPTY', cases: [], saved: null, screenCount: screenContexts.length };
+    }
+    // Save under a "Journey" suite — named after start→end screens
+    const startName = screenContexts[0]?.screenName ?? 'Start';
+    const endName = screenContexts[screenContexts.length - 1]?.screenName ?? 'End';
+    const suiteName = `Journey: ${startName} → ${endName}`;
+    const saved = await app_brain_1.AppBrain.saveGeneratedTestCases(opts.tenantId, opts.projectId, suiteName, parsed.map(tc => ({
+        ...tc,
+        screenId: opts.startScreenId,
+        source: 'AI_GENERATED',
+    })));
+    console.log(`[flow-agent] ${suiteName}: ${parsed.length} journey TCs across ${screenContexts.length} screens`);
+    return {
+        status: 'GENERATED',
+        cases: parsed,
+        saved,
+        screenCount: screenContexts.length,
+        suiteName,
+    };
+}

package/dist/github-agent.d.ts

@@ -0,0 +1,18 @@
+import { type LLMConfig } from './llm.js';
+/**
+ * Analyzes Git diffs and PR descriptions to map code changes
+ * to potentially impacted screens or test suites.
+ */
+export declare function analyzeCodeImpact(prTitle: string, prBody: string, diffStats: {
+    file: string;
+    additions: number;
+    deletions: number;
+}[], knownScreens: {
+    id: string;
+    name: string;
+    url: string;
+}[], llmCfg?: LLMConfig): Promise<{
+    impactedScreenIds: string[];
+    reasoning: string;
+    suggestedTestKinds: string[];
+}>;

package/dist/github-agent.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeCodeImpact = analyzeCodeImpact;
+const core_1 = require("@taodigital/core");
+const llm_js_1 = require("./llm.js");
+/**
+ * Analyzes Git diffs and PR descriptions to map code changes
+ * to potentially impacted screens or test suites.
+ */
+async function analyzeCodeImpact(prTitle, prBody, diffStats, knownScreens, llmCfg) {
+    const SYSTEM_DEFAULT = [
+        'You are a Test Impact Analyzer.',
+        'Review the PR title, description, and files changed.',
+        'Map the changes to the provided list of known application screens.',
+        'Return valid JSON: { "impactedScreenIds": string[], "reasoning": string, "suggestedTestKinds": string[] }',
+        'suggestedTestKinds should be an array of: "POSITIVE", "NEGATIVE", "EDGE", "SECURITY", "ACCESSIBILITY", "INTEGRATION", "API"'
+    ].join('\n');
+    const system = await (0, core_1.getAgentPrompt)('github-impact-analysis') ?? SYSTEM_DEFAULT;
+    const user = [
+        `PR: ${prTitle}`,
+        `Body:\n${prBody.slice(0, 1000)}`,
+        '',
+        'Files Changed:',
+        ...diffStats.slice(0, 50).map(f => `- ${f.file} (+${f.additions} -${f.deletions})`),
+        '',
+        'Known Screens:',
+        ...knownScreens.map(s => `[ID: ${s.id}] ${s.name} (${s.url})`),
+    ].join('\n');
+    try {
+        const seed = (0, llm_js_1.deterministicSeed)(`code-impact:${prTitle.slice(0, 100)}:${diffStats.slice(0, 5).map(f => f.file).join('|')}`);
+        const { text: raw } = await (0, llm_js_1.askTracked)(system, user, llmCfg, undefined, undefined, { temperature: 0, seed });
+        const cleaned = raw.replace(/^```[\w-]*\n?/m, '').replace(/\n?```$/m, '').trim();
+        return JSON.parse(cleaned);
+    }
+    catch (err) {
+        console.error('[github-agent] Failed to analyze code impact', err);
+        return { impactedScreenIds: [], reasoning: 'Analysis failed', suggestedTestKinds: [] };
+    }
+}

package/dist/github-write-agent.d.ts

@@ -0,0 +1,67 @@
+/**
+ * GitHub write operations — branch, commit, PR creation.
+ * Uses GitHub REST API v3 (no SDK dependency — just fetch).
+ * Works with PAT, fine-grained PAT, and GitHub App installation tokens.
+ */
+export declare function getRefSha(token: string, repo: string, ref: string): Promise<string>;
+export declare function createBranch(token: string, repo: string, branchName: string, fromSha: string): Promise<void>;
+export declare function branchExists(token: string, repo: string, branchName: string): Promise<boolean>;
+/**
+ * Fetch the current content of a file from GitHub (from the default branch).
+ * Returns the decoded text content, or null if the file doesn't exist.
+ */
+export declare function getFileContent(token: string, repo: string, path: string, ref?: string): Promise<string | null>;
+/**
+ * Merge new spec content into existing spec content.
+ * Strategy: append new test() / it() / @Test blocks inside the outermost describe/class wrapper.
+ * If no wrapper found, append at end.
+ * Returns merged content.
+ */
+export declare function mergeSpecContent(existing: string, incoming: string): string;
+export interface FileToCommit {
+    path: string;
+    content: string;
+}
+export declare function createCommitWithFiles(token: string, repo: string, baseSha: string, files: FileToCommit[], message: string): Promise<{
+    commitSha: string;
+    treeSha: string;
+}>;
+export declare function updateBranchRef(token: string, repo: string, branchName: string, commitSha: string): Promise<void>;
+export interface CreatePROptions {
+    token: string;
+    repo: string;
+    title: string;
+    body: string;
+    head: string;
+    base: string;
+    draft?: boolean;
+}
+export interface PRResult {
+    prNumber: number;
+    prUrl: string;
+    headSha: string;
+    branch: string;
+}
+export declare function createPullRequest(opts: CreatePROptions): Promise<PRResult>;
+export interface PushScriptsPROptions {
+    token: string;
+    repo: string;
+    baseBranch: string;
+    branchName: string;
+    files: FileToCommit[];
+    prTitle: string;
+    prBody: string;
+    draft?: boolean;
+}
+export declare function pushScriptsAsPR(opts: PushScriptsPROptions): Promise<PRResult>;
+/**
+ * Generate a short-lived JWT for GitHub App authentication.
+ * APP_ID and privateKeyPem come from env / DB. JWT expires in 10 min.
+ */
+export declare function buildGitHubAppJWT(appId: string, privateKeyPem: string): string;
+/**
+ * Exchange a GitHub App JWT for an installation access token (1-hour expiry).
+ */
+export declare function getGitHubAppInstallationToken(appId: string, privateKeyPem: string, installationId: number): Promise<string>;
+export declare function addPRComment(token: string, repo: string, prNumber: number, body: string): Promise<void>;
+export declare function verifyGitHubWebhookSignature(rawBody: string | Buffer, signatureHeader: string, secret: string): boolean;