@knowcode/doc-builder 1.0.0

package/lib/deploy.js

@@ -0,0 +1,158 @@
+const chalk = require('chalk');
+const prompts = require('prompts');
+const { execSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Setup Vercel project for first-time deployment
+ */
+async function setupVercelProject(config) {
+  console.log(chalk.blue('\n📋 Setting up Vercel project...\n'));
+  
+  // Check if Vercel CLI is installed
+  try {
+    execSync('vercel --version', { stdio: 'ignore' });
+  } catch (error) {
+    console.log(chalk.red('❌ Vercel CLI not found!'));
+    console.log(chalk.gray('Install it with: npm install -g vercel'));
+    process.exit(1);
+  }
+  
+  // Project setup questions
+  const answers = await prompts([
+    {
+      type: 'text',
+      name: 'projectName',
+      message: 'What is your project name?',
+      initial: config.siteName || 'my-docs'
+    },
+    {
+      type: 'select',
+      name: 'framework',
+      message: 'Which framework preset?',
+      choices: [
+        { title: 'Other (Static HTML)', value: 'other' },
+        { title: 'Next.js', value: 'nextjs' },
+        { title: 'Vite', value: 'vite' }
+      ],
+      initial: 0
+    },
+    {
+      type: 'confirm',
+      name: 'publicAccess',
+      message: 'Make the deployment publicly accessible?',
+      initial: true
+    }
+  ]);
+  
+  // Create vercel.json if it doesn't exist
+  const vercelConfigPath = path.join(process.cwd(), 'vercel.json');
+  if (!fs.existsSync(vercelConfigPath)) {
+    const vercelConfig = {
+      outputDirectory: config.outputDir || 'html',
+      framework: answers.framework === 'other' ? null : answers.framework,
+      buildCommand: "npm run build:docs",
+      devCommand: "npm run dev:docs",
+      installCommand: "npm install",
+      public: answers.publicAccess
+    };
+    
+    fs.writeJsonSync(vercelConfigPath, vercelConfig, { spaces: 2 });
+    console.log(chalk.green('✅ Created vercel.json'));
+  }
+  
+  // Run Vercel setup
+  console.log(chalk.blue('\n🔗 Linking to Vercel...\n'));
+  
+  try {
+    execSync('vercel link', { stdio: 'inherit' });
+  } catch (error) {
+    console.error(chalk.red('Failed to link Vercel project'));
+    process.exit(1);
+  }
+  
+  // Important reminders for Vercel settings
+  console.log(chalk.yellow('\n⚠️  IMPORTANT: Vercel Project Settings\n'));
+  console.log(chalk.white('After deployment, go to your Vercel dashboard and:'));
+  console.log(chalk.gray('1. Navigate to Project Settings > General'));
+  console.log(chalk.gray('2. Under "Security", find "Deployment Protection"'));
+  console.log(chalk.gray('3. Set "Deployment Protection" to "Disabled" for public access'));
+  console.log(chalk.gray('4. Or configure authentication if you want to keep it private'));
+  console.log();
+  console.log(chalk.cyan('Dashboard URL: https://vercel.com/dashboard'));
+  console.log();
+  
+  // Add .vercel to .gitignore if not already there
+  const gitignorePath = path.join(process.cwd(), '.gitignore');
+  if (fs.existsSync(gitignorePath)) {
+    const gitignore = fs.readFileSync(gitignorePath, 'utf8');
+    if (!gitignore.includes('.vercel')) {
+      fs.appendFileSync(gitignorePath, '\n# Vercel\n.vercel\n');
+      console.log(chalk.green('✅ Added .vercel to .gitignore'));
+    }
+  }
+}
+
+/**
+ * Deploy to Vercel
+ */
+async function deployToVercel(config, isProd = false) {
+  // Ensure the build output exists
+  const outputPath = path.join(process.cwd(), config.outputDir || 'html');
+  if (!fs.existsSync(outputPath)) {
+    throw new Error(`Output directory ${outputPath} does not exist. Run 'doc-builder build' first.`);
+  }
+  
+  // Deploy command
+  const deployCmd = isProd ? 'vercel --prod' : 'vercel';
+  
+  try {
+    // Run deployment and capture output
+    const output = execSync(deployCmd, { 
+      cwd: process.cwd(),
+      encoding: 'utf8'
+    });
+    
+    // Extract URL from output
+    const urlMatch = output.match(/https:\/\/[^\s]+/);
+    const deployUrl = urlMatch ? urlMatch[0] : 'Check Vercel dashboard';
+    
+    return deployUrl;
+  } catch (error) {
+    throw new Error(`Vercel deployment failed: ${error.message}`);
+  }
+}
+
+/**
+ * Create deployment-specific files
+ */
+async function prepareDeployment(config) {
+  const outputDir = path.join(process.cwd(), config.outputDir || 'html');
+  
+  // Create a simple index redirect if needed
+  const indexPath = path.join(outputDir, 'index.html');
+  if (!fs.existsSync(indexPath)) {
+    const readmePath = path.join(outputDir, 'README.html');
+    if (fs.existsSync(readmePath)) {
+      // Create redirect
+      const redirectHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="refresh" content="0; url=README.html">
+  <title>Redirecting...</title>
+</head>
+<body>
+  <p>Redirecting to <a href="README.html">documentation</a>...</p>
+</body>
+</html>`;
+      fs.writeFileSync(indexPath, redirectHtml);
+    }
+  }
+}
+
+module.exports = {
+  setupVercelProject,
+  deployToVercel,
+  prepareDeployment
+};

package/lib/dev-server.js

@@ -0,0 +1,96 @@
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Simple development server
+ */
+async function startDevServer(config, port = 3000) {
+  const outputDir = path.join(process.cwd(), config.outputDir);
+  
+  if (!fs.existsSync(outputDir)) {
+    console.log(chalk.yellow('Output directory not found. Building first...'));
+    const { build } = require('./builder');
+    await build(config);
+  }
+  
+  const server = http.createServer((req, res) => {
+    let filePath = path.join(outputDir, req.url === '/' ? 'index.html' : req.url);
+    
+    // Add .html extension if not present and not a file with extension
+    if (!path.extname(filePath) && !filePath.endsWith('/')) {
+      filePath += '.html';
+    }
+    
+    // Serve index.html for directories
+    if (filePath.endsWith('/')) {
+      filePath += 'index.html';
+    }
+    
+    fs.readFile(filePath, (err, content) => {
+      if (err) {
+        if (err.code === 'ENOENT') {
+          res.writeHead(404);
+          res.end('404 Not Found');
+        } else {
+          res.writeHead(500);
+          res.end(`Server Error: ${err.code}`);
+        }
+      } else {
+        // Determine content type
+        const ext = path.extname(filePath);
+        let contentType = 'text/html';
+        switch (ext) {
+          case '.js':
+            contentType = 'text/javascript';
+            break;
+          case '.css':
+            contentType = 'text/css';
+            break;
+          case '.json':
+            contentType = 'application/json';
+            break;
+          case '.png':
+            contentType = 'image/png';
+            break;
+          case '.jpg':
+            contentType = 'image/jpg';
+            break;
+        }
+        
+        res.writeHead(200, { 'Content-Type': contentType });
+        res.end(content, 'utf-8');
+      }
+    });
+  });
+  
+  server.listen(port, () => {
+    console.log(chalk.green(`\n📡 Development server running at: ${chalk.cyan(`http://localhost:${port}`)}\n`));
+    console.log(chalk.gray('Press Ctrl+C to stop'));
+  });
+  
+  // Watch for changes (basic implementation)
+  if (config.watch !== false) {
+    const docsDir = path.join(process.cwd(), config.docsDir);
+    console.log(chalk.gray(`Watching for changes in ${config.docsDir}...`));
+    
+    // Simple file watcher - in production, use chokidar
+    fs.watch(docsDir, { recursive: true }, async (eventType, filename) => {
+      if (filename && filename.endsWith('.md')) {
+        console.log(chalk.yellow(`\n🔄 ${filename} changed, rebuilding...`));
+        try {
+          const { build } = require('./builder');
+          await build(config);
+          console.log(chalk.green('✅ Rebuild complete'));
+        } catch (error) {
+          console.error(chalk.red(`❌ Rebuild failed: ${error.message}`));
+        }
+      }
+    });
+  }
+}
+
+module.exports = {
+  startDevServer
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@knowcode/doc-builder",
+  "version": "1.0.0",
+  "description": "Reusable documentation builder for markdown-based sites with Vercel deployment support",
+  "main": "index.js",
+  "bin": {
+    "doc-builder": "./cli.js",
+    "juno-docs": "./cli.js",
+    "@knowcode/doc-builder": "./scripts/npx-runner.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/setup.js || true",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "documentation",
+    "markdown",
+    "static-site-generator",
+    "vercel",
+    "juno"
+  ],
+  "author": "KnowCode",
+  "license": "MIT",
+  "dependencies": {
+    "marked": "^15.0.12",
+    "commander": "^11.0.0",
+    "chalk": "^4.1.2",
+    "prompts": "^2.4.2",
+    "ora": "5.4.1",
+    "fs-extra": "^11.2.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/scripts/npx-runner.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+/**
+ * NPX runner script for @knowcode/doc-builder
+ * This script enables zero-configuration usage via npx
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Get the command from arguments
+const [,, command = 'build', ...args] = process.argv;
+
+// Path to the actual CLI
+const cliPath = path.join(__dirname, '..', 'cli.js');
+
+// Build the command
+const fullCommand = `node "${cliPath}" ${command} ${args.join(' ')}`;
+
+try {
+  // Execute the CLI with stdio inherited to preserve colors and interactivity
+  execSync(fullCommand, { stdio: 'inherit' });
+} catch (error) {
+  // Exit with the same code as the CLI
+  process.exit(error.status || 1);
+}

package/scripts/setup.js

@@ -0,0 +1,56 @@
+/**
+ * Post-install setup script for @juno/doc-builder
+ * This script runs after npm install to help users get started
+ */
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+// Check if we're in the doc-builder package itself (skip setup)
+const packagePath = path.join(process.cwd(), 'package.json');
+if (fs.existsSync(packagePath)) {
+  const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  if (pkg.name === '@knowcode/doc-builder') {
+    // We're in the doc-builder package itself, skip setup
+    process.exit(0);
+  }
+}
+
+console.log(chalk.cyan('\n🚀 Welcome to @knowcode/doc-builder!\n'));
+
+console.log('You can use doc-builder in several ways:\n');
+
+console.log(chalk.yellow('1. Using npx (no installation required):'));
+console.log('   npx @knowcode/doc-builder build');
+console.log('   npx @knowcode/doc-builder dev');
+console.log('   npx @knowcode/doc-builder deploy\n');
+
+console.log(chalk.yellow('2. After installing as a dependency:'));
+console.log('   doc-builder build');
+console.log('   doc-builder dev');
+console.log('   doc-builder deploy\n');
+
+console.log(chalk.yellow('3. In your package.json scripts:'));
+console.log(chalk.gray('   "scripts": {'));
+console.log(chalk.gray('     "docs:build": "doc-builder build",'));
+console.log(chalk.gray('     "docs:dev": "doc-builder dev",'));
+console.log(chalk.gray('     "docs:deploy": "doc-builder deploy --prod"'));
+console.log(chalk.gray('   }\n'));
+
+console.log(chalk.yellow('4. Programmatically in your code:'));
+console.log(chalk.gray('   const { build } = require("@knowcode/doc-builder");'));
+console.log(chalk.gray('   await build();\n'));
+
+// Check for common doc directories
+const commonDirs = ['docs', 'documentation', 'doc'];
+const foundDir = commonDirs.find(dir => fs.existsSync(path.join(process.cwd(), dir)));
+
+if (foundDir) {
+  console.log(chalk.green(`✅ Found ${foundDir}/ directory - doc-builder will use this by default\n`));
+} else {
+  console.log(chalk.yellow(`ℹ️  No docs directory found. Create a 'docs' folder with markdown files to get started.\n`));
+}
+
+console.log(chalk.gray('For more information, visit: https://github.com/juno-platform/doc-builder'));
+console.log(chalk.gray('To create a config file, run: doc-builder init --config\n'));