@brainfish-ai/devdoc 0.1.21

package/dist/cli/commands/check.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = check;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const config_1 = require("../../config");
+const logger_1 = require("../../utils/logger");
+async function check() {
+    const projectRoot = process.cwd();
+    let hasErrors = false;
+    logger_1.logger.info('Checking documentation project...\n');
+    // Check for docs.json
+    const configPath = path_1.default.join(projectRoot, 'docs.json');
+    if (!fs_extra_1.default.existsSync(configPath)) {
+        logger_1.logger.error('✗ docs.json not found');
+        process.exit(1);
+    }
+    logger_1.logger.success('✓ docs.json found');
+    // Load and validate config
+    let config;
+    try {
+        config = await (0, config_1.loadConfig)(projectRoot);
+        logger_1.logger.success('✓ docs.json is valid JSON');
+    }
+    catch (error) {
+        logger_1.logger.error(`✗ Invalid JSON in docs.json: ${error.message}`);
+        process.exit(1);
+    }
+    // Validate config schema
+    const validation = (0, config_1.validateConfig)(config);
+    if (validation.valid) {
+        logger_1.logger.success('✓ docs.json schema is valid');
+    }
+    else {
+        logger_1.logger.error('✗ docs.json schema validation failed:');
+        validation.errors.forEach(err => {
+            logger_1.logger.error(`  - ${err}`);
+        });
+        hasErrors = true;
+    }
+    // Check navigation pages exist
+    if (config.navigation) {
+        logger_1.logger.info('\nChecking navigation pages...');
+        // Handle both old array format and new tabs format
+        const groups = [];
+        if (Array.isArray(config.navigation)) {
+            // Old format: navigation is an array of groups
+            groups.push(...config.navigation);
+        }
+        else if (config.navigation.tabs) {
+            // New format: navigation.tabs contains tabs with groups
+            for (const tab of config.navigation.tabs) {
+                if (tab.groups) {
+                    groups.push(...tab.groups);
+                }
+            }
+        }
+        for (const group of groups) {
+            if (group.pages) {
+                checkPages(projectRoot, group.pages, (found, pagePath) => {
+                    if (found) {
+                        logger_1.logger.success(`  ✓ ${pagePath}`);
+                    }
+                    else {
+                        logger_1.logger.error(`  ✗ ${pagePath} - file not found`);
+                        hasErrors = true;
+                    }
+                });
+            }
+        }
+    }
+    // Check for MDX files
+    logger_1.logger.info('\nScanning for MDX files...');
+    const mdxFiles = findMdxFiles(projectRoot);
+    logger_1.logger.info(`  Found ${mdxFiles.length} MDX file(s)`);
+    // Check for public assets
+    const publicDir = path_1.default.join(projectRoot, 'public');
+    if (fs_extra_1.default.existsSync(publicDir)) {
+        const publicFiles = await fs_extra_1.default.readdir(publicDir);
+        logger_1.logger.success(`✓ public/ directory found (${publicFiles.length} files)`);
+    }
+    else {
+        logger_1.logger.warn('⚠ public/ directory not found (optional)');
+    }
+    // Summary
+    console.log('');
+    if (hasErrors) {
+        logger_1.logger.error('Check completed with errors');
+        process.exit(1);
+    }
+    else {
+        logger_1.logger.success('All checks passed!');
+        process.exit(0);
+    }
+}
+/**
+ * Recursively check pages in navigation (handles nested groups)
+ */
+function checkPages(projectRoot, pages, callback) {
+    for (const page of pages) {
+        if (typeof page === 'string') {
+            // Simple page path
+            const mdxPath = path_1.default.join(projectRoot, `${page}.mdx`);
+            const mdPath = path_1.default.join(projectRoot, `${page}.md`);
+            callback(fs_extra_1.default.existsSync(mdxPath) || fs_extra_1.default.existsSync(mdPath), page);
+        }
+        else if (page.group && page.pages) {
+            // Nested group
+            checkPages(projectRoot, page.pages, callback);
+        }
+        else if (page.page) {
+            // Page object with explicit page property
+            const mdxPath = path_1.default.join(projectRoot, `${page.page}.mdx`);
+            const mdPath = path_1.default.join(projectRoot, `${page.page}.md`);
+            callback(fs_extra_1.default.existsSync(mdxPath) || fs_extra_1.default.existsSync(mdPath), page.page);
+        }
+    }
+}
+/**
+ * Recursively find all MDX files in a directory
+ */
+function findMdxFiles(dir, files = []) {
+    const items = fs_extra_1.default.readdirSync(dir);
+    for (const item of items) {
+        // Skip common directories
+        if (['node_modules', 'dist', '.next', '.git'].includes(item)) {
+            continue;
+        }
+        const fullPath = path_1.default.join(dir, item);
+        const stat = fs_extra_1.default.statSync(fullPath);
+        if (stat.isDirectory()) {
+            findMdxFiles(fullPath, files);
+        }
+        else if (item.endsWith('.mdx') || item.endsWith('.md')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"check.js","sourceRoot":"","sources":["../../../src/cli/commands/check.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'path';\nimport fs from 'fs-extra';\nimport { loadConfig, validateConfig } from '../../config';\nimport { logger } from '../../utils/logger';\n\nexport async function check(): Promise<void> {\n  const projectRoot = process.cwd();\n  let hasErrors = false;\n  \n  logger.info('Checking documentation project...\\n');\n  \n  // Check for docs.json\n  const configPath = path.join(projectRoot, 'docs.json');\n  if (!fs.existsSync(configPath)) {\n    logger.error('✗ docs.json not found');\n    process.exit(1);\n  }\n  logger.success('✓ docs.json found');\n  \n  // Load and validate config\n  let config: any;\n  try {\n    config = await loadConfig(projectRoot);\n    logger.success('✓ docs.json is valid JSON');\n  } catch (error: any) {\n    logger.error(`✗ Invalid JSON in docs.json: ${error.message}`);\n    process.exit(1);\n  }\n  \n  // Validate config schema\n  const validation = validateConfig(config);\n  if (validation.valid) {\n    logger.success('✓ docs.json schema is valid');\n  } else {\n    logger.error('✗ docs.json schema validation failed:');\n    validation.errors.forEach(err => {\n      logger.error(`  - ${err}`);\n    });\n    hasErrors = true;\n  }\n  \n  // Check navigation pages exist\n  if (config.navigation) {\n    logger.info('\\nChecking navigation pages...');\n    \n    // Handle both old array format and new tabs format\n    const groups: any[] = [];\n    \n    if (Array.isArray(config.navigation)) {\n      // Old format: navigation is an array of groups\n      groups.push(...config.navigation);\n    } else if (config.navigation.tabs) {\n      // New format: navigation.tabs contains tabs with groups\n      for (const tab of config.navigation.tabs) {\n        if (tab.groups) {\n          groups.push(...tab.groups);\n        }\n      }\n    }\n    \n    for (const group of groups) {\n      if (group.pages) {\n        checkPages(projectRoot, group.pages, (found, pagePath) => {\n          if (found) {\n            logger.success(`  ✓ ${pagePath}`);\n          } else {\n            logger.error(`  ✗ ${pagePath} - file not found`);\n            hasErrors = true;\n          }\n        });\n      }\n    }\n  }\n  \n  // Check for MDX files\n  logger.info('\\nScanning for MDX files...');\n  const mdxFiles = findMdxFiles(projectRoot);\n  logger.info(`  Found ${mdxFiles.length} MDX file(s)`);\n  \n  // Check for public assets\n  const publicDir = path.join(projectRoot, 'public');\n  if (fs.existsSync(publicDir)) {\n    const publicFiles = await fs.readdir(publicDir);\n    logger.success(`✓ public/ directory found (${publicFiles.length} files)`);\n  } else {\n    logger.warn('⚠ public/ directory not found (optional)');\n  }\n  \n  // Summary\n  console.log('');\n  if (hasErrors) {\n    logger.error('Check completed with errors');\n    process.exit(1);\n  } else {\n    logger.success('All checks passed!');\n    process.exit(0);\n  }\n}\n\n/**\n * Recursively check pages in navigation (handles nested groups)\n */\nfunction checkPages(\n  projectRoot: string, \n  pages: any[], \n  callback: (found: boolean, pagePath: string) => void\n): void {\n  for (const page of pages) {\n    if (typeof page === 'string') {\n      // Simple page path\n      const mdxPath = path.join(projectRoot, `${page}.mdx`);\n      const mdPath = path.join(projectRoot, `${page}.md`);\n      callback(fs.existsSync(mdxPath) || fs.existsSync(mdPath), page);\n    } else if (page.group && page.pages) {\n      // Nested group\n      checkPages(projectRoot, page.pages, callback);\n    } else if (page.page) {\n      // Page object with explicit page property\n      const mdxPath = path.join(projectRoot, `${page.page}.mdx`);\n      const mdPath = path.join(projectRoot, `${page.page}.md`);\n      callback(fs.existsSync(mdxPath) || fs.existsSync(mdPath), page.page);\n    }\n  }\n}\n\n/**\n * Recursively find all MDX files in a directory\n */\nfunction findMdxFiles(dir: string, files: string[] = []): string[] {\n  const items = fs.readdirSync(dir);\n  \n  for (const item of items) {\n    // Skip common directories\n    if (['node_modules', 'dist', '.next', '.git'].includes(item)) {\n      continue;\n    }\n    \n    const fullPath = path.join(dir, item);\n    const stat = fs.statSync(fullPath);\n    \n    if (stat.isDirectory()) {\n      findMdxFiles(fullPath, files);\n    } else if (item.endsWith('.mdx') || item.endsWith('.md')) {\n      files.push(fullPath);\n    }\n  }\n  \n  return files;\n}\n"]}

package/dist/cli/commands/create.d.ts

@@ -0,0 +1,24 @@
+declare const TEMPLATES: {
+    readonly basic: {
+        readonly name: "Basic";
+        readonly description: "Simple documentation site with guides and pages";
+    };
+    readonly openapi: {
+        readonly name: "OpenAPI";
+        readonly description: "Documentation with REST API reference (OpenAPI/Swagger)";
+    };
+    readonly graphql: {
+        readonly name: "GraphQL";
+        readonly description: "Documentation with GraphQL API playground";
+    };
+};
+type TemplateType = keyof typeof TEMPLATES;
+interface CreateOptions {
+    template?: TemplateType;
+    git?: boolean;
+    install?: boolean;
+    url?: string;
+    subdomain?: string;
+}
+export declare function create(projectDirectory: string | undefined, options: CreateOptions): Promise<void>;
+export {};

package/dist/cli/commands/create.js

@@ -0,0 +1,387 @@
+"use strict";
+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.create = create;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const logger_1 = require("../../utils/logger");
+const constants_1 = require("../../constants");
+// Available templates
+const TEMPLATES = {
+    basic: {
+        name: 'Basic',
+        description: 'Simple documentation site with guides and pages',
+    },
+    openapi: {
+        name: 'OpenAPI',
+        description: 'Documentation with REST API reference (OpenAPI/Swagger)',
+    },
+    graphql: {
+        name: 'GraphQL',
+        description: 'Documentation with GraphQL API playground',
+    },
+};
+// Simple prompt helper using readline
+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 promptSelect(question, choices) {
+    console.log(`\n${question}\n`);
+    choices.forEach((choice, i) => {
+        console.log(`  ${i + 1}. ${choice.label}`);
+    });
+    console.log();
+    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('Enter number: ', (answer) => {
+            rl.close();
+            const index = parseInt(answer.trim(), 10) - 1;
+            if (index >= 0 && index < choices.length) {
+                resolve(choices[index].value);
+            }
+            else {
+                // Default to first choice
+                resolve(choices[0].value);
+            }
+        });
+    });
+}
+async function promptConfirm(question, defaultValue = false) {
+    const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        const hint = defaultValue ? '[Y/n]' : '[y/N]';
+        rl.question(`${question} ${hint}: `, (answer) => {
+            rl.close();
+            const normalized = answer.trim().toLowerCase();
+            if (normalized === '') {
+                resolve(defaultValue);
+            }
+            else {
+                resolve(normalized === 'y' || normalized === 'yes');
+            }
+        });
+    });
+}
+function validateProjectName(name) {
+    if (!name) {
+        return { valid: false, error: 'Project name is required' };
+    }
+    // Check for valid npm package name
+    if (!/^[a-z0-9][a-z0-9-._]*$/i.test(name)) {
+        return { valid: false, error: 'Invalid project name. Use lowercase letters, numbers, and dashes.' };
+    }
+    return { valid: true };
+}
+/**
+ * Basic subdomain format validation (server does full validation including blacklist)
+ */
+function isValidSubdomainFormat(subdomain) {
+    if (!subdomain) {
+        return { valid: false, error: 'Subdomain is required' };
+    }
+    if (subdomain.length < 3) {
+        return { valid: false, error: 'Subdomain must be at least 3 characters' };
+    }
+    if (subdomain.length > 63) {
+        return { valid: false, error: 'Subdomain must be 63 characters or less' };
+    }
+    if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(subdomain)) {
+        return { valid: false, error: 'Subdomain must start and end with alphanumeric, can contain hyphens' };
+    }
+    if (/--/.test(subdomain)) {
+        return { valid: false, error: 'Subdomain cannot contain consecutive hyphens' };
+    }
+    return { valid: true };
+}
+/**
+ * Check subdomain availability via API (also validates against server blacklist)
+ */
+async function checkSubdomainAvailability(subdomain, apiUrl) {
+    try {
+        const response = await fetch(`${apiUrl}/api/subdomains/check`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ subdomain }),
+        });
+        const result = await response.json();
+        return result;
+    }
+    catch {
+        // If API is unavailable, allow proceeding (will fail at registration if invalid)
+        return { available: true };
+    }
+}
+function formatProjectName(name) {
+    return name
+        .replace(/-/g, ' ')
+        .replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function getPackageManager() {
+    const userAgent = process.env.npm_config_user_agent || '';
+    if (userAgent.startsWith('yarn')) {
+        return 'yarn';
+    }
+    if (userAgent.startsWith('pnpm')) {
+        return 'pnpm';
+    }
+    return 'npm';
+}
+async function create(projectDirectory, options) {
+    console.log();
+    logger_1.logger.info('🐟 Create DevDoc Doc');
+    console.log();
+    const apiUrl = options.url || process.env.DEVDOC_API_URL || constants_1.DEFAULT_API_URL;
+    // Get project name if not provided
+    let projectPath = projectDirectory;
+    if (!projectPath) {
+        projectPath = await prompt('What is your project named?', 'my-docs');
+        if (!projectPath) {
+            logger_1.logger.error('Project name is required');
+            process.exit(1);
+        }
+    }
+    // Validate project name
+    const validation = validateProjectName(projectPath);
+    if (!validation.valid) {
+        logger_1.logger.error(validation.error || 'Invalid project name');
+        process.exit(1);
+    }
+    // Get template selection if not provided
+    let template = options.template || 'basic';
+    if (!options.template) {
+        const templateChoices = Object.entries(TEMPLATES).map(([key, value]) => ({
+            value: key,
+            label: `${value.name} - ${value.description}`,
+        }));
+        template = await promptSelect('Which template would you like to use?', templateChoices);
+    }
+    // Resolve full path
+    const resolvedPath = path_1.default.resolve(projectPath);
+    const projectName = path_1.default.basename(resolvedPath);
+    const slug = projectName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    // Get subdomain - prompt if not provided
+    let subdomain = options.subdomain;
+    if (!subdomain) {
+        console.log();
+        subdomain = await prompt(`Enter subdomain for your docs (${slug}.devdoc.sh)`, slug);
+        subdomain = subdomain.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/^-|-$/g, '');
+    }
+    // Validate subdomain format locally
+    const formatCheck = isValidSubdomainFormat(subdomain);
+    if (!formatCheck.valid) {
+        logger_1.logger.error(formatCheck.error);
+        process.exit(1);
+    }
+    // Check subdomain availability via API (server validates blacklist)
+    logger_1.logger.info(`Checking if ${subdomain}.devdoc.sh is available...`);
+    const availability = await checkSubdomainAvailability(subdomain, apiUrl);
+    if (!availability.available) {
+        logger_1.logger.error(availability.error || `Subdomain "${subdomain}" is not available`);
+        if (availability.suggestion) {
+            logger_1.logger.info(`Suggestion: Try "${availability.suggestion}"`);
+        }
+        process.exit(1);
+    }
+    logger_1.logger.success(`✓ ${subdomain}.devdoc.sh is available!`);
+    // Check if directory exists
+    if (fs_extra_1.default.existsSync(resolvedPath)) {
+        const files = fs_extra_1.default.readdirSync(resolvedPath);
+        if (files.length > 0) {
+            const overwrite = await promptConfirm(`Directory ${projectName} is not empty. Continue anyway?`, false);
+            if (!overwrite) {
+                logger_1.logger.error('Operation cancelled');
+                process.exit(1);
+            }
+        }
+    }
+    const selectedTemplate = TEMPLATES[template];
+    console.log();
+    logger_1.logger.info(`Creating a new ${selectedTemplate.name} DevDoc documentation site in ${resolvedPath}`);
+    console.log();
+    // Create project directory
+    fs_extra_1.default.ensureDirSync(resolvedPath);
+    // Copy template
+    const templateDir = path_1.default.join(__dirname, '..', '..', '..', 'templates', template);
+    if (!fs_extra_1.default.existsSync(templateDir)) {
+        logger_1.logger.error(`Template "${template}" not found`);
+        logger_1.logger.debug(`Looked for template at: ${templateDir}`);
+        process.exit(1);
+    }
+    logger_1.logger.info('Copying template files...');
+    fs_extra_1.default.copySync(templateDir, resolvedPath, { overwrite: true });
+    // Update package.json with project name
+    const pkgPath = path_1.default.join(resolvedPath, 'package.json');
+    if (fs_extra_1.default.existsSync(pkgPath)) {
+        const pkg = fs_extra_1.default.readJsonSync(pkgPath);
+        pkg.name = projectName;
+        fs_extra_1.default.writeJsonSync(pkgPath, pkg, { spaces: 2 });
+    }
+    // Update docs.json with project name
+    const docsPath = path_1.default.join(resolvedPath, 'docs.json');
+    if (fs_extra_1.default.existsSync(docsPath)) {
+        const docs = fs_extra_1.default.readJsonSync(docsPath);
+        docs.name = formatProjectName(projectName);
+        fs_extra_1.default.writeJsonSync(docsPath, docs, { spaces: 2 });
+    }
+    // Register project with Brainfish API and create .devdoc.json
+    const devdocConfigPath = path_1.default.join(resolvedPath, '.devdoc.json');
+    logger_1.logger.info('Registering project with Brainfish...');
+    try {
+        const response = await fetch(`${apiUrl}/api/projects/register`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                name: formatProjectName(projectName),
+                slug,
+                subdomain,
+            }),
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(errorData.error || `HTTP ${response.status}`);
+        }
+        const result = await response.json();
+        const devdocConfig = {
+            projectId: result.projectId,
+            name: formatProjectName(projectName),
+            slug: result.slug,
+            subdomain: result.subdomain,
+            apiKey: result.apiKey,
+            createdAt: new Date().toISOString(),
+        };
+        fs_extra_1.default.writeJsonSync(devdocConfigPath, devdocConfig, { spaces: 2 });
+        logger_1.logger.success('Project registered - API key saved to .devdoc.json');
+        console.log();
+        console.log('  URL:', `https://${result.subdomain}.devdoc.sh`);
+        console.log('  API Key:', result.apiKey);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger_1.logger.warn(`Could not register project: ${message}`);
+        logger_1.logger.info('Creating local config - run "devdoc init" when online to register');
+        const devdocConfig = {
+            projectId: `${slug}-${Math.random().toString(36).substring(2, 8)}`,
+            name: formatProjectName(projectName),
+            slug: slug,
+            subdomain: subdomain,
+            createdAt: new Date().toISOString(),
+        };
+        fs_extra_1.default.writeJsonSync(devdocConfigPath, devdocConfig, { spaces: 2 });
+        logger_1.logger.success('Created .devdoc.json (offline mode)');
+    }
+    // Initialize git
+    if (options.git !== false) {
+        logger_1.logger.info('Initializing git repository...');
+        try {
+            (0, child_process_1.execSync)('git init', { cwd: resolvedPath, stdio: 'ignore' });
+            (0, child_process_1.execSync)('git add -A', { cwd: resolvedPath, stdio: 'ignore' });
+            (0, child_process_1.execSync)('git commit -m "Initial commit from devdoc create"', {
+                cwd: resolvedPath,
+                stdio: 'ignore',
+            });
+            logger_1.logger.success('Git repository initialized');
+        }
+        catch {
+            logger_1.logger.warn('Could not initialize git repository');
+        }
+    }
+    // Install dependencies
+    if (options.install !== false) {
+        logger_1.logger.info('Installing dependencies...');
+        try {
+            const packageManager = getPackageManager();
+            (0, child_process_1.execSync)(`${packageManager} install`, {
+                cwd: resolvedPath,
+                stdio: 'inherit',
+            });
+            logger_1.logger.success('Dependencies installed');
+        }
+        catch {
+            logger_1.logger.warn('Could not install dependencies');
+        }
+    }
+    // Success message
+    console.log();
+    logger_1.logger.success(`Created ${projectName} at ${resolvedPath}`);
+    console.log();
+    console.log('Your docs will be available at:');
+    console.log(`  https://${subdomain}.devdoc.sh`);
+    console.log();
+    console.log('Inside that directory, you can run several commands:');
+    console.log();
+    console.log('  npm run dev');
+    console.log('    Starts the development server.');
+    console.log();
+    console.log('  devdoc deploy');
+    console.log('    Deploys your documentation to Brainfish.');
+    console.log();
+    console.log('We suggest that you begin by typing:');
+    console.log();
+    console.log(`  cd ${projectName}`);
+    console.log('  npm run dev');
+    console.log();
+    console.log('Happy documenting! 📚');
+    console.log();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../src/cli/commands/create.ts"],"names":[],"mappings":"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","sourcesContent":["import { execSync } from 'child_process';\nimport path from 'path';\nimport fs from 'fs-extra';\nimport { logger } from '../../utils/logger';\nimport { DEFAULT_API_URL } from '../../constants';\n\n// Available templates\nconst TEMPLATES = {\n  basic: {\n    name: 'Basic',\n    description: 'Simple documentation site with guides and pages',\n  },\n  openapi: {\n    name: 'OpenAPI',\n    description: 'Documentation with REST API reference (OpenAPI/Swagger)',\n  },\n  graphql: {\n    name: 'GraphQL',\n    description: 'Documentation with GraphQL API playground',\n  },\n} as const;\n\ntype TemplateType = keyof typeof TEMPLATES;\n\ninterface CreateOptions {\n  template?: TemplateType;\n  git?: boolean;\n  install?: boolean;\n  url?: string;\n  subdomain?: string;\n}\n\ninterface RegisterResponse {\n  projectId: string;\n  slug: string;\n  subdomain: string;\n  apiKey: string;\n}\n\ninterface CheckSubdomainResponse {\n  available: boolean;\n  error?: string;\n  suggestion?: string;\n}\n\n// Simple prompt helper using readline\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 promptSelect(question: string, choices: { value: string; label: string }[]): Promise<string> {\n  console.log(`\\n${question}\\n`);\n  choices.forEach((choice, i) => {\n    console.log(`  ${i + 1}. ${choice.label}`);\n  });\n  console.log();\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('Enter number: ', (answer) => {\n      rl.close();\n      const index = parseInt(answer.trim(), 10) - 1;\n      if (index >= 0 && index < choices.length) {\n        resolve(choices[index].value);\n      } else {\n        // Default to first choice\n        resolve(choices[0].value);\n      }\n    });\n  });\n}\n\nasync function promptConfirm(question: string, defaultValue = false): Promise<boolean> {\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 hint = defaultValue ? '[Y/n]' : '[y/N]';\n    rl.question(`${question} ${hint}: `, (answer) => {\n      rl.close();\n      const normalized = answer.trim().toLowerCase();\n      if (normalized === '') {\n        resolve(defaultValue);\n      } else {\n        resolve(normalized === 'y' || normalized === 'yes');\n      }\n    });\n  });\n}\n\nfunction validateProjectName(name: string): { valid: boolean; error?: string } {\n  if (!name) {\n    return { valid: false, error: 'Project name is required' };\n  }\n  \n  // Check for valid npm package name\n  if (!/^[a-z0-9][a-z0-9-._]*$/i.test(name)) {\n    return { valid: false, error: 'Invalid project name. Use lowercase letters, numbers, and dashes.' };\n  }\n  \n  return { valid: true };\n}\n\n/**\n * Basic subdomain format validation (server does full validation including blacklist)\n */\nfunction isValidSubdomainFormat(subdomain: string): { valid: boolean; error?: string } {\n  if (!subdomain) {\n    return { valid: false, error: 'Subdomain is required' };\n  }\n  \n  if (subdomain.length < 3) {\n    return { valid: false, error: 'Subdomain must be at least 3 characters' };\n  }\n  \n  if (subdomain.length > 63) {\n    return { valid: false, error: 'Subdomain must be 63 characters or less' };\n  }\n  \n  if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(subdomain)) {\n    return { valid: false, error: 'Subdomain must start and end with alphanumeric, can contain hyphens' };\n  }\n  \n  if (/--/.test(subdomain)) {\n    return { valid: false, error: 'Subdomain cannot contain consecutive hyphens' };\n  }\n  \n  return { valid: true };\n}\n\n/**\n * Check subdomain availability via API (also validates against server blacklist)\n */\nasync function checkSubdomainAvailability(\n  subdomain: string,\n  apiUrl: string\n): Promise<CheckSubdomainResponse> {\n  try {\n    const response = await fetch(`${apiUrl}/api/subdomains/check`, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n      },\n      body: JSON.stringify({ subdomain }),\n    });\n    \n    const result = await response.json() as CheckSubdomainResponse;\n    return result;\n  } catch {\n    // If API is unavailable, allow proceeding (will fail at registration if invalid)\n    return { available: true };\n  }\n}\n\nfunction formatProjectName(name: string): string {\n  return name\n    .replace(/-/g, ' ')\n    .replace(/\\b\\w/g, (char) => char.toUpperCase());\n}\n\nfunction getPackageManager(): string {\n  const userAgent = process.env.npm_config_user_agent || '';\n  \n  if (userAgent.startsWith('yarn')) {\n    return 'yarn';\n  }\n  \n  if (userAgent.startsWith('pnpm')) {\n    return 'pnpm';\n  }\n  \n  return 'npm';\n}\n\nexport async function create(projectDirectory: string | undefined, options: CreateOptions): Promise<void> {\n  console.log();\n  logger.info('🐟 Create DevDoc Doc');\n  console.log();\n\n  const apiUrl = options.url || process.env.DEVDOC_API_URL || DEFAULT_API_URL;\n\n  // Get project name if not provided\n  let projectPath = projectDirectory;\n\n  if (!projectPath) {\n    projectPath = await prompt('What is your project named?', 'my-docs');\n    \n    if (!projectPath) {\n      logger.error('Project name is required');\n      process.exit(1);\n    }\n  }\n\n  // Validate project name\n  const validation = validateProjectName(projectPath);\n  if (!validation.valid) {\n    logger.error(validation.error || 'Invalid project name');\n    process.exit(1);\n  }\n\n  // Get template selection if not provided\n  let template: TemplateType = options.template || 'basic';\n  \n  if (!options.template) {\n    const templateChoices = Object.entries(TEMPLATES).map(([key, value]) => ({\n      value: key,\n      label: `${value.name} - ${value.description}`,\n    }));\n\n    template = await promptSelect('Which template would you like to use?', templateChoices) as TemplateType;\n  }\n\n  // Resolve full path\n  const resolvedPath = path.resolve(projectPath);\n  const projectName = path.basename(resolvedPath);\n  const slug = projectName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');\n\n  // Get subdomain - prompt if not provided\n  let subdomain = options.subdomain;\n  \n  if (!subdomain) {\n    console.log();\n    subdomain = await prompt(`Enter subdomain for your docs (${slug}.devdoc.sh)`, slug);\n    subdomain = subdomain.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/^-|-$/g, '');\n  }\n\n  // Validate subdomain format locally\n  const formatCheck = isValidSubdomainFormat(subdomain);\n  if (!formatCheck.valid) {\n    logger.error(formatCheck.error!);\n    process.exit(1);\n  }\n\n  // Check subdomain availability via API (server validates blacklist)\n  logger.info(`Checking if ${subdomain}.devdoc.sh is available...`);\n  const availability = await checkSubdomainAvailability(subdomain, apiUrl);\n  \n  if (!availability.available) {\n    logger.error(availability.error || `Subdomain \"${subdomain}\" is not available`);\n    if (availability.suggestion) {\n      logger.info(`Suggestion: Try \"${availability.suggestion}\"`);\n    }\n    process.exit(1);\n  }\n  \n  logger.success(`✓ ${subdomain}.devdoc.sh is available!`);\n\n  // Check if directory exists\n  if (fs.existsSync(resolvedPath)) {\n    const files = fs.readdirSync(resolvedPath);\n    if (files.length > 0) {\n      const overwrite = await promptConfirm(`Directory ${projectName} is not empty. Continue anyway?`, false);\n      \n      if (!overwrite) {\n        logger.error('Operation cancelled');\n        process.exit(1);\n      }\n    }\n  }\n\n  const selectedTemplate = TEMPLATES[template];\n  console.log();\n  logger.info(`Creating a new ${selectedTemplate.name} DevDoc documentation site in ${resolvedPath}`);\n  console.log();\n\n  // Create project directory\n  fs.ensureDirSync(resolvedPath);\n\n  // Copy template\n  const templateDir = path.join(__dirname, '..', '..', '..', 'templates', template);\n  \n  if (!fs.existsSync(templateDir)) {\n    logger.error(`Template \"${template}\" not found`);\n    logger.debug(`Looked for template at: ${templateDir}`);\n    process.exit(1);\n  }\n\n  logger.info('Copying template files...');\n  fs.copySync(templateDir, resolvedPath, { overwrite: true });\n\n  // Update package.json with project name\n  const pkgPath = path.join(resolvedPath, 'package.json');\n  if (fs.existsSync(pkgPath)) {\n    const pkg = fs.readJsonSync(pkgPath);\n    pkg.name = projectName;\n    fs.writeJsonSync(pkgPath, pkg, { spaces: 2 });\n  }\n\n  // Update docs.json with project name\n  const docsPath = path.join(resolvedPath, 'docs.json');\n  if (fs.existsSync(docsPath)) {\n    const docs = fs.readJsonSync(docsPath);\n    docs.name = formatProjectName(projectName);\n    fs.writeJsonSync(docsPath, docs, { spaces: 2 });\n  }\n\n  // Register project with Brainfish API and create .devdoc.json\n  const devdocConfigPath = path.join(resolvedPath, '.devdoc.json');\n  \n  logger.info('Registering project with Brainfish...');\n  \n  try {\n    const response = await fetch(`${apiUrl}/api/projects/register`, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n      },\n      body: JSON.stringify({\n        name: formatProjectName(projectName),\n        slug,\n        subdomain,\n      }),\n    });\n    \n    if (!response.ok) {\n      const errorData = await response.json().catch(() => ({ error: 'Unknown error' })) as { error?: string };\n      throw new Error(errorData.error || `HTTP ${response.status}`);\n    }\n    \n    const result = await response.json() as RegisterResponse;\n    \n    const devdocConfig = {\n      projectId: result.projectId,\n      name: formatProjectName(projectName),\n      slug: result.slug,\n      subdomain: result.subdomain,\n      apiKey: result.apiKey,\n      createdAt: new Date().toISOString(),\n    };\n    fs.writeJsonSync(devdocConfigPath, devdocConfig, { spaces: 2 });\n    logger.success('Project registered - API key saved to .devdoc.json');\n    console.log();\n    console.log('  URL:', `https://${result.subdomain}.devdoc.sh`);\n    console.log('  API Key:', result.apiKey);\n    \n  } catch (error: unknown) {\n    const message = error instanceof Error ? error.message : String(error);\n    logger.warn(`Could not register project: ${message}`);\n    logger.info('Creating local config - run \"devdoc init\" when online to register');\n    \n    const devdocConfig = {\n      projectId: `${slug}-${Math.random().toString(36).substring(2, 8)}`,\n      name: formatProjectName(projectName),\n      slug: slug,\n      subdomain: subdomain,\n      createdAt: new Date().toISOString(),\n    };\n    fs.writeJsonSync(devdocConfigPath, devdocConfig, { spaces: 2 });\n    logger.success('Created .devdoc.json (offline mode)');\n  }\n\n  // Initialize git\n  if (options.git !== false) {\n    logger.info('Initializing git repository...');\n    try {\n      execSync('git init', { cwd: resolvedPath, stdio: 'ignore' });\n      execSync('git add -A', { cwd: resolvedPath, stdio: 'ignore' });\n      execSync('git commit -m \"Initial commit from devdoc create\"', {\n        cwd: resolvedPath,\n        stdio: 'ignore',\n      });\n      logger.success('Git repository initialized');\n    } catch {\n      logger.warn('Could not initialize git repository');\n    }\n  }\n\n  // Install dependencies\n  if (options.install !== false) {\n    logger.info('Installing dependencies...');\n    try {\n      const packageManager = getPackageManager();\n      execSync(`${packageManager} install`, {\n        cwd: resolvedPath,\n        stdio: 'inherit',\n      });\n      logger.success('Dependencies installed');\n    } catch {\n      logger.warn('Could not install dependencies');\n    }\n  }\n\n  // Success message\n  console.log();\n  logger.success(`Created ${projectName} at ${resolvedPath}`);\n  console.log();\n  console.log('Your docs will be available at:');\n  console.log(`  https://${subdomain}.devdoc.sh`);\n  console.log();\n  console.log('Inside that directory, you can run several commands:');\n  console.log();\n  console.log('  npm run dev');\n  console.log('    Starts the development server.');\n  console.log();\n  console.log('  devdoc deploy');\n  console.log('    Deploys your documentation to Brainfish.');\n  console.log();\n  console.log('We suggest that you begin by typing:');\n  console.log();\n  console.log(`  cd ${projectName}`);\n  console.log('  npm run dev');\n  console.log();\n  console.log('Happy documenting! 📚');\n  console.log();\n}\n"]}

package/dist/cli/commands/deploy.d.ts

@@ -0,0 +1,9 @@
+interface DeployOptions {
+    url?: string;
+    apiKey?: string;
+}
+/**
+ * Deploy documentation to DevDoc platform
+ */
+export declare function deploy(options: DeployOptions): Promise<void>;
+export {};