@bis-code/study-dash 0.2.0

package/server/dist/bundle.mjs

@@ -0,0 +1,1240 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/storage/db.ts
+import BetterSqlite3 from "better-sqlite3";
+
+// src/storage/schema.ts
+var schema = `
+PRAGMA foreign_keys=ON;
+
+CREATE TABLE IF NOT EXISTS subjects (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  name       TEXT    NOT NULL,
+  slug       TEXT    NOT NULL UNIQUE,
+  language   TEXT    NOT NULL DEFAULT '',
+  source     TEXT    NOT NULL DEFAULT 'manual'
+               CHECK (source IN ('manual','roadmap','pdf')),
+  created_at TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS phases (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  subject_id  INTEGER NOT NULL REFERENCES subjects(id) ON DELETE CASCADE,
+  name        TEXT    NOT NULL,
+  description TEXT    NOT NULL DEFAULT '',
+  sort_order  INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE INDEX IF NOT EXISTS idx_phases_subject ON phases(subject_id);
+
+CREATE TABLE IF NOT EXISTS topics (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  phase_id    INTEGER NOT NULL REFERENCES phases(id) ON DELETE CASCADE,
+  name        TEXT    NOT NULL,
+  description TEXT    NOT NULL DEFAULT '',
+  sort_order  INTEGER NOT NULL DEFAULT 0,
+  status      TEXT    NOT NULL DEFAULT 'todo'
+                CHECK (status IN ('todo','in_progress','done')),
+  updated_at  TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_topics_phase  ON topics(phase_id);
+CREATE INDEX IF NOT EXISTS idx_topics_status ON topics(status);
+
+CREATE TABLE IF NOT EXISTS entries (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  topic_id    INTEGER NOT NULL REFERENCES topics(id) ON DELETE CASCADE,
+  kind        TEXT    NOT NULL CHECK (kind IN ('question','answer','note')),
+  content     TEXT    NOT NULL DEFAULT '',
+  session_id  TEXT    NOT NULL DEFAULT '',
+  question_id INTEGER REFERENCES entries(id) ON DELETE SET NULL,
+  created_at  TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_entries_topic   ON entries(topic_id);
+CREATE INDEX IF NOT EXISTS idx_entries_session ON entries(session_id);
+
+CREATE TABLE IF NOT EXISTS visualizations (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  topic_id   INTEGER NOT NULL REFERENCES topics(id) ON DELETE CASCADE,
+  title      TEXT    NOT NULL DEFAULT '',
+  steps_json TEXT    NOT NULL DEFAULT '[]',
+  created_at TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_viz_topic ON visualizations(topic_id);
+
+CREATE TABLE IF NOT EXISTS exercises (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  topic_id     INTEGER NOT NULL REFERENCES topics(id) ON DELETE CASCADE,
+  title        TEXT    NOT NULL DEFAULT '',
+  type         TEXT    NOT NULL DEFAULT 'coding'
+                 CHECK (type IN ('coding','quiz','project','assignment')),
+  description  TEXT    NOT NULL DEFAULT '',
+  difficulty   TEXT    NOT NULL DEFAULT 'medium'
+                 CHECK (difficulty IN ('easy','medium','hard')),
+  est_minutes  INTEGER NOT NULL DEFAULT 0,
+  source       TEXT    NOT NULL DEFAULT 'ai'
+                 CHECK (source IN ('ai','pdf_import')),
+  starter_code TEXT    NOT NULL DEFAULT '',
+  test_content TEXT    NOT NULL DEFAULT '',
+  quiz_json    TEXT    NOT NULL DEFAULT '{}',
+  file_path    TEXT    NOT NULL DEFAULT '',
+  status       TEXT    NOT NULL DEFAULT 'pending'
+                 CHECK (status IN ('pending','in_progress','passed','failed')),
+  created_at   TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_exercises_topic  ON exercises(topic_id);
+CREATE INDEX IF NOT EXISTS idx_exercises_status ON exercises(status);
+
+CREATE TABLE IF NOT EXISTS exercise_results (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  exercise_id INTEGER NOT NULL REFERENCES exercises(id) ON DELETE CASCADE,
+  test_name   TEXT    NOT NULL DEFAULT '',
+  passed      INTEGER NOT NULL DEFAULT 0,
+  output      TEXT    NOT NULL DEFAULT '',
+  ran_at      TEXT    NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_results_exercise ON exercise_results(exercise_id);
+
+CREATE TABLE IF NOT EXISTS settings (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL DEFAULT ''
+);
+
+-- FTS5 virtual table for full-text search over entries
+CREATE VIRTUAL TABLE IF NOT EXISTS entries_fts
+  USING fts5(content, content='entries', content_rowid='id');
+
+-- Sync triggers: keep entries_fts up to date with entries
+CREATE TRIGGER IF NOT EXISTS entries_ai
+  AFTER INSERT ON entries BEGIN
+    INSERT INTO entries_fts(rowid, content) VALUES (new.id, new.content);
+  END;
+
+CREATE TRIGGER IF NOT EXISTS entries_ad
+  AFTER DELETE ON entries BEGIN
+    INSERT INTO entries_fts(entries_fts, rowid, content)
+      VALUES ('delete', old.id, old.content);
+  END;
+
+CREATE TRIGGER IF NOT EXISTS entries_au
+  AFTER UPDATE ON entries BEGIN
+    INSERT INTO entries_fts(entries_fts, rowid, content)
+      VALUES ('delete', old.id, old.content);
+    INSERT INTO entries_fts(rowid, content) VALUES (new.id, new.content);
+  END;
+`;
+var migrations = [];
+
+// src/storage/db.ts
+var Database = class {
+  db;
+  constructor(dbPath) {
+    this.db = new BetterSqlite3(dbPath);
+    this.db.pragma("journal_mode=WAL");
+    this.db.pragma("foreign_keys=ON");
+    this.db.exec(schema);
+    const currentVersion = this.getSetting("schema_version");
+    if (!currentVersion) {
+      this.setSetting("schema_version", "1");
+      this.setSetting("auto_viz", "true");
+      this.setSetting("dashboard_port", "19282");
+    }
+    const versionNum = parseInt(this.getSetting("schema_version") ?? "1", 10);
+    for (let i = versionNum - 1; i < migrations.length; i++) {
+      this.db.exec(migrations[i]);
+      this.setSetting("schema_version", String(i + 2));
+    }
+  }
+  getSetting(key) {
+    const row = this.db.prepare("SELECT value FROM settings WHERE key = ?").get(key);
+    return row?.value;
+  }
+  setSetting(key, value) {
+    this.db.prepare("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+  }
+  listTables() {
+    const allRows = this.db.prepare("SELECT name FROM sqlite_master WHERE type IN ('table')").all();
+    return allRows.map((r) => r.name);
+  }
+  /** Expose the raw better-sqlite3 handle for advanced operations. */
+  get raw() {
+    return this.db;
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/storage/files.ts
+import { mkdirSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+var FileStore = class {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir ?? join(homedir(), ".claude", "learn");
+    mkdirSync(join(this.baseDir, "exercises"), { recursive: true });
+  }
+  get exercisesDir() {
+    return join(this.baseDir, "exercises");
+  }
+  get dataDir() {
+    return this.baseDir;
+  }
+  get dbPath() {
+    return join(this.baseDir, "data.db");
+  }
+  writeExerciseFiles(subjectSlug, exerciseSlug, files) {
+    const dir = join(this.exercisesDir, subjectSlug, exerciseSlug);
+    mkdirSync(dir, { recursive: true });
+    for (const [name, content] of Object.entries(files)) {
+      writeFileSync(join(dir, name), content, "utf-8");
+    }
+    return dir;
+  }
+  exerciseExists(subjectSlug, exerciseSlug) {
+    return existsSync(join(this.exercisesDir, subjectSlug, exerciseSlug));
+  }
+  readFile(path) {
+    return readFileSync(path, "utf-8");
+  }
+};
+
+// src/services/curriculum.ts
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+var CurriculumService = class {
+  constructor(db2) {
+    this.db = db2;
+  }
+  // ── Subjects ───────────────────────────────────────────────────────────────
+  createSubject(name, language = "", source = "manual") {
+    const slug = language && !language.includes(" ") && name.toLowerCase() === language.toLowerCase() ? language.toLowerCase() : slugify(name);
+    const result = this.db.raw.prepare(
+      "INSERT INTO subjects (name, slug, language, source) VALUES (?, ?, ?, ?) RETURNING id"
+    ).get(name, slug, language, source);
+    return this.getSubject(result.id);
+  }
+  listSubjects() {
+    return this.db.raw.prepare("SELECT * FROM subjects ORDER BY created_at DESC").all();
+  }
+  getSubject(id) {
+    return this.db.raw.prepare("SELECT * FROM subjects WHERE id = ?").get(id);
+  }
+  findSubjectByName(name) {
+    return this.db.raw.prepare("SELECT * FROM subjects WHERE lower(name) = lower(?)").get(name);
+  }
+  // ── Curriculum import ──────────────────────────────────────────────────────
+  importCurriculum(subjectId, phases) {
+    const insertPhase = this.db.raw.prepare(
+      "INSERT INTO phases (subject_id, name, description, sort_order) VALUES (?, ?, ?, ?) RETURNING id"
+    );
+    const insertTopic = this.db.raw.prepare(
+      "INSERT INTO topics (phase_id, name, description, sort_order) VALUES (?, ?, ?, ?)"
+    );
+    const run2 = this.db.raw.transaction(() => {
+      phases.forEach((phase, phaseIdx) => {
+        const phaseRow = insertPhase.get(subjectId, phase.name, phase.description, phaseIdx);
+        phase.topics.forEach((topic, topicIdx) => {
+          insertTopic.run(phaseRow.id, topic.name, topic.description, topicIdx);
+        });
+      });
+    });
+    run2();
+  }
+  getCurriculum(subjectId) {
+    const phases = this.db.raw.prepare(
+      "SELECT * FROM phases WHERE subject_id = ? ORDER BY sort_order"
+    ).all(subjectId);
+    const getTopics = this.db.raw.prepare(
+      "SELECT * FROM topics WHERE phase_id = ? ORDER BY sort_order"
+    );
+    return phases.map((phase) => ({
+      ...phase,
+      topics: getTopics.all(phase.id)
+    }));
+  }
+  // ── Progress ───────────────────────────────────────────────────────────────
+  getProgress(subjectId) {
+    const row = this.db.raw.prepare(
+      `WITH subject_topics AS (
+           SELECT t.id, t.status
+           FROM topics t
+           JOIN phases p ON p.id = t.phase_id
+           WHERE p.subject_id = :sid
+         )
+         SELECT
+           COUNT(*)                                                       AS total_topics,
+           SUM(CASE WHEN status = 'done'        THEN 1 ELSE 0 END)       AS done,
+           SUM(CASE WHEN status = 'in_progress' THEN 1 ELSE 0 END)       AS in_progress,
+           SUM(CASE WHEN status = 'todo'        THEN 1 ELSE 0 END)       AS todo,
+           (SELECT COUNT(*) FROM entries        WHERE topic_id IN (SELECT id FROM subject_topics)) AS total_entries,
+           (SELECT COUNT(*) FROM exercises      WHERE topic_id IN (SELECT id FROM subject_topics)) AS total_exercises,
+           (SELECT COUNT(*) FROM visualizations WHERE topic_id IN (SELECT id FROM subject_topics)) AS total_viz
+         FROM subject_topics`
+    ).get({ sid: subjectId });
+    return {
+      total_topics: row?.total_topics ?? 0,
+      done: row?.done ?? 0,
+      in_progress: row?.in_progress ?? 0,
+      todo: row?.todo ?? 0,
+      total_entries: row?.total_entries ?? 0,
+      total_exercises: row?.total_exercises ?? 0,
+      total_viz: row?.total_viz ?? 0
+    };
+  }
+  // ── Topics ─────────────────────────────────────────────────────────────────
+  setTopicStatus(topicId, status) {
+    this.db.raw.prepare(
+      "UPDATE topics SET status = ?, updated_at = datetime('now') WHERE id = ?"
+    ).run(status, topicId);
+  }
+  getTopic(id) {
+    return this.db.raw.prepare("SELECT * FROM topics WHERE id = ?").get(id);
+  }
+  findTopic(subjectId, name) {
+    return this.db.raw.prepare(
+      `SELECT t.* FROM topics t
+         JOIN phases p ON p.id = t.phase_id
+         WHERE p.subject_id = ? AND lower(t.name) = lower(?)
+         LIMIT 1`
+    ).get(subjectId, name);
+  }
+};
+
+// src/services/qa.ts
+var QAService = class {
+  constructor(db2) {
+    this.db = db2;
+  }
+  logEntry(topicId, kind, content, sessionId, questionId) {
+    const result = this.db.raw.prepare(
+      "INSERT INTO entries (topic_id, kind, content, session_id, question_id) VALUES (?, ?, ?, ?, ?) RETURNING id"
+    ).get(topicId, kind, content, sessionId ?? "", questionId ?? null);
+    return this.db.raw.prepare("SELECT * FROM entries WHERE id = ?").get(result.id);
+  }
+  listEntries(topicId) {
+    return this.db.raw.prepare(
+      "SELECT * FROM entries WHERE topic_id = ? ORDER BY created_at ASC"
+    ).all(topicId);
+  }
+  search(query) {
+    return this.db.raw.prepare(
+      `SELECT e.id, e.topic_id, e.kind, e.content, e.created_at
+         FROM entries e
+         JOIN entries_fts ON entries_fts.rowid = e.id
+         WHERE entries_fts MATCH ?
+         ORDER BY e.created_at ASC
+         LIMIT 50`
+    ).all(query);
+  }
+};
+
+// src/services/viz.ts
+var VizService = class {
+  constructor(db2) {
+    this.db = db2;
+  }
+  create(topicId, title, steps) {
+    const stepsJson = JSON.stringify(steps);
+    const result = this.db.raw.prepare(
+      "INSERT INTO visualizations (topic_id, title, steps_json) VALUES (?, ?, ?) RETURNING id"
+    ).get(topicId, title, stepsJson);
+    return this.db.raw.prepare("SELECT * FROM visualizations WHERE id = ?").get(result.id);
+  }
+  listForTopic(topicId) {
+    return this.db.raw.prepare(
+      "SELECT * FROM visualizations WHERE topic_id = ? ORDER BY created_at DESC, id DESC"
+    ).all(topicId);
+  }
+};
+
+// src/services/exercises.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+function slugify2(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function extensionForLanguage(language) {
+  switch (language) {
+    case "go":
+      return ".go";
+    case "python":
+      return ".py";
+    case "rust":
+      return ".rs";
+    case "javascript":
+    case "typescript":
+      return ".ts";
+    default:
+      return ".txt";
+  }
+}
+var ExerciseService = class {
+  constructor(db2, fileStore2) {
+    this.db = db2;
+    this.fileStore = fileStore2;
+  }
+  createExercise(topicId, data) {
+    const {
+      title,
+      type,
+      description,
+      difficulty = "medium",
+      est_minutes = 0,
+      source = "ai",
+      starter_code = "",
+      test_content = "",
+      quiz_json = "{}"
+    } = data;
+    const result = this.db.raw.prepare(
+      `INSERT INTO exercises
+         (topic_id, title, type, description, difficulty, est_minutes, source, starter_code, test_content, quiz_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         RETURNING id`
+    ).get(topicId, title, type, description, difficulty, est_minutes, source, starter_code, test_content, quiz_json);
+    const exerciseId = result.id;
+    if ((type === "coding" || type === "project") && (starter_code || test_content)) {
+      const subject = this.getSubjectForTopic(topicId);
+      if (subject) {
+        const exerciseSlug = slugify2(title);
+        const ext = extensionForLanguage(subject.language);
+        const files = {};
+        if (starter_code) {
+          files[`main${ext}`] = starter_code;
+        }
+        if (test_content) {
+          files[`main_test${ext}`] = test_content;
+        }
+        files["README.md"] = `# ${title}
+
+${description}`;
+        const filePath = this.fileStore.writeExerciseFiles(subject.slug, exerciseSlug, files);
+        this.db.raw.prepare("UPDATE exercises SET file_path = ? WHERE id = ?").run(filePath, exerciseId);
+      }
+    }
+    return this.db.raw.prepare("SELECT * FROM exercises WHERE id = ?").get(exerciseId);
+  }
+  async runTests(exerciseId) {
+    const exercise = this.db.raw.prepare("SELECT * FROM exercises WHERE id = ?").get(exerciseId);
+    if (!exercise) throw new Error(`Exercise ${exerciseId} not found`);
+    if (!exercise.file_path) throw new Error(`Exercise ${exerciseId} has no file_path`);
+    const subject = this.getSubjectForTopic(exercise.topic_id);
+    if (!subject) throw new Error(`No subject found for exercise ${exerciseId}`);
+    const commandMap = {
+      go: { command: "go", args: ["test", "-json", "-count=1", "./..."] },
+      python: { command: "python3", args: ["-m", "pytest", "--tb=short", "-q", "."] },
+      rust: { command: "cargo", args: ["test"] },
+      javascript: { command: "npx", args: ["vitest", "run"] },
+      typescript: { command: "npx", args: ["vitest", "run"] }
+    };
+    const config = commandMap[subject.language];
+    if (!config) throw new Error(`Unsupported language: ${subject.language}`);
+    let stdout = "";
+    let stderr = "";
+    let exitCode = 0;
+    try {
+      const result = await execFileAsync(config.command, config.args, {
+        cwd: exercise.file_path,
+        timeout: 6e4
+      });
+      stdout = result.stdout;
+      stderr = result.stderr;
+    } catch (err5) {
+      const execErr = err5;
+      stdout = execErr.stdout ?? "";
+      stderr = execErr.stderr ?? "";
+      exitCode = execErr.code ?? 1;
+    }
+    const results = [];
+    if (subject.language === "go") {
+      for (const line of stdout.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+          if (event.Action === "pass" && event.Test) {
+            results.push({ test_name: event.Test, passed: true, output: "" });
+          } else if (event.Action === "fail" && event.Test) {
+            results.push({ test_name: event.Test, passed: false, output: event.Output ?? "" });
+          }
+        } catch {
+        }
+      }
+    }
+    if (results.length === 0) {
+      results.push({
+        test_name: "all",
+        passed: exitCode === 0,
+        output: stdout + stderr
+      });
+    }
+    this.db.raw.prepare("DELETE FROM exercise_results WHERE exercise_id = ?").run(exerciseId);
+    const insertResult = this.db.raw.prepare(
+      "INSERT INTO exercise_results (exercise_id, test_name, passed, output) VALUES (?, ?, ?, ?)"
+    );
+    for (const r of results) {
+      insertResult.run(exerciseId, r.test_name, r.passed ? 1 : 0, r.output);
+    }
+    const allPassed = results.every((r) => r.passed);
+    this.db.raw.prepare("UPDATE exercises SET status = ? WHERE id = ?").run(allPassed ? "passed" : "failed", exerciseId);
+    return this.db.raw.prepare("SELECT * FROM exercise_results WHERE exercise_id = ?").all(exerciseId);
+  }
+  submitQuiz(exerciseId, answers) {
+    const exercise = this.db.raw.prepare("SELECT * FROM exercises WHERE id = ?").get(exerciseId);
+    if (!exercise) throw new Error(`Exercise ${exerciseId} not found`);
+    const payload = JSON.parse(exercise.quiz_json);
+    const questions = payload.questions;
+    let correct = 0;
+    const results = [];
+    for (let i = 0; i < questions.length; i++) {
+      const q = questions[i];
+      const answer = answers[i];
+      let isCorrect = false;
+      switch (q.type) {
+        case "multiple_choice":
+          isCorrect = answer === q.correct;
+          break;
+        case "true_false":
+          isCorrect = answer === q.correct;
+          break;
+        case "fill_in":
+          isCorrect = String(answer).toLowerCase().trim() === String(q.correct).toLowerCase().trim();
+          break;
+      }
+      if (isCorrect) correct++;
+      results.push({
+        test_name: `Q${i + 1}: ${q.text}`,
+        passed: isCorrect,
+        output: isCorrect ? "Correct" : `Wrong. Expected: ${q.correct}, Got: ${answer}`
+      });
+    }
+    const score = questions.length > 0 ? correct / questions.length : 0;
+    const passed = score >= 0.7;
+    this.db.raw.prepare("DELETE FROM exercise_results WHERE exercise_id = ?").run(exerciseId);
+    const insertResult = this.db.raw.prepare(
+      "INSERT INTO exercise_results (exercise_id, test_name, passed, output) VALUES (?, ?, ?, ?)"
+    );
+    for (const r of results) {
+      insertResult.run(exerciseId, r.test_name, r.passed ? 1 : 0, r.output);
+    }
+    this.db.raw.prepare("UPDATE exercises SET status = ? WHERE id = ?").run(passed ? "passed" : "failed", exerciseId);
+    return { score, total: questions.length, passed, results };
+  }
+  listForTopic(topicId) {
+    return this.db.raw.prepare(
+      "SELECT * FROM exercises WHERE topic_id = ? ORDER BY created_at ASC, id ASC"
+    ).all(topicId);
+  }
+  getSubjectForTopic(topicId) {
+    return this.db.raw.prepare(
+      `SELECT s.* FROM subjects s
+         JOIN phases p ON p.subject_id = s.id
+         JOIN topics t ON t.phase_id = p.id
+         WHERE t.id = ?`
+    ).get(topicId);
+  }
+};
+
+// src/tools/curriculum.ts
+import { z } from "zod";
+function getSession(sessions2, sessionId) {
+  const key = sessionId || "_default";
+  if (!sessions2.has(key)) {
+    sessions2.set(key, { subjectId: null, topicId: null });
+  }
+  return sessions2.get(key);
+}
+function err(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+function ok(text) {
+  return { content: [{ type: "text", text }] };
+}
+function registerCurriculumTools(server2, svc, sessions2, notify2) {
+  server2.tool(
+    "learn_create_subject",
+    "Create a new subject to study",
+    {
+      name: z.string().describe("Subject name"),
+      language: z.string().optional().describe("Programming language (optional)"),
+      source: z.enum(["manual", "roadmap", "pdf"]).optional().describe("Curriculum source")
+    },
+    async ({ name, language, source }) => {
+      const subject = svc.createSubject(name, language, source);
+      notify2();
+      return ok(`Created subject "${subject.name}" (id=${subject.id}, slug=${subject.slug})`);
+    }
+  );
+  server2.tool(
+    "learn_import_curriculum",
+    "Import a curriculum (phases + topics) for a subject from JSON",
+    {
+      subject_id: z.number().describe("Subject ID to import curriculum into"),
+      phases_json: z.string().describe("JSON array of phases, each with name, description, and topics array")
+    },
+    async ({ subject_id, phases_json }) => {
+      let phases;
+      try {
+        phases = JSON.parse(phases_json);
+      } catch {
+        return err("Invalid JSON in phases_json");
+      }
+      if (!Array.isArray(phases)) {
+        return err("phases_json must be a JSON array");
+      }
+      svc.importCurriculum(subject_id, phases);
+      notify2();
+      return ok(`Imported ${phases.length} phase(s) into subject id=${subject_id}`);
+    }
+  );
+  server2.tool(
+    "learn_switch_subject",
+    "Switch the active subject for the session (by name or numeric ID)",
+    {
+      subject: z.string().describe("Subject name or numeric ID"),
+      session_id: z.string().optional().describe("Session identifier (defaults to _default)")
+    },
+    async ({ subject, session_id }) => {
+      const numId = Number(subject);
+      let resolved = isNaN(numId) ? svc.findSubjectByName(subject) : svc.getSubject(numId) ?? svc.findSubjectByName(subject);
+      if (!resolved) {
+        return err(`Subject not found: "${subject}"`);
+      }
+      const session = getSession(sessions2, session_id);
+      session.subjectId = resolved.id;
+      session.topicId = null;
+      return ok(`Active subject: "${resolved.name}" (id=${resolved.id})`);
+    }
+  );
+  server2.tool(
+    "learn_set_topic",
+    "Set the active topic for the session and mark it in_progress",
+    {
+      topic: z.string().describe("Topic name or numeric ID"),
+      session_id: z.string().optional().describe("Session identifier (defaults to _default)")
+    },
+    async ({ topic, session_id }) => {
+      const session = getSession(sessions2, session_id);
+      if (session.subjectId === null) {
+        return err("No active subject. Use learn_switch_subject first.");
+      }
+      const numId = Number(topic);
+      let resolved = isNaN(numId) ? svc.findTopic(session.subjectId, topic) : svc.getTopic(numId) ?? svc.findTopic(session.subjectId, topic);
+      if (!resolved) {
+        return err(`Topic not found: "${topic}"`);
+      }
+      svc.setTopicStatus(resolved.id, "in_progress");
+      session.topicId = resolved.id;
+      notify2();
+      return ok(`Active topic: "${resolved.name}" (id=${resolved.id}, status=in_progress)`);
+    }
+  );
+  server2.tool(
+    "learn_mark_done",
+    "Mark a topic as done (defaults to the active session topic)",
+    {
+      topic: z.string().optional().describe("Topic name or numeric ID (uses session topic if omitted)"),
+      session_id: z.string().optional().describe("Session identifier (defaults to _default)")
+    },
+    async ({ topic, session_id }) => {
+      const session = getSession(sessions2, session_id);
+      let topicId = null;
+      if (topic !== void 0) {
+        const numId = Number(topic);
+        const resolved2 = isNaN(numId) ? session.subjectId !== null ? svc.findTopic(session.subjectId, topic) : void 0 : svc.getTopic(numId);
+        if (!resolved2) {
+          return err(`Topic not found: "${topic}"`);
+        }
+        topicId = resolved2.id;
+      } else {
+        topicId = session.topicId;
+      }
+      if (topicId === null) {
+        return err("No topic specified and no active topic in session.");
+      }
+      const resolved = svc.getTopic(topicId);
+      if (!resolved) {
+        return err(`Topic id=${topicId} not found.`);
+      }
+      svc.setTopicStatus(topicId, "done");
+      notify2();
+      return ok(`Topic "${resolved.name}" marked as done.`);
+    }
+  );
+  server2.tool(
+    "learn_get_progress",
+    "Get progress statistics for the active subject",
+    {
+      session_id: z.string().optional().describe("Session identifier (defaults to _default)")
+    },
+    async ({ session_id }) => {
+      const session = getSession(sessions2, session_id);
+      if (session.subjectId === null) {
+        return err("No active subject. Use learn_switch_subject first.");
+      }
+      const progress = svc.getProgress(session.subjectId);
+      return ok(JSON.stringify(progress, null, 2));
+    }
+  );
+  server2.tool(
+    "learn_get_curriculum",
+    "Get the full curriculum (phases + topics) for the active subject",
+    {
+      session_id: z.string().optional().describe("Session identifier (defaults to _default)")
+    },
+    async ({ session_id }) => {
+      const session = getSession(sessions2, session_id);
+      if (session.subjectId === null) {
+        return err("No active subject. Use learn_switch_subject first.");
+      }
+      const curriculum = svc.getCurriculum(session.subjectId);
+      return ok(JSON.stringify(curriculum, null, 2));
+    }
+  );
+}
+
+// src/tools/qa.ts
+import { z as z2 } from "zod";
+function getSession2(sessions2, sessionId) {
+  const key = sessionId || "_default";
+  if (!sessions2.has(key)) {
+    sessions2.set(key, { subjectId: null, topicId: null });
+  }
+  return sessions2.get(key);
+}
+function err2(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+function ok2(text) {
+  return { content: [{ type: "text", text }] };
+}
+function registerQATools(server2, svc, sessions2, notify2) {
+  server2.tool(
+    "learn_log_question",
+    "Log a question for the active topic",
+    {
+      content: z2.string().describe("The question text"),
+      session_id: z2.string().optional().describe("Session identifier (defaults to _default)")
+    },
+    async ({ content, session_id }) => {
+      const session = getSession2(sessions2, session_id);
+      if (session.topicId === null) {
+        return err2("No active topic. Use learn_set_topic first.");
+      }
+      const entry = svc.logEntry(session.topicId, "question", content, session_id);
+      notify2();
+      return ok2(`Logged question (id=${entry.id})`);
+    }
+  );
+  server2.tool(
+    "learn_log_answer",
+    "Log an answer or note for the active topic",
+    {
+      content: z2.string().describe("The answer or note text"),
+      question_id: z2.number().optional().describe("ID of the question this answers (optional)"),
+      kind: z2.enum(["answer", "note"]).optional().describe("Entry kind: answer or note (defaults to answer)"),
+      session_id: z2.string().optional().describe("Session identifier (defaults to _default)")
+    },
+    async ({ content, question_id, kind, session_id }) => {
+      const session = getSession2(sessions2, session_id);
+      if (session.topicId === null) {
+        return err2("No active topic. Use learn_set_topic first.");
+      }
+      const entryKind = kind ?? "answer";
+      const entry = svc.logEntry(session.topicId, entryKind, content, session_id, question_id);
+      notify2();
+      return ok2(`Logged ${entryKind} (id=${entry.id})`);
+    }
+  );
+  server2.tool(
+    "learn_search",
+    "Full-text search across all entries",
+    {
+      query: z2.string().describe("Search query")
+    },
+    async ({ query }) => {
+      const results = svc.search(query);
+      if (results.length === 0) {
+        return ok2("No results found.");
+      }
+      return ok2(JSON.stringify(results, null, 2));
+    }
+  );
+}
+
+// src/tools/viz.ts
+import { z as z3 } from "zod";
+function getSession3(sessions2, sessionId) {
+  const key = sessionId || "_default";
+  if (!sessions2.has(key)) {
+    sessions2.set(key, { subjectId: null, topicId: null });
+  }
+  return sessions2.get(key);
+}
+function err3(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+function ok3(text) {
+  return { content: [{ type: "text", text }] };
+}
+function registerVizTools(server2, svc, sessions2, notify2) {
+  server2.tool(
+    "learn_create_viz",
+    "Create a step-by-step HTML visualization for the active topic",
+    {
+      title: z3.string().describe("Title for the visualization"),
+      steps: z3.string().describe("JSON array of steps, each with { html: string, description: string }"),
+      session_id: z3.string().optional().describe("Session identifier (defaults to _default)")
+    },
+    async ({ title, steps, session_id }) => {
+      const session = getSession3(sessions2, session_id);
+      if (session.topicId === null) {
+        return err3("No active topic. Use learn_set_topic first.");
+      }
+      let parsedSteps;
+      try {
+        parsedSteps = JSON.parse(steps);
+      } catch {
+        return err3("Invalid JSON in steps parameter");
+      }
+      if (!Array.isArray(parsedSteps)) {
+        return err3("steps must be a JSON array");
+      }
+      const viz = svc.create(session.topicId, title, parsedSteps);
+      notify2();
+      return ok3(`Created visualization "${viz.title}" (id=${viz.id})`);
+    }
+  );
+  server2.tool(
+    "learn_get_viz",
+    "Get all visualizations for the active topic",
+    {
+      session_id: z3.string().optional().describe("Session identifier (defaults to _default)")
+    },
+    async ({ session_id }) => {
+      const session = getSession3(sessions2, session_id);
+      if (session.topicId === null) {
+        return err3("No active topic. Use learn_set_topic first.");
+      }
+      const vizList = svc.listForTopic(session.topicId);
+      return ok3(JSON.stringify(vizList, null, 2));
+    }
+  );
+}
+
+// src/tools/exercises.ts
+import { z as z4 } from "zod";
+function getSession4(sessions2, sessionId) {
+  const key = sessionId || "_default";
+  if (!sessions2.has(key)) {
+    sessions2.set(key, { subjectId: null, topicId: null });
+  }
+  return sessions2.get(key);
+}
+function err4(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+function ok4(text) {
+  return { content: [{ type: "text", text }] };
+}
+function registerExerciseTools(server2, svc, sessions2, notify2) {
+  server2.tool(
+    "learn_create_exercise",
+    "Create an exercise (coding, quiz, project, assignment) for the active topic",
+    {
+      title: z4.string().describe("Exercise title"),
+      type: z4.enum(["coding", "quiz", "project", "assignment"]).describe("Exercise type"),
+      description: z4.string().describe("Exercise description / instructions"),
+      difficulty: z4.enum(["easy", "medium", "hard"]).optional().describe("Difficulty level"),
+      est_minutes: z4.number().optional().describe("Estimated time in minutes"),
+      source: z4.enum(["ai", "pdf_import"]).optional().describe("Source of the exercise"),
+      starter_code: z4.string().optional().describe("Starter code for coding/project exercises"),
+      test_content: z4.string().optional().describe("Test code for coding/project exercises"),
+      quiz_json: z4.string().optional().describe("JSON string of QuizPayload for quiz exercises"),
+      session_id: z4.string().optional().describe("Session identifier (defaults to _default)")
+    },
+    async ({ title, type, description, difficulty, est_minutes, source, starter_code, test_content, quiz_json, session_id }) => {
+      const session = getSession4(sessions2, session_id);
+      if (session.topicId === null) {
+        return err4("No active topic. Use learn_set_topic first.");
+      }
+      const exercise = svc.createExercise(session.topicId, {
+        title,
+        type,
+        description,
+        difficulty,
+        est_minutes,
+        source,
+        starter_code,
+        test_content,
+        quiz_json
+      });
+      notify2();
+      return ok4(`Created exercise "${exercise.title}" (id=${exercise.id}, type=${exercise.type})`);
+    }
+  );
+  server2.tool(
+    "learn_run_tests",
+    "Run tests for a coding/project exercise and return results",
+    {
+      exercise_id: z4.number().describe("ID of the exercise to run tests for")
+    },
+    async ({ exercise_id }) => {
+      try {
+        const results = await svc.runTests(exercise_id);
+        notify2();
+        return ok4(JSON.stringify(results, null, 2));
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return err4(`Failed to run tests: ${msg}`);
+      }
+    }
+  );
+  server2.tool(
+    "learn_get_exercises",
+    "List all exercises for the active topic",
+    {
+      session_id: z4.string().optional().describe("Session identifier (defaults to _default)")
+    },
+    async ({ session_id }) => {
+      const session = getSession4(sessions2, session_id);
+      if (session.topicId === null) {
+        return err4("No active topic. Use learn_set_topic first.");
+      }
+      const exercises = svc.listForTopic(session.topicId);
+      return ok4(JSON.stringify(exercises, null, 2));
+    }
+  );
+}
+
+// src/dashboard/server.ts
+import http from "node:http";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join as join2 } from "node:path";
+
+// src/dashboard/api.ts
+function writeJSON(res, data, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function writeError(res, status, message) {
+  writeJSON(res, { error: message }, status);
+}
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString()));
+      } catch (err5) {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function extractId(url, prefix) {
+  if (!url.startsWith(prefix)) return null;
+  const rest = url.slice(prefix.length);
+  const segment = rest.split("/")[0];
+  const num = Number(segment);
+  return Number.isFinite(num) && num > 0 ? num : null;
+}
+function handleSubjects(curriculumSvc2) {
+  return (_req, res) => {
+    const subjects = curriculumSvc2.listSubjects();
+    const result = subjects.map((s) => ({
+      ...s,
+      progress: curriculumSvc2.getProgress(s.id)
+    }));
+    writeJSON(res, result);
+  };
+}
+function handlePhases(curriculumSvc2) {
+  return (req, res) => {
+    const id = extractId(req.url ?? "", "/api/subjects/");
+    if (id === null) {
+      writeError(res, 400, "Invalid subject ID");
+      return;
+    }
+    const phases = curriculumSvc2.getCurriculum(id);
+    writeJSON(res, phases);
+  };
+}
+function handleTopic(curriculumSvc2, qaSvc2) {
+  return (req, res) => {
+    const id = extractId(req.url ?? "", "/api/topics/");
+    if (id === null) {
+      writeError(res, 400, "Invalid topic ID");
+      return;
+    }
+    const topic = curriculumSvc2.getTopic(id);
+    if (!topic) {
+      writeError(res, 404, "Topic not found");
+      return;
+    }
+    const entries = qaSvc2.listEntries(id);
+    writeJSON(res, { ...topic, entries });
+  };
+}
+function handleTopicViz(vizSvc2) {
+  return (req, res) => {
+    const id = extractId(req.url ?? "", "/api/topics/");
+    if (id === null) {
+      writeError(res, 400, "Invalid topic ID");
+      return;
+    }
+    const vizList = vizSvc2.listForTopic(id);
+    writeJSON(res, vizList);
+  };
+}
+function handleTopicExercises(exerciseSvc2) {
+  return (req, res) => {
+    const id = extractId(req.url ?? "", "/api/topics/");
+    if (id === null) {
+      writeError(res, 400, "Invalid topic ID");
+      return;
+    }
+    const exercises = exerciseSvc2.listForTopic(id);
+    writeJSON(res, exercises);
+  };
+}
+function handleRunTests(exerciseSvc2) {
+  return async (req, res) => {
+    const id = extractId(req.url ?? "", "/api/exercises/");
+    if (id === null) {
+      writeError(res, 400, "Invalid exercise ID");
+      return;
+    }
+    try {
+      const results = await exerciseSvc2.runTests(id);
+      writeJSON(res, results);
+    } catch (err5) {
+      const msg = err5 instanceof Error ? err5.message : String(err5);
+      writeError(res, 500, msg);
+    }
+  };
+}
+function handleSubmitQuiz(exerciseSvc2) {
+  return async (req, res) => {
+    const id = extractId(req.url ?? "", "/api/exercises/");
+    if (id === null) {
+      writeError(res, 400, "Invalid exercise ID");
+      return;
+    }
+    try {
+      const body = await parseBody(req);
+      if (!Array.isArray(body?.answers)) {
+        writeError(res, 400, 'Request body must have an "answers" array');
+        return;
+      }
+      const result = exerciseSvc2.submitQuiz(id, body.answers);
+      writeJSON(res, result);
+    } catch (err5) {
+      const msg = err5 instanceof Error ? err5.message : String(err5);
+      writeError(res, 500, msg);
+    }
+  };
+}
+function handleSearch(qaSvc2) {
+  return (req, res) => {
+    const url = new URL(req.url ?? "", "http://localhost");
+    const query = url.searchParams.get("q") ?? "";
+    if (!query) {
+      writeJSON(res, []);
+      return;
+    }
+    try {
+      const results = qaSvc2.search(query);
+      writeJSON(res, results);
+    } catch (err5) {
+      const msg = err5 instanceof Error ? err5.message : String(err5);
+      writeError(res, 500, msg);
+    }
+  };
+}
+
+// src/dashboard/server.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var staticDir = join2(__dirname, "static");
+function loadStatic(name) {
+  try {
+    return readFileSync2(join2(staticDir, name), "utf-8");
+  } catch {
+    return "";
+  }
+}
+var indexHtml = loadStatic("index.html");
+var appJs = loadStatic("app.js");
+var stylesCss = loadStatic("styles.css");
+var STATIC_FILES = {
+  "/": { content: indexHtml, contentType: "text/html; charset=utf-8" },
+  "/index.html": { content: indexHtml, contentType: "text/html; charset=utf-8" },
+  "/app.js": { content: appJs, contentType: "application/javascript; charset=utf-8" },
+  "/styles.css": { content: stylesCss, contentType: "text/css; charset=utf-8" }
+};
+var DashboardServer = class {
+  constructor(curriculumSvc2, qaSvc2, vizSvc2, exerciseSvc2, port2) {
+    this.curriculumSvc = curriculumSvc2;
+    this.qaSvc = qaSvc2;
+    this.vizSvc = vizSvc2;
+    this.exerciseSvc = exerciseSvc2;
+    this.port = port2;
+  }
+  sseClients = /* @__PURE__ */ new Set();
+  httpServer = null;
+  start() {
+    this.httpServer = http.createServer((req, res) => this.handleRequest(req, res));
+    this.httpServer.listen(this.port, "127.0.0.1", () => {
+      console.error(`Dashboard running at http://127.0.0.1:${this.port}`);
+    });
+  }
+  stop() {
+    if (this.httpServer) {
+      this.httpServer.close();
+      this.httpServer = null;
+    }
+  }
+  notify() {
+    const data = JSON.stringify({ type: "update", ts: (/* @__PURE__ */ new Date()).toISOString() });
+    const message = `data: ${data}
+
+`;
+    for (const client of this.sseClients) {
+      client.write(message);
+    }
+  }
+  // ── Request routing ────────────────────────────────────────────────────
+  handleRequest(req, res) {
+    const url = req.url ?? "/";
+    const method = req.method ?? "GET";
+    if (method === "POST") {
+      const origin = req.headers.origin ?? "";
+      if (origin && !origin.startsWith("http://localhost") && !origin.startsWith("http://127.0.0.1")) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Forbidden: invalid origin" }));
+        return;
+      }
+    }
+    if (url === "/api/events" && method === "GET") {
+      this.handleSSE(req, res);
+      return;
+    }
+    if (url.startsWith("/api/")) {
+      this.routeAPI(method, url, req, res);
+      return;
+    }
+    this.serveStatic(url, res);
+  }
+  // ── SSE ────────────────────────────────────────────────────────────────
+  handleSSE(_req, res) {
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      "Access-Control-Allow-Origin": "*"
+    });
+    const connected = JSON.stringify({ type: "connected", ts: (/* @__PURE__ */ new Date()).toISOString() });
+    res.write(`data: ${connected}
+
+`);
+    this.sseClients.add(res);
+    res.on("close", () => {
+      this.sseClients.delete(res);
+    });
+  }
+  // ── API router ─────────────────────────────────────────────────────────
+  routeAPI(method, url, req, res) {
+    const path = url.split("?")[0];
+    if (method === "GET" && path === "/api/subjects") {
+      handleSubjects(this.curriculumSvc)(req, res);
+      return;
+    }
+    if (method === "GET" && /^\/api\/subjects\/\d+\/phases$/.test(path)) {
+      handlePhases(this.curriculumSvc)(req, res);
+      return;
+    }
+    if (method === "GET" && /^\/api\/topics\/\d+\/viz$/.test(path)) {
+      handleTopicViz(this.vizSvc)(req, res);
+      return;
+    }
+    if (method === "GET" && /^\/api\/topics\/\d+\/exercises$/.test(path)) {
+      handleTopicExercises(this.exerciseSvc)(req, res);
+      return;
+    }
+    if (method === "GET" && /^\/api\/topics\/\d+$/.test(path)) {
+      handleTopic(this.curriculumSvc, this.qaSvc)(req, res);
+      return;
+    }
+    if (method === "POST" && /^\/api\/exercises\/\d+\/run$/.test(path)) {
+      handleRunTests(this.exerciseSvc)(req, res);
+      return;
+    }
+    if (method === "POST" && /^\/api\/exercises\/\d+\/submit$/.test(path)) {
+      handleSubmitQuiz(this.exerciseSvc)(req, res);
+      return;
+    }
+    if (method === "GET" && path === "/api/search") {
+      handleSearch(this.qaSvc)(req, res);
+      return;
+    }
+    writeJSON(res, { error: "Not found" }, 404);
+  }
+  // ── Static file serving ────────────────────────────────────────────────
+  serveStatic(url, res) {
+    const file = STATIC_FILES[url];
+    if (file) {
+      res.writeHead(200, { "Content-Type": file.contentType });
+      res.end(file.content);
+      return;
+    }
+    const index = STATIC_FILES["/"];
+    if (index) {
+      res.writeHead(200, { "Content-Type": index.contentType });
+      res.end(index.content);
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not found");
+  }
+};
+
+// src/index.ts
+var fileStore = new FileStore();
+var db = new Database(fileStore.dbPath);
+var sessions = /* @__PURE__ */ new Map();
+var curriculumSvc = new CurriculumService(db);
+var qaSvc = new QAService(db);
+var vizSvc = new VizService(db);
+var exerciseSvc = new ExerciseService(db, fileStore);
+var port = Number(db.getSetting("dashboard_port") ?? "19282");
+var dashboard = new DashboardServer(curriculumSvc, qaSvc, vizSvc, exerciseSvc, port);
+var notify = () => dashboard.notify();
+var server = new McpServer({ name: "study-dash", version: "0.1.0" });
+registerCurriculumTools(server, curriculumSvc, sessions, notify);
+registerQATools(server, qaSvc, sessions, notify);
+registerVizTools(server, vizSvc, sessions, notify);
+registerExerciseTools(server, exerciseSvc, sessions, notify);
+dashboard.start();
+async function run() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`study-dash MCP server running, dashboard at http://127.0.0.1:${port}`);
+}
+run().catch((err5) => {
+  console.error("Fatal:", err5);
+  process.exit(1);
+});