@agentlang/agentmanager 0.0.3

package/README.md

@@ -0,0 +1,122 @@
+# AgentManager Monorepo
+
+A NestJS monorepo for building and managing AI Employees written
+in [Agentlang](https://github.com/agentlang-ai/agentlang). It contains multiple applications and shared libraries.
+
+## Applications
+
+### [AgentManager](apps/agentmanager/)
+
+REST API for managing a swarm of AI Employees. Handles employee registration, source code management, deployment tracking, inter-employee messaging (inboxes), and LLM-powered semantic discovery of employees by capability.
+
+**Port:** 3001
+
+### [AgentCraft](apps/agentcraft/)
+
+LLM-powered code generation service that produces complete Agentlang applications from natural-language descriptions. Supports interactive sessions, spec-driven resolver generation, autonomous fire-and-forget runs, and a continuous signal-driven architect loop.
+
+**Port:** 3002
+
+### [Knowledge](apps/knowledge/)
+
+Knowledge management API with document ingestion, graph visualization, and AI recommendations. Features topic management, document lifecycle, vector search (LanceDB), graph queries (Neo4j), and sync connections to external providers.
+
+**Port:** 3003
+
+### [Fabric](apps/fabric/)
+
+Deployment orchestration service with multi-provider support (Docker, EKS, PM2). Manages environments, versions, runtime deployments, and deployment events with database persistence.
+
+**Port:** 3004
+
+### [Monolith](apps/monolith/)
+
+Unified application that combines multiple services into a single deployable unit for local development and testing.
+
+**Port:** 3005
+
+## Shared Libraries
+
+| Library                 | Path                     | Description                                                                          |
+| ----------------------- | ------------------------ | ------------------------------------------------------------------------------------ |
+| `@app/project-provider` | `libs/project-provider/` | Filesystem-backed registry, employee code provider, knowledge base, and inbox client |
+| `@app/agentcraft`       | `libs/agentcraft/`       | Core generation engine — LLM pipeline, prompts, planner, executor, architect loop    |
+| `@app/auth`             | `libs/auth/`             | Authentication and authorization shared module                                       |
+| `@app/common`           | `libs/common/`           | Shared database infrastructure, filters, interceptors, and common utilities          |
+
+## Tech Stack
+
+- **NestJS 11** with **Fastify**
+- **TypeScript** compiled with **SWC**
+- **Zod** + `nestjs-zod` for validation
+- **Anthropic Claude** / **OpenAI** for LLM features
+- **Agentlang** runtime (`agentlang` npm package)
+- **Prisma** for database ORM
+- **LanceDB** for vector storage
+- **Neo4j** for graph database
+- **AWS SDK** for S3 and Cognito
+- Filesystem-backed storage (no database required for some apps)
+
+## Getting Started
+
+```bash
+# Install dependencies
+npm install
+
+# Start AgentManager (port 3001)
+npm run start:dev
+
+# Start AgentCraft (port 3002)
+npm run start:craft:dev
+
+# Start Knowledge (port 3003)
+npm run start:knowledge:dev
+
+# Build all applications
+npm run build
+```
+
+## Project Structure
+
+```
+agentmanager-mono/
+├── apps/
+│   ├── agentmanager/       # Swarm management API
+│   ├── agentcraft/         # LLM code generation service
+│   ├── knowledge/          # Knowledge management with ingestion
+│   ├── fabric/             # Deployment orchestration
+│   └── monolith/           # Unified application
+├── libs/
+│   ├── project-provider/   # Registry, code, inbox providers
+│   ├── agentcraft/         # Generation engine & prompts
+│   ├── auth/               # Authentication module
+│   └── common/             # Shared database & utilities
+├── nest-cli.json           # NestJS monorepo configuration
+├── package.json
+└── tsconfig.json
+```
+
+## Scripts
+
+| Script                        | Description                          |
+| ----------------------------- | ------------------------------------ |
+| `npm run start:dev`           | Start AgentManager in watch mode     |
+| `npm run start:craft:dev`     | Start AgentCraft in watch mode       |
+| `npm run start:knowledge:dev` | Start Knowledge app in watch mode    |
+| `npm run build`               | Build all applications and libraries |
+| `npm run build:knowledge`     | Build Knowledge app only             |
+| `npm test`                    | Run unit tests                       |
+| `npm run test:knowledge`      | Run Knowledge app tests              |
+| `npm run test:e2e`            | Run end-to-end tests                 |
+| `npm run test:cov`            | Run tests with coverage              |
+| `npm run lint`                | Lint and auto-fix                    |
+| `npm run lint:check`          | Check linting without fixing         |
+| `npm run format`              | Format with Prettier                 |
+| `npm run format:check`        | Check formatting                     |
+| `npm run typecheck`           | TypeScript type checking             |
+
+## Development Notes
+
+- The `docs/` folder is for local documentation only and is ignored by git
+- Always run `npm run format` before committing
+- The codebase has pre-existing lint errors; focus on not introducing new ones

package/apps/agentcraft/README.md

@@ -0,0 +1,237 @@
+# AgentCraft
+
+An LLM-powered code generation service that automates the creation of applications written in the [Agentlang](https://github.com/niclaswebb/agentlang) language. AgentCraft takes a natural-language description of what you want and produces complete Agentlang projects — data models, workflows, agents, and all supporting files.
+
+## Overview
+
+AgentCraft offers multiple modes of operation:
+
+- **Sessions** — Interactive, step-by-step project generation. The LLM proposes ideas and actions; you review and guide the process via SSE-streamed events.
+- **Resolver** — Generate an Agentlang app from an OpenAPI/external spec URL. Supports browsing and installing from the Agentlang registry.
+- **Autonomous** — Fire-and-forget generation. Supply a message, project name, and knowledge base path; AgentCraft runs a full pipeline and produces the output directory.
+- **Architect** — A continuous signal-processing loop. Ingest signals (requirements changes, bug reports, etc.) for a project, and the Architect autonomously plans and generates code in response.
+
+## Architecture
+
+```
+apps/agentcraft/src/
+├── config/             # App configuration (env vars)
+├── common/             # Shared exception filters
+├── sessions/           # Interactive project-generation sessions
+├── resolver/           # Spec-driven generation + registry integration
+├── autonomous/         # Fire-and-forget full pipeline runs
+├── architect/          # Signal-driven continuous generation loop
+└── main.ts             # Fastify bootstrap (port 3002)
+```
+
+### Shared Libraries
+
+- **`@app/agentcraft`** — Core generation engine containing the LLM pipeline, prompts, and services:
+  - **Pipeline**: planning, decomposition, codegen, assembly phases
+  - **Prompts**: system prompts for each generation phase, Agentlang semantics guide, example provider
+  - **Services**: planner, decomposer, design/requirements/UI-blueprint generators, executor, output parser/writer
+  - **Architect loop**: signal queue with debouncing, phase retries, and sub-app generation
+  - **Autonomous runner**: end-to-end pipeline orchestration with knowledge-base loading
+  - **LLM adapters**: Anthropic Claude and OpenAI support
+- **`@app/project-provider`** — Filesystem-backed registry, employee code provider, knowledge base, and inbox client
+
+## API Endpoints
+
+All routes are prefixed with `/api`. CORS is enabled.
+
+### Sessions (Interactive Generation)
+
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | `/api/projects` | Create a new generation session |
+| GET | `/api/projects/:id/status` | Get session status |
+| GET | `/api/projects/:id/output` | Get generated output |
+| GET | `/api/projects/:id/steps` | Get pipeline steps |
+| POST | `/api/projects/:id/idea` | Submit an idea for the LLM to work with |
+| POST | `/api/projects/:id/action` | Submit an action decision |
+| GET | `/api/projects/:id/files` | List generated files |
+| GET | `/api/projects/:id/files/*` | Get a specific generated file |
+| SSE | `/api/projects/:id/stream` | Real-time event stream |
+
+### Resolver (Spec-Driven Generation)
+
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | `/api/resolvers` | Create a resolver session from a spec URL |
+| GET | `/api/resolvers/:id/status` | Get resolver status |
+| GET | `/api/resolvers/:id/output` | Get generated output |
+| POST | `/api/resolvers/:id/action` | Submit an action decision |
+| GET | `/api/resolvers/registry/search?q=...` | Search the Agentlang registry |
+| POST | `/api/resolvers/registry/install` | Install a project from the registry |
+| SSE | `/api/resolvers/:id/stream` | Real-time event stream |
+
+### Autonomous (Fire-and-Forget)
+
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | `/api/autonomous` | Start an autonomous generation run |
+| GET | `/api/autonomous/:runId/status` | Poll run status |
+| POST | `/api/autonomous/watch` | Start watching a KB directory for changes |
+| GET | `/api/autonomous/watch` | Get current watch status |
+| DELETE | `/api/autonomous/watch` | Stop watching |
+
+### Architect (Signal-Driven Loop)
+
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | `/api/projects/:projectId/architect` | Ingest a signal (requirement, bug, etc.) |
+| GET | `/api/projects/:projectId/architect/status` | Get architect loop status |
+| GET | `/api/projects/:projectId/architect/history` | Get processed signal history |
+| SSE | `/api/projects/:projectId/architect/stream` | Real-time event stream |
+
+## Configuration
+
+All configuration is via environment variables:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `CRAFT_PORT` | `3002` | Server port |
+| `CRAFT_OUTPUT_DIR` | `.` | Base directory for generated project output |
+| `REGISTRY_PATH` | `./registry` | Path to the Agentlang registry |
+| `INBOXES_PATH` | `./inboxes` | Path for inbox message storage |
+
+### LLM Configuration
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `CRAFT_PROVIDER` | `anthropic` | LLM provider (`anthropic` or `openai`) |
+| `CRAFT_MODEL` | `claude-sonnet-4-6` / `gpt-4o` | Model to use |
+| `CRAFT_API_KEY` | — | API key (falls back to `ANTHROPIC_API_KEY` or `OPENAI_API_KEY`) |
+
+### Architect Tuning
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `ARCHITECT_DEBOUNCE_MS` | `5000` | Debounce window before processing queued signals |
+| `ARCHITECT_PHASE_RETRIES` | `2` | Max retries per pipeline phase |
+| `ARCHITECT_SUBAPP_RETRIES` | `2` | Max retries for sub-app generation |
+
+## Generation Pipeline
+
+AgentCraft uses a multi-phase LLM pipeline to produce Agentlang projects:
+
+1. **Planning** — Understand the user's requirements and produce a high-level plan
+2. **Decomposition** — Break the plan into sub-apps / modules
+3. **Design generation** — Produce data models, workflows, and agent definitions
+4. **Code generation** — Generate Agentlang source files (`.al` modules, `package.al`, `config.edn`)
+5. **Assembly** — Combine outputs, validate, and write to the output directory
+
+Each phase has dedicated prompts that embed the Agentlang semantics guide and reference examples from the registry.
+
+## Tech Stack
+
+- **Runtime**: Node.js + NestJS with Fastify
+- **Validation**: Zod via `nestjs-zod`
+- **Build**: SWC (fast TypeScript compilation)
+- **LLM**: Anthropic Claude (primary) / OpenAI (supported)
+- **Streaming**: Server-Sent Events (SSE) for real-time progress
+- **Storage**: Filesystem-backed (no database required)
+
+## Getting Started
+
+```bash
+# From the monorepo root
+npm install
+
+# Set your LLM API key
+export ANTHROPIC_API_KEY=sk-ant-...
+
+# Start AgentCraft
+npm run start:craft
+```
+
+The server starts on port **3002** by default.
+
+## Usage
+
+### Triggering an Autonomous Workflow
+
+Start a fire-and-forget generation run by POSTing to `/api/autonomous`:
+
+```bash
+curl -X POST http://localhost:3002/api/autonomous \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "Build a customer support ticketing system with agents that triage, assign, and resolve tickets",
+    "userId": "user-1",
+    "projectName": "support-desk",
+    "kbPath": "/path/to/your/knowledge-base"
+  }'
+```
+
+Response (`202 Accepted`):
+
+```json
+{
+  "runId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+  "projectName": "support-desk",
+  "status": "started"
+}
+```
+
+Poll for progress using the returned `runId`:
+
+```bash
+curl http://localhost:3002/api/autonomous/a1b2c3d4-e5f6-7890-abcd-ef1234567890/status
+```
+
+#### Optional fields
+
+| Field | Description |
+|-------|-------------|
+| `outputDir` | Override the output directory (defaults to `CRAFT_OUTPUT_DIR`) |
+| `provider` | LLM provider override (`anthropic` or `openai`) |
+| `model` | Model override (e.g. `claude-opus-4-6`) |
+| `apiKey` | Per-request API key override |
+| `inboxUrl` | URL for inbox message delivery |
+
+### Watching a KB Directory
+
+Start watching a root knowledge-base directory. When a subdirectory is added or its files change, AgentCraft automatically triggers an autonomous run for that project:
+
+```bash
+curl -X POST http://localhost:3002/api/autonomous/watch \
+  -H "Content-Type: application/json" \
+  -d '{
+    "kbPath": "/path/to/kb-root",
+    "userId": "user-1"
+  }'
+```
+
+Response (`202 Accepted`):
+
+```json
+{
+  "active": true,
+  "kbPath": "/path/to/kb-root",
+  "userId": "user-1",
+  "message": "Generate an Agentlang app from the knowledge base",
+  "pollIntervalMs": 3000,
+  "outputDir": ".",
+  "triggeredRuns": [],
+  "startedAt": "2026-03-13T12:00:00.000Z"
+}
+```
+
+Now drop a folder (e.g. `my-crm/`) with `.md` or `.txt` files into `/path/to/kb-root` — AgentCraft will detect it and kick off a generation run automatically. Check watch status or triggered runs:
+
+```bash
+# Watch status
+curl http://localhost:3002/api/autonomous/watch
+
+# Stop watching
+curl -X DELETE http://localhost:3002/api/autonomous/watch
+```
+
+#### Optional fields
+
+| Field | Description |
+|-------|-------------|
+| `message` | Custom prompt for generation (default: "Generate an Agentlang app from the knowledge base") |
+| `pollIntervalMs` | How often to poll for changes in ms (default: `3000`, range: 500–60000) |
+| `outputDir` | Override the output directory for generated projects |

package/apps/agentcraft/src/agentcraft-core.module.ts

@@ -0,0 +1,40 @@
+import { Module, DynamicModule } from '@nestjs/common';
+import { RouterModule } from '@nestjs/core';
+import { SessionsModule } from './sessions/sessions.module';
+import { ResolverModule } from './resolver/resolver.module';
+import { AutonomousModule } from './autonomous/autonomous.module';
+import { ArchitectModule } from './architect/architect.module';
+import { HealthModule } from './health/health.module';
+
+const AGENTCRAFT_FEATURE_MODULES = [
+  SessionsModule,
+  ResolverModule,
+  AutonomousModule,
+  ArchitectModule,
+  HealthModule,
+];
+
+@Module({})
+export class AgentcraftCoreModule {
+  static forRoot(routePrefix?: string): DynamicModule {
+    const imports: any[] = [...AGENTCRAFT_FEATURE_MODULES];
+    if (routePrefix) {
+      imports.unshift(
+        RouterModule.register([
+          {
+            path: routePrefix,
+            children: AGENTCRAFT_FEATURE_MODULES.map((module) => ({
+              path: '',
+              module,
+            })),
+          },
+        ]),
+      );
+    }
+
+    return {
+      module: AgentcraftCoreModule,
+      imports,
+    };
+  }
+}

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

@@ -0,0 +1,28 @@
+import { Module } from '@nestjs/common';
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
+import { ConfigModule } from '@nestjs/config';
+import { ThrottlerModule, ThrottlerGuard } from '@nestjs/throttler';
+import { ProjectProviderModule } from '@app/project-provider';
+import { AgentcraftModule } from '@app/agentcraft';
+import configuration from './config/configuration';
+import { DomainExceptionFilter, LoggingInterceptor } from '@app/common';
+import { AgentcraftCoreModule } from './agentcraft-core.module';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      load: [configuration],
+    }),
+    ThrottlerModule.forRoot([{ ttl: 60_000, limit: 100 }]),
+    ProjectProviderModule.forRootAsync(),
+    AgentcraftModule.forRootAsync(),
+    AgentcraftCoreModule.forRoot(),
+  ],
+  providers: [
+    { provide: APP_FILTER, useClass: DomainExceptionFilter },
+    { provide: APP_GUARD, useClass: ThrottlerGuard },
+    { provide: APP_INTERCEPTOR, useClass: LoggingInterceptor },
+  ],
+})
+export class AppModule {}

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

