@jiy/quizme 0.1.0

package/dist/providers/claudeAgent.js

@@ -0,0 +1,295 @@
+import { spawn, spawnSync } from "node:child_process";
+import crypto from "node:crypto";
+import { QUESTION_SCHEMA } from "../generation/schema.js";
+import { validateQuestions } from "../generation/validator.js";
+function isObject(value) {
+    return value !== null && typeof value === "object";
+}
+function isAssistantEvent(event) {
+    return isObject(event) && event.type === "assistant";
+}
+function isResultEvent(event) {
+    return isObject(event) && event.type === "result";
+}
+function getAssistantBlocks(event) {
+    const content = event.message?.content;
+    return Array.isArray(content) ? content : [];
+}
+function extractQuestionsPayload(value) {
+    if (!isObject(value)) {
+        return null;
+    }
+    if (!("questions" in value)) {
+        return null;
+    }
+    return Array.isArray(value.questions) ? value : null;
+}
+function summarizeSignals(signals) {
+    if (!signals.length)
+        return "None yet.";
+    const strongest = [...signals].sort((a, b) => b.score - a.score).slice(0, 5);
+    const weakest = [...signals]
+        .filter((s) => s.wrongCount > 0)
+        .sort((a, b) => a.score - b.score || b.wrongCount - a.wrongCount)
+        .slice(0, 5);
+    const format = (s) => `${s.tag}(score=${s.score.toFixed(2)}, conf=${s.confidence.toFixed(2)}, +${s.correctCount}/-${s.wrongCount})`;
+    return [
+        `Strong: ${strongest.map(format).join(", ") || "none"}`,
+        `Weak: ${weakest.map(format).join(", ") || "none"}`
+    ].join("\n");
+}
+function summarizePreferences(prefs) {
+    if (!prefs.length)
+        return "None.";
+    const boost = prefs.filter((p) => p.kind === "boost").map((p) => p.tag);
+    const suppress = prefs.filter((p) => p.kind === "suppress").map((p) => p.tag);
+    const known = prefs.filter((p) => p.kind === "known").map((p) => p.tag);
+    const lines = [];
+    if (boost.length)
+        lines.push(`Boost (user wants more): ${boost.join(", ")}`);
+    if (suppress.length)
+        lines.push(`Suppress (user wants less): ${suppress.join(", ")}`);
+    if (known.length)
+        lines.push(`Already known (deprioritize as strong-area): ${known.join(", ")}`);
+    return lines.join("\n") || "None.";
+}
+function buildQuizPrompt({ source, config, recentQuestions, mode, signals, preferences }) {
+    return [
+        "You are QuizMe, a CLI technical interview quiz generator for developers.",
+        "Return strict JSON only, matching the provided schema.",
+        "Generate 3 to 5 multiple-choice questions with exactly 4 choices (ids A, B, C, D) and exactly one best answer.",
+        "Every question MUST include a `sourceMode` field, one of: contextual (about the session/repo), adjacent (related tools/frameworks/concepts), interview_style (evergreen interview knowledge).",
+        "Target mix across the batch: ~40% contextual, ~40% adjacent, ~20% interview_style.",
+        "Every question MUST include a `whyWrong` object with a short reason for each non-answer choice id.",
+        "Focus on engineering judgment, debugging, tradeoffs, and code review reasoning — not trivia.",
+        "Weight the batch toward the user's weak areas from profile signals below; keep a small share of strong-area questions for positive reinforcement.",
+        "Respect user preferences: boost tags should appear more often; suppress and 'known' tags should appear less often (do not fully drop them, just deprioritize).",
+        `User level: ${config.level}`,
+        `Language for questions and explanations: ${config.language}`,
+        `Mode: ${mode}`,
+        "Profile signals:",
+        summarizeSignals(signals),
+        "Profile preferences:",
+        summarizePreferences(preferences),
+        "Recent questions to avoid repeating (topic:question pairs):",
+        JSON.stringify(recentQuestions.slice(0, 20).map((q) => ({ topic: q.topic, question: q.question }))),
+        "Source context summary:",
+        source.summary
+    ].join("\n\n");
+}
+function buildWhyPrompt({ question, config, asked, userAnswer }) {
+    return [
+        "You are QuizMe in why mode — an expert technical tutor.",
+        `Language: ${config.language}`,
+        `User level: ${config.level}`,
+        `Question: ${question.question}`,
+        `Choices: ${JSON.stringify(question.choices)}`,
+        `Correct answer: ${question.answer}`,
+        `User selected: ${userAnswer}`,
+        `Initial explanation: ${question.explanation}`,
+        `User follow-up question: ${asked}`,
+        "Provide a concise, concrete explanation. Explain why the correct answer is right, why each wrong option is weaker, and connect the concept to practical engineering work. Stay focused on this question — do not become a general tutor."
+    ].join("\n\n");
+}
+/**
+ * Print-mode hardening for scripted calls.
+ * - `--bare`: skip hooks, MCP, CLAUDE.md auto-discovery, etc.
+ * - `--tools ""`: disable built-in agent tools (Read/Bash/Edit/...).
+ * Context is already embedded in the prompt; `--json-schema` structured output
+ * is separate from the built-in tool set.
+ */
+const CLAUDE_PRINT_SECURITY_ARGS = ["--bare", "--tools", ""];
+/**
+ * Whether `claude` has already been verified on PATH this process. The check
+ * is cheap but synchronous, so we avoid repeating it on every generation call.
+ */
+let claudeAvailableVerified = false;
+/**
+ * Pre-flight check: ensure the `claude` CLI is installed and on PATH before
+ * we spawn a long-running print-mode call. Throws a clear, actionable error
+ * instead of letting `spawn` fail later with a generic ENOENT.
+ */
+function ensureClaudeAvailable() {
+    if (claudeAvailableVerified)
+        return;
+    const result = spawnSync("claude", ["--version"], {
+        stdio: "ignore",
+        shell: process.platform === "win32"
+    });
+    if (result.error || result.status !== 0) {
+        throw new Error([
+            "Claude Code CLI (`claude`) was not found on your PATH.",
+            "QuizMe needs it for quiz generation and the `why` mode.",
+            "",
+            "Install it with:  npm install -g @anthropic-ai/claude-code",
+            "Docs:             https://docs.anthropic.com/claude-code",
+            "",
+            "Or run QuizMe offline with QUIZME_PROVIDER=local."
+        ].join("\n"));
+    }
+    claudeAvailableVerified = true;
+}
+async function runClaude(args, { onEvent, timeout = 120000 } = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("claude", [...CLAUDE_PRINT_SECURITY_ARGS, ...args], {
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        const chunks = [];
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            reject(new Error("Claude timed out after " + timeout / 1000 + "s"));
+        }, timeout);
+        let buffer = "";
+        child.stdout.on("data", (chunk) => {
+            buffer += chunk.toString();
+            chunks.push(chunk.toString());
+            // Parse complete newline-delimited JSON events
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? ""; // keep incomplete line in buffer
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                if (onEvent) {
+                    try {
+                        const event = JSON.parse(trimmed);
+                        onEvent(event);
+                    }
+                    catch {
+                        // not a JSON event line, ignore
+                    }
+                }
+            }
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (timedOut) {
+                return;
+            }
+            if (code !== 0) {
+                const msg = stderr.trim() || `claude exited with code ${code}`;
+                reject(new Error(msg));
+                return;
+            }
+            resolve(chunks.join(""));
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(new Error(`Failed to spawn claude: ${err.message}. Is Claude Code installed and in PATH?`));
+        });
+    });
+}
+function parseQuestionsFromEvents(events) {
+    for (const event of events) {
+        if (isAssistantEvent(event)) {
+            for (const block of getAssistantBlocks(event)) {
+                // StructuredOutput tool_use contains the JSON schema result
+                if (isObject(block) && block.type === "tool_use" && block.name === "StructuredOutput" && block.input) {
+                    const payload = extractQuestionsPayload(block.input);
+                    if (payload) {
+                        return payload;
+                    }
+                }
+                // Fallback: text block containing JSON
+                if (isObject(block) && block.type === "text" && typeof block.text === "string") {
+                    try {
+                        const parsed = JSON.parse(block.text);
+                        const payload = extractQuestionsPayload(parsed);
+                        if (payload)
+                            return payload;
+                    }
+                    catch {
+                        // not JSON
+                    }
+                }
+            }
+        }
+        // result event may have JSON in result field
+        if (isResultEvent(event) && event.result) {
+            try {
+                const parsed = JSON.parse(event.result);
+                const payload = extractQuestionsPayload(parsed);
+                if (payload)
+                    return payload;
+            }
+            catch {
+                // not JSON
+            }
+        }
+    }
+    return null;
+}
+function extractTextFromEvents(events) {
+    const parts = [];
+    for (const event of events) {
+        if (isAssistantEvent(event)) {
+            for (const block of getAssistantBlocks(event)) {
+                if (isObject(block) && block.type === "text" && typeof block.text === "string") {
+                    parts.push(block.text);
+                }
+            }
+        }
+        if (isResultEvent(event) && event.result) {
+            return event.result;
+        }
+    }
+    return parts.join("");
+}
+export async function generateQuestions({ source, config, recentQuestions, mode = "mixed", signals = [], preferences = [], onProgress }) {
+    ensureClaudeAvailable();
+    const prompt = buildQuizPrompt({ source, config, recentQuestions, mode, signals, preferences });
+    const events = [];
+    await runClaude([
+        "-p",
+        "--output-format", "stream-json",
+        "--verbose",
+        "--json-schema", JSON.stringify(QUESTION_SCHEMA),
+        prompt
+    ], {
+        timeout: 300000,
+        onEvent: (event) => {
+            events.push(event);
+            if (onProgress && isAssistantEvent(event)) {
+                onProgress(".");
+            }
+        }
+    });
+    const parsed = parseQuestionsFromEvents(events);
+    if (!parsed) {
+        throw new Error("Claude returned no questions. Try again or use a different source.");
+    }
+    const questions = validateQuestions(parsed);
+    return questions.map((q, index) => ({
+        ...q,
+        id: q.id || `q_${crypto.createHash("sha1").update(`${source.title}:${q.question}:${index}`).digest("hex").slice(0, 10)}`
+    }));
+}
+export async function generateWhy({ question, config, asked, userAnswer, onProgress }) {
+    ensureClaudeAvailable();
+    const prompt = buildWhyPrompt({ question, config, asked, userAnswer });
+    const events = [];
+    let streamedText = "";
+    await runClaude(["-p", "--output-format", "stream-json", "--verbose", prompt], {
+        onEvent: (event) => {
+            events.push(event);
+            if (onProgress && isAssistantEvent(event)) {
+                for (const block of getAssistantBlocks(event)) {
+                    if (isObject(block) && block.type === "text" && typeof block.text === "string") {
+                        streamedText += block.text;
+                        onProgress(block.text);
+                    }
+                }
+            }
+        }
+    });
+    if (streamedText) {
+        return streamedText;
+    }
+    return extractTextFromEvents(events).trim();
+}

