@sun-asterisk/sungen 3.1.1 → 3.1.2-beta.100

package/src/harness/audit.ts

@@ -11,7 +11,7 @@ import * as fs from 'fs';
 import { loadScenarios, parseViewpointOverview, ScenarioInfo, ViewpointEntry } from './parse';
 import {
   loadCatalog, viewpointGate, assertionDepth, dataThemesFor, coverageBalance, duplicateClusters, traceability, claimProof, taxonomyLint,
-  GateResult, DepthResult, BalanceResult, DuplicateResult, TraceResult, ClaimProofResult, TaxonomyResult,
+  GateResult, DepthResult, BalanceResult, DuplicateResult, TraceResult, ClaimProofResult, TaxonomyResult, Catalog,
 } from './sensors';
 import { readIntent, projectRootFromScreenDir, IntentProfile } from './intent';
 import { getProvenance, Provenance } from './provenance';
@@ -19,6 +19,9 @@ import { specCoverage, SpecCoverageResult, parseSpecClauses } from './spec-cover
 import { downstreamScope, manualOracle, readText, DownstreamResult, ManualOracleResult,
   negativeSideEffect, sourceBacked, crossArtifactOwnership } from './quality-gates';
 import { viewpointLedger, parseViewpointItems, LedgerResult } from './viewpoint-ledger';
+import { capabilityRegistry } from '../capabilities/registry';
+import { discoverAndRegisterCapabilities } from '../capabilities/discover';
+import { contextRouter } from '../capabilities/context-router';
 
 export interface AuditReport {
   screen: string;
@@ -63,13 +66,23 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
 
   const scenarios: ScenarioInfo[] = loadScenarios(featurePath);
   const viewpoints: ViewpointEntry[] = parseViewpointOverview(viewpointPath);
-  const catalog = loadCatalog();
+  // The viewpoint catalog is owned by the default (UI) capability via the SPI; falls back to the
+  // in-core loader if no capability provides one. Same catalog content → identical scores (R2).
+  discoverAndRegisterCapabilities();
+  const defaultCap = capabilityRegistry.defaultCapabilityId();
+  const catalog = ((defaultCap && capabilityRegistry.get(defaultCap)?.viewpoints?.()) as Catalog | undefined) || loadCatalog();
   const spec = specCoverage(specPath, scenarios, featureText);
 
-  const gate = viewpointGate(scenarios, viewpoints, catalog);
   // P3 — intent profile from qa/context.md drives the depth threshold (focus).
   const intent = readIntent(projectRootFromScreenDir(screenDir));
-  const depth = assertionDepth(scenarios, dataThemesFor(catalog, gate.pageType), intent.focus);
+  // The viewpoint coverage gate + assertion depth are owned by the default (UI) capability and
+  // obtained via its `gateProvider` (R2.2b). Same functions underneath → byte-identical gate/depth
+  // → identical score. Falls back to the in-core functions if no capability provides them.
+  const uiGate = (defaultCap && capabilityRegistry.get(defaultCap)?.gateProvider) as
+    ((i: { scenarios: ScenarioInfo[]; viewpoints: ViewpointEntry[]; catalog: Catalog; focus: typeof intent.focus }) => { gate: GateResult; depth: DepthResult }) | undefined;
+  const provided = uiGate?.({ scenarios, viewpoints, catalog, focus: intent.focus });
+  const gate = provided?.gate ?? viewpointGate(scenarios, viewpoints, catalog);
+  const depth = provided?.depth ?? assertionDepth(scenarios, dataThemesFor(catalog, gate.pageType), intent.focus);
   const claim = claimProof(scenarios, intent.focus);
   const taxonomy = taxonomyLint(scenarios);
   const balance = coverageBalance(scenarios);
@@ -125,9 +138,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   if (trace.mappedRatio < 0.5) {
     findings.push(`TRACE: ${trace.note}`);
   }
-  if (gate.universalGaps.length) {
-    findings.push(`UNIVERSAL: missing theme(s): ${gate.universalGaps.join(', ')} (low priority reminder).`);
-  }
+  // (UNIVERSAL viewpoint-gap finding now emitted by the `ui` gate sensor — see the gate block below.)
   for (const g of spec.triggerGaps) {
     findings.push(`TRIGGER-UNCOVERED: spec validates "${g.constraint}"${g.code ? ` (${g.code})` : ''} on [${g.required.join(', ')}] but scenarios only exercise it on [${g.found.join(', ') || 'none'}] → add a ${g.missing.join(', ')}-trigger scenario for this constraint (don't collapse the trigger × input matrix).`);
   }
@@ -157,6 +168,24 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
     findings.push(`UNSOURCEABLE-SCENARIO: "${u}" doesn't trace to any FR / viewpoint item — link it to a source, or tag it @exploration (not part of the official suite).`);
   }
 
