@dewtech/dare-cli 3.11.0 → 3.13.0

package/skills/dare-layered-design/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@dewtech/dare-layered-design",
+  "version": "1.0.0",
+  "description": "dare-layered-design — 4-layer architecture skill for DARE Method v3.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "templates",
+    "skill.yml"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.41",
+    "typescript": "^5.9.3",
+    "vitest": "^1.6.1"
+  },
+  "keywords": [
+    "dare",
+    "dare-method",
+    "dare-layered-design",
+    "layered-architecture",
+    "clean-architecture",
+    "handlers",
+    "services",
+    "repositories"
+  ],
+  "author": "Dewtech Technologies",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dewtech-technologies/dare-method.git",
+    "directory": "packages/skills/dare-layered-design"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/skills/dare-layered-design/skill.yml

@@ -0,0 +1,35 @@
+name: dare-layered-design
+version: 1.0.0
+description: >
+  Layered Design skill — enforces a strict 4-layer architecture (Handlers → Services →
+  Repositories → Models) across all DARE projects, regardless of language or framework.
+  Inspired by Vladimir Dementyev's "Layered Design for Ruby on Rails Applications" and
+  Evil Martians methodology.
+author: Dewtech Technologies
+license: MIT
+dependencies: {}
+metrics:
+  - id: M-01
+    description: 100% of Services have unit tests (no real DB or HTTP)
+  - id: M-02
+    description: 0% Handler→Repository direct calls in codebase
+  - id: M-03
+    description: 100% of Handlers use dependency injection (no new Service() inside)
+  - id: M-04
+    description: 100% of Repositories are agnostic to upper layers (no HTTP status codes returned)
+layers:
+  - name: handlers
+    description: HTTP/gRPC entry points — no business logic
+    aliases: [controllers, routers, routes]
+  - name: services
+    description: Business logic — one operation per class/module
+    aliases: [use_cases, interactors, commands]
+  - name: repositories
+    description: Data access — abstractions over DB/cache/external APIs
+    aliases: [repos, data_access, stores]
+  - name: models
+    description: Domain objects — no HTTP or DB concerns
+    aliases: [entities, domain, structs]
+  - name: presenters
+    description: Serializers — converts Models to JSON/XML/etc
+    aliases: [serializers, formatters, views]

package/skills/dare-layered-design/tests/generator.spec.ts

