@c15t/cli 1.2.0-beta.17 → 1.2.0-canary.0

package/dist/index.mjs

@@ -1,1058 +1,2067 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import fs$1, { existsSync } from 'node:fs';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { logger } from '@c15t/backend';
-import { getConsentTables, getMigrations, getAdapter } from '@c15t/backend/db';
-import chalk from 'chalk';
-import prompts from 'prompts';
-import yoctoSpinner from 'yocto-spinner';
-import { z } from 'zod';
-import { produceSchema } from '@mrleebo/prisma-ast';
-import babelPresetReact from '@babel/preset-react';
-import babelPresetTypescript from '@babel/preset-typescript';
-import { C15TError } from '@c15t/backend/error';
-import { loadConfig } from 'c12';
-import 'dotenv/config';
-import Crypto from 'node:crypto';
-import fs$2 from 'fs-extra';
-
-function convertToSnakeCase(str) {
-  if (str === void 0 || str === null) {
-    return "";
-  }
-  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+import * as __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__ from "@clack/prompts";
+import "dotenv/config";
+import * as __WEBPACK_EXTERNAL_MODULE_open__ from "open";
+import * as __WEBPACK_EXTERNAL_MODULE_picocolors__ from "picocolors";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__ from "node:fs/promises";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_c12__ from "c12";
+import * as __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__ from "@doubletie/logger";
+import * as __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__ from "node:crypto";
+import * as __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__ from "node:os";
+import * as __WEBPACK_EXTERNAL_MODULE_posthog_node_1b07bdf4__ from "posthog-node";
+import * as __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__ from "node:child_process";
+import * as __WEBPACK_EXTERNAL_MODULE_node_events_0a6aefe7__ from "node:events";
+import * as __WEBPACK_EXTERNAL_MODULE_package_manager_detector_detect_94d6a9ae__ from "package-manager-detector/detect";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__ from "@c15t/backend/pkgs/db-adapters";
+import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_migrations_80b6e3bd__ from "@c15t/backend/pkgs/migrations";
+import * as __WEBPACK_EXTERNAL_MODULE_figlet__ from "figlet";
+import * as __WEBPACK_EXTERNAL_MODULE_fs_extra_ce68a66b__ from "fs-extra";
+function isC15TOptions(obj) {
+    return 'object' == typeof obj && null !== obj && 'appName' in obj;
 }
-const generateDrizzleSchema = async ({
-  options,
-  file,
-  adapter
-}) => {
-  const tables = getConsentTables(options);
-  const filePath = file || "./auth-schema.ts";
-  const databaseType = adapter.options?.provider;
-  const usePlural = adapter.options?.usePlural;
-  const timestampAndBoolean = databaseType !== "sqlite" ? "timestamp, boolean" : "";
-  const int = databaseType === "mysql" ? "int" : "integer";
-  const hasBigint = Object.values(tables).some(
-    (table) => Object.values(table.fields).some(
-      (field) => "bigint" in field && field.bigint
-    )
-  );
-  const bigint = databaseType !== "sqlite" ? "bigint" : "";
-  const text = databaseType === "mysql" ? "varchar, text" : "text";
-  const jsonType = ["mysql", "pg"].includes(databaseType || "") ? ", json" : "";
-  let code = `import { ${databaseType}Table, ${text}, ${int}${hasBigint ? `, ${bigint}` : ""}, ${timestampAndBoolean}${jsonType} } from "drizzle-orm/${databaseType}-core";`;
-  const fileExist = existsSync(filePath);
-  let isFirstTable = true;
-  for (const table in tables) {
-    if (Object.prototype.hasOwnProperty.call(tables, table)) {
-      let getMySQLStringType = function(field, name) {
-        if (field.unique) {
-          return `varchar('${name}', { length: 255 })`;
-        }
-        if (field.references) {
-          return `varchar('${name}', { length: 36 })`;
+function isClientOptions(obj) {
+    return 'object' == typeof obj && null !== obj && ('mode' in obj || 'backendURL' in obj);
+}
+function tryGetFunctionResult(fn) {
+    if ('function' == typeof fn) try {
+        return fn();
+    } catch (error) {
+        console.warn('Error executing config function:', error);
+    }
+    return null;
+}
+function extractOptionsFromConfig(config) {
+    if (config.c15tConfig && isClientOptions(config.c15tConfig)) return config.c15tConfig;
+    if (config.c15tOptions && isClientOptions(config.c15tOptions)) return config.c15tOptions;
+    if (isClientOptions(config)) return config;
+    if (isC15TOptions(config.c15t)) return config.c15t;
+    if ('function' == typeof config.c15t) {
+        const result = tryGetFunctionResult(config.c15t);
+        if (isC15TOptions(result)) return result;
+    }
+    if (isC15TOptions(config.default)) return config.default;
+    if ('function' == typeof config.default) {
+        const result = tryGetFunctionResult(config.default);
+        if (isC15TOptions(result)) return result;
+    }
+    if (isC15TOptions(config.c15tInstance)) return config.c15tInstance;
+    if ('function' == typeof config.c15tInstance) {
+        const result = tryGetFunctionResult(config.c15tInstance);
+        if (isC15TOptions(result)) return result;
+    }
+    if (isC15TOptions(config.consent)) return config.consent;
+    if ('function' == typeof config.consent) {
+        const result = tryGetFunctionResult(config.consent);
+        if (isC15TOptions(result)) return result;
+    }
+    if ('object' == typeof config.c15t && null !== config.c15t && isC15TOptions(config.c15t.options)) return config.c15t.options;
+    if ('object' == typeof config.default && null !== config.default && isC15TOptions(config.default.options)) return config.default.options;
+    if ('object' == typeof config.c15tInstance && null !== config.c15tInstance && isC15TOptions(config.c15tInstance.options)) return config.c15tInstance.options;
+    if ('object' == typeof config.instance && null !== config.instance && isC15TOptions(config.instance.options)) return config.instance.options;
+    if ('object' == typeof config.consent && null !== config.consent && isC15TOptions(config.consent.options)) return config.consent.options;
+    if ('object' == typeof config.config && null !== config.config && isC15TOptions(config.config.options)) return config.config.options;
+    console.debug('No valid configuration found in any of the expected locations');
+    return null;
+}
+const configFileNames = [
+    'c15t.config',
+    'c15t.backend',
+    'c15t',
+    'c15t.client',
+    'consent.config',
+    'consent.backend',
+    'consent',
+    'cmp.config',
+    'cmp.backend',
+    'cmp'
+];
+const constants_extensions = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.cjs',
+    '.cts',
+    '.mjs',
+    '.mts',
+    '.server.cjs',
+    '.server.cts',
+    '.server.js',
+    '.server.jsx',
+    '.server.mjs',
+    '.server.mts',
+    '.server.ts',
+    '.server.tsx'
+];
+let possiblePaths = configFileNames.flatMap((name)=>constants_extensions.map((ext)=>`${name}${ext}`));
+const directories = [
+    '',
+    'lib/server/',
+    'server/',
+    'lib/',
+    'utils/',
+    'config/',
+    'src/',
+    'app/'
+];
+possiblePaths = directories.flatMap((dir)=>possiblePaths.map((file)=>`${dir}${file}`));
+const jitiOptions = (context, cwd)=>{
+    const alias = context.config.getPathAliases(cwd) || {};
+    return {
+        extensions: [
+            '.ts',
+            '.tsx',
+            '.js',
+            '.jsx',
+            '.mjs',
+            '.cjs',
+            '.mts',
+            '.cts'
+        ],
+        alias
+    };
+};
+async function getConfig(contextOrOptions) {
+    const context = 'logger' in contextOrOptions ? contextOrOptions : {
+        ...contextOrOptions,
+        logger: {
+            debug: console.debug,
+            info: console.info,
+            warn: console.warn,
+            error: console.error
+        },
+        flags: {
+            config: contextOrOptions.configPath
+        },
+        error: {
+            handleError: (error)=>{
+                console.error('Error loading configuration:', error);
+                return null;
+            }
         }
-        return `text('${name}')`;
-      }, getType = function(fieldName, field) {
-        const snakeCaseName = convertToSnakeCase(fieldName);
-        const type = field.type;
-        const typeMap = {
-          string: {
-            sqlite: `text('${snakeCaseName}')`,
-            pg: `text('${snakeCaseName}')`,
-            mysql: getMySQLStringType(field, snakeCaseName)
-          },
-          boolean: {
-            sqlite: `integer('${snakeCaseName}', { mode: 'boolean' })`,
-            pg: `boolean('${snakeCaseName}')`,
-            mysql: `boolean('${snakeCaseName}')`
-          },
-          number: {
-            sqlite: `integer('${snakeCaseName}')`,
-            pg: "bigint" in field && field.bigint ? `bigint('${snakeCaseName}', { mode: 'number' })` : `integer('${snakeCaseName}')`,
-            mysql: "bigint" in field && field.bigint ? `bigint('${snakeCaseName}', { mode: 'number' })` : `int('${snakeCaseName}')`
-          },
-          date: {
-            sqlite: `integer('${snakeCaseName}', { mode: 'timestamp' })`,
-            pg: `timestamp('${snakeCaseName}')`,
-            mysql: `timestamp('${snakeCaseName}')`
-          },
-          // Add JSON type support
-          json: {
-            sqlite: `text('${snakeCaseName}')`,
-            // SQLite uses TEXT for JSON
-            pg: `json('${snakeCaseName}')`,
-            // PostgreSQL native JSON
-            mysql: `json('${snakeCaseName}')`
-            // MySQL native JSON
-          }
-        };
-        if (!typeMap[type]) {
-          return `text('${snakeCaseName}')`;
+    };
+    const { cwd, logger, flags } = context;
+    const configPath = flags.config;
+    let foundConfigPath = null;
+    try {
+        let options = null;
+        const customJitiOptions = jitiOptions(context, cwd);
+        if (configPath) {
+            foundConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(cwd, configPath);
+            logger.debug(`Using explicitly provided config path: ${foundConfigPath}`);
+        } else {
+            const prioritizedDirs = [
+                cwd,
+                __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'packages/cli')
+            ];
+            const primaryName = 'c15t.config';
+            const extensions = [
+                '.ts',
+                '.js',
+                '.mjs'
+            ];
+            for (const dir of prioritizedDirs){
+                for (const ext of extensions){
+                    const checkPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(dir, `${primaryName}${ext}`);
+                    try {
+                        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].access(checkPath);
+                        foundConfigPath = checkPath;
+                        logger.debug(`Found config via manual check: ${foundConfigPath}`);
+                        break;
+                    } catch  {}
+                }
+                if (foundConfigPath) break;
+            }
         }
-        const dbType = databaseType && ["sqlite", "pg", "mysql"].includes(databaseType) ? databaseType : "sqlite";
-        return typeMap[type][dbType];
-      };
-      let modelName = usePlural ? `${tables[table].modelName}s` : tables[table].modelName;
-      if (!modelName) {
-        modelName = table;
-      }
-      const fields = tables[table].fields;
-      const id = databaseType === "mysql" ? `varchar("id", { length: 36 }).primaryKey()` : `text("id").primaryKey()`;
-      const tableNameForSQL = convertToSnakeCase(modelName);
-      if (isFirstTable) {
-        code += "\n\n";
-        isFirstTable = false;
-      } else {
-        code += "\n\n";
-      }
-      const schema = `export const ${modelName} = ${databaseType}Table("${tableNameForSQL}", {
-  id: ${id},
-${Object.keys(fields).map((field) => {
-        if (Object.prototype.hasOwnProperty.call(fields, field)) {
-          const attr = fields[field];
-          return `  ${field}: ${getType(field, attr)}${attr.required ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${attr.references ? `.references(()=> ${usePlural ? `${attr.references.model}s` : attr.references.model}.${attr.references.field}, { onDelete: 'cascade' })` : ""}`;
+        if (foundConfigPath) try {
+            logger.debug(`Loading configuration from resolved path: ${foundConfigPath}`);
+            const result = await (0, __WEBPACK_EXTERNAL_MODULE_c12__.loadConfig)({
+                configFile: foundConfigPath,
+                jitiOptions: customJitiOptions
+            });
+            logger.debug('Raw config loading result:', result);
+            if (result.config) {
+                logger.debug('Trying to extract config from result.config');
+                options = extractOptionsFromConfig(result.config);
+            }
+            if (options) {
+                logger.debug('Extracted config:', options);
+                if (isC15TOptions(options) || isClientOptions(options)) {
+                    logger.debug('Configuration validated successfully.');
+                    return options;
+                }
+                logger.debug('Loaded config does not match expected schema');
+            } else logger.debug('No configuration extracted from loaded file');
+            logger.debug('Raw loaded configuration:', result);
+            return null;
+        } catch (error) {
+            logger.debug('Error loading config from explicit path:', error);
+            try {
+                logger.debug(`Trying to require module directly: ${foundConfigPath}`);
+                const importedModule = await import(foundConfigPath);
+                logger.debug('Directly imported module:', importedModule);
+                const extracted = extractOptionsFromConfig(importedModule);
+                if (extracted && (isC15TOptions(extracted) || isClientOptions(extracted))) {
+                    logger.debug('Found valid config through direct import');
+                    return extracted;
+                }
+            } catch (importError) {
+                logger.debug('Error importing module directly:', importError);
+            }
+            return null;
         }
-        return "";
-      }).filter(Boolean).join(",\n")}
-});`;
-      code += schema;
+        return options;
+    } catch (error) {
+        if ('error' in context && context.error && 'function' == typeof context.error.handleError) return context.error.handleError(error, 'Error loading configuration');
+        console.error('Error loading configuration:', error);
+        return null;
     }
-  }
-  return {
-    code,
-    fileName: filePath,
-    overwrite: fileExist
-  };
-};
-
-const CREATE_TABLE_REGEX = /create\s+table\s+"([^"]+)"\s+\((.*)\)/i;
-const CREATE_INDEX_REGEX = /create\s+index\s+"?([^"\s]+)"?\s+on\s+"?([^"\s]+)"?/i;
-const NOT_NULL_REGEX = /\bnot null\b/gi;
-const PRIMARY_KEY_REGEX = /\bprimary key\b/gi;
-const REFERENCES_REGEX = /\breferences\b/gi;
-const UNIQUE_REGEX = /\bunique\b/gi;
-const CREATE_TABLE_KEYWORD_REGEX = /\bcreate\s+table\b/gi;
-const CREATE_INDEX_KEYWORD_REGEX = /\bcreate\s+index\b/gi;
-const ALTER_TABLE_REGEX = /\balter\s+table\b/gi;
-const INSERT_INTO_REGEX = /\binsert\s+into\b/gi;
-const UPDATE_REGEX = /\bupdate\b/gi;
-const DELETE_FROM_REGEX = /\bdelete\s+from\b/gi;
-const SELECT_REGEX = /\bselect\b/gi;
-const FROM_REGEX = /\bfrom\b/gi;
-const WHERE_REGEX = /\bwhere\b/gi;
-const JOIN_REGEX = /\bjoin\b/gi;
-const ON_REGEX = /\bon\b/gi;
-const AND_REGEX = /\band\b/gi;
-const OR_REGEX = /\bor\b/gi;
-const BOOLEAN_FIELD_REGEX = /("is[A-Z][a-zA-Z0-9]*")\s+integer/g;
-const DATE_FIELD_REGEX = /("(?:created|updated|expires)At")\s+date/gi;
-const TEXT_FIELD_REGEX = /("(?:name|code|description|id)")\s+text/gi;
-const JSON_FIELD_REGEX = /("(?:metadata|config|data|settings|options|preferences|attributes)")\s+text/gi;
-function formatSQL(sql, databaseType = "sqlite", options) {
-  const dbType = databaseType === "pg" ? "postgresql" : databaseType;
-  const statements = sql.split(";").filter((stmt) => stmt.trim());
-  const rollbackStatements = [];
-  const formattedStatements = statements.map((statement) => {
-    const trimmedStmt = statement.trim().toLowerCase();
-    if (trimmedStmt.startsWith("create table")) {
-      const match = statement.match(CREATE_TABLE_REGEX);
-      if (match) {
-        const [_, tableName, columnsStr] = match;
-        rollbackStatements.unshift(`DROP TABLE IF EXISTS "${tableName}"`);
-        const columns = columnsStr.split(",").map((col) => col.trim());
-        const formattedColumns = columns.map((col) => {
-          let formattedCol = col.replace(NOT_NULL_REGEX, "NOT NULL").replace(PRIMARY_KEY_REGEX, "PRIMARY KEY").replace(REFERENCES_REGEX, "REFERENCES").replace(UNIQUE_REGEX, "UNIQUE");
-          if (dbType === "postgresql") {
-            formattedCol = formattedCol.replace(BOOLEAN_FIELD_REGEX, "$1 boolean").replace(DATE_FIELD_REGEX, "$1 timestamp with time zone").replace(TEXT_FIELD_REGEX, "$1 varchar(255)").replace(JSON_FIELD_REGEX, "$1 jsonb");
-          } else if (dbType === "mysql") {
-            formattedCol = formattedCol.replace(BOOLEAN_FIELD_REGEX, "$1 TINYINT(1)").replace(DATE_FIELD_REGEX, "$1 DATETIME").replace(TEXT_FIELD_REGEX, "$1 VARCHAR(255)").replace(JSON_FIELD_REGEX, "$1 JSON");
-          } else if (dbType === "sqlite") {
-            formattedCol = formattedCol.replace(
-              JSON_FIELD_REGEX,
-              "$1 text -- stored as JSON"
-            );
-          }
-          return formattedCol;
-        }).map((col) => `  ${col}`).join(",\n");
-        return `CREATE TABLE IF NOT EXISTS "${tableName}" (
-${formattedColumns}
-);`;
-      }
-    }
-    if (trimmedStmt.startsWith("create index")) {
-      const indexMatch = statement.match(CREATE_INDEX_REGEX);
-      if (indexMatch) {
-        const [_, indexName] = indexMatch;
-        rollbackStatements.unshift(`DROP INDEX IF EXISTS "${indexName}"`);
-        return `CREATE INDEX IF NOT EXISTS "${indexName}" ${statement.substring(statement.toLowerCase().indexOf("on")).trim()};`;
-      }
-    }
-    return `${statement.trim().replace(CREATE_TABLE_KEYWORD_REGEX, "CREATE TABLE").replace(CREATE_INDEX_KEYWORD_REGEX, "CREATE INDEX").replace(ALTER_TABLE_REGEX, "ALTER TABLE").replace(INSERT_INTO_REGEX, "INSERT INTO").replace(UPDATE_REGEX, "UPDATE").replace(DELETE_FROM_REGEX, "DELETE FROM").replace(SELECT_REGEX, "SELECT").replace(FROM_REGEX, "FROM").replace(WHERE_REGEX, "WHERE").replace(JOIN_REGEX, "JOIN").replace(ON_REGEX, "ON").replace(AND_REGEX, "AND").replace(OR_REGEX, "OR")};`;
-  }).join("\n\n");
-  const useTransactions = dbType !== "d1";
-  const transactionStart = useTransactions ? dbType === "mysql" ? "START TRANSACTION;" : "BEGIN;" : "";
-  const transactionEnd = useTransactions ? "COMMIT;" : "";
-  const timestamp = options?.timestamp || (/* @__PURE__ */ new Date()).toISOString();
-  return `-- Migration generated by C15T (${timestamp})
--- Database type: ${dbType}
--- Description: Automatically generated schema migration
--- 
--- Wrapped in a transaction for atomicity
--- To roll back this migration, use the ROLLBACK section below
+}
+function showHelpMenu(context, version, commands, flags) {
+    const { logger } = context;
+    logger.debug('Displaying help menu using command and flag structures.');
+    const commandLines = commands.map((cmd)=>`  ${cmd.name.padEnd(10)} ${cmd.description}`).join('\n');
+    const optionLines = flags.map((flag)=>{
+        const names = flag.names.join(', ');
+        const valuePlaceholder = flag.expectsValue ? ' <value>' : '';
+        return `  ${(names + valuePlaceholder).padEnd(20)} ${flag.description}`;
+    }).join('\n');
+    const helpContent = `c15t CLI version ${version}
 
-${transactionStart}
--- MIGRATION
-${formattedStatements}
-${transactionEnd}
+Available Commands:
+${commandLines}
 
--- ROLLBACK
--- Uncomment the section below to roll back this migration
-/*
-${transactionStart}
+Options:
+${optionLines}
 
-${rollbackStatements.join(";\n\n")};
+Run a command directly (e.g., ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('c15t generate')}) or select one interactively when no command is provided.
 
-${transactionEnd}
-*/`;
+For more help, visit: https://c15t.dev`;
+    logger.debug('Help menu content generated.');
+    logger.note(helpContent, 'Usage');
 }
-const generateMigrations = async ({
-  options,
-  file,
-  adapter
-}) => {
-  const { compileMigrations } = await getMigrations(options);
-  const migrations = await compileMigrations();
-  let databaseType = "sqlite";
-  if (adapter?.options?.provider) {
-    databaseType = adapter.options.provider;
-  } else if (options.database && "options" in options.database && options.database.options && typeof options.database.options === "object" && "provider" in options.database.options) {
-    databaseType = options.database.options.provider;
-  }
-  const isTest = process.env.NODE_ENV === "test" || file?.includes("test");
-  const testTimestamp = options?._testTimestamp;
-  const formatOptions = {
-    timestamp: testTimestamp || (isTest ? "2023-01-01T00:00:00.000Z" : void 0)
-  };
-  const formattedMigrations = formatSQL(
-    migrations,
-    databaseType,
-    formatOptions
-  );
-  const generatedFileName = file || `./c15t_migrations/${Date.now()}_create_tables.sql`;
-  return {
-    code: formattedMigrations,
-    fileName: generatedFileName
-  };
+const validLogLevels = [
+    'error',
+    'warn',
+    'info',
+    'debug'
+];
+const formatArgs = (args)=>{
+    if (0 === args.length) return '';
+    return `\n${args.map((arg)=>`  - ${JSON.stringify(arg, null, 2)}`).join('\n')}`;
 };
-
-function capitalizeFirstLetter(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-const generatePrismaSchema = async ({
-  adapter,
-  options,
-  file
-}) => {
-  const provider = adapter.options?.provider || "postgresql";
-  const tables = getConsentTables(options);
-  const filePath = file || "./prisma/schema.prisma";
-  const schemaPrismaExist = existsSync(path.join(process.cwd(), filePath));
-  let schemaPrisma = "";
-  if (schemaPrismaExist) {
-    schemaPrisma = await fs.readFile(
-      path.join(process.cwd(), filePath),
-      "utf-8"
-    );
-  } else {
-    schemaPrisma = getNewPrisma(provider);
-  }
-  const manyToManyRelations = /* @__PURE__ */ new Map();
-  for (const table in tables) {
-    if (Object.hasOwn(tables, table)) {
-      const fields = tables[table]?.fields;
-      for (const field in fields) {
-        if (Object.hasOwn(fields, field)) {
-          const attr = fields[field];
-          if (attr?.references) {
-            const referencedModel = capitalizeFirstLetter(
-              attr.references.model
-            );
-            if (!manyToManyRelations.has(referencedModel)) {
-              manyToManyRelations.set(referencedModel, /* @__PURE__ */ new Set());
+const formatLogMessage = (logLevel, message, args = [])=>{
+    const messageStr = 'string' == typeof message ? message : String(message);
+    const formattedArgs = formatArgs(args);
+    switch(logLevel){
+        case 'error':
+            return `${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].bgRed(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].black(' error '))} ${messageStr}${formattedArgs}`;
+        case 'warn':
+            return `${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].bgYellow(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].black(' warning '))} ${messageStr}${formattedArgs}`;
+        case 'info':
+            return `${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].bgGreen(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].black(' info '))} ${messageStr}${formattedArgs}`;
+        case 'debug':
+            return `${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].bgBlack(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].white(' debug '))} ${messageStr}${formattedArgs}`;
+        case 'success':
+            return `${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].bgGreen(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].white(' success '))} ${messageStr}${formattedArgs}`;
+        case 'failed':
+            return `${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].bgRed(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].white(' failed '))} ${messageStr}${formattedArgs}`;
+        default:
+            {
+                const levelStr = logLevel;
+                return `[${levelStr.toUpperCase()}] ${messageStr}${formattedArgs}`;
             }
-            manyToManyRelations.get(referencedModel).add(capitalizeFirstLetter(table));
-          }
-        }
-      }
     }
-  }
-  const schema = produceSchema(schemaPrisma, (builder) => {
-    function getPrismaType(type, isOptional, isBigint) {
-      const isJsonField = type === "json" || type === "jsonb";
-      if (isJsonField) {
-        if (provider === "postgresql" || provider === "mysql") {
-          return isOptional ? "Json?" : "Json";
+};
+const logMessage = (logLevel, message, ...args)=>{
+    const formattedMessage = formatLogMessage(logLevel, message, args);
+    switch(logLevel){
+        case 'error':
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.log.error(formattedMessage);
+            break;
+        case 'warn':
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.log.warn(formattedMessage);
+            break;
+        case 'info':
+        case 'debug':
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.log.info(formattedMessage);
+            break;
+        case 'success':
+        case 'failed':
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.outro(formattedMessage);
+            break;
+        default:
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.log.message(formattedMessage);
+    }
+};
+const createCliLogger = (level)=>{
+    const baseLogger = (0, __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.createLogger)({
+        level,
+        appName: 'c15t',
+        log: (logLevel, message, ...args)=>{
+            logMessage(logLevel, message, ...args);
         }
-        return isOptional ? "String?" : 'String @map("json_as_text")';
-      }
-      if (type === "string") {
-        return isOptional ? "String?" : "String";
-      }
-      if (type === "number" && isBigint) {
-        return isOptional ? "BigInt?" : "BigInt";
-      }
-      if (type === "number") {
-        return isOptional ? "Int?" : "Int";
-      }
-      if (type === "boolean") {
-        return isOptional ? "Boolean?" : "Boolean";
-      }
-      if (type === "date") {
-        return isOptional ? "DateTime?" : "DateTime";
-      }
-      if (type === "string[]") {
-        return "String[]";
-      }
-      if (type === "number[]") {
-        return "Int[]";
-      }
-      return "String";
-    }
-    for (const table in tables) {
-      if (Object.hasOwn(tables, table)) {
-        const fields = tables[table]?.fields;
-        const originalTable = tables[table]?.modelName;
-        const modelName = capitalizeFirstLetter(originalTable || table);
-        const prismaModel = builder.findByType("model", { name: modelName });
-        if (!prismaModel) {
-          if (provider === "mongodb") {
-            builder.model(modelName).field("id", "String").attribute("id").attribute(`map("_id")`);
-          } else {
-            builder.model(modelName).field("id", "String").attribute("id");
-          }
+    });
+    const extendedLogger = baseLogger;
+    extendedLogger.message = (message)=>{
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.log.message(message);
+    };
+    extendedLogger.note = (message, ...args)=>{
+        const messageStr = 'string' == typeof message ? message : String(message);
+        const title = args.length > 0 && 'string' == typeof args[0] ? args[0] : void 0;
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.note(messageStr, title, {
+            format: (line)=>line
+        });
+    };
+    extendedLogger.success = (message, ...args)=>{
+        logMessage('success', message, ...args);
+    };
+    extendedLogger.failed = (message, ...args)=>{
+        logMessage('failed', message, ...args);
+    };
+    extendedLogger.outro = (message)=>{
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.outro(message);
+    };
+    return extendedLogger;
+};
+const TELEMETRY_DISABLED_ENV = 'C15T_TELEMETRY_DISABLED';
+var telemetry_TelemetryEventName = /*#__PURE__*/ function(TelemetryEventName) {
+    TelemetryEventName["CLI_INVOKED"] = "cli.invoked";
+    TelemetryEventName["CLI_COMPLETED"] = "cli.completed";
+    TelemetryEventName["CLI_EXITED"] = "cli.exited";
+    TelemetryEventName["CLI_ENVIRONMENT_DETECTED"] = "cli.environment_detected";
+    TelemetryEventName["COMMAND_EXECUTED"] = "command.executed";
+    TelemetryEventName["COMMAND_SUCCEEDED"] = "command.succeeded";
+    TelemetryEventName["COMMAND_FAILED"] = "command.failed";
+    TelemetryEventName["COMMAND_UNKNOWN"] = "command.unknown";
+    TelemetryEventName["INTERACTIVE_MENU_OPENED"] = "ui.menu.opened";
+    TelemetryEventName["INTERACTIVE_MENU_EXITED"] = "ui.menu.exited";
+    TelemetryEventName["CONFIG_LOADED"] = "config.loaded";
+    TelemetryEventName["CONFIG_ERROR"] = "config.error";
+    TelemetryEventName["CONFIG_UPDATED"] = "config.updated";
+    TelemetryEventName["HELP_DISPLAYED"] = "help.displayed";
+    TelemetryEventName["VERSION_DISPLAYED"] = "version.displayed";
+    TelemetryEventName["ONBOARDING_STARTED"] = "onboarding.started";
+    TelemetryEventName["ONBOARDING_COMPLETED"] = "onboarding.completed";
+    TelemetryEventName["ONBOARDING_EXITED"] = "onboarding.exited";
+    TelemetryEventName["ONBOARDING_STORAGE_MODE_SELECTED"] = "onboarding.storage_mode_selected";
+    TelemetryEventName["ONBOARDING_C15T_MODE_CONFIGURED"] = "onboarding.c15t_mode_configured";
+    TelemetryEventName["ONBOARDING_OFFLINE_MODE_CONFIGURED"] = "onboarding.offline_mode_configured";
+    TelemetryEventName["ONBOARDING_SELF_HOSTED_CONFIGURED"] = "onboarding.self_hosted_configured";
+    TelemetryEventName["ONBOARDING_CUSTOM_MODE_CONFIGURED"] = "onboarding.custom_mode_configured";
+    TelemetryEventName["ONBOARDING_DEPENDENCIES_CHOICE"] = "onboarding.dependencies_choice";
+    TelemetryEventName["ONBOARDING_DEPENDENCIES_INSTALLED"] = "onboarding.dependencies_installed";
+    TelemetryEventName["ONBOARDING_GITHUB_STAR"] = "onboarding.github_star";
+    TelemetryEventName["ERROR_OCCURRED"] = "error.occurred";
+    TelemetryEventName["MIGRATION_STARTED"] = "migration.started";
+    TelemetryEventName["MIGRATION_PLANNED"] = "migration.planned";
+    TelemetryEventName["MIGRATION_EXECUTED"] = "migration.executed";
+    TelemetryEventName["MIGRATION_COMPLETED"] = "migration.completed";
+    TelemetryEventName["MIGRATION_FAILED"] = "migration.failed";
+    TelemetryEventName["GENERATE_STARTED"] = "generate.started";
+    TelemetryEventName["GENERATE_COMPLETED"] = "generate.completed";
+    TelemetryEventName["GENERATE_FAILED"] = "generate.failed";
+    return TelemetryEventName;
+}({});
+class Telemetry {
+    client = null;
+    disabled;
+    defaultProperties;
+    distinctId;
+    apiKey = 'phc_ViY5LtTmh4kqoumXZB2olPFoTz4AbbDfrogNgFi1MH3';
+    debug = false;
+    logger;
+    constructor(options){
+        const envDisabled = '1' === process.env[TELEMETRY_DISABLED_ENV] || process.env[TELEMETRY_DISABLED_ENV]?.toLowerCase() === 'true';
+        const hasValidApiKey = !!(this.apiKey && '' !== this.apiKey.trim());
+        this.disabled = options?.disabled ?? envDisabled ?? !hasValidApiKey;
+        this.defaultProperties = options?.defaultProperties ?? {};
+        this.logger = options?.logger;
+        this.distinctId = this.generateAnonymousId();
+        if (this.disabled) {
+            if (!hasValidApiKey) this.logDebug('Telemetry disabled: No API key provided');
+        } else this.initClient(options?.client);
+    }
+    trackEventSync(eventName, properties = {}) {
+        if (this.disabled || !this.client) {
+            if (this.debug) this.logDebug('Telemetry disabled or client not initialized');
+            return;
         }
-        for (const field in fields) {
-          if (Object.hasOwn(fields, field)) {
-            const attr = fields[field];
-            const existingField = builder.findByType("field", {
-              name: field,
-              within: prismaModel?.properties
+        const safeProperties = {};
+        for (const [key, value] of Object.entries(properties))if ('config' !== key && void 0 !== value) safeProperties[key] = value;
+        if (this.debug) this.logDebug(`Sending telemetry event: ${eventName}`);
+        try {
+            this.client.capture({
+                distinctId: this.distinctId,
+                event: eventName,
+                properties: {
+                    ...this.defaultProperties,
+                    ...safeProperties,
+                    timestamp: new Date().toISOString()
+                }
             });
-            if (existingField) {
-              continue;
-            }
-            builder.model(modelName).field(
-              field,
-              getPrismaType(attr.type, !attr?.required, attr?.bigint || false)
-            );
-            if (attr.unique) {
-              builder.model(modelName).blockAttribute(`unique([${field}])`);
-            }
-            if (attr.references) {
-              builder.model(modelName).field(
-                `${attr.references.model.toLowerCase()}`,
-                capitalizeFirstLetter(attr.references.model)
-              ).attribute(
-                `relation(fields: [${field}], references: [${attr.references.field}], onDelete: Cascade)`
-              );
+            this.client.flush();
+            if (this.debug) this.logDebug(`Flushed telemetry event: ${eventName}`);
+        } catch (error) {
+            if (this.debug) this.logDebug(`Error sending telemetry: ${error}`);
+        }
+    }
+    trackEvent(eventName, properties = {}) {
+        this.trackEventSync(eventName, properties);
+    }
+    trackCommand(command, args = [], flags = {}) {
+        if (this.disabled || !this.client) return;
+        const safeFlags = {};
+        for (const [key, value] of Object.entries(flags))if ('config' !== key && void 0 !== value) safeFlags[key] = value;
+        this.trackEvent("command.executed", {
+            command,
+            args: args.join(' '),
+            flagsData: JSON.stringify(safeFlags)
+        });
+    }
+    trackError(error, command) {
+        if (this.disabled || !this.client) return;
+        this.trackEvent("error.occurred", {
+            command,
+            error: error.message,
+            errorName: error.name,
+            stack: 'development' === process.env.NODE_ENV ? error.stack : void 0
+        });
+    }
+    setLogLevel(level) {
+        if (this.client && 'debug' === level) {
+            this.debug = true;
+            this.client.debug(true);
+            this.logDebug('Telemetry debug mode enabled');
+        }
+    }
+    disable() {
+        this.disabled = true;
+    }
+    enable() {
+        this.disabled = false;
+        if (!this.client) this.initClient();
+    }
+    isDisabled() {
+        return this.disabled;
+    }
+    async shutdown() {
+        if (this.client) {
+            await this.client.shutdown();
+            this.client = null;
+        }
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    logDebug(message, ...args) {
+        if (this.logger) this.logger.debug(message, ...args);
+        else console.debug(message, ...args);
+    }
+    initClient(customClient) {
+        if (customClient) {
+            this.client = customClient;
+            if (this.debug) this.logDebug('Using custom PostHog client');
+        } else {
+            if (!this.apiKey || '' === this.apiKey.trim()) {
+                this.disabled = true;
+                this.logDebug('Telemetry disabled: No API key provided');
+                return;
             }
-            if (!attr.unique && !attr.references && provider === "mysql" && attr.type === "string") {
-              builder.model(modelName).field(field).attribute("db.Text");
+            const startTime = Date.now();
+            try {
+                const clientConfig = {
+                    host: 'https://eu.i.posthog.com',
+                    flushInterval: 0,
+                    flushAt: 1,
+                    requestTimeout: 3000
+                };
+                if (this.debug) this.logDebug('Initializing PostHog client with config:', JSON.stringify(clientConfig));
+                this.client = new __WEBPACK_EXTERNAL_MODULE_posthog_node_1b07bdf4__.PostHog(this.apiKey, clientConfig);
+                const initTime = Date.now() - startTime;
+                if (this.debug) this.logDebug('PostHog client initialized in', initTime, 'ms');
+            } catch (error) {
+                this.disabled = true;
+                const errorDetails = error instanceof Error ? {
+                    message: error.message,
+                    name: error.name,
+                    stack: error.stack
+                } : {
+                    rawError: String(error)
+                };
+                if (this.debug) this.logDebug('Telemetry disabled due to initialization error:', JSON.stringify(errorDetails, null, 2));
+                try {
+                    if (this.debug) this.logDebug('Attempting fallback PostHog initialization');
+                    this.client = new __WEBPACK_EXTERNAL_MODULE_posthog_node_1b07bdf4__.PostHog(this.apiKey);
+                    this.disabled = false;
+                    if (this.debug) this.logDebug('PostHog client initialized using fallback method');
+                } catch (fallbackError) {
+                    this.logDebug('Fallback initialization also failed:', fallbackError instanceof Error ? fallbackError.message : String(fallbackError));
+                }
             }
-          }
         }
-        if (originalTable && originalTable !== modelName) {
-          const hasMapAttribute = builder.findByType("attribute", {
-            name: "map",
-            within: prismaModel?.properties
-          });
-          if (!hasMapAttribute) {
-            builder.model(modelName).blockAttribute("map", originalTable);
-          }
+    }
+    generateAnonymousId() {
+        const machineId = __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__["default"].createHash('sha256').update(__WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__["default"].hostname() + __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__["default"].platform() + __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__["default"].arch() + __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__["default"].totalmem()).digest('hex');
+        return machineId;
+    }
+    flushSync() {
+        if (this.disabled || !this.client) return;
+        try {
+            this.client.flush();
+            if (this.debug) this.logDebug('Manually flushed telemetry events');
+        } catch (error) {
+            if (this.debug) this.logDebug(`Error flushing telemetry: ${error}`);
+        }
+    }
+}
+function createTelemetry(options) {
+    return new Telemetry(options);
+}
+async function addAndInstallDependenciesViaPM(projectRoot, dependencies, packageManager) {
+    const depsToAdd = dependencies.map((dep)=>`${dep}`);
+    if (0 === depsToAdd.length) return;
+    let command = '';
+    let args = [];
+    switch(packageManager){
+        case 'npm':
+            command = 'npm';
+            args = [
+                'install',
+                ...depsToAdd
+            ];
+            break;
+        case 'yarn':
+            command = 'yarn';
+            args = [
+                'add',
+                ...depsToAdd
+            ];
+            break;
+        case 'pnpm':
+            command = 'pnpm';
+            args = [
+                'add',
+                ...depsToAdd
+            ];
+            break;
+        default:
+            throw new Error(`Unsupported package manager for dependency addition: ${packageManager}`);
+    }
+    const child = (0, __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__.spawn)(command, args, {
+        cwd: projectRoot,
+        stdio: 'inherit'
+    });
+    await (0, __WEBPACK_EXTERNAL_MODULE_node_events_0a6aefe7__.once)(child, 'exit');
+}
+function getManualInstallCommand(dependencies, packageManager) {
+    const depsToAdd = dependencies.map((dep)=>`${dep}`);
+    switch(packageManager){
+        case 'npm':
+            return `npm install ${depsToAdd.join(' ')}`;
+        case 'yarn':
+            return `yarn add ${depsToAdd.join(' ')}`;
+        case 'pnpm':
+            return `pnpm add ${depsToAdd.join(' ')}`;
+        default:
+            return `npm install ${depsToAdd.join(' ')}`;
+    }
+}
+async function detectFramework(projectRoot) {
+    try {
+        const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'package.json');
+        const packageJson = JSON.parse(await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].readFile(packageJsonPath, 'utf-8'));
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies
+        };
+        const hasReact = 'react' in deps;
+        let framework = null;
+        if ('next' in deps) framework = 'Next.js';
+        else if ('@remix-run/react' in deps) framework = 'Remix';
+        else if ('@vitejs/plugin-react' in deps || '@vitejs/plugin-react-swc' in deps) framework = 'Vite + React';
+        else if ('gatsby' in deps) framework = 'Gatsby';
+        else if (hasReact) framework = 'React';
+        return {
+            framework,
+            hasReact
+        };
+    } catch (error) {
+        return {
+            framework: null,
+            hasReact: false
+        };
+    }
+}
+async function detectProjectRoot(cwd) {
+    let projectRoot = cwd;
+    try {
+        let prevDir = '';
+        while(projectRoot !== prevDir)try {
+            await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].access(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'package.json'));
+            break;
+        } catch  {
+            prevDir = projectRoot;
+            projectRoot = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(projectRoot);
+        }
+        if (projectRoot === prevDir) throw new Error('Could not find project root (no package.json found)');
+        return projectRoot;
+    } catch  {
+        return cwd;
+    }
+}
+async function detectPackageManager(projectRoot) {
+    try {
+        const result = await (0, __WEBPACK_EXTERNAL_MODULE_package_manager_detector_detect_94d6a9ae__.detect)({
+            cwd: projectRoot
+        });
+        let detectedPm = null;
+        if ('string' == typeof result) detectedPm = result;
+        else if (result && 'object' == typeof result) {
+            if ('name' in result && 'string' == typeof result.name) detectedPm = result.name;
+            else if ('pm' in result && 'string' == typeof result.pm) detectedPm = result.pm;
         }
-      }
-    }
-    for (const [
-      referencedModel,
-      relatedModels
-    ] of manyToManyRelations.entries()) {
-      for (const relatedModel of relatedModels) {
-        const fieldName = `${relatedModel.toLowerCase()}s`;
-        const model = builder.findByType("model", { name: referencedModel });
-        if (model) {
-          const existingField = builder.findByType("field", {
-            name: fieldName,
-            within: model.properties
-          });
-          if (!existingField) {
-            builder.model(referencedModel).field(fieldName, `${relatedModel}[]`);
-          }
+        if (detectedPm && ('npm' === detectedPm || 'yarn' === detectedPm || 'pnpm' === detectedPm)) return detectedPm;
+        let detectedValueStr = String(result);
+        if (result && 'object' == typeof result) detectedValueStr = JSON.stringify(result);
+        throw new Error(`Could not reliably detect package manager (detected: ${detectedValueStr}).`);
+    } catch (error) {
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.log.warn(`Automatic package manager detection failed: ${error instanceof Error ? error.message : String(error)}`);
+        const selectedPackageManager = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.select({
+            message: 'Please select your package manager:',
+            options: [
+                {
+                    value: 'npm',
+                    label: 'npm'
+                },
+                {
+                    value: 'yarn',
+                    label: 'yarn'
+                },
+                {
+                    value: 'pnpm',
+                    label: 'pnpm'
+                }
+            ],
+            initialValue: 'npm'
+        });
+        if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(selectedPackageManager)) {
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.log.warn('Package manager selection cancelled. Exiting.');
+            process.exit(0);
         }
-      }
+        return selectedPackageManager;
+    }
+}
+function generateClientConfigContent(mode, backendURL, useEnvFile) {
+    let configContent = '';
+    const validModes = [
+        'c15t',
+        'offline',
+        'custom'
+    ];
+    if (!validModes.includes(mode)) throw new Error(`Invalid mode: ${mode}. Valid modes are: ${validModes.join(', ')}`);
+    switch(mode){
+        case 'c15t':
+            configContent = `// c15t Client Configuration
+import type { ConsentManagerOptions } from '@c15t/react';
+
+export const c15tConfig = {
+  // Using hosted c15t (consent.io) or self-hosted instance
+  mode: 'c15t',
+  backendURL: ${useEnvFile ? 'process.env.NEXT_PUBLIC_C15T_URL' : `'${backendURL || 'https://your-instance.c15t.dev'}'`},
+  
+  // Optional: Add callback functions for various events
+  callbacks: {
+    onConsentSet: (response) => {
+      console.log('Consent has been saved');
     }
-  });
-  return {
-    code: schema.trim() === schemaPrisma.trim() ? "" : schema,
-    fileName: filePath
-  };
-};
-const getNewPrisma = (provider) => `generator client {
-    provider = "prisma-client-js"
   }
+} satisfies ConsentManagerOptions;
+
+// Use in your app layout:
+// <ConsentManagerProvider options={c15tConfig}>
+//   {children}
+//   <CookieBanner />
+//   <ConsentManagerDialog />
+// </ConsentManagerProvider>
+`;
+            break;
+        case 'offline':
+            configContent = `// c15t Client Configuration
+import type { ConsentManagerOptions } from '@c15t/react';
+
+export const c15tConfig = {
+  // Using offline mode for browser-based storage
+  mode: 'offline',
   
-  datasource db {
-    provider = "${provider}"
-    url      = ${provider === "sqlite" ? `"file:./dev.db"` : `env("DATABASE_URL")`}
-  }`;
+  // Optional: Add callback functions for various events
+  callbacks: {
+    onConsentSet: (response) => {
+      console.log('Consent has been saved locally');
+    }
+  }
+} satisfies ConsentManagerOptions;
 
-const adapters = {
-  prisma: generatePrismaSchema,
-  drizzle: generateDrizzleSchema,
-  kysely: generateMigrations
-};
-const getGenerator = (opts) => {
-  const adapter = opts.adapter;
-  const generator = adapter.id in adapters ? adapters[adapter.id] : null;
-  if (!generator) {
-    logger.error(`${adapter.id} is not supported.`);
-    process.exit(1);
+// Use in your app layout:
+// <ConsentManagerProvider options={c15tConfig}>
+//   {children}
+//   <CookieBanner />
+//   <ConsentManagerDialog />
+// </ConsentManagerProvider>
+`;
+            break;
+        case 'custom':
+            configContent = `// c15t Client Configuration
+import type { ConsentManagerOptions } from '@c15t/react';
+import { createCustomHandlers } from './consent-handlers';
+
+export const c15tConfig = {
+  // Using custom mode for complete control
+  mode: 'custom',
+  endpointHandlers: createCustomHandlers(),
+  
+  // Optional: Add callback functions for various events
+  callbacks: {
+    onConsentSet: (response) => {
+      console.log('Consent has been saved');
+    }
   }
-  return generator(opts);
-};
+} satisfies ConsentManagerOptions;
 
-function addSvelteKitEnvModules(aliases) {
-  aliases["$env/dynamic/private"] = createDataUriModule(
-    createDynamicEnvModule()
-  );
-  aliases["$env/dynamic/public"] = createDataUriModule(
-    createDynamicEnvModule()
-  );
-  aliases["$env/static/private"] = createDataUriModule(
-    createStaticEnvModule(filterPrivateEnv("PUBLIC_", ""))
-  );
-  aliases["$env/static/public"] = createDataUriModule(
-    createStaticEnvModule(filterPublicEnv("PUBLIC_", ""))
-  );
-}
-function createDataUriModule(module) {
-  return `data:text/javascript;charset=utf-8,${encodeURIComponent(module)}`;
-}
-function createStaticEnvModule(env) {
-  const declarations = Object.keys(env).filter((k) => validIdentifier.test(k) && !reserved.has(k)).map((k) => `export const ${k} = ${JSON.stringify(env[k])};`);
-  return `
-  ${declarations.join("\n")}
-  // jiti dirty hack: .unknown
-  `;
-}
-function createDynamicEnvModule() {
-  return `
-  export const env = process.env;
-  // jiti dirty hack: .unknown
-  `;
+// Use in your app layout:
+// <ConsentManagerProvider options={c15tConfig}>
+//   {children}
+//   <CookieBanner />
+//   <ConsentManagerDialog />
+// </ConsentManagerProvider>
+
+// Don't forget to implement your custom handlers in consent-handlers.ts!
+`;
+            break;
+    }
+    return configContent;
 }
-function filterPrivateEnv(publicPrefix, privatePrefix) {
-  return Object.fromEntries(
-    Object.entries(process.env).filter(
-      ([k]) => k.startsWith(privatePrefix) && (!k.startsWith(publicPrefix))
-    )
-  );
+function generateBackendConfigContent(adapterChoice, connectionString, filePath) {
+    let adapterImport = '';
+    let adapterConfig = '';
+    switch(adapterChoice){
+        case 'kysely-postgres':
+            adapterImport = `import { kyselyAdapter } from '@c15t/backend/db/adapters/kysely';\nimport { PostgresDialect } from 'kysely';\nimport { Pool } from 'pg';`;
+            adapterConfig = `kyselyAdapter({
+      dialect: new PostgresDialect({
+        pool: new Pool({
+          connectionString: ${connectionString ? `"${connectionString}"` : 'process.env.DATABASE_URL || "postgresql://user:password@host:port/db"'}
+        })
+      })
+    })`;
+            break;
+        case 'kysely-sqlite':
+            adapterImport = `import { kyselyAdapter } from '@c15t/backend/db/adapters/kysely';\nimport { SqliteDialect } from 'kysely';\nimport Database from 'better-sqlite3';`;
+            adapterConfig = `kyselyAdapter({
+      dialect: new SqliteDialect({
+        database: new Database("${filePath || './db.sqlite'}")
+      })
+    })`;
+            break;
+        default:
+            adapterImport = "import { memoryAdapter } from '@c15t/backend/db/adapters/memory';";
+            adapterConfig = 'memoryAdapter({})';
+            break;
+    }
+    return `// c15t Backend Configuration
+// Generated by c15t CLI onboarding
+
+import { c15tInstance } from '@c15t/backend';
+${adapterImport}
+
+// WARNING: Database connection strings often contain sensitive credentials.
+// Consider using environment variables instead of hardcoding these values.
+
+// Define your c15t instance
+const instance = c15tInstance({
+  appName: 'Your App Name',
+  basePath: '/api/c15t',
+  database: ${adapterConfig},
+  trustedOrigins: ['http://localhost:3000'],
+});
+
+export default instance;
+`;
 }
-function filterPublicEnv(publicPrefix, privatePrefix) {
-  return Object.fromEntries(
-    Object.entries(process.env).filter(
-      ([k]) => k.startsWith(publicPrefix) && (privatePrefix === "")
-    )
-  );
+function generateEnvFileContent(backendURL) {
+    return `# c15t Configuration
+# Note: This URL is public and can be safely committed to version control
+NEXT_PUBLIC_C15T_URL=${backendURL}
+`;
 }
-const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-const reserved = /* @__PURE__ */ new Set([
-  "do",
-  "if",
-  "in",
-  "for",
-  "let",
-  "new",
-  "try",
-  "var",
-  "case",
-  "else",
-  "enum",
-  "eval",
-  "null",
-  "this",
-  "true",
-  "void",
-  "with",
-  "await",
-  "break",
-  "catch",
-  "class",
-  "const",
-  "false",
-  "super",
-  "throw",
-  "while",
-  "yield",
-  "delete",
-  "export",
-  "import",
-  "public",
-  "return",
-  "static",
-  "switch",
-  "typeof",
-  "default",
-  "extends",
-  "finally",
-  "package",
-  "private",
-  "continue",
-  "debugger",
-  "function",
-  "arguments",
-  "interface",
-  "protected",
-  "implements",
-  "instanceof"
-]);
-
-const configFileNames = ["c15t", "consent", "cmp"];
-const extensions = [
-  ".js",
-  ".jsx",
-  ".ts",
-  ".tsx",
-  ".cjs",
-  ".cts",
-  ".mjs",
-  ".mts",
-  ".server.cjs",
-  ".server.cts",
-  ".server.js",
-  ".server.jsx",
-  ".server.mjs",
-  ".server.mts",
-  ".server.ts",
-  ".server.tsx"
-];
-let possiblePaths = configFileNames.flatMap(
-  (name) => extensions.map((ext) => `${name}${ext}`)
-);
-const directories = [
-  "",
-  "lib/server/",
-  "server/",
-  "lib/",
-  "utils/",
-  "config/",
-  "src/",
-  "app/"
-];
-possiblePaths = directories.flatMap(
-  (dir) => possiblePaths.map((file) => `${dir}${file}`)
-);
-const monorepoSubdirs = ["packages/*", "apps/*"];
-function stripJsonComments(jsonString) {
-  return jsonString.replace(
-    /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g,
-    (m, g) => g ? "" : m
-  ).replace(/,(?=\s*[}\]])/g, "");
+async function setupC15tMode(context, projectRoot, spinner, initialBackendURL, handleCancel) {
+    const { logger, cwd } = context;
+    const needsAccount = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+        message: 'Do you need to create a consent.io account?',
+        initialValue: true
+    });
+    if (handleCancel?.(needsAccount)) throw new Error('Setup cancelled');
+    if (needsAccount) {
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.note(`We'll open your browser to create a consent.io account and set up your instance.\nFollow these steps:\n1. Sign up for a consent.io account\n2. Create a new instance in the dashboard\n3. Configure your trusted origins (domains that can connect)\n4. Copy the provided backendURL (e.g., https://your-instance.c15t.dev)`, 'consent.io Setup');
+        const shouldOpen = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+            message: 'Open browser to sign up for consent.io?',
+            initialValue: true
+        });
+        if (handleCancel?.(shouldOpen)) throw new Error('Setup cancelled');
+        if (shouldOpen) try {
+            await (0, __WEBPACK_EXTERNAL_MODULE_open__["default"])('https://consent.io/dashboard/register?ref=cli');
+            const enterPressed = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.text({
+                message: 'Press Enter once you have created your instance and have the backendURL'
+            });
+            if (handleCancel?.(enterPressed)) throw new Error('Setup cancelled');
+        } catch (error) {
+            logger.warn('Failed to open browser automatically. Please visit https://consent.io/dashboard/register manually.');
+        }
+    }
+    const backendURLSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.text({
+        message: 'Enter your consent.io instance URL:',
+        placeholder: 'https://your-instance.c15t.dev',
+        initialValue: initialBackendURL,
+        validate: (value)=>{
+            if (!value || '' === value) return 'URL is required';
+            try {
+                const url = new URL(value);
+                if (!url.hostname.endsWith('.c15t.dev')) return 'Please enter a valid *.c15t.dev URL';
+            } catch  {
+                return 'Please enter a valid URL';
+            }
+        }
+    });
+    if (handleCancel?.(backendURLSelection)) throw new Error('Setup cancelled');
+    if (!backendURLSelection || '' === backendURLSelection) {
+        logger.error('A valid consent.io URL is required');
+        throw new Error('A valid consent.io URL is required');
+    }
+    const backendURL = backendURLSelection;
+    const useEnvFileSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+        message: 'Store the backendURL in a .env file? (Recommended, URL is public)',
+        initialValue: true
+    });
+    if (handleCancel?.(useEnvFileSelection)) throw new Error('Setup cancelled');
+    const useEnvFile = useEnvFileSelection;
+    const clientConfigContent = generateClientConfigContent('c15t', backendURL, useEnvFile);
+    const configPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'c15t.config.ts');
+    spinner.start('Creating client configuration file...');
+    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(configPath, clientConfigContent);
+    spinner.stop(formatLogMessage('info', `Client configuration created: ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, configPath))}`));
+    if (useEnvFile) {
+        const envPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, '.env.local');
+        const envExamplePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, '.env.example');
+        spinner.start('Creating environment files...');
+        const envContent = generateEnvFileContent(backendURL);
+        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(envPath, envContent);
+        logger.info(`   - Created environment file: ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, envPath))}`);
+        const envExampleContent = '# c15t Configuration\nNEXT_PUBLIC_C15T_URL=https://your-instance.c15t.dev\n';
+        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(envExamplePath, envExampleContent);
+        logger.info(`   - Created example env file: ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, envExamplePath))}`);
+        spinner.stop(formatLogMessage('info', 'Environment files created.'));
+    }
+    return {
+        clientConfigContent,
+        backendURL,
+        usingEnvFile: useEnvFile
+    };
 }
-function getPathAliases(cwd) {
-  const tsConfigPath = path.join(cwd, "tsconfig.json");
-  if (!fs$1.existsSync(tsConfigPath)) {
-    const jsConfigPath = path.join(cwd, "jsconfig.json");
-    if (!fs$1.existsSync(jsConfigPath)) {
-      return null;
-    }
-    return extractAliasesFromConfigFile(jsConfigPath, cwd);
-  }
-  return extractAliasesFromConfigFile(tsConfigPath, cwd);
+async function setupCustomMode(context, projectRoot, spinner) {
+    const { logger, cwd } = context;
+    const clientConfigContent = generateClientConfigContent('custom');
+    const configPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'c15t.config.ts');
+    spinner.start('Creating client configuration file...');
+    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(configPath, clientConfigContent);
+    spinner.stop(formatLogMessage('info', `Client configuration created: ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, configPath))}`));
+    logger.info(`Remember to implement custom endpoint handlers (see ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, configPath))}).`);
+    return {
+        clientConfigContent
+    };
 }
-function extractAliasesFromConfigFile(configPath, cwd) {
-  try {
-    const configContent = fs$1.readFileSync(configPath, "utf8");
-    const strippedConfigContent = stripJsonComments(configContent);
-    const config = JSON.parse(strippedConfigContent);
-    const { paths = {}, baseUrl = "." } = config.compilerOptions || {};
-    const result = {};
-    const obj = Object.entries(paths);
-    for (const [alias, aliasPaths] of obj) {
-      for (const aliasedPath of aliasPaths) {
-        const resolvedBaseUrl = path.join(cwd, baseUrl);
-        const finalAlias = alias.slice(-1) === "*" ? alias.slice(0, -1) : alias;
-        const finalAliasedPath = aliasedPath.slice(-1) === "*" ? aliasedPath.slice(0, -1) : aliasedPath;
-        result[finalAlias || ""] = path.join(resolvedBaseUrl, finalAliasedPath);
-      }
-    }
-    addSvelteKitEnvModules(result);
-    return result;
-  } catch (error) {
-    logger.warn(`Error parsing config file ${configPath}`, error);
-    return null;
-  }
+async function setupOfflineMode(context, projectRoot, spinner, handleCancel) {
+    const { logger, cwd } = context;
+    const clientConfigContent = generateClientConfigContent('offline', void 0, false);
+    const configPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'c15t.config.ts');
+    spinner.start('Creating client configuration file...');
+    try {
+        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(configPath, clientConfigContent);
+        spinner.stop(formatLogMessage('info', `Client configuration created: ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, configPath))}`));
+    } catch (error) {
+        spinner.stop(formatLogMessage('error', `Failed to create configuration file: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        throw error;
+    } finally{}
+    return {
+        clientConfigContent
+    };
 }
-const jitiOptions = (cwd) => {
-  const alias = getPathAliases(cwd) || {};
-  return {
-    transformOptions: {
-      babel: {
-        presets: [
-          [
-            babelPresetTypescript,
-            {
-              isTSX: true,
-              allExtensions: true
+async function setupSelfHostedMode(context, projectRoot, spinner, handleCancel) {
+    const { logger, cwd } = context;
+    let backendConfigContent = null;
+    const dependencies = [
+        '@c15t/backend'
+    ];
+    const setupBackendSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+        message: 'Set up the backend configuration now?',
+        initialValue: true
+    });
+    if (handleCancel?.(setupBackendSelection)) throw new Error('Setup cancelled');
+    const setupBackend = setupBackendSelection;
+    let adapterChoice = 'memory';
+    if (setupBackend) {
+        const adapterSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.select({
+            message: 'Choose a database adapter:',
+            initialValue: 'kysely-sqlite',
+            options: [
+                {
+                    value: 'kysely-sqlite',
+                    label: 'Kysely (SQLite)',
+                    hint: 'Simple setups/local dev'
+                },
+                {
+                    value: 'kysely-postgres',
+                    label: 'Kysely (PostgreSQL)',
+                    hint: 'Production'
+                },
+                {
+                    value: 'memory',
+                    label: 'Memory',
+                    hint: 'Testing/development only'
+                }
+            ]
+        });
+        if (handleCancel?.(adapterSelection)) throw new Error('Setup cancelled');
+        adapterChoice = adapterSelection;
+        let connectionString;
+        let dbPath;
+        if ('kysely-postgres' === adapterChoice) {
+            const connectionStringSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.text({
+                message: 'Enter PostgreSQL connection string:',
+                placeholder: 'postgresql://user:pass@host:port/db'
+            });
+            if (handleCancel?.(connectionStringSelection)) throw new Error('Setup cancelled');
+            if (!connectionStringSelection || '' === connectionStringSelection) {
+                logger.error('A valid PostgreSQL connection string is required');
+                throw new Error('A valid PostgreSQL connection string is required');
             }
-          ],
-          [babelPresetReact, { runtime: "automatic" }]
-        ]
-      }
-    },
-    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
-    alias
-  };
-};
-function extractOptionsFromConfig(config) {
-  if (config.c15t && typeof config.c15t === "function") {
-    return config.c15t();
-  }
-  if (config.default && typeof config.default === "function") {
-    return config.default();
-  }
-  if (config.c15tInstance && typeof config.c15tInstance === "function") {
-    return config.c15tInstance();
-  }
-  if (config.consent && typeof config.consent === "function") {
-    return config.consent();
-  }
-  return config.c15t?.options || config.default?.options || config.c15tInstance?.options || config.instance?.options || config.consent?.options || config.config?.options || // Also check for direct exports of options objects
-  (config.default && typeof config.default === "object" && "appName" in config.default ? config.default : null) || // Finally check for direct exports of the instance
-  (config.c15t && typeof config.c15t === "object" && "appName" in config.c15t ? config.c15t : null) || null;
-}
-function findDirectories(cwd, patterns) {
-  const results = [];
-  for (const pattern of patterns) {
-    if (pattern.includes("*")) {
-      const [prefix, _] = pattern.split("*");
-      const basePath = path.join(cwd, prefix);
-      try {
-        if (fs$1.existsSync(basePath)) {
-          const entries = fs$1.readdirSync(basePath, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isDirectory()) {
-              results.push(path.join(prefix, entry.name));
+            connectionString = connectionStringSelection;
+        } else if ('kysely-sqlite' === adapterChoice) {
+            const dbPathSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.text({
+                message: 'Enter path for SQLite database file:',
+                placeholder: './db.sqlite',
+                initialValue: './db.sqlite'
+            });
+            if (handleCancel?.(dbPathSelection)) throw new Error('Setup cancelled');
+            if (!dbPathSelection || '' === dbPathSelection) {
+                logger.error('A valid database path is required');
+                throw new Error('A valid database path is required');
             }
-          }
+            dbPath = dbPathSelection;
         }
-      } catch {
-      }
-    } else if (fs$1.existsSync(path.join(cwd, pattern)) && fs$1.statSync(path.join(cwd, pattern)).isDirectory()) {
-      results.push(pattern);
+        backendConfigContent = generateBackendConfigContent(adapterChoice, connectionString, dbPath);
+        const backendConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'c15t.backend.ts');
+        spinner.start('Creating backend configuration file...');
+        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(backendConfigPath, backendConfigContent);
+        spinner.stop(formatLogMessage('info', `Backend configuration created: ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, backendConfigPath))}`));
     }
-  }
-  return results;
-}
-function validateConfig(config) {
-  if (!config) {
-    return false;
-  }
-  return typeof config === "object";
+    const clientConfigContent = generateClientConfigContent('c15t', '/api/c15t', false);
+    const configPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'c15t.config.ts');
+    spinner.start('Creating client configuration file...');
+    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(configPath, clientConfigContent);
+    spinner.stop(formatLogMessage('info', `Client configuration created: ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, configPath))}`));
+    return {
+        clientConfigContent,
+        backendConfigContent,
+        dependencies,
+        adapterChoice
+    };
 }
-async function getConfig({
-  cwd,
-  configPath
-}) {
-  const foundPaths = [];
-  const failedImports = [];
-  try {
-    let configFile = null;
-    if (configPath) {
-      const resolvedPath = path.join(cwd, configPath);
-      try {
-        if (!fs$1.existsSync(resolvedPath)) {
-          throw new C15TError(
-            `Configuration file not found: ${resolvedPath}
-Make sure the path is correct and the file exists.`
-          );
+async function startOnboarding(context, existingConfig) {
+    const { logger, cwd, telemetry } = context;
+    const handleCancel = (value)=>{
+        if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(value)) {
+            telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_EXITED, {
+                reason: 'user_cancelled',
+                stage: 'setup'
+            });
+            context.error.handleCancel('Configuration cancelled.');
+            return true;
         }
-        foundPaths.push(resolvedPath);
-        const { config } = await loadConfig({
-          configFile: resolvedPath,
-          dotenv: true,
-          jitiOptions: jitiOptions(cwd)
+        return false;
+    };
+    const isUpdate = !!existingConfig;
+    logger.info(isUpdate ? 'Starting configuration update...' : 'Starting onboarding process...');
+    telemetry.trackEvent(isUpdate ? telemetry_TelemetryEventName.CONFIG_UPDATED : telemetry_TelemetryEventName.ONBOARDING_STARTED, {
+        isUpdate
+    });
+    telemetry.flushSync();
+    logger.note(isUpdate ? "Let's update your c15t configuration." : `Welcome to c15t! Let's set up your consent management configuration.\nFirst, we'll help you choose the best storage approach for your needs.`, isUpdate ? 'Update Configuration' : 'First time setup');
+    const projectRoot = await detectProjectRoot(cwd);
+    if (projectRoot !== cwd) logger.debug(`Project root identified: ${projectRoot}`);
+    else logger.warn('Could not determine project root, using current directory');
+    const s = __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner();
+    let spinnerActive = false;
+    try {
+        const packageManager = await detectPackageManager(projectRoot);
+        const { framework, hasReact } = await detectFramework(projectRoot);
+        logger.debug(`Detected package manager: ${packageManager}`);
+        if (framework) logger.debug(`Detected framework: ${framework}`);
+        logger.debug(`React detected: ${hasReact}`);
+        telemetry.trackEvent(telemetry_TelemetryEventName.CLI_ENVIRONMENT_DETECTED, {
+            packageManager,
+            framework: framework || 'unknown',
+            hasReact
         });
-        configFile = extractOptionsFromConfig(config);
-        if (!configFile) {
-          throw new C15TError(
-            // biome-ignore lint/style/useTemplate: keep it split so its easier to read
-            `Found config file at ${resolvedPath} but couldn't extract c15t options.
-Make sure you're exporting c15t with one of these patterns:
-- export const c15t = c15tInstance({...})
-- export const consent = c15tInstance({...})
-- export const c15tInstance = c15tInstance({...})
-- export default c15tInstance({...})`
-          );
+        let initialStorageMode;
+        if (isUpdate && existingConfig && 'mode' in existingConfig) {
+            if (isClientOptions(existingConfig)) initialStorageMode = existingConfig.mode;
+            else if (isC15TOptions(existingConfig)) initialStorageMode = 'c15t';
         }
-      } catch (e) {
-        if (fs$1.existsSync(resolvedPath)) {
-          failedImports.push(resolvedPath);
-          if (e instanceof C15TError) {
-            throw e;
-          }
-          throw new C15TError(
-            // biome-ignore lint/style/useTemplate: keep it split so its easier to read
-            `Config file found at ${resolvedPath} but failed to load.
-This usually happens because of import problems:
-- Check for invalid import paths
-- Ensure all dependencies are installed
-- Verify path aliases in tsconfig.json
-
-Error details: ${e instanceof Error ? e.message : String(e)}`
-          );
+        let storageModeSelection;
+        try {
+            storageModeSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.select({
+                message: isUpdate ? `Select storage mode (current: ${initialStorageMode || 'unknown'}):` : 'How would you like to store consent decisions?',
+                initialValue: initialStorageMode || 'c15t',
+                options: [
+                    {
+                        value: 'c15t',
+                        label: 'Hosted c15t (consent.io)',
+                        hint: 'Recommended: Fully managed service'
+                    },
+                    {
+                        value: 'offline',
+                        label: 'Offline Mode',
+                        hint: 'Store in browser, no backend needed'
+                    },
+                    {
+                        value: 'self-hosted',
+                        label: 'Self-Hosted',
+                        hint: 'Run your own c15t backend'
+                    },
+                    {
+                        value: 'custom',
+                        label: 'Custom Implementation',
+                        hint: 'Full control over storage logic'
+                    }
+                ]
+            });
+        } catch (error) {
+            logger.error('Error selecting storage mode:', error);
+            throw error;
         }
-        throw e;
-      }
-    }
-    if (!configFile) {
-      const searchDirs = [""];
-      searchDirs.push(...findDirectories(cwd, monorepoSubdirs));
-      for (const dir of searchDirs) {
-        for (const possiblePath of possiblePaths) {
-          const configPath2 = path.join(dir, possiblePath);
-          const fullPath = path.join(cwd, configPath2);
-          if (!fs$1.existsSync(fullPath)) {
-            continue;
-          }
-          foundPaths.push(fullPath);
-          try {
-            const { config } = await loadConfig({
-              configFile: configPath2,
-              jitiOptions: jitiOptions(cwd)
+        if (handleCancel(storageModeSelection)) return;
+        const storageMode = storageModeSelection;
+        logger.debug(`Selected storage mode: ${storageMode}`);
+        telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_STORAGE_MODE_SELECTED, {
+            storageMode,
+            isUpdate
+        });
+        const dependenciesToAdd = [];
+        let installDepsConfirmed = false;
+        let ranInstall = false;
+        if (hasReact) dependenciesToAdd.push('@c15t/react');
+        else {
+            dependenciesToAdd.push('c15t');
+            if (null === framework) logger.note(`No React framework detected, installing base c15t package.\nIf you're using React, you might need to manually install @c15t/react instead.`, formatLogMessage('warn', 'Package Selection'));
+        }
+        if ('c15t' === storageMode) {
+            let initialBackendURL;
+            if (isUpdate && existingConfig && isClientOptions(existingConfig) && existingConfig.backendURL) initialBackendURL = existingConfig.backendURL;
+            const c15tResult = await setupC15tMode(context, projectRoot, s, initialBackendURL, handleCancel);
+            c15tResult.clientConfigContent;
+            telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_C15T_MODE_CONFIGURED, {
+                usingEnvFile: c15tResult.usingEnvFile,
+                hasInitialBackendURL: !!initialBackendURL
             });
-            if (Object.keys(config).length > 0) {
-              configFile = extractOptionsFromConfig(config);
-              if (configFile && validateConfig(configFile)) {
-                logger.info(`\u2705 Using c15t config from ${fullPath}`);
-                break;
-              }
-            }
-          } catch (e) {
-            if (typeof e === "object" && e && "message" in e && typeof e.message === "string" && e.message.includes(
-              "This module cannot be imported from a Client Component module"
-            )) {
-              throw new C15TError(
-                // biome-ignore lint/style/useTemplate: keep it split so its easier to read
-                `Found config file at ${fullPath}, but it imports 'server-only'.
-Please temporarily remove the 'server-only' import while using the CLI,
-and you can add it back afterwards.`
-              );
+        } else if ('offline' === storageMode) {
+            const offlineResult = await setupOfflineMode(context, projectRoot, s, handleCancel);
+            offlineResult.clientConfigContent;
+            telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_OFFLINE_MODE_CONFIGURED, {});
+        } else if ('self-hosted' === storageMode) {
+            const selfHostedResult = await setupSelfHostedMode(context, projectRoot, s, handleCancel);
+            selfHostedResult.clientConfigContent;
+            selfHostedResult.backendConfigContent;
+            dependenciesToAdd.push(...selfHostedResult.dependencies);
+            telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_SELF_HOSTED_CONFIGURED, {
+                databaseType: selfHostedResult.adapterChoice,
+                dependencies: selfHostedResult.dependencies.join(',')
+            });
+        } else if ('custom' === storageMode) {
+            const customResult = await setupCustomMode(context, projectRoot, s);
+            customResult.clientConfigContent;
+            telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_CUSTOM_MODE_CONFIGURED, {});
+        }
+        let addDeps = false;
+        if (dependenciesToAdd.length > 0) {
+            const depsString = dependenciesToAdd.map((d)=>__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(d)).join(', ');
+            const addDepsSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+                message: `${isUpdate ? 'Update' : 'Add'} required dependencies using ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(packageManager)}? (${depsString})`,
+                initialValue: true
+            });
+            if (handleCancel(addDepsSelection)) return;
+            addDeps = addDepsSelection;
+            telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_DEPENDENCIES_CHOICE, {
+                confirmed: addDeps,
+                dependencies: dependenciesToAdd.join(','),
+                packageManager
+            });
+            if (addDeps) {
+                installDepsConfirmed = true;
+                s.start(`Running ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(packageManager)} to add and install dependencies... (this might take a moment)`);
+                spinnerActive = true;
+                try {
+                    await addAndInstallDependenciesViaPM(projectRoot, dependenciesToAdd, packageManager);
+                    s.stop(`✅ Dependencies installed: ${dependenciesToAdd.map((d)=>__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(d)).join(', ')}`);
+                    spinnerActive = false;
+                    ranInstall = true;
+                    telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_DEPENDENCIES_INSTALLED, {
+                        success: true,
+                        dependencies: dependenciesToAdd.join(','),
+                        packageManager
+                    });
+                } catch (installError) {
+                    s.stop(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].yellow('⚠️ Dependency installation failed.'));
+                    spinnerActive = false;
+                    logger.error('Installation Error:', installError);
+                    telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_DEPENDENCIES_INSTALLED, {
+                        success: false,
+                        error: installError instanceof Error ? installError.message : String(installError),
+                        dependencies: dependenciesToAdd.join(','),
+                        packageManager
+                    });
+                    const pmCommand = getManualInstallCommand(dependenciesToAdd, packageManager);
+                    logger.info(`Please try running '${pmCommand}' manually in ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, projectRoot))}.`);
+                }
             }
