@edtools/cli 0.6.0 → 0.6.2

package/dist/cli/index.js

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   ContentGenerator
-} from "../chunk-JCUQ7D56.js";
+} from "../chunk-BI3UJPWA.js";
 import "../chunk-INVECVSW.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 
 // src/cli/commands/init.ts
-import fs from "fs-extra";
-import path from "path";
+import fs2 from "fs-extra";
+import path2 from "path";
 import chalk2 from "chalk";
 import ora from "ora";
 import inquirer from "inquirer";
@@ -104,12 +104,160 @@ function warningBox(message) {
   });
 }
 
+// src/utils/hosting-detection.ts
+import fs from "fs";
+import path from "path";
+import yaml from "yaml";
+var detectors = [
+  {
+    name: "Firebase",
+    file: "firebase.json",
+    parse: (content, projectPath) => {
+      try {
+        const config = JSON.parse(content);
+        const publicDir = config.hosting?.public || "public";
+        return {
+          platform: "Firebase",
+          publicDir,
+          configFile: "firebase.json"
+        };
+      } catch (error) {
+        return null;
+      }
+    }
+  },
+  {
+    name: "AWS Amplify",
+    file: "amplify.yml",
+    parse: (content, projectPath) => {
+      try {
+        const config = yaml.parse(content);
+        const baseDirectory = config?.frontend?.artifacts?.baseDirectory || "build";
+        return {
+          platform: "AWS Amplify",
+          publicDir: baseDirectory,
+          configFile: "amplify.yml"
+        };
+      } catch (error) {
+        return null;
+      }
+    }
+  },
+  {
+    name: "Vercel",
+    file: "vercel.json",
+    parse: (content, projectPath) => {
+      try {
+        const config = JSON.parse(content);
+        const outputDirectory = config.outputDirectory || config.buildCommand?.match(/out|dist|build/)?.[0] || "public";
+        return {
+          platform: "Vercel",
+          publicDir: outputDirectory,
+          configFile: "vercel.json"
+        };
+      } catch (error) {
+        return null;
+      }
+    }
+  },
+  {
+    name: "Netlify",
+    file: "netlify.toml",
+    parse: (content, projectPath) => {
+      try {
+        const match = content.match(/publish\s*=\s*"([^"]+)"/);
+        const publicDir = match?.[1] || "public";
+        return {
+          platform: "Netlify",
+          publicDir,
+          configFile: "netlify.toml"
+        };
+      } catch (error) {
+        return null;
+      }
+    }
+  },
+  {
+    name: "Next.js",
+    file: "next.config.js",
+    parse: (content, projectPath) => {
+      if (content.includes("output:") && content.includes("export")) {
+        const packageJsonPath = path.join(projectPath, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+          const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+          const buildScript = packageJson.scripts?.build || "";
+          if (buildScript.includes("out")) {
+            return {
+              platform: "Next.js (Static Export)",
+              publicDir: "out",
+              configFile: "next.config.js"
+            };
+          }
+        }
+        return {
+          platform: "Next.js (Static Export)",
+          publicDir: "out",
+          configFile: "next.config.js"
+        };
+      }
+      return null;
+    }
+  }
+];
+function detectHostingConfig(projectPath) {
+  for (const detector of detectors) {
+    const configPath = path.join(projectPath, detector.file);
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, "utf-8");
+        const result = detector.parse(content, projectPath);
+        if (result) {
+          return result;
+        }
+      } catch (error) {
+        console.error(`Error parsing ${detector.file}:`, error);
+      }
+    }
+  }
+  return null;
+}
+function validateOutputDir(outputDir, hostingConfig) {
+  if (!hostingConfig) {
+    return { valid: true };
+  }
+  const normalizedOutputDir = outputDir.replace(/^\.\//, "");
+  const normalizedPublicDir = hostingConfig.publicDir.replace(/^\.\//, "");
+  const isInPublicDir = normalizedOutputDir.startsWith(`${normalizedPublicDir}/`) || normalizedOutputDir === normalizedPublicDir;
+  const issues = [];
+  if (!isInPublicDir) {
+    issues.push(
+      `Output directory "${outputDir}" is outside the public directory "${hostingConfig.publicDir}"`
+    );
+    issues.push("Generated files will not be accessible in production");
+  }
+  return {
+    valid: isInPublicDir,
+    platform: hostingConfig.platform,
+    publicDir: hostingConfig.publicDir,
+    currentOutputDir: outputDir,
+    suggestion: `./${normalizedPublicDir}/blog`,
+    issues: issues.length > 0 ? issues : void 0
+  };
+}
+function getSuggestedOutputDir(projectPath) {
+  const hostingConfig = detectHostingConfig(projectPath);
+  if (hostingConfig) {
+    return `./${hostingConfig.publicDir}/blog`;
+  }
+  return "./blog";
+}
+
 // src/cli/commands/init.ts
 async function initCommand(options) {
   console.log(chalk2.cyan.bold("\n\u{1F680} Initializing Edtools...\n"));
-  const projectPath = path.resolve(options.path);
-  const configPath = path.join(projectPath, "edtools.config.js");
-  if (await fs.pathExists(configPath)) {
+  const projectPath = path2.resolve(options.path);
+  const configPath = path2.join(projectPath, "edtools.config.js");
+  if (await fs2.pathExists(configPath)) {
     const { overwrite } = await inquirer.prompt([
       {
         type: "confirm",
@@ -126,9 +274,9 @@ async function initCommand(options) {
   const spinner = ora("Analyzing your landing page...").start();
   let productInfo = {};
   try {
-    const indexPath = path.join(projectPath, "index.html");
-    if (await fs.pathExists(indexPath)) {
-      const html = await fs.readFile(indexPath, "utf-8");
+    const indexPath = path2.join(projectPath, "index.html");
+    if (await fs2.pathExists(indexPath)) {
+      const html = await fs2.readFile(indexPath, "utf-8");
       const $ = loadCheerio(html);
       productInfo = {
         name: $("title").text() || $("h1").first().text() || "My Product",
@@ -248,6 +396,15 @@ async function initCommand(options) {
     ...productInfo,
     ...answers
   };
+  const suggestedOutputDir = getSuggestedOutputDir(projectPath);
+  const hostingConfig = detectHostingConfig(projectPath);
+  if (hostingConfig) {
+    console.log("");
+    console.log(chalk2.cyan("\u2713 Detected hosting platform: ") + chalk2.white(hostingConfig.platform));
+    console.log(chalk2.cyan("  Public directory: ") + chalk2.white(hostingConfig.publicDir));
+    console.log(chalk2.cyan("  Suggested blog directory: ") + chalk2.white(suggestedOutputDir));
+    console.log("");
+  }
   const config = `module.exports = {
   product: {
     name: ${JSON.stringify(finalProductInfo.name)},
@@ -261,7 +418,7 @@ async function initCommand(options) {
   },
 
   content: {
-    outputDir: './blog',
+    outputDir: ${JSON.stringify(suggestedOutputDir)},
     generateBlog: true,
   },
 
@@ -272,17 +429,17 @@ async function initCommand(options) {
   },
 };
 `;
-  await fs.writeFile(configPath, config, "utf-8");
-  const edtoolsDir = path.join(projectPath, ".edtools");
-  await fs.ensureDir(edtoolsDir);
+  await fs2.writeFile(configPath, config, "utf-8");
+  const edtoolsDir = path2.join(projectPath, ".edtools");
+  await fs2.ensureDir(edtoolsDir);
   const edtoolsConfig = {
     apiKey: apiKeyAnswer.apiKey,
     provider: finalProductInfo.preferredProvider
   };
-  const edtoolsConfigPath = path.join(edtoolsDir, "config.json");
-  await fs.writeFile(edtoolsConfigPath, JSON.stringify(edtoolsConfig, null, 2), "utf-8");
-  const gitignorePath = path.join(edtoolsDir, ".gitignore");
-  await fs.writeFile(gitignorePath, "*\n!.gitignore\n", "utf-8");
+  const edtoolsConfigPath = path2.join(edtoolsDir, "config.json");
+  await fs2.writeFile(edtoolsConfigPath, JSON.stringify(edtoolsConfig, null, 2), "utf-8");
+  const gitignorePath = path2.join(edtoolsDir, ".gitignore");
+  await fs2.writeFile(gitignorePath, "*\n!.gitignore\n", "utf-8");
   console.log("");
   console.log(successBox("Configuration created successfully!"));
   const filesCreated = `${chalk2.cyan("Files created:")}
@@ -302,17 +459,18 @@ ${chalk2.gray("API key stored securely (gitignored)")}`;
 }
 
 // src/cli/commands/generate.ts
-import fs2 from "fs-extra";
-import path2 from "path";
+import fs3 from "fs-extra";
+import path3 from "path";
 import { pathToFileURL } from "url";
 import chalk3 from "chalk";
 import ora2 from "ora";
 import Table from "cli-table3";
+import inquirer2 from "inquirer";
 async function generateCommand(options) {
   console.log(chalk3.cyan.bold("\n\u{1F4DD} Generating content...\n"));
   const projectPath = process.cwd();
-  const configPath = path2.join(projectPath, "edtools.config.js");
-  if (!await fs2.pathExists(configPath)) {
+  const configPath = path3.join(projectPath, "edtools.config.js");
+  if (!await fs3.pathExists(configPath)) {
     console.log(chalk3.red("\u2717 No edtools.config.js found"));
     console.log(chalk3.yellow('  Run "edtools init" first\n'));
     process.exit(1);
@@ -326,10 +484,10 @@ async function generateCommand(options) {
   }
   const provider = productInfo.preferredProvider || "anthropic";
   let storedApiKey;
-  const edtoolsConfigPath = path2.join(projectPath, ".edtools", "config.json");
-  if (await fs2.pathExists(edtoolsConfigPath)) {
+  const edtoolsConfigPath = path3.join(projectPath, ".edtools", "config.json");
+  if (await fs3.pathExists(edtoolsConfigPath)) {
     try {
-      const edtoolsConfig = await fs2.readJson(edtoolsConfigPath);
+      const edtoolsConfig = await fs3.readJson(edtoolsConfigPath);
       storedApiKey = edtoolsConfig.apiKey;
     } catch (error) {
     }
@@ -356,14 +514,14 @@ async function generateCommand(options) {
   }
   let topics = options.topics;
   if (options.fromCsv) {
-    const opportunitiesPath = path2.join(projectPath, ".edtools", "opportunities.json");
-    if (!await fs2.pathExists(opportunitiesPath)) {
+    const opportunitiesPath = path3.join(projectPath, ".edtools", "opportunities.json");
+    if (!await fs3.pathExists(opportunitiesPath)) {
       console.log(chalk3.red("\u2717 No CSV analysis found"));
       console.log(chalk3.yellow('  Run "edtools analyze" first to analyze your GSC data\n'));
       process.exit(1);
     }
     try {
-      const oppData = await fs2.readJson(opportunitiesPath);
+      const oppData = await fs3.readJson(opportunitiesPath);
       topics = oppData.opportunities.slice(0, parseInt(options.posts, 10)).map((opp) => opp.suggestedTitle);
       console.log(chalk3.cyan("\u{1F4CA} Using topics from CSV analysis:\n"));
       topics.forEach((topic, i) => {
@@ -384,14 +542,58 @@ async function generateCommand(options) {
     console.log(chalk3.yellow(`\u26A0\uFE0F  Generating ${count} posts at once may trigger spam detection`));
     console.log(chalk3.yellow("   Recommended: 3-5 posts per week\n"));
   }
-  const outputDir = path2.resolve(projectPath, options.output);
-  await fs2.ensureDir(outputDir);
+  let outputDirConfig;
+  let outputDirSource;
+  if (options.output) {
+    outputDirConfig = options.output;
+    outputDirSource = "CLI flag (--output)";
+  } else if (config.default.content?.outputDir) {
+    outputDirConfig = config.default.content.outputDir;
+    outputDirSource = "edtools.config.js";
+  } else {
+    outputDirConfig = "./blog";
+    outputDirSource = "default";
+  }
+  const outputDir = path3.resolve(projectPath, outputDirConfig);
+  await fs3.ensureDir(outputDir);
+  const hostingConfig = detectHostingConfig(projectPath);
+  if (hostingConfig) {
+    const validation = validateOutputDir(outputDirConfig, hostingConfig);
+    if (!validation.valid) {
+      console.log(chalk3.yellow.bold("\n\u26A0\uFE0F  HOSTING PLATFORM DETECTED: ") + chalk3.white(validation.platform));
+      console.log(chalk3.yellow("    - Public directory: ") + chalk3.white(validation.publicDir));
+      console.log(chalk3.yellow("    - Your outputDir: ") + chalk3.white(validation.currentOutputDir));
+      console.log(chalk3.yellow("    - Problem: Files outside ") + chalk3.white(validation.publicDir + "/") + chalk3.yellow(" won't be accessible"));
+      console.log("");
+      console.log(chalk3.red.bold("\u274C ISSUE: Output directory misconfiguration"));
+      console.log(chalk3.red("    Generated files will return 404 in production"));
+      console.log("");
+      console.log(chalk3.cyan.bold("\u{1F4DD} Suggested fix:"));
+      console.log(chalk3.cyan("    Update edtools.config.js:"));
+      console.log("");
+      console.log(chalk3.gray("    content: {"));
+      console.log(chalk3.green(`      outputDir: '${validation.suggestion}'`) + chalk3.gray("  // \u2705 Correct path"));
+      console.log(chalk3.gray("    }"));
+      console.log("");
+      const answer = await inquirer2.prompt([{
+        type: "confirm",
+        name: "continue",
+        message: "Continue anyway?",
+        default: false
+      }]);
+      if (!answer.continue) {
+        console.log(chalk3.yellow("\n\u2717 Generation cancelled\n"));
+        process.exit(0);
+      }
+      console.log("");
+    }
+  }
   console.log(chalk3.cyan("Configuration:"));
   console.log(`  Product: ${chalk3.white(productInfo.name)}`);
   console.log(`  Category: ${chalk3.white(productInfo.category)}`);
   console.log(`  AI Provider: ${chalk3.white(provider === "anthropic" ? "Claude (Anthropic)" : "ChatGPT (OpenAI)")}`);
   console.log(`  Posts to generate: ${chalk3.white(count)}`);
-  console.log(`  Output directory: ${chalk3.white(outputDir)}
+  console.log(`  Output directory: ${chalk3.white(outputDir)} ${chalk3.gray("(" + outputDirSource + ")")}
 `);
   const generator = new ContentGenerator(apiKey, provider);
   const generateConfig = {
@@ -543,17 +745,17 @@ function truncateTitle(title, maxLen) {
 }
 
 // src/cli/commands/analyze.ts
-import fs4 from "fs-extra";
-import path3 from "path";
+import fs5 from "fs-extra";
+import path4 from "path";
 import chalk4 from "chalk";
 import ora3 from "ora";
 import Table2 from "cli-table3";
 
 // src/integrations/gsc-csv-analyzer.ts
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 import { parse } from "csv-parse/sync";
 async function parseGSCCSV(filePath) {
-  const content = await fs3.readFile(filePath, "utf-8");
+  const content = await fs4.readFile(filePath, "utf-8");
   const records = parse(content, {
     columns: true,
     skip_empty_lines: true,
@@ -649,7 +851,7 @@ async function saveOpportunities(opportunities, outputPath) {
     count: opportunities.length,
     opportunities
   };
-  await fs3.writeJson(outputPath, data, { spaces: 2 });
+  await fs4.writeJson(outputPath, data, { spaces: 2 });
 }
 
 // src/cli/commands/analyze.ts
@@ -658,9 +860,9 @@ async function analyzeCommand(options) {
   const projectPath = process.cwd();
   let csvPath;
   if (options.file) {
-    csvPath = path3.resolve(options.file);
+    csvPath = path4.resolve(options.file);
   } else {
-    const files = await fs4.readdir(projectPath);
+    const files = await fs5.readdir(projectPath);
     const csvFiles = files.filter((f) => f.endsWith(".csv") && f.toLowerCase().includes("search"));
     if (csvFiles.length === 0) {
       console.log(chalk4.red("\u2717 No CSV file found"));
@@ -673,9 +875,9 @@ async function analyzeCommand(options) {
       csvFiles.forEach((f) => console.log(`  - ${f}`));
       console.log(chalk4.yellow("\nUsing first file. Specify with --file to use a different one.\n"));
     }
-    csvPath = path3.join(projectPath, csvFiles[0]);
+    csvPath = path4.join(projectPath, csvFiles[0]);
   }
-  if (!await fs4.pathExists(csvPath)) {
+  if (!await fs5.pathExists(csvPath)) {
     console.log(chalk4.red(`\u2717 File not found: ${csvPath}
 `));
     process.exit(1);
@@ -684,7 +886,7 @@ async function analyzeCommand(options) {
   let data;
   try {
     data = await parseGSCCSV(csvPath);
-    spinner.succeed(`Parsed ${chalk4.white(data.length)} keywords from ${chalk4.white(path3.basename(csvPath))}`);
+    spinner.succeed(`Parsed ${chalk4.white(data.length)} keywords from ${chalk4.white(path4.basename(csvPath))}`);
   } catch (error) {
     spinner.fail("Failed to parse CSV");
     console.log(chalk4.red(`
@@ -789,9 +991,9 @@ Error: ${error.message}
     console.log(topTable.toString());
     console.log("");
   }
-  const edtoolsDir = path3.join(projectPath, ".edtools");
-  await fs4.ensureDir(edtoolsDir);
-  const opportunitiesPath = path3.join(edtoolsDir, "opportunities.json");
+  const edtoolsDir = path4.join(projectPath, ".edtools");
+  await fs5.ensureDir(edtoolsDir);
+  const opportunitiesPath = path4.join(edtoolsDir, "opportunities.json");
   await saveOpportunities(analysis.opportunities, opportunitiesPath);
   console.log(successBox(`Analysis saved to ${chalk4.white(".edtools/opportunities.json")}`));
   console.log(chalk4.cyan.bold("Next steps:"));
@@ -802,16 +1004,16 @@ Error: ${error.message}
 }
 
 // src/cli/commands/validate.ts
-import fs6 from "fs-extra";
-import path4 from "path";
+import fs7 from "fs-extra";
+import path5 from "path";
 import chalk5 from "chalk";
 import Table3 from "cli-table3";
 
 // src/utils/seo-validator.ts
 import * as cheerio from "cheerio";
-import fs5 from "fs-extra";
+import fs6 from "fs-extra";
 async function validatePost(htmlPath) {
-  const html = await fs5.readFile(htmlPath, "utf-8");
+  const html = await fs6.readFile(htmlPath, "utf-8");
   const $ = cheerio.load(html);
   const issues = [];
   const passed = [];
@@ -1038,15 +1240,15 @@ async function validateCommand(options) {
   const projectPath = process.cwd();
   let htmlFiles = [];
   if (options.post) {
-    const postPath = path4.resolve(projectPath, options.post);
-    if (!await fs6.pathExists(postPath)) {
+    const postPath = path5.resolve(projectPath, options.post);
+    if (!await fs7.pathExists(postPath)) {
       console.log(errorBox(`Post not found: ${postPath}`));
       process.exit(1);
     }
     htmlFiles = [postPath];
   } else if (options.posts) {
-    const postsDir = path4.resolve(projectPath, options.posts);
-    if (!await fs6.pathExists(postsDir)) {
+    const postsDir = path5.resolve(projectPath, options.posts);
+    if (!await fs7.pathExists(postsDir)) {
       console.log(errorBox(`Directory not found: ${postsDir}`));
       process.exit(1);
     }
@@ -1056,8 +1258,8 @@ async function validateCommand(options) {
       process.exit(1);
     }
   } else {
-    const defaultBlogDir = path4.join(projectPath, "blog");
-    if (await fs6.pathExists(defaultBlogDir)) {
+    const defaultBlogDir = path5.join(projectPath, "blog");
+    if (await fs7.pathExists(defaultBlogDir)) {
       htmlFiles = await findHtmlFiles(defaultBlogDir);
       if (htmlFiles.length === 0) {
         console.log(errorBox("No HTML files found in blog/ directory"));
@@ -1102,8 +1304,8 @@ async function validateCommand(options) {
       })),
       stats: stats2
     };
-    const outputPath = path4.resolve(projectPath, options.output);
-    await fs6.writeJson(outputPath, report, { spaces: 2 });
+    const outputPath = path5.resolve(projectPath, options.output);
+    await fs7.writeJson(outputPath, report, { spaces: 2 });
     console.log(successBox(`Validation report saved to ${outputPath}`));
   }
   if (filteredResults.length > 0) {
@@ -1181,9 +1383,9 @@ async function validateCommand(options) {
 }
 async function findHtmlFiles(dir) {
   const files = [];
-  const entries = await fs6.readdir(dir, { withFileTypes: true });
+  const entries = await fs7.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path4.join(dir, entry.name);
+    const fullPath = path5.join(dir, entry.name);
     if (entry.isDirectory()) {
       const subFiles = await findHtmlFiles(fullPath);
       files.push(...subFiles);
@@ -1207,18 +1409,163 @@ function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
+// src/cli/commands/doctor.ts
+import fs8 from "fs-extra";
+import path6 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import chalk6 from "chalk";
+async function doctorCommand(options) {
+  console.log(chalk6.cyan.bold("\n\u{1F50D} Diagnosing project configuration...\n"));
+  const projectPath = process.cwd();
+  const configPath = path6.join(projectPath, "edtools.config.js");
+  const issues = [];
+  const warnings = [];
+  const suggestions = [];
+  if (await fs8.pathExists(configPath)) {
+    console.log(chalk6.green("\u2713 Configuration file found: ") + chalk6.white("edtools.config.js"));
+  } else {
+    console.log(chalk6.red("\u2717 Configuration file not found"));
+    console.log(chalk6.yellow('  Run "edtools init" to create configuration\n'));
+    process.exit(1);
+  }
+  let productInfo;
+  let outputDir;
+  try {
+    const configUrl = pathToFileURL2(configPath).href;
+    const config = await import(configUrl);
+    productInfo = config.default.product;
+    outputDir = config.default.content?.outputDir || "./blog";
+    if (!productInfo || !productInfo.name) {
+      issues.push("Invalid product configuration in edtools.config.js");
+    }
+  } catch (error) {
+    issues.push(`Failed to load edtools.config.js: ${error.message}`);
+    console.log(chalk6.red("\u2717 Failed to load configuration file"));
+    console.log(chalk6.red(`  Error: ${error.message}
+`));
+    process.exit(1);
+  }
+  const outputDirPath = path6.resolve(projectPath, outputDir);
+  if (await fs8.pathExists(outputDirPath)) {
+    console.log(chalk6.green("\u2713 Output directory exists: ") + chalk6.white(outputDir));
+  } else {
+    warnings.push(`Output directory does not exist: ${outputDir}`);
+    console.log(chalk6.yellow("\u26A0\uFE0F  Output directory does not exist: ") + chalk6.white(outputDir));
+    console.log(chalk6.yellow('   It will be created when you run "edtools generate"'));
+  }
+  const edtoolsConfigPath = path6.join(projectPath, ".edtools", "config.json");
+  let hasApiKey = false;
+  if (await fs8.pathExists(edtoolsConfigPath)) {
+    try {
+      const edtoolsConfig = await fs8.readJson(edtoolsConfigPath);
+      hasApiKey = !!edtoolsConfig.apiKey;
+    } catch (error) {
+    }
+  }
+  const hasEnvApiKey = !!(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY);
+  if (hasApiKey || hasEnvApiKey) {
+    console.log(chalk6.green("\u2713 API key configured"));
+  } else {
+    warnings.push('No API key found (set via environment variable or "edtools init")');
+    console.log(chalk6.yellow("\u26A0\uFE0F  No API key configured"));
+    console.log(chalk6.yellow("   Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable"));
+    console.log(chalk6.yellow('   Or run "edtools init" to store API key'));
+  }
+  console.log("");
+  const hostingConfig = detectHostingConfig(projectPath);
+  if (hostingConfig) {
+    console.log(chalk6.cyan("\u26A0\uFE0F  HOSTING PLATFORM DETECTED: ") + chalk6.white(hostingConfig.platform));
+    console.log(chalk6.cyan("    - Public directory: ") + chalk6.white(hostingConfig.publicDir));
+    console.log(chalk6.cyan("    - Your outputDir: ") + chalk6.white(outputDir));
+    const validation = validateOutputDir(outputDir, hostingConfig);
+    if (!validation.valid) {
+      issues.push("Output directory misconfiguration");
+      console.log(chalk6.red("    - Problem: Files outside ") + chalk6.white(hostingConfig.publicDir + "/") + chalk6.red(" won't be accessible"));
+      console.log("");
+      console.log(chalk6.red.bold("\u274C ISSUE: Output directory misconfiguration"));
+      console.log(chalk6.red("    Generated files will return 404 in production"));
+      console.log("");
+      console.log(chalk6.cyan.bold("\u{1F4DD} Suggested fix:"));
+      console.log(chalk6.cyan("    Update edtools.config.js:"));
+      console.log("");
+      console.log(chalk6.gray("    content: {"));
+      console.log(chalk6.green(`      outputDir: '${validation.suggestion}'`) + chalk6.gray("  // \u2705 Correct path"));
+      console.log(chalk6.gray("    }"));
+      console.log("");
+      suggestions.push(`Update outputDir to '${validation.suggestion}'`);
+      if (options.fix) {
+        console.log(chalk6.yellow.bold("\u{1F527} Auto-fixing configuration...\n"));
+        try {
+          const configContent = await fs8.readFile(configPath, "utf-8");
+          const updatedConfig = configContent.replace(
+            /outputDir:\s*['"]([^'"]+)['"]/,
+            `outputDir: '${validation.suggestion}'`
+          );
+          await fs8.writeFile(configPath, updatedConfig, "utf-8");
+          console.log(chalk6.green("\u2713 Updated edtools.config.js"));
+          console.log(chalk6.green(`  outputDir: '${validation.suggestion}'`));
+          console.log("");
+          console.log(chalk6.cyan('\u{1F389} Configuration fixed! Run "edtools generate" to create content.\n'));
+        } catch (error) {
+          console.log(chalk6.red("\u2717 Failed to auto-fix configuration"));
+          console.log(chalk6.red(`  Error: ${error.message}`));
+          console.log(chalk6.yellow("  Please update edtools.config.js manually\n"));
+        }
+      } else {
+        console.log(chalk6.cyan.bold("Run: ") + chalk6.white("edtools doctor --fix"));
+        console.log(chalk6.cyan("To automatically apply suggested fixes\n"));
+      }
+    } else {
+      console.log(chalk6.green("    - Status: \u2705 Output directory correctly configured"));
+      console.log("");
+    }
+  } else {
+    console.log(chalk6.gray("No hosting platform configuration detected"));
+    console.log(chalk6.gray("(No firebase.json, vercel.json, netlify.toml, or amplify.yml found)"));
+    console.log("");
+  }
+  console.log(chalk6.cyan.bold("Summary:\n"));
+  if (issues.length === 0 && warnings.length === 0) {
+    console.log(chalk6.green.bold("\u2705 All checks passed! Your project is ready to generate content.\n"));
+  } else {
+    if (issues.length > 0) {
+      console.log(chalk6.red.bold(`\u274C ${issues.length} issue(s) found:`));
+      issues.forEach((issue) => {
+        console.log(chalk6.red(`   - ${issue}`));
+      });
+      console.log("");
+    }
+    if (warnings.length > 0) {
+      console.log(chalk6.yellow.bold(`\u26A0\uFE0F  ${warnings.length} warning(s):`));
+      warnings.forEach((warning) => {
+        console.log(chalk6.yellow(`   - ${warning}`));
+      });
+      console.log("");
+    }
+    if (suggestions.length > 0 && !options.fix) {
+      console.log(chalk6.cyan.bold("\u{1F4A1} Suggestions:"));
+      suggestions.forEach((suggestion) => {
+        console.log(chalk6.cyan(`   - ${suggestion}`));
+      });
+      console.log("");
+      console.log(chalk6.cyan("Run ") + chalk6.white("edtools doctor --fix") + chalk6.cyan(" to automatically apply fixes\n"));
+    }
+  }
+}
+
 // src/cli/index.ts
 var program = new Command();
-program.name("edtools").description("AI-Powered Content Marketing CLI - Generate, validate, and optimize SEO content").version("0.6.0");
+program.name("edtools").description("AI-Powered Content Marketing CLI - Generate, validate, and optimize SEO content").version("0.6.2");
 program.command("init").description("Initialize edtools in your project").option("-p, --path <path>", "Project path", process.cwd()).action(initCommand);
-program.command("generate").description("Generate SEO-optimized blog posts").option("-n, --posts <number>", "Number of posts to generate (1-10)", "3").option("-t, --topics <topics...>", "Specific topics to write about").option("-o, --output <dir>", "Output directory", "./blog").option("--api-key <key>", "API key (or use ANTHROPIC_API_KEY/OPENAI_API_KEY env var)").option("--from-csv", "Generate from CSV analysis opportunities").option("--dry-run", "Preview what would be generated without writing files").option("--report <format>", "Output format: json, table, pretty (default: table)", "table").action(generateCommand);
+program.command("generate").description("Generate SEO-optimized blog posts").option("-n, --posts <number>", "Number of posts to generate (1-10)", "3").option("-t, --topics <topics...>", "Specific topics to write about").option("-o, --output <dir>", "Output directory (defaults to config or ./blog)").option("--api-key <key>", "API key (or use ANTHROPIC_API_KEY/OPENAI_API_KEY env var)").option("--from-csv", "Generate from CSV analysis opportunities").option("--dry-run", "Preview what would be generated without writing files").option("--report <format>", "Output format: json, table, pretty (default: table)", "table").action(generateCommand);
 program.command("analyze").description("Analyze Google Search Console CSV data").option("-f, --file <path>", "Path to CSV file (auto-detects if not provided)").option("--min-impressions <number>", "Minimum impressions for opportunities", "50").option("--min-position <number>", "Minimum position for opportunities", "20").option("--limit <number>", "Number of opportunities to show", "10").action(analyzeCommand);
 program.command("validate").description("Validate SEO quality of existing posts").option("--posts <dir>", "Posts directory to validate").option("--post <file>", "Single post file to validate").option("--output <file>", "Save validation report as JSON").option("--threshold <score>", "Only show posts below this score").action(validateCommand);
+program.command("doctor").description("Diagnose project configuration and hosting setup").option("--fix", "Automatically fix issues").action(doctorCommand);
 program.command("config").description("View or set configuration").option("--set-api-key <key>", "Set Anthropic API key").action(async (options) => {
   if (options.setApiKey) {
-    console.log(chalk6.green("\u2713 API key saved"));
+    console.log(chalk7.green("\u2713 API key saved"));
   } else {
-    console.log(chalk6.cyan("Configuration:"));
+    console.log(chalk7.cyan("Configuration:"));
     console.log(`  API Key: ${process.env.ANTHROPIC_API_KEY ? "[set]" : "[not set]"}`);
   }
 });