@@ -0,0 +1,156 @@
+/**
+ * dare-layered-design — generator tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { LayeredDesignGenerator } from '../generator.js';
+
+describe('LayeredDesignGenerator', () => {
+  let tmpDir: string;
+  let generator: LayeredDesignGenerator;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dare-scaffold-test-'));
+    generator = new LayeredDesignGenerator();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('scaffold()', () => {
+    it('creates all 5 layer directories', () => {
+      const result = generator.scaffold(tmpDir);
+
+      const expectedDirs = ['handlers', 'services', 'repositories', 'models', 'presenters'];
+      for (const dir of expectedDirs) {
+        const fullPath = path.join(tmpDir, 'src', dir);
+        expect(fs.existsSync(fullPath), `Expected ${dir} to exist`).toBe(true);
+        expect(result.createdDirs).toContain(fullPath);
+      }
+    });
+
+    it('creates README.md in each layer directory', () => {
+      generator.scaffold(tmpDir);
+
+      const layers = ['handlers', 'services', 'repositories', 'models', 'presenters'];
+      for (const layer of layers) {
+        const readmePath = path.join(tmpDir, 'src', layer, 'README.md');
+        expect(fs.existsSync(readmePath), `Expected README.md in ${layer}`).toBe(true);
+      }
+    });
+
+    it('creates .gitkeep in each layer when withExamples=false', () => {
+      generator.scaffold(tmpDir, { withExamples: false });
+
+      const layers = ['handlers', 'services', 'repositories', 'models', 'presenters'];
+      for (const layer of layers) {
+        const gitkeepPath = path.join(tmpDir, 'src', layer, '.gitkeep');
+        expect(fs.existsSync(gitkeepPath), `Expected .gitkeep in ${layer}`).toBe(true);
+      }
+    });
+
+    it('uses custom srcDir', () => {
+      generator.scaffold(tmpDir, { srcDir: 'app' });
+
+      expect(fs.existsSync(path.join(tmpDir, 'app', 'handlers'))).toBe(true);
+      expect(fs.existsSync(path.join(tmpDir, 'app', 'services'))).toBe(true);
+      expect(fs.existsSync(path.join(tmpDir, 'src'))).toBe(false);
+    });
+
+    it('creates ARCHITECTURE.md in srcDir', () => {
+      generator.scaffold(tmpDir);
+
+      const archPath = path.join(tmpDir, 'src', 'ARCHITECTURE.md');
+      expect(fs.existsSync(archPath)).toBe(true);
+      const content = fs.readFileSync(archPath, 'utf-8');
+      expect(content).toContain('Handler → Service → Repository → Model');
+    });
+
+    it('creates TypeScript example files when withExamples=true', () => {
+      generator.scaffold(tmpDir, { withExamples: true, exampleEntity: 'user', language: 'typescript' });
+
+      expect(fs.existsSync(path.join(tmpDir, 'src', 'handlers', 'user_handler.ts'))).toBe(true);
+      expect(fs.existsSync(path.join(tmpDir, 'src', 'services', 'create_user_service.ts'))).toBe(true);
+      expect(fs.existsSync(path.join(tmpDir, 'src', 'repositories', 'user_repository.ts'))).toBe(true);
+      expect(fs.existsSync(path.join(tmpDir, 'src', 'models', 'user.ts'))).toBe(true);
+      expect(fs.existsSync(path.join(tmpDir, 'src', 'presenters', 'user_presenter.ts'))).toBe(true);
+    });
+
+    it('creates Ruby example files when withExamples=true and language=ruby', () => {
+      generator.scaffold(tmpDir, { withExamples: true, exampleEntity: 'user', language: 'ruby', srcDir: 'app' });
+
+      expect(fs.existsSync(path.join(tmpDir, 'app', 'handlers', 'user_handler.rb'))).toBe(true);
+      expect(fs.existsSync(path.join(tmpDir, 'app', 'services', 'create_user_service.rb'))).toBe(true);
+      expect(fs.existsSync(path.join(tmpDir, 'app', 'repositories', 'user_repository.rb'))).toBe(true);
+      expect(fs.existsSync(path.join(tmpDir, 'app', 'models', 'user.rb'))).toBe(true);
+      expect(fs.existsSync(path.join(tmpDir, 'app', 'presenters', 'user_presenter.rb'))).toBe(true);
+    });
+
+    it('TypeScript handler example does not import Repository', () => {
+      generator.scaffold(tmpDir, { withExamples: true, exampleEntity: 'user', language: 'typescript' });
+
+      const content = fs.readFileSync(
+        path.join(tmpDir, 'src', 'handlers', 'user_handler.ts'),
+        'utf-8'
+      );
+      expect(content).not.toContain('import.*Repository');
+      expect(content).toContain('Service');
+    });
+
+    it('TypeScript service example mentions DI (no new Repository)', () => {
+      generator.scaffold(tmpDir, { withExamples: true, exampleEntity: 'product', language: 'typescript' });
+
+      const content = fs.readFileSync(
+        path.join(tmpDir, 'src', 'services', 'create_product_service.ts'),
+        'utf-8'
+      );
+      // Should receive repository via constructor, not instantiate it
+      expect(content).toContain('constructor');
+      expect(content).not.toMatch(/new\s+\w+Repository\s*\(/);
+    });
+
+    it('TypeScript repository example includes InMemory implementation', () => {
+      generator.scaffold(tmpDir, { withExamples: true, exampleEntity: 'user', language: 'typescript' });
+
+      const content = fs.readFileSync(
+        path.join(tmpDir, 'src', 'repositories', 'user_repository.ts'),
+        'utf-8'
+      );
+      expect(content).toContain('InMemory');
+      expect(content).toContain('interface UserRepository');
+    });
+
+    it('does not overwrite existing files on second scaffold', () => {
+      generator.scaffold(tmpDir);
+
+      // Manually modify a README
+      const readmePath = path.join(tmpDir, 'src', 'handlers', 'README.md');
+      fs.writeFileSync(readmePath, '# Custom README\n', 'utf-8');
+
+      // Scaffold again
+      generator.scaffold(tmpDir);
+
+      // Custom README should be preserved
+      const content = fs.readFileSync(readmePath, 'utf-8');
+      expect(content).toContain('Custom README');
+    });
+
+    it('returns createdFiles list with README.md paths', () => {
+      const result = generator.scaffold(tmpDir);
+
+      expect(result.createdFiles.some((f) => f.endsWith('README.md'))).toBe(true);
+      expect(result.createdFiles.filter((f) => f.endsWith('README.md'))).toHaveLength(5);
+    });
+
+    it('handles multi-word entity names with snake_case convention', () => {
+      generator.scaffold(tmpDir, { withExamples: true, exampleEntity: 'user-profile', language: 'typescript' });
+
+      expect(fs.existsSync(path.join(tmpDir, 'src', 'handlers', 'user_profile_handler.ts'))).toBe(true);
+      expect(fs.existsSync(path.join(tmpDir, 'src', 'models', 'user_profile.ts'))).toBe(true);
+    });
+  });
+});

package/skills/dare-layered-design/tests/linter.spec.ts

@@ -0,0 +1,255 @@
+/**
+ * dare-layered-design — linter tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { LayeredDesignLinter } from '../linter.js';
+
+describe('LayeredDesignLinter', () => {
+  let tmpDir: string;
+  let linter: LayeredDesignLinter;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dare-linter-test-'));
+    linter = new LayeredDesignLinter();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // ── TypeScript / JavaScript ──────────────────────────────────────────────
+
+  describe('TypeScript handler violations', () => {
+    function createHandlerFile(name: string, content: string): string {
+      const handlersDir = path.join(tmpDir, 'src', 'handlers');
+      fs.mkdirSync(handlersDir, { recursive: true });
+      const file = path.join(handlersDir, name);
+      fs.writeFileSync(file, content, 'utf-8');
+      // Create tsconfig.json so language is detected
+      fs.writeFileSync(path.join(tmpDir, 'tsconfig.json'), '{}', 'utf-8');
+      return file;
+    }
+
+    it('detects import of Repository in handler (TS)', () => {
+      createHandlerFile(
+        'user_handler.ts',
+        `import { UserRepository } from '../repositories/user_repository';
+export class UserHandler {
+  async create(req: Request, res: Response) {
+    const repo = new UserRepository();
+    res.json(await repo.save(req.body));
+  }
+}
+`
+      );
+
+      const result = linter.lint(tmpDir, 'typescript');
+      expect(result.pass).toBe(false);
+      expect(result.violations.length).toBeGreaterThan(0);
+      expect(result.violations[0].message).toContain('Repository');
+    });
+
+    it('detects direct instantiation of Repository in handler (TS)', () => {
+      createHandlerFile(
+        'order_handler.ts',
+        `export class OrderHandler {
+  async create(req: Request, res: Response) {
+    const repo = new OrderRepository();  // VIOLATION
+    const order = await repo.save(req.body);
+    res.json(order);
+  }
+}
+`
+      );
+
+      const result = linter.lint(tmpDir, 'typescript');
+      expect(result.pass).toBe(false);
+      expect(result.violations.some((v) => v.message.includes('instantiates'))).toBe(true);
+    });
+
+    it('detects direct repository method call in handler (TS)', () => {
+      createHandlerFile(
+        'product_handler.ts',
+        `const userRepository = new UserRepository();
+
+export async function getUser(req: Request, res: Response) {
+  const user = await userRepository.findById(req.params.id);  // VIOLATION
+  res.json(user);
+}
+`
+      );
+
+      const result = linter.lint(tmpDir, 'typescript');
+      expect(result.pass).toBe(false);
+    });
+
+    it('does not flag a handler that only uses services (no violation)', () => {
+      createHandlerFile(
+        'user_handler.ts',
+        `export class UserHandler {
+  constructor(private readonly createUserService: CreateUserService) {}
+
+  async create(req: Request, res: Response) {
+    const user = await this.createUserService.execute(req.body);
+    res.status(201).json(user);
+  }
+}
+`
+      );
+
+      const result = linter.lint(tmpDir, 'typescript');
+      expect(result.pass).toBe(true);
+      expect(result.violations).toHaveLength(0);
+    });
+
+    it('does not flag import of Service in handler', () => {
+      createHandlerFile(
+        'user_handler.ts',
+        `import { CreateUserService } from '../services/create_user_service';
+
+export class UserHandler {
+  constructor(private readonly service: CreateUserService) {}
+
+  async create(req: Request, res: Response) {
+    const user = await this.service.execute(req.body);
+    res.json(user);
+  }
+}
+`
+      );
+
+      const result = linter.lint(tmpDir, 'typescript');
+      expect(result.pass).toBe(true);
+    });
+
+    it('skips commented-out violations', () => {
+      createHandlerFile(
+        'user_handler.ts',
+        `export class UserHandler {
+  async create(req: Request, res: Response) {
+    // const repo = new UserRepository(); // This would be a violation if uncommented
+    const user = await this.service.execute(req.body);
+    res.json(user);
+  }
+}
+`
+      );
+
+      const result = linter.lint(tmpDir, 'typescript');
+      expect(result.pass).toBe(true);
+    });
+  });
+
+  // ── Ruby ──────────────────────────────────────────────────────────────────
+
+  describe('Ruby handler violations', () => {
+    function createRubyHandlerFile(name: string, content: string): string {
+      const controllersDir = path.join(tmpDir, 'app', 'controllers');
+      fs.mkdirSync(controllersDir, { recursive: true });
+      const file = path.join(controllersDir, name);
+      fs.writeFileSync(file, content, 'utf-8');
+      fs.writeFileSync(path.join(tmpDir, 'Gemfile'), 'source "https://rubygems.org"', 'utf-8');
+      return file;
+    }
+
+    it('detects Repository call in Rails controller', () => {
+      createRubyHandlerFile(
+        'users_controller.rb',
+        `class UsersController < ApplicationController
+  def create
+    user = UserRepository.save(user_params)  # VIOLATION
+    render json: user
+  end
+end
+`
+      );
+
+      const result = linter.lint(tmpDir, 'ruby');
+      expect(result.pass).toBe(false);
+      expect(result.violations.length).toBeGreaterThan(0);
+    });
+
+    it('passes when controller only calls service', () => {
+      createRubyHandlerFile(
+        'users_controller.rb',
+        `class UsersController < ApplicationController
+  def initialize(create_user_service:)
+    @create_user_service = create_user_service
+  end
+
+  def create
+    user = @create_user_service.call(user_params)
+    render json: user, status: :created
+  end
+end
+`
+      );
+
+      const result = linter.lint(tmpDir, 'ruby');
+      expect(result.pass).toBe(true);
+    });
+  });
+
+  // ── lintFile() ────────────────────────────────────────────────────────────
+
+  describe('lintFile()', () => {
+    it('lints a single TypeScript handler file', () => {
+      const file = path.join(tmpDir, 'user_handler.ts');
+      fs.writeFileSync(
+        file,
+        `import { UserRepository } from '../repositories/user_repository';\n`,
+        'utf-8'
+      );
+
+      const result = linter.lintFile(file, 'typescript');
+      expect(result.pass).toBe(false);
+      expect(result.violations).toHaveLength(1);
+    });
+
+    it('returns pass=true for clean handler file', () => {
+      const file = path.join(tmpDir, 'user_handler.ts');
+      fs.writeFileSync(
+        file,
+        `import { CreateUserService } from '../services/create_user_service';\n`,
+        'utf-8'
+      );
+
+      const result = linter.lintFile(file, 'typescript');
+      expect(result.pass).toBe(true);
+    });
+
+    it('returns filesScanned=1 for single file lint', () => {
+      const file = path.join(tmpDir, 'user_handler.ts');
+      fs.writeFileSync(file, 'export const x = 1;\n', 'utf-8');
+
+      const result = linter.lintFile(file, 'typescript');
+      expect(result.filesScanned).toBe(1);
+    });
+  });
+
+  // ── Empty project ─────────────────────────────────────────────────────────
+
+  it('returns pass=true with 0 violations for empty project', () => {
+    const result = linter.lint(tmpDir);
+    expect(result.pass).toBe(true);
+    expect(result.violations).toHaveLength(0);
+  });
+
+  it('reports filesScanned > 0 when handler files exist', () => {
+    const handlersDir = path.join(tmpDir, 'src', 'handlers');
+    fs.mkdirSync(handlersDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(handlersDir, 'clean_handler.ts'),
+      'export const handler = () => {};\n',
+      'utf-8'
+    );
+    fs.writeFileSync(path.join(tmpDir, 'tsconfig.json'), '{}', 'utf-8');
+
+    const result = linter.lint(tmpDir, 'typescript');
+    expect(result.filesScanned).toBeGreaterThan(0);
+  });
+});