@@ -0,0 +1,69 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Param,
+  Body,
+  Sse,
+  HttpCode,
+  HttpStatus,
+  MessageEvent,
+} from '@nestjs/common';
+import { Observable, merge, from, interval, fromEvent } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ArchitectService } from './architect.service';
+import { IngestSignalDto } from './dto/ingest-signal.dto';
+import type { SSEEvent } from './interfaces/architect.interfaces';
+
+@Controller('projects/:projectId/architect')
+export class ArchitectController {
+  constructor(private readonly architectService: ArchitectService) {}
+
+  @Post()
+  @HttpCode(HttpStatus.ACCEPTED)
+  async ingestSignal(
+    @Param('projectId') projectId: string,
+    @Body() dto: IngestSignalDto,
+  ) {
+    const signal = await this.architectService.ingest(projectId, {
+      summary: dto.summary,
+      kind: dto.kind,
+      priority: dto.priority,
+      data: dto.data,
+      userId: dto.userId,
+    });
+
+    return {
+      id: signal.id,
+      summary: signal.summary,
+      priority: signal.priority,
+      queued: true,
+    };
+  }
+
+  @Get('status')
+  getStatus(@Param('projectId') projectId: string) {
+    return this.architectService.getStatus(projectId);
+  }
+
+  @Sse('stream')
+  async stream(
+    @Param('projectId') projectId: string,
+  ): Promise<Observable<MessageEvent>> {
+    const { buffer, emitter } =
+      await this.architectService.getStream(projectId);
+
+    return merge(
+      from(buffer).pipe(map((e) => ({ data: JSON.stringify(e) }))),
+      fromEvent<SSEEvent>(emitter, 'event').pipe(
+        map((e) => ({ data: JSON.stringify(e) })),
+      ),
+      interval(15_000).pipe(map(() => ({ data: '' }))),
+    );
+  }
+
+  @Get('history')
+  getHistory(@Param('projectId') projectId: string) {
+    return this.architectService.getHistory(projectId);
+  }
+}

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

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ArchitectController } from './architect.controller';
+import { ArchitectService } from './architect.service';
+import { ArchitectStore } from './architect.store';
+
+@Module({
+  controllers: [ArchitectController],
+  providers: [ArchitectService, ArchitectStore],
+  exports: [ArchitectService],
+})
+export class ArchitectModule {}