@adia-ai/a2ui-mcp 0.4.6 → 0.4.7

package/CHANGELOG.md

@@ -11,6 +11,12 @@ zettel strategies.
 
 _No pending changes._
 
+## [0.4.7] - 2026-05-12
+
+### Changed — smoke + test scripts aligned to post-§72 retrieval surface
+
+`scripts/smoke-engine-registry.mjs` retrieval probe set + `scripts/test-a2ui.mjs` (composition-count threshold + spot-checks + intent-gate keyword surface) now exercise the harvested-chunks substrate that survives §72's `corpus/patterns/` + `corpus/compositions/` retirement. Probe for "pricing tiers" dropped (no pricing surface in shipped `/site/`); replaced with "admin dashboard with kpi cards" matching `dashboard-admin-page`. Spot-check names updated to real chunk names (`auth-signin-card-password`, `auth-signup-entry`, `dashboard-admin-page`, `settings-admin-page`). No tool / API change — internal scripts only.
+
 ## [0.4.6] - 2026-05-12
 
 ### Changed — patterns surface retired (§64 step 5, 2026-05-12)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adia-ai/a2ui-mcp",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "description": "AdiaUI A2UI MCP server. Exposes the compose engine over MCP with an engine selector for monolithic + zettel strategies.",
   "type": "module",
   "bin": {

package/scripts/smoke-engine-registry.mjs

@@ -44,10 +44,15 @@ console.log(`\n[smoke] shape invariants: ${ok ? 'ok' : 'FAIL'}`);
 // component tree's text content must overlap the intent's keywords.
 // This catches retrieval regressions (wrong-domain top hit) that pure
 // shape-validation gates miss.
+// Probes pick intents that match the post-§65 harvested-chunks
+// substrate (auth flows, dashboard variants, settings, errors).
+// Removed: 'pricing tiers' (no pricing surface in shipped /site/ —
+// retrieval honestly returns synthesis-failed; LLM fallback handles
+// the intent at ~9s vs ~25ms).
 const RETRIEVAL_PROBES = [
   { intent: 'login form with email and password',     engine: 'zettel',       expectKeywords: ['sign in', 'login', 'email', 'password'] },
-  { intent: 'pricing tiers with three plans',          engine: 'zettel',       expectKeywords: ['pricing', 'tier', 'plan', 'starter', 'pro', 'enterprise', '$'] },
   { intent: 'sign up form for a new account',          engine: 'zettel',       expectKeywords: ['sign up', 'register', 'create account', 'email'] },
+  { intent: 'admin dashboard with kpi cards',          engine: 'zettel',       expectKeywords: ['dashboard', 'kpi', 'metric', 'revenue', 'users', 'orders', 'conversion'] },
 ];
 
 function extractText(messages) {

package/scripts/test-a2ui.mjs

@@ -72,20 +72,23 @@ try {
   bad('LLM adapter', e.message);
 }
 
-// ── Test 2: Pattern library ─────────────────────────────────────────
+// ── Test 2: Composition library (post-§65 chunks-only substrate) ───
 
-console.log('\n2. Pattern library');
+console.log('\n2. Composition library');
 
 const { searchBlocks, listPatterns, lookupDomain } = await import('../../compose/core/reference.js');
 
-const allPatterns = listPatterns();
-const withTemplates = allPatterns.filter(p => p.template && Array.isArray(p.template));
-const domains = [...new Set(allPatterns.map(p => p.domain).filter(Boolean))];
+const allCompositions = listPatterns();
+const withTemplates = allCompositions.filter(p => p.template && Array.isArray(p.template));
+const domains = [...new Set(allCompositions.map(p => p.domain).filter(Boolean))];
 
-if (allPatterns.length >= 70) {
-  ok('Pattern count', `${allPatterns.length} total (${withTemplates.length} with templates)`);
+// Post-§65: retrieval surface is the harvested-chunks substrate
+// (~28-32 annotated chunks at the time of v0.4.7). Threshold sized
+// for that floor; grows naturally as more source HTML gets annotated.
+if (allCompositions.length >= 20) {
+  ok('Composition count', `${allCompositions.length} total (${withTemplates.length} with templates)`);
 } else {
-  bad('Pattern count', `only ${allPatterns.length} (expected 70+)`);
+  bad('Composition count', `only ${allCompositions.length} (expected 20+)`);
 }
 
 if (domains.length >= 3) {
@@ -94,15 +97,17 @@ if (domains.length >= 3) {
   bad('Domains', `only ${domains.length}: ${domains.join(', ')}`);
 }
 
-// Spot-check known compositions (§64 retired pattern-library; reference.js
-// now reads from composition-library — these are real composition names).
-const spotChecks = ['login-form', 'stat-card-dashboard', 'data-table-paginated', 'settings-admin-page'];
-const foundAll = spotChecks.every(name => allPatterns.some(p => p.name === name));
+// Spot-check chunk names that exist in the harvested substrate. These
+// are real chunk names from /apps/user-flow/, /apps/saas/, etc. —
+// post-§65 the test asserts on actual product surfaces, not on
+// curated composition JSON that's no longer the canonical source.
+const spotChecks = ['auth-signin-card-password', 'auth-signup-entry', 'dashboard-admin-page', 'settings-admin-page'];
+const foundAll = spotChecks.every(name => allCompositions.some(p => p.name === name));
 if (foundAll) {
-  ok('Known patterns', spotChecks.join(', '));
+  ok('Known chunks', spotChecks.join(', '));
 } else {
-  const missing = spotChecks.filter(name => !allPatterns.some(p => p.name === name));
-  bad('Known patterns', `missing: ${missing.join(', ')}`);
+  const missing = spotChecks.filter(name => !allCompositions.some(p => p.name === name));
+  bad('Known chunks', `missing: ${missing.join(', ')}`);
 }
 
 // ── Test 3: Instant mode gate ───────────────────────────────────────
@@ -119,14 +124,20 @@ function testGate(intent) {
   const intentWords = intent.toLowerCase().split(/\s+/).filter(w => w.length > 2 && !GATE_STOPS.has(w));
   const nameWords = best.name.toLowerCase().split(/[-_\s]+/);
   const matchTags = (best.tags || []).map(t => t.toLowerCase());
+  // Post-§65: harvested chunks carry semantic intent in `keywords` more
+  // than in `tags` (which became {complexity, layout} slots). Include
+  // keywords in the gate so `login → auth-signin-card-password` strong-hits
+  // off the chunk's `keywords: ["login", ...]` field.
+  const matchKeywords = (best.keywords || []).map(k => k.toLowerCase());
   const matchDomain = (best.domain || '').toLowerCase();
 
   const hasStrongHit = intentWords.some(w => {
     if (w.length < 3) return false;
-    if (nameWords.includes(w) || matchTags.includes(w)) return true;
+    if (nameWords.includes(w) || matchTags.includes(w) || matchKeywords.includes(w)) return true;
     if (w.length >= 4) {
       return nameWords.some(n => n.length >= 3 && (w.startsWith(n) || n.startsWith(w))) ||
-             matchTags.some(t => t.length >= 3 && (w.startsWith(t) || t.startsWith(w)));
+             matchTags.some(t => t.length >= 3 && (w.startsWith(t) || t.startsWith(w))) ||
+             matchKeywords.some(k => k.length >= 3 && (w.startsWith(k) || k.startsWith(w)));
     }
     return false;
   });
@@ -134,19 +145,26 @@ function testGate(intent) {
   const hasWeakHit = !hasStrongHit && intentWords.some(w => {
     return nameWords.some(n => n.length >= 3 && (n.includes(w) || w.includes(n))) ||
            matchTags.some(t => t.length >= 3 && (t.includes(w) || w.includes(t))) ||
+           matchKeywords.some(k => k.length >= 3 && (k.includes(w) || w.includes(k))) ||
            matchDomain.includes(w);
   });
 
   return { gate: hasStrongHit ? 'STRONG' : hasWeakHit ? 'WEAK' : 'REJECTED', pattern: best.name };
 }
 
-// Should STRONG match
+// Should STRONG match — restricted to intents covered by the
+// harvested-chunks substrate (auth, dashboard, settings, error pages).
+// Intents previously tested ("pricing table", "chat interface",
+// "todo list", etc.) dropped because §65 retired the curated
+// composition surface — LLM fallback handles those now.
+// Intents need ≥2 content-token hits OR a direct name-token match —
+// short 1-content-word intents (e.g. just "login form") get gated out
+// by composition-library's anti-spurious-match logic. Use intents that
+// land naturally — they're what real users type anyway.
 const strongTests = [
-  ['login form', 'login-form'],
-  ['nav bar', null],         // any match is fine
-  ['dashboard stats', null],
-  ['pricing table', null],
-  ['chat interface', null],
+  ['login with email and password', null],   // → auth-signin-card-password (3 keyword hits)
+  ['admin dashboard kpi', null],              // → dashboard-admin-page
+  ['workspace admin settings', null],         // → settings-admin-page
 ];
 for (const [intent, expected] of strongTests) {
   const { gate, pattern } = testGate(intent);
@@ -159,10 +177,9 @@ for (const [intent, expected] of strongTests) {
 
 // Should NOT be REJECTED (STRONG or WEAK both acceptable)
 const passTests = [
-  'show me a table',
-  'create a todo list',
-  'user profile card',
+  'sign up for an account',
   'settings page',
+  '404 not found error',
 ];
 for (const intent of passTests) {
   const { gate, pattern } = testGate(intent);
@@ -238,17 +255,21 @@ if (!THINKING) {
 }
 
 // ── Test 6: Training corpus surfaces ────────────────────────────────
-// (The legacy exemplar extract → ingest path was retired 2026-04-28 in
-// mcp 0.0.5. The chunk corpus is the training surface now.)
+// Post-§65: `compositions/` retired alongside the hand-authored
+// pattern library. The harvested-chunks substrate is the sole
+// retrieval surface; everything else falls through to LLM.
+// (Legacy exemplar extract → ingest path retired 2026-04-28 mcp 0.0.5.)
 
 console.log('\n6. Training corpus surfaces');
 
-// 6a. Hand-authored pattern library — should be ≥ 100 entries.
+// 6a. Composition library (harvested chunks via composition-library).
+// Threshold sized for the post-§65 floor (~28 annotated chunks at
+// v0.4.7); grows as more source HTML gets annotated.
 const patterns = listPatterns();
-if (patterns.length >= 100) {
-  ok('Pattern library', `${patterns.length} hand-authored patterns`);
+if (patterns.length >= 20) {
+  ok('Composition library', `${patterns.length} compositions (harvested-chunks substrate)`);
 } else {
-  bad('Pattern library', `only ${patterns.length} (expected ≥ 100)`);
+  bad('Composition library', `only ${patterns.length} (expected ≥ 20)`);
 }
 
 // 6b. Gen-UI chunk corpus — should be ≥ 500 unique chunks across