@c15t/cli 0.0.1-rc.24 → 1.0.0

package/dist/index.mjs

@@ -1,424 +1,83 @@
 #!/usr/bin/env node
-import * as __WEBPACK_EXTERNAL_MODULE_commander__ from "commander";
-import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
+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__c15t_backend_pkgs_db_adapters_cee37d0f__ from "@c15t/backend/pkgs/db-adapters";
-import * as __WEBPACK_EXTERNAL_MODULE_chalk__ from "chalk";
-import * as __WEBPACK_EXTERNAL_MODULE_prompts__ from "prompts";
-import * as __WEBPACK_EXTERNAL_MODULE_yocto_spinner_579f0326__ from "yocto-spinner";
-import * as __WEBPACK_EXTERNAL_MODULE_zod__ from "zod";
-import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_logger_44a195c6__ from "@c15t/backend/pkgs/logger";
-import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_schema_4fae43f5__ from "@c15t/backend/schema";
-import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_migrations_80b6e3bd__ from "@c15t/backend/pkgs/migrations";
-import * as __WEBPACK_EXTERNAL_MODULE__mrleebo_prisma_ast_c5b328aa__ from "@mrleebo/prisma-ast";
-import * as __WEBPACK_EXTERNAL_MODULE__babel_preset_react_76cf724d__ from "@babel/preset-react";
-import * as __WEBPACK_EXTERNAL_MODULE__babel_preset_typescript_a7789c85__ from "@babel/preset-typescript";
-import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__ from "@c15t/backend/pkgs/results";
 import * as __WEBPACK_EXTERNAL_MODULE_c12__ from "c12";
