@agentlang/agentmanager 0.0.3

package/apps/agentcraft/src/main.ts

@@ -0,0 +1,53 @@
+import { NestFactory } from '@nestjs/core';
+import {
+  FastifyAdapter,
+  NestFastifyApplication,
+} from '@nestjs/platform-fastify';
+import { Logger } from '@nestjs/common';
+import { ZodValidationPipe } from 'nestjs-zod';
+import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
+import helmet from '@fastify/helmet';
+import { AppModule } from './app.module';
+import { ConfigService } from '@nestjs/config';
+
+async function bootstrap() {
+  const app = await NestFactory.create<NestFastifyApplication>(
+    AppModule,
+    new FastifyAdapter({ bodyLimit: 1_048_576 }),
+  );
+
+  await app.register(helmet as Parameters<typeof app.register>[0], {
+    contentSecurityPolicy: false,
+  });
+
+  const config = app.get(ConfigService);
+  const port = config.get<number>('port', 3002);
+  const corsOrigins = config.get<string[]>('cors.origins', [
+    'http://localhost:3000',
+    'http://127.0.0.1:3000',
+  ]);
+
+  app.enableCors({ origin: corsOrigins, credentials: true });
+  app.setGlobalPrefix('api');
+  app.enableShutdownHooks();
+  app.useGlobalPipes(new ZodValidationPipe());
+
+  const swaggerConfig = new DocumentBuilder()
+    .setTitle('Agentcraft API')
+    .setDescription('LLM-powered code generation service')
+    .setVersion('1.0')
+    .build();
+  const document = SwaggerModule.createDocument(app, swaggerConfig);
+  SwaggerModule.setup('docs', app, document);
+
+  await app.listen(port, '0.0.0.0');
+
+  const logger = new Logger('Bootstrap');
+  logger.log(`Agentcraft listening on port ${port}`);
+}
+
+bootstrap().catch((err) => {
+  const logger = new Logger('Bootstrap');
+  logger.error(`Failed to start Agentcraft: ${err}`);
+  process.exit(1);
+});

package/apps/agentcraft/src/resolver/dto/create-resolver.dto.ts

@@ -0,0 +1,14 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const CreateResolverSchema = z.object({
+  name: z.string().min(1).max(200),
+  description: z.string().min(1).max(5000),
+  specUrl: z.string().url(),
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  apiKey: z.string().optional(),
+  outputDir: z.string().optional(),
+});
+
+export class CreateResolverDto extends createZodDto(CreateResolverSchema) {}

package/apps/agentcraft/src/resolver/dto/install-registry.dto.ts

@@ -0,0 +1,10 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const InstallRegistrySchema = z.object({
+  repo: z.string(),
+  name: z.string(),
+  outputDir: z.string().optional(),
+});
+
+export class InstallRegistryDto extends createZodDto(InstallRegistrySchema) {}

package/apps/agentcraft/src/resolver/dto/search-registry-query.dto.ts

@@ -0,0 +1,10 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const SearchRegistryQuerySchema = z.object({
+  q: z.string(),
+});
+
+export class SearchRegistryQueryDto extends createZodDto(
+  SearchRegistryQuerySchema,
+) {}

package/apps/agentcraft/src/resolver/dto/submit-action.dto.ts

@@ -0,0 +1,4 @@
+export {
+  SubmitResolverActionDto,
+  SubmitActionBaseSchema as SubmitResolverActionSchema,
+} from '@app/agentcraft';

package/apps/agentcraft/src/resolver/resolver-session.store.ts

@@ -0,0 +1,39 @@
+import { Injectable, OnModuleDestroy, Logger } from '@nestjs/common';
+import { ApiAdapterService, SessionNotFoundError } from '@app/agentcraft';
+
+export interface ResolverSession {
+  id: string;
+  adapter: ApiAdapterService;
+  outputDir: string;
+  name: string;
+  status: 'running' | 'completed' | 'error';
+  error?: string;
+}
+
+@Injectable()
+export class ResolverSessionStore implements OnModuleDestroy {
+  private readonly logger = new Logger(ResolverSessionStore.name);
+  private counter = 0;
+  private readonly sessions = new Map<string, ResolverSession>();
+
+  set(session: ResolverSession): void {
+    this.sessions.set(session.id, session);
+  }
+
+  get(id: string): ResolverSession {
+    const session = this.sessions.get(id);
+    if (!session) {
+      throw new SessionNotFoundError();
+    }
+    return session;
+  }
+
+  generateId(): string {
+    return `resolver_${++this.counter}_${Date.now()}`;
+  }
+
+  onModuleDestroy() {
+    this.logger.log(`Cleaning up ${this.sessions.size} resolver session(s)`);
+    this.sessions.clear();
+  }
+}

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