package/dist/sources/claudeSession.js

@@ -0,0 +1,112 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getClaudeProjectsDir } from "../platform/paths.js";
+function isObject(value) {
+    return value !== null && typeof value === "object";
+}
+function getMessageContent(row) {
+    const message = row.message;
+    if (!isObject(message)) {
+        return null;
+    }
+    return typeof message.content === "string" ? message.content : null;
+}
+function parseJsonLines(filePath) {
+    const content = fs.readFileSync(filePath, "utf8");
+    return content
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            const parsed = JSON.parse(line);
+            return isObject(parsed) ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((row) => row !== null);
+}
+function listSessionFiles(projectDir) {
+    return fs.readdirSync(projectDir)
+        .filter((name) => name.endsWith(".jsonl"))
+        .map((name) => path.join(projectDir, name))
+        .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+}
+function summarizeRows(rows) {
+    const userRows = rows.filter((row) => row.type === "user" && getMessageContent(row));
+    const assistantRows = rows.filter((row) => row.type === "assistant" && getMessageContent(row));
+    const cwdRow = rows.find((row) => typeof row.cwd === "string");
+    const cwd = typeof cwdRow?.cwd === "string" ? cwdRow.cwd : "unknown";
+    return {
+        cwd,
+        userCount: userRows.length,
+        assistantCount: assistantRows.length,
+        promptPreview: userRows
+            .slice(-3)
+            .map((row) => {
+            const content = getMessageContent(row);
+            return (content ?? "").replace(/\s+/g, " ").trim();
+        })
+            .join("\n")
+    };
+}
+function findMostRecentSessionGlobally() {
+    const projectsDir = getClaudeProjectsDir();
+    if (!fs.existsSync(projectsDir)) {
+        return null;
+    }
+    const allFiles = fs.readdirSync(projectsDir)
+        .flatMap((entry) => {
+        const dir = path.join(projectsDir, entry);
+        try {
+            if (!fs.statSync(dir).isDirectory())
+                return [];
+            return listSessionFiles(dir);
+        }
+        catch {
+            return [];
+        }
+    })
+        .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+    return allFiles.length ? allFiles[0] : null;
+}
+function findLatestSessionFile() {
+    const projectsDir = getClaudeProjectsDir();
+    const mostRecent = findMostRecentSessionGlobally();
+    if (!mostRecent) {
+        throw new Error(`No Claude project transcripts found in ${projectsDir}. Run Claude Code in this repo first, or use --repo / "topic".`);
+    }
+    return mostRecent;
+}
+export function getClaudeSummaryFromFile(filePath, cwd = process.cwd()) {
+    const rows = parseJsonLines(filePath);
+    const { promptPreview } = summarizeRows(rows);
+    const userMessages = rows
+        .filter((row) => row.type === "user" && getMessageContent(row))
+        .slice(-8)
+        .map((row) => (getMessageContent(row) ?? "").replace(/\s+/g, " ").trim())
+        .join("\n");
+    const assistantMessages = rows
+        .filter((row) => row.type === "assistant" && getMessageContent(row))
+        .slice(-4)
+        .map((row) => JSON.stringify(getMessageContent(row)))
+        .join("\n");
+    return {
+        sourceType: "claude_session",
+        title: path.basename(filePath),
+        summary: [
+            `Claude project path: ${cwd}`,
+            `Transcript file: ${path.basename(filePath)}`,
+            "Prompt preview:",
+            promptPreview || "No recent prompt preview found.",
+            "Recent user prompts:",
+            userMessages || "No recent user prompts found.",
+            "Recent assistant content:",
+            assistantMessages || "No recent assistant messages found."
+        ].join("\n")
+    };
+}
+export function getLatestClaudeSummary(cwd = process.cwd()) {
+    return getClaudeSummaryFromFile(findLatestSessionFile(), cwd);
+}

