multi-agents-cli 1.1.9 → 1.1.10

package/core/templates/.frameworks/backend/django.md

@@ -0,0 +1,55 @@
+# Django — Scaffold Instructions
+
+## Critical: Use the Dot Argument
+
+Django creates a subfolder by default. Use `.` as the project name to scaffold in place:
+
+```bash
+cd backend
+django-admin startproject config .
+```
+
+The `.` argument tells Django to scaffold in the current directory.
+
+## Expected Structure After Scaffold
+
+```
+backend/
+  config/
+    __init__.py
+    asgi.py
+    settings.py
+    urls.py
+    wsgi.py
+  manage.py
+  requirements.txt
+```
+
+## Post-Scaffold
+
+```bash
+cd backend
+python -m venv venv
+source venv/bin/activate
+pip install django djangorestframework python-dotenv
+pip freeze > requirements.txt
+```
+
+## Update .scaffold/.paths.json
+
+```json
+{
+  "backend": {
+    "schemasDir": {
+      "expected": "backend/api/serializers",
+      "current": "backend/api/serializers",
+      "status": "verified"
+    },
+    "modelsDir": {
+      "expected": "backend/api/models",
+      "current": "backend/api/models",
+      "status": "verified"
+    }
+  }
+}
+```

package/core/templates/.frameworks/backend/express.md

@@ -0,0 +1,74 @@
+# Express — Scaffold Instructions
+
+## Scaffold Location
+
+Express has no official scaffold CLI. Create the structure manually inside `backend/`:
+
+```bash
+mkdir -p backend/src/routes
+mkdir -p backend/src/middleware
+mkdir -p backend/src/services
+mkdir -p backend/src/types
+touch backend/src/index.ts
+touch backend/src/app.ts
+```
+
+## package.json
+
+```json
+{
+  "name": "backend",
+  "version": "1.0.0",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "express": "^4.18.0",
+    "cors": "^2.8.5",
+    "dotenv": "^16.0.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.0",
+    "@types/cors": "^2.8.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "tsx": "^4.0.0"
+  }
+}
+```
+
+## app.ts Template
+
+```typescript
+import express from 'express';
+import cors from 'cors';
+
+export const app = express();
+
+app.use(cors({ origin: process.env.CLIENT_URL || 'http://localhost:3000' }));
+app.use(express.json());
+
+app.get('/health', (_, res) => res.json({ status: 'ok' }));
+```
+
+## Post-Scaffold
+
+```bash
+cd backend && npm install
+```
+
+## Update .scaffold/.paths.json
+
+```json
+{
+  "backend": {
+    "typesDir": {
+      "expected": "backend/src/types",
+      "current": "backend/src/types",
+      "status": "verified"
+    }
+  }
+}
+```

package/core/templates/.frameworks/backend/fastapi.md

@@ -0,0 +1,107 @@
+# FastAPI — Scaffold Instructions
+
+## Critical: Scaffold Location
+
+You are working inside a git worktree. Your root is the **repo root**, not `backend/`.
+All FastAPI files MUST live under `backend/`. Do NOT scaffold at the repo root.
+
+FastAPI has no official scaffold CLI — create the structure manually:
+
+```bash
+mkdir -p backend/app/api/routes
+mkdir -p backend/app/schemas
+mkdir -p backend/app/models
+mkdir -p backend/app/services
+mkdir -p backend/app/core
+touch backend/app/__init__.py
+touch backend/app/main.py
+touch backend/app/api/__init__.py
+touch backend/app/api/routes/__init__.py
+touch backend/app/schemas/__init__.py
+touch backend/app/models/__init__.py
+touch backend/app/services/__init__.py
+touch backend/app/core/__init__.py
+touch backend/app/core/config.py
+```
+
+## Expected Structure After Scaffold
+
+```
+backend/
+  app/
+    api/
+      routes/
+        __init__.py
+    core/
+      config.py
+      __init__.py
+    models/
+      __init__.py
+    schemas/
+      __init__.py
+    services/
+      __init__.py
+    __init__.py
+    main.py
+  requirements.txt
+  .env.example
+```
+
+## main.py Template
+
+```python
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI(title="{{PROJECT_NAME}}")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+```
+
+## requirements.txt
+
+```
+fastapi>=0.100.0
+uvicorn[standard]>=0.23.0
+pydantic>=2.0.0
+python-dotenv>=1.0.0
+```
+
+## Post-Scaffold
+
+```bash
+cd backend
+python -m venv venv
+source venv/bin/activate  # Windows: venv\Scripts\activate
+pip install -r requirements.txt
+```
+
+## Update .scaffold/.paths.json
+
+After scaffolding, update `current` paths and set `status: verified`:
+```json
+{
+  "backend": {
+    "schemasDir": {
+      "expected": "backend/app/schemas",
+      "current": "backend/app/schemas",
+      "status": "verified"
+    },
+    "modelsDir": {
+      "expected": "backend/app/models",
+      "current": "backend/app/models",
+      "status": "verified"
+    }
+  }
+}
+```