-import "dotenv/config";
+import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_logger_44a195c6__ from "@c15t/backend/pkgs/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";
-const logger = (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_logger_44a195c6__.createLogger)({
-    level: 'info',
-    appName: 'c15t'
-});
-const utils_logger = logger;
-function convertToSnakeCase(str) {
-    if (null == str) return '';
-    return str.replace(/[A-Z]/g, (letter)=>`_${letter.toLowerCase()}`);
-}
-const generateDrizzleSchema = async ({ options, file, adapter })=>{
-    const tables = (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_schema_4fae43f5__.getConsentTables)(options);
-    const filePath = file || './auth-schema.ts';
-    const databaseType = adapter.options?.provider;
-    const usePlural = adapter.options?.usePlural;
-    const timestampAndBoolean = 'sqlite' !== databaseType ? 'timestamp, boolean' : '';
-    const int = 'mysql' === databaseType ? 'int' : 'integer';
-    const hasBigint = Object.values(tables).some((table)=>Object.values(table.fields).some((field)=>'bigint' in field && field.bigint));
-    const bigint = 'sqlite' !== databaseType ? 'bigint' : '';
-    const text = 'mysql' === databaseType ? '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 = (0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(filePath);
-    let isFirstTable = true;
-    for(const table in tables)if (Object.prototype.hasOwnProperty.call(tables, table)) {
-        const tableDefinition = tables[table];
-        if (!tableDefinition) continue;
-        let modelName = usePlural ? `${tableDefinition.modelName}s` : tableDefinition.modelName;
-        if (!modelName) modelName = table;
-        const fields = tableDefinition.fields;
-        function getMySQLStringType(field, name) {
-            if (field.unique) return `varchar('${name}', { length: 255 })`;
-            if (field.references) return `varchar('${name}', { length: 36 })`;
-            return `text('${name}')`;
-        }
-        function getType(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}')`
-                },
-                json: {
-                    sqlite: `text('${snakeCaseName}')`,
-                    pg: `json('${snakeCaseName}')`,
-                    mysql: `json('${snakeCaseName}')`
-                }
-            };
-            if (!typeMap[type]) return `text('${snakeCaseName}')`;
-            const dbType = databaseType && [
-                'sqlite',
-                'pg',
-                'mysql'
-            ].includes(databaseType) ? databaseType : 'sqlite';
-            return typeMap[type][dbType];
-        }
-        const id = 'mysql' === databaseType ? 'varchar("id", { length: 36 }).primaryKey()' : 'text("id").primaryKey()';
-        const tableNameForSQL = convertToSnakeCase(modelName);
-        if (isFirstTable) {
-            code += '\n\n';
-            isFirstTable = false;
-        } else code += '\n\n';
-        const fieldDefinitions = Object.keys(fields).map((field)=>{
-            if (Object.prototype.hasOwnProperty.call(fields, field)) {
-                const attr = fields[field];
-                if (!attr) return '';
-                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' })` : ''}`;
-            }
-            return '';
-        }).filter(Boolean).join(',\n');
-        const schema = [
-            `export const ${modelName} = ${databaseType}Table("${tableNameForSQL}", {`,
-            `  id: ${id},`,
-            fieldDefinitions,
-            '});'
-        ].join('\n');
-        code += schema;
+function isC15TOptions(obj) {
+    return 'object' == typeof obj && null !== obj && 'appName' in obj;
+}
+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 {
-        code: 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 = 'pg' === databaseType ? '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;
-                if (!columnsStr) return `${statement.trim()};`;
-                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 ('postgresql' === dbType) 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 ('mysql' === dbType) 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 ('sqlite' === dbType) 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}" (\n${formattedColumns}\n);`;
-            }
-        }
-        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 = 'd1' !== dbType;
-    let transactionStart = '';
-    if (useTransactions) transactionStart = 'mysql' === dbType ? 'START TRANSACTION;' : 'BEGIN;';
-    const transactionEnd = useTransactions ? 'COMMIT;' : '';
-    const timestamp = options?.timestamp || 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
-
-${transactionStart}
--- MIGRATION
-${formattedStatements}
-${transactionEnd}
-
--- ROLLBACK
--- Uncomment the section below to roll back this migration
-/*
-${transactionStart}
-
-${rollbackStatements.join(';\n\n')};\n
-${transactionEnd}
-*/`;
-}
-const generateMigrations = async ({ options, file, adapter })=>{
-    const { compileMigrations } = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_migrations_80b6e3bd__.getMigrations)(options);
-    const migrations = await compileMigrations();
-    let databaseType = 'sqlite';
-    if (adapter?.options?.provider) databaseType = adapter.options.provider;
-    else {
-        const dbOptions = options.database?.options;
-        if (dbOptions?.provider) databaseType = dbOptions.provider;
-    }
-    const isTest = 'test' === process.env.NODE_ENV || 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
-    };
-};
-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 = (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_schema_4fae43f5__.getConsentTables)(options);
-    const filePath = file || './prisma/schema.prisma';
-    const schemaPrismaExist = (0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(process.cwd(), filePath));
-    let schemaPrisma = '';
-    schemaPrisma = schemaPrismaExist ? await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].readFile(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(process.cwd(), filePath), 'utf-8') : getNewPrisma(provider);
-    const manyToManyRelations = 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, new Set());
-                manyToManyRelations.get(referencedModel)?.add(capitalizeFirstLetter(table));
-            }
-        }
+    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;
     }
-    const schema = (0, __WEBPACK_EXTERNAL_MODULE__mrleebo_prisma_ast_c5b328aa__.produceSchema)(schemaPrisma, (builder)=>{
-        function getPrismaType(type, isOptional, isBigint) {
-            const isJsonField = 'json' === type || 'jsonb' === type;
-            if (isJsonField) {
-                if ('postgresql' === provider || 'mysql' === provider) return isOptional ? 'Json?' : 'Json';
-                return isOptional ? 'String?' : 'String @map("json_as_text")';
-            }
-            if ('string' === type) return isOptional ? 'String?' : 'String';
-            if ('number' === type && isBigint) return isOptional ? 'BigInt?' : 'BigInt';
-            if ('number' === type) return isOptional ? 'Int?' : 'Int';
-            if ('boolean' === type) return isOptional ? 'Boolean?' : 'Boolean';
-            if ('date' === type) return isOptional ? 'DateTime?' : 'DateTime';
-            if ('string[]' === type) return 'String[]';
-            if ('number[]' === type) 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 ('mongodb' === provider) builder.model(modelName).field('id', 'String').attribute('id').attribute('map("_id")');
-            else builder.model(modelName).field('id', 'String').attribute('id');
-            for(const field in fields)if (Object.hasOwn(fields, field)) {
-                const attr = fields[field];
-                const existingField = builder.findByType('field', {
-                    name: field,
-                    within: prismaModel?.properties
-                });
-                if (existingField) continue;
-                if (!attr) 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)`);
-                if (!attr.unique && !attr.references && 'mysql' === provider && 'string' === attr.type) builder.model(modelName).field(field).attribute('db.Text');
-            }
-            if (originalTable && originalTable !== modelName) {
-                const hasMapAttribute = builder.findByType('attribute', {
-                    name: 'map',
-                    within: prismaModel?.properties
-                });
-                if (!hasMapAttribute) builder.model(modelName).blockAttribute('map', originalTable);
-            }
-        }
-        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}[]`);
-            }
-        }
-    });
-    return {
-        code: schema.trim() === schemaPrisma.trim() ? '' : schema,
-        fileName: filePath
-    };
-};
-const getNewPrisma = (provider)=>`generator client {
-    provider = "prisma-client-js"
-  }
-  
-  datasource db {
-    provider = "${provider}"
-    url      = ${'sqlite' === provider ? '"file:./dev.db"' : 'env("DATABASE_URL")'}
-  }`;
-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) {
-        utils_logger.error(`${adapter.id} is not supported.`);
-        process.exit(1);
-    }
-    return generator(opts);
-};
-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
-  `;
-}
-function filterPrivateEnv(publicPrefix, privatePrefix) {
-    return Object.fromEntries(Object.entries(process.env).filter(([k])=>k.startsWith(privatePrefix) && ('' === publicPrefix || !k.startsWith(publicPrefix))));
-}
-function filterPublicEnv(publicPrefix, privatePrefix) {
-    return Object.fromEntries(Object.entries(process.env).filter(([k])=>k.startsWith(publicPrefix) && ('' === privatePrefix || !k.startsWith(privatePrefix))));
-}
-const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-const reserved = 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'
-]);
+    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 extensions = [
+const constants_extensions = [
     '.js',
     '.jsx',
     '.ts',
@@ -436,7 +95,7 @@ const extensions = [
     '.server.ts',
     '.server.tsx'
 ];
-let possiblePaths = configFileNames.flatMap((name)=>extensions.map((ext)=>`${name}${ext}`));
+let possiblePaths = configFileNames.flatMap((name)=>constants_extensions.map((ext)=>`${name}${ext}`));
 const directories = [
     '',
     'lib/server/',
@@ -448,65 +107,9 @@ const directories = [
     '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, '');
-}
-function getPathAliases(cwd) {
-    const tsConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'tsconfig.json');
-    if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(tsConfigPath)) {
-        const jsConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'jsconfig.json');
-        if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(jsConfigPath)) return null;
-        return extractAliasesFromConfigFile(jsConfigPath, cwd);
-    }
-    return extractAliasesFromConfigFile(tsConfigPath, cwd);
-}
-function extractAliasesFromConfigFile(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);
-        }
-        addSvelteKitEnvModules(result);
-        return result;
-    } catch (error) {
-        utils_logger.warn(`Error parsing config file ${configPath}`, error);
-        return null;
-    }
-}
-const jitiOptions = (cwd)=>{
-    const alias = getPathAliases(cwd) || {};
+const jitiOptions = (context, cwd)=>{
+    const alias = context.config.getPathAliases(cwd) || {};
     return {
-        transformOptions: {
-            babel: {
-                presets: [
-                    [
-                        __WEBPACK_EXTERNAL_MODULE__babel_preset_typescript_a7789c85__["default"],
-                        {
-                            isTSX: true,
-                            allExtensions: true
-                        }
-                    ],
-                    [
-                        __WEBPACK_EXTERNAL_MODULE__babel_preset_react_76cf724d__["default"],
-                        {
-                            runtime: 'automatic'
-                        }
-                    ]
-                ]
-            }
-        },
         extensions: [
             '.ts',
             '.tsx',
@@ -520,332 +123,1875 @@ const jitiOptions = (cwd)=>{
         alias
     };
 };
-function extractOptionsFromConfig(config) {
-    if (config.c15t && 'function' == typeof config.c15t) return config.c15t;
-    if (config.default && 'function' == typeof config.default) return config.default;
-    if (config.c15tInstance && 'function' == typeof config.c15tInstance) return config.c15tInstance;
-    if (config.consent && 'function' == typeof config.consent) return config.consent;
-    return config.c15t?.options || config.default?.options || config.c15tInstance?.options || config.instance?.options || config.consent?.options || config.config?.options || (config.default && 'object' == typeof config.default && 'appName' in config.default ? config.default : null) || (config.c15t && 'object' == typeof config.c15t && '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('*');
-        if (prefix) {
-            const basePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, prefix);
+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;
+            }
+        }
+    };
+    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;
+            }
+        }
+        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 {
-                if (__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(basePath)) {
-                    const entries = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readdirSync(basePath, {
-                        withFileTypes: true
-                    });
-                    for (const entry of entries)if (entry.isDirectory()) results.push(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(prefix, entry.name));
+                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  {}
+            } catch (importError) {
+                logger.debug('Error importing module directly:', importError);
+            }
+            return null;
         }
