dotclaudemd 0.1.1

package/templates/javascript/nextjs-prisma-tailwind.md

@@ -0,0 +1,58 @@
+---
+name: nextjs-prisma-tailwind
+displayName: Next.js + Prisma + Tailwind
+description: Full-stack Next.js with Prisma ORM and Tailwind CSS
+category: javascript
+tags: [javascript, typescript, nextjs, prisma, tailwind, fullstack]
+variables:
+  - name: db_provider
+    prompt: "Database provider?"
+    options: [PostgreSQL, MySQL, SQLite]
+    default: PostgreSQL
+  - name: auth_provider
+    prompt: "Auth provider?"
+    options: [NextAuth.js, Clerk, Auth0]
+    default: NextAuth.js
+detects:
+  files: [package.json, prisma/schema.prisma]
+  dependencies: [next, "@prisma/client"]
+priority: 15
+---
+
+# Project
+
+Next.js full-stack application with Prisma ORM ({{db_provider}}) and Tailwind CSS.
+
+## Commands
+
+- `npm run dev` — Start dev server
+- `npm run build` — Production build
+- `npx prisma generate` — Regenerate Prisma Client after schema changes
+- `npx prisma db push` — Push schema changes to database
+- `npx prisma migrate dev` — Create and apply migration
+- `npx prisma studio` — Open database browser
+- `npm test` — Run tests
+
+## Architecture
+
+- `src/app/` — App Router pages, layouts, API routes
+- `src/components/` — React components
+- `src/lib/` — Shared utilities, Prisma client singleton
+- `prisma/schema.prisma` — Database schema
+- `prisma/migrations/` — Migration history
+
+## Database (Prisma)
+
+- Schema lives in `prisma/schema.prisma`
+- Always run `npx prisma generate` after editing the schema
+- Use a singleton Prisma Client (see `src/lib/prisma.ts`)
+- Use `select` or `include` to avoid over-fetching; prefer `select` for performance
+- Use transactions for multi-step writes
+
+## Auth
+
+Authentication via {{auth_provider}}. Protect API routes and server actions by checking the session.
+
+## Styling
+
+Tailwind CSS with `cn()` helper for conditional classes. Use `@apply` sparingly — prefer utility classes in JSX.

package/templates/javascript/nextjs-typescript.md

@@ -0,0 +1,57 @@
+---
+name: nextjs-typescript
+displayName: Next.js + TypeScript
+description: Next.js App Router with TypeScript
+category: javascript
+tags: [javascript, typescript, nextjs, react, ssr]
+variables:
+  - name: src_dir
+    prompt: "Source directory?"
+    options: [src, app]
+    default: src
+  - name: styling
+    prompt: "Styling solution?"
+    options: [Tailwind CSS, CSS Modules, styled-components]
+    default: Tailwind CSS
+detects:
+  files: [package.json, next.config.mjs, next.config.js, next.config.ts]
+  dependencies: [next, react]
+priority: 20
+---
+
+# Project
+
+Next.js application with TypeScript and App Router.
+
+## Commands
+
+- `npm run dev` — Start dev server on localhost:3000
+- `npm run build` — Production build
+- `npm run start` — Start production server
+- `npm test` — Run tests
+- `npm run lint` — Run ESLint + Next.js lint rules
+
+## Architecture
+
+- `{{src_dir}}/app/` — App Router pages and layouts
+- `{{src_dir}}/app/api/` — API route handlers
+- `{{src_dir}}/components/` — Reusable React components
+- `{{src_dir}}/lib/` — Shared utilities and helpers
+- `public/` — Static assets
+
+## Conventions
+
+- Use Server Components by default; add `'use client'` only when needed (state, effects, browser APIs)
+- Colocate loading.tsx, error.tsx, and not-found.tsx in route segments
+- Use `{{styling}}` for styling
+- Fetch data in Server Components using `fetch` with Next.js caching
+- Use Server Actions for mutations instead of API routes when possible
+- Type all props, API responses, and function signatures
+- Prefer named exports from components
+
+## Data Fetching
+
+- Server Components: fetch directly in the component
+- Client Components: use SWR or React Query
+- Mutations: prefer Server Actions (`'use server'`)
+- Always handle loading and error states

package/templates/javascript/node-cli-tool.md

