agent-enderun 1.10.4 → 1.11.0

package/templates/standards/testing-standards.md

@@ -0,0 +1,31 @@
+# 🧪 Corporate Testing Standards
+
+This document defines the testing discipline and scope rules for projects managed by Agent Enderun. Code quality must be ensured with automated tests.
+
+## 1. Test Pyramid and Strategy
+- **Unit Tests:** Written for the smallest parts of business logic. Must be fast and isolated.
+- **Integration Tests:** Audits the compatibility of services with the database or external APIs.
+- **E2E Tests:** Simulates critical user flows (Login, Checkout, etc.) in a real browser environment.
+
+## 2. Writing Rules and Naming
+- **Framework:** Vitest (Unit/Integration) and Playwright (E2E) are standard.
+- **File Naming:** The `[module-name].test.ts` format is used.
+- **Pattern (Given-When-Then):**
+  ```typescript
+  it("should create a user when valid data is provided", async () => {
+    // Given
+    const userData = { ... };
+    // When
+    const result = await userService.create(userData);
+    // Then
+    expect(result.id).toBeDefined();
+  });
+  ```
+
+## 3. Scope and Success Criteria
+- **Critical Path Coverage:** Auth, Payment, and Data Mutation processes must have 100% test coverage.
+- **Zero Mock Policy (Internal):** Real contracts and test databases should be used between internal project services instead of mocks. External services (Stripe, Twilio, etc.) can be mocked.
+
+## 4. Auditing
+- The `@quality` agent verifies that the relevant test file is updated in each new function.
+- Code that does not pass tests (`npm run test`) is never approved.

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/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"));
-}

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

@@ -1,83 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { ensureDir, writeTextFile } from "./fs.js";
-import { getConfiguredPaths, getMemoryPath, updateProjectMemory } from "./memory.js";
-import type { AppSpec } from "./app-inferrer.js";
-
-const targetDir = process.cwd();
-
-export function updateProjectDocs(spec: AppSpec): void {
-    const pathsMap = getConfiguredPaths();
-    const docsDir = path.join(targetDir, pathsMap.docs);
-    const apiDir = path.join(docsDir, "api");
-    ensureDir(apiDir);
-
-    const architecture = [];
-    if (spec.platform === "full-stack" || spec.platform === "backend") {
-        architecture.push(`- \`${pathsMap.backend}\`: Fastify API`);
-        architecture.push(`- \`${pathsMap.backend}/src/types\`: Contract-first backend TypeScript types`);
-    }
-    if (spec.platform === "full-stack" || spec.platform === "web") {
-        architecture.push(`- \`${pathsMap.frontend}\`: React dashboard`);
-    }
-    if (spec.platform === "mobile") {
-        architecture.push(`- \`${pathsMap.mobile || "apps/mobile"}\`: Expo / React Native App`);
-    }
-
-    writeTextFile(path.join(docsDir, "project-docs.md"), [
-        `# ${spec.title} Requirements`,
-        "",
-        "## Request",
-        "",
-        spec.rawDescription,
-        "",
-        "## Generated Scope",
-        "",
-        `- Platform: ${spec.platform}`,
-        `- Domain: ${spec.domain}`,
-        `- Auth: ${spec.modules.auth ? "yes" : "no"}`,
-        `- Users: ${spec.modules.users ? "yes" : "no"}`,
-        `- Roles: ${spec.modules.roles ? "yes" : "no"}`,
-        `- Reports: ${spec.modules.reports ? "yes" : "no"}`,
-        "",
-        "## Architecture",
-        "",
-        ...architecture,
-    ].join("\n"));
-
-    writeTextFile(path.join(apiDir, "README.md"), [
-        "# API Registry",
-        "",
-        "- `POST /api/v1/auth/login`",
-        "- `GET /api/v1/dashboard`",
-        "- `GET /api/v1/users`",
-        "- `GET /api/v1/roles`",
-        "- `GET /api/v1/customers`",
-        "- `GET /api/v1/reports`",
-    ].join("\n"));
-}
-
-export function updateMemoryForGeneratedApp(spec: AppSpec, traceId: string): void {
-    const memoryPath = getMemoryPath();
-    if (!fs.existsSync(memoryPath)) return;
-
-    const pathsMap = getConfiguredPaths();
-    const today = new Date().toISOString().split("T")[0];
-    
-    const impactedFiles = [];
-    if (spec.platform === "full-stack" || spec.platform === "backend") impactedFiles.push(pathsMap.backend);
-    if (spec.platform === "full-stack" || spec.platform === "web") impactedFiles.push(pathsMap.frontend);
-    if (spec.platform === "mobile") impactedFiles.push(pathsMap.mobile || "apps/mobile");
-    impactedFiles.push("project docs");
-
-    const history = [
-        `### ${today} — Generated ${spec.title}`,
-        "",
-        "- **Agent:** @manager",
-        `- **Trace ID:** ${traceId}`,
-        `- **Action:** Created ${spec.platform} starter from natural language request.`,
-        `- **Files:** ${impactedFiles.join(", ")}`,
-    ].join("\n");
-
-    updateProjectMemory("HISTORY", history);
-}