-            failedImports.push(fullPath);
-          }
         }
-        if (configFile) {
-          break;
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.log.step('Configuration Complete! Next Steps:');
+        const configPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'c15t.config.ts');
+        const backendConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'c15t.backend.ts');
+        const relativeConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, configPath);
+        const importPath = `./${relativeConfigPath.replace(/\\/g, '/').replace(/\.(ts|js|tsx|jsx)$/, '')}`;
+        const importStatement = __WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(`import { c15tConfig } from '${importPath}';`);
+        switch(storageMode){
+            case 'c15t':
+                {
+                    let steps = '1. Ensure your consent.io instance is configured (trusted origins etc).\n';
+                    try {
+                        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].access(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, '.env.local'));
+                        steps += `      2. Verify ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('NEXT_PUBLIC_C15T_URL')} in ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, '.env.local')))}.\n`;
+                    } catch  {
+                        steps += `      2. Verify ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('backendURL')} in ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(relativeConfigPath)}.\n`;
+                    }
+                    steps += `      3. Import and use configuration in your app: ${importStatement}`;
+                    logger.info(steps);
+                    break;
+                }
+            case 'offline':
+                logger.info(`1. Import and use configuration in your app: ${importStatement}`);
+                break;
+            case 'self-hosted':
+                {
+                    let steps = '';
+                    try {
+                        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].access(backendConfigPath);
+                        steps += `1. Configure database connection in ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, backendConfigPath))}.\n`;
+                        steps += '      2. Set up API routes using the exported backend instance.\n';
+                    } catch  {
+                        steps += '1. Set up your c15t backend instance and API routes.\n';
+                    }
+                    steps += `      3. Ensure ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('backendURL')} in ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(relativeConfigPath)} points to your API.\n`;
+                    steps += `      4. Import and use client configuration: ${importStatement}`;
+                    logger.info(steps);
+                    break;
+                }
+            case 'custom':
+                {
+                    const steps = `1. Implement your custom endpoint handlers (referenced in ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(relativeConfigPath)}).\n      2. Import and use configuration in your app: ${importStatement}`;
+                    logger.info(steps);
+                    break;
+                }
         }
