aimeat 1.2.0

package/dist/public/js/services/foundry-prompts-cortex-app.js

@@ -0,0 +1,154 @@
+/**
+ * @file foundry-prompts-cortex-app.js
+ * @description Prompt template for generating app-domain cortex components.
+ *   App-domain cortex = composition layer. Combines all feature cortex components
+ *   + auth + translations + settings into a single entry point for the app.
+ * @usage
+ *   import { buildAppDomainCortexPrompt } from '/js/services/foundry-prompts-cortex-app.js';
+ * @version-history
+ *   v1.0.0 — 2026-03-26 — Initial app-domain cortex prompt template
+ */
+
+import { INSTRUCTION_DISCLAIMER } from './foundry-prompts-base.js';
+
+/**
+ * Build prompt for generating an app-domain cortex component.
+ * @param {string} label - Component label
+ * @param {string} projectDescription - Project description
+ * @param {Array} featureBundles - Context bundles from all feature cortex components
+ * @param {object} dataCortexBundle - Context bundle from the data cortex
+ * @param {object} translationBundle - Context bundle from translation component (keys)
+ * @returns {string} Complete prompt
+ */
+export function buildAppDomainCortexPrompt(label, projectDescription, featureBundles, dataCortexBundle, translationBundle) {
+
+  const featureAPIs = (featureBundles || []).map(b => `
+### ${b.name}
+Registered as: ${b.registeredAs}
+Access via: AIMEAT.${b.libName || b.registeredAs}
+Exports: ${(b.exports || []).join(', ')}
+`).join('\n');
+
+  const translationKeys = translationBundle?.keys?.slice(0, 30).join(', ') || 'none available';
+
+  return `${INSTRUCTION_DISCLAIMER}
+Create an App-Domain Cortex for: ${label}
+
+Project: ${projectDescription}
+
+## Goal
+
+Build the top-level cortex library that the APP will use. It composes:
+1. All feature cortex components (renders them into containers)
+2. Auth initialization (AIMEAT.auth)
+3. Translation loading and management
+4. Settings management
+5. Navigation support
+
+The app loads ONLY this cortex. This cortex provides everything the app needs.
+
+## Feature Cortex Components (compose these)
+${featureAPIs}
+
+## Data Cortex
+${dataCortexBundle ? `
+Access via: AIMEAT.${dataCortexBundle.libName}
+Methods: ${(dataCortexBundle.exports || []).join(', ')}
+` : 'No data cortex available'}
+
+## Translation Keys Available
+${translationKeys}
+
+## Methods to Export
+
+- **init()** — Initialize auth, load translations, check data readiness. Returns { ready: boolean, authenticated: boolean }.
+- **render(container)** — Render the full application UI into the container. Sets up navigation, renders feature views.
+- **getTranslations(locale)** — Load translation strings for a locale. Returns the translation object.
+- **t(key, vars)** — Translate a key with optional variable interpolation. Uses loaded translations.
+- **switchLocale(locale)** — Change language, reload translations, re-render.
+
+## Auth Pattern
+\`\`\`javascript
+// Restore session from storage (MUST call login() first — getSession() alone returns null)
+var session = await AIMEAT.auth.login();
+if (!session) {
+  // No stored session — show login button
+  // mountLoginButton takes a CSS SELECTOR string, not a DOM element
+  // Give the container an ID first, then pass the selector
+  container.id = container.id || 'app-auth';
+  AIMEAT.auth.mountLoginButton('#' + container.id);
+  return { ready: false, authenticated: false };
+}
+\`\`\`
+
+## Translation Pattern
+\`\`\`javascript
+// Load translations — try service-prefixed key first, then plain key
+async function loadTranslations(locale) {
+  try {
+    // Translations are stored in the OWNER namespace by the translation component
+    // Key format: SERVICE_PREFIX.i18n.LOCALE (dots throughout)
+    return await AIMEAT.data.get('SERVICE_PREFIX.i18n.' + locale)
+        || await AIMEAT.data.get('i18n.' + locale)
+        || {};
+  } catch (e) { return {}; }
+}
+
+// Translate with interpolation
+function t(key, vars) {
+  var str = translations[key] || key;
+  if (vars) {
+    Object.keys(vars).forEach(function(k) {
+      str = str.replace('\${' + k + '}', vars[k]);
+    });
+  }
+  return str;
+}
+\`\`\`
+
+## Output Format
+
+Return TWO separate, properly tagged code blocks.
+CRITICAL: Use \`\`\`yaml for the manifest and \`\`\`javascript for the library code.
+
+First block — YAML manifest:
+\`\`\`yaml
+apiVersion: cortex.aimeat.org/v1
+kind: Extension
+metadata:
+  name: kebab-case-app-name
+  namespace: community
+  description: "App-domain cortex description"
+  author: foundry
+  tags: [app, domain-tag]
+  labels:
+    domain: specific-domain
+spec:
+  version: "1.0.0"
+  license: MIT
+  components:
+    - type: lib
+      name: kebab-case-app-name
+      filename: kebab-case-app-name.js
+      exports: [init, render, t, switchLocale, getTranslations]
+      api_surface: |
+        AIMEAT.appLib.init() — Initialize auth, load translations. Returns { ready, authenticated }
+        AIMEAT.appLib.render(container) — Render the full application into DOM container
+        AIMEAT.appLib.t(key, vars) — Translate with interpolation
+        AIMEAT.appLib.switchLocale(locale) — Change language and re-render
+        AIMEAT.appLib.getTranslations(locale) — Load translations for locale
+\`\`\`
+
+Second block — JavaScript library:
+\`\`\`javascript
+(function (AIMEAT) {
+  'use strict';
+  const LIB_NAME = 'appLib'; // camelCase
+  // ... init/render implementation
+  var exports = { init, render, t, switchLocale, getTranslations };
+  if (AIMEAT.register) AIMEAT.register(LIB_NAME, exports);
+  AIMEAT[LIB_NAME] = exports;
+})(window.AIMEAT || (window.AIMEAT = {}));
+\`\`\`
+`;
+}

