claudient 0.1.0

package/mcp/recommended-servers.md

@@ -0,0 +1,168 @@
+# MCP Recommended Servers
+
+A practical guide to MCP servers worth enabling in Claude Code. Organized by category with token cost estimates and clear guidance on when to use each.
+
+---
+
+## Token Budget Awareness
+
+Every enabled MCP server contributes its tool descriptions to Claude's context window.
+
+| MCP servers enabled | Approximate token cost |
+|--------------------|----------------------|
+| 3 servers (~10 tools) | ~10,000 tokens |
+| 10 servers (~30 tools) | ~30,000 tokens |
+| 20 servers (~60 tools) | ~60,000 tokens |
+
+With a 200k token window, 10 active MCPs consume ~15% of your context before any conversation. Be selective. Disable servers you're not actively using.
+
+---
+
+## Filesystem & Search
+
+### `@modelcontextprotocol/server-filesystem`
+```bash
+npx -y @modelcontextprotocol/server-filesystem /path/to/project
+```
+- **What it gives:** Read, write, list, and search files with configurable path restrictions
+- **Token cost:** ~2,000 tokens
+- **Use when:** You want Claude to explore a codebase directory beyond the current working dir
+- **Avoid when:** Claude Code's built-in Read/Write tools already cover your project
+
+### `@modelcontextprotocol/server-brave-search` or `tavily`
+```bash
+npx -y @modelcontextprotocol/server-brave-search
+```
+- **What it gives:** Web search from within Claude
+- **Token cost:** ~1,500 tokens
+- **Use when:** Agents need current information (docs, news, package versions) not in training data
+- **Avoid when:** You only need code generation, no web lookups needed
+
+---
+
+## Databases
+
+### `@modelcontextprotocol/server-postgres`
+```json
+{
+  "mcpServers": {
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
+    }
+  }
+}
+```
+- **What it gives:** Query, inspect schema, list tables — direct DB access from Claude
+- **Token cost:** ~3,000 tokens
+- **Use when:** Schema exploration, writing complex queries, debugging data issues
+- **Avoid when:** Production database — use a read-only replica or dev DB only
+- **Security:** Never point at production DB. Use a read-only user at minimum.
+
+### `@modelcontextprotocol/server-sqlite`
+- **What it gives:** Same as postgres but for SQLite files
+- **Token cost:** ~2,500 tokens
+- **Use when:** Local development with SQLite, embedded databases
+
+---
+
+## APIs & Services
+
+### `@modelcontextprotocol/server-github`
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "<token>" }
+    }
+  }
+}
+```
+- **What it gives:** Read issues, PRs, commits, files from GitHub repos
+- **Token cost:** ~4,000 tokens
+- **Use when:** Reviewing PRs, triaging issues, fetching context from remote repos
+- **Avoid when:** You only need local git context (git CLI is faster)
+
+### `@modelcontextprotocol/server-linear`
+- **What it gives:** Create, update, and query Linear issues and projects
+- **Token cost:** ~3,000 tokens
+- **Use when:** Issue tracking integrated into development workflow
+
+### `stripe-mcp` (Stripe official)
+```bash
+npx -y @stripe/mcp --api-key sk_test_...
+```
+- **What it gives:** Create customers, products, prices, checkout sessions; query payments
+- **Token cost:** ~5,000 tokens
+- **Use when:** Building Stripe integrations, testing payment flows
+- **Avoid when:** Production Stripe keys — use test mode only in development
+
+---
+
+## Browser & Testing
+
+### `@modelcontextprotocol/server-puppeteer`
+- **What it gives:** Launch a browser, navigate pages, click elements, take screenshots
+- **Token cost:** ~3,500 tokens
+- **Use when:** Testing web UIs, scraping, automating browser interactions
+- **Avoid when:** API testing — overkill, use fetch/curl
+
+### `@playwright/mcp`
+```bash
+npx -y @playwright/mcp@latest
+```
+- **What it gives:** Playwright automation — more reliable than Puppeteer for modern SPAs
+- **Token cost:** ~4,000 tokens
+- **Use when:** E2E test writing, UI verification, complex browser automation
+- **Recommended over Puppeteer** for Next.js / React apps
+
+---
+
+## AI & Reasoning
+
+### `@modelcontextprotocol/server-memory`
+```bash
+npx -y @modelcontextprotocol/server-memory
+```
+- **What it gives:** A knowledge graph that persists across sessions — entities, relations, observations
+- **Token cost:** ~2,000 tokens
+- **Use when:** Long-running projects where you want Claude to remember context between sessions
+- **Avoid when:** Single-session tasks — overhead without benefit
+
+### `@modelcontextprotocol/server-sequential-thinking`
+- **What it gives:** Forces Claude through explicit reasoning steps before answering
+- **Token cost:** ~1,500 tokens
+- **Use when:** Complex multi-step problem solving, architectural decisions
+- **Avoid when:** Simple queries — adds latency with no benefit
+
+---
+
+## Configuration Template
+
+Add servers to `~/.claude/settings.json` (global) or `.claude/settings.json` (project):
+
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
+      }
+    },
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "${DATABASE_URL}"]
+    }
+  }
+}
+```
+
+Use environment variable references (`${VAR}`) instead of hardcoded secrets.
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. [uitbreiden.com](https://uitbreiden.com/)

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "claudient",
+  "version": "0.1.0",
+  "description": "The definitive Claude Code knowledge system — skills, agents, hooks, rules, and workflows.",
+  "keywords": [
+    "claude-code",
+    "claude",
+    "anthropic",
+    "llm",
+    "ai-tools",
+    "developer-productivity",
+    "skills",
+    "agents",
+    "hooks"
+  ],
+  "homepage": "https://github.com/Claudient/Claudient",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Claudient/Claudient.git"
+  },
+  "license": "MIT",
+  "bin": {
+    "claudient": "./scripts/cli.js"
+  },
+  "files": [
+    "scripts/",
+    "skills/",
+    "agents/",
+    "hooks/",
+    "rules/",
+    "workflows/",
+    "prompts/",
+    "mcp/",
+    "guides/",
+    ".claude-plugin/",
+    "CONTEXT.md",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "list": "node scripts/cli.js list"
+  }
+}

