@agentlang/agentmanager 0.0.3

package/libs/agentcraft/src/services/ui-blueprint-generator.service.ts

@@ -0,0 +1,387 @@
+import { Injectable, Inject, Optional, Logger } from '@nestjs/common';
+import { CRAFT_LLM_PROVIDER } from '../constants';
+import { CraftLlmProvider } from '../interfaces/llm-provider.interface';
+import type { ToolDefinition } from '../types/llm.types';
+import {
+  DesignResult,
+  RequirementsResult,
+  UIBlueprint,
+  PageBlueprint,
+  WidgetBlueprint,
+  NavigationGroup,
+  NavigationItem,
+} from '../types/architect.types';
+
+@Injectable()
+export class UIBlueprintGeneratorService {
+  private readonly logger = new Logger(UIBlueprintGeneratorService.name);
+
+  private readonly uiBlueprintTool: ToolDefinition = {
+    name: 'produce_ui_blueprint',
+    description: 'Produce a complete UI blueprint with flat arrays.',
+    inputSchema: {
+      type: 'object',
+      required: [
+        'projectName',
+        'navigationGroups',
+        'navigationItems',
+        'pages',
+        'widgets',
+      ],
+      additionalProperties: false,
+      properties: {
+        projectName: { type: 'string' },
+        navigationGroups: {
+          type: 'array',
+          items: {
+            type: 'object',
+            required: ['group', 'icon'],
+            additionalProperties: false,
+            properties: {
+              group: { type: 'string' },
+              icon: { type: 'string' },
+            },
+          },
+        },
+        navigationItems: {
+          type: 'array',
+          items: {
+            type: 'object',
+            required: ['id', 'label', 'type', 'target', 'group'],
+            additionalProperties: false,
+            properties: {
+              id: { type: 'string' },
+              label: { type: 'string' },
+              type: { type: 'string', enum: ['entity', 'page', 'agent'] },
+              target: { type: 'string' },
+              group: { type: 'string' },
+            },
+          },
+        },
+        pages: {
+          type: 'array',
+          items: {
+            type: 'object',
+            required: ['id', 'title', 'description', 'pageType'],
+            additionalProperties: false,
+            properties: {
+              id: { type: 'string' },
+              title: { type: 'string' },
+              description: { type: 'string' },
+              pageType: {
+                type: 'string',
+                enum: [
+                  'collection',
+                  'detail',
+                  'dashboard',
+                  'agent-chat',
+                  'custom',
+                ],
+              },
+              entity: { type: 'string' },
+              relatedEntities: { type: 'array', items: { type: 'string' } },
+              actions: { type: 'array', items: { type: 'string' } },
+            },
+          },
+        },
+        widgets: {
+          type: 'array',
+          items: {
+            type: 'object',
+            required: ['pageId', 'type', 'label', 'config'],
+            additionalProperties: false,
+            properties: {
+              pageId: { type: 'string' },
+              type: {
+                type: 'string',
+                enum: [
+                  'table',
+                  'chart',
+                  'stats',
+                  'kanban',
+                  'form',
+                  'card',
+                  'chat',
+                  'timeline',
+                  'heading',
+                ],
+              },
+              entity: { type: 'string' },
+              label: { type: 'string' },
+              config: { type: 'object' },
+            },
+          },
+        },
+      },
+    },
+  };
+
+  constructor(
+    @Inject(CRAFT_LLM_PROVIDER)
+    @Optional()
+    private readonly llm: CraftLlmProvider | null,
+  ) {}
+
+  async generateUIBlueprint(
+    inventory: DesignResult,
+    requirements: RequirementsResult,
+  ): Promise<UIBlueprint> {
+    if (!this.llm) throw new Error('LLM provider not configured');
+
+    this.logger.log(
+      `Generating UI blueprint for "${inventory.baseline.appName}"`,
+    );
+    const systemPrompt = this.buildBlueprintPrompt(inventory, requirements);
+
+    const response = await this.llm.chat({
+      system: systemPrompt,
+      messages: [
+        {
+          role: 'user',
+          content:
+            'Design the UI blueprint for this application. Include a home dashboard, collection and detail pages for all entities, agent chat pages, and a logical navigation structure.',
+        },
+      ],
+      maxTokens: 64000,
+      tools: [this.uiBlueprintTool],
+      toolChoice: { type: 'tool', name: 'produce_ui_blueprint' },
+      cacheControl: true,
+    });
+
+    this.logger.log(
+      `LLM response received (toolCalls: ${response.toolCalls?.length ?? 0}, truncated: ${response.truncated ?? false})`,
+    );
+
+    if (response.truncated) {
+      throw new Error(`UI blueprint generation was truncated.`);
+    }
+
+    const toolCall = response.toolCalls?.[0];
+    if (toolCall) {
+      this.logger.log('Parsing blueprint from tool call');
+      const result = this.parseToolCallInput(toolCall.input);
+      this.logger.log(
+        `Blueprint: ${result.navigation.length} nav groups, ${result.pages.length} pages`,
+      );
+      return result;
+    }
+
+    throw new Error('UI blueprint generation did not return a tool call.');
+  }
+
+  private buildBlueprintPrompt(
+    inventory: DesignResult,
+    requirements: RequirementsResult,
+  ): string {
+    const allEntities: string[] = [];
+    const allRelationships: string[] = [];
+    const allEvents: string[] = [];
+    const allAgents: string[] = [];
+
+    for (const e of inventory.baseline.entities) {
+      allEntities.push(
+        `- ${e.name} (baseline, ${inventory.baseline.moduleName}): ${e.description}`,
+      );
+    }
+    for (const r of inventory.baseline.relationships) {
+      allRelationships.push(
+        `- ${r.name}: ${r.between[0]} ↔ ${r.between[1]} (${r.type})`,
+      );
+    }
+
+    for (const app of inventory.subApps) {
+      for (const e of app.entities) {
+        allEntities.push(
+          `- ${e.name} (${app.appName}, ${app.moduleName}): ${e.description}`,
+        );
+      }
+      for (const r of app.relationships) {
+        allRelationships.push(
+          `- ${r.name}: ${r.between[0]} ↔ ${r.between[1]} (${r.type})`,
+        );
+      }
+      for (const ev of app.events) {
+        const pub = ev.public ? ' @public' : '';
+        allEvents.push(
+          `- ${ev.name} (${app.appName})${pub}: ${ev.description}`,
+        );
+      }
+      for (const a of app.agents) {
+        allAgents.push(`- ${a.name} (${app.appName}): ${a.description}`);
+      }
+    }
+
+    const reqSummary = [
+      `### Baseline: ${requirements.baseline.appName}`,
+      requirements.baseline.requirements,
+      ...requirements.subApps.map((s) => `### ${s.appName}\n${s.requirements}`),
+    ].join('\n\n');
+
+    return `You are a UI/UX architect. Given a complete application inventory and detailed requirements, design a UI blueprint.
+
+## Entities
+${allEntities.join('\n')}
+
+## Relationships
+${allRelationships.length > 0 ? allRelationships.join('\n') : '(none)'}
+
+## Events / Workflows
+${allEvents.length > 0 ? allEvents.join('\n') : '(none)'}
+
+## Agents
+${allAgents.length > 0 ? allAgents.join('\n') : '(none)'}
+
+## Detailed Requirements
+${reqSummary}
+
+## Design Rules
+
+1. Create a unified UI — one navigation, one set of pages.
+2. Group navigation items logically by functional area.
+3. Include a home dashboard with overview stats.
+4. For each entity, create collection and detail pages.
+5. Choose the best widget type for each use case.
+6. Map every event/workflow to a user action on the appropriate page.
+7. Every agent should have a chat page.
+8. Detail pages should show related entities.
+9. Use clear, user-friendly titles.
+
+Call the \`produce_ui_blueprint\` tool with the complete blueprint.`;
+  }
+
+  private parseToolCallInput(input: unknown): UIBlueprint {
+    if (!input || typeof input !== 'object') {
+      throw new Error('UI blueprint tool call input is not an object.');
+    }
+
+    const obj = input as Record<string, unknown>;
+    const projectName =
+      typeof obj.projectName === 'string' ? obj.projectName : 'App';
+
+    const rawGroups = Array.isArray(obj.navigationGroups)
+      ? obj.navigationGroups
+      : [];
+    const rawNavItems = Array.isArray(obj.navigationItems)
+      ? obj.navigationItems
+      : [];
+    const rawPages = Array.isArray(obj.pages) ? obj.pages : [];
+    const rawWidgets = Array.isArray(obj.widgets) ? obj.widgets : [];
+
+    if (!Array.isArray(obj.pages)) {
+      throw new Error('UI blueprint must include a pages array.');
+    }
+
+    const widgetsByPage = new Map<string, WidgetBlueprint[]>();
+    for (const raw of rawWidgets) {
+      if (!raw || typeof raw !== 'object') continue;
+      const w = raw as Record<string, unknown>;
+      const pageId = typeof w.pageId === 'string' ? w.pageId : '';
+      const widget = this.parseWidget(w);
+      const list = widgetsByPage.get(pageId);
+      if (list) {
+        list.push(widget);
+      } else {
+        widgetsByPage.set(pageId, [widget]);
+      }
+    }
+
+    const pages: PageBlueprint[] = rawPages.map((raw) => {
+      const page = this.parsePage(raw);
+      page.widgets = widgetsByPage.get(page.id) ?? [];
+      return page;
+    });
+
+    const itemsByGroup = new Map<string, NavigationItem[]>();
+    for (const raw of rawNavItems) {
+      if (!raw || typeof raw !== 'object') continue;
+      const n = raw as Record<string, unknown>;
+      const group = typeof n.group === 'string' ? n.group : '';
+      const item = this.parseNavItem(n);
+      const list = itemsByGroup.get(group);
+      if (list) {
+        list.push(item);
+      } else {
+        itemsByGroup.set(group, [item]);
+      }
+    }
+
+    const navigation: NavigationGroup[] = rawGroups.map((raw) => {
+      if (!raw || typeof raw !== 'object')
+        return { group: '', icon: '', items: [] };
+      const g = raw as Record<string, unknown>;
+      const groupName = typeof g.group === 'string' ? g.group : '';
+      return {
+        group: groupName,
+        icon: typeof g.icon === 'string' ? g.icon : '',
+        items: itemsByGroup.get(groupName) ?? [],
+      };
+    });
+
+    return { projectName, navigation, pages };
+  }
+
+  private parseNavItem(raw: Record<string, unknown>): NavigationItem {
+    return {
+      id: typeof raw.id === 'string' ? raw.id : '',
+      label: typeof raw.label === 'string' ? raw.label : '',
+      type:
+        typeof raw.type === 'string' &&
+        ['entity', 'page', 'agent'].includes(raw.type)
+          ? (raw.type as NavigationItem['type'])
+          : 'page',
+      target: typeof raw.target === 'string' ? raw.target : '',
+    };
+  }
+
+  private parsePage(raw: unknown): PageBlueprint {
+    if (!raw || typeof raw !== 'object')
+      throw new Error('Page blueprint is not an object.');
+    const obj = raw as Record<string, unknown>;
+    return {
+      id: typeof obj.id === 'string' ? obj.id : '',
+      title: typeof obj.title === 'string' ? obj.title : '',
+      description: typeof obj.description === 'string' ? obj.description : '',
+      pageType:
+        typeof obj.pageType === 'string' &&
+        ['collection', 'detail', 'dashboard', 'agent-chat', 'custom'].includes(
+          obj.pageType,
+        )
+          ? (obj.pageType as PageBlueprint['pageType'])
+          : 'custom',
+      entity: typeof obj.entity === 'string' ? obj.entity : undefined,
+      relatedEntities: Array.isArray(obj.relatedEntities)
+        ? obj.relatedEntities.filter((r): r is string => typeof r === 'string')
+        : undefined,
+      actions: Array.isArray(obj.actions)
+        ? obj.actions.filter((a): a is string => typeof a === 'string')
+        : undefined,
+      widgets: [],
+    };
+  }
+
+  private parseWidget(raw: Record<string, unknown>): WidgetBlueprint {
+    const validTypes = [
+      'table',
+      'chart',
+      'stats',
+      'kanban',
+      'form',
+      'card',
+      'chat',
+      'timeline',
+      'heading',
+    ];
+    return {
+      type:
+        typeof raw.type === 'string' && validTypes.includes(raw.type)
+          ? (raw.type as WidgetBlueprint['type'])
+          : 'table',
+      entity: typeof raw.entity === 'string' ? raw.entity : undefined,
+      label: typeof raw.label === 'string' ? raw.label : '',
+      config:
+        raw.config && typeof raw.config === 'object'
+          ? (raw.config as Record<string, unknown>)
+          : {},
+    };
+  }
+}

