schemantic 0.3.0 → 0.4.1

package/dist/cli/index.d.ts

@@ -8,6 +8,7 @@
  */
 export declare class SchemanticCli {
     private program;
+    private pluginDirectory;
     constructor();
     /**
      * Setup the CLI program
@@ -81,6 +82,7 @@ export declare class SchemanticCli {
      * Handle errors
      */
     private handleError;
+    private outputEffectiveConfiguration;
     /**
      * Run interactive mode
      */
@@ -97,6 +99,7 @@ export declare class SchemanticCli {
      * Save configuration to file
      */
     private saveConfig;
+    private templateConfig;
     /**
      * Ask a question and return the answer
      */
@@ -112,7 +115,7 @@ export declare class SchemanticCli {
     /**
      * Run the CLI
      */
-    run(): void;
+    run(argv?: string[]): Promise<void>;
 }
 export declare const cli: SchemanticCli;
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":";AAEA;;;GAGG;AA0BH;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAU;;IAOzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAoBpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAiD1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAa1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsBxB;;OAEG;IACH,OAAO,CAAC,cAAc;IAWtB;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;YACW,qBAAqB;IA+BnC;;OAEG;YACW,qBAAqB;IAqBnC;;OAEG;YACW,iBAAiB;IAiB/B;;OAEG;YACW,uBAAuB;IAerC;;OAEG;YACW,uBAAuB;IAYrC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgEzB;;OAEG;YACW,iBAAiB;IA8G/B;;OAEG;YACW,cAAc;IAsB5B;;OAEG;YACW,WAAW;IAsBzB;;OAEG;IACH,OAAO,CAAC,aAAa;IAqBrB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAoC/B;;OAEG;IACH,OAAO,CAAC,WAAW;IASnB;;OAEG;YACW,kBAAkB;IAuEhC;;OAEG;YACW,kBAAkB;IAoFhC;;OAEG;YACW,mBAAmB;IAsBjC;;OAEG;YACW,UAAU;IAWxB;;OAEG;IACH,OAAO,CAAC,WAAW;IASnB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAahB;;OAEG;IACH,OAAO,CAAC,SAAS;IAmBjB;;OAEG;IACH,GAAG,IAAI,IAAI;CAGZ;AAGD,eAAO,MAAM,GAAG,eAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":";AAEA;;;GAGG;AA8BH;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,eAAe,CAAiB;;IAOxC;;OAEG;IACH,OAAO,CAAC,YAAY;IAoBpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAgD1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAa1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsBxB;;OAEG;IACH,OAAO,CAAC,cAAc;IAYtB;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;YACW,qBAAqB;IAsDnC;;OAEG;YACW,qBAAqB;IAuBnC;;OAEG;YACW,iBAAiB;IAoB/B;;OAEG;YACW,uBAAuB;IAerC;;OAEG;YACW,uBAAuB;IAarC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAiEzB;;OAEG;YACW,iBAAiB;IA0I/B;;OAEG;YACW,cAAc;IAyB5B;;OAEG;YACW,WAAW;IAwBzB;;OAEG;IACH,OAAO,CAAC,aAAa;IAqBrB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAoC/B;;OAEG;IACH,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,4BAA4B;IAYpC;;OAEG;YACW,kBAAkB;IAyEhC;;OAEG;YACW,kBAAkB;IAoFhC;;OAEG;YACW,mBAAmB;IAsBjC;;OAEG;YACW,UAAU;IAkBxB,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,WAAW;IASnB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAchB;;OAEG;IACH,OAAO,CAAC,SAAS;IAoBjB;;OAEG;IACG,GAAG,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAG1C;AAGD,eAAO,MAAM,GAAG,eAAsB,CAAC"}

package/dist/cli/index.js

@@ -42,14 +42,19 @@ exports.cli = exports.SchemanticCli = void 0;
 const commander_1 = require("commander");
 const core_1 = require("../types/core");
 const schemantic_1 = require("../core/schemantic");
+const configuration_1 = require("../core/configuration");
 const plugins_1 = require("../plugins");
 const builtin_1 = require("../plugins/builtin");
 const readline = __importStar(require("readline"));
+const path = __importStar(require("path"));
+const chokidar_1 = require("chokidar");
+const module_1 = require("module");
 /**
  * Main CLI class
  */
 class SchemanticCli {
     constructor() {
+        this.pluginDirectory = process.cwd();
         this.program = new commander_1.Command();
         this.setupProgram();
     }
@@ -60,7 +65,7 @@ class SchemanticCli {
         this.program
             .name("schemantic")
             .description("Generate TypeScript types and API clients from OpenAPI schemas")
-            .version("1.0.0")
+            .version(require('../../package.json').version)
             .option("-i, --interactive", "Run in interactive mode")
             .option("-v, --verbose", "Verbose output")
             .option("-q, --quiet", "Quiet output")
@@ -86,10 +91,11 @@ class SchemanticCli {
             .option("--types", "Generate types only")
             .option("--client", "Generate API client only")
             .option("--hooks", "Generate React hooks")
-            .option("--strict", "Use strict TypeScript types", true)
-            .option("--naming <convention>", "Naming convention (camelCase|snake_case|PascalCase)", "camelCase")
-            .option("--prefix <prefix>", "Type name prefix (leave blank for none)", "")
-            .option("--suffix <suffix>", "Type name suffix", "")
+            .option("--strict", "Use strict TypeScript types")
+            .option("--no-strict", "Disable strict TypeScript types")
+            .option("--naming <convention>", "Naming convention (camelCase|snake_case|PascalCase)")
+            .option("--prefix <prefix>", "Type name prefix (leave blank for none)")
+            .option("--suffix <suffix>", "Type name suffix")
             .option("--exclude-paths <paths>", "Exclude paths (comma-separated)")
             .option("--include-paths <paths>", "Include paths (comma-separated)")
             .option("--exclude-schemas <schemas>", "Exclude schemas (comma-separated)")
@@ -101,7 +107,7 @@ class SchemanticCli {
             .option("-c, --config [file]", "Configuration file path (defaults to ./schemantic.config.json)")
             .option("--watch", "Watch for changes and regenerate")
             .action(async (source, options) => {
-            await this.handleGenerateCommand(source, options);
+            await this.handleGenerateCommand(source, { ...this.program.opts(), ...options });
         });
     }
     /**
@@ -114,9 +120,9 @@ class SchemanticCli {
             .description("Validate OpenAPI schema")
             .option("-u, --url <url>", "OpenAPI schema URL")
             .option("-f, --file <file>", "OpenAPI schema file path")
-            .option("--fix", "Attempt to fix common issues")
+            .option("-c, --config [file]", "Configuration file path (otherwise discover schemantic.config.json/.cjs/.js)")
             .action(async (source, options) => {
-            await this.handleValidateCommand(source, options);
+            await this.handleValidateCommand(source, { ...this.program.opts(), ...options });
         });
     }
     /**
@@ -136,7 +142,7 @@ class SchemanticCli {
         });
         pluginCommand
             .command("load <path>")
-            .description("Load plugin from file or package")
+            .description("Inspect a plugin file or package (does not persist installation)")
             .action(async (path) => {
             await this.handlePluginLoadCommand(path);
         });
@@ -148,10 +154,11 @@ class SchemanticCli {
         this.program
             .command("init [directory]")
             .description("Initialize a new schemantic configuration")
-            .option("-t, --template <template>", "Configuration template", "default")
+            .option("-t, --template <template>", "Configuration template (default|types|react)", "default")
             .option("--yes", "Skip interactive prompts")
+            .option("--force", "Replace an existing schemantic.config.json")
             .action(async (directory, options) => {
-            await this.handleInitCommand(directory, options);
+            await this.handleInitCommand(directory, { ...this.program.opts(), ...options });
         });
     }
     /**
@@ -178,6 +185,9 @@ class SchemanticCli {
             }
             // Load configuration
             const config = await this.loadConfiguration(source, options);
+            this.outputEffectiveConfiguration(config, options);
+            if (options.watch && !config.schemaFile)
+                throw new Error('--watch requires a local schema file');
             // Create Schemantic instance
             const schemanticInstance = new schemantic_1.Schemantic(config);
             // Load plugins
@@ -186,6 +196,33 @@ class SchemanticCli {
             const result = await schemanticInstance.generate();
             // Output results
             this.outputResults(result, options);
+            if (!result.success)
+                process.exitCode = 1;
+            if (options.watch) {
+                const watcher = (0, chokidar_1.watch)(config.schemaFile, { ignoreInitial: true, awaitWriteFinish: { stabilityThreshold: 100 } });
+                let generating = false;
+                let pending = false;
+                watcher.on('change', async () => {
+                    pending = true;
+                    if (generating)
+                        return;
+                    generating = true;
+                    try {
+                        while (pending) {
+                            pending = false;
+                            const update = await schemanticInstance.generate();
+                            this.outputResults(update, options);
+                            process.exitCode = update.success ? 0 : 1;
+                        }
+                    }
+                    finally {
+                        generating = false;
+                    }
+                });
+                watcher.on('ready', () => { if (!options.quiet)
+                    console.log(`Watching ${config.schemaFile}`); });
+                watcher.on('error', error => this.handleError(error, options));
+            }
         }
         catch (error) {
             this.handleError(error, options);
@@ -198,12 +235,15 @@ class SchemanticCli {
         try {
             // Load configuration
             const config = await this.loadConfiguration(source, options);
+            this.outputEffectiveConfiguration(config, options);
             // Create Schemantic instance
             const schemanticInstance = new schemantic_1.Schemantic(config);
             // Validate schema
             const result = await schemanticInstance.validate();
             // Output validation results
             this.outputValidationResults(result, options);
+            if (!result.isValid)
+                process.exitCode = 1;
         }
         catch (error) {
             this.handleError(error, options);
@@ -215,8 +255,11 @@ class SchemanticCli {
     async handleInitCommand(directory, options = {}) {
         try {
             const targetDir = directory || process.cwd();
+            if (!['default', 'types', 'react'].includes(String(options.template || 'default'))) {
+                throw new Error('Unknown template; choose default, types, or react');
+            }
             if (options.yes) {
-                await this.createDefaultConfig(targetDir);
+                await this.createDefaultConfig(targetDir, options);
             }
             else {
                 await this.runInitInteractive(targetDir, options);
@@ -247,9 +290,10 @@ class SchemanticCli {
     async handlePluginLoadCommand(path) {
         try {
             const loader = new plugins_1.PluginLoader();
-            const plugin = await loader.loadPluginFromFile(path);
+            const plugin = await loader.loadPlugin(path);
             console.log(`Loaded plugin: ${plugin.name} (${plugin.version})`);
             console.log(`Description: ${plugin.description}`);
+            console.log('Use this file/package in generate --plugins or the active config; inspection does not persist registration.');
         }
         catch (error) {
             this.handleError(error, {});
@@ -266,6 +310,7 @@ class SchemanticCli {
                 subCommand.help();
             }
             else {
+                process.exitCode = 1;
                 console.log(`Unknown command: ${command}`);
                 console.log("Available commands:");
                 this.program.commands.forEach((cmd) => {
@@ -311,18 +356,48 @@ class SchemanticCli {
      * Load configuration from options
      */
     async loadConfiguration(source, options = {}) {
+        this.pluginDirectory = process.cwd();
+        if (options.url && options.file)
+            throw new Error('Choose one schema source: --url or --file');
         let config = { ...core_1.DEFAULT_CONFIG };
-        // Load from config file if specified. Commander may set options.config to
-        // a string (path) or boolean true when the flag is present without value.
-        if (options.config) {
-            const configPath = typeof options.config === "string" && options.config.trim().length > 0
-                ? options.config
-                : "./schemantic.config.json";
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        let configPath = typeof options.config === 'string' ? path.resolve(options.config) : undefined;
+        if (!configPath) {
+            for (const name of ['schemantic.config.json', 'schemantic.config.cjs', 'schemantic.config.js']) {
+                const candidate = path.resolve(name);
+                try {
+                    await fs.access(candidate);
+                    configPath = candidate;
+                    break;
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+            }
+            if (options.config && !configPath)
+                throw new Error('No schemantic.config.json/.cjs/.js found in the current directory');
+        }
+        if (configPath) {
             const configFile = await this.loadConfigFile(configPath);
+            const directory = path.dirname(configPath);
+            this.pluginDirectory = directory;
+            if (configFile.schemaFile)
+                configFile.schemaFile = path.resolve(directory, configFile.schemaFile);
+            if (configFile.outputDir)
+                configFile.outputDir = path.resolve(directory, configFile.outputDir);
+            if (configFile.plugins)
+                configFile.plugins = configFile.plugins.map(plugin => ({
+                    ...plugin,
+                    name: plugins_1.PluginLoader.isFileSpecifier(plugin.name) ? path.resolve(directory, plugin.name) : plugin.name,
+                }));
             config = { ...config, ...configFile };
         }
         // Handle source parameter (URL or file path)
         if (source) {
+            delete config.schemaUrl;
+            delete config.schemaFile;
+            delete config.schemaData;
             if (source.startsWith("http://") || source.startsWith("https://")) {
                 config.schemaUrl = source;
             }
@@ -332,19 +407,25 @@ class SchemanticCli {
         }
         // Override with command line options
         if (options.url) {
+            delete config.schemaFile;
+            delete config.schemaData;
             config.schemaUrl = options.url;
         }
         if (options.file) {
+            delete config.schemaUrl;
+            delete config.schemaData;
             config.schemaFile = options.file;
         }
-        if (options.output) {
+        if (options.output !== undefined) {
             config.outputDir = options.output;
         }
         if (options.types) {
             config.generateTypes = true;
+            config.generateApiClient = !!options.client;
         }
         if (options.client) {
             config.generateApiClient = true;
+            config.generateTypes = true;
         }
         if (options.hooks) {
             config.generateHooks = true;
@@ -355,10 +436,10 @@ class SchemanticCli {
         if (options.naming) {
             config.namingConvention = options.naming;
         }
-        if (options.prefix) {
+        if (options.prefix !== undefined) {
             config.typePrefix = options.prefix;
         }
-        if (options.suffix) {
+        if (options.suffix !== undefined) {
             config.typeSuffix = options.suffix;
         }
         if (options.excludePaths) {
@@ -380,6 +461,11 @@ class SchemanticCli {
             }));
         }
         // Validate required fields
+        if (!['camelCase', 'snake_case', 'PascalCase'].includes(config.namingConvention)) {
+            throw new Error(`Invalid naming convention: ${config.namingConvention}`);
+        }
+        if (config.generateHooks && !config.generateApiClient)
+            throw new Error('React hooks require API client generation');
         if (!config.schemaUrl && !config.schemaFile && !config.schemaData) {
             throw new Error("Either source parameter, --url, --file, or schema data must be provided");
         }
@@ -389,7 +475,7 @@ class SchemanticCli {
             // ensure we set a concrete string fallback to satisfy strict types
             config.outputDir = core_1.DEFAULT_CONFIG.outputDir || "./src/generated";
         }
-        return config;
+        return (0, configuration_1.resolveConfiguration)(config);
     }
     /**
      * Load configuration file
@@ -399,11 +485,14 @@ class SchemanticCli {
             const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
             const content = await fs.readFile(filePath, "utf-8");
             if (filePath.endsWith(".json")) {
-                return JSON.parse(content);
+                const parsed = JSON.parse(content);
+                return (0, configuration_1.resolveConfiguration)(parsed);
             }
-            else if (filePath.endsWith(".js") || filePath.endsWith(".ts")) {
-                const module = await Promise.resolve(`${filePath}`).then(s => __importStar(require(s)));
-                return module.default || module;
+            else if (filePath.endsWith(".js") || filePath.endsWith(".cjs")) {
+                const configModule = (0, module_1.createRequire)(path.resolve(filePath))(path.resolve(filePath));
+                const loaded = configModule && typeof configModule === 'object' && 'default' in configModule
+                    ? configModule.default : configModule;
+                return (0, configuration_1.resolveConfiguration)(loaded);
             }
             else {
                 throw new Error(`Unsupported configuration file format: ${filePath}`);
@@ -418,15 +507,19 @@ class SchemanticCli {
      */
     async loadPlugins(config, Schemantic) {
         const pluginManager = Schemantic.getPluginManager();
-        // Load built-in plugins
-        const builtinPlugins = (0, builtin_1.getBuiltinPlugins)();
-        for (const plugin of builtinPlugins) {
-            pluginManager.registerPlugin(plugin);
-        }
         // Load configured plugins
+        const loader = new plugins_1.PluginLoader();
         if (config.plugins) {
             for (const pluginConfig of config.plugins) {
                 if (pluginConfig.enabled) {
+                    if (!pluginManager.getPlugin(pluginConfig.name)) {
+                        const plugin = await loader.loadPlugin(pluginConfig.name, this.pluginDirectory);
+                        if (pluginManager.getPlugin(plugin.name))
+                            throw new Error(`Duplicate plugin name: ${plugin.name}`);
+                        pluginManager.registerPlugin(plugin);
+                        // The config and instance share this entry; generation uses the resolved exported name.
+                        pluginConfig.name = plugin.name;
+                    }
                     pluginManager.enablePlugin(pluginConfig.name);
                 }
             }
@@ -481,11 +574,21 @@ class SchemanticCli {
      * Handle errors
      */
     handleError(error, options) {
-        if (options.quiet) {
-            process.exit(1);
-        }
-        console.error("❌ Error:", error);
-        process.exit(1);
+        process.exitCode = 1;
+        if (!options.quiet)
+            console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+    }
+    outputEffectiveConfiguration(config, options) {
+        if (!options.verbose || options.quiet)
+            return;
+        console.log('Effective configuration:', JSON.stringify({
+            source: config.schemaFile || config.schemaUrl || '<in-memory schema>',
+            output: config.outputDir,
+            generateTypes: config.generateTypes,
+            generateApiClient: config.generateApiClient,
+            generateHooks: config.generateHooks,
+            plugins: config.plugins?.filter(plugin => plugin.enabled).map(plugin => plugin.name) || [],
+        }, null, 2));
     }
     /**
      * Run interactive mode
@@ -517,16 +620,19 @@ class SchemanticCli {
             config.generateTypes = generateTypes !== false;
             const generateClient = await this.askYesNo(rl, "Generate API client? (Y/n): ");
             config.generateApiClient = generateClient !== false;
-            const generateHooks = await this.askYesNo(rl, "Generate React hooks? (y/N): ");
+            const generateHooks = await this.askYesNo(rl, "Generate React hooks? (y/N): ", false);
             config.generateHooks = generateHooks === true;
             const strictTypes = await this.askYesNo(rl, "Use strict TypeScript types? (Y/n): ");
             config.useStrictTypes = strictTypes !== false;
             // Create Schemantic instance and generate
-            const schemanticInstance = new schemantic_1.Schemantic(config);
-            await this.loadPlugins(config, schemanticInstance);
+            const resolvedConfig = (0, configuration_1.resolveConfiguration)(config);
+            const schemanticInstance = new schemantic_1.Schemantic(resolvedConfig);
+            await this.loadPlugins(resolvedConfig, schemanticInstance);
             console.log("\n⚙️ Generating types and API client...");
             const result = await schemanticInstance.generate();
             this.outputResults(result, {});
+            if (!result.success)
+                process.exitCode = 1;
         }
         finally {
             rl.close();
@@ -535,14 +641,14 @@ class SchemanticCli {
     /**
      * Run init interactive mode
      */
-    async runInitInteractive(directory, _options) {
+    async runInitInteractive(directory, options) {
         console.log("🚀 Schemantic Configuration Initialization\n");
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
         });
         try {
-            const config = { ...core_1.DEFAULT_CONFIG };
+            const config = this.templateConfig(options);
             // Get schema source
             const schemaSource = await this.askQuestion(rl, "Enter default OpenAPI schema URL or file path: ");
             if (schemaSource.startsWith("http")) {
@@ -563,14 +669,14 @@ class SchemanticCli {
             // Get generation options
             const generateTypes = await this.askYesNo(rl, "Generate types by default? (Y/n): ");
             config.generateTypes = generateTypes !== false;
-            const generateClient = await this.askYesNo(rl, "Generate API client by default? (Y/n): ");
+            const generateClient = await this.askYesNo(rl, options.template === 'types' ? "Generate API client by default? (y/N): " : "Generate API client by default? (Y/n): ", options.template !== 'types');
             config.generateApiClient = generateClient !== false;
-            const generateHooks = await this.askYesNo(rl, "Generate React hooks by default? (y/N): ");
+            const generateHooks = await this.askYesNo(rl, options.template === 'react' ? "Generate React hooks by default? (Y/n): " : "Generate React hooks by default? (y/N): ", options.template === 'react');
             config.generateHooks = generateHooks === true;
             const strictTypes = await this.askYesNo(rl, "Use strict TypeScript types by default? (Y/n): ");
             config.useStrictTypes = strictTypes !== false;
             // Save configuration
-            await this.saveConfig(directory, config);
+            await this.saveConfig(directory, (0, configuration_1.resolveConfiguration)(config), !!options.force);
             console.log("\n✅ Configuration saved to schemantic.config.json");
         }
         finally {
@@ -580,14 +686,14 @@ class SchemanticCli {
     /**
      * Create default configuration
      */
-    async createDefaultConfig(directory) {
+    async createDefaultConfig(directory, options) {
         const config = {
-            ...core_1.DEFAULT_CONFIG,
+            ...this.templateConfig(options),
             outputDir: "./src/generated",
             typePrefix: "",
             generateTypes: true,
-            generateApiClient: true,
-            generateHooks: false,
+            generateApiClient: options.template !== 'types',
+            generateHooks: options.template === 'react',
             useStrictTypes: true,
             namingConvention: "camelCase",
             typeSuffix: "",
@@ -597,17 +703,28 @@ class SchemanticCli {
             preserveComments: true,
             generateIndexFile: true,
         };
-        await this.saveConfig(directory, config);
+        await this.saveConfig(directory, config, !!options.force);
         console.log("✅ Default configuration created");
     }
     /**
      * Save configuration to file
      */
-    async saveConfig(directory, config) {
+    async saveConfig(directory, config, force = false) {
         const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
         const path = await Promise.resolve().then(() => __importStar(require("path")));
         const configPath = path.join(directory, "schemantic.config.json");
-        await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+        await fs.mkdir(directory, { recursive: true });
+        try {
+            await fs.writeFile(configPath, JSON.stringify(config, null, 2), { encoding: 'utf-8', flag: force ? 'w' : 'wx' });
+        }
+        catch (error) {
+            if (error.code === 'EEXIST')
+                throw new Error(`Configuration already exists: ${configPath}; use init --force to replace it`);
+            throw error;
+        }
+    }
+    templateConfig(options) {
+        return { ...core_1.DEFAULT_CONFIG, outputDir: './src/generated', generateApiClient: options.template !== 'types', generateHooks: options.template === 'react' };
     }
     /**
      * Ask a question and return the answer
@@ -620,16 +737,20 @@ class SchemanticCli {
     /**
      * Ask a yes/no question and return boolean
      */
-    askYesNo(rl, question) {
-        return new Promise((resolve) => {
+    askYesNo(rl, question, defaultValue = true) {
+        return new Promise((resolve, reject) => {
             rl.question(question, (answer) => {
                 const normalized = answer.toLowerCase().trim();
-                if (normalized === "" || normalized === "y" || normalized === "yes") {
+                if (normalized === '')
+                    resolve(defaultValue);
+                else if (normalized === "y" || normalized === "yes") {
                     resolve(true);
                 }
-                else {
+                else if (normalized === 'n' || normalized === 'no') {
                     resolve(false);
                 }
+                else
+                    reject(new Error('Answer yes or no'));
             });
         });
     }
@@ -637,7 +758,7 @@ class SchemanticCli {
      * Ask a choice question and return selected option
      */
     askChoice(rl, question, choices, defaultChoice) {
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             rl.question(question, (answer) => {
                 const normalized = answer.toLowerCase().trim();
                 if (normalized === "") {
@@ -645,7 +766,10 @@ class SchemanticCli {
                 }
                 else {
                     const choice = choices.find((c) => c.toLowerCase() === normalized);
-                    resolve(choice || defaultChoice);
+                    if (choice)
+                        resolve(choice);
+                    else
+                        reject(new Error(`Choose one of: ${choices.join(', ')}`));
                 }
             });
         });
@@ -653,8 +777,8 @@ class SchemanticCli {
     /**
      * Run the CLI
      */
-    run() {
-        this.program.parse();
+    async run(argv) {
+        await this.program.parseAsync(argv);
     }
 }
 exports.SchemanticCli = SchemanticCli;
@@ -662,6 +786,6 @@ exports.SchemanticCli = SchemanticCli;
 exports.cli = new SchemanticCli();
 // Run CLI if this file is executed directly
 if (require.main === module) {
-    exports.cli.run();
+    void exports.cli.run();
 }
 //# sourceMappingURL=index.js.map