@veestack-tools/cli 3.0.2 → 3.0.4

package/dist/index.js

@@ -0,0 +1,563 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/scan.ts
+import { glob } from "glob";
+import { readFileSync as readFileSync2, statSync } from "fs";
+import { join as join2, resolve } from "path";
+import crypto from "crypto";
+import ora from "ora";
+import chalk2 from "chalk";
+
+// src/utils/auth.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import chalk from "chalk";
+var CONFIG_DIR = join(homedir(), ".veestack");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function getAuthConfig() {
+  try {
+    if (!existsSync(CONFIG_FILE)) {
+      return null;
+    }
+    const config = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    return config;
+  } catch {
+    return null;
+  }
+}
+function isAuthenticated() {
+  const config = getAuthConfig();
+  return config !== null && config.apiKey !== void 0 && config.apiKey.length > 0;
+}
+function getSubscriptionTier() {
+  const config = getAuthConfig();
+  if (!config || !config.subscription) {
+    return "free";
+  }
+  return config.subscription.tier;
+}
+function isSubscriptionActive() {
+  const config = getAuthConfig();
+  if (!config || !config.subscription) {
+    return true;
+  }
+  if (config.subscription.tier === "free") {
+    return true;
+  }
+  if (config.subscription.expiresAt) {
+    const expiresAt = new Date(config.subscription.expiresAt);
+    const now = /* @__PURE__ */ new Date();
+    return expiresAt > now && config.subscription.isActive;
+  }
+  return config.subscription.isActive;
+}
+function requireAuth() {
+  const config = getAuthConfig();
+  if (!config || !config.apiKey) {
+    console.log(chalk.red("\u274C Authentication required"));
+    console.log(chalk.yellow("\nPlease login first:"));
+    console.log(chalk.cyan("  veestack login"));
+    console.log(chalk.gray("\nOr get an API key from: https://veestack.tools/dashboard"));
+    process.exit(1);
+  }
+  return config;
+}
+
+// src/commands/scan.ts
+async function scanCommand(options) {
+  const authConfig = requireAuth();
+  const tier = getSubscriptionTier();
+  console.log(chalk2.blue("\n\u{1F510} Authentication verified"));
+  console.log(chalk2.gray(`Subscription tier: ${tier === "pro" ? "Pro" : "Free"}`));
+  console.log(chalk2.gray("\u2500".repeat(40) + "\n"));
+  const spinner = ora({
+    text: "Scanning project...",
+    spinner: "dots",
+    stream: process.stdout
+  }).start();
+  try {
+    const snapshot = await generateSnapshot(options.path);
+    spinner.succeed(`Scanned ${snapshot.metadata.total_files} files`);
+    const fs = await import("fs/promises");
+    await fs.writeFile(options.output, JSON.stringify(snapshot, null, 2));
+    console.log(`
+\u2705 Snapshot saved to ${options.output}`);
+  } catch (error) {
+    spinner.fail("Scan failed");
+    console.error(error);
+    process.exit(1);
+  }
+}
+async function generateSnapshot(projectPath) {
+  const files = await scanFiles(projectPath);
+  const dependencies = await scanDependencies(projectPath);
+  const metadata = {
+    total_files: files.length,
+    total_dependencies: dependencies.length,
+    total_size_bytes: files.reduce((sum, f) => sum + f.size_bytes, 0),
+    total_lines: files.reduce((sum, f) => sum + (f.estimated_lines || 0), 0),
+    max_directory_depth: Math.max(...files.map((f) => f.depth), 0),
+    language_breakdown: calculateLanguageBreakdown(files)
+  };
+  return {
+    snapshot_version: "1.0.0",
+    engine_target_version: "1.0.0",
+    project_id: crypto.randomUUID(),
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    root_path_hash: hashString(projectPath),
+    project_root: resolve(projectPath),
+    // Use absolute path for content scanning
+    metadata,
+    files,
+    dependencies
+  };
+}
+async function scanFiles(projectPath) {
+  const files = [];
+  const patterns = ["**/*"];
+  const filePaths = await glob(patterns, {
+    cwd: projectPath,
+    ignore: [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.next/**",
+      "**/out/**",
+      "**/coverage/**"
+    ],
+    absolute: false
+  });
+  for (const filePath of filePaths) {
+    const fullPath = join2(projectPath, filePath);
+    const stats = statSync(fullPath);
+    if (stats.isFile()) {
+      const fileNode = {
+        id: crypto.randomUUID(),
+        path: filePath,
+        // Actual relative path for rule evaluation
+        path_hash: hashString(filePath),
+        depth: filePath.split(/[\\/]/).length,
+        size_bytes: stats.size,
+        estimated_lines: Math.floor(stats.size / 50),
+        // Rough estimate
+        extension: filePath.split(".").pop() || "",
+        is_binary: isBinaryFile(filePath)
+      };
+      files.push(fileNode);
+    }
+  }
+  return files.sort((a, b) => a.path_hash.localeCompare(b.path_hash));
+}
+async function scanDependencies(projectPath) {
+  const dependencies = [];
+  try {
+    const packageJsonPath = join2(projectPath, "package.json");
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    const processDeps = (deps, category) => {
+      for (const [name, version] of Object.entries(deps)) {
+        const versionMatch = version.match(/^(\d+)\.(\d+)/);
+        const major = versionMatch ? parseInt(versionMatch[1]) : 0;
+        const minor = versionMatch ? parseInt(versionMatch[2]) : 0;
+        dependencies.push({
+          id: crypto.randomUUID(),
+          name_hash: hashString(name),
+          major_version: major,
+          minor_version: minor,
+          category
+        });
+      }
+    };
+    if (packageJson.dependencies) {
+      processDeps(packageJson.dependencies, "prod");
+    }
+    if (packageJson.devDependencies) {
+      processDeps(packageJson.devDependencies, "dev");
+    }
+    if (packageJson.peerDependencies) {
+      processDeps(packageJson.peerDependencies, "peer");
+    }
+  } catch (error) {
+  }
+  return dependencies.sort((a, b) => a.name_hash.localeCompare(b.name_hash));
+}
+function calculateLanguageBreakdown(files) {
+  const breakdown = {};
+  for (const file of files) {
+    const ext = file.extension.toLowerCase();
+    const lang = getLanguageFromExtension(ext);
+    breakdown[lang] = (breakdown[lang] || 0) + 1;
+  }
+  return breakdown;
+}
+function getLanguageFromExtension(ext) {
+  const map = {
+    ts: "TypeScript",
+    js: "JavaScript",
+    tsx: "TypeScript",
+    jsx: "JavaScript",
+    py: "Python",
+    go: "Go",
+    rs: "Rust",
+    java: "Java",
+    kt: "Kotlin",
+    rb: "Ruby",
+    php: "PHP",
+    cs: "C#",
+    cpp: "C++",
+    c: "C",
+    h: "C",
+    json: "JSON",
+    yaml: "YAML",
+    yml: "YAML",
+    md: "Markdown",
+    html: "HTML",
+    css: "CSS",
+    scss: "SCSS",
+    sql: "SQL",
+    sh: "Shell"
+  };
+  return map[ext] || "Other";
+}
+function isBinaryFile(filePath) {
+  const binaryExtensions = [
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".bin",
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".pdf",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".7z",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot"
+  ];
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  return ext ? binaryExtensions.includes("." + ext) : false;
+}
+function hashString(str) {
+  return crypto.createHash("sha256").update(str).digest("hex");
+}
+
+// src/commands/upload.ts
+import ora2 from "ora";
+import chalk3 from "chalk";
+import readline from "readline";
+var supabaseUrl = process.env.SUPABASE_URL || "https://qhonrrojtqklvlkvfswb.supabase.co";
+var supabaseAnonKey = process.env.SUPABASE_ANON_KEY || "";
+async function fetchProjects() {
+  try {
+    const res = await fetch(`${supabaseUrl}/rest/v1/projects?select=id,name,created_at&order=created_at.desc`, {
+      headers: { "apikey": supabaseAnonKey, "Authorization": `Bearer ${supabaseAnonKey}` }
+    });
+    if (res.ok) {
+      const data = await res.json();
+      return data;
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+async function createProject(name) {
+  try {
+    const res = await fetch(`${supabaseUrl}/rest/v1/projects`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "apikey": supabaseAnonKey,
+        "Authorization": `Bearer ${supabaseAnonKey}`,
+        "Prefer": "return=representation"
+      },
+      body: JSON.stringify({
+        name,
+        user_id: "00000000-0000-0000-0000-000000000001"
+        // Default user
+      })
+    });
+    if (res.ok) {
+      const data = await res.json();
+      return data[0]?.id || null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function askQuestion(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer);
+    });
+  });
+}
+async function selectOrCreateProject() {
+  console.log(chalk3.blue("\n\u{1F4C1} Loading projects...\n"));
+  const projects = await fetchProjects();
+  if (projects.length === 0) {
+    console.log(chalk3.yellow("No projects found.\n"));
+    const answer2 = await askQuestion("Do you want to create a new project? (y/n): ");
+    if (answer2.toLowerCase() === "y") {
+      const name = await askQuestion("Enter project name: ");
+      if (name.trim()) {
+        const projectId = await createProject(name.trim());
+        if (projectId) {
+          console.log(chalk3.green(`
+\u2705 Project "${name}" created successfully!`));
+          return projectId;
+        }
+      }
+    }
+    return null;
+  }
+  console.log(chalk3.white("Select a project:\n"));
+  console.log(chalk3.gray("0. [+] Create new project\n"));
+  projects.forEach((p, i) => {
+    console.log(chalk3.white(`${i + 1}. ${p.name}`));
+    console.log(chalk3.gray(`   ID: ${p.id}`));
+    console.log(chalk3.gray(`   Created: ${new Date(p.created_at).toLocaleDateString()}
+`));
+  });
+  const answer = await askQuestion("Enter number (0-" + projects.length + "): ");
+  const choice = parseInt(answer, 10);
+  if (choice === 0) {
+    const name = await askQuestion("\nEnter project name: ");
+    if (name.trim()) {
+      const projectId = await createProject(name.trim());
+      if (projectId) {
+        console.log(chalk3.green(`
+\u2705 Project "${name}" created successfully!`));
+        return projectId;
+      }
+    }
+    return null;
+  } else if (choice > 0 && choice <= projects.length) {
+    const selected = projects[choice - 1];
+    console.log(chalk3.green(`
+\u2705 Selected project: "${selected.name}"`));
+    return selected.id;
+  } else {
+    console.log(chalk3.red("\n\u274C Invalid selection"));
+    return null;
+  }
+}
+async function uploadCommand(options) {
+  const authConfig = requireAuth();
+  const tier = getSubscriptionTier();
+  console.log(chalk3.blue("\n\u{1F510} Authentication verified"));
+  console.log(chalk3.gray(`Subscription tier: ${tier === "pro" ? "Pro" : "Free"}`));
+  console.log(chalk3.gray("\u2500".repeat(40) + "\n"));
+  const spinner = ora2("Preparing upload...").start();
+  try {
+    const fs = await import("fs/promises");
+    const snapshotData = await fs.readFile(options.file, "utf-8");
+    const snapshot = JSON.parse(snapshotData);
+    let projectId = options.projectId;
+    if (!projectId) {
+      spinner.stop();
+      const selectedProjectId = await selectOrCreateProject();
+      if (!selectedProjectId) {
+        console.log(chalk3.red("\n\u274C No project selected. Exiting."));
+        process.exit(1);
+      }
+      projectId = selectedProjectId;
+      spinner.start("Uploading snapshot...");
+    }
+    spinner.text = "Creating snapshot...";
+    const snapshotRes = await fetch(`${supabaseUrl}/rest/v1/snapshots`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "apikey": supabaseAnonKey,
+        "Authorization": `Bearer ${supabaseAnonKey}`,
+        "Prefer": "return=representation"
+      },
+      body: JSON.stringify({
+        project_id: projectId,
+        file_count: snapshot.metadata.total_files,
+        size_mb: snapshot.metadata.total_size_bytes / (1024 * 1024),
+        storage_path: "local://" + projectId
+      })
+    });
+    if (!snapshotRes.ok) {
+      const error = await snapshotRes.json();
+      spinner.fail("Failed to create snapshot");
+      console.error(chalk3.red(`Error: ${error.message || error.details || "Unknown error"}`));
+      process.exit(1);
+    }
+    const snapshotData2 = await snapshotRes.json();
+    const snapshotId = snapshotData2[0]?.id || snapshotData2[0]?.id;
+    spinner.text = "Analyzing snapshot...";
+    const { CoreEngine } = await import("@veestack-tools/engine");
+    const { RULES } = await import("@veestack-tools/engine");
+    const engine = new CoreEngine();
+    RULES.forEach((rule) => engine.registerRule(rule));
+    const result = await engine.analyze(snapshot);
+    if (!result.success) {
+      spinner.fail("Analysis failed");
+      console.error(chalk3.red("Error:", result.error));
+      process.exit(1);
+    }
+    spinner.text = "Creating report...";
+    const reportRes = await fetch(`${supabaseUrl}/rest/v1/reports`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "apikey": supabaseAnonKey,
+        "Authorization": `Bearer ${supabaseAnonKey}`,
+        "Prefer": "return=representation"
+      },
+      body: JSON.stringify({
+        snapshot_id: snapshotId,
+        score: result.report.total_score,
+        issues_count: result.report.summary.total_findings,
+        critical_count: result.report.summary.critical_count,
+        high_count: result.report.summary.high_count,
+        medium_count: result.report.summary.medium_count,
+        low_count: result.report.summary.low_count,
+        execution_time_ms: 0,
+        report_json: result.report
+      })
+    });
+    if (!reportRes.ok) {
+      const error = await reportRes.json();
+      spinner.fail("Failed to create report");
+      console.error(chalk3.red(`Error: ${error.message || error.details || "Unknown error"}`));
+      process.exit(1);
+    }
+    const reportData = await reportRes.json();
+    const reportId = reportData[0]?.id || reportData[0]?.id;
+    spinner.succeed("Analysis complete");
+    console.log(chalk3.green("\n\u2705 Report generated and saved to VeeStack"));
+    console.log(chalk3.gray("Project ID:"), projectId);
+    console.log(chalk3.gray("Snapshot ID:"), snapshotId);
+    console.log(chalk3.gray("Report ID:"), reportId);
+    console.log(chalk3.bold("\n\u{1F4CA} Score:"), result.report.total_score);
+    console.log(chalk3.gray("Severity:"), result.report.severity_band);
+    console.log(chalk3.gray("Findings:"), result.report.summary.total_findings);
+    console.log(chalk3.blue("\n\u{1F517} View your report at:"));
+    console.log(chalk3.underline(`http://localhost:3001/reports/${reportId}?project=${projectId}`));
+  } catch (error) {
+    spinner.fail("Upload failed");
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/commands/login.ts
+import { writeFileSync } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+import ora3 from "ora";
+import prompts from "prompts";
+async function loginCommand(options) {
+  const spinner = ora3({
+    text: "Authenticating...",
+    spinner: "dots",
+    stream: process.stdout
+  });
+  try {
+    let apiKey = options.key;
+    if (!apiKey) {
+      const response = await prompts({
+        type: "password",
+        name: "key",
+        message: "Enter your VeeStack API key:",
+        validate: (value) => value.length > 0 || "API key is required"
+      });
+      if (!response.key) {
+        console.log("\u274C Login cancelled");
+        process.exit(1);
+      }
+      apiKey = response.key;
+    }
+    spinner.start("Validating API key...");
+    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    const configDir = join3(homedir2(), ".veestack");
+    const configFile = join3(configDir, "config.json");
+    try {
+      const fs = await import("fs/promises");
+      await fs.mkdir(configDir, { recursive: true });
+      await fs.writeFile(configFile, JSON.stringify({ apiKey }, null, 2));
+    } catch {
+      const fs = await import("fs");
+      fs.mkdirSync(configDir, { recursive: true });
+      writeFileSync(configFile, JSON.stringify({ apiKey }, null, 2));
+    }
+    spinner.succeed("Authenticated successfully");
+    console.log("\u2705 API key saved to ~/.veestack/config.json");
+  } catch (error) {
+    spinner.fail("Authentication failed");
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/commands/status.ts
+import chalk4 from "chalk";
+async function statusCommand() {
+  console.log(chalk4.blue("\n\u{1F4CA} VeeStack CLI Status\n"));
+  console.log(chalk4.gray("\u2500".repeat(40)));
+  const authenticated = isAuthenticated();
+  const tier = getSubscriptionTier();
+  const active = isSubscriptionActive();
+  if (!authenticated) {
+    console.log(chalk4.red("\n\u274C Not authenticated"));
+    console.log(chalk4.yellow("\nTo use VeeStack CLI, you need to login:"));
+    console.log(chalk4.cyan("  veestack login"));
+    console.log(chalk4.gray("\nGet your API key from: https://veestack.tools/dashboard"));
+    console.log(chalk4.gray("\u2500".repeat(40) + "\n"));
+    process.exit(1);
+  }
+  console.log(chalk4.green("\n\u2705 Authenticated"));
+  if (tier === "pro") {
+    console.log(chalk4.cyan("\u{1F48E} Subscription: Pro"));
+    if (!active) {
+      console.log(chalk4.red("\u26A0\uFE0F  Status: Expired"));
+      console.log(chalk4.yellow("\nPlease renew your subscription:"));
+      console.log(chalk4.cyan("  https://veestack.tools/pricing"));
+    } else {
+      console.log(chalk4.green("\u2713 Status: Active"));
+    }
+  } else {
+    console.log(chalk4.blue("\u{1F4E6} Subscription: Free"));
+    console.log(chalk4.green("\u2713 Status: Active"));
+    console.log(chalk4.gray("\nUpgrade to Pro for advanced features:"));
+    console.log(chalk4.cyan("  https://veestack.tools/pricing"));
+  }
+  console.log(chalk4.gray("\u2500".repeat(40) + "\n"));
+  console.log(chalk4.white("Available commands:"));
+  console.log(chalk4.cyan("  veestack scan    ") + chalk4.gray(" - Scan project (Free)"));
+  console.log(chalk4.cyan("  veestack upload  ") + chalk4.gray(" - Upload to cloud (Free)"));
+  console.log(chalk4.cyan("  veestack status  ") + chalk4.gray(" - Check status (Free)"));
+  if (tier === "pro") {
+    console.log(chalk4.cyan("  veestack analyze ") + chalk4.gray(" - Advanced analysis (Pro)"));
+  }
+  console.log(chalk4.gray("\n\u2500".repeat(40) + "\n"));
+}
+
+// src/index.ts
+var program = new Command();
+program.name("veestack").description("VeeStack CLI - Technical Stack Visibility Tool").version("3.0.3");
+program.command("scan").description("Scan a project directory and generate analysis").option("-p, --path <path>", "Path to project directory", ".").option("-o, --output <path>", "Output file path", "snapshot.json").option("--ci", "CI mode (no interactive prompts)").action(scanCommand);
+program.command("upload").description("Upload a snapshot to VeeStack server").option("-f, --file <path>", "Snapshot file path", "snapshot.json").option("-p, --project-id <id>", "Project ID").action(uploadCommand);
+program.command("login").description("Authenticate with VeeStack server").option("-k, --key <apiKey>", "API key").action(loginCommand);
+program.command("status").description("Check authentication and subscription status").action(statusCommand);
+program.parse();

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@veestack-tools/cli",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "type": "module",
+  "files": [
+    "dist/**/*",
+    "bin/**/*"
+  ],
   "bin": {
     "veestack": "bin/veestack.mjs"
   },
@@ -11,9 +15,9 @@
     "start": "node bin/veestack.mjs"
   },
   "dependencies": {
-    "@veestack-tools/types": "3.0.1",
-    "@veestack-tools/utils": "3.0.1",
-    "@veestack-tools/engine": "3.0.2",
+    "@veestack-tools/types": "3.0.2",
+    "@veestack-tools/utils": "3.0.2",
+    "@veestack-tools/engine": "3.0.3",
     "commander": "^11.1.0",
     "chalk": "^5.3.0",
     "ora": "^8.0.1",

package/.env.example

@@ -1,14 +0,0 @@
-# VeeStack CLI Environment Variables
-# Copy this file to .env and fill in your actual values
-
-# Supabase Configuration (Required)
-SUPABASE_URL=https://your-project.supabase.co
-SUPABASE_ANON_KEY=your_anon_key_here
-
-# IMPORTANT SECURITY NOTES:
-# - CLI should use SUPABASE_ANON_KEY (not Service Role Key)
-# - User authentication is handled via OAuth browser flow
-# - Access token is stored securely after login
-
-# Optional: For admin/debug scripts only (never commit this)
-# SUPABASE_SERVICE_ROLE_KEY=your_service_role_key_here

package/src/commands/login.ts

@@ -1,60 +0,0 @@
-import { writeFileSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import ora from 'ora';
-import prompts from 'prompts';
-
-export async function loginCommand(options: { key?: string }): Promise<void> {
-  const spinner = ora({
-    text: 'Authenticating...',
-    spinner: 'dots',
-    stream: process.stdout
-  });
-
-  try {
-    let apiKey = options.key;
-
-    if (!apiKey) {
-      const response = await prompts({
-        type: 'password',
-        name: 'key',
-        message: 'Enter your VeeStack API key:',
-        validate: (value) => value.length > 0 || 'API key is required'
-      });
-
-      if (!response.key) {
-        console.log('❌ Login cancelled');
-        process.exit(1);
-      }
-
-      apiKey = response.key;
-    }
-
-    spinner.start('Validating API key...');
-
-    // Mock validation - in production this would validate with the server
-    await new Promise(resolve => setTimeout(resolve, 1000));
-
-    // Save to config file
-    const configDir = join(homedir(), '.veestack');
-    const configFile = join(configDir, 'config.json');
-
-    try {
-      const fs = await import('fs/promises');
-      await fs.mkdir(configDir, { recursive: true });
-      await fs.writeFile(configFile, JSON.stringify({ apiKey }, null, 2));
-    } catch {
-      // Fallback to sync
-      const fs = await import('fs');
-      fs.mkdirSync(configDir, { recursive: true });
-      writeFileSync(configFile, JSON.stringify({ apiKey }, null, 2));
-    }
-
-    spinner.succeed('Authenticated successfully');
-    console.log('✅ API key saved to ~/.veestack/config.json');
-  } catch (error) {
-    spinner.fail('Authentication failed');
-    console.error(error);
-    process.exit(1);
-  }
-}