package/libs/agentcraft/src/types/architect.types.ts

@@ -0,0 +1,156 @@
+// ── Decomposer types ────────────────────────────────────────────────
+
+export interface SubAppDefinition {
+  name: string;
+  description: string;
+}
+
+export interface DecompositionResult {
+  projectName: string;
+  baselineDescription: string;
+  subApps: SubAppDefinition[];
+}
+
+// ── Requirements types ──────────────────────────────────────────────
+
+export interface AppRequirements {
+  appName: string;
+  requirements: string;
+}
+
+export interface RequirementsResult {
+  baseline: AppRequirements;
+  subApps: AppRequirements[];
+}
+
+// ── Design types ────────────────────────────────────────────────────
+
+export interface FeatureAnnotation {
+  feature: string;
+  rationale: string;
+}
+
+export interface EntitySpec {
+  name: string;
+  description: string;
+  features: FeatureAnnotation[];
+}
+
+export interface RelationshipSpec {
+  name: string;
+  between: [string, string];
+  type: 'one_one' | 'one_many' | 'many_many';
+  kind: 'contains' | 'between';
+  rationale: string;
+  roleAliases?: [string, string];
+  hasSchema?: boolean;
+  hasSchemaRationale?: string;
+}
+
+export interface WorkflowSpec {
+  name: string;
+  description: string;
+  dataTouched: string[];
+  triggerOn?: {
+    timing: 'before' | 'after';
+    operation: 'create' | 'update' | 'delete';
+    entity: string;
+  };
+  withRole?: string;
+}
+
+export interface EventSpec {
+  name: string;
+  public: boolean;
+  description: string;
+}
+
+export interface AgentSpec {
+  name: string;
+  description: string;
+  goal: string;
+  tools: string[];
+  capabilities: FeatureAnnotation[];
+}
+
+export interface AppSpec {
+  appName: string;
+  dirName: string;
+  moduleName: string;
+  entities: EntitySpec[];
+  relationships: RelationshipSpec[];
+  events: EventSpec[];
+  workflows: WorkflowSpec[];
+  agents: AgentSpec[];
+}
+
+export interface DesignResult {
+  baseline: AppSpec;
+  subApps: AppSpec[];
+}
+
+// ── UI Blueprint types ──────────────────────────────────────────────
+
+export interface WidgetBlueprint {
+  type:
+    | 'table'
+    | 'chart'
+    | 'stats'
+    | 'kanban'
+    | 'form'
+    | 'card'
+    | 'chat'
+    | 'timeline'
+    | 'heading';
+  entity?: string;
+  label: string;
+  config: Record<string, unknown>;
+}
+
+export interface PageBlueprint {
+  id: string;
+  title: string;
+  description: string;
+  pageType: 'collection' | 'detail' | 'dashboard' | 'agent-chat' | 'custom';
+  entity?: string;
+  relatedEntities?: string[];
+  actions?: string[];
+  widgets: WidgetBlueprint[];
+}
+
+export interface NavigationItem {
+  id: string;
+  label: string;
+  type: 'entity' | 'page' | 'agent';
+  target: string;
+}
+
+export interface NavigationGroup {
+  group: string;
+  icon: string;
+  items: NavigationItem[];
+}
+
+export interface UIBlueprint {
+  projectName: string;
+  navigation: NavigationGroup[];
+  pages: PageBlueprint[];
+}
+
+// ── README types ────────────────────────────────────────────────────
+
+export interface GeneratedSources {
+  baseline?: { dirName: string; code: string };
+  subApps: { dirName: string; code: string }[];
+}
+
+// ── Watcher types ───────────────────────────────────────────────────
+
+export interface KBChangeEvent {
+  projectName: string;
+  kbPath: string;
+}
+
+export interface WatcherOptions {
+  pollIntervalMs?: number;
+}

