@chimerai/cli 0.2.73

package/dist/commands/add.js

@@ -0,0 +1,2126 @@
+"use strict";
+/**
+ * Add Command - Add components to existing project
+ * REFACTORED: Uses inline template generators instead of fs.copy() (PHASE 4)
+ * Extended with modular AI-Service support (ai-chat, rag, guardrails, ai-tools)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommand = addCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const crypto_1 = __importDefault(require("crypto"));
+const templates = __importStar(require("../templates/index.js"));
+const ai_service_tools_js_1 = require("../templates/ai-service-tools.js");
+const utils_js_1 = require("../utils.js");
+const schema_manager_js_1 = require("../schema-manager.js");
+const scanner_js_1 = require("../scanner.js");
+const license_js_1 = require("../license.js");
+/**
+ * Component configurations - centralized (eliminates 11 separate add* functions)
+ * Reduces lines from ~900 to ~120
+ */
+const COMPONENT_CONFIGS = {
+    auth: {
+        name: 'auth',
+        displayName: 'Authentication System',
+        description: 'NextAuth.js integration with login, session, RBAC, and GDPR support',
+        files: [
+            {
+                generator: () => templates.generateNextAuthRoute(),
+                target: 'app/api/auth/[...nextauth]/route.ts',
+            },
+            {
+                generator: () => templates.generateLoginPage(),
+                target: 'app/auth/signin/page.tsx',
+            },
+            {
+                generator: () => templates.generateSessionProvider(),
+                target: 'components/SessionProvider.tsx',
+            },
+            {
+                generator: () => templates.generateAuthLib(),
+                target: 'lib/auth.ts',
+            },
+            {
+                generator: () => templates.generateNextAuthTypes(),
+                target: 'types/next-auth.d.ts',
+            },
+            {
+                generator: () => templates.generateApiProtectionLib(),
+                target: 'lib/api-protection.ts',
+            },
+            {
+                generator: () => templates.generateResolveAuth(),
+                target: 'lib/auth/resolve-auth.ts',
+            },
+            {
+                generator: () => templates.generateApiKeyAuthLib(),
+                target: 'lib/api-key-auth.ts',
+            },
+            // User profile route
+            {
+                generator: () => templates.generateUserProfileRoute(),
+                target: 'app/api/user/profile/route.ts',
+            },
+            // GDPR self-service routes
+            {
+                generator: () => templates.generateGdprDataExportRoute(),
+                target: 'app/api/user/data-export/route.ts',
+            },
+            {
+                generator: () => templates.generateGdprAccountDeleteRoute(),
+                target: 'app/api/user/account/route.ts',
+            },
+        ],
+        dependencies: {
+            'next-auth': '^4.24.10',
+            bcryptjs: '^3.0.0',
+            '@auth/prisma-adapter': '^2.11.1',
+        },
+        requiredUtils: [
+            { generator: () => templates.generateAuditLogHelper(), target: 'lib/audit.ts' },
+        ],
+        schemaExtension: `
+model User {
+  id            String    @id @default(cuid())
+  name          String?
+  email         String?   @unique
+  emailVerified DateTime?
+  image         String?
+  password      String?
+  createdAt     DateTime  @default(now())
+  updatedAt     DateTime  @updatedAt
+  accounts      Account[]
+  sessions      Session[]
+  apiKeys       ApiKey[]
+}
+
+model Account {
+  id                String  @id @default(cuid())
+  userId            String
+  type              String
+  provider          String
+  providerAccountId String
+  refresh_token     String? @db.Text
+  access_token      String? @db.Text
+  expires_at        Int?
+  token_type        String?
+  scope             String?
+  id_token          String? @db.Text
+  session_state     String?
+  user              User    @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([provider, providerAccountId])
+}
+
+model Session {
+  id           String   @id @default(cuid())
+  sessionToken String   @unique
+  userId       String
+  expires      DateTime
+  user         User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+}
+
+model VerificationToken {
+  identifier String
+  token      String   @unique
+  expires    DateTime
+
+  @@unique([identifier, token])
+}
+
+model ApiKey {
+  id         String    @id @default(cuid())
+  name       String
+  keyHash    String    @unique
+  userId     String
+  scopes     String[]  @default(["chat"])
+  revoked    Boolean   @default(false)
+  lastUsedAt DateTime?
+  expiresAt  DateTime?
+  createdAt  DateTime  @default(now())
+  updatedAt  DateTime  @updatedAt
+  user       User      @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([keyHash])
+}
+`,
+        envVars: [
+            {
+                key: 'DATABASE_URL',
+                value: 'file:./dev.db',
+                comment: 'Database (SQLite for development, change to PostgreSQL for production)',
+            },
+            {
+                key: 'NEXTAUTH_SECRET',
+                value: () => crypto_1.default.randomBytes(32).toString('hex'),
+                comment: 'NextAuth.js secret (auto-generated)',
+            },
+            {
+                key: 'NEXTAUTH_URL',
+                value: 'http://localhost:__PORT_DETECT__',
+                comment: 'NextAuth.js base URL',
+            },
+        ],
+        postAddMessage: `Authentication system added successfully!
+
+✅ NextAuth.js route + login page (app/auth/signin)
+✅ Auth lib (lib/auth.ts) + Session Provider component
+✅ Type declarations (types/next-auth.d.ts)
+✅ API protection + resolve-auth (dual-auth support)
+✅ User profile API + GDPR data export & account deletion
+✅ Seed script (prisma/seed.ts) — Demo user: admin@example.com / admin123
+
+┌─────────────────────────────────────────────────────────┐
+│  IMPORTANT — Add SessionProvider to your root layout:   │
+│                                                         │
+│  // app/layout.tsx                                      │
+│  import { SessionProvider }                             │
+│    from '@/components/SessionProvider';                  │
+│                                                         │
+│  // Wrap {children} inside <body>:                      │
+│  <SessionProvider>{children}</SessionProvider>           │
+└─────────────────────────────────────────────────────────┘
+
+Next steps:
+1. Add <SessionProvider> to your root layout (see above)
+2. pnpm install
+3. npx prisma db push
+4. npx prisma db seed
+5. pnpm dev → Login: admin@example.com / admin123`,
+    },
+    'users-table': {
+        name: 'users-table',
+        displayName: 'Users Table',
+        description: 'User management data table with CRUD operations',
+        files: [
+            {
+                generator: () => templates.generateAdminUsersPage(),
+                target: 'app/admin/users/page.tsx',
+            },
+            {
+                generator: () => templates.generateAdminUsersRoute(),
+                target: 'app/api/admin/users/route.ts',
+            },
+            {
+                generator: () => templates.generateAdminUsersIdRoute(),
+                target: 'app/api/admin/users/[id]/route.ts',
+            },
+        ],
+        postAddMessage: 'Users table component added',
+    },
+    'roles-table': {
+        name: 'roles-table',
+        displayName: 'Roles Table',
+        description: 'Role management table for RBAC system',
+        files: [
+            {
+                generator: () => templates.generateAdminRolesPage(),
+                target: 'app/admin/roles/page.tsx',
+            },
+            {
+                generator: () => templates.generateAdminRolesRoute(),
+                target: 'app/api/admin/roles/route.ts',
+            },
+        ],
+        postAddMessage: 'Roles table component added',
+    },
+    'groups-table': {
+        name: 'groups-table',
+        displayName: 'Groups Table',
+        description: 'User groups/teams management table',
+        disabled: 'Not yet implemented — requires Entity-based RBAC (Group/GroupMember/GroupPermission models). Use admin-dashboard for Role-based access control.',
+        files: [],
+        postAddMessage: 'Groups table component added',
+    },
+    'permissions-table': {
+        name: 'permissions-table',
+        displayName: 'Permissions Table',
+        description: 'Permission management for roles',
+        disabled: 'Not yet implemented — CLI uses String-Array permissions on Role model. Use admin-dashboard for Role + Permission management.',
+        files: [],
+        postAddMessage: 'Permissions table component added',
+    },
+    'chat-ui': {
+        name: 'chat-ui',
+        displayName: 'Chat UI',
+        description: 'Full-featured chat interface with streaming, conversation management, and multi-provider support',
+        requiredUtils: [
+            { generator: () => templates.generateUseAppNameHook(), target: 'lib/use-app-name.ts' },
+        ],
+        files: [
+            // Hook
+            {
+                generator: () => templates.generateUseChatHook(),
+                target: 'components/chat/use-chat.ts',
+            },
+            // Components
+            {
+                generator: () => templates.generateChatMessage(),
+                target: 'components/chat/chat-message.tsx',
+            },
+            {
+                generator: () => templates.generateChatInput(),
+                target: 'components/chat/chat-input.tsx',
+            },
+            {
+                generator: () => templates.generateChatSidebar(),
+                target: 'components/chat/chat-sidebar.tsx',
+            },
+            {
+                generator: () => templates.generateModelSelector(),
+                target: 'components/chat/model-selector.tsx',
+            },
+            // Index barrel export
+            {
+                generator: () => `export { useChat } from './use-chat';
+export { ChatMessage } from './chat-message';
+export { ChatInput } from './chat-input';
+export { ChatSidebar } from './chat-sidebar';
+export { ModelSelector } from './model-selector';
+export type { ChatMessageData, MessageActions, ConversationItem, ModelOption } from './use-chat';
+`,
+                target: 'components/chat/index.ts',
+            },
+            // Example page — placed in _chimerai-examples/ so the user decides where to mount it
+            {
+                generator: () => templates.generateChatPage(),
+                target: '_chimerai-examples/chat-page.tsx',
+            },
+            // API Routes
+            {
+                generator: () => templates.generateChatStreamRouteWithPersistence(),
+                target: 'app/api/v1/chat/stream/route.ts',
+            },
+            {
+                generator: () => templates.generateConversationsRoute(),
+                target: 'app/api/conversations/route.ts',
+            },
+            {
+                generator: () => templates.generateConversationDetailRoute(),
+                target: 'app/api/conversations/[id]/route.ts',
+            },
+            {
+                generator: () => templates.generateModelsRoute(),
+                target: 'app/api/models/route.ts',
+            },
+            // Public v1 models route (dual-auth for external apps/widgets)
+            {
+                generator: () => templates.generateV1ModelsRoute(),
+                target: 'app/api/v1/models/route.ts',
+            },
+            {
+                generator: () => templates.generateProviderSyncRoute(),
+                target: 'app/api/providers/[id]/sync/route.ts',
+            },
+            // Infrastructure dependencies (prisma, encryption, dual-auth)
+            {
+                generator: () => templates.generatePrismaLib(),
+                target: 'lib/prisma.ts',
+            },
+            {
+                generator: () => templates.generateEncryptionLib(),
+                target: 'lib/encryption.ts',
+            },
+            {
+                generator: () => templates.generateResolveAuth(),
+                target: 'lib/auth/resolve-auth.ts',
+            },
+            {
+                generator: () => templates.generateApiKeyAuthLib(),
+                target: 'lib/api-key-auth.ts',
+            },
+        ],
+        dependencies: {
+            'react-markdown': '^9.0.0',
+            'remark-gfm': '^4.0.0',
+        },
+        schemaExtension: `model Conversation {
+  id         String    @id @default(cuid())
+  userId     String
+  title      String    @default("New Chat")
+  model      String?
+  providerId String?
+  metadata   Json?
+  archived   Boolean   @default(false)
+  createdAt  DateTime  @default(now())
+  updatedAt  DateTime  @updatedAt
+
+  user     User      @relation(fields: [userId], references: [id], onDelete: Cascade)
+  provider Provider? @relation(fields: [providerId], references: [id], onDelete: SetNull)
+  messages Message[]
+
+  @@index([userId])
+  @@index([archived])
+  @@index([providerId])
+}
+
+model Message {
+  id             String       @id @default(cuid())
+  conversationId String
+  role           String
+  content        String       @db.Text
+  model          String?
+  tokens         Int?
+  createdAt      DateTime     @default(now())
+
+  conversation   Conversation @relation(fields: [conversationId], references: [id], onDelete: Cascade)
+
+  @@index([conversationId])
+}`,
+        postAddMessage: `Chat UI added successfully!
+
+✅ Components: useChat hook, ChatMessage, ChatInput, ChatSidebar, ModelSelector
+✅ Routes: /api/v1/chat/stream, /api/conversations, /api/conversations/[id]
+✅ Features: Streaming, conversation persistence, multi-provider support
+✅ Example page: _chimerai-examples/chat-page.tsx
+
+┌─────────────────────────────────────────────────────────┐
+│  Integration — add the chat to any page in your app:    │
+│                                                         │
+│  Option A: Copy the example page                        │
+│  cp _chimerai-examples/chat-page.tsx                    │
+│     app/chat/page.tsx                                   │
+│                                                         │
+│  Option B: Use individual components                    │
+│  import { useChat, ChatMessage, ChatInput }             │
+│    from '@/components/chat';                            │
+│                                                         │
+│  Note: Pages using useSession() need SessionProvider    │
+│  in a parent layout (see: chimerai add auth).           │
+└─────────────────────────────────────────────────────────┘
+
+Next steps:
+1. Copy or adapt _chimerai-examples/chat-page.tsx into your app
+2. pnpm install
+3. npx prisma db push && npx prisma db seed
+4. pnpm dev`,
+    },
+    'chat-widget': {
+        name: 'chat-widget',
+        displayName: 'Embeddable Chat Widget',
+        description: 'Self-contained JS chat widget + API-Key management for external integrations',
+        files: [
+            {
+                generator: () => templates.generateWidgetBundle(),
+                target: 'public/widget/chat.js',
+            },
+            {
+                generator: () => templates.generateWidgetLoader(),
+                target: 'public/widget/loader.js',
+            },
+            {
+                generator: () => templates.generateApiKeyManagementPage(),
+                target: 'app/(app)/settings/api-keys/page.tsx',
+            },
+            {
+                generator: () => templates.generateApiKeysRoute(),
+                target: 'app/api/v1/api-keys/route.ts',
+            },
+            {
+                generator: () => templates.generateApiKeyIdRoute(),
+                target: 'app/api/v1/api-keys/[id]/route.ts',
+            },
+            {
+                generator: () => templates.generateRateLimiter(),
+                target: 'lib/rate-limit.ts',
+            },
+            // Infrastructure dependencies (encryption for API keys, prisma for DB, auth helper)
+            {
+                generator: () => templates.generateEncryptionLib(),
+                target: 'lib/encryption.ts',
+            },
+            {
+                generator: () => templates.generatePrismaLib(),
+                target: 'lib/prisma.ts',
+            },
+            {
+                generator: () => templates.generateApiKeyAuthLib(),
+                target: 'lib/api-key-auth.ts',
+            },
+        ],
+        requiredUtils: [
+            {
+                generator: () => templates.generateMiddleware(),
+                target: 'middleware.ts',
+            },
+        ],
+        envVars: [
+            {
+                key: 'CORS_ALLOWED_ORIGINS',
+                value: '*',
+                comment: 'Allowed origins for widget CORS (comma-separated, e.g. http://localhost:3002)',
+            },
+        ],
+        postAddMessage: `
+✅ Embeddable Chat Widget installed!
+
+Files created:
+  • public/widget/chat.js     — Self-contained Web Component (Shadow DOM)
+  • public/widget/loader.js   — Async loader with auto-mount
+  • app/(app)/settings/api-keys/page.tsx — API Key Management UI
+  • app/api/v1/api-keys/       — API Key CRUD routes
+  • lib/rate-limit.ts          — Rate limiter with API-key tier
+  • middleware.ts              — CORS headers for cross-origin widget access
+
+CORS (cross-origin embedding):
+  CORS_ALLOWED_ORIGINS has been added to .env (default: *).
+  For production, restrict to specific domains:
+    CORS_ALLOWED_ORIGINS=https://your-site.com,https://app.example.com
+
+Next steps:
+1. Navigate to /settings/api-keys to create an API key
+2. Use the embed code to add the chat to any external website:
+
+   <script src="https://your-app.com/widget/chat.js"></script>
+   <div id="chat"></div>
+   <script>
+     ChimerAI.mount('#chat', { apiKey: 'sk_live_...', theme: 'auto' });
+   </script>
+`,
+    },
+    'model-providers': {
+        name: 'model-providers',
+        displayName: 'Model Providers',
+        description: 'AI model provider management (page + CRUD + Internal API + test)',
+        requiredUtils: [
+            { generator: () => templates.generateAuditLogHelper(), target: 'lib/audit.ts' },
+        ],
+        files: [
+            // Example page — placed in _chimerai-examples/ so the user decides where to mount it
+            {
+                generator: () => templates.generateModelProvidersPage(),
+                target: '_chimerai-examples/providers-page.tsx',
+            },
+            // Provider CRUD route — /api/providers
+            {
+                generator: () => templates.generateProviderCrudRoute(),
+                target: 'app/api/providers/route.ts',
+            },
+            // Provider [id] route — /api/providers/[id]
+            {
+                generator: () => templates.generateProviderIdRoute(),
+                target: 'app/api/providers/[id]/route.ts',
+            },
+            // Provider test route — /api/providers/[id]/test
+            {
+                generator: () => templates.generateProviderTestRoute(),
+                target: 'app/api/providers/[id]/test/route.ts',
+            },
+            // Provider sync route — /api/providers/[id]/sync
+            {
+                generator: () => templates.generateProviderSyncRoute(),
+                target: 'app/api/providers/[id]/sync/route.ts',
+            },
+            // Internal providers route — /api/internal/providers
+            {
+                generator: () => templates.generateInternalProvidersRoute(),
+                target: 'app/api/internal/providers/route.ts',
+            },
+            // Internal provider [id] route — /api/internal/providers/[id]
+            {
+                generator: () => templates.generateInternalProviderIdRoute(),
+                target: 'app/api/internal/providers/[id]/route.ts',
+            },
+            // Internal usage route — /api/internal/providers/[id]/usage
+            {
+                generator: () => templates.generateInternalProviderUsageRoute(),
+                target: 'app/api/internal/providers/[id]/usage/route.ts',
+            },
+            // Notify provider change utility
+            {
+                generator: () => templates.generateNotifyProviderChangeLib(),
+                target: 'lib/notify-provider-change.ts',
+            },
+            // Infrastructure dependencies
+            {
+                generator: () => templates.generateEncryptionLib(),
+                target: 'lib/encryption.ts',
+            },
+            {
+                generator: () => templates.generatePrismaLib(),
+                target: 'lib/prisma.ts',
+            },
+        ],
+        schemaExtension: `model Provider {
+  id          String   @id @default(cuid())
+  name        String
+  type        String
+  description String?
+  baseUrl     String?
+  apiKey      String?  @db.Text
+  config      Json     @default("{}")
+  status      String   @default("active")
+  isDefault   Boolean  @default(false)
+  priority    Int      @default(0)
+  tags        String[]
+  createdAt   DateTime @default(now())
+  updatedAt   DateTime @updatedAt
+  createdBy   String?
+
+  models        Model[]
+  health        ProviderHealth?
+  apiUsage      ApiUsage[]
+
+  @@index([type])
+  @@index([status])
+}
+
+model Model {
+  id              String   @id @default(cuid())
+  providerId      String
+  modelId         String
+  name            String
+  description     String?
+  capabilities    String[]
+  contextWindow   Int      @default(4096)
+  maxOutputTokens Int?
+  inputCost       Float    @default(0)
+  outputCost      Float    @default(0)
+  isAvailable     Boolean  @default(true)
+  isDeprecated    Boolean  @default(false)
+
+  provider Provider @relation(fields: [providerId], references: [id], onDelete: Cascade)
+
+  @@unique([providerId, modelId])
+  @@index([providerId])
+}
+
+model ProviderHealth {
+  id                  String   @id @default(cuid())
+  providerId          String   @unique
+  status              String   @default("unknown")
+  responseTime        Int?
+  lastCheck           DateTime @default(now())
+  errorMessage        String?
+  modelsAvailable     Int      @default(0)
+  chatAvailable       Boolean  @default(false)
+  embeddingAvailable  Boolean  @default(false)
+  apiKeyValid         Boolean  @default(false)
+
+  provider Provider @relation(fields: [providerId], references: [id], onDelete: Cascade)
+}
+
+model ApiUsage {
+  id               String   @id @default(cuid())
+  userId           String
+  providerId       String?
+  model            String
+  endpoint         String
+  promptTokens     Int      @default(0)
+  completionTokens Int      @default(0)
+  totalTokens      Int      @default(0)
+  tokensUsed       Int      @default(0)
+  creditsUsed      Int      @default(0)
+  cost             Float    @default(0)
+  success          Boolean  @default(true)
+  errorMessage     String?
+  responseTime     Int      @default(0)
+  createdAt        DateTime @default(now())
+
+  provider Provider? @relation(fields: [providerId], references: [id], onDelete: SetNull)
+
+  @@index([userId])
+  @@index([providerId])
+  @@index([createdAt])
+}
+`,
+        envVars: [
+            {
+                key: 'PROVIDER_ENCRYPTION_KEY',
+                value: () => crypto_1.default.randomBytes(32).toString('hex'),
+                comment: 'Encryption key for provider API keys (auto-generated)',
+            },
+        ],
+        postAddMessage: `Model providers added successfully!
+
+✅ Provider CRUD + [id] + test + sync routes
+✅ Internal provider routes (AI-Service ↔ Frontend)
+✅ Encryption lib + notify-provider-change utility
+✅ Provider seed script (prisma/seed-providers.ts) — OpenAI defaults
+✅ Example page: _chimerai-examples/providers-page.tsx
+
+┌─────────────────────────────────────────────────────────┐
+│  Integration — add provider management to your app:     │
+│                                                         │
+│  cp _chimerai-examples/providers-page.tsx               │
+│     app/dashboard/providers/page.tsx                    │
+│                                                         │
+│  Note: The page uses useSession() and needs             │
+│  SessionProvider in a parent layout.                    │
+└─────────────────────────────────────────────────────────┘
+
+Next steps:
+1. Set OPENAI_API_KEY in .env (or add provider manually later)
+2. Copy or adapt _chimerai-examples/providers-page.tsx into your app
+3. npx prisma db push (if not done yet)
+4. npx prisma db seed`,
+    },
+    'prompt-management': {
+        name: 'prompt-management',
+        displayName: 'Prompt Management',
+        description: 'System prompt and instruction management',
+        files: [
+            {
+                generator: () => templates.generatePromptManagementPage(),
+                target: 'app/dashboard/prompts/page.tsx',
+            },
+            // Prompts API routes (CRUD)
+            {
+                generator: () => templates.generatePromptsRoute(),
+                target: 'app/api/prompts/route.ts',
+            },
+            {
+                generator: () => templates.generatePromptsIdRoute(),
+                target: 'app/api/prompts/[id]/route.ts',
+            },
+            {
+                generator: () => templates.generatePromptsSetDefaultRoute(),
+                target: 'app/api/prompts/[id]/set-default/route.ts',
+            },
+            {
+                generator: () => templates.generatePromptSelector(),
+                target: 'components/chat/prompt-selector.tsx',
+            },
+        ],
+        postAddMessage: `Prompt management added successfully!
+
+✅ Prompt Management page (app/dashboard/prompts)
+✅ Prompts API routes (/api/prompts, /api/prompts/[id], /api/prompts/[id]/set-default)
+✅ PromptSelector component (components/chat/prompt-selector.tsx)
+
+Next steps:
+1. Run: npx prisma db push (to apply PromptTemplate schema)
+2. Add seed data: npx prisma db seed
+3. Navigate to /dashboard/prompts to manage system prompts
+4. Chat integration: pass promptId in the chat request body to use a specific template
+   Or set a template as Default — it will be applied automatically to all new chats`,
+    },
+    rag: {
+        name: 'rag',
+        displayName: 'RAG (Retrieval Augmented Generation)',
+        description: 'Document upload, indexing, and AI-powered Q&A via AI Service',
+        files: [
+            // RAG library (AI Service client helper)
+            {
+                generator: () => templates.generateRagLib(),
+                target: 'lib/rag.ts',
+            },
+            {
+                generator: () => templates.generateRagQueryRoute(),
+                target: 'app/api/rag/query/route.ts',
+            },
+            {
+                generator: () => templates.generateRagUploadRoute(),
+                target: 'app/api/rag/route.ts',
+            },
+            {
+                generator: () => templates.generateRagPage(),
+                target: 'app/rag/page.tsx',
+            },
+            {
+                generator: () => templates.generateRagStatsRoute(),
+                target: 'app/api/rag/stats/route.ts',
+            },
+            {
+                generator: () => templates.generateRagClearRoute(),
+                target: 'app/api/rag/clear/route.ts',
+            },
+        ],
+        // No SDK dependencies — uses AI Service via fetch()
+        postAddMessage: 'RAG system added (uses AI Service for embeddings + vector search)',
+    },
+    billing: {
+        name: 'billing',
+        displayName: 'Billing System',
+        description: 'Stripe integration for subscriptions',
+        files: [
+            {
+                generator: () => templates.generateBillingPage(),
+                target: 'app/billing/page.tsx',
+            },
+            {
+                generator: () => templates.generateStripeLib(),
+                target: 'lib/stripe.ts',
+            },
+            {
+                generator: () => templates.generateCheckoutRoute(),
+                target: 'app/api/billing/checkout/route.ts',
+            },
+            {
+                generator: () => templates.generatePortalRoute(),
+                target: 'app/api/billing/portal/route.ts',
+            },
+            {
+                generator: () => templates.generateSubscriptionRoute(),
+                target: 'app/api/billing/subscription/route.ts',
+            },
+            {
+                generator: () => templates.generateStripeWebhookRoute(),
+                target: 'app/api/webhooks/stripe/route.ts',
+            },
+        ],
+        dependencies: {
+            stripe: '^14.0.0',
+        },
+        envVars: [
+            {
+                key: 'STRIPE_SECRET_KEY',
+                value: 'sk_test_',
+                comment: 'Stripe secret key (get from https://dashboard.stripe.com/apikeys)',
+            },
+            {
+                key: 'STRIPE_WEBHOOK_SECRET',
+                value: 'whsec_',
+                comment: 'Stripe webhook signing secret (get from Stripe Dashboard → Webhooks)',
+            },
+        ],
+        postAddMessage: 'Billing system added successfully',
+    },
+    gdpr: {
+        name: 'gdpr',
+        displayName: 'GDPR Compliance',
+        description: 'Consent management, data export and account deletion (right to erasure)',
+        files: [
+            {
+                generator: () => templates.generateGdprPage(),
+                target: 'app/gdpr/page.tsx',
+            },
+            {
+                generator: () => templates.generateGdprLib(),
+                target: 'lib/gdpr.ts',
+            },
+            {
+                generator: () => templates.generateGdprConsentRoute(),
+                target: 'app/api/gdpr/consent/route.ts',
+            },
+            {
+                generator: () => templates.generateGdprDataExportRoute(),
+                target: 'app/api/gdpr/export/route.ts',
+            },
+            {
+                generator: () => templates.generateGdprAccountDeleteRoute(),
+                target: 'app/api/gdpr/delete/route.ts',
+            },
+        ],
+        schemaExtension: templates.GDPR_SCHEMA_EXTENSION,
+        postAddMessage: '✅ GDPR portal at /gdpr\n✅ API routes: /api/gdpr/export, /api/gdpr/delete, /api/gdpr/consent\n✅ ConsentLog model added to Prisma schema',
+    },
+    mfa: {
+        name: 'mfa',
+        displayName: 'Multi-Factor Authentication',
+        description: 'TOTP-based 2FA (Google Authenticator, Authy) with QR code setup',
+        files: [
+            {
+                generator: () => templates.generateMfaPage(),
+                target: 'app/(app)/settings/mfa/page.tsx',
+            },
+            {
+                generator: () => templates.generateMfaLib(),
+                target: 'lib/mfa.ts',
+            },
+            {
+                generator: () => templates.generateMfaSetupRoute(),
+                target: 'app/api/mfa/setup/route.ts',
+            },
+            {
+                generator: () => templates.generateMfaVerifyRoute(),
+                target: 'app/api/mfa/verify/route.ts',
+            },
+            {
+                generator: () => templates.generateMfaDisableRoute(),
+                target: 'app/api/mfa/disable/route.ts',
+            },
+        ],
+        dependencies: {
+            otpauth: '^9.0.0',
+            qrcode: '^1.5.3',
+            '@types/qrcode': '^1.5.5',
+        },
+        schemaExtension: templates.MFA_SCHEMA_EXTENSION,
+        postAddMessage: '✅ MFA setup page at /settings/mfa\n✅ API routes: /api/mfa/setup, /api/mfa/verify, /api/mfa/disable\n✅ MfaBackupCode model added to Prisma schema (SQLite + PostgreSQL compatible)\n⚠️  Add mfaSecret/mfaEnabled fields to User model manually or run: npx prisma migrate dev --name add-mfa',
+    },
+    'audit-log': {
+        name: 'audit-log',
+        displayName: 'Audit Log',
+        description: 'Compliance audit logging — track all admin and user actions',
+        files: [
+            {
+                generator: () => templates.generateAdminLogsPage(),
+                target: 'app/admin/audit-logs/page.tsx',
+            },
+            {
+                generator: () => templates.generateAuditLogHelper(),
+                target: 'lib/audit-log.ts',
+            },
+            {
+                generator: () => templates.generateAuditLogRoute(),
+                target: 'app/api/admin/audit-logs/route.ts',
+            },
+        ],
+        postAddMessage: '✅ Audit log page at /admin/audit-logs\n✅ lib/audit-log.ts — call logAction() anywhere\n✅ API route: /api/admin/audit-logs\n⚠️  Requires AuditLog model in Prisma schema (included in admin-dashboard)',
+    },
+    'admin-dashboard': {
+        name: 'admin-dashboard',
+        displayName: 'Admin Dashboard',
+        description: 'Complete admin panel with user/role management, settings, audit logs, and RBAC',
+        files: [
+            // Admin layout with session + admin role guard
+            {
+                generator: () => templates.generateAdminLayout(),
+                target: 'app/admin/layout.tsx',
+            },
+            // Admin dashboard page
+            {
+                generator: () => templates.generateAdminDashboardPage(),
+                target: 'app/admin/page.tsx',
+            },
+            // Admin users page
+            {
+                generator: () => templates.generateAdminUsersPage(),
+                target: 'app/admin/users/page.tsx',
+            },
+            // Admin roles page
+            {
+                generator: () => templates.generateAdminRolesPage(),
+                target: 'app/admin/roles/page.tsx',
+            },
+            // Admin settings page
+            {
+                generator: () => templates.generateAdminSettingsPage(),
+                target: 'app/admin/settings/page.tsx',
+            },
+            // Admin audit logs page
+            {
+                generator: () => templates.generateAdminLogsPage(),
+                target: 'app/admin/audit-logs/page.tsx',
+            },
+            // Audit log helper utility
+            {
+                generator: () => templates.generateAuditLogHelper(),
+                target: 'lib/audit-log.ts',
+            },
+            // Admin API routes — users CRUD
+            {
+                generator: () => templates.generateAdminUsersRoute(),
+                target: 'app/api/admin/users/route.ts',
+            },
+            {
+                generator: () => templates.generateAdminUsersIdRoute(),
+                target: 'app/api/admin/users/[id]/route.ts',
+            },
+            // Admin API routes — roles CRUD
+            {
+                generator: () => templates.generateAdminRolesRoute(),
+                target: 'app/api/admin/roles/route.ts',
+            },
+            {
+                generator: () => templates.generateAdminRolesIdRoute(),
+                target: 'app/api/admin/roles/[id]/route.ts',
+            },
+            // Admin API routes — settings + audit logs
+            {
+                generator: () => templates.generateAdminSettingsRoute(),
+                target: 'app/api/admin/settings/route.ts',
+            },
+            {
+                generator: () => templates.generateAuditLogRoute(),
+                target: 'app/api/admin/audit-logs/route.ts',
+            },
+            // Public app-settings API route (used by useAppName hook)
+            {
+                generator: () => templates.generateAppSettingsRoute(),
+                target: 'app/api/app-settings/route.ts',
+            },
+            // useAppName client hook
+            {
+                generator: () => templates.generateUseAppNameHook(),
+                target: 'lib/use-app-name.ts',
+            },
+            // RBAC Permission utilities
+            {
+                generator: () => templates.generatePermissionsLib(),
+                target: 'lib/permissions.ts',
+            },
+            {
+                generator: () => templates.generateRequirePermissionLib(),
+                target: 'lib/auth/require-permission.ts',
+            },
+        ],
+        postAddMessage: `Admin dashboard added successfully!
+
+✅ Admin layout with role guard
+✅ Pages: dashboard, users, roles, settings, audit logs
+✅ API routes: users CRUD, roles CRUD, settings, audit-logs, app-settings
+✅ RBAC: permissions lib + require-permission helper
+✅ Utilities: audit log helper, useAppName hook
+
+Next steps:
+1. Ensure auth component is installed (required for admin)
+2. Run prisma migrate to create Role, UserRole, AuditLog models
+3. Navigate to /admin to access the admin panel`,
+    },
+};
+/**
+ * Detect the dev-server port from the project's package.json scripts.
+ * Scans "dev" script for `--port XXXX` or `-p XXXX`. Falls back to 3000.
+ */
+async function detectPort(targetDir) {
+    try {
+        const pkgPath = path_1.default.join(targetDir, 'package.json');
+        if (await fs_extra_1.default.pathExists(pkgPath)) {
+            const pkg = await fs_extra_1.default.readJson(pkgPath);
+            const devScript = pkg?.scripts?.dev ?? '';
+            // Match --port 3001 or -p 3001 (with or without =)
+            const match = devScript.match(/(?:--port|-p)[=\s]+(\d+)/);
+            if (match)
+                return parseInt(match[1], 10);
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    return 3000;
+}
+/**
+ * Generate prisma/seed.ts — creates a demo admin user.
+ * Minimal: only touches User model (no Role, UserRole, CreditBalance — those
+ * don't exist in foreign-project schemas installed via `chimerai add`).
+ */
+function generateAuthSeed() {
+    return `import { PrismaClient } from '@prisma/client';
+import { hash } from 'bcryptjs';
+
+const prisma = new PrismaClient();
+
+async function main() {
+  const email = 'admin@example.com';
+  const password = 'admin123';
+
+  const existing = await prisma.user.findUnique({ where: { email } });
+  if (existing) {
+    console.log(\`✅ User \${email} already exists — skipping.\`);
+    return;
+  }
+
+  const hashed = await hash(password, 12);
+  await prisma.user.create({
+    data: {
+      name: 'Admin',
+      email,
+      password: hashed,
+    },
+  });
+  console.log(\`✅ Demo user created: \${email} / \${password}\`);
+}
+
+main()
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  })
+  .finally(() => prisma.$disconnect());
+`;
+}
+/**
+ * Generate prisma/seed-providers.ts — seeds an OpenAI provider + default models.
+ * Uses findFirst + create (Provider.name is NOT @unique in foreign schemas).
+ */
+function generateProviderSeed() {
+    return `import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+async function main() {
+  // Check if OpenAI provider already exists
+  const existing = await prisma.provider.findFirst({ where: { name: 'OpenAI' } });
+  if (existing) {
+    console.log('✅ OpenAI provider already exists — skipping.');
+    return;
+  }
+
+  const apiKey = process.env.OPENAI_API_KEY ?? '';
+  const isActive = apiKey.length > 0;
+  const provider = await prisma.provider.create({
+    data: {
+      name: 'OpenAI',
+      type: 'openai',
+      baseUrl: 'https://api.openai.com/v1',
+      apiKey,
+      config: { defaultModel: 'gpt-4o-mini' },
+      status: isActive ? 'active' : 'inactive',
+      tags: JSON.stringify(['llm', 'chat', 'embeddings']),
+    },
+  });
+
+  // Seed default models
+  const models = [
+    { name: 'GPT-4o', modelId: 'gpt-4o', contextWindow: 128000, capabilities: JSON.stringify(['chat', 'vision']) },
+    { name: 'GPT-4o Mini', modelId: 'gpt-4o-mini', contextWindow: 128000, capabilities: JSON.stringify(['chat']) },
+  ];
+  for (const m of models) {
+    await prisma.model.create({
+      data: {
+        ...m,
+        providerId: provider.id,
+        isAvailable: isActive,
+      },
+    });
+  }
+
+  console.log(\`✅ OpenAI provider + \${models.length} models seeded.\`);
+  if (!apiKey) {
+    console.log('⚠️  No OPENAI_API_KEY found — provider created but inactive.');
+    console.log('   Set OPENAI_API_KEY in .env and re-run: npx prisma db seed');
+  }
+}
+
+main()
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  })
+  .finally(() => prisma.$disconnect());
+`;
+}
+/**
+ * Transform a PostgreSQL-native Prisma schema to be SQLite-compatible.
+ * Applied as a post-processing step so templates stay PostgreSQL-first.
+ *
+ *  @db.Text          → removed (SQLite String is unbounded)
+ *  Json / Json?      → String / String?
+ *  String[]          → String   (app code uses JSON.parse)
+ *  @default("{}")    → @default("{}") (kept, works as String default)
+ *  @default(["..."]) → @default("...") (array default → plain string)
+ */
+function transformSchemaForSqlite(schema) {
+    let s = schema;
+    // 1. Remove @db.Text annotations
+    s = s.replace(/\s+@db\.Text/g, '');
+    // 2. Convert Json fields → String (preserve optional ?)
+    //    Json?  → String?
+    //    Json   → String
+    s = s.replace(/(\s+)Json(\??)(\s+)/g, '$1String$2$3');
+    // 3. Convert String[] → String (arrays not supported)
+    s = s.replace(/String\[\]/g, 'String');
+    // 4. Fix array defaults: @default(["chat"]) → @default("chat")
+    s = s.replace(/@default\(\[([^\]]*)\]\)/g, (_match, inner) => {
+        // inner is e.g. '"chat"' — strip quotes, join if multiple
+        const items = inner
+            .replace(/"/g, '')
+            .split(',')
+            .map((x) => x.trim())
+            .join(',');
+        return `@default("${items}")`;
+    });
+    return s;
+}
+/**
+ * Generic component addition function (PHASE 4 refactoring)
+ * Uses inline template generators — no fs.copy(), no dependency on templates/ folder
+ */
+async function addComponent(config, targetDir) {
+    const spinner = (0, ora_1.default)(`Adding ${config.displayName}...`).start();
+    try {
+        // 1. Generate and write all required files
+        // Detect if project uses (app) route group for pages
+        const hasAppGroup = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'app/(app)'));
+        for (const file of config.files) {
+            let target = file.target;
+            // Place page files inside (app) route group if it exists
+            // (but not API routes which stay under app/api/)
+            if (hasAppGroup &&
+                target.startsWith('app/') &&
+                !target.startsWith('app/api/') &&
+                !target.startsWith('app/dashboard/') &&
+                target.endsWith('page.tsx')) {
+                target = target.replace('app/', 'app/(app)/');
+            }
+            const targetPath = path_1.default.join(targetDir, target);
+            // Ensure directory exists
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(targetPath));
+            // Generate content from inline template and write
+            const content = file.generator();
+            await fs_extra_1.default.writeFile(targetPath, content);
+            spinner.text = `Adding ${config.displayName}... (${file.target})`;
+        }
+        // 1.5 Create required utility stubs if they don't already exist.
+        // Some templates reference utilities (lib/audit.ts, lib/use-app-name.ts) that are
+        // fully provided by admin-ui. When installing components standalone we create the
+        // same full-featured files here so the project builds without admin-ui.
+        if (config.requiredUtils) {
+            for (const util of config.requiredUtils) {
+                const utilPath = path_1.default.join(targetDir, util.target);
+                if (!(await fs_extra_1.default.pathExists(utilPath))) {
+                    await fs_extra_1.default.ensureDir(path_1.default.dirname(utilPath));
+                    await fs_extra_1.default.writeFile(utilPath, util.generator());
+                    spinner.text = `Adding ${config.displayName}... (created ${util.target})`;
+                }
+            }
+        }
+        // 1.6 (removed) — We no longer patch the user's root layout.
+        // Instead, the postAddMessage tells the user how to add SessionProvider.
+        // 1.7 Auto-write environment variables to .env
+        if (config.envVars && config.envVars.length > 0) {
+            const envPath = path_1.default.join(targetDir, '.env');
+            let envContent = '';
+            if (await fs_extra_1.default.pathExists(envPath)) {
+                envContent = await fs_extra_1.default.readFile(envPath, 'utf-8');
+            }
+            // Resolve __PORT_DETECT__ placeholder once (lazy)
+            let resolvedPort = null;
+            const newLines = [];
+            for (const envVar of config.envVars) {
+                if (!envContent.includes(`${envVar.key}=`)) {
+                    let val = typeof envVar.value === 'function' ? envVar.value() : envVar.value;
+                    // Replace port placeholder with detected port
+                    if (typeof val === 'string' && val.includes('__PORT_DETECT__')) {
+                        if (resolvedPort === null) {
+                            resolvedPort = await detectPort(targetDir);
+                        }
+                        val = val.replace('__PORT_DETECT__', String(resolvedPort));
+                    }
+                    if (envVar.comment) {
+                        newLines.push(`# ${envVar.comment}`);
+                    }
+                    newLines.push(`${envVar.key}=${val}`);
+                }
+            }
+            if (newLines.length > 0) {
+                const separator = envContent.length > 0 && !envContent.endsWith('\n') ? '\n' : '';
+                await fs_extra_1.default.appendFile(envPath, `${separator}\n${newLines.join('\n')}\n`);
+                spinner.text = `Adding ${config.displayName}... (configured .env)`;
+            }
+        }
+        // 1.8 Generate seed scripts for runtime-readiness
+        if (config.name === 'auth') {
+            const seedPath = path_1.default.join(targetDir, 'prisma', 'seed.ts');
+            if (!(await fs_extra_1.default.pathExists(seedPath))) {
+                await fs_extra_1.default.ensureDir(path_1.default.dirname(seedPath));
+                await fs_extra_1.default.writeFile(seedPath, generateAuthSeed());
+                spinner.text = `Adding ${config.displayName}... (created prisma/seed.ts)`;
+            }
+            // Wire prisma.seed in package.json (ts-node + esm)
+            const pkgPath = path_1.default.join(targetDir, 'package.json');
+            if (await fs_extra_1.default.pathExists(pkgPath)) {
+                const pkg = await fs_extra_1.default.readJson(pkgPath);
+                if (!pkg.prisma?.seed) {
+                    pkg.prisma = pkg.prisma ?? {};
+                    pkg.prisma.seed = 'npx tsx prisma/seed.ts';
+                    await fs_extra_1.default.writeJson(pkgPath, pkg, { spaces: 2 });
+                    spinner.text = `Adding ${config.displayName}... (configured prisma.seed in package.json)`;
+                }
+            }
+        }
+        if (config.name === 'model-providers') {
+            const seedProvPath = path_1.default.join(targetDir, 'prisma', 'seed-providers.ts');
+            if (!(await fs_extra_1.default.pathExists(seedProvPath))) {
+                await fs_extra_1.default.ensureDir(path_1.default.dirname(seedProvPath));
+                await fs_extra_1.default.writeFile(seedProvPath, generateProviderSeed());
+                spinner.text = `Adding ${config.displayName}... (created prisma/seed-providers.ts)`;
+            }
+            // Append provider-seed call to seed.ts if it exists (auth installed first)
+            const seedPath = path_1.default.join(targetDir, 'prisma', 'seed.ts');
+            if (await fs_extra_1.default.pathExists(seedPath)) {
+                const seedContent = await fs_extra_1.default.readFile(seedPath, 'utf-8');
+                if (!seedContent.includes('seed-providers')) {
+                    // Add import and call at the end of the main() function
+                    const patchedSeed = seedContent.replace(/main\(\)\s*\n\s*\.catch/, `main()\n  .then(async () => {\n    // Auto-added by chimerai add model-providers\n    const { execSync } = require('child_process');\n    execSync('npx tsx prisma/seed-providers.ts', { stdio: 'inherit', env: { ...process.env } });\n  })\n  .catch`);
+                    if (patchedSeed !== seedContent) {
+                        await fs_extra_1.default.writeFile(seedPath, patchedSeed);
+                        spinner.text = `Adding ${config.displayName}... (wired seed-providers into seed.ts)`;
+                    }
+                }
+            }
+        }
+        // 1.9 Ensure Tailwind CSS is available (all templates use Tailwind utility classes)
+        //     Only runs once — checks if tailwindcss is already a dependency.
+        //     Installs Tailwind v4 (CSS-based config, no tailwind.config.js needed).
+        {
+            const packageJsonPath = path_1.default.join(targetDir, 'package.json');
+            if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+                const pkg = await fs_extra_1.default.readJson(packageJsonPath);
+                const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+                if (!allDeps['tailwindcss']) {
+                    spinner.text = `Adding ${config.displayName}... (setting up Tailwind CSS)`;
+                    // a) Add tailwindcss + postcss plugin as devDependencies
+                    pkg.devDependencies = pkg.devDependencies || {};
+                    pkg.devDependencies['tailwindcss'] = '^4';
+                    pkg.devDependencies['@tailwindcss/postcss'] = '^4';
+                    await fs_extra_1.default.writeJson(packageJsonPath, pkg, { spaces: 2 });
+                    // b) Create postcss.config.mjs if it doesn't exist
+                    const postcssConfigs = ['postcss.config.mjs', 'postcss.config.js', 'postcss.config.cjs'];
+                    const hasPostcss = (await Promise.all(postcssConfigs.map((f) => fs_extra_1.default.pathExists(path_1.default.join(targetDir, f))))).some(Boolean);
+                    if (!hasPostcss) {
+                        await fs_extra_1.default.writeFile(path_1.default.join(targetDir, 'postcss.config.mjs'), `/** @type {import('postcss-load-config').Config} */\nconst config = {\n  plugins: {\n    "@tailwindcss/postcss": {},\n  },\n};\n\nexport default config;\n`);
+                    }
+                    // c) Ensure Tailwind directives in globals.css (if not already present)
+                    //    Wrap existing CSS in @layer base {} so stock Next.js resets
+                    //    (e.g. * { padding:0; margin:0 }) don't override Tailwind
+                    //    utility classes which live in @layer utilities.
+                    const globalsPath = path_1.default.join(targetDir, 'app', 'globals.css');
+                    if (await fs_extra_1.default.pathExists(globalsPath)) {
+                        const css = await fs_extra_1.default.readFile(globalsPath, 'utf-8');
+                        if (!css.includes('@import "tailwindcss"') &&
+                            !css.includes("@import 'tailwindcss'") &&
+                            !css.includes('@tailwind base')) {
+                            // Wrap existing CSS in @layer base so it doesn't conflict
+                            // with Tailwind's cascade layers (unlayered CSS beats
+                            // layered utilities regardless of specificity).
+                            const indented = css
+                                .split('\n')
+                                .map((line) => (line.trim() ? `  ${line}` : line))
+                                .join('\n');
+                            await fs_extra_1.default.writeFile(globalsPath, `@tailwind base;\n@tailwind components;\n@tailwind utilities;\n\n@layer base {\n${indented}\n}\n`);
+                        }
+                    }
+                    else {
+                        // No globals.css — create one with Tailwind directives
+                        await fs_extra_1.default.ensureDir(path_1.default.join(targetDir, 'app'));
+                        await fs_extra_1.default.writeFile(path_1.default.join(targetDir, 'app', 'globals.css'), `@tailwind base;\n@tailwind components;\n@tailwind utilities;\n`);
+                    }
+                    console.log(chalk_1.default.cyan(`\n  🎨 Tailwind CSS configured (all ChimerAI components use Tailwind)`));
+                }
+            }
+        }
+        // 2. Extend Prisma schema if needed
+        if (config.schemaExtension) {
+            const schemaPath = path_1.default.join(targetDir, 'prisma', 'schema.prisma');
+            // Shared helper: inject a relation field before the closing brace of a Prisma model
+            const injectRelation = (s, modelName, relation) => {
+                // Check if this model already has the relation (whitespace-insensitive)
+                const modelStart = s.indexOf(`model ${modelName} {`);
+                if (modelStart === -1)
+                    return s;
+                const nextModel = s.indexOf('\nmodel ', modelStart + 1);
+                const modelBlock = nextModel === -1 ? s.substring(modelStart) : s.substring(modelStart, nextModel);
+                // Extract the field name (first word) from the relation string
+                // e.g. "apiUsage ApiUsage[]" → "apiUsage", "user User @relation(...)" → "user"
+                const fieldName = relation.trim().split(/\s+/)[0];
+                // Check if this field already exists in the model block (any spacing)
+                const fieldRegex = new RegExp(`^\\s+${fieldName}\\s+`, 'm');
+                if (fieldRegex.test(modelBlock))
+                    return s;
+                // Find the closing brace line of this model (line-based, avoids regex issues with } in defaults)
+                const lines = s.split('\n');
+                let inModel = false;
+                for (let i = 0; i < lines.length; i++) {
+                    if (lines[i].includes(`model ${modelName} {`)) {
+                        inModel = true;
+                        continue;
+                    }
+                    if (inModel && lines[i].trim() === '}') {
+                        lines.splice(i, 0, `  ${relation}`);
+                        return lines.join('\n');
+                    }
+                }
+                return s;
+            };
+            // Registry of cross-component relations that need back-relations injected.
+            // Runs after EVERY schema extension, regardless of which component triggered it.
+            // This makes installation order irrelevant.
+            // Each entry can have:
+            //   backRelation  → injected into targetModel (the array/list side)
+            //   forwardRelation → injected into ifModel (the FK side, if missing)
+            const CROSS_RELATIONS = [
+                // chat-ui ↔ auth: Conversation.user → User needs User.conversations
+                {
+                    ifModel: 'Conversation',
+                    targetModel: 'User',
+                    backRelation: 'conversations Conversation[]',
+                },
+                // chat-ui ↔ model-providers: Conversation.provider → Provider needs Provider.conversations
+                {
+                    ifModel: 'Conversation',
+                    targetModel: 'Provider',
+                    backRelation: 'conversations Conversation[]',
+                },
+                // model-providers ↔ auth: ApiUsage ↔ User (both sides needed)
+                {
+                    ifModel: 'ApiUsage',
+                    targetModel: 'User',
+                    backRelation: 'apiUsage ApiUsage[]',
+                    forwardRelation: 'user       User      @relation(fields: [userId], references: [id], onDelete: Cascade)',
+                },
+            ];
+            const fixCrossRelations = async () => {
+                if (!(await fs_extra_1.default.pathExists(schemaPath)))
+                    return;
+                let schema = await fs_extra_1.default.readFile(schemaPath, 'utf-8');
+                let changed = false;
+                for (const { ifModel, targetModel, backRelation, forwardRelation } of CROSS_RELATIONS) {
+                    if (schema.includes(`model ${ifModel} {`) && schema.includes(`model ${targetModel} {`)) {
+                        // Inject back-relation into targetModel (e.g. User.conversations)
+                        const afterBack = injectRelation(schema, targetModel, backRelation);
+                        if (afterBack !== schema) {
+                            schema = afterBack;
+                            changed = true;
+                        }
+                        // Inject forward-relation into ifModel if specified (e.g. ApiUsage.user)
+                        if (forwardRelation) {
+                            const afterFwd = injectRelation(schema, ifModel, forwardRelation);
+                            if (afterFwd !== schema) {
+                                schema = afterFwd;
+                                changed = true;
+                            }
+                        }
+                    }
+                }
+                if (changed) {
+                    await fs_extra_1.default.writeFile(schemaPath, schema);
+                }
+            };
+            if (await fs_extra_1.default.pathExists(schemaPath)) {
+                try {
+                    await (0, schema_manager_js_1.extendPrismaSchema)(schemaPath, config.schemaExtension);
+                    await fixCrossRelations();
+                    spinner.text = `Adding ${config.displayName}... (prisma schema extended)`;
+                }
+                catch (err) {
+                    console.log(chalk_1.default.yellow(`\n  ⚠️  Could not extend Prisma schema: ${err.message}`));
+                    console.log(chalk_1.default.yellow(`  You may need to add Conversation/Message models manually.`));
+                }
+            }
+            else {
+                // === Schema does not exist — create base schema + apply extension ===
+                console.log(chalk_1.default.yellow(`\n  ⚠️  No Prisma schema found — creating base schema...`));
+                // 1. Create prisma/ directory
+                await fs_extra_1.default.ensureDir(path_1.default.join(targetDir, 'prisma'));
+                // 2. Write base schema (generator + datasource)
+                //    Detect provider from DATABASE_URL in .env (default: sqlite for dev)
+                const envPath = path_1.default.join(targetDir, '.env');
+                let dbProvider = 'sqlite';
+                if (await fs_extra_1.default.pathExists(envPath)) {
+                    const envContent = await fs_extra_1.default.readFile(envPath, 'utf-8');
+                    const dbUrlMatch = envContent.match(/DATABASE_URL\s*=\s*(.+)/);
+                    if (dbUrlMatch) {
+                        const dbUrl = dbUrlMatch[1].trim();
+                        if (dbUrl.startsWith('postgresql://') || dbUrl.startsWith('postgres://')) {
+                            dbProvider = 'postgresql';
+                        }
+                        else if (dbUrl.startsWith('mysql://')) {
+                            dbProvider = 'mysql';
+                        }
+                        // file: or anything else → sqlite
+                    }
+                }
+                const baseSchema = `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${dbProvider}"
+  url      = env("DATABASE_URL")
+}
+
+`;
+                await fs_extra_1.default.writeFile(schemaPath, baseSchema);
+                // 3. Apply schema extension
+                try {
+                    await (0, schema_manager_js_1.extendPrismaSchema)(schemaPath, config.schemaExtension);
+                    await fixCrossRelations();
+                    spinner.text = `Adding ${config.displayName}... (prisma schema created + extended)`;
+                }
+                catch (err) {
+                    console.log(chalk_1.default.yellow(`\n  ⚠️  Could not extend Prisma schema: ${err.message}`));
+                    console.log(chalk_1.default.yellow(`  You may need to add the models manually.`));
+                }
+                // 4. Create lib/prisma.ts (PrismaClient singleton) if not present
+                const prismaLibPath = path_1.default.join(targetDir, 'lib', 'prisma.ts');
+                if (!(await fs_extra_1.default.pathExists(prismaLibPath))) {
+                    await fs_extra_1.default.ensureDir(path_1.default.join(targetDir, 'lib'));
+                    await fs_extra_1.default.writeFile(prismaLibPath, templates.generatePrismaLib());
+                }
+                // 5. Add Prisma dependencies + scripts to package.json
+                const packageJsonPath = path_1.default.join(targetDir, 'package.json');
+                if (fs_extra_1.default.existsSync(packageJsonPath)) {
+                    const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
+                    packageJson.dependencies = packageJson.dependencies || {};
+                    packageJson.devDependencies = packageJson.devDependencies || {};
+                    if (!packageJson.dependencies['@prisma/client']) {
+                        packageJson.dependencies['@prisma/client'] = '^5.22.0';
+                    }
+                    if (!packageJson.devDependencies['prisma']) {
+                        packageJson.devDependencies['prisma'] = '^5.22.0';
+                    }
+                    // Scripts
+                    packageJson.scripts = packageJson.scripts || {};
+                    if (!packageJson.scripts['db:push']) {
+                        packageJson.scripts['db:push'] = 'prisma db push';
+                    }
+                    if (!packageJson.scripts['db:generate']) {
+                        packageJson.scripts['db:generate'] = 'prisma generate';
+                    }
+                    if (!packageJson.scripts['db:studio']) {
+                        packageJson.scripts['db:studio'] = 'prisma studio';
+                    }
+                    await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+                }
+                console.log(chalk_1.default.cyan(`\n  📦 Created Prisma base schema + dependencies`));
+                console.log(chalk_1.default.yellow(`  → Configure DATABASE_URL in .env (or run: chimerai setup database)`));
+                // Optional: warn if referenced models are missing
+                if (config.schemaExtension.includes('userId') &&
+                    !(await fs_extra_1.default.readFile(schemaPath, 'utf-8')).includes('model User {')) {
+                    console.log(chalk_1.default.yellow(`  ⚠️  Schema references User model which doesn't exist yet.`));
+                    console.log(chalk_1.default.yellow(`      Run: chimerai add auth`));
+                }
+            }
+        }
+        // 2.5 SQLite compatibility transform
+        //     Templates are PostgreSQL-native (production). When the datasource is
+        //     sqlite we post-process the schema to strip unsupported types.
+        if (config.schemaExtension) {
+            const schemaPath = path_1.default.join(targetDir, 'prisma', 'schema.prisma');
+            if (await fs_extra_1.default.pathExists(schemaPath)) {
+                const schema = await fs_extra_1.default.readFile(schemaPath, 'utf-8');
+                if (schema.includes('provider = "sqlite"')) {
+                    const transformed = transformSchemaForSqlite(schema);
+                    if (transformed !== schema) {
+                        await fs_extra_1.default.writeFile(schemaPath, transformed);
+                        spinner.text = `Adding ${config.displayName}... (adapted schema for SQLite)`;
+                    }
+                }
+            }
+        }
+        // 3. Update package.json if dependencies required
+        if (config.dependencies && Object.keys(config.dependencies).length > 0) {
+            const packageJsonPath = path_1.default.join(targetDir, 'package.json');
+            if (fs_extra_1.default.existsSync(packageJsonPath)) {
+                const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
+                packageJson.dependencies = packageJson.dependencies || {};
+                Object.entries(config.dependencies).forEach(([dep, version]) => {
+                    if (!packageJson.dependencies[dep]) {
+                        packageJson.dependencies[dep] = version;
+                    }
+                });
+                await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+            }
+        }
+        // 3. Show success message
+        spinner.succeed(chalk_1.default.green(config.postAddMessage));
+        // 3.5 prompt-management: optionally patch chat/page.tsx if chat-ui is installed
+        if (config.name === 'prompt-management') {
+            // Cleanup legacy route-group prompts page to avoid duplicate /dashboard/prompts routes
+            const legacyPromptPage = path_1.default.join(targetDir, 'app', '(app)', 'dashboard', 'prompts', 'page.tsx');
+            const canonicalPromptPage = path_1.default.join(targetDir, 'app', 'dashboard', 'prompts', 'page.tsx');
+            if ((await fs_extra_1.default.pathExists(legacyPromptPage)) && (await fs_extra_1.default.pathExists(canonicalPromptPage))) {
+                await fs_extra_1.default.remove(legacyPromptPage);
+                console.log(chalk_1.default.green('  ✓ Removed legacy app/(app)/dashboard/prompts/page.tsx'));
+            }
+            // Patch dashboard sidebar link (/dashboard/prompts)
+            const dashboardLayoutPath = path_1.default.join(targetDir, 'app', 'dashboard', 'layout.tsx');
+            if (await fs_extra_1.default.pathExists(dashboardLayoutPath)) {
+                let layout = await fs_extra_1.default.readFile(dashboardLayoutPath, 'utf-8');
+                const original = layout;
+                if (!layout.includes('/dashboard/prompts') && layout.includes('/dashboard/settings')) {
+                    layout = layout.replace(`          <Link href="/dashboard/settings" onClick={() => setSidebarOpen(false)} className="block px-4 py-2 rounded hover:bg-gray-200 dark:hover:bg-gray-700 dark:text-gray-200">`, `          <Link href="/dashboard/prompts" onClick={() => setSidebarOpen(false)} className="block px-4 py-2 rounded hover:bg-gray-200 dark:hover:bg-gray-700 dark:text-gray-200">\n            Prompt Templates\n          </Link>\n          <Link href="/dashboard/settings" onClick={() => setSidebarOpen(false)} className="block px-4 py-2 rounded hover:bg-gray-200 dark:hover:bg-gray-700 dark:text-gray-200">`);
+                }
+                if (layout !== original) {
+                    await fs_extra_1.default.writeFile(dashboardLayoutPath, layout, 'utf-8');
+                    console.log(chalk_1.default.green('  ✓ Patched app/dashboard/layout.tsx — Prompt Templates link added'));
+                }
+            }
+            // Patch dashboard tiles page (/dashboard/prompts card)
+            const dashboardPagePath = path_1.default.join(targetDir, 'app', 'dashboard', 'page.tsx');
+            if (await fs_extra_1.default.pathExists(dashboardPagePath)) {
+                let dashboardPage = await fs_extra_1.default.readFile(dashboardPagePath, 'utf-8');
+                const original = dashboardPage;
+                if (dashboardPage.includes(`const links = [`)) {
+                    dashboardPage = dashboardPage.replace(/\s*\{ href: '\/dashboard\/prompts', label: 'Prompt Templates', icon: '📝', description: 'Create and manage system prompts' \},?/g, '');
+                    dashboardPage = dashboardPage.replace(`  ];`, `    { href: '/dashboard/prompts', label: 'Prompt Templates', icon: '📝', description: 'Create and manage system prompts' },\n  ];`);
+                }
+                if (dashboardPage !== original) {
+                    await fs_extra_1.default.writeFile(dashboardPagePath, dashboardPage, 'utf-8');
+                    console.log(chalk_1.default.green('  ✓ Patched app/dashboard/page.tsx — Prompt Templates tile added'));
+                }
+            }
+            const chatPageCandidates = [
+                path_1.default.join(targetDir, 'app', '(app)', 'chat', 'page.tsx'),
+                path_1.default.join(targetDir, 'app', 'chat', 'page.tsx'),
+            ];
+            for (const chatPagePath of chatPageCandidates) {
+                if (await fs_extra_1.default.pathExists(chatPagePath)) {
+                    let chatPage = await fs_extra_1.default.readFile(chatPagePath, 'utf-8');
+                    let patched = false;
+                    if (!chatPage.includes('PromptSelector') && chatPage.includes('ModelSelector')) {
+                        chatPage = chatPage.replace(`import { ModelSelector } from '@/components/chat/model-selector';`, `import { ModelSelector } from '@/components/chat/model-selector';\nimport { PromptSelector } from '@/components/chat/prompt-selector';`);
+                        patched = true;
+                    }
+                    if (!chatPage.includes('selectedPromptId') && chatPage.includes('setSelectedModelId,')) {
+                        chatPage = chatPage.replace(`    setSelectedModelId,`, `    setSelectedModelId,\n    selectedPromptId,\n    setSelectedPromptId,`);
+                        patched = true;
+                    }
+                    if (!chatPage.includes('<PromptSelector') && chatPage.includes('<ModelSelector')) {
+                        chatPage = chatPage.replace(/(<ModelSelector[\s\S]*?disabled={isStreaming}\s*\/>)/, `$1\n          <PromptSelector\n            value={selectedPromptId}\n            onChange={setSelectedPromptId}\n            category="system"\n            placeholder="No system prompt"\n          />`);
+                        patched = true;
+                    }
+                    if (patched) {
+                        await fs_extra_1.default.writeFile(chatPagePath, chatPage, 'utf-8');
+                        console.log(chalk_1.default.green(`  ✓ Patched ${path_1.default.relative(targetDir, chatPagePath)} — PromptSelector added`));
+                    }
+                    break;
+                }
+            }
+            const streamRoutePath = path_1.default.join(targetDir, 'app', 'api', 'v1', 'chat', 'stream', 'route.ts');
+            if (await fs_extra_1.default.pathExists(streamRoutePath)) {
+                let route = await fs_extra_1.default.readFile(streamRoutePath, 'utf-8');
+                const original = route;
+                // Ensure payload contains promptId
+                route = route
+                    .replace(`const { messages, model, providerId, conversationId } = payload;`, `const { messages, model, providerId, conversationId, promptId } = payload;`)
+                    .replace(`const { messages, model, providerId, conversationId,promptId } = payload;`, `const { messages, model, providerId, conversationId, promptId } = payload;`);
+                // Insert template-loading block only once
+                if (!route.includes('let systemPromptContent: string | undefined;')) {
+                    route = route.replace(`    // --- 3. Load provider and decrypt API key ---`, `    // --- 2.5 Load system prompt template ---\n    let systemPromptContent: string | undefined;\n    if (promptId) {\n      const template = await (prisma as any).promptTemplate.findFirst({ where: { id: promptId, isActive: true } });\n      if (template) systemPromptContent = template.content;\n    }\n    if (!systemPromptContent) {\n      const def = await (prisma as any).promptTemplate.findFirst({ where: { category: 'system', isDefault: true, isActive: true } });\n      if (def) systemPromptContent = def.content;\n    }\n\n    // --- 3. Load provider and decrypt API key ---`);
+                }
+                // Anthropic: dedicated system field
+                route = route.replace(`system: messages.find((m: any) => m.role === 'system')?.content || undefined,`, `system: systemPromptContent || messages.find((m: any) => m.role === 'system')?.content || undefined,`);
+                // Ollama/OpenAI-like providers: prepend system message if selected/default template exists
+                const promptMessagesBlock = `messages: systemPromptContent\n              ? [{ role: 'system', content: systemPromptContent }, ...messages.filter((m: any) => m.role !== 'system')]\n              : messages,`;
+                // Replace plain `messages` payload in both blocks (ollama + openai-like)
+                route = route.replace(`            model: modelId,\n            messages,\n            stream: true,`, `            model: modelId,\n            ${promptMessagesBlock}\n            stream: true,`);
+                route = route.replace(`            model: modelId,\n            messages,\n            stream: true,`, `            model: modelId,\n            ${promptMessagesBlock}\n            stream: true,`);
+                // Heal accidental duplicated ternary from previous patch versions
+                route = route.replace(`            messages: systemPromptContent\n              ? [{ role: 'system', content: systemPromptContent }, ...messages.filter((m: any) => m.role !== 'system')]\n              : messages: systemPromptContent\n              ? [{ role: 'system', content: systemPromptContent }, ...messages.filter((m: any) => m.role !== 'system')]\n              : messages,`, `            ${promptMessagesBlock}`);
+                if (route !== original) {
+                    await fs_extra_1.default.writeFile(streamRoutePath, route, 'utf-8');
+                    console.log(chalk_1.default.green(`  ✓ Patched app/api/v1/chat/stream/route.ts — promptId support added`));
+                }
+            }
+            const useChatPath = path_1.default.join(targetDir, 'components', 'chat', 'use-chat.ts');
+            if (await fs_extra_1.default.pathExists(useChatPath)) {
+                let useChat = await fs_extra_1.default.readFile(useChatPath, 'utf-8');
+                if (!useChat.includes('selectedPromptId') && useChat.includes('setSystemPrompt')) {
+                    useChat = useChat
+                        .replace(`  setSystemPrompt: (prompt: string) => void;`, `  setSystemPrompt: (prompt: string) => void;\n  selectedPromptId: string | null;\n  setSelectedPromptId: (id: string | null) => void;`)
+                        .replace(`  const [systemPrompt, setSystemPrompt] = useState('');`, `  const [systemPrompt, setSystemPrompt] = useState('');\n  const [selectedPromptId, setSelectedPromptId] = useState<string | null>(null);`)
+                        .replace(`          conversationId: conversationIdRef.current || undefined,\n          providerId,\n        };`, `          conversationId: conversationIdRef.current || undefined,\n          providerId,\n          ...(selectedPromptId ? { promptId: selectedPromptId } : {}),\n        };`)
+                        .replace(`    setSystemPrompt,\n    regenerateMessage,`, `    setSystemPrompt,\n    selectedPromptId,\n    setSelectedPromptId,\n    regenerateMessage,`)
+                        .replace(`    [isStreaming, messages, models, selectedModelId, systemPrompt, options, refreshConversations, fetchCreditBalance]`, `    [isStreaming, messages, models, selectedModelId, selectedPromptId, systemPrompt, options, refreshConversations, fetchCreditBalance]`);
+                    await fs_extra_1.default.writeFile(useChatPath, useChat, 'utf-8');
+                    console.log(chalk_1.default.green(`  ✓ Patched components/chat/use-chat.ts — selectedPromptId added`));
+                }
+            }
+        }
+        // 4. Show what was added
+        console.log(chalk_1.default.cyan('\n  Files added:'));
+        config.files.forEach((file) => {
+            console.log(chalk_1.default.cyan(`    ✓ ${file.target}`));
+        });
+        if (config.dependencies && Object.keys(config.dependencies).length > 0) {
+            console.log(chalk_1.default.cyan('\n  Installing dependencies...'));
+            try {
+                (0, child_process_1.execSync)('pnpm install', { cwd: targetDir, stdio: 'inherit' });
+                console.log(chalk_1.default.green('  ✓ Dependencies installed'));
+            }
+            catch {
+                console.log(chalk_1.default.yellow('\n  Dependencies to install:'));
+                Object.entries(config.dependencies).forEach(([dep, version]) => {
+                    console.log(chalk_1.default.yellow(`    • ${dep}@${version}`));
+                });
+                console.log(chalk_1.default.white('  Run: pnpm install'));
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red(`Failed to add ${config.displayName}`));
+        console.error(error.message);
+        throw error;
+    }
+}
+// ============================================================================
+// AI Service — Modular installation logic
+// ============================================================================
+const AI_SERVICE_DIR = 'services/ai';
+/**
+ * Ensure the core AI service structure exists.
+ * Creates services/ai/ with config.py, provider_client.py, services/__init__.py, routes/__init__.py
+ */
+async function ensureAiServiceCore(targetDir, spinner) {
+    const aiDir = path_1.default.join(targetDir, AI_SERVICE_DIR);
+    const manifestPath = path_1.default.join(aiDir, '.chimerai-ai');
+    // If manifest exists, read and return it
+    if (await fs_extra_1.default.pathExists(manifestPath)) {
+        return templates.readAiManifest(targetDir);
+    }
+    // First time — create core structure
+    spinner.text = 'Creating AI service core structure...';
+    await fs_extra_1.default.ensureDir(path_1.default.join(aiDir, 'services'));
+    await fs_extra_1.default.ensureDir(path_1.default.join(aiDir, 'routes'));
+    // Core files (always present)
+    await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'config.py'), templates.generateAiServiceConfig([]));
+    await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'provider_client.py'), templates.generateProviderClient());
+    await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', '__init__.py'), templates.generateServicesInit());
+    // Initial manifest
+    const manifest = {
+        modules: [],
+        tools: [],
+        installedAt: new Date().toISOString().split('T')[0],
+        cliVersion: '1.0.0',
+    };
+    templates.writeAiManifest(targetDir, manifest);
+    return manifest;
+}
+/**
+ * Regenerate dynamic files (main.py, models.py, requirements.txt, README.md, routes/__init__.py)
+ * based on the current manifest state.
+ */
+async function regenerateAiServiceFiles(targetDir, manifest, spinner) {
+    const aiDir = path_1.default.join(targetDir, AI_SERVICE_DIR);
+    spinner.text = 'Regenerating AI service files...';
+    // Dynamic files
+    await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'main.py'), templates.generateAiServiceMain(manifest.modules, manifest.tools));
+    await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'models.py'), templates.generateAiServiceModels(manifest.modules));
+    await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'requirements.txt'), templates.generateAiServiceRequirements(manifest.modules, manifest.tools));
+    await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'config.py'), templates.generateAiServiceConfig(manifest.modules));
+    await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'README.md'), templates.generateAiServiceReadme(manifest.modules, manifest.tools));
+    await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'routes', '__init__.py'), templates.generateRoutesInit());
+    // Dockerfile (static but only created once)
+    const dockerfilePath = path_1.default.join(aiDir, 'Dockerfile');
+    if (!(await fs_extra_1.default.pathExists(dockerfilePath))) {
+        await fs_extra_1.default.writeFile(dockerfilePath, templates.generateAiServiceDockerfile());
+    }
+    // Update manifest
+    templates.writeAiManifest(targetDir, manifest);
+}
+/**
+ * Extend docker-compose.yml with ai-service block if not already present
+ */
+async function ensureDockerComposeAiService(targetDir) {
+    const composePath = path_1.default.join(targetDir, 'docker-compose.yml');
+    if (!(await fs_extra_1.default.pathExists(composePath)))
+        return;
+    const content = await fs_extra_1.default.readFile(composePath, 'utf-8');
+    if (content.includes('ai-service:'))
+        return; // Already has AI service block
+    // Append AI service block before the last line (networks/volumes)
+    const aiBlock = templates.generateDockerComposeAiService();
+    // Simple approach: append the service block to the services section
+    const updatedContent = content.replace(/^(services:.*)/m, `$1\n${aiBlock}`);
+    // If that didn't work (no 'services:' header found), append at end
+    if (updatedContent === content) {
+        await fs_extra_1.default.appendFile(composePath, '\n' + aiBlock);
+    }
+    else {
+        await fs_extra_1.default.writeFile(composePath, updatedContent);
+    }
+}
+/**
+ * Ensure .env has AI_SERVICE_URL
+ */
+async function ensureEnvAiServiceUrl(targetDir) {
+    const envPath = path_1.default.join(targetDir, '.env');
+    const envLine = 'AI_SERVICE_URL=http://localhost:8002';
+    if (await fs_extra_1.default.pathExists(envPath)) {
+        const content = await fs_extra_1.default.readFile(envPath, 'utf-8');
+        if (content.includes('AI_SERVICE_URL'))
+            return;
+        await fs_extra_1.default.appendFile(envPath, `\n# AI Service\n${envLine}\n`);
+    }
+    else {
+        await fs_extra_1.default.writeFile(envPath, `# AI Service\n${envLine}\n`);
+    }
+}
+/**
+ * Ensure .gitignore has AI service entries
+ */
+async function ensureGitignoreAiEntries(targetDir) {
+    const gitignorePath = path_1.default.join(targetDir, '.gitignore');
+    const entries = ['services/ai/.venv/', 'services/ai/data/*', '!services/ai/data/.gitkeep'];
+    if (await fs_extra_1.default.pathExists(gitignorePath)) {
+        let content = await fs_extra_1.default.readFile(gitignorePath, 'utf-8');
+        const missing = entries.filter((e) => !content.includes(e));
+        if (missing.length > 0) {
+            content += `\n# AI Service\n${missing.join('\n')}\n`;
+            await fs_extra_1.default.writeFile(gitignorePath, content);
+        }
+    }
+}
+// ---- Individual AI module installers ----
+async function addAiChat(targetDir) {
+    const spinner = (0, ora_1.default)('Adding AI Chat module...').start();
+    try {
+        const manifest = await ensureAiServiceCore(targetDir, spinner);
+        const aiDir = path_1.default.join(targetDir, AI_SERVICE_DIR);
+        if (manifest.modules.includes('chat')) {
+            spinner.info(chalk_1.default.yellow('AI Chat module is already installed.'));
+            return;
+        }
+        // Write chat-specific service files
+        spinner.text = 'Installing chat services...';
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'chat_service.py'), templates.generateChatService());
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'model_service.py'), templates.generateModelService());
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'moderation_service.py'), templates.generateModerationService());
+        // Write chat routes
+        await fs_extra_1.default.ensureDir(path_1.default.join(aiDir, 'routes'));
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'routes', 'chat_routes.py'), templates.generateChatRoutes());
+        // Update manifest
+        manifest.modules.push('chat');
+        // Regenerate dynamic files
+        await regenerateAiServiceFiles(targetDir, manifest, spinner);
+        // Docker + env
+        await ensureDockerComposeAiService(targetDir);
+        await ensureEnvAiServiceUrl(targetDir);
+        await ensureGitignoreAiEntries(targetDir);
+        spinner.succeed(chalk_1.default.green('AI Chat module installed'));
+        console.log(chalk_1.default.cyan('\n  Files added:'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/config.py'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/provider_client.py'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/services/chat_service.py'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/services/model_service.py'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/services/moderation_service.py'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/routes/chat_routes.py'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/main.py (generated)'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/models.py (generated)'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/requirements.txt (generated)'));
+        console.log(chalk_1.default.white('\n  To start the AI service:'));
+        console.log(chalk_1.default.gray('    cd services/ai'));
+        console.log(chalk_1.default.gray('    python -m venv .venv'));
+        console.log(chalk_1.default.gray('    .venv/Scripts/activate  (Windows) or  source .venv/bin/activate'));
+        console.log(chalk_1.default.gray('    pip install -r requirements.txt'));
+        console.log(chalk_1.default.gray('    uvicorn main:app --reload --port 8002'));
+        console.log(chalk_1.default.white('\n  Or use: chimerai dev (starts both Next.js + AI service)'));
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Failed to add AI Chat module'));
+        console.error(error.message);
+        throw error;
+    }
+}
+async function addRag(targetDir) {
+    const spinner = (0, ora_1.default)('Adding RAG module...').start();
+    try {
+        const manifest = await ensureAiServiceCore(targetDir, spinner);
+        const aiDir = path_1.default.join(targetDir, AI_SERVICE_DIR);
+        if (manifest.modules.includes('rag')) {
+            spinner.info(chalk_1.default.yellow('RAG module is already installed.'));
+            return;
+        }
+        // RAG requires chat — auto-install if missing
+        if (!manifest.modules.includes('chat')) {
+            spinner.info(chalk_1.default.cyan('ℹ️  RAG requires the Chat module. Installing both...'));
+            spinner.start('Installing Chat module first...');
+            await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'chat_service.py'), templates.generateChatService());
+            await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'model_service.py'), templates.generateModelService());
+            await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'moderation_service.py'), templates.generateModerationService());
+            await fs_extra_1.default.ensureDir(path_1.default.join(aiDir, 'routes'));
+            await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'routes', 'chat_routes.py'), templates.generateChatRoutes());
+            manifest.modules.push('chat');
+        }
+        // Write RAG-specific service files
+        spinner.text = 'Installing RAG services...';
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'rag_service.py'), templates.generateRagService());
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'vector_store.py'), templates.generateVectorStore());
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'embedding_service.py'), templates.generateEmbeddingService());
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'file_extractor.py'), templates.generateFileExtractor());
+        // RAG routes
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'routes', 'rag_routes.py'), templates.generateRagRoutes());
+        // Create data directory with .gitkeep
+        await fs_extra_1.default.ensureDir(path_1.default.join(aiDir, 'data'));
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'data', '.gitkeep'), '');
+        // Update manifest
+        manifest.modules.push('rag');
+        // Regenerate dynamic files
+        await regenerateAiServiceFiles(targetDir, manifest, spinner);
+        // Docker + env
+        await ensureDockerComposeAiService(targetDir);
+        await ensureEnvAiServiceUrl(targetDir);
+        await ensureGitignoreAiEntries(targetDir);
+        // ── Frontend proxy routes + RAG page ──────────────────────────────────
+        spinner.start('Installing RAG frontend routes...');
+        const srcDir = path_1.default.join(targetDir, 'src');
+        const appBase = (await fs_extra_1.default.pathExists(srcDir)) ? srcDir : targetDir;
+        // lib/rag.ts — AI Service client helper
+        await fs_extra_1.default.ensureDir(path_1.default.join(appBase, 'lib'));
+        await fs_extra_1.default.writeFile(path_1.default.join(appBase, 'lib', 'rag.ts'), templates.generateRagLib());
+        // API proxy routes
+        await fs_extra_1.default.ensureDir(path_1.default.join(appBase, 'app', 'api', 'rag', 'query'));
+        await fs_extra_1.default.ensureDir(path_1.default.join(appBase, 'app', 'api', 'rag', 'stats'));
+        await fs_extra_1.default.ensureDir(path_1.default.join(appBase, 'app', 'api', 'rag', 'clear'));
+        await fs_extra_1.default.ensureDir(path_1.default.join(appBase, 'app', 'api', 'rag', 'delete'));
+        await fs_extra_1.default.writeFile(path_1.default.join(appBase, 'app', 'api', 'rag', 'route.ts'), templates.generateRagUploadRoute());
+        await fs_extra_1.default.writeFile(path_1.default.join(appBase, 'app', 'api', 'rag', 'query', 'route.ts'), templates.generateRagQueryRoute());
+        await fs_extra_1.default.writeFile(path_1.default.join(appBase, 'app', 'api', 'rag', 'stats', 'route.ts'), templates.generateRagStatsRoute());
+        await fs_extra_1.default.writeFile(path_1.default.join(appBase, 'app', 'api', 'rag', 'clear', 'route.ts'), templates.generateRagClearRoute());
+        await fs_extra_1.default.writeFile(path_1.default.join(appBase, 'app', 'api', 'rag', 'delete', 'route.ts'), templates.generateRagDeleteRoute());
+        // RAG page
+        await fs_extra_1.default.ensureDir(path_1.default.join(appBase, 'app', 'rag'));
+        await fs_extra_1.default.writeFile(path_1.default.join(appBase, 'app', 'rag', 'page.tsx'), templates.generateRagPage());
+        spinner.succeed(chalk_1.default.green('RAG module installed'));
+        console.log(chalk_1.default.cyan('\n  Files added (AI Service):'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/services/rag_service.py'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/services/vector_store.py'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/services/embedding_service.py'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/services/file_extractor.py'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/routes/rag_routes.py'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/data/.gitkeep'));
+        console.log(chalk_1.default.cyan('\n  Files added (Frontend):'));
+        console.log(chalk_1.default.cyan('    ✓ lib/rag.ts'));
+        console.log(chalk_1.default.cyan('    ✓ app/api/rag/route.ts (upload)'));
+        console.log(chalk_1.default.cyan('    ✓ app/api/rag/query/route.ts'));
+        console.log(chalk_1.default.cyan('    ✓ app/api/rag/stats/route.ts'));
+        console.log(chalk_1.default.cyan('    ✓ app/api/rag/clear/route.ts'));
+        console.log(chalk_1.default.cyan('    ✓ app/api/rag/delete/route.ts'));
+        console.log(chalk_1.default.cyan('    ✓ app/rag/page.tsx'));
+        if (!manifest.modules.includes('chat')) {
+            console.log(chalk_1.default.cyan('    ✓ (Chat module auto-installed)'));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Failed to add RAG module'));
+        console.error(error.message);
+        throw error;
+    }
+}
+async function addGuardrails(targetDir) {
+    (0, license_js_1.assertComponentAccess)('guardrails');
+    const spinner = (0, ora_1.default)('Adding Guardrails module...').start();
+    try {
+        const manifest = await ensureAiServiceCore(targetDir, spinner);
+        const aiDir = path_1.default.join(targetDir, AI_SERVICE_DIR);
+        if (manifest.modules.includes('guardrails')) {
+            spinner.info(chalk_1.default.yellow('Guardrails module is already installed.'));
+            return;
+        }
+        // Write guardrails service
+        spinner.text = 'Installing guardrails service...';
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'guardrails_service.py'), templates.generateGuardrailsService());
+        // Guardrails routes
+        await fs_extra_1.default.ensureDir(path_1.default.join(aiDir, 'routes'));
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'routes', 'guardrails_routes.py'), templates.generateGuardrailsRoutes());
+        // Update manifest
+        manifest.modules.push('guardrails');
+        // Regenerate dynamic files
+        await regenerateAiServiceFiles(targetDir, manifest, spinner);
+        // Docker + env
+        await ensureDockerComposeAiService(targetDir);
+        await ensureEnvAiServiceUrl(targetDir);
+        await ensureGitignoreAiEntries(targetDir);
+        spinner.succeed(chalk_1.default.green('Guardrails module installed'));
+        console.log(chalk_1.default.cyan('\n  Files added:'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/services/guardrails_service.py'));
+        console.log(chalk_1.default.cyan('    ✓ services/ai/routes/guardrails_routes.py'));
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Failed to add Guardrails module'));
+        console.error(error.message);
+        throw error;
+    }
+}
+async function addAiTools(targetDir) {
+    (0, license_js_1.assertComponentAccess)('ai-tools');
+    const spinner = (0, ora_1.default)('Preparing AI Tools...').start();
+    try {
+        const manifest = await ensureAiServiceCore(targetDir, spinner);
+        const aiDir = path_1.default.join(targetDir, AI_SERVICE_DIR);
+        spinner.stop();
+        // Build choices for interactive menu
+        const toolChoices = Object.entries(templates.TOOL_INFO).map(([key, info]) => ({
+            name: `${info.displayName} — ${info.description}`,
+            value: key,
+            checked: manifest.tools.includes(key), // Pre-check already installed tools
+        }));
+        const { selectedTools } = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'selectedTools',
+                message: 'Select AI tools to install:',
+                choices: toolChoices,
+                pageSize: 12,
+            },
+        ]);
+        if (selectedTools.length === 0) {
+            console.log(chalk_1.default.yellow('\n  No tools selected. Skipping.\n'));
+            return;
+        }
+        spinner.start('Installing AI tools...');
+        // Create tools directory
+        await fs_extra_1.default.ensureDir(path_1.default.join(aiDir, 'services', 'tools'));
+        // Install each selected tool
+        const newTools = [];
+        for (const toolKey of selectedTools) {
+            if (manifest.tools.includes(toolKey))
+                continue; // Already installed
+            const generator = ai_service_tools_js_1.TOOL_GENERATORS[toolKey];
+            if (!generator)
+                continue;
+            spinner.text = `Installing ${templates.TOOL_INFO[toolKey]?.displayName || toolKey}...`;
+            await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'tools', `${toolKey}.py`), generator());
+            newTools.push(toolKey);
+        }
+        if (newTools.length === 0) {
+            spinner.info(chalk_1.default.yellow('All selected tools are already installed.'));
+            return;
+        }
+        // Update manifest
+        manifest.tools = [...new Set([...manifest.tools, ...selectedTools])];
+        if (!manifest.modules.includes('tools')) {
+            manifest.modules.push('tools');
+        }
+        // Generate tools __init__.py
+        const { generateToolsInit } = await import('../templates/ai-service-tools.js');
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'services', 'tools', '__init__.py'), generateToolsInit(manifest.tools));
+        // Generate tools routes
+        await fs_extra_1.default.ensureDir(path_1.default.join(aiDir, 'routes'));
+        await fs_extra_1.default.writeFile(path_1.default.join(aiDir, 'routes', 'tools_routes.py'), templates.generateToolsRoutes(manifest.tools));
+        // Regenerate dynamic files
+        await regenerateAiServiceFiles(targetDir, manifest, spinner);
+        // Docker + env
+        await ensureDockerComposeAiService(targetDir);
+        await ensureEnvAiServiceUrl(targetDir);
+        await ensureGitignoreAiEntries(targetDir);
+        spinner.succeed(chalk_1.default.green(`${newTools.length} AI tool(s) installed`));
+        console.log(chalk_1.default.cyan('\n  Tools installed:'));
+        for (const toolKey of newTools) {
+            const info = templates.TOOL_INFO[toolKey];
+            console.log(chalk_1.default.cyan(`    ✓ ${info?.displayName || toolKey}`));
+        }
+        // Show required env vars for specific tools
+        const needsGoogleCreds = newTools.includes('google_sheets_tools');
+        const needsAirtable = newTools.includes('airtable_tools');
+        const needsDeepl = newTools.includes('deepl_tools');
+        if (needsGoogleCreds || needsAirtable || needsDeepl) {
+            console.log(chalk_1.default.yellow('\n  Required environment variables:'));
+            if (needsGoogleCreds)
+                console.log(chalk_1.default.yellow('    • GOOGLE_SERVICE_ACCOUNT_JSON=path/to/credentials.json'));
+            if (needsAirtable)
+                console.log(chalk_1.default.yellow('    • AIRTABLE_API_KEY=your-api-key'));
+            if (needsDeepl)
+                console.log(chalk_1.default.yellow('    • DEEPL_AUTH_KEY=your-auth-key'));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Failed to add AI tools'));
+        console.error(error.message);
+        throw error;
+    }
+}
+async function addCommand(component, options) {
+    console.log(chalk_1.default.bold.cyan(`\n📦 Adding ${component} to your project\n`));
+    // 🔒 Edition gate — exits with upsell message if Pro component and no license
+    (0, license_js_1.assertComponentAccess)(component);
+    const targetDir = (0, utils_js_1.resolveTargetDir)(options.dir);
+    console.log(chalk_1.default.gray(`  Project: ${targetDir}\n`));
+    // Ensure the target is marked as a ChimerAI project
+    const markerPath = path_1.default.join(targetDir, '.chimerai');
+    if (!fs_extra_1.default.existsSync(markerPath) || !fs_extra_1.default.statSync(markerPath).isFile()) {
+        const projectName = path_1.default.basename(targetDir);
+        fs_extra_1.default.writeFileSync(markerPath, JSON.stringify({
+            name: projectName,
+            createdAt: new Date().toISOString(),
+            version: '0.2.0',
+            adoptedBy: 'chimerai add',
+        }, null, 2));
+        // Register in global registry
+        const { registerProject } = await import('../utils.js');
+        registerProject(projectName, targetDir);
+        console.log(chalk_1.default.green(`  ✓ Marked as ChimerAI project (.chimerai created)\n`));
+    }
+    // Check Next.js version — templates require Next.js 15+
+    const project = await (0, scanner_js_1.scanProject)(targetDir);
+    if (project.nextVersion) {
+        const match = project.nextVersion.match(/\d+/);
+        const major = match ? parseInt(match[0], 10) : null;
+        if (major && major < 15) {
+            console.log(chalk_1.default.yellow(`\n⚠️  Next.js ${project.nextVersion} detected. ChimerAI CLI requires Next.js 15 or later.`));
+            console.log(chalk_1.default.yellow('   Generated code uses async params (Promise<params>) which is not compatible with Next.js 14.'));
+            console.log(chalk_1.default.yellow('   Please upgrade: npx @next/codemod@canary upgrade latest\n'));
+            const { proceed } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'proceed',
+                    message: 'Continue anyway? (generated code may not compile)',
+                    default: false,
+                },
+            ]);
+            if (!proceed) {
+                console.log(chalk_1.default.gray('Aborted.'));
+                return;
+            }
+        }
+    }
+    // AI Service modules — special handling (not simple file copy)
+    const AI_COMPONENTS = {
+        'ai-chat': addAiChat,
+        rag: addRag, // Note: existing 'rag' config handles frontend proxy routes
+        guardrails: addGuardrails,
+        'ai-tools': addAiTools,
+    };
+    // Check if it's an AI service module
+    if (AI_COMPONENTS[component]) {
+        await AI_COMPONENTS[component](targetDir);
+        console.log(chalk_1.default.bold.green(`\n✨ ${component} added successfully!\n`));
+        return;
+    }
+    // Check if component exists in standard configs
+    const config = COMPONENT_CONFIGS[component];
+    if (!config) {
+        console.log(chalk_1.default.red(`❌ Unknown component: ${component}`));
+        console.log(chalk_1.default.yellow('\nAvailable components:'));
+        Object.values(COMPONENT_CONFIGS).forEach((cfg) => {
+            if (cfg.disabled) {
+                console.log(chalk_1.default.gray(`  - ${cfg.name.padEnd(20)} ${cfg.description} (coming soon)`));
+            }
+            else {
+                console.log(chalk_1.default.white(`  - ${cfg.name.padEnd(20)} ${cfg.description}`));
+            }
+        });
+        // Also show AI modules
+        console.log(chalk_1.default.yellow('\nAI Service modules:'));
+        console.log(chalk_1.default.white('  - ai-chat              AI chat with streaming (installs core + chat services)'));
+        console.log(chalk_1.default.white('  - rag                  RAG pipeline with vector search (requires ai-chat)'));
+        console.log(chalk_1.default.white('  - guardrails           Content moderation & safety guardrails'));
+        console.log(chalk_1.default.white('  - ai-tools             AI tools (web search, NLP, vision, etc.)'));
+        (0, utils_js_1.handleCliError)(`Unknown component: ${component}`);
+    }
+    // Check if component is disabled (not yet implemented)
+    if (config.disabled) {
+        console.log(chalk_1.default.yellow(`⚠️  ${config.displayName} is not yet available.`));
+        console.log(chalk_1.default.gray(`   ${config.disabled}`));
+        console.log(chalk_1.default.cyan('\n   Tip: Use "chimerai add admin-dashboard" for the full admin panel with RBAC.'));
+        return;
+    }
+    // Add component using generic function
+    await addComponent(config, targetDir);
+    console.log(chalk_1.default.bold.green(`\n✨ ${component} added successfully!\n`));
+}