@reshotdev/screenshot 0.0.1-beta.0

package/src/commands/setup.js

@@ -0,0 +1,137 @@
+// setup.js - Consolidated command: auth + init + studio launch
+const chalk = require("chalk");
+const oraModule = require("ora");
+const ora = oraModule.default || oraModule;
+
+const {
+  writeSettings,
+  readSettings,
+  configExists,
+  writeConfig,
+  SETTINGS_DIR,
+} = require("../lib/config");
+
+/**
+ * Create a default docsync.config.json for platform mode
+ * @param {Object} settings - Project settings from auth
+ * @returns {Object} The created config
+ */
+function createDefaultConfig(settings) {
+  const defaultConfig = {
+    $schema: "https://reshot.dev/schemas/docsync-config.json",
+    version: "2.0",
+    projectId: settings.projectId,
+    baseUrl: "http://localhost:3000",
+    assetDir: ".reshot/output",
+    viewport: { width: 1280, height: 720 },
+    timeout: 30000,
+    headless: true,
+    scenarios: [],
+  };
+
+  return defaultConfig;
+}
+
+/**
+ * Main setup command - consolidates auth, init, and launches studio
+ * One command to rule them all!
+ * 
+ * @param {Object} options - Command options
+ * @param {boolean} options.noStudio - Skip launching studio after setup
+ * @param {boolean} options.force - Force re-initialization even if already set up
+ */
+async function setupCommand(options = {}) {
+  const { noStudio = false, force = false } = options;
+
+  console.log(chalk.cyan("\n🚀 Reshot Setup\n"));
+  console.log(chalk.gray("Setting up your project in one step...\n"));
+
+  // Step 1: Check current authentication state
+  let existingSettings = null;
+  let isAlreadyAuthed = false;
+
+  try {
+    existingSettings = readSettings();
+    isAlreadyAuthed = !!(
+      existingSettings?.apiKey && existingSettings?.projectId
+    );
+  } catch (e) {
+    // No existing settings - that's fine
+  }
+
+  // Step 2: Handle authentication
+  if (isAlreadyAuthed && !force) {
+    console.log(
+      chalk.green("✔ Already authenticated as:"),
+      chalk.cyan(existingSettings.projectName || existingSettings.projectId)
+    );
+    console.log(
+      chalk.gray(
+        "  Use --force to re-authenticate with a different project.\n"
+      )
+    );
+  } else {
+    // Run browser-based authentication
+    console.log(chalk.gray("Opening browser for authentication...\n"));
+    
+    const authCommand = require("./auth");
+    await authCommand();
+
+    // Re-read settings after auth
+    try {
+      existingSettings = readSettings();
+      isAlreadyAuthed = !!(
+        existingSettings?.apiKey && existingSettings?.projectId
+      );
+    } catch (e) {
+      throw new Error("Authentication failed. Please try again.");
+    }
+
+    if (!isAlreadyAuthed) {
+      throw new Error("Authentication was not completed.");
+    }
+
+    console.log(); // Add spacing after auth
+  }
+
+  // Step 3: Handle initialization (create docsync.config.json if missing)
+  const hasConfig = configExists();
+
+  if (hasConfig && !force) {
+    console.log(chalk.green("✔ Configuration found:"), chalk.cyan("docsync.config.json"));
+  } else if (hasConfig && force) {
+    console.log(chalk.yellow("⚠ Overwriting existing docsync.config.json..."));
+    const newConfig = createDefaultConfig(existingSettings);
+    writeConfig(newConfig);
+    console.log(chalk.green("✔ Configuration updated"));
+  } else {
+    // No config - create it
+    console.log(chalk.gray("Creating docsync.config.json..."));
+    const newConfig = createDefaultConfig(existingSettings);
+    writeConfig(newConfig);
+    console.log(chalk.green("✔ Configuration created:"), chalk.cyan("docsync.config.json"));
+  }
+
+  // Step 4: Success summary
+  console.log(chalk.green("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
+  console.log(chalk.green.bold("✔ Project initialized successfully!"));
+  console.log(chalk.green("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"));
+
+  // Step 5: Launch Studio (unless --no-studio)
+  if (!noStudio) {
+    console.log(chalk.cyan("🎬 Launching Reshot Studio...\n"));
+    
+    // Small delay to let the user read the success message
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    
+    const uiCommand = require("./ui");
+    await uiCommand({ open: true });
+  } else {
+    console.log(chalk.gray("Next steps:"));
+    console.log(chalk.gray("  • Run"), chalk.cyan("reshot studio"), chalk.gray("to open the management UI"));
+    console.log(chalk.gray("  • Run"), chalk.cyan("reshot record"), chalk.gray("to capture your first visual"));
+    console.log(chalk.gray("  • Run"), chalk.cyan("reshot run"), chalk.gray("to execute scenarios\n"));
+  }
+}
+
+module.exports = setupCommand;

package/src/commands/status.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+/**
+ * status - Check DocSync status, sync jobs, and drift queue
+ *
+ * Displays:
+ * - Current project configuration
+ * - Recent sync jobs with status
+ * - Drift queue summary
+ * - Pending actions
+ *
+ * Usage: reshot status [--jobs] [--drifts] [--json]
+ */
+
+const chalk = require("chalk");
+const config = require("../lib/config");
+const apiClient = require("../lib/api-client");
+
+/**
+ * Format timestamp for display
+ */
+function formatTime(dateString) {
+  const date = new Date(dateString);
+  const now = new Date();
+  const diffMs = now - date;
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMs / 3600000);
+  const diffDays = Math.floor(diffMs / 86400000);
+
+  if (diffMins < 1) return "just now";
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return date.toLocaleDateString();
+}
+
+/**
+ * Format job status with color
+ */
+function formatJobStatus(status) {
+  switch (status) {
+    case "COMPLETED":
+      return chalk.green("✓ Completed");
+    case "PROCESSING":
+      return chalk.blue("⟳ Processing");
+    case "QUEUED":
+      return chalk.yellow("◷ Queued");
+    case "FAILED":
+      return chalk.red("✗ Failed");
+    default:
+      return chalk.gray(status);
+  }
+}
+
+/**
+ * Format drift status with color
+ */
+function formatDriftStatus(status) {
+  switch (status) {
+    case "PENDING":
+      return chalk.yellow("● Pending");
+    case "APPROVED":
+      return chalk.green("✓ Approved");
+    case "REJECTED":
+      return chalk.red("✗ Rejected");
+    case "IGNORED":
+      return chalk.gray("○ Ignored");
+    default:
+      return chalk.gray(status);
+  }
+}
+
+/**
+ * Format drift type with color
+ */
+function formatDriftType(type) {
+  switch (type) {
+    case "VISUAL":
+      return chalk.cyan("🖼 Visual");
+    case "SEMANTIC":
+      return chalk.magenta("📝 Text");
+    case "BOTH":
+      return chalk.yellow("⚡ Both");
+    default:
+      return chalk.gray(type);
+  }
+}
+
+/**
+ * Get and display project configuration
+ */
+async function displayConfig(docSyncConfig) {
+  console.log(chalk.bold("\n📋 Project Configuration\n"));
+
+  const docConfig = docSyncConfig.documentation;
+  if (!docConfig) {
+    console.log(chalk.yellow("  No documentation block configured."));
+    console.log(chalk.gray("  Add a 'documentation' block to docsync.config.json"));
+    return;
+  }
+
+  console.log(chalk.gray("  Root:      ") + chalk.white(docConfig.root || "./docs"));
+  console.log(chalk.gray("  Strategy:  ") + chalk.white(docConfig.strategy));
+  console.log(chalk.gray("  Format:    ") + chalk.white(docConfig.assetFormat || "markdown"));
+  
+  if (docConfig.include?.length) {
+    console.log(chalk.gray("  Include:   ") + chalk.white(docConfig.include.join(", ")));
+  }
+  if (docConfig.exclude?.length) {
+    console.log(chalk.gray("  Exclude:   ") + chalk.white(docConfig.exclude.join(", ")));
+  }
+  
+  const mappingCount = Object.keys(docConfig.mappings || {}).length;
+  if (mappingCount > 0) {
+    console.log(chalk.gray("  Mappings:  ") + chalk.white(`${mappingCount} explicit binding(s)`));
+  }
+}
+
+/**
+ * Get and display sync job history
+ */
+async function displayJobs(apiKey, projectId, limit = 5) {
+  console.log(chalk.bold("\n📦 Recent Sync Jobs\n"));
+
+  try {
+    // Fetch jobs via API
+    const response = await apiClient.getSyncJobs(apiKey, projectId, { limit });
+
+    const jobs = response.jobs || response.data?.jobs || [];
+
+    if (jobs.length === 0) {
+      console.log(chalk.gray("  No sync jobs found."));
+      console.log(chalk.gray("  Run `reshot ingest` to upload traces and docs."));
+      return;
+    }
+
+    for (const job of jobs) {
+      console.log(
+        `  ${formatJobStatus(job.status)} ` +
+        chalk.gray(`${job.id.slice(0, 8)} `) +
+        chalk.white(`${job.branch || "unknown"}@${(job.commitHash || "").slice(0, 7)} `) +
+        chalk.gray(formatTime(job.createdAt))
+      );
+      
+      if (job.driftCount > 0) {
+        console.log(chalk.gray(`      └─ ${job.driftCount} drift(s) detected`));
+      }
+      if (job.errorMessage) {
+        console.log(chalk.red(`      └─ Error: ${job.errorMessage}`));
+      }
+    }
+  } catch (error) {
+    console.log(chalk.yellow("  Could not fetch sync jobs: " + error.message));
+    console.log(chalk.gray("  This endpoint may not be available yet."));
+  }
+}
+
+/**
+ * Get and display drift queue
+ */
+async function displayDrifts(apiKey, projectId, limit = 10) {
+  console.log(chalk.bold("\n🔄 Drift Queue\n"));
+
+  try {
+    const response = await apiClient.getDrifts(apiKey, projectId, { status: "PENDING" });
+    const drifts = response.drifts || [];
+    const stats = response.stats || {};
+
+    // Show stats summary
+    if (stats.total > 0) {
+      console.log(
+        chalk.gray("  Summary: ") +
+        chalk.yellow(`${stats.pending || 0} pending`) + ", " +
+        chalk.green(`${stats.approved || 0} approved`) + ", " +
+        chalk.red(`${stats.rejected || 0} rejected`) + ", " +
+        chalk.gray(`${stats.ignored || 0} ignored`)
+      );
+      console.log();
+    }
+
+    if (drifts.length === 0) {
+      console.log(chalk.green("  ✓ No pending drifts!"));
+      console.log(chalk.gray("  Your documentation is in sync with the application."));
+      return;
+    }
+
+    // Show pending drifts
+    const displayed = drifts.slice(0, limit);
+    for (const drift of displayed) {
+      console.log(
+        `  ${formatDriftType(drift.driftType)} ` +
+        chalk.white(drift.journeyKey || drift.docPath) + " " +
+        chalk.gray(`(${Math.round(drift.confidenceScore * 100)}% confidence)`)
+      );
+      
+      if (drift.docPath) {
+        console.log(chalk.gray(`      └─ ${drift.docPath}`));
+      }
+    }
+
+    if (drifts.length > limit) {
+      console.log(chalk.gray(`\n  ... and ${drifts.length - limit} more.`));
+    }
+
+    console.log();
+    console.log(chalk.gray("  View in dashboard: ") + chalk.blue(`https://reshot.dev/app/projects/${projectId}/docsync`));
+  } catch (error) {
+    console.log(chalk.yellow("  Could not fetch drifts: " + error.message));
+  }
+}
+
+/**
+ * Main status command
+ */
+async function statusCommand(options = {}) {
+  console.log(chalk.blue("\n📊 Reshot DocSync Status\n"));
+
+  // Read configuration
+  let docSyncConfig;
+  try {
+    docSyncConfig = config.readDocSyncConfig();
+  } catch (error) {
+    console.error(chalk.red("Error:"), "docsync.config.json not found. Run `reshot init` first.");
+    process.exit(1);
+  }
+
+  // Get API key and project ID
+  const settings = config.readSettings();
+  const apiKey = process.env.RESHOT_API_KEY || settings?.apiKey;
+  const projectId =
+    process.env.RESHOT_PROJECT_ID ||
+    settings?.projectId ||
+    docSyncConfig._metadata?.projectId;
+
+  if (!apiKey) {
+    console.error(chalk.red("Error:"), "API key not found. Set RESHOT_API_KEY or run `reshot auth`.");
+    process.exit(1);
+  }
+
+  if (!projectId) {
+    console.error(chalk.red("Error:"), "Project ID not found. Set RESHOT_PROJECT_ID or run `reshot init`.");
+    process.exit(1);
+  }
+
+  console.log(chalk.gray(`  Project: ${projectId}`));
+
+  // Display configuration
+  if (options.config || (!options.jobs && !options.drifts)) {
+    await displayConfig(docSyncConfig);
+  }
+
+  // Display jobs
+  if (options.jobs || (!options.config && !options.drifts)) {
+    await displayJobs(apiKey, projectId, options.limit || 5);
+  }
+
+  // Display drifts
+  if (options.drifts || (!options.config && !options.jobs)) {
+    await displayDrifts(apiKey, projectId, options.limit || 10);
+  }
+
+  // JSON output mode
+  if (options.json) {
+    const response = await apiClient.getDrifts(apiKey, projectId).catch(() => ({}));
+    console.log(JSON.stringify({
+      projectId,
+      config: docSyncConfig.documentation,
+      drifts: response.drifts || [],
+      stats: response.stats || {},
+    }, null, 2));
+  }
+
+  console.log();
+}
+
+module.exports = statusCommand;