@genesislcap/blank-app-seed 5.27.2-prerelease.2 → 5.28.0

package/.genx/ai-consumer.json

@@ -0,0 +1,18 @@
+{
+  "version": 1,
+  "kinds": ["request", "event", "query"],
+  "resourceFields": [
+    "name",
+    "kind",
+    "op",
+    "context",
+    "maxRows",
+    "customCode",
+    "references",
+    "shape",
+    "entity",
+    "key",
+    "inputs",
+    "effects"
+  ]
+}

package/.genx/configure.js

@@ -1,4 +1,7 @@
 const versions = require('./versions.json');
+// What the pinned @genesislcap/ai-assistant reads: the kinds and resource fields the chat writer passes
+// on. CI proves it against that assistant's GENESIS_AI_CONSUMES (C-15A.6 S-6).
+const aiConsumer = require('./ai-consumer.json');
 const fs = require('fs');
 const path = require('path');
 const {
@@ -44,6 +47,26 @@ module.exports = async (data, utils) => {
   const FDC3EventHandlersEnabled = data.routes.find(
     (route) => route.FDC3EventHandlersEnabled,
   );
+  // AI chat — ONE gate for everything the feature emits, server and client alike.
+  //
+  // `data.ui` here IS the project's ui.config (the generator passes it as the `ui` argument), so the
+  // block is `data.ui.ai`, not `data.ui.config.ai`: gated on the latter it would silently never
+  // fire. React only, because the panel is React only, and the server endpoint follows the same
+  // gate — an endpoint with no panel to call it would be a router compile risk with no user.
+  const aiVendor = data.ui?.ai?.vendor === 'anthropic' ? 'anthropic' : 'gemini';
+  data.AI = {
+    enabled: !!data.ui?.ai?.enabled && data.framework === 'react',
+    // The models the proxy lets a request ask for: every tier (low, high, reasoning) of the chosen
+    // vendor, copied from foundation-ui's DEFAULT_AI_TIERS (foundation-ai src/tiers/ai-tiers.ts,
+    // 3fb72a1096: lines 150, 159, 171 and 179, 187, 196). Hard-coded, so a tier-table change means
+    // updating these too.
+    allowedModels:
+      aiVendor === 'anthropic'
+        ? 'claude-haiku-4-5-20251001,claude-sonnet-5,claude-opus-4-8'
+        : 'gemini-3.1-flash-lite,gemini-3.8-flash,gemini-3.1-pro-preview',
+    maxOutputTokens: 16000,
+  };
+
   const FDC3ListenersEnabled = data.ui?.fdc3?.channels?.length;
   data.FDC3 = {
     includeDependencies: !!(FDC3ListenersEnabled || FDC3EventHandlersEnabled),
@@ -176,6 +199,105 @@ module.exports = async (data, utils) => {
     });
 
 
+  // The chat proxy. It declares the AI_CHAT right but does not seed it: the project's rights files
+  // belong to the generator that sends them, and a second writer here would be overwritten by the
+  // csv loop above anyway (RIGHT, PROFILE and PROFILE_RIGHT arrive with no mode, so they replace).
+  if (data.AI.enabled) {
+    const appModule = path.resolve(__dirname, '../server/{{appName}}-app/src/main/genesis');
+    utils.writeFileWithData(
+      path.join(appModule, 'scripts/ai-service-web-handler.kts'),
+      data,
+      path.resolve(__dirname, 'templates/server/ai-service-web-handler.kts.hbs'),
+    );
+  }
+
+  // The chat panel's configuration as Create resolved it (C-8). Only what the pinned assistant reads is
+  // copied, as .genx/ai-consumer.json declares it (C-15A.6 S-1): a resource of any other kind, and any
+  // other key on a resource, is dropped and said. A customCode is rebuilt from the two values the
+  // assistant reads, and only an insert, modify or delete keeps it (C-18.D.5); references are rebuilt
+  // the same way, and only an insert or a modify keeps them (C-17.5); and a row action's key, inputs
+  // and effects are rebuilt from theirs (C-18.8.3). So nothing else in the payload can reach a file in
+  // the customer's app. Genx runs every .json file through Handlebars after
+  // this, so each `{{` is written as the JSON escape `\u007b\u007b`: it parses back to `{{`, and leaves
+  // Handlebars nothing to expand.
+  if (data.AI.enabled) {
+    const { enabled, vendor, tier, systemPrompt, resources } = data.ui.ai;
+    const passed = `passed to @genesislcap/ai-assistant ${versions.UI}`;
+    const projectedCode = ({ op, customCode: code }) => {
+      if (!code || !['insert', 'modify', 'delete'].includes(op)) return undefined;
+      const names = Array.isArray(code.alsoWrites) ? code.alsoWrites : [];
+      const alsoWrites = names.filter((name) => typeof name === 'string');
+      // A list that had to be cut is not complete, whatever it says.
+      const whole = Array.isArray(code.alsoWrites) && alsoWrites.length === names.length;
+      return { alsoWrites, listComplete: whole && code.listComplete === true };
+    };
+    // A list rebuilt item by item. Absent stays absent; a value that is not a list, or an item that is
+    // not an object, becomes null, which the assistant refuses rather than reads.
+    const isObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+    const listOf = (value, each) => {
+      if (value === undefined) return undefined;
+      if (!Array.isArray(value)) return null;
+      return value.map((item) => (isObject(item) ? each(item) : null));
+    };
+    const projectedReferences = ({ op, references }) =>
+      op === 'insert' || op === 'modify'
+        ? listOf(references, ({ resource, fields }) => ({
+            resource,
+            fields: fields == null ? [] : listOf(fields, ({ field, targetField }) => ({ field, targetField })),
+          }))
+        : undefined;
+    // A row action's fields: shape and entity as given, and each list rebuilt (C-18.8.3). A key is
+    // kept only where it names a row, on a custom event, a modify or a delete (C-19); anywhere else
+    // the assistant would leave the whole resource out over it, so it is not written.
+    const rowFields = {
+      key: (key, { op }) => {
+        if (key === undefined || !['custom', 'modify', 'delete'].includes(op)) return undefined;
+        return Array.isArray(key) ? key.filter((name) => typeof name === 'string') : null;
+      },
+      inputs: (inputs) => listOf(inputs, ({ field, required }) => ({ field, required })),
+      effects: (effects) => listOf(effects, ({ op, table }) => ({ op, table })),
+    };
+    const kept = [];
+    for (const resource of resources || []) {
+      if (!aiConsumer.kinds.includes(resource.kind)) {
+        console.warn(`ai: dropped resource ${resource.name} — kind ${resource.kind} is not ${passed}`);
+        continue;
+      }
+      for (const key of Object.keys(resource).filter((key) => !aiConsumer.resourceFields.includes(key))) {
+        console.warn(`ai: dropped ${key} on ${resource.name} — not ${passed}`);
+      }
+      const copy = Object.fromEntries(
+        aiConsumer.resourceFields.filter((key) => key in resource).map((key) => [key, resource[key]]),
+      );
+      // Left undefined, it is not written at all.
+      if ('customCode' in copy) copy.customCode = projectedCode(resource);
+      if ('references' in copy) copy.references = projectedReferences(resource);
+      for (const [field, rebuilt] of Object.entries(rowFields)) {
+        if (field in copy) copy[field] = rebuilt(resource[field], resource);
+      }
+      kept.push(copy);
+    }
+    const config = { enabled, vendor, tier, systemPrompt, resources: kept };
+    const file = path.resolve(__dirname, '../client/src/ai/generated/ai-config.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const json = JSON.stringify(config, null, 2).replace(/\{\{/g, '\\u007b\\u007b');
+    fs.writeFileSync(file, `${json}\n`);
+
+    // The panel's code, copied as written. Genx renders these once more like any other file, so they
+    // hold no Handlebars and come out unchanged.
+    const templates = path.resolve(__dirname, 'templates/react/ai');
+    const clientSrc = path.resolve(__dirname, '../client/src');
+    [
+      ['pbc-elements.ts.hbs', 'pbc/ai-assistant/elements.ts'],
+      ['assistant-host.ts.hbs', 'ai/generated/assistant-host.ts'],
+      ['assistant.ts.hbs', 'ai/generated/assistant.ts'],
+      ['extensions.ts.hbs', 'ai/extensions/index.ts'],
+    ].forEach(([template, target]) => {
+      fs.mkdirSync(path.dirname(path.join(clientSrc, target)), { recursive: true });
+      fs.copyFileSync(path.join(templates, template), path.join(clientSrc, target));
+    });
+  }
+
   if (data.excludeGradleWrapper) {
     deleteGradleWrappers();
   }

package/.genx/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/blank-app-seed-config",
   "description": "Genesis Blank App Seed Configuration",
-  "version": "5.27.2-prerelease.2",
+  "version": "5.28.0",
   "license": "Apache-2.0",
   "scripts": {
     "lint": "eslint .",

package/.genx/scripts/check-ai-declaration.mjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+//
+// Proves the seed's AI declaration against the @genesislcap/ai-assistant a generated app installed
+// (C-15A.6 S-6). This is the only place "the assistant reads it" is checked, and it is checked where
+// the pinned package really is.
+//
+//   baseline ⊆ declaration ⊆ GENESIS_AI_CONSUMES, for the kinds and for the resource fields.
+//
+// An assistant with no `./genesis/consumes` entry (before the release that added it) reads the
+// baseline only, so the declaration must then BE the baseline. Absent means exactly Node's
+// ERR_PACKAGE_PATH_NOT_EXPORTED for that subpath, when resolving it: the package missing, any error
+// while loading the module (whatever its code), or a constant that is not an object of two lists of
+// names fails the check.
+//
+// How: a child `node --input-type=module` runs in the client dir, so the app's own install answers,
+// under import conditions. It calls import.meta.resolve, then import(), each in a try of its own,
+// prints what each said and exits, so a module that keeps a process alive cannot hang the step.
+// Resolved with require instead, an export for import only would read as absent. An export for
+// require only does read as absent here, which fails safe: that assistant is held to the baseline.
+//
+// Usage: node check-ai-declaration.mjs <.genx/ai-consumer.json> <generated app's client dir>
+
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+
+// What every assistant with a chat reads, and what Create emits when a seed declares nothing (G-2).
+const BASELINE = {
+  kinds: ['request', 'event'],
+  resourceFields: ['name', 'kind', 'op', 'context', 'maxRows'],
+};
+
+const [declarationFile, clientDir] = process.argv.slice(2);
+const problems = [];
+
+const declaration = JSON.parse(readFileSync(declarationFile, 'utf8'));
+const listOfNames = (value) => Array.isArray(value) && value.every((item) => typeof item === 'string');
+if (declaration.version !== 1) problems.push(`version is ${declaration.version}, not 1`);
+for (const part of ['kinds', 'resourceFields']) {
+  if (!listOfNames(declaration[part])) problems.push(`${part} is not a list of names`);
+}
+
+// See the header for why this runs in a child.
+const SUBPATH = '@genesislcap/ai-assistant/genesis/consumes';
+const probe = `
+const said = {};
+let url;
+try {
+  url = import.meta.resolve(${JSON.stringify(SUBPATH)});
+} catch (error) {
+  said.resolve = { code: error?.code, message: String(error?.message) };
+}
+if (url) {
+  try {
+    const loaded = await import(url);
+    const value = loaded.GENESIS_AI_CONSUMES ?? loaded.default?.GENESIS_AI_CONSUMES;
+    // JSON drops a function, so what it is travels on its own.
+    said.type =
+      value === undefined || value === null ? 'missing' : Array.isArray(value) ? 'array' : typeof value;
+    said.consumes = value;
+  } catch (error) {
+    said.load = { code: error?.code, message: String(error?.message) };
+  }
+}
+process.stdout.write('\\n' + JSON.stringify(said), () => process.exit(0));
+`;
+const run = spawnSync(process.execPath, ['--input-type=module', '-e', probe], {
+  cwd: clientDir,
+  encoding: 'utf8',
+  timeout: 60_000,
+});
+let said = {};
+let probed = false;
+try {
+  // A child that had to be killed, whatever it printed, did not finish: that is not an answer.
+  if (run.error) throw run.error;
+  // The last line: whatever the module itself prints comes before it.
+  said = JSON.parse(run.stdout.trim().split('\n').pop());
+  probed = true;
+} catch {
+  const why = run.error?.message ?? (run.stderr.trim().split('\n')[0] || `exit ${run.status}`);
+  problems.push(`${SUBPATH} could not be probed: ${why}`);
+}
+const absent =
+  said.resolve?.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED' && said.resolve.message.includes("'./genesis/consumes'");
+if (said.resolve && !absent) {
+  problems.push(`${SUBPATH} could not be resolved: ${said.resolve.code ?? said.resolve.message}`);
+}
+if (said.load) {
+  problems.push(`${SUBPATH} could not be loaded: ${said.load.code ?? said.load.message}`);
+}
+// Loaded, the constant must be an object of two lists of names, or nothing is known about it.
+const consumes = said.type === 'object' ? said.consumes : undefined;
+if (probed && !said.resolve && !said.load && !consumes) {
+  problems.push(`${SUBPATH} exports no GENESIS_AI_CONSUMES object (${said.type ?? 'nothing said'})`);
+}
+for (const part of consumes ? ['kinds', 'resourceFields'] : []) {
+  if (!listOfNames(consumes[part])) problems.push(`the installed assistant's ${part} is not a list of names`);
+}
+
+const missing = (from, within) => from.filter((item) => !within.includes(item));
+for (const part of ['kinds', 'resourceFields']) {
+  const declared = listOfNames(declaration[part]) ? declaration[part] : [];
+  const below = missing(BASELINE[part], declared);
+  if (below.length) problems.push(`${part} leaves out the baseline's ${below.join(', ')}`);
+  if (consumes) {
+    const beyond = missing(declared, listOfNames(consumes[part]) ? consumes[part] : []);
+    if (beyond.length) problems.push(`${part} names ${beyond.join(', ')}, which the installed assistant does not read`);
+  } else if (absent) {
+    // Nothing to read beyond the baseline: the declaration is the baseline, exactly.
+    const beyond = missing(declared, BASELINE[part]);
+    if (beyond.length) problems.push(`${part} names ${beyond.join(', ')}, and this assistant reads the baseline only`);
+  }
+}
+
+problems.forEach((problem) => console.log(`    ${problem}`));
+process.exit(problems.length ? 1 : 0);