claudeship 0.2.24 → 0.2.25

package/apps/server/dist/chat/prompts/backend/express.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPRESS_PROMPT = void 0;
+exports.EXPRESS_PROMPT = `## Backend: Express + TypeScript + Prisma
+
+You are building an Express.js backend with TypeScript and Prisma ORM.
+
+### Technology Stack (Backend)
+
+| Category | Technology | Notes |
+|----------|------------|-------|
+| Runtime | Node.js 20+ | LTS version |
+| Framework | Express 4.x | Minimal framework |
+| Language | TypeScript | Strict mode |
+| ORM | Prisma | Type-safe database access |
+| Database | SQLite (dev) / PostgreSQL (prod) | |
+| Validation | Zod | Schema validation |
+
+### Project Structure
+
+\`\`\`
+backend/
+├── src/
+│   ├── index.ts          # Entry point
+│   ├── routes/           # Route handlers
+│   ├── controllers/      # Request/response handling
+│   ├── services/         # Business logic
+│   ├── middleware/       # Express middleware
+│   └── types/            # TypeScript types
+├── prisma/
+│   └── schema.prisma     # Database schema
+├── package.json
+└── tsconfig.json
+\`\`\`
+
+### Backend Setup
+
+\`\`\`bash
+cd backend
+npm init -y
+npm install express cors dotenv zod
+npm install -D typescript @types/express @types/node @types/cors ts-node nodemon
+npm install prisma @prisma/client
+npx prisma init --datasource-provider sqlite
+\`\`\`
+
+### package.json scripts
+
+\`\`\`json
+{
+  "scripts": {
+    "dev": "nodemon --exec ts-node src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "db:push": "prisma db push",
+    "db:studio": "prisma studio"
+  }
+}
+\`\`\`
+
+### tsconfig.json
+
+\`\`\`json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}
+\`\`\`
+
+### Server Setup Pattern
+
+\`\`\`typescript
+// backend/src/index.ts
+import express from 'express';
+import cors from 'cors';
+import { PrismaClient } from '@prisma/client';
+import usersRouter from './routes/users';
+
+const app = express();
+const prisma = new PrismaClient();
+const PORT = process.env.PORT || 3001;
+
+// Middleware
+app.use(cors({ origin: 'http://localhost:3000' }));
+app.use(express.json());
+
+// Health check
+app.get('/api/health', (req, res) => {
+  res.json({ status: 'ok', timestamp: new Date().toISOString() });
+});
+
+// Routes
+app.use('/api/users', usersRouter);
+
+// Error handler
+app.use((err: Error, req: express.Request, res: express.Response, next: express.NextFunction) => {
+  console.error(err.stack);
+  res.status(500).json({ error: 'Internal server error' });
+});
+
+// Graceful shutdown
+process.on('SIGTERM', async () => {
+  await prisma.$disconnect();
+  process.exit(0);
+});
+
+app.listen(PORT, () => {
+  console.log(\`Server running on http://localhost:\${PORT}\`);
+});
+\`\`\`
+
+### Route Pattern with Zod Validation
+
+\`\`\`typescript
+// backend/src/routes/users.ts
+import { Router } from 'express';
+import { z } from 'zod';
+import { PrismaClient } from '@prisma/client';
+
+const router = Router();
+const prisma = new PrismaClient();
+
+const createUserSchema = z.object({
+  name: z.string().min(1),
+  email: z.string().email(),
+});
+
+// GET /api/users
+router.get('/', async (req, res, next) => {
+  try {
+    const users = await prisma.user.findMany();
+    res.json(users);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// GET /api/users/:id
+router.get('/:id', async (req, res, next) => {
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: parseInt(req.params.id) },
+    });
+    if (!user) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+    res.json(user);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// POST /api/users
+router.post('/', async (req, res, next) => {
+  try {
+    const data = createUserSchema.parse(req.body);
+    const user = await prisma.user.create({ data });
+    res.status(201).json(user);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return res.status(400).json({ errors: error.errors });
+    }
+    next(error);
+  }
+});
+
+// PUT /api/users/:id
+router.put('/:id', async (req, res, next) => {
+  try {
+    const data = createUserSchema.partial().parse(req.body);
+    const user = await prisma.user.update({
+      where: { id: parseInt(req.params.id) },
+      data,
+    });
+    res.json(user);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return res.status(400).json({ errors: error.errors });
+    }
+    next(error);
+  }
+});
+
+// DELETE /api/users/:id
+router.delete('/:id', async (req, res, next) => {
+  try {
+    await prisma.user.delete({
+      where: { id: parseInt(req.params.id) },
+    });
+    res.status(204).send();
+  } catch (error) {
+    next(error);
+  }
+});
+
+export default router;
+\`\`\`
+
+### Prisma Schema Example
+
+\`\`\`prisma
+// backend/prisma/schema.prisma
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "sqlite"
+  url      = "file:./dev.db"
+}
+
+model User {
+  id        Int      @id @default(autoincrement())
+  name      String
+  email     String   @unique
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  posts     Post[]
+}
+
+model Post {
+  id        Int      @id @default(autoincrement())
+  title     String
+  content   String?
+  published Boolean  @default(false)
+  authorId  Int
+  author    User     @relation(fields: [authorId], references: [id])
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+\`\`\`
+
+### API Design Guidelines
+
+- **RESTful conventions**: GET read, POST create, PUT update, DELETE delete
+- **Consistent response format**: \`{ data, error, message }\`
+- **Proper status codes**: 200 OK, 201 Created, 400 Bad Request, 404 Not Found, 500 Error
+- **Input validation**: Use Zod for all request body validation
+- **Error messages**: User-friendly messages, log technical details
+
+### Environment Variables
+
+\`\`\`
+# backend/.env
+PORT=3001
+DATABASE_URL="file:./dev.db"
+\`\`\``;
+//# sourceMappingURL=express.js.map

