@brainfish-ai/devdoc 0.1.45 → 0.1.46

package/dist/cli/commands/sdk.js

@@ -0,0 +1,365 @@
+"use strict";
+/**
+ * SDK Generation CLI Commands
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdkInit = sdkInit;
+exports.sdkGenerate = sdkGenerate;
+exports.sdkValidate = sdkValidate;
+exports.sdkList = sdkList;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const logger_1 = require("../../utils/logger");
+const sdk_1 = require("../../sdk");
+// Simple prompt helper
+async function prompt(question, defaultValue) {
+    const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        const displayQuestion = defaultValue
+            ? `${question} (${defaultValue}): `
+            : `${question}: `;
+        rl.question(displayQuestion, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+}
+async function promptMultiSelect(question, choices) {
+    console.log(`\n${question}\n`);
+    choices.forEach((choice, i) => {
+        const marker = choice.checked ? '[x]' : '[ ]';
+        console.log(`  ${i + 1}. ${marker} ${choice.label}`);
+    });
+    console.log();
+    console.log('Enter numbers separated by commas (e.g., 1,2,3):');
+    const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question('> ', (answer) => {
+            rl.close();
+            if (!answer.trim()) {
+                // Return defaults
+                resolve(choices.filter((c) => c.checked).map((c) => c.value));
+                return;
+            }
+            const indices = answer
+                .split(',')
+                .map((s) => parseInt(s.trim(), 10) - 1)
+                .filter((i) => i >= 0 && i < choices.length);
+            resolve(indices.map((i) => choices[i].value));
+        });
+    });
+}
+/**
+ * Initialize SDK configuration
+ */
+async function sdkInit(options) {
+    console.log();
+    logger_1.logger.info('🔧 Initialize SDK Generation');
+    console.log();
+    const projectRoot = process.cwd();
+    // Find OpenAPI spec if not provided
+    let openapiPath = options.openapi;
+    if (!openapiPath) {
+        // Look for common OpenAPI spec locations
+        const commonPaths = [
+            'openapi.json',
+            'openapi.yaml',
+            'openapi.yml',
+            'api-reference/openapi.json',
+            'api-reference/openapi.yaml',
+            'api-reference/openapi.yml',
+            'docs/openapi.json',
+            'spec/openapi.json',
+        ];
+        for (const p of commonPaths) {
+            if (await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, p))) {
+                openapiPath = p;
+                logger_1.logger.info(`Found OpenAPI spec at: ${p}`);
+                break;
+            }
+        }
+        if (!openapiPath) {
+            openapiPath = await prompt('Path to OpenAPI specification', './openapi.json');
+        }
+    }
+    // Validate spec exists
+    const fullSpecPath = path_1.default.resolve(projectRoot, openapiPath);
+    if (!(await fs_extra_1.default.pathExists(fullSpecPath))) {
+        logger_1.logger.error(`OpenAPI specification not found: ${openapiPath}`);
+        process.exit(1);
+    }
+    // Get package name
+    let packageName = options.packageName;
+    if (!packageName) {
+        // Try to get from docs.json or package.json
+        const docsJsonPath = path_1.default.join(projectRoot, 'docs.json');
+        const pkgJsonPath = path_1.default.join(projectRoot, 'package.json');
+        if (await fs_extra_1.default.pathExists(docsJsonPath)) {
+            const docsJson = await fs_extra_1.default.readJson(docsJsonPath);
+            packageName = docsJson.name?.toLowerCase().replace(/\s+/g, '-');
+        }
+        else if (await fs_extra_1.default.pathExists(pkgJsonPath)) {
+            const pkgJson = await fs_extra_1.default.readJson(pkgJsonPath);
+            packageName = pkgJson.name;
+        }
+        packageName = await prompt('Base package name', packageName || 'api-sdk');
+    }
+    // Select languages
+    const generators = (0, sdk_1.getGeneratorInfo)();
+    const languageChoices = generators.map((g) => ({
+        value: g.language,
+        label: `${g.displayName}${g.native ? ' (recommended)' : g.requiresJava ? ' (requires Java)' : ''}`,
+        checked: g.language === 'typescript' || g.language === 'python',
+    }));
+    const selectedLanguages = (await promptMultiSelect('Select languages to generate:', languageChoices));
+    if (selectedLanguages.length === 0) {
+        logger_1.logger.error('At least one language must be selected');
+        process.exit(1);
+    }
+    // Create configuration
+    try {
+        const { configPath, config } = await (0, sdk_1.initSDKConfig)(projectRoot, {
+            openapi: openapiPath,
+            packageName,
+            languages: selectedLanguages,
+            force: options.force,
+        });
+        console.log();
+        logger_1.logger.success(`Created ${path_1.default.basename(configPath)}`);
+        console.log();
+        console.log('Configuration:');
+        console.log(`  OpenAPI spec: ${config.openapi}`);
+        console.log(`  Package name: ${config.packageName}`);
+        console.log(`  Languages: ${selectedLanguages.join(', ')}`);
+        console.log(`  Output: ${config.output}`);
+        console.log();
+        console.log('Next steps:');
+        console.log("  Run 'devdoc sdk generate' to generate SDKs");
+        console.log("  Run 'devdoc sdk generate --preview' to preview without overwriting");
+        console.log();
+    }
+    catch (error) {
+        logger_1.logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+/**
+ * Generate SDKs
+ */
+async function sdkGenerate(options) {
+    console.log();
+    logger_1.logger.info('📦 Generate SDKs');
+    console.log();
+    const projectRoot = process.cwd();
+    // Validate language option if provided
+    if (options.lang && !sdk_1.SUPPORTED_LANGUAGES.includes(options.lang)) {
+        logger_1.logger.error(`Unsupported language: ${options.lang}`);
+        console.log();
+        console.log('Supported languages:');
+        sdk_1.SUPPORTED_LANGUAGES.forEach((lang) => {
+            console.log(`  - ${lang}`);
+        });
+        process.exit(1);
+    }
+    try {
+        // Check if config exists
+        const { config, error } = await (0, sdk_1.loadSDKConfig)(projectRoot);
+        if (!config) {
+            logger_1.logger.error(error || 'SDK configuration not found');
+            console.log();
+            console.log("Run 'devdoc sdk init' to create a configuration");
+            process.exit(1);
+        }
+        // Validate spec first
+        const specPath = (0, sdk_1.resolveSpecPath)(projectRoot, config.openapi);
+        logger_1.logger.info('Validating OpenAPI spec...');
+        const validation = await (0, sdk_1.validateSpec)(specPath);
+        if (!validation.valid) {
+            logger_1.logger.error('OpenAPI specification is invalid:');
+            validation.errors.forEach((err) => console.log(`  - ${err}`));
+            process.exit(1);
+        }
+        if (validation.warnings.length > 0) {
+            validation.warnings.forEach((warn) => logger_1.logger.warn(warn));
+        }
+        logger_1.logger.success('OpenAPI spec is valid');
+        console.log();
+        // Generate SDKs
+        logger_1.logger.info('Generating SDKs...');
+        console.log();
+        const result = await (0, sdk_1.generateSDKs)(projectRoot, {
+            language: options.lang,
+            preview: options.preview,
+            outputDir: options.output,
+        });
+        // Display results
+        for (const r of result.results) {
+            const generator = (0, sdk_1.getGeneratorInfo)().find((g) => g.language === r.language);
+            const displayName = generator?.displayName || r.language;
+            if (r.success) {
+                const relPath = path_1.default.relative(projectRoot, r.outputPath);
+                logger_1.logger.success(`${displayName.padEnd(12)} ./${relPath.padEnd(25)} ${(r.duration / 1000).toFixed(1)}s`);
+            }
+            else {
+                logger_1.logger.error(`${displayName.padEnd(12)} Failed: ${r.error}`);
+            }
+        }
+        console.log();
+        if (result.failureCount > 0) {
+            logger_1.logger.warn(`Generated ${result.successCount} SDK(s), ${result.failureCount} failed`);
+        }
+        else {
+            logger_1.logger.success(`Generated ${result.successCount} SDK(s) in ${(result.totalDuration / 1000).toFixed(1)}s`);
+        }
+        // Show next steps
+        if (result.successCount > 0) {
+            console.log();
+            console.log('Next steps:');
+            for (const r of result.results.filter((r) => r.success)) {
+                const relPath = path_1.default.relative(projectRoot, r.outputPath);
+                switch (r.language) {
+                    case 'typescript':
+                        console.log(`  cd ${relPath} && npm install`);
+                        break;
+                    case 'python':
+                        console.log(`  cd ${relPath} && pip install -e .`);
+                        break;
+                    case 'go':
+                        console.log(`  # Import from ${relPath}`);
+                        break;
+                    default:
+                        console.log(`  # See ${relPath}/README.md`);
+                }
+            }
+            console.log();
+        }
+    }
+    catch (error) {
+        logger_1.logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+/**
+ * Validate OpenAPI specification
+ */
+async function sdkValidate(specPath) {
+    console.log();
+    logger_1.logger.info('🔍 Validate OpenAPI Specification');
+    console.log();
+    const projectRoot = process.cwd();
+    // Get spec path from config if not provided
+    if (!specPath) {
+        const { config } = await (0, sdk_1.loadSDKConfig)(projectRoot);
+        if (config) {
+            specPath = config.openapi;
+        }
+        else {
+            logger_1.logger.error('No spec path provided and no sdk.json found');
+            process.exit(1);
+        }
+    }
+    const fullPath = (0, sdk_1.resolveSpecPath)(projectRoot, specPath);
+    logger_1.logger.info(`Validating: ${specPath}`);
+    console.log();
+    const result = await (0, sdk_1.validateSpec)(fullPath);
+    if (result.errors.length > 0) {
+        logger_1.logger.error('Errors:');
+        result.errors.forEach((err) => console.log(`  ✗ ${err}`));
+        console.log();
+    }
+    if (result.warnings.length > 0) {
+        logger_1.logger.warn('Warnings:');
+        result.warnings.forEach((warn) => console.log(`  ⚠ ${warn}`));
+        console.log();
+    }
+    if (result.valid) {
+        logger_1.logger.success('Specification is valid');
+    }
+    else {
+        logger_1.logger.error('Specification is invalid');
+        process.exit(1);
+    }
+}
+/**
+ * List available generators and their status
+ */
+async function sdkList() {
+    console.log();
+    logger_1.logger.info('📋 SDK Generators');
+    console.log();
+    const projectRoot = process.cwd();
+    const { config } = await (0, sdk_1.loadSDKConfig)(projectRoot);
+    const enabledLanguages = config ? (0, sdk_1.getEnabledGenerators)(config) : [];
+    const generators = (0, sdk_1.getGeneratorInfo)();
+    console.log('Available generators:\n');
+    // Native generators (no Java required)
+    console.log('Native (no Java required):');
+    for (const g of generators.filter((g) => g.native)) {
+        const enabled = enabledLanguages.includes(g.language);
+        const status = enabled ? logger_1.logger.green('enabled') : logger_1.logger.yellow('disabled');
+        console.log(`  ${g.displayName.padEnd(12)} ${status}`);
+    }
+    console.log();
+    // Java-based generators
+    console.log('OpenAPI Generator (requires Java):');
+    for (const g of generators.filter((g) => g.requiresJava)) {
+        const enabled = enabledLanguages.includes(g.language);
+        const status = enabled ? logger_1.logger.green('enabled') : logger_1.logger.yellow('disabled');
+        console.log(`  ${g.displayName.padEnd(12)} ${status}`);
+    }
+    console.log();
+    if (!config) {
+        console.log("No sdk.json found. Run 'devdoc sdk init' to configure generators.");
+    }
+    else {
+        console.log(`Configuration: sdk.json`);
+        console.log(`OpenAPI spec: ${config.openapi}`);
+        console.log(`Enabled: ${enabledLanguages.join(', ') || 'none'}`);
+    }
+    console.log();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk.js","sourceRoot":"","sources":["../../../src/cli/commands/sdk.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SDK Generation CLI Commands\n */\n\nimport path from 'path';\nimport fs from 'fs-extra';\nimport { logger } from '../../utils/logger';\nimport {\n  generateSDKs,\n  validateSpec,\n  initSDKConfig,\n  loadSDKConfig,\n  getEnabledGenerators,\n  getGeneratorInfo,\n  resolveSpecPath,\n  isNativeGenerator,\n  SDKLanguage,\n  SUPPORTED_LANGUAGES,\n} from '../../sdk';\n\n// Simple prompt helper\nasync function prompt(question: string, defaultValue?: string): Promise<string> {\n  const readline = await import('readline');\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise((resolve) => {\n    const displayQuestion = defaultValue\n      ? `${question} (${defaultValue}): `\n      : `${question}: `;\n\n    rl.question(displayQuestion, (answer) => {\n      rl.close();\n      resolve(answer.trim() || defaultValue || '');\n    });\n  });\n}\n\nasync function promptMultiSelect(\n  question: string,\n  choices: { value: string; label: string; checked?: boolean }[]\n): Promise<string[]> {\n  console.log(`\\n${question}\\n`);\n  choices.forEach((choice, i) => {\n    const marker = choice.checked ? '[x]' : '[ ]';\n    console.log(`  ${i + 1}. ${marker} ${choice.label}`);\n  });\n  console.log();\n  console.log('Enter numbers separated by commas (e.g., 1,2,3):');\n\n  const readline = await import('readline');\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise((resolve) => {\n    rl.question('> ', (answer) => {\n      rl.close();\n      if (!answer.trim()) {\n        // Return defaults\n        resolve(choices.filter((c) => c.checked).map((c) => c.value));\n        return;\n      }\n\n      const indices = answer\n        .split(',')\n        .map((s) => parseInt(s.trim(), 10) - 1)\n        .filter((i) => i >= 0 && i < choices.length);\n\n      resolve(indices.map((i) => choices[i].value));\n    });\n  });\n}\n\ninterface SDKInitOptions {\n  openapi?: string;\n  packageName?: string;\n  force?: boolean;\n}\n\n/**\n * Initialize SDK configuration\n */\nexport async function sdkInit(options: SDKInitOptions): Promise<void> {\n  console.log();\n  logger.info('🔧 Initialize SDK Generation');\n  console.log();\n\n  const projectRoot = process.cwd();\n\n  // Find OpenAPI spec if not provided\n  let openapiPath = options.openapi;\n\n  if (!openapiPath) {\n    // Look for common OpenAPI spec locations\n    const commonPaths = [\n      'openapi.json',\n      'openapi.yaml',\n      'openapi.yml',\n      'api-reference/openapi.json',\n      'api-reference/openapi.yaml',\n      'api-reference/openapi.yml',\n      'docs/openapi.json',\n      'spec/openapi.json',\n    ];\n\n    for (const p of commonPaths) {\n      if (await fs.pathExists(path.join(projectRoot, p))) {\n        openapiPath = p;\n        logger.info(`Found OpenAPI spec at: ${p}`);\n        break;\n      }\n    }\n\n    if (!openapiPath) {\n      openapiPath = await prompt('Path to OpenAPI specification', './openapi.json');\n    }\n  }\n\n  // Validate spec exists\n  const fullSpecPath = path.resolve(projectRoot, openapiPath);\n  if (!(await fs.pathExists(fullSpecPath))) {\n    logger.error(`OpenAPI specification not found: ${openapiPath}`);\n    process.exit(1);\n  }\n\n  // Get package name\n  let packageName = options.packageName;\n  if (!packageName) {\n    // Try to get from docs.json or package.json\n    const docsJsonPath = path.join(projectRoot, 'docs.json');\n    const pkgJsonPath = path.join(projectRoot, 'package.json');\n\n    if (await fs.pathExists(docsJsonPath)) {\n      const docsJson = await fs.readJson(docsJsonPath);\n      packageName = docsJson.name?.toLowerCase().replace(/\\s+/g, '-');\n    } else if (await fs.pathExists(pkgJsonPath)) {\n      const pkgJson = await fs.readJson(pkgJsonPath);\n      packageName = pkgJson.name;\n    }\n\n    packageName = await prompt('Base package name', packageName || 'api-sdk');\n  }\n\n  // Select languages\n  const generators = getGeneratorInfo();\n  const languageChoices = generators.map((g) => ({\n    value: g.language,\n    label: `${g.displayName}${g.native ? ' (recommended)' : g.requiresJava ? ' (requires Java)' : ''}`,\n    checked: g.language === 'typescript' || g.language === 'python',\n  }));\n\n  const selectedLanguages = (await promptMultiSelect(\n    'Select languages to generate:',\n    languageChoices\n  )) as SDKLanguage[];\n\n  if (selectedLanguages.length === 0) {\n    logger.error('At least one language must be selected');\n    process.exit(1);\n  }\n\n  // Create configuration\n  try {\n    const { configPath, config } = await initSDKConfig(projectRoot, {\n      openapi: openapiPath,\n      packageName,\n      languages: selectedLanguages,\n      force: options.force,\n    });\n\n    console.log();\n    logger.success(`Created ${path.basename(configPath)}`);\n    console.log();\n    console.log('Configuration:');\n    console.log(`  OpenAPI spec: ${config.openapi}`);\n    console.log(`  Package name: ${config.packageName}`);\n    console.log(`  Languages: ${selectedLanguages.join(', ')}`);\n    console.log(`  Output: ${config.output}`);\n    console.log();\n    console.log('Next steps:');\n    console.log(\"  Run 'devdoc sdk generate' to generate SDKs\");\n    console.log(\"  Run 'devdoc sdk generate --preview' to preview without overwriting\");\n    console.log();\n  } catch (error) {\n    logger.error(error instanceof Error ? error.message : String(error));\n    process.exit(1);\n  }\n}\n\ninterface SDKGenerateOptions {\n  lang?: string;\n  preview?: boolean;\n  output?: string;\n}\n\n/**\n * Generate SDKs\n */\nexport async function sdkGenerate(options: SDKGenerateOptions): Promise<void> {\n  console.log();\n  logger.info('📦 Generate SDKs');\n  console.log();\n\n  const projectRoot = process.cwd();\n\n  // Validate language option if provided\n  if (options.lang && !SUPPORTED_LANGUAGES.includes(options.lang as SDKLanguage)) {\n    logger.error(`Unsupported language: ${options.lang}`);\n    console.log();\n    console.log('Supported languages:');\n    SUPPORTED_LANGUAGES.forEach((lang) => {\n      console.log(`  - ${lang}`);\n    });\n    process.exit(1);\n  }\n\n  try {\n    // Check if config exists\n    const { config, error } = await loadSDKConfig(projectRoot);\n\n    if (!config) {\n      logger.error(error || 'SDK configuration not found');\n      console.log();\n      console.log(\"Run 'devdoc sdk init' to create a configuration\");\n      process.exit(1);\n    }\n\n    // Validate spec first\n    const specPath = resolveSpecPath(projectRoot, config.openapi);\n    logger.info('Validating OpenAPI spec...');\n    \n    const validation = await validateSpec(specPath);\n    \n    if (!validation.valid) {\n      logger.error('OpenAPI specification is invalid:');\n      validation.errors.forEach((err) => console.log(`  - ${err}`));\n      process.exit(1);\n    }\n    \n    if (validation.warnings.length > 0) {\n      validation.warnings.forEach((warn) => logger.warn(warn));\n    }\n    \n    logger.success('OpenAPI spec is valid');\n    console.log();\n\n    // Generate SDKs\n    logger.info('Generating SDKs...');\n    console.log();\n\n    const result = await generateSDKs(projectRoot, {\n      language: options.lang as SDKLanguage | undefined,\n      preview: options.preview,\n      outputDir: options.output,\n    });\n\n    // Display results\n    for (const r of result.results) {\n      const generator = getGeneratorInfo().find((g) => g.language === r.language);\n      const displayName = generator?.displayName || r.language;\n\n      if (r.success) {\n        const relPath = path.relative(projectRoot, r.outputPath);\n        logger.success(`${displayName.padEnd(12)} ./${relPath.padEnd(25)} ${(r.duration / 1000).toFixed(1)}s`);\n      } else {\n        logger.error(`${displayName.padEnd(12)} Failed: ${r.error}`);\n      }\n    }\n\n    console.log();\n\n    if (result.failureCount > 0) {\n      logger.warn(`Generated ${result.successCount} SDK(s), ${result.failureCount} failed`);\n    } else {\n      logger.success(`Generated ${result.successCount} SDK(s) in ${(result.totalDuration / 1000).toFixed(1)}s`);\n    }\n\n    // Show next steps\n    if (result.successCount > 0) {\n      console.log();\n      console.log('Next steps:');\n      \n      for (const r of result.results.filter((r) => r.success)) {\n        const relPath = path.relative(projectRoot, r.outputPath);\n        \n        switch (r.language) {\n          case 'typescript':\n            console.log(`  cd ${relPath} && npm install`);\n            break;\n          case 'python':\n            console.log(`  cd ${relPath} && pip install -e .`);\n            break;\n          case 'go':\n            console.log(`  # Import from ${relPath}`);\n            break;\n          default:\n            console.log(`  # See ${relPath}/README.md`);\n        }\n      }\n      console.log();\n    }\n  } catch (error) {\n    logger.error(error instanceof Error ? error.message : String(error));\n    process.exit(1);\n  }\n}\n\n/**\n * Validate OpenAPI specification\n */\nexport async function sdkValidate(specPath?: string): Promise<void> {\n  console.log();\n  logger.info('🔍 Validate OpenAPI Specification');\n  console.log();\n\n  const projectRoot = process.cwd();\n\n  // Get spec path from config if not provided\n  if (!specPath) {\n    const { config } = await loadSDKConfig(projectRoot);\n    \n    if (config) {\n      specPath = config.openapi;\n    } else {\n      logger.error('No spec path provided and no sdk.json found');\n      process.exit(1);\n    }\n  }\n\n  const fullPath = resolveSpecPath(projectRoot, specPath);\n  logger.info(`Validating: ${specPath}`);\n  console.log();\n\n  const result = await validateSpec(fullPath);\n\n  if (result.errors.length > 0) {\n    logger.error('Errors:');\n    result.errors.forEach((err) => console.log(`  ✗ ${err}`));\n    console.log();\n  }\n\n  if (result.warnings.length > 0) {\n    logger.warn('Warnings:');\n    result.warnings.forEach((warn) => console.log(`  ⚠ ${warn}`));\n    console.log();\n  }\n\n  if (result.valid) {\n    logger.success('Specification is valid');\n  } else {\n    logger.error('Specification is invalid');\n    process.exit(1);\n  }\n}\n\n/**\n * List available generators and their status\n */\nexport async function sdkList(): Promise<void> {\n  console.log();\n  logger.info('📋 SDK Generators');\n  console.log();\n\n  const projectRoot = process.cwd();\n  const { config } = await loadSDKConfig(projectRoot);\n  const enabledLanguages = config ? getEnabledGenerators(config) : [];\n\n  const generators = getGeneratorInfo();\n\n  console.log('Available generators:\\n');\n\n  // Native generators (no Java required)\n  console.log('Native (no Java required):');\n  for (const g of generators.filter((g) => g.native)) {\n    const enabled = enabledLanguages.includes(g.language);\n    const status = enabled ? logger.green('enabled') : logger.yellow('disabled');\n    console.log(`  ${g.displayName.padEnd(12)} ${status}`);\n  }\n\n  console.log();\n\n  // Java-based generators\n  console.log('OpenAPI Generator (requires Java):');\n  for (const g of generators.filter((g) => g.requiresJava)) {\n    const enabled = enabledLanguages.includes(g.language);\n    const status = enabled ? logger.green('enabled') : logger.yellow('disabled');\n    console.log(`  ${g.displayName.padEnd(12)} ${status}`);\n  }\n\n  console.log();\n\n  if (!config) {\n    console.log(\"No sdk.json found. Run 'devdoc sdk init' to configure generators.\");\n  } else {\n    console.log(`Configuration: sdk.json`);\n    console.log(`OpenAPI spec: ${config.openapi}`);\n    console.log(`Enabled: ${enabledLanguages.join(', ') || 'none'}`);\n  }\n\n  console.log();\n}\n"]}

package/dist/cli/index.js

@@ -13,6 +13,7 @@ const whoami_1 = require("./commands/whoami");
 const upload_1 = require("./commands/upload");
 const ai_1 = require("./commands/ai");
 const domain_1 = require("./commands/domain");
+const sdk_1 = require("./commands/sdk");
 const packageJson = require('../../package.json');
 const program = new commander_1.Command();
 program
@@ -142,5 +143,31 @@ domainCmd
     .option('-u, --url <url>', 'API URL')
     .option('-k, --api-key <key>', 'API key for authentication')
     .action(domain_1.domainRemove);
+// SDK generation
+const sdkCmd = program
+    .command('sdk')
+    .description('Generate client SDKs from OpenAPI specification');
+sdkCmd
+    .command('init')
+    .description('Initialize SDK generation configuration')
+    .option('-o, --openapi <path>', 'Path to OpenAPI specification')
+    .option('-n, --package-name <name>', 'Base package name for generated SDKs')
+    .option('-f, --force', 'Overwrite existing configuration')
+    .action(sdk_1.sdkInit);
+sdkCmd
+    .command('generate')
+    .description('Generate SDKs for configured languages')
+    .option('-l, --lang <language>', 'Generate only for specific language')
+    .option('-p, --preview', 'Preview what would be generated without writing files')
+    .option('-o, --output <dir>', 'Override output directory')
+    .action(sdk_1.sdkGenerate);
+sdkCmd
+    .command('validate [spec]')
+    .description('Validate OpenAPI specification')
+    .action(sdk_1.sdkValidate);
+sdkCmd
+    .command('list')
+    .description('List available generators and their status')
+    .action(sdk_1.sdkList);
 program.parse(process.argv);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { Command } from 'commander';\nimport { create } from './commands/create';\nimport { init } from './commands/init';\nimport { dev } from './commands/dev';\nimport { build } from './commands/build';\nimport { start } from './commands/start';\nimport { check } from './commands/check';\nimport { deploy } from './commands/deploy';\nimport { listKeys, regenerateKey } from './commands/keys';\nimport { whoami } from './commands/whoami';\nimport { upload, listAssets } from './commands/upload';\nimport { ai } from './commands/ai';\nimport { domainAdd, domainStatus, domainVerify, domainRemove } from './commands/domain';\n\nconst packageJson = require('../../package.json');\n\nconst program = new Command();\n\nprogram\n  .name('devdoc')\n  .description('Documentation framework for developers')\n  .version(packageJson.version);\n\nprogram\n  .command('create [project-directory]')\n  .description('Create a new DevDoc documentation site')\n  .option('-t, --template <type>', 'Template to use (basic, openapi, graphql)')\n  .option('-d, --doc-type <type>', 'Documentation type (public, internal)')\n  .option('-s, --subdomain <subdomain>', 'Subdomain for your docs (e.g., my-docs.devdoc.sh)')\n  .option('--no-git', 'Skip git initialization')\n  .option('--no-install', 'Skip installing dependencies')\n  .option('-u, --url <url>', 'API URL (default: https://devdoc.sh)')\n  .action(create);\n\nprogram\n  .command('init')\n  .description('Initialize/register project with Brainfish')\n  .option('-s, --slug <slug>', 'Project slug')\n  .option('--subdomain <subdomain>', 'Subdomain for your docs (e.g., my-docs.devdoc.sh)')\n  .option('-f, --force', 'Overwrite existing .devdoc.json')\n  .option('--ai [tool]', 'Set up AI agents (claude, cursor, both, or just --ai to choose)')\n  .option('-u, --url <url>', 'API URL (default: https://devdoc.sh)')\n  .action(init);\n\nprogram\n  .command('dev')\n  .description('Start development server with hot reload')\n  .option('-p, --port <port>', 'Port to run the server on', '3333')\n  .option('-H, --host <host>', 'Host to bind the server to', 'localhost')\n  .option('-o, --open', 'Open browser automatically', true)\n  .option('--no-open', 'Do not open browser automatically')\n  .action(dev);\n\nprogram\n  .command('build')\n  .description('Build documentation for production')\n  .option('-o, --output <dir>', 'Output directory', 'dist')\n  .action(build);\n\nprogram\n  .command('start')\n  .description('Start production server')\n  .option('-p, --port <port>', 'Port to run the server on', '3000')\n  .action(start);\n\nprogram\n  .command('check')\n  .description('Validate docs.json and MDX files')\n  .action(check);\n\nprogram\n  .command('ai')\n  .description('Set up or update AI agent configuration (Claude Code skills, Cursor rules)')\n  .option('-t, --tool <tool>', 'AI tool to configure (claude, cursor, both)')\n  .option('--update', 'Update existing skills/rules to latest version')\n  .action(ai);\n\nprogram\n  .command('deploy')\n  .description('Deploy documentation to DevDoc platform')\n  .option('-u, --url <url>', 'API URL (default: https://devdoc.sh)')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(deploy);\n\n// Keys management\nconst keysCmd = program\n  .command('keys')\n  .description('Manage API keys for your project');\n\nkeysCmd\n  .command('list')\n  .description('Show current API key info')\n  .option('-u, --url <url>', 'API URL')\n  .action(listKeys);\n\nkeysCmd\n  .command('regenerate')\n  .description('Generate a new API key (invalidates the old one)')\n  .option('-u, --url <url>', 'API URL')\n  .action(regenerateKey);\n\nprogram\n  .command('whoami')\n  .description('Show current project information')\n  .option('-u, --url <url>', 'API URL')\n  .action(whoami);\n\n// Assets management\nconst assetsCmd = program\n  .command('assets')\n  .description('Manage project assets (images, files)');\n\nassetsCmd\n  .command('upload <files...>')\n  .description('Upload assets to storage (max 25MB per file)')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(upload);\n\nassetsCmd\n  .command('list')\n  .description('List uploaded assets')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(listAssets);\n\n// Shortcut for upload\nprogram\n  .command('upload <files...>')\n  .description('Upload assets to storage (shortcut for \"devdoc assets upload\")')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(upload);\n\n// Domain management - custom domains (one per project, free)\nconst domainCmd = program\n  .command('domain')\n  .description('Manage custom domain for your documentation');\n\ndomainCmd\n  .command('add <custom-domain>')\n  .description('Add a custom domain (e.g., docs.example.com)')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(domainAdd);\n\ndomainCmd\n  .command('status')\n  .description('Check custom domain status and DNS configuration')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(domainStatus);\n\ndomainCmd\n  .command('verify')\n  .description('Verify DNS configuration for your custom domain')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(domainVerify);\n\ndomainCmd\n  .command('remove [custom-domain]')\n  .description('Remove custom domain from project')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(domainRemove);\n\nprogram.parse(process.argv);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { Command } from 'commander';\nimport { create } from './commands/create';\nimport { init } from './commands/init';\nimport { dev } from './commands/dev';\nimport { build } from './commands/build';\nimport { start } from './commands/start';\nimport { check } from './commands/check';\nimport { deploy } from './commands/deploy';\nimport { listKeys, regenerateKey } from './commands/keys';\nimport { whoami } from './commands/whoami';\nimport { upload, listAssets } from './commands/upload';\nimport { ai } from './commands/ai';\nimport { domainAdd, domainStatus, domainVerify, domainRemove } from './commands/domain';\nimport { sdkInit, sdkGenerate, sdkValidate, sdkList } from './commands/sdk';\n\nconst packageJson = require('../../package.json');\n\nconst program = new Command();\n\nprogram\n  .name('devdoc')\n  .description('Documentation framework for developers')\n  .version(packageJson.version);\n\nprogram\n  .command('create [project-directory]')\n  .description('Create a new DevDoc documentation site')\n  .option('-t, --template <type>', 'Template to use (basic, openapi, graphql)')\n  .option('-d, --doc-type <type>', 'Documentation type (public, internal)')\n  .option('-s, --subdomain <subdomain>', 'Subdomain for your docs (e.g., my-docs.devdoc.sh)')\n  .option('--no-git', 'Skip git initialization')\n  .option('--no-install', 'Skip installing dependencies')\n  .option('-u, --url <url>', 'API URL (default: https://devdoc.sh)')\n  .action(create);\n\nprogram\n  .command('init')\n  .description('Initialize/register project with Brainfish')\n  .option('-s, --slug <slug>', 'Project slug')\n  .option('--subdomain <subdomain>', 'Subdomain for your docs (e.g., my-docs.devdoc.sh)')\n  .option('-f, --force', 'Overwrite existing .devdoc.json')\n  .option('--ai [tool]', 'Set up AI agents (claude, cursor, both, or just --ai to choose)')\n  .option('-u, --url <url>', 'API URL (default: https://devdoc.sh)')\n  .action(init);\n\nprogram\n  .command('dev')\n  .description('Start development server with hot reload')\n  .option('-p, --port <port>', 'Port to run the server on', '3333')\n  .option('-H, --host <host>', 'Host to bind the server to', 'localhost')\n  .option('-o, --open', 'Open browser automatically', true)\n  .option('--no-open', 'Do not open browser automatically')\n  .action(dev);\n\nprogram\n  .command('build')\n  .description('Build documentation for production')\n  .option('-o, --output <dir>', 'Output directory', 'dist')\n  .action(build);\n\nprogram\n  .command('start')\n  .description('Start production server')\n  .option('-p, --port <port>', 'Port to run the server on', '3000')\n  .action(start);\n\nprogram\n  .command('check')\n  .description('Validate docs.json and MDX files')\n  .action(check);\n\nprogram\n  .command('ai')\n  .description('Set up or update AI agent configuration (Claude Code skills, Cursor rules)')\n  .option('-t, --tool <tool>', 'AI tool to configure (claude, cursor, both)')\n  .option('--update', 'Update existing skills/rules to latest version')\n  .action(ai);\n\nprogram\n  .command('deploy')\n  .description('Deploy documentation to DevDoc platform')\n  .option('-u, --url <url>', 'API URL (default: https://devdoc.sh)')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(deploy);\n\n// Keys management\nconst keysCmd = program\n  .command('keys')\n  .description('Manage API keys for your project');\n\nkeysCmd\n  .command('list')\n  .description('Show current API key info')\n  .option('-u, --url <url>', 'API URL')\n  .action(listKeys);\n\nkeysCmd\n  .command('regenerate')\n  .description('Generate a new API key (invalidates the old one)')\n  .option('-u, --url <url>', 'API URL')\n  .action(regenerateKey);\n\nprogram\n  .command('whoami')\n  .description('Show current project information')\n  .option('-u, --url <url>', 'API URL')\n  .action(whoami);\n\n// Assets management\nconst assetsCmd = program\n  .command('assets')\n  .description('Manage project assets (images, files)');\n\nassetsCmd\n  .command('upload <files...>')\n  .description('Upload assets to storage (max 25MB per file)')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(upload);\n\nassetsCmd\n  .command('list')\n  .description('List uploaded assets')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(listAssets);\n\n// Shortcut for upload\nprogram\n  .command('upload <files...>')\n  .description('Upload assets to storage (shortcut for \"devdoc assets upload\")')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(upload);\n\n// Domain management - custom domains (one per project, free)\nconst domainCmd = program\n  .command('domain')\n  .description('Manage custom domain for your documentation');\n\ndomainCmd\n  .command('add <custom-domain>')\n  .description('Add a custom domain (e.g., docs.example.com)')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(domainAdd);\n\ndomainCmd\n  .command('status')\n  .description('Check custom domain status and DNS configuration')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(domainStatus);\n\ndomainCmd\n  .command('verify')\n  .description('Verify DNS configuration for your custom domain')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(domainVerify);\n\ndomainCmd\n  .command('remove [custom-domain]')\n  .description('Remove custom domain from project')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(domainRemove);\n\n// SDK generation\nconst sdkCmd = program\n  .command('sdk')\n  .description('Generate client SDKs from OpenAPI specification');\n\nsdkCmd\n  .command('init')\n  .description('Initialize SDK generation configuration')\n  .option('-o, --openapi <path>', 'Path to OpenAPI specification')\n  .option('-n, --package-name <name>', 'Base package name for generated SDKs')\n  .option('-f, --force', 'Overwrite existing configuration')\n  .action(sdkInit);\n\nsdkCmd\n  .command('generate')\n  .description('Generate SDKs for configured languages')\n  .option('-l, --lang <language>', 'Generate only for specific language')\n  .option('-p, --preview', 'Preview what would be generated without writing files')\n  .option('-o, --output <dir>', 'Override output directory')\n  .action(sdkGenerate);\n\nsdkCmd\n  .command('validate [spec]')\n  .description('Validate OpenAPI specification')\n  .action(sdkValidate);\n\nsdkCmd\n  .command('list')\n  .description('List available generators and their status')\n  .action(sdkList);\n\nprogram.parse(process.argv);\n"]}

package/dist/sdk/index.d.ts

@@ -0,0 +1,126 @@
+/**
+ * SDK Generation Module
+ *
+ * This module provides functionality for generating client SDKs from OpenAPI specifications.
+ * It supports multiple languages using both native generators and OpenAPI Generator.
+ */
+/**
+ * Supported SDK languages
+ */
+export type SDKLanguage = 'typescript' | 'python' | 'go' | 'java' | 'csharp' | 'ruby' | 'php' | 'swift' | 'kotlin' | 'rust';
+/**
+ * SDK configuration file (sdk.json)
+ */
+export interface SDKConfig {
+    openapi: string;
+    packageName: string;
+    output: string;
+    languages: {
+        [key in SDKLanguage]?: LanguageConfig;
+    };
+}
+/**
+ * Language-specific configuration
+ */
+export interface LanguageConfig {
+    enabled: boolean;
+    packageName?: string;
+    output?: string;
+    additionalOptions?: Record<string, string>;
+}
+/**
+ * Generator information
+ */
+export interface GeneratorInfo {
+    language: SDKLanguage;
+    displayName: string;
+    native: boolean;
+    requiresJava: boolean;
+    generatorName?: string;
+}
+/**
+ * SDK generation result for a single language
+ */
+export interface SDKGenerationResult {
+    language: SDKLanguage;
+    success: boolean;
+    outputPath: string;
+    error?: string;
+    duration: number;
+}
+/**
+ * Overall SDK generation result
+ */
+export interface GenerateSDKsResult {
+    results: SDKGenerationResult[];
+    successCount: number;
+    failureCount: number;
+    totalDuration: number;
+}
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Options for SDK generation
+ */
+export interface GenerateOptions {
+    language?: SDKLanguage;
+    preview?: boolean;
+    outputDir?: string;
+}
+/**
+ * Options for SDK config initialization
+ */
+export interface InitConfigOptions {
+    openapi: string;
+    packageName: string;
+    languages: SDKLanguage[];
+    force?: boolean;
+}
+/**
+ * All supported languages
+ */
+export declare const SUPPORTED_LANGUAGES: SDKLanguage[];
+/**
+ * Load SDK configuration from project directory
+ */
+export declare function loadSDKConfig(projectRoot: string): Promise<{
+    config: SDKConfig | null;
+    error?: string;
+}>;
+/**
+ * Initialize SDK configuration
+ */
+export declare function initSDKConfig(projectRoot: string, options: InitConfigOptions): Promise<{
+    configPath: string;
+    config: SDKConfig;
+}>;
+/**
+ * Get enabled generators from config
+ */
+export declare function getEnabledGenerators(config: SDKConfig): SDKLanguage[];
+/**
+ * Get generator information for all languages
+ */
+export declare function getGeneratorInfo(): GeneratorInfo[];
+/**
+ * Check if a generator is native (doesn't require Java)
+ */
+export declare function isNativeGenerator(language: SDKLanguage): boolean;
+/**
+ * Resolve OpenAPI spec path relative to project root
+ */
+export declare function resolveSpecPath(projectRoot: string, specPath: string): string;
+/**
+ * Validate an OpenAPI specification
+ */
+export declare function validateSpec(specPath: string): Promise<ValidationResult>;
+/**
+ * Generate SDKs for configured languages
+ */
+export declare function generateSDKs(projectRoot: string, options?: GenerateOptions): Promise<GenerateSDKsResult>;