+  // Capability gate sensors (Capability SPI): the ContextRouter scopes WHICH gate sensors run to
+  // the capabilities this feature actually uses — generic ('core') + the default UI + any whose
+  // annotation tags appear (e.g. @query). Today core+ui gate sensors are always in scope, so this
+  // is behaviour-identical; it bounds the set as capability-specific gate sensors (@api, …) are
+  // added. Each runs over the audit context; an 'error' finding fails the gate.
+  const featureTags = [
+    ...(scenarios.some((s) => s.queryRefs && s.queryRefs.length) ? ['@query'] : []),
+    ...(scenarios.some((s) => s.apiRefs && s.apiRefs.length) ? ['@api'] : []),
+  ];
+  const routedGateIds = contextRouter.route({ target: { kind: 'screen', id: screenName }, artifact: 'feature', tags: featureTags }).gateSensorIds;
+  const gateSensorFindings = capabilityRegistry.sensors('gate')
+    .filter((s) => routedGateIds.includes(s.id))
+    .flatMap((s) => s.run({ screenName, cwd: projectRootFromScreenDir(screenDir), featureText, scenarios, universalGaps: gate.universalGaps }));
+  // Each gate sensor's message carries its own code prefix (VERIFICATION-FAIL / UNIVERSAL / …)
+  // → push verbatim.
+  for (const f of gateSensorFindings) findings.push(f.message);
+  const gateSensorError = gateSensorFindings.some((f) => f.severity === 'error');
+
   // #8 — multi-axis calibration: a high overall must not hide a weak axis.
   const manualCompleteness = manualOracleResult.manualTotal
     ? 1 - manualOracleResult.insufficient.length / manualOracleResult.manualTotal : 1;
@@ -180,7 +209,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   // Gate spans coverage (viewpoint themes), depth, claim-proof, spec-clause coverage,
   // AND taxonomy-match (scenarios must use the project's viewpoint IDs when defined).
   const gateStatus: 'PASS' | 'FAIL' =
