@veestack-tools/cli 3.0.2 → 3.0.3

package/src/commands/scan.ts

@@ -1,219 +0,0 @@
-import { glob } from 'glob';
-import { readFileSync, statSync, readdirSync } from 'fs';
-import { join, resolve } from 'path';
-import type { Snapshot, FileNode, DependencyNode } from '@veestack-tools/types';
-import crypto from 'crypto';
-import ora from 'ora';
-
-export async function scanCommand(options: {
-  path: string;
-  output: string;
-}): Promise<void> {
-  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`);
-
-    // Save to file
-    const fs = await import('fs/promises');
-    await fs.writeFile(options.output, JSON.stringify(snapshot, null, 2));
-
-    console.log(`\n✅ Snapshot saved to ${options.output}`);
-  } catch (error) {
-    spinner.fail('Scan failed');
-    console.error(error);
-    process.exit(1);
-  }
-}
-
-async function generateSnapshot(projectPath: string): Promise<Snapshot> {
-  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: 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: string): Promise<FileNode[]> {
-  const files: FileNode[] = [];
-  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 = join(projectPath, filePath);
-    const stats = statSync(fullPath);
-
-    if (stats.isFile()) {
-      const fileNode: 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);
-    }
-  }
-
-  // Sort deterministically by path_hash
-  return files.sort((a, b) => a.path_hash.localeCompare(b.path_hash));
-}
-
-async function scanDependencies(projectPath: string): Promise<DependencyNode[]> {
-  const dependencies: DependencyNode[] = [];
-
-  try {
-    const packageJsonPath = join(projectPath, 'package.json');
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-
-    const processDeps = (
-      deps: Record<string, string>,
-      category: 'dev' | 'prod' | 'peer'
-    ) => {
-      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) {
-    // No package.json found
-  }
-
-  // Sort deterministically by name_hash
-  return dependencies.sort((a, b) => a.name_hash.localeCompare(b.name_hash));
-}
-
-function calculateLanguageBreakdown(files: FileNode[]): Record<string, number> {
-  const breakdown: Record<string, number> = {};
-
-  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: string): string {
-  const map: Record<string, string> = {
-    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: string): boolean {
-  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: string): string {
-  return crypto.createHash('sha256').update(str).digest('hex');
-}

package/src/commands/upload.ts

@@ -1,241 +0,0 @@
-import { readFileSync } from 'fs';
-import ora from 'ora';
-import chalk from 'chalk';
-import readline from 'readline';
-
-const supabaseUrl = process.env.SUPABASE_URL || 'https://qhonrrojtqklvlkvfswb.supabase.co';
-const supabaseAnonKey = process.env.SUPABASE_ANON_KEY || ''; // Must be set in environment
-
-// Fetch projects from Supabase
-async function fetchProjects(): Promise<any[]> {
-  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() as any[];
-      return data;
-    }
-    return [];
-  } catch {
-    return [];
-  }
-}
-
-// Create new project in Supabase
-async function createProject(name: string): Promise<string | null> {
-  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() as any[];
-      return data[0]?.id || null;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-// Interactive prompt
-function askQuestion(question: string): Promise<string> {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer);
-    });
-  });
-}
-
-// Select or create project
-async function selectOrCreateProject(): Promise<string | null> {
-  console.log(chalk.blue('\n📁 Loading projects...\n'));
-  
-  const projects = await fetchProjects();
-  
-  if (projects.length === 0) {
-    console.log(chalk.yellow('No projects found.\n'));
-    const answer = await askQuestion('Do you want to create a new project? (y/n): ');
-    if (answer.toLowerCase() === 'y') {
-      const name = await askQuestion('Enter project name: ');
-      if (name.trim()) {
-        const projectId = await createProject(name.trim());
-        if (projectId) {
-          console.log(chalk.green(`\n✅ Project "${name}" created successfully!`));
-          return projectId;
-        }
-      }
-    }
-    return null;
-  }
-  
-  // Display projects
-  console.log(chalk.white('Select a project:\n'));
-  console.log(chalk.gray('0. [+] Create new project\n'));
-  
-  projects.forEach((p, i) => {
-    console.log(chalk.white(`${i + 1}. ${p.name}`));
-    console.log(chalk.gray(`   ID: ${p.id}`));
-    console.log(chalk.gray(`   Created: ${new Date(p.created_at).toLocaleDateString()}\n`));
-  });
-  
-  const answer = await askQuestion('Enter number (0-' + projects.length + '): ');
-  const choice = parseInt(answer, 10);
-  
-  if (choice === 0) {
-    // Create new project
-    const name = await askQuestion('\nEnter project name: ');
-    if (name.trim()) {
-      const projectId = await createProject(name.trim());
-      if (projectId) {
-        console.log(chalk.green(`\n✅ Project "${name}" created successfully!`));
-        return projectId;
-      }
-    }
-    return null;
-  } else if (choice > 0 && choice <= projects.length) {
-    // Select existing project
-    const selected = projects[choice - 1];
-    console.log(chalk.green(`\n✅ Selected project: "${selected.name}"`));
-    return selected.id;
-  } else {
-    console.log(chalk.red('\n❌ Invalid selection'));
-    return null;
-  }
-}
-
-export async function uploadCommand(options: {
-  file: string;
-  projectId?: string;
-  apiKey?: string;
-}): Promise<void> {
-  const spinner = ora('Preparing upload...').start();
-
-  try {
-    const fs = await import('fs/promises');
-    const snapshotData = await fs.readFile(options.file, 'utf-8');
-    const snapshot = JSON.parse(snapshotData);
-
-    // Determine project ID
-    let projectId: string | undefined = options.projectId;
-    
-    if (!projectId) {
-      spinner.stop();
-      const selectedProjectId = await selectOrCreateProject();
-      if (!selectedProjectId) {
-        console.log(chalk.red('\n❌ No project selected. Exiting.'));
-        process.exit(1);
-      }
-      projectId = selectedProjectId;
-      spinner.start('Uploading snapshot...');
-    }
-
-    // 1. Create 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() as any;
-      spinner.fail('Failed to create snapshot');
-      console.error(chalk.red(`Error: ${error.message || error.details || 'Unknown error'}`));
-      process.exit(1);
-    }
-
-    const snapshotData2 = await snapshotRes.json() as any[];
-    const snapshotId = snapshotData2[0]?.id || snapshotData2[0]?.id;
-
-    // 2. Run analysis locally
-    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: any) => engine.registerRule(rule));
-    const result = await engine.analyze(snapshot);
-
-    if (!result.success) {
-      spinner.fail('Analysis failed');
-      console.error(chalk.red('Error:', result.error));
-      process.exit(1);
-    }
-
-    // 3. Create report
-    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() as any;
-      spinner.fail('Failed to create report');
-      console.error(chalk.red(`Error: ${error.message || error.details || 'Unknown error'}`));
-      process.exit(1);
-    }
-
-    const reportData = await reportRes.json() as any[];
-    const reportId = reportData[0]?.id || reportData[0]?.id;
-
-    spinner.succeed('Analysis complete');
-
-    console.log(chalk.green('\n✅ Report generated and saved to VeeStack'));
-    console.log(chalk.gray('Project ID:'), projectId);
-    console.log(chalk.gray('Snapshot ID:'), snapshotId);
-    console.log(chalk.gray('Report ID:'), reportId);
-    console.log(chalk.bold('\n📊 Score:'), result.report.total_score);
-    console.log(chalk.gray('Severity:'), result.report.severity_band);
-    console.log(chalk.gray('Findings:'), result.report.summary.total_findings);
-    
-    console.log(chalk.blue('\n🔗 View your report at:'));
-    console.log(chalk.underline(`http://localhost:3001/reports/${reportId}?project=${projectId}`));
-  } catch (error) {
-    spinner.fail('Upload failed');
-    console.error(error);
-    process.exit(1);
-  }
-}

