@nimblebrain/mpak 0.1.0 → 0.2.0

package/src/commands/skills/validate.test.ts

@@ -1,466 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, writeFileSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { validateSkillDirectory, formatValidationResult } from './validate.js';
-
-describe('validateSkillDirectory', () => {
-  let testDir: string;
-
-  beforeEach(() => {
-    testDir = join(tmpdir(), `skill-test-${Date.now()}`);
-    mkdirSync(testDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  describe('directory checks', () => {
-    it('fails for non-existent directory', () => {
-      const result = validateSkillDirectory('/non/existent/path');
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('Directory not found: /non/existent/path');
-    });
-
-    it('fails for file instead of directory', () => {
-      const filePath = join(testDir, 'not-a-dir');
-      writeFileSync(filePath, 'content');
-
-      const result = validateSkillDirectory(filePath);
-      expect(result.valid).toBe(false);
-      expect(result.errors[0]).toMatch(/Path is not a directory/);
-    });
-  });
-
-  describe('SKILL.md checks', () => {
-    it('fails when SKILL.md is missing', () => {
-      const skillDir = join(testDir, 'test-skill');
-      mkdirSync(skillDir);
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('SKILL.md not found');
-    });
-
-    it('fails when frontmatter is missing', () => {
-      const skillDir = join(testDir, 'test-skill');
-      mkdirSync(skillDir);
-      writeFileSync(join(skillDir, 'SKILL.md'), '# Just content\nNo frontmatter here');
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('No frontmatter found in SKILL.md');
-    });
-
-    it('fails when frontmatter is empty', () => {
-      const skillDir = join(testDir, 'test-skill');
-      mkdirSync(skillDir);
-      writeFileSync(join(skillDir, 'SKILL.md'), '---\n---\n# Content');
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('No frontmatter found in SKILL.md');
-    });
-  });
-
-  describe('frontmatter validation', () => {
-    it('fails when name is missing', () => {
-      const skillDir = join(testDir, 'test-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-description: A test skill
----
-# Test`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(false);
-      expect(result.errors.some((e) => e.includes('name'))).toBe(true);
-    });
-
-    it('fails when description is missing', () => {
-      const skillDir = join(testDir, 'test-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: test-skill
----
-# Test`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(false);
-      expect(result.errors.some((e) => e.includes('description'))).toBe(true);
-    });
-
-    it('fails when name format is invalid', () => {
-      const skillDir = join(testDir, 'test-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: Test_Skill
-description: A test skill
----
-# Test`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(false);
-      expect(result.errors.some((e) => e.toLowerCase().includes('lowercase'))).toBe(true);
-    });
-
-    it('fails when name has uppercase', () => {
-      const skillDir = join(testDir, 'test-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: TestSkill
-description: A test skill
----
-# Test`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(false);
-    });
-
-    it('fails when name starts with hyphen', () => {
-      const skillDir = join(testDir, '-test-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: -test-skill
-description: A test skill
----
-# Test`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(false);
-    });
-
-    it('fails when name does not match directory', () => {
-      const skillDir = join(testDir, 'dir-name');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: different-name
-description: A test skill
----
-# Test`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(false);
-      expect(result.errors.some((e) => e.includes('does not match directory'))).toBe(true);
-    });
-  });
-
-  describe('valid skills', () => {
-    it('validates minimal skill', () => {
-      const skillDir = join(testDir, 'test-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: test-skill
-description: A test skill for validation
----
-# Test Skill
-
-Instructions here.`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(true);
-      expect(result.name).toBe('test-skill');
-      expect(result.frontmatter?.description).toBe('A test skill for validation');
-    });
-
-    it('validates skill with optional fields', () => {
-      const skillDir = join(testDir, 'full-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: full-skill
-description: A fully featured test skill
-license: MIT
-compatibility: Works with Claude Code
-allowed-tools: Read Grep Bash
----
-# Full Skill`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(true);
-      expect(result.frontmatter?.license).toBe('MIT');
-      expect(result.frontmatter?.compatibility).toBe('Works with Claude Code');
-      expect(result.frontmatter?.['allowed-tools']).toBe('Read Grep Bash');
-    });
-
-    it('validates skill with metadata', () => {
-      const skillDir = join(testDir, 'meta-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: meta-skill
-description: A skill with metadata
-metadata:
-  version: "1.0.0"
-  category: development
-  tags:
-    - testing
-    - validation
-  surfaces:
-    - claude-code
-  author:
-    name: Test Author
----
-# Meta Skill`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(true);
-      expect(result.frontmatter?.metadata?.version).toBe('1.0.0');
-      expect(result.frontmatter?.metadata?.category).toBe('development');
-      expect(result.frontmatter?.metadata?.tags).toEqual(['testing', 'validation']);
-      expect(result.frontmatter?.metadata?.surfaces).toEqual(['claude-code']);
-      expect(result.frontmatter?.metadata?.author?.name).toBe('Test Author');
-    });
-  });
-
-  describe('warnings', () => {
-    it('warns when metadata is missing', () => {
-      const skillDir = join(testDir, 'basic-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: basic-skill
-description: A basic skill without metadata
----
-# Basic Skill`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(true);
-      expect(result.warnings.some((w) => w.includes('No metadata field'))).toBe(true);
-    });
-
-    it('warns when version is missing from metadata', () => {
-      const skillDir = join(testDir, 'no-version-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: no-version-skill
-description: A skill without version
-metadata:
-  category: development
----
-# No Version Skill`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(true);
-      expect(result.warnings.some((w) => w.includes('No version'))).toBe(true);
-    });
-
-    it('warns when tags are missing', () => {
-      const skillDir = join(testDir, 'no-tags-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: no-tags-skill
-description: A skill without tags
-metadata:
-  version: "1.0.0"
----
-# No Tags Skill`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(true);
-      expect(result.warnings.some((w) => w.includes('No tags'))).toBe(true);
-    });
-
-    it('warns about invalid optional directory', () => {
-      const skillDir = join(testDir, 'file-as-dir-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: file-as-dir-skill
-description: A skill with scripts as file
----
-# Skill`
-      );
-      writeFileSync(join(skillDir, 'scripts'), 'not a directory');
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(true);
-      expect(result.warnings.some((w) => w.includes('scripts'))).toBe(true);
-    });
-  });
-
-  describe('optional directories', () => {
-    it('accepts valid optional directories', () => {
-      const skillDir = join(testDir, 'dirs-skill');
-      mkdirSync(skillDir);
-      mkdirSync(join(skillDir, 'scripts'));
-      mkdirSync(join(skillDir, 'references'));
-      mkdirSync(join(skillDir, 'assets'));
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: dirs-skill
-description: A skill with all optional dirs
----
-# Skill`
-      );
-
-      const result = validateSkillDirectory(skillDir);
-      expect(result.valid).toBe(true);
-      expect(result.warnings.filter((w) => w.includes('not a directory'))).toHaveLength(0);
-    });
-  });
-});
-
-describe('formatValidationResult', () => {
-  it('formats valid result correctly', () => {
-    const result = {
-      valid: true,
-      name: 'test-skill',
-      path: '/path/to/skill',
-      frontmatter: {
-        name: 'test-skill',
-        description: 'A test skill description',
-      },
-      errors: [],
-      warnings: [],
-    };
-
-    const output = formatValidationResult(result);
-    expect(output).toContain('✓ Valid: test-skill');
-    expect(output).toContain('✓ SKILL.md found');
-    expect(output).toContain('name: test-skill');
-    expect(output).toContain('description:');
-  });
-
-  it('formats invalid result correctly', () => {
-    const result = {
-      valid: false,
-      name: null,
-      path: '/path/to/skill',
-      frontmatter: null,
-      errors: ['SKILL.md not found'],
-      warnings: [],
-    };
-
-    const output = formatValidationResult(result);
-    expect(output).toContain('✗ Invalid: /path/to/skill');
-    expect(output).toContain('Errors:');
-    expect(output).toContain('SKILL.md not found');
-  });
-
-  it('formats warnings correctly', () => {
-    const result = {
-      valid: true,
-      name: 'test-skill',
-      path: '/path/to/skill',
-      frontmatter: {
-        name: 'test-skill',
-        description: 'A test skill',
-      },
-      errors: [],
-      warnings: ['No metadata field'],
-    };
-
-    const output = formatValidationResult(result);
-    expect(output).toContain('Warnings:');
-    expect(output).toContain('No metadata field');
-  });
-
-  it('formats optional fields', () => {
-    const result = {
-      valid: true,
-      name: 'test-skill',
-      path: '/path/to/skill',
-      frontmatter: {
-        name: 'test-skill',
-        description: 'A test skill',
-        license: 'MIT',
-        compatibility: 'Claude Code',
-        'allowed-tools': 'Read Grep',
-      },
-      errors: [],
-      warnings: [],
-    };
-
-    const output = formatValidationResult(result);
-    expect(output).toContain('license: MIT');
-    expect(output).toContain('compatibility: Claude Code');
-    expect(output).toContain('allowed-tools: Read Grep');
-  });
-
-  it('formats metadata correctly', () => {
-    const result = {
-      valid: true,
-      name: 'test-skill',
-      path: '/path/to/skill',
-      frontmatter: {
-        name: 'test-skill',
-        description: 'A test skill',
-        metadata: {
-          version: '1.0.0',
-          category: 'development' as const,
-          tags: ['test', 'validation'],
-          triggers: ['test trigger'],
-          surfaces: ['claude-code' as const],
-          author: { name: 'Test Author' },
-        },
-      },
-      errors: [],
-      warnings: [],
-    };
-
-    const output = formatValidationResult(result);
-    expect(output).toContain('Discovery metadata');
-    expect(output).toContain('version: 1.0.0');
-    expect(output).toContain('category: development');
-    expect(output).toContain('tags: [test, validation]');
-    expect(output).toContain('triggers: 1 defined');
-    expect(output).toContain('surfaces: [claude-code]');
-    expect(output).toContain('author: Test Author');
-  });
-
-  it('truncates long descriptions', () => {
-    const longDescription = 'A'.repeat(100);
-    const result = {
-      valid: true,
-      name: 'test-skill',
-      path: '/path/to/skill',
-      frontmatter: {
-        name: 'test-skill',
-        description: longDescription,
-      },
-      errors: [],
-      warnings: [],
-    };
-
-    const output = formatValidationResult(result);
-    expect(output).toContain('...');
-    expect(output).toContain('(100 chars)');
-  });
-});

package/src/commands/skills/validate.ts

@@ -1,227 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
-import { join, basename } from 'path';
-import matter from 'gray-matter';
-import { SkillFrontmatterSchema } from '../../schemas/generated/skill.js';
-import type { SkillFrontmatter } from '../../schemas/generated/skill.js';
-
-export interface ValidationResult {
-  valid: boolean;
-  name: string | null;
-  path: string;
-  frontmatter: SkillFrontmatter | null;
-  errors: string[];
-  warnings: string[];
-}
-
-/**
- * Validate a skill directory against the Agent Skills spec
- */
-export function validateSkillDirectory(skillPath: string): ValidationResult {
-  const result: ValidationResult = {
-    valid: true,
-    name: null,
-    path: skillPath,
-    frontmatter: null,
-    errors: [],
-    warnings: [],
-  };
-
-  // Check directory exists
-  if (!existsSync(skillPath)) {
-    result.valid = false;
-    result.errors.push(`Directory not found: ${skillPath}`);
-    return result;
-  }
-
-  const stats = statSync(skillPath);
-  if (!stats.isDirectory()) {
-    result.valid = false;
-    result.errors.push(`Path is not a directory: ${skillPath}`);
-    return result;
-  }
-
-  // Check SKILL.md exists
-  const skillMdPath = join(skillPath, 'SKILL.md');
-  if (!existsSync(skillMdPath)) {
-    result.valid = false;
-    result.errors.push('SKILL.md not found');
-    return result;
-  }
-
-  // Read and parse SKILL.md
-  let content: string;
-  try {
-    content = readFileSync(skillMdPath, 'utf-8');
-  } catch (err) {
-    result.valid = false;
-    result.errors.push(`Failed to read SKILL.md: ${err}`);
-    return result;
-  }
-
-  // Parse frontmatter
-  let parsed: matter.GrayMatterFile<string>;
-  try {
-    parsed = matter(content);
-  } catch (err) {
-    result.valid = false;
-    result.errors.push(`Failed to parse frontmatter: ${err}`);
-    return result;
-  }
-
-  if (!parsed.data || Object.keys(parsed.data).length === 0) {
-    result.valid = false;
-    result.errors.push('No frontmatter found in SKILL.md');
-    return result;
-  }
-
-  // Validate against schema
-  const validation = SkillFrontmatterSchema.safeParse(parsed.data);
-
-  if (!validation.success) {
-    result.valid = false;
-    for (const issue of validation.error.issues) {
-      const path = issue.path.join('.');
-      result.errors.push(`${path}: ${issue.message}`);
-    }
-    return result;
-  }
-
-  result.frontmatter = validation.data;
-  result.name = validation.data.name;
-
-  // Validate name matches directory name
-  const dirName = basename(skillPath);
-  if (validation.data.name !== dirName) {
-    result.valid = false;
-    result.errors.push(
-      `Skill name "${validation.data.name}" does not match directory name "${dirName}"`
-    );
-  }
-
-  // Check for optional directories and files
-  const contents = readdirSync(skillPath);
-
-  // Standard optional directories
-  const optionalDirs = ['scripts', 'references', 'assets'];
-  for (const dir of optionalDirs) {
-    if (contents.includes(dir)) {
-      const dirPath = join(skillPath, dir);
-      if (!statSync(dirPath).isDirectory()) {
-        result.warnings.push(`"${dir}" exists but is not a directory`);
-      }
-    }
-  }
-
-  // Check for discovery metadata (not required, but recommended)
-  if (!validation.data.metadata) {
-    result.warnings.push('No metadata field - consider adding for better discovery');
-  } else {
-    const meta = validation.data.metadata;
-    if (!meta.tags || meta.tags.length === 0) {
-      result.warnings.push('No tags in metadata - consider adding for better discovery');
-    }
-    if (!meta.category) {
-      result.warnings.push('No category in metadata - consider adding for better discovery');
-    }
-    if (!meta.version) {
-      result.warnings.push('No version in metadata - required for registry publishing');
-    }
-  }
-
-  return result;
-}
-
-/**
- * Format validation result for CLI output
- */
-export function formatValidationResult(result: ValidationResult): string {
-  const lines: string[] = [];
-
-  if (result.valid) {
-    lines.push(`\u2713 Valid: ${result.name || result.path}`);
-  } else {
-    lines.push(`\u2717 Invalid: ${result.name || result.path}`);
-  }
-
-  lines.push('');
-
-  if (result.frontmatter) {
-    lines.push('\u2713 SKILL.md found');
-    lines.push('\u2713 Required fields');
-    lines.push(`  \u251c\u2500 name: ${result.frontmatter.name}`);
-    lines.push(
-      `  \u2514\u2500 description: ${result.frontmatter.description.slice(0, 60)}${result.frontmatter.description.length > 60 ? '...' : ''} (${result.frontmatter.description.length} chars)`
-    );
-
-    // Optional fields
-    const optionalFields: string[] = [];
-    if (result.frontmatter.license) optionalFields.push(`license: ${result.frontmatter.license}`);
-    if (result.frontmatter.compatibility)
-      optionalFields.push(`compatibility: ${result.frontmatter.compatibility}`);
-    if (result.frontmatter['allowed-tools'])
-      optionalFields.push(`allowed-tools: ${result.frontmatter['allowed-tools']}`);
-
-    if (optionalFields.length > 0) {
-      lines.push('');
-      lines.push('\u2713 Optional fields');
-      optionalFields.forEach((field, i) => {
-        const prefix = i === optionalFields.length - 1 ? '\u2514\u2500' : '\u251c\u2500';
-        lines.push(`  ${prefix} ${field}`);
-      });
-    }
-
-    // Discovery metadata
-    if (result.frontmatter.metadata) {
-      const meta = result.frontmatter.metadata;
-      lines.push('');
-      lines.push('\u2713 Discovery metadata (metadata:)');
-      if (meta.tags) lines.push(`  \u251c\u2500 tags: [${meta.tags.join(', ')}]`);
-      if (meta.category) lines.push(`  \u251c\u2500 category: ${meta.category}`);
-      if (meta.triggers) lines.push(`  \u251c\u2500 triggers: ${meta.triggers.length} defined`);
-      if (meta.version) lines.push(`  \u251c\u2500 version: ${meta.version}`);
-      if (meta.surfaces) lines.push(`  \u251c\u2500 surfaces: [${meta.surfaces.join(', ')}]`);
-      if (meta.author) lines.push(`  \u2514\u2500 author: ${meta.author.name}`);
-    }
-  }
-
-  if (result.errors.length > 0) {
-    lines.push('');
-    lines.push('Errors:');
-    result.errors.forEach((err) => lines.push(`  \u2717 ${err}`));
-  }
-
-  if (result.warnings.length > 0) {
-    lines.push('');
-    lines.push('Warnings:');
-    result.warnings.forEach((warn) => lines.push(`  \u26a0 ${warn}`));
-  }
-
-  return lines.join('\n');
-}
-
-export interface ValidateOptions {
-  json?: boolean;
-}
-
-/**
- * Handle the validate command
- */
-export async function handleSkillValidate(
-  skillPath: string,
-  options: ValidateOptions
-): Promise<void> {
-  const result = validateSkillDirectory(skillPath);
-
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else {
-    console.log('');
-    console.log(`Validating ${skillPath}...`);
-    console.log('');
-    console.log(formatValidationResult(result));
-  }
-
-  if (!result.valid) {
-    process.exit(1);
-  }
-}

package/src/index.ts

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-
-import { createProgram } from './program.js';
-import { handleError } from './utils/errors.js';
-
-async function main() {
-  const program = createProgram();
-  await program.parseAsync(process.argv);
-}
-
-main().catch(handleError);