@agentlang/agentmanager 0.0.3

package/apps/agentmanager/src/deployments/deployments.service.ts

@@ -0,0 +1,166 @@
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import * as path from 'node:path';
+import { REGISTRY_PATH } from '@app/project-provider';
+import {
+  DeploymentNotFoundError,
+  DeploymentServiceUnavailableError,
+} from './errors/deployment.errors';
+import type {
+  DeploymentSource,
+  DeploymentStatus,
+  DeploymentInfo,
+  EmployeeDeploymentInfo,
+} from './interfaces/deployment.interfaces';
+
+export type {
+  DeploymentSource,
+  DeploymentStatus,
+  DeploymentInfo,
+  EmployeeDeploymentInfo,
+};
+
+@Injectable()
+export class DeploymentsService {
+  private readonly logger = new Logger(DeploymentsService.name);
+  private readonly registryPath: string;
+  private readonly deploymentServiceUrl?: string;
+
+  constructor(
+    @Inject(REGISTRY_PATH) registryPath: string,
+    private readonly config: ConfigService,
+  ) {
+    this.registryPath = registryPath;
+    this.deploymentServiceUrl = this.config.get<string>(
+      'deploymentService.baseUrl',
+    );
+  }
+
+  get isConfigured(): boolean {
+    return !!this.deploymentServiceUrl;
+  }
+
+  private employeeDir(projectId: string, employeeId: string): string {
+    return path.resolve(this.registryPath, projectId, employeeId);
+  }
+
+  async getLocalDeployment(
+    projectId: string,
+    employeeId: string,
+  ): Promise<DeploymentInfo> {
+    const filePath = path.join(
+      this.employeeDir(projectId, employeeId),
+      'deployment.json',
+    );
+    let raw: string;
+    try {
+      raw = await readFile(filePath, 'utf-8');
+    } catch {
+      throw new DeploymentNotFoundError(projectId, employeeId);
+    }
+    return JSON.parse(raw) as DeploymentInfo;
+  }
+
+  async getLiveStatus(deploymentId: string): Promise<DeploymentInfo> {
+    if (!this.deploymentServiceUrl) {
+      throw new DeploymentServiceUnavailableError(
+        'Deployment service URL not configured',
+      );
+    }
+    const url = `${this.deploymentServiceUrl}/deployments/${deploymentId}`;
+    let res: Response;
+    try {
+      res = await fetch(url);
+    } catch (err) {
+      throw new DeploymentServiceUnavailableError(
+        `Failed to reach deployment service: ${err instanceof Error ? err.message : err}`,
+      );
+    }
+
+    if (!res.ok) {
+      throw new DeploymentServiceUnavailableError(
+        `Deployment service returned ${res.status} for deployment ${deploymentId}`,
+      );
+    }
+
+    return (await res.json()) as DeploymentInfo;
+  }
+
+  async getEmployeeStatus(
+    projectId: string,
+    employeeId: string,
+  ): Promise<EmployeeDeploymentInfo> {
+    const local = await this.getLocalDeployment(projectId, employeeId);
+    let deployment = local;
+    try {
+      deployment = await this.getLiveStatus(local.id);
+    } catch (err) {
+      this.logger.warn(
+        `Could not fetch live status for ${projectId}/${employeeId}, using local: ${
+          err instanceof Error ? err.message : err
+        }`,
+      );
+    }
+    return { projectId, employeeId, deployment };
+  }
+
+  async isRunning(projectId: string, employeeId: string): Promise<boolean> {
+    try {
+      const info = await this.getEmployeeStatus(projectId, employeeId);
+      return info.deployment.status === 'running';
+    } catch (err) {
+      this.logger.debug(
+        `isRunning check failed for ${projectId}/${employeeId}: ${err instanceof Error ? err.message : err}`,
+      );
+      return false;
+    }
+  }
+
+  async listDeployments(): Promise<EmployeeDeploymentInfo[]> {
+    const results: EmployeeDeploymentInfo[] = [];
+    let projectDirs: string[];
+    try {
+      projectDirs = await readdir(this.registryPath);
+    } catch (err) {
+      this.logger.warn(
+        `Failed to read registry path ${this.registryPath}: ${err instanceof Error ? err.message : err}`,
+      );
+      return results;
+    }
+
+    for (const projectId of projectDirs) {
+      const projectPath = path.join(this.registryPath, projectId);
+      const projectStat = await stat(projectPath).catch(() => null);
+      if (!projectStat?.isDirectory()) continue;
+
+      let employeeDirs: string[];
+      try {
+        employeeDirs = await readdir(projectPath);
+      } catch (err) {
+        this.logger.debug(
+          `Failed to read project directory ${projectPath}: ${err instanceof Error ? err.message : err}`,
+        );
+        continue;
+      }
+
+      for (const employeeId of employeeDirs) {
+        const employeePath = path.join(projectPath, employeeId);
+        const empStat = await stat(employeePath).catch(() => null);
+        if (!empStat?.isDirectory()) continue;
+
+        const deploymentFile = path.join(employeePath, 'deployment.json');
+        try {
+          const raw = await readFile(deploymentFile, 'utf-8');
+          const deployment = JSON.parse(raw) as DeploymentInfo;
+          results.push({ projectId, employeeId, deployment });
+        } catch (err) {
+          this.logger.debug(
+            `No deployment.json for ${projectId}/${employeeId}: ${err instanceof Error ? err.message : err}`,
+          );
+        }
+      }
+    }
+    return results;
+  }
+}