package/apps/server/dist/chat/prompts/backend/express.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.js","sourceRoot":"","sources":["../../../../src/chat/prompts/backend/express.ts"],"names":[],"mappings":";;;AAMa,QAAA,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+PvB,CAAC"}

package/apps/server/dist/chat/prompts/backend/fastapi.d.ts

@@ -0,0 +1 @@
+export declare const FASTAPI_PROMPT = "## Backend: FastAPI + Python + SQLAlchemy\n\nYou are building a FastAPI backend with Python and SQLAlchemy ORM.\n\n### Technology Stack (Backend)\n\n| Category | Technology | Notes |\n|----------|------------|-------|\n| Runtime | Python 3.11+ | Latest stable |\n| Framework | FastAPI | Async-first API framework |\n| ORM | SQLAlchemy 2.0 | Async support |\n| Database | SQLite (dev) / PostgreSQL (prod) | |\n| Validation | Pydantic | Built into FastAPI |\n| Server | Uvicorn | ASGI server |\n\n### Project Structure\n\n```\nbackend/\n\u251C\u2500\u2500 app/\n\u2502   \u251C\u2500\u2500 __init__.py\n\u2502   \u251C\u2500\u2500 main.py           # FastAPI app\n\u2502   \u251C\u2500\u2500 config.py         # Settings\n\u2502   \u251C\u2500\u2500 database.py       # DB connection\n\u2502   \u251C\u2500\u2500 models/           # SQLAlchemy models\n\u2502   \u2502   \u2514\u2500\u2500 user.py\n\u2502   \u251C\u2500\u2500 schemas/          # Pydantic schemas\n\u2502   \u2502   \u2514\u2500\u2500 user.py\n\u2502   \u251C\u2500\u2500 routers/          # API routes\n\u2502   \u2502   \u2514\u2500\u2500 users.py\n\u2502   \u2514\u2500\u2500 services/         # Business logic\n\u2502       \u2514\u2500\u2500 user_service.py\n\u251C\u2500\u2500 requirements.txt\n\u2514\u2500\u2500 .env\n```\n\n### Python Environment Setup (CRITICAL)\n\n**ALWAYS use virtual environment for Python projects:**\n\n```bash\ncd backend\npython -m venv venv\nsource venv/bin/activate  # Windows: venv\\Scripts\\activate\n\npip install fastapi uvicorn sqlalchemy aiosqlite python-dotenv\npip freeze > requirements.txt\n```\n\n### Virtual Environment Rules\n\n1. **ALWAYS create venv** in the `backend/` directory\n2. **NEVER install packages globally** - always use venv\n3. **Keep requirements.txt updated** after installing new packages\n4. **Include .gitignore** with venv/ excluded:\n   ```\n   # backend/.gitignore\n   venv/\n   __pycache__/\n   *.pyc\n   .env\n   *.db\n   ```\n5. **Use python -m pip** to ensure correct pip version:\n   ```bash\n   python -m pip install <package>\n   ```\n\n### Main Application\n\n```python\n# backend/app/main.py\nfrom fastapi import FastAPI\nfrom fastapi.middleware.cors import CORSMiddleware\nfrom app.database import engine, Base\nfrom app.routers import users\n\nBase.metadata.create_all(bind=engine)\n\napp = FastAPI(title=\"API\", version=\"1.0.0\")\n\napp.add_middleware(\n    CORSMiddleware,\n    allow_origins=[\"http://localhost:3000\"],\n    allow_credentials=True,\n    allow_methods=[\"*\"],\n    allow_headers=[\"*\"],\n)\n\napp.include_router(users.router, prefix=\"/api/users\", tags=[\"users\"])\n\n@app.get(\"/api/health\")\nasync def health_check():\n    return {\"status\": \"ok\"}\n```\n\n### Database Configuration\n\n```python\n# backend/app/database.py\nfrom sqlalchemy import create_engine\nfrom sqlalchemy.ext.declarative import declarative_base\nfrom sqlalchemy.orm import sessionmaker\nimport os\n\nDATABASE_URL = os.getenv(\"DATABASE_URL\", \"sqlite:///./dev.db\")\n\nengine = create_engine(DATABASE_URL, connect_args={\"check_same_thread\": False})\nSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)\nBase = declarative_base()\n\ndef get_db():\n    db = SessionLocal()\n    try:\n        yield db\n    finally:\n        db.close()\n```\n\n### SQLAlchemy Model\n\n```python\n# backend/app/models/user.py\nfrom sqlalchemy import Column, Integer, String, DateTime\nfrom sqlalchemy.sql import func\nfrom app.database import Base\n\nclass User(Base):\n    __tablename__ = \"users\"\n\n    id = Column(Integer, primary_key=True, index=True)\n    name = Column(String, nullable=False)\n    email = Column(String, unique=True, index=True, nullable=False)\n    created_at = Column(DateTime(timezone=True), server_default=func.now())\n    updated_at = Column(DateTime(timezone=True), onupdate=func.now())\n```\n\n### Pydantic Schemas\n\n```python\n# backend/app/schemas/user.py\nfrom pydantic import BaseModel, EmailStr\nfrom datetime import datetime\nfrom typing import Optional\n\nclass UserBase(BaseModel):\n    name: str\n    email: EmailStr\n\nclass UserCreate(UserBase):\n    pass\n\nclass UserUpdate(BaseModel):\n    name: Optional[str] = None\n    email: Optional[EmailStr] = None\n\nclass UserResponse(UserBase):\n    id: int\n    created_at: datetime\n    updated_at: Optional[datetime] = None\n\n    class Config:\n        from_attributes = True\n```\n\n### Router with CRUD\n\n```python\n# backend/app/routers/users.py\nfrom fastapi import APIRouter, Depends, HTTPException\nfrom sqlalchemy.orm import Session\nfrom typing import List\n\nfrom app.database import get_db\nfrom app.models.user import User\nfrom app.schemas.user import UserCreate, UserUpdate, UserResponse\n\nrouter = APIRouter()\n\n@router.get(\"/\", response_model=List[UserResponse])\ndef get_users(db: Session = Depends(get_db)):\n    return db.query(User).all()\n\n@router.get(\"/{user_id}\", response_model=UserResponse)\ndef get_user(user_id: int, db: Session = Depends(get_db)):\n    user = db.query(User).filter(User.id == user_id).first()\n    if not user:\n        raise HTTPException(status_code=404, detail=\"User not found\")\n    return user\n\n@router.post(\"/\", response_model=UserResponse, status_code=201)\ndef create_user(user: UserCreate, db: Session = Depends(get_db)):\n    db_user = User(**user.model_dump())\n    db.add(db_user)\n    db.commit()\n    db.refresh(db_user)\n    return db_user\n\n@router.put(\"/{user_id}\", response_model=UserResponse)\ndef update_user(user_id: int, user: UserUpdate, db: Session = Depends(get_db)):\n    db_user = db.query(User).filter(User.id == user_id).first()\n    if not db_user:\n        raise HTTPException(status_code=404, detail=\"User not found\")\n\n    update_data = user.model_dump(exclude_unset=True)\n    for key, value in update_data.items():\n        setattr(db_user, key, value)\n\n    db.commit()\n    db.refresh(db_user)\n    return db_user\n\n@router.delete(\"/{user_id}\", status_code=204)\ndef delete_user(user_id: int, db: Session = Depends(get_db)):\n    db_user = db.query(User).filter(User.id == user_id).first()\n    if not db_user:\n        raise HTTPException(status_code=404, detail=\"User not found\")\n    db.delete(db_user)\n    db.commit()\n```\n\n### Run Command\n\n```bash\n# Do NOT run this - the preview system handles it\nuvicorn app.main:app --reload --port 3001\n```\n\n### Environment Variables\n\n```\n# backend/.env\nDATABASE_URL=sqlite:///./dev.db\n```\n\n### API Design Guidelines\n\n- **RESTful conventions**: GET read, POST create, PUT update, DELETE delete\n- **Use Pydantic schemas** for request/response validation\n- **Dependency injection** with `Depends()`\n- **Proper status codes**: 200, 201, 400, 404, 500\n- **HTTPException** for error responses";

