@agentlang/agentmanager 0.0.3

package/apps/agentcraft/src/architect/architect.service.ts

@@ -0,0 +1,193 @@
+import { Injectable, Inject, Optional, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { EventEmitter } from 'node:events';
+import { resolve, join } from 'node:path';
+import { access, mkdir } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import {
+  REGISTRY_PROVIDER,
+  EMPLOYEE_CODE_PROVIDER,
+  INBOX_CLIENT,
+  RegistryProvider,
+  EmployeeCodeProvider,
+  InboxClient,
+} from '@app/project-provider';
+import {
+  LLM_PROVIDER,
+  LlmProvider,
+  ArchitectLoopFactory,
+  Signal,
+  SignalKind,
+  SignalPriority,
+} from '@app/agentcraft';
+import type {
+  SSEEvent,
+  SignalHistoryEntry,
+  ArchitectStatus,
+} from './interfaces/architect.interfaces';
+import { ArchitectStore, type ProjectArchitect } from './architect.store';
+
+export type { SSEEvent, SignalHistoryEntry, ArchitectStatus };
+
+@Injectable()
+export class ArchitectService {
+  private readonly logger = new Logger(ArchitectService.name);
+  private readonly registryPath: string;
+
+  constructor(
+    @Inject(REGISTRY_PROVIDER) private readonly registry: RegistryProvider,
+    @Inject(EMPLOYEE_CODE_PROVIDER) private readonly code: EmployeeCodeProvider,
+    @Inject(INBOX_CLIENT) private readonly inboxClient: InboxClient,
+    @Inject(LLM_PROVIDER)
+    @Optional()
+    private readonly llmProvider: LlmProvider | null,
+    private readonly loopFactory: ArchitectLoopFactory,
+    private readonly config: ConfigService,
+    private readonly store: ArchitectStore,
+  ) {
+    this.registryPath = resolve(
+      this.config.get<string>('registryPath', './registry'),
+    );
+  }
+
+  get isEnabled(): boolean {
+    return this.llmProvider !== null;
+  }
+
+  async ensureRunning(projectId: string): Promise<ProjectArchitect> {
+    const existing = this.store.get(projectId);
+    if (existing) return existing;
+
+    const kbPath = join(this.registryPath, projectId, '.kb');
+    try {
+      await access(kbPath);
+    } catch {
+      await mkdir(kbPath, { recursive: true });
+    }
+
+    const outputDir = resolve(this.config.get<string>('outputDir', '.'));
+
+    const loop = this.loopFactory.create({
+      projectId,
+      userId: this.config.get<string>('architectUserId', 'default'),
+      registryPath: this.registryPath,
+      outputDir,
+      debounceMs: this.config.get<number>('architect.debounceMs', 5000),
+      phaseRetries: this.config.get<number>('architect.phaseRetries', 2),
+      subAppRetries: this.config.get<number>('architect.subAppRetries', 2),
+    });
+
+    const entry: ProjectArchitect = {
+      loop,
+      eventEmitter: new EventEmitter(),
+      eventBuffer: [],
+      history: [],
+      currentSignal: null,
+      signalsProcessed: 0,
+      upSince: new Date().toISOString(),
+    };
+
+    loop.onLog = (phase, detail) => {
+      this.store.emit(entry, 'log', { phase, detail });
+    };
+
+    loop.onSignalComplete = (signal, summary) => {
+      entry.currentSignal = null;
+      entry.signalsProcessed++;
+      entry.history.push({
+        signalId: signal.id,
+        summary: signal.summary,
+        result: summary,
+        completedAt: new Date().toISOString(),
+      });
+      this.store.emit(entry, 'signal-complete', {
+        signalId: signal.id,
+        summary: signal.summary,
+        result: summary,
+      });
+    };
+
+    this.store.set(projectId, entry);
+
+    loop.run().catch((err) => {
+      this.store.emit(entry, 'error', {
+        message: err instanceof Error ? err.message : String(err),
+      });
+    });
+
+    return entry;
+  }
+
+  async ingest(
+    projectId: string,
+    params: {
+      kind?: string;
+      summary: string;
+      priority?: string;
+      data?: Record<string, unknown>;
+      userId?: string;
+    },
+  ): Promise<Signal> {
+    const entry = await this.ensureRunning(projectId);
+
+    const signal: Signal = {
+      id: randomUUID(),
+      kind: (params.kind as SignalKind) ?? 'requirements-change',
+      source: 'api',
+      summary: params.summary,
+      data: params.data ?? {},
+      timestamp: new Date().toISOString(),
+      priority: (params.priority as SignalPriority) ?? 'medium',
+    };
+
+    entry.loop.ingest(signal);
+    entry.currentSignal = signal;
+
+    this.store.emit(entry, 'signal-queued', {
+      signalId: signal.id,
+      summary: signal.summary,
+      priority: signal.priority,
+    });
+
+    return signal;
+  }
+
+  getStatus(projectId: string): ArchitectStatus {
+    const entry = this.store.get(projectId);
+    if (!entry) {
+      return {
+        status: 'idle',
+        currentSignal: null,
+        queueDepth: 0,
+        signalsProcessed: 0,
+        upSince: new Date().toISOString(),
+      };
+    }
+
+    return {
+      status: entry.currentSignal ? 'processing' : 'idle',
+      currentSignal: entry.currentSignal
+        ? { id: entry.currentSignal.id, summary: entry.currentSignal.summary }
+        : null,
+      queueDepth: 0,
+      signalsProcessed: entry.signalsProcessed,
+      upSince: entry.upSince,
+    };
+  }
+
+  getHistory(projectId: string): SignalHistoryEntry[] {
+    const entry = this.store.get(projectId);
+    return entry?.history ?? [];
+  }
+
+  async getStream(projectId: string): Promise<{
+    buffer: SSEEvent[];
+    emitter: EventEmitter;
+  }> {
+    const entry = await this.ensureRunning(projectId);
+    return {
+      buffer: entry.eventBuffer,
+      emitter: entry.eventEmitter,
+    };
+  }
+}

package/apps/agentcraft/src/architect/architect.store.ts

@@ -0,0 +1,63 @@
+import { Injectable, OnModuleDestroy, Logger } from '@nestjs/common';
+import { EventEmitter } from 'node:events';
+import type { ArchitectLoop } from '@app/agentcraft';
+import type {
+  SSEEvent,
+  SignalHistoryEntry,
+} from './interfaces/architect.interfaces';
+
+export interface ProjectArchitect {
+  loop: ArchitectLoop;
+  eventEmitter: EventEmitter;
+  eventBuffer: SSEEvent[];
+  history: SignalHistoryEntry[];
+  currentSignal: { id: string; summary: string } | null;
+  signalsProcessed: number;
+  upSince: string;
+}
+
+const MAX_EVENT_BUFFER = 200;
+
+@Injectable()
+export class ArchitectStore implements OnModuleDestroy {
+  private readonly logger = new Logger(ArchitectStore.name);
+  private readonly architects = new Map<string, ProjectArchitect>();
+
+  has(projectId: string): boolean {
+    return this.architects.has(projectId);
+  }
+
+  get(projectId: string): ProjectArchitect | undefined {
+    return this.architects.get(projectId);
+  }
+
+  set(projectId: string, entry: ProjectArchitect): void {
+    this.architects.set(projectId, entry);
+  }
+
+  emit(
+    entry: ProjectArchitect,
+    type: string,
+    data: Record<string, unknown>,
+  ): void {
+    const event: SSEEvent = {
+      type,
+      data,
+      timestamp: new Date().toISOString(),
+    };
+    entry.eventBuffer.push(event);
+    if (entry.eventBuffer.length > MAX_EVENT_BUFFER) {
+      entry.eventBuffer.shift();
+    }
+    entry.eventEmitter.emit('event', event);
+  }
+
+  onModuleDestroy() {
+    this.logger.log(`Cleaning up ${this.architects.size} architect(s)`);
+    for (const [, entry] of this.architects) {
+      entry.loop.stop();
+      entry.eventEmitter.removeAllListeners();
+    }
+    this.architects.clear();
+  }
+}

package/apps/agentcraft/src/architect/dto/ingest-signal.dto.ts

@@ -0,0 +1,20 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const IngestSignalSchema = z.object({
+  summary: z.string().min(1).max(10_000),
+  kind: z
+    .enum([
+      'requirements-change',
+      'incident',
+      'feedback',
+      'scheduled',
+      'manual',
+    ])
+    .optional(),
+  priority: z.enum(['low', 'medium', 'high', 'critical']).optional(),
+  data: z.object({}).catchall(z.unknown()).optional(),
+  userId: z.string().optional(),
+});
+
+export class IngestSignalDto extends createZodDto(IngestSignalSchema) {}

package/apps/agentcraft/src/architect/interfaces/architect.interfaces.ts

@@ -0,0 +1,20 @@
+export interface SSEEvent {
+  type: string;
+  data: Record<string, unknown>;
+  timestamp: string;
+}
+
+export interface SignalHistoryEntry {
+  signalId: string;
+  summary: string;
+  result: string;
+  completedAt: string;
+}
+
+export interface ArchitectStatus {
+  status: 'idle' | 'processing';
+  currentSignal: { id: string; summary: string } | null;
+  queueDepth: number;
+  signalsProcessed: number;
+  upSince: string;
+}

package/apps/agentcraft/src/autonomous/autonomous.controller.ts

@@ -0,0 +1,92 @@
+import {
+  Controller,
+  Post,
+  Get,
+  Delete,
+  Param,
+  Body,
+  HttpCode,
+  HttpStatus,
+  Logger,
+  NotFoundException,
+} from '@nestjs/common';
+import { randomUUID } from 'node:crypto';
+import { RunAutonomousDto } from './dto/run-autonomous.dto';
+import { WatchKbDto } from './dto/watch-kb.dto';
+import { AutonomousService } from './autonomous.service';
+
+@Controller('autonomous')
+export class AutonomousController {
+  private readonly logger = new Logger(AutonomousController.name);
+
+  constructor(private readonly autonomousService: AutonomousService) {}
+
+  @Post()
+  @HttpCode(HttpStatus.ACCEPTED)
+  run(@Body() dto: RunAutonomousDto) {
+    const runId = randomUUID();
+
+    this.logger.log(
+      `Autonomous run ${runId} started for project "${dto.projectName}" by user "${dto.userId}"`,
+    );
+
+    this.autonomousService.startRun(runId, {
+      message: dto.message,
+      userId: dto.userId,
+      projectName: dto.projectName,
+      kbPath: dto.kbPath,
+      outputDir: dto.outputDir,
+    });
+
+    return {
+      runId,
+      projectName: dto.projectName,
+      status: 'started',
+    };
+  }
+
+  @Get(':runId/status')
+  getStatus(@Param('runId') runId: string) {
+    const status = this.autonomousService.getStatus(runId);
+    if (!status) {
+      throw new NotFoundException(`Run ${runId} not found`);
+    }
+    return status;
+  }
+
+  @Post('watch')
+  @HttpCode(HttpStatus.ACCEPTED)
+  startWatch(@Body() dto: WatchKbDto) {
+    this.logger.log(
+      `Starting KB watch on "${dto.kbPath}" for user "${dto.userId}"`,
+    );
+
+    const status = this.autonomousService.startWatch({
+      kbPath: dto.kbPath,
+      userId: dto.userId,
+      message: dto.message,
+      pollIntervalMs: dto.pollIntervalMs,
+      outputDir: dto.outputDir,
+    });
+
+    return status;
+  }
+
+  @Delete('watch')
+  stopWatch() {
+    const status = this.autonomousService.stopWatch();
+    if (!status) {
+      throw new NotFoundException('No active watch');
+    }
+    return status;
+  }
+
+  @Get('watch')
+  getWatchStatus() {
+    const status = this.autonomousService.getWatchStatus();
+    if (!status) {
+      throw new NotFoundException('No active watch');
+    }
+    return status;
+  }
+}

package/apps/agentcraft/src/autonomous/autonomous.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { AutonomousController } from './autonomous.controller';
+import { AutonomousService } from './autonomous.service';
+
+@Module({
+  controllers: [AutonomousController],
+  providers: [AutonomousService],
+})
+export class AutonomousModule {}

package/apps/agentcraft/src/autonomous/autonomous.service.ts

@@ -0,0 +1,160 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { AutonomousRunnerService, KbWatcherService } from '@app/agentcraft';
+
+export interface RunStatus {
+  runId: string;
+  projectName: string;
+  status: 'running' | 'completed' | 'failed';
+  outputDir?: string;
+  error?: string;
+  startedAt: string;
+  completedAt?: string;
+}
+
+export interface WatchStatus {
+  active: boolean;
+  kbPath: string;
+  userId: string;
+  message: string;
+  pollIntervalMs: number;
+  outputDir: string;
+  triggeredRuns: string[];
+  startedAt: string;
+}
+
+@Injectable()
+export class AutonomousService {
+  private readonly logger = new Logger(AutonomousService.name);
+  private readonly runs = new Map<string, RunStatus>();
+  private readonly defaultOutputDir: string;
+  private watchStatus: WatchStatus | null = null;
+
+  constructor(
+    private readonly runner: AutonomousRunnerService,
+    private readonly kbWatcher: KbWatcherService,
+    private readonly config: ConfigService,
+  ) {
+    this.defaultOutputDir = resolve(this.config.get<string>('outputDir', '.'));
+  }
+
+  startRun(
+    runId: string,
+    params: {
+      message: string;
+      userId: string;
+      projectName: string;
+      kbPath: string;
+      outputDir?: string;
+    },
+  ): void {
+    const status: RunStatus = {
+      runId,
+      projectName: params.projectName,
+      status: 'running',
+      startedAt: new Date().toISOString(),
+    };
+
+    this.runs.set(runId, status);
+
+    const outputDir = params.outputDir
+      ? resolve(params.outputDir)
+      : resolve(this.defaultOutputDir, params.projectName);
+
+    this.runner
+      .run(
+        {
+          userMessage: params.message,
+          userId: params.userId,
+          projectName: params.projectName,
+          kbPath: resolve(params.kbPath),
+          outputDir,
+          mode: 'full',
+        },
+        (subject, body) => this.logger.log(`[${runId}] ${subject}: ${body}`),
+      )
+      .then((result) => {
+        status.status = 'completed';
+        status.outputDir = result.outputDir;
+        status.completedAt = new Date().toISOString();
+        this.logger.log(`Run ${runId} completed: ${result.outputDir}`);
+      })
+      .catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        status.status = 'failed';
+        status.error = message;
+        status.completedAt = new Date().toISOString();
+        this.logger.error(`Run ${runId} failed: ${message}`);
+      });
+  }
+
+  getStatus(runId: string): RunStatus | undefined {
+    return this.runs.get(runId);
+  }
+
+  startWatch(params: {
+    kbPath: string;
+    userId: string;
+    message: string;
+    pollIntervalMs?: number;
+    outputDir?: string;
+  }): WatchStatus {
+    if (this.watchStatus?.active) {
+      this.kbWatcher.stopWatching();
+    }
+
+    const kbPath = resolve(params.kbPath);
+    const outputDir = params.outputDir
+      ? resolve(params.outputDir)
+      : this.defaultOutputDir;
+    const pollIntervalMs = params.pollIntervalMs ?? 3000;
+
+    this.watchStatus = {
+      active: true,
+      kbPath,
+      userId: params.userId,
+      message: params.message,
+      pollIntervalMs,
+      outputDir,
+      triggeredRuns: [],
+      startedAt: new Date().toISOString(),
+    };
+
+    this.kbWatcher.startWatching(
+      kbPath,
+      (event) => {
+        const runId = randomUUID();
+        this.logger.log(
+          `KB change detected in "${event.projectName}" — starting autonomous run ${runId}`,
+        );
+
+        this.watchStatus?.triggeredRuns.push(runId);
+
+        this.startRun(runId, {
+          message: params.message,
+          userId: params.userId,
+          projectName: event.projectName,
+          kbPath: event.kbPath,
+          outputDir: resolve(outputDir, event.projectName),
+        });
+      },
+      { pollIntervalMs },
+    );
+
+    return this.watchStatus;
+  }
+
+  stopWatch(): WatchStatus | null {
+    if (!this.watchStatus?.active) return this.watchStatus;
+
+    this.kbWatcher.stopWatching();
+    this.watchStatus.active = false;
+    return this.watchStatus;
+  }
+
+  getWatchStatus(): WatchStatus | null {
+    return this.watchStatus;
+  }
+}

