@ggui-ai/ui-gen 0.23.0 → 0.25.0

package/src/harness/primitive-slice.ts

@@ -23,6 +23,7 @@
 // prompt-build time and modifies the LLM's *initial* conditioning
 // uniformly — it cannot contaminate a retry trajectory mid-run.
 
+import type { DataContract, JsonSchema } from "@ggui-ai/protocol";
 import type { Classification } from "../classifier/index.js";
 
 /** Primitives every fixture needs — layout + typography + core interaction.
@@ -162,6 +163,62 @@ export function computePrimitiveAllowlist(
   return [...set].sort();
 }
 
+/**
+ * The input primitives a contract's own fields imply (ggui#1324).
+ *
+ * The axis-keyed allowlist is derived from the classification alone, so a card
+ * whose axes do not say "form" still loses the inputs its contract needs: the
+ * #45 kanban canary edits a task's title and priority through an action
+ * payload, and the axis slice dropped `Input` / `TextArea` / `Select`.
+ *
+ * Walks every context slot's schema and every action payload's schema down to
+ * its leaves (object `properties`, array `items`) and maps each leaf type:
+ * an `enum` → `Select`, `RadioGroup`; `string` → `Input`, `TextArea`,
+ * `FormField`; `number` / `integer` → `Input`, `Slider`; `boolean` →
+ * `Checkbox`, `Toggle`. A declared stream adds `Spinner` and `Badge`. Props are
+ * display data and add nothing (the classification covers display). Returns a
+ * sorted array.
+ */
+export function computeContractPrimitives(
+  contract: DataContract | undefined,
+): readonly string[] {
+  const out = new Set<string>();
+  if (!contract) return [];
+  for (const slot of Object.values(contract.contextSpec ?? {})) addLeaves(slot.schema, out);
+  for (const action of Object.values(contract.actionSpec ?? {})) {
+    if (action.schema) addLeaves(action.schema, out);
+  }
+  if (Object.keys(contract.streamSpec ?? {}).length > 0) {
+    out.add("Spinner");
+    out.add("Badge");
+  }
+  return [...out].sort();
+}
+
+function addLeaves(schema: JsonSchema, out: Set<string>): void {
+  for (const child of Object.values(schema.properties ?? {})) addLeaves(child, out);
+  if (schema.items) addLeaves(schema.items, out);
+  if (schema.enum && schema.enum.length > 0) {
+    out.add("Select");
+    out.add("RadioGroup");
+    return;
+  }
+  const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+  for (const t of types) {
+    if (t === "string") {
+      out.add("Input");
+      out.add("TextArea");
+      out.add("FormField");
+    } else if (t === "number" || t === "integer") {
+      out.add("Input");
+      out.add("Slider");
+    } else if (t === "boolean") {
+      out.add("Checkbox");
+      out.add("Toggle");
+    }
+  }
+}
+
 /**
  * Slice `PRIMITIVES_DOCUMENTATION` to include only the allowlisted primitive
  * sections. The doc structure is:
@@ -222,3 +279,50 @@ export function slicePrimitiveDocumentation(
 
   return preamble + kept.join("");
 }
+
+/**
+ * Slice the TypeScript-interface primitives reference
+ * (`PRIMITIVES_DOCUMENTATION_TS`) by the same allowlist the markdown
+ * slicer takes (ggui#1324, speed/002).
+ *
+ * The TS doc is a sequence of SECTIONS, each opened by a header line
+ * `// <Name> — <description>` and carrying that name's `interface`, its
+ * `// Example:` and the usage snippet that follows; category banners
+ * (`// ═══…`) sit between sections. A section whose `<Name>` is a KNOWN
+ * primitive is kept iff `<Name>` is in the allowlist. Every other line is
+ * kept: the preamble, the banners, the `CRITICAL` guidance sections, the
+ * support-type sections (`SelectOption`, `TableColumn`, …) and any section
+ * the slicer does not know — the same guidance rule as
+ * {@link slicePrimitiveDocumentation}. Allowing every known name returns the
+ * doc byte-identical.
+ *
+ * With no section header found the doc is returned whole (defensive, as the
+ * markdown slicer does when it finds no `### ` sections).
+ */
+export function slicePrimitiveDocumentationTs(
+  fullDoc: string,
+  allowlist: readonly string[],
+): string {
+  const allow = new Set(allowlist);
+  const lines = fullDoc.split("\n");
+  let sawHeader = false;
+  let keep = true;
+  const kept: string[] = [];
+  for (const line of lines) {
+    const header = TS_SECTION_HEADER.exec(line);
+    if (header !== null) {
+      sawHeader = true;
+      const name = header[1]!;
+      keep = !KNOWN_PRIMITIVE_SECTIONS.has(name) || allow.has(name);
+    } else if (TS_SECTION_BANNER.test(line)) {
+      keep = true;
+    }
+    if (keep) kept.push(line);
+  }
+  return sawHeader ? kept.join("\n") : fullDoc;
+}
+
+/** `// Button — A clickable button …`: the line that opens a TS-doc section. */
+const TS_SECTION_HEADER = /^\/\/ ([A-Za-z]+) — /;
+/** `// ═══…`: a category banner between TS-doc sections; always kept. */
+const TS_SECTION_BANNER = /^\/\/ ═/;

