skillverse 0.1.0

package/server/src/routes/dashboard.ts

@@ -0,0 +1,102 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { prisma } from '../lib/db.js';
+
+const router = Router();
+
+// GET /api/dashboard/stats - Get dashboard statistics
+router.get('/stats', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const [totalSkills, totalWorkspaces, totalLinks, marketplaceSkills, recentSkills] =
+            await Promise.all([
+                prisma.skill.count(),
+                prisma.workspace.count(),
+                prisma.skillWorkspace.count(),
+                prisma.marketplaceSkill.count(),
+                prisma.skill.findMany({
+                    orderBy: { installDate: 'desc' },
+                    take: 5,
+                    include: {
+                        linkedWorkspaces: {
+                            include: {
+                                workspace: true,
+                            },
+                        },
+                    },
+                }),
+            ]);
+
+        res.json({
+            success: true,
+            data: {
+                totalSkills,
+                totalWorkspaces,
+                totalLinks,
+                marketplaceSkills,
+                recentSkills,
+            },
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+// GET /api/dashboard/activity - Get recent activity
+router.get('/activity', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const [recentSkills, recentLinks, recentPublished] = await Promise.all([
+            prisma.skill.findMany({
+                orderBy: { createdAt: 'desc' },
+                take: 10,
+                select: {
+                    id: true,
+                    name: true,
+                    source: true,
+                    createdAt: true,
+                },
+            }),
+            prisma.skillWorkspace.findMany({
+                orderBy: { linkedAt: 'desc' },
+                take: 10,
+                include: {
+                    skill: { select: { name: true } },
+                    workspace: { select: { name: true } },
+                },
+            }),
+            prisma.marketplaceSkill.findMany({
+                orderBy: { publishDate: 'desc' },
+                take: 10,
+                include: {
+                    skill: { select: { name: true } },
+                },
+            }),
+        ]);
+
+        // Combine and sort by date
+        const activities = [
+            ...recentSkills.map((s) => ({
+                type: 'skill_added' as const,
+                date: s.createdAt,
+                data: { skillName: s.name, source: s.source },
+            })),
+            ...recentLinks.map((l) => ({
+                type: 'skill_linked' as const,
+                date: l.linkedAt,
+                data: { skillName: l.skill.name, workspaceName: l.workspace.name },
+            })),
+            ...recentPublished.map((p) => ({
+                type: 'skill_published' as const,
+                date: p.publishDate,
+                data: { skillName: p.skill.name },
+            })),
+        ].sort((a, b) => b.date.getTime() - a.date.getTime());
+
+        res.json({
+            success: true,
+            data: activities.slice(0, 20),
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+export default router;

package/server/src/routes/marketplace.ts

@@ -0,0 +1,273 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { prisma } from '../lib/db.js';
+import { skillService } from '../services/skillService.js';
+import { bundleService } from '../services/bundleService.js';
+import { AppError } from '../middleware/errorHandler.js';
+import { ErrorCode } from '@skillverse/shared';
+import { existsSync } from 'fs';
+
+const router = Router();
+
+// GET /api/marketplace/skills - Get all marketplace skills
+router.get('/skills', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const { search, page = '1', pageSize = '20' } = req.query;
+
+        const where: any = {};
+        if (search) {
+            where.skill = {
+                OR: [
+                    { name: { contains: search as string } },
+                    { description: { contains: search as string } },
+                ],
+            };
+        }
+
+        const [items, total] = await Promise.all([
+            prisma.marketplaceSkill.findMany({
+                where,
+                include: {
+                    skill: true,
+                },
+                orderBy: {
+                    downloads: 'desc',
+                },
+                skip: (parseInt(page as string) - 1) * parseInt(pageSize as string),
+                take: parseInt(pageSize as string),
+            }),
+            prisma.marketplaceSkill.count({ where }),
+        ]);
+
+        res.json({
+            success: true,
+            data: {
+                items,
+                total,
+                page: parseInt(page as string),
+                pageSize: parseInt(pageSize as string),
+            },
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+// GET /api/marketplace/skills/:id - Get marketplace skill by ID
+router.get('/skills/:id', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const marketplaceSkill = await prisma.marketplaceSkill.findUnique({
+            where: { id: req.params.id },
+            include: {
+                skill: true,
+            },
+        });
+
+        if (!marketplaceSkill) {
+            throw new AppError(ErrorCode.NOT_FOUND, 'Marketplace skill not found', 404);
+        }
+
+        res.json({
+            success: true,
+            data: marketplaceSkill,
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+// GET /api/marketplace/download/:id - Download skill bundle
+router.get('/download/:id', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const marketplaceSkill = await prisma.marketplaceSkill.findUnique({
+            where: { id: req.params.id },
+            include: {
+                skill: true,
+            },
+        });
+
+        if (!marketplaceSkill) {
+            throw new AppError(ErrorCode.NOT_FOUND, 'Marketplace skill not found', 404);
+        }
+
+        // For Git skills, redirect to the source URL or return info
+        if (marketplaceSkill.skill.source === 'git' && marketplaceSkill.skill.sourceUrl) {
+            return res.json({
+                success: true,
+                data: {
+                    type: 'git',
+                    sourceUrl: marketplaceSkill.skill.sourceUrl,
+                },
+            });
+        }
+
+        // For bundled skills, serve the bundle file
+        if (marketplaceSkill.bundlePath && existsSync(marketplaceSkill.bundlePath)) {
+            res.setHeader('Content-Type', 'application/gzip');
+            res.setHeader(
+                'Content-Disposition',
+                `attachment; filename="${marketplaceSkill.skill.name}.tar.gz"`
+            );
+            return res.sendFile(marketplaceSkill.bundlePath);
+        }
+
+        throw new AppError(ErrorCode.NOT_FOUND, 'Bundle not available for this skill', 404);
+    } catch (error) {
+        next(error);
+    }
+});
+
+// POST /api/marketplace/publish - Publish skill to marketplace
+router.post('/publish', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const { skillId, publisherName } = req.body;
+
+        if (!skillId) {
+            return res.status(400).json({
+                success: false,
+                error: 'skillId is required',
+            });
+        }
+
+        // Check if skill exists
+        const skill = await prisma.skill.findUnique({
+            where: { id: skillId },
+        });
+
+        if (!skill) {
+            throw new AppError(ErrorCode.NOT_FOUND, 'Skill not found', 404);
+        }
+
+        // Check if already published
+        const existingEntry = await prisma.marketplaceSkill.findUnique({
+            where: { skillId },
+        });
+
+        if (existingEntry) {
+            throw new AppError(ErrorCode.ALREADY_EXISTS, 'Skill is already published to marketplace', 409);
+        }
+
+        // Create bundle for local skills
+        let bundlePath: string | null = null;
+        let bundleSize: number | null = null;
+
+        if (skill.source === 'local' && existsSync(skill.storagePath)) {
+            bundlePath = await bundleService.createBundle(skill.storagePath, skill.name);
+            bundleSize = await bundleService.getBundleSize(bundlePath);
+        }
+
+        // Create marketplace entry
+        const marketplaceSkill = await prisma.marketplaceSkill.create({
+            data: {
+                skillId,
+                publisherName: publisherName || 'Anonymous',
+                bundlePath,
+                bundleSize,
+            },
+            include: {
+                skill: true,
+            },
+        });
+
+        res.status(201).json({
+            success: true,
+            data: marketplaceSkill,
+            message: 'Skill published to marketplace successfully',
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+
+// POST /api/marketplace/install/:id - Install skill from marketplace
+router.post('/install/:id', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const marketplaceSkill = await prisma.marketplaceSkill.findUnique({
+            where: { id: req.params.id },
+            include: {
+                skill: true,
+            },
+        });
+
+        if (!marketplaceSkill) {
+            throw new AppError(ErrorCode.NOT_FOUND, 'Marketplace skill not found', 404);
+        }
+
+        const sourceSkill = marketplaceSkill.skill;
+
+        // For Git source, clone the repository
+        if (sourceSkill.source === 'git' && sourceSkill.sourceUrl) {
+            const newSkill = await skillService.createSkillFromGit(
+                sourceSkill.sourceUrl,
+                sourceSkill.description || undefined
+            );
+
+            // Increment download count
+            await prisma.marketplaceSkill.update({
+                where: { id: req.params.id },
+                data: { downloads: { increment: 1 } },
+            });
+
+            return res.status(201).json({
+                success: true,
+                data: newSkill,
+                message: 'Skill installed from marketplace successfully',
+            });
+        }
+
+        // For local source with bundle, extract the bundle
+        if (sourceSkill.source === 'local' && marketplaceSkill.bundlePath && existsSync(marketplaceSkill.bundlePath)) {
+            const newSkill = await skillService.createSkillFromBundle(
+                marketplaceSkill.bundlePath,
+                sourceSkill.name,
+                sourceSkill.description || undefined
+            );
+
+            // Increment download count
+            await prisma.marketplaceSkill.update({
+                where: { id: req.params.id },
+                data: { downloads: { increment: 1 } },
+            });
+
+            return res.status(201).json({
+                success: true,
+                data: newSkill,
+                message: 'Skill installed from marketplace successfully',
+            });
+        }
+
+        // No bundle available
+        return res.status(400).json({
+            success: false,
+            error: 'Cannot install this skill. Bundle not available.',
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+// DELETE /api/marketplace/unpublish/:id - Unpublish skill from marketplace
+router.delete('/unpublish/:skillId', async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const marketplaceSkill = await prisma.marketplaceSkill.findUnique({
+            where: { skillId: req.params.skillId },
+        });
+
+        if (!marketplaceSkill) {
+            throw new AppError(ErrorCode.NOT_FOUND, 'Skill is not published to marketplace', 404);
+        }
+
+        await prisma.marketplaceSkill.delete({
+            where: { id: marketplaceSkill.id },
+        });
+
+        res.json({
+            success: true,
+            message: 'Skill unpublished from marketplace successfully',
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+export default router;

package/server/src/routes/skills.ts

@@ -0,0 +1,294 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import multer from 'multer';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { mkdir, rm } from 'fs/promises';
+import { skillService } from '../services/skillService.js';
+import { workspaceService } from '../services/workspaceService.js';
+
+const router = Router();
+
+// Configure multer for file uploads
+const TEMP_DIR = process.env.TEMP_DIR || join(process.env.HOME || '', '.skillverse', 'temp');
+
+// Ensure temp directory exists
+if (!existsSync(TEMP_DIR)) {
+  mkdir(TEMP_DIR, { recursive: true });
+}
+
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    cb(null, TEMP_DIR);
+  },
+  filename: (req, file, cb) => {
+    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1e9);
+    cb(null, uniqueSuffix + '-' + file.originalname);
+  },
+});
+
+const upload = multer({
+  storage,
+  limits: {
+    fileSize: 100 * 1024 * 1024, // 100MB limit
+  },
+  fileFilter: (req, file, cb) => {
+    if (file.mimetype === 'application/zip' || file.originalname.endsWith('.zip')) {
+      cb(null, true);
+    } else {
+      cb(new Error('Only ZIP files are allowed'));
+    }
+  },
+});
+
+// GET /api/skills - Get all skills
+router.get('/', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const skills = await skillService.getAllSkills();
+    res.json({
+      success: true,
+      data: skills,
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+// GET /api/skills/:id - Get skill by ID
+router.get('/:id', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const skill = await skillService.getSkillById(req.params.id);
+    res.json({
+      success: true,
+      data: skill,
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+// POST /api/skills/from-git - Create skill from Git repository
+router.post('/from-git', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { gitUrl, description } = req.body;
+
+    if (!gitUrl) {
+      return res.status(400).json({
+        success: false,
+        error: 'gitUrl is required',
+      });
+    }
+
+    const skill = await skillService.createSkillFromGit(gitUrl, description);
+    res.status(201).json({
+      success: true,
+      data: skill,
+      message: 'Skill created successfully from Git repository',
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+// POST /api/skills/from-local - Create skill from local ZIP file
+router.post(
+  '/from-local',
+  upload.single('file'),
+  async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const { name, description } = req.body;
+      const file = req.file;
+
+      if (!name) {
+        // Clean up uploaded file
+        if (file) {
+          await rm(file.path, { force: true });
+        }
+        return res.status(400).json({
+          success: false,
+          error: 'name is required',
+        });
+      }
+
+      if (!file) {
+        return res.status(400).json({
+          success: false,
+          error: 'ZIP file is required',
+        });
+      }
+
+      const skill = await skillService.createSkillFromLocal(name, file.path, description);
+
+      // Clean up temp file
+      await rm(file.path, { force: true });
+
+      res.status(201).json({
+        success: true,
+        data: skill,
+        message: 'Skill created successfully from local file',
+      });
+    } catch (error) {
+      // Clean up uploaded file on error
+      if (req.file) {
+        await rm(req.file.path, { force: true }).catch(() => { });
+      }
+      next(error);
+    }
+  }
+);
+
+// PUT /api/skills/:id - Update skill
+router.put('/:id', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { name, description, metadata } = req.body;
+    const skill = await skillService.updateSkill(req.params.id, {
+      name,
+      description,
+      metadata,
+    });
+    res.json({
+      success: true,
+      data: skill,
+      message: 'Skill updated successfully',
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+// DELETE /api/skills/:id - Delete skill
+router.delete('/:id', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const removeFiles = req.query.removeFiles !== 'false';
+    const result = await skillService.deleteSkill(req.params.id, removeFiles);
+    res.json(result);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// POST /api/skills/:id/link - Link skill to workspace
+router.post('/:id/link', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { workspaceId } = req.body;
+
+    if (!workspaceId) {
+      return res.status(400).json({
+        success: false,
+        error: 'workspaceId is required',
+      });
+    }
+
+    const link = await workspaceService.linkSkillToWorkspace(req.params.id, workspaceId);
+    res.status(201).json({
+      success: true,
+      data: link,
+      message: 'Skill linked to workspace successfully',
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+// DELETE /api/skills/:id/unlink/:workspaceId - Unlink skill from workspace
+router.delete(
+  '/:id/unlink/:workspaceId',
+  async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const result = await workspaceService.unlinkSkillFromWorkspace(
+        req.params.id,
+        req.params.workspaceId
+      );
+      res.json(result);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+// GET /api/skills/:id/check-update - Check for updates
+router.get('/:id/check-update', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const result = await skillService.checkForUpdate(req.params.id);
+    res.json({
+      success: true,
+      data: result,
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+// POST /api/skills/:id/upgrade - Upgrade skill
+router.post('/:id/upgrade', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const skill = await skillService.upgradeSkill(req.params.id);
+    res.json({
+      success: true,
+      data: skill,
+      message: 'Skill upgraded successfully',
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+// POST /api/skills/check-updates - Check for updates for multiple skills
+router.post('/check-updates', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { ids } = req.body; // Optional: ids array to check specific skills
+    const results = await skillService.checkUpdates(ids);
+    res.json({
+      success: true,
+      data: results,
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+// POST /api/skills/:id/refresh-metadata - Refresh skill metadata
+router.post('/:id/refresh-metadata', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const skill = await skillService.refreshMetadata(req.params.id);
+    res.json({
+      success: true,
+      data: skill,
+      message: 'Metadata refreshed successfully',
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+// GET /api/skills/:id/skill-md - Get SKILL.md content for preview
+router.get('/:id/skill-md', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { readFile } = await import('fs/promises');
+    const skill = await skillService.getSkillById(req.params.id);
+    const skillMdPath = join(skill.storagePath, 'SKILL.md');
+
+    if (!existsSync(skillMdPath)) {
+      return res.json({
+        success: true,
+        data: {
+          exists: false,
+          content: null,
+        },
+      });
+    }
+
+    const content = await readFile(skillMdPath, 'utf-8');
+    res.json({
+      success: true,
+      data: {
+        exists: true,
+        content,
+      },
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+export default router;
+