package/apps/server/dist/chat/prompts/backend/fastapi.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FASTAPI_PROMPT = void 0;
+exports.FASTAPI_PROMPT = `## Backend: FastAPI + Python + SQLAlchemy
+
+You are building a FastAPI backend with Python and SQLAlchemy ORM.
+
+### Technology Stack (Backend)
+
+| Category | Technology | Notes |
+|----------|------------|-------|
+| Runtime | Python 3.11+ | Latest stable |
+| Framework | FastAPI | Async-first API framework |
+| ORM | SQLAlchemy 2.0 | Async support |
+| Database | SQLite (dev) / PostgreSQL (prod) | |
+| Validation | Pydantic | Built into FastAPI |
+| Server | Uvicorn | ASGI server |
+
+### Project Structure
+
+\`\`\`
+backend/
+├── app/
+│   ├── __init__.py
+│   ├── main.py           # FastAPI app
+│   ├── config.py         # Settings
+│   ├── database.py       # DB connection
+│   ├── models/           # SQLAlchemy models
+│   │   └── user.py
+│   ├── schemas/          # Pydantic schemas
+│   │   └── user.py
+│   ├── routers/          # API routes
+│   │   └── users.py
+│   └── services/         # Business logic
+│       └── user_service.py
+├── requirements.txt
+└── .env
+\`\`\`
+
+### Python Environment Setup (CRITICAL)
+
+**ALWAYS use virtual environment for Python projects:**
+
+\`\`\`bash
+cd backend
+python -m venv venv
+source venv/bin/activate  # Windows: venv\\Scripts\\activate
+
+pip install fastapi uvicorn sqlalchemy aiosqlite python-dotenv
+pip freeze > requirements.txt
+\`\`\`
+
+### Virtual Environment Rules
+
+1. **ALWAYS create venv** in the \`backend/\` directory
+2. **NEVER install packages globally** - always use venv
+3. **Keep requirements.txt updated** after installing new packages
+4. **Include .gitignore** with venv/ excluded:
+   \`\`\`
+   # backend/.gitignore
+   venv/
+   __pycache__/
+   *.pyc
+   .env
+   *.db
+   \`\`\`
+5. **Use python -m pip** to ensure correct pip version:
+   \`\`\`bash
+   python -m pip install <package>
+   \`\`\`
+
+### Main Application
+
+\`\`\`python
+# backend/app/main.py
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.database import engine, Base
+from app.routers import users
+
+Base.metadata.create_all(bind=engine)
+
+app = FastAPI(title="API", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(users.router, prefix="/api/users", tags=["users"])
+
+@app.get("/api/health")
+async def health_check():
+    return {"status": "ok"}
+\`\`\`
+
+### Database Configuration
+
+\`\`\`python
+# backend/app/database.py
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+import os
+
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///./dev.db")
+
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+\`\`\`
+
+### SQLAlchemy Model
+
+\`\`\`python
+# backend/app/models/user.py
+from sqlalchemy import Column, Integer, String, DateTime
+from sqlalchemy.sql import func
+from app.database import Base
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, nullable=False)
+    email = Column(String, unique=True, index=True, nullable=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+\`\`\`
+
+### Pydantic Schemas
+
+\`\`\`python
+# backend/app/schemas/user.py
+from pydantic import BaseModel, EmailStr
+from datetime import datetime
+from typing import Optional
+
+class UserBase(BaseModel):
+    name: str
+    email: EmailStr
+
+class UserCreate(UserBase):
+    pass
+
+class UserUpdate(BaseModel):
+    name: Optional[str] = None
+    email: Optional[EmailStr] = None
+
+class UserResponse(UserBase):
+    id: int
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+\`\`\`
+
+### Router with CRUD
+
+\`\`\`python
+# backend/app/routers/users.py
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List
+
+from app.database import get_db
+from app.models.user import User
+from app.schemas.user import UserCreate, UserUpdate, UserResponse
+
+router = APIRouter()
+
+@router.get("/", response_model=List[UserResponse])
+def get_users(db: Session = Depends(get_db)):
+    return db.query(User).all()
+
+@router.get("/{user_id}", response_model=UserResponse)
+def get_user(user_id: int, db: Session = Depends(get_db)):
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+
+@router.post("/", response_model=UserResponse, status_code=201)
+def create_user(user: UserCreate, db: Session = Depends(get_db)):
+    db_user = User(**user.model_dump())
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return db_user
+
+@router.put("/{user_id}", response_model=UserResponse)
+def update_user(user_id: int, user: UserUpdate, db: Session = Depends(get_db)):
+    db_user = db.query(User).filter(User.id == user_id).first()
+    if not db_user:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    update_data = user.model_dump(exclude_unset=True)
+    for key, value in update_data.items():
+        setattr(db_user, key, value)
+
+    db.commit()
+    db.refresh(db_user)
+    return db_user
+
+@router.delete("/{user_id}", status_code=204)
+def delete_user(user_id: int, db: Session = Depends(get_db)):
+    db_user = db.query(User).filter(User.id == user_id).first()
+    if not db_user:
+        raise HTTPException(status_code=404, detail="User not found")
+    db.delete(db_user)
+    db.commit()
+\`\`\`
+
+### Run Command
+
+\`\`\`bash
+# Do NOT run this - the preview system handles it
+uvicorn app.main:app --reload --port 3001
+\`\`\`
+
+### Environment Variables
+
+\`\`\`
+# backend/.env
+DATABASE_URL=sqlite:///./dev.db
+\`\`\`
+
+### API Design Guidelines
+
+- **RESTful conventions**: GET read, POST create, PUT update, DELETE delete
+- **Use Pydantic schemas** for request/response validation
+- **Dependency injection** with \`Depends()\`
+- **Proper status codes**: 200, 201, 400, 404, 500
+- **HTTPException** for error responses`;
+//# sourceMappingURL=fastapi.js.map

