@agentlang/agentmanager 0.0.3

package/apps/fabric/src/ai-agent/ai-agent.service.ts

@@ -0,0 +1,374 @@
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import type { ConfigType } from '@nestjs/config';
+import fabricConfig from '../config/configuration';
+import type {
+  ProbeInvestigationContext,
+  ProbeInvestigationDecision,
+  ProbeInvestigationResult,
+} from './probe-investigation.types';
+
+export const OPENAI_MODULE = Symbol('OPENAI_MODULE');
+export const ANTHROPIC_MODULE = Symbol('ANTHROPIC_MODULE');
+
+export type {
+  ProbeAiPreviousAction,
+  ProbeInvestigationContext,
+  ProbeInvestigationDecision,
+  ProbeInvestigationResult,
+} from './probe-investigation.types';
+
+const PROBE_SYSTEM_PROMPT = `You are an SRE agent. A health probe sent POST with JSON body "{}" to the app root and required HTTP 200. That did not succeed.
+
+You must respond with a single JSON object only (no markdown fences, no other text). Schema:
+{"action":"restart"|"escalate","reasoning":"<brief explanation citing logs when possible>"}
+
+- action "restart": likely transient; restarting the process/container may fix it.
+- action "escalate": needs a human (misconfiguration, data corruption, security, unclear root cause, or repeated failures after prior restarts).
+
+Use prior decisions in the user message to avoid restart loops if restarts did not help before.`;
+
+const VALID_PROBE_DECISIONS: ProbeInvestigationDecision[] = [
+  'restart',
+  'escalate',
+];
+
+const MAX_PROBE_PREVIOUS_ACTIONS_IN_PROMPT = 12;
+
+function buildProbeUserContent(context: ProbeInvestigationContext): string {
+  const lines: string[] = [
+    `Project: ${context.projectId}`,
+    `Employee: ${context.employeeId}`,
+    `Env: ${context.env}`,
+    context.httpStatus != null
+      ? `HTTP status from probe: ${context.httpStatus}`
+      : '(no HTTP response)',
+    context.fetchError ? `Fetch error: ${context.fetchError}` : '',
+  ].filter((s) => s.length > 0);
+
+  const prev = context.previousActions ?? [];
+  if (prev.length > 0) {
+    const slice = prev.slice(-MAX_PROBE_PREVIOUS_ACTIONS_IN_PROMPT);
+    lines.push('');
+    lines.push(
+      '--- Previous AI probe decisions for this deployment (oldest first) ---',
+    );
+    for (const p of slice) {
+      lines.push(
+        `- [${p.atIso}] action=${p.action} | ${p.reasoning.replace(/\s+/g, ' ').trim()}`,
+      );
+    }
+  }
+
+  lines.push('', '--- Logs ---', context.logs || '(no logs)');
+  return lines.join('\n');
+}
+
+function extractJsonObject(raw: string): unknown {
+  const trimmed = raw.trim();
+  const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const candidate = fenced ? fenced[1].trim() : trimmed;
+  try {
+    return JSON.parse(candidate) as unknown;
+  } catch {
+    const start = candidate.indexOf('{');
+    const end = candidate.lastIndexOf('}');
+    if (start >= 0 && end > start) {
+      try {
+        return JSON.parse(candidate.slice(start, end + 1)) as unknown;
+      } catch {
+        return undefined;
+      }
+    }
+    return undefined;
+  }
+}
+
+function normalizeProbeAction(s: string): ProbeInvestigationDecision | null {
+  const lower = s.trim().toLowerCase().replace(/['"]/g, '');
+  for (const v of VALID_PROBE_DECISIONS) {
+    if (lower === v) return v;
+  }
+  if (lower.includes('escalate')) return 'escalate';
+  if (lower.includes('restart')) return 'restart';
+  return null;
+}
+
+interface OpenAIConstructor {
+  new (opts: { apiKey: string }): {
+    chat: {
+      completions: {
+        create: (params: Record<string, unknown>) => Promise<{
+          choices: Array<{ message?: { content?: string } }>;
+        }>;
+      };
+    };
+  };
+}
+
+/** Anthropic SDK default export */
+interface AnthropicConstructor {
+  new (opts: { apiKey: string }): {
+    messages: {
+      create: (params: Record<string, unknown>) => Promise<{
+        content: Array<{ type: string; text?: string }>;
+      }>;
+    };
+  };
+}
+
+export type AiRecoveryAction =
+  | 'restart_app'
+  | 'send_email_to_user'
+  | 'reconfigure_db'
+  | 'rescale_kubernetes';
+
+export interface AiFailureContext {
+  projectId: string;
+  employeeId: string;
+  env: string;
+  error: string;
+  retryCount: number;
+  maxRetries: number;
+  logs: string;
+  hasPostgresStore: boolean;
+  hasKubernetes: boolean;
+  healthData?: Record<string, unknown>;
+}
+
+const SYSTEM_PROMPT = `You are an AI ops agent analyzing deployment failures. Given logs, health metrics, and context, you must choose exactly ONE recovery action.
+
+Available actions (respond with ONLY this exact string, nothing else):
+- restart_app: Try restarting the application container. Use when the failure seems transient (e.g. memory spike, temporary network blip).
+- send_email_to_user: Notify the user via email. Use when the failure appears to need human attention (e.g. config error, auth failure, persistent crash).
+- reconfigure_db: Create a new database and redeploy. Use when logs suggest database corruption, connection pool exhaustion, or schema/connection issues.
+- rescale_kubernetes: Scale up the Kubernetes deployment (add replicas). Use ONLY when hasKubernetes is true AND health metrics show high memory_usage or cpu_usage (e.g. >0.8 or 80%). This adds capacity to handle load.
+
+Respond with ONLY the action string: restart_app, send_email_to_user, reconfigure_db, or rescale_kubernetes.`;
+
+const VALID_ACTIONS: AiRecoveryAction[] = [
+  'restart_app',
+  'send_email_to_user',
+  'reconfigure_db',
+  'rescale_kubernetes',
+];
+
+@Injectable()
+export class AiAgentService {
+  private readonly logger = new Logger(AiAgentService.name);
+
+  constructor(
+    @Inject(fabricConfig.KEY)
+    private readonly config: ConfigType<typeof fabricConfig>,
+    @Inject(OPENAI_MODULE) private readonly OpenAI: OpenAIConstructor | null,
+    @Inject(ANTHROPIC_MODULE)
+    private readonly Anthropic: AnthropicConstructor | null,
+  ) {}
+
+  /**
+   * After POST probe to localhost:port returns non-200, decide restart vs human escalation.
+   * Uses Anthropic and/or OpenAI API keys from config / env (`FABRIC_AI_PROVIDER`).
+   */
+  async getProbeInvestigationDecision(
+    context: ProbeInvestigationContext,
+  ): Promise<ProbeInvestigationResult | null> {
+    const userContent = buildProbeUserContent(context);
+
+    const mode = this.config.aiProvider;
+    if (mode === 'anthropic') {
+      return this.probeWithAnthropic(userContent);
+    }
+    if (mode === 'openai') {
+      return this.probeWithOpenAI(userContent);
+    }
+    if (this.config.anthropic.apiKey && this.Anthropic) {
+      return this.probeWithAnthropic(userContent);
+    }
+    if (this.config.openai.apiKey && this.OpenAI) {
+      return this.probeWithOpenAI(userContent);
+    }
+    this.logger.warn(
+      'Probe investigation: set ANTHROPIC_API_KEY or OPENAI_API_KEY (and install the client if needed)',
+    );
+    return null;
+  }
+
+  private async probeWithAnthropic(
+    userContent: string,
+  ): Promise<ProbeInvestigationResult | null> {
+    const apiKey = this.config.anthropic.apiKey;
+    if (!apiKey || !this.Anthropic) {
+      this.logger.warn('Anthropic selected but API key or SDK missing');
+      return null;
+    }
+    try {
+      const client = new this.Anthropic({ apiKey });
+      const msg = await client.messages.create({
+        model: this.config.anthropic.model,
+        max_tokens: 1024,
+        system: PROBE_SYSTEM_PROMPT,
+        messages: [{ role: 'user', content: userContent }],
+      });
+      const text = msg.content
+        .filter((b): b is { type: 'text'; text: string } => b.type === 'text')
+        .map((b) => b.text)
+        .join('');
+      return this.parseProbeStructured(text);
+    } catch (err) {
+      this.logger.error(`Anthropic probe investigation failed: ${err}`);
+      return null;
+    }
+  }
+
+  private async probeWithOpenAI(
+    userContent: string,
+  ): Promise<ProbeInvestigationResult | null> {
+    const apiKey = this.config.openai.apiKey;
+    if (!apiKey || !this.OpenAI) {
+      this.logger.warn('OpenAI selected but API key or package missing');
+      return null;
+    }
+    try {
+      const client = new this.OpenAI({ apiKey });
+      const completion = await client.chat.completions.create({
+        model: this.config.openai.model,
+        messages: [
+          { role: 'system', content: PROBE_SYSTEM_PROMPT },
+          { role: 'user', content: userContent },
+        ],
+        max_tokens: 800,
+        temperature: 0,
+      });
+      const raw = completion.choices[0]?.message?.content?.trim() ?? '';
+      return this.parseProbeStructured(raw);
+    } catch (err) {
+      this.logger.error(`OpenAI probe investigation failed: ${err}`);
+      return null;
+    }
+  }
+
+  /**
+   * Prefer JSON {"action","reasoning"}; fall back to inferring action from plain text.
+   */
+  private parseProbeStructured(raw: string): ProbeInvestigationResult | null {
+    this.logger.log(`Probe AI raw output: ${JSON.stringify(raw)}`);
+    const parsed = extractJsonObject(raw);
+    if (parsed && typeof parsed === 'object' && parsed !== null) {
+      const rec = parsed as Record<string, unknown>;
+      const actionRaw = rec.action;
+      const reasoningRaw = rec.reasoning;
+      const action =
+        typeof actionRaw === 'string' ? normalizeProbeAction(actionRaw) : null;
+      const reasoning =
+        typeof reasoningRaw === 'string' && reasoningRaw.trim().length > 0
+          ? reasoningRaw.trim()
+          : '(no reasoning in JSON)';
+      if (action) {
+        this.logger.log(
+          `Probe investigation decision: action=${action} reasoning=${JSON.stringify(reasoning)}`,
+        );
+        return { action, reasoning };
+      }
+    }
+
+    const fallback = this.parseProbeDecision(raw);
+    if (fallback) {
+      this.logger.warn(
+        `Probe investigation: invalid JSON, inferred action=${fallback} from text`,
+      );
+      return {
+        action: fallback,
+        reasoning:
+          '(model did not return valid JSON; action inferred from response text)',
+      };
+    }
+    return null;
+  }
+
+  private parseProbeDecision(raw: string): ProbeInvestigationDecision | null {
+    const lower = raw.trim().toLowerCase();
+    for (const v of VALID_PROBE_DECISIONS) {
+      if (lower === v || lower.includes(v)) {
+        return v;
+      }
+    }
+    const cleaned = lower.replace(/[^a-z]/g, '');
+    if (cleaned.includes('escalate')) return 'escalate';
+    if (cleaned.includes('restart')) return 'restart';
+    return null;
+  }
+
+  async getRecoveryAction(
+    context: AiFailureContext,
+  ): Promise<AiRecoveryAction | null> {
+    const apiKey = this.config.openai.apiKey;
+    if (!apiKey) {
+      this.logger.warn('OPENAI_API_KEY not set, skipping AI recovery');
+      return null;
+    }
+
+    if (!this.OpenAI) {
+      this.logger.warn('openai package not installed, skipping AI recovery');
+      return null;
+    }
+
+    const userContent = [
+      `Project: ${context.projectId}`,
+      `Employee: ${context.employeeId}`,
+      `Env: ${context.env}`,
+      `Error: ${context.error}`,
+      `Retry count: ${context.retryCount}/${context.maxRetries}`,
+      `Uses Postgres: ${context.hasPostgresStore}`,
+      `Kubernetes deployment: ${context.hasKubernetes}`,
+      context.healthData
+        ? `Health metrics: ${JSON.stringify(context.healthData)}`
+        : '(no health metrics)',
+      '',
+      '--- Logs ---',
+      context.logs || '(no logs available)',
+    ].join('\n');
+
+    this.logger.log(
+      `AI agent input: ${JSON.stringify({ projectId: context.projectId, employeeId: context.employeeId, error: context.error })}`,
+    );
+
+    try {
+      const client = new this.OpenAI({ apiKey });
+
+      const completion = await client.chat.completions.create({
+        model: this.config.openai.model,
+        messages: [
+          { role: 'system', content: SYSTEM_PROMPT },
+          { role: 'user', content: userContent },
+        ],
+        max_tokens: 50,
+        temperature: 0,
+      });
+
+      const raw = completion.choices[0]?.message?.content?.trim().toLowerCase();
+      this.logger.log(
+        `AI agent output: ${JSON.stringify({ raw: raw ?? '(empty)' })}`,
+      );
+
+      if (!raw) return null;
+
+      const action = raw.replace(/[^a-z_]/g, '') as AiRecoveryAction;
+      if (VALID_ACTIONS.includes(action)) {
+        this.logger.log(`AI chosen action: ${action}`);
+        return action;
+      }
+
+      for (const v of VALID_ACTIONS) {
+        if (raw.includes(v)) {
+          this.logger.log(`AI chosen action (extracted): ${v}`);
+          return v;
+        }
+      }
+
+      this.logger.log(`No valid action parsed from: ${raw}`);
+      return null;
+    } catch (err) {
+      this.logger.error(`OpenAI call failed: ${err}`);
+      return null;
+    }
+  }
+}

package/apps/fabric/src/ai-agent/probe-investigation.types.ts

@@ -0,0 +1,24 @@
+export type ProbeInvestigationDecision = 'restart' | 'escalate';
+
+/** Prior probe investigations for this deployment (for model context). */
+export interface ProbeAiPreviousAction {
+  atIso: string;
+  action: ProbeInvestigationDecision;
+  reasoning: string;
+}
+
+export interface ProbeInvestigationContext {
+  projectId: string;
+  employeeId: string;
+  env: string;
+  httpStatus?: number;
+  fetchError?: string;
+  logs: string;
+  /** Earlier AI decisions for this deployment (oldest → newest). */
+  previousActions?: ProbeAiPreviousAction[];
+}
+
+export interface ProbeInvestigationResult {
+  action: ProbeInvestigationDecision;
+  reasoning: string;
+}

package/apps/fabric/src/app.module.ts

@@ -0,0 +1,40 @@
+import { Module } from '@nestjs/common';
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
+import { ConfigModule } from '@nestjs/config';
+import type { ConfigType } from '@nestjs/config';
+import { ThrottlerModule, ThrottlerGuard } from '@nestjs/throttler';
+import {
+  DatabaseModule,
+  DomainExceptionFilter,
+  LoggingInterceptor,
+} from '@app/common';
+import configuration from './config/configuration';
+import { fabricEntities } from './database/entities';
+import { FabricCoreModule } from './fabric-core.module';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      load: [configuration],
+    }),
+    ThrottlerModule.forRoot([{ ttl: 60_000, limit: 100 }]),
+    DatabaseModule.forRootAsync({
+      inject: [configuration.KEY],
+      useFactory: (config: ConfigType<typeof configuration>) => ({
+        dataPath: config.dataPath,
+        database: config.database,
+        embeddedDbPort: config.embeddedDbPort,
+        embeddedDbName: config.embeddedDbName,
+        entities: fabricEntities,
+      }),
+    }),
+    FabricCoreModule.forRoot(),
+  ],
+  providers: [
+    { provide: APP_FILTER, useClass: DomainExceptionFilter },
+    { provide: APP_GUARD, useClass: ThrottlerGuard },
+    { provide: APP_INTERCEPTOR, useClass: LoggingInterceptor },
+  ],
+})
+export class AppModule {}

package/apps/fabric/src/auth/current-user.decorator.ts

@@ -0,0 +1,11 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { DEFAULT_USER_ID } from '../user-config/user-config.types';
+import type { RequestUser } from './request-user';
+
+export const CurrentUser = createParamDecorator(
+  (field: keyof RequestUser | undefined, ctx: ExecutionContext) => {
+    const request = ctx.switchToHttp().getRequest<{ user?: RequestUser }>();
+    const user: RequestUser = request.user ?? { userId: DEFAULT_USER_ID };
+    return field ? user[field] : user;
+  },
+);

package/apps/fabric/src/auth/request-user.ts

@@ -0,0 +1,4 @@
+export interface RequestUser {
+  userId: string;
+  email?: string;
+}