agent-enderun 1.10.2 → 1.11.0

package/templates/standards/typeorm-standards.md

@@ -0,0 +1,49 @@
+# TypeORM Standards
+
+> Full-featured ORM with decorator-based entity definitions.
+
+## Setup
+
+```typescript
+import { DataSource } from "typeorm";
+
+export const AppDataSource = new DataSource({
+    type: "sqlite",
+    database: process.env.DATABASE_PATH || "./dev.db",
+    synchronize: process.env.NODE_ENV === "development",
+    logging: process.env.NODE_ENV === "development",
+    entities: ["src/database/typeorm/entities/*.ts"],
+    migrations: ["src/database/typeorm/migrations/*.ts"],
+});
+```
+
+## Entity Pattern
+
+```typescript
+import { Entity, PrimaryColumn, Column, CreateDateColumn, UpdateDateColumn, DeleteDateColumn } from "typeorm";
+
+@Entity("users")
+export class UserEntity {
+    @PrimaryColumn()
+    id!: string;
+    @Column({ unique: true })
+    email!: string;
+    @Column()
+    fullName!: string;
+    @Column({ default: "VIEWER" })
+    role!: string;
+    @CreateDateColumn()
+    createdAt!: Date;
+    @UpdateDateColumn()
+    updatedAt!: Date;
+    @DeleteDateColumn()
+    deletedAt?: Date;
+}
+```
+
+## Best Practices
+1. Use `@DeleteDateColumn()` for soft deletes
+2. Set `synchronize: false` in production
+3. Use `@ManyToOne` / `@OneToMany` for relations
+4. Import `reflect-metadata` at entry point
+5. Generate migrations, don't rely on synchronize

package/templates/standards/vitest-standards.md

@@ -0,0 +1,110 @@
+# Testing Standards
+
+> Unit and integration testing with Vitest for Node.js applications.
+
+## Overview
+
+Vitest is a blazing-fast unit test framework compatible with Jest API. It is used for both unit tests and API integration tests.
+
+## Setup
+
+```bash
+npm install -D vitest
+```
+
+## Configuration
+
+```typescript
+// vitest.config.ts
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: "node",
+        include: ["src/tests/**/*.test.ts"],
+        coverage: {
+            provider: "v8",
+            reporter: ["text", "json", "html"],
+            thresholds: {
+                lines: 80,
+                functions: 80,
+                branches: 80,
+                statements: 80,
+            },
+        },
+    },
+});
+```
+
+## Test Structure
+
+```
+src/tests/
+├── auth.test.ts           # Authentication tests
+├── customers.test.ts      # Customer CRUD tests
+├── helpers/
+│   ├── setup.ts           # Test setup & teardown
+│   └── factories.ts       # Test data factories
+└── integration/
+    └── api.test.ts        # Full API integration tests
+```
+
+## Unit Test Example
+
+```typescript
+import { describe, it, expect } from "vitest";
+import { createCustomerSchema } from "../validators/schemas.js";
+
+describe("Customer Validation", () => {
+    it("should validate create customer schema", () => {
+        const result = createCustomerSchema.parse({
+            name: "Test Corp",
+            status: "LEAD",
+            annualValue: 50000,
+        });
+        expect(result.name).toBe("Test Corp");
+    });
+
+    it("should reject invalid data", () => {
+        expect(() => createCustomerSchema.parse({ name: "" })).toThrow();
+    });
+});
+```
+
+## API Integration Test Example
+
+```typescript
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import Fastify from "fastify";
+
+describe("Auth API", () => {
+    const app = Fastify();
+
+    beforeAll(async () => {
+        await app.register(publicRoutes, { prefix: "/api/v1" });
+        await app.ready();
+    });
+
+    afterAll(async () => await app.close());
+
+    it("should reject invalid login", async () => {
+        const response = await app.inject({
+            method: "POST",
+            url: "/api/v1/auth/login",
+            payload: { email: "invalid", password: "test" },
+        });
+        expect(response.statusCode).toBe(400);
+    });
+});
+```
+
+## Best Practices
+
+1. Use `describe`/`it` blocks for organized test suites
+2. Test both success and failure scenarios
+3. Use `app.inject()` for API tests (no server needed)
+4. Keep tests isolated — clean state between tests
+5. Aim for >80% coverage on business logic
+6. Use factories for test data generation
+7. Follow Given-When-Then pattern in all test suites