-      }
-    }
-    if (!configFile) {
-      if (foundPaths.length > 0) {
-        logger.error(
-          `\u274C Found ${foundPaths.length} potential config files, but couldn't load any of them:`
-        );
-        for (const filePath of foundPaths.slice(0, 3)) {
-          logger.error(`   - ${filePath}`);
+        if (installDepsConfirmed && !ranInstall) logger.info(`  - ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].yellow('Dependency installation failed.')} Please check errors and install manually.`);
+        else if (!addDeps && dependenciesToAdd.length > 0) {
+            const pmCommand = getManualInstallCommand(dependenciesToAdd, packageManager);
+            logger.warn(`  - Run ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(pmCommand)} to install required dependencies.`);
         }
-        if (foundPaths.length > 3) {
-          logger.error(`   - ...and ${foundPaths.length - 3} more`);
+        logger.note(`${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].bold('✨ Setup complete!')} Your c15t configuration is ready to use. \n
+
+We're building c15t as an ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].bold('open source')} project to make consent management more accessible.
+If you find this useful, we'd really appreciate a GitHub star - it helps others discover the project!`, '🎉 Thanks for using c15t');
+        const shouldOpenGithub = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+            message: 'Would you like to star c15t on GitHub now?',
+            initialValue: true
+        });
+        if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(shouldOpenGithub)) {
+            telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_GITHUB_STAR, {
+                action: 'cancelled'
+            });
+            return context.error.handleCancel('GitHub star prompt cancelled. Exiting onboarding.');
         }