@@ -0,0 +1,86 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Param,
+  Body,
+  Query,
+  Sse,
+  HttpCode,
+  HttpStatus,
+  MessageEvent,
+} from '@nestjs/common';
+import { Observable, from, interval, merge, fromEvent } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ResolverService } from './resolver.service';
+import { CreateResolverDto } from './dto/create-resolver.dto';
+import { SubmitResolverActionDto } from './dto/submit-action.dto';
+import { SearchRegistryQueryDto } from './dto/search-registry-query.dto';
+import { InstallRegistryDto } from './dto/install-registry.dto';
+import type { SSEEvent } from '@app/agentcraft';
+
+@Controller('resolvers')
+export class ResolverController {
+  constructor(private readonly resolverService: ResolverService) {}
+
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  async create(@Body() dto: CreateResolverDto) {
+    return this.resolverService.create({
+      name: dto.name,
+      description: dto.description,
+      specUrl: dto.specUrl,
+      provider: dto.provider,
+      model: dto.model,
+      apiKey: dto.apiKey,
+      outputDir: dto.outputDir,
+    });
+  }
+
+  @Get(':id/status')
+  async getStatus(@Param('id') id: string) {
+    return this.resolverService.getStatus(id);
+  }
+
+  @Get(':id/output')
+  getOutput(@Param('id') id: string) {
+    return { output: this.resolverService.getOutput(id) };
+  }
+
+  @Post(':id/action')
+  @HttpCode(HttpStatus.OK)
+  submitAction(@Param('id') id: string, @Body() dto: SubmitResolverActionDto) {
+    this.resolverService.resolveAction(id, dto);
+    return { ok: true };
+  }
+
+  @Get('registry/search')
+  async searchRegistry(@Query() query: SearchRegistryQueryDto) {
+    const results = await this.resolverService.searchRegistry(query.q);
+    return { query: query.q, results };
+  }
+
+  @Post('registry/install')
+  @HttpCode(HttpStatus.CREATED)
+  async install(@Body() dto: InstallRegistryDto) {
+    const installedTo = await this.resolverService.installFromRegistry(
+      dto.repo,
+      dto.name,
+      dto.outputDir,
+    );
+    return { installedTo };
+  }
+
+  @Sse(':id/stream')
+  stream(@Param('id') id: string): Observable<MessageEvent> {
+    const { events, adapter } = this.resolverService.getStream(id);
+
+    return merge(
+      from(events).pipe(map((e) => ({ data: JSON.stringify(e) }))),
+      fromEvent<SSEEvent>(adapter.eventEmitter, 'sse').pipe(
+        map((e) => ({ data: JSON.stringify(e) })),
+      ),
+      interval(15_000).pipe(map(() => ({ data: '' }))),
+    );
+  }
+}

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { ResolverController } from './resolver.controller';
+import { ResolverService } from './resolver.service';
+import { ResolverSessionStore } from './resolver-session.store';
+
+@Module({
+  controllers: [ResolverController],
+  providers: [ResolverService, ResolverSessionStore],
+})
+export class ResolverModule {}

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