@@ -0,0 +1,55 @@
+---
+name: node-cli-tool
+displayName: Node.js CLI Tool
+description: Node.js command-line tool with TypeScript
+category: javascript
+tags: [javascript, typescript, node, cli, tool]
+variables:
+  - name: cli_framework
+    prompt: "CLI framework?"
+    options: [Commander, yargs, Clipanion]
+    default: Commander
+  - name: package_manager
+    prompt: "Package manager?"
+    options: [npm, pnpm, yarn]
+    default: npm
+detects:
+  files: [package.json, tsup.config.ts]
+  devDependencies: [tsup]
+priority: 5
+---
+
+# Project
+
+Node.js CLI tool built with TypeScript and {{cli_framework}}.
+
+## Commands
+
+- `{{package_manager}} run build` — Build with tsup
+- `{{package_manager}} run dev` — Watch mode
+- `{{package_manager}} test` — Run tests
+- `node dist/cli.mjs --help` — Test built CLI
+
+## Architecture
+
+- `src/cli.ts` — Entry point, command registration
+- `src/commands/` — Individual command implementations
+- `src/core/` — Business logic (framework-agnostic)
+- `src/utils/` — Shared helpers
+- `src/types.ts` — TypeScript interfaces
+
+## Conventions
+
+- Keep commands thin: parse args, call core logic, format output
+- Core logic should be pure functions with dependency injection for testability
+- Use `process.exitCode` instead of `process.exit()` to allow cleanup
+- Output to stdout for data, stderr for status/errors
+- Support `--json` flag for machine-readable output where applicable
+- Test core logic with unit tests; test commands with integration tests
+
+## Publishing
+
+- Package uses `"type": "module"` (ESM)
+- `bin` field in package.json points to `dist/cli.mjs`
+- Shebang (`#!/usr/bin/env node`) is added by tsup banner
+- Verify with `npm pack --dry-run` before publishing

package/templates/javascript/react-vite.md

@@ -0,0 +1,55 @@
+---
+name: react-vite
+displayName: React + Vite
+description: React SPA with Vite build tool
+category: javascript
+tags: [javascript, typescript, react, vite, spa]
+variables:
+  - name: state_management
+    prompt: "State management?"
+    options: [Zustand, Redux Toolkit, Jotai, React Context]
+    default: Zustand
+  - name: styling
+    prompt: "Styling solution?"
+    options: [Tailwind CSS, CSS Modules, styled-components]
+    default: Tailwind CSS
+detects:
+  files: [package.json, vite.config.ts, vite.config.js]
+  dependencies: [react, vite]
+  devDependencies: [vite]
+priority: 12
+---
+
+# Project
+
+React single-page application built with Vite.
+
+## Commands
+
+- `npm run dev` — Start Vite dev server
+- `npm run build` — Production build to `dist/`
+- `npm run preview` — Preview production build locally
+- `npm test` — Run tests
+- `npm run lint` — Run ESLint
+
+## Architecture
+
+- `src/components/` — Reusable UI components
+- `src/pages/` — Route-level page components
+- `src/hooks/` — Custom React hooks
+- `src/stores/` — {{state_management}} stores
+- `src/services/` — API client and external service wrappers
+- `src/types/` — TypeScript type definitions
+
+## Conventions
+
+- Functional components with hooks only; no class components
+- Use {{styling}} for styling
+- Manage global state with {{state_management}}; prefer local state when possible
+- Colocate component, styles, and tests in the same directory
+- Use barrel exports (`index.ts`) for public APIs of directories
+- Type all props and API responses
+
+## Testing
+
+Tests live next to source files (`Component.test.tsx`). Use React Testing Library for component tests. Test behavior, not implementation.

package/templates/python/django-rest.md

@@ -0,0 +1,55 @@
+---
+name: django-rest
+displayName: Django REST Framework
+description: Django application with REST Framework
+category: python
+tags: [python, django, drf, api, backend]
+variables:
+  - name: db_type
+    prompt: "Database?"
+    options: [PostgreSQL, SQLite]
+    default: PostgreSQL
+  - name: auth_method
+    prompt: "Authentication?"
+    options: [Token, JWT, Session]
+    default: Token
+detects:
+  files: [requirements.txt, pyproject.toml, manage.py]
+  dependencies: [django, djangorestframework]
+priority: 10
+---
+
+# Project
+
+Django application with Django REST Framework and {{db_type}}.
+
+## Commands
+
+- `python manage.py runserver` — Start dev server
+- `python manage.py test` — Run tests
+- `python manage.py makemigrations` — Create migrations
+- `python manage.py migrate` — Apply migrations
+- `python manage.py shell_plus` — Enhanced Django shell
+
+## Architecture
+
+- `config/` — Project settings, root URL conf, WSGI/ASGI
+- `apps/` — Django applications (one per domain)
+- `apps/<name>/models.py` — Database models
+- `apps/<name>/serializers.py` — DRF serializers
+- `apps/<name>/views.py` — DRF viewsets and views
+- `apps/<name>/urls.py` — URL patterns
+- `apps/<name>/tests/` — Test modules
+
+## Conventions
+
+- One Django app per domain concern
+- Use ModelViewSet for standard CRUD; APIView for custom logic
+- Serializers handle all validation; keep views thin
+- {{auth_method}} authentication for API endpoints
+- Use `select_related()` and `prefetch_related()` to avoid N+1 queries
+- Write model methods for business logic; keep views as orchestrators
+
+## Testing
+
+Use Django's TestCase with DRF's APIClient. Use `setUpTestData` for shared test fixtures. Test serializer validation separately from views.

package/templates/python/fastapi-sqlalchemy.md