package/core/templates/.frameworks/backend/fastify.md

@@ -0,0 +1,74 @@
+# Fastify — Scaffold Instructions
+
+## Scaffold Location
+
+Fastify has no official scaffold CLI. Create the structure manually inside `backend/`:
+
+```bash
+mkdir -p backend/src/routes
+mkdir -p backend/src/plugins
+mkdir -p backend/src/schemas
+mkdir -p backend/src/services
+mkdir -p backend/src/types
+touch backend/src/app.ts
+touch backend/src/index.ts
+```
+
+## package.json
+
+```json
+{
+  "name": "backend",
+  "version": "1.0.0",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "fastify": "^4.0.0",
+    "@fastify/cors": "^8.0.0",
+    "dotenv": "^16.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "tsx": "^4.0.0"
+  }
+}
+```
+
+## app.ts Template
+
+```typescript
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+
+export const app = Fastify({ logger: true });
+
+await app.register(cors, {
+  origin: process.env.CLIENT_URL || 'http://localhost:3000',
+});
+
+app.get('/health', async () => ({ status: 'ok' }));
+```
+
+## Post-Scaffold
+
+```bash
+cd backend && npm install
+```
+
+## Update .scaffold/.paths.json
+
+```json
+{
+  "backend": {
+    "typesDir": {
+      "expected": "backend/src/types",
+      "current": "backend/src/types",
+      "status": "verified"
+    }
+  }
+}
+```

package/core/templates/.frameworks/backend/laravel.md

@@ -0,0 +1,79 @@
+# Laravel — Scaffold Instructions
+
+## Scaffold Location
+
+Use the Laravel installer inside the project root:
+
+```bash
+composer create-project laravel/laravel backend
+```
+
+## Key Directory Structure
+
+```
+backend/
+  app/
+    Http/
+      Controllers/
+      Middleware/
+    Models/
+    Services/
+  routes/
+    api.php
+    web.php
+  database/
+    migrations/
+    seeders/
+  config/
+  tests/
+```
+
+## composer.json (key dependencies)
+
+```json
+{
+  "require": {
+    "php": "^8.2",
+    "laravel/framework": "^11.0",
+    "laravel/sanctum": "^4.0"
+  },
+  "require-dev": {
+    "phpunit/phpunit": "^11.0"
+  }
+}
+```
+
+## routes/api.php Template
+
+```php
+<?php
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Route;
+
+Route::get('/health', fn() => response()->json(['status' => 'ok']));
+
+Route::middleware('auth:sanctum')->group(function () {
+    Route::get('/user', fn(Request $request) => $request->user());
+});
+```
+
+## Post-Scaffold
+
+```bash
+cd backend
+composer install
+cp .env.example .env
+php artisan key:generate
+php artisan migrate
+```
+
+## Update .scaffold/.paths.json
+
+```json
+{
+  "backend": {
+    "routesDir": { "expected": "backend/routes", "current": "backend/routes", "status": "verified" },
+    "modelsDir": { "expected": "backend/app/Models", "current": "backend/app/Models", "status": "verified" }
+  }
+}
+```

package/core/templates/.frameworks/backend/nestjs.md

@@ -0,0 +1,75 @@
+# NestJS — Scaffold Instructions
+
+## Critical: Scaffold Location
+
+You are working inside a git worktree. Your root is the **repo root**, not `backend/`.
+All NestJS files MUST live under `backend/`. Do NOT scaffold at the repo root.
+
+NestJS's `nest new` creates a subfolder by default. To scaffold in place:
+
+```bash
+# From the REPO ROOT — scaffold directly into backend/
+nest new . --directory backend --skip-git --package-manager npm
+```
+
+OR scaffold with period to use current directory:
+```bash
+cd backend
+nest new . --skip-git --package-manager npm
+```
+
+## Expected Structure After Scaffold
+
+```
+backend/
+  src/
+    app.controller.ts
+    app.controller.spec.ts
+    app.module.ts
+    app.service.ts
+    main.ts
+  test/
+  nest-cli.json
+  package.json
+  tsconfig.json
+  tsconfig.build.json
+```
+
+## Verify Location
+
+After scaffolding, confirm:
+```bash
+ls backend/src/main.ts     # should exist
+ls backend/nest-cli.json   # should exist
+```
+
+If files landed at `backend/my-app/` instead of `backend/` — move them up:
+```bash
+mv backend/my-app/* backend/
+mv backend/my-app/.* backend/ 2>/dev/null || true
+rmdir backend/my-app
+```
+
+## Post-Scaffold
+
+```bash
+cd backend
+npm install
+```
+
+## Update .scaffold/.paths.json
+
+After scaffolding, update `current` paths and set `status: verified`:
+```json
+{
+  "backend": {
+    "dtoDir": {
+      "expected": "backend/src/dto",
+      "current": "backend/src/dto",
+      "status": "verified"
+    }
+  }
+}
+```
+
+Create `backend/src/dto/` if it doesn't exist.

