vigthoria-cli 1.1.0 → 1.3.0

package/src/commands/repo.ts

@@ -0,0 +1,701 @@
+/**
+ * Vigthoria CLI - Repo Commands
+ * 
+ * Push and pull projects to/from Vigthoria Repository
+ * Enables version control and project sharing through the Vigthoria platform
+ * 
+ * Usage:
+ *   vigthoria repo push [path]     - Push current/specified project to Vigthoria Repo
+ *   vigthoria repo pull <name>     - Pull a project from your Vigthoria Repo
+ *   vigthoria repo list            - List all your projects in Vigthoria Repo
+ *   vigthoria repo status          - Show sync status of current project
+ *   vigthoria repo share <name>    - Generate shareable link for a project
+ *   vigthoria repo delete <name>   - Remove a project from your Vigthoria Repo
+ */
+
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import archiver from 'archiver';
+import { createWriteStream, createReadStream } from 'fs';
+import { pipeline } from 'stream/promises';
+
+interface Project {
+    id: number;
+    project_name: string;
+    project_path: string;
+    description: string;
+    tech_stack: string;
+    visibility: 'public' | 'private' | 'restricted';
+    is_public: boolean;
+    demo_url: string | null;
+    repo_url: string | null;
+    status: string;
+    storage_usage_mb: number;
+    created_at: string;
+    updated_at: string;
+    last_synced_at: string | null;
+}
+
+interface PushOptions {
+    path?: string;
+    visibility?: 'public' | 'private' | 'restricted';
+    description?: string;
+    force?: boolean;
+}
+
+interface PullOptions {
+    output?: string;
+    force?: boolean;
+}
+
+interface ListOptions {
+    visibility?: string;
+    showAll?: boolean;
+}
+
+interface ShareOptions {
+    expires?: string;
+}
+
+export class RepoCommand {
+    private config: Config;
+    private logger: Logger;
+    private apiBase: string;
+
+    constructor(config: Config, logger: Logger) {
+        this.config = config;
+        this.logger = logger;
+        this.apiBase = this.config.get('apiUrl') || 'https://coder.vigthoria.io';
+    }
+
+    private getAuthHeaders(): Record<string, string> {
+        const token = this.config.get('authToken');
+        return {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json'
+        };
+    }
+
+    private isAuthenticated(): boolean {
+        const token = this.config.get('authToken');
+        return !!token;
+    }
+
+    private requireAuth(): void {
+        if (!this.isAuthenticated()) {
+            console.log(chalk.red('\n❌ Authentication required. Run: vigthoria login\n'));
+            process.exit(1);
+        }
+    }
+
+    /**
+     * Detect project info from package.json, requirements.txt, etc.
+     */
+    private detectProjectInfo(projectPath: string): { name: string; description: string; techStack: string[] } {
+        let name = path.basename(projectPath);
+        let description = '';
+        const techStack: string[] = [];
+
+        // Check package.json (Node.js)
+        const packageJsonPath = path.join(projectPath, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                name = pkg.name || name;
+                description = pkg.description || '';
+                techStack.push('Node.js');
+                
+                // Detect frameworks from dependencies
+                const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                if (deps.express) techStack.push('Express');
+                if (deps.react) techStack.push('React');
+                if (deps.vue) techStack.push('Vue');
+                if (deps.next) techStack.push('Next.js');
+                if (deps.typescript) techStack.push('TypeScript');
+                if (deps.sqlite3 || deps['better-sqlite3']) techStack.push('SQLite');
+                if (deps.stripe) techStack.push('Stripe');
+            } catch (e) {
+                // Ignore parse errors
+            }
+        }
+
+        // Check requirements.txt (Python)
+        const requirementsPath = path.join(projectPath, 'requirements.txt');
+        if (fs.existsSync(requirementsPath)) {
+            techStack.push('Python');
+            const content = fs.readFileSync(requirementsPath, 'utf8').toLowerCase();
+            if (content.includes('flask')) techStack.push('Flask');
+            if (content.includes('django')) techStack.push('Django');
+            if (content.includes('fastapi')) techStack.push('FastAPI');
+            if (content.includes('torch') || content.includes('pytorch')) techStack.push('PyTorch');
+            if (content.includes('tensorflow')) techStack.push('TensorFlow');
+        }
+
+        // Check Cargo.toml (Rust)
+        if (fs.existsSync(path.join(projectPath, 'Cargo.toml'))) {
+            techStack.push('Rust');
+        }
+
+        // Check go.mod (Go)
+        if (fs.existsSync(path.join(projectPath, 'go.mod'))) {
+            techStack.push('Go');
+        }
+
+        return { name, description, techStack: [...new Set(techStack)] };
+    }
+
+    /**
+     * Create a zip archive of a project
+     */
+    private async createProjectArchive(projectPath: string): Promise<string> {
+        const tempDir = path.join(require('os').tmpdir(), 'vigthoria-cli');
+        if (!fs.existsSync(tempDir)) {
+            fs.mkdirSync(tempDir, { recursive: true });
+        }
+
+        const archivePath = path.join(tempDir, `project-${Date.now()}.zip`);
+        const output = createWriteStream(archivePath);
+        const archive = archiver('zip', { zlib: { level: 9 } });
+
+        return new Promise((resolve, reject) => {
+            output.on('close', () => resolve(archivePath));
+            archive.on('error', (err) => reject(err));
+
+            archive.pipe(output);
+
+            // Ignore patterns
+            const ignorePatterns = [
+                'node_modules/**',
+                '.git/**',
+                'dist/**',
+                'build/**',
+                '__pycache__/**',
+                '.venv/**',
+                'venv/**',
+                '*.log',
+                '.env',
+                '.DS_Store'
+            ];
+
+            archive.glob('**/*', {
+                cwd: projectPath,
+                ignore: ignorePatterns,
+                dot: true
+            });
+
+            archive.finalize();
+        });
+    }
+
+    /**
+     * Push a project to Vigthoria Repository
+     */
+    async push(options: PushOptions = {}): Promise<void> {
+        this.requireAuth();
+
+        const projectPath = options.path ? path.resolve(options.path) : process.cwd();
+        
+        if (!fs.existsSync(projectPath)) {
+            console.log(chalk.red(`\n❌ Path does not exist: ${projectPath}\n`));
+            return;
+        }
+
+        const spinner = ora('Analyzing project...').start();
+
+        try {
+            const projectInfo = this.detectProjectInfo(projectPath);
+            spinner.succeed(`Project detected: ${chalk.cyan(projectInfo.name)}`);
+
+            console.log(chalk.gray(`\n  📁 Path: ${projectPath}`));
+            console.log(chalk.gray(`  📝 Description: ${projectInfo.description || '(none)'}`));
+            console.log(chalk.gray(`  🔧 Tech Stack: ${projectInfo.techStack.join(', ') || 'Unknown'}`));
+            console.log();
+
+            // Ask for confirmation and additional info
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Project name:',
+                    default: projectInfo.name
+                },
+                {
+                    type: 'input',
+                    name: 'description',
+                    message: 'Description:',
+                    default: options.description || projectInfo.description
+                },
+                {
+                    type: 'list',
+                    name: 'visibility',
+                    message: 'Visibility:',
+                    choices: [
+                        { name: 'Private - Only you can access', value: 'private' },
+                        { name: 'Restricted - Invite only', value: 'restricted' },
+                        { name: 'Public - Anyone can view', value: 'public' }
+                    ],
+                    default: options.visibility || 'private'
+                },
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Push project to Vigthoria Repo?',
+                    default: true
+                }
+            ]);
+
+            if (!answers.confirm) {
+                console.log(chalk.yellow('\n⚠️  Push cancelled.\n'));
+                return;
+            }
+
+            const uploadSpinner = ora('Creating project archive...').start();
+
+            // Create archive
+            const archivePath = await this.createProjectArchive(projectPath);
+            uploadSpinner.text = 'Uploading to Vigthoria Repo...';
+
+            // First, register/update the project
+            const registerResponse = await fetch(`${this.apiBase}/api/repo/push`, {
+                method: 'POST',
+                headers: this.getAuthHeaders(),
+                body: JSON.stringify({
+                    projectName: answers.name,
+                    projectPath: projectPath,
+                    description: answers.description,
+                    techStack: projectInfo.techStack.join(', '),
+                    visibility: answers.visibility,
+                    force: options.force || false
+                })
+            });
+
+            if (!registerResponse.ok) {
+                const error = await registerResponse.json() as { error?: string };
+                throw new Error(error.error || 'Failed to register project');
+            }
+
+            const registerData = await registerResponse.json() as { 
+                success: boolean; 
+                project: Project;
+                uploadUrl?: string;
+            };
+
+            // Upload the archive if there's an upload URL
+            if (registerData.uploadUrl) {
+                const archiveBuffer = fs.readFileSync(archivePath);
+                const uploadResponse = await fetch(registerData.uploadUrl, {
+                    method: 'PUT',
+                    headers: {
+                        ...this.getAuthHeaders(),
+                        'Content-Type': 'application/zip'
+                    },
+                    body: archiveBuffer
+                });
+
+                if (!uploadResponse.ok) {
+                    throw new Error('Failed to upload project archive');
+                }
+            }
+
+            // Clean up temp archive
+            fs.unlinkSync(archivePath);
+
+            uploadSpinner.succeed(chalk.green('Project pushed successfully!'));
+
+            console.log(chalk.cyan('\n📦 Project Details:'));
+            console.log(chalk.gray(`   Name: ${registerData.project.project_name}`));
+            console.log(chalk.gray(`   Visibility: ${registerData.project.visibility}`));
+            console.log(chalk.gray(`   ID: ${registerData.project.id}`));
+            
+            if (registerData.project.visibility === 'public') {
+                console.log(chalk.cyan(`\n🔗 Public URL: https://coder.vigthoria.io/preview/${registerData.project.id}`));
+            }
+            
+            console.log(chalk.gray('\nTip: Use `vigthoria repo pull <name>` to restore this project anywhere.\n'));
+
+        } catch (error) {
+            spinner.fail('Push failed');
+            const errMsg = error instanceof Error ? error.message : 'Unknown error';
+            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+        }
+    }
+
+    /**
+     * Pull a project from Vigthoria Repository
+     */
+    async pull(projectName: string, options: PullOptions = {}): Promise<void> {
+        this.requireAuth();
+
+        const spinner = ora(`Fetching project: ${projectName}...`).start();
+
+        try {
+            const response = await fetch(`${this.apiBase}/api/repo/pull/${encodeURIComponent(projectName)}`, {
+                method: 'GET',
+                headers: this.getAuthHeaders()
+            });
+
+            if (!response.ok) {
+                const error = await response.json() as { error?: string };
+                throw new Error(error.error || 'Project not found');
+            }
+
+            const data = await response.json() as { 
+                success: boolean; 
+                project: Project;
+                downloadUrl?: string;
+                files?: Array<{ path: string; content: string }>;
+            };
+
+            spinner.succeed(`Found project: ${chalk.cyan(data.project.project_name)}`);
+
+            const outputPath = options.output 
+                ? path.resolve(options.output)
+                : path.join(process.cwd(), data.project.project_name);
+
+            if (fs.existsSync(outputPath) && !options.force) {
+                const { overwrite } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: `Directory ${outputPath} exists. Overwrite?`,
+                    default: false
+                }]);
+
+                if (!overwrite) {
+                    console.log(chalk.yellow('\n⚠️  Pull cancelled.\n'));
+                    return;
+                }
+            }
+
+            const downloadSpinner = ora('Downloading project files...').start();
+
+            // Create output directory
+            fs.mkdirSync(outputPath, { recursive: true });
+
+            // If we have a download URL, fetch and extract
+            if (data.downloadUrl) {
+                const archiveResponse = await fetch(data.downloadUrl, {
+                    headers: this.getAuthHeaders()
+                });
+
+                if (!archiveResponse.ok) {
+                    throw new Error('Failed to download project archive');
+                }
+
+                // Save and extract the archive
+                const tempArchive = path.join(require('os').tmpdir(), `vigthoria-pull-${Date.now()}.zip`);
+                const archiveBuffer = Buffer.from(await archiveResponse.arrayBuffer());
+                fs.writeFileSync(tempArchive, archiveBuffer);
+
+                // Extract using unzip command or adm-zip
+                const { execSync } = await import('child_process');
+                execSync(`unzip -o "${tempArchive}" -d "${outputPath}"`, { stdio: 'ignore' });
+                fs.unlinkSync(tempArchive);
+            } else if (data.files) {
+                // If we have files inline (small projects)
+                for (const file of data.files) {
+                    const filePath = path.join(outputPath, file.path);
+                    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                    fs.writeFileSync(filePath, file.content);
+                }
+            }
+
+            downloadSpinner.succeed(chalk.green('Project pulled successfully!'));
+
+            console.log(chalk.cyan('\n📁 Project extracted to:'));
+            console.log(chalk.white(`   ${outputPath}`));
+            console.log(chalk.gray(`\n   Tech Stack: ${data.project.tech_stack || 'Unknown'}`));
+            console.log(chalk.gray(`   Description: ${data.project.description || '(none)'}`));
+            console.log();
+
+        } catch (error) {
+            spinner.fail('Pull failed');
+            const errMsg = error instanceof Error ? error.message : 'Unknown error';
+            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+        }
+    }
+
+    /**
+     * List all projects in user's Vigthoria Repository
+     */
+    async list(options: ListOptions = {}): Promise<void> {
+        this.requireAuth();
+
+        const spinner = ora('Fetching your projects...').start();
+
+        try {
+            let url = `${this.apiBase}/api/repo/projects`;
+            if (options.visibility) {
+                url += `?visibility=${options.visibility}`;
+            }
+
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: this.getAuthHeaders()
+            });
+
+            if (!response.ok) {
+                throw new Error('Failed to fetch projects');
+            }
+
+            const data = await response.json() as { 
+                success: boolean; 
+                projects: Project[];
+                total: number;
+            };
+
+            spinner.stop();
+
+            if (data.projects.length === 0) {
+                console.log(chalk.yellow('\n📦 No projects in your Vigthoria Repo yet.\n'));
+                console.log(chalk.gray('Use `vigthoria repo push` to upload your first project.\n'));
+                return;
+            }
+
+            console.log(chalk.cyan(`\n📦 Your Vigthoria Repository (${data.total} project${data.total !== 1 ? 's' : ''})\n`));
+
+            // Group by visibility
+            const grouped = data.projects.reduce((acc: Record<string, Project[]>, project) => {
+                const vis = project.visibility || 'private';
+                if (!acc[vis]) acc[vis] = [];
+                acc[vis].push(project);
+                return acc;
+            }, {});
+
+            const visibilityOrder = ['private', 'restricted', 'public'];
+            const visibilityIcons: Record<string, string> = {
+                private: '🔒',
+                restricted: '👥',
+                public: '🌍'
+            };
+
+            visibilityOrder.forEach(vis => {
+                const projects = grouped[vis];
+                if (!projects || projects.length === 0) return;
+
+                console.log(chalk.bold.white(`  ${visibilityIcons[vis]} ${vis.toUpperCase()}`));
+                console.log(chalk.gray('  ' + '─'.repeat(50)));
+
+                projects.forEach((project) => {
+                    const syncStatus = project.last_synced_at 
+                        ? chalk.green('✓ synced')
+                        : chalk.yellow('○ not synced');
+                    
+                    console.log(chalk.white(`  ${project.project_name.padEnd(30)} ${syncStatus}`));
+                    if (project.description) {
+                        console.log(chalk.gray(`     ${project.description.substring(0, 50)}${project.description.length > 50 ? '...' : ''}`));
+                    }
+                    console.log(chalk.gray(`     Tech: ${project.tech_stack || 'Unknown'}`));
+                    console.log(chalk.gray(`     Updated: ${new Date(project.updated_at).toLocaleDateString()}`));
+                    console.log();
+                });
+            });
+
+            console.log(chalk.gray('─'.repeat(60)));
+            console.log(chalk.cyan('\nCommands:'));
+            console.log(chalk.gray('  vigthoria repo pull <name>     - Download a project'));
+            console.log(chalk.gray('  vigthoria repo push            - Upload current directory'));
+            console.log(chalk.gray('  vigthoria repo status          - Check sync status'));
+            console.log(chalk.gray('  vigthoria repo share <name>    - Share a project\n'));
+
+        } catch (error) {
+            spinner.fail('List failed');
+            const errMsg = error instanceof Error ? error.message : 'Unknown error';
+            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+        }
+    }
+
+    /**
+     * Show sync status of current project
+     */
+    async status(): Promise<void> {
+        this.requireAuth();
+
+        const projectPath = process.cwd();
+        const projectInfo = this.detectProjectInfo(projectPath);
+
+        const spinner = ora('Checking sync status...').start();
+
+        try {
+            const response = await fetch(`${this.apiBase}/api/repo/status/${encodeURIComponent(projectInfo.name)}`, {
+                method: 'GET',
+                headers: this.getAuthHeaders()
+            });
+
+            if (!response.ok) {
+                spinner.succeed('Project not tracked in Vigthoria Repo');
+                console.log(chalk.yellow('\n📦 Current project is not synced with Vigthoria Repo.\n'));
+                console.log(chalk.gray('Use `vigthoria repo push` to upload it.\n'));
+                return;
+            }
+
+            const data = await response.json() as { 
+                success: boolean; 
+                project: Project;
+                syncStatus: 'synced' | 'ahead' | 'behind' | 'diverged';
+                localChanges?: number;
+            };
+
+            spinner.stop();
+
+            const statusIcons: Record<string, string> = {
+                synced: '✅',
+                ahead: '⬆️',
+                behind: '⬇️',
+                diverged: '⚠️'
+            };
+
+            console.log(chalk.cyan(`\n📦 Project: ${chalk.white(data.project.project_name)}\n`));
+            console.log(chalk.gray(`  Path: ${projectPath}`));
+            console.log(chalk.gray(`  Visibility: ${data.project.visibility}`));
+            console.log(chalk.gray(`  Tech Stack: ${data.project.tech_stack || 'Unknown'}`));
+            console.log();
+            console.log(`  Status: ${statusIcons[data.syncStatus]} ${data.syncStatus.toUpperCase()}`);
+            
+            if (data.localChanges && data.localChanges > 0) {
+                console.log(chalk.yellow(`  Local changes: ${data.localChanges} file(s) modified`));
+            }
+            
+            console.log(chalk.gray(`\n  Last synced: ${data.project.last_synced_at 
+                ? new Date(data.project.last_synced_at).toLocaleString() 
+                : 'Never'}`));
+            console.log();
+
+            if (data.syncStatus === 'ahead' || data.syncStatus === 'diverged') {
+                console.log(chalk.cyan('Tip: Use `vigthoria repo push` to sync changes.\n'));
+            }
+
+        } catch (error) {
+            spinner.fail('Status check failed');
+            const errMsg = error instanceof Error ? error.message : 'Unknown error';
+            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+        }
+    }
+
+    /**
+     * Generate a shareable link for a project
+     */
+    async share(projectName: string, options: ShareOptions = {}): Promise<void> {
+        this.requireAuth();
+
+        const spinner = ora('Generating share link...').start();
+
+        try {
+            const response = await fetch(`${this.apiBase}/api/repo/share`, {
+                method: 'POST',
+                headers: this.getAuthHeaders(),
+                body: JSON.stringify({
+                    projectName,
+                    expiresIn: options.expires || '7d'
+                })
+            });
+
+            if (!response.ok) {
+                const error = await response.json() as { error?: string };
+                throw new Error(error.error || 'Failed to generate share link');
+            }
+
+            const data = await response.json() as { 
+                success: boolean; 
+                shareUrl: string;
+                expiresAt: string;
+            };
+
+            spinner.succeed(chalk.green('Share link generated!'));
+
+            console.log(chalk.cyan('\n🔗 Share Link:'));
+            console.log(chalk.white(`   ${data.shareUrl}`));
+            console.log(chalk.gray(`\n   Expires: ${new Date(data.expiresAt).toLocaleString()}`));
+            console.log(chalk.gray('\n   Anyone with this link can view/download the project.\n'));
+
+        } catch (error) {
+            spinner.fail('Share failed');
+            const errMsg = error instanceof Error ? error.message : 'Unknown error';
+            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+        }
+    }
+
+    /**
+     * Delete a project from Vigthoria Repository
+     */
+    async delete(projectName: string): Promise<void> {
+        this.requireAuth();
+
+        const { confirm } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: chalk.red(`Are you sure you want to delete "${projectName}" from Vigthoria Repo?`),
+            default: false
+        }]);
+
+        if (!confirm) {
+            console.log(chalk.yellow('\n⚠️  Delete cancelled.\n'));
+            return;
+        }
+
+        const spinner = ora('Deleting project...').start();
+
+        try {
+            const response = await fetch(`${this.apiBase}/api/repo/projects/${encodeURIComponent(projectName)}`, {
+                method: 'DELETE',
+                headers: this.getAuthHeaders()
+            });
+
+            if (!response.ok) {
+                const error = await response.json() as { error?: string };
+                throw new Error(error.error || 'Failed to delete project');
+            }
+
+            spinner.succeed(chalk.green('Project deleted from Vigthoria Repo'));
+            console.log(chalk.gray('\nNote: Your local files are not affected.\n'));
+
+        } catch (error) {
+            spinner.fail('Delete failed');
+            const errMsg = error instanceof Error ? error.message : 'Unknown error';
+            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+        }
+    }
+
+    /**
+     * Clone a public project from Vigthoria Repository
+     */
+    async clone(projectUrl: string, options: PullOptions = {}): Promise<void> {
+        // Parse project URL or name
+        const projectIdMatch = projectUrl.match(/preview\/(\d+)/);
+        const projectId = projectIdMatch ? projectIdMatch[1] : projectUrl;
+
+        const spinner = ora(`Cloning project...`).start();
+
+        try {
+            const response = await fetch(`${this.apiBase}/api/repo/clone/${projectId}`, {
+                method: 'GET',
+                headers: this.isAuthenticated() ? this.getAuthHeaders() : { 'Content-Type': 'application/json' }
+            });
+
+            if (!response.ok) {
+                const error = await response.json() as { error?: string };
+                throw new Error(error.error || 'Project not found or not public');
+            }
+
+            const data = await response.json() as { 
+                success: boolean; 
+                project: Project;
+                downloadUrl: string;
+            };
+
+            spinner.succeed(`Found project: ${chalk.cyan(data.project.project_name)}`);
+
+            // Use pull logic for the rest
+            await this.pull(data.project.project_name, options);
+
+        } catch (error) {
+            spinner.fail('Clone failed');
+            const errMsg = error instanceof Error ? error.message : 'Unknown error';
+            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+        }
+    }
+}