@agentlang/agentmanager 0.0.3

package/libs/agentcraft/src/interfaces/llm-provider.interface.ts

@@ -0,0 +1,18 @@
+import type {
+  LlmRequest,
+  LlmResponse,
+  ChatRequest,
+  ChatResponse,
+} from '../types/llm.types';
+
+export interface LlmProvider {
+  complete(request: LlmRequest): Promise<LlmResponse>;
+}
+
+export interface CraftLlmProvider {
+  chat(request: ChatRequest): Promise<ChatResponse>;
+  chatStream(
+    request: ChatRequest,
+    onChunk: (text: string) => void,
+  ): Promise<ChatResponse>;
+}

package/libs/agentcraft/src/prompts/assembly.prompt.ts

@@ -0,0 +1,104 @@
+import { kebabToPascalCase, pascalToKebabCase } from '../utils/text-utils';
+
+export function buildAssemblySystemPrompt(
+  projectName: string,
+  baseAppDirName?: string,
+): string {
+  const appName = kebabToPascalCase(projectName);
+
+  return `You are an Agentlang developer assembling the final application package.
+
+## Task
+
+Take the complete agentlang module code provided and produce a deployable application package consisting of four files:
+
+1. **src/core.al** — the complete agentlang module (all entities, relationships, events, workflows, and agents merged into a single module named \`${appName}.core\`)
+2. **config.al** — LLM configuration for the agents defined in the module
+3. **package.json** — npm package manifest for the application
+4. **README.md** — project overview with setup instructions and API usage examples
+
+## Module Naming
+
+The module in src/core.al MUST be declared as: \`module ${appName}.core\`
+
+## Output Format
+
+Output exactly four files (or more if resolver files are included), each preceded by a file header line:
+
+--- FILE: src/core.al ---
+
+<the complete agentlang module>
+
+--- FILE: config.al ---
+
+<LLM configuration>
+
+--- FILE: package.json ---
+
+<package manifest>
+
+--- FILE: README.md ---
+
+<documentation>
+
+### config.al format
+
+config.al is a JSON file (despite the .al extension). Generate a complete application configuration with service, store, and LLM settings:
+
+\`\`\`json
+{
+    "agentlang": {
+        "service": {
+            "port": "#js parseInt(process.env.SERVICE_PORT || '8080')"
+        },
+        "store": {
+            "type": "sqlite",
+            "dbname": "${projectName.toLowerCase().replace(/[^a-z0-9]/g, '_')}.db"
+        }
+    },
+    "agentlang.ai": [
+        {
+            "agentlang.ai/LLM": {
+                "name": "<llm_name_referenced_by_agents>",
+                "service": "anthropic",
+                "config": {
+                    "model": "claude-sonnet-4-5",
+                    "maxTokens": 21333,
+                    "enableThinking": false,
+                    "temperature": 0.7,
+                    "budgetTokens": 8192,
+                    "enablePromptCaching": true,
+                    "stream": false,
+                    "enableExtendedOutput": true
+                }
+            }
+        }
+    ]
+}
+\`\`\`
+
+Rules:
+- **Always include \`agentlang.service\`** with a configurable port (default 8080 via env var)
+- **Always include \`agentlang.store\`** with \`"type": "sqlite"\` and a \`"dbname"\` derived from the app name
+- Include one LLM entry for each unique \`llm\` name referenced by agents in the module
+- If agents don't specify an llm, include a default entry
+
+### package.json format
+
+\`\`\`json
+{
+  "name": "${pascalToKebabCase(appName)}",
+  "version": "0.1.0",
+  "dependencies": {
+    "agentlang": "*"${baseAppDirName ? `,\n    "${baseAppDirName}": "*"` : ''}
+  }
+}
+\`\`\`
+
+Rules:
+- The \`name\` field must be kebab-case (e.g. "lead-router")
+- Always include \`"agentlang": "*"\` as a dependency
+- Do NOT include \`@anthropic-ai/sdk\` — it is provided by the agentlang runtime${baseAppDirName ? `\n- Always include \`"${baseAppDirName}": "*"\` — this app depends on the baseline data model` : ''}
+
+If resolver files are provided in the context, include them as additional --- FILE: <path> --- sections.`;
+}

package/libs/agentcraft/src/prompts/codegen.prompt.ts

@@ -0,0 +1,162 @@
+import { PlanStepKind } from '../types/autonomous.types';
+import { getBuiltInExamplesSection } from './examples-provider';
+import { step6DataModelInstructions } from '../instructions/step6-data-model';
+import { step7WorkflowsInstructions } from '../instructions/step7-workflows';
+import { step8AgentsInstructions } from '../instructions/step8-agents';
+import {
+  kebabToPascalCase,
+  extractModuleName,
+  extractEntityNames,
+} from '../utils/text-utils';
+
+function extractSyntaxReference(
+  instructions: string,
+  fromHeading: string,
+): string {
+  const idx = instructions.indexOf(fromHeading);
+  if (idx === -1) return '';
+  return instructions
+    .slice(idx)
+    .replace(/<file>\??[^<]*<\/file>/g, '')
+    .trim();
+}
+
+const DATA_MODEL_SYNTAX = extractSyntaxReference(
+  step6DataModelInstructions,
+  '## Agentlang Data Model Syntax',
+);
+const WORKFLOW_SYNTAX = extractSyntaxReference(
+  step7WorkflowsInstructions,
+  '## Agentlang Event Syntax',
+);
+const AGENT_SYNTAX = extractSyntaxReference(
+  step8AgentsInstructions,
+  '## Agentlang Agent Syntax',
+);
+
+const SYNTAX_MAP: Record<string, string> = {
+  'data-model': DATA_MODEL_SYNTAX,
+  workflows: WORKFLOW_SYNTAX,
+  agents: AGENT_SYNTAX,
+};
+
+export function buildCodeGenSystemPrompt(
+  kind: PlanStepKind,
+  stepDescription: string,
+  previousCode: string,
+  kbContent: string,
+  projectName: string,
+  resolverContext?: string,
+  baselineDataModel?: string,
+): string {
+  const syntaxRef = SYNTAX_MAP[kind] ?? '';
+  const examples = getBuiltInExamplesSection();
+  const appName = kebabToPascalCase(projectName);
+  const moduleName = `${appName}.core`;
+
+  const parts: string[] = [
+    `You are an Agentlang developer generating ${kind} code for an application.`,
+    '',
+    `## Module Naming`,
+    '',
+    `Your module MUST be declared as: \`module ${moduleName}\``,
+    `The convention is \`module <AppName>.<file_name>\` where the file is src/core.al. Do NOT use "DataModel", "Core", or any other suffix — the module name must match the filename (core).`,
+    '',
+    '## Task',
+    '',
+    stepDescription,
+    '',
+    '## Application Specification (from Knowledge Base)',
+    '',
+    kbContent,
+    '',
+  ];
+
+  if (baselineDataModel) {
+    const baselineModuleName = extractModuleName(baselineDataModel);
+    const baselineEntityNames = extractEntityNames(baselineDataModel);
+    const entityList =
+      baselineEntityNames.length > 0
+        ? baselineEntityNames.join(', ')
+        : '(see code below)';
+
+    const qualifiedExamples =
+      baselineModuleName && baselineEntityNames.length > 0
+        ? baselineEntityNames
+            .map((e) => `\`${baselineModuleName}/${e}\``)
+            .join(', ')
+        : 'e.g. `BaselineModule/EntityName`';
+
+    parts.push(
+      '## Baseline Data Model (Shared Entities) — DO NOT COPY',
+      '',
+      `A separate baseline module provides these shared entities: ${entityList}`,
+      '',
+      `**CRITICAL RULES:**`,
+      `- Do NOT redefine, copy, or re-declare ANY of these entities: ${entityList}`,
+      `- Do NOT use the baseline module name (\`${baselineModuleName ?? 'baseline module'}\`) as your module name — your module MUST have its own unique name`,
+      `- Reference baseline entities using fully-qualified names: ${qualifiedExamples}`,
+      `- Use \`@ref()\` with fully-qualified names for relationships, e.g. \`leadId @ref(${baselineModuleName ?? 'Baseline'}/${baselineEntityNames[0] ?? 'Entity'})\``,
+      `- You MAY define your own local entities specific to this sub-app`,
+      '',
+      'Baseline code (for reference only — do NOT include any of this in your output):',
+      '',
+      '```agentlang',
+      baselineDataModel,
+      '```',
+      '',
+    );
+  }
+
+  if (previousCode) {
+    parts.push(
+      '## Previously Generated Code',
+      '',
+      'The following code has already been generated and validated. Build on it — do NOT redefine entities, events, workflows, or agents that already exist below.',
+      '',
+      '```agentlang',
+      previousCode,
+      '```',
+      '',
+    );
+  }
+
+  if (resolverContext) {
+    parts.push(
+      '## Resolver Context',
+      '',
+      resolverContext,
+      '',
+      'If resolver metadata is shown above:',
+      '- Do NOT redefine resolver entities (they exist in the resolver module)',
+      '- Do NOT write `resolver` blocks',
+      '- You MAY reference resolver entities using fully-qualified names (e.g. `Resolvers.Petstore/Pet`)',
+      '',
+    );
+  }
+
+  if (syntaxRef) {
+    parts.push(syntaxRef, '');
+  }
+
+  if (examples) {
+    parts.push(examples, '');
+  }
+
+  parts.push(
+    '## CRITICAL: Output Requirements',
+    '',
+    'Your response must contain ONLY valid agentlang code. Do not include any explanatory text, markdown formatting, or code fences.',
+    'The entire response must be parseable agentlang code starting with `module`.',
+    '',
+    'Your output is validated by the agentlang parser. If validation fails, you will receive the parse errors and must correct the code.',
+    '',
+    kind === 'data-model'
+      ? baselineDataModel
+        ? 'Output ONLY your own module declaration and your own LOCAL entity and relationship definitions. Do NOT include any entity from the baseline — those already exist in a separate file.'
+        : 'Output the complete module with all entity and relationship definitions.'
+      : 'Output ONLY the module declaration line and the new definitions. Do NOT repeat entities, relationships, events, workflows, or agents from the previously generated code — those will be merged automatically.',
+  );
+
+  return parts.join('\n');
+}

