create-interview-cockpit 0.1.0

package/template/server/src/index.ts

@@ -0,0 +1,758 @@
+import dotenv from "dotenv";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+dotenv.config({ path: path.join(__dirname, "../../.env") });
+
+import express from "express";
+import cors from "cors";
+import multer from "multer";
+import mammoth from "mammoth";
+import { PDFParse } from "pdf-parse";
+import {
+  convertToModelMessages,
+  generateText,
+  streamText,
+  tool,
+  stepCountIs,
+  type LanguageModel,
+} from "ai";
+import { z } from "zod";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { randomUUID } from "crypto";
+import fs from "fs/promises";
+import * as storage from "./storage.js";
+
+const app = express();
+app.use(cors());
+app.use(express.json({ limit: "10mb" }));
+
+const upload = multer({
+  limits: { fileSize: 10 * 1024 * 1024 }, // 10MB max
+  fileFilter: (_req, file, cb) => {
+    const allowed =
+      /\.(txt|md|ts|tsx|js|jsx|json|css|scss|html|xml|yaml|yml|csv|py|java|cs|go|rs|sql|sh|env|cfg|conf|toml|ini|log|pdf|docx)$/i;
+    if (allowed.test(file.originalname) || file.mimetype.startsWith("text/")) {
+      cb(null, true);
+    } else {
+      cb(new Error("Unsupported file type"));
+    }
+  },
+});
+
+// Extract text from uploaded files (docx, pdf, or plain text)
+async function extractText(buffer: Buffer, filename: string): Promise<string> {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  if (ext === "docx") {
+    const result = await mammoth.extractRawText({ buffer });
+    return result.value;
+  }
+  if (ext === "pdf") {
+    const parser = new PDFParse({ data: buffer });
+    const result = await parser.getText();
+    return result.text;
+  }
+  return buffer.toString("utf-8");
+}
+
+const PORT = process.env.PORT || 3001;
+const CODE_CONTEXT_DIR = process.env.CODE_CONTEXT_DIR || "";
+
+// ─── AI Providers (Vercel AI SDK) ────────────────────────
+// Set the provider + model in .env. Supports: openai, google, anthropic
+
+function getModel(): LanguageModel {
+  const provider = (process.env.AI_PROVIDER || "openai").toLowerCase();
+  const model = process.env.AI_MODEL || "";
+
+  switch (provider) {
+    case "google":
+    case "gemini": {
+      const google = createGoogleGenerativeAI({
+        apiKey: process.env.GOOGLE_API_KEY || "",
+      });
+      return google(model || "gemini-2.5-flash");
+    }
+    case "anthropic":
+    case "claude": {
+      const anthropic = createAnthropic({
+        apiKey: process.env.ANTHROPIC_API_KEY || "",
+      });
+      return anthropic(model || "claude-sonnet-4-20250514");
+    }
+    case "openai":
+    default: {
+      const openai = createOpenAI({
+        apiKey: process.env.OPENAI_API_KEY || "",
+      });
+      return openai(model || "gpt-4o");
+    }
+  }
+}
+
+function getTextFromUIMessage(message: any): string {
+  if (typeof message?.content === "string") {
+    return message.content;
+  }
+
+  if (Array.isArray(message?.parts)) {
+    return message.parts
+      .filter((part: any) => part?.type === "text")
+      .map((part: any) => part.text || "")
+      .join("");
+  }
+
+  return "";
+}
+
+// ─── Topics ──────────────────────────────────────────────
+
+app.get("/api/topics", async (_req, res) => {
+  const topics = await storage.getTopics();
+  res.json(topics);
+});
+
+app.post("/api/topics", async (req, res) => {
+  const topic: storage.Topic = {
+    id: randomUUID(),
+    name: req.body.name,
+    contextFiles: [],
+    createdAt: new Date().toISOString(),
+  };
+  await storage.saveTopic(topic);
+  res.json(topic);
+});
+
+app.delete("/api/topics/:id", async (req, res) => {
+  await storage.deleteTopic(req.params.id);
+  res.json({ ok: true });
+});
+
+app.patch("/api/topics/:id", async (req, res) => {
+  const topics = await storage.getTopics();
+  const topic = topics.find((t) => t.id === req.params.id);
+  if (!topic) return res.status(404).json({ error: "Not found" });
+  if (typeof req.body.name === "string") topic.name = req.body.name;
+  await storage.saveTopic(topic);
+  res.json(topic);
+});
+
+// ─── Topic Context Files ─────────────────────────────────
+
+app.post(
+  "/api/topics/:topicId/context-files",
+  upload.array("files", 20),
+  async (req, res) => {
+    const files = req.files as Express.Multer.File[];
+    if (!files?.length) return res.status(400).json({ error: "No files" });
+    const results: storage.ContextFile[] = [];
+    for (const file of files) {
+      const text = await extractText(file.buffer, file.originalname);
+      const cf = await storage.saveContextFile(
+        req.params.topicId as string,
+        randomUUID(),
+        file.originalname,
+        Buffer.from(text, "utf-8"),
+      );
+      results.push(cf);
+    }
+    res.json(results);
+  },
+);
+
+app.delete("/api/topics/:topicId/context-files/:fileId", async (req, res) => {
+  await storage.deleteContextFile(req.params.topicId, req.params.fileId);
+  res.json({ ok: true });
+});
+
+// ─── Questions ───────────────────────────────────────────
+
+app.get("/api/topics/:topicId/questions", async (req, res) => {
+  const questions = await storage.getQuestionsByTopic(req.params.topicId);
+  res.json(questions);
+});
+
+app.post("/api/topics/:topicId/questions", async (req, res) => {
+  const question: storage.Question = {
+    id: randomUUID(),
+    topicId: req.params.topicId,
+    parentQuestionId: req.body.parentQuestionId || undefined,
+    title: req.body.title,
+    systemContext: req.body.systemContext || "",
+    codeContextFiles: req.body.codeContextFiles || [],
+    contextFiles: [],
+    messages: [],
+    createdAt: new Date().toISOString(),
+  };
+  await storage.saveQuestion(question);
+  res.json(question);
+});
+
+app.get("/api/questions/:id", async (req, res) => {
+  const q = await storage.getQuestion(req.params.id);
+  if (!q) return res.status(404).json({ error: "Not found" });
+  res.json(q);
+});
+
+app.patch("/api/questions/:id", async (req, res) => {
+  const q = await storage.getQuestion(req.params.id);
+  if (!q) return res.status(404).json({ error: "Not found" });
+  if (req.body.codeContextFiles !== undefined)
+    q.codeContextFiles = req.body.codeContextFiles;
+  if (req.body.systemContext !== undefined)
+    q.systemContext = req.body.systemContext;
+  if (req.body.title !== undefined) q.title = req.body.title;
+  if (req.body.parentQuestionId !== undefined)
+    q.parentQuestionId = req.body.parentQuestionId;
+  if (req.body.messages !== undefined) q.messages = req.body.messages;
+  if (req.body.annotations !== undefined) q.annotations = req.body.annotations;
+  if (req.body.readingBookmark !== undefined)
+    q.readingBookmark = req.body.readingBookmark;
+  await storage.saveQuestion(q);
+  res.json(q);
+});
+
+app.delete("/api/questions/:id", async (req, res) => {
+  const q = await storage.getQuestion(req.params.id);
+  if (q) {
+    // Cascade: delete children that point to this question
+    const siblings = await storage.getQuestionsByTopic(q.topicId);
+    const children = siblings.filter((c) => c.parentQuestionId === q.id);
+    await Promise.all(children.map((c) => storage.deleteQuestion(c.id)));
+  }
+  await storage.deleteQuestion(req.params.id);
+  res.json({ ok: true });
+});
+
+// ─── Question Context Files ─────────────────────────────
+
+app.post(
+  "/api/questions/:questionId/context-files",
+  upload.array("files", 20),
+  async (req, res) => {
+    const files = req.files as Express.Multer.File[];
+    if (!files?.length) return res.status(400).json({ error: "No files" });
+    const results: storage.ContextFile[] = [];
+    for (const file of files) {
+      const text = await extractText(file.buffer, file.originalname);
+      const cf = await storage.saveQuestionContextFile(
+        req.params.questionId as string,
+        randomUUID(),
+        file.originalname,
+        Buffer.from(text, "utf-8"),
+      );
+      results.push(cf);
+    }
+    res.json(results);
+  },
+);
+
+app.delete(
+  "/api/questions/:questionId/context-files/:fileId",
+  async (req, res) => {
+    await storage.deleteQuestionContextFile(
+      req.params.questionId,
+      req.params.fileId,
+    );
+    res.json({ ok: true });
+  },
+);
+
+// ─── Chat ────────────────────────────────────────────────
+
+app.post("/api/chat", async (req, res) => {
+  const {
+    messages,
+    questionId,
+    topicId,
+    topicTitle,
+    questionTitle,
+    codeContextFiles,
+    codeSnippets,
+    systemContext,
+    responseLength,
+  } = req.body;
+
+  const responseProfiles: Record<
+    string,
+    { maxOutputTokens: number; maxSteps: number }
+  > = {
+    concise: {
+      maxOutputTokens: 1000,
+      maxSteps: 3,
+    },
+    moderate: {
+      maxOutputTokens: 1000,
+      maxSteps: 5,
+    },
+    normal: {
+      maxOutputTokens: 3000,
+      maxSteps: 5,
+    },
+  };
+  const selectedResponseProfile =
+    responseProfiles[responseLength] || responseProfiles.normal;
+
+  let system = `You are a senior engineering interview coach.
+
+Highest priority: follow the user's explicit response preferences and current conversation context. If they conflict with your default teaching behavior, the user's preference wins.
+Explain clearly, accurately, and practically.
+Only include Mermaid diagrams, code blocks, or tables when the user explicitly asks for them or when they materially improve the answer.
+If you show code, use a fenced code block with the correct language.
+
+Mermaid syntax rules (follow strictly):
+- Wrap node labels in quotes when they contain special characters: A["Microservice A (Producer)"]
+- Edge labels use |text| syntax: A -->|sends message| B
+- Never put parentheses or brackets inside [] without quoting the label
+- Use simple node IDs (letters/numbers) and put descriptive text in the label`;
+
+  if (topicTitle || questionTitle) {
+    system += `\n\n--- Current Context ---`;
+    if (topicTitle) system += `\nTopic: ${topicTitle}`;
+    if (questionTitle) system += `\nQuestion: ${questionTitle}`;
+  }
+
+  if (systemContext) {
+    system += `\n\n--- Additional Context ---\n${systemContext}`;
+  }
+
+  // Build a file registry: id → { label, reader }
+  // The model sees the list of file names and can call readFile(id) for any of them.
+  const fileRegistry = new Map<
+    string,
+    { label: string; reader: () => Promise<string> }
+  >();
+
+  // Topic-level uploaded files
+  if (topicId) {
+    const topics = await storage.getTopics();
+    const topic = topics.find((t) => t.id === topicId);
+    if (topic?.contextFiles?.length) {
+      for (const cf of topic.contextFiles) {
+        fileRegistry.set(cf.id, {
+          label: `[topic] ${cf.originalName}`,
+          reader: () => storage.readContextFileContent(cf.id),
+        });
+      }
+    }
+  }
+
+  // Question-level uploaded files
+  if (questionId) {
+    const question = await storage.getQuestion(questionId);
+    if (question?.contextFiles?.length) {
+      for (const cf of question.contextFiles) {
+        fileRegistry.set(cf.id, {
+          label: `[question] ${cf.originalName}`,
+          reader: () => storage.readContextFileContent(cf.id),
+        });
+      }
+    }
+  }
+
+  // Code-context files from the project directory
+  if (codeContextFiles?.length && CODE_CONTEXT_DIR) {
+    for (const filePath of codeContextFiles as string[]) {
+      const fullPath = path.join(CODE_CONTEXT_DIR, filePath);
+      const resolved = path.resolve(fullPath);
+      if (!resolved.startsWith(path.resolve(CODE_CONTEXT_DIR))) continue;
+      fileRegistry.set(`code:${filePath}`, {
+        label: `[code] ${filePath}`,
+        reader: () => fs.readFile(resolved, "utf-8"),
+      });
+    }
+  }
+
+  // Tell the model what files are available
+  if (fileRegistry.size > 0) {
+    // collect just the code-context file paths for linking instructions
+    const codeFilePaths: string[] = [];
+    for (const [id, { label }] of fileRegistry) {
+      if (id.startsWith("code:")) codeFilePaths.push(id.slice("code:".length));
+    }
+
+    system += `\n\n--- Available Reference Files ---
+The following files are available to you. Use the readFile tool to retrieve a file's content when it would help answer the question. Only read files that are relevant — you do not need to read them all.
+
+`;
+    for (const [id, { label }] of fileRegistry) {
+      system += `• ${label}  (id: "${id}")\n`;
+    }
+
+    if (codeFilePaths.length > 0) {
+      system += `
+--- Linking Code Files in Your Response ---
+When you mention or reference one of the **[code]** files above in your response text, format it as a clickable link so the user can open it directly:
+
+  [DisplayText](coderef://relative/path/to/file)
+
+Examples:
+  [EmployeesController](coderef://src/Controllers/EmployeesController.cs)
+  [SettleDeferredPaymentCaseRequest](coderef://src/Requests/SettleDeferredPaymentCaseRequest.cs)
+
+Use this for class names, method names, or any mention of a specific file from the code context. The display text should be the class, file, or concept name — not the raw path.
+Only use coderef:// for [code] files. Do not use it for uploaded documents.`;
+    }
+  }
+
+  // Code snippets hand-picked by the user from the file viewer
+  if (Array.isArray(codeSnippets) && codeSnippets.length > 0) {
+    system += `\n\n--- Code Snippets (highlighted by user) ---\nThe user has selected these specific sections of code as focus areas for this conversation:\n\n`;
+    for (const snippet of codeSnippets as Array<{
+      fileName: string;
+      filePath: string;
+      startLine: number;
+      endLine: number;
+      code: string;
+    }>) {
+      const lineLabel =
+        snippet.startLine === snippet.endLine
+          ? `line ${snippet.startLine}`
+          : `lines ${snippet.startLine}–${snippet.endLine}`;
+      system += `**${snippet.fileName}** (${lineLabel}):\n\`\`\`\n${snippet.code}\n\`\`\`\n\n`;
+    }
+  }
+
+  if (!Array.isArray(messages)) {
+    return res.status(400).json({
+      error: "Invalid chat payload: messages must be an array",
+    });
+  }
+
+  try {
+    const modelMessages = await convertToModelMessages(messages as any[]);
+
+    const isGoogle = ["google", "gemini"].includes(
+      (process.env.AI_PROVIDER || "openai").toLowerCase(),
+    );
+
+    const result = streamText({
+      model: getModel(),
+      maxOutputTokens: selectedResponseProfile.maxOutputTokens,
+      ...(isGoogle && {
+        providerOptions: {
+          google: { thinkingConfig: { thinkingBudget: 0 } },
+        },
+      }),
+      system,
+      messages: modelMessages,
+      tools:
+        fileRegistry.size > 0
+          ? {
+              readFile: tool({
+                description:
+                  "Read the content of an available reference file. Use this to get file contents when they are relevant to the user's question.",
+                inputSchema: z.object({
+                  fileId: z
+                    .string()
+                    .describe(
+                      "The id of the file to read, from the available files list.",
+                    ),
+                }),
+                execute: async ({ fileId }) => {
+                  const entry = fileRegistry.get(fileId);
+                  if (!entry) return { error: "File not found" };
+                  try {
+                    const content = await entry.reader();
+                    return { fileName: entry.label, content };
+                  } catch {
+                    return { error: "Could not read file" };
+                  }
+                },
+              }),
+            }
+          : undefined,
+      stopWhen: stepCountIs(selectedResponseProfile.maxSteps),
+    });
+
+    result.pipeUIMessageStreamToResponse(res, {
+      originalMessages: messages,
+      onFinish: async ({ messages: finalMessages, isAborted }) => {
+        if (questionId == null || isAborted) {
+          return;
+        }
+
+        try {
+          const normalized = finalMessages.map((message: any) => ({
+            id: message.id || randomUUID(),
+            role: message.role,
+            content: getTextFromUIMessage(message),
+          }));
+
+          await storage.updateQuestionMessages(questionId, normalized);
+        } catch (e) {
+          console.error("Failed to save messages:", e);
+        }
+      },
+    });
+  } catch (err: any) {
+    console.error("Chat error:", err?.message || err);
+    if (!res.headersSent) {
+      res
+        .status(500)
+        .json({ error: err?.message || "Failed to generate response" });
+    }
+  }
+});
+
+// ─── Code Context Browser ────────────────────────────────
+
+const IGNORE_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".cache",
+  "__pycache__",
+  ".vscode",
+  ".idea",
+  "coverage",
+  ".turbo",
+  // .NET build artifacts
+  "bin",
+  "obj",
+  ".vs",
+  "packages",
+  "TestResults",
+  "publish",
+  // Python / misc
+  ".mypy_cache",
+  ".pytest_cache",
+  ".ruff_cache",
+  "venv",
+  ".venv",
+  // macOS / editor noise
+  ".DS_Store",
+  ".Spotlight-V100",
+  ".Trashes",
+  ".env",
+  ".env.local",
+  ".env.development",
+  ".env.production",
+]);
+
+// File extensions that are binary or auto-generated — never useful as context
+const IGNORE_EXTENSIONS = new Set([
+  // .NET compiled outputs
+  ".dll",
+  ".exe",
+  ".pdb",
+  ".nupkg",
+  ".snupkg",
+  ".suo",
+  // Lock / generated
+  ".lock",
+  ".user",
+  // Images
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".ico",
+  ".webp",
+  ".bmp",
+  // Fonts
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  // Archives / binaries
+  ".zip",
+  ".tar",
+  ".gz",
+  ".rar",
+  ".7z",
+  ".bin",
+  ".so",
+  ".dylib",
+  ".lib",
+  ".obj",
+  // Misc
+  ".min.js",
+  ".map",
+]);
+
+async function walkDir(dir: string, prefix = ""): Promise<string[]> {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const files: string[] = [];
+  for (const entry of entries) {
+    if (IGNORE_DIRS.has(entry.name)) continue;
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...(await walkDir(path.join(dir, entry.name), rel)));
+    } else {
+      const lower = entry.name.toLowerCase();
+      if (IGNORE_EXTENSIONS.has(path.extname(lower))) continue;
+      // Also catch compound extensions like .min.js, .d.ts generated files
+      if (lower.endsWith(".min.js") || lower.endsWith(".d.ts")) continue;
+      files.push(rel);
+    }
+  }
+  return files;
+}
+
+app.get("/api/code-context/tree", async (_req, res) => {
+  if (!CODE_CONTEXT_DIR) return res.json([]);
+  try {
+    const files = await walkDir(CODE_CONTEXT_DIR);
+    res.json(files);
+  } catch {
+    res.json([]);
+  }
+});
+
+app.get("/api/code-context/file", async (req, res) => {
+  if (!CODE_CONTEXT_DIR)
+    return res.status(400).json({ error: "No code context directory" });
+  const filePath = req.query.path as string;
+  if (!filePath) return res.status(400).json({ error: "Path required" });
+
+  const fullPath = path.join(CODE_CONTEXT_DIR, filePath);
+  const resolved = path.resolve(fullPath);
+  if (!resolved.startsWith(path.resolve(CODE_CONTEXT_DIR))) {
+    return res.status(403).json({ error: "Access denied" });
+  }
+
+  try {
+    const content = await fs.readFile(resolved, "utf-8");
+    res.json({ path: filePath, content });
+  } catch {
+    res.status(404).json({ error: "File not found" });
+  }
+});
+
+// ─── Inline Ask ─────────────────────────────────────────
+
+app.post("/api/inline-ask", async (req, res) => {
+  const {
+    selectedText,
+    prompt,
+    messageContent,
+    priorResponse,
+    followUps,
+    responseLength,
+    responseStyle,
+    responseAudience,
+  } = req.body;
+  if (typeof selectedText !== "string" || typeof prompt !== "string") {
+    return res
+      .status(400)
+      .json({ error: "selectedText and prompt are required" });
+  }
+
+  try {
+    const isGoogle = ["google", "gemini"].includes(
+      (process.env.AI_PROVIDER || "openai").toLowerCase(),
+    );
+
+    // Build conversation thread context for follow-ups
+    let threadContext = "";
+    if (priorResponse) {
+      threadContext += `\n\nInitial response about "${selectedText}":\n${priorResponse}`;
+    }
+    if (Array.isArray(followUps) && followUps.length > 0) {
+      threadContext += `\n\nFollow-up thread so far:`;
+      for (const fu of followUps) {
+        threadContext += `\n\nUser asked: "${fu.prompt}"\nAnswer: ${fu.response}`;
+      }
+    }
+
+    const lengthHints: Record<string, string> = {
+      concise: "Be concise — aim for a short focused answer.",
+      moderate: "Keep the answer moderately detailed.",
+      normal: "Use a full explanation with enough context.",
+    };
+    const styleHints: Record<string, string> = {
+      prose: "Use natural prose; avoid bullet lists unless essential.",
+      bullets: "Use bullet points as the main format.",
+      structured: "Use sections/headings and numbered steps when helpful.",
+    };
+    const audienceHints: Record<string, string> = {
+      beginner:
+        "When using technical terms or abbreviations, immediately expand their meaning in square brackets right after the term — e.g. 'TCP [Transmission Control Protocol — a connection-oriented transport protocol]' or 'log lines [text entries written to a file or stream that record what happened at a given moment]'. Do this for every technical term throughout your response.",
+    };
+    const systemLines: string[] = [
+      "You are a senior engineering interview coach. Provide focused, helpful responses about the highlighted text.",
+    ];
+    if (responseLength && lengthHints[responseLength])
+      systemLines.push(lengthHints[responseLength]);
+    if (responseStyle && styleHints[responseStyle])
+      systemLines.push(styleHints[responseStyle]);
+    if (responseAudience && audienceHints[responseAudience])
+      systemLines.push(audienceHints[responseAudience]);
+
+    const { text } = await generateText({
+      model: getModel(),
+      maxOutputTokens: 800,
+      ...(isGoogle && {
+        providerOptions: {
+          google: { thinkingConfig: { thinkingBudget: 0 } },
+        },
+      }),
+      system: systemLines.join("\n"),
+      prompt: `The user is reading this coaching response:
+---
+${messageContent || ""}
+---
+
+They highlighted: "${selectedText}"
+${threadContext}
+
+Their question: "${prompt}"`,
+    });
+
+    res.json({ response: text });
+  } catch (err: any) {
+    console.error("inline-ask error:", err?.message || err);
+    res.status(500).json({ error: err?.message || "Failed to get response" });
+  }
+});
+
+// ─── Fix Diagram ────────────────────────────────────────
+
+app.post("/api/fix-diagram", async (req, res) => {
+  const { chart, error: renderError } = req.body;
+  if (typeof chart !== "string" || !chart.trim()) {
+    return res.status(400).json({ error: "chart is required" });
+  }
+
+  try {
+    const isGoogle = ["google", "gemini"].includes(
+      (process.env.AI_PROVIDER || "openai").toLowerCase(),
+    );
+
+    const { text } = await generateText({
+      model: getModel(),
+      maxOutputTokens: 800,
+      ...(isGoogle && {
+        providerOptions: {
+          google: { thinkingConfig: { thinkingBudget: 0 } },
+        },
+      }),
+      prompt: `The following Mermaid diagram failed to render.${renderError ? `\n\nRender error:\n${renderError}` : ""}\n\nFix the syntax so it renders correctly. Common issues to check:\n- Parentheses inside edge labels |like (this)| must be quoted: |"like (this)"|\n- Parentheses inside node labels [like (this)] must be quoted: ["like (this)"]\n- Special characters in labels generally need quoting\n\nReturn ONLY the corrected Mermaid code with no explanation and no markdown fences — just the raw diagram definition.\n\nFailed diagram:\n${chart}`,
+    });
+
+    // Strip any fences the model might have added anyway
+    const fixed = text
+      .replace(/^```mermaid\s*/i, "")
+      .replace(/^```\s*/i, "")
+      .replace(/```\s*$/, "")
+      .trim();
+
+    res.json({ chart: fixed });
+  } catch (err: any) {
+    console.error("fix-diagram error:", err?.message || err);
+    res.status(500).json({ error: err?.message || "Failed to fix diagram" });
+  }
+});
+
+// ─── Start ───────────────────────────────────────────────
+
+app.listen(PORT, () => {
+  console.log(`\n  ✈  Interview Cockpit server → http://localhost:${PORT}\n`);
+});