@agentlang/agentmanager 0.0.3

package/libs/agentcraft/src/services/executor.service.ts

@@ -0,0 +1,452 @@
+import { Injectable, Inject, Optional, Logger } from '@nestjs/common';
+import fs from 'node:fs';
+import path from 'node:path';
+import { CRAFT_LLM_PROVIDER } from '../constants';
+import { CraftLlmProvider } from '../interfaces/llm-provider.interface';
+import {
+  ExecutionContext,
+  PlanStep,
+  StepResult,
+  ExecutorCallbacks,
+} from '../types/autonomous.types';
+import type { ConversationMessage } from '../types/llm.types';
+import { buildCodeGenSystemPrompt } from '../prompts/codegen.prompt';
+import { buildAssemblySystemPrompt } from '../prompts/assembly.prompt';
+import {
+  buildResolverSystemPrompt,
+  parseResolverOutput,
+  buildResolverMeta,
+} from '../prompts/resolver.prompt';
+import { fetchSpec } from '../utils/spec-fetcher';
+import { trimSpec } from '../utils/spec-trimmer';
+import { validateCode, normalizeGeneratedCode } from '../utils/validator';
+import { writeAppFiles } from '../utils/output-writer';
+import {
+  extractModuleName,
+  pascalToKebabCase,
+  stripModuleLine,
+} from '../utils/text-utils';
+import { PlannerService } from './planner.service';
+
+const MAX_VALIDATION_RETRIES = 3;
+
+@Injectable()
+export class ExecutorService {
+  private readonly logger = new Logger(ExecutorService.name);
+
+  constructor(
+    @Inject(CRAFT_LLM_PROVIDER)
+    @Optional()
+    private readonly llm: CraftLlmProvider | null,
+    private readonly planner: PlannerService,
+  ) {}
+
+  async executePlan(
+    ctx: ExecutionContext,
+    outputDir: string,
+    callbacks: ExecutorCallbacks,
+  ): Promise<void> {
+    if (!this.llm) throw new Error('LLM provider not configured');
+
+    const ordered = this.planner.getExecutionOrder(ctx.plan.steps);
+
+    for (let i = 0; i < ordered.length; i++) {
+      const step = ordered[i];
+      callbacks.onStepStart(step, i + 1, ordered.length);
+
+      let result: StepResult;
+
+      switch (step.kind) {
+        case 'data-model':
+        case 'workflows':
+        case 'agents':
+          result = await this.generateCodeStep(step, ctx, callbacks);
+          break;
+        case 'resolver':
+          result = await this.handleResolverStep(step, ctx, callbacks);
+          break;
+        case 'assembly':
+          result = await this.handleAssemblyStep(ctx, outputDir, callbacks);
+          break;
+        default:
+          throw new Error(`Unknown step kind: ${step.kind}`);
+      }
+
+      ctx.completedSteps.set(step.id, result);
+      callbacks.onStepComplete(step, result);
+    }
+  }
+
+  writeBestEffortOutput(
+    ctx: ExecutionContext,
+    outputDir: string,
+    callbacks: ExecutorCallbacks,
+  ): void {
+    const mergedCode = this.collectPreviousCode(ctx);
+    if (!mergedCode.trim()) return;
+
+    const srcDir = path.join(outputDir, 'src');
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(srcDir, 'core.al'),
+      normalizeGeneratedCode(mergedCode) + '\n',
+    );
+    callbacks.onInfo(`Wrote best-effort src/core.al to ${outputDir}`);
+
+    if (ctx.resolverFiles) {
+      this.writeResolverFiles(ctx, outputDir, callbacks);
+    }
+  }
+
+  private collectPreviousCode(ctx: ExecutionContext): string {
+    const parts: string[] = [];
+    let hasModule = false;
+
+    for (const [, result] of ctx.completedSteps) {
+      if (result.kind === 'assembly' || result.kind === 'resolver') continue;
+      if (!result.code.trim()) continue;
+
+      if (!hasModule) {
+        parts.push(result.code);
+        hasModule = true;
+      } else {
+        parts.push(stripModuleLine(result.code));
+      }
+    }
+
+    return parts.join('\n\n');
+  }
+
+  private async generateCodeStep(
+    step: PlanStep,
+    ctx: ExecutionContext,
+    callbacks: ExecutorCallbacks,
+  ): Promise<StepResult> {
+    const previousCode = this.collectPreviousCode(ctx);
+    const systemPrompt = buildCodeGenSystemPrompt(
+      step.kind,
+      step.description,
+      previousCode,
+      ctx.kbContent,
+      ctx.plan.projectName,
+      ctx.resolverMeta,
+      ctx.baselineDataModel,
+    );
+
+    const messages: ConversationMessage[] = [
+      { role: 'user', content: 'Generate the code as described in the task.' },
+    ];
+
+    for (let attempt = 1; attempt <= MAX_VALIDATION_RETRIES + 1; attempt++) {
+      const response = await this.llm!.chat({
+        system: systemPrompt,
+        messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      });
+      const text = response.content
+        .filter((b) => b.type === 'text')
+        .map((b) => b.text)
+        .join('');
+      const code = normalizeGeneratedCode(text);
+
+      const codeToValidate =
+        step.kind === 'data-model'
+          ? code
+          : previousCode
+            ? previousCode + '\n\n' + stripModuleLine(code)
+            : code;
+
+      const validation = await validateCode(codeToValidate);
+
+      if (validation.valid) {
+        return {
+          stepId: step.id,
+          kind: step.kind,
+          code,
+          validated: true,
+          attempts: attempt,
+        };
+      }
+
+      callbacks.onValidationError(
+        step,
+        validation.errors ?? 'Unknown error',
+        codeToValidate,
+        attempt,
+      );
+
+      if (attempt <= MAX_VALIDATION_RETRIES) {
+        messages.push({ role: 'assistant', content: text });
+        messages.push({
+          role: 'user',
+          content: `Validation for your last response failed:\n${JSON.stringify({ status: 'error', reason: validation.errors })}\n\nPlease fix the agentlang code and try again.`,
+        });
+      } else {
+        callbacks.onWarning(
+          `Step "${step.title}" failed validation after ${attempt} attempts. Continuing with best effort.`,
+        );
+        return {
+          stepId: step.id,
+          kind: step.kind,
+          code,
+          validated: false,
+          attempts: attempt,
+        };
+      }
+    }
+
+    return {
+      stepId: step.id,
+      kind: step.kind,
+      code: '',
+      validated: false,
+      attempts: MAX_VALIDATION_RETRIES + 1,
+    };
+  }
+
+  private async handleResolverStep(
+    step: PlanStep,
+    ctx: ExecutionContext,
+    callbacks: ExecutorCallbacks,
+  ): Promise<StepResult> {
+    const directive = step.resolver;
+    if (!directive) {
+      callbacks.onWarning(
+        `Resolver step "${step.title}" has no resolver directive. Skipping.`,
+      );
+      return {
+        stepId: step.id,
+        kind: 'resolver',
+        code: '',
+        validated: false,
+        attempts: 0,
+      };
+    }
+
+    if (directive.action === 'use-existing') {
+      callbacks.onInfo(
+        `Using existing resolver: ${directive.name}` +
+          (directive.existingResolverRepo
+            ? ` from ${directive.existingResolverRepo}`
+            : ''),
+      );
+      ctx.resolverMeta = `# Existing Resolver: ${directive.name}\n\n${directive.description}\n\nThe resolver is pre-built and available. Reference its entities using fully-qualified names.`;
+      return {
+        stepId: step.id,
+        kind: 'resolver',
+        code: '',
+        validated: true,
+        attempts: 0,
+      };
+    }
+
+    if (!directive.specSource) {
+      callbacks.onWarning(
+        `Resolver step "${step.title}" has no specSource. Skipping.`,
+      );
+      return {
+        stepId: step.id,
+        kind: 'resolver',
+        code: '',
+        validated: false,
+        attempts: 0,
+      };
+    }
+
+    callbacks.onInfo(`Fetching API spec from: ${directive.specSource}`);
+
+    let specContent: string;
+    try {
+      specContent = await fetchSpec(directive.specSource);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      callbacks.onWarning(
+        `Failed to fetch API spec: ${msg}. Skipping resolver generation.`,
+      );
+      return {
+        stepId: step.id,
+        kind: 'resolver',
+        code: '',
+        validated: false,
+        attempts: 0,
+      };
+    }
+
+    const trimResult = trimSpec(specContent, directive.description);
+    if (trimResult.trimmedSize < trimResult.originalSize) {
+      const pct = (
+        (1 - trimResult.trimmedSize / trimResult.originalSize) *
+        100
+      ).toFixed(0);
+      callbacks.onInfo(`API spec trimmed by ${pct}%`);
+    }
+
+    const systemPrompt = buildResolverSystemPrompt(
+      directive.name,
+      directive.description,
+      trimResult.content,
+    );
+
+    const messages: ConversationMessage[] = [
+      {
+        role: 'user',
+        content: `Generate a resolver for: ${directive.description}`,
+      },
+    ];
+
+    const response = await this.llm!.chat({
+      system: systemPrompt,
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+    });
+
+    const text = response.content
+      .filter((b) => b.type === 'text')
+      .map((b) => b.text)
+      .join('');
+
+    const parsed = parseResolverOutput(text);
+
+    if (!parsed) {
+      callbacks.onWarning('Could not parse resolver output. Skipping.');
+      return {
+        stepId: step.id,
+        kind: 'resolver',
+        code: text,
+        validated: false,
+        attempts: 1,
+      };
+    }
+
+    ctx.resolverMeta = parsed.meta;
+    ctx.resolverFiles = { al: parsed.al, js: parsed.js };
+
+    callbacks.onInfo(`Resolver "${directive.name}" generated successfully.`);
+    return {
+      stepId: step.id,
+      kind: 'resolver',
+      code: parsed.rawOutput,
+      validated: true,
+      attempts: 1,
+    };
+  }
+
+  private async handleAssemblyStep(
+    ctx: ExecutionContext,
+    outputDir: string,
+    callbacks: ExecutorCallbacks,
+  ): Promise<StepResult> {
+    const mergedCode = this.collectPreviousCode(ctx);
+
+    if (!mergedCode.trim()) {
+      callbacks.onWarning('No code to assemble.');
+      return {
+        stepId: 'assembly',
+        kind: 'assembly',
+        code: '',
+        validated: false,
+        attempts: 0,
+      };
+    }
+
+    let baseAppDirName: string | undefined;
+    if (ctx.baselineDataModel) {
+      const baseModuleName = extractModuleName(ctx.baselineDataModel);
+      if (baseModuleName) {
+        const baseAppName = baseModuleName.replace(/\.core$/, '');
+        baseAppDirName = pascalToKebabCase(baseAppName);
+      }
+    }
+    const systemPrompt = buildAssemblySystemPrompt(
+      ctx.plan.projectName,
+      baseAppDirName,
+    );
+
+    const resolverContext = this.buildResolverContext(ctx);
+
+    const userContent = [
+      '## Complete Agentlang Module',
+      '',
+      '```agentlang',
+      mergedCode,
+      '```',
+    ];
+
+    if (resolverContext) {
+      userContent.push('', '## Resolver Files', '', resolverContext);
+    }
+
+    const response = await this.llm!.chat({
+      system: systemPrompt,
+      messages: [{ role: 'user', content: userContent.join('\n') }],
+    });
+
+    const text = response.content
+      .filter((b) => b.type === 'text')
+      .map((b) => b.text)
+      .join('');
+
+    const writtenFiles = writeAppFiles(text, outputDir);
+
+    if (writtenFiles.length > 0) {
+      callbacks.onInfo(`Wrote ${writtenFiles.length} file(s) to ${outputDir}`);
+    } else {
+      callbacks.onWarning(
+        'Assembly output could not be parsed into files. Writing raw model as src/core.al.',
+      );
+      const srcDir = path.join(outputDir, 'src');
+      fs.mkdirSync(srcDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(srcDir, 'core.al'),
+        normalizeGeneratedCode(mergedCode) + '\n',
+      );
+      callbacks.onInfo(`Wrote src/core.al to ${outputDir}`);
+    }
+
+    if (ctx.resolverFiles) {
+      this.writeResolverFiles(ctx, outputDir, callbacks);
+    }
+
+    return {
+      stepId: 'assembly',
+      kind: 'assembly',
+      code: text,
+      validated: true,
+      attempts: 1,
+    };
+  }
+
+  private buildResolverContext(ctx: ExecutionContext): string {
+    if (!ctx.resolverFiles) return '';
+    const parts: string[] = [];
+    if (ctx.resolverFiles.al) {
+      parts.push(`--- RESOLVER FILE: resolver.al ---\n${ctx.resolverFiles.al}`);
+    }
+    if (ctx.resolverFiles.js) {
+      parts.push(`--- RESOLVER FILE: resolver.js ---\n${ctx.resolverFiles.js}`);
+    }
+    return parts.join('\n\n');
+  }
+
+  private writeResolverFiles(
+    ctx: ExecutionContext,
+    outputDir: string,
+    callbacks: ExecutorCallbacks,
+  ): void {
+    if (!ctx.resolverFiles) return;
+    const srcDir = path.join(outputDir, 'src');
+    fs.mkdirSync(srcDir, { recursive: true });
+
+    if (ctx.resolverFiles.al) {
+      fs.writeFileSync(
+        path.join(srcDir, 'resolver.al'),
+        ctx.resolverFiles.al + '\n',
+      );
+    }
+    if (ctx.resolverFiles.js) {
+      fs.writeFileSync(
+        path.join(srcDir, 'resolver.js'),
+        ctx.resolverFiles.js + '\n',
+      );
+    }
+    callbacks.onInfo('Wrote resolver files to src/');
+  }
+}