-        if (failedImports.length > 0) {
-          logger.error("\n\u2753 Common issues that prevent loading config files:");
-          logger.error("   - Missing dependencies (check your package.json)");
-          logger.error(
-            "   - Import path issues (check your import statements)"
-          );
-          logger.error(
-            "   - Path alias configuration (check your tsconfig.json)"
-          );
-          logger.error(
-            "   - Export format (make sure you're exporting c15t, c15tInstance, consent, or default)"
-          );
+        telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_GITHUB_STAR, {
+            action: shouldOpenGithub ? 'opened_browser' : 'declined'
+        });
+        if (shouldOpenGithub) try {
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.note('Your support helps us continue improving c15t.\nThank you for being part of our community!', '⭐ Star Us on GitHub');
+            await (0, __WEBPACK_EXTERNAL_MODULE_open__["default"])('https://github.com/c15t/c15t');
+            logger.success('GitHub repository opened. Thank you for your support!');
+        } catch (error) {
+            logger.debug('Failed to open browser:', error);
+            logger.info(`You can star us later by visiting: ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('https://github.com/c15t/c15t')}`);
+        }
+        telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_COMPLETED, {
+            success: true,
+            storageMode,
+            installDependencies: ranInstall
+        });
+        logger.success('🚀 Setup completed successfully!');
+    } catch (error) {
+        if (spinnerActive) s.stop(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].red('Onboarding failed.'));
+        if (!__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(error)) {
+            logger.error('An unexpected error occurred during onboarding:', error);
+            if (error instanceof Error && error.message) logger.error(`Error details: ${error.message}`);
+            logger.failed('Onboarding process could not be completed.');
+            telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_COMPLETED, {
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            });
         }