package/apps/agentmanager/src/deployments/errors/deployment.errors.ts

@@ -0,0 +1,13 @@
+import { DomainError } from '@app/project-provider';
+
+export class DeploymentNotFoundError extends DomainError {
+  constructor(projectId: string, employeeId: string) {
+    super(`No deployment.json found for ${projectId}/${employeeId}`, 404);
+  }
+}
+
+export class DeploymentServiceUnavailableError extends DomainError {
+  constructor(message: string) {
+    super(message, 503);
+  }
+}

package/apps/agentmanager/src/deployments/interfaces/deployment.interfaces.ts

@@ -0,0 +1,25 @@
+export interface DeploymentSource {
+  type: string;
+  org: string;
+  repo: string;
+  branch: string;
+}
+
+export type DeploymentStatus = 'running' | 'pending' | 'paused' | 'stopped';
+
+export interface DeploymentInfo {
+  id: string;
+  userId: string;
+  source: DeploymentSource;
+  provider: string;
+  status: DeploymentStatus;
+  port: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface EmployeeDeploymentInfo {
+  projectId: string;
+  employeeId: string;
+  deployment: DeploymentInfo;
+}

package/apps/agentmanager/src/discovery/discovery.controller.ts

@@ -0,0 +1,14 @@
+import { Controller, Post, Body, HttpCode, HttpStatus } from '@nestjs/common';
+import { DiscoveryService } from './discovery.service';
+import { DiscoverDto } from './dto/discover.dto';
+
+@Controller('discover')
+export class DiscoveryController {
+  constructor(private readonly discoveryService: DiscoveryService) {}
+
+  @Post()
+  @HttpCode(HttpStatus.OK)
+  async discover(@Body() dto: DiscoverDto) {
+    return this.discoveryService.discover(dto.query);
+  }
+}

package/apps/agentmanager/src/discovery/discovery.module.ts

@@ -0,0 +1,36 @@
+import { Module } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { DiscoveryController } from './discovery.controller';
+import { DiscoveryService } from './discovery.service';
+import { LLM_PROVIDER } from './llm/llm-provider.interface';
+import { AnthropicLlmService } from './llm/anthropic-llm.service';
+import { OpenaiLlmService } from './llm/openai-llm.service';
+
+@Module({
+  controllers: [DiscoveryController],
+  providers: [
+    DiscoveryService,
+    {
+      provide: LLM_PROVIDER,
+      useFactory: (config: ConfigService) => {
+        const llmConfig = config.get('llm');
+        if (!llmConfig?.apiKey) return null;
+
+        if (llmConfig.provider === 'openai') {
+          return new OpenaiLlmService(
+            llmConfig.model,
+            llmConfig.apiKey,
+            llmConfig.baseUrl,
+          );
+        }
+        return new AnthropicLlmService(
+          llmConfig.model,
+          llmConfig.apiKey,
+          llmConfig.baseUrl,
+        );
+      },
+      inject: [ConfigService],
+    },
+  ],
+})
+export class DiscoveryModule {}

package/apps/agentmanager/src/discovery/discovery.service.ts

@@ -0,0 +1,174 @@
+import { Injectable, Inject, Optional, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import {
+  REGISTRY_PROVIDER,
+  RegistryProvider,
+  EmployeeDetail,
+  Capability,
+} from '@app/project-provider';
+import { LLM_PROVIDER, LlmProvider } from './llm/llm-provider.interface';
+import { LlmNotConfiguredError } from './llm/llm.errors';
+import type {
+  DiscoveryMatch,
+  DiscoveryResult,
+} from './interfaces/discovery.interfaces';
+
+export type { DiscoveryMatch, DiscoveryResult };
+
+@Injectable()
+export class DiscoveryService {
+  private readonly logger = new Logger(DiscoveryService.name);
+
+  constructor(
+    @Inject(REGISTRY_PROVIDER) private readonly registry: RegistryProvider,
+    @Inject(LLM_PROVIDER) @Optional() private readonly llm: LlmProvider | null,
+    private readonly config: ConfigService,
+  ) {}
+
+  async discover(query: string): Promise<DiscoveryResult> {
+    if (!this.llm) {
+      throw new LlmNotConfiguredError();
+    }
+
+    const catalog = await this.buildCatalog();
+    if (catalog.length === 0) {
+      return this.withCreateSuggestion({ query, matches: [] });
+    }
+
+    const systemPrompt = `You are an AI Employee discovery engine. You will be given a user query describing a business need, and a catalog of AI Employees with their capabilities.
+
+Your task:
+1. Compare the user query against each AI Employee's capabilities.
+2. Return a JSON array of matches. Each match must have:
+   - "employeeId": the employee's ID
+   - "projectId": the project it belongs to
+   - "relevanceScore": integer 0-100 indicating how well the employee matches the query
+   - "reason": a brief explanation of why this employee matches
+   - "matchedCapabilities": array of capability names that are relevant to the query
+3. Only include employees with relevanceScore >= 30.
+4. Sort by relevanceScore descending.
+5. If nothing matches, return an empty array [].
+
+Return ONLY the JSON array, no other text.`;
+
+    const userPrompt = this.buildUserPrompt(query, catalog);
+
+    const response = await this.llm.complete({
+      systemPrompt,
+      userPrompt,
+      temperature: 0,
+    });
+
+    const matches = this.parseResponse(response.text);
+    return this.withCreateSuggestion({ query, matches });
+  }
+
+  private async buildCatalog(): Promise<
+    { employee: EmployeeDetail; projectId: string }[]
+  > {
+    const projects = await this.registry.listProjects();
+    const catalog: { employee: EmployeeDetail; projectId: string }[] = [];
+
+    for (const project of projects) {
+      const employees = await this.registry.listEmployees(project.id);
+      for (const emp of employees) {
+        const detail = await this.registry.getEmployee(project.id, emp.id);
+        catalog.push({ employee: detail, projectId: project.id });
+      }
+    }
+    return catalog;
+  }
+
+  private buildUserPrompt(
+    query: string,
+    catalog: { employee: EmployeeDetail; projectId: string }[],
+  ): string {
+    const catalogText = catalog
+      .map(({ employee, projectId }) => {
+        const caps = employee.capabilities
+          .map((c: Capability) => {
+            let entry = `    - [${c.kind}] ${c.name} (invoke: ${c.invokeEndpoint})`;
+            if (c.role) entry += `\n      Role: ${c.role}`;
+            if (c.instruction) entry += `\n      Instruction: ${c.instruction}`;
+            return entry;
+          })
+          .join('\n');
+        return `  Employee: ${employee.id} (project: ${projectId}, module: ${employee.module ?? 'N/A'})\n  Capabilities:\n${caps}`;
+      })
+      .join('\n\n');
+
+    return `User query: "${query}"\n\nAI Employee Catalog:\n${catalogText}`;
+  }
+
+  private parseResponse(text: string): DiscoveryMatch[] {
+    let cleaned = text.trim();
+    cleaned = cleaned
+      .replace(/^```(?:json)?\s*\n?/i, '')
+      .replace(/\n?```\s*$/, '');
+    cleaned = cleaned.trim();
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(cleaned);
+    } catch {
+      return [];
+    }
+
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+
+    return (parsed as Record<string, unknown>[])
+      .filter(
+        (item) =>
+          typeof item.employeeId === 'string' &&
+          typeof item.projectId === 'string' &&
+          typeof item.relevanceScore === 'number' &&
+          (item.relevanceScore as number) >= 30,
+      )
+      .sort(
+        (a, b) => (b.relevanceScore as number) - (a.relevanceScore as number),
+      )
+      .map((item) => ({
+        employeeId: item.employeeId as string,
+        projectId: item.projectId as string,
+        module: (item.module as string) ?? null,
+        relevanceScore: item.relevanceScore as number,
+        reason: (item.reason as string) ?? '',
+        matchedCapabilities: Array.isArray(item.matchedCapabilities)
+          ? (item.matchedCapabilities as unknown[]).map((cap) =>
+              typeof cap === 'string'
+                ? { name: cap, kind: 'unknown', invokeEndpoint: '' }
+                : {
+                    name:
+                      ((cap as Record<string, unknown>).name as string) ?? '',
+                    kind:
+                      ((cap as Record<string, unknown>).kind as string) ??
+                      'unknown',
+                    invokeEndpoint:
+                      ((cap as Record<string, unknown>)
+                        .invokeEndpoint as string) ?? '',
+                    ...((cap as Record<string, unknown>).instruction
+                      ? {
+                          instruction: (cap as Record<string, unknown>)
+                            .instruction as string,
+                        }
+                      : {}),
+                  },
+            )
+          : [],
+      }));
+  }
+
+  private withCreateSuggestion(result: DiscoveryResult): DiscoveryResult {
+    const agentcraftUrl = this.config.get<string>('agentcraft.baseUrl');
+    if (result.matches.length === 0 && agentcraftUrl) {
+      result.createSuggestion = {
+        message:
+          'No matching AI Employee was found. You can create one using AgentCraft.',
+        agentcraftUrl,
+      };
+    }
+    return result;
+  }
+}

package/apps/agentmanager/src/discovery/dto/discover.dto.ts

@@ -0,0 +1,8 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const DiscoverSchema = z.object({
+  query: z.string().min(1).max(2000),
+});
+
+export class DiscoverDto extends createZodDto(DiscoverSchema) {}

package/apps/agentmanager/src/discovery/interfaces/discovery.interfaces.ts

@@ -0,0 +1,22 @@
+export interface DiscoveryMatch {
+  employeeId: string;
+  projectId: string;
+  module: string | null;
+  relevanceScore: number;
+  reason: string;
+  matchedCapabilities: {
+    name: string;
+    kind: string;
+    invokeEndpoint: string;
+    instruction?: string;
+  }[];
+}
+
+export interface DiscoveryResult {
+  query: string;
+  matches: DiscoveryMatch[];
+  createSuggestion?: {
+    message: string;
+    agentcraftUrl: string;
+  };
+}

package/apps/agentmanager/src/discovery/llm/anthropic-llm.service.ts

@@ -0,0 +1,67 @@
+import { Injectable } from '@nestjs/common';
+import { DomainError } from '@app/project-provider';
+import type {
+  LlmProvider,
+  LlmRequest,
+  LlmResponse,
+} from './llm-provider.interface';
+
+@Injectable()
+export class AnthropicLlmService implements LlmProvider {
+  constructor(
+    private readonly model: string,
+    private readonly apiKey: string,
+    private readonly baseUrl: string = 'https://api.anthropic.com',
+  ) {}
+
+  async complete(request: LlmRequest): Promise<LlmResponse> {
+    const url = `${this.baseUrl.replace(/\/+$/, '')}/v1/messages`;
+    let res: Response;
+    try {
+      res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+          model: this.model,
+          max_tokens: request.maxTokens ?? 16384,
+          temperature: request.temperature ?? 0,
+          system: request.systemPrompt,
+          messages: [{ role: 'user', content: request.userPrompt }],
+        }),
+      });
+    } catch (err) {
+      throw new DomainError(
+        `Failed to connect to Anthropic API: ${(err as Error).message}`,
+        502,
+      );
+    }
+
+    if (!res.ok) {
+      const body = await res.text().catch(() => '');
+      throw new DomainError(
+        `Anthropic API returned ${res.status}: ${body}`,
+        502,
+      );
+    }
+
+    const json = await res.json();
+    const textBlock = json?.content?.find(
+      (b: { type: string }) => b.type === 'text',
+    );
+    if (!textBlock || typeof textBlock.text !== 'string') {
+      throw new DomainError(
+        'Unexpected response shape from Anthropic API',
+        502,
+      );
+    }
+    const stopReason =
+      json.stop_reason === 'max_tokens'
+        ? ('max_tokens' as const)
+        : ('end_turn' as const);
+    return { text: textBlock.text, stopReason };
+  }
+}