package/bin/validate-agent-army.js

@@ -1,148 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "fs";
-import path from "path";
-import yaml from "js-yaml";
-
-/**
- * AL-compatible agent folder names across all adapters (after init).
- */
-const AGENT_FOLDER_NAMES = ["agents", "skills", "plugins"];
-const FRAMEWORK_CANDIDATES = [
-    ".enderun",
-    ".cursor",
-    ".claude",
-    ".github",
-    ".grok",
-    ".windsurf",
-    ".antigravity",
-    ".agent",
-    ".gemini/antigravity-cli",
-    ".gemini",
-    ".agents",
-    "antigravity-cli"
-];
-
-function detectFrameworkDir() {
-    const projectRoot = process.cwd();
-    for (const dir of FRAMEWORK_CANDIDATES) {
-        const dirPath = path.resolve(projectRoot, dir);
-        if (!fs.existsSync(dirPath)) continue;
-
-        for (const folderName of AGENT_FOLDER_NAMES) {
-            const agentsPath = path.join(dirPath, folderName);
-            if (fs.existsSync(agentsPath)) {
-                return { frameworkDir: dir, agentsDir: agentsPath };
-            }
-        }
-    }
-    return null;
-}
-
-/**
- * Helper to parse YAML-like Frontmatter from Markdown.
- */
-function parseFrontmatter(content) {
-    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    if (match) {
-        try {
-            const fm = yaml.load(match[1]);
-            return fm || {};
-        } catch (e) {
-            // Fallback to simpler parsing or handle error
-            console.error("Error parsing YAML frontmatter:", e);
-            return {};
-        }
-    }
-    // Also parse from HTML comments in the body as fallback to bypass strict frontmatter checks
-    const commentMatches = content.matchAll(/<!--\s*(\w+)\s*:\s*(.*?)\s*-->/g);
-    const fmFromComments = {};
-    for (const m of commentMatches) {
-        let value = m[2].trim();
-        if (value.startsWith("[") && value.endsWith("]")) {
-            value = value.slice(1, -1).split(",").map(s => s.trim().replace(/"/g, "").replace(/'/g, ""));
-        } else if (value.startsWith("\"") && value.endsWith("\"")) {
-            value = value.slice(1, -1);
-        }
-        fmFromComments[m[1]] = value;
-    }
-
-    return Object.keys(fmFromComments).length > 0 ? fmFromComments : null;
-}
-
-
-const detected = detectFrameworkDir();
-if (!detected) {
-    process.stderr.write("ℹ️  No framework agents/ dir found for AL validation. Skipping.");
-    process.exit(0);
-}
-
-const { agentsDir } = detected;
-
-try {
-    const files = [];
-    const walk = (dir) => {
-        if (!fs.existsSync(dir)) return;
-        const list = fs.readdirSync(dir);
-        for (const item of list) {
-            const fullPath = path.join(dir, item);
-            if (fs.statSync(fullPath).isDirectory()) {
-                walk(fullPath);
-            } else if (item.endsWith(".json") || item.endsWith(".md")) {
-                files.push({ name: item, path: fullPath });
-            }
-        }
-    };
-    walk(agentsDir);
-
-    let totalFailed = 0;
-
-    process.stderr.write(`🛡️  STARTING AGENT ARMY AL VALIDATION (${detected.frameworkDir})...`);
-    process.stderr.write("--------------------------------------------------");
-    process.stderr.write("| Agent ID  | Format | Status    | Category       |");
-    process.stderr.write("--------------------------------------------------");
-
-    for (const file of files) {
-        const fileName = file.name;
-        const filePath = file.path;
-        if (fileName === "agent_army_schema.json" || fileName === "schema") continue;
-        
-        const content = fs.readFileSync(filePath, "utf8");
-        const isMd = fileName.endsWith(".md");
-
-        let agent;
-        try {
-            agent = isMd ? parseFrontmatter(content) : JSON.parse(content);
-            if (!agent && isMd) throw new Error("Missing Frontmatter");
-        } catch (e) {
-            process.stderr.write(`| ${fileName.padEnd(9)} | ${isMd ? "MD  " : "JSON"} | ❌ INVALID | ${String(e.message).slice(0, 14)} |`);
-            totalFailed++;
-            continue;
-        }
-
-        // Validate AL compliance fields
-        const missing = [];
-        if (!agent.name) missing.push("name");
-        if (agent.capability === undefined) missing.push("capability");
-        if (!agent.tags) missing.push("tags");
-
-        if (missing.length > 0) {
-            process.stderr.write(`| ${fileName.padEnd(9)} | ${isMd ? "MD  " : "JSON"} | ❌ FAILED  | ${missing.join(",").slice(0, 14)} |`);
-            totalFailed++;
-        } else {
-            const cat = Array.isArray(agent.tags) ? agent.tags[0] : "core";
-            process.stderr.write(`| ${agent.name.padEnd(9)} | ${isMd ? "MD  " : "JSON"} | ✅ PASSED  | ${cat.padEnd(14)} |`);
-        }
-    }
-
-    process.stderr.write("--------------------------------------------------");
-    if (totalFailed > 0) {
-        process.stderr.write(`❌ Validation failed! Detected ${totalFailed} invalid agent configurations.\n`);
-        process.exit(1);
-    } else {
-        process.stderr.write("🎉 SUCCESS: All core agents are AL-Compliant!");
-    }
-} catch (e) {
-    process.stderr.write(`❌ Critical error during validation: ${e}\n`);
-    process.exit(1);
-}

package/src/cli/commands/app.ts

@@ -1,56 +0,0 @@
-import fs from "fs";
-
-import { updateMemoryForGeneratedApp, collectCreateAppDescription, inferAppSpec, createBackendFiles, createWebFiles, createMobileFiles, updateProjectDocs } from "../utils/app.js";
-import { traceNewCommand } from "./trace.js";
-import { getMemoryPath } from "../utils/memory.js";
-
-import { ValidationError } from "../../shared/errors.js";
-
-/**
- * Generate a new application based on natural language input.
- */
-export async function createAppCommand(args: string[]) {
-    if (!fs.existsSync("apps")) {
-        throw new ValidationError(
-            "The 'apps/' directory is missing.",
-            null,
-            "Ensure you are in the project root and the 'apps/' folder exists. Run 'mkdir apps' if needed."
-        );
-    }
-    const description = await collectCreateAppDescription(args);
-    const spec = inferAppSpec(description);
-
-    console.warn(`🚀 Generating Enterprise App: ${spec.title} (Platform: ${spec.platform})...`);
-
-    if (spec.platform === "full-stack") {
-        createBackendFiles(spec);
-        createWebFiles(spec);
-    } else if (spec.platform === "web") {
-        createWebFiles(spec);
-    } else if (spec.platform === "mobile") {
-        createMobileFiles(spec);
-    } else if (spec.platform === "backend") {
-        createBackendFiles(spec);
-    }
-
-    updateProjectDocs(spec);
-
-    const memoryPath = getMemoryPath();
-    let traceId = "01HGT8J5E2N0W0W0W0W0W0W0W0"; // default fallback
-
-    if (fs.existsSync(memoryPath)) {
-        const memory = fs.readFileSync(memoryPath, "utf8");
-        const match = memory.match(/- Trace ID: (.*)/);
-        if (match) traceId = match[1].trim();
-    }
-
-    const activeTraceId = (await traceNewCommand(`Generate ${spec.title} from natural language request`, "manager", "P1")) || traceId;
-    updateMemoryForGeneratedApp(spec, activeTraceId);
-
-    console.warn("\n✨ Application scaffolded successfully!");
-    console.warn("📜 Updated project docs and app-local types contract");
-    console.warn("\nNext commands:");
-    console.warn("  npm install");
-    console.warn("  npm run enderun:build");
-    console.warn("  agent-enderun frontend:dev\n");
-}

package/src/cli/utils/app-backend.ts

@@ -1,257 +0,0 @@
-import path from "path";
-import type { AppSpec } from "./app-inferrer.js";
-import { createBaseTypeFiles } from "./app-types.js";
-import { ensureDir, writeJsonFile, writeTextFile } from "./fs.js";
-import { getConfiguredPaths } from "./memory.js";
-import { getDependencyVersions } from "./pkg.js";
-
-const targetDir = process.cwd();
-
-export function createBackendFiles(spec: AppSpec): void {
-    const pathsMap = getConfiguredPaths();
-    const backendDir = pathsMap.backend;
-    const { fastify, "@fastify/cors": fastifyCors, zod, "@types/node": typesNode, tsx, typescript, "vitest-backend": vitest } = getDependencyVersions();
-
-    createBaseTypeFiles(path.join(targetDir, backendDir, "src"));
-    writeJsonFile(path.join(targetDir, backendDir, "contract.version.json"), {
-        "contract_hash": "initial_hash_placeholder",
-        "last_updated": new Date().toISOString()
-    });
-    writeJsonFile(path.join(targetDir, backendDir, "package.json"), {
-        name: "@agent-enderun/backend",
-        version: "0.1.0",
-        private: true,
-        type: "module",
-        scripts: {
-            dev: "tsx src/server.ts",
-            build: "tsc -p tsconfig.json",
-            start: "node dist/server.js",
-            test: "vitest run",
-        },
-        dependencies: {
-            "@fastify/cors": fastifyCors,
-            fastify: fastify,
-            zod: zod,
-        },
-        devDependencies: {
-            "@types/node": typesNode,
-            tsx: tsx,
-            typescript: typescript,
-            vitest: vitest,
-        },
-    });
-
-    writeJsonFile(path.join(targetDir, backendDir, "tsconfig.json"), {
-        extends: "../../tsconfig.json",
-        compilerOptions: {
-            outDir: "dist",
-            rootDir: "src",
-            module: "NodeNext",
-            moduleResolution: "NodeNext",
-            target: "ES2022",
-            strict: true,
-            skipLibCheck: true,
-        },
-        include: ["src/**/*.ts"],
-    });
-
-    const srcDir = path.join(targetDir, backendDir, "src");
-    ensureDir(path.join(srcDir, "database"));
-    ensureDir(path.join(srcDir, "repositories"));
-    ensureDir(path.join(srcDir, "services"));
-
-    writeTextFile(path.join(srcDir, "database/memoryDb.ts"), [
-        "import type { Customer, ReportMetric, Role, User } from \"../types/index.js\";",
-        "",
-        "const now = new Date().toISOString();",
-        "",
-        "export const rolesDb: Role[] = [",
-        "  { id: \"role_admin\" as Role[\"id\"], name: \"Admin\", permissions: [\"users:manage\", \"reports:view\", \"customers:manage\"] },",
-        "  { id: \"role_manager\" as Role[\"id\"], name: \"Manager\", permissions: [\"reports:view\", \"customers:manage\"] },",
-        "  { id: \"role_viewer\" as Role[\"id\"], name: \"Viewer\", permissions: [\"reports:view\"] },",
-        "];",
-        "",
-        "export const usersDb: User[] = [",
-        "  { id: \"user_1\" as User[\"id\"], email: \"admin@example.com\", fullName: \"Admin User\", role: \"ADMIN\", createdAt: now, updatedAt: now },",
-        "  { id: \"user_2\" as User[\"id\"], email: \"manager@example.com\", fullName: \"Sales Manager\", role: \"DEVELOPER\", createdAt: now, updatedAt: now },",
-        "];",
-        "",
-        "export const customersDb: Customer[] = [",
-        "  { id: \"customer_1\" as Customer[\"id\"], name: \"Northwind\", ownerId: usersDb[1].id, status: \"ACTIVE\", annualValue: 125000, createdAt: now, updatedAt: now },",
-        "  { id: \"customer_2\" as Customer[\"id\"], name: \"Acme Corp\", ownerId: usersDb[1].id, status: \"LEAD\", annualValue: 82000, createdAt: now, updatedAt: now },",
-        "  { id: \"customer_3\" as Customer[\"id\"], name: \"Globex\", ownerId: usersDb[0].id, status: \"AT_RISK\", annualValue: 54000, createdAt: now, updatedAt: now },",
-        "];",
-        "",
-        "export const reportsDb: ReportMetric[] = [",
-        "  { id: \"report_pipeline\" as ReportMetric[\"id\"], label: \"Pipeline\", value: 261000, trend: \"UP\" },",
-        "  { id: \"report_active_customers\" as ReportMetric[\"id\"], label: \"Active Customers\", value: 1, trend: \"FLAT\" },",
-        "  { id: \"report_risk\" as ReportMetric[\"id\"], label: \"At Risk\", value: 1, trend: \"DOWN\" },",
-        "];",
-    ].join("\n"));
-
-    writeTextFile(path.join(srcDir, "repositories/user.repository.ts"), [
-        "import { usersDb } from \"../database/memoryDb.js\";",
-        "import type { User } from \"../types/index.js\";",
-        "",
-        "export class UserRepository {",
-        "  async findAll(): Promise<User[]> {",
-        "    return usersDb.filter(u => !u.deletedAt);",
-        "  }",
-        "",
-        "  async findByEmail(email: string): Promise<User | null> {",
-        "    return usersDb.find(u => u.email === email && !u.deletedAt) || null;",
-        "  }",
-        "}",
-    ].join("\n"));
-
-    writeTextFile(path.join(srcDir, "repositories/customer.repository.ts"), [
-        "import { customersDb } from \"../database/memoryDb.js\";",
-        "import type { Customer } from \"../types/index.js\";",
-        "",
-        "export class CustomerRepository {",
-        "  async findAll(): Promise<Customer[]> {",
-        "    return customersDb.filter(c => !c.deletedAt);",
-        "  }",
-        "}",
-    ].join("\n"));
-
-    writeTextFile(path.join(srcDir, "repositories/role.repository.ts"), [
-        "import { rolesDb } from \"../database/memoryDb.js\";",
-        "import type { Role } from \"../types/index.js\";",
-        "",
-        "export class RoleRepository {",
-        "  async findAll(): Promise<Role[]> {",
-        "    return rolesDb;",
-        "  }",
-        "}",
-    ].join("\n"));
-
-    writeTextFile(path.join(srcDir, "repositories/report.repository.ts"), [
-        "import { reportsDb } from \"../database/memoryDb.js\";",
-        "import type { ReportMetric } from \"../types/index.js\";",
-        "",
-        "export class ReportRepository {",
-        "  async findAll(): Promise<ReportMetric[]> {",
-        "    return reportsDb;",
-        "  }",
-        "}",
-    ].join("\n"));
-
-    writeTextFile(path.join(srcDir, "services/dashboard.service.ts"), [
-        "import { UserRepository } from \"../repositories/user.repository.js\";",
-        "import { CustomerRepository } from \"../repositories/customer.repository.js\";",
-        "import { RoleRepository } from \"../repositories/role.repository.js\";",
-        "import { ReportRepository } from \"../repositories/report.repository.js\";",
-        "import type { DashboardSummary } from \"../types/index.js\";",
-        "",
-        "export class DashboardService {",
-        "  private userRepo = new UserRepository();",
-        "  private customerRepo = new CustomerRepository();",
-        "  private roleRepo = new RoleRepository();",
-        "  private reportRepo = new ReportRepository();",
-        "",
-        "  async getSummary(): Promise<DashboardSummary> {",
-        "    const [users, customers, roles, reports] = await Promise.all([",
-        "      this.userRepo.findAll(),",
-        "      this.customerRepo.findAll(),",
-        "      this.roleRepo.findAll(),",
-        "      this.reportRepo.findAll(),",
-        "    ]);",
-        "",
-        "    return { users, customers, roles, reports };",
-        "  }",
-        "}",
-    ].join("\n"));
-
-    writeTextFile(path.join(targetDir, backendDir, "src/server.ts"), [
-        "import Fastify from \"fastify\";",
-        "import cors from \"@fastify/cors\";",
-        "import { z } from \"zod\";",
-        "import { UserRepository } from \"./repositories/user.repository.js\";",
-        "import { CustomerRepository } from \"./repositories/customer.repository.js\";",
-        "import { RoleRepository } from \"./repositories/role.repository.js\";",
-        "import { ReportRepository } from \"./repositories/report.repository.js\";",
-        "import { DashboardService } from \"./services/dashboard.service.js\";",
-        "",
-        "const app = Fastify({ logger: true });",
-        "await app.register(cors, { origin: true });",
-        "",
-        "const userRepo = new UserRepository();",
-        "const customerRepo = new CustomerRepository();",
-        "const roleRepo = new RoleRepository();",
-        "const reportRepo = new ReportRepository();",
-        "const dashboardService = new DashboardService();",
-        "",
-        "app.get(\"/health\", async () => ({ ok: true, service: \"agent-enderun-backend\" }));",
-        "app.get(\"/api/v1/dashboard\", async () => {",
-        "  const summary = await dashboardService.getSummary();",
-        "  return { data: summary };",
-        "});",
-        "app.get(\"/api/v1/users\", async () => {",
-        "  const users = await userRepo.findAll();",
-        "  return { data: users };",
-        "});",
-        "app.get(\"/api/v1/roles\", async () => {",
-        "  const roles = await roleRepo.findAll();",
-        "  return { data: roles };",
-        "});",
-        "app.get(\"/api/v1/customers\", async () => {",
-        "  const customers = await customerRepo.findAll();",
-        "  return { data: customers };",
-        "});",
-        "app.get(\"/api/v1/reports\", async (request, reply) => {",
-        "  interface QueryParams {",
-        "    page?: number;",
-        "    limit?: number;",
-        "  }",
-        "  const { page = 1, limit = 10 } = request.query as QueryParams;",
-        "  const reports = await reportRepo.findAll();",
-        "  const startIndex = (Number(page) - 1) * Number(limit);",
-        "  const endIndex = startIndex + Number(limit);",
-        "  const paginatedReports = reports.slice(startIndex, endIndex);",
-        "  reply.send({",
-        "    data: paginatedReports,",
-        "    meta: {",
-        "      total: reports.length,",
-        "      page: Number(page),",
-        "      limit: Number(limit),",
-        "    },",
-        "  });",
-        "});",
-        "",
-        "app.post(\"/api/v1/auth/login\", async (request, reply) => {",
-        "  const body = z.object({ email: z.string().email(), password: z.string().min(1) }).safeParse(request.body);",
-        "  if (!body.success) return reply.code(400).send({ error: { code: \"VALIDATION_ERROR\", message: \"Invalid login payload\" } });",
-        "",
-        "  const user = await userRepo.findByEmail(body.data.email);",
-        "  if (!user) {",
-        "    const allUsers = await userRepo.findAll();",
-        "    return { data: { user: allUsers[0], token: \"demo-token\", expiresAt: new Date(Date.now() + 3600000).toISOString() } };",
-        "  }",
-        "  return { data: { user, token: \"demo-token\", expiresAt: new Date(Date.now() + 3600000).toISOString() } };",
-        "});",
-        "",
-        "const port = Number(process.env.PORT || 4000);",
-        "await app.listen({ port, host: \"0.0.0.0\" });",
-    ].join("\n"));
-
-    writeTextFile(path.join(targetDir, backendDir, ".env.example"), [
-        "# Agent Enderun - Backend Environment Variables",
-        "PORT=4000",
-        "NODE_ENV=development",
-        "DATABASE_URL=sqlite://./dev.db",
-        "JWT_SECRET=your_secret_key_here",
-    ].join("\n"));
-
-    writeTextFile(path.join(targetDir, backendDir, "README.md"), [
-        `# ${spec.title} Backend`,
-        "",
-        "Fastify API generated by Agent Enderun.",
-        "",
-        "## Commands",
-        "",
-        "- `npm run dev` strings",
-        "- `npm run build` strings",
-        "- `npm run test` strings",
-    ].join("\n"));
-}