package/libs/agentcraft/src/prompts/decomposition.prompt.ts

@@ -0,0 +1,32 @@
+export const DECOMPOSITION_SYSTEM_PROMPT = `You are an application architect. Given a knowledge base describing an application, decompose it into:
+
+1. A **baseline data model** — the shared entity definitions used across the entire application (entities, attributes, relationships only — no workflows, no agents, no business logic)
+2. A list of **sub-apps** — independent functional areas that each become a complete application with their own workflows and agents
+
+## Rules
+
+- The baseline data model should contain ALL entities that are shared across sub-apps or that represent core domain concepts. Be comprehensive — it is better to include too many entities than too few.
+- Each sub-app should be a coherent functional area (e.g. "adoption-management", "inventory-tracking", "reporting").
+- Sub-apps will each get a copy of the baseline data model and should reference those entities rather than redefining them. Each sub-app may also define its own local entities specific to its domain.
+- Use PascalCase for sub-app names (e.g. "AdoptionManager", "InventoryTracker"). Choose concise, descriptive names — do NOT prefix with the project name.
+- The sub-app description should be detailed enough that a developer can build the sub-app from it — include the specific workflows, agents, and business rules relevant to that sub-app.
+- Aim for 2-5 sub-apps. Don't over-decompose — each sub-app should have meaningful functionality.
+
+## Output format
+
+Respond with ONLY a JSON object (no markdown fences, no explanatory text):
+
+{
+  "projectName": "pet-store",
+  "baselineDescription": "Generate entity definitions for the entire pet-store application: Pet (id, name, species, breed, age, status with values available/adopted/pending), Owner (id, name, email, phone, address), Adoption (id, petId referencing Pet, ownerId referencing Owner, applicationDate, status with values pending/approved/rejected, notes), ...",
+  "subApps": [
+    {
+      "name": "AdoptionManager",
+      "description": "Handles the pet adoption workflow. Adopters browse available pets and submit adoption applications. Staff review applications, check eligibility, and approve or reject them. When approved, the pet status changes to adopted and is linked to the owner. Includes: adoption application workflow, eligibility checking, approval/rejection process, adoption history tracking."
+    },
+    {
+      "name": "InventoryTracker",
+      "description": "Manages the pet store inventory and supplies. Track food, medicine, toys, and other supplies. Generate low-stock alerts. Record purchases and usage. Includes: inventory CRUD, stock level monitoring, reorder alerts, purchase recording."
+    }
+  ]
+}`;