@@ -0,0 +1,128 @@
+import { Injectable } from '@nestjs/common';
+import {
+  ApiAdapterFactory,
+  CraftConfigService,
+  SpecFetcherService,
+  RegistryClientService,
+  ReviewAction,
+  InvalidSessionStateError,
+} from '@app/agentcraft';
+import type {
+  SSEEvent,
+  ApiAdapterService,
+  CraftConfig,
+  RegistrySearchResult,
+} from '@app/agentcraft';
+import { resolve } from 'node:path';
+import { ResolverSessionStore } from './resolver-session.store';
+
+@Injectable()
+export class ResolverService {
+  constructor(
+    private readonly craftConfig: CraftConfigService,
+    private readonly specFetcher: SpecFetcherService,
+    private readonly registryClient: RegistryClientService,
+    private readonly sessionStore: ResolverSessionStore,
+    private readonly adapterFactory: ApiAdapterFactory,
+  ) {}
+
+  async create(params: {
+    name: string;
+    description: string;
+    specUrl: string;
+    provider?: string;
+    model?: string;
+    apiKey?: string;
+    outputDir?: string;
+  }): Promise<{ sessionId: string; name: string; outputDir: string }> {
+    const flags: Partial<CraftConfig> = {
+      provider: params.provider as CraftConfig['provider'],
+      model: params.model,
+      apiKey: params.apiKey,
+      outputDir: params.outputDir,
+    };
+
+    const config = await this.craftConfig.resolve(flags);
+
+    // Validate spec is fetchable
+    await this.specFetcher.fetch(params.specUrl);
+
+    const outputDir = resolve(config.outputDir, params.name);
+    const adapter = this.adapterFactory.create();
+    const sessionId = this.sessionStore.generateId();
+
+    adapter.showInfo(`Starting resolver generation for "${params.name}"`);
+
+    this.sessionStore.set({
+      id: sessionId,
+      adapter,
+      outputDir,
+      name: params.name,
+      status: 'running',
+    });
+
+    return { sessionId, name: params.name, outputDir };
+  }
+
+  getStatus(sessionId: string) {
+    const session = this.sessionStore.get(sessionId);
+    return {
+      sessionId: session.id,
+      status: session.status,
+      waitingFor: session.adapter.waitingFor,
+      error: session.error ?? null,
+    };
+  }
+
+  getOutput(sessionId: string): string {
+    return this.sessionStore.get(sessionId).adapter.output;
+  }
+
+  resolveAction(
+    sessionId: string,
+    body: { action?: string; feedback?: string },
+  ): void {
+    const session = this.sessionStore.get(sessionId);
+    const { action, feedback } = body;
+
+    if (action && session.adapter.waitingFor === 'reviewAction') {
+      this.assertReviewAction(action);
+      session.adapter.resolveReviewAction(action, feedback);
+      return;
+    }
+
+    throw new InvalidSessionStateError(
+      `Cannot perform action. Currently waiting for: ${session.adapter.waitingFor}`,
+    );
+  }
+
+  async searchRegistry(query: string): Promise<RegistrySearchResult[]> {
+    return this.registryClient.search(query);
+  }
+
+  async installFromRegistry(
+    repo: string,
+    name: string,
+    outputDir?: string,
+  ): Promise<string> {
+    const targetDir = resolve(outputDir || '.', name);
+    await this.registryClient.clone(repo, targetDir);
+    return targetDir;
+  }
+
+  getStream(sessionId: string): {
+    events: readonly SSEEvent[];
+    adapter: ApiAdapterService;
+  } {
+    const session = this.sessionStore.get(sessionId);
+    return { events: session.adapter.events, adapter: session.adapter };
+  }
+
+  private assertReviewAction(action: string): asserts action is ReviewAction {
+    if (!(Object.values(ReviewAction) as string[]).includes(action)) {
+      throw new InvalidSessionStateError(
+        `Invalid action. Must be one of: ${Object.values(ReviewAction).join(', ')}`,
+      );
+    }
+  }
+}

package/apps/agentcraft/src/sessions/dto/create-session.dto.ts

@@ -0,0 +1,12 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const CreateSessionSchema = z.object({
+  name: z.string().min(1).max(200),
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  apiKey: z.string().optional(),
+  outputDir: z.string().optional(),
+});
+
+export class CreateSessionDto extends createZodDto(CreateSessionSchema) {}

package/apps/agentcraft/src/sessions/dto/submit-action.dto.ts

@@ -0,0 +1 @@
+export { SubmitActionDto, SubmitActionSchema } from '@app/agentcraft';

package/apps/agentcraft/src/sessions/dto/submit-idea.dto.ts

@@ -0,0 +1,8 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const SubmitIdeaSchema = z.object({
+  idea: z.string().min(1).max(10_000),
+});
+
+export class SubmitIdeaDto extends createZodDto(SubmitIdeaSchema) {}

package/apps/agentcraft/src/sessions/session.store.ts

