@nimblebrain/mpak 0.1.0 → 0.2.0

package/src/schemas/generated/package.ts

@@ -1,29 +0,0 @@
-import { z } from 'zod';
-
-// Server type enum
-export const ServerTypeSchema = z.enum(['node', 'python', 'binary']);
-
-// Platform enum
-export const PlatformSchema = z.enum(['darwin', 'win32', 'linux']);
-
-// Sort options
-export const PackageSortSchema = z.enum(['downloads', 'recent', 'name']);
-
-// Package search params schema
-// Query params from HTTP are always strings, but we parse them to proper types
-export const PackageSearchParamsSchema = z.object({
-  q: z.string().optional(),
-  type: ServerTypeSchema.optional(),
-  tool: z.string().optional(),
-  prompt: z.string().optional(),
-  platform: PlatformSchema.optional(),
-  sort: PackageSortSchema.optional(),
-  limit: z.union([z.string(), z.number()]).optional(),
-  offset: z.union([z.string(), z.number()]).optional(),
-});
-
-// Export TypeScript types
-export type ServerType = z.infer<typeof ServerTypeSchema>;
-export type Platform = z.infer<typeof PlatformSchema>;
-export type PackageSort = z.infer<typeof PackageSortSchema>;
-export type PackageSearchParams = z.infer<typeof PackageSearchParamsSchema>;

package/src/schemas/generated/skill.ts

