@taodigital/agents 0.0.0-stage → 1.2.0

package/README.md

@@ -1,3 +1,100 @@
-# Temporary Holding Version
+# @detiq/agents — Generation Agents & E2E Evaluation Harness
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+AI agents that produce test artifacts grounded in the ZeTa Core, coordinated by orchestrators:
+- `DualContextOrchestrator` / `SwarmOrchestrator`: Multi-agent pipeline coordinating CAG (Component-Augmented Generation) and KAG (Knowledge-Augmented Generation).
+- `test-case-agent.ts`: 22-pass test case generation grounded in real crawled elements with semantic dedup.
+- `data-agent.ts`: Realistic synthetic test data and slot generation matching field constraints.
+- `script-agent.ts`: Deterministic Playwright test script generation and linting.
+- `alignment-agent.ts`: Verification of script actions against test case steps.
+- `llm.ts`: Choke-point wrapper around LLM providers with token tracking, caching, and error sanitization.
+- `llm-mock.ts`: Mock / record / replay engine for zero-cost, deterministic CI runs.
+
+---
+
+## E2E Evaluation Harness (`scripts/agent-e2e.ts`)
+
+The E2E harness tests the entire agent pipeline from screen fixture to verified Playwright script without requiring live browser crawling or UI clicks.
+
+### Commands
+
+```bash
+# 1. Run all fixtures in mock mode (CI default, zero token cost)
+npm run e2e -- --fixture all --mock --fail-on-assert
+
+# 2. Run a specific fixture
+npm run e2e -- --fixture login --mock
+
+# 3. Run against an existing project in the database
+npm run e2e -- --project <projectId> --screen <screenId>
+
+# 4. Limit pipeline stages
+npm run e2e -- --fixture login --mock --stages cases,data
+
+# 5. Output JSON report for CI/monitoring
+npm run e2e -- --fixture all --mock --json report.json
+```
+
+---
+
+## Mock & Record Modes
+
+The mock engine intercepts calls in `askTracked` and `askTrackedWithImages`.
+
+| Environment Variable | Value | Description |
+|---|---|---|
+| `ZETA_LLM_MOCK` | `1` or `replay` | Replays saved fixtures from `eval/fixtures/llm/`. Falls back to schema-valid deterministic mock if fixture is missing. |
+| `ZETA_LLM_MOCK` | `record` | Hits the live LLM provider and automatically records prompt/response pairs to `eval/fixtures/llm/` for future replay. |
+| `ZETA_LLM_MOCK_FAIL` | `429` \| `503` \| `malformed-json` \| `empty` | Injects synthetic provider failures to test error handling and retry resilience. |
+
+> **Safety:** `ZETA_LLM_MOCK` immediately throws an exception if `NODE_ENV=production`.
+
+---
+
+## Golden Set Evaluation (`eval/`)
+
+```
+eval/
+  fixtures/screens/<name>.json     # Screen + elements as captured by crawler
+  fixtures/llm/<key>.json          # Recorded LLM responses for deterministic replay
+  golden/<name>.golden.json        # Golden assertion criteria (minCases, kinds, title pattern)
+  baseline.json                    # Historical score baseline
+  run-eval.ts                      # Evaluator runner comparing outputs against baseline
+```
+
+### Golden Evaluation Commands
+
+```bash
+# Run eval across all golden screens
+npm run eval
+
+# Accept current scores and update baseline.json
+npm run eval:accept
+
+# Run eval for specific screens only
+npm run eval -- login checkout
+```
+
+### Golden Spec Format (`eval/golden/<name>.golden.json`)
+
+```json
+{
+  "screen": "login",
+  "minCases": 12,
+  "mockMinCases": 1,
+  "mustHaveKinds": ["FUNCTIONAL", "SECURITY"],
+  "kindMinimums": { "SECURITY": 2 },
+  "maxDuplicateRatio": 0.10,
+  "titlePattern": "^[^—]+ — [^—]+ — .+$",
+  "requiredCoverageTerms": ["invalid password", "empty email", "sql injection"],
+  "script": { "minAlignment": 75, "maxLintViolations": 0 }
+}
+```
+
+---
+
+## CI Integration
+
+Mock evaluation is automated via GitHub Actions in [`.github/workflows/agents-eval.yml`](file:///Users/deepak/Downloads/Projects/Zeta-AI-Final/quality-intelligence-platform/.github/workflows/agents-eval.yml):
+- Triggers on PRs modifying `packages/agents/**`, `packages/core/**`, `packages/app-brain/**`, or agent prompt seeds.
+- Runs unit tests and `npm run e2e -- --fixture all --mock --fail-on-assert`.
+- Uploads `report.json` as a build artifact.

package/dist/api-test-agent.d.ts

@@ -0,0 +1,126 @@
+/**
+ * API Test Agent — Endpoint Contract & Behavior Testing
+ *
+ * Reads API_CONTRACT + DATA_MODEL skill files captured during crawl,
+ * generates test cases validating backend endpoint contracts:
+ * status codes, request schemas, auth, error handling — no UI required.
+ *
+ * Test kinds: API, NEGATIVE, EDGE
+ * Steps use Playwright APIRequestContext syntax.
+ */
+export interface ApiTestCase {
+    title: string;
+    kind: 'API' | 'NEGATIVE' | 'EDGE';
+    priority: 'CRITICAL' | 'HIGH' | 'MEDIUM';
+    endpoint: string;
+    method: string;
+    preconditions: string;
+    steps: string[];
+    expectedResult: string;
+    groundedOn: string[];
+    tags: string[];
+}
+export declare function generateApiTests(opts: {
+    tenantId: string;
+    projectId: string;
+    apiEndpoints?: Array<{
+        method: string;
+        urlPattern: string;
+    }>;
+}): Promise<{
+    status: string;
+    cases: never[];
+    saved: null;
+    suiteName?: undefined;
+} | {
+    status: string;
+    cases: ApiTestCase[];
+    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;
+        }[];
+    };
+    suiteName: string;
+}>;
+export declare function generatePactContract(endpoints: Array<{
+    method: string;
+    path: string;
+    summary?: string;
+    operationId?: string;
+}>, options: {
+    consumerName: string;
+    providerName: string;
+}): Promise<string>;
+type JsonSchema = Record<string, unknown>;
+export declare function generateSyntheticValue(fieldName: string, schemaType?: string): string | number | boolean | null;
+export declare function generateSyntheticBody(schema?: JsonSchema): Record<string, unknown>;
+export {};