package/libs/agentcraft/src/prompts/examples-provider.ts

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+// docs/examples/ is two levels up from dist/prompts/ (or src/prompts/)
+const EXAMPLES_DIR = path.resolve(__dirname, '..', '..', 'docs', 'examples');
+
+export interface BuiltInExample {
+  filename: string;
+  title: string;
+  content: string;
+}
+
+let cachedExamples: BuiltInExample[] | null = null;
+
+function loadExamples(): BuiltInExample[] {
+  if (cachedExamples) return cachedExamples;
+
+  cachedExamples = [];
+  let files: string[];
+  try {
+    files = fs.readdirSync(EXAMPLES_DIR);
+  } catch {
+    return cachedExamples;
+  }
+
+  for (const file of files) {
+    if (!file.endsWith('.al')) continue;
+    const filePath = path.join(EXAMPLES_DIR, file);
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      // Extract title from first comment line: "// Blog Application — ..."
+      const firstLine = content.split('\n')[0] ?? '';
+      const title = firstLine.replace(/^\/\/\s*/, '').trim() || file;
+      cachedExamples.push({ filename: file, title, content });
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  return cachedExamples;
+}
+
+/**
+ * Returns a formatted reference section containing all built-in Agentlang
+ * example applications. Intended to be appended to system prompts for
+ * code generation steps (6-9).
+ */
+export function getBuiltInExamplesSection(): string {
+  const examples = loadExamples();
+  if (examples.length === 0) return '';
+
+  const sections = examples.map(
+    (ex) => `### ${ex.title}\n\n\`\`\`agentlang\n${ex.content}\`\`\``,
+  );
+
+  return `
+
+## Reference: Built-in Agentlang Examples
+
+The following are complete, working Agentlang applications. Study these carefully and follow their patterns when generating code. These examples demonstrate correct syntax for entities, relationships, workflows, events, agents, queries, and more.
+
+${sections.join('\n\n')}`;
+}

package/libs/agentcraft/src/prompts/planning.prompt.ts

@@ -0,0 +1,52 @@
+export const PLANNING_SYSTEM_PROMPT = `You are an Agentlang application architect. Given a knowledge base describing an application, produce a step-by-step generation plan as a JSON object.
+
+## Available step kinds
+
+- "data-model": Generate entity definitions with attributes, relationships, and type annotations
+- "workflows": Generate event and workflow definitions for custom business logic
+- "agents": Generate AI agent definitions with tools for natural-language interaction
+- "resolver": Generate or reference a resolver for external API integration
+- "assembly": Combine all generated code into the final deployable application files
+
+## Rules
+
+1. "data-model" should be the first code-generation step
+2. "workflows" depends on "data-model"
+3. "agents" depends on "workflows" (or "data-model" if there are no custom workflows)
+4. "assembly" is always the LAST step and depends on all other steps
+5. Only include "resolver" steps if the KB explicitly describes how to generate or use a resolver (e.g. an API spec URL, endpoint descriptions, or an existing resolver repo). If the KB has no resolver information, do NOT add resolver steps — even if you think one might be useful.
+6. For resolver steps with action "generate", include specSource (URL or file path to the API spec) and a description. For action "use-existing", include existingResolverRepo.
+7. Each step gets a unique id: "step-1", "step-2", etc.
+8. dependsOn lists the ids of prerequisite steps
+9. The description for each step should be specific and detailed — describe exactly what entities, workflows, or agents to generate based on the KB content
+
+## Output format
+
+Respond with ONLY a JSON object (no markdown fences, no explanatory text):
+
+{
+  "projectName": "AppName",
+  "summary": "One-paragraph overview of the application",
+  "steps": [
+    {
+      "id": "step-1",
+      "kind": "data-model",
+      "title": "Define core entities",
+      "description": "Detailed instructions...",
+      "dependsOn": []
+    },
+    {
+      "id": "step-2",
+      "kind": "resolver",
+      "title": "Generate Petstore resolver",
+      "description": "...",
+      "dependsOn": ["step-1"],
+      "resolver": {
+        "name": "petstore",
+        "description": "Petstore API integration",
+        "specSource": "https://petstore.swagger.io/v2/swagger.json",
+        "action": "generate"
+      }
+    }
+  ]
+}`;