package/apps/agentmanager/src/discovery/llm/llm-provider.interface.ts

@@ -0,0 +1,17 @@
+export const LLM_PROVIDER = 'LLM_PROVIDER';
+
+export interface LlmRequest {
+  systemPrompt: string;
+  userPrompt: string;
+  temperature?: number;
+  maxTokens?: number;
+}
+
+export interface LlmResponse {
+  text: string;
+  stopReason?: 'end_turn' | 'max_tokens';
+}
+
+export interface LlmProvider {
+  complete(request: LlmRequest): Promise<LlmResponse>;
+}

package/apps/agentmanager/src/discovery/llm/llm.errors.ts

@@ -0,0 +1,7 @@
+import { DomainError } from '@app/project-provider';
+
+export class LlmNotConfiguredError extends DomainError {
+  constructor() {
+    super('LLM provider is not configured', 501);
+  }
+}

package/apps/agentmanager/src/discovery/llm/openai-llm.service.ts

@@ -0,0 +1,67 @@
+import { Injectable } from '@nestjs/common';
+import { DomainError } from '@app/project-provider';
+import type {
+  LlmProvider,
+  LlmRequest,
+  LlmResponse,
+} from './llm-provider.interface';
+
+@Injectable()
+export class OpenaiLlmService implements LlmProvider {
+  constructor(
+    private readonly model: string,
+    private readonly apiKey: string,
+    private readonly baseUrl: string = 'https://api.openai.com/v1',
+  ) {}
+
+  async complete(request: LlmRequest): Promise<LlmResponse> {
+    const url = `${this.baseUrl.replace(/\/+$/, '')}/chat/completions`;
+    let res: Response;
+    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 DomainError(
+        `Failed to connect to OpenAI-compatible API: ${(err as Error).message}`,
+        502,
+      );
+    }
+
+    if (!res.ok) {
+      const body = await res.text().catch(() => '');
+      throw new DomainError(
+        `OpenAI-compatible API returned ${res.status}: ${body}`,
+        502,
+      );
+    }
+
+    const json = await res.json();
+    const text = json?.choices?.[0]?.message?.content;
+    if (typeof text !== 'string') {
+      throw new DomainError(
+        'Unexpected response shape from OpenAI-compatible API',
+        502,
+      );
+    }
+    const finishReason = json?.choices?.[0]?.finish_reason;
+    const stopReason =
+      finishReason === 'length'
+        ? ('max_tokens' as const)
+        : ('end_turn' as const);
+    return { text, stopReason };
+  }
+}

package/apps/agentmanager/src/employee-code/dto/put-config.dto.ts

@@ -0,0 +1,8 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const PutConfigSchema = z.object({
+  content: z.string().min(1).max(500_000),
+});
+
+export class PutConfigDto extends createZodDto(PutConfigSchema) {}

package/apps/agentmanager/src/employee-code/dto/put-module.dto.ts

@@ -0,0 +1,8 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const PutModuleSchema = z.object({
+  source: z.string().min(1).max(500_000),
+});
+
+export class PutModuleDto extends createZodDto(PutModuleSchema) {}

package/apps/agentmanager/src/employee-code/dto/put-package.dto.ts

@@ -0,0 +1,13 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const PutPackageSchema = z
+  .object({
+    name: z.string(),
+    version: z.string().optional(),
+    description: z.string().optional(),
+    dependencies: z.object({}).catchall(z.string()).optional(),
+  })
+  .passthrough();
+
+export class PutPackageDto extends createZodDto(PutPackageSchema) {}