@shaykec/claude-teach 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaykec/claude-teach",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Socratic AI teaching platform — learn anything through guided dialogue, visual canvas, and gamification",
   "type": "module",
   "main": "src/cli.js",
@@ -15,7 +15,7 @@
     "commander": "^12.0.0",
     "js-yaml": "^4.1.0",
     "chalk": "^5.3.0",
-    "@shaykec/bridge": "0.2.0",
+    "@shaykec/bridge": "0.3.0",
     "@shaykec/shared": "0.1.0",
     "@shaykec/plugin": "0.1.0",
     "@shaykec/extension": "0.1.0"

package/src/cli.e2e.test.js

@@ -2,7 +2,7 @@
  * Level 1 E2E tests — run the claude-teach CLI binary and assert on output.
  */
 
-import { describe, it, expect, beforeEach, afterEach, beforeAll } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, beforeAll, afterAll } from 'vitest';
 import { spawn } from 'child_process';
 import { existsSync, mkdtempSync, rmSync } from 'fs';
 import { join } from 'path';
@@ -638,36 +638,325 @@ describe('CLI E2E: npx @shaykec/claude-teach', () => {
 });
 
 // =====================================================================
-//  Group H — Plugin integration (setup + start)
+//  Group H — Setup command (all options)
 // =====================================================================
 
