@zintrust/core 0.1.0

package/src/cli/commands/SimulateCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimulateCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/SimulateCommand.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA+BhD;;GAEG;AACH,eAAO,MAAM,eAAe,EAuDvB,YAAY,CAAC"}

package/src/cli/commands/SimulateCommand.js

@@ -0,0 +1,79 @@
+/**
+ * Simulate Command
+ * Internal dev tool that generates a simulated Zintrust app under ./simulate/
+ * IMPORTANT: this uses the same ProjectScaffolder as `zin new`.
+ * Usage: zin -sim my-blog
+ */
+import { ProjectScaffolder } from '../scaffolding/ProjectScaffolder';
+import { DistPackager } from '../utils/DistPackager';
+import { Logger } from '../../config/logger';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import fs from '../../node-singletons/fs';
+import * as path from '../../node-singletons/path';
+import chalk from 'chalk';
+import { Command } from 'commander';
+const rewriteSimulatedAppDependencyToDist = (appPath, distPath) => {
+    const packageJsonPath = path.join(appPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        throw ErrorFactory.createCliError(`Missing simulated app package.json at: ${packageJsonPath}`);
+    }
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const dependencies = { ...pkg.dependencies };
+    dependencies['@zintrust/core'] = `file:${distPath}`;
+    const nextPkg = {
+        ...pkg,
+        dependencies,
+    };
+    fs.writeFileSync(packageJsonPath, JSON.stringify(nextPkg, null, 2) + '\n');
+};
+/**
+ * SimulateCommand - Generate simulated apps for testing
+ */
+export const SimulateCommand = {
+    name: 'simulate',
+    description: '[INTERNAL] Generate simulated Zintrust app for testing new developer experience',
+    getCommand() {
+        const command = new Command('simulate')
+            .alias('-sim')
+            .alias('--sim')
+            .description('[INTERNAL DEV] Create a simulated Zintrust application in simulate/ folder')
+            .argument('<name>', 'Name of the simulated app')
+            .action(async (appName) => {
+            try {
+                const simulateBasePath = path.join(process.cwd(), 'simulate');
+                if (!appName || appName.trim() === '') {
+                    throw ErrorFactory.createValidationError('App name is required');
+                }
+                // Delegate validation + file generation to the same scaffolder used by `zin new`.
+                Logger.info(`Creating simulated app via ProjectScaffolder: ${chalk.cyan(appName)}`);
+                const result = await ProjectScaffolder.scaffold(simulateBasePath, {
+                    name: appName,
+                    template: 'basic',
+                    database: 'sqlite',
+                    author: 'Internal',
+                    description: `Simulated Zintrust app - ${appName}`,
+                });
+                if (!result.success) {
+                    throw ErrorFactory.createCliError(result.message, result.error);
+                }
+                const appPath = path.join(simulateBasePath, appName);
+                // For simulate apps only: install the locally-built framework from dist/
+                // so the dev experience matches "fresh install" of the current build output.
+                const distPath = path.join(process.cwd(), 'dist');
+                DistPackager.prepare(distPath, process.cwd());
+                rewriteSimulatedAppDependencyToDist(appPath, distPath);
+                Logger.info('✅ Simulated app created successfully!');
+                Logger.info(`📁 Location: ${chalk.cyan(appPath)}`);
+                Logger.info(`\n${chalk.bold('Next steps:')}`);
+                Logger.info(`  cd ${path.relative(process.cwd(), appPath)}`);
+                Logger.info('  npm install');
+                Logger.info('  npm run dev');
+            }
+            catch (error) {
+                Logger.error('Failed to create simulated app', error);
+                process.exit(1);
+            }
+        });
+        return command;
+    },
+};

package/src/cli/commands/StartCommand.d.ts

@@ -0,0 +1,5 @@
+import { type IBaseCommand } from '../BaseCommand';
+export declare const StartCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=StartCommand.d.ts.map

package/src/cli/commands/StartCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StartCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/StartCommand.ts"],"names":[],"mappings":"AACA,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAkSvF,eAAO,MAAM,YAAY;cACb,YAAY;EAsBtB,CAAC"}

package/src/cli/commands/StartCommand.js

