@almadar/agent 3.5.7 → 3.5.12

package/dist/evals/online-sampling.d.ts

@@ -110,5 +110,19 @@ export interface ReviewOptions {
     minScore?: number;
     format?: 'json' | 'table';
 }
+/**
+ * Review collected online evaluation samples.
+ *
+ * Displays a table or JSON summary of sampled evaluations for a given date,
+ * including scores, latency, provider, and success status.
+ *
+ * @param {OnlineEvalSampler} sampler - The sampler instance to pull samples from
+ * @param {ReviewOptions} [options] - Options for filtering and formatting output
+ * @param {string} [options.date] - Date to review (YYYY-MM-DD format, defaults to today)
+ * @param {number} [options.limit] - Maximum number of samples to show (default: 20)
+ * @param {number} [options.minScore] - Minimum score filter
+ * @param {string} [options.format] - Output format: 'json' or 'table' (default: table)
+ * @returns {Promise<void>}
+ */
 export declare function reviewSamples(sampler: OnlineEvalSampler, options?: ReviewOptions): Promise<void>;
 export declare function createOnlineEvalSampler(config?: Partial<SamplingConfig>): OnlineEvalSampler;

package/dist/gates/agentic/tools.d.ts

@@ -262,23 +262,33 @@ export declare function createConnectTool(workDir: string): import("@langchain/c
 export declare function createComposeTool(workDir: string): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
     appName: z.ZodOptional<z.ZodString>;
     orbitalFiles: z.ZodOptional<z.ZodString>;
-    pagesJson: z.ZodOptional<z.ZodString>;
+    layoutStrategy: z.ZodOptional<z.ZodEnum<["sidebar", "tabs", "dashboard", "wizard-flow", "auto"]>>;
+    eventWiringJson: z.ZodOptional<z.ZodString>;
+    entityMappingsJson: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     appName?: string | undefined;
     orbitalFiles?: string | undefined;
-    pagesJson?: string | undefined;
+    layoutStrategy?: "dashboard" | "sidebar" | "tabs" | "wizard-flow" | "auto" | undefined;
+    eventWiringJson?: string | undefined;
+    entityMappingsJson?: string | undefined;
 }, {
     appName?: string | undefined;
     orbitalFiles?: string | undefined;
-    pagesJson?: string | undefined;
+    layoutStrategy?: "dashboard" | "sidebar" | "tabs" | "wizard-flow" | "auto" | undefined;
+    eventWiringJson?: string | undefined;
+    entityMappingsJson?: string | undefined;
 }>, {
     appName?: string | undefined;
     orbitalFiles?: string | undefined;
-    pagesJson?: string | undefined;
+    layoutStrategy?: "dashboard" | "sidebar" | "tabs" | "wizard-flow" | "auto" | undefined;
+    eventWiringJson?: string | undefined;
+    entityMappingsJson?: string | undefined;
 }, {
     appName?: string | undefined;
     orbitalFiles?: string | undefined;
-    pagesJson?: string | undefined;
+    layoutStrategy?: "dashboard" | "sidebar" | "tabs" | "wizard-flow" | "auto" | undefined;
+    eventWiringJson?: string | undefined;
+    entityMappingsJson?: string | undefined;
 }, {
     success: boolean;
     error: string;
@@ -299,4 +309,4 @@ export declare function createComposeTool(workDir: string): import("@langchain/c
         errors: string[];
     };
     error?: undefined;
-}, unknown, "compose_app">;
+}, unknown, "compose_behaviors">;

package/dist/gates/behavior-gates/behavior-orchestrator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Behavior Pipeline Orchestrator
+ *
+ * Chains BG0-A (decompose, 1 LLM call) -> BG0-B (match, 1 LLM call)
+ * -> BG1 -> BG2 -> BG3 (all deterministic).
+ *
+ * Total: 2 LLM calls for any app size.
+ *
+ * @packageDocumentation
+ */
+import type { LLMClient } from '@almadar/llm';
+import type { BehaviorPipelineConfig, BehaviorPipelineResult } from './types.js';
+/**
+ * Execute the complete Behavior Pipeline.
+ *
+ * Chains all behavior gates: BG0-A (decompose, 1 LLM call) -> BG0-B (match, 1 LLM call)
+ * -> BG1 -> BG2 -> BG3 (all deterministic). Total: 2 LLM calls for any app size.
+ *
+ * @param {LLMClient} client - The LLM client to use for generation
+ * @param {string} prompt - The user's natural language request
+ * @param {BehaviorPipelineConfig} [config] - Optional pipeline configuration
+ * @returns {Promise<BehaviorPipelineResult>} The complete pipeline result with schema
+ */
+export declare function runBehaviorPipeline(client: LLMClient, prompt: string, config?: BehaviorPipelineConfig): Promise<BehaviorPipelineResult>;
+/** Create the default Mistral Small client for behavior pipeline */
+export declare function createBehaviorClient(): LLMClient;