package/dist/api-test-agent.js

@@ -0,0 +1,267 @@
+"use strict";
+/**
+ * API Test Agent — Endpoint Contract & Behavior Testing
+ *
+ * Reads API_CONTRACT + DATA_MODEL skill files captured during crawl,
+ * generates test cases validating backend endpoint contracts:
+ * status codes, request schemas, auth, error handling — no UI required.
+ *
+ * Test kinds: API, NEGATIVE, EDGE
+ * Steps use Playwright APIRequestContext syntax.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApiTests = generateApiTests;
+exports.generatePactContract = generatePactContract;
+exports.generateSyntheticValue = generateSyntheticValue;
+exports.generateSyntheticBody = generateSyntheticBody;
+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");
+// GAP-010: helper for batched endpoint processing
+function chunkArray(arr, size) {
+    const chunks = [];
+    for (let i = 0; i < arr.length; i += size) {
+        chunks.push(arr.slice(i, i + size));
+    }
+    return chunks;
+}
+function parseTestCasesFromRaw(raw) {
+    const jsonMatch = raw.match(/\[[\s\S]*\]/);
+    if (!jsonMatch)
+        return [];
+    const items = JSON.parse(jsonMatch[0]);
+    return items
+        .filter((tc) => tc.title && Array.isArray(tc.steps) && tc.steps.length >= 1)
+        .map((tc) => ({
+        title: String(tc.title).slice(0, 200),
+        kind: (['API', 'NEGATIVE', 'EDGE'].includes(tc.kind) ? tc.kind : 'API'),
+        priority: (['CRITICAL', 'HIGH', 'MEDIUM'].includes(tc.priority) ? tc.priority : 'HIGH'),
+        endpoint: String(tc.endpoint || '').slice(0, 100),
+        method: String(tc.method || 'GET'),
+        preconditions: String(tc.preconditions || '').slice(0, 300),
+        steps: tc.steps.map((s) => String(s).slice(0, 400)),
+        expectedResult: String(tc.expectedResult || '').slice(0, 500),
+        groundedOn: Array.isArray(tc.groundedOn) ? tc.groundedOn.map(String) : [],
+        tags: ['api', ...(Array.isArray(tc.tags) ? tc.tags.map(String) : [])],
+    }));
+}
+async function generateApiTests(opts) {
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(opts.tenantId, 'testGeneration');
+    const skillFiles = await app_brain_1.AppBrain.listSkillFiles(opts.tenantId, opts.projectId, ['API_CONTRACT', 'DATA_MODEL', 'AUTH_SESSION', 'TECH_STACK']);
+    const skillCtx = skillFiles.map((sf) => `### ${sf.kind}\n${sf.content}`).join('\n\n');
+    // GAP-010: raised default from 40 to 100; batching handles larger APIs
+    const ENDPOINT_LIMIT = parseInt(process.env.API_AGENT_ENDPOINT_LIMIT ?? '100', 10);
+    let dedupedEndpoints = [];
+    if (opts.apiEndpoints && opts.apiEndpoints.length > 0) {
+        dedupedEndpoints = [...new Map(opts.apiEndpoints.map((e) => [`${e.method}:${e.urlPattern}`, e])).values()];
+    }
+    const SYSTEM_DEFAULT = `You are an expert API QA engineer generating REST endpoint test cases.
+Cover: status codes, request/response schema contracts, auth/authz, error handling, boundary values.
+
+GROUNDING RULES:
+- Only generate tests for endpoints in API_CONTRACT or the endpoint list below
+- Never invent endpoints not documented
+- Steps use Playwright APIRequestContext format
+- Step format: "API [METHOD] [path]: [what is tested]"
+- groundedOn: "endpoint:METHOD /path" pairs
+
+OUTPUT FORMAT — valid JSON array only, no markdown fences:
+[
+  {
+    "title": "string",
+    "kind": "API|NEGATIVE|EDGE",
+    "priority": "CRITICAL|HIGH|MEDIUM",
+    "endpoint": "METHOD /path",
+    "method": "GET|POST|PUT|DELETE|PATCH",
+    "preconditions": "string",
+    "steps": ["step1", "step2"],
+    "expectedResult": "string",
+    "groundedOn": ["endpoint:METHOD /path"],
+    "tags": ["api"]
+  }
+]`;
+    // GAP-008: CRUD chain instruction appended to every user prompt
+    const buildUserPrompt = (endpointSummary) => `Generate comprehensive API test cases for this application.
+
+${endpointSummary ? `ENDPOINTS DISCOVERED DURING CRAWL:\n${endpointSummary}\n\n` : ''}SKILL FILE CONTEXT:
+${skillCtx.slice(0, 6000)}
+
+Cover these dimensions:
+1. HAPPY PATH (API): Valid inputs → 200/201 with correct response schema
+2. NO AUTH (NEGATIVE): Missing Bearer token → 401
+3. WRONG ROLE (NEGATIVE): Authenticated but insufficient role → 403
+4. MISSING FIELDS (NEGATIVE): Omit required fields → 400 with field-level errors
+5. NOT FOUND (NEGATIVE): Valid shape, nonexistent ID → 404
+6. INVALID TYPES (EDGE): String where number expected, null in non-nullable → 422
+7. BOUNDARY VALUES (EDGE): Max-length strings, zero/negative numbers, empty arrays
+8. DUPLICATE CREATE (EDGE): POST same unique resource twice → 409 Conflict
+
+Minimum 2 test cases per major endpoint family. Reference ACTUAL endpoints.
+
+Additionally, detect CRUD endpoint patterns: if endpoints include POST /resource AND GET /resource/:id AND PUT/PATCH /resource/:id AND DELETE /resource/:id for the same resource name, generate ONE additional test case with:
+- kind: 'API' or 'POSITIVE'
+- title: 'Full CRUD lifecycle for {resource}'
+- steps: ['POST /resource to create → capture id from response.body.id', 'GET /resource/{id} to verify creation', 'PUT /resource/{id} to update', 'DELETE /resource/{id} to verify deletion']
+- expectedResult: 'All CRUD operations succeed in sequence, id flows between steps'`;
+    const system = await (0, core_1.getAgentPrompt)('api-test-generation', undefined, opts.tenantId) ?? SYSTEM_DEFAULT;
+    let parsed = [];
+    // GAP-010: batch processing for endpoint lists exceeding ENDPOINT_LIMIT
+    if (dedupedEndpoints.length <= ENDPOINT_LIMIT) {
+        const endpointSummary = dedupedEndpoints.map((e) => `${e.method} ${e.urlPattern}`).join('\n');
+        const seed = (0, llm_js_1.deterministicSeed)(`${opts.tenantId}:${opts.projectId}:api-tests:${endpointSummary.slice(0, 500)}`);
+        const t0 = Date.now();
+        try {
+            const { text: raw, usage } = await (0, llm_js_1.askTracked)(system, buildUserPrompt(endpointSummary), llmCfg, undefined, undefined, { temperature: 0, seed });
+            const latencyMs = Date.now() - t0;
+            (0, app_brain_1.recordLLMCall)({
+                tenantId: opts.tenantId, projectId: opts.projectId,
+                agentType: 'api_test', label: 'api_test_generation', usage, latencyMs,
+            }).catch(console.error);
+            parsed = parseTestCasesFromRaw(raw);
+        }
+        catch (e) {
+            console.error('[api-test-agent] parse error:', e?.message);
+        }
+    }
+    else {
+        // Split into chunks of ENDPOINT_LIMIT, call LLM per chunk, then merge
+        const chunks = chunkArray(dedupedEndpoints, ENDPOINT_LIMIT);
+        console.log(`[api-test-agent] batching ${dedupedEndpoints.length} endpoints into ${chunks.length} chunks of ${ENDPOINT_LIMIT}`);
+        const seenKeys = new Set();
+        for (let i = 0; i < chunks.length; i++) {
+            const chunkSummary = chunks[i].map((e) => `${e.method} ${e.urlPattern}`).join('\n');
+            const seed = (0, llm_js_1.deterministicSeed)(`${opts.tenantId}:${opts.projectId}:api-tests:batch${i}:${chunkSummary.slice(0, 500)}`);
+            const t0 = Date.now();
+            try {
+                const { text: raw, usage } = await (0, llm_js_1.askTracked)(system, buildUserPrompt(chunkSummary), llmCfg, undefined, undefined, { temperature: 0, seed });
+                const latencyMs = Date.now() - t0;
+                (0, app_brain_1.recordLLMCall)({
+                    tenantId: opts.tenantId, projectId: opts.projectId,
+                    agentType: 'api_test', label: `api_test_generation_batch_${i}`, usage, latencyMs,
+                }).catch(console.error);
+                const batchCases = parseTestCasesFromRaw(raw);
+                // Deduplicate by endpoint+title across batches
+                for (const tc of batchCases) {
+                    const key = `${tc.endpoint}:${tc.title}`;
+                    if (!seenKeys.has(key)) {
+                        seenKeys.add(key);
+                        parsed.push(tc);
+                    }
+                }
+            }
+            catch (e) {
+                console.error(`[api-test-agent] parse error in batch ${i}:`, e?.message);
+            }
+        }
+    }
+    if (parsed.length === 0)
+        return { status: 'LLM_EMPTY', cases: [], saved: null };
+    const suiteName = 'API Contract Tests';
+    const saved = await app_brain_1.AppBrain.saveGeneratedTestCases(opts.tenantId, opts.projectId, suiteName, parsed.map((tc) => ({
+        title: tc.title, kind: tc.kind, priority: tc.priority,
+        preconditions: tc.preconditions, steps: tc.steps,
+        expectedResult: tc.expectedResult, groundedOn: tc.groundedOn,
+        tags: tc.tags, source: 'AI_GENERATED',
+    })));
+    // GAP-007: executable API test scripts
+    // After saving test cases, trigger script generation via script-agent
+    // TODO: await triggerApiTestScriptGeneration(tenantId, projectId, savedCases)
+    // This will generate Playwright request() test files as TEST_SCRIPTS skill file
+    console.log(`[api-test-agent] ${parsed.length} API test cases saved`);
+    return { status: 'GENERATED', cases: parsed, saved, suiteName };
+}
+// GAP-014: Pact v3 consumer contract generation
+async function generatePactContract(endpoints, options) {
+    const interactions = endpoints
+        .filter((ep) => ep.method !== 'WEBSOCKET')
+        .map((ep) => {
+        const desc = ep.summary ?? `${ep.method} ${ep.path}`;
+        const expectedStatus = ep.method === 'POST' ? 201 : ep.method === 'DELETE' ? 204 : 200;
+        return {
+            description: desc,
+            providerState: `${ep.path} exists`,
+            request: {
+                method: ep.method.toUpperCase(),
+                path: ep.path.replace(/\{([^}]+)\}/g, (_, p) => `test-${p}`),
+                headers: { Accept: 'application/json', ...(ep.method !== 'GET' && ep.method !== 'DELETE' ? { 'Content-Type': 'application/json' } : {}) },
+            },
+            response: {
+                status: expectedStatus,
+                headers: { 'Content-Type': 'application/json' },
+                body: expectedStatus !== 204 ? { matchingRules: { body: { '': { matchers: [{ match: 'type' }] } } } } : undefined,
+            },
+        };
+    });
+    const pact = {
+        consumer: { name: options.consumerName },
+        provider: { name: options.providerName },
+        interactions,
+        metadata: { pactSpecification: { version: '3.0.0' } },
+    };
+    return JSON.stringify(pact, null, 2);
+}
+function generateSyntheticValue(fieldName, schemaType) {
+    const name = fieldName.toLowerCase();
+    // Name heuristics
+    if (name.includes('email'))
+        return `test.user.${Math.floor(Math.random() * 9999)}@example.com`;
+    if (name.includes('first_name') || name === 'firstname')
+        return ['Alice', 'Bob', 'Carol', 'Dave', 'Eve'][Math.floor(Math.random() * 5)];
+    if (name.includes('last_name') || name === 'lastname')
+        return ['Smith', 'Jones', 'Brown', 'Davis', 'Wilson'][Math.floor(Math.random() * 5)];
+    if (name.includes('name') && !name.includes('file'))
+        return `Test User ${Math.floor(Math.random() * 100)}`;
+    if (name.includes('phone'))
+        return `+1-555-${String(Math.floor(Math.random() * 900) + 100)}-${String(Math.floor(Math.random() * 9000) + 1000)}`;
+    if (name.includes('url') || name.includes('href') || name.includes('link'))
+        return `https://example.com/item/${Math.floor(Math.random() * 1000)}`;
+    if (name.includes('image') || name.includes('avatar') || name.includes('photo'))
+        return 'https://picsum.photos/200';
+    if (name.includes('description') || name.includes('content') || name.includes('body'))
+        return 'Sample test content for automated testing purposes.';
+    if (name.includes('title') || name.includes('subject'))
+        return `Test Item ${Math.floor(Math.random() * 1000)}`;
+    if (name.includes('id') && schemaType === 'string')
+        return `id-${Math.random().toString(36).slice(2, 10)}`;
+    if (name.includes('id') || name === 'id')
+        return Math.floor(Math.random() * 10000) + 1;
+    if (name.includes('count') || name.includes('quantity') || name.includes('amount'))
+        return Math.floor(Math.random() * 100) + 1;
+    if (name.includes('price') || name.includes('cost') || name.includes('fee'))
+        return Math.round(Math.random() * 999.99 * 100) / 100;
+    if (name.includes('date') || name.includes('created') || name.includes('updated'))
+        return new Date().toISOString();
+    if (name.includes('active') || name.includes('enabled') || name.includes('visible'))
+        return true;
+    if (name.includes('status'))
+        return 'active';
+    if (name.includes('type') || name.includes('kind') || name.includes('category'))
+        return 'standard';
+    if (name.includes('color') || name.includes('colour'))
+        return '#3b82f6';
+    if (name.includes('tags') || name.includes('labels'))
+        return ['test', 'sample'];
+    // Schema type fallbacks
+    if (schemaType === 'boolean')
+        return true;
+    if (schemaType === 'number' || schemaType === 'integer')
+        return Math.floor(Math.random() * 100) + 1;
+    if (schemaType === 'array')
+        return [];
+    if (schemaType === 'object')
+        return {};
+    return `test-${fieldName}-value`;
+}
+function generateSyntheticBody(schema) {
+    if (!schema || typeof schema !== 'object')
+        return {};
+    const properties = schema.properties;
+    if (!properties)
+        return {};
+    const result = {};
+    for (const [key, def] of Object.entries(properties)) {
+        result[key] = generateSyntheticValue(key, def?.type);
+    }
+    return result;
+}

package/dist/artifact-intel-agent.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Fires after artifact intel extraction.
+ * Reads the relevant skill file for the project, merges artifact knowledge into it,
+ * and upserts. This is how knowledge base uploads "teach" the agent swarm.
+ */
+export declare function learnFromArtifact(tenantId: string, projectId: string, content: string, name: string, docType: string): Promise<void>;
+export declare function generateArtifactIntelligence(tenantId: string, projectId: string, artifactId: string, content: string, name: string, jobId?: string): Promise<{
+    summary: string;
+    keywords: string[];
+    docType: string;
+}>;