package/prompts/project-starters/de/fastapi-project.md

@@ -0,0 +1,62 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../fastapi-project.md).
+
+# Projekt-Starter: FastAPI
+
+Diesen Prompt verwenden, um ein neues FastAPI-Projekt mit Claude Code zu starten.
+
+---
+
+## Kickoff-Prompt
+
+```
+Bootstrap a new FastAPI project with production-ready defaults.
+
+Project: [name and one-sentence description]
+Database: PostgreSQL with SQLAlchemy async + Alembic migrations
+Auth: JWT (python-jose) with refresh tokens
+Testing: pytest + httpx async client
+
+Create the following structure:
+app/
+├── api/
+│   └── v1/
+│       ├── routes/       ← One file per resource (users.py, items.py, etc.)
+│       └── deps.py       ← Shared dependencies (get_db, get_current_user)
+├── core/
+│   ├── config.py         ← Settings via pydantic-settings
+│   ├── security.py       ← JWT creation and validation
+│   └── database.py       ← Async engine and session factory
+├── models/               ← SQLAlchemy ORM models
+├── schemas/              ← Pydantic request/response schemas
+├── services/             ← Business logic (no HTTP, no ORM)
+├── tests/
+│   ├── conftest.py       ← Test database, async client, fixtures
+│   └── test_[resource].py
+├── alembic/              ← Migration files
+├── main.py               ← App factory
+└── requirements.txt      ← Pinned versions
+
+Start with:
+1. Show the full directory structure
+2. Create requirements.txt with pinned versions
+3. Create main.py with app factory pattern
+4. Create core/config.py with Settings class
+5. Create core/database.py with async session
+6. Verify it starts with: uvicorn main:app --reload
+
+Do not add business logic yet — skeleton only.
+```
+
+---
+
+## Was als nächstes tun
+
+Nachdem das Skeleton läuft:
+
+1. Erste Ressource hinzufügen: "Ein User-Modell, CRUD-Endpunkte (GET /users, POST /users, GET /users/{id}) und Tests hinzufügen"
+2. Auth hinzufügen: "JWT-Login und Refresh-Token-Endpunkte implementieren, die mit der eingerichteten security.py arbeiten"
+3. Das erste Business-Feature mit dem Feature-Entwicklungs-Workflow hinzufügen
+
+---
+
+> **Mit uns arbeiten:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir bauen KI-Produkte und B2B-Lösungen mit Entwickler-Communities. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/project-starters/de/nextjs-project.md

