hale-commenting-system 1.0.0

package/cli/dist/index.js

@@ -0,0 +1,843 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk11 from "chalk";
+
+// src/commands/init.ts
+import chalk9 from "chalk";
+import ora from "ora";
+import inquirer3 from "inquirer";
+
+// src/utils/detect.ts
+import fs from "fs/promises";
+import path from "path";
+async function detectProject(cwd) {
+  const packageJsonPath = path.join(cwd, "package.json");
+  let packageJson = {};
+  try {
+    const content = await fs.readFile(packageJsonPath, "utf-8");
+    packageJson = JSON.parse(content);
+  } catch (error) {
+    throw new Error("No package.json found. Are you in a Node.js project?");
+  }
+  const deps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  const buildTool = await detectBuildTool(cwd, deps);
+  return {
+    root: cwd,
+    framework: detectFramework(deps),
+    buildTool,
+    isReact: !!deps["react"],
+    hasPatternFly: !!deps["@patternfly/react-core"],
+    hasTypeScript: !!deps["typescript"],
+    packageJson
+  };
+}
+function detectFramework(deps) {
+  if (deps["react"]) return "React";
+  if (deps["vue"]) return "Vue";
+  if (deps["@angular/core"]) return "Angular";
+  return "Unknown";
+}
+async function detectBuildTool(cwd, deps) {
+  if (deps["vite"]) return "Vite";
+  if (deps["webpack"]) return "Webpack";
+  try {
+    await fs.access(path.join(cwd, "next.config.js"));
+    return "Next.js";
+  } catch {
+  }
+  return "Unknown";
+}
+async function detectPlatform(cwd) {
+  try {
+    await fs.access(path.join(cwd, "vercel.json"));
+    return "vercel";
+  } catch {
+  }
+  try {
+    await fs.access(path.join(cwd, "netlify.toml"));
+    return "netlify";
+  } catch {
+  }
+  return null;
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+function printWelcome() {
+  console.log(chalk.bold.cyan("\n\u{1F680} Apollo Commenting System Setup Wizard\n"));
+}
+function printSetupInstructions(platform, project) {
+  console.log(chalk.bold("\n\u{1F4DD} Manual Setup Required:\n"));
+  console.log(chalk.cyan("1. Add the CommentProvider to your App.tsx:\n"));
+  console.log(chalk.white(`import {
+  CommentProvider,
+  VersionProvider,
+  GitHubAuthProvider,
+  CommentOverlay,
+  CommentDrawer
+} from '@apollo/commenting-system';
+import apolloCommentsConfig from './apollo-comments.config.json';
+import React from 'react';
+
+function App() {
+  const [selectedThreadId, setSelectedThreadId] = React.useState<string | null>(null);
+
+  return (
+    <GitHubAuthProvider config={apolloCommentsConfig}>
+      <VersionProvider>
+        <CommentProvider>
+          <CommentDrawer 
+            selectedThreadId={selectedThreadId} 
+            onThreadSelect={setSelectedThreadId}
+          >
+            <CommentOverlay 
+              selectedThreadId={selectedThreadId} 
+              onThreadSelect={setSelectedThreadId}
+            />
+            {/* Your app content */}
+          </CommentDrawer>
+        </CommentProvider>
+      </VersionProvider>
+    </GitHubAuthProvider>
+  );
+}
+`));
+  console.log(chalk.cyan("\n2. Deploy your serverless functions:\n"));
+  if (platform === "vercel") {
+    console.log(chalk.white("  vercel --prod"));
+  } else if (platform === "netlify") {
+    console.log(chalk.white("  netlify deploy --prod"));
+  } else {
+    console.log(chalk.white("  Follow your platform's deployment guide"));
+  }
+  console.log(chalk.cyan("\n3. Update your GitHub OAuth App callback URL:\n"));
+  console.log(chalk.white("  https://your-domain.com/api/github-oauth-callback\n"));
+}
+function printSuccess() {
+  console.log(chalk.green.bold("\n\u2713 Setup complete!\n"));
+}
+function printNextSteps() {
+  console.log(chalk.cyan("\nNext steps:"));
+  console.log(chalk.white("1. Review generated files in your project"));
+  console.log(chalk.white("2. Add the CommentProvider to your App.tsx (see instructions above)"));
+  console.log(chalk.white("3. Deploy your serverless functions"));
+  console.log(chalk.white("4. Run: npm run dev\n"));
+  console.log(chalk.dim('Run "apollo-comments validate" to verify your setup.\n'));
+}
+function printWarning(message) {
+  console.log(chalk.yellow(`\u26A0\uFE0F  ${message}`));
+}
+
+// src/prompts/platform.ts
+import inquirer from "inquirer";
+import chalk2 from "chalk";
+async function promptPlatform(projectRoot) {
+  const detectedPlatform = await detectPlatform(projectRoot);
+  if (detectedPlatform) {
+    console.log(chalk2.green(`\u2713 Detected ${detectedPlatform} configuration`));
+    const { usePlatform } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "usePlatform",
+        message: `Use ${detectedPlatform} for serverless functions?`,
+        default: true
+      }
+    ]);
+    if (usePlatform) {
+      return detectedPlatform;
+    }
+  }
+  const { platform } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "platform",
+      message: "Select your deployment platform:",
+      choices: [
+        { name: "Vercel", value: "vercel" },
+        { name: "Netlify", value: "netlify" },
+        { name: "Manual (I will configure myself)", value: "manual" }
+      ]
+    }
+  ]);
+  return platform;
+}
+
+// src/prompts/github.ts
+import inquirer2 from "inquirer";
+import chalk3 from "chalk";
+async function promptGitHubConfig(skipPrompts = false) {
+  if (skipPrompts) {
+    console.log(chalk3.yellow("Using default/environment values..."));
+    return {
+      clientId: process.env.GITHUB_CLIENT_ID || "",
+      clientSecret: process.env.GITHUB_CLIENT_SECRET || "",
+      owner: process.env.GITHUB_OWNER || "",
+      repo: process.env.GITHUB_REPO || ""
+    };
+  }
+  console.log(chalk3.bold("\n\u{1F4CB} GitHub OAuth Configuration\n"));
+  console.log(chalk3.dim("You need to create a GitHub OAuth App:"));
+  console.log(chalk3.dim("https://github.com/settings/developers\n"));
+  const answers = await inquirer2.prompt([
+    {
+      type: "input",
+      name: "clientId",
+      message: "GitHub OAuth Client ID:",
+      validate: (input) => input.length > 0 || "Client ID is required"
+    },
+    {
+      type: "password",
+      name: "clientSecret",
+      message: "GitHub OAuth Client Secret:",
+      mask: "*",
+      validate: (input) => input.length > 0 || "Client Secret is required"
+    },
+    {
+      type: "input",
+      name: "owner",
+      message: "GitHub Repository Owner (user or org):",
+      validate: (input) => input.length > 0 || "Owner is required"
+    },
+    {
+      type: "input",
+      name: "repo",
+      message: "GitHub Repository Name:",
+      validate: (input) => input.length > 0 || "Repository name is required"
+    }
+  ]);
+  return answers;
+}
+
+// src/generators/serverless.ts
+import path2 from "path";
+import chalk4 from "chalk";
+
+// src/utils/fs.ts
+import fs2 from "fs/promises";
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(dirPath) {
+  await fs2.mkdir(dirPath, { recursive: true });
+}
+async function appendToFile(filePath, content) {
+  await fs2.appendFile(filePath, content, "utf-8");
+}
+async function readFile(filePath) {
+  return fs2.readFile(filePath, "utf-8");
+}
+async function writeFile(filePath, content) {
+  await fs2.writeFile(filePath, content, "utf-8");
+}
+
+// src/templates/vercel-auth.ts
+var vercelAuthLoginTemplate = `import { VercelRequest, VercelResponse } from '@vercel/node';
+
+export default async function handler(req: VercelRequest, res: VercelResponse): Promise<void> {
+  try {
+    const clientId = process.env.GITHUB_CLIENT_ID || process.env.VITE_GITHUB_CLIENT_ID;
+    
+    if (!clientId) {
+      res.status(500).json({ error: 'GitHub OAuth not configured - missing client ID' });
+      return;
+    }
+
+    // Get the base URL from the request
+    const protocol = (req.headers['x-forwarded-proto'] as string) || 'https';
+    const host = (req.headers.host || req.headers['x-forwarded-host']) as string;
+    
+    if (!host) {
+      res.status(500).json({ error: 'Could not determine host' });
+      return;
+    }
+    
+    const baseUrl = \`\${protocol}://\${host}\`;
+    const redirectUri = \`\${baseUrl}/api/github-oauth-callback\`;
+
+    // Redirect to GitHub OAuth
+    // Scope: public_repo allows read/write access to public repositories only
+    const githubAuthUrl = \`https://github.com/login/oauth/authorize?client_id=\${clientId}&redirect_uri=\${encodeURIComponent(redirectUri)}&scope=public_repo\`;
+
+    res.redirect(302, githubAuthUrl);
+  } catch (error: any) {
+    res.status(500).json({ 
+      error: 'Internal server error', 
+      details: error.message
+    });
+  }
+}
+`;
+var vercelAuthCallbackTemplate = `import { VercelRequest, VercelResponse } from '@vercel/node';
+import axios from 'axios';
+
+export default async function handler(req: VercelRequest, res: VercelResponse): Promise<void> {
+  try {
+    const code = req.query.code as string;
+    const clientId = process.env.GITHUB_CLIENT_ID || process.env.VITE_GITHUB_CLIENT_ID;
+    const clientSecret = process.env.GITHUB_CLIENT_SECRET;
+
+    if (!code) {
+      res.status(400).json({ error: 'No code provided' });
+      return;
+    }
+
+    if (!clientId || !clientSecret) {
+      res.status(500).json({ error: 'GitHub OAuth not configured properly' });
+      return;
+    }
+
+    // Exchange code for access token
+    const tokenResponse = await axios.post(
+      'https://github.com/login/oauth/access_token',
+      {
+        client_id: clientId,
+        client_secret: clientSecret,
+        code,
+      },
+      {
+        headers: {
+          Accept: 'application/json',
+        },
+      }
+    );
+
+    const accessToken = tokenResponse.data.access_token;
+
+    if (!accessToken) {
+      throw new Error('No access token received');
+    }
+
+    // Get user info
+    const userResponse = await axios.get('https://api.github.com/user', {
+      headers: {
+        Authorization: \`token \${accessToken}\`,
+      },
+    });
+
+    const user = userResponse.data;
+
+    // Redirect back to the app with token in URL fragment (client-side only)
+    const protocol = req.headers['x-forwarded-proto'] || 'https';
+    const host = req.headers.host || req.headers['x-forwarded-host'];
+    const baseUrl = \`\${protocol}://\${host}\`;
+    const redirectUrl = \`\${baseUrl}/#/auth-callback?token=\${accessToken}&login=\${user.login}&avatar=\${encodeURIComponent(user.avatar_url)}\`;
+
+    res.redirect(302, redirectUrl);
+  } catch (error: any) {
+    res.status(500).json({
+      error: 'Failed to exchange code for token',
+      details: error.message,
+    });
+  }
+}
+`;
+
+// src/templates/netlify-auth.ts
+var netlifyAuthLoginTemplate = `import { Handler, HandlerEvent, HandlerContext } from '@netlify/functions';
+import axios from 'axios';
+
+const handler: Handler = async (event: HandlerEvent, context: HandlerContext) => {
+  try {
+    const clientId = process.env.GITHUB_CLIENT_ID || process.env.VITE_GITHUB_CLIENT_ID;
+    
+    if (!clientId) {
+      return {
+        statusCode: 500,
+        body: JSON.stringify({ error: 'GitHub OAuth not configured - missing client ID' })
+      };
+    }
+
+    // Get the base URL from the request
+    const protocol = event.headers['x-forwarded-proto'] || 'https';
+    const host = event.headers.host;
+    
+    if (!host) {
+      return {
+        statusCode: 500,
+        body: JSON.stringify({ error: 'Could not determine host' })
+      };
+    }
+    
+    const baseUrl = \`\${protocol}://\${host}\`;
+    const redirectUri = \`\${baseUrl}/.netlify/functions/github-oauth-callback\`;
+
+    // Redirect to GitHub OAuth
+    const githubAuthUrl = \`https://github.com/login/oauth/authorize?client_id=\${clientId}&redirect_uri=\${encodeURIComponent(redirectUri)}&scope=public_repo\`;
+
+    return {
+      statusCode: 302,
+      headers: {
+        Location: githubAuthUrl
+      },
+      body: ''
+    };
+  } catch (error: any) {
+    return {
+      statusCode: 500,
+      body: JSON.stringify({ 
+        error: 'Internal server error', 
+        details: error.message
+      })
+    };
+  }
+};
+
+export { handler };
+`;
+var netlifyAuthCallbackTemplate = `import { Handler, HandlerEvent, HandlerContext } from '@netlify/functions';
+import axios from 'axios';
+
+const handler: Handler = async (event: HandlerEvent, context: HandlerContext) => {
+  try {
+    const code = event.queryStringParameters?.code;
+    const clientId = process.env.GITHUB_CLIENT_ID || process.env.VITE_GITHUB_CLIENT_ID;
+    const clientSecret = process.env.GITHUB_CLIENT_SECRET;
+
+    if (!code) {
+      return {
+        statusCode: 400,
+        body: JSON.stringify({ error: 'No code provided' })
+      };
+    }
+
+    if (!clientId || !clientSecret) {
+      return {
+        statusCode: 500,
+        body: JSON.stringify({ error: 'GitHub OAuth not configured properly' })
+      };
+    }
+
+    // Exchange code for access token
+    const tokenResponse = await axios.post(
+      'https://github.com/login/oauth/access_token',
+      {
+        client_id: clientId,
+        client_secret: clientSecret,
+        code,
+      },
+      {
+        headers: {
+          Accept: 'application/json',
+        },
+      }
+    );
+
+    const accessToken = tokenResponse.data.access_token;
+
+    if (!accessToken) {
+      throw new Error('No access token received');
+    }
+
+    // Get user info
+    const userResponse = await axios.get('https://api.github.com/user', {
+      headers: {
+        Authorization: \`token \${accessToken}\`,
+      },
+    });
+
+    const user = userResponse.data;
+
+    // Redirect back to the app with token in URL fragment
+    const protocol = event.headers['x-forwarded-proto'] || 'https';
+    const host = event.headers.host;
+    const baseUrl = \`\${protocol}://\${host}\`;
+    const redirectUrl = \`\${baseUrl}/#/auth-callback?token=\${accessToken}&login=\${user.login}&avatar=\${encodeURIComponent(user.avatar_url)}\`;
+
+    return {
+      statusCode: 302,
+      headers: {
+        Location: redirectUrl
+      },
+      body: ''
+    };
+  } catch (error: any) {
+    return {
+      statusCode: 500,
+      body: JSON.stringify({
+        error: 'Failed to exchange code for token',
+        details: error.message,
+      })
+    };
+  }
+};
+
+export { handler };
+`;
+
+// src/generators/serverless.ts
+async function generateServerless(platform, projectRoot) {
+  if (platform === "vercel") {
+    const apiDir = path2.join(projectRoot, "api");
+    await ensureDir(apiDir);
+    await writeFile(
+      path2.join(apiDir, "github-oauth-login.ts"),
+      vercelAuthLoginTemplate
+    );
+    await writeFile(
+      path2.join(apiDir, "github-oauth-callback.ts"),
+      vercelAuthCallbackTemplate
+    );
+    console.log(chalk4.dim("  \u2192 Created api/github-oauth-login.ts"));
+    console.log(chalk4.dim("  \u2192 Created api/github-oauth-callback.ts"));
+  } else if (platform === "netlify") {
+    const functionsDir = path2.join(projectRoot, "netlify", "functions");
+    await ensureDir(functionsDir);
+    await writeFile(
+      path2.join(functionsDir, "github-oauth-login.ts"),
+      netlifyAuthLoginTemplate
+    );
+    await writeFile(
+      path2.join(functionsDir, "github-oauth-callback.ts"),
+      netlifyAuthCallbackTemplate
+    );
+    console.log(chalk4.dim("  \u2192 Created netlify/functions/github-oauth-login.ts"));
+    console.log(chalk4.dim("  \u2192 Created netlify/functions/github-oauth-callback.ts"));
+  } else {
+    console.log(chalk4.yellow("  Manual platform selected. You must create serverless functions yourself."));
+    console.log(chalk4.dim("  See: https://github.com/apollo/commenting-system/blob/main/docs/manual-setup.md"));
+  }
+}
+
+// src/generators/env.ts
+import path3 from "path";
+import chalk5 from "chalk";
+async function generateEnvFiles(githubConfig, platform, projectRoot) {
+  const envContent = `
+# Apollo Commenting System Configuration
+# Generated by apollo-comments CLI
+
+# GitHub OAuth
+GITHUB_CLIENT_ID=${githubConfig.clientId}
+GITHUB_CLIENT_SECRET=${githubConfig.clientSecret}
+GITHUB_OWNER=${githubConfig.owner}
+GITHUB_REPO=${githubConfig.repo}
+
+# Vite (if using Vite)
+VITE_GITHUB_CLIENT_ID=${githubConfig.clientId}
+VITE_GITHUB_OWNER=${githubConfig.owner}
+VITE_GITHUB_REPO=${githubConfig.repo}
+`;
+  const envLocalPath = path3.join(projectRoot, ".env.local");
+  const envPath = path3.join(projectRoot, ".env");
+  const envLocalExists = await fileExists(envLocalPath);
+  if (envLocalExists) {
+    const existingEnv = await readFile(envLocalPath);
+    if (existingEnv.includes("GITHUB_CLIENT_ID")) {
+      console.log(chalk5.yellow("  .env.local already contains GitHub config. Skipping..."));
+    } else {
+      await appendToFile(envLocalPath, envContent);
+      console.log(chalk5.dim("  \u2192 Updated .env.local"));
+    }
+  } else {
+    await writeFile(envLocalPath, envContent.trim());
+    console.log(chalk5.dim("  \u2192 Created .env.local"));
+  }
+  const envExampleContent = `# Apollo Commenting System Configuration
+
+# GitHub OAuth (get from https://github.com/settings/developers)
+GITHUB_CLIENT_ID=your_client_id_here
+GITHUB_CLIENT_SECRET=your_client_secret_here
+GITHUB_OWNER=your_github_org
+GITHUB_REPO=your_repo_name
+
+# Vite (if using Vite)
+VITE_GITHUB_CLIENT_ID=your_client_id_here
+VITE_GITHUB_OWNER=your_github_org
+VITE_GITHUB_REPO=your_repo_name
+`;
+  await writeFile(path3.join(projectRoot, ".env.example"), envExampleContent);
+  console.log(chalk5.dim("  \u2192 Created .env.example"));
+  const gitignorePath = path3.join(projectRoot, ".gitignore");
+  if (await fileExists(gitignorePath)) {
+    const gitignoreContent = await readFile(gitignorePath);
+    if (!gitignoreContent.includes(".env.local")) {
+      await appendToFile(gitignorePath, "\n# Apollo Commenting System\n.env.local\n");
+      console.log(chalk5.dim("  \u2192 Updated .gitignore"));
+    }
+  }
+}
+
+// src/generators/config.ts
+import path4 from "path";
+import chalk6 from "chalk";
+async function generateConfig(githubConfig, platform, projectRoot) {
+  let redirectUri = "http://localhost:9000/api/github-oauth-callback";
+  if (platform === "netlify") {
+    redirectUri = "https://your-domain.com/.netlify/functions/github-oauth-callback";
+  } else if (platform === "vercel") {
+    redirectUri = "https://your-domain.com/api/github-oauth-callback";
+  }
+  const config = {
+    version: "1.0.0",
+    platform,
+    github: {
+      owner: githubConfig.owner,
+      repo: githubConfig.repo,
+      clientId: githubConfig.clientId
+    },
+    redirectUri,
+    features: {
+      aiSummarization: true,
+      versionTracking: true,
+      gitlabIntegration: false
+    },
+    labels: [
+      { name: "comment", color: "0075ca", description: "User feedback comment" },
+      { name: "prototype-feedback", color: "d93f0b", description: "Prototype feedback" },
+      { name: "needs-review", color: "fbca04", description: "Needs team review" }
+    ]
+  };
+  const configPath = path4.join(projectRoot, "apollo-comments.config.json");
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+  console.log(chalk6.dim("  \u2192 Created apollo-comments.config.json"));
+}
+
+// src/validators/github.ts
+import axios from "axios";
+async function validateGitHubConnection(config) {
+  try {
+    const response = await axios.get("https://api.github.com/rate_limit", {
+      headers: {
+        "Accept": "application/vnd.github.v3+json"
+      },
+      timeout: 5e3
+    });
+    return response.status === 200;
+  } catch (error) {
+    console.error("GitHub connection error:", error);
+    return false;
+  }
+}
+
+// src/validators/repo.ts
+import axios2 from "axios";
+import chalk7 from "chalk";
+async function validateRepoAccess(config) {
+  try {
+    const response = await axios2.get(
+      `https://api.github.com/repos/${config.owner}/${config.repo}`,
+      {
+        headers: {
+          "Accept": "application/vnd.github.v3+json"
+        },
+        timeout: 5e3
+      }
+    );
+    return response.status === 200;
+  } catch (error) {
+    if (error.response?.status === 404) {
+      console.log(chalk7.yellow(`  Repository ${config.owner}/${config.repo} not found or is private`));
+      console.log(chalk7.yellow("  Note: Private repos require authentication at runtime"));
+      return true;
+    }
+    console.error("  Repo access error:", error.message);
+    return false;
+  }
+}
+
+// src/validators/labels.ts
+import chalk8 from "chalk";
+var REQUIRED_LABELS = [
+  { name: "comment", color: "0075ca", description: "User feedback comment" },
+  { name: "prototype-feedback", color: "d93f0b", description: "Prototype feedback" },
+  { name: "needs-review", color: "fbca04", description: "Needs team review" }
+];
+async function ensureLabels(config) {
+  console.log(chalk8.dim("\n  Required labels for GitHub issues:"));
+  REQUIRED_LABELS.forEach((label) => {
+    console.log(chalk8.dim(`    - ${label.name} (#${label.color}): ${label.description}`));
+  });
+  console.log(chalk8.dim("  These will be created automatically at runtime with proper authentication.\n"));
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  printWelcome();
+  const spinner = ora("Detecting project...").start();
+  let project;
+  try {
+    project = await detectProject(process.cwd());
+    spinner.succeed(`Detected: ${project.framework} with ${project.buildTool}`);
+  } catch (error) {
+    spinner.fail(error.message);
+    process.exit(1);
+  }
+  if (!project.isReact) {
+    spinner.fail("This package requires a React project");
+    console.log(chalk9.red("\n\u2717 Apollo Commenting System requires React.\n"));
+    process.exit(1);
+  }
+  if (!project.hasPatternFly) {
+    printWarning("PatternFly not detected. This package is optimized for PatternFly projects.");
+    if (!options.yes) {
+      const { continueAnyway } = await inquirer3.prompt([
+        {
+          type: "confirm",
+          name: "continueAnyway",
+          message: "Continue anyway?",
+          default: false
+        }
+      ]);
+      if (!continueAnyway) {
+        console.log(chalk9.dim("\nSetup cancelled.\n"));
+        process.exit(0);
+      }
+    }
+  }
+  const platform = options.platform || await promptPlatform(project.root);
+  const githubConfig = await promptGitHubConfig(options.yes || false);
+  spinner.start("Validating GitHub connection...");
+  const isValid = await validateGitHubConnection(githubConfig);
+  if (!isValid) {
+    spinner.fail("GitHub connection failed. Please check your internet connection.");
+    process.exit(1);
+  }
+  spinner.succeed("GitHub connection validated");
+  spinner.start("Checking repository access...");
+  const hasAccess = await validateRepoAccess(githubConfig);
+  if (!hasAccess) {
+    spinner.fail("Cannot access repository. Check the owner/repo name.");
+    process.exit(1);
+  }
+  spinner.succeed("Repository access confirmed");
+  spinner.start("Checking issue labels...");
+  await ensureLabels(githubConfig);
+  spinner.succeed("Issue labels documented");
+  spinner.start("Generating serverless functions...");
+  try {
+    await generateServerless(platform, project.root);
+    spinner.succeed("Serverless functions created");
+  } catch (error) {
+    spinner.fail(`Failed to generate serverless functions: ${error.message}`);
+    process.exit(1);
+  }
+  spinner.start("Creating environment files...");
+  try {
+    await generateEnvFiles(githubConfig, platform, project.root);
+    spinner.succeed("Environment files created");
+  } catch (error) {
+    spinner.fail(`Failed to create environment files: ${error.message}`);
+    process.exit(1);
+  }
+  spinner.start("Creating apollo-comments.config.json...");
+  try {
+    await generateConfig(githubConfig, platform, project.root);
+    spinner.succeed("Configuration file created");
+  } catch (error) {
+    spinner.fail(`Failed to create config file: ${error.message}`);
+    process.exit(1);
+  }
+  printSuccess();
+  printSetupInstructions(platform, project);
+  printNextSteps();
+}
+
+// src/commands/validate.ts
+import chalk10 from "chalk";
+import ora2 from "ora";
+import path5 from "path";
+async function validateCommand() {
+  console.log(chalk10.bold.cyan("\n\u{1F50D} Validating Apollo Commenting System Setup\n"));
+  const spinner = ora2("Checking configuration files...").start();
+  const cwd = process.cwd();
+  const configPath = path5.join(cwd, "apollo-comments.config.json");
+  const hasConfig = await fileExists(configPath);
+  if (!hasConfig) {
+    spinner.fail("Configuration file not found");
+    console.log(chalk10.red("\n\u2717 apollo-comments.config.json not found"));
+    console.log(chalk10.dim("  Run: apollo-comments init\n"));
+    process.exit(1);
+  }
+  let config;
+  try {
+    const configContent = await readFile(configPath);
+    config = JSON.parse(configContent);
+    spinner.succeed("Configuration file found");
+  } catch (error) {
+    spinner.fail("Invalid configuration file");
+    console.log(chalk10.red("\n\u2717 Could not parse apollo-comments.config.json\n"));
+    process.exit(1);
+  }
+  spinner.start("Checking environment files...");
+  const envPath = path5.join(cwd, ".env.local");
+  const hasEnv = await fileExists(envPath);
+  if (!hasEnv) {
+    spinner.warn("Environment file not found (.env.local)");
+  } else {
+    spinner.succeed("Environment file found");
+  }
+  spinner.start("Checking serverless functions...");
+  let hasServerless = false;
+  if (config.platform === "vercel") {
+    const apiDir = path5.join(cwd, "api");
+    const loginPath = path5.join(apiDir, "github-oauth-login.ts");
+    const callbackPath = path5.join(apiDir, "github-oauth-callback.ts");
+    hasServerless = await fileExists(loginPath) && await fileExists(callbackPath);
+  } else if (config.platform === "netlify") {
+    const functionsDir = path5.join(cwd, "netlify", "functions");
+    const loginPath = path5.join(functionsDir, "github-oauth-login.ts");
+    const callbackPath = path5.join(functionsDir, "github-oauth-callback.ts");
+    hasServerless = await fileExists(loginPath) && await fileExists(callbackPath);
+  }
+  if (!hasServerless && config.platform !== "manual") {
+    spinner.warn("Serverless functions not found");
+  } else {
+    spinner.succeed("Serverless functions found");
+  }
+  spinner.start("Validating GitHub connection...");
+  const isValid = await validateGitHubConnection(config.github);
+  if (!isValid) {
+    spinner.fail("GitHub connection failed");
+    console.log(chalk10.red("\n\u2717 Could not connect to GitHub API\n"));
+    process.exit(1);
+  }
+  spinner.succeed("GitHub connection validated");
+  spinner.start("Validating repository access...");
+  const hasAccess = await validateRepoAccess(config.github);
+  if (!hasAccess) {
+    spinner.warn("Repository access could not be confirmed");
+  } else {
+    spinner.succeed("Repository access confirmed");
+  }
+  console.log(chalk10.green.bold("\n\u2713 Validation complete!\n"));
+  console.log(chalk10.white("Your Apollo Commenting System setup looks good.\n"));
+}
+
+// src/index.ts
+var program = new Command();
+program.name("apollo-comments").description("Apollo Commenting System CLI - Setup wizard and tooling").version("1.0.0");
+program.command("init").description("Initialize Apollo Commenting System in your project").option("-y, --yes", "Skip prompts and use defaults").option("--platform <platform>", "Target platform (vercel, netlify, manual)").action(async (options) => {
+  try {
+    await initCommand(options);
+  } catch (error) {
+    console.error(chalk11.red("\n\u2717 Error:"), error.message);
+    process.exit(1);
+  }
+});
+program.command("validate").description("Validate your commenting system setup").action(async () => {
+  try {
+    await validateCommand();
+  } catch (error) {
+    console.error(chalk11.red("\n\u2717 Error:"), error.message);
+    process.exit(1);
+  }
+});
+program.command("update").description("Update existing configuration").action(() => {
+  console.log(chalk11.yellow("\n\u26A0\uFE0F  Coming soon: Update configuration\n"));
+  console.log(chalk11.dim("For now, you can manually edit apollo-comments.config.json\n"));
+});
+if (!process.argv.slice(2).length) {
+  program.help();
+}
+program.parse();
+//# sourceMappingURL=index.js.map