package/apps/agentcraft/src/autonomous/dto/run-autonomous.dto.ts

@@ -0,0 +1,16 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const RunAutonomousSchema = z.object({
+  message: z.string().min(1).max(10_000),
+  userId: z.string().min(1).max(200),
+  projectName: z.string().min(1).max(200),
+  kbPath: z.string().min(1),
+  inboxUrl: z.string().url().optional(),
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  apiKey: z.string().optional(),
+  outputDir: z.string().optional(),
+});
+
+export class RunAutonomousDto extends createZodDto(RunAutonomousSchema) {}

package/apps/agentcraft/src/autonomous/dto/watch-kb.dto.ts

@@ -0,0 +1,16 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const WatchKbSchema = z.object({
+  kbPath: z.string().min(1),
+  userId: z.string().min(1).max(200),
+  message: z
+    .string()
+    .min(1)
+    .max(10_000)
+    .default('Generate an Agentlang app from the knowledge base'),
+  pollIntervalMs: z.number().int().min(500).max(60_000).optional(),
+  outputDir: z.string().optional(),
+});
+
+export class WatchKbDto extends createZodDto(WatchKbSchema) {}

package/apps/agentcraft/src/config/configuration.ts

@@ -0,0 +1,74 @@
+import { Logger } from '@nestjs/common';
+import { z } from 'zod';
+
+const configSchema = z.object({
+  port: z.number().int().positive(),
+  outputDir: z.string().min(1),
+  registryPath: z.string().min(1),
+  inboxesPath: z.string().min(1),
+  llm: z
+    .object({
+      provider: z.string(),
+      model: z.string(),
+      apiKey: z.string(),
+    })
+    .nullable(),
+  architect: z.object({
+    debounceMs: z.number().int().nonnegative(),
+    phaseRetries: z.number().int().nonnegative(),
+    subAppRetries: z.number().int().nonnegative(),
+  }),
+  cors: z.object({ origins: z.array(z.string()) }),
+});
+
+export type AppConfiguration = z.infer<typeof configSchema>;
+
+export default (): AppConfiguration => {
+  const logger = new Logger('AgentcraftConfig');
+
+  const raw = {
+    port: parseInt(process.env.CRAFT_PORT || '3002', 10),
+    outputDir: process.env.CRAFT_OUTPUT_DIR || '.',
+    registryPath: process.env.REGISTRY_PATH || './registry',
+    inboxesPath: process.env.INBOXES_PATH || './inboxes',
+    llm: buildLlmConfig(),
+    architect: {
+      debounceMs: parseInt(process.env.ARCHITECT_DEBOUNCE_MS || '5000', 10),
+      phaseRetries: parseInt(process.env.ARCHITECT_PHASE_RETRIES || '2', 10),
+      subAppRetries: parseInt(process.env.ARCHITECT_SUBAPP_RETRIES || '2', 10),
+    },
+    cors: {
+      origins: process.env.CORS_ORIGINS
+        ? process.env.CORS_ORIGINS.split(',').map((o: string) => o.trim())
+        : ['http://localhost:3000', 'http://127.0.0.1:3000'],
+    },
+  };
+
+  const result = configSchema.safeParse(raw);
+  if (!result.success) {
+    logger.error(`Invalid configuration: ${result.error.message}`);
+    throw new Error(
+      `Invalid Agentcraft configuration: ${result.error.message}`,
+    );
+  }
+
+  return result.data;
+};
+
+function buildLlmConfig() {
+  const provider = process.env.CRAFT_PROVIDER || 'anthropic';
+  const apiKey =
+    process.env.CRAFT_API_KEY ||
+    process.env.ANTHROPIC_API_KEY ||
+    process.env.OPENAI_API_KEY;
+
+  if (!apiKey) return null;
+
+  return {
+    provider,
+    model:
+      process.env.CRAFT_MODEL ||
+      (provider === 'anthropic' ? 'claude-sonnet-4-6' : 'gpt-4o'),
+    apiKey,
+  };
+}

package/apps/agentcraft/src/health/health.controller.ts

@@ -0,0 +1,22 @@
+import { Controller, Get } from '@nestjs/common';
+import {
+  HealthCheck,
+  HealthCheckService,
+  MemoryHealthIndicator,
+} from '@nestjs/terminus';
+
+@Controller('health')
+export class HealthController {
+  constructor(
+    private readonly health: HealthCheckService,
+    private readonly memory: MemoryHealthIndicator,
+  ) {}
+
+  @Get()
+  @HealthCheck()
+  check() {
+    return this.health.check([
+      () => this.memory.checkHeap('memory_heap', 256 * 1024 * 1024),
+    ]);
+  }
+}

package/apps/agentcraft/src/health/health.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { TerminusModule } from '@nestjs/terminus';
+import { HealthController } from './health.controller';
+
+@Module({
+  imports: [TerminusModule],
+  controllers: [HealthController],
+})
+export class HealthModule {}