@imstudium/cli 0.1.1

package/dist/cli.js

@@ -0,0 +1,1484 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFile as readFile2 } from "fs/promises";
+import { basename, join as join4 } from "path";
+import { Command } from "commander";
+import {
+  buildAgentVisualPayload,
+  buildSlideViewer,
+  createSdk as createSdk2,
+  detectTools,
+  ImstudiumError as ImstudiumError2,
+  expandPath as expandPath3,
+  extractSlug,
+  isChromeRunning,
+  probeOAuthServer,
+  pickCourse,
+  rebuildSearchIndexes,
+  resolveCourseDir,
+  toolHints,
+  ensureMigrated as ensureMigrated2,
+  archiveLegacyConfigDir
+} from "@imstudium/sdk";
+
+// src/setup.ts
+import { existsSync as existsSync2 } from "fs";
+import { cp, mkdir, readFile, rm, writeFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { expandPath, paths } from "@imstudium/sdk";
+
+// src/agents.ts
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { join as join2 } from "path";
+
+// src/version.ts
+import { createRequire } from "module";
+import { realpathSync } from "fs";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var require2 = createRequire(import.meta.url);
+var CLI_PACKAGES = ["@imstudium/cli", "@imstudium/mcp"];
+function getCliVersion() {
+  try {
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    return require2(pkgPath).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function detectInstallMode(entryPath) {
+  try {
+    const resolved = realpathSync(entryPath);
+    if (resolved.includes(join("packages", "cli"))) {
+      return "development";
+    }
+    const globalRoot = execSync("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }).trim();
+    if (resolved.startsWith(globalRoot)) return "global";
+  } catch {
+  }
+  return "npx";
+}
+function semverLt(current, latest) {
+  const parse = (v) => v.replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
+  const a = parse(current);
+  const b = parse(latest);
+  for (let i = 0; i < 3; i++) {
+    if (a[i] < b[i]) return true;
+    if (a[i] > b[i]) return false;
+  }
+  return false;
+}
+async function fetchNpmLatest(name) {
+  const registryPath = name.startsWith("@") ? name.replace("/", "%2F") : name;
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${registryPath}/latest`, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdates(entryPath) {
+  const current = getCliVersion();
+  const installMode = detectInstallMode(entryPath);
+  const packages = [];
+  let latestMain = null;
+  for (const name of CLI_PACKAGES) {
+    const latest = await fetchNpmLatest(name);
+    if (name === "@imstudium/cli") latestMain = latest;
+    packages.push({
+      name,
+      current: name === "@imstudium/cli" ? current : current,
+      latest,
+      updateAvailable: latest ? semverLt(current, latest) : false
+    });
+  }
+  const updateAvailable = latestMain ? semverLt(current, latestMain) : false;
+  return {
+    schemaVersion: "1",
+    current,
+    latest: latestMain,
+    updateAvailable,
+    installMode,
+    packages,
+    recommendedAction: "imstudium update"
+  };
+}
+async function runGlobalUpdate() {
+  try {
+    const out = execSync("npm install -g @imstudium/cli@latest @imstudium/mcp@latest", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { ok: true, output: out.trim() };
+  } catch (err) {
+    const e = err;
+    return { ok: false, output: e.stderr || e.stdout || e.message || "npm install failed" };
+  }
+}
+
+// src/agents.ts
+function claudeDesktopConfigPath() {
+  if (platform() === "darwin") {
+    return join2(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  if (platform() === "win32") {
+    return join2(process.env.APPDATA || homedir(), "Claude", "claude_desktop_config.json");
+  }
+  return join2(homedir(), ".config", "Claude", "claude_desktop_config.json");
+}
+var AGENT_REGISTRY = [
+  {
+    id: "cursor",
+    label: "Cursor",
+    detect: () => existsSync(join2(homedir(), ".cursor")) || Boolean(process.env.CURSOR_TRACE_ID || process.env.CURSOR_AGENT),
+    skillsDir: () => join2(homedir(), ".cursor", "skills"),
+    mcpFiles: () => [join2(homedir(), ".cursor", "mcp.json")]
+  },
+  {
+    id: "claude-code",
+    label: "Claude Code",
+    detect: () => existsSync(join2(homedir(), ".claude")) || Boolean(process.env.CLAUDE_CODE),
+    skillsDir: () => join2(homedir(), ".claude", "skills"),
+    mcpFiles: () => [join2(homedir(), ".claude", "mcp.json")]
+  },
+  {
+    id: "claude-desktop",
+    label: "Claude Desktop / Cowork",
+    detect: () => {
+      const cfg = claudeDesktopConfigPath();
+      const dir = join2(cfg, "..");
+      return existsSync(cfg) || existsSync(dir);
+    },
+    skillsDir: () => join2(homedir(), ".claude", "skills"),
+    mcpFiles: () => [claudeDesktopConfigPath()]
+  },
+  {
+    id: "codex",
+    label: "OpenAI Codex",
+    detect: () => existsSync(join2(homedir(), ".codex")) || Boolean(process.env.CODEX_HOME),
+    skillsDir: () => join2(homedir(), ".codex", "skills"),
+    mcpFiles: () => [join2(homedir(), ".codex", "mcp.json")]
+  },
+  {
+    id: "windsurf",
+    label: "Windsurf",
+    detect: () => existsSync(join2(homedir(), ".codeium", "windsurf")),
+    skillsDir: () => join2(homedir(), ".codeium", "windsurf", "skills"),
+    mcpFiles: () => [join2(homedir(), ".codeium", "windsurf", "mcp.json")]
+  },
+  {
+    id: "opencode",
+    label: "OpenCode",
+    detect: () => existsSync(join2(homedir(), ".config", "opencode")) || existsSync(join2(homedir(), ".opencode")),
+    skillsDir: () => join2(homedir(), ".config", "opencode", "skills"),
+    mcpFiles: () => [join2(homedir(), ".config", "opencode", "mcp.json")]
+  }
+];
+function detectAgents(all = false) {
+  if (all) return [...AGENT_REGISTRY];
+  const detected = AGENT_REGISTRY.filter((a) => a.detect());
+  return detected.length > 0 ? detected : [AGENT_REGISTRY[0]];
+}
+function getAgent(id) {
+  return AGENT_REGISTRY.find((a) => a.id === id);
+}
+function resolveAgentProfiles(agent, allAgents = false) {
+  if (agent && agent !== "all") {
+    const one = getAgent(agent);
+    return one ? [one] : [];
+  }
+  return detectAgents(allAgents || agent === "all");
+}
+function uniqueSkillsDirs(agents) {
+  const map = /* @__PURE__ */ new Map();
+  for (const a of agents) {
+    const dir = a.skillsDir();
+    const list = map.get(dir) ?? [];
+    list.push(a);
+    map.set(dir, list);
+  }
+  return map;
+}
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+var SETUP_MANIFEST_VERSION = "1";
+var IMSTUDIUM_SETUP_VERSION = getCliVersion();
+function emptyManifest(workspace) {
+  return {
+    schemaVersion: SETUP_MANIFEST_VERSION,
+    imstudiumVersion: IMSTUDIUM_SETUP_VERSION,
+    workspace,
+    skills: {},
+    mcp: {},
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/setup.ts
+import { convertLegacyManifest, ensureMigrated, legacyPaths } from "@imstudium/sdk";
+var PKG_ROOT = join3(dirname2(fileURLToPath2(import.meta.url)), "..");
+var SKILLS_ROOT = join3(PKG_ROOT, "skills");
+var WORKFLOWS_ROOT = join3(SKILLS_ROOT, "workflows");
+var MANIFEST_FILE = join3(paths.configDir, "setup-manifest.json");
+function resolveMcpLaunch() {
+  if (process.env.IMSTUDIUM_MCP_LAUNCH === "npx") {
+    return { command: "npx", args: ["-y", "@imstudium/mcp"] };
+  }
+  const local = join3(homedir2(), ".local", "bin", "imstudium-mcp");
+  if (existsSync2(local)) {
+    return { command: local, args: [] };
+  }
+  return { command: "npx", args: ["-y", "@imstudium/mcp"] };
+}
+function mergeMcpConfig(existing, workspace) {
+  const servers = existing.mcpServers ?? {};
+  const { digicampus: _legacy, ...rest } = servers;
+  const launch = resolveMcpLaunch();
+  return {
+    ...existing,
+    mcpServers: {
+      ...rest,
+      imstudium: {
+        ...launch,
+        env: { IMSTUDIUM_WORKSPACE: expandPath(workspace) }
+      }
+    }
+  };
+}
+function imstudiumMcpEntry(workspace) {
+  const merged = mergeMcpConfig({}, workspace);
+  return merged.mcpServers.imstudium;
+}
+function mcpEntryMatches(existing, desired) {
+  if (!existing) return false;
+  return stableJson(existing) === stableJson(desired);
+}
+function stableJson(obj) {
+  const sortKeys = (value) => {
+    if (Array.isArray(value)) return value.map(sortKeys);
+    if (value && typeof value === "object") {
+      const record = value;
+      return Object.keys(record).sort().reduce((acc, key) => {
+        acc[key] = sortKeys(record[key]);
+        return acc;
+      }, {});
+    }
+    return value;
+  };
+  return JSON.stringify(sortKeys(obj));
+}
+async function loadManifest() {
+  try {
+    return JSON.parse(await readFile(MANIFEST_FILE, "utf-8"));
+  } catch {
+    try {
+      const legacyFile = join3(legacyPaths.configDir, "setup-manifest.json");
+      const raw = JSON.parse(await readFile(legacyFile, "utf-8"));
+      const converted = convertLegacyManifest(raw);
+      await saveManifest(converted);
+      return converted;
+    } catch {
+      return null;
+    }
+  }
+}
+async function saveManifest(manifest) {
+  await mkdir(dirname2(MANIFEST_FILE), { recursive: true });
+  manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(MANIFEST_FILE, `${JSON.stringify(manifest, null, 2)}
+`);
+}
+async function listSkillDirs(root) {
+  try {
+    const { readdir } = await import("fs/promises");
+    const entries = await readdir(root, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function cleanupLegacySkills(skillsDir) {
+  const removed = [];
+  for (const name of await listSkillDirs(skillsDir)) {
+    if (!name.startsWith("digicampus-")) continue;
+    await rm(join3(skillsDir, name), { recursive: true, force: true });
+    removed.push(name);
+  }
+  return removed;
+}
+async function installSkillIfChanged(src, dest, force) {
+  const srcFile = join3(src, "SKILL.md");
+  const destFile = join3(dest, "SKILL.md");
+  const srcContent = await readFile(srcFile, "utf-8");
+  const srcHash = hashContent(srcContent);
+  if (!force) {
+    try {
+      const destContent = await readFile(destFile, "utf-8");
+      if (hashContent(destContent) === srcHash) {
+        return { action: "skipped", path: dest };
+      }
+    } catch {
+    }
+  }
+  let hadPrevious = false;
+  try {
+    await readFile(destFile, "utf-8");
+    hadPrevious = true;
+  } catch {
+  }
+  await mkdir(dest, { recursive: true });
+  await cp(src, dest, { recursive: true, force: true });
+  return { action: hadPrevious ? "updated" : "installed", path: dest };
+}
+async function installMcpFile(file, workspace, force) {
+  const desired = imstudiumMcpEntry(workspace);
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(file, "utf-8"));
+  } catch {
+  }
+  const servers = existing.mcpServers ?? {};
+  if (!force && mcpEntryMatches(servers.imstudium, desired)) {
+    return { action: "skipped", path: file };
+  }
+  const merged = mergeMcpConfig(existing, workspace);
+  await mkdir(dirname2(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(merged, null, 2)}
+`);
+  return { action: servers.imstudium ? "updated" : "installed", path: file };
+}
+async function installProjectMcp(workspace, force = false) {
+  const file = join3(expandPath(workspace), "mcp.json");
+  return installMcpFile(file, workspace, force);
+}
+async function installSkillsForAgents(agents, manifest, force) {
+  const results = [];
+  const names = await listSkillDirs(SKILLS_ROOT);
+  const byDir = uniqueSkillsDirs(agents);
+  for (const [skillsDir, group] of byDir) {
+    await mkdir(skillsDir, { recursive: true });
+    await cleanupLegacySkills(skillsDir);
+    for (const name of names) {
+      if (name === "workflows") continue;
+      const result = await installSkillIfChanged(
+        join3(SKILLS_ROOT, name),
+        join3(skillsDir, name),
+        force
+      );
+      results.push(result);
+      for (const a of group) {
+        manifest.skills[a.id] ??= {};
+        manifest.skills[a.id][name] = hashContent(
+          await readFile(join3(SKILLS_ROOT, name, "SKILL.md"), "utf-8")
+        );
+      }
+    }
+  }
+  return results;
+}
+async function installWorkflowsForAgents(agents, force) {
+  const results = [];
+  const names = await listSkillDirs(WORKFLOWS_ROOT);
+  const byDir = uniqueSkillsDirs(agents);
+  for (const [skillsDir] of byDir) {
+    for (const name of names) {
+      results.push(
+        await installSkillIfChanged(join3(WORKFLOWS_ROOT, name), join3(skillsDir, name), force)
+      );
+    }
+  }
+  return results;
+}
+async function installMcpForAgents(agents, workspace, manifest, force) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const agent of agents) {
+    manifest.mcp[agent.id] ??= [];
+    for (const file of agent.mcpFiles()) {
+      if (seen.has(file)) continue;
+      seen.add(file);
+      const result = await installMcpFile(file, workspace, force);
+      results.push(result);
+      if (result.action !== "skipped") manifest.mcp[agent.id].push(file);
+    }
+  }
+  return results;
+}
+async function runSetup(what, opts = {}) {
+  await ensureMigrated();
+  const workspace = expandPath(opts.workspace ?? homedir2() + "/Studium");
+  const agents = resolveAgentProfiles(opts.agent, opts.allAgents || opts.agent === "all");
+  const prev = await loadManifest();
+  const manifest = prev?.workspace === workspace && !opts.force ? { ...prev, workspace } : emptyManifest(workspace);
+  manifest.imstudiumVersion = IMSTUDIUM_SETUP_VERSION;
+  const result = {
+    agents: agents.map((a) => a.id),
+    skills: [],
+    mcp: [],
+    workflows: [],
+    manifest
+  };
+  if (what === "migrate") {
+    opts.force = true;
+    what = "all";
+  }
+  if (what === "status") return result;
+  const force = Boolean(opts.force);
+  if (what === "skills" || what === "all") {
+    result.skills = await installSkillsForAgents(agents, manifest, force);
+  }
+  if (what === "workflows" || what === "all") {
+    result.workflows = await installWorkflowsForAgents(agents, force);
+  }
+  if (what === "mcp" || what === "all") {
+    result.mcp = await installMcpForAgents(agents, workspace, manifest, force);
+    if (opts.project !== false) {
+      result.project = [await installProjectMcp(workspace, force)];
+    }
+  }
+  await saveManifest(manifest);
+  return result;
+}
+async function bundledSkillHashes() {
+  const hashes = {};
+  const core = await listSkillDirs(SKILLS_ROOT);
+  for (const name of core) {
+    if (name === "workflows") continue;
+    const content = await readFile(join3(SKILLS_ROOT, name, "SKILL.md"), "utf-8");
+    hashes[name] = hashContent(content);
+  }
+  const workflows = await listSkillDirs(WORKFLOWS_ROOT);
+  for (const name of workflows) {
+    const content = await readFile(join3(WORKFLOWS_ROOT, name, "SKILL.md"), "utf-8");
+    hashes[name] = hashContent(content);
+  }
+  return hashes;
+}
+async function findStaleSkills(agents) {
+  const bundled = await bundledSkillHashes();
+  const stale = /* @__PURE__ */ new Set();
+  const byDir = uniqueSkillsDirs(agents);
+  for (const [skillsDir] of byDir) {
+    for (const [name, expected] of Object.entries(bundled)) {
+      try {
+        const content = await readFile(join3(skillsDir, name, "SKILL.md"), "utf-8");
+        if (hashContent(content) !== expected) stale.add(name);
+      } catch {
+        stale.add(name);
+      }
+    }
+  }
+  return [...stale].sort();
+}
+async function getSetupStatus(workspace) {
+  const ws = expandPath(workspace ?? homedir2() + "/Studium");
+  const manifest = await loadManifest();
+  const agentProfiles = detectAgents();
+  const detected = agentProfiles.map((a) => ({
+    id: a.id,
+    label: a.label,
+    skillsDir: a.skillsDir(),
+    mcpFiles: a.mcpFiles()
+  }));
+  const configured = manifest ? Object.keys(manifest.mcp).filter((id) => (manifest.mcp[id]?.length ?? 0) > 0) : [];
+  const agentsToCheck = configured.length > 0 ? resolveAgentProfiles("all", true).filter((a) => configured.includes(a.id)) : agentProfiles;
+  const staleSkills = await findStaleSkills(agentsToCheck.length > 0 ? agentsToCheck : agentProfiles);
+  const versionOk = manifest?.imstudiumVersion === IMSTUDIUM_SETUP_VERSION;
+  const workspaceOk = manifest?.workspace === ws;
+  const skillsOk = staleSkills.length === 0;
+  const upToDate = Boolean(manifest && versionOk && workspaceOk && skillsOk);
+  const stale = !upToDate;
+  return { detected, configured, manifest, upToDate, stale, staleSkills, workspace: ws };
+}
+function formatSetupSummary(result) {
+  const count = (items) => ({
+    installed: items.filter((i) => i.action === "installed").length,
+    updated: items.filter((i) => i.action === "updated").length,
+    skipped: items.filter((i) => i.action === "skipped").length
+  });
+  const s = count(result.skills);
+  const m = count(result.mcp);
+  const w = count(result.workflows);
+  const parts = [
+    `Agents: ${result.agents.join(", ") || "none"}`,
+    `Skills: ${s.installed} new, ${s.updated} updated, ${s.skipped} unchanged`,
+    `MCP: ${m.installed} new, ${m.updated} updated, ${m.skipped} unchanged`
+  ];
+  if (result.workflows.length) {
+    parts.push(`Workflows: ${w.installed + w.updated} changed, ${w.skipped} unchanged`);
+  }
+  return parts.join(" \xB7 ");
+}
+
+// src/onboard-flow.ts
+import {
+  createSdk,
+  ImstudiumError,
+  expandPath as expandPath2,
+  OnboardUI
+} from "@imstudium/sdk";
+function shouldShowOnboardUI(opts) {
+  return !opts.json && !opts.quiet && !opts.yes;
+}
+async function runOnboardFlow(opts) {
+  const partial = opts.instance ? {
+    baseUrl: `${opts.instance.replace(/\/$/, "")}/jsonapi.php/v1`,
+    instanceOrigin: opts.instance.replace(/\/$/, "")
+  } : void 0;
+  const sdk = await createSdk(partial);
+  const out = expandPath2(opts.output || sdk.workspacePath);
+  await sdk.saveConfig({ workspacePath: out });
+  const ui = shouldShowOnboardUI(opts) ? new OnboardUI(out) : null;
+  if (ui && opts.agentsOnly) ui.configureForAgentsOnly();
+  try {
+    if (ui) await ui.start(true);
+    ui?.updateStep("config", { status: "active" });
+    ui?.updateStep("config", { status: "done", detail: out });
+    let report;
+    let studium;
+    if (!opts.agentsOnly) {
+      const session = await sdk.auth.loadSession();
+      if (!session) {
+        if (opts.yes) {
+          throw new ImstudiumError(
+            "Not logged in.",
+            "NO_SESSION",
+            void 0,
+            "Run: imstudium login"
+          );
+        }
+        ui?.updateStep("login", { status: "active" });
+        ui?.setLiveMessage("Opening sign-in browser \u2014 complete MFA if prompted\u2026");
+        await opts.runLogin(sdk, (text) => ui?.setLiveMessage(text));
+        ui?.updateStep("login", { status: "done", detail: "Signed in" });
+      } else {
+        ui?.updateStep("login", { status: "skipped", detail: "Already signed in" });
+      }
+      if (!opts.skipSync) {
+        ui?.updateStep("sync", { status: "active" });
+        ui?.setLiveMessage("Downloading course files from Stud.IP\u2026");
+        const semOpts = {
+          semesterId: sdk.config.semesterId
+        };
+        report = await sdk.sync.sync({
+          outputDir: out,
+          include: ["wiki", "news", "calendar"],
+          ...semOpts
+        });
+        ui?.updateStep("sync", {
+          status: "done",
+          detail: `${report.downloaded} downloaded \xB7 ${report.skipped} unchanged`
+        });
+        ui?.updateStep("studium", { status: "active" });
+        ui?.setLiveMessage("Building studium.json and study overview\u2026");
+        studium = await sdk.studium.build(out, sdk.config.instanceOrigin, semOpts);
+        ui?.updateStep("studium", {
+          status: "done",
+          detail: `${studium.courses.length} courses`
+        });
+      } else {
+        ui?.updateStep("sync", { status: "skipped", detail: "--skip-sync" });
+        ui?.updateStep("studium", { status: "skipped", detail: "--skip-sync" });
+      }
+    }
+    ui?.updateStep("agents", { status: "active" });
+    ui?.setLiveMessage("Installing skills and MCP for detected AI tools\u2026");
+    const setup = await runSetup("all", {
+      yes: opts.yes,
+      workspace: out,
+      force: opts.force,
+      allAgents: opts.allAgents
+    });
+    const summary = formatSetupSummary(setup);
+    ui?.updateStep("agents", { status: "done", detail: setup.agents.join(", ") || "none" });
+    ui?.complete({
+      workspacePath: out,
+      courses: studium?.courses.length,
+      downloaded: report?.downloaded,
+      agents: setup.agents
+    });
+    if (ui) {
+      await ui.closeAfter(12e3);
+    }
+    return { workspace: out, report, studium, setup, summary };
+  } catch (err) {
+    const message = err instanceof ImstudiumError ? err.message : err instanceof Error ? err.message : String(err);
+    ui?.fail(message);
+    if (ui) await ui.closeAfter(8e3);
+    throw err;
+  }
+}
+
+// src/cli.ts
+import { fileURLToPath as fileURLToPath3 } from "url";
+var globalOpts = {};
+function output(data, text) {
+  if (globalOpts.json) {
+    console.log(JSON.stringify({ schemaVersion: "1", ...typeof data === "object" && data || { data } }, null, 2));
+  } else if (text) {
+    console.log(text);
+  } else if (typeof data === "string") {
+    console.log(data);
+  }
+}
+function fail(err) {
+  const error = err instanceof ImstudiumError2 ? err : new ImstudiumError2(err instanceof Error ? err.message : String(err), "UNKNOWN");
+  if (globalOpts.json) {
+    console.error(JSON.stringify(error.toJSON(), null, 2));
+  } else {
+    console.error(`Error: ${error.message}`);
+    if (error.hint) console.error(`Hint: ${error.hint}`);
+  }
+  process.exit(1);
+}
+async function getSdk() {
+  const partial = globalOpts.instance ? { baseUrl: `${globalOpts.instance.replace(/\/$/, "")}/jsonapi.php/v1`, instanceOrigin: globalOpts.instance.replace(/\/$/, "") } : void 0;
+  return createSdk2(partial);
+}
+function semesterSyncOptions(sdk, opts) {
+  if (opts.allSemesters) return { allSemesters: true };
+  if (opts.semester) return { semesterLabel: opts.semester };
+  if (sdk.config.semesterId) return { semesterId: sdk.config.semesterId };
+  return {};
+}
+function courseDirFor(ws, workspaceRoot, slug) {
+  const course = ws.courses.find((c) => c.slug === slug);
+  if (course) return resolveCourseDir(workspaceRoot, course, ws);
+  return join4(workspaceRoot, ws.activeSemester?.slug || "current", slug);
+}
+async function runLogin(sdk, opts) {
+  const loginOpts = {
+    instanceOrigin: sdk.config.instanceOrigin,
+    onMessage: (text) => {
+      opts.onMessage?.(text);
+      if (!opts.onMessage && !globalOpts.quiet) output(null, text);
+    }
+  };
+  const forceBrowser = opts.force ?? opts.relogin ?? false;
+  if (!forceBrowser && !opts.manual) {
+    const valid = await sdk.auth.ensureValidSession({
+      instanceOrigin: sdk.config.instanceOrigin,
+      clientId: sdk.config.oauth?.clientId
+    });
+    if (valid) {
+      if (!globalOpts.quiet) output(null, "Already signed in \u2014 session is valid.");
+      return;
+    }
+  }
+  const clientId = sdk.config.oauth?.clientId;
+  const useOAuth = opts.oauth || Boolean(clientId);
+  if (useOAuth && !opts.manual) {
+    if (!clientId) {
+      fail(new ImstudiumError2("Set IMSTUDIUM_OAUTH_CLIENT_ID or config oauth.clientId", "NO_CLIENT_ID"));
+    }
+    const probe = await probeOAuthServer(sdk.config.instanceOrigin, clientId);
+    if (probe.status === "ready") {
+      await sdk.auth.loginWithOAuth({
+        instanceOrigin: sdk.config.instanceOrigin,
+        clientId,
+        onMessage: loginOpts.onMessage
+      });
+      return;
+    }
+    if (probe.status === "broken_setup") {
+      if (!globalOpts.quiet) {
+        output(
+          null,
+          "Stud.IP OAuth is not set up on this instance yet \u2014 using browser sign-in instead."
+        );
+        output(null, `University admin: ${probe.endpoints.admin}`);
+      }
+    } else if (probe.status === "no_client") {
+      fail(
+        new ImstudiumError2(
+          "OAuth client_id was rejected by Stud.IP.",
+          "OAUTH_CLIENT_INVALID",
+          void 0,
+          "Check oauth.clientId in ~/.config/imstudium/config.json"
+        )
+      );
+    } else if (opts.oauth) {
+      fail(
+        new ImstudiumError2(
+          probe.message || "OAuth is unavailable on this Stud.IP instance.",
+          "OAUTH_UNAVAILABLE"
+        )
+      );
+    } else if (!globalOpts.quiet) {
+      output(null, `${probe.message || "OAuth unavailable"} \u2014 using browser sign-in.`);
+    }
+  }
+  if (opts.manual) {
+    if (globalOpts.json) {
+      output(null, "Starting manual login helper\u2026");
+      const result = await sdk.auth.loginInteractive(loginOpts);
+      output({ ok: true, sessionType: result.type }, "Session saved");
+      return;
+    }
+    output(null, "Opening manual login helper\u2026");
+    await sdk.auth.loginInteractive(loginOpts);
+    return;
+  }
+  const browserBase = {
+    instanceOrigin: sdk.config.instanceOrigin,
+    profileDirectory: opts.profileDirectory,
+    force: forceBrowser,
+    onMessage: loginOpts.onMessage
+  };
+  if (!globalOpts.quiet) {
+    output(null, "Opening sign-in browser\u2026");
+  }
+  if (opts.chromeProfile) {
+    if (await isChromeRunning()) {
+      fail(
+        new ImstudiumError2(
+          "Google Chrome is still running.",
+          "CHROME_PROFILE_LOCKED",
+          void 0,
+          "Quit Chrome completely, then run: imstudium login --chrome-profile"
+        )
+      );
+    }
+    await sdk.auth.loginWithBrowser({ ...browserBase, profile: "system" });
+    return;
+  }
+  await sdk.auth.loginWithBrowser({ ...browserBase, profile: "isolated" });
+}
+var CLI_ENTRY = fileURLToPath3(import.meta.url);
+var program = new Command();
+program.name("imstudium").description("ImStudium \u2014 extract, sync, and plan your studies").version(getCliVersion()).option("--json", "JSON output for agents").option("--quiet", "Minimal output").option("--instance <url>", "Stud.IP instance origin (default: digicampus.uni-augsburg.de)").hook("preAction", (thisCommand) => {
+  globalOpts = thisCommand.opts();
+});
+program.command("onboard").description("First-time setup: login, sync workspace, wire agents (idempotent)").option("-o, --output <dir>", "Workspace directory", "~/Studium").option("-y, --yes", "Non-interactive").option(
+  "--agents-only",
+  "Skip login/sync \u2014 only configure Cursor, Claude Code, Claude Desktop, Codex, Windsurf, OpenCode"
+).option("--skip-sync", "Login + agent setup, no file sync").option("--force", "Re-install skills/MCP even when unchanged").option("--all-agents", "Configure every harness path, not only detected ones").action(async (opts) => {
+  try {
+    const result = await runOnboardFlow({
+      ...opts,
+      json: globalOpts.json,
+      quiet: globalOpts.quiet,
+      instance: globalOpts.instance,
+      runLogin: async (sdk, onMessage) => {
+        await runLogin(sdk, {
+          onMessage: (text) => {
+            onMessage?.(text);
+            if (!globalOpts.quiet && !onMessage) output(null, text);
+          }
+        });
+      }
+    });
+    output(
+      {
+        workspace: result.workspace,
+        report: result.report,
+        studium: result.studium,
+        setup: result.setup,
+        summary: result.summary
+      },
+      `Onboarded \u2192 ${result.workspace}
+${result.summary}`
+    );
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("init").description("Login + sync Studium workspace (use onboard for first-time agent setup)").option("-o, --output <dir>", "Workspace directory").option("-y, --yes", "Non-interactive (skip prompts)").option("--relogin", "Sign in again even if a session is already stored").option("--chrome-profile", "Use your Chrome profile with saved passwords (quit Chrome first)").option("--extract", "Extract text + slide images after sync").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const out = expandPath3(opts.output || sdk.workspacePath);
+    const session = await sdk.auth.loadSession();
+    if (!session || opts.relogin) {
+      if (opts.yes && !session) {
+        fail(
+          new ImstudiumError2("Not logged in.", "NO_SESSION", void 0, "Run: imstudium login")
+        );
+      }
+      await runLogin(sdk, { chromeProfile: opts.chromeProfile });
+    }
+    await sdk.saveConfig({ workspacePath: out });
+    const semOpts = semesterSyncOptions(sdk, {});
+    const report = await sdk.sync.sync({
+      outputDir: out,
+      include: ["wiki", "news", "calendar"],
+      ...semOpts
+    });
+    const workspace = await sdk.studium.build(out, sdk.config.instanceOrigin, semOpts);
+    let extracted = 0;
+    if (opts.extract) {
+      for (const course of workspace.courses) {
+        const courseDir = courseDirFor(workspace, out, course.slug);
+        const results = await sdk.extractor.extractDir(
+          join4(courseDir, "files"),
+          join4(courseDir, "extracted"),
+          {
+            course: { title: course.title, path: course.path || `${workspace.activeSemester?.slug}/${course.slug}` },
+            workspaceRoot: out
+          }
+        );
+        extracted += results.filter((r) => !r.error && !r.skipped).length;
+      }
+      await rebuildSearchIndexes(out, workspace);
+      await sdk.studium.refreshSearchArtifacts(out, workspace);
+    }
+    output(
+      { workspace, report, extracted: opts.extract ? extracted : void 0, next: "imstudium onboard --agents-only" },
+      `Studium workspace ready at ${out} \u2014 ${workspace.activeSemester.title} in ${workspace.workspaceFolder}/${opts.extract ? ` \xB7 ${extracted} extracted` : ""}
+Run: imstudium onboard --agents-only  (once, idempotent)`
+    );
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("login").description("Sign in via browser \u2014 opens Stud.IP login every time").option("--oauth", "Use OAuth2 PKCE (requires registered client_id)").option("--chrome-profile", "Use your Chrome profile with saved passwords (quit Chrome first)").option("--profile-directory <name>", "Chrome profile folder with --chrome-profile", "Default").option("--manual", "Expert fallback: local helper page with manual session paste").option("--relogin", "Alias for login (browser sign-in always runs)").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    await runLogin(sdk, { ...opts, force: true });
+    const me = await sdk.courses.getMe();
+    const name = me.attributes?.["formatted-name"] || me.id;
+    output({ user: { id: me.id, name } }, `Logged in as ${name}`);
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("logout").description("Clear stored session").action(async () => {
+  try {
+    const sdk = await getSdk();
+    await sdk.auth.clearSession();
+    output({ ok: true }, "Logged out");
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("status").description("Auth and instance status").action(async () => {
+  try {
+    const sdk = await getSdk();
+    const oauth = await probeOAuthServer(sdk.config.instanceOrigin, sdk.config.oauth?.clientId);
+    const session = await sdk.auth.loadSession();
+    if (!session) {
+      output(
+        {
+          authenticated: false,
+          cliVersion: getCliVersion(),
+          oauth: {
+            status: oauth.status,
+            message: oauth.message,
+            recommended: oauth.status === "ready" ? "imstudium login --oauth" : "imstudium login",
+            adminUrl: oauth.endpoints.admin
+          }
+        },
+        [
+          "Not logged in. Run: imstudium login",
+          oauth.status === "broken_setup" ? "Note: Stud.IP OAuth is not configured on this instance \u2014 browser sign-in is used." : oauth.status === "ready" && sdk.config.oauth?.clientId ? "OAuth is ready \u2014 imstudium login will use it automatically." : oauth.status === "ready" ? "OAuth is available \u2014 register a client (see docs/OAUTH.md) for one-click login." : ""
+        ].filter(Boolean).join("\n")
+      );
+      return;
+    }
+    const me = await sdk.courses.getMe();
+    const props = await sdk.discovery.getProperties();
+    output({
+      authenticated: true,
+      cliVersion: getCliVersion(),
+      user: { id: me.id, name: me.attributes?.["formatted-name"] },
+      studipVersion: props["studip-version"],
+      workspace: sdk.workspacePath,
+      sessionType: session.type,
+      oauth: {
+        status: oauth.status,
+        adminUrl: oauth.endpoints.admin
+      },
+      next: "imstudium update"
+    });
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("update").description("Upgrade CLI (if needed) and refresh agent skills/MCP").action(async () => {
+  try {
+    const sdk = await getSdk();
+    const before = await checkForUpdates(CLI_ENTRY);
+    let upgraded = false;
+    let upgradeNote = "";
+    if (before.installMode === "global" && before.updateAvailable) {
+      const result = await runGlobalUpdate();
+      if (!result.ok) {
+        fail(
+          new ImstudiumError2(
+            "npm global upgrade failed",
+            "UPDATE_FAILED",
+            void 0,
+            result.output.slice(0, 500)
+          )
+        );
+      }
+      upgraded = true;
+      upgradeNote = `CLI ${before.current} \u2192 ${before.latest}
+`;
+    }
+    const setup = await runSetup("all", {
+      yes: true,
+      workspace: sdk.workspacePath,
+      force: upgraded
+    });
+    const after = await checkForUpdates(CLI_ENTRY);
+    const summary = formatSetupSummary(setup);
+    const text = before.installMode === "npx" && before.updateAvailable ? `${summary}
+Tip: npx -y @imstudium/cli@latest for newest CLI` : `${upgradeNote}${summary}`.trim();
+    output({ ...after, upgraded, setup, summary }, text);
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("studium").description("Show STUDIUM.md or studium.json").option("-o, --output <dir>", "Workspace directory").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const dir = expandPath3(opts.output || sdk.workspacePath);
+    if (globalOpts.json) {
+      const ws = await sdk.studium.loadWorkspace(dir);
+      if (!ws) fail(new ImstudiumError2("No workspace. Run imstudium init", "NO_WORKSPACE"));
+      output(ws);
+    } else {
+      const md = await readFile2(join4(dir, "STUDIUM.md"), "utf-8");
+      output(md);
+    }
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("klausuren").description("Exam timeline").option("-o, --output <dir>", "Workspace directory").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const dir = expandPath3(opts.output || sdk.workspacePath);
+    if (globalOpts.json) {
+      const ws = await sdk.studium.loadWorkspace(dir);
+      if (!ws) fail(new ImstudiumError2("No workspace", "NO_WORKSPACE"));
+      const exams = ws.courses.flatMap((c) => c.examDates);
+      output({ exams, nextDeadlines: ws.nextDeadlines });
+    } else {
+      const md = await readFile2(join4(dir, "klausuren.md"), "utf-8");
+      output(md);
+    }
+  } catch (e) {
+    fail(e);
+  }
+});
+var courses = program.command("courses").description("Course commands");
+courses.command("list").description("List my courses").option("--semester <name>", "Semester title or slug (default: calendar current)").option("--all-semesters", "List every enrollment").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const me = await sdk.courses.getMe();
+    const semOpts = semesterSyncOptions(sdk, opts);
+    const ctx = await sdk.courses.resolveSemesterContext(semOpts);
+    let list = await sdk.courses.listMine(me.id, {
+      semesterId: semOpts.semesterId ?? ctx?.semester.id,
+      allSemesters: opts.allSemesters
+    });
+    output(
+      {
+        courses: list.map((c) => ({
+          id: c.id,
+          title: c.attributes?.title,
+          type: c.attributes?.["course-type"],
+          number: c.attributes?.["course-number"]
+        })),
+        semester: ctx ? { id: ctx.semester.id, title: ctx.title, slug: ctx.slug } : void 0,
+        count: list.length
+      },
+      ctx ? `${list.length} courses in ${ctx.title}` : `${list.length} courses (all semesters)`
+    );
+  } catch (e) {
+    fail(e);
+  }
+});
+courses.command("show <idOrName>").description("Show course details").action(async (idOrName) => {
+  try {
+    const sdk = await getSdk();
+    const me = await sdk.courses.getMe();
+    const list = await sdk.courses.listMine(me.id);
+    const course = list.find((c) => c.id === idOrName) || list.find(
+      (c) => (c.attributes?.title || "").toLowerCase().includes(idOrName.toLowerCase())
+    );
+    if (!course) fail(new ImstudiumError2("Course not found", "NOT_FOUND"));
+    const full = await sdk.courses.get(course.id);
+    const fileCount = (await sdk.files.listAllFileRefs(course.id)).length;
+    output({ course: full, fileCount });
+  } catch (e) {
+    fail(e);
+  }
+});
+var files = program.command("files").description("File commands");
+files.command("tree <course>").description("Folder/file tree for a course").action(async (courseName) => {
+  try {
+    const sdk = await getSdk();
+    const me = await sdk.courses.getMe();
+    const list = await sdk.courses.listMine(me.id);
+    const course = list.find(
+      (c) => c.id === courseName || (c.attributes?.title || "").toLowerCase().includes(courseName.toLowerCase())
+    );
+    if (!course) fail(new ImstudiumError2("Course not found", "NOT_FOUND"));
+    const tree = await sdk.files.buildFolderTree(course.id);
+    output({ courseId: course.id, tree });
+  } catch (e) {
+    fail(e);
+  }
+});
+files.command("download <fileRefId>").description("Download a single file").option("-o, --output <path>", "Output path").action(async (fileRefId, opts) => {
+  try {
+    const sdk = await getSdk();
+    const meta = await sdk.files.getFileRef(fileRefId);
+    const name = meta.attributes?.name || fileRefId;
+    const dest = opts.output || name;
+    const bytes = await sdk.files.downloadFileRef(fileRefId, dest);
+    output({ path: dest, bytes }, `Downloaded ${dest} (${bytes} bytes)`);
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("sync").description("Sync files and rebuild Studium workspace").option("-o, --output <dir>", "Output directory").option("--course <name>", "Sync single course").option("--semester <label>", "Semester title or slug (e.g. SS2026, WS2025-26)").option("--all-semesters", "Sync every enrollment (all semesters)").option("--layout <mode>", "flat or tree", "flat").option("--dry-run", "List changes without downloading").option("--include <items>", "Comma-separated: wiki,news,calendar").option("--extract", "Extract text + page images from new/changed files after sync").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const out = expandPath3(opts.output || sdk.workspacePath);
+    const include = opts.include?.split(",").map((s) => s.trim());
+    const semOpts = semesterSyncOptions(sdk, opts);
+    const report = await sdk.sync.sync({
+      outputDir: out,
+      layout: opts.layout || "flat",
+      dryRun: opts.dryRun,
+      include,
+      ...semOpts,
+      courseFilter: opts.course ? (c) => c.title.toLowerCase().includes(opts.course.toLowerCase()) || c.id === opts.course : void 0
+    });
+    let extracted = 0;
+    let folderNote = "";
+    if (!opts.dryRun) {
+      const workspace = await sdk.studium.build(out, sdk.config.instanceOrigin, semOpts);
+      folderNote = ` \u2014 ${workspace.activeSemester.title} in ${workspace.workspaceFolder}/`;
+      if (opts.extract) {
+        for (const course of workspace.courses) {
+          const courseDir = courseDirFor(workspace, out, course.slug);
+          const results = await sdk.extractor.extractDir(
+            join4(courseDir, "files"),
+            join4(courseDir, "extracted"),
+            {
+              course: { title: course.title, path: course.path || `${workspace.activeSemester?.slug}/${course.slug}` },
+              workspaceRoot: out
+            }
+          );
+          extracted += results.filter((r) => !r.error && !r.skipped).length;
+        }
+        await rebuildSearchIndexes(out, workspace);
+        await sdk.studium.refreshSearchArtifacts(out, workspace);
+      }
+    }
+    output(
+      { ...report, extracted: opts.extract ? extracted : void 0 },
+      `Sync: ${report.downloaded} downloaded, ${report.skipped} skipped, ${report.failed} failed${opts.extract ? `, ${extracted} extracted` : ""}${folderNote}`
+    );
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("extract").description("Extract text + page images from synced materials (PDF, PPTX, DOCX, images, ...)").option("--course <name>", "Only one course (title substring or slug)").option("--file <path>", "Extract a single file to <file>-extracted/").option("--no-images", "Text only, skip page image rendering").option("--dpi <n>", "Image resolution", "144").option("--force", "Re-extract even if unchanged").option("-o, --output <dir>", "Workspace directory").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const extractOpts = {
+      images: opts.images,
+      dpi: parseInt(opts.dpi || "144", 10),
+      force: opts.force
+    };
+    if (opts.file) {
+      const src = expandPath3(opts.file);
+      const outDir = src.replace(/\.[^.]+$/, "") + "-extracted";
+      const result = await sdk.extractor.extractFile(src, outDir, extractOpts);
+      output(result, `Extracted ${result.pages} page(s) \u2192 ${result.outDir}${result.hint ? `
+Hint: ${result.hint}` : ""}`);
+      return;
+    }
+    const ws = expandPath3(opts.output || sdk.workspacePath);
+    const workspace = await sdk.studium.loadWorkspace(ws);
+    if (!workspace) fail(new ImstudiumError2("No workspace. Run imstudium init", "NO_WORKSPACE"));
+    const courses2 = opts.course ? [pickCourse(workspace, opts.course)].filter(Boolean) : workspace.courses.filter((c) => c.semesterId === workspace.activeSemester?.id || !workspace.activeSemester?.id);
+    if (courses2.length === 0) fail(new ImstudiumError2("Course not found", "NOT_FOUND"));
+    const tools = await sdk.extractor.getTools();
+    const results = [];
+    for (const course of courses2) {
+      if (!course) continue;
+      const courseDir = courseDirFor(workspace, ws, course.slug);
+      const courseResults = await sdk.extractor.extractDir(
+        join4(courseDir, "files"),
+        join4(courseDir, "extracted"),
+        {
+          ...extractOpts,
+          course: { title: course.title, path: course.path },
+          workspaceRoot: ws
+        }
+      );
+      results.push(...courseResults);
+    }
+    const searchIndex = await rebuildSearchIndexes(ws, workspace);
+    if (searchIndex) await sdk.studium.refreshSearchArtifacts(ws, workspace);
+    const done = results.filter((r) => !r.error && !r.skipped).length;
+    const skipped = results.filter((r) => r.skipped).length;
+    const failed = results.filter((r) => r.error).length;
+    const hints = toolHints(tools);
+    output(
+      { extracted: done, skipped, failed, hints, results, searchIndex },
+      `Extracted ${done}, skipped ${skipped} (unchanged), failed ${failed}${searchIndex ? ` \xB7 ${searchIndex.chunkCount} search chunks` : ""}${hints.length ? `
+${hints.join("\n")}` : ""}`
+    );
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("index").description("Build/rebuild page index (corpus.jsonl) \u2014 for agent grep / semantic search, not a custom search engine").option("--course <name>", "Only one course").option("-o, --output <dir>", "Workspace directory").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const ws = expandPath3(opts.output || sdk.workspacePath);
+    const workspace = await sdk.studium.loadWorkspace(ws);
+    if (!workspace) fail(new ImstudiumError2("No workspace. Run imstudium init", "NO_WORKSPACE"));
+    if (opts.course) {
+      const course = pickCourse(workspace, opts.course);
+      if (!course?.path) fail(new ImstudiumError2("Course not found", "NOT_FOUND"));
+      const { buildCourseSearchIndex, buildMaterialsManifest } = await import("@imstudium/sdk");
+      const idx2 = await buildCourseSearchIndex(join4(ws, course.path), course, ws);
+      if (!idx2) fail(new ImstudiumError2("No extractions for this course. Run: imstudium extract --course ...", "NO_CORPUS"));
+      await buildMaterialsManifest(join4(ws, course.path), course);
+      await sdk.studium.refreshSearchArtifacts(ws, workspace);
+      output(idx2, `Indexed ${idx2.chunkCount} chunks from ${idx2.materialCount} files \u2192 ${course.path}/search/corpus.jsonl`);
+      return;
+    }
+    const idx = await rebuildSearchIndexes(ws, workspace);
+    if (!idx) fail(new ImstudiumError2("No extractions yet. Run: imstudium extract", "NO_CORPUS"));
+    await sdk.studium.refreshSearchArtifacts(ws, workspace);
+    output(idx, `Indexed ${idx.chunkCount} chunks across ${idx.courseCount} courses \u2192 per-course search/corpus.jsonl + materials.json`);
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("view").description("Build viewer.html for slide PNGs \u2014 fast path for Playwright / browser agents").option("--dir <path>", "Already-extracted directory (contains pages/)").option("--course <name>", "Course title substring").option("--file <name>", "Material filename substring").option("-o, --output <dir>", "Workspace directory").action(async (opts) => {
+  try {
+    let outDir = opts.dir ? expandPath3(opts.dir) : void 0;
+    let title = outDir ? basename(outDir) : "slides";
+    if (!outDir) {
+      if (!opts.course || !opts.file) {
+        fail(new ImstudiumError2("Provide --dir OR both --course and --file", "MISSING_ARG"));
+      }
+      const sdk = await getSdk();
+      const ws = expandPath3(opts.output || sdk.workspacePath);
+      const workspace = await sdk.studium.loadWorkspace(ws);
+      if (!workspace) fail(new ImstudiumError2("No workspace. Run imstudium init", "NO_WORKSPACE"));
+      const course = pickCourse(workspace, opts.course);
+      if (!course) fail(new ImstudiumError2("Course not found", "NOT_FOUND"));
+      const courseDir = resolveCourseDir(ws, course, workspace);
+      const filesDir = join4(courseDir, "files");
+      const { readdir: rd } = await import("fs/promises");
+      const matches = [];
+      async function walk(d) {
+        const entries = await rd(d, { withFileTypes: true }).catch(() => []);
+        for (const e of entries) {
+          const p = join4(d, e.name);
+          if (e.isDirectory()) await walk(p);
+          else if (e.name.toLowerCase().includes(opts.file.toLowerCase())) matches.push(p);
+        }
+      }
+      await walk(filesDir);
+      if (!matches.length) fail(new ImstudiumError2("File not found", "NOT_FOUND"));
+      const src = matches[0];
+      title = basename(src);
+      outDir = join4(courseDir, "extracted", extractSlug(title));
+      await sdk.extractor.extractFile(src, outDir);
+    }
+    const { viewerHtml, pageImages } = await buildSlideViewer(outDir, title);
+    const visual = buildAgentVisualPayload(pageImages, viewerHtml);
+    output(
+      { ...visual, viewerHtml, viewerFileUrl: `file://${viewerHtml}` },
+      pageImages.length ? `Viewer: file://${viewerHtml}
+${pageImages.length} slide(s) \u2014 agents must read pageImages or open viewer in Playwright` : `No page images in ${outDir}. Run: imstudium extract --file <path>`
+    );
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("doctor").description("Check extraction tool availability").action(async () => {
+  try {
+    const sdk = await getSdk();
+    const oauth = await probeOAuthServer(sdk.config.instanceOrigin, sdk.config.oauth?.clientId);
+    const tools = await detectTools();
+    const hints = toolHints(tools);
+    const update = await checkForUpdates(CLI_ENTRY);
+    const lines = [
+      `imstudium:  ${getCliVersion()} (${update.installMode})`,
+      update.updateAvailable ? `update:      ${update.current} \u2192 ${update.latest} \u2014 run: imstudium update` : `update:      up to date`,
+      "",
+      `oauth:       ${oauth.status}${oauth.message ? ` \u2014 ${oauth.message}` : ""}`,
+      oauth.status === "broken_setup" ? `oauth fix:   university admin \u2192 ${oauth.endpoints.admin}` : oauth.status === "ready" && !sdk.config.oauth?.clientId ? `oauth tip:   register client \u2192 docs/OAUTH.md` : "",
+      "",
+      `pdftotext:   ${tools.pdftotext || "MISSING"}`,
+      `pdftoppm:    ${tools.pdftoppm || "MISSING"}`,
+      `libreoffice: ${tools.soffice || "MISSING (native PPTX/DOCX text fallback active)"}`,
+      `tesseract:   ${tools.tesseract || "MISSING (no OCR for scanned PDFs/photos \u2014 agents can still read page images)"}`,
+      `unzip:       ${tools.unzip || "MISSING"}`
+    ];
+    if (hints.length) lines.push("", ...hints);
+    output({ cliVersion: getCliVersion(), update, oauth, tools, hints }, lines.filter(Boolean).join("\n"));
+  } catch (e) {
+    fail(e);
+  }
+});
+var exportCmd = program.command("export").description("Export rich content");
+exportCmd.command("calendar").option("-o, --output <dir>").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const me = await sdk.courses.getMe();
+    const ics = await sdk.schedule.exportCalendarIcs(me.id);
+    const dir = expandPath3(opts.output || sdk.workspacePath);
+    const { writeFile: writeFile2, mkdir: mkdir2 } = await import("fs/promises");
+    await mkdir2(dir, { recursive: true });
+    const path = join4(dir, "calendar.ics");
+    await writeFile2(path, ics);
+    output({ path }, `Wrote ${path}`);
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("watch").description("Continuous sync loop").option("--interval <duration>", "Interval e.g. 1h, 30m", "1h").option("-o, --output <dir>").action(async (opts) => {
+  const ms = parseInterval(opts.interval || "1h");
+  const sdk = await getSdk();
+  const out = expandPath3(opts.output || sdk.workspacePath);
+  output(null, `Watching every ${opts.interval} \u2192 ${out} (Ctrl+C to stop)`);
+  const semOpts = semesterSyncOptions(sdk, {});
+  for (; ; ) {
+    try {
+      const report = await sdk.sync.sync({ outputDir: out, include: ["wiki", "news", "calendar"], ...semOpts });
+      await sdk.studium.build(out, sdk.config.instanceOrigin, semOpts);
+      if (!globalOpts.quiet) {
+        output(report, `[${(/* @__PURE__ */ new Date()).toISOString()}] ${report.downloaded} new files`);
+      }
+    } catch (e) {
+      console.error(e);
+    }
+    await sleep(ms);
+  }
+});
+program.command("semesters").description("List Stud.IP semesters and show the calendar-current one").action(async () => {
+  try {
+    const sdk = await getSdk();
+    const { SemestersResource, computeSemesterProgress } = await import("@imstudium/sdk");
+    const semesters = new SemestersResource(sdk.client);
+    const all = await semesters.listAll();
+    const current = await semesters.getCurrent();
+    const progress = current ? computeSemesterProgress(current) : void 0;
+    output(
+      {
+        current: current ? {
+          id: current.id,
+          title: current.attributes?.title,
+          start: current.attributes?.start,
+          end: current.attributes?.end,
+          ...progress
+        } : null,
+        semesters: all.slice(-12).map((s) => ({
+          id: s.id,
+          title: s.attributes?.title,
+          start: s.attributes?.start,
+          end: s.attributes?.end,
+          current: s.id === current?.id
+        }))
+      },
+      [
+        current ? `Current: ${current.attributes?.title} (${current.id})${progress ? ` \u2014 week ${progress.weekNumber}, day ${progress.daysElapsed}/${progress.daysTotal} (${progress.progressPercent}%)` : ""}` : "No current semester",
+        'Default sync/studium/courses commands focus on this semester. Use --semester "<name>" or --all-semesters for others.',
+        "",
+        ...all.slice(-8).map((s) => {
+          const mark = s.id === current?.id ? " \u2190 current" : "";
+          return `${s.attributes?.title}${mark}`;
+        })
+      ].join("\n")
+    );
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("discover").description("List JSON:API routes").action(async () => {
+  try {
+    const sdk = await getSdk();
+    const routes = await sdk.discovery.listRoutes();
+    output({ routes, count: routes.length });
+  } catch (e) {
+    fail(e);
+  }
+});
+var sessionCmd = program.command("session").description("Session management");
+sessionCmd.command("import").option("--cookie <value>", "Seminar_Session cookie value").option("--file <path>", "Netscape cookie file").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    if (opts.cookie) {
+      await sdk.auth.importCookies({ Seminar_Session: opts.cookie });
+    } else if (opts.file) {
+      const content = await readFile2(opts.file, "utf-8");
+      await sdk.auth.importFromNetscapeCookieFile(content);
+    } else {
+      fail(new ImstudiumError2("Provide --cookie or --file", "MISSING_ARG"));
+    }
+    output({ ok: true }, "Session imported");
+  } catch (e) {
+    fail(e);
+  }
+});
+var configCmd = program.command("config").description("Configuration");
+configCmd.command("show").action(async () => {
+  try {
+    const sdk = await getSdk();
+    output(sdk.config);
+  } catch (e) {
+    fail(e);
+  }
+});
+configCmd.command("set <key> <value>").action(async (key, value) => {
+  try {
+    const sdk = await getSdk();
+    if (key === "base-url") {
+      await sdk.saveConfig({ baseUrl: value, instanceOrigin: value.replace(/\/jsonapi\.php\/v1$/, "") });
+    } else if (key === "workspace") {
+      await sdk.saveConfig({ workspacePath: value });
+    } else {
+      fail(new ImstudiumError2(`Unknown key: ${key}`, "INVALID_KEY"));
+    }
+    output({ ok: true }, `Set ${key}`);
+  } catch (e) {
+    fail(e);
+  }
+});
+var AGENT_HELP = "cursor | claude-code | claude-desktop | codex | windsurf | opencode | all";
+var setupCmd = program.command("setup").description("Idempotent agent wiring (skills, MCP) \u2014 only updates what changed");
+setupCmd.command("status").description("Show detected agents and setup manifest").action(async () => {
+  try {
+    const sdk = await getSdk();
+    const status = await getSetupStatus(sdk.workspacePath);
+    const lines = [
+      `Workspace: ${status.workspace}`,
+      `Manifest: ${status.manifest ? status.manifest.updatedAt : "none"}`,
+      `Up to date: ${status.upToDate ? "yes" : "no"}`,
+      `Stale: ${status.stale ? "yes" : "no"}`,
+      "",
+      `Configured agents: ${status.configured.length ? status.configured.join(", ") : "none"}`,
+      "",
+      "Detected agents:",
+      ...status.detected.map(
+        (a) => `  ${a.label} (${a.id}) \u2014 skills: ${a.skillsDir}`
+      )
+    ];
+    if (status.staleSkills.length) {
+      lines.push("", `Stale skills: ${status.staleSkills.join(", ")}`);
+      lines.push("Run: imstudium setup all -y");
+    }
+    output(status, lines.join("\n"));
+  } catch (e) {
+    fail(e);
+  }
+});
+setupCmd.command("skills").option("--agent <agent>", AGENT_HELP).option("--all-agents", "Configure every harness, not only detected").option("--force", "Overwrite unchanged skills").option("-y, --yes", "Non-interactive").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const result = await runSetup("skills", {
+      yes: opts.yes,
+      agent: opts.agent || void 0,
+      workspace: sdk.workspacePath,
+      allAgents: opts.allAgents,
+      force: opts.force
+    });
+    output(result, formatSetupSummary(result));
+  } catch (e) {
+    fail(e);
+  }
+});
+setupCmd.command("workflows").option("--agent <agent>", AGENT_HELP).option("--all-agents", "Configure every harness, not only detected").option("--force", "Overwrite unchanged workflows").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const result = await runSetup("workflows", {
+      agent: opts.agent || void 0,
+      workspace: sdk.workspacePath,
+      allAgents: opts.allAgents,
+      force: opts.force
+    });
+    output(result, formatSetupSummary(result));
+  } catch (e) {
+    fail(e);
+  }
+});
+setupCmd.command("mcp").option("--agent <agent>", AGENT_HELP).option("--all-agents", "Configure every harness, not only detected").option("-o, --workspace <dir>", "Studium workspace path").option("--force", "Rewrite MCP config even if identical").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const result = await runSetup("mcp", {
+      agent: opts.agent || void 0,
+      workspace: opts.workspace || sdk.workspacePath,
+      allAgents: opts.allAgents,
+      force: opts.force
+    });
+    output(result, formatSetupSummary(result));
+  } catch (e) {
+    fail(e);
+  }
+});
+setupCmd.command("migrate").description("Migrate DigiCampus config/skills/MCP to ImStudium (idempotent)").option("-o, --workspace <dir>", "Studium workspace path").option("--all-agents", "Configure every harness, not only detected").option("-y, --yes", "Non-interactive").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const migration = await ensureMigrated2();
+    const result = await runSetup("migrate", {
+      yes: opts.yes,
+      workspace: opts.workspace || sdk.workspacePath,
+      allAgents: opts.allAgents,
+      force: true
+    });
+    const archived = await archiveLegacyConfigDir();
+    output(
+      { migration, setup: result, archivedLegacyConfig: archived },
+      [
+        `Migration: ${migration.migrated.length ? migration.migrated.join(", ") : "already up to date"}`,
+        formatSetupSummary(result),
+        archived ? "Archived ~/.config/digicampus \u2192 digicampus.archived" : ""
+      ].filter(Boolean).join("\n")
+    );
+  } catch (e) {
+    fail(e);
+  }
+});
+setupCmd.command("all").description("Skills + workflows + MCP (idempotent \u2014 skips unchanged)").option("--agent <agent>", AGENT_HELP).option("-o, --workspace <dir>", "Studium workspace path").option("--all-agents", "Configure every harness, not only detected").option("--force", "Overwrite even when unchanged").option("-y, --yes", "Non-interactive").action(async (opts) => {
+  try {
+    const sdk = await getSdk();
+    const result = await runSetup("all", {
+      yes: opts.yes,
+      agent: opts.agent || void 0,
+      workspace: opts.workspace || sdk.workspacePath,
+      allAgents: opts.allAgents,
+      force: opts.force
+    });
+    output(result, formatSetupSummary(result));
+  } catch (e) {
+    fail(e);
+  }
+});
+function parseInterval(s) {
+  const m = s.match(/^(\d+)([hms])$/);
+  if (!m) return 36e5;
+  const n = parseInt(m[1], 10);
+  if (m[2] === "h") return n * 36e5;
+  if (m[2] === "m") return n * 6e4;
+  return n * 1e3;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+program.parse();