@agentlang/agentmanager 0.0.3

package/libs/agentcraft/src/services/pipeline-steps.service.ts

@@ -0,0 +1,126 @@
+import { Injectable } from '@nestjs/common';
+import { PipelineStep, StepDefinition } from '../types/pipeline.types';
+
+export const STEP_DEFINITIONS: StepDefinition[] = [
+  {
+    id: PipelineStep.Requirements,
+    name: 'Capture Requirements',
+    order: 1,
+    role: 'Senior Product Manager',
+    outputFile: 'requirementsAnalysis.md',
+    requiresValidation: false,
+    inputFiles: [],
+  },
+  {
+    id: PipelineStep.RequirementsDoc,
+    name: 'Requirements Document',
+    order: 2,
+    role: 'Technical Writer',
+    outputFile: 'requirementsDoc.md',
+    requiresValidation: false,
+    inputFiles: ['requirementsAnalysis.md'],
+  },
+  {
+    id: PipelineStep.DataModelSpec,
+    name: 'Core Objects Identification',
+    order: 3,
+    role: 'Domain Modeler',
+    outputFile: 'coreObjects.md',
+    requiresValidation: false,
+    inputFiles: ['requirementsAnalysis.md'],
+  },
+  {
+    id: PipelineStep.UISpec,
+    name: 'UI Specification',
+    order: 4,
+    role: 'UI Designer',
+    outputFile: 'uiSpec.md',
+    requiresValidation: false,
+    inputFiles: ['requirementsAnalysis.md', 'coreObjects.md'],
+  },
+  {
+    id: PipelineStep.APISpec,
+    name: 'API Specification',
+    order: 5,
+    role: 'API Architect',
+    outputFile: 'apiSpec.md',
+    requiresValidation: false,
+    inputFiles: ['requirementsAnalysis.md', 'coreObjects.md', 'uiSpec.md'],
+  },
+  {
+    id: PipelineStep.DataModel,
+    name: 'Data Model Generation',
+    order: 6,
+    role: 'Agentlang Developer',
+    outputFile: 'dataModel.al',
+    requiresValidation: true,
+    inputFiles: ['requirementsAnalysis.md', 'coreObjects.md', 'apiSpec.md'],
+  },
+  {
+    id: PipelineStep.Workflows,
+    name: 'Workflow Generation',
+    order: 7,
+    role: 'Agentlang Developer',
+    outputFile: 'workflows.al',
+    requiresValidation: true,
+    inputFiles: [
+      'requirementsAnalysis.md',
+      'coreObjects.md',
+      'apiSpec.md',
+      'dataModel.al',
+    ],
+  },
+  {
+    id: PipelineStep.Agents,
+    name: 'Agent Generation',
+    order: 8,
+    role: 'Agentlang Developer',
+    outputFile: 'agents.al',
+    requiresValidation: true,
+    inputFiles: ['requirementsAnalysis.md', 'workflows.al'],
+  },
+  {
+    id: PipelineStep.Assemble,
+    name: 'Final Assembly',
+    order: 9,
+    role: 'Agentlang Developer',
+    outputFile: 'finalApp.md',
+    requiresValidation: true,
+    inputFiles: ['agents.al'],
+  },
+  {
+    id: PipelineStep.Tests,
+    name: 'Test Generation',
+    order: 10,
+    role: 'QA Engineer',
+    outputFile: 'tests.js',
+    requiresValidation: false,
+    inputFiles: ['agents.al', 'finalApp.md'],
+  },
+];
+
+@Injectable()
+export class PipelineStepsService {
+  readonly definitions = STEP_DEFINITIONS;
+  readonly totalSteps = STEP_DEFINITIONS.length;
+
+  getDefinition(step: PipelineStep): StepDefinition {
+    const def = STEP_DEFINITIONS.find((s) => s.id === step);
+    if (!def) throw new Error(`Unknown step: ${step}`);
+    return def;
+  }
+
+  getByOrder(order: number): StepDefinition | undefined {
+    return STEP_DEFINITIONS.find((s) => s.order === order);
+  }
+
+  getNext(step: PipelineStep): StepDefinition | undefined {
+    const current = this.getDefinition(step);
+    return this.getByOrder(current.order + 1);
+  }
+
+  getPrevious(step: PipelineStep): StepDefinition | undefined {
+    const current = this.getDefinition(step);
+    return this.getByOrder(current.order - 1);
+  }
+}

package/libs/agentcraft/src/services/planner.service.ts

