@shaykec/claude-teach 0.6.1 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaykec/claude-teach",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Socratic AI teaching platform — learn anything through guided dialogue, visual canvas, and gamification",
   "type": "module",
   "main": "src/cli.js",

package/src/author.js

@@ -272,7 +272,38 @@ export async function validatePack(packPath, builtinSlugs = []) {
     }
   }
 
-  // 4. Validate prerequisites
+  // 4. Validate media entries
+  for (const dirName of actualDirs) {
+    const moduleYamlPath = join(modulesDir, dirName, 'module.yaml');
+    if (!existsSync(moduleYamlPath)) continue;
+    try {
+      const mod = yaml.load(readFileSync(moduleYamlPath, 'utf-8'));
+      if (Array.isArray(mod.media)) {
+        for (let i = 0; i < mod.media.length; i++) {
+          const entry = mod.media[i];
+          const prefix = `modules/${dirName}: media[${i}]`;
+          if (!entry.url) {
+            errors.push(`${prefix}: missing "url" field`);
+          } else if (!/^https?:\/\/.+/.test(entry.url)) {
+            warnings.push(`${prefix}: url should be a full URL (got "${entry.url}")`);
+          }
+          if (!entry.type) {
+            warnings.push(`${prefix}: missing "type" field (image, video, audio, link)`);
+          }
+          if (entry.type === 'image' && !entry.alt) {
+            warnings.push(`${prefix}: images should have "alt" text for accessibility`);
+          }
+          if ((entry.type === 'audio' || entry.type === 'video') && !entry.label && !entry.title) {
+            warnings.push(`${prefix}: audio/video should have "label" or "title"`);
+          }
+        }
+      }
+    } catch {
+      // Already reported parse error above
+    }
+  }
+
+  // 5. Validate prerequisites
   const validSlugs = new Set([...allPackSlugs, ...builtinSlugs]);
   for (const dirName of actualDirs) {
     const moduleYamlPath = join(modulesDir, dirName, 'module.yaml');

package/src/author.test.js

@@ -0,0 +1,200 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { validatePack } from './author.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import yaml from 'js-yaml';
+
+describe('validatePack — media validation', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'teach-author-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function createPack(modules = {}) {
+    const packDir = path.join(tmpDir, 'test-pack');
+    const modulesDir = path.join(packDir, 'modules');
+    fs.mkdirSync(modulesDir, { recursive: true });
+
+    const moduleNames = Object.keys(modules);
+    fs.writeFileSync(
+      path.join(packDir, 'pack.yaml'),
+      yaml.dump({ name: 'test-pack', version: '1.0.0', modules: moduleNames }),
+      'utf-8',
+    );
+
+    for (const [name, meta] of Object.entries(modules)) {
+      const modDir = path.join(modulesDir, name);
+      fs.mkdirSync(modDir, { recursive: true });
+
+      const defaults = {
+        slug: name,
+        title: name,
+        description: 'Test module',
+        category: 'test',
+        difficulty: 'beginner',
+        tags: [],
+        xp: { read: 10 },
+        time: { read: 5 },
+        prerequisites: [],
+        related: [],
+        triggers: [],
+      };
+
+      fs.writeFileSync(
+        path.join(modDir, 'module.yaml'),
+        yaml.dump({ ...defaults, ...meta }),
+        'utf-8',
+      );
+      fs.writeFileSync(path.join(modDir, 'content.md'), '# Content\n', 'utf-8');
+    }
+
+    return packDir;
+  }
+
+  it('passes with valid media entries', async () => {
+    const packDir = createPack({
+      'media-mod': {
+        media: [
+          { url: 'https://example.com/img.png', type: 'image', alt: 'A diagram' },
+          { url: 'https://youtube.com/watch?v=abc', type: 'video', title: 'Tutorial' },
+        ],
+      },
+    });
+
+    const result = await validatePack(packDir);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    // No warnings for properly filled media entries
+    const mediaWarnings = result.warnings.filter(w => w.includes('media'));
+    expect(mediaWarnings).toHaveLength(0);
+  });
+
+  it('errors when media entry is missing url', async () => {
+    const packDir = createPack({
+      'bad-media': {
+        media: [
+          { type: 'image', alt: 'Missing URL' },
+        ],
+      },
+    });
+
+    const result = await validatePack(packDir);
+    expect(result.errors.some(e => e.includes('media[0]') && e.includes('missing "url"'))).toBe(true);
+  });
+
+  it('warns when media url is not a full URL', async () => {
+    const packDir = createPack({
+      'relative-url': {
+        media: [
+          { url: 'media/img.png', type: 'image', alt: 'Relative' },
+        ],
+      },
+    });
+
+    const result = await validatePack(packDir);
+    expect(result.warnings.some(w => w.includes('media[0]') && w.includes('full URL'))).toBe(true);
+  });
+
+  it('warns when media entry is missing type', async () => {
+    const packDir = createPack({
+      'no-type': {
+        media: [
+          { url: 'https://example.com/img.png', alt: 'No type' },
+        ],
+      },
+    });
+
+    const result = await validatePack(packDir);
+    expect(result.warnings.some(w => w.includes('media[0]') && w.includes('missing "type"'))).toBe(true);
+  });
+
+  it('warns when image is missing alt text', async () => {
+    const packDir = createPack({
+      'no-alt': {
+        media: [
+          { url: 'https://example.com/img.png', type: 'image' },
+        ],
+      },
+    });
+
+    const result = await validatePack(packDir);
+    expect(result.warnings.some(w => w.includes('media[0]') && w.includes('alt'))).toBe(true);
+  });
+
+  it('warns when audio/video is missing label or title', async () => {
+    const packDir = createPack({
+      'no-label': {
+        media: [
+          { url: 'https://example.com/sound.mp3', type: 'audio' },
+          { url: 'https://youtube.com/watch?v=xyz', type: 'video' },
+        ],
+      },
+    });
+
+    const result = await validatePack(packDir);
+    expect(result.warnings.some(w => w.includes('media[0]') && w.includes('label'))).toBe(true);
+    expect(result.warnings.some(w => w.includes('media[1]') && w.includes('label'))).toBe(true);
+  });
+
+  it('does not warn for audio/video with label field', async () => {
+    const packDir = createPack({
+      'with-label': {
+        media: [
+          { url: 'https://example.com/sound.mp3', type: 'audio', label: 'Achievement' },
+        ],
+      },
+    });
+
+    const result = await validatePack(packDir);
+    const mediaWarnings = result.warnings.filter(w => w.includes('media'));
+    expect(mediaWarnings).toHaveLength(0);
+  });
+
+  it('does not warn for audio/video with title field', async () => {
+    const packDir = createPack({
+      'with-title': {
+        media: [
+          { url: 'https://youtube.com/watch?v=abc', type: 'video', title: 'Tutorial' },
+        ],
+      },
+    });
+
+    const result = await validatePack(packDir);
+    const mediaWarnings = result.warnings.filter(w => w.includes('media'));
+    expect(mediaWarnings).toHaveLength(0);
+  });
+
+  it('validates multiple media entries independently', async () => {
+    const packDir = createPack({
+      'multi-media': {
+        media: [
+          { url: 'https://example.com/img.png', type: 'image', alt: 'Valid' },
+          { type: 'audio' }, // missing url
+          { url: 'https://example.com/img2.png', type: 'image' }, // missing alt
+        ],
+      },
+    });
+
+    const result = await validatePack(packDir);
+    expect(result.errors.some(e => e.includes('media[1]') && e.includes('missing "url"'))).toBe(true);
+    expect(result.warnings.some(w => w.includes('media[2]') && w.includes('alt'))).toBe(true);
+    // First entry should have no issues
+    expect(result.errors.some(e => e.includes('media[0]'))).toBe(false);
+    expect(result.warnings.some(w => w.includes('media[0]'))).toBe(false);
+  });
+
+  it('passes when module has no media section', async () => {
+    const packDir = createPack({
+      'no-media': {},
+    });
+
+    const result = await validatePack(packDir);
+    expect(result.valid).toBe(true);
+  });
+});

