@nimblebrain/mpak 0.1.0 → 0.2.0

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

@@ -1,260 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
-import { join, basename } from 'path';
-import { tmpdir } from 'os';
-import { packSkill } from './pack.js';
-import { execSync } from 'child_process';
-
-describe('packSkill', () => {
-  let testDir: string;
-
-  beforeEach(() => {
-    testDir = join(tmpdir(), `skill-pack-test-${Date.now()}`);
-    mkdirSync(testDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  describe('validation before packing', () => {
-    it('fails for invalid skill', async () => {
-      const skillDir = join(testDir, 'invalid-skill');
-      mkdirSync(skillDir);
-      // No SKILL.md
-
-      const result = await packSkill(skillDir);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Validation failed');
-    });
-
-    it('fails when name format is invalid', async () => {
-      const skillDir = join(testDir, 'BadName');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: BadName
-description: Invalid name
----
-# Bad`
-      );
-
-      const result = await packSkill(skillDir);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Validation failed');
-    });
-  });
-
-  describe('successful packing', () => {
-    it('creates a .skill bundle', async () => {
-      const skillDir = join(testDir, 'test-skill');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: test-skill
-description: A test skill for packing
-metadata:
-  version: "1.0.0"
----
-# Test Skill
-
-Instructions here.`
-      );
-
-      const outputPath = join(testDir, 'test-skill-1.0.0.skill');
-      const result = await packSkill(skillDir, outputPath);
-
-      expect(result.success).toBe(true);
-      expect(result.name).toBe('test-skill');
-      expect(result.version).toBe('1.0.0');
-      expect(result.path).toBe(outputPath);
-      expect(result.path!.endsWith('.skill')).toBe(true);
-      expect(result.sha256).toMatch(/^[a-f0-9]{64}$/);
-      expect(result.size).toBeGreaterThan(0);
-
-      // Verify bundle exists
-      expect(existsSync(result.path!)).toBe(true);
-    });
-
-    it('uses 0.0.0 version when metadata version is missing', async () => {
-      const skillDir = join(testDir, 'no-version');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: no-version
-description: A skill without version
----
-# No Version`
-      );
-
-      const outputPath = join(testDir, 'no-version-0.0.0.skill');
-      const result = await packSkill(skillDir, outputPath);
-
-      expect(result.success).toBe(true);
-      expect(result.version).toBe('0.0.0');
-      expect(basename(result.path!)).toBe('no-version-0.0.0.skill');
-    });
-
-    it('creates bundle in current directory by default', async () => {
-      const skillDir = join(testDir, 'output-test');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: output-test
-description: Testing output path
-metadata:
-  version: "1.0.0"
----
-# Output Test`
-      );
-
-      // Change to temp directory to test default output location
-      const originalCwd = process.cwd();
-      process.chdir(testDir);
-
-      try {
-        const result = await packSkill(skillDir);
-
-        expect(result.success).toBe(true);
-        expect(result.path).toContain(testDir);
-      } finally {
-        process.chdir(originalCwd);
-      }
-    });
-
-    it('uses custom output path when provided', async () => {
-      const skillDir = join(testDir, 'custom-output');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: custom-output
-description: Custom output path test
-metadata:
-  version: "2.0.0"
----
-# Custom Output`
-      );
-
-      const outputPath = join(testDir, 'custom-name.skill');
-      const result = await packSkill(skillDir, outputPath);
-
-      expect(result.success).toBe(true);
-      expect(result.path).toBe(outputPath);
-      expect(existsSync(outputPath)).toBe(true);
-    });
-
-    it('includes skill directory structure in bundle', async () => {
-      const skillDir = join(testDir, 'structured-skill');
-      mkdirSync(skillDir);
-      mkdirSync(join(skillDir, 'scripts'));
-      mkdirSync(join(skillDir, 'references'));
-
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: structured-skill
-description: A skill with structure
-metadata:
-  version: "1.0.0"
----
-# Structured Skill`
-      );
-      writeFileSync(join(skillDir, 'scripts', 'helper.py'), '# Python helper');
-      writeFileSync(join(skillDir, 'references', 'PATTERNS.md'), '# Patterns');
-
-      const outputPath = join(testDir, 'structured-skill-1.0.0.skill');
-      const result = await packSkill(skillDir, outputPath);
-
-      expect(result.success).toBe(true);
-
-      // Verify bundle contents using unzip -l
-      try {
-        const listing = execSync(`unzip -l "${result.path}"`, { encoding: 'utf-8' });
-        expect(listing).toContain('structured-skill/SKILL.md');
-        expect(listing).toContain('structured-skill/scripts/helper.py');
-        expect(listing).toContain('structured-skill/references/PATTERNS.md');
-      } catch {
-        // unzip may not be available, skip this check
-      }
-    });
-
-    it('calculates correct SHA256', async () => {
-      const skillDir = join(testDir, 'hash-test');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: hash-test
-description: Testing SHA256 calculation
-metadata:
-  version: "1.0.0"
----
-# Hash Test`
-      );
-
-      const outputPath = join(testDir, 'hash-test-1.0.0.skill');
-      const result = await packSkill(skillDir, outputPath);
-
-      expect(result.success).toBe(true);
-      expect(result.sha256).toHaveLength(64);
-
-      // Verify hash using shasum if available
-      try {
-        const shasum = execSync(`shasum -a 256 "${result.path}"`, { encoding: 'utf-8' });
-        const computedHash = shasum.split(' ')[0];
-        expect(result.sha256).toBe(computedHash);
-      } catch {
-        // shasum may not be available, skip this check
-      }
-    });
-  });
-
-  describe('bundle naming', () => {
-    it('creates bundle with name-version.skill format', async () => {
-      const skillDir = join(testDir, 'naming-test');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: naming-test
-description: Testing bundle naming
-metadata:
-  version: "3.2.1"
----
-# Naming Test`
-      );
-
-      const outputPath = join(testDir, 'naming-test-3.2.1.skill');
-      const result = await packSkill(skillDir, outputPath);
-
-      expect(result.success).toBe(true);
-      expect(basename(result.path!)).toBe('naming-test-3.2.1.skill');
-    });
-
-    it('handles prerelease versions', async () => {
-      const skillDir = join(testDir, 'prerelease-test');
-      mkdirSync(skillDir);
-      writeFileSync(
-        join(skillDir, 'SKILL.md'),
-        `---
-name: prerelease-test
-description: Testing prerelease version
-metadata:
-  version: "1.0.0-beta.1"
----
-# Prerelease Test`
-      );
-
-      const outputPath = join(testDir, 'prerelease-test-1.0.0-beta.1.skill');
-      const result = await packSkill(skillDir, outputPath);
-
-      expect(result.success).toBe(true);
-      expect(basename(result.path!)).toBe('prerelease-test-1.0.0-beta.1.skill');
-    });
-  });
-});