-        throw new C15TError("Unable to load any c15t configuration file");
-      }
-      logger.error(
-        "\u274C No c15t configuration files found in standard locations"
-      );
-      logger.info("\n\u{1F4DD} Create a c15t.ts file with your configuration:");
-      logger.info(`
-import { c15tInstance } from '@c15t/backend';
-
-export const c15t = c15tInstance({
-  appName: 'My App',
-  basePath: '/api/c15t',
-  // Add your configuration here
-});
-			`);
-      throw new C15TError(
-        "No c15t config file found. Create a c15t.ts file or specify with --config"
-      );
-    }
-    return configFile;
-  } catch (e) {
-    if (typeof e === "object" && e && "message" in e && typeof e.message === "string" && e.message.includes(
-      "This module cannot be imported from a Client Component module"
-    )) {
-      logger.error(
-        "\u274C Server-only import detected in config file\nPlease temporarily remove the 'server-only' import while using the CLI,\nand you can add it back afterwards."
-      );
-      process.exit(1);
-    }
-    if (e instanceof C15TError) {
-      logger.error(`\u274C ${e.message}`);
-    } else {
-      logger.error(`\u274C Couldn't read your c15t configuration`);
-      logger.error(`   Error: ${e instanceof Error ? e.message : String(e)}`);
     }
-    if (failedImports.length > 0) {
-      logger.info(
-        "\n\u{1F4A1} Tip: If you're having import issues, try running with verbose logging:"
-      );
-      logger.info("   DEBUG=c15t* npx c15t@latest <command>");
+}
+async function setupGenerateEnvironment(context) {
+    const { logger, flags, cwd, error, telemetry } = context;
+    logger.debug('Setting up generate environment...');
+    logger.debug('Context flags:', flags);
+    logger.debug(`Context CWD: ${cwd}`);
+    if (!(0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(cwd)) {
+        telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_FAILED, {
+            error: `Directory ${cwd} does not exist`,
+            stage: 'setup'
+        });
+        return error.handleError(new Error(`The directory "${cwd}" does not exist`), 'Generate setup failed');
     }
-    process.exit(1);
-  }
+    logger.debug('Attempting to load configuration...');
+    const config = await context.config.loadConfig();
+    if (!config) {
+        logger.debug('No config found during setup, generate command will handle onboarding.');
+        try {
+            const memAdapter = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__.getAdapter)({
+                appName: 'temp-for-setup',
+                database: {
+                    adapter: 'memory'
+                }
+            });
+            return {
+                config: null,
+                adapter: memAdapter
+            };
+        } catch (adapterError) {
+            telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_FAILED, {
+                error: adapterError instanceof Error ? adapterError.message : String(adapterError),
+                stage: 'adapter_initialization'
+            });
+            return error.handleError(adapterError, 'Failed to initialize default memory adapter');
+        }
+    }
+    logger.debug('Config loaded, initializing adapter...');
+    let adapter;
+    try {
+        adapter = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__.getAdapter)(config);
+        logger.debug('Adapter initialized successfully');
+    } catch (e) {
+        telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_FAILED, {
+            error: e instanceof Error ? e.message : String(e),
+            stage: 'adapter_initialization_with_config'
+        });
+        return error.handleError(e, 'Failed to initialize database adapter');
+    }
+    if (!adapter) {
+        telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_FAILED, {
+            error: 'Adapter initialization returned undefined',
+            stage: 'adapter_initialization_check'
+        });
+        return error.handleError(new Error('Adapter initialization returned undefined'), 'Database adapter could not be initialized');
+    }
+    logger.debug('Environment setup complete');
+    return {
+        config,
+        adapter
+    };
 }