@@ -0,0 +1,39 @@
+import { Injectable, OnModuleDestroy, Logger } from '@nestjs/common';
+import { ApiAdapterService, SessionNotFoundError } from '@app/agentcraft';
+
+export interface Session {
+  id: string;
+  adapter: ApiAdapterService;
+  outputDir: string;
+  projectName: string;
+  status: 'running' | 'completed' | 'error';
+  error?: string;
+}
+
+@Injectable()
+export class SessionStore implements OnModuleDestroy {
+  private readonly logger = new Logger(SessionStore.name);
+  private counter = 0;
+  private readonly sessions = new Map<string, Session>();
+
+  set(session: Session): void {
+    this.sessions.set(session.id, session);
+  }
+
+  get(id: string): Session {
+    const session = this.sessions.get(id);
+    if (!session) {
+      throw new SessionNotFoundError();
+    }
+    return session;
+  }
+
+  generateId(): string {
+    return `session_${++this.counter}_${Date.now()}`;
+  }
+
+  onModuleDestroy() {
+    this.logger.log(`Cleaning up ${this.sessions.size} session(s)`);
+    this.sessions.clear();
+  }
+}

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

@@ -0,0 +1,87 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Param,
+  Body,
+  Sse,
+  HttpCode,
+  HttpStatus,
+  MessageEvent,
+} from '@nestjs/common';
+import { Observable, from, interval, merge, fromEvent } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { SessionsService } from './sessions.service';
+import { CreateSessionDto } from './dto/create-session.dto';
+import { SubmitIdeaDto } from './dto/submit-idea.dto';
+import { SubmitActionDto } from './dto/submit-action.dto';
+import type { SSEEvent } from '@app/agentcraft';
+
+@Controller('projects')
+export class SessionsController {
+  constructor(private readonly sessionsService: SessionsService) {}
+
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  async create(@Body() dto: CreateSessionDto) {
+    return this.sessionsService.create({
+      name: dto.name,
+      provider: dto.provider,
+      model: dto.model,
+      apiKey: dto.apiKey,
+      outputDir: dto.outputDir,
+    });
+  }
+
+  @Get(':id/status')
+  async getStatus(@Param('id') id: string) {
+    return this.sessionsService.getStatus(id);
+  }
+
+  @Get(':id/output')
+  getOutput(@Param('id') id: string) {
+    return { output: this.sessionsService.getOutput(id) };
+  }
+
+  @Get(':id/steps')
+  async getSteps(@Param('id') id: string) {
+    return { steps: await this.sessionsService.getSteps(id) };
+  }
+
+  @Post(':id/idea')
+  @HttpCode(HttpStatus.OK)
+  submitIdea(@Param('id') id: string, @Body() dto: SubmitIdeaDto) {
+    this.sessionsService.resolveIdea(id, dto.idea);
+    return { ok: true };
+  }
+
+  @Post(':id/action')
+  @HttpCode(HttpStatus.OK)
+  submitAction(@Param('id') id: string, @Body() dto: SubmitActionDto) {
+    this.sessionsService.resolveAction(id, dto);
+    return { ok: true };
+  }
+
+  @Get(':id/files')
+  async getFiles(@Param('id') id: string) {
+    return { files: await this.sessionsService.getFiles(id) };
+  }
+
+  @Get(':id/files/*')
+  async getFile(@Param('id') id: string, @Param('0') filePath: string) {
+    return this.sessionsService.getFile(id, filePath);
+  }
+
+  @Sse(':id/stream')
+  stream(@Param('id') id: string): Observable<MessageEvent> {
+    const { events, adapter } = this.sessionsService.getStream(id);
+
+    return merge(
+      from(events).pipe(map((e) => ({ data: JSON.stringify(e) }))),
+      fromEvent<SSEEvent>(adapter.eventEmitter, 'sse').pipe(
+        map((e) => ({ data: JSON.stringify(e) })),
+      ),
+      interval(15_000).pipe(map(() => ({ data: '' }))),
+    );
+  }
+}

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { SessionsController } from './sessions.controller';
+import { SessionsService } from './sessions.service';
+import { SessionStore } from './session.store';
+
+@Module({
+  controllers: [SessionsController],
+  providers: [SessionsService, SessionStore],
+})
+export class SessionsModule {}