package/dist/public/js/services/foundry-prompts-cortex-data.js

@@ -0,0 +1,241 @@
+/**
+ * @file foundry-prompts-cortex-data.js
+ * @description Prompt template for generating data cortex components.
+ *   Data cortex is the data repository layer — wraps extension actions for
+ *   external data, uses AIMEAT platform libraries for internal data.
+ *   Pure data access, no UI.
+ * @usage
+ *   import { buildDataCortexPrompt } from '/js/services/foundry-prompts-cortex-data.js';
+ * @version-history
+ *   v1.0.0 — 2026-03-26 — Initial data cortex prompt template
+ *   v1.1.0 — 2026-03-26 — Add full cortex YAML manifest format to output section
+ *   v1.2.0 — 2026-03-28 — Add callExt/readExtMemory/readOwnerMemory/dv() helpers, error handling rules
+ */
+
+import { AIMEAT_CONTEXT, INSTRUCTION_DISCLAIMER } from './foundry-prompts-base.js';
+
+/**
+ * Build prompt for generating a data cortex component.
+ * @param {string} label - Component label
+ * @param {string} projectDescription - Project description
+ * @param {object} blueprint - Full blueprint with structures/actions
+ * @param {Array} completedBundles - Context bundles from completed components
+ * @returns {string} Complete prompt
+ */
+export function buildDataCortexPrompt(label, projectDescription, blueprint, completedBundles) {
+  const structures = blueprint?.dataModel?.structures || {};
+  const actions = blueprint?.dataModel?.actions || {};
+  const memoryKeys = blueprint?.dataModel?.memoryKeys || {};
+
+  // Find extension bundle
+  const extBundle = completedBundles.find(b => b.type === 'extension');
+
+  // Find cortex actions (methods this data cortex must export)
+  const cortexActions = Object.entries(actions)
+    .filter(([key]) => key.startsWith('cortex:'))
+    .map(([key, def]) => ({ method: key.replace('cortex:', ''), ...def }));
+
+  // Build structures section
+  const structuresText = Object.entries(structures).map(([name, schema]) =>
+    `### ${name}\n\`\`\`json\n${JSON.stringify(schema, null, 2)}\n\`\`\``
+  ).join('\n\n');
+
+  return `${INSTRUCTION_DISCLAIMER}
+Create a Data Cortex library for: ${label}
+
+Project: ${projectDescription}
+
+## Goal
+
+Build a client-side JavaScript library (IIFE) that provides data access methods.
+This is the DATA LAYER — pure data access, no UI rendering.
+Other cortex components will use this library to get and modify data.
+
+## Structures (shared data types — use these exact shapes)
+
+${structuresText}
+
+## Methods to Export
+
+${cortexActions.map(a => {
+  const inputStr = a.input ? JSON.stringify(a.input) : '{}';
+  const outputRef = a.output?.$ref || JSON.stringify(a.output || 'any');
+  return `- **${a.method}**(${Object.keys(a.input || {}).join(', ')}) → returns ${outputRef}`;
+}).join('\n')}
+
+${extBundle ? `
+## Extension (this cortex wraps it)
+
+Extension name: ${extBundle.registeredAs}
+Actions: ${extBundle.actions?.join(', ') || 'none'}
+
+### Actual responses from live probes:
+${(extBundle.probeResults || []).map(p =>
+  `${p.action}(${JSON.stringify(p.input)}) → ${JSON.stringify(p.response).substring(0, 500)}`
+).join('\n')}
+
+Use callExt('${extBundle.registeredAs}', actionId, body) for extension calls.
+session.fetch returns ALREADY-PARSED JSON — use resp.data, never resp.json().
+` : `
+## No Extension
+
+This data cortex uses AIMEAT platform libraries directly (no extension needed).
+`}
+
+## AIMEAT Platform Libraries Available
+
+- **AIMEAT.data** — get(key), set(key, value), delete(key), list(opts), search(query), getPublic(gaii, key), getEntry(key), update(key, value, version)
+- **AIMEAT.storage** — upload(file), download(key), list(), delete(key)
+- **AIMEAT.social** — createBoard(name), post(boardId, content), boards(), posts(boardId)
+- **AIMEAT.wallet** — balance(), transactions()
+- **AIMEAT.auth** — login(), getSession(), mountLoginButton(container)
+
+## Data Access Rules (CRITICAL — follow precisely)
+
+Two namespaces, two different methods:
+
+1. **Extension runtime data** (watchlist items, cached API results, change logs — data the EXTENSION wrote via ctx.memory.set):
+   → Read with: \`AIMEAT.data.getPublic('ext:EXTENSION_NAME', key)\`
+   → This reads from the extension's own namespace. Public, no auth needed.
+
+2. **Owner/user data** (translations, settings, seed data — data stored by memory/translation components):
+   → Read with: \`AIMEAT.data.get(key)\`
+   → This reads from the CURRENT USER's own namespace. Requires auth session.
+
+NEVER read translations or settings from ext: namespace. They live in the owner namespace.
+NEVER read extension runtime data with data.get() — that reads the wrong namespace.
+
+## Output Format
+
+Return TWO separate, properly tagged code blocks.
+The installer expects them separately — YAML defines the manifest, JS is the library file.
+
+CRITICAL: Use \`\`\`yaml for the manifest and \`\`\`javascript for the library code.
+Do NOT combine them into a single block. Do NOT use an untagged block.
+
+First block — YAML manifest:
+\`\`\`yaml
+apiVersion: cortex.aimeat.org/v1
+kind: Extension
+metadata:
+  name: kebab-case-name
+  namespace: community
+  description: "What this data cortex does"
+  author: foundry
+  tags: [data, domain-tag]
+  labels:
+    domain: specific-domain
+spec:
+  version: "1.0.0"
+  license: MIT
+  components:
+    - type: prompt
+      name: domain-assistant
+      content: |
+        You are using the {{metadata.name}} cortex library.
+        Node URL: {{node_url}}
+
+        Available API:
+        AIMEAT.yourLib.methodName(params) — Description
+        ...
+
+        To load in an app:
+        <script src="{{node_url}}/v1/cortex/kebab-case-name/libs/kebab-case-name.js"></script>
+
+    - type: lib
+      name: kebab-case-name
+      filename: kebab-case-name.js
+      exports: [methodName, ...]
+      api_surface: |
+        AIMEAT.yourLib.methodName(params) — Description and return type
+        ...
+\`\`\`
+
+Second block — JavaScript library:
+\`\`\`javascript
+(function (AIMEAT) {
+  'use strict';
+  const LIB_NAME = 'yourLibName'; // camelCase of metadata.name
+  const EXT_NAME = 'extension-name'; // the extension this cortex wraps
+
+  // --- callExt helper — uses session.fetch() for proper auth ---
+  // session.fetch() returns ALREADY-PARSED JSON — do NOT call resp.json()
+  // Access resp.ok, resp.data, resp.error directly
+  async function callExt(actionId, body) {
+    try {
+      if (!AIMEAT.auth || !AIMEAT.auth.getSession) {
+        console.warn('[' + LIB_NAME + '] callExt(' + actionId + '): auth not available');
+        return null;
+      }
+      var session = AIMEAT.auth.getSession();
+      if (!session || !session.fetch) {
+        console.warn('[' + LIB_NAME + '] callExt(' + actionId + '): no session — login required');
+        return null;
+      }
+      var resp = await session.fetch('/v1/ext/' + EXT_NAME + '/' + actionId, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body || {})
+      });
+      if (!resp || !resp.ok) {
+        console.warn('[' + LIB_NAME + '] callExt(' + actionId + '): failed', resp?.error || resp?.status);
+        return null;
+      }
+      return resp.data?.result ?? resp.data ?? null;
+    } catch(e) {
+      console.warn('[' + LIB_NAME + '] callExt(' + actionId + '):', e.message);
+      return null;
+    }
+  }
+
+  // --- readExtMemory — reads extension-owned data from ext: namespace ---
+  async function readExtMemory(key) {
+    try { return await AIMEAT.data.getPublic('ext:' + EXT_NAME, key); }
+    catch(e) { return null; }
+  }
+
+  // --- readOwnerMemory — reads from current user's namespace (translations, settings) ---
+  async function readOwnerMemory(key) {
+    try { return await AIMEAT.data.get(key); }
+    catch(e) { return null; }
+  }
+
+  // --- Nested object display helper ---
+  function dv(val) {
+    if (val == null) return '-';
+    if (typeof val === 'string' || typeof val === 'number' || typeof val === 'boolean') return String(val);
+    if (val.value) return val.value;
+    if (val.url) return val.url;
+    if (val.name) return val.name;
+    if (Array.isArray(val)) return val.map(dv).join(', ');
+    return JSON.stringify(val);
+  }
+
+  // Public data access methods
+  // ALWAYS null-check callExt results — it returns null on auth failure or network error
+  async function methodName(params) {
+    var result = await callExt('myAction', { param: params });
+    if (!result) return []; // Return safe fallback, NEVER crash
+    return result;
+  }
+
+  // Register
+  const exports = { methodName, ... };
+  if (AIMEAT.register) AIMEAT.register(LIB_NAME, exports);
+  AIMEAT[LIB_NAME] = exports;
+})(window.AIMEAT || (window.AIMEAT = {}));
+\`\`\`
+
+## Error Handling Rules (CRITICAL)
+
+1. **callExt returns null on error** — EVERY method MUST null-check before using results
+2. **Return safe fallbacks** — empty arrays \`[]\`, empty objects \`{}\`, or default values. NEVER crash.
+3. **On first run, extension data may not exist** — always handle null/empty gracefully
+4. **console.warn on failures** — so developers can diagnose issues in browser console
+5. **NEVER call resp.json()** on session.fetch results — they are already parsed
+
+## No HTML Entities in Code
+
+Your code MUST use real operators (>, <, &&), NOT HTML entities (&gt; &lt; &amp;).
+`;
+}