@@ -1,271 +0,0 @@
-import { z } from 'zod';
-
-// =============================================================================
-// Agent Skills Specification - Skill Frontmatter Schema
-// https://agentskills.io/specification
-// =============================================================================
-
-/**
- * Skill name validation
- * - 1-64 characters
- * - Lowercase alphanumeric with single hyphens
- * - Cannot start or end with hyphen
- * - Must match directory name (validated separately)
- */
-export const SkillNameSchema = z
-  .string()
-  .min(1)
-  .max(64)
-  .regex(
-    /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/,
-    'Lowercase alphanumeric with single hyphens, cannot start/end with hyphen'
-  );
-
-/**
- * Skill description
- * - 1-1024 characters
- * - Should describe what the skill does AND when to use it
- */
-export const SkillDescriptionSchema = z.string().min(1).max(1024);
-
-// =============================================================================
-// Discovery Metadata Extension (via metadata: field)
-// =============================================================================
-
-/**
- * Category taxonomy for skill discovery
- */
-export const SkillCategorySchema = z.enum([
-  'development', // Code, debugging, architecture
-  'writing', // Documentation, content, editing
-  'research', // Investigation, analysis, learning
-  'consulting', // Strategy, decisions, planning
-  'data', // Analysis, visualization, processing
-  'design', // UI/UX, visual, creative
-  'operations', // DevOps, infrastructure, automation
-  'security', // Auditing, compliance, protection
-  'other', // Uncategorized
-]);
-
-/**
- * Surfaces where the skill works
- */
-export const SkillSurfaceSchema = z.enum([
-  'claude-code', // Claude Code CLI
-  'claude-api', // Claude API with code execution
-  'claude-ai', // claude.ai web interface
-]);
-
-/**
- * Author information for attribution
- */
-export const SkillAuthorSchema = z.object({
-  name: z.string().min(1),
-  url: z.string().url().optional(),
-  email: z.string().email().optional(),
-});
-
-/**
- * Example usage for discovery
- */
-export const SkillExampleSchema = z.object({
-  prompt: z.string().min(1),
-  context: z.string().optional(),
-});
-
-/**
- * Discovery metadata (via metadata: field in frontmatter)
- * All fields optional - skills can start minimal and add discovery metadata later
- */
-export const SkillDiscoveryMetadataSchema = z
-  .object({
-    // Discovery
-    tags: z.array(z.string().max(32)).max(10).optional(),
-    category: SkillCategorySchema.optional(),
-    triggers: z.array(z.string().max(128)).max(20).optional(),
-    keywords: z.array(z.string().max(32)).max(30).optional(),
-    surfaces: z.array(SkillSurfaceSchema).optional(),
-
-    // Attribution
-    author: SkillAuthorSchema.optional(),
-
-    // Version (for registry tracking)
-    version: z.string().optional(),
-
-    // Examples
-    examples: z.array(SkillExampleSchema).max(5).optional(),
-  })
-  .passthrough(); // Allow additional custom keys
-
-// =============================================================================
-// Complete SKILL.md Frontmatter Schema
-// =============================================================================
-
-/**
- * Complete SKILL.md frontmatter schema
- * Combines official Agent Skills spec with discovery metadata extension
- */
-export const SkillFrontmatterSchema = z.object({
-  // Required (official spec)
-  name: SkillNameSchema,
-  description: SkillDescriptionSchema,
-
-  // Optional (official spec - informational pass-through)
-  license: z.string().optional(),
-  compatibility: z.string().max(500).optional(),
-  'allowed-tools': z.string().optional(), // space-delimited, experimental
-
-  // Extensible metadata (official spec) - our discovery extension
-  metadata: SkillDiscoveryMetadataSchema.optional(),
-});
-
-// =============================================================================
-// Registry API Schemas
-// =============================================================================
-
-/**
- * Scoped skill name for registry (e.g., @nimblebraininc/strategic-thought-partner)
- */
-export const ScopedSkillNameSchema = z
-  .string()
-  .regex(
-    /^@[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/,
-    'Scoped name format: @scope/name'
-  );
-
-/**
- * Skill artifact info for announce endpoint
- */
-export const SkillArtifactSchema = z.object({
-  filename: z.string().regex(/\.skill$/, 'Must have .skill extension'),
-  sha256: z.string().length(64),
-  size: z.number().int().positive(),
-});
-
-/**
- * Announce request schema for POST /v1/skills/announce
- */
-export const SkillAnnounceRequestSchema = z.object({
-  name: ScopedSkillNameSchema,
-  version: z.string(),
-  skill: SkillFrontmatterSchema,
-  release_tag: z.string(),
-  prerelease: z.boolean().optional().default(false),
-  artifact: SkillArtifactSchema,
-});
-
-/**
- * Announce response schema
- */
-export const SkillAnnounceResponseSchema = z.object({
-  skill: z.string(),
-  version: z.string(),
-  status: z.enum(['created', 'exists']),
-});
-
-// =============================================================================
-// Search/List API Schemas
-// =============================================================================
-
-/**
- * Skill search parameters
- */
-export const SkillSearchParamsSchema = z.object({
-  q: z.string().optional(),
-  tags: z.string().optional(), // comma-separated
-  category: SkillCategorySchema.optional(),
-  surface: SkillSurfaceSchema.optional(),
-  sort: z.enum(['downloads', 'recent', 'name']).optional(),
-  limit: z.union([z.string(), z.number()]).optional(),
-  offset: z.union([z.string(), z.number()]).optional(),
-});
-
-/**
- * Skill summary for search results
- */
-export const SkillSummarySchema = z.object({
-  name: z.string(), // scoped name
-  description: z.string(),
-  latest_version: z.string(),
-  tags: z.array(z.string()).optional(),
-  category: SkillCategorySchema.optional(),
-  surfaces: z.array(SkillSurfaceSchema).optional(),
-  downloads: z.number(),
-  published_at: z.string(),
-  author: SkillAuthorSchema.optional(),
-});
-
-/**
- * Skill search response
- */
-export const SkillSearchResponseSchema = z.object({
-  skills: z.array(SkillSummarySchema),
-  total: z.number(),
-  pagination: z.object({
-    limit: z.number(),
-    offset: z.number(),
-    has_more: z.boolean(),
-  }),
-});
-
-/**
- * Skill detail response
- */
-export const SkillDetailSchema = z.object({
-  name: z.string(), // scoped name
-  description: z.string(),
-  latest_version: z.string(),
-  license: z.string().optional(),
-  compatibility: z.string().optional(),
-  allowed_tools: z.array(z.string()).optional(),
-  tags: z.array(z.string()).optional(),
-  category: SkillCategorySchema.optional(),
-  triggers: z.array(z.string()).optional(),
-  surfaces: z.array(SkillSurfaceSchema).optional(),
-  downloads: z.number(),
-  published_at: z.string(),
-  author: SkillAuthorSchema.optional(),
-  examples: z.array(SkillExampleSchema).optional(),
-  versions: z.array(
-    z.object({
-      version: z.string(),
-      published_at: z.string(),
-      downloads: z.number(),
-    })
-  ),
-});
-
-/**
- * Skill download info response
- */
-export const SkillDownloadInfoSchema = z.object({
-  url: z.string(),
-  skill: z.object({
-    name: z.string(),
-    version: z.string(),
-    sha256: z.string(),
-    size: z.number(),
-  }),
-  expires_at: z.string(),
-});
-
-// =============================================================================
-// TypeScript Types
-// =============================================================================
-
-export type SkillName = z.infer<typeof SkillNameSchema>;
-export type SkillCategory = z.infer<typeof SkillCategorySchema>;
-export type SkillSurface = z.infer<typeof SkillSurfaceSchema>;
-export type SkillAuthor = z.infer<typeof SkillAuthorSchema>;
-export type SkillExample = z.infer<typeof SkillExampleSchema>;
-export type SkillDiscoveryMetadata = z.infer<typeof SkillDiscoveryMetadataSchema>;
-export type SkillFrontmatter = z.infer<typeof SkillFrontmatterSchema>;
-export type ScopedSkillName = z.infer<typeof ScopedSkillNameSchema>;
-export type SkillArtifact = z.infer<typeof SkillArtifactSchema>;
-export type SkillAnnounceRequest = z.infer<typeof SkillAnnounceRequestSchema>;
-export type SkillAnnounceResponse = z.infer<typeof SkillAnnounceResponseSchema>;
-export type SkillSearchParams = z.infer<typeof SkillSearchParamsSchema>;
-export type SkillSummary = z.infer<typeof SkillSummarySchema>;
-export type SkillSearchResponse = z.infer<typeof SkillSearchResponseSchema>;
-export type SkillDetail = z.infer<typeof SkillDetailSchema>;
-export type SkillDownloadInfo = z.infer<typeof SkillDownloadInfoSchema>;

package/src/utils/config-manager.test.ts

@@ -1,330 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { ConfigManager, ConfigCorruptedError } from './config-manager.js';
-import { existsSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-
-describe('ConfigManager', () => {
-  const testConfigDir = join(homedir(), '.mpak');
-  const testConfigFile = join(testConfigDir, 'config.json');
-
-  beforeEach(() => {
-    // Clean up test config before each test
-    if (existsSync(testConfigFile)) {
-      rmSync(testConfigFile, { force: true });
-    }
-  });
-
-  afterEach(() => {
-    // Clean up test config after each test
-    if (existsSync(testConfigFile)) {
-      rmSync(testConfigFile, { force: true });
-    }
-  });
-
-  describe('loadConfig', () => {
-    it('should create a new config if none exists', () => {
-      const manager = new ConfigManager();
-      const config = manager.loadConfig();
-
-      expect(config).toBeDefined();
-      expect(config.version).toBe('1.0.0');
-      expect(config.lastUpdated).toBeTruthy();
-    });
-
-    it('should set registryUrl in config', () => {
-      const manager = new ConfigManager();
-      manager.setRegistryUrl('http://test.example.com');
-
-      // Get the config to verify it's set
-      expect(manager.getRegistryUrl()).toBe('http://test.example.com');
-    });
-  });
-
-  describe('getRegistryUrl', () => {
-    it('should return default registry URL', () => {
-      const manager = new ConfigManager();
-      const url = manager.getRegistryUrl();
-
-      expect(url).toBe('https://api.mpak.dev');
-    });
-
-    it('should return configured registry URL', () => {
-      const manager = new ConfigManager();
-      manager.setRegistryUrl('http://custom.example.com');
-
-      expect(manager.getRegistryUrl()).toBe('http://custom.example.com');
-    });
-  });
-
-  describe('package config', () => {
-    it('should set and get package config value', () => {
-      const manager = new ConfigManager();
-      manager.setPackageConfigValue('@scope/name', 'api_key', 'test-value');
-
-      expect(manager.getPackageConfigValue('@scope/name', 'api_key')).toBe('test-value');
-    });
-
-    it('should return undefined for non-existent package', () => {
-      const manager = new ConfigManager();
-
-      expect(manager.getPackageConfig('@nonexistent/pkg')).toBeUndefined();
-    });
-
-    it('should return undefined for non-existent key', () => {
-      const manager = new ConfigManager();
-      manager.setPackageConfigValue('@scope/name', 'existing', 'value');
-
-      expect(manager.getPackageConfigValue('@scope/name', 'nonexistent')).toBeUndefined();
-    });
-
-    it('should get all package config', () => {
-      const manager = new ConfigManager();
-      manager.setPackageConfigValue('@scope/name', 'key1', 'value1');
-      manager.setPackageConfigValue('@scope/name', 'key2', 'value2');
-
-      const config = manager.getPackageConfig('@scope/name');
-      expect(config).toEqual({
-        key1: 'value1',
-        key2: 'value2',
-      });
-    });
-
-    it('should clear specific package config value', () => {
-      const manager = new ConfigManager();
-      manager.setPackageConfigValue('@scope/name', 'key1', 'value1');
-      manager.setPackageConfigValue('@scope/name', 'key2', 'value2');
-
-      const cleared = manager.clearPackageConfigValue('@scope/name', 'key1');
-      expect(cleared).toBe(true);
-      expect(manager.getPackageConfigValue('@scope/name', 'key1')).toBeUndefined();
-      expect(manager.getPackageConfigValue('@scope/name', 'key2')).toBe('value2');
-    });
-
-    it('should return false when clearing non-existent key', () => {
-      const manager = new ConfigManager();
-      manager.setPackageConfigValue('@scope/name', 'key1', 'value1');
-
-      const cleared = manager.clearPackageConfigValue('@scope/name', 'nonexistent');
-      expect(cleared).toBe(false);
-    });
-
-    it('should clear all package config', () => {
-      const manager = new ConfigManager();
-      manager.setPackageConfigValue('@scope/name', 'key1', 'value1');
-      manager.setPackageConfigValue('@scope/name', 'key2', 'value2');
-
-      const cleared = manager.clearPackageConfig('@scope/name');
-      expect(cleared).toBe(true);
-      expect(manager.getPackageConfig('@scope/name')).toBeUndefined();
-    });
-
-    it('should return false when clearing non-existent package', () => {
-      const manager = new ConfigManager();
-
-      const cleared = manager.clearPackageConfig('@nonexistent/pkg');
-      expect(cleared).toBe(false);
-    });
-
-    it('should list packages with config', () => {
-      const manager = new ConfigManager();
-      manager.setPackageConfigValue('@scope/pkg1', 'key', 'value');
-      manager.setPackageConfigValue('@scope/pkg2', 'key', 'value');
-
-      const packages = manager.listPackagesWithConfig();
-      expect(packages).toContain('@scope/pkg1');
-      expect(packages).toContain('@scope/pkg2');
-      expect(packages).toHaveLength(2);
-    });
-
-    it('should clean up empty package entry after clearing last key', () => {
-      const manager = new ConfigManager();
-      manager.setPackageConfigValue('@scope/name', 'only_key', 'value');
-      manager.clearPackageConfigValue('@scope/name', 'only_key');
-
-      expect(manager.getPackageConfig('@scope/name')).toBeUndefined();
-      expect(manager.listPackagesWithConfig()).not.toContain('@scope/name');
-    });
-  });
-
-  describe('config validation', () => {
-    beforeEach(() => {
-      // Ensure config directory exists for writing test files
-      if (!existsSync(testConfigDir)) {
-        mkdirSync(testConfigDir, { recursive: true, mode: 0o700 });
-      }
-    });
-
-    it('should throw ConfigCorruptedError for invalid JSON', () => {
-      writeFileSync(testConfigFile, 'not valid json {{{', { mode: 0o600 });
-
-      const manager = new ConfigManager();
-      expect(() => manager.loadConfig()).toThrow(ConfigCorruptedError);
-      expect(() => manager.loadConfig()).toThrow(/invalid JSON/);
-    });
-
-    it('should throw ConfigCorruptedError when version is missing', () => {
-      writeFileSync(
-        testConfigFile,
-        JSON.stringify({ lastUpdated: '2024-01-01T00:00:00Z' }),
-        { mode: 0o600 }
-      );
-
-      const manager = new ConfigManager();
-      expect(() => manager.loadConfig()).toThrow(ConfigCorruptedError);
-      expect(() => manager.loadConfig()).toThrow(/version/);
-    });
-
-    it('should throw ConfigCorruptedError when lastUpdated is missing', () => {
-      writeFileSync(
-        testConfigFile,
-        JSON.stringify({ version: '1.0.0' }),
-        { mode: 0o600 }
-      );
-
-      const manager = new ConfigManager();
-      expect(() => manager.loadConfig()).toThrow(ConfigCorruptedError);
-      expect(() => manager.loadConfig()).toThrow(/lastUpdated/);
-    });
-
-    it('should throw ConfigCorruptedError when registryUrl is not a string', () => {
-      writeFileSync(
-        testConfigFile,
-        JSON.stringify({
-          version: '1.0.0',
-          lastUpdated: '2024-01-01T00:00:00Z',
-          registryUrl: 12345,
-        }),
-        { mode: 0o600 }
-      );
-
-      const manager = new ConfigManager();
-      expect(() => manager.loadConfig()).toThrow(ConfigCorruptedError);
-      expect(() => manager.loadConfig()).toThrow(/registryUrl must be a string/);
-    });
-
-    it('should throw ConfigCorruptedError when packages is not an object', () => {
-      writeFileSync(
-        testConfigFile,
-        JSON.stringify({
-          version: '1.0.0',
-          lastUpdated: '2024-01-01T00:00:00Z',
-          packages: 'not an object',
-        }),
-        { mode: 0o600 }
-      );
-
-      const manager = new ConfigManager();
-      expect(() => manager.loadConfig()).toThrow(ConfigCorruptedError);
-      expect(() => manager.loadConfig()).toThrow(/packages must be an object/);
-    });
-
-    it('should throw ConfigCorruptedError when package config is not an object', () => {
-      writeFileSync(
-        testConfigFile,
-        JSON.stringify({
-          version: '1.0.0',
-          lastUpdated: '2024-01-01T00:00:00Z',
-          packages: {
-            '@scope/pkg': 'not an object',
-          },
-        }),
-        { mode: 0o600 }
-      );
-
-      const manager = new ConfigManager();
-      expect(() => manager.loadConfig()).toThrow(ConfigCorruptedError);
-      expect(() => manager.loadConfig()).toThrow(/packages.@scope\/pkg must be an object/);
-    });
-
-    it('should throw ConfigCorruptedError when package config value is not a string', () => {
-      writeFileSync(
-        testConfigFile,
-        JSON.stringify({
-          version: '1.0.0',
-          lastUpdated: '2024-01-01T00:00:00Z',
-          packages: {
-            '@scope/pkg': {
-              api_key: 12345,
-            },
-          },
-        }),
-        { mode: 0o600 }
-      );
-
-      const manager = new ConfigManager();
-      expect(() => manager.loadConfig()).toThrow(ConfigCorruptedError);
-      expect(() => manager.loadConfig()).toThrow(/packages.@scope\/pkg.api_key must be a string/);
-    });
-
-    it('should throw ConfigCorruptedError for unknown fields', () => {
-      writeFileSync(
-        testConfigFile,
-        JSON.stringify({
-          version: '1.0.0',
-          lastUpdated: '2024-01-01T00:00:00Z',
-          unknownField: 'should not be here',
-        }),
-        { mode: 0o600 }
-      );
-
-      const manager = new ConfigManager();
-      expect(() => manager.loadConfig()).toThrow(ConfigCorruptedError);
-      expect(() => manager.loadConfig()).toThrow(/unknown field: unknownField/);
-    });
-
-    it('should include config path in error', () => {
-      writeFileSync(testConfigFile, 'invalid json', { mode: 0o600 });
-
-      const manager = new ConfigManager();
-      try {
-        manager.loadConfig();
-        expect.fail('Should have thrown');
-      } catch (err) {
-        expect(err).toBeInstanceOf(ConfigCorruptedError);
-        expect((err as ConfigCorruptedError).configPath).toBe(testConfigFile);
-      }
-    });
-
-    it('should load valid minimal config', () => {
-      writeFileSync(
-        testConfigFile,
-        JSON.stringify({
-          version: '1.0.0',
-          lastUpdated: '2024-01-01T00:00:00Z',
-        }),
-        { mode: 0o600 }
-      );
-
-      const manager = new ConfigManager();
-      const config = manager.loadConfig();
-      expect(config.version).toBe('1.0.0');
-      expect(config.lastUpdated).toBe('2024-01-01T00:00:00Z');
-    });
-
-    it('should load valid full config', () => {
-      writeFileSync(
-        testConfigFile,
-        JSON.stringify({
-          version: '1.0.0',
-          lastUpdated: '2024-01-01T00:00:00Z',
-          registryUrl: 'https://custom.registry.com',
-          packages: {
-            '@scope/pkg': {
-              api_key: 'secret',
-              other_key: 'value',
-            },
-          },
-        }),
-        { mode: 0o600 }
-      );
-
-      const manager = new ConfigManager();
-      const config = manager.loadConfig();
-      expect(config.version).toBe('1.0.0');
-      expect(config.registryUrl).toBe('https://custom.registry.com');
-      expect(config.packages?.['@scope/pkg']?.api_key).toBe('secret');
-    });
-  });
-
-});