package/libs/agentcraft/src/services/kb-watcher.service.ts

@@ -0,0 +1,150 @@
+import { Injectable, OnModuleDestroy, Logger } from '@nestjs/common';
+import fs from 'node:fs';
+import path from 'node:path';
+import { KBChangeEvent, WatcherOptions } from '../types/architect.types';
+
+const SUPPORTED_EXTENSIONS = new Set([
+  '.txt',
+  '.md',
+  '.markdown',
+  '.al',
+  '.json',
+  '.yaml',
+  '.yml',
+]);
+
+interface FolderSnapshot {
+  files: Map<string, number>;
+}
+
+@Injectable()
+export class KbWatcherService implements OnModuleDestroy {
+  private readonly logger = new Logger(KbWatcherService.name);
+  private timer: ReturnType<typeof setInterval> | null = null;
+
+  startWatching(
+    rootKbPath: string,
+    onChange: (event: KBChangeEvent) => void,
+    options?: WatcherOptions,
+  ): void {
+    if (this.timer) {
+      this.stopWatching();
+    }
+
+    const resolvedRoot = path.resolve(rootKbPath);
+    const pollInterval = options?.pollIntervalMs ?? 3000;
+    const snapshots = new Map<string, FolderSnapshot>();
+
+    for (const dir of this.listSubdirectories(resolvedRoot)) {
+      const kbPath = path.join(resolvedRoot, dir);
+      const snap = this.snapshotFolder(kbPath);
+      if (snap.files.size > 0) {
+        snapshots.set(dir, snap);
+      }
+    }
+
+    this.timer = setInterval(() => {
+      const currentDirs = this.listSubdirectories(resolvedRoot);
+
+      for (const dir of currentDirs) {
+        const kbPath = path.join(resolvedRoot, dir);
+        const currentSnap = this.snapshotFolder(kbPath);
+
+        if (currentSnap.files.size === 0) continue;
+
+        const prevSnap = snapshots.get(dir);
+
+        if (!prevSnap) {
+          snapshots.set(dir, currentSnap);
+          onChange({ projectName: dir, kbPath });
+        } else if (this.hasChanged(prevSnap, currentSnap)) {
+          snapshots.set(dir, currentSnap);
+          onChange({ projectName: dir, kbPath });
+        }
+      }
+
+      for (const dir of snapshots.keys()) {
+        if (!currentDirs.includes(dir)) {
+          snapshots.delete(dir);
+        }
+      }
+    }, pollInterval);
+
+    this.logger.log(
+      `Started watching ${resolvedRoot} (poll: ${pollInterval}ms)`,
+    );
+  }
+
+  stopWatching(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+      this.logger.log('Stopped watching');
+    }
+  }
+
+  onModuleDestroy() {
+    this.stopWatching();
+  }
+
+  private snapshotFolder(dirPath: string): FolderSnapshot {
+    const files = new Map<string, number>();
+    let entries: string[];
+    try {
+      entries = fs.readdirSync(dirPath);
+    } catch {
+      return { files };
+    }
+
+    for (const entry of entries) {
+      const ext = path.extname(entry).toLowerCase();
+      if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
+
+      const filePath = path.join(dirPath, entry);
+      try {
+        const stat = fs.statSync(filePath);
+        if (stat.isFile()) {
+          files.set(entry, stat.mtimeMs);
+        }
+      } catch {
+        // skip
+      }
+    }
+
+    return { files };
+  }
+
+  private hasChanged(prev: FolderSnapshot, curr: FolderSnapshot): boolean {
+    if (prev.files.size !== curr.files.size) return true;
+
+    for (const [file, mtime] of curr.files) {
+      const prevMtime = prev.files.get(file);
+      if (prevMtime === undefined || prevMtime !== mtime) return true;
+    }
+
+    return false;
+  }
+
+  private listSubdirectories(dirPath: string): string[] {
+    let entries: string[];
+    try {
+      entries = fs.readdirSync(dirPath);
+    } catch {
+      return [];
+    }
+
+    const dirs: string[] = [];
+    for (const entry of entries) {
+      if (entry.startsWith('.')) continue;
+      const fullPath = path.join(dirPath, entry);
+      try {
+        if (fs.statSync(fullPath).isDirectory()) {
+          dirs.push(entry);
+        }
+      } catch {
+        // skip
+      }
+    }
+    return dirs.sort();
+  }
+}