-    } else if (__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, pattern)) && __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].statSync(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, pattern)).isDirectory()) results.push(pattern);
-    return results;
+        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;
+    }
 }
-function validateConfig(config) {
-    if (!config) return false;
-    return 'object' == typeof config;
+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}
+
+Available Commands:
+${commandLines}
+
+Options:
+${optionLines}
+
+Run a command directly (e.g., ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('c15t generate')}) or select one interactively when no command is provided.
+
+For more help, visit: https://c15t.dev`;
+    logger.debug('Help menu content generated.');
+    logger.note(helpContent, 'Usage');
 }
-async function getConfig({ cwd, configPath }) {
-    const foundPaths = [];
-    const failedImports = [];
-    try {
-        let configFile = null;
-        if (configPath) {
-            const resolvedPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, configPath);
+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')}`;
+};
+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}`;
+            }
+    }
+};
+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__c15t_backend_pkgs_logger_44a195c6__.createLogger)({
+        level,
+        appName: 'c15t',
+        log: (logLevel, message, ...args)=>{
+            logMessage(logLevel, message, ...args);
+        }
+    });
+    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';
+    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.distinctId = this.generateAnonymousId();
+        if (this.disabled) {
+            if (!hasValidApiKey) console.debug('Telemetry disabled: No API key provided');
+        } else this.initClient(options?.client);
+    }
+    trackEvent(eventName, properties = {}) {
+        if (this.disabled || !this.client) return;
+        const safeProperties = {};
+        for (const [key, value] of Object.entries(properties))if ('config' !== key && void 0 !== value) safeProperties[key] = value;
+        this.client.capture({
+            distinctId: this.distinctId,
+            event: eventName,
+            properties: {
+                ...this.defaultProperties,
+                ...safeProperties,
+                timestamp: new Date().toISOString()
+            }
+        });
+    }
+    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.client.debug(true);
+    }
+    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;
+        }
+    }
+    initClient(customClient) {
+        if (customClient) this.client = customClient;
+        else {
+            if (!this.apiKey || '' === this.apiKey.trim()) {
+                this.disabled = true;
+                console.debug('Telemetry disabled: No API key provided');
+                return;
+            }
             try {
-                if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(resolvedPath)) throw new __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError(`Configuration file not found: ${resolvedPath}\nMake sure the path is correct and the file exists.`, {
-                    code: 'CONFIG_FILE_NOT_FOUND',
-                    status: 404,
-                    category: 'CONFIG_FILE_NOT_FOUND'
+                this.client = new __WEBPACK_EXTERNAL_MODULE_posthog_node_1b07bdf4__.PostHog(this.apiKey, {
+                    host: 'https://eu.i.posthog.com',
+                    flushInterval: 0
                 });
-                foundPaths.push(resolvedPath);
-                const { config } = await (0, __WEBPACK_EXTERNAL_MODULE_c12__.loadConfig)({
-                    configFile: resolvedPath,
-                    dotenv: true,
-                    jitiOptions: jitiOptions(cwd)
-                });
-                configFile = extractOptionsFromConfig(config);
-                if (!configFile) throw new __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError(`Found config file at ${resolvedPath} but couldn't extract c15t options.\nMake sure you're exporting c15t with one of these patterns:\n- export const c15t = c15tInstance({...})\n- export const consent = c15tInstance({...})\n- export const c15tInstance = c15tInstance({...})\n- export default c15tInstance({...})`, {
-                    code: 'CONFIG_FILE_LOAD_ERROR',
-                    status: 500,
-                    category: 'CONFIG_FILE_LOAD_ERROR'
-                });
-            } catch (e) {
-                if (__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(resolvedPath)) {
-                    failedImports.push(resolvedPath);
-                    if (e instanceof __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError) throw e;
-                    throw new __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError(`Config file found at ${resolvedPath} but failed to load.\nThis usually happens because of import problems:\n- Check for invalid import paths\n- Ensure all dependencies are installed\n- Verify path aliases in tsconfig.json\n\nError details: ${e instanceof Error ? e.message : String(e)}`, {
-                        code: 'CONFIG_FILE_LOAD_ERROR',
-                        status: 500,
-                        category: 'CONFIG_FILE_LOAD_ERROR',
-                        cause: e instanceof Error ? e : new Error(String(e))
-                    });
-                }
-                throw e;
+            } catch (error) {
+                this.disabled = true;
+                console.debug('Telemetry disabled due to initialization error:', error);
             }
         }
-        if (!configFile) {
-            const searchDirs = [
-                ''
+    }
+    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;
+    }
+}
+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
             ];
-            searchDirs.push(...findDirectories(cwd, monorepoSubdirs));
-            for (const dir of searchDirs){
-                for (const possiblePath of possiblePaths){
-                    const configPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(dir, possiblePath);
-                    const fullPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, configPath);
-                    if (__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(fullPath)) {
-                        foundPaths.push(fullPath);
-                        try {
-                            const { config } = await (0, __WEBPACK_EXTERNAL_MODULE_c12__.loadConfig)({
-                                configFile: configPath,
-                                jitiOptions: jitiOptions(cwd)
-                            });
-                            if (Object.keys(config).length > 0) {
-                                configFile = extractOptionsFromConfig(config);
-                                if (configFile && validateConfig(configFile)) {
-                                    utils_logger.info(`✅ Using c15t config from ${fullPath}`);
-                                    break;
-                                }
-                            }
-                        } catch (e) {
-                            if ('object' == typeof e && e && 'message' in e && 'string' == typeof e.message && e.message.includes('This module cannot be imported from a Client Component module')) throw new __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError(`Found config file at ${fullPath}, but it imports 'server-only'.\nPlease temporarily remove the 'server-only' import while using the CLI,\nand you can add it back afterwards.`, {
-                                code: 'SERVER_ONLY_IMPORT_DETECTED',
-                                status: 500,
-                                category: 'SERVER_ONLY_IMPORT_DETECTED'
-                            });
-                            failedImports.push(fullPath);
-                        }
-                    }
-                }
-                if (configFile) break;
-            }
+            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 (!configFile) {
-            if (foundPaths.length > 0) {
-                utils_logger.error(`❌ Found ${foundPaths.length} potential config files, but couldn't load any of them:`);
-                for (const filePath of foundPaths.slice(0, 3))utils_logger.error(`   - ${filePath}`);
-                if (foundPaths.length > 3) utils_logger.error(`   - ...and ${foundPaths.length - 3} more`);
-                if (failedImports.length > 0) {
-                    utils_logger.error('\n❓ Common issues that prevent loading config files:');
-                    utils_logger.error('   - Missing dependencies (check your package.json)');
-                    utils_logger.error('   - Import path issues (check your import statements)');
-                    utils_logger.error('   - Path alias configuration (check your tsconfig.json)');
-                    utils_logger.error("   - Export format (make sure you're exporting c15t, c15tInstance, consent, or default)");
+        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;
+        }
+        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'
                 }