package/dist/artifact-intel-agent.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.learnFromArtifact = learnFromArtifact;
+exports.generateArtifactIntelligence = generateArtifactIntelligence;
+const llm_js_1 = require("./llm.js");
+const llm_config_js_1 = require("./llm-config.js");
+const app_brain_1 = require("@taodigital/app-brain");
+const core_1 = require("@taodigital/core");
+const SYSTEM = `You are a document intelligence analyst. Given the markdown content of an uploaded document, extract:
+1. A concise summary (2-3 sentences) describing what this document is about and its purpose.
+2. 8-15 search keywords that best represent the document's topics, entities, and domain.
+3. The document type classification.
+
+Respond with ONLY valid JSON (no markdown, no code blocks):
+{
+  "summary": "...",
+  "keywords": ["keyword1", "keyword2", ...],
+  "docType": "one of: REQUIREMENTS|TEST_CASES|API_SPEC|USER_STORY|ARCHITECTURE|SPREADSHEET|TEST_DATA|DATASHEET|REPORT|OTHER"
+}`;
+// Maps artifact docType → which skill file to update
+const DOC_TYPE_SKILL_MAP = {
+    TEST_CASES: 'COVERAGE_MATRIX',
+    SPREADSHEET: 'COVERAGE_MATRIX', // Excel/CSV test files
+    DATASHEET: 'COVERAGE_MATRIX', // Datasheets carry test data context
+    TEST_DATA: 'COVERAGE_MATRIX', // Test data files feed into coverage context
+    REQUIREMENTS: 'BUSINESS_DOMAIN',
+    USER_STORY: 'BUSINESS_DOMAIN',
+    REPORT: 'BUSINESS_DOMAIN', // Reports carry domain/business knowledge
+    API_SPEC: 'API_CONTRACT',
+    ARCHITECTURE: 'TECH_STACK',
+};
+const MERGE_PROMPTS = {
+    COVERAGE_MATRIX: `You are a QA knowledge integrator. Given an existing COVERAGE_MATRIX skill file and a new test case document, merge new information in.
+Extract test scenario names, covered features, test types (FUNCTIONAL/SECURITY/ACCESSIBILITY/PERFORMANCE), and any gaps.
+Return a complete updated COVERAGE_MATRIX skill file in Markdown. Keep existing data, add new rows/sections.`,
+    BUSINESS_DOMAIN: `You are a domain knowledge integrator. Given an existing BUSINESS_DOMAIN skill file and a requirements/user-story document, merge new domain knowledge.
+Extract user roles, business rules, user journeys, domain entities, and constraints.
+Return a complete updated BUSINESS_DOMAIN skill file in Markdown. Keep existing data, add new sections.`,
+    API_CONTRACT: `You are an API knowledge integrator. Given an existing API_CONTRACT skill file and a new API spec, merge new endpoint/contract information.
+Extract endpoints, auth patterns, request/response shapes, and error codes.
+Return a complete updated API_CONTRACT skill file in Markdown. Keep existing data, add new endpoints.`,
+    TECH_STACK: `You are a tech stack integrator. Given an existing TECH_STACK skill file and a new architecture document, merge new technical information.
+Extract frameworks, libraries, deployment topology, and technical constraints.
+Return a complete updated TECH_STACK skill file in Markdown. Keep existing data, add new details.`,
+};
+/**
+ * Fires after artifact intel extraction.
+ * Reads the relevant skill file for the project, merges artifact knowledge into it,
+ * and upserts. This is how knowledge base uploads "teach" the agent swarm.
+ */
+async function learnFromArtifact(tenantId, projectId, content, name, docType) {
+    const skillKind = DOC_TYPE_SKILL_MAP[docType];
+    if (!skillKind)
+        return;
+    const promptDefault = MERGE_PROMPTS[skillKind];
+    if (!promptDefault)
+        return;
+    const prompt = await (0, core_1.getAgentPrompt)('artifact-intel', skillKind, tenantId) ?? promptDefault;
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(tenantId, 'appBrain').catch(() => null);
+    if (!llmCfg)
+        return;
+    const existing = await app_brain_1.AppBrain.getSkillFile(tenantId, projectId, skillKind);
+    const existingContent = existing?.content ?? `# ${skillKind}\n\n(No data yet — first artifact)`;
+    const user = `EXISTING ${skillKind} SKILL FILE:\n${existingContent.slice(0, 4000)}\n\n---\n\nNEW DOCUMENT "${name}":\n${content.slice(0, 6000)}`;
+    const t0 = Date.now();
+    const contentKey = (existingContent ?? '').slice(0, 500);
+    const seed = (0, llm_js_1.deterministicSeed)(`${tenantId}:${projectId}:merge-skill:${skillKind}:${name}:${contentKey}`);
+    const result = await (0, llm_js_1.askTracked)(prompt, user, llmCfg, 2000, undefined, { temperature: 0, seed });
+    (0, app_brain_1.recordLLMCall)({
+        tenantId,
+        projectId,
+        agentType: 'artifact_learn',
+        label: `${skillKind} ← ${name}`,
+        usage: result.usage,
+        latencyMs: Date.now() - t0,
+    }).catch(console.error);
+    const updatedContent = result.text.trim();
+    if (updatedContent.length >= 200) {
+        await app_brain_1.AppBrain.upsertSkillFile(tenantId, projectId, skillKind, updatedContent, {
+            summary: `Learned from artifact: ${name}`,
+            tags: ['artifact-learned', docType.toLowerCase()],
+            source: 'ARTIFACT',
+        });
+        console.log(`[artifact-learn] Updated ${skillKind} from "${name}"`);
+    }
+}
+async function generateArtifactIntelligence(tenantId, projectId, artifactId, content, name, jobId) {
+    const t0 = Date.now();
+    let parsed = {};
+    let llmSucceeded = false;
+    try {
+        const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(tenantId, 'appBrain');
+        // Truncate to avoid large token usage — first 8000 chars is enough for summary/keywords
+        const excerpt = content.length > 8000 ? content.slice(0, 8000) + '\n… (truncated)' : content;
+        const user = `Document name: ${name}\n\nContent:\n${excerpt}`;
+        const seed = (0, llm_js_1.deterministicSeed)(`${tenantId}:${projectId}:artifact-intel:${artifactId}`);
+        const effectiveSystem = await (0, core_1.getAgentPrompt)('artifact-intel', undefined, tenantId) ?? SYSTEM;
+        const result = await (0, llm_js_1.askTracked)(effectiveSystem, user, llmCfg, 512, undefined, { temperature: 0, seed });
+        (0, app_brain_1.recordLLMCall)({
+            tenantId,
+            projectId,
+            agentType: 'artifact_intel',
+            label: name,
+            jobId,
+            usage: result.usage,
+            latencyMs: Date.now() - t0,
+        }).catch(console.error);
+        try {
+            parsed = JSON.parse(result.text);
+            llmSucceeded = true;
+        }
+        catch {
+            const m = result.text.match(/\{[\s\S]*\}/);
+            if (m) {
+                try {
+                    parsed = JSON.parse(m[0]);
+                    llmSucceeded = true;
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    catch (e) {
+        // Any failure (no LLM config, network error, etc.) — throw so the caller's
+        // trackArtifactIntel marks the job as failed and summary stays null in the DB.
+        // A null summary keeps processingIntel=true on the UI, showing the spinner.
+        console.error('[artifact-intel] failed for', name, e?.message);
+        throw e;
+    }
+    // Validate that the LLM returned a usable summary — if parse succeeded but the
+    // response had no summary field, throw so the DB is NOT written and the artifact
+    // stays in "Analysing…" state on the UI (processingIntel = !a.summary = true).
+    const summary = typeof parsed.summary === 'string' && parsed.summary.trim().length > 0
+        ? parsed.summary.trim()
+        : null;
+    const keywords = Array.isArray(parsed.keywords) ? parsed.keywords.filter((k) => typeof k === 'string') : [];
+    const docType = parsed.docType ?? 'OTHER';
+    if (!llmSucceeded || !summary) {
+        const reason = !llmSucceeded ? 'JSON parse failed' : 'no summary in response';
+        throw new Error(`[artifact-intel] LLM analysis incomplete for "${name}" (${reason}) — summary stays null so UI shows spinner`);
+    }
+    // Persist intelligence to DB — only reached when LLM succeeded with a real summary.
+    // This ensures processingIntel (= !a.summary) correctly resolves to false only on success.
+    await app_brain_1.AppBrain.updateArtifactIntelligence(tenantId, artifactId, { summary, keywords, docType, chunkCount: 1 });
+    // Re-index with keywords prepended for better BM25 recall
+    await app_brain_1.AppBrain.enrichChunkKeywords(tenantId, projectId, artifactId, content, name, keywords);
+    // Fire-and-forget: merge artifact knowledge into the relevant skill file (swarm learning)
+    if (DOC_TYPE_SKILL_MAP[docType]) {
+        learnFromArtifact(tenantId, projectId, content, name, docType).catch((e) => console.error('[artifact-learn] failed for', name, e?.message));
+    }
+    return { summary, keywords, docType };
+}