package/libs/agentcraft/src/services/openai-llm.service.d.ts

@@ -0,0 +1,9 @@
+import { LlmProvider } from '../interfaces/llm-provider.interface';
+import { LlmRequest, LlmResponse } from '../types/llm.types';
+export declare class OpenaiLlmService implements LlmProvider {
+  private readonly model;
+  private readonly apiKey;
+  private readonly baseUrl;
+  constructor(model: string, apiKey: string, baseUrl?: string);
+  complete(request: LlmRequest): Promise<LlmResponse>;
+}

package/libs/agentcraft/src/services/openai-llm.service.js

@@ -0,0 +1,91 @@
+'use strict';
+var __decorate =
+  (this && this.__decorate) ||
+  function (decorators, target, key, desc) {
+    var c = arguments.length,
+      r =
+        c < 3
+          ? target
+          : desc === null
+            ? (desc = Object.getOwnPropertyDescriptor(target, key))
+            : desc,
+      d;
+    if (typeof Reflect === 'object' && typeof Reflect.decorate === 'function')
+      r = Reflect.decorate(decorators, target, key, desc);
+    else
+      for (var i = decorators.length - 1; i >= 0; i--)
+        if ((d = decorators[i]))
+          r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return (c > 3 && r && Object.defineProperty(target, key, r), r);
+  };
+var __metadata =
+  (this && this.__metadata) ||
+  function (k, v) {
+    if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function')
+      return Reflect.metadata(k, v);
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.OpenaiLlmService = void 0;
+const common_1 = require('@nestjs/common');
+const llm_errors_1 = require('../errors/llm.errors');
+let OpenaiLlmService = class OpenaiLlmService {
+  model;
+  apiKey;
+  baseUrl;
+  constructor(model, apiKey, baseUrl = 'https://api.openai.com/v1') {
+    this.model = model;
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  async complete(request) {
+    const url = `${this.baseUrl.replace(/\/+$/, '')}/chat/completions`;
+    let res;
+    try {
+      res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify({
+          model: this.model,
+          max_tokens: request.maxTokens ?? 16384,
+          temperature: request.temperature ?? 0,
+          messages: [
+            { role: 'system', content: request.systemPrompt },
+            { role: 'user', content: request.userPrompt },
+          ],
+        }),
+      });
+    } catch (err) {
+      throw new llm_errors_1.LlmRequestFailedError(
+        `Failed to connect to OpenAI-compatible API: ${err.message}`,
+      );
+    }
+    if (!res.ok) {
+      const body = await res.text().catch(() => '');
+      throw new llm_errors_1.LlmRequestFailedError(
+        `OpenAI-compatible API returned ${res.status}: ${body}`,
+      );
+    }
+    const json = await res.json();
+    const text = json?.choices?.[0]?.message?.content;
+    if (typeof text !== 'string') {
+      throw new llm_errors_1.LlmRequestFailedError(
+        'Unexpected response shape from OpenAI-compatible API',
+      );
+    }
+    const finishReason = json?.choices?.[0]?.finish_reason;
+    const stopReason = finishReason === 'length' ? 'max_tokens' : 'end_turn';
+    return { text, stopReason };
+  }
+};
+exports.OpenaiLlmService = OpenaiLlmService;
+exports.OpenaiLlmService = OpenaiLlmService = __decorate(
+  [
+    (0, common_1.Injectable)(),
+    __metadata('design:paramtypes', [String, String, String]),
+  ],
+  OpenaiLlmService,
+);
+//# sourceMappingURL=openai-llm.service.js.map