-                throw new __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError('Unable to load any c15t configuration file', {
-                    code: 'CONFIG_FILE_LOAD_ERROR',
-                    status: 500,
-                    category: 'CONFIG_FILE_LOAD_ERROR'
-                });
-            }
-            utils_logger.error('❌ No c15t configuration files found in standard locations');
-            utils_logger.info('\n📝 Create a c15t.ts file with your configuration:');
-            utils_logger.info(`
+            ],
+            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, localStorageKey, 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');
+    }
+  }
+} 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',
+  localStorageKey: '${localStorageKey || 'c15t-consent'}',
+  
+  // Optional: Add callback functions for various events
+  callbacks: {
+    onConsentSet: (response) => {
+      console.log('Consent has been saved locally');
+    }
+  }
+} satisfies ConsentManagerOptions;
+
+// 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');
+    }
+  }
+} satisfies ConsentManagerOptions;
+
+// 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 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.
 
-export const c15t = c15tInstance({
-  appName: 'My App',
+// Define your c15t instance
+const instance = c15tInstance({
+  appName: 'Your App Name',
   basePath: '/api/c15t',
-  // Add your configuration here
+  database: ${adapterConfig},
+  trustedOrigins: ['http://localhost:3000'],
 });
-			`);
-            throw new __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError('No c15t config file found. Create a c15t.ts file or specify with --config', {
-                code: 'CONFIG_FILE_NOT_FOUND',
-                status: 404,
-                category: 'CONFIG_FILE_NOT_FOUND'
+
+export default instance;
+`;
+}
+function generateEnvFileContent(backendURL) {
+    return `# c15t Configuration
+# Note: This URL is public and can be safely committed to version control
+NEXT_PUBLIC_C15T_URL=${backendURL}
+`;
+}
+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://app.consent.io/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://app.consent.io/register manually.');
         }
-        return configFile;
-    } catch (e) {
-        if ('object' == typeof e && e && 'message' in e && 'string' == typeof e.message && e.message.includes('This module cannot be imported from a Client Component module')) {
-            utils_logger.error("❌ 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);
+    }
+    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 (e instanceof __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_results_3ca2b89f__.DoubleTieError) utils_logger.error(`❌ ${e.message}`);
-        else if (e instanceof Error) {
-            utils_logger.error(`❌ Couldn't read your c15t configuration`);
-            utils_logger.error(`   Error: ${e.message}`);
-        } else {
-            utils_logger.error(`❌ Couldn't read your c15t configuration`);
-            utils_logger.error(`   Error: ${String(e)}`);
+    });
+    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, void 0, 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
+    };
+}
+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
+    };
+}
+async function setupOfflineMode(context, projectRoot, spinner, handleCancel) {
+    const { logger, cwd } = context;
+    const localStorageKeySelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.text({
+        message: 'Enter a key for localStorage (optional):',
+        placeholder: 'c15t-consent'
+    });
+    if (handleCancel?.(localStorageKeySelection)) throw new Error('Setup cancelled');
+    const localStorageKey = localStorageKeySelection || 'c15t-consent';
+    logger.debug(`Using localStorage key: ${localStorageKey}`);
+    const clientConfigContent = generateClientConfigContent('offline', void 0, localStorageKey, 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,
+        localStorageKey
+    };
+}
+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');
+            }
+            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;
+        }
+        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))}`));
+    }
+    const clientConfigContent = generateClientConfigContent('c15t', '/api/c15t', void 0, 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 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;
+        }
+        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
+    });
+    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
+        });
+        let initialStorageMode;
+        if (isUpdate && existingConfig && 'mode' in existingConfig) {
+            if (isClientOptions(existingConfig)) initialStorageMode = existingConfig.mode;
+            else if (isC15TOptions(existingConfig)) initialStorageMode = 'c15t';
+        }
+        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;
+        }
+        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
+            });
+        } 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))}.`);
+                }
+            }
+        }
+        __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 (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.`);
+        }
+        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.');
+        }
+        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')}`);
         }
