skillverse 0.1.0

package/server/src/routes/workspaces.ts

@@ -0,0 +1,168 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { workspaceService } from '../services/workspaceService.js';
+import { WorkspaceType, WorkspaceScope } from '@skillverse/shared';
+
+const router = Router();
+
+// GET /api/workspaces - Get all workspaces
+router.get('/', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const workspaces = await workspaceService.getAllWorkspaces();
+        res.json({
+            success: true,
+            data: workspaces,
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+// GET /api/workspaces/:id - Get workspace by ID
+router.get('/:id', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const workspace = await workspaceService.getWorkspaceById(req.params.id);
+        res.json({
+            success: true,
+            data: workspace,
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+// POST /api/workspaces - Create workspace
+router.post('/', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const { name, projectPath, type, scope } = req.body;
+
+        if (!name || !type || !scope) {
+            return res.status(400).json({
+                success: false,
+                error: 'name, type, and scope are required',
+            });
+        }
+
+        // For project scope, projectPath is required
+        if (scope === 'project' && !projectPath) {
+            return res.status(400).json({
+                success: false,
+                error: 'projectPath is required for project scope',
+            });
+        }
+
+        const validTypes: WorkspaceType[] = ['vscode', 'cursor', 'claude-desktop', 'codex', 'antigravity', 'custom'];
+        if (!validTypes.includes(type)) {
+            return res.status(400).json({
+                success: false,
+                error: `type must be one of: ${validTypes.join(', ')}`,
+            });
+        }
+
+        const validScopes: WorkspaceScope[] = ['project', 'global'];
+        if (!validScopes.includes(scope)) {
+            return res.status(400).json({
+                success: false,
+                error: `scope must be one of: ${validScopes.join(', ')}`,
+            });
+        }
+
+        const workspace = await workspaceService.createWorkspace(name, projectPath || '', type, scope);
+        res.status(201).json({
+            success: true,
+            data: workspace,
+            message: 'Workspace created successfully',
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+// PUT /api/workspaces/:id - Update workspace
+router.put('/:id', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const { name, path, type, scope } = req.body;
+
+        if (type) {
+            const validTypes: WorkspaceType[] = ['vscode', 'cursor', 'claude-desktop', 'codex', 'antigravity', 'custom'];
+            if (!validTypes.includes(type)) {
+                return res.status(400).json({
+                    success: false,
+                    error: `type must be one of: ${validTypes.join(', ')}`,
+                });
+            }
+        }
+
+        if (scope) {
+            const validScopes: WorkspaceScope[] = ['project', 'global'];
+            if (!validScopes.includes(scope)) {
+                return res.status(400).json({
+                    success: false,
+                    error: `scope must be one of: ${validScopes.join(', ')}`,
+                });
+            }
+        }
+
+        const workspace = await workspaceService.updateWorkspace(req.params.id, {
+            name,
+            path,
+            type,
+            scope,
+        });
+        res.json({
+            success: true,
+            data: workspace,
+            message: 'Workspace updated successfully',
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+// DELETE /api/workspaces/:id - Delete workspace
+router.delete('/:id', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const result = await workspaceService.deleteWorkspace(req.params.id);
+        res.json(result);
+    } catch (error) {
+        next(error);
+    }
+});
+
+// POST /api/workspaces/:id/detect-skills - Detect existing skills in workspace
+router.post('/:id/detect-skills', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const workspace = await workspaceService.getWorkspaceById(req.params.id);
+        const existingSkills = await workspaceService.detectExistingSkills(workspace.path);
+        res.json({
+            success: true,
+            data: existingSkills,
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+// POST /api/workspaces/:id/migrate-skills - Migrate existing skills to unified storage
+router.post('/:id/migrate-skills', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const { skillNames } = req.body;
+
+        if (!skillNames || !Array.isArray(skillNames) || skillNames.length === 0) {
+            return res.status(400).json({
+                success: false,
+                error: 'skillNames array is required',
+            });
+        }
+
+        const result = await workspaceService.migrateExistingSkills(req.params.id, skillNames);
+        res.json({
+            success: true,
+            data: result,
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+export default router;
+

package/server/src/services/bundleService.ts

@@ -0,0 +1,123 @@
+import { createWriteStream, existsSync, createReadStream } from 'fs';
+import { mkdir, rm, readdir, stat } from 'fs/promises';
+import { join, basename } from 'path';
+import { pipeline } from 'stream/promises';
+import archiver from 'archiver';
+import { createGunzip } from 'zlib';
+import { extract } from 'tar';
+
+const BUNDLES_DIR = join(
+    process.env.SKILLVERSE_HOME || join(process.env.HOME || '', '.skillverse'),
+    'bundles'
+);
+
+/**
+ * Ensures the bundles directory exists
+ */
+async function ensureBundlesDir(): Promise<void> {
+    if (!existsSync(BUNDLES_DIR)) {
+        await mkdir(BUNDLES_DIR, { recursive: true });
+    }
+}
+
+/**
+ * Creates a .tar.gz bundle from a skill directory
+ * @param skillPath - Path to the skill directory
+ * @param skillName - Name of the skill (used for bundle filename)
+ * @returns Path to the created bundle
+ */
+export async function createBundle(skillPath: string, skillName: string): Promise<string> {
+    await ensureBundlesDir();
+
+    const bundleName = `${skillName}-${Date.now()}.tar.gz`;
+    const bundlePath = join(BUNDLES_DIR, bundleName);
+
+    return new Promise((resolve, reject) => {
+        const output = createWriteStream(bundlePath);
+        const archive = archiver('tar', {
+            gzip: true,
+            gzipOptions: { level: 9 },
+        });
+
+        output.on('close', () => {
+            console.log(`📦 Bundle created: ${bundlePath} (${archive.pointer()} bytes)`);
+            resolve(bundlePath);
+        });
+
+        archive.on('error', (err) => {
+            reject(err);
+        });
+
+        archive.pipe(output);
+
+        // Add all files from the skill directory
+        archive.directory(skillPath, false);
+
+        archive.finalize();
+    });
+}
+
+/**
+ * Extracts a bundle to a target directory
+ * @param bundlePath - Path to the .tar.gz bundle
+ * @param targetDir - Directory to extract to
+ */
+export async function extractBundle(bundlePath: string, targetDir: string): Promise<void> {
+    if (!existsSync(bundlePath)) {
+        throw new Error(`Bundle not found: ${bundlePath}`);
+    }
+
+    // Create target directory if it doesn't exist
+    if (!existsSync(targetDir)) {
+        await mkdir(targetDir, { recursive: true });
+    }
+
+    await pipeline(
+        createReadStream(bundlePath),
+        createGunzip(),
+        extract({ cwd: targetDir })
+    );
+
+    console.log(`📂 Bundle extracted to: ${targetDir}`);
+}
+
+/**
+ * Deletes a bundle file
+ * @param bundlePath - Path to the bundle to delete
+ */
+export async function deleteBundle(bundlePath: string): Promise<void> {
+    if (existsSync(bundlePath)) {
+        await rm(bundlePath);
+        console.log(`🗑️ Bundle deleted: ${bundlePath}`);
+    }
+}
+
+/**
+ * Gets the size of a bundle in bytes
+ * @param bundlePath - Path to the bundle
+ */
+export async function getBundleSize(bundlePath: string): Promise<number> {
+    if (!existsSync(bundlePath)) {
+        return 0;
+    }
+    const stats = await stat(bundlePath);
+    return stats.size;
+}
+
+/**
+ * Lists all bundles in the bundles directory
+ */
+export async function listBundles(): Promise<string[]> {
+    await ensureBundlesDir();
+    const files = await readdir(BUNDLES_DIR);
+    return files.filter((f) => f.endsWith('.tar.gz')).map((f) => join(BUNDLES_DIR, f));
+}
+
+export const bundleService = {
+    createBundle,
+    extractBundle,
+    deleteBundle,
+    getBundleSize,
+    listBundles,
+    BUNDLES_DIR,
+};