create-interview-cockpit 0.3.0 → 0.5.0

package/template/server/src/storage.ts

@@ -32,6 +32,9 @@ function questionsDirPath(id = _activeWorkspaceId) {
 function contextFilesDirPath(id = _activeWorkspaceId) {
   return path.join(workspaceDir(id), "context-files");
 }
+function workspaceFilesFilePath(id = _activeWorkspaceId) {
+  return path.join(workspaceDir(id), "workspace-files.json");
+}
 async function ensureWorkspaceDirs(id = _activeWorkspaceId) {
   await fs.mkdir(workspaceDir(id), { recursive: true });
   await fs.mkdir(questionsDirPath(id), { recursive: true });
@@ -51,12 +54,21 @@ export interface ContextFile {
   originalName: string;
   driveFileId?: string;
   createdAt: string;
+  /** Distinguishes how this file was added. 'upload' = user-uploaded doc,
+   *  'user' = code saved from Code Runner, 'ai' = AI-generated code block,
+   *  'sandbox' = paired server+client sandbox saved as JSON. */
+  origin?: "user" | "ai" | "upload" | "sandbox";
+  /** Language hint for code snippets (e.g. 'typescript', 'javascript'). */
+  language?: string;
+  /** Short display label for code snippets. */
+  label?: string;
 }
 
 export interface Message {
   id: string;
   role: string;
   content: string;
+  parts?: any[];
   createdAt?: string;
 }
 
@@ -82,6 +94,16 @@ export interface ReadingBookmark {
   blockIndex: number;
 }
 
+export interface StoredCodeAnnotation {
+  id: string;
+  lineNumber: number;
+  lineContent: string;
+  prompt: string;
+  response: string;
+  filePath: string;
+  createdAt: string;
+}
+
 export interface Question {
   id: string;
   topicId: string;
@@ -93,6 +115,8 @@ export interface Question {
   messages: Message[];
   annotations?: Annotation[];
   readingBookmark?: ReadingBookmark;
+  /** Code-line annotations keyed by file path. */
+  codeAnnotations?: { [filePath: string]: StoredCodeAnnotation[] };
   createdAt: string;
 }
 
@@ -469,6 +493,11 @@ export async function deleteContextFile(
   } catch {
     /* already gone */
   }
+  try {
+    await fs.unlink(path.join(contextFilesDirPath(), `${fileId}.orig`));
+  } catch {
+    /* already gone */
+  }
   const topics = await getTopics();
   const topic = topics.find((t) => t.id === topicId);
   if (topic) {
@@ -483,7 +512,117 @@ export async function readContextFileContent(fileId: string): Promise<string> {
   return fs.readFile(path.join(contextFilesDirPath(), fileId), "utf-8");
 }
 
-// --- Questions ---
+/**
+ * Store the raw original file bytes at {fileId}.orig so downloads can serve the
+ * real file rather than the extracted-text version used by the LLM.
+ */
+export async function writeOriginalBlob(
+  fileId: string,
+  buffer: Buffer,
+  workspaceId = _activeWorkspaceId,
+): Promise<void> {
+  await ensureWorkspaceDirs(workspaceId);
+  await fs.writeFile(
+    path.join(contextFilesDirPath(workspaceId), `${fileId}.orig`),
+    buffer,
+  );
+}
+
+/**
+ * Read the original file bytes. Returns null if the file was uploaded before
+ * original storage was added (graceful fallback).
+ */
+export async function readOriginalBlob(
+  fileId: string,
+  workspaceId = _activeWorkspaceId,
+): Promise<Buffer | null> {
+  try {
+    return await fs.readFile(
+      path.join(contextFilesDirPath(workspaceId), `${fileId}.orig`),
+    );
+  } catch {
+    return null;
+  }
+}
+// --- Workspace-level Context Files ---
+// Stored in data/workspaces/{id}/workspace-files.json
+// Blobs share the same context-files/ dir as topic/question files.
+
+export async function getWorkspaceContextFiles(
+  workspaceId = _activeWorkspaceId,
+): Promise<ContextFile[]> {
+  try {
+    const data = await fs.readFile(
+      workspaceFilesFilePath(workspaceId),
+      "utf-8",
+    );
+    return JSON.parse(data) as ContextFile[];
+  } catch {
+    return [];
+  }
+}
+
+export async function saveWorkspaceContextFile(
+  fileId: string,
+  originalName: string,
+  buffer: Buffer,
+  workspaceId = _activeWorkspaceId,
+): Promise<ContextFile> {
+  await ensureWorkspaceDirs(workspaceId);
+  await fs.writeFile(
+    path.join(contextFilesDirPath(workspaceId), fileId),
+    buffer,
+  );
+  const cf: ContextFile = {
+    id: fileId,
+    name: originalName,
+    originalName,
+    createdAt: new Date().toISOString(),
+  };
+  const existing = await getWorkspaceContextFiles(workspaceId);
+  existing.push(cf);
+  await fs.writeFile(
+    workspaceFilesFilePath(workspaceId),
+    JSON.stringify(existing, null, 2),
+  );
+  return cf;
+}
+
+export async function deleteWorkspaceContextFile(
+  fileId: string,
+  workspaceId = _activeWorkspaceId,
+): Promise<void> {
+  try {
+    await fs.unlink(path.join(contextFilesDirPath(workspaceId), fileId));
+  } catch {
+    /* already gone */
+  }
+  try {
+    await fs.unlink(
+      path.join(contextFilesDirPath(workspaceId), `${fileId}.orig`),
+    );
+  } catch {
+    /* already gone */
+  }
+  const existing = await getWorkspaceContextFiles(workspaceId);
+  const updated = existing.filter((f) => f.id !== fileId);
+  await fs.writeFile(
+    workspaceFilesFilePath(workspaceId),
+    JSON.stringify(updated, null, 2),
+  );
+}
+
+// --- Workspace-level Context Files ---
+
+export async function readWorkspaceContextFileContent(
+  fileId: string,
+  workspaceId = _activeWorkspaceId,
+): Promise<string> {
+  return fs.readFile(
+    path.join(contextFilesDirPath(workspaceId), fileId),
+    "utf-8",
+  );
+}
 
 export async function getQuestion(id: string): Promise<Question | null> {
   await ensureWorkspaceDirs();
@@ -525,6 +664,31 @@ export async function getQuestionsByTopic(
   }
 }
 
+export async function getAllQuestions(): Promise<Question[]> {
+  await ensureWorkspaceDirs();
+  try {
+    const files = await fs.readdir(questionsDirPath());
+    const questions: Question[] = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const data = await fs.readFile(
+          path.join(questionsDirPath(), file),
+          "utf-8",
+        );
+        const q: Question = JSON.parse(data);
+        if (!q.contextFiles) q.contextFiles = [];
+        questions.push(q);
+      } catch {
+        /* skip malformed */
+      }
+    }
+    return questions;
+  } catch {
+    return [];
+  }
+}
+
 export async function saveQuestion(question: Question): Promise<Question> {
   await ensureWorkspaceDirs();
   await fs.writeFile(
@@ -558,14 +722,18 @@ export async function saveQuestionContextFile(
   fileId: string,
   originalName: string,
   buffer: Buffer,
+  extra?: { origin?: ContextFile["origin"]; language?: string; label?: string },
 ): Promise<ContextFile> {
   await ensureWorkspaceDirs();
   await fs.writeFile(path.join(contextFilesDirPath(), fileId), buffer);
   const cf: ContextFile = {
     id: fileId,
-    name: originalName,
+    name: extra?.label ?? originalName,
     originalName,
     createdAt: new Date().toISOString(),
+    ...(extra?.origin ? { origin: extra.origin } : {}),
+    ...(extra?.language ? { language: extra.language } : {}),
+    ...(extra?.label ? { label: extra.label } : {}),
   };
   const q = await getQuestion(questionId);
   if (q) {
@@ -576,6 +744,32 @@ export async function saveQuestionContextFile(
   return cf;
 }
 
+export async function overwriteQuestionContextFileContent(
+  questionId: string,
+  fileId: string,
+  buffer: Buffer,
+): Promise<void> {
+  await ensureWorkspaceDirs();
+  await fs.writeFile(path.join(contextFilesDirPath(), fileId), buffer);
+}
+
+export async function renameQuestionContextFile(
+  questionId: string,
+  fileId: string,
+  label: string,
+): Promise<ContextFile> {
+  const q = await getQuestion(questionId);
+  if (!q) throw new Error("Question not found");
+  const cf = (q.contextFiles || []).find((f) => f.id === fileId);
+  if (!cf) throw new Error("Context file not found");
+  const safe =
+    label.replace(/[/\\:*?"<>|]/g, "-").trim() || cf.label || cf.originalName;
+  cf.label = safe;
+  cf.name = safe;
+  await saveQuestion(q);
+  return cf;
+}
+
 export async function deleteQuestionContextFile(
   questionId: string,
   fileId: string,
@@ -601,3 +795,166 @@ export async function updateQuestionMessages(
   q.messages = messages;
   await saveQuestion(q);
 }
+
+export async function updateCodeAnnotationsForFile(
+  questionId: string,
+  filePath: string,
+  annotations: StoredCodeAnnotation[],
+): Promise<void> {
+  const q = await getQuestion(questionId);
+  if (!q) throw new Error("Question not found");
+  if (!q.codeAnnotations) q.codeAnnotations = {};
+  q.codeAnnotations[filePath] = annotations;
+  await saveQuestion(q);
+}
+
+/**
+ * Register an already-uploaded file in a topic's contextFiles without copying
+ * any bytes — the file content on disk (identified by fileId) is shared.
+ */
+export async function linkContextFileToTopic(
+  topicId: string,
+  fileId: string,
+  originalName: string,
+): Promise<ContextFile> {
+  const cf: ContextFile = {
+    id: fileId,
+    name: originalName,
+    originalName,
+    createdAt: new Date().toISOString(),
+  };
+  const topics = await getTopics();
+  const topic = topics.find((t) => t.id === topicId);
+  if (topic) {
+    if (!topic.contextFiles) topic.contextFiles = [];
+    if (!topic.contextFiles.find((f) => f.id === fileId)) {
+      topic.contextFiles.push(cf);
+      await fs.writeFile(topicsFilePath(), JSON.stringify(topics, null, 2));
+    }
+  }
+  return cf;
+}
+
+/**
+ * Register an already-uploaded file in a question's contextFiles without copying bytes.
+ */
+export async function linkContextFileToQuestion(
+  questionId: string,
+  fileId: string,
+  originalName: string,
+): Promise<ContextFile> {
+  const cf: ContextFile = {
+    id: fileId,
+    name: originalName,
+    originalName,
+    createdAt: new Date().toISOString(),
+  };
+  const q = await getQuestion(questionId);
+  if (q) {
+    if (!q.contextFiles) q.contextFiles = [];
+    if (!q.contextFiles.find((f) => f.id === fileId)) {
+      q.contextFiles.push(cf);
+      await saveQuestion(q);
+    }
+  }
+  return cf;
+}
+
+// ── AI Settings ───────────────────────────────────────────────
+
+const AI_SETTINGS_FILE = path.join(DATA_DIR, "ai-settings.json");
+
+export interface ResponseProfile {
+  maxOutputTokens: number;
+  maxSteps: number;
+}
+
+export interface PromptGroup {
+  label: string;
+  description?: string;
+  default: string;
+  options: Record<string, string>;
+}
+
+export interface AiSettings {
+  /** Base system prompt sent to the AI on every chat turn. */
+  systemPrompt: string;
+  /** Per-length-preference token and step limits. */
+  responseProfiles: Record<string, ResponseProfile>;
+  /** Full viz diagram spec reference — returned by the getVizGuide tool. */
+  vizGuide: string;
+  /** All user-selectable prompt groups. Add new entries here to extend the UI. */
+  promptGroups: Record<string, PromptGroup>;
+  /** Gemini thinking budget in tokens. 0 = disabled. Only applies to Google models. */
+  thinkingBudget?: number;
+  /** When true, preference prompt texts are appended to every message (not just on change). */
+  alwaysSendPrefsDefault?: boolean;
+}
+
+const DEFAULT_AI_SETTINGS: AiSettings = {
+  systemPrompt:
+    "You are a senior engineering interview coach.\n\nExplain clearly, accurately, and practically.",
+  responseProfiles: {
+    concise: { maxOutputTokens: 1000, maxSteps: 3 },
+    moderate: { maxOutputTokens: 1000, maxSteps: 5 },
+    normal: { maxOutputTokens: 3000, maxSteps: 5 },
+  },
+  vizGuide: "No viz guide configured.",
+  promptGroups: {
+    length: {
+      label: "Response Length",
+      description:
+        "Appended to the user message when the selected length changes.",
+      default: "normal",
+      options: {
+        concise: "Keep the response concise.",
+        moderate: "Keep the response moderately detailed.",
+        normal:
+          "Use a fuller answer with enough context to explain the idea clearly.",
+      },
+    },
+    style: {
+      label: "Response Style",
+      description:
+        "Appended to the user message when the selected style changes.",
+      default: "prose",
+      options: {
+        prose: "Use natural prose with short paragraphs.",
+        bullets: "Use bullet points and short lists as the main format.",
+        structured:
+          "Use structured sections with headings and numbered steps when helpful.",
+      },
+    },
+    audience: {
+      label: "Response Audience",
+      description:
+        "Appended to the user message when the selected audience changes.",
+      default: "normal",
+      options: {
+        normal: "",
+        beginner:
+          "When using technical terms or abbreviations, immediately expand their meaning in square brackets.",
+      },
+    },
+  },
+};
+
+export async function getAiSettings(): Promise<AiSettings> {
+  try {
+    const raw = await fs.readFile(AI_SETTINGS_FILE, "utf-8");
+    return {
+      ...DEFAULT_AI_SETTINGS,
+      ...(JSON.parse(raw) as Partial<AiSettings>),
+    };
+  } catch {
+    return DEFAULT_AI_SETTINGS;
+  }
+}
+
+export async function saveAiSettings(settings: AiSettings): Promise<void> {
+  await fs.writeFile(
+    AI_SETTINGS_FILE,
+    JSON.stringify(settings, null, 2),
+    "utf-8",
+  );
+}