Initial release v1.0.0

Open-source marketplace for AI Agent skills.

Features:
- Next.js 15 web app with i18n (en/fa)
- CLI tool for skill installation (npx skillhub)
- GitHub crawler/indexer with multi-strategy discovery
- Security scanning for all indexed skills
- Self-hostable with Docker

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

apps/web/app/api/skills/featured/route.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { NextRequest } from 'next/server';
+
+// Mock rate limiting - must be before route import
+vi.mock('@/lib/rate-limit', () => ({
+  withRateLimit: vi.fn().mockResolvedValue({ allowed: true, remaining: 100, limit: 120, resetAt: Date.now() + 60000 }),
+  createRateLimitResponse: vi.fn(),
+  createRateLimitHeaders: vi.fn().mockReturnValue({}),
+}));
+
+// Helper to create mock skill
+function createMockSkill(overrides: Partial<{
+  id: string;
+  name: string;
+  isFeatured: boolean;
+  githubStars: number;
+}> = {}) {
+  return {
+    id: 'test-owner/test-repo/test-skill',
+    name: 'test-skill',
+    description: 'A test skill',
+    githubOwner: 'test-owner',
+    githubRepo: 'test-repo',
+    githubStars: 100,
+    downloadCount: 50,
+    securityScore: 85,
+    isVerified: false,
+    isFeatured: true,
+    compatibility: { platforms: ['claude'] },
+    ...overrides,
+  };
+}
+
+// Mock db
+vi.mock('@skillhub/db', () => ({
+  createDb: vi.fn(() => ({})),
+  skillQueries: {
+    getFeatured: vi.fn(),
+    getByPopularity: vi.fn(),
+    getFeaturedWithDiversity: vi.fn(),
+  },
+  skills: {},
+}));
+
+import { GET } from './route';
+import { skillQueries } from '@skillhub/db';
+
+describe('GET /api/skills/featured', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return featured skills', async () => {
+    const mockSkills = [
+      createMockSkill({ id: 'skill-1', isFeatured: true }),
+      createMockSkill({ id: 'skill-2', isFeatured: true }),
+    ];
+    vi.mocked(skillQueries.getFeatured).mockResolvedValue(mockSkills as any);
+
+    const request = new NextRequest('http://localhost:3000/api/skills/featured');
+    const response = await GET(request);
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data.skills).toBeDefined();
+    expect(Array.isArray(data.skills)).toBe(true);
+    expect(data.skills.length).toBe(2);
+  });
+
+  it('should respect limit parameter', async () => {
+    const mockSkills = [createMockSkill()];
+    vi.mocked(skillQueries.getFeatured).mockResolvedValue(mockSkills as any);
+
+    const request = new NextRequest('http://localhost:3000/api/skills/featured?limit=5');
+    await GET(request);
+
+    expect(skillQueries.getFeatured).toHaveBeenCalledWith(expect.anything(), 5);
+  });
+
+  it('should fallback to diversity-based popularity when no featured', async () => {
+    vi.mocked(skillQueries.getFeatured).mockResolvedValue([]);
+    vi.mocked(skillQueries.getFeaturedWithDiversity).mockResolvedValue([createMockSkill()] as any);
+
+    const request = new NextRequest('http://localhost:3000/api/skills/featured');
+    const response = await GET(request);
+    const data = await response.json();
+
+    expect(skillQueries.getFeaturedWithDiversity).toHaveBeenCalled();
+    expect(data.skills.length).toBeGreaterThan(0);
+  });
+
+  it('should handle database errors gracefully', async () => {
+    vi.mocked(skillQueries.getFeatured).mockRejectedValue(new Error('Database error'));
+
+    const request = new NextRequest('http://localhost:3000/api/skills/featured');
+    const response = await GET(request);
+    const data = await response.json();
+
+    expect(response.status).toBe(500);
+    expect(data.error).toBeDefined();
+  });
+});

apps/web/app/api/skills/featured/route.ts

@@ -0,0 +1,88 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { createDb, skillQueries, type skills } from '@skillhub/db';
+import { getCached, setCache, cacheKeys, cacheTTL } from '@/lib/cache';
+import { withRateLimit, createRateLimitResponse, createRateLimitHeaders } from '@/lib/rate-limit';
+
+const db = createDb();
+
+type Skill = typeof skills.$inferSelect;
+
+interface SkillData {
+  id: string;
+  name: string;
+  description: string | null;
+  githubOwner: string;
+  githubRepo: string;
+  githubStars: number | null;
+  downloadCount: number | null;
+  securityStatus: string | null;
+  isVerified: boolean | null;
+  compatibility: unknown;
+}
+
+interface FeaturedResponse {
+  skills: SkillData[];
+}
+
+export async function GET(request: NextRequest) {
+  // Rate limiting
+  const rateLimitResult = await withRateLimit(request, 'anonymous');
+  if (!rateLimitResult.allowed) {
+    return createRateLimitResponse(rateLimitResult);
+  }
+
+  try {
+    const searchParams = request.nextUrl.searchParams;
+    const limit = parseInt(searchParams.get('limit') || '6');
+
+    // Try to get from cache first (only for default limit)
+    const cacheKey = cacheKeys.featuredSkills();
+    if (limit === 6) {
+      const cached = await getCached<FeaturedResponse>(cacheKey);
+      if (cached) {
+        return NextResponse.json(cached, {
+          headers: { 'X-Cache': 'HIT', ...createRateLimitHeaders(rateLimitResult) },
+        });
+      }
+    }
+
+    // Get featured skills, fallback to popularity-based ranking
+    // Uses adaptive algorithm: quality + freshness + engagement
+    let featuredSkills = await skillQueries.getFeatured(db, limit);
+
+    // If no manually featured skills, use adaptive popularity with owner/repo diversity
+    if (featuredSkills.length === 0) {
+      featuredSkills = await skillQueries.getFeaturedWithDiversity(db, limit, 2, 3);
+    }
+
+    const data: FeaturedResponse = {
+      skills: featuredSkills.map((skill: Skill) => ({
+        id: skill.id,
+        name: skill.name,
+        description: skill.description,
+        githubOwner: skill.githubOwner,
+        githubRepo: skill.githubRepo,
+        githubStars: skill.githubStars,
+        downloadCount: skill.downloadCount,
+        securityStatus: skill.securityStatus,
+        isVerified: skill.isVerified,
+        compatibility: skill.compatibility,
+      })),
+    };
+
+    // Cache the result (2 hours)
+    if (limit === 6) {
+      await setCache(cacheKey, data, cacheTTL.featured);
+    }
+
+    return NextResponse.json(data, {
+      headers: { 'X-Cache': 'MISS', ...createRateLimitHeaders(rateLimitResult) },
+    });
+  } catch (error) {
+    console.error('Error fetching featured skills:', error);
+    return NextResponse.json(
+      { error: 'Failed to fetch featured skills' },
+      { status: 500 }
+    );
+  }
+}