@@ -0,0 +1,82 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../nextjs-project.md).
+
+# Projekt-Starter: Next.js
+
+Diesen Prompt verwenden, um ein neues Next.js-Projekt mit Claude Code zu starten.
+
+---
+
+## Kickoff-Prompt
+
+```
+Bootstrap a new Next.js 15 project with production-ready defaults.
+
+Project: [name and one-sentence description]
+Stack: Next.js 15 (App Router), TypeScript, Tailwind CSS, shadcn/ui
+Database: PostgreSQL with Prisma
+Auth: [Clerk / NextAuth.js / custom JWT]
+Testing: Vitest + React Testing Library
+
+Create the following structure:
+src/
+├── app/
+│   ├── (auth)/           ← Auth routes (sign-in, sign-up)
+│   ├── (dashboard)/      ← Protected routes
+│   ├── api/              ← API route handlers
+│   ├── layout.tsx        ← Root layout
+│   └── page.tsx          ← Landing page
+├── components/
+│   ├── ui/               ← shadcn/ui components (auto-generated)
+│   └── [feature]/        ← Feature-specific components
+├── lib/
+│   ├── db.ts             ← Prisma client singleton
+│   ├── auth.ts           ← Auth utilities
+│   └── utils.ts          ← cn() and shared utilities
+├── server/               ← Server-only code (no client imports)
+│   └── actions/          ← Server actions
+└── types/                ← Shared TypeScript types
+
+prisma/
+├── schema.prisma
+└── migrations/
+
+Start with:
+1. Show the full directory structure
+2. package.json with pinned versions
+3. tsconfig.json and tailwind.config.ts
+4. Root layout.tsx and a working landing page
+5. Prisma schema with a User model
+6. Verify it runs: npm run dev
+
+Do not add features yet — skeleton only.
+```
+
+---
+
+## Zu erzwingende Schlüsselkonventionen
+
+Nach dem Bootstrap zu CLAUDE.md hinzufügen:
+
+```markdown
+## Next.js Konventionen
+- Server Components standardmäßig — 'use client' nur hinzufügen, wenn benötigt (Event-Handler, Hooks, Browser-APIs)
+- Server Actions für Mutationen — niemals API-Routes aus Server Components aufrufen
+- Niemals server-only Code in Client Components importieren (server/-Verzeichnisgrenze verwenden)
+- API-Routes nur für: Webhooks, OAuth-Callbacks, Streaming-Antworten
+- Prisma Client: Singleton in lib/db.ts — niemals inline instanziieren
+- Alle Datenbankzugriffe in server/ — niemals in Client Components
+```
+
+---
+
+## Was als nächstes tun
+
+Nachdem das Skeleton läuft:
+
+1. Auth einrichten: "[Clerk/NextAuth] mit den eingerichteten Auth-Routes konfigurieren"
+2. Erste Seite hinzufügen: "Eine Dashboard-Seite erstellen, die [Ressource] mit einer Datentabelle zeigt"
+3. Erste Mutation hinzufügen: "Eine Server Action zum Erstellen von [Ressource] mit Formularvalidierung hinzufügen"
+
+---
+
+> **Mit uns arbeiten:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir bauen KI-Produkte und B2B-Lösungen mit Entwickler-Communities. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/project-starters/es/fastapi-project.md

