@dewtech/dare-cli 2.17.0 → 3.1.0

package/templates/stacks/node-nestjs/src/users/dto/create-user.dto.ts

@@ -0,0 +1,22 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEmail, IsEnum, IsOptional, IsString, Matches, MinLength } from 'class-validator';
+import { Transform } from 'class-transformer';
+
+export class CreateUserDto {
+  @ApiProperty()
+  @Transform(({ value }) => (typeof value === 'string' ? value.trim().toLowerCase() : value))
+  @IsEmail()
+  email!: string;
+
+  @ApiProperty()
+  @IsString()
+  @MinLength(8)
+  @Matches(/[A-Z]/)
+  @Matches(/[0-9]/)
+  password!: string;
+
+  @ApiProperty({ enum: ['USER', 'ADMIN'], required: false, default: 'USER' })
+  @IsOptional()
+  @IsEnum(['USER', 'ADMIN'])
+  role?: 'USER' | 'ADMIN';
+}

package/templates/stacks/node-nestjs/src/users/dto/user.dto.ts

@@ -0,0 +1,15 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class UserDto {
+  @ApiProperty()
+  id!: string;
+
+  @ApiProperty()
+  email!: string;
+
+  @ApiProperty({ enum: ['USER', 'ADMIN'] })
+  role!: string;
+
+  @ApiProperty({ description: 'ISO-8601 timestamp' })
+  createdAt!: string;
+}

package/templates/stacks/node-nestjs/src/users/users.controller.ts