package/src/commands/skills/pack.ts

@@ -1,145 +0,0 @@
-import { createWriteStream, createReadStream } from 'fs';
-import { createHash } from 'crypto';
-import { basename, join, resolve } from 'path';
-import archiver from 'archiver';
-import { validateSkillDirectory, formatValidationResult } from './validate.js';
-
-export interface PackResult {
-  success: boolean;
-  path: string | null;
-  name: string | null;
-  version: string | null;
-  size: number | null;
-  sha256: string | null;
-  error: string | null;
-}
-
-/**
- * Create a .skill bundle from a skill directory
- */
-export async function packSkill(skillPath: string, outputPath?: string): Promise<PackResult> {
-  // Validate first
-  const validation = validateSkillDirectory(skillPath);
-
-  if (!validation.valid) {
-    return {
-      success: false,
-      path: null,
-      name: null,
-      version: null,
-      size: null,
-      sha256: null,
-      error: `Validation failed:\n${formatValidationResult(validation)}`,
-    };
-  }
-
-  const skillName = validation.name!;
-  const version = validation.frontmatter?.metadata?.version || '0.0.0';
-
-  // Determine output path
-  const bundleName = `${skillName}-${version}.skill`;
-  const finalOutputPath = outputPath || join(process.cwd(), bundleName);
-
-  // Create the zip archive
-  return new Promise((resolvePromise) => {
-    const output = createWriteStream(finalOutputPath);
-    const archive = archiver('zip', { zlib: { level: 9 } });
-
-    let size = 0;
-
-    output.on('close', async () => {
-      size = archive.pointer();
-
-      // Calculate SHA256
-      const hash = createHash('sha256');
-      const stream = createReadStream(finalOutputPath);
-
-      stream.on('data', (chunk) => hash.update(chunk));
-      stream.on('end', () => {
-        const sha256 = hash.digest('hex');
-
-        resolvePromise({
-          success: true,
-          path: finalOutputPath,
-          name: skillName,
-          version,
-          size,
-          sha256,
-          error: null,
-        });
-      });
-      stream.on('error', (err) => {
-        resolvePromise({
-          success: false,
-          path: null,
-          name: skillName,
-          version,
-          size: null,
-          sha256: null,
-          error: `Failed to calculate SHA256: ${err.message}`,
-        });
-      });
-    });
-
-    archive.on('error', (err) => {
-      resolvePromise({
-        success: false,
-        path: null,
-        name: skillName,
-        version,
-        size: null,
-        sha256: null,
-        error: `Archive error: ${err.message}`,
-      });
-    });
-
-    archive.pipe(output);
-
-    // Add the skill directory to the archive
-    // The archive should contain: skillName/SKILL.md, skillName/scripts/, etc.
-    const dirName = basename(resolve(skillPath));
-    archive.directory(skillPath, dirName);
-
-    archive.finalize();
-  });
-}
-
-/**
- * Format file size for display
- */
-function formatSize(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-
-export interface PackOptions {
-  output?: string;
-  json?: boolean;
-}
-
-/**
- * Handle the pack command
- */
-export async function handleSkillPack(skillPath: string, options: PackOptions): Promise<void> {
-  console.log('');
-  console.log(`Validating ${skillPath}...`);
-
-  const result = await packSkill(skillPath, options.output);
-
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else if (result.success) {
-    console.log(`\u2713 Valid: ${result.name}`);
-    console.log('');
-    console.log('Creating bundle...');
-    console.log(`\u2713 Created: ${basename(result.path!)} (${formatSize(result.size!)})`);
-    console.log(`  SHA256: ${result.sha256}`);
-  } else {
-    console.log(result.error);
-  }
-
-  if (!result.success) {
-    process.exit(1);
-  }
-}

package/src/commands/skills/pull.ts

@@ -1,88 +0,0 @@
-import { writeFileSync } from 'fs';
-import { basename, join } from 'path';
-import { getSkillDownloadInfo, downloadSkillBundle } from '../../lib/api/skills-client.js';
-
-/**
- * Parse skill spec into name and version
- * Examples: @scope/name, @scope/name@1.0.0
- */
-function parseSkillSpec(spec: string): { name: string; version?: string } {
-  // Handle @scope/name@version format
-  const atIndex = spec.lastIndexOf('@');
-
-  // If @ is at position 0, it's just the scope prefix
-  if (atIndex <= 0) {
-    return { name: spec };
-  }
-
-  // Check if the @ is part of version (after the /)
-  const slashIndex = spec.indexOf('/');
-  if (atIndex > slashIndex) {
-    return {
-      name: spec.slice(0, atIndex),
-      version: spec.slice(atIndex + 1),
-    };
-  }
-
-  return { name: spec };
-}
-
-export interface PullOptions {
-  output?: string;
-  json?: boolean;
-}
-
-/**
- * Handle the skill pull command
- */
-export async function handleSkillPull(skillSpec: string, options: PullOptions): Promise<void> {
-  try {
-    const { name, version } = parseSkillSpec(skillSpec);
-
-    // Get download info
-    const downloadInfo = await getSkillDownloadInfo(name, version);
-
-    console.log(
-      `Pulling ${downloadInfo.skill.name}@${downloadInfo.skill.version}...`
-    );
-
-    // Download the bundle
-    const buffer = await downloadSkillBundle(downloadInfo.url, downloadInfo.skill.sha256);
-
-    // Determine output path
-    const filename = `${basename(downloadInfo.skill.name.replace('@', '').replace('/', '-'))}-${downloadInfo.skill.version}.skill`;
-    const outputPath = options.output || join(process.cwd(), filename);
-
-    // Write to disk
-    writeFileSync(outputPath, buffer);
-
-    if (options.json) {
-      console.log(
-        JSON.stringify(
-          {
-            path: outputPath,
-            name: downloadInfo.skill.name,
-            version: downloadInfo.skill.version,
-            size: downloadInfo.skill.size,
-            sha256: downloadInfo.skill.sha256,
-          },
-          null,
-          2
-        )
-      );
-    } else {
-      console.log(`Downloaded ${filename} (${formatSize(downloadInfo.skill.size)})`);
-      console.log(`  SHA256: ${downloadInfo.skill.sha256}`);
-      console.log(`  Path: ${outputPath}`);
-    }
-  } catch (err) {
-    console.error(`Error: ${err instanceof Error ? err.message : err}`);
-    process.exit(1);
-  }
-}
-
-function formatSize(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}

package/src/commands/skills/search.ts

@@ -1,73 +0,0 @@
-import { searchSkills } from '../../lib/api/skills-client.js';
-
-export interface SearchOptions {
-  tags?: string;
-  category?: string;
-  surface?: string;
-  sort?: string;
-  limit?: number;
-  offset?: number;
-  json?: boolean;
-}
-
-/**
- * Handle the skill search command
- */
-export async function handleSkillSearch(query: string, options: SearchOptions): Promise<void> {
-  try {
-    const result = await searchSkills({
-      q: query,
-      tags: options.tags,
-      category: options.category as any,
-      surface: options.surface as any,
-      sort: options.sort as any,
-      limit: options.limit,
-      offset: options.offset,
-    });
-
-    if (options.json) {
-      console.log(JSON.stringify(result, null, 2));
-      return;
-    }
-
-    if (result.skills.length === 0) {
-      console.log(`No skills found for "${query}"`);
-      return;
-    }
-
-    // Table header
-    const nameWidth = 45;
-    const categoryWidth = 12;
-    const downloadsWidth = 10;
-
-    console.log('');
-    console.log(
-      'NAME'.padEnd(nameWidth) +
-        'CATEGORY'.padEnd(categoryWidth) +
-        'DOWNLOADS'.padStart(downloadsWidth)
-    );
-
-    // Table rows
-    for (const skill of result.skills) {
-      const name = skill.name.length > nameWidth - 2
-        ? skill.name.slice(0, nameWidth - 5) + '...'
-        : skill.name;
-      const category = skill.category || '-';
-      const downloads = skill.downloads.toLocaleString();
-
-      console.log(
-        name.padEnd(nameWidth) +
-          category.padEnd(categoryWidth) +
-          downloads.padStart(downloadsWidth)
-      );
-    }
-
-    if (result.pagination.has_more) {
-      console.log('');
-      console.log(`Showing ${result.skills.length} of ${result.total} results. Use --offset to see more.`);
-    }
-  } catch (err) {
-    console.error(`Error: ${err instanceof Error ? err.message : err}`);
-    process.exit(1);
-  }
-}

package/src/commands/skills/show.ts

@@ -1,72 +0,0 @@
-import { getSkillDetails } from '../../lib/api/skills-client.js';
-
-export interface ShowOptions {
-  json?: boolean;
-}
-
-/**
- * Handle the skill show command
- */
-export async function handleSkillShow(name: string, options: ShowOptions): Promise<void> {
-  try {
-    const skill = await getSkillDetails(name);
-
-    if (options.json) {
-      console.log(JSON.stringify(skill, null, 2));
-      return;
-    }
-
-    console.log('');
-    console.log(`${skill.name}@${skill.latest_version}`);
-    console.log('');
-    console.log(skill.description);
-    console.log('');
-
-    // Metadata section
-    console.log('Metadata:');
-    if (skill.license) console.log(`  License: ${skill.license}`);
-    if (skill.category) console.log(`  Category: ${skill.category}`);
-    if (skill.tags && skill.tags.length > 0) console.log(`  Tags: ${skill.tags.join(', ')}`);
-    if (skill.surfaces && skill.surfaces.length > 0)
-      console.log(`  Surfaces: ${skill.surfaces.join(', ')}`);
-    if (skill.author) console.log(`  Author: ${skill.author.name}${skill.author.url ? ` (${skill.author.url})` : ''}`);
-    console.log(`  Downloads: ${skill.downloads.toLocaleString()}`);
-    console.log(`  Published: ${new Date(skill.published_at).toLocaleDateString()}`);
-
-    // Triggers
-    if (skill.triggers && skill.triggers.length > 0) {
-      console.log('');
-      console.log('Triggers:');
-      skill.triggers.forEach((t: string) => console.log(`  - ${t}`));
-    }
-
-    // Examples
-    if (skill.examples && skill.examples.length > 0) {
-      console.log('');
-      console.log('Examples:');
-      skill.examples.forEach((ex: { prompt: string; context?: string }) => {
-        console.log(`  - "${ex.prompt}"${ex.context ? ` (${ex.context})` : ''}`);
-      });
-    }
-
-    // Versions
-    if (skill.versions && skill.versions.length > 0) {
-      console.log('');
-      console.log('Versions:');
-      skill.versions.slice(0, 5).forEach((v: { version: string; published_at: string; downloads: number }) => {
-        console.log(
-          `  ${v.version.padEnd(12)} ${new Date(v.published_at).toLocaleDateString().padEnd(12)} ${v.downloads.toLocaleString()} downloads`
-        );
-      });
-      if (skill.versions.length > 5) {
-        console.log(`  ... and ${skill.versions.length - 5} more`);
-      }
-    }
-
-    console.log('');
-    console.log(`Install: mpak skill install ${skill.name}`);
-  } catch (err) {
-    console.error(`Error: ${err instanceof Error ? err.message : err}`);
-    process.exit(1);
-  }
-}