@@ -0,0 +1,62 @@
+> 🇪🇸 Esta es la traducción en español. [Versión en inglés](../fastapi-project.md).
+
+# Iniciador de Proyecto: FastAPI
+
+Usa este prompt para arrancar un nuevo proyecto FastAPI con Claude Code.
+
+---
+
+## Prompt de inicio
+
+```
+Bootstrap a new FastAPI project with production-ready defaults.
+
+Project: [name and one-sentence description]
+Database: PostgreSQL with SQLAlchemy async + Alembic migrations
+Auth: JWT (python-jose) with refresh tokens
+Testing: pytest + httpx async client
+
+Create the following structure:
+app/
+├── api/
+│   └── v1/
+│       ├── routes/       ← One file per resource (users.py, items.py, etc.)
+│       └── deps.py       ← Shared dependencies (get_db, get_current_user)
+├── core/
+│   ├── config.py         ← Settings via pydantic-settings
+│   ├── security.py       ← JWT creation and validation
+│   └── database.py       ← Async engine and session factory
+├── models/               ← SQLAlchemy ORM models
+├── schemas/              ← Pydantic request/response schemas
+├── services/             ← Business logic (no HTTP, no ORM)
+├── tests/
+│   ├── conftest.py       ← Test database, async client, fixtures
+│   └── test_[resource].py
+├── alembic/              ← Migration files
+├── main.py               ← App factory
+└── requirements.txt      ← Pinned versions
+
+Start with:
+1. Show the full directory structure
+2. Create requirements.txt with pinned versions
+3. Create main.py with app factory pattern
+4. Create core/config.py with Settings class
+5. Create core/database.py with async session
+6. Verify it starts with: uvicorn main:app --reload
+
+Do not add business logic yet — skeleton only.
+```
+
+---
+
+## Qué hacer a continuación
+
+Después de que el esqueleto funcione:
+
+1. Agrega tu primer recurso: "Add a User model, CRUD endpoints (GET /users, POST /users, GET /users/{id}), and tests"
+2. Agrega autenticación: "Implement JWT login and refresh token endpoints using the security.py we set up"
+3. Agrega la primera funcionalidad de negocio usando el flujo de trabajo de desarrollo de funcionalidades
+
+---
+
+> **Trabaja con nosotros:** Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA y soluciones B2B con comunidades de desarrolladores. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/project-starters/es/nextjs-project.md

@@ -0,0 +1,82 @@
+> 🇪🇸 Esta es la traducción en español. [Versión en inglés](../nextjs-project.md).
+
+# Iniciador de Proyecto: Next.js
+
+Usa este prompt para arrancar un nuevo proyecto Next.js con Claude Code.
+
+---
+
+## Prompt de inicio
+
+```
+Bootstrap a new Next.js 15 project with production-ready defaults.
+
+Project: [name and one-sentence description]
+Stack: Next.js 15 (App Router), TypeScript, Tailwind CSS, shadcn/ui
+Database: PostgreSQL with Prisma
+Auth: [Clerk / NextAuth.js / custom JWT]
+Testing: Vitest + React Testing Library
+
+Create the following structure:
+src/
+├── app/
+│   ├── (auth)/           ← Auth routes (sign-in, sign-up)
+│   ├── (dashboard)/      ← Protected routes
+│   ├── api/              ← API route handlers
+│   ├── layout.tsx        ← Root layout
+│   └── page.tsx          ← Landing page
+├── components/
+│   ├── ui/               ← shadcn/ui components (auto-generated)
+│   └── [feature]/        ← Feature-specific components
+├── lib/
+│   ├── db.ts             ← Prisma client singleton
+│   ├── auth.ts           ← Auth utilities
+│   └── utils.ts          ← cn() and shared utilities
+├── server/               ← Server-only code (no client imports)
+│   └── actions/          ← Server actions
+└── types/                ← Shared TypeScript types
+
+prisma/
+├── schema.prisma
+└── migrations/
+
+Start with:
+1. Show the full directory structure
+2. package.json with pinned versions
+3. tsconfig.json and tailwind.config.ts
+4. Root layout.tsx and a working landing page
+5. Prisma schema with a User model
+6. Verify it runs: npm run dev
+
+Do not add features yet — skeleton only.
+```
+
+---
+
+## Convenciones clave a aplicar
+
+Agrega a CLAUDE.md después del bootstrap:
+
+```markdown
+## Convenciones de Next.js
+- Server Components por defecto — agrega 'use client' solo cuando sea necesario (manejadores de eventos, hooks, APIs del navegador)
+- Server Actions para mutations — nunca llames a rutas de API desde Server Components
+- Nunca importes código solo del servidor en Client Components (usa el límite del directorio server/)
+- Las rutas de API solo para: webhooks, callbacks de OAuth, respuestas con streaming
+- Cliente Prisma: singleton en lib/db.ts — nunca instancies inline
+- Todo el acceso a la base de datos en server/ — nunca en Client Components
+```
+
+---
+
+## Qué hacer a continuación
+
+Después de que el esqueleto funcione:
+
+1. Configura la autenticación: "Configure [Clerk/NextAuth] with the auth routes we set up"
+2. Agrega la primera página: "Create a dashboard page showing [resource] with a data table"
+3. Agrega la primera mutation: "Add a server action to create [resource] with form validation"
+
+---
+
+> **Trabaja con nosotros:** Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA y soluciones B2B con comunidades de desarrolladores. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/project-starters/fastapi-project.md

