@viji-dev/sdk 1.0.0

package/src/cli/commands/init.js

@@ -0,0 +1,262 @@
+/**
+ * Init Command - Initialize a new Viji workspace
+ */
+
+import { mkdir, writeFile, readFile, copyFile, readdir, stat } from 'fs/promises';
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import { createRequire } from 'module';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export async function initCommand(workspaceName, options) {
+  try {
+    console.log('🎨 Initializing Viji workspace...');
+    
+    // Determine workspace path
+    let workspacePath;
+    if (workspaceName === '.' || workspaceName === './') {
+      workspacePath = process.cwd();
+      workspaceName = basename(workspacePath);
+      console.log(`📁 Initializing in current directory: ${workspacePath}`);
+      console.log(`🏷️  Workspace name: ${workspaceName}`);
+    } else {
+      workspacePath = resolve(process.cwd(), workspaceName);
+      console.log(`📁 Creating workspace: ${workspacePath}`);
+    }
+    
+    // Check if directory exists and is not empty
+    if (existsSync(workspacePath)) {
+      const files = await readdir(workspacePath);
+      if (files.length > 0) {
+        console.error(`❌ Directory ${workspacePath} is not empty`);
+        console.log('💡 Use "viji init ." to initialize in current directory');
+        process.exit(1);
+      }
+    }
+    
+    // Find SDK directory (where this command is running from)
+    const sdkDir = findSDKDirectory();
+    if (!sdkDir) {
+      console.error('❌ Could not find Viji SDK installation');
+      process.exit(1);
+    }
+    
+    console.log('🛠️ SDK directory:', sdkDir);
+    console.log('🚀 Copying workspace files...');
+    
+    // Create workspace directory if it doesn't exist
+    await mkdir(workspacePath, { recursive: true });
+    
+    // Copy SDK structure to workspace
+    await copyWorkspaceFiles(sdkDir, workspacePath, workspaceName);
+    
+    console.log('📦 Installing dependencies...');
+    
+    // Install dependencies in the new workspace
+    await installDependencies(workspacePath);
+    
+    console.log('✅ Workspace initialized successfully!');
+    console.log('');
+    console.log('🎯 Next steps:');
+    if (workspaceName !== basename(process.cwd())) {
+      console.log(`   cd ${workspaceName}`);
+    }
+    console.log('   viji create my-first-scene --lang=js');
+    console.log('   viji dev');
+    console.log('');
+    console.log('🚀 Happy creating!');
+    
+  } catch (error) {
+    console.error('💥 Failed to initialize workspace:', error.message);
+    process.exit(1);
+  }
+}
+
+async function copyWorkspaceFiles(sdkDir, workspacePath, workspaceName) {
+  // Files and directories to copy from SDK to workspace
+  const filesToCopy = [
+    'src',
+    'scenes', 
+    'public',
+    'index.html',
+    'vite.config.ts',
+    'tsconfig.json',
+    'tsconfig.app.json', 
+    'tsconfig.node.json',
+    'tailwind.config.js',
+    'postcss.config.js',
+    'eslint.config.js',
+    '.gitignore'
+  ];
+  
+  // Files to exclude from copying
+  const excludePatterns = [
+    'node_modules',
+    'dist',
+    'build', 
+    '.git',
+    'package-lock.json',
+    'tsconfig.tsbuildinfo',
+    'vite.config.d.ts'
+  ];
+  
+  for (const item of filesToCopy) {
+    const sourcePath = join(sdkDir, item);
+    const targetPath = join(workspacePath, item);
+    
+    if (existsSync(sourcePath)) {
+      await copyRecursive(sourcePath, targetPath, excludePatterns);
+    }
+  }
+  
+  // Create workspace-specific package.json
+  await createWorkspacePackageJson(sdkDir, workspacePath, workspaceName);
+}
+
+async function copyRecursive(source, target, excludePatterns = []) {
+  const stats = await stat(source);
+  
+  // Check if this path should be excluded
+  const sourceName = basename(source);
+  if (excludePatterns.some(pattern => sourceName.includes(pattern))) {
+    return;
+  }
+  
+  if (stats.isDirectory()) {
+    await mkdir(target, { recursive: true });
+    const files = await readdir(source);
+    
+    for (const file of files) {
+      await copyRecursive(
+        join(source, file),
+        join(target, file),
+        excludePatterns
+      );
+    }
+  } else {
+    await copyFile(source, target);
+  }
+}
+
+async function createWorkspacePackageJson(sdkDir, workspacePath, workspaceName) {
+  // Read the SDK package.json as template
+  const sdkPackageJson = JSON.parse(readFileSync(join(sdkDir, 'package.json'), 'utf8'));
+  
+  // Create workspace package.json
+  const workspacePackageJson = {
+    name: workspaceName,
+    private: true,
+    version: "0.1.0",
+    type: "module",
+    description: `Viji workspace: ${workspaceName}`,
+    scripts: {
+      dev: "vite",
+      build: "tsc -b && vite build", 
+      lint: "eslint .",
+      preview: "vite preview"
+    },
+    dependencies: {
+      // Copy runtime dependencies from SDK
+      "@heroicons/react": sdkPackageJson.dependencies["@heroicons/react"],
+      "@heroui/react": sdkPackageJson.dependencies["@heroui/react"],
+      "@viji-dev/core": sdkPackageJson.dependencies["@viji-dev/core"],
+      "autoprefixer": sdkPackageJson.dependencies["autoprefixer"],
+      "chokidar": sdkPackageJson.dependencies["chokidar"],
+      "clsx": sdkPackageJson.dependencies["clsx"],
+      "framer-motion": sdkPackageJson.dependencies["framer-motion"],
+      "react": sdkPackageJson.dependencies["react"],
+      "react-dom": sdkPackageJson.dependencies["react-dom"],
+      "tailwind-merge": sdkPackageJson.dependencies["tailwind-merge"],
+      "tailwindcss": sdkPackageJson.dependencies["tailwindcss"],
+      "zustand": sdkPackageJson.dependencies["zustand"]
+    },
+    devDependencies: {
+      // Copy dev dependencies from SDK
+      "@eslint/js": sdkPackageJson.devDependencies["@eslint/js"],
+      "@types/node": sdkPackageJson.devDependencies["@types/node"],
+      "@types/react": sdkPackageJson.devDependencies["@types/react"],
+      "@types/react-dom": sdkPackageJson.devDependencies["@types/react-dom"],
+      "@vitejs/plugin-react": sdkPackageJson.devDependencies["@vitejs/plugin-react"],
+      "eslint": sdkPackageJson.devDependencies["eslint"],
+      "eslint-plugin-react-hooks": sdkPackageJson.devDependencies["eslint-plugin-react-hooks"],
+      "eslint-plugin-react-refresh": sdkPackageJson.devDependencies["eslint-plugin-react-refresh"],
+      "globals": sdkPackageJson.devDependencies["globals"],
+      "typescript": sdkPackageJson.devDependencies["typescript"],
+      "typescript-eslint": sdkPackageJson.devDependencies["typescript-eslint"],
+      "vite": sdkPackageJson.devDependencies["vite"]
+    },
+    viji: {
+      sdkVersion: sdkPackageJson.version,
+      initDate: new Date().toISOString(),
+      workspaceVersion: "1.0.0"
+    }
+  };
+  
+  await writeFile(
+    join(workspacePath, 'package.json'),
+    JSON.stringify(workspacePackageJson, null, 2)
+  );
+}
+
+async function installDependencies(workspacePath) {
+  return new Promise((resolve, reject) => {
+    // Use platform-specific npm command
+    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    
+    const installProcess = spawn(npmCommand, ['install'], {
+      cwd: workspacePath,
+      stdio: 'inherit',
+      shell: true
+    });
+    
+    installProcess.on('exit', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`npm install failed with code ${code}`));
+      }
+    });
+    
+    installProcess.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+function findSDKDirectory() {
+  // Try relative to this CLI file first (for development)
+  const relativeSDK = resolve(__dirname, '..', '..', '..');
+  if (existsSync(join(relativeSDK, 'package.json'))) {
+    const packageJson = JSON.parse(readFileSync(join(relativeSDK, 'package.json'), 'utf8'));
+    if (packageJson.name === 'viji-sdk') {
+      return relativeSDK;
+    }
+  }
+  
+  // Try to find global installation
+  try {
+    const require = createRequire(import.meta.url);
+    const globalSDK = require.resolve('viji-sdk');
+    if (globalSDK) {
+      return dirname(dirname(globalSDK)); // Go up from lib/index.js to root
+    }
+  } catch (error) {
+    // Not found globally
+  }
+  
+  // Try to find in node_modules
+  let currentPath = process.cwd();
+  while (currentPath !== dirname(currentPath)) {
+    const potentialSDK = join(currentPath, 'node_modules', 'viji-sdk');
+    if (existsSync(potentialSDK)) {
+      return potentialSDK;
+    }
+    currentPath = dirname(currentPath);
+  }
+  
+  return null;
+}