@@ -0,0 +1,189 @@
+import { Injectable, Inject, Optional, Logger } from '@nestjs/common';
+import { CRAFT_LLM_PROVIDER } from '../constants';
+import { CraftLlmProvider } from '../interfaces/llm-provider.interface';
+import { Plan, PlanStep } from '../types/autonomous.types';
+import { PLANNING_SYSTEM_PROMPT } from '../prompts/planning.prompt';
+
+@Injectable()
+export class PlannerService {
+  private readonly logger = new Logger(PlannerService.name);
+
+  constructor(
+    @Inject(CRAFT_LLM_PROVIDER)
+    @Optional()
+    private readonly llm: CraftLlmProvider | null,
+  ) {}
+
+  async generatePlan(
+    kbContent: string,
+    userMessage: string,
+    projectName: string,
+  ): Promise<Plan> {
+    if (!this.llm) throw new Error('LLM provider not configured');
+
+    const userPrompt = `## User Request\n\n${userMessage}\n\n## Knowledge Base\n\n${kbContent}`;
+
+    const response = await this.llm.chat({
+      system: PLANNING_SYSTEM_PROMPT,
+      messages: [{ role: 'user', content: userPrompt }],
+    });
+
+    const text = response.content
+      .filter((b) => b.type === 'text')
+      .map((b) => b.text)
+      .join('');
+
+    const plan = this.parsePlanResponse(text, projectName);
+    this.validatePlan(plan);
+    return plan;
+  }
+
+  parsePlanResponse(response: string, fallbackName: string): Plan {
+    let json = response.trim();
+    json = json.replace(/^```(?:json)?\s*\n?/i, '').replace(/\n?```\s*$/i, '');
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(json);
+    } catch {
+      throw new Error(
+        `Failed to parse plan JSON from LLM response.\nResponse starts with: ${response.slice(0, 200)}`,
+      );
+    }
+
+    if (!parsed || typeof parsed !== 'object') {
+      throw new Error('Plan response is not a JSON object.');
+    }
+
+    const obj = parsed as Record<string, unknown>;
+
+    const projectName =
+      typeof obj.projectName === 'string' ? obj.projectName : fallbackName;
+    const summary = typeof obj.summary === 'string' ? obj.summary : '';
+
+    if (!Array.isArray(obj.steps) || obj.steps.length === 0) {
+      throw new Error('Plan must contain at least one step.');
+    }
+
+    const steps: PlanStep[] = obj.steps.map((s: unknown, i: number) => {
+      if (!s || typeof s !== 'object') {
+        throw new Error(`Step ${i} is not an object.`);
+      }
+      const step = s as Record<string, unknown>;
+      return {
+        id: typeof step.id === 'string' ? step.id : `step-${i + 1}`,
+        kind: this.validateStepKind(step.kind, i),
+        title: typeof step.title === 'string' ? step.title : `Step ${i + 1}`,
+        description:
+          typeof step.description === 'string' ? step.description : '',
+        dependsOn: Array.isArray(step.dependsOn)
+          ? step.dependsOn.filter((d): d is string => typeof d === 'string')
+          : [],
+        resolver: step.resolver
+          ? this.parseResolverDirective(step.resolver)
+          : undefined,
+      };
+    });
+
+    return { projectName, summary, steps };
+  }
+
+  private validateStepKind(kind: unknown, index: number): PlanStep['kind'] {
+    const valid = ['data-model', 'workflows', 'agents', 'resolver', 'assembly'];
+    if (typeof kind === 'string' && valid.includes(kind)) {
+      return kind as PlanStep['kind'];
+    }
+    throw new Error(
+      `Step ${index} has invalid kind: ${String(kind)}. Must be one of: ${valid.join(', ')}`,
+    );
+  }
+
+  private parseResolverDirective(obj: unknown): PlanStep['resolver'] {
+    if (!obj || typeof obj !== 'object') return undefined;
+    const r = obj as Record<string, unknown>;
+    return {
+      name: typeof r.name === 'string' ? r.name : 'resolver',
+      description: typeof r.description === 'string' ? r.description : '',
+      specSource: typeof r.specSource === 'string' ? r.specSource : '',
+      action: r.action === 'use-existing' ? 'use-existing' : 'generate',
+      existingResolverRepo:
+        typeof r.existingResolverRepo === 'string'
+          ? r.existingResolverRepo
+          : undefined,
+    };
+  }
+
+  validatePlan(plan: Plan): void {
+    const ids = new Set(plan.steps.map((s) => s.id));
+
+    for (const step of plan.steps) {
+      for (const dep of step.dependsOn) {
+        if (!ids.has(dep)) {
+          throw new Error(
+            `Step "${step.id}" depends on unknown step "${dep}".`,
+          );
+        }
+      }
+    }
+
+    const assemblySteps = plan.steps.filter((s) => s.kind === 'assembly');
+    if (assemblySteps.length > 1) {
+      throw new Error('Plan must have at most one assembly step.');
+    }
+    if (assemblySteps.length === 1) {
+      const assemblyId = assemblySteps[0].id;
+      const afterAssembly = plan.steps.some(
+        (s) => s.id !== assemblyId && s.dependsOn.includes(assemblyId),
+      );
+      if (afterAssembly) {
+        throw new Error(
+          'No step can depend on the assembly step — it must be the last step.',
+        );
+      }
+    }
+
+    const completed = new Set<string>();
+    const remaining = new Set(ids);
+    let progress = true;
+    while (remaining.size > 0 && progress) {
+      progress = false;
+      for (const id of remaining) {
+        const step = plan.steps.find((s) => s.id === id)!;
+        if (step.dependsOn.every((d) => completed.has(d))) {
+          completed.add(id);
+          remaining.delete(id);
+          progress = true;
+        }
+      }
+    }
+    if (remaining.size > 0) {
+      throw new Error(
+        `Circular dependency detected among steps: ${[...remaining].join(', ')}`,
+      );
+    }
+  }
+
+  getExecutionOrder(steps: PlanStep[]): PlanStep[] {
+    const completed = new Set<string>();
+    const ordered: PlanStep[] = [];
+    const remaining = [...steps];
+
+    while (remaining.length > 0) {
+      const ready = remaining.filter((s) =>
+        s.dependsOn.every((dep) => completed.has(dep)),
+      );
+      if (ready.length === 0) {
+        throw new Error(
+          'Circular dependency in plan — cannot determine execution order.',
+        );
+      }
+      for (const step of ready) {
+        ordered.push(step);
+        completed.add(step.id);
+        remaining.splice(remaining.indexOf(step), 1);
+      }
+    }
+
+    return ordered;
+  }
+}