package/src/registry.js

@@ -196,6 +196,16 @@ function detectCapabilities(modulePath) {
   if (existsSync(join(modulePath, 'exercises.md'))) caps.push('exercises');
   if (existsSync(join(modulePath, 'quiz.md'))) caps.push('quiz');
   if (existsSync(join(modulePath, 'quick-ref.md'))) caps.push('quick-ref');
+  if (existsSync(join(modulePath, 'resources.md'))) caps.push('resources');
+
+  // Check for media entries in module.yaml
+  try {
+    const raw = readFileSync(join(modulePath, 'module.yaml'), 'utf-8');
+    const meta = yaml.load(raw);
+    if (Array.isArray(meta?.media) && meta.media.length > 0) caps.push('media');
+  } catch {
+    // Ignore — module.yaml already read elsewhere
+  }
 
   return caps;
 }

package/src/registry.test.js

@@ -290,6 +290,61 @@ describe('buildRegistry (filesystem)', () => {
     expect(mod.title).toBe('Fallback Module');
   });
 
+  it('should detect resources capability when resources.md exists', async () => {
+    const moduleDir = createModule('res-test');
+    fs.writeFileSync(path.join(moduleDir, 'resources.md'), '# Resources\n\n## Videos\n- [Example](https://example.com)\n', 'utf-8');
+
+    const { buildRegistry } = await import('./registry.js');
+    const registry = await buildRegistry(tmpDir);
+
+    const mod = registry.modules.find(m => m.slug === 'res-test');
+    expect(mod.capabilities).toContain('resources');
+  });
+
+  it('should not detect resources capability when resources.md is absent', async () => {
+    createModule('no-res-test');
+
+    const { buildRegistry } = await import('./registry.js');
+    const registry = await buildRegistry(tmpDir);
+
+    const mod = registry.modules.find(m => m.slug === 'no-res-test');
+    expect(mod.capabilities).not.toContain('resources');
+  });
+
+  it('should detect media capability when module.yaml has media entries', async () => {
+    createModule('media-test', {
+      media: [
+        { url: 'https://example.com/img.png', type: 'image', alt: 'Test image' },
+      ],
+    });
+
+    const { buildRegistry } = await import('./registry.js');
+    const registry = await buildRegistry(tmpDir);
+
+    const mod = registry.modules.find(m => m.slug === 'media-test');
+    expect(mod.capabilities).toContain('media');
+  });
+
+  it('should not detect media capability when media array is empty', async () => {
+    createModule('no-media-test', { media: [] });
+
+    const { buildRegistry } = await import('./registry.js');
+    const registry = await buildRegistry(tmpDir);
+
+    const mod = registry.modules.find(m => m.slug === 'no-media-test');
+    expect(mod.capabilities).not.toContain('media');
+  });
+
+  it('should not detect media capability when media field is absent', async () => {
+    createModule('absent-media-test');
+
+    const { buildRegistry } = await import('./registry.js');
+    const registry = await buildRegistry(tmpDir);
+
+    const mod = registry.modules.find(m => m.slug === 'absent-media-test');
+    expect(mod.capabilities).not.toContain('media');
+  });
+
   it('should skip directories without module.yaml', async () => {
     // Create a directory without module.yaml
     const emptyDir = path.join(tmpDir, 'packages', 'modules', 'no-yaml');