package/src/cli/utils/cli-utils.js

@@ -0,0 +1,208 @@
+/**
+ * CLI Utilities - Common functions for CLI commands
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+export function validateProject(projectDir = process.cwd()) {
+  // Support two layouts:
+  // 1) SDK scene folder: scenes/<project>/main.(js|ts)
+  // 2) External project: src/main.(js|ts)
+  const candidates = [
+    join(projectDir, 'main.ts'),
+    join(projectDir, 'main.js'),
+    join(projectDir, 'main.tsx'),
+    join(projectDir, 'main.jsx'),
+    join(projectDir, 'src', 'main.ts'),
+    join(projectDir, 'src', 'main.js'),
+    join(projectDir, 'src', 'main.tsx'),
+    join(projectDir, 'src', 'main.jsx')
+  ];
+
+  const mainScenePath = candidates.find(p => existsSync(p));
+  const packageJsonPath = join(projectDir, 'package.json');
+
+  const issues = [];
+  if (!mainScenePath) {
+    issues.push('No main.(js|ts|jsx|tsx) found in current folder or src/');
+  }
+
+  return {
+    valid: issues.length === 0,
+    issues,
+    paths: {
+      packageJson: packageJsonPath,
+      mainScene: mainScenePath || join(projectDir, 'main.js'),
+      projectDir
+    }
+  };
+}
+
+export function getProjectInfo(projectDir = process.cwd()) {
+  const validation = validateProject(projectDir);
+  
+  if (!validation.valid) {
+    return { valid: false, ...validation };
+  }
+  
+  try {
+    const packageJson = JSON.parse(readFileSync(validation.paths.packageJson, 'utf8'));
+    
+    return {
+      valid: true,
+      name: packageJson.name,
+      version: packageJson.version,
+      description: packageJson.description,
+      dependencies: packageJson.dependencies || {},
+      devDependencies: packageJson.devDependencies || {},
+      scripts: packageJson.scripts || {},
+      paths: validation.paths
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      issues: ['Could not read project information'],
+      error: error.message
+    };
+  }
+}
+
+export function formatProjectPath(projectName, targetDir = process.cwd()) {
+  return join(targetDir, projectName);
+}
+
+export function generateProjectId() {
+  return Math.random().toString(36).substr(2, 9);
+}
+
+export function validateProjectName(name) {
+  const issues = [];
+  
+  if (!name || name.trim().length === 0) {
+    issues.push('Project name cannot be empty');
+  }
+  
+  if (name.length > 214) {
+    issues.push('Project name too long (max 214 characters)');
+  }
+  
+  if (name.toLowerCase() !== name) {
+    issues.push('Project name should be lowercase');
+  }
+  
+  if (!/^[a-z0-9-_]+$/.test(name)) {
+    issues.push('Project name can only contain lowercase letters, numbers, hyphens, and underscores');
+  }
+  
+  if (name.startsWith('.') || name.startsWith('-') || name.startsWith('_')) {
+    issues.push('Project name cannot start with a dot, hyphen, or underscore');
+  }
+  
+  const reservedNames = ['viji', 'viji-sdk', 'core', 'main', 'index', 'src', 'dist', 'build'];
+  if (reservedNames.includes(name.toLowerCase())) {
+    issues.push(`Project name "${name}" is reserved`);
+  }
+  
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+
+export function logWithIcon(icon, message, color = 'white') {
+  const colors = {
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    reset: '\x1b[0m'
+  };
+  
+  console.log(`${colors[color]}${icon} ${message}${colors.reset}`);
+}
+
+export function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${(ms / 60000).toFixed(1)}m`;
+}
+
+export function formatFileSize(bytes) {
+  if (bytes === 0) return '0 B';
+  
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
+export function createSpinner(text = 'Loading...') {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  let intervalId;
+  
+  const spinner = {
+    start() {
+      process.stdout.write(`${frames[0]} ${text}`);
+      intervalId = setInterval(() => {
+        process.stdout.write(`\r${frames[i]} ${text}`);
+        i = (i + 1) % frames.length;
+      }, 80);
+    },
+    
+    stop(finalText) {
+      if (intervalId) {
+        clearInterval(intervalId);
+        process.stdout.write(`\r${finalText || text}\n`);
+      }
+    },
+    
+    update(newText) {
+      text = newText;
+    }
+  };
+  
+  return spinner;
+}
+
+export function isVijiWorkspace(dir = process.cwd()) {
+  // Check for key workspace files
+  const requiredFiles = [
+    join(dir, 'src'),
+    join(dir, 'scenes'), 
+    join(dir, 'vite.config.ts'),
+    join(dir, 'package.json')
+  ];
+  
+  // All required files must exist
+  if (!requiredFiles.every(file => existsSync(file))) {
+    return false;
+  }
+  
+  // Check if package.json has viji workspace marker
+  try {
+    const packageJson = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+    return packageJson.viji && packageJson.viji.workspaceVersion;
+  } catch (error) {
+    return false;
+  }
+}
+
+export function findWorkspaceRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+  
+  while (currentDir !== dirname(currentDir)) {
+    if (isVijiWorkspace(currentDir)) {
+      return currentDir;
+    }
+    currentDir = dirname(currentDir);
+  }
+  
+  return null;
+}
+