package/libs/agentcraft/src/types/autonomous.types.ts

@@ -0,0 +1,71 @@
+export type PlanStepKind =
+  | 'data-model'
+  | 'workflows'
+  | 'agents'
+  | 'resolver'
+  | 'assembly';
+
+export type AutonomousMode = 'full' | 'data-model-only';
+
+export interface ResolverDirective {
+  name: string;
+  description: string;
+  specSource: string;
+  action: 'generate' | 'use-existing';
+  existingResolverRepo?: string;
+}
+
+export interface PlanStep {
+  id: string;
+  kind: PlanStepKind;
+  title: string;
+  description: string;
+  dependsOn: string[];
+  resolver?: ResolverDirective;
+}
+
+export interface Plan {
+  projectName: string;
+  summary: string;
+  steps: PlanStep[];
+}
+
+export interface StepResult {
+  stepId: string;
+  kind: PlanStepKind;
+  code: string;
+  validated: boolean;
+  attempts: number;
+}
+
+export interface ExecutionContext {
+  plan: Plan;
+  kbContent: string;
+  completedSteps: Map<string, StepResult>;
+  resolverMeta?: string;
+  resolverFiles?: { al: string; js: string };
+  baselineDataModel?: string;
+}
+
+export interface AutonomousRunConfig {
+  userMessage: string;
+  userId: string;
+  projectName: string;
+  kbPath: string;
+  outputDir?: string;
+  mode?: AutonomousMode;
+  baselineDataModel?: string;
+}
+
+export interface ExecutorCallbacks {
+  onStepStart(step: PlanStep, index: number, total: number): void;
+  onStepComplete(step: PlanStep, result: StepResult): void;
+  onValidationError(
+    step: PlanStep,
+    errors: string,
+    code: string,
+    attempt: number,
+  ): void;
+  onInfo(message: string): void;
+  onWarning(message: string): void;
+}