@@ -0,0 +1,41 @@
+import {
+  Body,
+  Controller,
+  ForbiddenException,
+  Get,
+  Post,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import type { Request } from 'express';
+import { UsersService } from './users.service.js';
+import { UserDto } from './dto/user.dto.js';
+import { CreateUserDto } from './dto/create-user.dto.js';
+
+@ApiTags('users')
+@ApiBearerAuth()
+@UseGuards(AuthGuard('jwt'))
+@Controller('users')
+export class UsersController {
+  constructor(private readonly users: UsersService) {}
+
+  @Get()
+  list(
+    @Query('page') page = '1',
+    @Query('limit') limit = '20',
+  ): Promise<{ items: UserDto[]; total: number; page: number }> {
+    return this.users.list(Number(page), Number(limit));
+  }
+
+  @Post()
+  create(@Req() req: Request, @Body() dto: CreateUserDto): Promise<UserDto> {
+    const caller = req.user as { role: string } | undefined;
+    if (!caller || caller.role !== 'ADMIN') {
+      throw new ForbiddenException('admin role required');
+    }
+    return this.users.create(dto);
+  }
+}

package/templates/stacks/node-nestjs/src/users/users.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { UsersController } from './users.controller.js';
+import { UsersService } from './users.service.js';
+import { UsersRepository } from './users.repository.js';
+
+@Module({
+  controllers: [UsersController],
+  providers: [UsersService, UsersRepository],
+  exports: [UsersRepository, UsersService],
+})
+export class UsersModule {}

package/templates/stacks/node-nestjs/src/users/users.repository.ts

@@ -0,0 +1,38 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from '../prisma/prisma.service.js';
+
+interface UserRow {
+  id: string;
+  email: string;
+  password: string;
+  role: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+@Injectable()
+export class UsersRepository {
+  constructor(private readonly prisma: PrismaService) {}
+
+  findByEmail(email: string): Promise<UserRow | null> {
+    return this.prisma.user.findUnique({ where: { email } });
+  }
+
+  async findPage(page: number, limit: number): Promise<{ items: UserRow[]; total: number }> {
+    const [items, total] = await Promise.all([
+      this.prisma.user.findMany({
+        skip: (page - 1) * limit,
+        take: limit,
+        orderBy: { createdAt: 'desc' },
+      }),
+      this.prisma.user.count(),
+    ]);
+    return { items, total };
+  }
+
+  create(data: { email: string; password: string; role: 'USER' | 'ADMIN' }): Promise<UserRow> {
+    return this.prisma.user.create({
+      data: { email: data.email, password: data.password, role: data.role },
+    });
+  }
+}

package/templates/stacks/node-nestjs/src/users/users.service.ts

@@ -0,0 +1,38 @@
+import { ConflictException, Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import * as bcrypt from 'bcrypt';
+import { UsersRepository } from './users.repository.js';
+import { UserDto } from './dto/user.dto.js';
+import { CreateUserDto } from './dto/create-user.dto.js';
+
+@Injectable()
+export class UsersService {
+  constructor(
+    private readonly repo: UsersRepository,
+    private readonly config: ConfigService,
+  ) {}
+
+  async list(page = 1, limit = 20): Promise<{ items: UserDto[]; total: number; page: number }> {
+    const safePage = Math.max(1, page);
+    const safeLimit = Math.min(100, Math.max(1, limit));
+    const { items, total } = await this.repo.findPage(safePage, safeLimit);
+    return { items: items.map(toDto), total, page: safePage };
+  }
+
+  async create(input: CreateUserDto): Promise<UserDto> {
+    const existing = await this.repo.findByEmail(input.email);
+    if (existing) throw new ConflictException('email already in use');
+    const cost = Number(this.config.get<string>('BCRYPT_COST', '12'));
+    const hash = await bcrypt.hash(input.password, cost);
+    const created = await this.repo.create({
+      email: input.email,
+      password: hash,
+      role: input.role ?? 'USER',
+    });
+    return toDto(created);
+  }
+}
+
+function toDto(u: { id: string; email: string; role: string; createdAt: Date }): UserDto {
+  return { id: u.id, email: u.email, role: u.role, createdAt: u.createdAt.toISOString() };
+}

package/templates/stacks/node-nestjs/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*.spec.ts"]
+}

package/templates/stacks/node-nestjs/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2022",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "noImplicitAny": true,
+    "strictBindCallApply": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"]
+}

package/templates/stacks/php-laravel/.dare/skills.yml

@@ -0,0 +1,11 @@
+version: 1
+skills:
+  - id: skill-laravel-api
+    source: skill-laravel-api
+    description: Laravel 11 + Sanctum + Reverb + Pail + Layered Design
+  - id: dare-ax
+    source: dare-ax
+    description: Agent eXperience invariants (llms.txt, OpenAPI, --json, rate limit)
+  - id: dare-layered-design
+    source: dare-layered-design
+    description: Controller → Service → Repository → Model 4-layer architecture

package/templates/stacks/php-laravel/.env.example

@@ -0,0 +1,41 @@
+APP_NAME=Laravel
+APP_ENV=local
+APP_KEY=
+APP_DEBUG=true
+APP_URL=http://localhost
+APP_PORT=8000
+
+LOG_CHANNEL=stack
+LOG_LEVEL=info
+
+DB_CONNECTION=pgsql
+DB_HOST=127.0.0.1
+DB_PORT=5432
+DB_DATABASE=myapi
+DB_USERNAME=user
+DB_PASSWORD=pass
+
+CACHE_STORE=database
+QUEUE_CONNECTION=database
+SESSION_DRIVER=database
+SESSION_LIFETIME=120
+
+SANCTUM_STATEFUL_DOMAINS=localhost:3000
+
+BCRYPT_ROUNDS=12
+
+# Reverb (WebSocket)
+BROADCAST_CONNECTION=reverb
+REVERB_APP_ID=myapp
+REVERB_APP_KEY=
+REVERB_APP_SECRET=
+REVERB_HOST=127.0.0.1
+REVERB_PORT=8080
+REVERB_SCHEME=http
+
+# Rate limit
+RATE_LIMIT_PER_MIN=60
+
+# LLM provider
+LLM_PROVIDER=dummy
+# OPENAI_API_KEY=

package/templates/stacks/php-laravel/.github/workflows/dare-ci.yml

@@ -0,0 +1,43 @@
+name: DARE CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  audit:
+    name: Audit dependencies
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: shivammathur/setup-php@v2
+        with:
+          php-version: "8.3"
+      - uses: ramsey/composer-install@v3
+      - run: composer audit --no-dev
+
+  lint:
+    name: PHPStan
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: shivammathur/setup-php@v2
+        with:
+          php-version: "8.3"
+      - uses: ramsey/composer-install@v3
+      - run: vendor/bin/phpstan analyse
+
+  test:
+    name: Pest
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: shivammathur/setup-php@v2
+        with:
+          php-version: "8.3"
+      - uses: ramsey/composer-install@v3
+      - run: cp .env.example .env
+      - run: php artisan key:generate
+      - run: vendor/bin/pest

package/templates/stacks/php-laravel/README.md.hbs

@@ -0,0 +1,36 @@
+# {{projectName}}
+
+DARE-shaped Laravel 11 API. Layered Design (Controller → Service → Repository → Model).
+
+## Setup
+
+```bash
+cp .env.example .env
+composer install
+php artisan key:generate
+docker compose up -d postgres
+php artisan migrate --seed
+php artisan l5-swagger:generate
+php artisan serve
+```
+
+## Endpoints
+
+- `POST /api/auth/login` — exchange email/password for Sanctum token
+- `GET /api/auth/me` — current user (Bearer)
+- `GET /api/users` — list users (paginated)
+- `POST /api/users` — create user (admin only)
+- `GET /openapi.json` — OpenAPI 3.x surface
+- `GET /api/documentation` — Swagger UI (l5-swagger)
+
+## Commands
+
+- `php artisan serve` — dev server (port 8000)
+- `php artisan pail` — tail logs
+- `pest` (or `php artisan test`) — run tests
+- `vendor/bin/phpstan analyse` — static analysis
+- `composer audit` — dependency audit
+
+## DARE Method
+
+See `.dare/skills.yml` for installed skills, `llms.txt` for agent context.

package/templates/stacks/php-laravel/app/Http/Controllers/Api/AuthController.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Http\Requests\LoginRequest;
+use App\Services\AuthService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+
+class AuthController extends Controller
+{
+    public function __construct(private readonly AuthService $auth)
+    {
+    }
+
+    public function login(LoginRequest $request): JsonResponse
+    {
+        $payload = $this->auth->login($request->validated());
+        return response()->json($payload);
+    }
+
+    public function me(Request $request): JsonResponse
+    {
+        $user = $request->user();
+        if ($user === null) {
+            return response()->json(['error' => 'Unauthenticated'], 401);
+        }
+        return response()->json([
+            'id' => $user->id,
+            'email' => $user->email,
+            'role' => $user->role,
+            'createdAt' => $user->created_at?->toIso8601String(),
+        ]);
+    }
+}

package/templates/stacks/php-laravel/app/Http/Controllers/Api/UsersController.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Http\Requests\CreateUserRequest;
+use App\Services\UsersService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+
+class UsersController extends Controller
+{
+    public function __construct(private readonly UsersService $users)
+    {
+    }
+
+    public function index(Request $request): JsonResponse
+    {
+        $page = max(1, (int) $request->query('page', '1'));
+        $limit = min(100, max(1, (int) $request->query('limit', '20')));
+        return response()->json($this->users->list($page, $limit));
+    }
+
+    public function store(CreateUserRequest $request): JsonResponse
+    {
+        $caller = $request->user();
+        if ($caller === null || $caller->role !== 'ADMIN') {
+            return response()->json(['error' => 'admin role required'], 403);
+        }
+        $created = $this->users->create($request->validated());
+        return response()->json($created, 201);
+    }
+}

package/templates/stacks/php-laravel/app/Http/Requests/CreateUserRequest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class CreateUserRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function rules(): array
+    {
+        return [
+            'email' => ['required', 'email', 'max:254', 'unique:users,email'],
+            'password' => ['required', 'string', 'min:8', 'regex:/[A-Z]/', 'regex:/[0-9]/'],
+            'role' => ['sometimes', Rule::in(['USER', 'ADMIN'])],
+        ];
+    }
+}