package/core/templates/.frameworks/backend/rails.md

@@ -0,0 +1,84 @@
+# Ruby on Rails — Scaffold Instructions
+
+## Scaffold Location
+
+Use the Rails CLI from the project root:
+
+```bash
+rails new backend --api --database=postgresql
+```
+
+Flags:
+- `--api` strips views, uses API-only middleware stack
+- `--database` set to your chosen DB: postgresql, mysql, sqlite3
+
+## Key Directory Structure
+
+```
+backend/
+  app/
+    controllers/
+      api/
+        v1/
+    models/
+    serializers/
+    services/
+  config/
+    routes.rb
+  db/
+    migrate/
+    schema.rb
+  spec/
+    requests/
+    models/
+```
+
+## Gemfile (key dependencies)
+
+```ruby
+gem 'rails', '~> 7.2'
+gem 'pg', '~> 1.5'
+gem 'puma', '>= 5.0'
+gem 'rack-cors'
+gem 'devise'
+gem 'jwt'
+
+group :development, :test do
+  gem 'rspec-rails'
+  gem 'factory_bot_rails'
+end
+```
+
+## config/routes.rb Template
+
+```ruby
+Rails.application.routes.draw do
+  get '/health', to: proc { [200, {}, [{ status: 'ok' }.to_json]] }
+
+  namespace :api do
+    namespace :v1 do
+      # define resources here
+    end
+  end
+end
+```
+
+## Post-Scaffold
+
+```bash
+cd backend
+bundle install
+rails db:create
+rails db:migrate
+```
+
+## Update .scaffold/.paths.json
+
+```json
+{
+  "backend": {
+    "modelsDir": { "expected": "backend/app/models", "current": "backend/app/models", "status": "verified" },
+    "schemasDir": { "expected": "backend/app/serializers", "current": "backend/app/serializers", "status": "verified" }
+  }
+}
+```

package/core/templates/.frameworks/client/angular.md

@@ -0,0 +1,80 @@
+# Angular — Scaffold Instructions
+
+## Critical: Scaffold Location
+
+You are working inside a git worktree. Your root is the **repo root**, not `client/`.
+All Angular files MUST live under `client/`. Do NOT scaffold at the repo root.
+
+Angular's `ng new` creates a subfolder by default. To scaffold correctly:
+
+```bash
+# From the REPO ROOT — create a temp app, then move files into client/
+ng new temp-app --directory client --skip-git --routing --style=scss
+```
+
+OR using the `--directory` flag directly:
+
+```bash
+ng new my-app --directory client --skip-git --routing --style=scss
+```
+
+This places all Angular files inside `client/` at the correct level.
+
+## Expected Structure After Scaffold
+
+```
+client/
+  src/
+    app/
+      app.component.ts
+      app.component.html
+      app.config.ts
+      app.routes.ts
+    assets/
+    index.html
+    main.ts
+    styles.scss
+  angular.json
+  package.json
+  tsconfig.json
+  tsconfig.app.json
+```
+
+## Verify Location
+
+After scaffolding, confirm:
+```bash
+ls client/src/app/   # should show app.component.ts
+ls client/angular.json  # should exist
+```
+
+If files landed at `client/my-app/` instead of `client/` — move them up:
+```bash
+mv client/my-app/* client/
+mv client/my-app/.* client/ 2>/dev/null || true
+rmdir client/my-app
+```
+
+## Post-Scaffold
+
+```bash
+cd client
+npm install
+```
+
+## Update .scaffold/.paths.json
+
+After scaffolding, update `current` paths and set `status: verified`:
+```json
+{
+  "client": {
+    "typesDir": {
+      "expected": "client/src/app/core/types",
+      "current": "client/src/app/core/types",
+      "status": "verified"
+    }
+  }
+}
+```
+
+Create `client/src/app/core/types/` if it doesn't exist — this is where shared types live.

package/core/templates/.frameworks/client/nextjs.md

@@ -0,0 +1,47 @@
+# Next.js — Scaffold Instructions
+
+## Scaffold Location
+
+Scaffold directly into `client/` from the repo root:
+
+```bash
+npx create-next-app@latest client --typescript --tailwind --eslint --app --src-dir --import-alias "@/*" --no-git
+```
+
+## Expected Structure After Scaffold
+
+```
+client/
+  src/
+    app/
+      layout.tsx
+      page.tsx
+      globals.css
+    lib/
+  public/
+  next.config.ts
+  package.json
+  tsconfig.json
+  tailwind.config.ts
+  postcss.config.mjs
+```
+
+## Post-Scaffold
+
+Dependencies are installed automatically by create-next-app.
+
+## Update .scaffold/.paths.json
+
+```json
+{
+  "client": {
+    "typesDir": {
+      "expected": "client/src/types",
+      "current": "client/src/types",
+      "status": "verified"
+    }
+  }
+}
+```
+
+Create `client/src/types/` — this is where shared types live.