-        if (failedImports.length > 0) {
-            utils_logger.info("\n💡 Tip: If you're having import issues, try running with verbose logging:");
-            utils_logger.info('   DEBUG=c15t* npx c15t@latest <command>');
+        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)
+            });
         }
-        process.exit(1);
     }
 }
-async function generateAction(opts) {
-    const options = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
-        cwd: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
-        config: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
-        output: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
-        y: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional()
-    }).parse(opts);
-    const cwd = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(options.cwd);
+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)) {
-        utils_logger.error(`The directory "${cwd}" does not exist.`);
-        process.exit(1);
+        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');
     }
-    const config = await getConfig({
-        cwd,
-        configPath: options.config
-    });
-    if (!config) return void utils_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.');
-    const adapter = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__.getAdapter)(config).catch((e)=>{
-        utils_logger.error(e.message);
-        process.exit(1);
-    });
-    const spinner = (0, __WEBPACK_EXTERNAL_MODULE_yocto_spinner_579f0326__["default"])({
-        text: 'preparing schema...'
-    }).start();
-    const schema = await getGenerator({
-        adapter,
-        file: options.output,
-        options: config
-    });
-    spinner.stop();
-    if (!schema.code) {
-        utils_logger.info('Your schema is already up to date.');
-        process.exit(0);
+    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');
+        }
     }
