claude-code-tutor 1.0.0

package/dist/cli.js

@@ -0,0 +1,1362 @@
+#!/usr/bin/env node
+import {
+  getMetaPath,
+  getVersion,
+  isStale,
+  readMeta,
+  writeMeta
+} from "./chunk-OYDUGORC.js";
+import {
+  getBaseDir,
+  readMemory,
+  updateMemory,
+  writeMemory
+} from "./chunk-A6ZZXTHB.js";
+
+// src/cli.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
+import { createInterface } from "readline";
+
+// src/config/skills-registry.ts
+var SKILLS_REGISTRY = [
+  // ── STATIC SKILLS (tutor and learning path) ──────────────────
+  {
+    id: "cc-tutor",
+    sourceUrl: null,
+    name: "cc-tutor",
+    description: "Tutor interactivo de Claude Code. \xDAsame cuando el usuario parezca ser nuevo en Claude Code, pregunte c\xF3mo empezar, qu\xE9 puede hacer, c\xF3mo funciona, o pida que lo gu\xEDes o ense\xF1es. Tambi\xE9n respondo sobre hooks, MCP, sub-agents y features avanzadas. Detecto el idioma del usuario autom\xE1ticamente y me adapto.",
+    splitStrategy: "none",
+    tokenBudget: 900,
+    priority: "critical",
+    static: true
+  },
+  {
+    id: "cc-learning-path",
+    sourceUrl: null,
+    name: "cc-learning-path",
+    description: "Ruta de aprendizaje estructurada de Claude Code por niveles: beginner, intermediate y advanced. \xDAsame cuando el usuario quiera ver el curr\xEDculo completo, saber qu\xE9 aprender despu\xE9s, o pida un plan de estudio. Inv\xF3came con /cc-learning-path.",
+    splitStrategy: "none",
+    tokenBudget: 700,
+    priority: "high",
+    static: true
+  },
+  // ── CRITICAL (from official docs) ────────────────────────────
+  {
+    id: "cc-changelog",
+    sourceUrl: "https://code.claude.com/docs/en/changelog.md",
+    name: "cc-changelog",
+    description: "Changelog y novedades recientes de Claude Code. \xDAsame cuando pregunten qu\xE9 hay de nuevo, qu\xE9 cambi\xF3 en una versi\xF3n, o qu\xE9 features se agregaron recientemente.",
+    splitStrategy: "none",
+    tokenBudget: 800,
+    priority: "critical"
+  },
+  {
+    id: "cc-hooks-events",
+    sourceUrl: "https://code.claude.com/docs/en/hooks.md",
+    name: "cc-hooks-events",
+    description: "Tabla de todos los hook events de Claude Code: SessionStart, PreToolUse, PostToolUse, Stop, Notification, ConfigChange, FileChanged, CwdChanged, WorktreeCreate, Elicitation y m\xE1s. Cu\xE1ndo se dispara cada uno.",
+    splitStrategy: "manual",
+    manualSections: [
+      {
+        id: "cc-hooks-events",
+        heading: "Hook lifecycle",
+        description: "Tabla de eventos y cu\xE1ndo se disparan"
+      },
+      {
+        id: "cc-hooks-config",
+        heading: "Configuration",
+        description: "Configuraci\xF3n de hooks en settings.json, matchers, campos"
+      },
+      {
+        id: "cc-hooks-io",
+        heading: "Hook input and output",
+        description: "Esquemas JSON de input/output, exit codes, decisiones"
+      }
+    ],
+    priority: "critical"
+  },
+  {
+    id: "cc-hooks-guide",
+    sourceUrl: "https://code.claude.com/docs/en/hooks-guide.md",
+    name: "cc-hooks-guide",
+    description: "Gu\xEDa pr\xE1ctica de hooks con ejemplos: notificaciones, auto-format, bloquear archivos, re-inyectar contexto, auto-approve.",
+    splitStrategy: "none",
+    tokenBudget: 700,
+    priority: "critical"
+  },
+  {
+    id: "cc-mcp",
+    sourceUrl: "https://code.claude.com/docs/en/mcp.md",
+    name: "cc-mcp",
+    description: "Configuraci\xF3n de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticaci\xF3n OAuth, tool search, managed MCP, recursos y prompts MCP.",
+    splitStrategy: "sections",
+    tokenBudget: 700,
+    priority: "critical"
+  },
+  {
+    id: "cc-settings",
+    sourceUrl: "https://code.claude.com/docs/en/settings.md",
+    name: "cc-settings",
+    description: "Todas las opciones de configuraci\xF3n de Claude Code en settings.json: permisos, hooks, plugins, sandbox, env vars, precedencia de scopes.",
+    splitStrategy: "sections",
+    tokenBudget: 700,
+    priority: "critical"
+  },
+  {
+    id: "cc-permissions",
+    sourceUrl: "https://code.claude.com/docs/en/permissions.md",
+    name: "cc-permissions",
+    description: "Sistema de permisos de Claude Code: sintaxis de reglas, modos (auto, plan, bypassPermissions), tool-specific rules, wildcards.",
+    splitStrategy: "none",
+    tokenBudget: 600,
+    priority: "critical"
+  },
+  // ── HIGH PRIORITY ─────────────────────────────────────────────
+  {
+    id: "cc-sub-agents",
+    sourceUrl: "https://code.claude.com/docs/en/sub-agents.md",
+    name: "cc-sub-agents",
+    description: "Configuraci\xF3n de sub-agents en Claude Code: frontmatter fields, modelos, tools disponibles, persistent memory, hooks en subagents.",
+    splitStrategy: "none",
+    tokenBudget: 700,
+    priority: "high"
+  },
+  {
+    id: "cc-agent-teams",
+    sourceUrl: "https://code.claude.com/docs/en/agent-teams.md",
+    name: "cc-agent-teams",
+    description: "Agent teams en Claude Code: coordinar m\xFAltiples sesiones, asignar tareas, hablar con teammates, display modes, token costs.",
+    splitStrategy: "none",
+    tokenBudget: 600,
+    priority: "high"
+  },
+  {
+    id: "cc-skills-guide",
+    sourceUrl: "https://code.claude.com/docs/en/skills.md",
+    name: "cc-skills-guide",
+    description: "C\xF3mo crear y configurar Skills en Claude Code: frontmatter, invocation control, subagent skills, path-specific, bundled skills.",
+    splitStrategy: "none",
+    tokenBudget: 600,
+    priority: "high"
+  },
+  {
+    id: "cc-memory",
+    sourceUrl: "https://code.claude.com/docs/en/memory.md",
+    name: "cc-memory",
+    description: "CLAUDE.md y auto-memory en Claude Code: d\xF3nde poner archivos, import de archivos adicionales, rules directory, gesti\xF3n para equipos.",
+    splitStrategy: "none",
+    tokenBudget: 600,
+    priority: "high"
+  },
+  {
+    id: "cc-cli-reference",
+    sourceUrl: "https://code.claude.com/docs/en/cli-reference.md",
+    name: "cc-cli-reference",
+    description: "Referencia completa CLI de Claude Code: flags, comandos, system prompt flags, opciones de headless.",
+    splitStrategy: "none",
+    tokenBudget: 500,
+    priority: "high"
+  },
+  {
+    id: "cc-commands",
+    sourceUrl: "https://code.claude.com/docs/en/commands.md",
+    name: "cc-commands",
+    description: "Comandos built-in de Claude Code: /batch, /debug, /loop, /simplify, /claude-api, /compact, /memory y m\xE1s.",
+    splitStrategy: "none",
+    tokenBudget: 500,
+    priority: "high"
+  },
+  {
+    id: "cc-model-config",
+    sourceUrl: "https://code.claude.com/docs/en/model-config.md",
+    name: "cc-model-config",
+    description: "Configuraci\xF3n de modelos en Claude Code: aliases (opusplan, fast-mode), restrict model selection, extended context, env vars para pinning.",
+    splitStrategy: "none",
+    tokenBudget: 500,
+    priority: "high"
+  },
+  // ── MEDIUM PRIORITY ────────────────────────────────────────────
+  {
+    id: "cc-plugins",
+    sourceUrl: "https://code.claude.com/docs/en/plugins.md",
+    name: "cc-plugins",
+    description: "Crear plugins para Claude Code: estructura, skills, LSP servers, MCP servers incluidos, distribuci\xF3n en marketplaces.",
+    splitStrategy: "none",
+    tokenBudget: 600,
+    priority: "medium"
+  },
+  {
+    id: "cc-channels",
+    sourceUrl: "https://code.claude.com/docs/en/channels.md",
+    name: "cc-channels",
+    description: "Channels en Claude Code: push events a sesiones activas, webhooks, alertas de CI, chat messages desde MCP server.",
+    splitStrategy: "none",
+    tokenBudget: 500,
+    priority: "medium"
+  },
+  {
+    id: "cc-scheduled-tasks",
+    sourceUrl: "https://code.claude.com/docs/en/scheduled-tasks.md",
+    name: "cc-scheduled-tasks",
+    description: "Tareas programadas en Claude Code: /loop, cron syntax, one-time reminders, gesti\xF3n de tasks recurrentes.",
+    splitStrategy: "none",
+    tokenBudget: 400,
+    priority: "medium"
+  },
+  {
+    id: "cc-headless",
+    sourceUrl: "https://code.claude.com/docs/en/headless.md",
+    name: "cc-headless",
+    description: "Modo headless y Agent SDK de Claude Code: uso program\xE1tico desde CLI, Python y TypeScript, output estructurado, bare mode.",
+    splitStrategy: "none",
+    tokenBudget: 500,
+    priority: "medium"
+  },
+  {
+    id: "cc-sandboxing",
+    sourceUrl: "https://code.claude.com/docs/en/sandboxing.md",
+    name: "cc-sandboxing",
+    description: "Sandboxing en Claude Code: filesystem isolation, network isolation, c\xF3mo habilitar, configurar paths permitidos, relaci\xF3n con permisos.",
+    splitStrategy: "none",
+    tokenBudget: 400,
+    priority: "medium"
+  },
+  {
+    id: "cc-common-workflows",
+    sourceUrl: "https://code.claude.com/docs/en/common-workflows.md",
+    name: "cc-common-workflows",
+    description: "Flujos de trabajo comunes en Claude Code: worktrees paralelos, git workflows, plan mode, extended thinking, pipe input/output.",
+    splitStrategy: "sections",
+    tokenBudget: 700,
+    priority: "medium"
+  },
+  {
+    id: "cc-best-practices",
+    sourceUrl: "https://code.claude.com/docs/en/best-practices.md",
+    name: "cc-best-practices",
+    description: "Best practices de Claude Code: dar contexto efectivo, gestionar contexto, course-correct, evitar patrones de fallo comunes.",
+    splitStrategy: "none",
+    tokenBudget: 600,
+    priority: "medium"
+  },
+  {
+    id: "cc-github-actions",
+    sourceUrl: "https://code.claude.com/docs/en/github-actions.md",
+    name: "cc-github-actions",
+    description: "Claude Code en GitHub Actions: setup, @claude mentions, configuraci\xF3n con Bedrock y Vertex, security considerations.",
+    splitStrategy: "none",
+    tokenBudget: 500,
+    priority: "medium"
+  }
+];
+
+// src/config/loader.ts
+import { cosmiconfig } from "cosmiconfig";
+var DEFAULTS = {
+  skills: ["critical", "high"],
+  maxAge: 86400,
+  transformer: "auto",
+  silent: false
+};
+var ALL_PRIORITIES = ["critical", "high", "medium"];
+function normalizeSkillsFilter(raw) {
+  if (raw === "all") {
+    return [...ALL_PRIORITIES];
+  }
+  if (Array.isArray(raw) && raw.every((x) => typeof x === "string")) {
+    return raw.length > 0 ? raw : DEFAULTS.skills;
+  }
+  return DEFAULTS.skills;
+}
+async function loadConfig() {
+  const explorer = cosmiconfig("pulse");
+  try {
+    const result = await explorer.search();
+    if (result && result.config) {
+      const c = result.config;
+      const merged = { ...DEFAULTS, ...c };
+      return {
+        ...merged,
+        skills: normalizeSkillsFilter(c.skills !== void 0 ? c.skills : merged.skills)
+      };
+    }
+  } catch {
+  }
+  return { ...DEFAULTS };
+}
+
+// src/core/hook-manager.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
+import { join, dirname } from "path";
+
+// src/utils/platform.ts
+import { execFile } from "child_process";
+import { readFileSync, existsSync } from "fs";
+function detectPlatform() {
+  if (process.platform === "win32") return "windows";
+  if (process.platform === "linux" && existsSync("/proc/version")) {
+    try {
+      const version = readFileSync("/proc/version", "utf-8");
+      if (/microsoft/i.test(version)) return "wsl";
+    } catch {
+    }
+  }
+  return "unix";
+}
+function getHookCommand() {
+  const platform = detectPlatform();
+  if (platform === "windows") {
+    return "npx.cmd pulse sync --if-stale 86400 --silent & npx.cmd pulse greet --once";
+  }
+  return "npx pulse sync --if-stale 86400 --silent && npx pulse greet --once || true";
+}
+function isClaudeCliAvailable() {
+  return new Promise((resolve) => {
+    const cmd = process.platform === "win32" ? "claude.cmd" : "claude";
+    const child = execFile(cmd, ["--version"], { timeout: 5e3 }, (err) => {
+      if (err) {
+        if (process.platform === "win32" && cmd === "claude.cmd") {
+          execFile("claude", ["--version"], { timeout: 5e3 }, (err2) => {
+            resolve(!err2);
+          });
+          return;
+        }
+        resolve(false);
+        return;
+      }
+      resolve(true);
+    });
+    child.on("error", () => resolve(false));
+  });
+}
+
+// src/core/hook-manager.ts
+function settingsPath() {
+  return join(process.cwd(), ".claude", "settings.json");
+}
+function readSettings() {
+  const path = settingsPath();
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings(settings) {
+  const path = settingsPath();
+  const dir = dirname(path);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+}
+function hasPulseHook(entries) {
+  return entries.some((e) => e._pulse === true);
+}
+function addHook() {
+  const settings = readSettings();
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!settings.hooks.SessionStart) {
+    settings.hooks.SessionStart = [];
+  }
+  const sessionStart = settings.hooks.SessionStart;
+  if (hasPulseHook(sessionStart)) {
+    return;
+  }
+  sessionStart.push({
+    _pulse: true,
+    matcher: "",
+    hooks: [{ type: "command", command: getHookCommand() }]
+  });
+  writeSettings(settings);
+}
+function removeHook() {
+  const path = settingsPath();
+  if (!existsSync2(path)) return;
+  const settings = readSettings();
+  if (!settings.hooks) return;
+  const sessionStart = settings.hooks.SessionStart;
+  if (!sessionStart) return;
+  if (!hasPulseHook(sessionStart)) return;
+  const filtered = sessionStart.filter((e) => e._pulse !== true);
+  if (filtered.length > 0) {
+    settings.hooks.SessionStart = filtered;
+  } else {
+    delete settings.hooks.SessionStart;
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  writeSettings(settings);
+}
+
+// src/core/fetcher.ts
+import { request } from "undici";
+import pLimit from "p-limit";
+
+// src/utils/logger.ts
+var silent = false;
+function setSilent(value) {
+  silent = value;
+}
+function log(...args) {
+  if (!silent) console.log(...args);
+}
+function warn(...args) {
+  if (!silent) console.warn(...args);
+}
+function success(...args) {
+  if (!silent) console.log(...args);
+}
+function error(...args) {
+  console.error(...args);
+}
+
+// src/core/fetcher.ts
+var REQUEST_TIMEOUT = 1e4;
+var MAX_RETRIES = 2;
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchDoc(url, etag) {
+  const headers = {};
+  if (etag) {
+    headers["If-None-Match"] = etag;
+  }
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    if (attempt > 0) {
+      const delay = 1e3 * 2 ** (attempt - 1);
+      await sleep(delay);
+    }
+    try {
+      const res = await request(url, {
+        headers,
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT)
+      });
+      if (res.statusCode === 304) {
+        return {
+          url,
+          content: "",
+          changed: false,
+          etag,
+          fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      if (res.statusCode < 200 || res.statusCode >= 300) {
+        throw new Error(`HTTP ${res.statusCode} fetching ${url}`);
+      }
+      const content = await res.body.text();
+      const newEtag = res.headers["etag"];
+      return {
+        url,
+        content,
+        changed: true,
+        etag: newEtag ?? etag,
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt < MAX_RETRIES) {
+        warn(`Fetch attempt ${attempt + 1} failed for ${url}, retrying...`);
+      }
+    }
+  }
+  throw lastError ?? new Error(`Failed to fetch ${url}`);
+}
+
+// src/core/transformer-static.ts
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkStringify from "remark-stringify";
+var JSX_TAG_RE = /^<\/?[A-Z][A-Za-z]*[\s/>]/;
+var INTERNAL_LINK_RE = /^\/docs\//;
+function isJsxNode(node) {
+  if (node.type === "html" && JSX_TAG_RE.test(node.value)) return true;
+  return false;
+}
+function isImageNode(node) {
+  return node.type === "image";
+}
+function isInternalLink(node) {
+  if (node.type === "link" && INTERNAL_LINK_RE.test(node.url)) return true;
+  return false;
+}
+function filterChildren(nodes) {
+  const result = [];
+  for (const node of nodes) {
+    if (isJsxNode(node) || isImageNode(node)) continue;
+    if (isInternalLink(node)) {
+      if ("children" in node && node.children.length > 0) {
+        result.push(...filterChildren(node.children));
+      }
+      continue;
+    }
+    if ("children" in node && Array.isArray(node.children)) {
+      const filtered = filterChildren(node.children);
+      result.push({ ...node, children: filtered });
+    } else {
+      result.push(node);
+    }
+  }
+  return result;
+}
+function cleanAst() {
+  return (tree) => {
+    tree.children = filterChildren(tree.children);
+  };
+}
+function transformStatic(rawMarkdown, tokenBudget) {
+  const processor = unified().use(remarkParse).use(cleanAst).use(remarkStringify, { bullet: "-", emphasis: "*", strong: "*" });
+  const result = processor.processSync(rawMarkdown);
+  const cleaned = String(result);
+  const charBudget = tokenBudget * 4;
+  if (cleaned.length <= charBudget) {
+    return cleaned;
+  }
+  return truncateAtSectionBoundary(cleaned, charBudget);
+}
+function truncateAtSectionBoundary(text, charBudget) {
+  const lines = text.split("\n");
+  let length = 0;
+  let lastHeadingIndex = 0;
+  for (let i = 0; i < lines.length; i++) {
+    length += lines[i].length + 1;
+    if (/^#{1,3} /.test(lines[i])) {
+      lastHeadingIndex = i;
+    }
+    if (length > charBudget) {
+      const cutIndex = lastHeadingIndex > 0 ? lastHeadingIndex : i;
+      return lines.slice(0, cutIndex).join("\n").trim();
+    }
+  }
+  return text;
+}
+
+// src/core/transformer-claude.ts
+import { execFile as execFile2 } from "child_process";
+var TRANSFORM_PROMPT = `You are a documentation condenser for Claude Code skills.
+Transform the following markdown documentation into a concise skill reference.
+
+Rules:
+- Keep ALL code examples exactly as-is \u2014 do not modify, summarize, or omit any code block
+- Keep ALL reference tables intact
+- Convert prose paragraphs to concise bullet points
+- Remove navigation elements, breadcrumbs, and "see also" links
+- Conserve syntax details, parameters, edge cases, and caveats
+- Output in English
+- Start directly with the content \u2014 no frontmatter, no title like "# Skill"
+- Respect the token budget \u2014 be concise but preserve technical accuracy
+- Prioritize: code examples > tables > parameter lists > prose explanations
+
+Transform this documentation:`;
+var cachedCliAvailable;
+async function checkCliAvailable() {
+  if (cachedCliAvailable !== void 0) return cachedCliAvailable;
+  try {
+    cachedCliAvailable = await isClaudeCliAvailable();
+  } catch {
+    cachedCliAvailable = false;
+  }
+  return cachedCliAvailable;
+}
+async function transformWithClaude(rawMarkdown, tokenBudget) {
+  const available = await checkCliAvailable();
+  if (!available) {
+    warn("Claude CLI not available, skipping AI transformation");
+    return null;
+  }
+  const cmd = process.platform === "win32" ? "claude" : "claude";
+  const args = [
+    "--print",
+    "--model",
+    "claude-haiku-4-5-20251001",
+    "--max-tokens",
+    String(tokenBudget)
+  ];
+  const input = `${TRANSFORM_PROMPT}
+
+${rawMarkdown}`;
+  return new Promise((resolve) => {
+    const child = execFile2(cmd, args, {
+      timeout: 3e4,
+      maxBuffer: 1024 * 1024,
+      encoding: "utf-8"
+    }, (err, stdout) => {
+      if (err) {
+        if (err.killed) {
+          warn("Claude CLI transformation timed out (30s)");
+        } else {
+          warn(`Claude CLI transformation failed: ${err.message}`);
+        }
+        resolve(null);
+        return;
+      }
+      const result = stdout.trim();
+      if (!result) {
+        warn("Claude CLI returned empty output");
+        resolve(null);
+        return;
+      }
+      resolve(result);
+    });
+    if (child.stdin) {
+      child.stdin.write(input);
+      child.stdin.end();
+    }
+  });
+}
+
+// src/core/splitter.ts
+function splitDocument(content, strategy, manualSections) {
+  switch (strategy) {
+    case "sections":
+      return splitBySections(content);
+    case "manual":
+      return splitByManual(content, manualSections ?? []);
+    case "none":
+    default:
+      return [{ id: "", content }];
+  }
+}
+function splitBySections(markdown) {
+  const lines = markdown.split("\n");
+  const sections = [];
+  const preambleLines = [];
+  let currentHeading = null;
+  let currentLines = [];
+  for (const line of lines) {
+    const h2Match = line.match(/^## (.+)/);
+    if (h2Match) {
+      if (currentLines.length > 0) {
+        if (currentHeading === null) {
+          preambleLines.push(...currentLines);
+        } else {
+          sections.push({
+            id: toKebabCase(currentHeading),
+            content: currentLines.join("\n").trim()
+          });
+        }
+      }
+      currentHeading = h2Match[1].trim();
+      if (preambleLines.length > 0) {
+        currentLines = [...preambleLines, "", line];
+        preambleLines.length = 0;
+      } else {
+        currentLines = [line];
+      }
+      continue;
+    }
+    currentLines.push(line);
+  }
+  if (currentLines.length === 0) {
+    return sections;
+  }
+  if (currentHeading === null) {
+    return [{ id: "document", content: currentLines.join("\n").trim() }];
+  }
+  sections.push({
+    id: toKebabCase(currentHeading),
+    content: currentLines.join("\n").trim()
+  });
+  return sections;
+}
+function splitByManual(markdown, manualSections) {
+  const results = [];
+  for (let i = 0; i < manualSections.length; i++) {
+    const section = manualSections[i];
+    const startIdx = findHeadingIndex(markdown, section.heading);
+    if (startIdx === -1) {
+      warn(`Heading not found: "${section.heading}" \u2014 skipping section ${section.id}`);
+      continue;
+    }
+    let endIdx = markdown.length;
+    if (i + 1 < manualSections.length) {
+      const nextIdx = findHeadingIndex(markdown, manualSections[i + 1].heading);
+      if (nextIdx !== -1) {
+        endIdx = nextIdx;
+      }
+    }
+    const content = markdown.slice(startIdx, endIdx).trim();
+    results.push({ id: section.id, content });
+  }
+  return results;
+}
+function findHeadingIndex(markdown, heading) {
+  const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`^#{1,6}\\s+${escapedHeading}`, "m");
+  const match = regex.exec(markdown);
+  return match ? match.index : -1;
+}
+function toKebabCase(str) {
+  return str.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/core/transformer.ts
+function generateFrontmatter(name, description, source, transformedWith) {
+  const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return [
+    "---",
+    `name: ${name}`,
+    `description: ${JSON.stringify(description)}`,
+    "invocation: auto",
+    "_pulse: true",
+    `_syncedAt: "${syncedAt}"`,
+    `_source: "${source}"`,
+    "---",
+    ""
+  ].join("\n");
+}
+async function transformSkill(def, rawContent) {
+  const tokenBudget = def.tokenBudget ?? 600;
+  const source = def.sourceUrl ?? "static";
+  if (def.static) {
+    log(`  \u2192 ${def.id}: fixed (static skill)`);
+    const frontmatter = generateFrontmatter(def.id, def.description, "static", "fixed");
+    return [{
+      id: def.id,
+      filename: `.claude/skills/${def.id}/SKILL.md`,
+      content: frontmatter + rawContent,
+      transformedWith: "fixed"
+    }];
+  }
+  let transformed;
+  let method;
+  const claudeResult = await transformWithClaude(rawContent, tokenBudget);
+  if (claudeResult) {
+    transformed = claudeResult;
+    method = "claude";
+    log(`  \u2192 ${def.id}: transformed with Claude`);
+  } else {
+    transformed = transformStatic(rawContent, tokenBudget);
+    method = "static";
+    log(`  \u2192 ${def.id}: transformed with static fallback`);
+  }
+  const strategy = def.splitStrategy ?? "none";
+  const sections = splitDocument(transformed, strategy, def.manualSections);
+  return sections.map((section) => {
+    const skillId = section.id ? `${def.id}-${section.id}` : def.id;
+    const finalId = def.manualSections?.find((ms) => ms.id === section.id) ? section.id : skillId;
+    const sectionDef = def.manualSections?.find((ms) => ms.id === section.id);
+    const description = sectionDef?.description ?? def.description;
+    const frontmatter = generateFrontmatter(finalId, description, source, method);
+    return {
+      id: finalId,
+      filename: `.claude/skills/${finalId}/SKILL.md`,
+      content: frontmatter + section.content,
+      transformedWith: method
+    };
+  });
+}
+
+// src/core/installer.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import { join as join2 } from "path";
+function skillsBase() {
+  return join2(process.cwd(), ".claude", "skills");
+}
+function skillFilePath(id) {
+  return join2(skillsBase(), id, "SKILL.md");
+}
+function hasPulseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  return match !== null && /^_pulse:\s*true$/m.test(match[1]);
+}
+function ensurePulseFrontmatter(content) {
+  if (hasPulseFrontmatter(content)) return content;
+  return `---
+_pulse: true
+---
+${content}`;
+}
+function isManaged(skillDir) {
+  const filePath = join2(skillDir, "SKILL.md");
+  try {
+    const raw = readFileSync3(filePath, "utf-8");
+    const match = raw.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return false;
+    return /^_pulse:\s*true$/m.test(match[1]);
+  } catch {
+    return false;
+  }
+}
+function install(skills) {
+  for (const skill of skills) {
+    const dir = join2(skillsBase(), skill.id);
+    const filePath = skillFilePath(skill.id);
+    if (existsSync3(filePath) && !isManaged(dir)) {
+      continue;
+    }
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync2(filePath, ensurePulseFrontmatter(skill.content), "utf-8");
+  }
+}
+
+// src/commands/sync.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+function getSkillsFallbackDir() {
+  const thisFile = fileURLToPath(import.meta.url);
+  const root = join3(dirname2(thisFile), "..", "..");
+  return join3(root, "skills-fallback");
+}
+function loadStaticSkillContent(skillId) {
+  const fallbackDir = getSkillsFallbackDir();
+  const skillPath = join3(fallbackDir, skillId, "SKILL.md");
+  return readFileSync4(skillPath, "utf-8");
+}
+async function syncCore(options) {
+  if (options.silent) {
+    setSilent(true);
+  }
+  const config = await loadConfig();
+  if (options.ifStale) {
+    const maxAge = parseInt(options.ifStale, 10);
+    if (!isNaN(maxAge) && !isStale(maxAge)) {
+      setSilent(false);
+      return [];
+    }
+  }
+  let skills;
+  if (options.skills && options.skills.length > 0) {
+    skills = SKILLS_REGISTRY.filter((s) => options.skills.includes(s.id));
+  } else {
+    const priorities = config.skills ?? ["critical", "high"];
+    skills = SKILLS_REGISTRY.filter((s) => priorities.includes(s.priority) || priorities.includes("all"));
+  }
+  const meta = readMeta();
+  const results = [];
+  let hasErrors = false;
+  log("Syncing skills...");
+  for (const skill of skills) {
+    try {
+      if (skill.static) {
+        const content = loadStaticSkillContent(skill.id);
+        install([{ id: skill.id, content }]);
+        meta.skills[skill.id] = {
+          syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          transformedWith: "fixed"
+        };
+        results.push({ id: skill.id, action: "updated", transformer: "fixed" });
+        log(`  \u2713 ${skill.id} (static)`);
+        continue;
+      }
+      if (!skill.sourceUrl) {
+        results.push({ id: skill.id, action: "skipped" });
+        continue;
+      }
+      const etag = options.force ? void 0 : meta.etags[skill.sourceUrl];
+      const fetchResult = await fetchDoc(skill.sourceUrl, etag);
+      if (!fetchResult.changed) {
+        results.push({ id: skill.id, action: "skipped", transformer: meta.skills[skill.id]?.transformedWith });
+        log(`  \xB7 ${skill.id} unchanged (304)`);
+        continue;
+      }
+      if (fetchResult.etag) {
+        meta.etags[skill.sourceUrl] = fetchResult.etag;
+      }
+      const transformed = await transformSkill(skill, fetchResult.content);
+      install(transformed.map((t) => ({ id: t.id, content: t.content })));
+      for (const t of transformed) {
+        meta.skills[t.id] = {
+          syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          transformedWith: t.transformedWith,
+          etag: fetchResult.etag
+        };
+      }
+      results.push({ id: skill.id, action: "updated", transformer: transformed[0]?.transformedWith });
+      log(`  \u2713 ${skill.id} updated`);
+    } catch (err) {
+      hasErrors = true;
+      const msg = err instanceof Error ? err.message : String(err);
+      warn(`  \u2717 ${skill.id} failed: ${msg}`);
+      results.push({ id: skill.id, action: "failed", error: msg });
+    }
+  }
+  meta.version = (await import("./meta-TZOSLFST.js")).readMeta().version;
+  meta.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+  meta.lastSyncStatus = hasErrors ? results.some((r) => r.action === "updated") ? "partial" : "failed" : "success";
+  if (hasErrors) {
+    const errors = results.filter((r) => r.action === "failed").map((r) => r.error);
+    meta.lastSyncError = errors.join("; ");
+  } else {
+    delete meta.lastSyncError;
+  }
+  writeMeta(meta);
+  if (!options.silent && results.length > 0) {
+    log("");
+    log("  Skill ID                Action     Transformer");
+    log("  " + "\u2500".repeat(50));
+    for (const r of results) {
+      const id = r.id.padEnd(22);
+      const action = r.action.padEnd(10);
+      const transformer = r.transformer ?? "";
+      log(`  ${id}  ${action} ${transformer}`);
+    }
+    log("");
+  }
+  setSilent(false);
+  return results;
+}
+function registerSync(program2) {
+  program2.command("sync").description("Fetch, transform, and install skills").option("--force", "Ignore ETags, re-download everything").option("--if-stale <seconds>", "Only sync if last sync is older than N seconds").option("--silent", "Suppress all non-error output").option("--skills <ids...>", "Sync only specific skill IDs").action(async (opts) => {
+    try {
+      await syncCore(opts);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : err}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/init.ts
+async function confirm(message) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith("y"));
+    });
+  });
+}
+function registerInit(program2) {
+  program2.command("init").description("Initialize pulse in the current project").option("--force", "Re-initialize even if already set up").option("--yes", "Skip confirmation prompt").option("--skills <ids...>", "Install only specific skill IDs").action(async (opts) => {
+    try {
+      const metaPath = getMetaPath();
+      if (existsSync4(metaPath) && !opts.force) {
+        const meta2 = readMeta();
+        log("pulse is already initialized.");
+        log(`  Last sync: ${meta2.lastSync || "never"}`);
+        log(`  Status: ${meta2.lastSyncStatus}`);
+        log(`  Skills: ${Object.keys(meta2.skills).length} installed`);
+        log("");
+        log("Use --force to re-initialize.");
+        return;
+      }
+      const claudeDir = join4(process.cwd(), ".claude");
+      const skillsDir = join4(claudeDir, "skills");
+      if (!existsSync4(claudeDir)) {
+        mkdirSync3(claudeDir, { recursive: true });
+      }
+      if (!existsSync4(skillsDir)) {
+        mkdirSync3(skillsDir, { recursive: true });
+      }
+      const config = await loadConfig();
+      let skillsToInstall = SKILLS_REGISTRY;
+      if (opts.skills && opts.skills.length > 0) {
+        skillsToInstall = SKILLS_REGISTRY.filter((s) => opts.skills.includes(s.id));
+      } else {
+        const priorities = config.skills ?? ["critical", "high"];
+        skillsToInstall = SKILLS_REGISTRY.filter(
+          (s) => priorities.includes(s.priority) || priorities.includes("all")
+        );
+      }
+      log("Skills to install:");
+      log("");
+      for (const skill of skillsToInstall) {
+        const tag = skill.static ? " (static)" : "";
+        log(`  [${skill.priority}] ${skill.id}${tag}`);
+      }
+      log("");
+      log(`Total: ${skillsToInstall.length} skills`);
+      log("");
+      if (!opts.yes) {
+        const accepted = await confirm("Proceed? (y/N) ");
+        if (!accepted) {
+          log("Aborted.");
+          return;
+        }
+      }
+      log("");
+      const syncOpts = {
+        force: true,
+        skills: opts.skills
+      };
+      await syncCore(syncOpts);
+      addHook();
+      log("SessionStart hook added to .claude/settings.json");
+      const meta = readMeta();
+      meta.firstSessionDone = false;
+      writeMeta(meta);
+      log("");
+      success("pulse initialized successfully!");
+      log(`  Skills installed: ${Object.keys(meta.skills).length}`);
+      log("  Hook: SessionStart \u2713");
+      log("  Next auto-sync: in ~24 hours (via hook)");
+      log("");
+      log("Tip: commit .claude/skills/cc-*/ to share skills with your team.");
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : err}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/greet.ts
+var WELCOME_MESSAGE = `claude-code-tutor is active \u2014 your skills are synchronized with the official Claude Code docs.
+
+- Use /cc-tutor for an interactive guided tour of Claude Code features
+- Use /cc-learning-path to see the full structured curriculum by level
+- Skills auto-update daily via the SessionStart hook
+
+The user has a pulse tutor memory at ~/.claude/pulse/memory.json. Read it only if the cc-tutor skill activates.
+
+Happy coding!`;
+function registerGreet(program2) {
+  program2.command("greet").description("Output welcome context for SessionStart hook").option("--once", "Only greet on first session").action((opts) => {
+    const meta = readMeta();
+    if (opts.once && meta.firstSessionDone) {
+      return;
+    }
+    const output = JSON.stringify({ additionalContext: WELCOME_MESSAGE });
+    process.stdout.write(output + "\n");
+    if (opts.once) {
+      meta.firstSessionDone = true;
+      writeMeta(meta);
+    }
+  });
+}
+
+// src/commands/list.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+var MAX_AGE_SECONDS = 86400;
+function statusIcon(skillId, meta) {
+  const skillMeta = meta.skills[skillId];
+  if (!skillMeta) {
+    const skillPath = join5(process.cwd(), ".claude", "skills", skillId, "SKILL.md");
+    if (!existsSync5(skillPath)) return "\u2717";
+    return "?";
+  }
+  if (!skillMeta.syncedAt) return "\u2717";
+  const elapsed = (Date.now() - new Date(skillMeta.syncedAt).getTime()) / 1e3;
+  return elapsed > MAX_AGE_SECONDS ? "\u26A0" : "\u2713";
+}
+function registerList(program2) {
+  program2.command("list").description("List all skills and their sync status").action(async () => {
+    const meta = readMeta();
+    log("  Status  Skill ID                Last Sync            Transformer");
+    log("  " + "\u2500".repeat(70));
+    for (const skill of SKILLS_REGISTRY) {
+      const icon = statusIcon(skill.id, meta);
+      const skillMeta = meta.skills[skill.id];
+      const id = skill.id.padEnd(22);
+      const lastSync = skillMeta?.syncedAt ? new Date(skillMeta.syncedAt).toLocaleString() : "";
+      const syncPad = lastSync.padEnd(20);
+      const transformer = skillMeta?.transformedWith ?? "";
+      log(`  ${icon}      ${id}  ${syncPad} ${transformer}`);
+    }
+    log("");
+    const installed = Object.keys(meta.skills).length;
+    log(`  ${installed} / ${SKILLS_REGISTRY.length} skills tracked`);
+  });
+}
+
+// src/commands/status.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
+function relativeTime(isoDate) {
+  const ms = Date.now() - new Date(isoDate).getTime();
+  if (isNaN(ms)) return "unknown";
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function checkHookInstalled() {
+  const settingsPath2 = join6(process.cwd(), ".claude", "settings.json");
+  try {
+    const settings = JSON.parse(readFileSync5(settingsPath2, "utf-8"));
+    const hooks = settings?.hooks?.SessionStart;
+    if (!Array.isArray(hooks)) return false;
+    return hooks.some((h) => h._pulse === true);
+  } catch {
+    return false;
+  }
+}
+function registerStatus(program2) {
+  program2.command("status").description("Show pulse status overview").action(async () => {
+    const meta = readMeta();
+    const platform = detectPlatform();
+    let claudeAvailable = false;
+    try {
+      claudeAvailable = await isClaudeCliAvailable();
+    } catch {
+    }
+    const hookInstalled = checkHookInstalled();
+    const installed = Object.keys(meta.skills).length;
+    log(`  pulse v${getVersion()}`);
+    log(`  Directory:          ${process.cwd()}`);
+    log(`  Skills:             ${installed} / ${SKILLS_REGISTRY.length} installed`);
+    if (meta.lastSync) {
+      const syncTime = relativeTime(meta.lastSync);
+      log(`  Last sync:          ${syncTime} (${meta.lastSyncStatus})`);
+      if (meta.lastSyncStatus === "failed" && meta.lastSyncError) {
+        log(`  Last error:         ${meta.lastSyncError}`);
+      }
+    } else {
+      log("  Last sync:          never");
+    }
+    log(`  Hook SessionStart:  ${hookInstalled ? "\u2713 installed" : "\u2717 not installed"}`);
+    log(`  Claude CLI:         ${claudeAvailable ? "\u2713 available (transformer: claude)" : "\u2717 not available (transformer: static)"}`);
+    log(`  Platform:           ${platform}`);
+    log(`  firstSessionDone:   ${meta.firstSessionDone}`);
+  });
+}
+
+// src/commands/uninstall.ts
+import { readdirSync, rmSync, existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+import { createInterface as createInterface2 } from "readline";
+function registerUninstall(program2) {
+  program2.command("uninstall").description("Remove pulse from the current project").option("--keep-hook", "Leave the SessionStart hook in place").option("--keep-skills", "Leave installed skill files in place").option("--purge-memory", "Also delete tutor memory (~/.claude/pulse/)").action(async (opts) => {
+    if (!opts.keepHook) {
+      removeHook();
+      log("  \u2713 SessionStart hook removed");
+    } else {
+      log("  \xB7 SessionStart hook kept (--keep-hook)");
+    }
+    if (!opts.keepSkills) {
+      const skillsDir = join7(process.cwd(), ".claude", "skills");
+      if (existsSync7(skillsDir)) {
+        let removed = 0;
+        const entries = readdirSync(skillsDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          if (!entry.name.startsWith("cc-")) continue;
+          const dirPath = join7(skillsDir, entry.name);
+          if (isManaged(dirPath)) {
+            rmSync(dirPath, { recursive: true, force: true });
+            removed++;
+            log(`  \u2713 Removed ${entry.name}`);
+          }
+        }
+        if (removed === 0) {
+          log("  \xB7 No pulse-managed skills found");
+        }
+      }
+    } else {
+      log("  \xB7 Skills kept (--keep-skills)");
+    }
+    const metaPath = getMetaPath();
+    if (existsSync7(metaPath)) {
+      rmSync(metaPath);
+      log("  \u2713 Meta file removed");
+    }
+    if (opts.purgeMemory) {
+      const pulseDir = getBaseDir();
+      if (existsSync7(pulseDir)) {
+        const rl = createInterface2({ input: process.stdin, output: process.stdout });
+        const yes = await new Promise((resolve) => {
+          rl.question("Delete all tutor memory and session logs? (y/N) ", (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === "y");
+          });
+        });
+        if (yes) {
+          rmSync(pulseDir, { recursive: true, force: true });
+          log("  \u2713 Tutor memory purged");
+        } else {
+          log("  \xB7 Tutor memory preserved (cancelled)");
+        }
+      } else {
+        log("  \xB7 No tutor memory found");
+      }
+    }
+    log("");
+    success("pulse has been uninstalled.");
+  });
+}
+
+// src/commands/memory.ts
+import { readFile, rm } from "fs/promises";
+import { createInterface as createInterface3 } from "readline";
+import { join as join8 } from "path";
+async function confirm2(message) {
+  const rl = createInterface3({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${message} (y/N) `, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
+function formatDate(iso) {
+  if (!iso) return "N/A";
+  return new Date(iso).toLocaleDateString();
+}
+async function showProgress() {
+  const memory = await readMemory();
+  if (!memory) {
+    log("No tutor sessions recorded yet. Start a session with the cc-tutor skill.");
+    return;
+  }
+  log("\n\u{1F4CB} Tutor Memory");
+  log("\u2500".repeat(40));
+  log(`  Name:     ${memory.name || "(not set)"}`);
+  log(`  Level:    ${memory.level}`);
+  log(`  Language: ${memory.language}`);
+  log(`  Joined:   ${formatDate(memory.joinedAt)}`);
+  if (memory.lastSession) {
+    log(`
+  Last session: ${formatDate(memory.lastSession.date)}`);
+    if (memory.lastSession.topicsCovered.length > 0) {
+      log(`  Topics:       ${memory.lastSession.topicsCovered.join(", ")}`);
+    }
+    if (memory.lastSession.endNote) {
+      log(`  Note:         ${memory.lastSession.endNote}`);
+    }
+  }
+  const topicEntries = Object.entries(memory.topics);
+  if (topicEntries.length > 0) {
+    const completed = topicEntries.filter(([, t]) => t.status === "completed").length;
+    const inProgress = topicEntries.filter(([, t]) => t.status === "in-progress").length;
+    const pending = topicEntries.filter(([, t]) => t.status === "pending").length;
+    log(`
+  Topics: ${completed} completed, ${inProgress} in progress, ${pending} pending`);
+    for (const [id, topic] of topicEntries) {
+      const icon = topic.status === "completed" ? "\u2713" : topic.status === "in-progress" ? "\u2026" : "\u25CB";
+      log(`    ${icon} ${id}`);
+    }
+  }
+  const exerciseEntries = Object.entries(memory.exercises);
+  if (exerciseEntries.length > 0) {
+    log(`
+  Exercises:`);
+    for (const [id, ex] of exerciseEntries) {
+      const icon = ex.status === "completed" ? "\u2713" : ex.status === "in-progress" ? "\u2026" : "\u25CB";
+      log(`    ${icon} ${id}`);
+    }
+  }
+  if (memory.frequentQuestions.length > 0) {
+    log(`
+  Frequent questions:`);
+    for (const q of memory.frequentQuestions) {
+      log(`    (${q.count}x) ${q.question}`);
+    }
+  }
+  if (memory.nextSteps.length > 0) {
+    log(`
+  Next steps:`);
+    for (const step of memory.nextSteps) {
+      log(`    \u2192 ${step.topicId}: ${step.reason}`);
+    }
+  }
+  log("");
+}
+function registerMemory(program2) {
+  program2.command("memory").description("View and manage tutor memory").option("--reset", "Delete memory (keeps session logs)").option("--export", "Print memory as JSON to stdout").option("--import <file>", "Replace memory from a JSON file").option("--update <json>", "Merge a JSON patch into memory").option("--exercise <id>", "Update an exercise entry").option("--status <status>", "Exercise status (use with --exercise)").option("--next-step <desc>", "Add a next step recommendation").option("--reason <reason>", "Reason for the next step").action(async (opts) => {
+    if (opts.reset) {
+      const yes = await confirm2("Delete tutor memory? Session logs will be preserved.");
+      if (!yes) {
+        log("Reset cancelled.");
+        return;
+      }
+      const memoryFile = join8(getBaseDir(), "memory.json");
+      try {
+        await rm(memoryFile);
+        success("Memory reset successfully.");
+      } catch {
+        log("No memory file to delete.");
+      }
+      return;
+    }
+    if (opts.export) {
+      const memory = await readMemory();
+      if (!memory) {
+        error("No memory file found.");
+        process.exitCode = 1;
+        return;
+      }
+      process.stdout.write(JSON.stringify(memory, null, 2) + "\n");
+      return;
+    }
+    if (opts.import) {
+      try {
+        const raw = await readFile(opts.import, "utf-8");
+        const data = JSON.parse(raw);
+        await writeMemory(data);
+        success("Memory imported successfully.");
+      } catch (err) {
+        error(`Failed to import: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+      }
+      return;
+    }
+    if (opts.update) {
+      try {
+        const patch = JSON.parse(opts.update);
+        await updateMemory(patch);
+        success("Memory updated.");
+      } catch (err) {
+        error(`Invalid JSON: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+      }
+      return;
+    }
+    if (opts.exercise) {
+      const status = opts.status;
+      if (!status) {
+        error("--exercise requires --status <pending|in-progress|completed>");
+        process.exitCode = 1;
+        return;
+      }
+      const memory = await readMemory() ?? (await import("./tutor-memory-M6GNB3LQ.js")).getDefaultMemory();
+      const existing = memory.exercises[opts.exercise] ?? { status: "pending" };
+      existing.status = status;
+      if (status === "completed") {
+        existing.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      if (status === "in-progress" && !existing.assignedAt) {
+        existing.assignedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      memory.exercises[opts.exercise] = existing;
+      await writeMemory(memory);
+      success(`Exercise "${opts.exercise}" updated to ${status}.`);
+      return;
+    }
+    if (opts.nextStep) {
+      const memory = await readMemory() ?? (await import("./tutor-memory-M6GNB3LQ.js")).getDefaultMemory();
+      memory.nextSteps.push({
+        topicId: opts.nextStep,
+        reason: opts.reason ?? "",
+        suggestedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await writeMemory(memory);
+      success(`Next step added: ${opts.nextStep}`);
+      return;
+    }
+    await showProgress();
+  });
+}
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var program = new Command();
+program.name("pulse").version(pkg.version).description(pkg.description).configureOutput({
+  writeErr: (str) => process.stderr.write(str),
+  writeOut: (str) => process.stdout.write(str)
+});
+registerInit(program);
+registerSync(program);
+registerGreet(program);
+registerList(program);
+registerStatus(program);
+registerUninstall(program);
+registerMemory(program);
+program.parse();