@agentlang/agentmanager 0.0.3

package/libs/agentcraft/src/services/architect-loop.service.js

@@ -0,0 +1,92 @@
+'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 ArchitectLoopFactory_1;
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ArchitectLoopFactory = void 0;
+const common_1 = require('@nestjs/common');
+let ArchitectLoopFactory =
+  (ArchitectLoopFactory_1 = class ArchitectLoopFactory {
+    logger = new common_1.Logger(ArchitectLoopFactory_1.name);
+    create(config) {
+      return new DefaultArchitectLoop(config, this.logger);
+    }
+  });
+exports.ArchitectLoopFactory = ArchitectLoopFactory;
+exports.ArchitectLoopFactory =
+  ArchitectLoopFactory =
+  ArchitectLoopFactory_1 =
+    __decorate([(0, common_1.Injectable)()], ArchitectLoopFactory);
+class DefaultArchitectLoop {
+  config;
+  logger;
+  queue = [];
+  running = false;
+  stopped = false;
+  onLog = null;
+  onSignalComplete = null;
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+  ingest(signal) {
+    this.queue.push(signal);
+    this.log('ingest', `Queued signal ${signal.id}: ${signal.summary}`);
+  }
+  stop() {
+    this.stopped = true;
+  }
+  async run() {
+    if (this.running) return;
+    this.running = true;
+    this.log(
+      'start',
+      `Architect loop started for project ${this.config.projectId}`,
+    );
+    while (!this.stopped) {
+      const signal = this.queue.shift();
+      if (!signal) {
+        await this.sleep(1000);
+        continue;
+      }
+      this.log(
+        'processing',
+        `Processing signal ${signal.id}: ${signal.summary}`,
+      );
+      try {
+        const summary = `Processed signal: ${signal.summary}`;
+        this.onSignalComplete?.(signal, summary);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.log('error', `Failed to process signal ${signal.id}: ${message}`);
+      }
+    }
+    this.running = false;
+    this.log('stop', 'Architect loop stopped');
+  }
+  log(phase, detail) {
+    this.logger.log(`[${phase}] ${detail}`);
+    this.onLog?.(phase, detail);
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+//# sourceMappingURL=architect-loop.service.js.map

package/libs/agentcraft/src/services/architect-loop.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"architect-loop.service.js","sourceRoot":"","sources":["architect-loop.service.ts"],"names":[],"mappings":"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"}

package/libs/agentcraft/src/services/architect-loop.service.ts

@@ -0,0 +1,407 @@
+import { Injectable, Logger } from '@nestjs/common';
+import fs from 'node:fs';
+import path from 'node:path';
+import { Signal } from '../types/signal.types';
+import { loadAllKBDocuments } from '../utils/kb-loader';
+import { designSpecToDescription } from './design-generator.service';
+import { DecomposerService } from './decomposer.service';
+import { RequirementsGeneratorService } from './requirements-generator.service';
+import { DesignGeneratorService } from './design-generator.service';
+import { UIBlueprintGeneratorService } from './ui-blueprint-generator.service';
+import { ReadmeGeneratorService } from './readme-generator.service';
+import { AutonomousRunnerService } from './autonomous-runner.service';
+import { KbWatcherService } from './kb-watcher.service';
+import type {
+  DecompositionResult,
+  RequirementsResult,
+  DesignResult,
+  UIBlueprint,
+  GeneratedSources,
+} from '../types/architect.types';
+import { normalizeGeneratedCode } from '../utils/validator';
+
+export interface ArchitectLoopConfig {
+  projectId: string;
+  userId: string;
+  registryPath: string;
+  outputDir: string;
+  debounceMs?: number;
+  phaseRetries?: number;
+  subAppRetries?: number;
+}
+
+export interface ArchitectLoop {
+  ingest(signal: Signal): void;
+  run(): Promise<void>;
+  stop(): void;
+  onLog: ((phase: string, detail: string) => void) | null;
+  onSignalComplete: ((signal: Signal, summary: string) => void) | null;
+}
+
+@Injectable()
+export class ArchitectLoopFactory {
+  private readonly logger = new Logger(ArchitectLoopFactory.name);
+
+  constructor(
+    private readonly decomposer: DecomposerService,
+    private readonly requirementsGen: RequirementsGeneratorService,
+    private readonly designGen: DesignGeneratorService,
+    private readonly blueprintGen: UIBlueprintGeneratorService,
+    private readonly readmeGen: ReadmeGeneratorService,
+    private readonly autonomousRunner: AutonomousRunnerService,
+    private readonly kbWatcher: KbWatcherService,
+  ) {}
+
+  create(config: ArchitectLoopConfig): ArchitectLoop {
+    return new DefaultArchitectLoop(
+      config,
+      this.logger,
+      this.decomposer,
+      this.requirementsGen,
+      this.designGen,
+      this.blueprintGen,
+      this.readmeGen,
+      this.autonomousRunner,
+    );
+  }
+}
+
+class DefaultArchitectLoop implements ArchitectLoop {
+  private queue: Signal[] = [];
+  private running = false;
+  private stopped = false;
+
+  onLog: ((phase: string, detail: string) => void) | null = null;
+  onSignalComplete: ((signal: Signal, summary: string) => void) | null = null;
+
+  private readonly phaseRetries: number;
+  private readonly subAppRetries: number;
+
+  constructor(
+    private readonly config: ArchitectLoopConfig,
+    private readonly logger: Logger,
+    private readonly decomposer: DecomposerService,
+    private readonly requirementsGen: RequirementsGeneratorService,
+    private readonly designGen: DesignGeneratorService,
+    private readonly blueprintGen: UIBlueprintGeneratorService,
+    private readonly readmeGen: ReadmeGeneratorService,
+    private readonly autonomousRunner: AutonomousRunnerService,
+  ) {
+    this.phaseRetries = config.phaseRetries ?? 2;
+    this.subAppRetries = config.subAppRetries ?? 2;
+  }
+
+  ingest(signal: Signal): void {
+    this.queue.push(signal);
+    this.log('ingest', `Queued signal ${signal.id}: ${signal.summary}`);
+  }
+
+  stop(): void {
+    this.stopped = true;
+  }
+
+  async run(): Promise<void> {
+    if (this.running) return;
+    this.running = true;
+    this.log(
+      'start',
+      `Architect loop started for project ${this.config.projectId}`,
+    );
+
+    while (!this.stopped) {
+      const signal = this.queue.shift();
+      if (!signal) {
+        await this.sleep(1000);
+        continue;
+      }
+
+      this.log(
+        'processing',
+        `Processing signal ${signal.id}: ${signal.summary}`,
+      );
+
+      try {
+        const summary = await this.processSignal(signal);
+        this.onSignalComplete?.(signal, summary);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.log('error', `Failed to process signal ${signal.id}: ${message}`);
+        this.onSignalComplete?.(signal, `Error: ${message}`);
+      }
+    }
+
+    this.running = false;
+    this.log('stop', 'Architect loop stopped');
+  }
+
+  private async processSignal(signal: Signal): Promise<string> {
+    const kbPath = path.join(
+      this.config.registryPath,
+      this.config.projectId,
+      '.kb',
+    );
+    const outputDir = path.join(this.config.outputDir, this.config.projectId);
+
+    // 1. Load KB
+    this.log('phase:kb', 'Loading knowledge base...');
+    let kbContent: string;
+    try {
+      kbContent = loadAllKBDocuments(kbPath);
+    } catch (err) {
+      throw new Error(
+        `KB load failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+    this.log('phase:kb', `KB loaded (${kbContent.length} chars)`);
+
+    // 2. Decompose
+    this.log('phase:decompose', 'Decomposing application...');
+    const decomposition = await this.withRetry('decompose', () =>
+      this.decomposer.decomposeApp(kbContent, this.config.projectId),
+    );
+    this.log(
+      'phase:decompose',
+      `Decomposed into ${decomposition.subApps.length} sub-apps: ${decomposition.subApps.map((s) => s.name).join(', ')}`,
+    );
+
+    // 3. Requirements
+    this.log('phase:requirements', 'Generating requirements...');
+    const requirements = await this.withRetry('requirements', () =>
+      this.requirementsGen.generateRequirements(kbContent, decomposition),
+    );
+    this.log(
+      'phase:requirements',
+      `Requirements generated for ${requirements.subApps.length + 1} apps`,
+    );
+
+    // 4. Design
+    this.log('phase:design', 'Generating design...');
+    const design = await this.withRetry('design', () =>
+      this.designGen.generateDesign(
+        kbContent,
+        this.config.projectId,
+        decomposition,
+        requirements,
+      ),
+    );
+    this.log(
+      'phase:design',
+      `Design: ${design.baseline.entities.length} baseline entities, ${design.subApps.length} sub-apps`,
+    );
+
+    // Write design.json
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(outputDir, 'design.json'),
+      JSON.stringify(design, null, 2) + '\n',
+    );
+
+    // 5. UI Blueprint
+    this.log('phase:blueprint', 'Generating UI blueprint...');
+    let blueprint: UIBlueprint | null = null;
+    try {
+      blueprint = await this.withRetry('blueprint', () =>
+        this.blueprintGen.generateUIBlueprint(design, requirements),
+      );
+      fs.writeFileSync(
+        path.join(outputDir, 'ui-blueprint.json'),
+        JSON.stringify(blueprint, null, 2) + '\n',
+      );
+      this.log(
+        'phase:blueprint',
+        `Blueprint: ${blueprint.pages.length} pages, ${blueprint.navigation.length} nav groups`,
+      );
+    } catch (err) {
+      this.log(
+        'phase:blueprint',
+        `Blueprint generation failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+
+    // 6. Baseline generation
+    this.log('phase:baseline', 'Generating baseline data model...');
+    const baselineDesc = designSpecToDescription(design.baseline);
+    const baselineOutputDir = path.join(outputDir, design.baseline.dirName);
+
+    await this.autonomousRunner.run(
+      {
+        userMessage: baselineDesc,
+        userId: this.config.userId,
+        projectName: design.baseline.dirName,
+        kbPath,
+        outputDir: baselineOutputDir,
+        mode: 'data-model-only',
+      },
+      (s, b) => this.log('phase:baseline', `${s}: ${b}`),
+    );
+
+    // Read baseline code for sub-apps
+    let baselineCode = '';
+    const baselineCoreAlPath = path.join(baselineOutputDir, 'src', 'core.al');
+    try {
+      baselineCode = fs.readFileSync(baselineCoreAlPath, 'utf-8');
+    } catch {
+      this.log(
+        'phase:baseline',
+        'Could not read baseline core.al — sub-apps will not have baseline context.',
+      );
+    }
+
+    // 7. Sub-app generation
+    this.log(
+      'phase:subapps',
+      `Generating ${design.subApps.length} sub-apps...`,
+    );
+    const sources: GeneratedSources = {
+      baseline: baselineCode
+        ? { dirName: design.baseline.dirName, code: baselineCode }
+        : undefined,
+      subApps: [],
+    };
+
+    const failedApps: string[] = [];
+
+    for (const subApp of design.subApps) {
+      this.log('phase:subapps', `Generating sub-app: ${subApp.appName}`);
+      const subAppDesc = designSpecToDescription(subApp, design.baseline);
+      const subAppOutputDir = path.join(outputDir, subApp.dirName);
+
+      let success = false;
+      for (let attempt = 1; attempt <= this.subAppRetries; attempt++) {
+        try {
+          await this.autonomousRunner.run(
+            {
+              userMessage: subAppDesc,
+              userId: this.config.userId,
+              projectName: subApp.dirName,
+              kbPath,
+              outputDir: subAppOutputDir,
+              mode: 'full',
+              baselineDataModel: baselineCode || undefined,
+            },
+            (s, b) =>
+              this.log('phase:subapps', `[${subApp.appName}] ${s}: ${b}`),
+          );
+
+          // Patch package.json to add baseline dependency
+          if (baselineCode) {
+            this.patchBaselineDependency(
+              subAppOutputDir,
+              design.baseline.dirName,
+            );
+          }
+
+          // Read generated code for README
+          const coreAlPath = path.join(subAppOutputDir, 'src', 'core.al');
+          try {
+            const code = fs.readFileSync(coreAlPath, 'utf-8');
+            sources.subApps.push({
+              dirName: subApp.dirName,
+              code,
+            });
+          } catch (err) {
+            this.log(
+              'phase:subapps',
+              `Could not read generated core.al for ${subApp.appName}: ${err instanceof Error ? err.message : err}`,
+            );
+          }
+
+          success = true;
+          break;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          this.log(
+            'phase:subapps',
+            `Sub-app "${subApp.appName}" attempt ${attempt}/${this.subAppRetries} failed: ${msg}`,
+          );
+          if (attempt >= this.subAppRetries) {
+            failedApps.push(subApp.appName);
+          }
+        }
+      }
+
+      if (!success) {
+        this.log(
+          'phase:subapps',
+          `Sub-app "${subApp.appName}" failed after ${this.subAppRetries} attempts.`,
+        );
+      }
+    }
+
+    // 8. README
+    this.log('phase:readme', 'Generating README...');
+    try {
+      const readme = await this.readmeGen.generateReadme(
+        this.config.projectId,
+        decomposition,
+        design,
+        requirements,
+        sources,
+      );
+      fs.writeFileSync(path.join(outputDir, 'README.md'), readme + '\n');
+      this.log('phase:readme', 'README written');
+    } catch (err) {
+      this.log(
+        'phase:readme',
+        `README generation failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+
+    const successCount = design.subApps.length - failedApps.length;
+    const summary =
+      failedApps.length > 0
+        ? `Completed with ${successCount}/${design.subApps.length} sub-apps. Failed: ${failedApps.join(', ')}`
+        : `All ${design.subApps.length} sub-apps generated successfully.`;
+
+    this.log('complete', summary);
+    return summary;
+  }
+
+  private patchBaselineDependency(
+    appDir: string,
+    baselineDirName: string,
+  ): void {
+    const pkgPath = path.join(appDir, 'package.json');
+    try {
+      const pkgStr = fs.readFileSync(pkgPath, 'utf-8');
+      const pkg = JSON.parse(pkgStr);
+      if (!pkg.dependencies) pkg.dependencies = {};
+      if (!pkg.dependencies[baselineDirName]) {
+        pkg.dependencies[baselineDirName] = '*';
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+      }
+    } catch (err) {
+      this.log(
+        'phase:subapps',
+        `Failed to patch baseline dependency in ${appDir}: ${err instanceof Error ? err.message : err}`,
+      );
+    }
+  }
+
+  private async withRetry<T>(phase: string, fn: () => Promise<T>): Promise<T> {
+    let lastError: Error | undefined;
+    for (let i = 0; i <= this.phaseRetries; i++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (i < this.phaseRetries) {
+          this.log(
+            `phase:${phase}`,
+            `Attempt ${i + 1} failed, retrying... (${lastError.message})`,
+          );
+        }
+      }
+    }
+    throw lastError;
+  }
+
+  private log(phase: string, detail: string): void {
+    this.logger.log(`[${phase}] ${detail}`);
+    this.onLog?.(phase, detail);
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

package/libs/agentcraft/src/services/autonomous-runner.service.ts

@@ -0,0 +1,178 @@
+import { Injectable, Logger } from '@nestjs/common';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  AutonomousRunConfig,
+  ExecutionContext,
+  Plan,
+  PlanStep,
+  StepResult,
+  ExecutorCallbacks,
+} from '../types/autonomous.types';
+import { loadAllKBDocuments } from '../utils/kb-loader';
+import { normalizeGeneratedCode } from '../utils/validator';
+import { PlannerService } from './planner.service';
+import { ExecutorService } from './executor.service';
+
+@Injectable()
+export class AutonomousRunnerService {
+  private readonly logger = new Logger(AutonomousRunnerService.name);
+
+  constructor(
+    private readonly planner: PlannerService,
+    private readonly executor: ExecutorService,
+  ) {}
+
+  async run(
+    config: AutonomousRunConfig,
+    notify?: (subject: string, body: string) => void,
+  ): Promise<{ outputDir: string }> {
+    const mode = config.mode ?? 'full';
+    const kbContent = loadAllKBDocuments(config.kbPath);
+    const outputDir = config.outputDir
+      ? path.resolve(config.outputDir)
+      : path.resolve('.', config.projectName);
+
+    const log =
+      notify ?? ((s: string, b: string) => this.logger.log(`${s}: ${b}`));
+    const callbacks = this.buildCallbacks(log);
+
+    if (mode === 'data-model-only') {
+      return this.runDataModelOnly(
+        config,
+        kbContent,
+        outputDir,
+        log,
+        callbacks,
+      );
+    }
+
+    log(
+      'Planning',
+      `Analyzing knowledge base and planning application "${config.projectName}"...`,
+    );
+
+    const plan = await this.planner.generatePlan(
+      kbContent,
+      config.userMessage,
+      config.projectName,
+    );
+
+    const stepSummary = plan.steps
+      .map((s) => `${s.id}: ${s.title} (${s.kind})`)
+      .join('\n  ');
+    log('Plan ready', `${plan.steps.length} steps:\n  ${stepSummary}`);
+
+    const ctx: ExecutionContext = {
+      plan,
+      kbContent,
+      completedSteps: new Map(),
+      baselineDataModel: config.baselineDataModel,
+    };
+
+    try {
+      await this.executor.executePlan(ctx, outputDir, callbacks);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log('Error', `Pipeline failed: ${msg}`);
+      this.executor.writeBestEffortOutput(ctx, outputDir, callbacks);
+      throw err;
+    }
+
+    log('Complete', `Application generated at ${outputDir}`);
+    return { outputDir };
+  }
+
+  async runDataModelOnly(
+    config: AutonomousRunConfig,
+    kbContent: string,
+    outputDir: string,
+    notify: (subject: string, body: string) => void,
+    callbacks: ExecutorCallbacks,
+  ): Promise<{ outputDir: string }> {
+    notify(
+      'Generating',
+      `Generating baseline data model for "${config.projectName}"...`,
+    );
+
+    const syntheticPlan: Plan = {
+      projectName: config.projectName,
+      summary: 'Baseline data model generation',
+      steps: [
+        {
+          id: 'step-1',
+          kind: 'data-model',
+          title: 'Generate baseline data model',
+          description: config.userMessage,
+          dependsOn: [],
+        },
+      ],
+    };
+
+    const ctx: ExecutionContext = {
+      plan: syntheticPlan,
+      kbContent,
+      completedSteps: new Map(),
+    };
+
+    try {
+      await this.executor.executePlan(ctx, outputDir, callbacks);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      notify('Error', `Baseline data model generation failed: ${msg}`);
+      throw err;
+    }
+
+    const dataModelResult = ctx.completedSteps.get('step-1');
+    if (dataModelResult?.code.trim()) {
+      const srcDir = path.join(outputDir, 'src');
+      fs.mkdirSync(srcDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(srcDir, 'core.al'),
+        normalizeGeneratedCode(dataModelResult.code) + '\n',
+      );
+      notify('Complete', `Baseline data model written to ${outputDir}`);
+    } else {
+      notify('Warning', 'No data model code was generated.');
+    }
+
+    return { outputDir };
+  }
+
+  private buildCallbacks(
+    notify: (subject: string, body: string) => void,
+  ): ExecutorCallbacks {
+    const logger = this.logger;
+    return {
+      onStepStart(step: PlanStep, index: number, total: number) {
+        notify(
+          `Step ${index}/${total}`,
+          `Starting: ${step.title} (${step.kind})`,
+        );
+      },
+      onStepComplete(step: PlanStep, result: StepResult) {
+        const status = result.validated ? 'validated' : 'best-effort';
+        notify(
+          'Step complete',
+          `${step.title} — ${status} (${result.attempts} attempt(s))`,
+        );
+      },
+      onValidationError(
+        step: PlanStep,
+        errors: string,
+        _code: string,
+        attempt: number,
+      ) {
+        logger.warn(
+          `Validation error in "${step.title}" (attempt ${attempt}): ${errors.slice(0, 500)}`,
+        );
+      },
+      onInfo(message: string) {
+        logger.log(message);
+      },
+      onWarning(message: string) {
+        logger.warn(message);
+      },
+    };
+  }
+}

package/libs/agentcraft/src/services/craft-config.service.d.ts

@@ -0,0 +1,11 @@
+import { ConfigService } from '@nestjs/config';
+import { CraftConfig } from '../types/pipeline.types';
+export declare class CraftConfigService {
+  private readonly configService?;
+  constructor(configService?: ConfigService | undefined);
+  resolve(flags?: Partial<CraftConfig>): Promise<CraftConfig>;
+  saveGlobal(updates: Partial<CraftConfig>): Promise<void>;
+  getDefaultModel(provider: CraftConfig['provider']): string;
+  private loadConfigFile;
+  private loadEnvConfig;
+}