package/templates/stacks/php-laravel/app/Http/Requests/LoginRequest.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class LoginRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function rules(): array
+    {
+        return [
+            'email' => ['required', 'email', 'max:254'],
+            'password' => ['required', 'string', 'min:8', 'regex:/[A-Z]/', 'regex:/[0-9]/'],
+        ];
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function messages(): array
+    {
+        return [
+            'password.regex' => 'Password must contain an uppercase letter and a digit.',
+        ];
+    }
+}

package/templates/stacks/php-laravel/app/Llm/Contracts/LlmProvider.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace App\Llm\Contracts;
+
+interface LlmProvider
+{
+    /**
+     * Complete a prompt. Implementations decide on streaming vs. one-shot
+     * via their own configuration; this contract is the synchronous shape.
+     */
+    public function complete(string $prompt, int $maxTokens = 512): string;
+}

package/templates/stacks/php-laravel/app/Llm/Providers/DummyProvider.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Llm\Providers;
+
+use App\Llm\Contracts\LlmProvider;
+
+class DummyProvider implements LlmProvider
+{
+    public function complete(string $prompt, int $maxTokens = 512): string
+    {
+        return '[dummy] '.substr($prompt, 0, $maxTokens);
+    }
+}

package/templates/stacks/php-laravel/app/Llm/Providers/OpenAiProvider.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Llm\Providers;
+
+use App\Llm\Contracts\LlmProvider;
+use Illuminate\Support\Facades\Http;
+use RuntimeException;
+
+class OpenAiProvider implements LlmProvider
+{
+    public function __construct(
+        private readonly string $apiKey,
+        private readonly string $model = 'gpt-4o-mini',
+        private readonly string $baseUri = 'https://api.openai.com/v1',
+    ) {
+    }
+
+    public function complete(string $prompt, int $maxTokens = 512): string
+    {
+        $res = Http::withToken($this->apiKey)
+            ->post("{$this->baseUri}/chat/completions", [
+                'model' => $this->model,
+                'messages' => [['role' => 'user', 'content' => $prompt]],
+                'max_tokens' => $maxTokens,
+            ]);
+
+        if (! $res->successful()) {
+            throw new RuntimeException('OpenAI request failed: '.$res->status());
+        }
+
+        return (string) ($res->json('choices.0.message.content') ?? '');
+    }
+}

