@shaykec/claude-teach 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaykec/claude-teach",
-  "version": "0.2.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,8 +15,10 @@
     "commander": "^12.0.0",
     "js-yaml": "^4.1.0",
     "chalk": "^5.3.0",
-    "@shaykec/bridge": "0.1.0",
-    "@shaykec/shared": "0.1.0"
+    "@shaykec/bridge": "0.3.0",
+    "@shaykec/shared": "0.1.0",
+    "@shaykec/plugin": "0.1.0",
+    "@shaykec/extension": "0.1.0"
   },
   "publishConfig": {
     "access": "public"

package/src/cli.e2e.helpers.js

@@ -0,0 +1,289 @@
+/**
+ * E2E test helpers for running the claude-teach CLI binary.
+ */
+
+import { execFileSync } from 'child_process';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync, copyFileSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { tmpdir } from 'os';
+import yaml from 'js-yaml';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export const CLI_PATH = resolve(__dirname, 'cli.js');
+export const PROJECT_ROOT = resolve(__dirname, '..', '..', '..');
+const PROGRESS_FILE = '.teach-progress.yaml';
+
+/**
+ * Strip ANSI escape codes from a string.
+ */
+export function stripAnsi(str) {
+  return str.replace(
+    // eslint-disable-next-line no-control-regex
+    /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
+    '',
+  );
+}
+
+/**
+ * Run the CLI binary and capture output.
+ *
+ * @param {string[]} args — CLI arguments
+ * @param {object} [opts]
+ * @param {string} [opts.cwd] — working directory (defaults to PROJECT_ROOT)
+ * @param {object} [opts.env] — extra env vars (merged with process.env)
+ * @param {number} [opts.timeout] — timeout in ms (default 10000)
+ * @param {boolean} [opts.expectError] — if true, don't throw on non-zero exit
+ * @returns {{ stdout: string, stderr: string, exitCode: number }}
+ */
+export function runCli(args, opts = {}) {
+  const {
+    cwd = PROJECT_ROOT,
+    env = {},
+    timeout = 10000,
+    expectError = false,
+  } = opts;
+
+  const mergedEnv = { ...process.env, ...env };
+
+  try {
+    const stdout = execFileSync('node', [CLI_PATH, ...args], {
+      cwd,
+      env: mergedEnv,
+      timeout,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { stdout, stderr: '', exitCode: 0 };
+  } catch (err) {
+    if (expectError || err.status !== null) {
+      return {
+        stdout: err.stdout || '',
+        stderr: err.stderr || '',
+        exitCode: err.status ?? 1,
+      };
+    }
+    throw err;
+  }
+}
+
+/**
+ * Run the package via npx and capture output.
+ *
+ * @param {string[]} args — CLI arguments
+ * @param {object} [opts]
+ * @param {number} [opts.timeout] — timeout in ms (default 30000)
+ * @param {boolean} [opts.expectError] — if true, don't throw on non-zero exit
+ * @returns {{ stdout: string, stderr: string, exitCode: number }}
+ */
+export function runNpx(args, opts = {}) {
+  const { timeout = 30000, expectError = false } = opts;
+
+  try {
+    const stdout = execFileSync('npx', ['@shaykec/claude-teach', ...args], {
+      cwd: PROJECT_ROOT,
+      env: process.env,
+      timeout,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { stdout, stderr: '', exitCode: 0 };
+  } catch (err) {
+    if (expectError || err.status !== null) {
+      return {
+        stdout: err.stdout || '',
+        stderr: err.stderr || '',
+        exitCode: err.status ?? 1,
+      };
+    }
+    throw err;
+  }
+}
+
+/**
+ * Create an isolated temp HOME directory with .claude-teach/ structure.
+ * Marketplace commands use homedir() for paths, so setting HOME isolates them.
+ *
+ * @returns {{ path: string, env: object, cleanup: () => void }}
+ */
+export function createTempHome() {
+  const tmpHome = mkdtempSync(join(tmpdir(), 'teach-e2e-home-'));
+  const teachDir = join(tmpHome, '.claude-teach');
+  const modulesDir = join(teachDir, 'modules');
+  const localDir = join(modulesDir, 'local');
+
+  mkdirSync(localDir, { recursive: true });
+
+  return {
+    path: tmpHome,
+    env: { HOME: tmpHome },
+    cleanup() {
+      rmSync(tmpHome, { recursive: true, force: true });
+    },
+  };
+}
+
+/**
+ * Create a valid test module pack in the given directory.
+ *
+ * @param {string} dir — parent directory to create the pack in
+ * @param {string} name — pack name
+ * @param {string[]} [modules] — module names to create
+ * @returns {string} — path to the created pack
+ */
+export function createTestPack(dir, name, modules = []) {
+  const packDir = join(dir, name);
+  const modulesDir = join(packDir, 'modules');
+  mkdirSync(modulesDir, { recursive: true });
+
+  const packYaml = {
+    name,
+    author: 'test',
+    description: 'Test pack for e2e tests',
+    version: '1.0.0',
+    modules,
+  };
+
+  writeFileSync(
+    join(packDir, 'pack.yaml'),
+    yaml.dump(packYaml, { lineWidth: 120 }),
+    'utf-8',
+  );
+
+  writeFileSync(join(packDir, 'README.md'), `# ${name}\n`, 'utf-8');
+
+  for (const mod of modules) {
+    const moduleDir = join(modulesDir, mod);
+    mkdirSync(moduleDir, { recursive: true });
+
+    const moduleYaml = {
+      slug: mod,
+      title: mod.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
+      version: '1.0.0',
+      description: 'Test module',
+      category: 'developer-skills',
+      tags: ['test'],
+      difficulty: 'beginner',
+      xp: { read: 10 },
+      time: { read: 5 },
+      prerequisites: [],
+      related: [],
+      triggers: [],
+    };
+
+    writeFileSync(
+      join(moduleDir, 'module.yaml'),
+      yaml.dump(moduleYaml, { lineWidth: 120 }),
+      'utf-8',
+    );
+
+    writeFileSync(
+      join(moduleDir, 'content.md'),
+      `# ${moduleYaml.title}\n\nTest content.\n`,
+      'utf-8',
+    );
+  }
+
+  return packDir;
+}
+
+/**
+ * Backup the progress file if it exists.
+ * @returns {string|null} — path to backup, or null if no file existed
+ */
+export function backupProgress() {
+  const filePath = join(PROJECT_ROOT, PROGRESS_FILE);
+  if (!existsSync(filePath)) return null;
+
+  const backupPath = join(PROJECT_ROOT, `${PROGRESS_FILE}.e2e-backup`);
+  copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+
+/**
+ * Restore the progress file from backup, or remove it if no backup existed.
+ * @param {string|null} backupPath — path from backupProgress()
+ */
+export function restoreProgress(backupPath) {
+  const filePath = join(PROJECT_ROOT, PROGRESS_FILE);
+
+  if (backupPath && existsSync(backupPath)) {
+    copyFileSync(backupPath, filePath);
+    rmSync(backupPath, { force: true });
+  } else {
+    // No backup means file didn't exist before — remove any created during test
+    if (existsSync(filePath)) rmSync(filePath, { force: true });
+  }
+}
+
+/**
+ * Write a seeded progress file for testing.
+ * @param {object} progress — progress data
+ */
+export function seedProgress(progress) {
+  const filePath = join(PROJECT_ROOT, PROGRESS_FILE);
+  writeFileSync(filePath, yaml.dump(progress, { lineWidth: 120, noRefs: true }), 'utf-8');
+}
+
+/**
+ * Create a bare git repo with a valid pack.yaml for testing install.
+ * @param {string} parentDir — directory to create the fixture in
+ * @param {string} packName — pack name
+ * @param {string[]} [modules] — module names
+ * @returns {string} — file:// URL to the bare repo
+ */
+export function createGitFixture(parentDir, packName, modules = []) {
+  const bareRepo = join(parentDir, `${packName}.git`);
+  const tmpClone = join(parentDir, `${packName}-clone`);
+
+  // Create bare repo
+  execFileSync('git', ['init', '--bare', bareRepo], { stdio: 'pipe' });
+
+  // Clone, add content, push
+  execFileSync('git', ['clone', bareRepo, tmpClone], { stdio: 'pipe' });
+
+  // Create pack structure in clone
+  createTestPack(tmpClone, '.', modules);
+
+  // Move files up (createTestPack creates a subdirectory, but we want them at root)
+  // Actually, createTestPack creates in dir/name, so for root we need to handle differently
+  // Let's just write the files directly
+  const modulesDir = join(tmpClone, 'modules');
+  if (!existsSync(modulesDir)) mkdirSync(modulesDir, { recursive: true });
+
+  const packYaml = {
+    name: packName,
+    author: 'test',
+    description: 'Test fixture pack',
+    version: '1.0.0',
+    modules,
+  };
+  writeFileSync(join(tmpClone, 'pack.yaml'), yaml.dump(packYaml), 'utf-8');
+
+  for (const mod of modules) {
+    const moduleDir = join(modulesDir, mod);
+    mkdirSync(moduleDir, { recursive: true });
+    writeFileSync(join(moduleDir, 'module.yaml'), yaml.dump({
+      slug: mod,
+      title: mod,
+      version: '1.0.0',
+      description: 'test',
+      category: 'developer-skills',
+      difficulty: 'beginner',
+      xp: { read: 10 },
+    }), 'utf-8');
+    writeFileSync(join(moduleDir, 'content.md'), `# ${mod}\n`, 'utf-8');
+  }
+
+  // Git add + commit + push
+  execFileSync('git', ['-C', tmpClone, 'add', '.'], { stdio: 'pipe' });
+  execFileSync('git', ['-C', tmpClone, '-c', 'user.name=test', '-c', 'user.email=test@test.com', 'commit', '-m', 'init'], { stdio: 'pipe' });
+  execFileSync('git', ['-C', tmpClone, 'push'], { stdio: 'pipe' });
+
+  // Clean up the clone
+  rmSync(tmpClone, { recursive: true, force: true });
+
+  return `file://${bareRepo}`;
+}