@citeme/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1239 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/login.ts
+import * as p from "@clack/prompts";
+import chalk2 from "chalk";
+
+// src/services/api.ts
+import axios from "axios";
+
+// src/utils/config.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: "citeme",
+  schema: {
+    apiKey: {
+      type: "string"
+    },
+    apiUrl: {
+      type: "string",
+      default: "https://citeme.io"
+    },
+    email: {
+      type: "string"
+    }
+  }
+});
+function getApiKey() {
+  return config.get("apiKey");
+}
+function setApiKey(apiKey) {
+  config.set("apiKey", apiKey);
+}
+function getApiUrl() {
+  return config.get("apiUrl") || "https://citeme.io";
+}
+function getEmail() {
+  return config.get("email");
+}
+function setEmail(email) {
+  config.set("email", email);
+}
+function clearConfig() {
+  config.clear();
+}
+function isAuthenticated() {
+  return !!config.get("apiKey");
+}
+function getConfigPath() {
+  return config.path;
+}
+
+// src/services/api.ts
+var ApiService = class {
+  client;
+  constructor() {
+    this.client = axios.create({
+      baseURL: getApiUrl(),
+      timeout: 3e4,
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "@citeme/cli"
+      }
+    });
+    this.client.interceptors.request.use((config2) => {
+      const apiKey = getApiKey();
+      if (apiKey) {
+        config2.headers.Authorization = `Bearer ${apiKey}`;
+      }
+      return config2;
+    });
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        if (error.response?.status === 401) {
+          throw new ApiError("Authentication failed. Please run `citeme login` first.", 401);
+        }
+        if (error.response?.status === 403) {
+          throw new ApiError("Access denied. Your API key may have expired.", 403);
+        }
+        if (error.response?.status === 429) {
+          throw new ApiError("Rate limit exceeded. Please try again later.", 429);
+        }
+        throw new ApiError(
+          error.response?.data?.message || error.message,
+          error.response?.status
+        );
+      }
+    );
+  }
+  async authenticate(email, password2) {
+    const response = await this.client.post("/api/v1/cli/auth", {
+      email,
+      password: password2
+    });
+    return response.data;
+  }
+  async audit(request) {
+    const response = await this.client.post("/api/v1/cli/audit", request);
+    return response.data;
+  }
+  async getApprovedPatches(auditId) {
+    const params = auditId ? { auditId } : {};
+    const response = await this.client.get("/api/v1/cli/patches", { params });
+    return response.data.patches;
+  }
+  async confirmPatchApplied(patchId) {
+    await this.client.post(`/api/v1/cli/patches/${patchId}/applied`);
+  }
+  async validateApiKey() {
+    try {
+      const response = await this.client.get("/api/v1/cli/validate");
+      return response.data;
+    } catch {
+      return { valid: false };
+    }
+  }
+  async getLatestAudit() {
+    try {
+      const response = await this.client.get("/api/v1/cli/audits/latest");
+      return response.data.audit;
+    } catch {
+      return null;
+    }
+  }
+  async generateSuggestions(request) {
+    const response = await this.client.post(
+      "/api/v1/cli/suggestions/generate",
+      request
+    );
+    return response.data.suggestions;
+  }
+  async listSuggestions(options) {
+    const response = await this.client.get(
+      "/api/v1/cli/suggestions",
+      { params: options }
+    );
+    return response.data.suggestions;
+  }
+  async getSuggestion(suggestionId) {
+    const response = await this.client.get(
+      `/api/v1/cli/suggestions/${suggestionId}`
+    );
+    return response.data;
+  }
+};
+var ApiError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
+  }
+};
+var api = new ApiService();
+
+// src/utils/display.ts
+import chalk from "chalk";
+var PULSE_METER_WIDTH = 50;
+function renderPulseMeter(score, label) {
+  const normalizedScore = Math.max(0, Math.min(100, score));
+  const filledWidth = Math.round(normalizedScore / 100 * PULSE_METER_WIDTH);
+  const emptyWidth = PULSE_METER_WIDTH - filledWidth;
+  const color = getScoreColor(normalizedScore);
+  const filled = color("\u2588".repeat(filledWidth));
+  const empty = chalk.gray("\u2591".repeat(emptyWidth));
+  const lines = [
+    "",
+    chalk.bold("  GEO Score"),
+    `  \u250C${"\u2500".repeat(PULSE_METER_WIDTH + 2)}\u2510`,
+    `  \u2502 ${filled}${empty} \u2502`,
+    `  \u2514${"\u2500".repeat(PULSE_METER_WIDTH + 2)}\u2518`,
+    `  ${color.bold(`${normalizedScore}/100`)}${label ? chalk.gray(` - ${label}`) : ""}`,
+    ""
+  ];
+  return lines.join("\n");
+}
+function getScoreColor(score) {
+  if (score >= 80) return chalk.green;
+  if (score >= 60) return chalk.yellow;
+  if (score >= 40) return chalk.hex("#FFA500");
+  return chalk.red;
+}
+function getScoreLabel(score) {
+  if (score >= 80) return "Excellent";
+  if (score >= 60) return "Good";
+  if (score >= 40) return "Needs Improvement";
+  if (score >= 20) return "Poor";
+  return "Critical";
+}
+function renderBox(title, content, width = 60) {
+  const lines = [];
+  const innerWidth = width - 4;
+  lines.push(`\u256D${"\u2500".repeat(width - 2)}\u256E`);
+  lines.push(`\u2502 ${chalk.bold(title.padEnd(innerWidth))} \u2502`);
+  lines.push(`\u251C${"\u2500".repeat(width - 2)}\u2524`);
+  for (const line of content) {
+    const truncated = line.length > innerWidth ? line.slice(0, innerWidth - 3) + "..." : line;
+    lines.push(`\u2502 ${truncated.padEnd(innerWidth)} \u2502`);
+  }
+  lines.push(`\u2570${"\u2500".repeat(width - 2)}\u256F`);
+  return lines.join("\n");
+}
+function renderError(message) {
+  return chalk.red(`\u2716 ${message}`);
+}
+function renderSuccess(message) {
+  return chalk.green(`\u2714 ${message}`);
+}
+function renderWarning(message) {
+  return chalk.yellow(`\u26A0 ${message}`);
+}
+function renderInfo(message) {
+  return chalk.blue(`\u2139 ${message}`);
+}
+function renderIssuesList(issues) {
+  if (issues.length === 0) {
+    return chalk.green("\n  \u2714 No technical issues found\n");
+  }
+  const grouped = issues.reduce((acc, issue) => {
+    if (!acc[issue.category]) acc[issue.category] = [];
+    acc[issue.category].push(issue);
+    return acc;
+  }, {});
+  const lines = [""];
+  for (const [category, categoryIssues] of Object.entries(grouped)) {
+    lines.push(chalk.bold(`  ${category}`));
+    for (const issue of categoryIssues) {
+      const icon = issue.type === "error" ? chalk.red("\u2716") : issue.type === "warning" ? chalk.yellow("\u26A0") : chalk.blue("\u2139");
+      const location = issue.file ? chalk.gray(` (${issue.file}${issue.line ? `:${issue.line}` : ""})`) : "";
+      lines.push(`    ${icon} ${issue.message}${location}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderHeader() {
+  const logo = `
+  ${chalk.hex("#8B5CF6")("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
+  ${chalk.hex("#8B5CF6")("\u2551")}  ${chalk.bold.hex("#8B5CF6")("CiteMe CLI")} ${chalk.gray("- GEO Optimization Tool")}  ${chalk.hex("#8B5CF6")("\u2551")}
+  ${chalk.hex("#8B5CF6")("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
+  `;
+  return logo;
+}
+
+// src/commands/login.ts
+async function loginCommand() {
+  console.log(renderHeader());
+  if (isAuthenticated()) {
+    const email = getEmail();
+    const shouldContinue = await p.confirm({
+      message: `You are already logged in as ${chalk2.cyan(email)}. Do you want to log in with a different account?`
+    });
+    if (p.isCancel(shouldContinue) || !shouldContinue) {
+      p.outro(chalk2.gray("Login cancelled."));
+      return;
+    }
+    clearConfig();
+  }
+  p.intro(chalk2.hex("#8B5CF6")("Login to CiteMe"));
+  const credentials = await p.group(
+    {
+      email: () => p.text({
+        message: "Enter your email:",
+        placeholder: "you@example.com",
+        validate: (value) => {
+          if (!value) return "Email is required";
+          if (!value.includes("@")) return "Please enter a valid email";
+        }
+      }),
+      password: () => p.password({
+        message: "Enter your password:",
+        validate: (value) => {
+          if (!value) return "Password is required";
+          if (value.length < 6) return "Password must be at least 6 characters";
+        }
+      })
+    },
+    {
+      onCancel: () => {
+        p.cancel("Login cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  const spinner2 = p.spinner();
+  spinner2.start("Authenticating...");
+  try {
+    const response = await api.authenticate(credentials.email, credentials.password);
+    setApiKey(response.apiKey);
+    setEmail(response.email);
+    spinner2.stop(renderSuccess("Authentication successful!"));
+    p.note(
+      [
+        `Logged in as: ${chalk2.cyan(response.email)}`,
+        `Config saved to: ${chalk2.gray(getConfigPath())}`,
+        "",
+        `Run ${chalk2.cyan("citeme audit")} to analyze your project.`
+      ].join("\n"),
+      "Success"
+    );
+    p.outro(chalk2.green("You are now authenticated!"));
+  } catch (error) {
+    spinner2.stop(renderError("Authentication failed"));
+    if (error instanceof ApiError) {
+      if (error.statusCode === 401) {
+        p.log.error("Invalid email or password. Please try again.");
+      } else if (error.statusCode === 404) {
+        p.log.error("No account found with this email. Please sign up at https://citeme.io");
+      } else {
+        p.log.error(error.message);
+      }
+    } else {
+      p.log.error("An unexpected error occurred. Please check your internet connection.");
+    }
+    process.exit(1);
+  }
+}
+async function logoutCommand() {
+  console.log(renderHeader());
+  if (!isAuthenticated()) {
+    p.outro(chalk2.yellow("You are not currently logged in."));
+    return;
+  }
+  const email = getEmail();
+  const confirm3 = await p.confirm({
+    message: `Are you sure you want to log out from ${chalk2.cyan(email)}?`
+  });
+  if (p.isCancel(confirm3) || !confirm3) {
+    p.outro(chalk2.gray("Logout cancelled."));
+    return;
+  }
+  clearConfig();
+  p.outro(chalk2.green("Successfully logged out."));
+}
+async function whoamiCommand() {
+  console.log(renderHeader());
+  if (!isAuthenticated()) {
+    p.log.warn("Not logged in. Run `citeme login` to authenticate.");
+    return;
+  }
+  const spinner2 = p.spinner();
+  spinner2.start("Validating session...");
+  try {
+    const { valid, email } = await api.validateApiKey();
+    if (valid) {
+      spinner2.stop(renderSuccess("Session valid"));
+      p.log.info(`Logged in as: ${chalk2.cyan(email || getEmail())}`);
+      p.log.info(`Config location: ${chalk2.gray(getConfigPath())}`);
+    } else {
+      spinner2.stop(renderError("Session expired"));
+      p.log.warn("Your session has expired. Please run `citeme login` again.");
+    }
+  } catch {
+    spinner2.stop(renderError("Could not validate session"));
+    p.log.error("Failed to connect to CiteMe. Please check your internet connection.");
+  }
+}
+
+// src/commands/audit.ts
+import * as p2 from "@clack/prompts";
+import chalk3 from "chalk";
+import ora from "ora";
+
+// src/services/scanner.ts
+import fg from "fast-glob";
+import { readFile } from "fs/promises";
+import { extname, relative } from "path";
+var CONTENT_EXTENSIONS = [".md", ".mdx"];
+var STRUCTURE_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js"];
+var IGNORED_DIRS = ["node_modules", ".next", "dist", ".git", "coverage", "build", "out"];
+async function scanDirectory(options = {}) {
+  const { cwd = process.cwd(), includeContent = false, maxFiles = 100 } = options;
+  const ignorePatterns = IGNORED_DIRS.map((dir) => `**/${dir}/**`);
+  const contentPattern = `**/*{${CONTENT_EXTENSIONS.join(",")}}`;
+  const structurePattern = `**/*{${STRUCTURE_EXTENSIONS.join(",")}}`;
+  const [contentFiles, structureFiles] = await Promise.all([
+    fg(contentPattern, { cwd, ignore: ignorePatterns, absolute: true }),
+    fg(structurePattern, { cwd, ignore: ignorePatterns, absolute: true })
+  ]);
+  const allFiles = [...contentFiles, ...structureFiles];
+  const limitedFiles = allFiles.slice(0, maxFiles);
+  const skipped = allFiles.length - limitedFiles.length;
+  const filesMetadata = await Promise.all(
+    limitedFiles.map(async (filePath) => {
+      const ext = extname(filePath);
+      const isContent = CONTENT_EXTENSIONS.includes(ext);
+      const relativePath = relative(cwd, filePath);
+      const metadata = {
+        path: relativePath,
+        type: isContent ? "content" : "structure"
+      };
+      if (includeContent || isContent) {
+        const content = await readFile(filePath, "utf-8");
+        metadata.content = content;
+        if (!isContent) {
+          metadata.meta = extractMeta(content);
+        }
+      }
+      return metadata;
+    })
+  );
+  return {
+    files: filesMetadata,
+    contentFiles: contentFiles.length,
+    structureFiles: structureFiles.length,
+    skipped
+  };
+}
+function extractMeta(content) {
+  const meta = {};
+  const titleMatch = content.match(/<title[^>]*>([^<]+)<\/title>/i) || content.match(/title:\s*["']([^"']+)["']/);
+  if (titleMatch) {
+    meta.title = titleMatch[1];
+  }
+  const descMatch = content.match(/<meta[^>]*name=["']description["'][^>]*content=["']([^"']+)["']/i) || content.match(/<meta[^>]*content=["']([^"']+)["'][^>]*name=["']description["']/i) || content.match(/description:\s*["']([^"']+)["']/);
+  if (descMatch) {
+    meta.description = descMatch[1];
+  }
+  const h1Matches = content.match(/<h1[^>]*>([^<]+)<\/h1>/gi);
+  if (h1Matches) {
+    meta.h1 = h1Matches.map((h1) => {
+      const innerMatch = h1.match(/>([^<]+)</);
+      return innerMatch ? innerMatch[1] : "";
+    }).filter(Boolean);
+  }
+  meta.hasJsonLd = /<script[^>]*type=["']application\/ld\+json["'][^>]*>/i.test(content);
+  const imgMatches = content.match(/<img[^>]+>/gi) || [];
+  meta.imagesWithoutAlt = imgMatches.filter(
+    (img) => !img.includes("alt=") || img.includes('alt=""') || img.includes("alt=''")
+  ).length;
+  return meta;
+}
+
+// src/commands/audit.ts
+async function auditCommand(options) {
+  if (!options.json) {
+    console.log(renderHeader());
+  }
+  if (!isAuthenticated()) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Not authenticated" }));
+      process.exit(1);
+    }
+    p2.log.error("You must be logged in to run an audit.");
+    p2.log.info(`Run ${chalk3.cyan("citeme login")} first.`);
+    process.exit(1);
+  }
+  if (!options.json) {
+    p2.intro(chalk3.hex("#8B5CF6")("GEO Audit"));
+  }
+  const scanSpinner = ora({
+    text: "Scanning project files...",
+    color: "magenta"
+  }).start();
+  let scanResult;
+  try {
+    scanResult = await scanDirectory({
+      includeContent: true,
+      maxFiles: 100
+    });
+    scanSpinner.succeed(
+      `Found ${chalk3.cyan(scanResult.contentFiles)} content files and ${chalk3.cyan(scanResult.structureFiles)} structure files`
+    );
+    if (scanResult.skipped > 0) {
+      console.log(renderWarning(`Skipped ${scanResult.skipped} files (limit: 100)`));
+    }
+  } catch (error) {
+    scanSpinner.fail("Failed to scan project");
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Scan failed" }));
+    }
+    process.exit(1);
+  }
+  if (scanResult.files.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "No files found" }));
+      process.exit(1);
+    }
+    p2.log.warn("No content or structure files found in this directory.");
+    p2.log.info("Make sure you are in a project with .md, .mdx, .tsx, or .jsx files.");
+    process.exit(1);
+  }
+  const auditSpinner = ora({
+    text: "Analyzing with CiteMe AI...",
+    color: "magenta"
+  }).start();
+  try {
+    const result = await api.audit({
+      files: scanResult.files,
+      projectUrl: options.url
+    });
+    auditSpinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log("\n");
+    console.log(renderPulseMeter(result.score, getScoreLabel(result.score)));
+    const technicalScoreColor = getScoreColor(result.technicalScore);
+    console.log(
+      chalk3.gray("  Technical Score: ") + technicalScoreColor.bold(`${result.technicalScore}/100`)
+    );
+    console.log("");
+    if (result.issues.length > 0) {
+      const issueBox = renderBox(
+        `Technical Issues (${result.issues.length})`,
+        result.issues.slice(0, 10).map((issue) => {
+          const icon = issue.type === "error" ? "\u2716" : issue.type === "warning" ? "\u26A0" : "\u2139";
+          const color = issue.type === "error" ? chalk3.red : issue.type === "warning" ? chalk3.yellow : chalk3.blue;
+          return `${color(icon)} ${issue.message}`;
+        })
+      );
+      console.log(issueBox);
+      if (result.issues.length > 10) {
+        console.log(chalk3.gray(`  ... and ${result.issues.length - 10} more issues
+`));
+      }
+    } else {
+      console.log(renderSuccess("No critical technical issues found!"));
+      console.log("");
+    }
+    if (result.suggestions.length > 0) {
+      console.log(
+        chalk3.bold(`  ${chalk3.hex("#8B5CF6")(result.suggestions.length)} technical suggestions available`)
+      );
+      console.log(chalk3.gray(`  Run ${chalk3.cyan("citeme apply")} to review and apply them.
+`));
+    }
+    p2.note(
+      [
+        `Audit ID: ${chalk3.gray(result.auditId)}`,
+        `Files analyzed: ${chalk3.cyan(scanResult.files.length)}`,
+        `Issues found: ${result.issues.length > 0 ? chalk3.yellow(result.issues.length) : chalk3.green("0")}`,
+        `Suggestions: ${chalk3.hex("#8B5CF6")(result.suggestions.length)}`
+      ].join("\n"),
+      "Summary"
+    );
+    if (options.verbose) {
+      console.log("\n" + chalk3.bold.underline("Detailed Issues:\n"));
+      console.log(renderIssuesList(result.issues));
+    }
+    p2.outro(
+      result.score >= 60 ? chalk3.green("Audit complete!") : chalk3.yellow("Audit complete. Consider applying suggestions to improve your score.")
+    );
+  } catch (error) {
+    auditSpinner.fail("Audit failed");
+    if (error instanceof ApiError) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: error.message }));
+      } else {
+        p2.log.error(error.message);
+      }
+    } else {
+      if (options.json) {
+        console.log(JSON.stringify({ error: "Unknown error" }));
+      } else {
+        p2.log.error("An unexpected error occurred during the audit.");
+      }
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/apply.ts
+import * as p3 from "@clack/prompts";
+import chalk5 from "chalk";
+import ora2 from "ora";
+
+// src/services/patcher.ts
+import { readFile as readFile2, writeFile, copyFile, unlink, access } from "fs/promises";
+import { constants } from "fs";
+import { resolve } from "path";
+import { createPatch, structuredPatch } from "diff";
+import chalk4 from "chalk";
+async function fileExists(filePath) {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createBackup(filePath) {
+  const absolutePath = resolve(process.cwd(), filePath);
+  const backupPath = `${absolutePath}.bak`;
+  let finalBackupPath = backupPath;
+  if (await fileExists(backupPath)) {
+    finalBackupPath = `${absolutePath}.${Date.now()}.bak`;
+  }
+  await copyFile(absolutePath, finalBackupPath);
+  return finalBackupPath;
+}
+async function restoreBackup(backupPath, originalPath) {
+  await copyFile(backupPath, originalPath);
+  await unlink(backupPath);
+}
+async function removeBackup(backupPath) {
+  try {
+    await unlink(backupPath);
+  } catch {
+  }
+}
+async function applyPatch(filePath, original, patched) {
+  const absolutePath = resolve(process.cwd(), filePath);
+  try {
+    if (!await fileExists(absolutePath)) {
+      return {
+        success: false,
+        error: `File not found: ${filePath}`
+      };
+    }
+    const currentContent = await readFile2(absolutePath, "utf-8");
+    const normalizedCurrent = normalizeWhitespace(currentContent);
+    const normalizedOriginal = normalizeWhitespace(original);
+    if (!normalizedCurrent.includes(normalizedOriginal)) {
+      return {
+        success: false,
+        error: "File content has changed since the patch was generated. Please run a new audit."
+      };
+    }
+    const backupPath = await createBackup(absolutePath);
+    try {
+      const newContent = currentContent.replace(original, patched);
+      await writeFile(absolutePath, newContent, "utf-8");
+      return {
+        success: true,
+        backupPath
+      };
+    } catch (writeError) {
+      await restoreBackup(backupPath, absolutePath);
+      return {
+        success: false,
+        error: `Failed to write file: ${writeError.message}`
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: `Error applying patch: ${error.message}`
+    };
+  }
+}
+function normalizeWhitespace(str) {
+  return str.replace(/\s+/g, " ").trim();
+}
+function generateDiff(original, patched, filePath) {
+  const patch = structuredPatch(filePath, filePath, original, patched, "", "");
+  const lines = [];
+  lines.push(chalk4.bold(`--- ${filePath}`));
+  lines.push(chalk4.bold(`+++ ${filePath}`));
+  for (const hunk of patch.hunks) {
+    lines.push(chalk4.cyan(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`));
+    for (const line of hunk.lines) {
+      if (line.startsWith("+")) {
+        lines.push(chalk4.green(line));
+      } else if (line.startsWith("-")) {
+        lines.push(chalk4.red(line));
+      } else {
+        lines.push(chalk4.gray(line));
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function getDiffStats(original, patched) {
+  const patch = structuredPatch("file", "file", original, patched, "", "");
+  let additions = 0;
+  let deletions = 0;
+  for (const hunk of patch.hunks) {
+    for (const line of hunk.lines) {
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        additions++;
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        deletions++;
+      }
+    }
+  }
+  return { additions, deletions };
+}
+function formatDiffStats(additions, deletions) {
+  const add = additions > 0 ? chalk4.green(`+${additions}`) : chalk4.gray("+0");
+  const del = deletions > 0 ? chalk4.red(`-${deletions}`) : chalk4.gray("-0");
+  return `${add} ${del}`;
+}
+async function previewPatch(filePath, original, patched) {
+  const header = [
+    "",
+    chalk4.bold.underline(`File: ${filePath}`),
+    ""
+  ].join("\n");
+  const diff = generateDiff(original, patched, filePath);
+  const stats = getDiffStats(original, patched);
+  const statsLine = `
+${formatDiffStats(stats.additions, stats.deletions)} changes
+`;
+  return header + diff + statsLine;
+}
+
+// src/commands/apply.ts
+async function applyCommand(options) {
+  console.log(renderHeader());
+  if (!isAuthenticated()) {
+    p3.log.error("You must be logged in to apply patches.");
+    p3.log.info(`Run ${chalk5.cyan("citeme login")} first.`);
+    process.exit(1);
+  }
+  p3.intro(chalk5.hex("#8B5CF6")("Apply Technical Suggestions"));
+  const fetchSpinner = ora2({
+    text: "Fetching approved technical patches...",
+    color: "magenta"
+  }).start();
+  let patches;
+  try {
+    patches = await api.getApprovedPatches(options.auditId);
+    fetchSpinner.stop();
+    if (patches.length === 0) {
+      console.log(renderInfo("No technical patches available to apply."));
+      p3.log.info("Run `citeme audit` first to generate suggestions.");
+      p3.outro(chalk5.gray("Nothing to apply."));
+      return;
+    }
+    console.log(renderSuccess(`Found ${patches.length} technical patches`));
+  } catch (error) {
+    fetchSpinner.fail("Failed to fetch patches");
+    if (error instanceof ApiError) {
+      p3.log.error(error.message);
+    } else {
+      p3.log.error("An unexpected error occurred.");
+    }
+    process.exit(1);
+  }
+  if (options.dryRun) {
+    console.log(renderWarning("Dry run mode - no changes will be made\n"));
+    for (const patch of patches) {
+      const preview = await previewPatch(patch.file, patch.original, patch.patched);
+      console.log(preview);
+      console.log(chalk5.gray(`Description: ${patch.description}`));
+      console.log("");
+    }
+    p3.outro(chalk5.green(`Dry run complete. ${patches.length} patches would be applied.`));
+    return;
+  }
+  if (options.all) {
+    const result2 = await applyAllPatches(patches);
+    displayResults(result2);
+    return;
+  }
+  const result = await interactiveApply(patches);
+  displayResults(result);
+}
+async function interactiveApply(patches) {
+  const result = {
+    applied: 0,
+    skipped: 0,
+    failed: 0,
+    backups: /* @__PURE__ */ new Map()
+  };
+  for (let i = 0; i < patches.length; i++) {
+    const patch = patches[i];
+    const stats = getDiffStats(patch.original, patch.patched);
+    console.log("\n" + chalk5.bold(`[${i + 1}/${patches.length}] ${patch.file}`));
+    console.log(chalk5.gray(patch.description));
+    console.log(formatDiffStats(stats.additions, stats.deletions));
+    const action = await p3.select({
+      message: "What would you like to do?",
+      options: [
+        { value: "apply", label: "Apply this change", hint: "y" },
+        { value: "skip", label: "Skip this change", hint: "n" },
+        { value: "diff", label: "Show full diff", hint: "d" },
+        { value: "quit", label: "Quit and rollback all changes", hint: "q" }
+      ]
+    });
+    if (p3.isCancel(action) || action === "quit") {
+      console.log(renderWarning("Aborting..."));
+      if (result.backups.size > 0) {
+        console.log(chalk5.yellow("Rolling back applied changes..."));
+        for (const [file, backupPath] of result.backups) {
+          await restoreBackup(backupPath, file);
+          console.log(chalk5.gray(`  Restored: ${file}`));
+        }
+        result.applied = 0;
+      }
+      break;
+    }
+    if (action === "diff") {
+      const preview = await previewPatch(patch.file, patch.original, patch.patched);
+      console.log(preview);
+      const confirmAfterDiff = await p3.confirm({
+        message: "Apply this change?"
+      });
+      if (p3.isCancel(confirmAfterDiff) || !confirmAfterDiff) {
+        result.skipped++;
+        console.log(chalk5.gray("Skipped"));
+        continue;
+      }
+    } else if (action === "skip") {
+      result.skipped++;
+      console.log(chalk5.gray("Skipped"));
+      continue;
+    }
+    const applySpinner = ora2({
+      text: "Applying patch...",
+      color: "magenta"
+    }).start();
+    const patchResult = await applyPatch(patch.file, patch.original, patch.patched);
+    if (patchResult.success) {
+      applySpinner.succeed(chalk5.green("Applied"));
+      result.applied++;
+      if (patchResult.backupPath) {
+        result.backups.set(patch.file, patchResult.backupPath);
+      }
+      try {
+        await api.confirmPatchApplied(patch.id);
+      } catch {
+      }
+    } else {
+      applySpinner.fail(chalk5.red("Failed"));
+      console.log(renderError(patchResult.error || "Unknown error"));
+      result.failed++;
+    }
+  }
+  if (result.applied > 0 && result.failed === 0) {
+    const cleanup = await p3.confirm({
+      message: `Remove ${result.backups.size} backup files?`,
+      initialValue: true
+    });
+    if (cleanup && !p3.isCancel(cleanup)) {
+      for (const backupPath of result.backups.values()) {
+        await removeBackup(backupPath);
+      }
+      console.log(chalk5.gray("Backup files removed."));
+    } else {
+      console.log(chalk5.gray("Backup files kept. They will be named *.bak"));
+    }
+  }
+  return result;
+}
+async function applyAllPatches(patches) {
+  const result = {
+    applied: 0,
+    skipped: 0,
+    failed: 0,
+    backups: /* @__PURE__ */ new Map()
+  };
+  console.log(renderWarning("Applying all patches without confirmation...\n"));
+  for (const patch of patches) {
+    const spinner2 = ora2({
+      text: `Applying: ${patch.file}`,
+      color: "magenta"
+    }).start();
+    const patchResult = await applyPatch(patch.file, patch.original, patch.patched);
+    if (patchResult.success) {
+      spinner2.succeed(chalk5.green(patch.file));
+      result.applied++;
+      if (patchResult.backupPath) {
+        result.backups.set(patch.file, patchResult.backupPath);
+      }
+      try {
+        await api.confirmPatchApplied(patch.id);
+      } catch {
+      }
+    } else {
+      spinner2.fail(chalk5.red(`${patch.file}: ${patchResult.error}`));
+      result.failed++;
+    }
+  }
+  return result;
+}
+function displayResults(result) {
+  console.log("\n");
+  const lines = [
+    `${chalk5.green("Applied")}: ${result.applied}`,
+    `${chalk5.gray("Skipped")}: ${result.skipped}`,
+    `${chalk5.red("Failed")}: ${result.failed}`
+  ];
+  if (result.backups.size > 0) {
+    lines.push("");
+    lines.push(`Backup files: ${result.backups.size}`);
+  }
+  p3.note(lines.join("\n"), "Results");
+  if (result.failed > 0) {
+    p3.outro(chalk5.yellow("Some patches failed to apply. Check the errors above."));
+  } else if (result.applied > 0) {
+    p3.outro(chalk5.green("All patches applied successfully!"));
+  } else {
+    p3.outro(chalk5.gray("No patches were applied."));
+  }
+}
+
+// src/commands/suggestions.ts
+import * as p4 from "@clack/prompts";
+import chalk6 from "chalk";
+import ora3 from "ora";
+async function suggestionsCommand() {
+  console.log(renderHeader());
+  console.log(`
+  ${chalk6.bold("Suggestions Commands:")}
+
+    ${chalk6.cyan("citeme suggestions generate")}   Generate new suggestions from audit
+    ${chalk6.cyan("citeme suggestions list")}       List all suggestions
+    ${chalk6.cyan("citeme suggestions view <id>")}  View a specific suggestion
+
+  Run ${chalk6.gray("citeme suggestions <command> --help")} for more info.
+  `);
+}
+async function generateSuggestionsCommand(options) {
+  console.log(renderHeader());
+  if (!isAuthenticated()) {
+    p4.log.error("You must be logged in to generate suggestions.");
+    p4.log.info(`Run ${chalk6.cyan("citeme login")} first.`);
+    process.exit(1);
+  }
+  p4.intro(chalk6.hex("#8B5CF6")("Generate Suggestions"));
+  let auditId = options.auditId;
+  if (!auditId) {
+    const spinner2 = ora3({
+      text: "Fetching latest audit...",
+      color: "magenta"
+    }).start();
+    try {
+      const latestAudit = await api.getLatestAudit();
+      if (!latestAudit) {
+        spinner2.fail("No audit found");
+        p4.log.warn("No audit found. Run `citeme audit` first.");
+        process.exit(1);
+      }
+      auditId = latestAudit.id;
+      spinner2.succeed(`Using audit ${chalk6.gray(auditId.slice(0, 8))}... (score: ${latestAudit.score})`);
+    } catch (error) {
+      spinner2.fail("Failed to fetch audit");
+      if (error instanceof ApiError) {
+        p4.log.error(error.message);
+      }
+      process.exit(1);
+    }
+  }
+  const types = options.types ? options.types.split(",").map((t) => t.trim().toUpperCase()) : ["LINKEDIN_POST", "BLOG_ARTICLE", "WEBSITE_OPTIMIZATION"];
+  const count = options.count || 3;
+  const generateSpinner = ora3({
+    text: "Generating suggestions with AI...",
+    color: "magenta"
+  }).start();
+  try {
+    const suggestions2 = await api.generateSuggestions({
+      auditId,
+      types,
+      count
+    });
+    generateSpinner.succeed(`Generated ${chalk6.cyan(suggestions2.length)} suggestions`);
+    console.log("");
+    for (const suggestion of suggestions2) {
+      const typeColor = getTypeColor(suggestion.type);
+      const statusIcon = getStatusIcon(suggestion.status);
+      console.log(
+        `  ${statusIcon} ${typeColor(suggestion.type.padEnd(20))} ${chalk6.bold(suggestion.title.slice(0, 50))}${suggestion.title.length > 50 ? "..." : ""}`
+      );
+    }
+    console.log("");
+    p4.note(
+      [
+        `Total generated: ${chalk6.cyan(suggestions2.length)}`,
+        "",
+        `View details: ${chalk6.gray("citeme suggestions view <id>")}`,
+        `List all: ${chalk6.gray("citeme suggestions list")}`
+      ].join("\n"),
+      "Summary"
+    );
+    p4.outro(chalk6.green("Suggestions generated successfully!"));
+  } catch (error) {
+    generateSpinner.fail("Failed to generate suggestions");
+    if (error instanceof ApiError) {
+      p4.log.error(error.message);
+    } else {
+      p4.log.error("An unexpected error occurred.");
+    }
+    process.exit(1);
+  }
+}
+async function listSuggestionsCommand(options) {
+  if (!options.json) {
+    console.log(renderHeader());
+  }
+  if (!isAuthenticated()) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Not authenticated" }));
+      process.exit(1);
+    }
+    p4.log.error("You must be logged in to list suggestions.");
+    p4.log.info(`Run ${chalk6.cyan("citeme login")} first.`);
+    process.exit(1);
+  }
+  if (!options.json) {
+    p4.intro(chalk6.hex("#8B5CF6")("Suggestions"));
+  }
+  const spinner2 = ora3({
+    text: "Fetching suggestions...",
+    color: "magenta"
+  }).start();
+  try {
+    const suggestions2 = await api.listSuggestions({
+      status: options.status,
+      type: options.type,
+      limit: options.limit || 20
+    });
+    spinner2.stop();
+    if (options.json) {
+      console.log(JSON.stringify(suggestions2, null, 2));
+      return;
+    }
+    if (suggestions2.length === 0) {
+      console.log(renderWarning("No suggestions found."));
+      p4.log.info("Run `citeme suggestions generate` to create new suggestions.");
+      return;
+    }
+    console.log("");
+    const grouped = suggestions2.reduce((acc, s) => {
+      if (!acc[s.type]) acc[s.type] = [];
+      acc[s.type].push(s);
+      return acc;
+    }, {});
+    for (const [type, typeSuggestions] of Object.entries(grouped)) {
+      const typeColor = getTypeColor(type);
+      console.log(chalk6.bold(`  ${typeColor(type)} (${typeSuggestions.length})`));
+      console.log("");
+      for (const suggestion of typeSuggestions) {
+        const statusIcon = getStatusIcon(suggestion.status);
+        const id = chalk6.gray(`[${suggestion.id.slice(0, 8)}]`);
+        console.log(`    ${statusIcon} ${id} ${suggestion.title.slice(0, 60)}${suggestion.title.length > 60 ? "..." : ""}`);
+        if (suggestion.reasoning) {
+          console.log(chalk6.gray(`       ${suggestion.reasoning.slice(0, 70)}...`));
+        }
+      }
+      console.log("");
+    }
+    const stats = {
+      total: suggestions2.length,
+      pending: suggestions2.filter((s) => s.status === "PENDING").length,
+      approved: suggestions2.filter((s) => s.status === "APPROVED").length,
+      published: suggestions2.filter((s) => s.status === "PUBLISHED").length
+    };
+    p4.note(
+      [
+        `Total: ${chalk6.cyan(stats.total)}`,
+        `Pending: ${chalk6.yellow(stats.pending)}`,
+        `Approved: ${chalk6.blue(stats.approved)}`,
+        `Published: ${chalk6.green(stats.published)}`
+      ].join("  |  "),
+      "Statistics"
+    );
+    p4.outro(chalk6.gray("Use `citeme suggestions view <id>` to see full content."));
+  } catch (error) {
+    spinner2.fail("Failed to fetch suggestions");
+    if (error instanceof ApiError) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: error.message }));
+      } else {
+        p4.log.error(error.message);
+      }
+    }
+    process.exit(1);
+  }
+}
+async function viewSuggestionCommand(suggestionId) {
+  console.log(renderHeader());
+  if (!isAuthenticated()) {
+    p4.log.error("You must be logged in to view suggestions.");
+    p4.log.info(`Run ${chalk6.cyan("citeme login")} first.`);
+    process.exit(1);
+  }
+  if (!suggestionId) {
+    p4.log.error("Suggestion ID is required.");
+    p4.log.info("Usage: citeme suggestions view <id>");
+    process.exit(1);
+  }
+  const spinner2 = ora3({
+    text: "Fetching suggestion...",
+    color: "magenta"
+  }).start();
+  try {
+    const suggestion = await api.getSuggestion(suggestionId);
+    spinner2.stop();
+    const typeColor = getTypeColor(suggestion.type);
+    const statusIcon = getStatusIcon(suggestion.status);
+    console.log("");
+    console.log(chalk6.bold.underline(`  ${suggestion.title}`));
+    console.log("");
+    console.log(`  ${typeColor(suggestion.type)}  ${statusIcon} ${suggestion.status}`);
+    console.log(chalk6.gray(`  ID: ${suggestion.id}`));
+    console.log("");
+    console.log(chalk6.bold("  Content:"));
+    console.log(chalk6.gray("  " + "\u2500".repeat(60)));
+    const contentLines = suggestion.content.split("\n");
+    for (const line of contentLines) {
+      console.log(`  ${line}`);
+    }
+    console.log(chalk6.gray("  " + "\u2500".repeat(60)));
+    console.log("");
+    if (suggestion.reasoning) {
+      console.log(chalk6.bold("  Why this suggestion:"));
+      console.log(chalk6.italic.gray(`  ${suggestion.reasoning}`));
+      console.log("");
+    }
+    p4.note(
+      [
+        `Copy to clipboard: ${chalk6.gray("citeme suggestions copy " + suggestionId.slice(0, 8))}`,
+        `Approve: ${chalk6.gray("citeme suggestions approve " + suggestionId.slice(0, 8))}`
+      ].join("\n"),
+      "Actions"
+    );
+  } catch (error) {
+    spinner2.fail("Failed to fetch suggestion");
+    if (error instanceof ApiError) {
+      if (error.statusCode === 404) {
+        p4.log.error("Suggestion not found. Check the ID and try again.");
+      } else {
+        p4.log.error(error.message);
+      }
+    }
+    process.exit(1);
+  }
+}
+function getTypeColor(type) {
+  switch (type) {
+    case "LINKEDIN_POST":
+      return chalk6.hex("#0A66C2");
+    // LinkedIn blue
+    case "BLOG_ARTICLE":
+      return chalk6.hex("#FF6B6B");
+    // Red
+    case "TWEET":
+    case "TWITTER_POST":
+      return chalk6.hex("#1DA1F2");
+    // Twitter blue
+    case "WEBSITE_OPTIMIZATION":
+    case "TECHNICAL":
+      return chalk6.hex("#8B5CF6");
+    // Violet
+    default:
+      return chalk6.gray;
+  }
+}
+function getStatusIcon(status) {
+  switch (status) {
+    case "PENDING":
+      return chalk6.yellow("\u25CB");
+    case "APPROVED":
+      return chalk6.blue("\u25C9");
+    case "PUBLISHED":
+      return chalk6.green("\u2714");
+    case "REJECTED":
+      return chalk6.red("\u2716");
+    case "EDITED":
+      return chalk6.cyan("\u270E");
+    default:
+      return chalk6.gray("\u25CB");
+  }
+}
+
+// src/index.ts
+import chalk7 from "chalk";
+var program = new Command();
+program.name("citeme").description("CiteMe CLI - Audit your GEO score and apply optimizations").version("0.1.0", "-v, --version", "Display CLI version").helpOption("-h, --help", "Display help for command");
+program.command("login").description("Authenticate with your CiteMe account").action(loginCommand);
+program.command("logout").description("Log out and remove stored credentials").action(logoutCommand);
+program.command("whoami").description("Display current user information").action(whoamiCommand);
+program.command("audit").description("Analyze your project for GEO optimization opportunities").option("-u, --url <url>", "Project URL for enhanced analysis").option("-v, --verbose", "Show detailed output").option("--json", "Output results as JSON").action((options) => auditCommand(options));
+program.command("apply").description("Apply approved technical suggestions to your code").option("-a, --audit-id <id>", "Apply patches from a specific audit").option("--all", "Apply all patches without confirmation").option("--dry-run", "Preview changes without applying them").action((options) => applyCommand(options));
+var suggestions = program.command("suggestions").description("Manage content suggestions").action(suggestionsCommand);
+suggestions.command("generate").description("Generate new suggestions based on audit results").option("-a, --audit-id <id>", "Use a specific audit").option("-t, --types <types>", "Suggestion types (comma-separated): LINKEDIN_POST,BLOG_ARTICLE,WEBSITE_OPTIMIZATION").option("-c, --count <number>", "Number of suggestions per type", "3").action((options) => generateSuggestionsCommand({
+  ...options,
+  count: parseInt(options.count, 10)
+}));
+suggestions.command("list").description("List all suggestions").option("-s, --status <status>", "Filter by status: PENDING,APPROVED,PUBLISHED,REJECTED").option("-t, --type <type>", "Filter by type: LINKEDIN_POST,BLOG_ARTICLE,WEBSITE_OPTIMIZATION").option("-l, --limit <number>", "Maximum number of suggestions", "20").option("--json", "Output as JSON").action((options) => listSuggestionsCommand({
+  ...options,
+  limit: parseInt(options.limit, 10)
+}));
+suggestions.command("view <id>").description("View a specific suggestion").action((id) => viewSuggestionCommand(id));
+program.command("status").description("Show CLI status and configuration").action(() => {
+  console.log("\n" + chalk7.bold("CiteMe CLI Status") + "\n");
+  if (isAuthenticated()) {
+    console.log(chalk7.green("\u2714") + " Authenticated as: " + chalk7.cyan(getEmail()));
+  } else {
+    console.log(chalk7.yellow("\u25CB") + " Not authenticated");
+  }
+  console.log(chalk7.gray("  Config: ") + getConfigPath());
+  console.log("");
+});
+program.command("config").description("Show configuration file path").action(() => {
+  console.log(getConfigPath());
+});
+program.command("help [command]").description("Display help for a command").action((command) => {
+  if (command) {
+    const cmd = program.commands.find((c) => c.name() === command);
+    if (cmd) {
+      cmd.outputHelp();
+    } else {
+      console.error(chalk7.red(`Unknown command: ${command}`));
+      console.log(`Run ${chalk7.cyan("citeme help")} for available commands.`);
+    }
+  } else {
+    program.outputHelp();
+  }
+});
+program.command("version").description("Display CLI version").action(() => {
+  console.log(`${chalk7.hex("#8B5CF6").bold("CiteMe CLI")} v${program.version()}`);
+});
+program.on("command:*", () => {
+  console.error(chalk7.red(`Unknown command: ${program.args.join(" ")}`));
+  console.log(`Run ${chalk7.cyan("citeme --help")} for usage information.`);
+  process.exit(1);
+});
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+  console.log(`
+  ${chalk7.hex("#8B5CF6").bold("CiteMe CLI")} - GEO Optimization Tool
+
+  ${chalk7.bold("Quick Start:")}
+    ${chalk7.cyan("citeme login")}                  Authenticate with your account
+    ${chalk7.cyan("citeme audit")}                  Analyze your project
+    ${chalk7.cyan("citeme suggestions generate")}   Generate content suggestions
+    ${chalk7.cyan("citeme apply")}                  Apply technical suggestions
+
+  ${chalk7.bold("Commands:")}
+    login                   Log in to your CiteMe account
+    logout                  Log out and clear credentials
+    whoami                  Show current user
+    audit                   Run GEO audit on current directory
+    suggestions generate    Generate suggestions from audit
+    suggestions list        List all suggestions
+    suggestions view <id>   View suggestion details
+    apply                   Apply approved technical patches
+    status                  Show CLI status
+    config                  Show config file path
+
+  ${chalk7.gray("Run `citeme <command> --help` for more information.")}
+  `);
+}