package/dist/gates/behavior-gates/behavior-prompts.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Behavior Prompts (BG0)
+ *
+ * Builds system and user prompts for the behavior selection gate.
+ * Uses behavior catalog sections from @almadar/skills.
+ *
+ * @packageDocumentation
+ */
+export declare function buildBG0SystemPrompt(): string;
+export declare function buildBG0UserPrompt(prompt: string): string;

package/dist/gates/behavior-gates/bg0-behavior-selection.d.ts

@@ -0,0 +1,23 @@
+/**
+ * BG0: Behavior Selection
+ *
+ * One LLM call. Selects behaviors from the standard library based on
+ * a natural language prompt and produces a BehaviorPlan.
+ *
+ * @packageDocumentation
+ */
+import type { LLMClient } from '@almadar/llm';
+import type { BehaviorPlan, BehaviorPipelineConfig } from './types.js';
+/**
+ * Execute BG0: Behavior Selection.
+ *
+ * Selects behaviors from the standard library based on a natural language
+ * prompt and produces a BehaviorPlan. This is the first step in the
+ * behavior-based generation pipeline.
+ *
+ * @param {LLMClient} client - The LLM client to use for selection
+ * @param {string} prompt - The user's natural language request
+ * @param {BehaviorPipelineConfig} [_config] - Optional pipeline configuration
+ * @returns {Promise<BehaviorPlan>} The selected behavior plan
+ */
+export declare function runBG0(client: LLMClient, prompt: string, _config?: BehaviorPipelineConfig): Promise<BehaviorPlan>;

package/dist/gates/behavior-gates/bg0a-decompose.d.ts

@@ -0,0 +1,29 @@
+/**
+ * BG0-A: Decompose
+ *
+ * First LLM call. Breaks a natural language prompt into a shell OrbitalSchema
+ * (orbital names, entity names with fields, pages). Then converts each orbital
+ * to a domain language paragraph for BG0-B to match against behaviors.
+ *
+ * Reuses the existing Gate 0 (decompose_app) logic.
+ *
+ * @packageDocumentation
+ */
+import type { LLMClient } from '@almadar/llm';
+import type { OrbitalSchema } from '@almadar/core/types';
+import type { BehaviorPipelineConfig } from './types.js';
+export interface DecomposeResult {
+    /** Shell schema from Gate 0 */
+    shellOrb: OrbitalSchema;
+    /** One domain language paragraph per orbital */
+    orbitalDescriptions: Array<{
+        orbitalName: string;
+        entityName: string;
+        domainText: string;
+        fields: Array<{
+            name: string;
+            type: string;
+        }>;
+    }>;
+}
+export declare function runBG0A(client: LLMClient, prompt: string, _config?: BehaviorPipelineConfig): Promise<DecomposeResult>;

package/dist/gates/behavior-gates/bg0b-match.d.ts

@@ -0,0 +1,29 @@
+/**
+ * BG0-B: Per-Orbital Behavior Matching
+ *
+ * Second LLM call. For each orbital description from BG0-A, selects the
+ * best behavior from the catalog. One focused decision per orbital.
+ *
+ * Uses a single batched LLM call for all orbitals (not one call per orbital)
+ * to keep total LLM calls at 2.
+ *
+ * @packageDocumentation
+ */
+import type { LLMClient } from '@almadar/llm';
+import type { BehaviorPlan, BehaviorPipelineConfig } from './types.js';
+import type { DecomposeResult } from './bg0a-decompose.js';
+/**
+ * Execute BG0-B: Per-Orbital Behavior Matching.
+ *
+ * Second LLM call in the behavior pipeline. For each orbital description
+ * from BG0-A, selects the best behavior from the catalog.
+ *
+ * Uses a single batched LLM call for all orbitals to keep total LLM calls at 2.
+ *
+ * @param {LLMClient} client - The LLM client to use for matching
+ * @param {DecomposeResult} decomposed - The decomposed result from BG0-A
+ * @param {string} originalPrompt - The original user request for context
+ * @param {BehaviorPipelineConfig} [_config] - Optional pipeline configuration
+ * @returns {Promise<BehaviorPlan>} The matched behavior plan
+ */
+export declare function runBG0B(client: LLMClient, decomposed: DecomposeResult, originalPrompt: string, _config?: BehaviorPipelineConfig): Promise<BehaviorPlan>;