package/libs/agentcraft/src/services/openai-llm.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-llm.service.js","sourceRoot":"","sources":["openai-llm.service.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAA4C;AAG5C,qDAA6D;AAGtD,IAAM,gBAAgB,GAAtB,MAAM,gBAAgB;IAER;IACA;IACA;IAHnB,YACmB,KAAa,EACb,MAAc,EACd,UAAkB,2BAA2B;QAF7C,UAAK,GAAL,KAAK,CAAQ;QACb,WAAM,GAAN,MAAM,CAAQ;QACd,YAAO,GAAP,OAAO,CAAsC;IAC7D,CAAC;IAEJ,KAAK,CAAC,QAAQ,CAAC,OAAmB;QAChC,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,mBAAmB,CAAC;QACnE,IAAI,GAAa,CAAC;QAClB,IAAI,CAAC;YACH,GAAG,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;gBACrB,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE;oBACP,cAAc,EAAE,kBAAkB;oBAClC,aAAa,EAAE,UAAU,IAAI,CAAC,MAAM,EAAE;iBACvC;gBACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;oBACnB,KAAK,EAAE,IAAI,CAAC,KAAK;oBACjB,UAAU,EAAE,OAAO,CAAC,SAAS,IAAI,KAAK;oBACtC,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,CAAC;oBACrC,QAAQ,EAAE;wBACR,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,YAAY,EAAE;wBACjD,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE;qBAC9C;iBACF,CAAC;aACH,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,IAAI,kCAAqB,CAC7B,+CAAgD,GAAa,CAAC,OAAO,EAAE,CACxE,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;YACZ,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;YAC9C,MAAM,IAAI,kCAAqB,CAC7B,kCAAkC,GAAG,CAAC,MAAM,KAAK,IAAI,EAAE,CACxD,CAAC;QACJ,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC;QAC9B,MAAM,IAAI,GAAG,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC;QAClD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7B,MAAM,IAAI,kCAAqB,CAC7B,sDAAsD,CACvD,CAAC;QACJ,CAAC;QACD,MAAM,YAAY,GAAG,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC;QACvD,MAAM,UAAU,GACd,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAqB,CAAC,CAAC,CAAC,UAAmB,CAAC;QAC1E,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;IAC9B,CAAC;CACF,CAAA;AApDY,4CAAgB;2BAAhB,gBAAgB;IAD5B,IAAA,mBAAU,GAAE;;GACA,gBAAgB,CAoD5B"}