-
-async function generateAction(opts) {
-  const options = z.object({
-    cwd: z.string(),
-    config: z.string().optional(),
-    output: z.string().optional(),
-    y: z.boolean().optional()
-  }).parse(opts);
-  const cwd = path.resolve(options.cwd);
-  if (!existsSync(cwd)) {
-    logger.error(`The directory "${cwd}" does not exist.`);
-    process.exit(1);
-  }
-  const config = await getConfig({
-    cwd,
-    configPath: options.config
-  });
-  if (!config) {
-    logger.error(
-      "No configuration file found. Add a `c15t.ts` file to your project or pass the path to the configuration file using the `--config` flag."
-    );
-    return;
-  }
-  const adapter = await getAdapter(config).catch((e) => {
-    logger.error(e.message);
-    process.exit(1);
-  });
-  const spinner = yoctoSpinner({ text: "preparing schema..." }).start();
-  const schema = await getGenerator({
-    adapter,
-    file: options.output,
-    options: config
-  });
-  spinner.stop();
-  if (!schema.code) {
-    logger.info("Your schema is already up to date.");
-    process.exit(0);
-  }
-  if (schema.append || schema.overwrite) {
-    let confirm2 = options.y;
-    if (!confirm2) {
-      const response = await prompts({
-        type: "confirm",
-        name: "confirm",
-        message: `The file ${schema.fileName} already exists. Do you want to ${chalk.yellow(
-          `${schema.overwrite ? "overwrite" : "append"}`
-        )} the schema to the file?`
-      });
-      confirm2 = response.confirm;
-    }
-    if (confirm2) {
-      const exist = existsSync(path.join(cwd, schema.fileName));
-      if (!exist) {
-        await fs.mkdir(path.dirname(path.join(cwd, schema.fileName)), {
-          recursive: true
+async function generate(context) {
+    const { logger, error, telemetry } = context;
+    logger.debug('Starting generate command...');
+    telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_STARTED, {});
+    const setupResult = await setupGenerateEnvironment(context);
+    let { config, adapter } = setupResult;
+    if (config) {
+        let currentMode = 'unknown';
+        if (isClientOptions(config)) {
+            if (config.mode) currentMode = config.mode;
+        } else if (isC15TOptions(config)) currentMode = 'backend';
+        telemetry.trackEvent(telemetry_TelemetryEventName.CONFIG_LOADED, {
+            type: currentMode,
+            exists: true
+        });
+        const shouldUpdate = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+            message: formatLogMessage('warn', `A c15t configuration already exists. Would you like to update it before generating? (${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].dim(`Current mode: ${currentMode}`)})`),
+            initialValue: false
         });
-      }
-      if (schema.overwrite) {
-        await fs.writeFile(path.join(cwd, schema.fileName), schema.code);
-      } else {
-        await fs.appendFile(path.join(cwd, schema.fileName), schema.code);
-      }
-      logger.success(
-        `\u{1F680} Schema was ${schema.overwrite ? "overwritten" : "appended"} successfully!`
-      );
-      process.exit(0);
+        if (!shouldUpdate) {
+            telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_COMPLETED, {
+                success: false,
+                reason: 'user_cancelled'
+            });
+            return error.handleCancel('Operation cancelled.');
+        }
+        if (shouldUpdate) {
+            await startOnboarding(context, config);
+            logger.debug('Reloading configuration after update...');
+            const postUpdateResult = await setupGenerateEnvironment(context);
+            if (!postUpdateResult.config) {
+                telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_FAILED, {
+                    error: 'Failed to load configuration after update'
+                });
+                return error.handleError(new Error('Failed to load configuration after update.'), 'Configuration Error');
+            }
+            config = postUpdateResult.config;
+            postUpdateResult.adapter;
+            logger.info('Configuration updated successfully.');
+            telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_COMPLETED, {
+                success: true,
+                configUpdated: true
+            });
+        } else {
+            logger.debug('Proceeding with existing configuration.');
+            telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_COMPLETED, {
+                success: true,
+                configUpdated: false
+            });
+        }
     } else {
-      logger.error("Schema generation aborted.");
-      process.exit(1);
+        logger.info('No configuration found.');
+        telemetry.trackEvent(telemetry_TelemetryEventName.CONFIG_LOADED, {
+            exists: false
+        });
+        const shouldOnboard = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+            message: 'No c15t configuration found. Would you like to create one now?',
+            initialValue: true
+        });
+        if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(shouldOnboard) || !shouldOnboard) {
+            telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_COMPLETED, {
+                success: false,
+                reason: 'onboarding_declined'
+            });
+            return error.handleCancel('Configuration setup cancelled.');
+        }
+        await startOnboarding(context);
+        logger.debug('Reloading configuration after onboarding...');
+        const postOnboardResult = await setupGenerateEnvironment(context);
+        if (!postOnboardResult.config) {
+            telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_FAILED, {
+                error: 'Failed to load configuration even after onboarding'
+            });
+            return error.handleError(new Error('Failed to load configuration even after onboarding.'), 'Configuration Error');
+        }
+        config = postOnboardResult.config;
+        postOnboardResult.adapter;
+        logger.info('New configuration loaded successfully.');
+        telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_COMPLETED, {
+            success: true,
+            newConfigCreated: true
+        });
     }