package/apps/server/dist/chat/prompts/backend/fastapi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastapi.js","sourceRoot":"","sources":["../../../../src/chat/prompts/backend/fastapi.ts"],"names":[],"mappings":";;;AAMa,QAAA,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAiPU,CAAC"}

package/apps/server/dist/chat/prompts/backend/index.d.ts

@@ -0,0 +1,4 @@
+export { EXPRESS_PROMPT } from "./express";
+export { FASTAPI_PROMPT } from "./fastapi";
+export { DJANGO_PROMPT } from "./django";
+export { NESTJS_PROMPT } from "./nestjs";

package/apps/server/dist/chat/prompts/backend/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NESTJS_PROMPT = exports.DJANGO_PROMPT = exports.FASTAPI_PROMPT = exports.EXPRESS_PROMPT = void 0;
+var express_1 = require("./express");
+Object.defineProperty(exports, "EXPRESS_PROMPT", { enumerable: true, get: function () { return express_1.EXPRESS_PROMPT; } });
+var fastapi_1 = require("./fastapi");
+Object.defineProperty(exports, "FASTAPI_PROMPT", { enumerable: true, get: function () { return fastapi_1.FASTAPI_PROMPT; } });
+var django_1 = require("./django");
+Object.defineProperty(exports, "DJANGO_PROMPT", { enumerable: true, get: function () { return django_1.DJANGO_PROMPT; } });
+var nestjs_1 = require("./nestjs");
+Object.defineProperty(exports, "NESTJS_PROMPT", { enumerable: true, get: function () { return nestjs_1.NESTJS_PROMPT; } });
+//# sourceMappingURL=index.js.map