package/src/index.ts

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import { scanCommand } from './commands/scan';
-import { uploadCommand } from './commands/upload';
-import { loginCommand } from './commands/login';
-
-const program = new Command();
-
-program
-  .name('veestack')
-  .description('VeeStack CLI - Technical Stack Visibility Tool')
-  .version('3.0.1');
-
-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.parse();

package/src/wasm/license.ts

@@ -1,181 +0,0 @@
-import crypto from 'crypto';
-import fs from 'fs';
-import path from 'path';
-import { WasmEngineLoader, type WasmSnapshot, type WasmFileInfo, type WasmDependency, type WasmMetadata } from '../wasm/loader.js';
-
-const LICENSE_FILE = '.veestack/license.key';
-const SESSION_FILE = '.veestack/session.json';
-
-export interface LicenseData {
-  key: string;
-  hardware_id: string;
-  issued_at: string;
-  expires_at: string;
-  tier: 'free' | 'pro' | 'enterprise';
-  features: string[];
-}
-
-export class LicenseManager {
-  private projectPath: string;
-  private licenseData: LicenseData | null = null;
-
-  constructor(projectPath: string = '.') {
-    this.projectPath = projectPath;
-  }
-
-  /**
-   * Check if valid license exists
-   */
-  async hasValidLicense(): Promise<boolean> {
-    const licensePath = path.join(this.projectPath, LICENSE_FILE);
-    
-    if (!fs.existsSync(licensePath)) {
-      return false;
-    }
-
-    try {
-      const data = fs.readFileSync(licensePath, 'utf-8');
-      this.licenseData = JSON.parse(data);
-      
-      // Validate hardware binding
-      const currentHardwareId = this.generateHardwareId();
-      if (this.licenseData?.hardware_id !== currentHardwareId) {
-        console.warn('⚠️  License bound to different machine');
-        return false;
-      }
-
-      // Check expiration
-      if (this.licenseData?.expires_at) {
-        const expiry = new Date(this.licenseData.expires_at);
-        if (expiry < new Date()) {
-          console.warn('⚠️  License has expired');
-          return false;
-        }
-      }
-
-      return true;
-    } catch (error) {
-      console.error('❌ Error reading license:', error);
-      return false;
-    }
-  }
-
-  /**
-   * Get license key
-   */
-  getLicenseKey(): string | null {
-    return this.licenseData?.key || null;
-  }
-
-  /**
-   * Get license tier
-   */
-  getLicenseTier(): string {
-    return this.licenseData?.tier || 'free';
-  }
-
-  /**
-   * Validate license with remote server
-   */
-  async validateWithServer(apiUrl: string, apiKey: string): Promise<boolean> {
-    if (!this.licenseData) return false;
-
-    try {
-      const response = await fetch(`${apiUrl}/functions/v1/validate-license`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${apiKey}`
-        },
-        body: JSON.stringify({
-          license_key: this.licenseData.key,
-          hardware_id: this.licenseData.hardware_id
-        })
-      });
-
-      if (!response.ok) return false;
-      
-      const result = await response.json() as { valid: boolean };
-      return result.valid === true;
-    } catch (error) {
-      console.error('❌ License validation error:', error);
-      return false;
-    }
-  }
-
-  /**
-   * Generate hardware fingerprint
-   */
-  generateHardwareId(): string {
-    const components = [
-      process.platform,
-      process.arch,
-      process.version,
-      require('os').hostname(),
-      require('os').userInfo().username,
-      'veestack-v1'
-    ];
-    
-    const combined = components.join('|');
-    return crypto.createHash('sha256').update(combined).digest('hex');
-  }
-
-  /**
-   * Save license to file
-   */
-  async saveLicense(licenseData: LicenseData): Promise<void> {
-    const licenseDir = path.dirname(path.join(this.projectPath, LICENSE_FILE));
-    
-    if (!fs.existsSync(licenseDir)) {
-      fs.mkdirSync(licenseDir, { recursive: true });
-    }
-
-    fs.writeFileSync(
-      path.join(this.projectPath, LICENSE_FILE),
-      JSON.stringify(licenseData, null, 2)
-    );
-    
-    this.licenseData = licenseData;
-  }
-
-  /**
-   * Get or create session
-   */
-  getOrCreateSession(): { sessionId: string; isNew: boolean } {
-    const sessionPath = path.join(this.projectPath, SESSION_FILE);
-    
-    if (fs.existsSync(sessionPath)) {
-      try {
-        const data = JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
-        
-        // Check if session is still valid (24 hours)
-        const created = new Date(data.created_at);
-        const now = new Date();
-        const hoursDiff = (now.getTime() - created.getTime()) / (1000 * 60 * 60);
-        
-        if (hoursDiff < 24) {
-          return { sessionId: data.session_id, isNew: false };
-        }
-      } catch {
-        // Invalid session file, create new
-      }
-    }
-
-    // Create new session
-    const sessionId = crypto.randomUUID();
-    const sessionData = {
-      session_id: sessionId,
-      created_at: new Date().toISOString(),
-      hardware_id: this.generateHardwareId()
-    };
-
-    const sessionDir = path.dirname(sessionPath);
-    if (!fs.existsSync(sessionDir)) {
-      fs.mkdirSync(sessionDir, { recursive: true });
-    }
-
-    fs.writeFileSync(sessionPath, JSON.stringify(sessionData, null, 2));
-    
-    return { sessionId, isNew: true };
-  }
-}