-  }
-  let confirm = options.y;
-  if (!confirm) {
-    const response = await prompts({
-      type: "confirm",
-      name: "confirm",
-      message: `Do you want to generate the schema to ${chalk.yellow(
-        schema.fileName
-      )}?`
+}
+async function executeMigrations(context, runMigrationsFn) {
+    const { logger, telemetry } = context;
+    logger.info('Executing migrations...');
+    const s = __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner();
+    s.start('Running migrations...');
+    telemetry.trackEvent(telemetry_TelemetryEventName.MIGRATION_EXECUTED, {
+        status: 'started'
     });
-    confirm = response.confirm;
-  }
-  if (!confirm) {
-    logger.error("Schema generation aborted.");
-    process.exit(1);
-  }
-  if (!options.output) {
-    const dirExist = existsSync(path.dirname(path.join(cwd, schema.fileName)));
-    if (!dirExist) {
-      await fs.mkdir(path.dirname(path.join(cwd, schema.fileName)), {
-        recursive: true
-      });
+    try {
+        await runMigrationsFn();
+        s.stop('Migrations completed successfully!');
+        logger.success('🚀 Database migrated successfully');
+        telemetry.trackEvent(telemetry_TelemetryEventName.MIGRATION_EXECUTED, {
+            status: 'completed'
+        });
+    } catch (error) {
+        logger.error('Migration failed.');
+        telemetry.trackEvent(telemetry_TelemetryEventName.MIGRATION_EXECUTED, {
+            status: 'failed',
+            error: error instanceof Error ? error.message : String(error)
+        });
+        context.error.handleError(error, 'Error running migrations');
     }
-  }
-  await fs.writeFile(
-    options.output || path.join(cwd, schema.fileName),
-    schema.code
-  );
-  logger.success("\u{1F680} Schema was generated successfully!");
-  process.exit(0);
 }
-const generate = new Command("generate").option(
-  "-c, --cwd <cwd>",
-  "the working directory. defaults to the current directory.",
-  process.cwd()
-).option(
-  "--config <config>",
-  "the path to the configuration file. defaults to the first configuration file found."
-).option("--output <output>", "the file to output to the generated schema").option("-y, --y", "automatically answer yes to all prompts", false).action(generateAction);
-
-async function migrateAction(opts) {
-  const options = z.object({
-    cwd: z.string(),
-    config: z.string().optional(),
-    y: z.boolean().optional()
-  }).parse(opts);
-  const cwd = path.resolve(options.cwd);
-  if (!existsSync(cwd)) {
-    logger.error(`The directory "${cwd}" does not exist.`);
-    process.exit(1);
-  }
-  const config = await getConfig({
-    cwd,
-    configPath: options.config
-  });
-  if (!config) {
-    logger.error(
-      "No configuration file found. Add a `c15t.ts` file to your project or pass the path to the configuration file using the `--config` flag."
-    );
-    return;
-  }
-  const db = await getAdapter(config);
-  if (!db) {
-    logger.error(
-      "Invalid database configuration. Make sure you're not using adapters. Migrate command only works with built-in Kysely adapter."
-    );
-    process.exit(1);
-  }
-  if (db.id !== "kysely") {
-    if (db.id === "prisma") {
-      logger.error(
-        "The migrate command only works with the built-in Kysely adapter. For Prisma, run `npx @c15t/cli generate` to create the schema, then use Prisma\u2019s migrate or push to apply it."
-      );
-      process.exit(0);
-    }
-    if (db.id === "drizzle") {
-      logger.error(
-        "The migrate command only works with the built-in Kysely adapter. For Drizzle, run `npx @c15t/cli generate` to create the schema, then use Drizzle\u2019s migrate or push to apply it."
-      );
-      process.exit(0);
-    }
-    logger.error("Migrate command isn't supported for this adapter.");
-    process.exit(1);
-  }
-  const spinner = yoctoSpinner({ text: "preparing migration..." }).start();
-  const { toBeAdded, toBeCreated, runMigrations } = await getMigrations(config);
-  if (!toBeAdded.length && !toBeCreated.length) {
-    spinner.stop();
-    logger.info("\u{1F680} No migrations needed.");
-    process.exit(0);
-  }
-  spinner.stop();
-  logger.info("\u{1F511} The migration will affect the following:");
-  for (const table of [...toBeCreated, ...toBeAdded]) {
-    console.log(
-      "->",
-      chalk.magenta(Object.keys(table.fields).join(", ")),
-      chalk.white("fields on"),
-      chalk.yellow(`${table.table}`),
-      chalk.white("table.")
-    );
-  }
-  let migrate2 = options.y;
-  if (!migrate2) {
-    const response = await prompts({
-      type: "confirm",
-      name: "migrate",
-      message: "Are you sure you want to run these migrations?",
-      initial: false
+async function planMigrations(context, config, skipConfirmation) {
+    const { logger } = context;
+    logger.info('Planning migrations...');
+    logger.debug('Config:', config);
+    logger.debug(`Skip confirmation: ${skipConfirmation}`);
+    const s = __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner();
+    s.start('Preparing migration plan...');
+    let migrationData;
+    try {
+        migrationData = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_migrations_80b6e3bd__.getMigrations)(config);
+        logger.debug('Migration data:', migrationData);
+    } catch (err) {
+        s.stop('Migration preparation failed.');
+        if (err instanceof Error) logger.error(err.message);
+        else logger.error(String(err));
+        logger.failed('Migration planning failed');
+        return {
+            shouldRun: false,
+            runMigrationsFn: null
+        };
+    }
+    if (!migrationData) {
+        s.stop('Could not retrieve migration data.');
+        logger.failed('Migration planning failed');
+        return {
+            shouldRun: false,
+            runMigrationsFn: null
+        };
+    }
+    const { toBeAdded, toBeCreated, runMigrations } = migrationData;
+    logger.debug('Migrations to be added:', toBeAdded);
+    logger.debug('Migrations to be created:', toBeCreated);
+    if (!toBeAdded.length && !toBeCreated.length) {
+        s.stop('No migrations needed.');
+        logger.info('🚀 Database is up to date');
+        return {
+            shouldRun: false,
+            runMigrationsFn: null
+        };
+    }
+    s.stop('Migration plan prepared.');
+    logger.info('🔑 The following migrations will be applied:');
+    for (const table of [
+        ...toBeCreated,
+        ...toBeAdded
+    ]){
+        const fields = Object.keys(table.fields).join(', ');
+        const tableName = table.table;
+        logger.info(`  + Table ${tableName}: Add fields [${fields}]`);
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.log.message(`  ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('+')} Table ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].yellow(tableName)}: Add fields [${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].green(fields)}]`);
+    }
+    __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.log.message('');
+    let shouldMigrate = skipConfirmation;
+    if (!shouldMigrate) {
+        shouldMigrate = await context.confirm('Apply these migrations to the database?', false);
+        logger.debug(`User confirmation: ${shouldMigrate}`);
+    }
+    if (!shouldMigrate) {
+        logger.failed('Migration cancelled');
+        return {
+            shouldRun: false,
+            runMigrationsFn: null
+        };
+    }
+    logger.debug('Proceeding with migration execution');
+    return {
+        shouldRun: true,
+        runMigrationsFn: runMigrations
+    };
+}
+async function loadConfigAndOnboard(context) {
+    const { logger } = context;
+    logger.debug('Checking for existing configuration...');
+    let config;
+    try {
+        config = await context.config.loadConfig();
+    } catch (error) {
+        return context.error.handleError(error, 'Unexpected error during configuration loading');
+    }
+    if (!config) {
+        logger.info('No config found, starting onboarding.');
+        await startOnboarding(context);
+        logger.debug('Exiting after triggering onboarding.');
+        process.exit(0);
+    }
+    logger.debug('Configuration loaded successfully.');
+    return config;
+}
+function validateAdapterIsKysely(context, adapter) {
+    const { logger, error } = context;
+    logger.debug('Validating adapter:', adapter);
+    if (!adapter || 'kysely' !== adapter.id) {
+        let message = 'Invalid or unsupported database configuration for migrate. Migrate command only works with built-in Kysely adapter.';
+        if (adapter?.id === 'prisma') message = "The migrate command only works with the built-in Kysely adapter. For Prisma, run `npx @c15t/cli generate` to create the schema, then use Prisma's migrate or push to apply it.";
+        else if (adapter?.id === 'drizzle') message = "The migrate command only works with the built-in Kysely adapter. For Drizzle, run `npx @c15t/cli generate` to create the schema, then use Drizzle's migrate or push to apply it.";
+        error.handleError(new Error('Adapter validation failed: Not using Kysely'), message);
+    }
+}
+async function setupEnvironment(context) {
+    const { logger, flags, cwd, error } = context;
+    logger.info('Setting up migration environment...');
+    logger.debug('Flags:', flags);
+    logger.debug(`Working directory: ${cwd}`);
+    if (!(0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(cwd)) return error.handleError(new Error(`The directory "${cwd}" does not exist`), 'Migration setup failed');
+    const config = await loadConfigAndOnboard(context);
+    logger.debug('Config loaded:', config);
+    let adapter;
+    try {
+        logger.debug('Initializing database adapter...');
+        adapter = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__.getAdapter)(config);
+        logger.debug('Adapter initialized:', adapter);
+    } catch (e) {
+        return error.handleError(e, 'Failed to initialize database adapter');
+    }
+    validateAdapterIsKysely(context, adapter);
+    logger.info('✅ Environment setup complete');
+    return {
+        config,
+        adapter: adapter
+    };
+}
+async function migrate(context) {
+    const { logger, flags, telemetry } = context;
+    logger.info('Starting migration process...');
+    logger.debug('Context:', context);
+    telemetry.trackEvent(telemetry_TelemetryEventName.MIGRATION_STARTED, {
+        skipConfirmation: true === flags.y
     });
-    migrate2 = response.migrate;
-  }
-  if (!migrate2) {
-    logger.info("Migration cancelled.");
-    process.exit(0);
-  }
-  spinner?.start("migrating...");
-  await runMigrations();
-  spinner.stop();
-  logger.info("\u{1F680} migration was completed successfully!");
-  process.exit(0);
+    const skipConfirmation = flags.y;
+    try {
+        const { config } = await setupEnvironment(context);
+        const planResult = await planMigrations(context, config, skipConfirmation);
+        logger.debug('Plan result:', planResult);
+        telemetry.trackEvent(telemetry_TelemetryEventName.MIGRATION_PLANNED, {
+            shouldRun: planResult.shouldRun,
+            hasMigrations: !!planResult.runMigrationsFn
+        });
+        if (planResult.shouldRun && planResult.runMigrationsFn) {
+            await executeMigrations(context, planResult.runMigrationsFn);
+            telemetry.trackEvent(telemetry_TelemetryEventName.MIGRATION_COMPLETED, {
+                success: true
+            });
+        } else {
+            logger.debug('Skipping migration execution based on plan result');
+            telemetry.trackEvent(telemetry_TelemetryEventName.MIGRATION_COMPLETED, {
+                success: true,
+                reason: planResult.shouldRun ? 'no_migrations_needed' : 'user_cancelled'
+            });
+        }
+    } catch (error) {
+        telemetry.trackEvent(telemetry_TelemetryEventName.MIGRATION_FAILED, {
+            error: error instanceof Error ? error.message : String(error)
+        });
+        context.error.handleError(error, 'An unexpected error occurred during the migration process');
+    }
 }
-const migrate = new Command("migrate").option(
-  "-c, --cwd <cwd>",
-  "the working directory. defaults to the current directory.",
-  process.cwd()
-).option(
-  "--config <config>",
-  "the path to the configuration file. defaults to the first configuration file found."
-).option(
-  "-y, --y",
-  "automatically accept and run migrations without prompting",
-  false
-).action(migrateAction);
-
-const generateSecret = new Command("secret").action(() => {
-  const secret = Crypto.randomBytes(32).toString("hex");
-  logger.info(`
-Add the following to your .env file: 
-${chalk.gray("# Auth Secret") + chalk.green(`
-C15T_SECRET=${secret}`)}`);
-});
-
-function getPackageInfo() {
-  const packageJsonPath = path.join("package.json");
-  return fs$2.readJSONSync(packageJsonPath);
+async function displayIntro(context, version) {
+    const { logger } = context;
+    logger.info(`${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].bold('Welcome!')} Let's get you set up.`);
+    logger.message('');
+    let figletText = 'c15t';
+    try {
+        figletText = await new Promise((resolve)=>{
+            __WEBPACK_EXTERNAL_MODULE_figlet__["default"].text('c15t', {
+                font: 'Nancyj-Improved',
+                horizontalLayout: 'default',
+                verticalLayout: 'default',
+                width: 80,
+                whitespaceBreak: true
+            }, (err, data)=>{
+                if (err) {
+                    logger.debug('Failed to generate figlet text');
+                    resolve('c15t');
+                } else resolve(data || 'c15t');
+            });
+        });
+    } catch (error) {
+        logger.debug('Error generating figlet text', error);
+    }
+    const customColor = {
+        teal10: (text)=>`\x1b[38;2;10;80;70m${text}\x1b[0m`,
+        teal20: (text)=>`\x1b[38;2;15;100;90m${text}\x1b[0m`,
+        teal30: (text)=>`\x1b[38;2;20;120;105m${text}\x1b[0m`,
+        teal40: (text)=>`\x1b[38;2;25;150;130m${text}\x1b[0m`,
+        teal50: (text)=>`\x1b[38;2;30;170;150m${text}\x1b[0m`,
+        teal75: (text)=>`\x1b[38;2;34;211;187m${text}\x1b[0m`,
+        teal90: (text)=>`\x1b[38;2;45;225;205m${text}\x1b[0m`,
+        teal100: (text)=>`\x1b[38;2;65;235;220m${text}\x1b[0m`
+    };
+    const lines = figletText.split('\n');
+    const coloredLines = lines.map((line, index)=>{
+        const position = index / (lines.length - 1);
+        if (position < 0.1) return customColor.teal10(line);
+        if (position < 0.2) return customColor.teal20(line);
+        if (position < 0.3) return customColor.teal30(line);
+        if (position < 0.4) return customColor.teal40(line);
+        if (position < 0.5) return customColor.teal50(line);
+        if (position < 0.65) return customColor.teal75(line);
+        if (position < 0.8) return customColor.teal90(line);
+        return customColor.teal100(line);
+    });
+    logger.message(coloredLines.join('\n'));
 }
-
-process.on("SIGINT", () => process.exit(0));
-process.on("SIGTERM", () => process.exit(0));
+function createConfigManagement(context) {
+    const { logger, error } = context;
+    return {
+        loadConfig: async ()=>{
+            logger.debug('Attempting to load configuration...');
+            try {
+                const configResult = await getConfig(context);
+                const config = configResult ?? null;
+                logger.debug('Config loading result:', config);
+                if (config) logger.debug('Configuration loaded successfully.');
+                else logger.debug('No configuration found.');
+                return config;
+            } catch (err) {
+                return error.handleError(err, 'Error loading configuration');
+            }
+        },
+        requireConfig: async ()=>{
+            const config = await context.config.loadConfig();
+            if (!config) return error.handleError(new Error('Configuration required but not found'), 'Missing required configuration');
+            return config;
+        },
+        getPathAliases: (configDir)=>{
+            const cwd = configDir || context.cwd;
+            const tsConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'tsconfig.json');
+            const jsConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'jsconfig.json');
+            const configPath = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(tsConfigPath) ? tsConfigPath : __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(jsConfigPath) ? jsConfigPath : null;
+            if (!configPath) return null;
+            try {
+                return extractAliasesFromConfigFile(context, configPath, cwd);
+            } catch (extractError) {
+                logger.warn(`Error extracting path aliases from ${configPath}:`, extractError);
+                return null;
+            }
+        }
+    };
+}
+function stripJsonComments(jsonString) {
+    return jsonString.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g)=>g ? '' : m).replace(/,(?=\s*[}\]])/g, '');
+}
+function extractAliasesFromConfigFile(context, configPath, cwd) {
+    try {
+        const configContent = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(configPath, 'utf8');
+        const strippedConfigContent = stripJsonComments(configContent);
+        const config = JSON.parse(strippedConfigContent);
+        const { paths = {}, baseUrl = '.' } = config.compilerOptions || {};
+        const result = {};
+        const obj = Object.entries(paths);
+        for (const [alias, aliasPaths] of obj)for (const aliasedPath of aliasPaths){
+            const resolvedBaseUrl = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, baseUrl);
+            const finalAlias = '*' === alias.slice(-1) ? alias.slice(0, -1) : alias;
+            const finalAliasedPath = '*' === aliasedPath.slice(-1) ? aliasedPath.slice(0, -1) : aliasedPath;
+            result[finalAlias || ''] = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(resolvedBaseUrl, finalAliasedPath);
+        }
+        if (hasSvelteKit(cwd)) addSvelteKitEnvModules(result);
+        return result;
+    } catch (error) {
+        context.logger.warn(`Error parsing config file ${configPath}`, error);
+        return null;
+    }
+}
+function hasSvelteKit(cwd) {
+    try {
+        const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'package.json');
+        if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(packageJsonPath)) return false;
+        const packageJson = JSON.parse(__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(packageJsonPath, 'utf8'));
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies
+        };
+        return '@sveltejs/kit' in deps;
+    } catch (error) {
+        return false;
+    }
+}
+function addSvelteKitEnvModules(aliases) {
+    aliases['$app/'] = '$app/';
+    aliases['$lib/'] = '$lib/';
+    aliases['$env/'] = '$env/';
+    aliases['$service-worker'] = '$service-worker';
+}
+function createErrorHandlers(context) {
+    const { logger } = context;
+    return {
+        handleError: (error, message)=>{
+            logger.error(message, error);
+            if (error instanceof Error) logger.error(error.message);
+            else logger.error(String(error));
+            logger.failed(`${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].red('Operation failed unexpectedly.')}`);
+            process.exit(1);
+        },
+        handleCancel: (message = 'Operation cancelled.')=>{
+            logger.debug(`Handling cancellation: ${message}`);
+            logger.failed(message);
+            process.exit(0);
+        }
+    };
+}
+function createFileSystem(context) {
+    const { logger, cwd } = context;
+    return {
+        getPackageInfo: ()=>{
+            logger.debug('Reading package.json');
+            const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'package.json');
+            logger.debug(`package.json path: ${packageJsonPath}`);
+            try {
+                const packageInfo = __WEBPACK_EXTERNAL_MODULE_fs_extra_ce68a66b__["default"].readJSONSync(packageJsonPath);
+                logger.debug('Successfully read package.json');
+                return {
+                    name: packageInfo?.name || 'unknown',
+                    version: packageInfo?.version || 'unknown',
+                    ...packageInfo
+                };
+            } catch (error) {
+                logger.error(`Error reading package.json at ${packageJsonPath}:`, error);
+                return {
+                    name: 'unknown',
+                    version: 'unknown'
+                };
+            }
+        }
+    };
+}
+const globalFlags = [
+    {
+        names: [
+            '--help',
+            '-h'
+        ],
+        description: 'Show this help message.',
+        type: 'special',
+        expectsValue: false
+    },
+    {
+        names: [
+            '--version',
+            '-v'
+        ],
+        description: 'Show the CLI version.',
+        type: 'special',
+        expectsValue: false
+    },
+    {
+        names: [
+            '--logger'
+        ],
+        description: 'Set log level (fatal, error, warn, info, debug).',
+        type: 'string',
+        expectsValue: true
+    },
+    {
+        names: [
+            '--config'
+        ],
+        description: 'Specify path to configuration file.',
+        type: 'string',
+        expectsValue: true
+    },
+    {
+        names: [
+            '-y'
+        ],
+        description: 'Skip confirmation prompts (use with caution).',
+        type: 'boolean',
+        expectsValue: false
+    },
+    {
+        names: [
+            '--no-telemetry'
+        ],
+        description: 'Disable telemetry data collection.',
+        type: 'boolean',
+        expectsValue: false
+    }
+];
+function parseCliArgs(rawArgs, commands) {
+    const parsedFlags = {};
+    const potentialCommandArgsAndUndefined = [];
+    let commandName;
+    const commandArgs = [];
+    for (const flag of globalFlags){
+        const primaryName = flag.names[0]?.replace(/^--/, '').replace(/^-/, '');
+        if (primaryName) parsedFlags[primaryName] = 'boolean' === flag.type ? false : void 0;
+    }
+    for(let i = 0; i < rawArgs.length; i++){
+        const arg = rawArgs[i];
+        if ('string' != typeof arg) continue;
+        let argIsFlagOrValue = false;
+        for (const flag of globalFlags)if (flag.names.includes(arg)) {
+            const primaryName = flag.names[0]?.replace(/^--/, '').replace(/^-/, '');
+            if (primaryName) {
+                argIsFlagOrValue = true;
+                if ('boolean' === flag.type) parsedFlags[primaryName] = true;
+                else if (flag.expectsValue) {
+                    const nextArg = rawArgs[i + 1];
+                    if (nextArg && !nextArg.startsWith('-')) {
+                        parsedFlags[primaryName] = nextArg;
+                        i++;
+                    } else __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.log.warn(formatLogMessage('warn', `Flag ${arg} expects a value, but none was found or the next item is a flag.`));
+                } else parsedFlags[primaryName] = true;
+            }
+            break;
+        }
+        if (!argIsFlagOrValue) potentialCommandArgsAndUndefined.push(arg);
+    }
+    const potentialCommandArgs = potentialCommandArgsAndUndefined.filter((arg)=>'string' == typeof arg);
+    commandName = potentialCommandArgs.find((arg)=>commands.some((cmd)=>cmd.name === arg));
+    for (const arg of potentialCommandArgs)if (arg !== commandName) commandArgs.push(arg);
+    return {
+        commandName,
+        commandArgs,
+        parsedFlags
+    };
+}
+function createUserInteraction(context) {
+    const { logger, error } = context;
+    return {
+        confirm: async (message, initialValue)=>{
+            logger.debug(`Confirm action: "${message}", Initial: ${initialValue}`);
+            const confirmed = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+                message,
+                initialValue
+            });
+            if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(confirmed)) {
+                error.handleCancel();
+                return false;
+            }
+            logger.debug(`Confirmation result: ${confirmed}`);
+            return confirmed;
+        }
+    };
+}
+function createCliContext(rawArgs, cwd, commands) {
+    const { commandName, commandArgs, parsedFlags } = parseCliArgs(rawArgs, commands);
+    let desiredLogLevel = 'info';
+    const levelArg = parsedFlags.logger;
+    if ('string' == typeof levelArg) if (validLogLevels.includes(levelArg)) desiredLogLevel = levelArg;
+    else console.warn(`[CLI Setup] Invalid log level '${levelArg}' provided via --logger. Using default 'info'.`);
+    else if (true === levelArg) console.warn("[CLI Setup] --logger flag found but no level specified. Using default 'info'.");
+    const logger = createCliLogger(desiredLogLevel);
+    logger.debug(`Logger initialized with level: ${desiredLogLevel}`);
+    const baseContext = {
+        logger,
+        flags: parsedFlags,
+        commandName,
+        commandArgs,
+        cwd
+    };
+    const context = baseContext;
+    context.error = createErrorHandlers(context);
+    const userInteraction = createUserInteraction(context);
+    context.confirm = userInteraction.confirm;
+    context.config = createConfigManagement(context);
+    context.fs = createFileSystem(context);
+    const telemetryDisabled = true === parsedFlags['no-telemetry'];
+    context.telemetry = createTelemetry({
+        disabled: telemetryDisabled,
+        defaultProperties: {
+            cliVersion: context.fs.getPackageInfo().version
+        },
+        logger: context.logger
+    });
+    context.telemetry.setLogLevel(desiredLogLevel);
+    if (telemetryDisabled) logger.debug('Telemetry is disabled by user preference');
+    else logger.debug('Telemetry initialized');
+    logger.debug('CLI context fully initialized with all utilities');
+    return context;
+}
+const src_commands = [
+    {
+        name: 'generate',
+        label: 'generate',
+        hint: 'Generate schema/code',
+        description: 'Generate schema/code based on your c15t config.',
+        action: (context)=>generate(context)
+    },
+    {
+        name: 'migrate',
+        label: 'migrate',
+        hint: 'Run database migrations',
+        description: 'Run database migrations based on your c15t config.',
+        action: (context)=>migrate(context)
+    },
+    {
+        name: 'github',
+        label: 'Github',
+        hint: 'Star us on GitHub',
+        description: 'Open our GitHub repository to give us a star.',
+        action: async (context)=>{
+            const { logger } = context;
+            logger.note(`We're building c15t as an ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].bold('open source')} project to make consent management more accessible.\nIf you find this useful, we'd really appreciate a GitHub star - it helps others discover the project!`, '⭐ Star Us on GitHub');
+            await (0, __WEBPACK_EXTERNAL_MODULE_open__["default"])('https://github.com/c15t/c15t');
+            logger.success('Thank you for your support!');
+        }
+    },
+    {
+        name: 'docs',
+        label: 'c15t docs',
+        hint: 'Open documentation',
+        description: 'Open the c15t documentation in your browser.',
+        action: async (context)=>{
+            const { logger } = context;
+            await (0, __WEBPACK_EXTERNAL_MODULE_open__["default"])('https://c15t.com/docs?ref=cli');
+            logger.success('Documentation opened in your browser.');
+        }
+    }
+];
 async function main() {
-  const program = new Command("c15t");
-  const packageInfo = await getPackageInfo();
-  program.addCommand(migrate).addCommand(generate).addCommand(generateSecret).version(packageInfo.version || "1.1.2").description("c15t CLI");
-  program.parse();
+    const rawArgs = process.argv.slice(2);
+    const cwd = process.cwd();
+    const context = createCliContext(rawArgs, cwd, src_commands);
+    const { logger, flags, commandName, commandArgs, error, telemetry } = context;
+    const packageInfo = context.fs.getPackageInfo();
+    const version = packageInfo.version;
+    if (!telemetry.isDisabled()) logger.note(`c15t collects anonymous usage data to help improve the CLI. 
+This data is not personally identifiable and helps us prioritize features.
+To disable telemetry, use the ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('--no-telemetry')}
+flag or set ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('C15T_TELEMETRY_DISABLED=1')} in your environment.`, `${formatLogMessage('info', 'Telemetry Notice')}`);
+    try {
+        telemetry.trackEvent(telemetry_TelemetryEventName.CLI_INVOKED, {
+            version,
+            nodeVersion: process.version,
+            platform: process.platform
+        });
+        telemetry.flushSync();
+    } catch (error) {
+        logger.debug('Failed to track CLI invocation:', error);
+    }
+    if (flags.version) {
+        logger.debug('Version flag detected');
+        logger.message(`c15t CLI version ${version}`);
+        telemetry.trackEvent(telemetry_TelemetryEventName.VERSION_DISPLAYED, {
+            version
+        });
+        telemetry.flushSync();
+        await telemetry.shutdown();
+        process.exit(0);
+    }
+    if (flags.help) {
+        logger.debug('Help flag detected. Displaying help and exiting.');
+        telemetry.trackEvent(telemetry_TelemetryEventName.HELP_DISPLAYED, {
+            version
+        });
+        telemetry.flushSync();
+        showHelpMenu(context, version, src_commands, globalFlags);
+        await telemetry.shutdown();
+        process.exit(0);
+    }
+    logger.debug('Raw process arguments:', process.argv);
+    logger.debug('Parsed command name:', commandName);
+    logger.debug('Parsed command args:', commandArgs);
+    logger.debug('Parsed global flags:', flags);
+    await displayIntro(context, version);
+    logger.debug(`Current working directory: ${cwd}`);
+    logger.debug(`Config path flag: ${flags.config}`);
+    let clientConfig;
+    let backendConfig;
+    try {
+        const loadedConfig = await getConfig(context);
+        if (loadedConfig) if (isClientOptions(loadedConfig)) clientConfig = loadedConfig;
+        else if (isC15TOptions(loadedConfig)) backendConfig = loadedConfig;
+        else logger.warn('Loaded configuration is of an unknown type.');
+        if (loadedConfig) telemetry.trackEvent(telemetry_TelemetryEventName.CONFIG_LOADED, {
+            configType: clientConfig ? 'client' : backendConfig ? 'backend' : 'unknown',
+            hasBackend: Boolean(backendConfig)
+        });
+    } catch (loadError) {
+        telemetry.trackEvent(telemetry_TelemetryEventName.CONFIG_ERROR, {
+            error: loadError instanceof Error ? loadError.message : String(loadError)
+        });
+        return error.handleError(loadError, 'An unexpected error occurred during configuration loading');
+    }
+    if (!clientConfig) {
+        telemetry.trackEvent(telemetry_TelemetryEventName.ONBOARDING_STARTED, {});
+        await startOnboarding(context);
+        await telemetry.shutdown();
+        return;
+    }
+    const coloredConsentIo = __WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyanBright('consent.io');
+    const backendStatus = backendConfig ? 'Backend configuration loaded' : `Using ${coloredConsentIo} for your c15t deployment`;
+    logger.info(`Client configuration successfully loaded and validated \n        ${backendStatus}`);
+    logger.debug('Client config details:', clientConfig);
+    if (backendConfig) logger.debug('Backend config details:', backendConfig);
+    try {
+        if (commandName) {
+            const command = src_commands.find((cmd)=>cmd.name === commandName);
+            if (command) {
+                logger.info(`Executing command: ${command.name}`);
+                telemetry.trackCommand(command.name, commandArgs, flags);
+                await command.action(context);
+                telemetry.trackEvent(telemetry_TelemetryEventName.COMMAND_SUCCEEDED, {
+                    command: command.name,
+                    executionTime: Date.now() - performance.now()
+                });
+                telemetry.flushSync();
+            } else {
+                logger.error(`Unknown command: ${commandName}`);
+                telemetry.trackEvent(telemetry_TelemetryEventName.COMMAND_UNKNOWN, {
+                    unknownCommand: commandName
+                });
+                telemetry.flushSync();
+                logger.info('Run c15t --help to see available commands.');
+                await telemetry.shutdown();
+                process.exit(1);
+            }
+        } else {
+            logger.debug('No command specified, entering interactive selection.');
+            telemetry.trackEvent(telemetry_TelemetryEventName.INTERACTIVE_MENU_OPENED, {});
+            const promptOptions = src_commands.map((cmd)=>({
+                    value: cmd.name,
+                    label: cmd.label,
+                    hint: cmd.hint
+                }));
+            promptOptions.push({
+                value: 'exit',
+                label: 'exit',
+                hint: 'Close the CLI'
+            });
+            const selectedCommandName = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.select({
+                message: formatLogMessage('info', 'Which command would you like to run?'),
+                options: promptOptions
+            });
+            if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(selectedCommandName) || 'exit' === selectedCommandName) {
+                logger.debug('Interactive selection cancelled or exit chosen.');
+                telemetry.trackEvent(telemetry_TelemetryEventName.INTERACTIVE_MENU_EXITED, {
+                    action: __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(selectedCommandName) ? 'cancelled' : 'exit'
+                });
+                context.error.handleCancel('Operation cancelled.');
+            } else {
+                const selectedCommand = src_commands.find((cmd)=>cmd.name === selectedCommandName);
+                if (selectedCommand) {
+                    logger.debug(`User selected command: ${selectedCommand.name}`);
+                    telemetry.trackCommand(selectedCommand.name, [], flags);
+                    await selectedCommand.action(context);
+                    telemetry.trackEvent(telemetry_TelemetryEventName.COMMAND_SUCCEEDED, {
+                        command: selectedCommand.name,
+                        executionTime: Date.now() - performance.now()
+                    });
+                    telemetry.flushSync();
+                } else {
+                    telemetry.trackEvent(telemetry_TelemetryEventName.COMMAND_UNKNOWN, {
+                        unknownCommand: String(selectedCommandName)
+                    });
+                    telemetry.flushSync();
+                    error.handleError(new Error(`Command '${selectedCommandName}' not found`), 'An internal error occurred');
+                }
+            }
+        }
+        logger.debug('Command execution completed');
+        telemetry.trackEvent(telemetry_TelemetryEventName.CLI_COMPLETED, {
+            success: true
+        });
+        telemetry.flushSync();
+    } catch (executionError) {
+        telemetry.trackEvent(telemetry_TelemetryEventName.COMMAND_FAILED, {
+            command: commandName,
+            error: executionError instanceof Error ? executionError.message : String(executionError)
+        });
+        telemetry.flushSync();
+        error.handleError(executionError, 'An unexpected error occurred during command execution');
+    }
+    await telemetry.shutdown();
 }
 main();
+export { main };