package/dist/public/js/services/foundry-prompts-cortex-feature.js

@@ -0,0 +1,281 @@
+/**
+ * @file foundry-prompts-cortex-feature.js
+ * @description Prompt template for generating feature cortex components.
+ *   Feature cortex = one use case, data + UI combined. Self-contained module
+ *   that exports render(container). Like aimeat-charts exports ChartPanel.
+ * @usage
+ *   import { buildFeatureCortexPrompt } from '/js/services/foundry-prompts-cortex-feature.js';
+ * @version-history
+ *   v1.0.0 — 2026-03-26 — Initial feature cortex prompt template
+ *   v1.1.0 — 2026-03-28 — Inject actual service name into translation loading, add AIMEAT._translations note
+ */
+
+import { INSTRUCTION_DISCLAIMER } from './foundry-prompts-base.js';
+
+/**
+ * Working code examples for platform UI cortex libraries.
+ * Extracted from actual source code — these show REAL parameter patterns.
+ */
+const PLATFORM_UI_EXAMPLES = `
+## Platform UI Cortex Libraries — Working Examples
+
+All components take an options object. They return a DOM element you append to your container.
+
+### Tabs (AIMEAT['aimeat-ui-nav'].Tabs)
+\`\`\`javascript
+var tabs = AIMEAT['aimeat-ui-nav'].Tabs({
+  target: container,  // DOM element or CSS selector string
+  tabs: [
+    { id: 'search', label: 'Haku', icon: '🔍' },
+    { id: 'watchlist', label: 'Seuranta', icon: '⭐' },
+    { id: 'settings', label: 'Asetukset', icon: '⚙' }
+  ],
+  active: 'search',  // which tab is active initially
+  onChange: function(tabId) {
+    // called when user clicks a tab
+    renderTabContent(tabId);
+  }
+});
+\`\`\`
+
+### DataTable (AIMEAT['aimeat-ui-viewers'].DataTable)
+\`\`\`javascript
+var table = AIMEAT['aimeat-ui-viewers'].DataTable({
+  columns: [
+    { key: 'name', label: 'Name', sortable: true },
+    { key: 'id', label: 'ID' },
+    { key: 'status', label: 'Status' }
+  ],
+  rows: [
+    { name: 'Example Item', id: 'item-001', status: 'Active' }
+  ],
+  sortable: true,
+  filterable: true,
+  pageSize: 20
+});
+container.appendChild(table);
+// NOTE: DataTable does NOT have onRowClick. For clickable rows, build your own
+// card list with click handlers, or use the List component with onItemClick.
+\`\`\`
+
+### Timeline (AIMEAT['aimeat-ui-viewers'].Timeline)
+\`\`\`javascript
+var timeline = AIMEAT['aimeat-ui-viewers'].Timeline({
+  events: [
+    { date: '2026-03-26', title: 'Osoite muuttui', description: 'Vanha: Mannerheimintie 1 → Uusi: Pohjantie 8' },
+    { date: '2026-03-20', title: 'Toimiala päivittyi', description: 'Uusi: Ohjelmistojen suunnittelu' }
+  ]
+});
+container.appendChild(timeline);
+\`\`\`
+
+### Form components (AIMEAT['aimeat-ui-forms'])
+\`\`\`javascript
+// Text input — returns { el, getValue(), setValue(v), setError(msg), clearError() }
+var nameInput = AIMEAT['aimeat-ui-forms'].Input({
+  label: 'Hakusana',
+  placeholder: 'Hae nimellä...',
+  type: 'text'
+});
+container.appendChild(nameInput.el);
+// Read value: nameInput.getValue()
+// Set value: nameInput.setValue('test')
+// Listen for changes: nameInput.el.querySelector('input').addEventListener('input', function(e) { doSearch(e.target.value); });
+
+// Select dropdown — returns { el, getValue(), setValue(v) }
+var langSelect = AIMEAT['aimeat-ui-forms'].Select({
+  label: 'Kieli',
+  options: [
+    { value: 'fi', label: 'Suomi' },
+    { value: 'en', label: 'English' }
+  ]
+});
+container.appendChild(langSelect.el);
+// Read value: langSelect.getValue()
+
+// Toggle switch — returns { el, getValue(), setValue(v) }
+// Toggle HAS onChange callback
+var notifToggle = AIMEAT['aimeat-ui-forms'].Toggle({
+  label: 'Ilmoitukset',
+  checked: true,
+  onChange: function(checked) { saveNotificationPref(checked); }
+});
+container.appendChild(notifToggle.el);
+\`\`\`
+
+### Dialogs (AIMEAT['aimeat-ui-dialogs'])
+\`\`\`javascript
+// Toast notification
+AIMEAT['aimeat-ui-dialogs'].toast('Tallennettu!', 'success');
+AIMEAT['aimeat-ui-dialogs'].toast('Virhe tapahtui', 'error');
+
+// Confirm dialog (returns Promise)
+var confirmed = await AIMEAT['aimeat-ui-dialogs'].Confirm({
+  title: 'Poista yritys?',
+  message: 'Haluatko varmasti poistaa yrityksen seurannasta?',
+  confirmLabel: 'Poista',
+  cancelLabel: 'Peruuta'
+});
+if (confirmed) { removeFromWatchlist(id); }
+
+// Modal
+var modal = AIMEAT['aimeat-ui-dialogs'].Modal({
+  title: 'Yrityksen tiedot',
+  content: detailElement,  // DOM element
+  width: 'lg'  // 'sm', 'md', 'lg'
+});
+\`\`\`
+`;
+
+/**
+ * Build prompt for generating a feature cortex component.
+ * @param {string} label - Component label
+ * @param {object} useCase - The use case from interview spec this feature implements
+ * @param {object} view - The view from interview spec matching this use case
+ * @param {object} dataCortexBundle - Context bundle from the data cortex
+ * @param {object} structures - Blueprint structures relevant to this feature
+ * @param {Array} translationKeys - Translation keys relevant to this feature
+ * @param {Array} usesLibs - Platform cortex libraries this component uses (from blueprint)
+ * @returns {string} Complete prompt
+ */
+export function buildFeatureCortexPrompt(label, useCase, view, dataCortexBundle, structures, translationKeys, usesLibs) {
+
+  const structuresText = Object.entries(structures || {}).map(([name, schema]) =>
+    `**${name}**: ${JSON.stringify(schema, null, 2)}`
+  ).join('\n\n');
+
+  const dataCortexAPI = dataCortexBundle ? `
+## Data Cortex API (use this for all data access)
+
+Access via: AIMEAT.${dataCortexBundle.libName}
+Methods: ${(dataCortexBundle.exports || []).join(', ')}
+
+${(dataCortexBundle.probeResults || []).map(p =>
+    `${p.method || p.action}(${JSON.stringify(p.input || {})}) → ${JSON.stringify(p.response).substring(0, 400)}`
+  ).join('\n')}
+` : '';
+
+  const translationSection = translationKeys && translationKeys.length > 0 ? `
+## Translation Keys (use these exact keys)
+
+${translationKeys.map(k => '- `' + k + '`').join('\n')}
+` : '';
+
+  return `${INSTRUCTION_DISCLAIMER}
+Create a Feature Cortex component for: ${label}
+
+## Use Case
+${useCase ? `**${useCase.title}** [${useCase.priority}]: ${useCase.description}` : 'No specific use case provided'}
+
+## View
+${view ? `**${view.title}** (${view.type}): ${view.description}${view.interactions ? '\nInteractions: ' + view.interactions.join(', ') : ''}` : 'No specific view provided'}
+
+## Goal
+
+Build a self-contained feature module (data + UI) as a cortex IIFE.
+It must export a \`render(container)\` function that:
+1. Creates all DOM elements for this feature
+2. Fetches data from the data cortex
+3. Renders the data using platform UI components
+4. Handles user interactions
+5. Uses translation keys for all visible text
+
+Think of it like aimeat-charts: \`ChartPanel({ target: container, ... })\` creates a complete chart.
+Your \`render(container)\` creates a complete feature view.
+
+## Data Structures
+${structuresText}
+
+${dataCortexAPI}
+
+${PLATFORM_UI_EXAMPLES}
+
+${translationSection}
+
+## Loading Translations
+
+Translations are stored in the OWNER namespace (by the translation component).
+Load them with AIMEAT.data.get() — NOT from ext: namespace:
+\`\`\`javascript
+// CORRECT — reads from owner namespace where translation component stored them:
+// Try service-prefixed key first, then plain key:
+var translations = await AIMEAT.data.get('${dataCortexBundle?.registeredAs || 'SERVICE_NAME'}.i18n.fi')
+  || await AIMEAT.data.get('i18n.fi') || {};
+
+// WRONG — ext: namespace does NOT contain translations:
+// var translations = await AIMEAT.data.getPublic('ext:...', 'i18n.fi'); // ← NEVER do this
+\`\`\`
+
+NOTE: In most apps, the app-domain cortex loads translations during init() and stores them in \`AIMEAT._translations\`. Feature cortexes can access them via \`AIMEAT._translations\` — you don't need to load them again in each feature.
+
+## Translation Helper
+Use a t() function for all user-visible text:
+\`\`\`javascript
+function t(key, translations, vars) {
+  if (!key || !translations) return key || '';
+  var str = translations[key] != null ? translations[key] : key;
+  if (vars && typeof str === 'string') {
+    Object.keys(vars).forEach(function(k) {
+      str = str.replace('\${' + k + '}', vars[k]);
+    });
+  }
+  return str;
+}
+\`\`\`
+
+## Nested Object Helper
+API responses contain nested objects. Use this to safely render values:
+\`\`\`javascript
+function dv(val) {
+  if (val == null) return '-';
+  if (typeof val === 'string' || typeof val === 'number' || typeof val === 'boolean') return String(val);
+  if (val.value) return val.value;
+  if (val.url) return val.url;
+  if (val.name) return val.name;
+  if (Array.isArray(val)) return val.map(dv).join(', ');
+  return JSON.stringify(val);
+}
+\`\`\`
+
+## Output Format
+
+Return TWO separate, properly tagged code blocks.
+CRITICAL: Use \`\`\`yaml for the manifest and \`\`\`javascript for the library code.
+
+First block — YAML manifest:
+\`\`\`yaml
+apiVersion: cortex.aimeat.org/v1
+kind: Extension
+metadata:
+  name: kebab-case-feature-name
+  namespace: community
+  description: "Feature description"
+  author: foundry
+  tags: [feature, domain-tag]
+  labels:
+    domain: specific-domain
+spec:
+  version: "1.0.0"
+  license: MIT
+  components:
+    - type: lib
+      name: kebab-case-feature-name
+      filename: kebab-case-feature-name.js
+      exports: [render]
+      api_surface: |
+        AIMEAT.featureLib.render(container) — Renders the feature UI into the given DOM element
+\`\`\`
+
+Second block — JavaScript library:
+\`\`\`javascript
+(function (AIMEAT) {
+  'use strict';
+  const LIB_NAME = 'featureLib'; // camelCase
+  // ... render(container) implementation
+  var exports = { render: render };
+  if (AIMEAT.register) AIMEAT.register(LIB_NAME, exports);
+  AIMEAT[LIB_NAME] = exports;
+})(window.AIMEAT || (window.AIMEAT = {}));
+\`\`\`
+`;
+}