-    if (schema.append || schema.overwrite) {
-        let confirm = options.y;
-        if (!confirm) {
-            const response = await (0, __WEBPACK_EXTERNAL_MODULE_prompts__["default"])({
-                type: 'confirm',
-                name: 'confirm',
-                message: `The file ${schema.fileName} already exists. Do you want to ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].yellow(`${schema.overwrite ? 'overwrite' : 'append'}`)} the schema to the file?`
+    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 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 (!shouldUpdate) {
+            telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_COMPLETED, {
+                success: false,
+                reason: 'user_cancelled'
             });
-            confirm = response.confirm;
+            return error.handleCancel('Operation cancelled.');
         }
-        if (confirm) {
-            const exist = (0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName));
-            if (!exist) await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].mkdir(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName)), {
-                recursive: true
+        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
             });
-            if (schema.overwrite) await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName), schema.code);
-            else await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].appendFile(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName), schema.code);
-            utils_logger.success(`🚀 Schema was ${schema.overwrite ? 'overwritten' : 'appended'} successfully!`);
-            process.exit(0);
         } else {
-            utils_logger.error('Schema generation aborted.');
-            process.exit(1);
+            logger.debug('Proceeding with existing configuration.');
+            telemetry.trackEvent(telemetry_TelemetryEventName.GENERATE_COMPLETED, {
+                success: true,
+                configUpdated: false
+            });
         }
