@edtools/cli 0.5.0 → 0.6.1

package/dist/cli/index.js

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   ContentGenerator
-} from "../chunk-AJSCN4WK.js";
+} from "../chunk-BI3UJPWA.js";
 import "../chunk-INVECVSW.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
-import chalk5 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";
@@ -49,14 +49,22 @@ function showWelcome() {
   console.log("");
   console.log(`  ${chalk.cyan("edtools init")}          ${chalk.gray("Initialize your project")}`);
   console.log(`  ${chalk.cyan("edtools generate")}      ${chalk.gray("Generate SEO-optimized posts")}`);
+  console.log(`  ${chalk.cyan("edtools validate")}      ${chalk.gray("Validate post quality")}`);
   console.log(`  ${chalk.cyan("edtools analyze")}       ${chalk.gray("Analyze Google Search Console CSV")}`);
   console.log("");
+  console.log(chalk.bold.cyan("  Advanced Usage:"));
+  console.log(chalk.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log("");
+  console.log(`  ${chalk.cyan("edtools generate --dry-run")}           ${chalk.gray("Preview generation")}`);
+  console.log(`  ${chalk.cyan("edtools generate --report json")}       ${chalk.gray("JSON output")}`);
+  console.log(`  ${chalk.cyan("edtools validate --threshold 85")}      ${chalk.gray("Show posts < 85")}`);
+  console.log("");
   console.log(chalk.gray("  Run ") + chalk.cyan("edtools --help") + chalk.gray(" for all commands"));
   console.log("");
 }
 function getVersion() {
   try {
-    return "0.5.0";
+    return "0.6.0";
   } catch {
     return "dev";
   }
@@ -96,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",
@@ -118,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",
@@ -240,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)},
@@ -253,7 +418,7 @@ async function initCommand(options) {
   },
 
   content: {
-    outputDir: './blog',
+    outputDir: ${JSON.stringify(suggestedOutputDir)},
     generateBlog: true,
   },
 
@@ -264,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:")}
@@ -294,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);
@@ -318,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) {
     }
