@chimerai/cli 0.2.73

package/dist/license.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * ChimerAI License & Edition Management
+ *
+ * Drei Tiers: free < enterprise < enterprise-pro
+ * License keys werden via Lemon Squeezy ausgegeben und lokal gespeichert.
+ *
+ * Key-Präfixe (Konvention):
+ *   ls_live_ent_...     → Enterprise
+ *   ls_live_entpro_...  → Enterprise Pro
+ *   chi_ent_...         → Enterprise (interner Test-Key)
+ *   chi_entpro_...      → Enterprise Pro (interner Test-Key)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTERPRISE_PRO_COMPONENTS = exports.ENTERPRISE_COMPONENTS = exports.FREE_COMPONENTS = void 0;
+exports.getRequiredEdition = getRequiredEdition;
+exports.readLicense = readLicense;
+exports.writeLicense = writeLicense;
+exports.clearLicense = clearLicense;
+exports.getEdition = getEdition;
+exports.verifyLicenseToken = verifyLicenseToken;
+exports.activateLicenseOnline = activateLicenseOnline;
+exports.isEnterpriseOrHigher = isEnterpriseOrHigher;
+exports.isEnterpriseProEdition = isEnterpriseProEdition;
+exports.assertComponentAccess = assertComponentAccess;
+exports.printLicenseStatus = printLicenseStatus;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const jose_1 = require("jose");
+// ─── JWT Public Key (Ed25519) ─────────────────────────────────────────────────
+// Private key lives only in Cloudflare Worker secret — never in binary.
+// Public key is safe to embed: it can verify, but NOT sign.
+const PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAJVKs6IZX5OqyVSxaKpLK6leRpKHVAZF5nUUB6B9BqdI=
+-----END PUBLIC KEY-----`;
+const ACTIVATE_ENDPOINT = 'https://chimerai-activate-worker.chimerai.workers.dev/activate';
+const LICENSE_DIR = path_1.default.join(os_1.default.homedir(), '.chimerai');
+const LICENSE_PATH = path_1.default.join(LICENSE_DIR, 'license.json');
+// ─── Tier-Hierarchie ─────────────────────────────────────────────────────────
+// enterprise-pro ⊇ enterprise ⊇ free
+// Ein höherer Tier hat immer Zugriff auf alle Features darunter.
+const TIER_LEVEL = {
+    free: 0,
+    enterprise: 1,
+    'enterprise-pro': 2,
+};
+function meetsRequirement(actual, required) {
+    return TIER_LEVEL[actual] >= TIER_LEVEL[required];
+}
+// ─── Komponenten-Definitionen ─────────────────────────────────────────────────
+/** Free-Komponenten — immer verfügbar, kein Gate */
+exports.FREE_COMPONENTS = new Set([
+    'chat-ui',
+    'chat-widget',
+    'ai-chat',
+    'rag',
+    'model-providers',
+    'prompt-management',
+]);
+/** Enterprise-Komponenten (Enterprise + Enterprise Pro) */
+exports.ENTERPRISE_COMPONENTS = {
+    auth: 'NextAuth Authentication + Session Management',
+    billing: 'Stripe Billing & Subscriptions',
+    'admin-dashboard': 'Admin Dashboard Overview',
+    'users-table': 'User Management CRUD',
+    'roles-table': 'Role Management CRUD',
+    gdpr: 'GDPR Compliance (Export, Deletion, Consent)',
+    mfa: 'Multi-Factor Authentication (TOTP)',
+    'audit-log': 'Audit Logging for Compliance',
+    analytics: 'API Usage Analytics',
+    sentry: 'Error Tracking & Monitoring',
+};
+/** Enterprise Pro-Komponenten (nur Enterprise Pro) */
+exports.ENTERPRISE_PRO_COMPONENTS = {
+    webhooks: 'Webhook Dispatch with HMAC Signing',
+    theming: 'Dynamic Theme Engine',
+    guardrails: 'AI Content Safety & PII Detection',
+    'ai-tools': 'AI Tools (Web Search, NLP, Vision)',
+};
+// ─── Hilfsfunktionen ─────────────────────────────────────────────────────────
+function getRequiredEdition(component) {
+    if (exports.FREE_COMPONENTS.has(component))
+        return 'free';
+    if (exports.ENTERPRISE_COMPONENTS[component])
+        return 'enterprise';
+    if (exports.ENTERPRISE_PRO_COMPONENTS[component])
+        return 'enterprise-pro';
+    return null; // Unbekannte Komponente — wird anderswo behandelt
+}
+// ─── License File I/O ─────────────────────────────────────────────────────────
+function readLicense() {
+    try {
+        if (!fs_extra_1.default.existsSync(LICENSE_PATH))
+            return null;
+        const raw = fs_extra_1.default.readFileSync(LICENSE_PATH, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function writeLicense(license) {
+    fs_extra_1.default.ensureDirSync(LICENSE_DIR);
+    fs_extra_1.default.writeFileSync(LICENSE_PATH, JSON.stringify(license, null, 2));
+}
+function clearLicense() {
+    if (fs_extra_1.default.existsSync(LICENSE_PATH)) {
+        fs_extra_1.default.removeSync(LICENSE_PATH);
+    }
+}
+// ─── Edition Detection ────────────────────────────────────────────────────────
+function getEdition() {
+    const license = readLicense();
+    if (!license)
+        return 'free';
+    if (license.edition !== 'enterprise' && license.edition !== 'enterprise-pro')
+        return 'free';
+    // If we have a JWT token, we trust only the locally cached edition
+    // (full async JWT verification happens in verifyLicenseToken)
+    // For sync gate checks we trust the stored edition — JWT is verified on activate
+    if (license.validUntil) {
+        const expiry = new Date(license.validUntil);
+        if (expiry < new Date())
+            return 'free';
+    }
+    return license.edition;
+}
+/** Verifies the JWT signature of a stored license token (async). */
+async function verifyLicenseToken(token) {
+    try {
+        const publicKey = await (0, jose_1.importSPKI)(PUBLIC_KEY_PEM, 'EdDSA');
+        const { payload } = await (0, jose_1.jwtVerify)(token, publicKey, { issuer: 'chimerai.dev' });
+        const edition = payload['edition'];
+        const email = payload['email'] ?? '';
+        if (edition !== 'enterprise' && edition !== 'enterprise-pro')
+            return null;
+        return { edition, email };
+    }
+    catch {
+        return null;
+    }
+}
+/** Activates a license key by calling the chimerai.dev API. Returns error string or null on success. */
+async function activateLicenseOnline(key) {
+    try {
+        const res = await fetch(ACTIVATE_ENDPOINT, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ key, instance: os_1.default.hostname() }),
+        });
+        const data = (await res.json());
+        if (!res.ok || data['error']) {
+            return { error: String(data['error'] ?? 'Activation failed') };
+        }
+        const token = String(data['token'] ?? '');
+        const edition = String(data['edition'] ?? '');
+        const email = String(data['email'] ?? '');
+        // Verify JWT signature before trusting it
+        const publicKey = await (0, jose_1.importSPKI)(PUBLIC_KEY_PEM, 'EdDSA');
+        await (0, jose_1.jwtVerify)(token, publicKey, { issuer: 'chimerai.dev' });
+        return { edition, email, token };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('fetch') || msg.includes('ENOTFOUND') || msg.includes('network')) {
+            return { error: 'Network error — check your internet connection.' };
+        }
+        return { error: `Activation failed: ${msg}` };
+    }
+}
+function isEnterpriseOrHigher() {
+    return meetsRequirement(getEdition(), 'enterprise');
+}
+function isEnterpriseProEdition() {
+    return getEdition() === 'enterprise-pro';
+}
+// ─── Feature Gate ─────────────────────────────────────────────────────────────
+/**
+ * Prüft ob eine Komponente in der aktuellen Edition zugänglich ist.
+ * Gibt kontextuelle Upsell-Meldung aus und beendet den Prozess wenn nicht.
+ */
+function assertComponentAccess(component) {
+    const required = getRequiredEdition(component);
+    // Unbekannte Komponente — wird anderswo behandelt
+    if (required === null)
+        return;
+    // Free — immer erlaubt
+    if (required === 'free')
+        return;
+    const actual = getEdition();
+    // Zugriff erlaubt
+    if (meetsRequirement(actual, required))
+        return;
+    // --- Blockiert: kontextuelle Upsell-Meldung ---
+    if (actual === 'enterprise' && required === 'enterprise-pro') {
+        // Enterprise-Kunde will Enterprise-Pro-Feature
+        console.log(chalk_1.default.red(`\n  🔒 "${component}" is an Enterprise Pro feature.\n`));
+        console.log(chalk_1.default.bold('  Exclusive to ChimerAI Enterprise Pro:\n'));
+        for (const [name, desc] of Object.entries(exports.ENTERPRISE_PRO_COMPONENTS)) {
+            console.log(`    ${chalk_1.default.yellow('•')} ${chalk_1.default.white(name.padEnd(22))} ${chalk_1.default.gray(desc)}`);
+        }
+        console.log(chalk_1.default.bold('\n  You have Enterprise — upgrade to unlock these features:'));
+        console.log(chalk_1.default.bold('\n  → Upgrade: ') + chalk_1.default.cyan('https://chimerai.dev/enterprise-pro'));
+        console.log(chalk_1.default.bold('  → Contact: ') + chalk_1.default.cyan('sales@chimerai.dev\n'));
+        throw new Error(`"${component}" requires an Enterprise Pro license.`);
+    }
+    else {
+        // Free-Kunde will Enterprise- oder Enterprise-Pro-Feature
+        const isEntPro = required === 'enterprise-pro';
+        console.log(chalk_1.default.red(`\n  🔒 "${component}" is an ${isEntPro ? 'Enterprise Pro' : 'Enterprise'} feature.\n`));
+        console.log(chalk_1.default.bold('  🏢 ChimerAI Enterprise:\n'));
+        for (const [name, desc] of Object.entries(exports.ENTERPRISE_COMPONENTS)) {
+            console.log(`    ${chalk_1.default.green('•')} ${chalk_1.default.white(name.padEnd(22))} ${chalk_1.default.gray(desc)}`);
+        }
+        console.log(chalk_1.default.bold('\n  🚀 ChimerAI Enterprise Pro:\n'));
+        for (const [name, desc] of Object.entries(exports.ENTERPRISE_PRO_COMPONENTS)) {
+            console.log(`    ${chalk_1.default.yellow('•')} ${chalk_1.default.white(name.padEnd(22))} ${chalk_1.default.gray(desc)}`);
+        }
+        console.log(chalk_1.default.bold('\n  → Enterprise:     ') + chalk_1.default.cyan('https://chimerai.dev/enterprise'));
+        console.log(chalk_1.default.bold('  → Enterprise Pro: ') + chalk_1.default.cyan('https://chimerai.dev/enterprise-pro'));
+        console.log(chalk_1.default.bold('  → Activate:       ') + chalk_1.default.white('chimerai activate <LICENSE-KEY>'));
+        console.log(chalk_1.default.bold('  → Contact:        ') + chalk_1.default.cyan('sales@chimerai.dev\n'));
+        throw new Error(isEntPro
+            ? `"${component}" requires an Enterprise Pro license.`
+            : `"${component}" requires an Enterprise license.`);
+    }
+}
+// ─── License Info (für chimerai license) ─────────────────────────────────────
+const EDITION_LABELS = {
+    free: 'Free',
+    enterprise: 'Enterprise',
+    'enterprise-pro': 'Enterprise Pro',
+};
+function printLicenseStatus() {
+    const license = readLicense();
+    const edition = getEdition();
+    if (!license || edition === 'free') {
+        console.log(chalk_1.default.bold.yellow('\n  📋 Edition: ') + chalk_1.default.white('Free'));
+        console.log(chalk_1.default.gray('  No license key activated.'));
+        console.log(chalk_1.default.gray('  Enterprise:     ') + chalk_1.default.cyan('https://chimerai.dev/enterprise'));
+        console.log(chalk_1.default.gray('  Activate with:  ') + chalk_1.default.white('chimerai activate <KEY>\n'));
+        return;
+    }
+    const expiry = license.validUntil
+        ? new Date(license.validUntil).toLocaleDateString('de-AT')
+        : 'unbegrenzt';
+    const color = edition === 'enterprise-pro' ? chalk_1.default.bold.magenta : chalk_1.default.bold.green;
+    console.log(color('\n  📋 Edition: ') + chalk_1.default.white(`${EDITION_LABELS[edition]} ✅`));
+    if (license.email)
+        console.log(chalk_1.default.gray(`  Licensed to: ${license.email}`));
+    console.log(chalk_1.default.gray(`  Valid until: ${expiry}`));
+    console.log(chalk_1.default.gray(`  Activated:   ${new Date(license.activatedAt).toLocaleDateString('en-US')}\n`));
+}

package/dist/scanner.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Project Scanner - PHASE 3.1
+ * Analyzes existing Next.js projects to detect configuration, frameworks, and installed components
+ * Used by `add` and `dev` commands to make intelligent decisions
+ */
+export interface ProjectInfo {
+    hasPackageJson: boolean;
+    packageManager: 'pnpm' | 'npm' | 'yarn' | 'bun' | 'unknown';
+    nextVersion: string | null;
+    hasAppRouter: boolean;
+    hasPagesRouter: boolean;
+    hasPrisma: boolean;
+    prismaProvider: 'postgresql' | 'mysql' | 'sqlite' | null;
+    prismaModels: string[];
+    hasNextAuth: boolean;
+    hasClerk: boolean;
+    hasSupabaseAuth: boolean;
+    hasShadcn: boolean;
+    hasTailwind: boolean;
+    hasChakra: boolean;
+    installedComponents: string[];
+    hasStripe: boolean;
+    hasLemonSqueezy: boolean;
+}
+/**
+ * Scan project for framework, dependencies, and installed components
+ * @param targetDir - Project root directory
+ * @returns ProjectInfo with detailed project configuration
+ */
+export declare function scanProject(targetDir: string): Promise<ProjectInfo>;
+//# sourceMappingURL=scanner.d.ts.map

package/dist/scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../src/scanner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,MAAM,WAAW,WAAW;IAE1B,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;IAG5D,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,OAAO,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;IAGxB,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,YAAY,GAAG,OAAO,GAAG,QAAQ,GAAG,IAAI,CAAC;IACzD,YAAY,EAAE,MAAM,EAAE,CAAC;IAGvB,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,OAAO,CAAC;IAGzB,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IAGnB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAG9B,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CA0GzE"}

package/dist/scanner.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Project Scanner - PHASE 3.1
+ * Analyzes existing Next.js projects to detect configuration, frameworks, and installed components
+ * Used by `add` and `dev` commands to make intelligent decisions
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanProject = scanProject;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+/**
+ * Scan project for framework, dependencies, and installed components
+ * @param targetDir - Project root directory
+ * @returns ProjectInfo with detailed project configuration
+ */
+async function scanProject(targetDir) {
+    const info = {
+        hasPackageJson: false,
+        packageManager: 'unknown',
+        nextVersion: null,
+        hasAppRouter: false,
+        hasPagesRouter: false,
+        hasPrisma: false,
+        prismaProvider: null,
+        prismaModels: [],
+        hasNextAuth: false,
+        hasClerk: false,
+        hasSupabaseAuth: false,
+        hasShadcn: false,
+        hasTailwind: false,
+        hasChakra: false,
+        installedComponents: [],
+        hasStripe: false,
+        hasLemonSqueezy: false,
+    };
+    // 1. Check package.json
+    const pkgPath = path_1.default.join(targetDir, 'package.json');
+    if (await fs_extra_1.default.pathExists(pkgPath)) {
+        info.hasPackageJson = true;
+        const pkg = await fs_extra_1.default.readJson(pkgPath);
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        // Package Manager detection
+        if (await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'pnpm-lock.yaml'))) {
+            info.packageManager = 'pnpm';
+        }
+        else if (await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'yarn.lock'))) {
+            info.packageManager = 'yarn';
+        }
+        else if (await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'bun.lockb'))) {
+            info.packageManager = 'bun';
+        }
+        else if (await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'package-lock.json'))) {
+            info.packageManager = 'npm';
+        }
+        // Framework
+        info.nextVersion = allDeps['next'] || null;
+        // Auth systems
+        info.hasNextAuth = !!allDeps['next-auth'];
+        info.hasClerk = !!allDeps['@clerk/nextjs'];
+        info.hasSupabaseAuth = !!allDeps['@supabase/auth-helpers-nextjs'];
+        // UI frameworks
+        info.hasTailwind = !!allDeps['tailwindcss'];
+        info.hasShadcn =
+            !!allDeps['@radix-ui/react-dialog'] || !!allDeps['class-variance-authority'];
+        info.hasChakra = !!allDeps['@chakra-ui/react'];
+        // Billing
+        info.hasStripe = !!allDeps['stripe'];
+        info.hasLemonSqueezy = !!allDeps['@lemonsqueezy/lemonsqueezy.js'];
+    }
+    // 2. Check directory structure for routing
+    info.hasAppRouter = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'app'));
+    info.hasPagesRouter = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, 'pages'));
+    // 3. Check Prisma configuration
+    const schemaPath = path_1.default.join(targetDir, 'prisma', 'schema.prisma');
+    if (await fs_extra_1.default.pathExists(schemaPath)) {
+        info.hasPrisma = true;
+        const schema = await fs_extra_1.default.readFile(schemaPath, 'utf-8');
+        // Detect database provider
+        const providerMatch = schema.match(/provider\s*=\s*"(postgresql|mysql|sqlite)"/);
+        if (providerMatch) {
+            info.prismaProvider = providerMatch[1];
+        }
+        // Extract all model names
+        const modelMatches = schema.matchAll(/^model\s+(\w+)\s*\{/gm);
+        for (const match of modelMatches) {
+            info.prismaModels.push(match[1]);
+        }
+    }
+    // 4. Check installed ChimerAI components
+    // Map component names to key files that indicate their presence
+    const componentChecks = {
+        'auth': ['lib/auth.ts', 'app/api/auth/[...nextauth]/route.ts'],
+        'billing': ['lib/stripe.ts', 'app/billing/page.tsx'],
+        'chat-ui': ['app/chat/page.tsx', 'components/StreamingChat.tsx'],
+        'rbac': ['app/admin/users/page.tsx', 'lib/permissions.ts'],
+        'mfa': ['app/api/auth/mfa/setup/route.ts'],
+        'gdpr': ['app/api/gdpr/consent/route.ts'],
+        'webhooks': ['app/api/webhooks/route.ts'],
+        'audit-log': ['lib/audit-log.ts'],
+        'analytics': ['lib/analytics.ts'],
+        'admin': ['app/admin/page.tsx'],
+    };
+    for (const [name, files] of Object.entries(componentChecks)) {
+        const hasAny = await Promise.all(files.map((f) => fs_extra_1.default.pathExists(path_1.default.join(targetDir, f))));
+        if (hasAny.some(Boolean)) {
+            info.installedComponents.push(name);
+        }
+    }
+    return info;
+}

package/dist/schema-manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Schema Manager - PHASE 3.2
+ * Manages Prisma schema extensions without overwriting existing configurations
+ * Prevents duplicate models and intelligently merges schema changes
+ */
+/**
+ * Extend Prisma schema with new models/enums without overwriting existing ones
+ * @param schemaPath - Path to prisma/schema.prisma
+ * @param newModels - Prisma model definitions to add
+ * @param newEnums - Optional Prisma enum definitions to add
+ */
+export declare function extendPrismaSchema(schemaPath: string, newModels: string, newEnums?: string): Promise<void>;
+/**
+ * Get all model names from a Prisma schema
+ * @param schemaPath - Path to prisma/schema.prisma
+ * @returns Array of model names
+ */
+export declare function getPrismaModels(schemaPath: string): Promise<string[]>;
+/**
+ * Check if a specific model exists in schema
+ * @param schemaPath - Path to prisma/schema.prisma
+ * @param modelName - Model name to check
+ * @returns true if model exists
+ */
+export declare function modelExists(schemaPath: string, modelName: string): Promise<boolean>;
+//# sourceMappingURL=schema-manager.d.ts.map

package/dist/schema-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-manager.d.ts","sourceRoot":"","sources":["../src/schema-manager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CA+Ff;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAQ3E;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGzF"}

package/dist/schema-manager.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * Schema Manager - PHASE 3.2
+ * Manages Prisma schema extensions without overwriting existing configurations
+ * Prevents duplicate models and intelligently merges schema changes
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendPrismaSchema = extendPrismaSchema;
+exports.getPrismaModels = getPrismaModels;
+exports.modelExists = modelExists;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Extend Prisma schema with new models/enums without overwriting existing ones
+ * @param schemaPath - Path to prisma/schema.prisma
+ * @param newModels - Prisma model definitions to add
+ * @param newEnums - Optional Prisma enum definitions to add
+ */
+async function extendPrismaSchema(schemaPath, newModels, newEnums) {
+    if (!(await fs_extra_1.default.pathExists(schemaPath))) {
+        throw new Error(`Prisma schema not found at ${schemaPath}`);
+    }
+    let schema = await fs_extra_1.default.readFile(schemaPath, 'utf-8');
+    // 1. Extract model names from both existing and new schemas
+    const existingModels = [...schema.matchAll(/^model\s+(\w+)\s*\{/gm)].map((m) => m[1]);
+    const newModelNames = [...newModels.matchAll(/^model\s+(\w+)\s*\{/gm)].map((m) => m[1]);
+    // 2. Check for duplicates
+    const duplicates = newModelNames.filter((m) => existingModels.includes(m));
+    let modelsToAdd = newModels;
+    if (duplicates.length > 0) {
+        console.log(chalk_1.default.yellow(`⚠️  Models already exist: ${duplicates.join(', ')} - skipping duplicates`));
+        // Remove duplicate models from the new schema
+        // Use brace-counting instead of regex to handle nested braces in @default("{}")
+        for (const dup of duplicates) {
+            const modelStart = modelsToAdd.search(new RegExp(`model\\s+${dup}\\s*\\{`));
+            if (modelStart === -1)
+                continue;
+            const braceStart = modelsToAdd.indexOf('{', modelStart);
+            let depth = 0;
+            let braceEnd = braceStart;
+            for (let i = braceStart; i < modelsToAdd.length; i++) {
+                if (modelsToAdd[i] === '{')
+                    depth++;
+                if (modelsToAdd[i] === '}')
+                    depth--;
+                if (depth === 0) {
+                    braceEnd = i;
+                    break;
+                }
+            }
+            modelsToAdd = (modelsToAdd.slice(0, modelStart) + modelsToAdd.slice(braceEnd + 1)).trim();
+        }
+    }
+    // 3. Extract existing enums
+    const existingEnums = [...schema.matchAll(/^enum\s+(\w+)\s*\{/gm)].map((m) => m[1]);
+    const newEnumNames = newEnums
+        ? [...newEnums.matchAll(/^enum\s+(\w+)\s*\{/gm)].map((m) => m[1])
+        : [];
+    const duplicateEnums = newEnumNames.filter((e) => existingEnums.includes(e));
+    let enumsToAdd = newEnums || '';
+    if (duplicateEnums.length > 0) {
+        console.log(chalk_1.default.yellow(`⚠️  Enums already exist: ${duplicateEnums.join(', ')} - skipping duplicates`));
+        // Remove duplicate enums using brace-counting
+        for (const dup of duplicateEnums) {
+            const enumStart = enumsToAdd.search(new RegExp(`enum\\s+${dup}\\s*\\{`));
+            if (enumStart === -1)
+                continue;
+            const braceStart = enumsToAdd.indexOf('{', enumStart);
+            let depth = 0;
+            let braceEnd = braceStart;
+            for (let i = braceStart; i < enumsToAdd.length; i++) {
+                if (enumsToAdd[i] === '{')
+                    depth++;
+                if (enumsToAdd[i] === '}')
+                    depth--;
+                if (depth === 0) {
+                    braceEnd = i;
+                    break;
+                }
+            }
+            enumsToAdd = (enumsToAdd.slice(0, enumStart) + enumsToAdd.slice(braceEnd + 1)).trim();
+        }
+    }
+    // 4. Add enums at beginning (before models)
+    if (enumsToAdd.trim()) {
+        // Find where models start
+        const firstModelIndex = schema.search(/^model\s+/m);
+        if (firstModelIndex !== -1) {
+            schema =
+                schema.slice(0, firstModelIndex) +
+                    '\n' +
+                    enumsToAdd +
+                    '\n\n' +
+                    schema.slice(firstModelIndex);
+        }
+        else {
+            schema += '\n\n' + enumsToAdd;
+        }
+    }
+    // 5. Add models at end
+    if (modelsToAdd.trim()) {
+        schema += '\n\n// Added by chimerai\n' + modelsToAdd;
+    }
+    // 6. Write updated schema
+    await fs_extra_1.default.writeFile(schemaPath, schema.trim() + '\n');
+}
+/**
+ * Get all model names from a Prisma schema
+ * @param schemaPath - Path to prisma/schema.prisma
+ * @returns Array of model names
+ */
+async function getPrismaModels(schemaPath) {
+    if (!(await fs_extra_1.default.pathExists(schemaPath))) {
+        return [];
+    }
+    const schema = await fs_extra_1.default.readFile(schemaPath, 'utf-8');
+    const models = [...schema.matchAll(/^model\s+(\w+)\s*\{/gm)].map((m) => m[1]);
+    return models;
+}
+/**
+ * Check if a specific model exists in schema
+ * @param schemaPath - Path to prisma/schema.prisma
+ * @param modelName - Model name to check
+ * @returns true if model exists
+ */
+async function modelExists(schemaPath, modelName) {
+    const models = await getPrismaModels(schemaPath);
+    return models.includes(modelName);
+}

package/dist/templates/admin.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Admin panel component templates
+ * Generates admin dashboard, users management page, roles management page, and admin layout guard
+ */
+/**
+ * Generates the admin layout with session check and admin role guard.
+ * Redirects unauthenticated users to sign-in, unauthorized users to dashboard.
+ * @returns TypeScript/JSX content for app/admin/layout.tsx
+ */
+export declare function generateAdminLayout(): string;
+/**
+ * Generates the main admin dashboard
+ * Shows cards linking to RBAC, AI configuration, and system management sections
+ * @returns TypeScript/JSX content for app/admin/page.tsx
+ */
+export declare function generateAdminDashboardPage(): string;
+/**
+ * Generates the admin users management page
+ * Displays user list with search, create/edit/delete functionality
+ * @returns TypeScript/JSX content for app/admin/users/page.tsx
+ */
+export declare function generateAdminUsersPage(): string;
+/**
+ * Generates the admin roles management page
+ * Allows CRUD operations on roles and permission assignment
+ * @returns TypeScript/JSX content for app/admin/roles/page.tsx
+ */
+export declare function generateAdminRolesPage(): string;
+/**
+ * Generates the admin settings page
+ * Functional page for system configuration with save/reset
+ * @returns TypeScript/JSX content for app/admin/settings/page.tsx
+ */
+export declare function generateAdminSettingsPage(): string;
+/**
+ * Generates the admin activity logs page
+ * Full audit log table with filters for action, user, and date range
+ * @returns TypeScript/JSX content for app/admin/logs/page.tsx
+ */
+export declare function generateAdminLogsPage(): string;
+/**
+ * Generates the audit log helper utility.
+ * Provides logAuditAction() for recording actions across the app.
+ * @returns TypeScript content for lib/audit.ts
+ */
+export declare function generatePermissionsLib(): string;
+export declare function generateRequirePermissionLib(): string;
+export declare function generateAuditLogHelper(): string;
+//# sourceMappingURL=admin.d.ts.map

package/dist/templates/admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../../src/templates/admin.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CA6G5C;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAmEnD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAuU/C;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CA+Q/C;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CA4LlD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CA6K9C;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAgE/C;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CA+DrD;AAED,wBAAgB,sBAAsB,IAAI,MAAM,CAqC/C"}