-    gate.gaps.length === 0 && depth.verdict !== 'fail' && claim.verdict !== 'fail' && spec.verdict !== 'fail' && !taxonomyMismatch ? 'PASS' : 'FAIL';
+    gate.gaps.length === 0 && depth.verdict !== 'fail' && claim.verdict !== 'fail' && spec.verdict !== 'fail' && !taxonomyMismatch && !gateSensorError ? 'PASS' : 'FAIL';
 
   return {
     screen: screenName,

package/src/harness/catalog/drivers.yaml

@@ -1,21 +1,37 @@
 # Driver Catalog (metadata only — NO driver code is bundled here).
 # Lets Sungen RECOMMEND/RESOLVE a driver that may not be installed yet, and tells
-# `sungen capability add` which package to install. See docs/spec/sungen_phase2a_spec.md.
+# `sungen capability add` which package to install. See docs/spec/sungen_phase2a_spec.md
+# and docs/spec/sungen_packaging_spec.md (R5 — the capability SPI + npm packages).
 #
-# kind: platform → the runtime/codegen adapter for a target (pick ONE per project)
-# kind: capability → an extra ability added on top of a platform (Phase 3)
-# unblocks: manual-reason codes (M1–M9) this driver can resolve (Phase 2b taxonomy)
+# Two axes:
+#   kind: platform   → HOW tests run (runtime/codegen adapter). Pick ONE per project.
+#   kind: capability → WHAT extra thing is verified, added on top of a platform.
+# Fields:
+#   status:    shipped → published as an npm package (R5);  planned → not built yet.
+#   bundled:   true → installed automatically (a dependency of @sun-asterisk/sungen),
+#              so `capability add` is unnecessary.
+#   unblocks:  manual-reason codes (M1–M9) this driver resolves (Phase 2b taxonomy).
+#
+# R5 status: the three real capabilities ship as packages — @sungen/driver-ui (web UI,
+# bundled as the default), @sungen/driver-db, @sungen/driver-api. The web *platform*
+# entry below points at @sungen/driver-ui (the UI step vocabulary + viewpoint gate); the
+# Playwright codegen *adapter* itself is still in-core (Phase 2a). Mobile + the remaining
+# capabilities are planned. See the "Platform axis & mobile evolution" section of the
+# packaging spec for the `sungen init --platform <web|mobile>` roadmap.
 
 drivers:
   web:
     kind: platform
-    package: "@sungen/driver-web"     # Phase 2a: bundled Playwright adapter serves this (back-compat)
-    runtime: playwright
-    adapter: web                       # registry adapter name
+    package: "@sungen/driver-ui"       # R5: web UI capability (step patterns + viewpoint gate)
+    status: shipped
+    bundled: true                       # @sun-asterisk/sungen depends on it → UI works out of the box
+    runtime: playwright                 # codegen adapter still in-core (Phase 2a)
+    adapter: web                        # registry adapter name
     capabilities: ["@ui"]
   mobile:
     kind: platform
     package: "@sungen/driver-mobile"
+    status: planned                     # PoC on the feat/mobile branch (Appium / Flutter)
     runtime: appium
     adapter: mobile
     capabilities: ["@ui"]
@@ -23,35 +39,42 @@ drivers:
   api:
     kind: capability
     package: "@sungen/driver-api"
+    status: shipped
     capabilities: ["@api", "@apiAssert", "@hybrid"]
     unblocks: [M2]
-  data-factory:
-    kind: capability
-    package: "@sungen/driver-data-factory"
-    capabilities: ["@dataFactory"]
-    unblocks: [M1]
   db:
     kind: capability
     package: "@sungen/driver-db"
+    status: shipped
     capabilities: ["@dbAssert"]
     unblocks: [M2]
+  data-factory:
+    kind: capability
+    package: "@sungen/driver-data-factory"
+    status: planned
+    capabilities: ["@dataFactory"]
+    unblocks: [M1]
   mock:
     kind: capability
     package: "@sungen/driver-mock"
+    status: planned
     capabilities: ["@mock", "@network"]
     unblocks: [M3]
   mail-file:
     kind: capability
     package: "@sungen/driver-mail-file"
+    status: planned
     capabilities: ["@mail", "@file"]
     unblocks: [M5]
   contract:
     kind: capability
     package: "@sungen/driver-contract"
+    status: planned
     capabilities: ["@contract"]
     unblocks: [M5]
   specialized:
     kind: capability
     package: "@sungen/driver-specialized"
+    status: planned
     capabilities: ["@specialized"]
     unblocks: [M6]

package/src/harness/parse.ts

@@ -32,6 +32,7 @@ export interface ScenarioInfo {
   vpId?: string;              // raw leading ID token of the title (project's scheme: VP0-001, MS-HP-001, VP-LIST-001)
   casesDataset?: string;      // @cases:<dataset> — data-driven; one scenario expands to N row-tests
   queryRefs?: string[];       // named queries referenced by this scenario (inline `query [name]` + @query: tags)
+  apiRefs?: string[];         // named API endpoints referenced by this scenario (@api: tags)
 }
 
 /** Format-tolerant: is this token an ID (project's scheme), not a prose word?
@@ -102,12 +103,15 @@ function classifyScenario(sc: ParsedScenario): ScenarioInfo {
   const manual = tags.includes('@manual');
   const casesTag = tags.find((t) => t.startsWith('@cases:'));
   const casesDataset = casesTag ? casesTag.slice('@cases:'.length).trim() : undefined;
-  // Named-query references: @query:<name> tags + inline `query [name]` step refs.
+  // Named-query references: @query:<name>[(overrides)] tags + inline `query [name]` step refs.
   const queryRefs = new Set<string>();
-  for (const t of tags) if (t.startsWith('@query:')) { const n = t.slice('@query:'.length).trim(); if (n) queryRefs.add(n); }
+  for (const t of tags) if (t.startsWith('@query:')) { const m = t.slice('@query:'.length).match(/^([A-Za-z_][A-Za-z0-9_]*)/); if (m) queryRefs.add(m[1]); }
   for (const step of (sc.steps as ParsedStep[]) || []) {
     for (const m of (step.text || '').matchAll(/\bquery\s+\[([A-Za-z_][A-Za-z0-9_]*)\]/gi)) queryRefs.add(m[1]);
   }
+  // Named-API references: @api:<name>[(overrides)] tags.
+  const apiRefs = new Set<string>();
+  for (const t of tags) if (t.startsWith('@api:')) { const m = t.slice('@api:'.length).match(/^([A-Za-z_][A-Za-z0-9_]*)/); if (m) apiRefs.add(m[1]); }
   let priority: Priority = 'unknown';
   for (const t of tags) if (PRIORITY_TAGS[t]) priority = PRIORITY_TAGS[t];
 
@@ -164,6 +168,7 @@ function classifyScenario(sc: ParsedScenario): ScenarioInfo {
     vpId,
     casesDataset,
     queryRefs: queryRefs.size ? [...queryRefs] : undefined,
+    apiRefs: apiRefs.size ? [...apiRefs] : undefined,
   };
 }
 

package/src/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Public API of `@sun-asterisk/sungen` — the capability SPI plus the shared compiler/harness surface
+ * that capability drivers (`@sungen/driver-*`) build against. Drivers import from here; core never
+ * imports from a driver (discovery loads them at runtime). Keep this surface small and intentional.
+ */
+
+// --- Capability SPI ---
+export { capabilityRegistry, CapabilityRegistry } from './capabilities/registry';
+export type { CapabilityDescriptor } from './capabilities/registry';
+export type { Sensor, SensorFinding, AdvisoryScanInput, GateInput } from './capabilities/sensor';
+export type { Context, DiscoveryProvider, ContextMapper, GenerationUnit } from './capabilities/context';
+
+// --- Step-pattern authoring (a driver contributes step patterns via its descriptor) ---
+export type { PatternContext, StepPattern, StepTemplateData } from './generators/test-generator/patterns/types';
+export type { MappedStep } from './generators/test-generator/step-mapper';
+export type { ParsedStep } from './generators/gherkin-parser';
+export { getPathCode, inferPath, resolvePathVariables } from './generators/test-generator/utils/path-inference';
+
+// --- Precondition-annotation override grammar (shared by the @query / @api driver codegen) ---
+export { parseQueryOverrides } from './harness/annotation-overrides';
+
+// --- Named-query catalog (shared: the DB driver's codegen + core's data-driven advisory lint) ---
+export { resolveQuery, compileQuery, lintCatalog } from './harness/query-catalog';
+export type { QueryEntry } from './harness/query-catalog';
+
+// --- Shared harness: viewpoint catalog + coverage gate / assertion depth ---
+// (the UI capability's gateProvider composes these; they also back core's ingest + audit fallback)
+export { loadCatalog, viewpointGate, assertionDepth, dataThemesFor } from './harness/sensors';
+export type { Catalog, GateResult, DepthResult } from './harness/sensors';
+export type { ScenarioInfo, ViewpointEntry } from './harness/parse';

package/src/orchestrator/templates/ai-instructions/claude-cmd-create-test.md

@@ -31,9 +31,10 @@ Parse **name** from `$ARGUMENTS`. If missing, ask the user.
    **Screen**: Verify `qa/screens/<name>/` exists. If not → `/sungen:add-screen` first.
 2. Check if `.feature` file already has scenarios.
    - If yes → use `AskUserQuestion` to ask the update mode (see `sungen-tc-generation` skill — mode depends on which tiers already exist).
-   - If no → fresh creation. Use `AskUserQuestion` to ask generation scope:
-     - **Tier 1 — Critical & High priority** — ~10-15 scenarios/section covering happy paths, core validation, security basics **(Recommended)**
-     - **Full coverage — All tiers at once** — generates Tier 1 + 2 + 3 in one run. Large output (~40-60 scenarios/section), best for experienced users who want complete coverage immediately
+   - If no → fresh creation. **Write the feature file incrementally** (successive `Write`/`Edit`, ≈10-15 scenarios per call) — never emit the whole suite in one response, or it can exceed the model's output-token cap (`API Error: Claude's response exceeded the N output token maximum`). Use `AskUserQuestion` to ask generation scope:
+     - **Tier 1 — Critical & High priority** — ~10-15 scenarios/section: happy paths, core validation, security basics **(Recommended)**
+     - **Full coverage (incremental)** — Tier 1 + 2 + 3, written tier-by-tier in batches (`Write` T1 → `Edit` append T2 → `Edit` append T3). Safe on any output-token budget.
+     - **Full coverage (single pass)** — generate everything in one go (~40-60 scenarios/section). Faster, but **only if you raised your output cap** (`CLAUDE_CODE_MAX_OUTPUT_TOKENS ≥ 64000`) — otherwise it errors mid-generation. For power users on a high-token model/config.
 3. **Read project context + screen requirements**
 
    **Project context** — check `qa/context.md` (project root, not screen-specific):

package/src/orchestrator/templates/ai-instructions/claude-skill-gherkin-syntax.md

@@ -213,6 +213,7 @@ Options: `nth` `exact` `scope` `match` `variant` `frame` `contenteditable` `colu
 | `@flow` | Mark feature as E2E flow (cross-screen testing) |
 | `@cases:dataset` | Data-driven: run the scenario once per row of the `dataset` LIST in test-data → one `test()` per row |
 | `@query:name` | Database: run the named query from `database/queries.yaml` (precondition) and bind its rows to `{{name}}`; assert with `expect {{name.count}} …` + path access. Override params `@query:name(p={{v}})`. Repeatable. (Optional Data Driver — see Database verification above) |
+| `@api:name` | API: run the named request from `api/apis.yaml` (precondition) and bind the response to `{{name}}`; assert with `expect {{name.status}} …` + path access (`{{name.body.<path>}}`). Override params `@api:name(p={{v}})`. Repeatable. (Optional API Driver) |
 
 ### Data-driven scenarios (`@cases`)
 

package/src/orchestrator/templates/ai-instructions/claude-skill-tc-generation.md

@@ -6,6 +6,9 @@ user-invocable: false
 
 ## ⚠️ Gotchas — read before generating
 
+- **Write incrementally — never emit the whole suite in one response.** Build the `.feature` in batches via successive `Write`/`Edit` (≈10–15 scenarios per call). For **Full coverage**, write tier-by-tier: `Write` Tier 1 → `Edit` append Tier 2 → `Edit` append Tier 3.
+  → One huge `Write` can exceed the model's output-token cap → `API Error: Claude's response exceeded the N output token maximum`. Single-pass full coverage only fits when `CLAUDE_CODE_MAX_OUTPUT_TOKENS ≥ 64000`; otherwise batch. Batching also lets the audit/reviewer run per batch — higher quality.
+
 - `spec_figma.md` exists → read file only, **NEVER** call `mcp__figma__*`
   → PAT auth flow already done by `sungen-capture` (mode figma-pat); re-calling fails or duplicates work.
 

package/src/orchestrator/templates/ai-instructions/copilot-cmd-create-test.md

@@ -26,9 +26,10 @@ You are a **Senior QA Engineer**. You structure test cases by viewpoint categori
    **Screen**: Verify `qa/screens/${input:name}/` exists. If not → `/sungen-add-screen` first.
 2. Check if `.feature` already has scenarios.
    - If yes → summarize existing coverage and ask update mode (options depend on which tiers already exist — see `sungen-tc-generation` skill for details).
-   - If no → fresh creation. Ask generation scope:
-     - **1) Tier 1 — Critical & High priority** — ~10-15 scenarios/section covering happy paths, core validation, security basics **(Recommended)**
-     - **2) Full coverage — All tiers at once** — generates Tier 1 + 2 + 3 in one run. Large output (~40-60 scenarios/section), best for experienced users who want complete coverage immediately
+   - If no → fresh creation. **Write the feature file incrementally** (successive writes/edits, ≈10-15 scenarios per call) — never emit the whole suite in one response, or it can exceed the model's output-token cap (`response exceeded the N output token maximum`). Ask generation scope:
+     - **1) Tier 1 — Critical & High priority** — ~10-15 scenarios/section: happy paths, core validation, security basics **(Recommended)**
+     - **2) Full coverage (incremental)** — Tier 1 + 2 + 3, written tier-by-tier in batches. Safe on any output-token budget.
+     - **3) Full coverage (single pass)** — everything in one go (~40-60 scenarios/section). Faster, but **only if you raised your output cap** (`CLAUDE_CODE_MAX_OUTPUT_TOKENS ≥ 64000`) — otherwise it errors mid-generation. For power users on a high-token model/config.
 3. **Read project context + screen requirements**
 
    **Project context** — check `qa/context.md` (project root, not screen-specific):

package/src/orchestrator/templates/ai-instructions/github-skill-sungen-gherkin-syntax.md

@@ -213,6 +213,7 @@ Options: `nth` `exact` `scope` `match` `variant` `frame` `contenteditable` `colu
 | `@flow` | Mark feature as E2E flow (cross-screen testing) |
 | `@cases:dataset` | Data-driven: run the scenario once per row of the `dataset` LIST in test-data → one `test()` per row |
 | `@query:name` | Database: run the named query from `database/queries.yaml` (precondition) and bind its rows to `{{name}}`; assert with `expect {{name.count}} …` + path access. Override params `@query:name(p={{v}})`. Repeatable. (Optional Data Driver — see Database verification above) |
+| `@api:name` | API: run the named request from `api/apis.yaml` (precondition) and bind the response to `{{name}}`; assert with `expect {{name.status}} …` + path access (`{{name.body.<path>}}`). Override params `@api:name(p={{v}})`. Repeatable. (Optional API Driver) |
 
 ### Data-driven scenarios (`@cases`)
 

package/src/orchestrator/templates/ai-instructions/github-skill-sungen-tc-generation.md

@@ -6,6 +6,9 @@ user-invocable: false
 
 ## ⚠️ Gotchas — read before generating
 
+- **Write incrementally — never emit the whole suite in one response.** Build the `.feature` in batches via successive `Write`/`Edit` (≈10–15 scenarios per call). For **Full coverage**, write tier-by-tier: `Write` Tier 1 → `Edit` append Tier 2 → `Edit` append Tier 3.
+  → One huge `Write` can exceed the model's output-token cap → `API Error: Claude's response exceeded the N output token maximum`. Single-pass full coverage only fits when `CLAUDE_CODE_MAX_OUTPUT_TOKENS ≥ 64000`; otherwise batch. Batching also lets the audit/reviewer run per batch — higher quality.
+
 - `spec_figma.md` exists → read file only, **NEVER** call `mcp__figma__*`
   → PAT auth flow already done by `sungen-capture` (mode figma-pat); re-calling fails or duplicates work.
 

package/src/orchestrator/templates/specs-api.ts

@@ -0,0 +1,101 @@
+/* eslint-disable */
+/**
+ * Sungen API Driver — runtime helper (auto-generated into specs/api.ts).
+ *
+ * Runs a catalog-defined HTTP request and returns { status, ok, body, headers } — bound to a
+ * `{{name}}` variable by the `@api:<name>` annotation, asserted with `expect {{name.status}} …` /
+ * `{{name.body.<path>}}`. Base URL + auth come from a `kind: api` datasource in datasources.yaml,
+ * with `${VAR}` resolved from .env.qa / process.env — never inline.
+ *
+ * Safety: a datasource flagged `env: production` is refused unless SUNGEN_ALLOW_PROD=1.
+ * DO NOT EDIT — regenerated by `sungen generate`.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface ApiDataSource {
+  kind?: string;
+  base_url?: string;
+  baseUrl?: string;
+  env?: string;
+  headers?: Record<string, string>;
+  timeout_ms?: number;
+}
+
+function loadEnvQa(): void {
+  for (const name of ['.env.qa', `.env.qa.${process.env.SUNGEN_ENV || ''}`]) {
+    const p = path.join(process.cwd(), name);
+    if (!name.endsWith('.') && fs.existsSync(p)) {
+      for (const line of fs.readFileSync(p, 'utf8').split('\n')) {
+        const m = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/);
+        if (m && process.env[m[1]] === undefined) process.env[m[1]] = m[2].replace(/^["']|["']$/g, '');
+      }
+    }
+  }
+}
+
+function loadConfig(): Record<string, ApiDataSource> {
+  loadEnvQa();
+  const file = [path.join(process.cwd(), 'datasources.yaml'), path.join(process.cwd(), 'qa', 'datasources.yaml')].find((f) => fs.existsSync(f));
+  if (!file) throw new Error('API Driver: no datasources.yaml found (project root or qa/).');
+  const raw = fs.readFileSync(file, 'utf8').replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, k) => process.env[k] ?? '');
+  const { parse } = require('yaml');
+  const doc = parse(raw) || {};
+  return doc.datasources || {};
+}
+
+function substitute(text: string, params: Record<string, any>): string {
+  return text.replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, (_m, p) => encodeURIComponent(String(params[p] ?? '')));
+}
+
+class ApiClient {
+  private configs: Record<string, ApiDataSource> | null = null;
+
+  private cfg(name?: string): { key: string; conf: ApiDataSource } {
+    if (!this.configs) this.configs = loadConfig();
+    const key = name || Object.keys(this.configs).find((k) => (this.configs![k].kind || 'api') === 'api') || Object.keys(this.configs)[0];
+    const conf = this.configs[key];
+    if (!conf) throw new Error(`API Driver: datasource "${key}" not found in datasources.yaml`);
+    if (conf.env === 'production' && process.env.SUNGEN_ALLOW_PROD !== '1') {
+      throw new Error(`API Driver: datasource "${key}" is env: production — refused (set SUNGEN_ALLOW_PROD=1 to override).`);
+    }
+    return { key, conf };
+  }
+
+  /** Run a catalog request and return the response. `req` is embedded at compile time; `params` bind at runtime. */
+  async call(
+    label: string,
+    req: { method: string; path: string; body?: unknown; datasource?: string },
+    params: Record<string, any> = {},
+  ): Promise<{ status: number; ok: boolean; body: any; headers: Record<string, string> }> {
+    const { conf } = this.cfg(req.datasource);
+    const base = (conf.base_url || conf.baseUrl || '').replace(/\/$/, '');
+    if (!base) throw new Error(`API Driver: ${label} — datasource has no base_url (set it in .env.qa).`);
+    const url = base + substitute(req.path, params);
+
+    let body: string | undefined;
+    const headers: Record<string, string> = { ...(conf.headers || {}) };
+    if (req.body !== undefined && req.body !== null) {
+      const resolved = JSON.parse(JSON.stringify(req.body).replace(/":([A-Za-z_][A-Za-z0-9_]*)"/g, (_m, p) => JSON.stringify(params[p] ?? null)));
+      body = JSON.stringify(resolved);
+      if (!headers['content-type'] && !headers['Content-Type']) headers['content-type'] = 'application/json';
+    }
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), conf.timeout_ms ?? 15000);
+    let res: Response;
+    try {
+      res = await fetch(url, { method: req.method, headers, body, signal: controller.signal });
+    } finally {
+      clearTimeout(timer);
+    }
+    const text = await res.text();
+    let parsed: any = text;
+    try { parsed = text ? JSON.parse(text) : null; } catch { /* non-JSON → keep text */ }
+    const outHeaders: Record<string, string> = {};
+    res.headers.forEach((v, k) => { outHeaders[k] = v; });
+    return { status: res.status, ok: res.ok, body: parsed, headers: outHeaders };
+  }
+}
+
+export const api = new ApiClient();

package/dist/generators/test-generator/patterns/assertion-patterns.d.ts

@@ -1,7 +0,0 @@
-import { StepPattern } from './types';
-/**
- * Assertion patterns: visibility, text content, state, attributes
- * Uses template engine for framework-agnostic code generation
- */
-export declare const assertionPatterns: StepPattern[];
-//# sourceMappingURL=assertion-patterns.d.ts.map

package/dist/generators/test-generator/patterns/assertion-patterns.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assertion-patterns.d.ts","sourceRoot":"","sources":["../../../../src/generators/test-generator/patterns/assertion-patterns.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAoB,MAAM,SAAS,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAAW,EA2qB1C,CAAC"}