@@ -348,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) => {
@@ -376,8 +542,40 @@ 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);
+  const outputDir = path3.resolve(projectPath, options.output);
+  await fs3.ensureDir(outputDir);
+  const hostingConfig = detectHostingConfig(projectPath);
+  if (hostingConfig) {
+    const validation = validateOutputDir(options.output, 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)}`);
@@ -395,52 +593,120 @@ async function generateCommand(options) {
     avoidDuplicates: true,
     similarityThreshold: 0.85,
     provider,
-    apiKey
+    apiKey,
+    dryRun: options.dryRun
   };
   const providerName = provider === "anthropic" ? "Claude" : "ChatGPT";
   const spinner = ora2(`Generating content with ${providerName}...`).start();
   try {
     const result = await generator.generate(generateConfig);
     if (result.success && result.posts.length > 0) {
-      spinner.succeed(chalk3.bold("Content generated successfully!"));
+      const dryRunMode = result.dryRun || false;
+      spinner.succeed(chalk3.bold(dryRunMode ? "Preview generated successfully!" : "Content generated successfully!"));
       console.log("");
-      const table = new Table({
-        head: [
-          chalk3.cyan.bold("#"),
-          chalk3.cyan.bold("Title"),
-          chalk3.cyan.bold("SEO Score"),
-          chalk3.cyan.bold("Path")
-        ],
-        colWidths: [5, 40, 12, 50],
-        wordWrap: true,
-        style: {
-          head: [],
-          border: ["cyan"]
-        }
-      });
-      result.posts.forEach((post, i) => {
-        const scoreColor = getScoreColorFn(post.seoScore);
-        table.push([
-          chalk3.gray((i + 1).toString()),
-          chalk3.white(post.title),
-          scoreColor(`${post.seoScore}/100`),
-          chalk3.gray(post.path)
-        ]);
-      });
-      console.log(table.toString());
-      console.log("");
-      console.log(successBox(`Generated ${result.posts.length} SEO-optimized ${result.posts.length === 1 ? "post" : "posts"}!`));
-      if (result.warnings && result.warnings.length > 0) {
-        const warningText = result.warnings.join("\n");
-        console.log(warningBox(warningText));
+      if (dryRunMode) {
+        console.log(chalk3.yellow.bold("\u{1F50D} DRY RUN MODE - No files were written\n"));
       }
-      console.log(chalk3.cyan.bold("Next steps:"));
-      console.log(`  ${chalk3.cyan("1.")} Review generated content in ${chalk3.white(outputDir)}`);
-      console.log(`  ${chalk3.cyan("2.")} Edit posts to add personal experience/expertise`);
-      console.log(`  ${chalk3.cyan("3.")} Deploy to your website`);
-      console.log("");
-      console.log(chalk3.yellow(`\u{1F4A1} Tip: Wait 3-7 days before generating more posts to avoid spam detection
+      if (options.report === "json" || options.report === "pretty") {
+        const report = {
+          success: result.success,
+          generated: result.posts.length,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          files: result.posts.map((post) => ({
+            path: post.path,
+            slug: post.slug,
+            title: post.title,
+            url: post.url,
+            wordCount: post.wordCount,
+            readTime: post.readTime,
+            seoScore: post.seoScore,
+            issues: post.seoIssues || [],
+            metadata: {
+              id: post.id,
+              tags: post.tags,
+              keywords: post.keywords,
+              datePublished: post.datePublished
+            }
+          })),
+          manifestPath: result.manifestPath,
+          sitemapPath: result.sitemapPath,
+          stats: result.stats || {
+            avgSeoScore: result.posts.reduce((sum, p) => sum + p.seoScore, 0) / result.posts.length,
+            totalWords: result.posts.reduce((sum, p) => sum + p.wordCount, 0),
+            avgReadTime: result.posts[0]?.readTime || "0 min"
+          },
+          warnings: result.warnings || [],
+          errors: result.errors || [],
+          dryRun: dryRunMode
+        };
+        const indent = options.report === "pretty" ? 2 : 0;
+        console.log(JSON.stringify(report, null, indent));
+      } else {
+        const table = new Table({
+          head: [
+            chalk3.cyan.bold("#"),
+            chalk3.cyan.bold("Title"),
+            chalk3.cyan.bold("Words"),
+            chalk3.cyan.bold("SEO"),
+            dryRunMode ? chalk3.cyan.bold("Would Create") : chalk3.cyan.bold("Path")
+          ],
+          colWidths: [5, 35, 10, 10, 45],
+          wordWrap: true,
+          style: {
+            head: [],
+            border: ["cyan"]
+          }
+        });
+        result.posts.forEach((post, i) => {
+          const scoreColor = getScoreColorFn(post.seoScore);
+          table.push([
+            chalk3.gray((i + 1).toString()),
+            chalk3.white(truncateTitle(post.title, 33)),
+            chalk3.white(post.wordCount.toString()),
+            scoreColor(`${post.seoScore}/100`),
+            chalk3.gray(post.path)
+          ]);
+        });
+        console.log(table.toString());
+        console.log("");
+        if (result.stats) {
+          console.log(chalk3.cyan.bold("Statistics:\n"));
+          console.log(`  Total words: ${chalk3.white(result.stats.totalWords)}`);
+          console.log(`  Avg SEO score: ${getScoreColorFn(result.stats.avgSeoScore)(result.stats.avgSeoScore + "/100")}`);
+          console.log(`  Avg read time: ${chalk3.white(result.stats.avgReadTime)}`);
+          console.log("");
+        }
+        if (dryRunMode) {
+          console.log(chalk3.yellow.bold("Would create:\n"));
+          if (result.manifestPath) {
+            console.log(`  ${chalk3.yellow("\u2022")} ${chalk3.white(result.manifestPath)} (manifest with ${result.posts.length} posts)`);
+          }
+          if (result.sitemapPath) {
+            console.log(`  ${chalk3.yellow("\u2022")} ${chalk3.white(result.sitemapPath)} (sitemap with ${result.posts.length} URLs)`);
+          }
+          console.log("");
+        }
+        if (!dryRunMode) {
+          console.log(successBox(`Generated ${result.posts.length} SEO-optimized ${result.posts.length === 1 ? "post" : "posts"}!`));
+        }
+        if (result.warnings && result.warnings.length > 0) {
+          const warningText = result.warnings.join("\n");
+          console.log(warningBox(warningText));
+        }
+        if (dryRunMode) {
+          console.log(chalk3.cyan.bold("Next step:"));
+          console.log(`  ${chalk3.cyan("\u2022")} Run without ${chalk3.white("--dry-run")} to generate files
+`);
+        } else {
+          console.log(chalk3.cyan.bold("Next steps:"));
+          console.log(`  ${chalk3.cyan("1.")} Review generated content in ${chalk3.white(outputDir)}`);
+          console.log(`  ${chalk3.cyan("2.")} Edit posts to add personal experience/expertise`);
+          console.log(`  ${chalk3.cyan("3.")} Deploy to your website`);
+          console.log("");
+          console.log(chalk3.yellow(`\u{1F4A1} Tip: Wait 3-7 days before generating more posts to avoid spam detection
 `));
+        }
+      }
     } else {
       spinner.fail(chalk3.bold("Failed to generate content"));
       if (result.errors && result.errors.length > 0) {
@@ -456,23 +722,28 @@ async function generateCommand(options) {
   }
 }
 function getScoreColorFn(score) {
-  if (score >= 80) return chalk3.green;
-  if (score >= 60) return chalk3.yellow;
+  if (score >= 90) return chalk3.green;
+  if (score >= 75) return chalk3.yellow;
+  if (score >= 60) return chalk3.hex("#FFA500");
   return chalk3.red;
 }
+function truncateTitle(title, maxLen) {
+  if (title.length <= maxLen) return title;
+  return title.substring(0, maxLen - 3) + "...";
+}
 
 // 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,
@@ -568,7 +839,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
@@ -577,9 +848,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"));
@@ -592,9 +863,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);
@@ -603,7 +874,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(`
@@ -708,9 +979,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:"));
@@ -720,17 +991,569 @@ Error: ${error.message}
   console.log(chalk4.gray("\u{1F4A1} Use --from-csv to automatically generate posts for top opportunities\n"));
 }
 
+// src/cli/commands/validate.ts
+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 fs6 from "fs-extra";
+async function validatePost(htmlPath) {
+  const html = await fs6.readFile(htmlPath, "utf-8");
+  const $ = cheerio.load(html);
+  const issues = [];
+  const passed = [];
+  const metadata = {};
+  const title = $("title").text().trim();
+  metadata.titleLength = title.length;
+  if (!title) {
+    issues.push({
+      severity: "error",
+      category: "metadata",
+      message: "Missing <title> tag",
+      suggestion: "Add a descriptive title (50-60 characters)"
+    });
+  } else if (title.length < 30) {
+    issues.push({
+      severity: "warning",
+      category: "metadata",
+      message: `Title too short (${title.length} chars)`,
+      suggestion: "Optimal length is 50-60 characters for better CTR"
+    });
+  } else if (title.length > 60) {
+    issues.push({
+      severity: "warning",
+      category: "metadata",
+      message: `Title too long (${title.length} chars)`,
+      suggestion: "Shorten to 50-60 characters to avoid truncation in SERPs"
+    });
+  } else {
+    passed.push(`Title length optimal (${title.length} chars)`);
+  }
+  const metaDesc = $('meta[name="description"]').attr("content")?.trim() || "";
+  metadata.descriptionLength = metaDesc.length;
+  if (!metaDesc) {
+    issues.push({
+      severity: "error",
+      category: "metadata",
+      message: "Missing meta description",
+      suggestion: "Add a compelling description (150-160 characters)"
+    });
+  } else if (metaDesc.length < 120) {
+    issues.push({
+      severity: "warning",
+      category: "metadata",
+      message: `Meta description too short (${metaDesc.length}/160 chars)`,
+      suggestion: `Add ${160 - metaDesc.length} more characters to optimize CTR`
+    });
+  } else if (metaDesc.length > 160) {
+    issues.push({
+      severity: "warning",
+      category: "metadata",
+      message: `Meta description too long (${metaDesc.length}/160 chars)`,
+      suggestion: `Remove ${metaDesc.length - 160} characters to avoid truncation`
+    });
+  } else {
+    passed.push(`Meta description optimal (${metaDesc.length} chars)`);
+  }
+  const h1Elements = $("h1");
+  const h1Count = h1Elements.length;
+  metadata.h1Count = h1Count;
+  if (h1Count === 0) {
+    issues.push({
+      severity: "error",
+      category: "headings",
+      message: "Missing H1 heading",
+      suggestion: "Add a single H1 with primary keyword"
+    });
+  } else if (h1Count > 1) {
+    issues.push({
+      severity: "warning",
+      category: "headings",
+      message: `Multiple H1 tags found (${h1Count})`,
+      suggestion: "Use only one H1 per page for proper structure"
+    });
+  } else {
+    passed.push("Single H1 heading");
+  }
+  const h2Count = $("h2").length;
+  metadata.h2Count = h2Count;
+  if (h2Count < 2) {
+    issues.push({
+      severity: "warning",
+      category: "headings",
+      message: `Few H2 headings for readability (${h2Count} found)`,
+      suggestion: "Add 3-5 H2 headings for better structure and scannability"
+    });
+  } else if (h2Count > 10) {
+    issues.push({
+      severity: "info",
+      category: "headings",
+      message: `Many H2 headings (${h2Count})`,
+      suggestion: "Consider if all sections need H2 or some should be H3"
+    });
+  } else {
+    passed.push(`Good heading structure (${h2Count} H2s)`);
+  }
+  const images = $("img");
+  metadata.imageCount = images.length;
+  const imagesWithoutAlt = images.filter((i, el) => !$(el).attr("alt")).length;
+  if (imagesWithoutAlt > 0) {
+    issues.push({
+      severity: "warning",
+      category: "images",
+      message: `${imagesWithoutAlt} image${imagesWithoutAlt > 1 ? "s" : ""} missing alt text`,
+      suggestion: "Add descriptive alt text to all images for accessibility and SEO"
+    });
+  } else if (images.length > 0) {
+    passed.push(`All images have alt text (${images.length} images)`);
+  }
+  const schemaScript = $('script[type="application/ld+json"]');
+  if (schemaScript.length === 0) {
+    issues.push({
+      severity: "info",
+      category: "structure",
+      message: "Missing Schema.org markup",
+      suggestion: "Add structured data for rich snippets in search results"
+    });
+  } else {
+    passed.push("Has Schema.org markup");
+  }
+  const metaKeywords = $('meta[name="keywords"]');
+  if (metaKeywords.length > 0) {
+    issues.push({
+      severity: "info",
+      category: "metadata",
+      message: "Using deprecated meta keywords tag",
+      suggestion: "Remove meta keywords tag (not used by modern search engines)"
+    });
+  }
+  const ogTitle = $('meta[property="og:title"]').attr("content");
+  const ogDescription = $('meta[property="og:description"]').attr("content");
+  const ogImage = $('meta[property="og:image"]').attr("content");
+  if (!ogTitle || !ogDescription) {
+    issues.push({
+      severity: "info",
+      category: "metadata",
+      message: "Missing Open Graph tags",
+      suggestion: "Add og:title, og:description, og:image for better social sharing"
+    });
+  } else {
+    passed.push("Has Open Graph tags");
+  }
+  const bodyText = $("article, main, body").text();
+  const wordCount = bodyText.replace(/\s+/g, " ").trim().split(/\s+/).filter((word) => word.length > 0).length;
+  metadata.wordCount = wordCount;
+  if (wordCount < 300) {
+    issues.push({
+      severity: "warning",
+      category: "content",
+      message: `Content too short (${wordCount} words)`,
+      suggestion: "Aim for at least 1000 words for better SEO performance"
+    });
+  } else if (wordCount < 1e3) {
+    issues.push({
+      severity: "info",
+      category: "content",
+      message: `Content could be longer (${wordCount} words)`,
+      suggestion: "Consider expanding to 1500+ words for comprehensive coverage"
+    });
+  } else {
+    passed.push(`Good content length (${wordCount} words)`);
+  }
+  const links = $("a[href]");
+  const internalLinks = links.filter((i, el) => {
+    const href = $(el).attr("href") || "";
+    return href.startsWith("/") || href.startsWith("#");
+  }).length;
+  const externalLinks = links.length - internalLinks;
+  if (internalLinks === 0 && links.length > 0) {
+    issues.push({
+      severity: "info",
+      category: "links",
+      message: "No internal links found",
+      suggestion: "Add 2-3 internal links to related content"
+    });
+  } else if (internalLinks > 0) {
+    passed.push(`Has internal links (${internalLinks} links)`);
+  }
+  const errorCount = issues.filter((i) => i.severity === "error").length;
+  const warningCount = issues.filter((i) => i.severity === "warning").length;
+  const infoCount = issues.filter((i) => i.severity === "info").length;
+  let score = 100;
+  score -= errorCount * 20;
+  score -= warningCount * 7;
+  score -= infoCount * 2;
+  score = Math.max(0, Math.min(100, score));
+  return {
+    path: htmlPath,
+    title: title || "Untitled",
+    seoScore: score,
+    issues,
+    passed,
+    metadata
+  };
+}
+function calculateValidationStats(results) {
+  const totalPosts = results.length;
+  const avgSeoScore = results.reduce((sum, r) => sum + r.seoScore, 0) / totalPosts;
+  const totalIssues = results.reduce((sum, r) => sum + r.issues.length, 0);
+  const postsWithIssues = results.filter((r) => r.issues.length > 0).length;
+  const issuesBySeverity = {
+    error: results.reduce((sum, r) => sum + r.issues.filter((i) => i.severity === "error").length, 0),
+    warning: results.reduce((sum, r) => sum + r.issues.filter((i) => i.severity === "warning").length, 0),
+    info: results.reduce((sum, r) => sum + r.issues.filter((i) => i.severity === "info").length, 0)
+  };
+  const issuesByCategory = results.reduce((acc, r) => {
+    r.issues.forEach((issue) => {
+      acc[issue.category] = (acc[issue.category] || 0) + 1;
+    });
+    return acc;
+  }, {});
+  return {
+    totalPosts,
+    avgSeoScore: Math.round(avgSeoScore * 10) / 10,
+    totalIssues,
+    postsWithIssues,
+    issuesBySeverity,
+    issuesByCategory
+  };
+}
+
+// src/cli/commands/validate.ts
+async function validateCommand(options) {
+  console.log(chalk5.cyan.bold("\n\u{1F4CA} Validating SEO quality...\n"));
+  const projectPath = process.cwd();
+  let htmlFiles = [];
+  if (options.post) {
+    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 = path5.resolve(projectPath, options.posts);
+    if (!await fs7.pathExists(postsDir)) {
+      console.log(errorBox(`Directory not found: ${postsDir}`));
+      process.exit(1);
+    }
+    htmlFiles = await findHtmlFiles(postsDir);
+    if (htmlFiles.length === 0) {
+      console.log(errorBox(`No HTML files found in: ${postsDir}`));
+      process.exit(1);
+    }
+  } else {
+    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"));
+        process.exit(1);
+      }
+    } else {
+      console.log(errorBox("No posts directory specified"));
+      console.log(chalk5.yellow("Usage: edtools validate --posts <dir> or --post <file>\n"));
+      process.exit(1);
+    }
+  }
+  console.log(chalk5.cyan(`Found ${htmlFiles.length} post${htmlFiles.length > 1 ? "s" : ""} to validate
+`));
+  const results = [];
+  for (const htmlFile of htmlFiles) {
+    try {
+      const result = await validatePost(htmlFile);
+      results.push(result);
+    } catch (error) {
+      console.log(chalk5.yellow(`\u26A0\uFE0F  Failed to validate ${htmlFile}: ${error.message}`));
+    }
+  }
+  if (results.length === 0) {
+    console.log(errorBox("No posts could be validated"));
+    process.exit(1);
+  }
+  const threshold = options.threshold ? parseInt(options.threshold, 10) : 0;
+  const filteredResults = threshold > 0 ? results.filter((r) => r.seoScore < threshold) : results;
+  if (options.output) {
+    const stats2 = calculateValidationStats(results);
+    const report = {
+      success: true,
+      validated: results.length,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      posts: results.map((r) => ({
+        path: r.path,
+        title: r.title,
+        seoScore: r.seoScore,
+        issues: r.issues,
+        passed: r.passed,
+        metadata: r.metadata
+      })),
+      stats: stats2
+    };
+    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) {
+    const table = new Table3({
+      head: [
+        chalk5.cyan.bold("#"),
+        chalk5.cyan.bold("Title"),
+        chalk5.cyan.bold("Score"),
+        chalk5.cyan.bold("Issues")
+      ],
+      colWidths: [5, 40, 10, 50],
+      wordWrap: true,
+      style: {
+        head: [],
+        border: ["cyan"]
+      }
+    });
+    filteredResults.forEach((result, i) => {
+      const scoreColor = getScoreColor(result.seoScore);
+      const issuesText = result.issues.length > 0 ? result.issues.map((issue) => {
+        const icon = issue.severity === "error" ? "\u2717" : issue.severity === "warning" ? "\u26A0" : "\u2139";
+        const color = issue.severity === "error" ? chalk5.red : issue.severity === "warning" ? chalk5.yellow : chalk5.blue;
+        return color(`${icon} ${issue.message}`);
+      }).join("\n") : chalk5.green("\u2713 No issues");
+      table.push([
+        chalk5.gray((i + 1).toString()),
+        chalk5.white(truncate(result.title, 38)),
+        scoreColor(`${result.seoScore}/100`),
+        issuesText
+      ]);
+    });
+    console.log(table.toString());
+    console.log("");
+  } else if (threshold > 0) {
+    console.log(successBox(`All posts have SEO score >= ${threshold}`));
+  }
+  const stats = calculateValidationStats(results);
+  console.log(chalk5.cyan.bold("Overall Statistics:\n"));
+  console.log(`  Total posts validated: ${chalk5.white(stats.totalPosts)}`);
+  console.log(`  Average SEO score: ${getScoreColor(stats.avgSeoScore)(stats.avgSeoScore + "/100")}`);
+  console.log(`  Posts with issues: ${chalk5.white(stats.postsWithIssues)} (${Math.round(stats.postsWithIssues / stats.totalPosts * 100)}%)`);
+  console.log(`  Total issues found: ${chalk5.white(stats.totalIssues)}`);
+  console.log("");
+  if (stats.totalIssues > 0) {
+    console.log(chalk5.cyan.bold("Issues by Severity:\n"));
+    if (stats.issuesBySeverity.error > 0) {
+      console.log(`  ${chalk5.red("\u2717 Errors:")} ${chalk5.white(stats.issuesBySeverity.error)}`);
+    }
+    if (stats.issuesBySeverity.warning > 0) {
+      console.log(`  ${chalk5.yellow("\u26A0 Warnings:")} ${chalk5.white(stats.issuesBySeverity.warning)}`);
+    }
+    if (stats.issuesBySeverity.info > 0) {
+      console.log(`  ${chalk5.blue("\u2139 Info:")} ${chalk5.white(stats.issuesBySeverity.info)}`);
+    }
+    console.log("");
+  }
+  if (Object.keys(stats.issuesByCategory).length > 0) {
+    console.log(chalk5.cyan.bold("Top Issue Categories:\n"));
+    const sortedCategories = Object.entries(stats.issuesByCategory).sort((a, b) => b[1] - a[1]).slice(0, 5);
+    sortedCategories.forEach(([category, count]) => {
+      console.log(`  ${chalk5.white(capitalize(category))}: ${chalk5.yellow(count)}`);
+    });
+    console.log("");
+  }
+  if (stats.avgSeoScore < 85) {
+    console.log(chalk5.yellow.bold("\u{1F4A1} Recommendations:\n"));
+    console.log(chalk5.yellow("  \u2022 Focus on fixing critical errors first"));
+    console.log(chalk5.yellow("  \u2022 Optimize meta descriptions to 150-160 characters"));
+    console.log(chalk5.yellow("  \u2022 Ensure all posts have proper heading structure (H1, H2s)"));
+    console.log(chalk5.yellow("  \u2022 Add alt text to all images"));
+    console.log("");
+  } else {
+    console.log(successBox(`Great job! Average SEO score is ${stats.avgSeoScore}/100`));
+  }
+}
+async function findHtmlFiles(dir) {
+  const files = [];
+  const entries = await fs7.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path5.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const subFiles = await findHtmlFiles(fullPath);
+      files.push(...subFiles);
+    } else if (entry.isFile() && entry.name.endsWith(".html")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function getScoreColor(score) {
+  if (score >= 90) return chalk5.green;
+  if (score >= 75) return chalk5.yellow;
+  if (score >= 60) return chalk5.hex("#FFA500");
+  return chalk5.red;
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 3) + "...";
+}
+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").version("0.5.0");
+program.name("edtools").description("AI-Powered Content Marketing CLI - Generate, validate, and optimize SEO content").version("0.6.1");
 program.command("init").description("Initialize edtools in your project").option("-p, --path <path>", "Project path", process.cwd()).action(initCommand);
-program.command("generate").description("Generate blog posts").option("-n, --posts <number>", "Number of posts to generate", "3").option("-t, --topics <topics...>", "Specific topics to write about").option("-o, --output <dir>", "Output directory", "./blog").option("--api-key <key>", "Anthropic API key (or set ANTHROPIC_API_KEY env var)").option("--from-csv", "Generate from CSV analysis opportunities").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", "./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(chalk5.green("\u2713 API key saved"));
+    console.log(chalk7.green("\u2713 API key saved"));
   } else {
-    console.log(chalk5.cyan("Configuration:"));
+    console.log(chalk7.cyan("Configuration:"));
     console.log(`  API Key: ${process.env.ANTHROPIC_API_KEY ? "[set]" : "[not set]"}`);
   }
 });