package/libs/agentcraft/src/services/readme-generator.service.ts

@@ -0,0 +1,229 @@
+import { Injectable, Inject, Optional, Logger } from '@nestjs/common';
+import { CRAFT_LLM_PROVIDER } from '../constants';
+import { CraftLlmProvider } from '../interfaces/llm-provider.interface';
+import type { ToolDefinition } from '../types/llm.types';
+import {
+  DecompositionResult,
+  DesignResult,
+  RequirementsResult,
+  GeneratedSources,
+} from '../types/architect.types';
+
+const README_TOOL: ToolDefinition = {
+  name: 'produce_readme',
+  description:
+    'Produce a global README.md for a multi-app project that explains the business logic, sub-app architecture, and end-to-end flows.',
+  inputSchema: {
+    type: 'object',
+    required: ['readme'],
+    additionalProperties: false,
+    properties: {
+      readme: {
+        type: 'string',
+        description: 'The full markdown content of the README.',
+      },
+    },
+  },
+};
+
+@Injectable()
+export class ReadmeGeneratorService {
+  private readonly logger = new Logger(ReadmeGeneratorService.name);
+
+  constructor(
+    @Inject(CRAFT_LLM_PROVIDER)
+    @Optional()
+    private readonly llm: CraftLlmProvider | null,
+  ) {}
+
+  async generateReadme(
+    projectName: string,
+    decomposition: DecompositionResult,
+    design: DesignResult,
+    requirements: RequirementsResult,
+    sources?: GeneratedSources,
+  ): Promise<string> {
+    if (!this.llm) throw new Error('LLM provider not configured');
+
+    this.logger.log(
+      `Generating global README for "${projectName}" (${design.subApps.length} sub-apps)`,
+    );
+
+    const systemPrompt = this.buildReadmePrompt(
+      projectName,
+      decomposition,
+      design,
+      requirements,
+      sources,
+    );
+
+    const response = await this.llm.chat({
+      system: systemPrompt,
+      messages: [
+        {
+          role: 'user',
+          content:
+            'Generate the global README.md for this project. Make sure the end-to-end flows are detailed and span multiple sub-apps.',
+        },
+      ],
+      maxTokens: 16384,
+      tools: [README_TOOL],
+      toolChoice: { type: 'tool', name: 'produce_readme' },
+      cacheControl: true,
+    });
+
+    this.logger.log(
+      `LLM response received (toolCalls: ${response.toolCalls?.length ?? 0})`,
+    );
+
+    const toolCall = response.toolCalls?.[0];
+    if (toolCall) {
+      const input = toolCall.input as Record<string, unknown>;
+      const readme = typeof input.readme === 'string' ? input.readme : '';
+      if (!readme) {
+        throw new Error('README tool call returned empty content.');
+      }
+      this.logger.log(`README generated (${readme.length} chars)`);
+      return readme;
+    }
+
+    const text = response.content
+      .filter((b) => b.type === 'text')
+      .map((b) => b.text)
+      .join('');
+
+    if (text.trim()) {
+      this.logger.log(
+        `README extracted from text response (${text.length} chars)`,
+      );
+      return text.trim();
+    }
+
+    throw new Error(
+      'README generation did not return content. LLM response: ' +
+        text.slice(0, 200),
+    );
+  }
+
+  private buildReadmePrompt(
+    projectName: string,
+    decomposition: DecompositionResult,
+    design: DesignResult,
+    requirements: RequirementsResult,
+    sources?: GeneratedSources,
+  ): string {
+    const subAppList = decomposition.subApps
+      .map((s) => `- **${s.name}**: ${s.description}`)
+      .join('\n');
+
+    const baselineEntities = design.baseline.entities
+      .map((e) => `- **${e.name}**: ${e.description}`)
+      .join('\n');
+
+    const subAppDesigns = design.subApps
+      .map((s) => {
+        const entities = s.entities.map((e) => `  - ${e.name}`).join('\n');
+        const workflows = s.workflows
+          .map((w) => `  - **${w.name}**: ${w.description}`)
+          .join('\n');
+        const agents = s.agents
+          .map((a) => `  - **${a.name}**: ${a.goal}`)
+          .join('\n');
+        return `### ${s.appName} (\`${s.dirName}/\`)
+Entities:\n${entities || '  (none)'}
+Workflows:\n${workflows || '  (none)'}
+Agents:\n${agents || '  (none)'}`;
+      })
+      .join('\n\n');
+
+    const reqSummaries = requirements.subApps
+      .map((r) => `### ${r.appName}\n${r.requirements}`)
+      .join('\n\n');
+
+    return `You are a technical writer. Given the architecture of a multi-app project, produce a comprehensive global README.md.
+
+## Project: ${projectName}
+
+## Decomposition rationale
+
+The application was decomposed into a shared baseline data model and the following sub-apps:
+${subAppList}
+
+Baseline description: ${decomposition.baselineDescription}
+
+## Baseline entities
+
+${baselineEntities}
+
+## Sub-app designs
+
+${subAppDesigns}
+
+## Detailed requirements
+
+### Baseline
+${requirements.baseline.requirements}
+
+${reqSummaries}
+
+${sources ? this.buildSourcesSection(sources) : ''}
+
+---
+
+## README structure
+
+Write the README with these sections:
+
+1. **Project title and overview** — what this system does in business terms.
+2. **Architecture overview** — explain the baseline + sub-app decomposition.
+3. **Shared data model** — list the baseline entities.
+4. **Sub-apps** — for each sub-app: purpose, entities, workflows, agents.
+5. **End-to-end business flows** — 2-4 concrete scenarios spanning multiple sub-apps with curl examples.
+6. **Running the system** — setup instructions.
+
+## Agentlang API format
+
+Each sub-app exposes a REST API:
+
+\`\`\`
+POST http://localhost:<port>/<Module.core>/<EventOrEntityName>
+Content-Type: application/json
+
+{ "field1": "value1" }
+\`\`\`
+
+## Rules
+
+- Write clear, developer-friendly markdown.
+- Be specific — use actual entity, event, and agent names.
+- ALL curl examples MUST use the agentlang API format.
+- Do NOT invent REST-style URLs like \`/api/v1/...\`.
+
+Call the \`produce_readme\` tool with the complete README content.`;
+  }
+
+  private buildSourcesSection(sources: GeneratedSources): string {
+    const parts: string[] = [
+      '## Generated source code (ACTUAL schemas — use these for curl examples)',
+      '',
+    ];
+
+    if (sources.baseline) {
+      parts.push(`### Baseline (\`${sources.baseline.dirName}/src/core.al\`)`);
+      parts.push('```');
+      parts.push(sources.baseline.code.trim());
+      parts.push('```');
+      parts.push('');
+    }
+
+    for (const sub of sources.subApps) {
+      parts.push(`### Sub-app (\`${sub.dirName}/src/core.al\`)`);
+      parts.push('```');
+      parts.push(sub.code.trim());
+      parts.push('```');
+      parts.push('');
+    }
+
+    return parts.join('\n');
+  }
+}

package/libs/agentcraft/src/services/registry-client.service.d.ts

@@ -0,0 +1,14 @@
+import { ConfigService } from '@nestjs/config';
+import { RegistrySearchResult } from '../types/resolver.types';
+export declare class RegistryClientService {
+  private readonly configService?;
+  constructor(configService?: ConfigService | undefined);
+  search(query: string): Promise<RegistrySearchResult[]>;
+  clone(repoSlug: string, targetDir: string): Promise<void>;
+  private fetchListing;
+  private fetchEntry;
+  private extractServicePrefix;
+  private tokenizeQuery;
+  private scoreEntry;
+  private filterByPrefix;
+}