@@ -0,0 +1,60 @@
+# Project Starter: FastAPI
+
+Use this prompt to kick off a new FastAPI project with Claude Code.
+
+---
+
+## Kickoff prompt
+
+```
+Bootstrap a new FastAPI project with production-ready defaults.
+
+Project: [name and one-sentence description]
+Database: PostgreSQL with SQLAlchemy async + Alembic migrations
+Auth: JWT (python-jose) with refresh tokens
+Testing: pytest + httpx async client
+
+Create the following structure:
+app/
+├── api/
+│   └── v1/
+│       ├── routes/       ← One file per resource (users.py, items.py, etc.)
+│       └── deps.py       ← Shared dependencies (get_db, get_current_user)
+├── core/
+│   ├── config.py         ← Settings via pydantic-settings
+│   ├── security.py       ← JWT creation and validation
+│   └── database.py       ← Async engine and session factory
+├── models/               ← SQLAlchemy ORM models
+├── schemas/              ← Pydantic request/response schemas
+├── services/             ← Business logic (no HTTP, no ORM)
+├── tests/
+│   ├── conftest.py       ← Test database, async client, fixtures
+│   └── test_[resource].py
+├── alembic/              ← Migration files
+├── main.py               ← App factory
+└── requirements.txt      ← Pinned versions
+
+Start with:
+1. Show the full directory structure
+2. Create requirements.txt with pinned versions
+3. Create main.py with app factory pattern
+4. Create core/config.py with Settings class
+5. Create core/database.py with async session
+6. Verify it starts with: uvicorn main:app --reload
+
+Do not add business logic yet — skeleton only.
+```
+
+---
+
+## What to do next
+
+After the skeleton runs:
+
+1. Add your first resource: "Add a User model, CRUD endpoints (GET /users, POST /users, GET /users/{id}), and tests"
+2. Add auth: "Implement JWT login and refresh token endpoints using the security.py we set up"
+3. Add the first business feature using the feature-development workflow
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/project-starters/fr/fastapi-project.md

@@ -0,0 +1,62 @@
+> 🇫🇷 This is the French translation. [English version](../fastapi-project.md).
+
+# Starter de Projet : FastAPI
+
+Utilisez ce prompt pour lancer un nouveau projet FastAPI avec Claude Code.
+
+---
+
+## Prompt de démarrage
+
+```
+Bootstrap a new FastAPI project with production-ready defaults.
+
+Project: [name and one-sentence description]
+Database: PostgreSQL with SQLAlchemy async + Alembic migrations
+Auth: JWT (python-jose) with refresh tokens
+Testing: pytest + httpx async client
+
+Create the following structure:
+app/
+├── api/
+│   └── v1/
+│       ├── routes/       ← One file per resource (users.py, items.py, etc.)
+│       └── deps.py       ← Shared dependencies (get_db, get_current_user)
+├── core/
+│   ├── config.py         ← Settings via pydantic-settings
+│   ├── security.py       ← JWT creation and validation
+│   └── database.py       ← Async engine and session factory
+├── models/               ← SQLAlchemy ORM models
+├── schemas/              ← Pydantic request/response schemas
+├── services/             ← Business logic (no HTTP, no ORM)
+├── tests/
+│   ├── conftest.py       ← Test database, async client, fixtures
+│   └── test_[resource].py
+├── alembic/              ← Migration files
+├── main.py               ← App factory
+└── requirements.txt      ← Pinned versions
+
+Start with:
+1. Show the full directory structure
+2. Create requirements.txt with pinned versions
+3. Create main.py with app factory pattern
+4. Create core/config.py with Settings class
+5. Create core/database.py with async session
+6. Verify it starts with: uvicorn main:app --reload
+
+Do not add business logic yet — skeleton only.
+```
+
+---
+
+## Que faire ensuite
+
+Une fois le squelette en cours d'exécution :
+
+1. Ajouter votre première ressource : "Add a User model, CRUD endpoints (GET /users, POST /users, GET /users/{id}), and tests"
+2. Ajouter l'auth : "Implement JWT login and refresh token endpoints using the security.py we set up"
+3. Ajouter la première fonctionnalité métier en utilisant le workflow de développement de fonctionnalité
+
+---
+
+> **Travaillez avec nous :** Claudient est soutenu par [Uitbreiden](https://uitbreiden.com/) — nous construisons des produits IA et des solutions B2B avec des communautés de développeurs. [uitbreiden.com](https://uitbreiden.com/)