package/apps/server/dist/chat/prompts/backend/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/chat/prompts/backend/index.ts"],"names":[],"mappings":";;;AAMA,qCAA2C;AAAlC,yGAAA,cAAc,OAAA;AACvB,qCAA2C;AAAlC,yGAAA,cAAc,OAAA;AACvB,mCAAyC;AAAhC,uGAAA,aAAa,OAAA;AACtB,mCAAyC;AAAhC,uGAAA,aAAa,OAAA"}

package/apps/server/dist/chat/prompts/backend/nestjs.d.ts

@@ -0,0 +1 @@
+export declare const NESTJS_PROMPT = "## Backend: NestJS + TypeScript + Prisma\n\nYou are building a NestJS backend with TypeScript and Prisma ORM.\n\n### Technology Stack (Backend)\n\n| Category | Technology | Notes |\n|----------|------------|-------|\n| Runtime | Node.js 20+ | LTS version |\n| Framework | NestJS 10+ | Enterprise-grade |\n| Language | TypeScript | Strict mode |\n| ORM | Prisma | Type-safe database access |\n| Database | SQLite (dev) / PostgreSQL (prod) | |\n| Validation | class-validator | DTO validation |\n\n### Project Structure\n\n```\nbackend/\n\u251C\u2500\u2500 src/\n\u2502   \u251C\u2500\u2500 main.ts                  # Entry point\n\u2502   \u251C\u2500\u2500 app.module.ts            # Root module\n\u2502   \u251C\u2500\u2500 prisma/\n\u2502   \u2502   \u251C\u2500\u2500 prisma.module.ts\n\u2502   \u2502   \u2514\u2500\u2500 prisma.service.ts\n\u2502   \u2514\u2500\u2500 users/\n\u2502       \u251C\u2500\u2500 users.module.ts\n\u2502       \u251C\u2500\u2500 users.controller.ts\n\u2502       \u251C\u2500\u2500 users.service.ts\n\u2502       \u2514\u2500\u2500 dto/\n\u2502           \u251C\u2500\u2500 create-user.dto.ts\n\u2502           \u2514\u2500\u2500 update-user.dto.ts\n\u251C\u2500\u2500 prisma/\n\u2502   \u2514\u2500\u2500 schema.prisma\n\u251C\u2500\u2500 package.json\n\u2514\u2500\u2500 tsconfig.json\n```\n\n### Backend Setup\n\n```bash\ncd backend\nnpm init -y\nnpm install @nestjs/core @nestjs/common @nestjs/platform-express reflect-metadata rxjs\nnpm install class-validator class-transformer\nnpm install prisma @prisma/client\nnpm install -D typescript @types/node @types/express ts-node\nnpx prisma init --datasource-provider sqlite\n```\n\n### Main Entry Point\n\n```typescript\n// backend/src/main.ts\nimport { NestFactory } from '@nestjs/core';\nimport { ValidationPipe } from '@nestjs/common';\nimport { AppModule } from './app.module';\n\nasync function bootstrap() {\n  const app = await NestFactory.create(AppModule);\n\n  app.enableCors({\n    origin: 'http://localhost:3000',\n  });\n\n  app.setGlobalPrefix('api');\n  app.useGlobalPipes(new ValidationPipe({ transform: true }));\n\n  await app.listen(3001);\n  console.log('Server running on http://localhost:3001');\n}\nbootstrap();\n```\n\n### App Module\n\n```typescript\n// backend/src/app.module.ts\nimport { Module } from '@nestjs/common';\nimport { PrismaModule } from './prisma/prisma.module';\nimport { UsersModule } from './users/users.module';\n\n@Module({\n  imports: [PrismaModule, UsersModule],\n})\nexport class AppModule {}\n```\n\n### Prisma Service\n\n```typescript\n// backend/src/prisma/prisma.service.ts\nimport { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';\nimport { PrismaClient } from '@prisma/client';\n\n@Injectable()\nexport class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {\n  async onModuleInit() {\n    await this.$connect();\n  }\n\n  async onModuleDestroy() {\n    await this.$disconnect();\n  }\n}\n```\n\n```typescript\n// backend/src/prisma/prisma.module.ts\nimport { Module, Global } from '@nestjs/common';\nimport { PrismaService } from './prisma.service';\n\n@Global()\n@Module({\n  providers: [PrismaService],\n  exports: [PrismaService],\n})\nexport class PrismaModule {}\n```\n\n### DTOs with Validation\n\n```typescript\n// backend/src/users/dto/create-user.dto.ts\nimport { IsString, IsEmail, MinLength } from 'class-validator';\n\nexport class CreateUserDto {\n  @IsString()\n  @MinLength(1)\n  name: string;\n\n  @IsEmail()\n  email: string;\n}\n```\n\n```typescript\n// backend/src/users/dto/update-user.dto.ts\nimport { PartialType } from '@nestjs/common';\nimport { CreateUserDto } from './create-user.dto';\n\nexport class UpdateUserDto extends PartialType(CreateUserDto) {}\n```\n\n### Service\n\n```typescript\n// backend/src/users/users.service.ts\nimport { Injectable, NotFoundException } from '@nestjs/common';\nimport { PrismaService } from '../prisma/prisma.service';\nimport { CreateUserDto } from './dto/create-user.dto';\nimport { UpdateUserDto } from './dto/update-user.dto';\n\n@Injectable()\nexport class UsersService {\n  constructor(private prisma: PrismaService) {}\n\n  async findAll() {\n    return this.prisma.user.findMany();\n  }\n\n  async findOne(id: number) {\n    const user = await this.prisma.user.findUnique({ where: { id } });\n    if (!user) {\n      throw new NotFoundException(`User #${id} not found`);\n    }\n    return user;\n  }\n\n  async create(createUserDto: CreateUserDto) {\n    return this.prisma.user.create({ data: createUserDto });\n  }\n\n  async update(id: number, updateUserDto: UpdateUserDto) {\n    await this.findOne(id); // Check existence\n    return this.prisma.user.update({\n      where: { id },\n      data: updateUserDto,\n    });\n  }\n\n  async remove(id: number) {\n    await this.findOne(id); // Check existence\n    return this.prisma.user.delete({ where: { id } });\n  }\n}\n```\n\n### Controller\n\n```typescript\n// backend/src/users/users.controller.ts\nimport {\n  Controller,\n  Get,\n  Post,\n  Put,\n  Delete,\n  Body,\n  Param,\n  ParseIntPipe,\n  HttpCode,\n  HttpStatus,\n} from '@nestjs/common';\nimport { UsersService } from './users.service';\nimport { CreateUserDto } from './dto/create-user.dto';\nimport { UpdateUserDto } from './dto/update-user.dto';\n\n@Controller('users')\nexport class UsersController {\n  constructor(private readonly usersService: UsersService) {}\n\n  @Get()\n  findAll() {\n    return this.usersService.findAll();\n  }\n\n  @Get(':id')\n  findOne(@Param('id', ParseIntPipe) id: number) {\n    return this.usersService.findOne(id);\n  }\n\n  @Post()\n  @HttpCode(HttpStatus.CREATED)\n  create(@Body() createUserDto: CreateUserDto) {\n    return this.usersService.create(createUserDto);\n  }\n\n  @Put(':id')\n  update(\n    @Param('id', ParseIntPipe) id: number,\n    @Body() updateUserDto: UpdateUserDto,\n  ) {\n    return this.usersService.update(id, updateUserDto);\n  }\n\n  @Delete(':id')\n  @HttpCode(HttpStatus.NO_CONTENT)\n  remove(@Param('id', ParseIntPipe) id: number) {\n    return this.usersService.remove(id);\n  }\n}\n```\n\n### Module\n\n```typescript\n// backend/src/users/users.module.ts\nimport { Module } from '@nestjs/common';\nimport { UsersController } from './users.controller';\nimport { UsersService } from './users.service';\n\n@Module({\n  controllers: [UsersController],\n  providers: [UsersService],\n})\nexport class UsersModule {}\n```\n\n### API Design Guidelines\n\n- **Decorators for everything**: @Controller, @Get, @Post, etc.\n- **DTOs for validation**: Use class-validator decorators\n- **Dependency Injection**: Inject services via constructor\n- **Exception filters**: Use built-in exceptions (NotFoundException, etc.)\n- **Pipes for transformation**: ParseIntPipe, ValidationPipe";