package/libs/agentcraft/src/types/llm.types.d.ts

@@ -0,0 +1,26 @@
+export interface LlmRequest {
+  systemPrompt: string;
+  userPrompt: string;
+  temperature?: number;
+  maxTokens?: number;
+}
+export interface LlmResponse {
+  text: string;
+  stopReason?: 'end_turn' | 'max_tokens';
+}
+export interface ChatMessage {
+  role: 'user' | 'assistant';
+  content: string | ContentBlock[];
+}
+export interface ContentBlock {
+  type: 'text';
+  text: string;
+}
+export interface ChatRequest {
+  system: string;
+  messages: ChatMessage[];
+}
+export interface ChatResponse {
+  content: ContentBlock[];
+  stopReason: 'end_turn' | 'max_tokens';
+}

package/libs/agentcraft/src/types/llm.types.js

@@ -0,0 +1,3 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+//# sourceMappingURL=llm.types.js.map

package/libs/agentcraft/src/types/llm.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm.types.js","sourceRoot":"","sources":["llm.types.ts"],"names":[],"mappings":""}

package/libs/agentcraft/src/types/llm.types.ts

@@ -0,0 +1,60 @@
+export interface LlmRequest {
+  systemPrompt: string;
+  userPrompt: string;
+  temperature?: number;
+  maxTokens?: number;
+}
+
+export interface LlmResponse {
+  text: string;
+  stopReason?: 'end_turn' | 'max_tokens';
+}
+
+export interface ChatMessage {
+  role: 'user' | 'assistant';
+  content: string | ContentBlock[];
+}
+
+export interface ContentBlock {
+  type: 'text';
+  text: string;
+}
+
+export interface ToolDefinition {
+  name: string;
+  description?: string;
+  inputSchema: Record<string, unknown>;
+}
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  input: unknown;
+}
+
+export interface ConversationMessage {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
+export interface ChatRequest {
+  system: string;
+  messages: ChatMessage[];
+  maxTokens?: number;
+  tools?: ToolDefinition[];
+  toolChoice?: { type: 'tool'; name: string };
+  cacheControl?: boolean;
+}
+
+export interface ChatResponse {
+  content: ContentBlock[];
+  stopReason: 'end_turn' | 'max_tokens';
+  toolCalls?: ToolCall[];
+  truncated?: boolean;
+  usage?: {
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+  };
+}