package/dist/sources/repository.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+function readIfExists(filePath, max = 4000) {
+    if (!fs.existsSync(filePath)) {
+        return "";
+    }
+    return fs.readFileSync(filePath, "utf8").slice(0, max);
+}
+function safeGit(args, cwd) {
+    try {
+        return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+export function getRepoSummary(repoPath = process.cwd()) {
+    const packageJson = readIfExists(path.join(repoPath, "package.json"), 5000);
+    const readme = readIfExists(path.join(repoPath, "README.md"), 5000);
+    const srcFiles = fs.existsSync(repoPath)
+        ? fs.readdirSync(repoPath).slice(0, 30).join(", ")
+        : "";
+    const gitStatus = safeGit(["status", "--short"], repoPath);
+    const gitLog = safeGit(["log", "--oneline", "-5"], repoPath);
+    return {
+        sourceType: "repo",
+        title: path.basename(repoPath),
+        summary: [
+            `Repository: ${repoPath}`,
+            "Top-level files:",
+            srcFiles,
+            "package.json excerpt:",
+            packageJson || "None",
+            "README excerpt:",
+            readme || "None",
+            "Git status:",
+            gitStatus || "Unavailable",
+            "Recent commits:",
+            gitLog || "Unavailable"
+        ].join("\n")
+    };
+}

package/dist/sources/topic.js

@@ -0,0 +1,7 @@
+export function getTopicSummary(topic) {
+    return {
+        sourceType: "topic",
+        title: topic,
+        summary: `Topic requested by user: ${topic}`
+    };
+}

package/dist/storage/index.js

@@ -0,0 +1,18 @@
+import path from "node:path";
+import { getAppDataDir } from "../platform/paths.js";
+import { SqliteStore } from "./sqlite.js";
+import { ensureDir } from "../platform/fs.js";
+export function createStore() {
+    let dataDir = getAppDataDir();
+    try {
+        ensureDir(dataDir);
+    }
+    catch {
+        dataDir = path.join(process.cwd(), ".quizme");
+        ensureDir(dataDir);
+    }
+    const dbPath = path.join(dataDir, "history.sqlite");
+    const store = new SqliteStore(dbPath);
+    store.init();
+    return store;
+}