package/templates/stacks/php-laravel/app/Models/User.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Concerns\HasUuids;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Foundation\Auth\User as Authenticatable;
+use Illuminate\Notifications\Notifiable;
+use Laravel\Sanctum\HasApiTokens;
+
+/**
+ * @property string $id
+ * @property string $email
+ * @property string $password
+ * @property string $role
+ * @property \Illuminate\Support\Carbon|null $created_at
+ * @property \Illuminate\Support\Carbon|null $updated_at
+ */
+class User extends Authenticatable
+{
+    use HasApiTokens;
+    use HasFactory;
+    use HasUuids;
+    use Notifiable;
+
+    protected $fillable = [
+        'email',
+        'password',
+        'role',
+    ];
+
+    protected $hidden = [
+        'password',
+        'remember_token',
+    ];
+
+    protected function casts(): array
+    {
+        return [
+            'email_verified_at' => 'datetime',
+            'password' => 'hashed',
+        ];
+    }
+}

package/templates/stacks/php-laravel/app/Repositories/UsersRepository.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Repositories;
+
+use App\Models\User;
+
+class UsersRepository
+{
+    public function findByEmail(string $email): ?User
+    {
+        return User::query()->where('email', $email)->first();
+    }
+
+    /**
+     * @return array{0: list<User>, 1: int}
+     */
+    public function page(int $page, int $limit): array
+    {
+        $offset = ($page - 1) * $limit;
+        $items = User::query()->orderByDesc('created_at')->skip($offset)->take($limit)->get()->all();
+        $total = User::query()->count();
+        return [$items, $total];
+    }
+
+    /**
+     * @param  array{email: string, password: string, role: string}  $data
+     */
+    public function create(array $data): User
+    {
+        return User::query()->create($data);
+    }
+}

package/templates/stacks/php-laravel/app/Services/AuthService.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Services;
+
+use App\Repositories\UsersRepository;
+use Illuminate\Auth\AuthenticationException;
+use Illuminate\Support\Facades\Hash;
+
+class AuthService
+{
+    public function __construct(private readonly UsersRepository $users)
+    {
+    }
+
+    /**
+     * @param  array<string, mixed>  $input
+     * @return array{accessToken: string, tokenType: string}
+     *
+     * @throws AuthenticationException
+     */
+    public function login(array $input): array
+    {
+        $email = strtolower(trim((string) $input['email']));
+        $user = $this->users->findByEmail($email);
+
+        if ($user === null || ! Hash::check((string) $input['password'], (string) $user->password)) {
+            throw new AuthenticationException('Invalid credentials');
+        }
+
+        $token = $user->createToken('api', ['*'])->plainTextToken;
+
+        return [
+            'accessToken' => $token,
+            'tokenType' => 'Bearer',
+        ];
+    }
+}