@@ -0,0 +1,227 @@
+import { resolveNpmPath } from '../../common';
+import { BaseCommand } from '../BaseCommand';
+import { EnvFileLoader } from '../utils/EnvFileLoader';
+import { SpawnUtil } from '../utils/spawn';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import { existsSync, readFileSync } from '../../node-singletons/fs';
+import * as path from 'node:path';
+const isValidModeInput = (value) => value === 'development' ||
+    value === 'dev' ||
+    value === 'production' ||
+    value === 'pro' ||
+    value === 'prod' ||
+    value === 'testing';
+const normalizeMode = (value) => {
+    if (value === 'production' || value === 'pro' || value === 'prod')
+        return 'production';
+    if (value === 'testing')
+        return 'testing';
+    return 'development';
+};
+const resolveModeFromAppMode = () => {
+    const raw = typeof process.env['APP_MODE'] === 'string' ? process.env['APP_MODE'].trim() : '';
+    const normalized = raw.toLowerCase();
+    if (normalized === 'production' || normalized === 'pro' || normalized === 'prod') {
+        return 'production';
+    }
+    // Per spec: any other APP_MODE is treated as development.
+    return 'development';
+};
+const resolveMode = (options) => {
+    const raw = typeof options.mode === 'string' ? options.mode.trim() : '';
+    if (raw !== '') {
+        if (isValidModeInput(raw))
+            return normalizeMode(raw);
+        throw ErrorFactory.createCliError(`Error: Invalid --mode '${raw}'. Expected one of: development, production, testing.`);
+    }
+    return resolveModeFromAppMode();
+};
+const resolvePort = (options) => {
+    const cliPort = typeof options.port === 'string' ? options.port.trim() : '';
+    if (cliPort !== '') {
+        const parsed = Number.parseInt(cliPort, 10);
+        if (!Number.isFinite(parsed) || parsed <= 0 || parsed >= 65536) {
+            throw ErrorFactory.createCliError(`Error: Invalid --port '${cliPort}'. Expected 1-65535.`);
+        }
+        return parsed;
+    }
+    // .env is primary (loaded by EnvFileLoader with overrideExisting=true)
+    const envPort = process.env['APP_PORT'] ?? process.env['PORT'] ?? '';
+    if (envPort === '')
+        return undefined;
+    const parsed = Number.parseInt(envPort, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0 || parsed >= 65536) {
+        throw ErrorFactory.createCliError(`Error: Invalid APP_PORT/PORT '${envPort}'. Expected 1-65535.`);
+    }
+    return parsed;
+};
+const resolveRuntime = (options) => {
+    const raw = typeof options.runtime === 'string' ? options.runtime.trim() : '';
+    return raw === '' ? undefined : raw;
+};
+const hasFlag = (flag) => process.argv.includes(flag);
+const resolveWatchPreference = (options, mode) => {
+    const hasWatch = hasFlag('--watch');
+    const hasNoWatch = hasFlag('--no-watch');
+    if (hasWatch && hasNoWatch) {
+        throw ErrorFactory.createCliError('Error: Cannot use both --watch and --no-watch.');
+    }
+    if (hasWatch)
+        return true;
+    if (hasNoWatch)
+        return false;
+    if (typeof options.watch === 'boolean')
+        return options.watch;
+    return mode === 'development';
+};
+const readPackageJson = (cwd) => {
+    const packagePath = path.join(cwd, 'package.json');
+    if (!existsSync(packagePath)) {
+        throw ErrorFactory.createCliError("Error: No Zintrust app found. Run 'zin new <project>' or ensure package.json exists.");
+    }
+    try {
+        const raw = readFileSync(packagePath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError('Failed to read package.json', error);
+    }
+};
+const isFrameworkRepo = (packageJson) => packageJson.name === '@zintrust/core';
+const hasDevScript = (packageJson) => {
+    const scripts = packageJson.scripts;
+    if (!scripts)
+        return false;
+    return typeof scripts['dev'] === 'string' && scripts['dev'] !== '';
+};
+const findWranglerConfig = (cwd) => {
+    const candidates = ['wrangler.toml', 'wrangler.json', 'wrangler.jsonc'];
+    for (const candidate of candidates) {
+        const full = path.join(cwd, candidate);
+        if (existsSync(full))
+            return full;
+    }
+    return undefined;
+};
+const resolveWranglerEntry = (cwd) => {
+    const entry = path.join(cwd, 'src/functions/cloudflare.ts');
+    return existsSync(entry) ? 'src/functions/cloudflare.ts' : undefined;
+};
+const resolveBootstrapEntryTs = (cwd) => {
+    const boot = path.join(cwd, 'src/boot/bootstrap.ts');
+    if (existsSync(boot))
+        return 'src/boot/bootstrap.ts';
+    return undefined;
+};
+const resolveNodeDevCommand = (cwd, packageJson) => {
+    if (isFrameworkRepo(packageJson)) {
+        const bootstrap = resolveBootstrapEntryTs(cwd);
+        return { command: 'tsx', args: ['watch', bootstrap ?? 'src/index.ts'] };
+    }
+    const bootstrap = resolveBootstrapEntryTs(cwd);
+    if (bootstrap !== undefined) {
+        return { command: 'tsx', args: ['watch', bootstrap] };
+    }
+    if (existsSync(path.join(cwd, 'src/index.ts'))) {
+        return { command: 'tsx', args: ['watch', 'src/index.ts'] };
+    }
+    // Fallback: if the app provides a dev script, run it.
+    // IMPORTANT: avoid calling `npm run dev` when the dev script itself invokes `zin`/`zintrust`
+    // (e.g. "dev": "zin s"), which would cause infinite recursion.
+    const devScript = typeof packageJson.scripts?.['dev'] === 'string' ? String(packageJson.scripts['dev']) : '';
+    const devScriptCallsZin = /\bzin(?:trust)?\b/.test(devScript);
+    if (hasDevScript(packageJson) && !devScriptCallsZin) {
+        const npm = resolveNpmPath();
+        return { command: npm, args: ['run', 'dev'] };
+    }
+    throw ErrorFactory.createCliError("Error: No entry point found. Expected 'src/index.ts' or 'src/boot/bootstrap.ts'. Ensure your project is correctly scaffolded.");
+};
+const resolveNodeProdCommand = (cwd) => {
+    const compiledBoot = path.join(cwd, 'dist/src/boot/bootstrap.js');
+    let compiled;
+    if (existsSync(compiledBoot)) {
+        compiled = 'dist/src/boot/bootstrap.js';
+    }
+    if (compiled === undefined) {
+        throw ErrorFactory.createCliError("Error: Compiled app not found at dist/src/boot/bootstrap.js Run 'npm run build' first.");
+    }
+    return { command: 'node', args: [compiled] };
+};
+const executeWranglerStart = async (cmd, cwd, port, runtime) => {
+    if (runtime !== undefined) {
+        throw ErrorFactory.createCliError('Error: --runtime is not supported with --wrangler (Wrangler controls Workers runtime).');
+    }
+    const configPath = findWranglerConfig(cwd);
+    const entry = resolveWranglerEntry(cwd);
+    if (configPath === undefined && entry === undefined) {
+        throw ErrorFactory.createCliError("Error: wrangler config not found (wrangler.toml/json). Run 'wrangler init' first.");
+    }
+    const wranglerArgs = ['dev'];
+    if (configPath === undefined && entry !== undefined) {
+        wranglerArgs.push(entry);
+    }
+    if (typeof port === 'number') {
+        wranglerArgs.push('--port', String(port));
+    }
+    cmd.info('Starting in Wrangler dev mode...');
+    const exitCode = await SpawnUtil.spawnAndWait({ command: 'wrangler', args: wranglerArgs });
+    process.exit(exitCode);
+};
+const executeNodeStart = async (cmd, cwd, mode, watchEnabled) => {
+    if (mode === 'testing') {
+        throw ErrorFactory.createCliError('Error: Cannot start server in testing mode. Use --force to override (not supported).');
+    }
+    if (mode === 'development') {
+        if (!watchEnabled) {
+            cmd.warn('Watch mode disabled; starting once.');
+            const bootstrap = resolveBootstrapEntryTs(cwd);
+            const args = bootstrap === undefined ? ['src/index.ts'] : [bootstrap];
+            const exitCode = await SpawnUtil.spawnAndWait({ command: 'tsx', args });
+            process.exit(exitCode);
+        }
+        const packageJson = readPackageJson(cwd);
+        const dev = resolveNodeDevCommand(cwd, packageJson);
+        cmd.info('Starting in development mode (watch enabled)...');
+        const exitCode = await SpawnUtil.spawnAndWait({ command: dev.command, args: dev.args });
+        process.exit(exitCode);
+    }
+    const prod = resolveNodeProdCommand(cwd);
+    cmd.info('Starting in production mode...');
+    const exitCode = await SpawnUtil.spawnAndWait({ command: prod.command, args: prod.args });
+    process.exit(exitCode);
+};
+const executeStart = async (options, cmd) => {
+    const cwd = process.cwd();
+    EnvFileLoader.ensureLoaded();
+    const mode = resolveMode(options);
+    const port = resolvePort(options);
+    const runtime = resolveRuntime(options);
+    EnvFileLoader.applyCliOverrides({ nodeEnv: mode, port, runtime });
+    if (options.wrangler === true) {
+        await executeWranglerStart(cmd, cwd, port, runtime);
+        return;
+    }
+    const watchEnabled = resolveWatchPreference(options, mode);
+    await executeNodeStart(cmd, cwd, mode, watchEnabled);
+};
+export const StartCommand = Object.freeze({
+    create() {
+        const addOptions = (command) => {
+            command.alias('s');
+            command
+                .option('-w, --wrangler', 'Start with Wrangler dev mode (Cloudflare Workers)')
+                .option('--watch', 'Force watch mode (Node only)')
+                .option('--no-watch', 'Disable watch mode (Node only)')
+                .option('--mode <development|production|testing>', 'Override app mode')
+                .option('--runtime <nodejs|cloudflare|lambda|deno|auto>', 'Set RUNTIME for spawned Node')
+                .option('--port <number>', 'Override server port');
+        };
+        const cmd = BaseCommand.create({
+            name: 'start',
+            description: 'Start the application (dev watch, production, or Wrangler mode)',
+            addOptions,
+            execute: async (options) => executeStart(options, cmd),
+        });
+        return cmd;
+    },
+});

package/src/cli/commands/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CLI Commands Module Index
+ */
+export { AddCommand } from '../commands/AddCommand';
+export { ConfigCommand } from '../commands/ConfigCommand';
+export { DebugCommand } from '../commands/DebugCommand';
+export { MigrateCommand } from '../commands/MigrateCommand';
+export { NewCommand } from '../commands/NewCommand';
+export { PrepareCommand } from '../commands/PrepareCommand';
+export { StartCommand } from '../commands/StartCommand';
+//# sourceMappingURL=index.d.ts.map

package/src/cli/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC"}

package/src/cli/commands/index.js

@@ -0,0 +1,10 @@
+/**
+ * CLI Commands Module Index
+ */
+export { AddCommand } from '../commands/AddCommand';
+export { ConfigCommand } from '../commands/ConfigCommand';
+export { DebugCommand } from '../commands/DebugCommand';
+export { MigrateCommand } from '../commands/MigrateCommand';
+export { NewCommand } from '../commands/NewCommand';
+export { PrepareCommand } from '../commands/PrepareCommand';
+export { StartCommand } from '../commands/StartCommand';

package/src/cli/config/ConfigManager.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ */
+import { ProjectConfig } from '../config/ConfigSchema';
+export interface IConfigManager {
+    load(): Promise<ProjectConfig>;
+    save(config?: ProjectConfig): Promise<void>;
+    getConfig(): ProjectConfig;
+    get(key: string): unknown;
+    set(key: string, value: unknown): void;
+    exists(): Promise<boolean>;
+    create(initialConfig?: Partial<ProjectConfig>): Promise<void>;
+    reset(): Promise<void>;
+    merge(partial: Partial<ProjectConfig>): void;
+    export(): string;
+    getAllKeys(): string[];
+}
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ * Sealed namespace for immutability
+ */
+export declare const ConfigManager: Readonly<{
+    /**
+     * Create a new config manager instance
+     */
+    create(configPath?: string): IConfigManager;
+    /**
+     * Create global config directory if not exists
+     */
+    ensureGlobalConfigDir(): Promise<void>;
+    /**
+     * Get or create global config manager
+     */
+    getGlobalConfig(): Promise<IConfigManager>;
+    /**
+     * Get or create project config manager
+     */
+    getProjectConfig(): Promise<IConfigManager>;
+}>;
+//# sourceMappingURL=ConfigManager.d.ts.map

package/src/cli/config/ConfigManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigManager.d.ts","sourceRoot":"","sources":["../../../../src/cli/config/ConfigManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIL,aAAa,EAEd,MAAM,0BAA0B,CAAC;AAMlC,MAAM,WAAW,cAAc;IAC7B,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IAC/B,IAAI,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,SAAS,IAAI,aAAa,CAAC;IAC3B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IACvC,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3B,MAAM,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAC7C,MAAM,IAAI,MAAM,CAAC;IACjB,UAAU,IAAI,MAAM,EAAE,CAAC;CACxB;AAkHD;;;;GAIG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;wBACgB,MAAM,GAAgC,cAAc;IAqCvE;;OAEG;6BAC4B,OAAO,CAAC,IAAI,CAAC;IAS5C;;OAEG;uBACsB,OAAO,CAAC,cAAc,CAAC;IAOhD;;OAEG;wBACuB,OAAO,CAAC,cAAc,CAAC;EAKjD,CAAC"}

package/src/cli/config/ConfigManager.js

@@ -0,0 +1,175 @@
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ */
+import { ConfigPaths, DEFAULT_CONFIG, getConfigValue, setConfigValue, } from '../config/ConfigSchema';
+import { Logger } from '../../config/logger';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import { fsPromises as fs } from '../../node-singletons/fs';
+import * as path from 'node:path';
+/**
+ * Deep merge helper
+ */
+const deepMerge = (target, source) => {
+    const result = { ...target };
+    for (const key in source) {
+        if (typeof source[key] === 'object' && source[key] !== null && !Array.isArray(source[key])) {
+            result[key] = deepMerge(target[key] ?? {}, source[key]);
+        }
+        else {
+            result[key] = source[key];
+        }
+    }
+    return result;
+};
+/**
+ * Load configuration from file
+ */
+async function loadConfig(state) {
+    try {
+        const content = await fs.readFile(state.configPath, 'utf-8');
+        state.config = JSON.parse(content);
+        return state.config;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            Logger.debug(`Config file not found at ${state.configPath}, using defaults`);
+            state.config = structuredClone(DEFAULT_CONFIG);
+            return state.config;
+        }
+        ErrorFactory.createCliError(`Failed to load config: ${err.message}`);
+        throw err;
+    }
+}
+/**
+ * Save configuration to file
+ */
+async function saveConfig(state, newConfig) {
+    const toSave = newConfig ?? state.config;
+    if (!toSave) {
+        throw ErrorFactory.createConfigError('No configuration to save');
+    }
+    try {
+        // Ensure directory exists
+        const dir = path.dirname(state.configPath);
+        if (dir !== '.') {
+            await fs.mkdir(dir, { recursive: true });
+        }
+        // Write config with nice formatting
+        await fs.writeFile(state.configPath, JSON.stringify(toSave, null, 2));
+        state.config = toSave;
+        Logger.debug(`Config saved to ${state.configPath}`);
+    }
+    catch (err) {
+        ErrorFactory.createCliError(`Failed to save config: ${err.message}`);
+        throw err;
+    }
+}
+/**
+ * Get current configuration
+ */
+function getConfig(state) {
+    state.config ??= structuredClone(DEFAULT_CONFIG);
+    return state.config;
+}
+/**
+ * Check if config file exists
+ */
+async function configExists(configPath) {
+    try {
+        await fs.access(configPath);
+        return true;
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Config file access check failed', error);
+        return false;
+    }
+}
+/**
+ * Flatten object keys
+ */
+function flattenKeys(obj, prefix = '') {
+    const keys = [];
+    for (const key in obj) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        const value = obj[key];
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            keys.push(...flattenKeys(value, fullKey));
+        }
+        else {
+            keys.push(fullKey);
+        }
+    }
+    return keys;
+}
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ * Sealed namespace for immutability
+ */
+export const ConfigManager = Object.freeze({
+    /**
+     * Create a new config manager instance
+     */
+    create(configPath = ConfigPaths.PROJECT_CONFIG) {
+        const state = {
+            config: null,
+            configPath,
+        };
+        return {
+            load: async () => loadConfig(state),
+            save: async (newConfig) => saveConfig(state, newConfig),
+            getConfig: () => getConfig(state),
+            get(key) {
+                return getConfigValue(getConfig(state), key);
+            },
+            set(key, value) {
+                setConfigValue(getConfig(state), key, value);
+            },
+            exists: async () => configExists(configPath),
+            async create(initialConfig) {
+                const newConfig = { ...DEFAULT_CONFIG, ...initialConfig };
+                await saveConfig(state, newConfig);
+            },
+            async reset() {
+                state.config = structuredClone(DEFAULT_CONFIG);
+                await saveConfig(state);
+            },
+            merge(partial) {
+                const currentConfig = getConfig(state);
+                state.config = deepMerge(currentConfig, partial);
+            },
+            export: () => JSON.stringify(getConfig(state), null, 2),
+            getAllKeys: () => flattenKeys(getConfig(state)),
+        };
+    },
+    /**
+     * Create global config directory if not exists
+     */
+    async ensureGlobalConfigDir() {
+        try {
+            await fs.mkdir(ConfigPaths.GLOBAL_DIR, { recursive: true });
+        }
+        catch (err) {
+            ErrorFactory.createCliError('Could not create global config dir', err);
+            Logger.debug(`Could not create global config dir: ${err.message}`);
+        }
+    },
+    /**
+     * Get or create global config manager
+     */
+    async getGlobalConfig() {
+        await this.ensureGlobalConfigDir();
+        const manager = this.create(ConfigPaths.GLOBAL_CONFIG);
+        await manager.load();
+        return manager;
+    },
+    /**
+     * Get or create project config manager
+     */
+    async getProjectConfig() {
+        const manager = this.create(ConfigPaths.PROJECT_CONFIG);
+        await manager.load();
+        return manager;
+    },
+});