package/src/harness/runtime.ts

@@ -33,6 +33,7 @@ import { renderPitfallsBlock } from "./pitfalls.js";
 import type { GadgetDescriptor, DataContract, JsonObject } from "@ggui-ai/protocol";
 import { buildSystemPrompt as buildSystemPromptSkeleton } from "../boilerplate.js";
 import type { AgentConfig } from "./llm-router.js";
+import type { CriteriaBank } from "../evaluation/criteria/bank.js";
 import type { CanvasClass, DesignMode } from "../design-mode.js";
 
 // Re-export the boilerplate generator so existing internal importers
@@ -103,6 +104,10 @@ export interface SingleComponentParams {
      * default tokens. Never part of the prompt or the identity.
      */
     cssTokens?: string;
+    /** ggui#1436 — the visual criteria bank (data, parsed by `parseCriteriaBank`); absent = no block, today's judge. */
+    criteriaBank?: CriteriaBank;
+    /** ggui#1436 — the caller's item kind for the selector (a bootstrap mint's `hello`); absent = not gated by kind. */
+    criteriaKind?: string;
   };
   onProgress?: (event: unknown) => void;
   onInitialResult?: (result: {

package/src/harness/types-public.ts

@@ -148,10 +148,18 @@ export interface RuntimeRenderOutcome {
   readonly issues: readonly EvalIssue[];
   /** Populated for `infra-skipped` / `not-applicable` / `timed-out` — why the probe didn't finish. */
   readonly reason?: string;
-  /** `timed-out` only: how long the probe ran before it was stopped. */
+  /**
+   * How long the check took, wall-clock, measured by the adapter around the
+   * check — on every status that reached it (`ran`, `timed-out`,
+   * `infra-skipped`). Absent on `not-applicable`: nothing ran.
+   */
   readonly elapsedMs?: number;
+  /** `ran` only: the check's own render time, inside `elapsedMs`. */
+  readonly renderMs?: number;
   /** Host load around the probe, when it ran isolated (absent for an in-process probe). */
   readonly hostLoad?: ProbeHostLoad;
+  /** Time the check waited for a probe slot before it started, ms; present only when > 0 (ggui#1380 C2b). */
+  readonly queuedMs?: number;
 }
 
 export interface RuntimeRenderCheck {

package/src/harness-tool-names.ts

@@ -0,0 +1,38 @@
+/**
+ * The coding loop's tool set — the ONE list `createHarness` builds its
+ * coding and scoped tools from, and the identity a build stamp names it
+ * by.
+ *
+ * `harnessToolNames(mode)` returns one entry per tool definition,
+ * `<name>@<digest>`: the tool's own (unprefixed) name and the first 8 hex
+ * of sha256 over `JSON.stringify` of its definition — so a change to a
+ * tool's schema OR its description (prompt text, as output-changing as a
+ * template) moves the entry, and two definitions that share a name (a
+ * scoped variant keeps the name and narrows the grammar) are two entries.
+ * Coding and scoped alike, since the scoped set runs on the
+ * duplicate-fingerprint escape; sorted, de-duplicated, a fresh array. It
+ * reads the same constants the harness is assembled from, so the list can
+ * never drift from what runs; the pin beside it holds the two equal for
+ * every design mode. The design mode is part of the signature because the
+ * tool set is keyed by the harness a mode builds, even while both modes
+ * declare the same tools.
+ */
+import { createHash } from 'node:crypto';
+import type { LLMToolDef } from './llm.js';
+import type { DesignMode } from './design-mode.js';
+import { APPLY_CHANGES_TOOL, APPLY_CHANGES_TOOL_SCOPED } from './tools.js';
+
+/** The coding tools every harness declares (`what.codingTools`). */
+export const HARNESS_CODING_TOOLS: readonly LLMToolDef[] = [APPLY_CHANGES_TOOL];
+/** The scoped fallback the runtime promotes into `codingTools` on a duplicate-fingerprint escape. */
+export const HARNESS_SCOPED_TOOLS: readonly LLMToolDef[] = [APPLY_CHANGES_TOOL_SCOPED];
+
+/** One tool's entry: `<name>@<first 8 hex of sha256(JSON.stringify(def))>`. */
+export function harnessToolEntry(def: LLMToolDef): string {
+  return `${def.name}@${createHash('sha256').update(JSON.stringify(def), 'utf8').digest('hex').slice(0, 8)}`;
+}
+
+export function harnessToolNames(designMode: DesignMode): string[] {
+  void designMode; // one tool set for every mode today; the mode keys the harness, so it stays on the signature
+  return [...new Set([...HARNESS_CODING_TOOLS, ...HARNESS_SCOPED_TOOLS].map(harnessToolEntry))].sort();
+}

package/src/index.ts

@@ -20,8 +20,14 @@ export {
   extractComponentCode,
 } from './create-ui-generator.js';
 export type { CreateUiGeneratorOptions } from './create-ui-generator.js';
+export type { RuntimeRenderProbeConfig } from './harness/check/runtime-render/adapter.js';
 export type { ProviderRetryInfo } from './harness/llm-router.js';
 export type { GenerationResult, SameExchangeBreak } from './harness/result-types.js';
+// The build identity a stamp outside this package can name: the same
+// digests `createUiGenerator` puts on every result's `metadata.build`, for
+// either design mode — so a harness definition can carry both modes' digests
+// while a run's metadata carries only the mode that ran.
+export { generatorBuild } from './generator-build.js';
 export type { UiGenBuild } from './generator-build.js';
 
 // Generator registry seam re-export. The interface + slug helpers live
@@ -53,6 +59,12 @@ export {
 export type { RenderingContext } from './contract-context.js';
 export { canvasForRenderingContext } from './contract-context.js';
 
+// ── The coding loop's tool set ───────────────────────────────────────
+//
+// The tools the harness declares, by name — the one list `createHarness`
+// builds from, so a build stamp names the same set that runs.
+export { harnessToolEntry, harnessToolNames, HARNESS_CODING_TOOLS, HARNESS_SCOPED_TOOLS } from './harness-tool-names.js';
+
 // ── Design mode ──────────────────────────────────────────────────────
 //
 // `createUiGenerator({ designMode })` — `constrained` (default) or
@@ -83,5 +95,9 @@ export type {
 // go through this helper instead of `new Anthropic(...)` so future
 // header / baseURL tweaks land in one place.
 export { createAnthropicClient } from './adapters/claude/client.js';
+// ggui#1185: the credential a key resolver returns to select the local CLI
+// login path (`ggui serve --local-cli-login`); never a real key.
+export { CLAUDE_CODE_LOGIN_CREDENTIAL } from './adapters/claude/claude-code-login.js';
 export { AESTHETIC_BRIEF_MAX_CHARS, type GenerationProfileInput } from './boilerplate/styling-profile.js';
+export type { VisualEvalAgentSpec } from './adapters/generation-dispatch.js';
 export { EFFORT_DIALS, EFFORT_TABLE_VERSION, effortDials, type EffortDials } from './effort.js';

package/src/policy.ts

@@ -86,12 +86,15 @@ export interface ContextPolicy {
    * Axis-keyed primitives doc slice. When `"axis-keyed"`, the first-turn
    * system prompt injects only the allowlisted primitives derived from
    * the classification, shrinking the ~130 KB monolith to ~30–50 KB.
-   * Default `"full"`.
+   * `"axis-keyed+contract"` adds the input primitives the contract's own
+   * fields imply (ggui#1324: the axis slice alone dropped `Input` /
+   * `TextArea` from a card that edits a string). Default `"full"`.
    */
-  readonly primitiveDocSlice?: "full" | "axis-keyed";
+  readonly primitiveDocSlice?: "full" | "axis-keyed" | "axis-keyed+contract";
   /**
-   * Primitives to exclude from the axis-keyed slice. Only meaningful
-   * when `primitiveDocSlice === "axis-keyed"`.
+   * Primitives to exclude from the axis-keyed slice (applied after the
+   * contract additions under `"axis-keyed+contract"`). Only meaningful
+   * when `primitiveDocSlice` is one of the two slice modes.
    */
   readonly primitiveDocExcludes?: readonly string[];
   /**

package/src/run-check.ts

@@ -121,6 +121,8 @@ export async function runCheck(input: RunCheckInput): Promise<CheckResult> {
     designMode: harness.designMode,
     // ggui#1117: the canvas the harness was built for, when it has one — never a default.
     ...(harness.canvas !== undefined ? { canvas: harness.canvas } : {}),
+    // ggui#1285: the props the probe and judge rendered with — the fixture-echo check reads them.
+    ...(input.fixtureProps !== undefined ? { fixtureProps: input.fixtureProps } : {}),
   };
   // The one runner `runAxisChecks` shares (ggui#1046 trace prints here, on the served path).
   const axisRun = runGatedAxisChecks(check.axisChecks, axisInput);