skillverse 0.1.0

package/server/src/services/workspaceService.ts

@@ -0,0 +1,521 @@
+import { join } from 'path';
+import { homedir } from 'os';
+import { symlink, unlink, rm, mkdir, appendFile, readFile } from 'fs/promises';
+import { existsSync, lstatSync } from 'fs';
+import { prisma } from '../lib/db.js';
+import { AppError } from '../middleware/errorHandler.js';
+import { ErrorCode, WorkspaceType, WorkspaceScope, WORKSPACE_SKILLS_PATHS } from '@skillverse/shared';
+
+/**
+ * Compute the final skills path based on project path, type, and scope
+ */
+function computeSkillsPath(projectPath: string, type: WorkspaceType, scope: WorkspaceScope): string {
+  const pathConfig = WORKSPACE_SKILLS_PATHS[type];
+
+  if (scope === 'global') {
+    // Global path: replace ~ with actual home directory
+    return pathConfig.global.replace('~', homedir());
+  }
+
+  // Project path = projectPath + sub-directory
+  return join(projectPath, pathConfig.project);
+}
+
+export class WorkspaceService {
+  /**
+   * Helper to get expected skills path for a project
+   */
+  getSkillsPath(projectPath: string, type: WorkspaceType, scope: WorkspaceScope): string {
+    return computeSkillsPath(projectPath, type, scope);
+  }
+
+  /**
+   * Sync database links with filesystem state
+   * Removes links from DB if the symlink is missing from the workspace
+   */
+  private async syncLinks(workspace: any) {
+    if (!workspace.linkedSkills || workspace.linkedSkills.length === 0) return;
+
+    for (const link of workspace.linkedSkills) {
+      if (!link.skill) continue;
+
+      const linkPath = join(workspace.path, link.skill.name);
+
+      // Check if symlink exists
+      if (!existsSync(linkPath)) {
+        console.log(`Link missing for skill "${link.skill.name}" in workspace "${workspace.name}". Removing from DB.`);
+        try {
+          await prisma.skillWorkspace.delete({
+            where: { id: link.id },
+          });
+          // Update the in-memory object so the returned response is correct
+          workspace.linkedSkills = workspace.linkedSkills.filter((l: any) => l.id !== link.id);
+        } catch (err) {
+          console.error(`Failed to sync link for ${link.skill.name}:`, err);
+        }
+      }
+    }
+  }
+
+  async findWorkspaceByPath(path: string) {
+    const workspace = await prisma.workspace.findUnique({
+      where: { path },
+      include: {
+        linkedSkills: {
+          include: {
+            skill: true,
+          },
+        },
+      },
+    });
+    return workspace;
+  }
+
+  async getAllWorkspaces() {
+    const workspaces = await prisma.workspace.findMany({
+      include: {
+        linkedSkills: {
+          include: {
+            skill: true,
+          },
+        },
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+    });
+
+    // Sync links for all workspaces (in parallel)
+    await Promise.all(workspaces.map(w => this.syncLinks(w)));
+
+    // Add isPathValid status for each workspace
+    return workspaces.map(workspace => ({
+      ...workspace,
+      isPathValid: existsSync(workspace.path),
+    }));
+  }
+
+  async getWorkspaceById(id: string) {
+    const workspace = await prisma.workspace.findUnique({
+      where: { id },
+      include: {
+        linkedSkills: {
+          include: {
+            skill: true,
+          },
+        },
+      },
+    });
+
+    if (!workspace) {
+      throw new AppError(ErrorCode.NOT_FOUND, 'Workspace not found', 404);
+    }
+
+    // Sync links with filesystem
+    await this.syncLinks(workspace);
+
+    return {
+      ...workspace,
+      isPathValid: existsSync(workspace.path),
+    };
+  }
+
+  async createWorkspace(name: string, projectPath: string, type: WorkspaceType, scope: WorkspaceScope) {
+    // Compute the final skills path
+    const skillsPath = computeSkillsPath(projectPath, type, scope);
+
+    // For project scope, check if project path exists
+    if (scope === 'project' && projectPath && !existsSync(projectPath)) {
+      throw new AppError(ErrorCode.FILE_SYSTEM_ERROR, `Project path does not exist: ${projectPath}`, 400);
+    }
+
+    // Auto-create skills directory if it doesn't exist
+    if (!existsSync(skillsPath)) {
+      try {
+        await mkdir(skillsPath, { recursive: true });
+      } catch (err: any) {
+        throw new AppError(
+          ErrorCode.FILE_SYSTEM_ERROR,
+          `Failed to create skills directory: ${err.message}`,
+          500
+        );
+      }
+    }
+
+    // Check if workspace already exists at this path
+    const existingWorkspace = await prisma.workspace.findUnique({
+      where: { path: skillsPath },
+    });
+
+    if (existingWorkspace) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, 'Workspace already exists at this path', 409);
+    }
+
+    const workspace = await prisma.workspace.create({
+      data: {
+        name,
+        path: skillsPath,
+        type,
+        scope,
+      },
+    });
+
+    // For project scope, try to add skills directory to .gitignore
+    if (scope === 'project' && projectPath && existsSync(projectPath)) {
+      try {
+        const gitignorePath = join(projectPath, '.gitignore');
+        const relativeSkillsPath = WORKSPACE_SKILLS_PATHS[type].project;
+
+        let shouldAppend = false;
+
+        if (existsSync(gitignorePath)) {
+          const content = await readFile(gitignorePath, 'utf-8');
+          // Check if path is already ignored (simple check)
+          if (!content.includes(relativeSkillsPath)) {
+            shouldAppend = true;
+          }
+        } else {
+          // Create .gitignore if it doesn't exist
+          shouldAppend = true;
+        }
+
+        if (shouldAppend) {
+          const ignoreEntry = `\n\n# SkillVerse\n${relativeSkillsPath}/\n`;
+          await appendFile(gitignorePath, ignoreEntry);
+          console.log(`Added ${relativeSkillsPath}/ to .gitignore in ${projectPath}`);
+        }
+      } catch (err) {
+        // Non-fatal error, just log it
+        console.warn('Failed to update .gitignore:', err);
+      }
+    }
+
+    return {
+      ...workspace,
+      isPathValid: true,
+    };
+  }
+
+  async updateWorkspace(id: string, data: { name?: string; path?: string; type?: WorkspaceType; scope?: WorkspaceScope }) {
+    await this.getWorkspaceById(id);
+
+    const workspace = await prisma.workspace.update({
+      where: { id },
+      data,
+    });
+
+    return {
+      ...workspace,
+      isPathValid: existsSync(workspace.path),
+    };
+  }
+
+  async deleteWorkspace(id: string) {
+    const workspace = await this.getWorkspaceById(id);
+
+    // Remove all symlinks for this workspace
+    const links = await prisma.skillWorkspace.findMany({
+      where: { workspaceId: id },
+      include: { skill: true },
+    });
+
+    for (const link of links) {
+      try {
+        const linkPath = join(workspace.path, link.skill.name);
+        if (existsSync(linkPath)) {
+          await rm(linkPath, { recursive: true, force: true });
+        }
+      } catch (error) {
+        console.error(`Failed to remove symlink for ${link.skill.name}:`, error);
+      }
+    }
+
+    // Delete workspace
+    await prisma.workspace.delete({ where: { id } });
+
+    return { success: true, message: 'Workspace deleted successfully' };
+  }
+
+  async linkSkillToWorkspace(skillId: string, workspaceId: string) {
+    const skill = await prisma.skill.findUnique({ where: { id: skillId } });
+    const workspace = await prisma.workspace.findUnique({ where: { id: workspaceId } });
+
+    if (!skill) {
+      throw new AppError(ErrorCode.NOT_FOUND, 'Skill not found', 404);
+    }
+
+    if (!workspace) {
+      throw new AppError(ErrorCode.NOT_FOUND, 'Workspace not found', 404);
+    }
+
+    // Validate workspace path still exists
+    if (!existsSync(workspace.path)) {
+      throw new AppError(
+        ErrorCode.FILE_SYSTEM_ERROR,
+        `Workspace skills directory does not exist: ${workspace.path}. The folder may have been deleted. Please recreate it or remove this workspace.`,
+        400
+      );
+    }
+
+    // Check if link already exists
+    const existingLink = await prisma.skillWorkspace.findFirst({
+      where: {
+        skillId,
+        workspaceId,
+      },
+    });
+
+    if (existingLink) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, 'Skill is already linked to this workspace', 409);
+    }
+
+    // Create symlink
+    const targetPath = join(workspace.path, skill.name);
+
+    try {
+      // Remove existing file/link if it exists
+      if (existsSync(targetPath)) {
+        const stats = lstatSync(targetPath);
+        if (stats.isSymbolicLink()) {
+          await unlink(targetPath);
+        } else {
+          throw new AppError(
+            ErrorCode.FILE_SYSTEM_ERROR,
+            `A file or directory already exists at ${targetPath}`,
+            409
+          );
+        }
+      }
+
+      // Create symlink
+      await symlink(skill.storagePath, targetPath, 'dir');
+
+      // Record link in database
+      const link = await prisma.skillWorkspace.create({
+        data: {
+          skillId,
+          workspaceId,
+        },
+        include: {
+          skill: true,
+          workspace: true,
+        },
+      });
+
+      return link;
+    } catch (error: any) {
+      if (error instanceof AppError) throw error;
+
+      console.error('Symlink creation error:', error);
+      throw new AppError(
+        ErrorCode.SYMLINK_ERROR,
+        `Failed to create symlink: ${error.message}`,
+        500,
+        error
+      );
+    }
+  }
+
+  async unlinkSkillFromWorkspace(skillId: string, workspaceId: string) {
+    const link = await prisma.skillWorkspace.findFirst({
+      where: {
+        skillId,
+        workspaceId,
+      },
+      include: {
+        skill: true,
+        workspace: true,
+      },
+    });
+
+    if (!link) {
+      throw new AppError(ErrorCode.NOT_FOUND, 'Link not found', 404);
+    }
+
+    // Remove symlink
+    const linkPath = join(link.workspace.path, link.skill.name);
+
+    try {
+      if (existsSync(linkPath)) {
+        await rm(linkPath, { recursive: true, force: true });
+      }
+
+      // Remove link from database
+      await prisma.skillWorkspace.delete({
+        where: { id: link.id },
+      });
+
+      return { success: true, message: 'Skill unlinked successfully' };
+    } catch (error: any) {
+      console.error('Unlink error:', error);
+      throw new AppError(
+        ErrorCode.FILE_SYSTEM_ERROR,
+        `Failed to unlink skill: ${error.message}`,
+        500,
+        error
+      );
+    }
+  }
+
+  /**
+   * Detect existing skills in a workspace skills directory
+   * Returns list of skill names that could be migrated
+   */
+  async detectExistingSkills(skillsPath: string): Promise<{ name: string; hasSkillMd: boolean; path: string }[]> {
+    if (!existsSync(skillsPath)) {
+      return [];
+    }
+
+    const { readdir, stat, readFile } = await import('fs/promises');
+    const items = await readdir(skillsPath);
+    const existingSkills: { name: string; hasSkillMd: boolean; path: string }[] = [];
+
+    for (const item of items) {
+      // Skip hidden files/directories
+      if (item.startsWith('.')) continue;
+
+      const itemPath = join(skillsPath, item);
+      try {
+        const itemStat = await stat(itemPath);
+
+        // Skip symlinks (already linked skills)
+        const lstats = lstatSync(itemPath);
+        if (lstats.isSymbolicLink()) continue;
+
+        if (itemStat.isDirectory()) {
+          // Check if it has SKILL.md or other skill markers
+          const hasSkillMd = existsSync(join(itemPath, 'SKILL.md'));
+          const hasSkillJson = existsSync(join(itemPath, 'skill.json'));
+          const hasPackageJson = existsSync(join(itemPath, 'package.json'));
+
+          if (hasSkillMd || hasSkillJson || hasPackageJson) {
+            existingSkills.push({
+              name: item,
+              hasSkillMd,
+              path: itemPath,
+            });
+          }
+        }
+      } catch (error) {
+        console.warn(`Failed to check ${itemPath}:`, error);
+      }
+    }
+
+    return existingSkills;
+  }
+
+  /**
+   * Migrate existing skills from workspace to unified storage
+   * 1. Move skills to ~/.skillverse/skills/
+   * 2. Register in database
+   * 3. Create symlinks back to workspace
+   */
+  async migrateExistingSkills(workspaceId: string, skillNames: string[]): Promise<{ success: boolean; migrated: string[]; errors: string[] }> {
+    const workspace = await this.getWorkspaceById(workspaceId);
+    const SKILLVERSE_HOME = process.env.SKILLVERSE_HOME || join(homedir(), '.skillverse');
+    const SKILLS_DIR = process.env.SKILLS_DIR || join(SKILLVERSE_HOME, 'skills');
+
+    // Ensure skills directory exists
+    if (!existsSync(SKILLS_DIR)) {
+      await mkdir(SKILLS_DIR, { recursive: true });
+    }
+
+    const { rename, readFile, cp } = await import('fs/promises');
+    const migrated: string[] = [];
+    const errors: string[] = [];
+
+    for (const skillName of skillNames) {
+      const sourcePath = join(workspace.path, skillName);
+      const targetPath = join(SKILLS_DIR, skillName);
+
+      try {
+        // Check if source exists and is not a symlink
+        if (!existsSync(sourcePath)) {
+          errors.push(`${skillName}: Source path not found`);
+          continue;
+        }
+
+        const lstats = lstatSync(sourcePath);
+        if (lstats.isSymbolicLink()) {
+          errors.push(`${skillName}: Already a symlink, skipping`);
+          continue;
+        }
+
+        // Check if skill already exists in unified storage
+        if (existsSync(targetPath)) {
+          // Check if it's the same skill by comparing paths or skip
+          errors.push(`${skillName}: Already exists in unified storage`);
+          continue;
+        }
+
+        // Check if skill already exists in database
+        const existingSkill = await prisma.skill.findUnique({
+          where: { name: skillName },
+        });
+
+        if (existingSkill) {
+          errors.push(`${skillName}: Already registered in database`);
+          continue;
+        }
+
+        // Parse metadata before moving
+        const skillMdPath = join(sourcePath, 'SKILL.md');
+        let description = '';
+        let metadata: any = {};
+
+        if (existsSync(skillMdPath)) {
+          try {
+            const matter = await import('gray-matter');
+            const fileContent = await readFile(skillMdPath, 'utf-8');
+            const parsed = matter.default(fileContent);
+            description = parsed.data.description || '';
+            metadata = parsed.data;
+          } catch (e) {
+            console.warn(`Failed to parse SKILL.md for ${skillName}:`, e);
+          }
+        }
+
+        // Move skill to unified storage
+        await cp(sourcePath, targetPath, { recursive: true });
+        await rm(sourcePath, { recursive: true, force: true });
+
+        // Register in database
+        const skill = await prisma.skill.create({
+          data: {
+            name: skillName,
+            source: 'local',
+            description,
+            storagePath: targetPath,
+            metadata: JSON.stringify(metadata),
+          },
+        });
+
+        // Create symlink back to workspace
+        await symlink(targetPath, sourcePath, 'dir');
+
+        // Create skill-workspace link in database
+        await prisma.skillWorkspace.create({
+          data: {
+            skillId: skill.id,
+            workspaceId: workspace.id,
+          },
+        });
+
+        migrated.push(skillName);
+        console.log(`✅ Migrated skill "${skillName}" to unified storage`);
+
+      } catch (error: any) {
+        console.error(`Failed to migrate ${skillName}:`, error);
+        errors.push(`${skillName}: ${error.message}`);
+      }
+    }
+
+    return {
+      success: errors.length === 0,
+      migrated,
+      errors,
+    };
+  }
+}
+
+export const workspaceService = new WorkspaceService();