+    } else {
+        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 (0, __WEBPACK_EXTERNAL_MODULE_prompts__["default"])({
-            type: 'confirm',
-            name: 'confirm',
-            message: `Do you want to generate the schema to ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].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'
+    });
+    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)
         });
-        confirm = response.confirm;
+        context.error.handleError(error, 'Error running migrations');
+    }
+}
+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 (!confirm) {
-        utils_logger.error('Schema generation aborted.');
-        process.exit(1);
+    if (!migrationData) {
+        s.stop('Could not retrieve migration data.');
+        logger.failed('Migration planning failed');
+        return {
+            shouldRun: false,
+            runMigrationsFn: null
+        };
     }
-    if (!options.output) {
-        const dirExist = (0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName)));
-        if (!dirExist) await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].mkdir(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName)), {
-            recursive: true
+    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
+    });
+    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');
     }
-    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(options.output || __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, schema.fileName), schema.code);
-    utils_logger.success('🚀 Schema was generated successfully!');
-    process.exit(0);
 }
-const generate = new __WEBPACK_EXTERNAL_MODULE_commander__.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 = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
-        cwd: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
-        config: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
-        y: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional()
-    }).parse(opts);
-    const cwd = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(options.cwd);
-    if (!(0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(cwd)) {
-        utils_logger.error(`The directory "${cwd}" does not exist.`);
-        process.exit(1);
+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 config = await getConfig({
-        cwd,
-        configPath: options.config
+    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);
     });
-    if (!config) return void utils_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.');
-    const db = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__.getAdapter)(config);
-    if (!db) {
-        utils_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 ('kysely' !== db.id) {
-        if ('prisma' === db.id) {
-            utils_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’s migrate or push to apply it.');
-            process.exit(0);
+    logger.message(coloredLines.join('\n'));
+}
+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 ('drizzle' === db.id) {
-            utils_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’s migrate or push to apply it.');
+        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);
         }
-        utils_logger.error("Migrate command isn't supported for this adapter.");
-        process.exit(1);
+    };
+}
+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
     }
-    const spinner = (0, __WEBPACK_EXTERNAL_MODULE_yocto_spinner_579f0326__["default"])({
-        text: 'preparing migration...'
-    }).start();
-    const { toBeAdded, toBeCreated, runMigrations } = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_migrations_80b6e3bd__.getMigrations)(config);
-    if (!toBeAdded.length && !toBeCreated.length) {
-        spinner.stop();
-        utils_logger.info('🚀 No migrations needed.');
-        process.exit(0);
+];
+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;
     }
-    spinner.stop();
-    utils_logger.info('🔑 The migration will affect the following:');
-    for (const table of [
-        ...toBeCreated,
-        ...toBeAdded
-    ])console.log('->', __WEBPACK_EXTERNAL_MODULE_chalk__["default"].magenta(Object.keys(table.fields).join(', ')), __WEBPACK_EXTERNAL_MODULE_chalk__["default"].white('fields on'), __WEBPACK_EXTERNAL_MODULE_chalk__["default"].yellow(`${table.table}`), __WEBPACK_EXTERNAL_MODULE_chalk__["default"].white('table.'));
-    let migrate = options.y;
-    if (!migrate) {
-        const response = await (0, __WEBPACK_EXTERNAL_MODULE_prompts__["default"])({
-            type: 'confirm',
-            name: 'migrate',
-            message: 'Are you sure you want to run these migrations?',
-            initial: false
-        });
-        migrate = response.migrate;
-    }
-    if (!migrate) {
-        utils_logger.info('Migration cancelled.');
-        process.exit(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);
     }
-    spinner?.start('migrating...');
-    await runMigrations();
-    spinner.stop();
-    utils_logger.info('🚀 migration was completed successfully!');
-    process.exit(0);
-}
-const migrate_migrate = new __WEBPACK_EXTERNAL_MODULE_commander__.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 __WEBPACK_EXTERNAL_MODULE_commander__.Command('secret').action(()=>{
-    const secret = __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__["default"].randomBytes(32).toString('hex');
-    utils_logger.info(`\nAdd the following to your .env file: 
-${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].gray('# C15T Secret') + __WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(`\nC15T_SECRET=${secret}`)}`);
-});
-function getPackageInfo() {
-    const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join('package.json');
-    return __WEBPACK_EXTERNAL_MODULE_fs_extra_ce68a66b__["default"].readJSONSync(packageJsonPath);
+    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;
+        }
+    };
 }
-process.on('SIGINT', ()=>process.exit(0));
-process.on('SIGTERM', ()=>process.exit(0));
+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
+        }
+    });
+    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 __WEBPACK_EXTERNAL_MODULE_commander__.Command('c15t');
-    const packageInfo = await getPackageInfo();
-    program.addCommand(migrate_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;
+    telemetry.trackEvent(telemetry_TelemetryEventName.CLI_INVOKED, {
+        version,
+        nodeVersion: process.version,
+        platform: process.platform
+    });
+    if (flags.version) {
+        logger.debug('Version flag detected');
+        logger.message(`c15t CLI version ${version}`);
+        telemetry.trackEvent(telemetry_TelemetryEventName.VERSION_DISPLAYED, {
+            version
+        });
+        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
+        });
+        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()
+                });
+            } else {
+                logger.error(`Unknown command: ${commandName}`);
+                telemetry.trackEvent(telemetry_TelemetryEventName.COMMAND_UNKNOWN, {
+                    unknownCommand: commandName
+                });
+                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()
+                    });
+                } else {
+                    telemetry.trackEvent(telemetry_TelemetryEventName.COMMAND_UNKNOWN, {
+                        unknownCommand: String(selectedCommandName)
+                    });
+                    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
+        });
+    } catch (executionError) {
+        telemetry.trackEvent(telemetry_TelemetryEventName.COMMAND_FAILED, {
+            command: commandName,
+            error: executionError instanceof Error ? executionError.message : String(executionError)
+        });
+        error.handleError(executionError, 'An unexpected error occurred during command execution');
+    }
+    await telemetry.shutdown();
 }
 main();
+export { main };