@@ -0,0 +1,54 @@
+---
+name: fastapi-sqlalchemy
+displayName: FastAPI + SQLAlchemy
+description: FastAPI application with SQLAlchemy ORM
+category: python
+tags: [python, fastapi, sqlalchemy, api, backend]
+variables:
+  - name: db_type
+    prompt: "Database?"
+    options: [PostgreSQL, MySQL, SQLite]
+    default: PostgreSQL
+  - name: package_manager
+    prompt: "Package manager?"
+    options: [pip, poetry, uv]
+    default: pip
+detects:
+  files: [requirements.txt, pyproject.toml]
+  dependencies: [fastapi, sqlalchemy]
+priority: 10
+---
+
+# Project
+
+FastAPI application with SQLAlchemy ORM and {{db_type}}.
+
+## Commands
+
+- `uvicorn app.main:app --reload` — Start dev server
+- `pytest` — Run tests
+- `alembic upgrade head` — Apply database migrations
+- `alembic revision --autogenerate -m "description"` — Create new migration
+
+## Architecture
+
+- `app/main.py` — FastAPI application factory
+- `app/routers/` — API route modules
+- `app/models/` — SQLAlchemy models
+- `app/schemas/` — Pydantic request/response schemas
+- `app/services/` — Business logic layer
+- `app/core/` — Config, security, dependencies
+- `alembic/` — Database migrations
+
+## Conventions
+
+- Use Pydantic v2 models for all request/response validation
+- Dependency injection via FastAPI `Depends()` for DB sessions and auth
+- Async endpoints where possible (`async def`)
+- Use SQLAlchemy 2.0 style queries (select statements, not legacy Query API)
+- Return proper HTTP status codes (201 for creation, 204 for deletion)
+- All models need `created_at` and `updated_at` timestamps
+
+## Testing
+
+Use pytest with httpx AsyncClient for API tests. Use factory fixtures for test data. Test against a real test database, not mocks.

package/templates/python/flask-basic.md

@@ -0,0 +1,51 @@
+---
+name: flask-basic
+displayName: Flask Basic
+description: Flask web application
+category: python
+tags: [python, flask, web, backend]
+variables:
+  - name: db_type
+    prompt: "Database?"
+    options: [SQLite, PostgreSQL, None]
+    default: SQLite
+  - name: template_engine
+    prompt: "Template engine?"
+    options: [Jinja2, None (API only)]
+    default: Jinja2
+detects:
+  files: [requirements.txt, pyproject.toml]
+  dependencies: [flask]
+priority: 5
+---
+
+# Project
+
+Flask web application.
+
+## Commands
+
+- `flask run --debug` — Start dev server with hot reload
+- `pytest` — Run tests
+- `flask db upgrade` — Apply migrations (if using Flask-Migrate)
+
+## Architecture
+
+- `app/__init__.py` — Application factory (`create_app`)
+- `app/routes/` — Blueprint route modules
+- `app/models/` — Database models
+- `app/templates/` — Jinja2 templates
+- `app/static/` — Static assets
+- `tests/` — Test suite
+
+## Conventions
+
+- Use the application factory pattern (`create_app()`)
+- Organize routes with Blueprints
+- Use Flask-SQLAlchemy for database operations with {{db_type}}
+- Configure via environment variables and `config.py`
+- Use `flask.g` for per-request state; use sessions for user state
+
+## Testing
+
+Use pytest with the Flask test client. Create an app fixture with test config. Test routes return expected status codes and data.

package/templates/rust/cargo-workspace.md

@@ -0,0 +1,50 @@
+---
+name: cargo-workspace
+displayName: Rust Cargo Workspace
+description: Rust project with Cargo workspace
+category: rust
+tags: [rust, cargo, systems]
+variables:
+  - name: project_type
+    prompt: "Project type?"
+    options: [Binary, Library, Both]
+    default: Binary
+detects:
+  files: [Cargo.toml]
+priority: 5
+---
+
+# Project
+
+Rust project managed with Cargo.
+
+## Commands
+
+- `cargo build` — Build the project
+- `cargo run` — Build and run (binary crate)
+- `cargo test` — Run all tests
+- `cargo clippy` — Run linter
+- `cargo fmt` — Format code
+- `cargo doc --open` — Generate and view docs
+
+## Architecture
+
+- `src/main.rs` — Binary entry point
+- `src/lib.rs` — Library root
+- `src/` — Source modules
+- `tests/` — Integration tests
+- `benches/` — Benchmarks
+
+## Conventions
+
+- Use `Result<T, E>` for fallible operations; use `thiserror` for custom error types
+- Prefer `&str` over `String` in function parameters
+- Use `clippy::pedantic` lint level for strictness
+- Derive `Debug` on all public types
+- Use `#[cfg(test)]` modules for unit tests within source files
+- Integration tests go in `tests/` directory
+- Document all public APIs with `///` doc comments
+
+## Error Handling
+
+Use `anyhow` for application code and `thiserror` for library code. Propagate errors with `?`; avoid `.unwrap()` in production code.