-describe('CLI E2E: Plugin integration', () => {
-  it('setup outputs plugin and extension paths', () => {
+describe('CLI E2E: Setup command', () => {
+  it('setup --show-path outputs plugin path containing packages/plugin', () => {
     const { stdout, exitCode } = runCli(['setup', '--show-path']);
     expect(exitCode).toBe(0);
     expect(stdout.trim()).toContain('packages/plugin');
   });
 
-  it('setup shows checklist with plugin and extension info', () => {
-    // setup without --show-path prints the full checklist but also
-    // starts the bridge + opens browser. We can't let it do that in tests.
-    // Instead, just test --show-path (machine-readable) works.
+  it('setup --show-path outputs an absolute path', () => {
     const { stdout, exitCode } = runCli(['setup', '--show-path']);
     expect(exitCode).toBe(0);
-    expect(stdout.trim().length).toBeGreaterThan(0);
+    expect(stdout.trim()).toMatch(/^\//); // starts with /
   });
 
-  it('start --help shows command description', () => {
+  it('setup --show-path path actually has plugin.json', () => {
+    const { stdout, exitCode } = runCli(['setup', '--show-path']);
+    expect(exitCode).toBe(0);
+    const pluginDir = stdout.trim();
+    expect(existsSync(join(pluginDir, '.claude-plugin', 'plugin.json'))).toBe(true);
+  });
+
+  it('setup --help shows all options', () => {
+    const { stdout, exitCode } = runCli(['setup', '--help']);
+    expect(exitCode).toBe(0);
+    const clean = stripAnsi(stdout);
+    expect(clean).toContain('Check environment');
+    expect(clean).toContain('--show-path');
+    expect(clean).toContain('--extension');
+  });
+
+  it('start --help shows command description and options', () => {
     const { stdout, exitCode } = runCli(['start', '--help']);
     expect(exitCode).toBe(0);
     const clean = stripAnsi(stdout);
     expect(clean).toContain('Launch Claude Code');
+    expect(clean).toContain('--no-server');
+    expect(clean).toContain('--port');
   });
+});
 
-  it('setup --help shows command description', () => {
-    const { stdout, exitCode } = runCli(['setup', '--help']);
+// =====================================================================
+//  Group I — Start command (spawn-based, no actual Claude)
+// =====================================================================
+
+describe('CLI E2E: Start command', () => {
+  it('start --no-server fails gracefully when claude is not on PATH', () => {
+    // Build a PATH that includes node but excludes claude
+    const nodeBinDir = join(process.execPath, '..');
+    const { exitCode, stderr, stdout } = runCli(['start', '--no-server'], {
+      env: { PATH: `${nodeBinDir}:/usr/bin:/bin` },
+      expectError: true,
+      timeout: 10000,
+    });
+    const output = stripAnsi(stdout + stderr);
+    // Should fail because claude is not found on this restricted PATH
+    expect(exitCode).not.toBe(0);
+    expect(output).toContain('Claude Code CLI not found');
+  });
+
+  it('start spawns bridge server on custom port', async () => {
+    const port = 14456 + Math.floor(Math.random() * 1000);
+    // Spawn start with a bogus claude path to test bridge startup
+    // Use a wrapper script that just exits so we can verify bridge started
+    const child = spawn('node', [
+      join(PROJECT_ROOT, 'packages/core/src/cli.js'),
+      'start',
+      '--port', String(port),
+    ], {
+      cwd: PROJECT_ROOT,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    child.stdout.on('data', (d) => { stdout += d.toString(); });
+
+    try {
+      // Wait a bit for the bridge to start
+      let bridgeStarted = false;
+      for (let i = 0; i < 10; i++) {
+        await new Promise(r => setTimeout(r, 500));
+        try {
+          const resp = await fetch(`http://localhost:${port}/health`);
+          if (resp.ok) {
+            bridgeStarted = true;
+            break;
+          }
+        } catch { /* not ready */ }
+      }
+
+      // If claude is installed, bridge should have started
+      // If claude is not installed, the process exits with error before bridge starts
+      // Either way, the test should not fail - just verify the behavior
+      const cleanOutput = stripAnsi(stdout);
+      if (bridgeStarted) {
+        const resp = await fetch(`http://localhost:${port}/health`);
+        const data = await resp.json();
+        expect(data).toHaveProperty('status', 'ok');
+      } else {
+        // Process exited because claude is not on PATH — valid behavior
+        expect(true).toBe(true);
+      }
+    } finally {
+      child.kill('SIGTERM');
+      await new Promise(resolve => child.on('close', resolve));
+    }
+  }, 15000);
+});
+
+// =====================================================================
+//  Group J — Bridge server /api/open-extension endpoint
+// =====================================================================
+
+describe('CLI E2E: Bridge API endpoints', () => {
+  let port;
+  let child;
+
+  beforeAll(async () => {
+    port = 15456 + Math.floor(Math.random() * 1000);
+    child = spawn('node', [
+      join(PROJECT_ROOT, 'packages/core/src/cli.js'),
+      'serve',
+      '--port', String(port),
+    ], {
+      cwd: PROJECT_ROOT,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    // Wait for server to be ready
+    for (let i = 0; i < 20; i++) {
+      await new Promise(r => setTimeout(r, 500));
+      try {
+        const resp = await fetch(`http://localhost:${port}/health`);
+        if (resp.ok) break;
+      } catch { /* not ready */ }
+    }
+  }, 15000);
+
+  afterAll(async () => {
+    if (child) {
+      child.kill('SIGTERM');
+      await new Promise(resolve => child.on('close', resolve));
+    }
+  });
+
+  it('POST /api/open-extension returns ok with extension path', async () => {
+    const resp = await fetch(`http://localhost:${port}/api/open-extension`, {
+      method: 'POST',
+    });
+    const data = await resp.json();
+    expect(resp.status).toBe(200);
+    expect(data.ok).toBe(true);
+    expect(data.path).toContain('extension');
+  });
+
+  it('GET /health returns status ok and tier info', async () => {
+    const resp = await fetch(`http://localhost:${port}/health`);
+    const data = await resp.json();
+    expect(resp.status).toBe(200);
+    expect(data.status).toBe('ok');
+    expect(data).toHaveProperty('tier');
+    expect(data).toHaveProperty('uptime');
+  });
+
+  it('GET /api/tier returns tier info', async () => {
+    const resp = await fetch(`http://localhost:${port}/api/tier`);
+    const data = await resp.json();
+    expect(resp.status).toBe(200);
+    expect(data).toHaveProperty('tier');
+  });
+
+  it('GET /api/progress returns progress data', async () => {
+    const resp = await fetch(`http://localhost:${port}/api/progress`);
+    const data = await resp.json();
+    expect(resp.status).toBe(200);
+    // Default empty progress
+    expect(data).toHaveProperty('user');
+  });
+
+  it('GET /api/events returns empty events array', async () => {
+    const resp = await fetch(`http://localhost:${port}/api/events`);
+    const data = await resp.json();
+    expect(resp.status).toBe(200);
+    expect(data).toHaveProperty('events');
+    expect(Array.isArray(data.events)).toBe(true);
+    expect(data).toHaveProperty('count');
+  });
+
+  it('GET /api/templates returns templates list', async () => {
+    const resp = await fetch(`http://localhost:${port}/api/templates`);
+    const data = await resp.json();
+    expect(resp.status).toBe(200);
+    expect(data).toHaveProperty('templates');
+    expect(Array.isArray(data.templates)).toBe(true);
+  });
+
+  it('POST /api/event with invalid body returns 400', async () => {
+    const resp = await fetch(`http://localhost:${port}/api/event`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: 'not-json',
+    });
+    expect(resp.status).toBe(400);
+  });
+
+  it('POST /api/capture saves a capture file', async () => {
+    const resp = await fetch(`http://localhost:${port}/api/capture`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: 'test-capture', content: 'hello' }),
+    });
+    const data = await resp.json();
+    expect(resp.status).toBe(200);
+    expect(data.ok).toBe(true);
+    expect(data.saved).toContain('test-capture');
+  });
+
+  it('GET /nonexistent returns 404', async () => {
+    const resp = await fetch(`http://localhost:${port}/nonexistent.xyz`);
+    expect(resp.status).toBe(404);
+  });
+
+  it('OPTIONS returns 204 (CORS preflight)', async () => {
+    const resp = await fetch(`http://localhost:${port}/api/event`, {
+      method: 'OPTIONS',
+    });
+    expect(resp.status).toBe(204);
+  });
+});
+
+// =====================================================================
+//  Group K — All CLI subcommand help texts
+// =====================================================================
+
+describe('CLI E2E: Subcommand help texts', () => {
+  const subcommands = [
+    { args: ['list', '--help'], contains: 'List available learning modules' },
+    { args: ['get', '--help'], contains: 'Get module content' },
+    { args: ['stats', '--help'], contains: 'gamification dashboard' },
+    { args: ['level-up', '--help'], contains: 'belt roadmap' },
+    { args: ['serve', '--help'], contains: 'bridge server' },
+    { args: ['inbox', '--help'], contains: 'captured from the browser' },
+    { args: ['start', '--help'], contains: 'Launch Claude Code' },
+    { args: ['setup', '--help'], contains: 'Check environment' },
+    { args: ['registry:build', '--help'], contains: 'Rebuild the module registry' },
+    { args: ['install', '--help'], contains: 'Install a module pack' },
+    { args: ['packs', '--help'], contains: 'installed module packs' },
+    { args: ['update', '--help'], contains: 'Update an installed module pack' },
+    { args: ['remove', '--help'], contains: 'Remove an installed module pack' },
+    { args: ['search', '--help'], contains: 'Search configured registries' },
+    { args: ['author', '--help'], contains: 'authoring tools' },
+  ];
+
+  for (const { args, contains } of subcommands) {
+    it(`${args[0]} --help shows description`, () => {
+      const { stdout, exitCode } = runCli(args);
+      expect(exitCode).toBe(0);
+      expect(stripAnsi(stdout)).toContain(contains);
+    });
+  }
+});
+
+// =====================================================================
+//  Group L — Comprehensive npx tests (all commands)
+// =====================================================================
+
+describe('CLI E2E: npx comprehensive', () => {
+  it('npx setup --show-path resolves plugin via npm', () => {
+    const { stdout, exitCode } = runNpx(['setup', '--show-path'], { timeout: 60000 });
+    expect(exitCode).toBe(0);
+    expect(stdout.trim()).toContain('plugin');
+    expect(stdout.trim().length).toBeGreaterThan(5);
+  });
+
+  it('npx start --help shows launch description', () => {
+    const { stdout, exitCode } = runNpx(['start', '--help'], { timeout: 60000 });
+    expect(exitCode).toBe(0);
+    expect(stripAnsi(stdout)).toContain('Launch Claude Code');
+  });
+
+  it('npx setup --help shows setup options', () => {
+    const { stdout, exitCode } = runNpx(['setup', '--help'], { timeout: 60000 });
     expect(exitCode).toBe(0);
     const clean = stripAnsi(stdout);
-    expect(clean).toContain('Check environment');
+    expect(clean).toContain('--show-path');
+    expect(clean).toContain('--extension');
+  });
+
+  it('npx level-up outputs recommendations', () => {
+    const { stdout, exitCode } = runNpx(['level-up'], { timeout: 60000 });
+    expect(exitCode).toBe(0);
+    expect(stdout.trim().length).toBeGreaterThan(20);
+  });
+
+  it('npx get git --quick outputs quick reference', () => {
+    const { stdout, exitCode } = runNpx(['get', 'git', '--quick'], { timeout: 60000 });
+    expect(exitCode).toBe(0);
+    expect(stdout.length).toBeGreaterThan(50);
+  });
+
+  it('npx get nonexistent-module fails with exit 1', () => {
+    const { exitCode, stderr } = runNpx(['get', 'nonexistent-module-xyz'], {
+      timeout: 60000,
+      expectError: true,
+    });
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain('not found');
+  });
+
+  it('npx list --difficulty beginner shows filtered modules', () => {
+    const { stdout, exitCode } = runNpx(['list', '--difficulty', 'beginner'], { timeout: 60000 });
+    expect(exitCode).toBe(0);
+    expect(stripAnsi(stdout)).toContain('git');
+  });
+
+  it('npx registry:build rebuilds registry', () => {
+    const { stdout, exitCode } = runNpx(['registry:build'], { timeout: 60000 });
+    expect(exitCode).toBe(0);
+    expect(stripAnsi(stdout)).toContain('Registry rebuilt');
   });
 });