package/dist/gates/behavior-gates/bg1-instantiation.d.ts

@@ -0,0 +1,11 @@
+/**
+ * BG1: Behavior Instantiation
+ *
+ * Zero LLM calls. Calls behavior pure functions from @almadar/std
+ * to produce OrbitalDefinitions. Falls back to golden .orb files.
+ *
+ * @packageDocumentation
+ */
+import type { OrbitalDefinition } from '@almadar/core/types';
+import type { BehaviorPlan } from './types.js';
+export declare function runBG1(plan: BehaviorPlan): Promise<OrbitalDefinition[]>;

package/dist/gates/behavior-gates/bg2-wiring.d.ts

@@ -0,0 +1,21 @@
+/**
+ * BG2: Event Wiring
+ *
+ * Zero LLM calls. Applies cross-orbital event wiring from
+ * the BehaviorPlan's suggestedWiring entries.
+ *
+ * @packageDocumentation
+ */
+import type { OrbitalDefinition } from '@almadar/core/types';
+import type { BehaviorPlan } from './types.js';
+/**
+ * Execute BG2: Event Wiring.
+ *
+ * Zero LLM calls. Applies cross-orbital event wiring from the BehaviorPlan's
+ * suggestedWiring entries to connect orbitals via events.
+ *
+ * @param {OrbitalDefinition[]} orbitals - The orbitals to wire together
+ * @param {BehaviorPlan} plan - The behavior plan containing wiring suggestions
+ * @returns {Promise<OrbitalDefinition[]>} The wired orbitals
+ */
+export declare function runBG2(orbitals: OrbitalDefinition[], plan: BehaviorPlan): Promise<OrbitalDefinition[]>;

package/dist/gates/behavior-gates/bg3-composition.d.ts

@@ -0,0 +1,22 @@
+/**
+ * BG3: Application Composition
+ *
+ * Zero LLM calls. Uses composeBehaviors from @almadar/core to
+ * produce a complete OrbitalSchema with pages and layout.
+ *
+ * @packageDocumentation
+ */
+import type { ComposeBehaviorsResult } from '@almadar/core/builders';
+import type { OrbitalDefinition } from '@almadar/core/types';
+import type { BehaviorPlan } from './types.js';
+/**
+ * Execute BG3: Application Composition.
+ *
+ * Zero LLM calls. Uses composeBehaviors from @almadar/core to produce
+ * a complete OrbitalSchema with pages and layout.
+ *
+ * @param {OrbitalDefinition[]} orbitals - The wired orbitals to compose
+ * @param {BehaviorPlan} plan - The behavior plan containing composition settings
+ * @returns {Promise<ComposeBehaviorsResult>} The composed application schema
+ */
+export declare function runBG3(orbitals: OrbitalDefinition[], plan: BehaviorPlan): Promise<ComposeBehaviorsResult>;

package/dist/gates/behavior-gates/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Behavior Gate Pipeline
+ *
+ * Sequential pipeline for behavior-based application composition.
+ * BG0-A (decompose, 1 LLM) -> BG0-B (match, 1 LLM) -> BG1 -> BG2 -> BG3 (deterministic).
+ *
+ * @packageDocumentation
+ */
+export { runBehaviorPipeline, createBehaviorClient } from './behavior-orchestrator.js';
+export { runBG0A, type DecomposeResult } from './bg0a-decompose.js';
+export { runBG0B } from './bg0b-match.js';
+export { runBG0 } from './bg0-behavior-selection.js';
+export { runBG1 } from './bg1-instantiation.js';
+export { runBG2 } from './bg2-wiring.js';
+export { runBG3 } from './bg3-composition.js';
+export type { BehaviorPlan, BehaviorSelection, BehaviorPipelineConfig, BehaviorPipelineResult } from './types.js';