package/server/src/verify-sync.ts

@@ -0,0 +1,91 @@
+import { workspaceService } from './services/workspaceService';
+import { prisma } from './lib/db';
+import { join } from 'path';
+import { mkdir, symlink, rm, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { tmpdir } from 'os';
+
+async function main() {
+    console.log('Starting verification...');
+
+    // Setup paths
+    const tmpDir = join(tmpdir(), 'skillverse-verify-' + Date.now());
+    const projectPath = join(tmpDir, 'project');
+    const skillsPath = join(projectPath, '.agent/skills'); // antigravity default
+    const skillStoragePath = join(tmpDir, 'storage', 'test-skill');
+
+    console.log(`Temp dir: ${tmpDir}`);
+
+    try {
+        // 1. Create directories
+        await mkdir(projectPath, { recursive: true });
+        await mkdir(skillStoragePath, { recursive: true });
+        await writeFile(join(skillStoragePath, 'SKILL.md'), 'Test Skill');
+
+        // 2. Create Skill in DB
+        const skillName = 'test-skill-verify-' + Date.now();
+        const skill = await prisma.skill.create({
+            data: {
+                name: skillName,
+                source: 'local',
+                storagePath: skillStoragePath,
+                installDate: new Date(),
+                updateAvailable: false
+            }
+        });
+        console.log(`Created skill: ${skill.id}`);
+
+        // 3. Create Workspace in DB
+        // Use service to create so it creates directory structure
+        const workspace = await workspaceService.createWorkspace(
+            'verify-workspace-' + Date.now(),
+            projectPath,
+            'antigravity',
+            'project'
+        );
+        console.log(`Created workspace: ${workspace.id}`);
+
+        // 4. Link Skill
+        // This creates the symlink
+        await workspaceService.linkSkillToWorkspace(skill.id, workspace.id);
+        console.log('Linked skill to workspace');
+
+        // 5. Verify Link exists in DB and FS
+        let ws = await workspaceService.getWorkspaceById(workspace.id);
+        if (ws.linkedSkills.length !== 1) throw new Error('Link not found in DB after linking');
+        if (!existsSync(join(skillsPath, skillName))) throw new Error('Symlink not found');
+        console.log('Verified link exists.');
+
+        // 6. Manually delete symlink
+        await rm(join(skillsPath, skillName));
+        console.log('Deleted symlink manually');
+
+        // 7. Call getWorkspaceById to trigger sync
+        ws = await workspaceService.getWorkspaceById(workspace.id);
+
+        // 8. Assert link is gone
+        if (ws.linkedSkills.length !== 0) {
+            // Double check DB directly to be sure it's not just the return value
+            const dbLink = await prisma.skillWorkspace.findFirst({ where: { workspaceId: workspace.id, skillId: skill.id } });
+            if (dbLink) {
+                throw new Error('FAILED: Link still exists in DB after manual deletion!');
+            }
+        }
+        console.log('PASSED: Link removed from DB after manual deletion.');
+
+        // Cleanup DB
+        await prisma.skillWorkspace.deleteMany({ where: { workspaceId: workspace.id } });
+        await prisma.workspace.delete({ where: { id: workspace.id } });
+        await prisma.skill.delete({ where: { id: skill.id } });
+
+    } catch (err) {
+        console.error('Verification failed:', err);
+        process.exit(1);
+    } finally {
+        // Cleanup FS
+        await rm(tmpDir, { recursive: true, force: true });
+        await prisma.$disconnect();
+    }
+}
+
+main();

package/server/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "types": ["node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"],
+  "references": [
+    {
+      "path": "../shared"
+    }
+  ]
+}

package/server/tsup.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entry: ['src/index.ts', 'src/bin.ts'],
+    format: ['esm'],
+    clean: true,
+    splitting: false,
+    sourcemap: true,
+    noExternal: ['@skillverse/shared'], // Bundle shared library
+    external: [
+        'express',
+        'cors',
+        'dotenv',
+        'prisma',
+        '@prisma/client',
+        // Add other dependencies that should remain external
+    ],
+});

package/shared/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@skillverse/shared",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3"
+  }
+}

package/shared/pnpm-lock.yaml

@@ -0,0 +1,24 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    devDependencies:
+      typescript:
+        specifier: ^5.3.3
+        version: 5.9.3
+
+packages:
+
+  typescript@5.9.3:
+    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+snapshots:
+
+  typescript@5.9.3: {}