package/dist/gates/behavior-gates/types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Behavior Gate Pipeline Types
+ *
+ * Type definitions for the sequential BG0-BG3 behavior composition pipeline.
+ *
+ * @packageDocumentation
+ */
+import type { OrbitalDefinition, OrbitalSchema } from '@almadar/core/types';
+import type { EventWiringEntry } from '@almadar/core/builders';
+export interface BehaviorSelection {
+    behaviorName: string;
+    entityName: string;
+    fields: Array<{
+        name: string;
+        type: string;
+        required?: boolean;
+        default?: unknown;
+    }>;
+    persistence: 'persistent' | 'runtime' | 'singleton';
+    pageTitle?: string;
+    pagePath?: string;
+}
+export interface BehaviorPlan {
+    appName: string;
+    selections: BehaviorSelection[];
+    suggestedWiring: EventWiringEntry[];
+    layoutStrategy?: 'sidebar' | 'tabs' | 'dashboard' | 'wizard-flow' | 'auto';
+}
+export interface BehaviorPipelineConfig {
+    workDir?: string;
+    validateAfterCompose?: boolean;
+}
+export interface BehaviorPipelineResult {
+    plan: BehaviorPlan;
+    orbitals: OrbitalDefinition[];
+    schema: OrbitalSchema;
+    layout: {
+        strategy: string;
+        pageCount: number;
+    };
+    validation: {
+        valid: boolean;
+        errors: string[];
+    };
+    timings: {
+        total: number;
+        bg0: number;
+        bg1: number;
+        bg2: number;
+        bg3: number;
+    };
+    llmCalls: number;
+}

package/dist/gates/gate0-application.d.ts

@@ -10,4 +10,17 @@
 import type { LLMClient } from '@almadar/llm';
 import type { OrbitalSchema } from '@almadar/core/types';
 import type { GateOpts, BehaviorGateData } from './types.js';
+/**
+ * Execute Gate 0: Application Decomposition.
+ *
+ * Decomposes a natural language prompt into an initial orbital schema
+ * with entities, traits, and pages. This is the first gate in the
+ * multi-gate generation pipeline.
+ *
+ * @param {LLMClient} client - The LLM client to use for generation
+ * @param {string} prompt - The user's natural language request
+ * @param {GateOpts} [opts] - Optional configuration for the gate
+ * @param {BehaviorGateData} [behaviorData] - Optional guidance from behavior analysis
+ * @returns {Promise<OrbitalSchema>} The decomposed orbital schema
+ */
 export declare function runGate0(client: LLMClient, prompt: string, opts?: GateOpts, behaviorData?: BehaviorGateData): Promise<OrbitalSchema>;

package/dist/gates/gate35-pattern-match.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Gate 3.5: Pattern Matching
+ *
+ * Selects the 10-20 most relevant UI patterns for this application.
+ * Two-phase approach:
+ *   1. Deterministic pre-filter: analyze state machine to exclude irrelevant
+ *      categories (game patterns for CRUD apps, form patterns for read-only, etc.)
+ *   2. LLM selection: pick from the pre-filtered set
+ *
+ * Gate 4 then receives only these patterns with full prop details.
+ *
+ * @packageDocumentation
+ */
+import type { LLMClient } from '@almadar/llm';
+import type { OrbitalSchema } from '@almadar/core/types';
+import type { GateOpts } from './types.js';
+/**
+ * Run Gate 3.5: select relevant patterns for this application.
+ * Phase 1: deterministic pre-filter based on state machine analysis.
+ * Phase 2: LLM selects from the pre-filtered set.
+ * Returns an array of pattern names (always includes core patterns).
+ */
+export declare function runGate35(client: LLMClient, orb: OrbitalSchema, _opts?: GateOpts): Promise<string[]>;

package/dist/gates/gate4-render-ui.d.ts

@@ -14,4 +14,4 @@ import type { GateOpts, BehaviorGateData } from './types.js';
  * Append render-ui effects to all transitions.
  * Builds slot context from state machine and passes it to every LLM call.
  */
-export declare function runGate4(client: LLMClient, orb: OrbitalSchema, opts?: GateOpts, _behaviorData?: BehaviorGateData): Promise<OrbitalSchema>;
+export declare function runGate4(client: LLMClient, orb: OrbitalSchema, opts?: GateOpts, _behaviorData?: BehaviorGateData, matchedPatterns?: string[]): Promise<OrbitalSchema>;