pi-interview 0.5.5 → 0.6.1

package/README.md

@@ -38,6 +38,8 @@ Restart pi to load the extension.
 - **Session Status Bar**: Shows project path, git branch, and session ID for identification
 - **Image Support**: Drag & drop anywhere on question, file picker, paste image or path
 - **Path Normalization**: Handles shell-escaped paths (`\ `) and macOS screenshot filenames (narrow no-break space before AM/PM)
+- **Generate & Review Options**: Single/multi-select questions show "✦ Generate more" (appends new choices) and "↻ Review options" (reviews options and rewrites the question for clarity) buttons powered by an LLM
+- **Tool Discoverability (pi v0.59+)**: Registers a `promptSnippet` so `interview` remains eligible for inclusion in pi's default `Available tools` prompt section
 - **Themes**: Built-in default + optional light/dark + custom theme CSS
 
 ## How It Works
@@ -287,6 +289,7 @@ Settings in `~/.pi/agent/settings.json`:
     "port": 19847,
     "snapshotDir": "~/.pi/interview-snapshots/",
     "autoSaveOnSubmit": true,
+    "generateModel": "anthropic/claude-haiku-4-5",
     "theme": {
       "mode": "auto",
       "name": "default",
@@ -306,6 +309,8 @@ Settings in `~/.pi/agent/settings.json`:
 
 **Port setting**: Set a fixed `port` (e.g., `19847`) to use a consistent port across sessions.
 
+**Generate model**: `generateModel` sets the model for the generate/review option actions (e.g., `"anthropic/claude-haiku-4-5"`). Defaults to the agent's current model, then falls back to a cheap available model. If an explicitly configured generate model fails at request time and the current session is using a different model, interview retries once with the current session model.
+
 **Theme notes:**
 - `mode`: `dark` (default), `light`, or `auto` (follows OS unless overridden)
 - `name`: built-in themes are `default` and `tufte`

package/form/script.js

@@ -401,6 +401,35 @@
     return typeof option === "object" && option !== null && "label" in option;
   }
 
+  function syncRecommendations(question, options) {
+    if (!question.recommended) return;
+
+    if (question.type === "single") {
+      if (typeof question.recommended === "string" && options.includes(question.recommended)) {
+        return;
+      }
+      delete question.recommended;
+      delete question.conviction;
+      return;
+    }
+
+    if (question.type !== "multi") {
+      delete question.recommended;
+      delete question.conviction;
+      return;
+    }
+
+    const nextRecommended = (Array.isArray(question.recommended)
+      ? question.recommended
+      : [question.recommended]).filter((option) => options.includes(option));
+    if (nextRecommended.length === 0) {
+      delete question.recommended;
+      delete question.conviction;
+      return;
+    }
+    question.recommended = nextRecommended;
+  }
+
   function renderCodeBlock(block) {
     if (!block || !block.code) return null;
 
@@ -1232,7 +1261,8 @@
     
     if (event.key === 'Tab') {
       const inAttachArea = document.activeElement?.closest('.attach-inline');
-      if (inAttachArea) return;
+      const inGenerateArea = document.activeElement?.closest('.generate-more');
+      if (inAttachArea || inGenerateArea) return;
       
       event.preventDefault();
       
@@ -1287,6 +1317,9 @@
         if (document.activeElement?.closest('.attach-inline')) {
           return;
         }
+        if (document.activeElement?.closest('.generate-more')) {
+          return;
+        }
         event.preventDefault();
         const option = options[nav.optionIndex];
         if (option) {
@@ -1388,6 +1421,224 @@
     }
   }
 
+  function createGenerateMoreUI(question, list) {
+    if (!data.canGenerate) return null;
+    if (question.options.some(isRichOption)) return null;
+
+    const container = document.createElement("div");
+    container.className = "generate-more";
+
+    const btnRow = document.createElement("div");
+    btnRow.className = "generate-more-row";
+
+    const addBtn = document.createElement("button");
+    addBtn.type = "button";
+    addBtn.className = "generate-more-btn";
+    addBtn.innerHTML = '<span class="generate-more-icon">✦</span> Generate more';
+
+    const reviewBtn = document.createElement("button");
+    reviewBtn.type = "button";
+    reviewBtn.className = "generate-more-btn";
+    reviewBtn.innerHTML = '<span class="generate-more-icon">↻</span> Review options';
+
+    const status = document.createElement("div");
+    status.className = "generate-more-status hidden";
+
+    btnRow.appendChild(addBtn);
+    btnRow.appendChild(reviewBtn);
+    container.appendChild(btnRow);
+    container.appendChild(status);
+
+    let generating = false;
+    let abortController = null;
+    let statusTimer = null;
+
+    function clearStatus() {
+      if (statusTimer !== null) {
+        clearTimeout(statusTimer);
+        statusTimer = null;
+      }
+      status.classList.add("hidden");
+      status.classList.remove("error");
+    }
+
+    function showStatus(message, timeoutMs, isError = false) {
+      if (statusTimer !== null) {
+        clearTimeout(statusTimer);
+        statusTimer = null;
+      }
+
+      status.textContent = message;
+      status.classList.remove("hidden");
+      status.classList.toggle("error", isError);
+
+      if (timeoutMs == null) {
+        return;
+      }
+
+      statusTimer = setTimeout(() => {
+        status.classList.add("hidden");
+        statusTimer = null;
+      }, timeoutMs);
+    }
+
+    function getExistingOptions() {
+      const inputs = list.querySelectorAll(
+        'input[name="' + escapeSelector(question.id) + '"]'
+      );
+      return Array.from(inputs)
+        .map((input) => input.value)
+        .filter((v) => v && v !== "__other__");
+    }
+
+    async function runGenerate(btn, mode) {
+      if (generating) {
+        if (abortController) abortController.abort();
+        return;
+      }
+
+      generating = true;
+      const icon = btn.querySelector(".generate-more-icon").textContent;
+      btn.innerHTML = '<span class="generate-more-icon">' + icon + '</span> Cancel';
+      btn.classList.add("loading");
+      addBtn.disabled = true;
+      reviewBtn.disabled = true;
+      btn.disabled = false;
+      clearStatus();
+
+      abortController = new AbortController();
+      const existingOptions = getExistingOptions();
+
+      try {
+        const response = await fetch("/generate", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            token: sessionToken,
+            questionId: question.id,
+            existingOptions,
+            mode,
+          }),
+          signal: abortController.signal,
+        });
+
+        const result = await response.json();
+        if (!result.ok) throw new Error(result.error || "Generation failed");
+        if (!Array.isArray(result.options) || result.options.length === 0) {
+          throw new Error("No options generated");
+        }
+
+        if (mode === "review") {
+          if (typeof result.question !== "string" || !result.question.trim()) {
+            throw new Error("No revised question returned");
+          }
+
+          const seen = new Set();
+          const revisedOptions = result.options.filter((option) => {
+            const key = option.toLowerCase().trim();
+            if (seen.has(key)) return false;
+            seen.add(key);
+            return true;
+          });
+          if (revisedOptions.length === 0) {
+            throw new Error("No valid options returned for review");
+          }
+
+          question.question = result.question.trim();
+          question.options = revisedOptions;
+          syncRecommendations(question, revisedOptions);
+          const title = list.closest('.question-card')?.querySelector('.question-title');
+          if (title) {
+            title.innerHTML = renderLightMarkdown(question.question);
+          }
+
+          list
+            .querySelectorAll('.option-item:not(.option-other):not(.done-item)')
+            .forEach((el) => el.remove());
+          revisedOptions.forEach((optionText, i) => {
+            const optionEl = createGeneratedOption(question, optionText, i);
+            list.insertBefore(optionEl, container);
+          });
+          if (question.type === "multi") updateDoneState(question.id);
+          debounceSave();
+          showStatus(
+            "Question updated and " + revisedOptions.length + " option" + (revisedOptions.length > 1 ? "s" : "") + " revised",
+            2500,
+          );
+        } else {
+          const existingSet = new Set(existingOptions.map((o) => o.toLowerCase().trim()));
+          const seen = new Set();
+          const newOptions = result.options.filter((o) => {
+            const key = o.toLowerCase().trim();
+            if (existingSet.has(key) || seen.has(key)) return false;
+            seen.add(key);
+            return true;
+          });
+
+          if (newOptions.length === 0) {
+            showStatus("All generated options already exist", 3000);
+          } else {
+            question.options = question.options.concat(newOptions);
+            newOptions.forEach((optionText, i) => {
+              const optionEl = createGeneratedOption(question, optionText, i);
+              list.insertBefore(optionEl, container);
+            });
+            showStatus(
+              newOptions.length + " option" + (newOptions.length > 1 ? "s" : "") + " added",
+              2500,
+            );
+          }
+        }
+        refreshCountdown();
+      } catch (err) {
+        if (!(err instanceof Error && err.name === "AbortError")) {
+          showStatus(err instanceof Error ? err.message : "Generation failed", null, true);
+        }
+      } finally {
+        generating = false;
+        addBtn.innerHTML = '<span class="generate-more-icon">✦</span> Generate more';
+        reviewBtn.innerHTML = '<span class="generate-more-icon">↻</span> Review options';
+        addBtn.classList.remove("loading");
+        reviewBtn.classList.remove("loading");
+        addBtn.disabled = false;
+        reviewBtn.disabled = false;
+        abortController = null;
+      }
+    }
+
+    addBtn.addEventListener("click", () => runGenerate(addBtn, "add"));
+    reviewBtn.addEventListener("click", () => runGenerate(reviewBtn, "review"));
+
+    return container;
+  }
+
+  function createGeneratedOption(question, optionText, animIndex) {
+    const label = document.createElement("label");
+    label.className = "option-item generated";
+    label.style.animationDelay = (animIndex * 0.08) + "s";
+
+    const input = document.createElement("input");
+    input.type = question.type === "single" ? "radio" : "checkbox";
+    input.name = question.id;
+    input.value = optionText;
+    input.setAttribute("tabindex", "-1");
+
+    input.addEventListener("change", () => {
+      debounceSave();
+      if (question.type === "multi") {
+        updateDoneState(question.id);
+      }
+    });
+
+    const text = document.createElement("span");
+    text.textContent = optionText;
+
+    label.appendChild(input);
+    label.appendChild(text);
+
+    return label;
+  }
+
   function createQuestionCard(question, index, badgeNumber) {
     const card = document.createElement("section");
     card.className = "question-card";
@@ -1523,6 +1774,8 @@
         list.appendChild(label);
       });
 
+      const generateMoreEl = createGenerateMoreUI(question, list);
+      if (generateMoreEl) list.appendChild(generateMoreEl);
 
       const otherLabel = document.createElement("label");
       otherLabel.className = "option-item option-other";
@@ -2368,7 +2621,8 @@
       }
     } catch (err) {
       if (!submitted) {
-        showSaveError("Failed to save interview");
+        const message = err instanceof Error ? err.message : String(err);
+        showSaveError(`Failed to save interview: ${message}`);
       }
       return false;
     }
@@ -2449,7 +2703,8 @@
       if (isNetworkError(err)) {
         showSessionExpired();
       } else {
-        showGlobalError("Failed to submit responses.");
+        const message = err instanceof Error ? err.message : String(err);
+        showGlobalError(`Failed to submit responses: ${message}`);
         submitBtn.disabled = false;
       }
     }

package/form/styles.css

@@ -1391,7 +1391,7 @@ button {
 .code-block pre {
   margin: 0;
   padding: 0.75rem;
-  overflow-x: auto;
+  overflow-x: hidden;
   line-height: 1.5;
 }
 
@@ -1404,7 +1404,8 @@ button {
 
 .code-block-lines-container {
   display: table;
-  min-width: 100%;
+  width: 100%;
+  table-layout: fixed;
 }
 
 .code-block-line {
@@ -1425,7 +1426,8 @@ button {
 
 .code-block-line-content {
   display: table-cell;
-  white-space: pre;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
   padding-right: 0.75rem;
 }
 
@@ -1710,6 +1712,106 @@ button {
   background: color-mix(in srgb, var(--card-accent, var(--accent)) 4%, var(--bg-elevated));
 }
 
+/* Generate more options */
+.generate-more {
+  margin: 4px 0 2px;
+}
+
+.generate-more-row {
+  display: flex;
+  gap: 6px;
+}
+
+.generate-more-btn {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  padding: 10px 14px;
+  border: 1px dashed var(--border-muted);
+  border-radius: 8px;
+  background: transparent;
+  color: var(--fg-dim);
+  font-family: var(--font-body);
+  font-size: var(--font-size-option);
+  cursor: pointer;
+  transition: border-color 150ms ease, color 150ms ease, background 150ms ease;
+}
+
+.generate-more-btn:hover {
+  border-color: color-mix(in srgb, var(--card-accent, var(--accent)) 50%, transparent);
+  color: var(--card-accent, var(--accent));
+  background: color-mix(in srgb, var(--card-accent, var(--accent)) 5%, transparent);
+}
+
+.generate-more-btn:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 2px var(--focus-ring);
+}
+
+.generate-more-icon {
+  font-size: 14px;
+  line-height: 1;
+}
+
+@keyframes generate-shimmer {
+  0% { background-position: 200% center; }
+  100% { background-position: -200% center; }
+}
+
+@keyframes generate-spin {
+  from { transform: rotate(0deg); }
+  to { transform: rotate(360deg); }
+}
+
+.generate-more-btn.loading {
+  border-style: solid;
+  border-color: color-mix(in srgb, var(--card-accent, var(--accent)) 30%, transparent);
+  color: var(--card-accent, var(--accent));
+  background: linear-gradient(
+    90deg,
+    transparent 0%,
+    color-mix(in srgb, var(--card-accent, var(--accent)) 8%, transparent) 40%,
+    color-mix(in srgb, var(--card-accent, var(--accent)) 15%, transparent) 50%,
+    color-mix(in srgb, var(--card-accent, var(--accent)) 8%, transparent) 60%,
+    transparent 100%
+  );
+  background-size: 200% 100%;
+  animation: generate-shimmer 2s ease-in-out infinite;
+}
+
+.generate-more-btn.loading .generate-more-icon {
+  animation: generate-spin 1.5s linear infinite;
+  display: inline-block;
+}
+
+.generate-more-btn:disabled:not(.loading) {
+  opacity: 0.4;
+  pointer-events: none;
+}
+
+.generate-more-status {
+  margin-top: 8px;
+  font-family: var(--font-mono);
+  font-size: 11px;
+  color: var(--fg-muted);
+}
+
+.generate-more-status.error {
+  color: var(--error);
+}
+
+/* Generated option entrance */
+@keyframes option-slide-in {
+  from { opacity: 0; transform: translateY(8px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+.option-item.generated {
+  animation: option-slide-in 0.25s ease-out backwards;
+}
+
 /* Side-by-side layout */
 .question-side-layout {
   display: grid;

package/index.ts

@@ -1,5 +1,5 @@
 import { Type } from "@sinclair/typebox";
-import { StringEnum } from "@mariozechner/pi-ai";
+import { StringEnum, complete, type Api, type AssistantMessage, type Model } from "@mariozechner/pi-ai";
 import { Text } from "@mariozechner/pi-tui";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import * as path from "node:path";
@@ -8,7 +8,7 @@ import * as fs from "node:fs";
 import { randomUUID } from "node:crypto";
 import { execSync, execFileSync } from "node:child_process";
 import { createRequire } from "node:module";
-import { startInterviewServer, getActiveSessions, type ResponseItem } from "./server.js";
+import { startInterviewServer, getActiveSessions, type ResponseItem, type InterviewServerCallbacks } from "./server.js";
 import { validateQuestions, sanitizeLLMJSON, type QuestionsFile } from "./schema.js";
 import { loadSettings, type InterviewThemeSettings } from "./settings.js";
 
@@ -232,7 +232,202 @@ function loadQuestions(questionsInput: string, cwd: string): SavedQuestionsFile
 	return validateQuestions(data);
 }
 
-function loadSavedInterview(html: string, filePath: string): SavedQuestionsFile {
+interface GenerateModelCandidate {
+	provider: string;
+	id: string;
+}
+
+const PREFERRED_GENERATE_MODELS = [
+	"anthropic/claude-haiku-4-5",
+	"google/gemini-2.5-flash",
+	"openai/gpt-4.1-mini",
+];
+
+const GENERATE_OPTIONS_SYSTEM_PROMPT =
+	"You generate interview answer options. Return only a JSON array of strings. Do not include explanations or markdown.";
+
+const REVIEW_QUESTION_SYSTEM_PROMPT =
+	"You review interview questions and answer options. Preserve intent. Return only JSON with a rewritten question string and an options array.";
+
+function formatModelRef(model: GenerateModelCandidate): string {
+	return `${model.provider}/${model.id}`;
+}
+
+function findModelByRef<T extends GenerateModelCandidate>(models: T[], modelRef: string): T | null {
+	for (const model of models) {
+		if (formatModelRef(model) === modelRef) {
+			return model;
+		}
+	}
+	return null;
+}
+
+export function selectGenerateModels<T extends GenerateModelCandidate>(
+	configuredModel: T | null,
+	currentModel: T | null,
+	availableModels: T[],
+): { primary: T | null; fallback: T | null } {
+	if (configuredModel) {
+		if (!currentModel || formatModelRef(currentModel) === formatModelRef(configuredModel)) {
+			return { primary: configuredModel, fallback: null };
+		}
+		return { primary: configuredModel, fallback: currentModel };
+	}
+
+	if (currentModel) {
+		return { primary: currentModel, fallback: null };
+	}
+
+	for (const modelRef of PREFERRED_GENERATE_MODELS) {
+		const preferredModel = findModelByRef(availableModels, modelRef);
+		if (preferredModel) {
+			return { primary: preferredModel, fallback: null };
+		}
+	}
+
+	return { primary: availableModels[0] ?? null, fallback: null };
+}
+
+export function extractGenerateResponseText(
+	modelRef: string,
+	response: Pick<AssistantMessage, "content" | "stopReason" | "errorMessage">,
+): string {
+	if (response.stopReason === "aborted") {
+		throw new Error("Aborted");
+	}
+	if (response.stopReason === "error") {
+		throw new Error(response.errorMessage ? `${modelRef}: ${response.errorMessage}` : `${modelRef} failed`);
+	}
+
+	const text = response.content
+		.filter((part): part is { type: "text"; text: string } => part.type === "text")
+		.map((part) => part.text)
+		.join("")
+		.trim();
+	if (!text) {
+		throw new Error(`${modelRef} returned no text response`);
+	}
+	return text;
+}
+
+function extractJSONBlock(text: string, openChar: "[" | "{", closeChar: "]" | "}"): string {
+	const start = text.indexOf(openChar);
+	if (start === -1) return text;
+
+	let depth = 0;
+	let inString = false;
+	let escaping = false;
+
+	for (let i = start; i < text.length; i++) {
+		const char = text[i];
+
+		if (inString) {
+			if (escaping) {
+				escaping = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaping = true;
+				continue;
+			}
+			if (char === '"') {
+				inString = false;
+			}
+			continue;
+		}
+
+		if (char === '"') {
+			inString = true;
+			continue;
+		}
+		if (char === openChar) {
+			depth++;
+			continue;
+		}
+		if (char !== closeChar) {
+			continue;
+		}
+
+		depth--;
+		if (depth === 0) {
+			return text.slice(start, i + 1);
+		}
+	}
+
+	return text;
+}
+
+export function extractJSONArray(text: string): string {
+	return extractJSONBlock(text, "[", "]");
+}
+
+function extractJSONObject(text: string): string {
+	return extractJSONBlock(text, "{", "}");
+}
+
+export function createGenerateContext(prompt: string, systemPrompt = GENERATE_OPTIONS_SYSTEM_PROMPT) {
+	return {
+		systemPrompt,
+		messages: [{
+			role: "user" as const,
+			content: [{ type: "text" as const, text: prompt }],
+			timestamp: Date.now(),
+		}],
+	};
+}
+
+function normalizeGeneratedOptions(parsed: unknown): string[] {
+	if (!Array.isArray(parsed)) {
+		throw new Error("Expected array of options");
+	}
+
+	const options = parsed
+		.filter(
+			(item: unknown): item is string =>
+				typeof item === "string" && item.trim().length > 0,
+		)
+		.map((option: string) => option.trim());
+	if (options.length === 0) {
+		throw new Error("No valid options generated");
+	}
+	return options;
+}
+
+export function parseGeneratedOptions(text: string): string[] {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(extractJSONArray(text));
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		throw new Error(`Failed to parse generated options: ${detail}`);
+	}
+	return normalizeGeneratedOptions(parsed);
+}
+
+export function parseReviewedQuestion(text: string): { question: string; options: string[] } {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(extractJSONObject(text));
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		throw new Error(`Failed to parse reviewed question: ${detail}`);
+	}
+	if (typeof parsed !== "object" || parsed === null) {
+		throw new Error("Expected reviewed question object");
+	}
+
+	const review = parsed as Record<string, unknown>;
+	if (typeof review.question !== "string" || !review.question.trim()) {
+		throw new Error("Reviewed question must include a non-empty question string");
+	}
+
+	return {
+		question: review.question.trim(),
+		options: normalizeGeneratedOptions(review.options),
+	};
+}
+
+export function loadSavedInterview(html: string, filePath: string): SavedQuestionsFile {
 	// Extract JSON from <script id="pi-interview-data">
 	const match = html.match(/<script[^>]+id=["']pi-interview-data["'][^>]*>([\s\S]*?)<\/script>/i);
 	if (!match) {
@@ -249,11 +444,13 @@ function loadSavedInterview(html: string, filePath: string): SavedQuestionsFile
 
 	const raw = data as Record<string, unknown>;
 	const validated = validateQuestions(data);
+	const questionTypeById = new Map(validated.questions.map((question) => [question.id, question.type]));
 
-	// Resolve relative image paths to absolute based on HTML file location
+	// Resolve relative image paths to absolute based on HTML file location.
+	// Only image-question values are treated as paths; text/single/multi values must stay literal.
 	const snapshotDir = path.dirname(filePath);
 	const savedAnswers = Array.isArray(raw.savedAnswers)
-		? resolveAnswerPaths(raw.savedAnswers as ResponseItem[], snapshotDir)
+		? resolveAnswerPaths(raw.savedAnswers as ResponseItem[], snapshotDir, questionTypeById)
 		: undefined;
 
 	// Validate savedFrom if present
@@ -279,26 +476,28 @@ function loadSavedInterview(html: string, filePath: string): SavedQuestionsFile
 	};
 }
 
-function resolveAnswerPaths(answers: ResponseItem[], baseDir: string): ResponseItem[] {
-	return answers.map((ans) => ({
-		...ans,
-		value: resolvePathValue(ans.value, baseDir),
-		attachments: ans.attachments?.map((p) => resolveImagePath(p, baseDir)),
-	}));
+function resolveAnswerPaths(
+	answers: ResponseItem[],
+	baseDir: string,
+	questionTypeById: Map<string, "single" | "multi" | "text" | "image" | "info">,
+): ResponseItem[] {
+	return answers.map((ans) => {
+		const questionType = questionTypeById.get(ans.id);
+		return {
+			...ans,
+			value: questionType === "image" ? resolvePathValue(ans.value, baseDir) : ans.value,
+			attachments: ans.attachments?.map((attachmentPath) => resolveImagePath(attachmentPath, baseDir)),
+		};
+	});
 }
 
 function resolveImagePath(p: string, baseDir: string): string {
 	if (!p) return p;
-	// Skip URLs
-	if (p.includes("://")) return p;
-	// Expand ~ first
+	// Skip URLs and data/file URIs
+	if (p.includes("://") || p.startsWith("data:") || p.startsWith("file:")) return p;
 	const expanded = expandHome(p);
-	// Don't resolve if already absolute (cross-platform check)
-	if (path.isAbsolute(expanded)) {
-		return expanded;
-	}
-	// Resolve relative path against snapshot directory
-	return path.join(baseDir, p);
+	if (path.isAbsolute(expanded)) return expanded;
+	return path.join(baseDir, expanded);
 }
 
 function resolvePathValue(value: string | string[], baseDir: string): string | string[] {
@@ -366,6 +565,8 @@ export default function (pi: ExtensionAPI) {
 			"Questions can have a codeBlock field to display code above options. Types: single (radio), multi (checkbox), text (textarea), image (file upload), info (non-interactive). " +
 			'Media blocks: { type: "image", src, alt, caption }, { type: "table", table: { headers, rows, highlights }, caption }, { type: "chart", chart: { type, data, options }, caption }, { type: "mermaid", mermaid: "graph LR\\n..." }, { type: "html", html }. ' +
 			"Info type is a non-interactive content panel for displaying context with media. Media position: above (default), below, side (two-column).",
+		promptSnippet:
+			"Gather structured user input through an interactive form for requirements, tradeoffs, or multi-dimensional decisions.",
 		parameters: InterviewParams,
 
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
@@ -395,6 +596,32 @@ export default function (pi: ExtensionAPI) {
 			const themeConfig = mergeThemeConfig(settings.theme, theme, ctx.cwd);
 			const questionsData = loadQuestions(questions, ctx.cwd);
 
+			let configuredGenerateModel: Model<Api> | null = null;
+			if (settings.generateModel) {
+				const slashIdx = settings.generateModel.indexOf("/");
+				if (slashIdx > 0) {
+					configuredGenerateModel = ctx.modelRegistry.find(
+						settings.generateModel.slice(0, slashIdx),
+						settings.generateModel.slice(slashIdx + 1),
+					);
+				}
+			}
+
+			let availableGenerateModels: Model<Api>[] = [];
+			if (!configuredGenerateModel && !ctx.model) {
+				try {
+					availableGenerateModels = ctx.modelRegistry.getAvailable();
+				} catch {
+					// Leave generation disabled when model discovery is unavailable.
+				}
+			}
+
+			const { primary: generateModel, fallback: fallbackGenerateModel } = selectGenerateModels(
+				configuredGenerateModel,
+				ctx.model ?? null,
+				availableGenerateModels,
+			);
+
 			// Expand ~ in snapshotDir if present
 			const snapshotDir = settings.snapshotDir
 				? expandHome(settings.snapshotDir)
@@ -469,6 +696,126 @@ export default function (pi: ExtensionAPI) {
 				};
 				signal?.addEventListener("abort", handleAbort, { once: true });
 
+				let onGenerate: InterviewServerCallbacks["onGenerate"];
+				if (generateModel) {
+					const generateOptions = async (model: Model<Api>, prompt: string, generateSignal: AbortSignal) => {
+						const modelRef = formatModelRef(model);
+						const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+						if (!auth.ok) throw new Error(`${modelRef}: ${auth.error}`);
+						if (!auth.apiKey) throw new Error(`No API key for ${modelRef}`);
+
+						const response = await complete(
+							model,
+							createGenerateContext(prompt),
+							{ apiKey: auth.apiKey, headers: auth.headers, signal: generateSignal },
+						);
+
+						return parseGeneratedOptions(extractGenerateResponseText(modelRef, response));
+					};
+
+					const reviewQuestion = async (model: Model<Api>, prompt: string, generateSignal: AbortSignal) => {
+						const modelRef = formatModelRef(model);
+						const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+						if (!auth.ok) throw new Error(`${modelRef}: ${auth.error}`);
+						if (!auth.apiKey) throw new Error(`No API key for ${modelRef}`);
+
+						const response = await complete(
+							model,
+							createGenerateContext(prompt, REVIEW_QUESTION_SYSTEM_PROMPT),
+							{ apiKey: auth.apiKey, headers: auth.headers, signal: generateSignal },
+						);
+
+						return parseReviewedQuestion(extractGenerateResponseText(modelRef, response));
+					};
+
+					onGenerate = async (questionId, existingOptions, generateSignal, mode) => {
+						const question = questionsData.questions.find((q) => q.id === questionId);
+						if (!question) throw new Error(`Unknown question: ${questionId}`);
+
+						const existingList = existingOptions.length > 0
+							? existingOptions.map((option) => `- ${option}`).join("\n")
+							: "(none)";
+
+						let prompt: string;
+						if (mode === "review") {
+							let recommended = "";
+							if (question.recommended) {
+								const value = Array.isArray(question.recommended)
+									? question.recommended.join(", ")
+									: question.recommended;
+								recommended = `\nRecommended: ${value}`;
+							}
+							prompt = [
+								"Review this interview question and its options.",
+								"Rewrite the question so it is easier to understand while preserving the original intent.",
+								"Review the options the same way you already would: keep good ones as-is, fix bad ones, add missing ones, and remove bad ones.",
+								"Return ONLY JSON in this format:",
+								'{"question":"Clearer question text","options":["Option A","Option B","Option C"]}',
+								"",
+								questionsData.title ? `Interview: ${questionsData.title}` : null,
+								questionsData.description ? `Interview context: ${questionsData.description}` : null,
+								`Question: ${question.question}`,
+								question.context ? `Question context: ${question.context}` : null,
+								recommended || null,
+								"",
+								"Current options:",
+								existingList,
+							].filter((line) => line !== null).join("\n");
+						} else {
+							prompt = [
+								"Generate 3 new, distinct options for this question.",
+								"Return ONLY a JSON array of short option strings. No explanation, no markdown.",
+								"",
+								`Question: ${question.question}`,
+								question.context ? `Context: ${question.context}` : null,
+								"",
+								"Existing options (do NOT repeat):",
+								existingList,
+								"",
+								'Format: ["Option A", "Option B", "Option C"]',
+							].filter((line) => line !== null).join("\n");
+						}
+
+						if (mode === "review") {
+							let result: { question: string; options: string[] };
+							try {
+								result = await reviewQuestion(generateModel, prompt, generateSignal);
+							} catch (err) {
+								if (!fallbackGenerateModel || generateSignal.aborted) {
+									throw err;
+								}
+								try {
+									result = await reviewQuestion(fallbackGenerateModel, prompt, generateSignal);
+								} catch (fallbackErr) {
+									const primaryMessage = err instanceof Error ? err.message : String(err);
+									const fallbackMessage = fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr);
+									throw new Error(`${primaryMessage}. Fallback failed: ${fallbackMessage}`);
+								}
+							}
+
+							return result;
+						}
+
+						let options: string[];
+						try {
+							options = await generateOptions(generateModel, prompt, generateSignal);
+						} catch (err) {
+							if (!fallbackGenerateModel || generateSignal.aborted) {
+								throw err;
+							}
+							try {
+								options = await generateOptions(fallbackGenerateModel, prompt, generateSignal);
+							} catch (fallbackErr) {
+								const primaryMessage = err instanceof Error ? err.message : String(err);
+								const fallbackMessage = fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr);
+								throw new Error(`${primaryMessage}. Fallback failed: ${fallbackMessage}`);
+							}
+						}
+
+						return { options };
+					};
+				}
+
 				startInterviewServer(
 					{
 						questions: questionsData,
@@ -482,6 +829,7 @@ export default function (pi: ExtensionAPI) {
 						snapshotDir,
 						autoSaveOnSubmit: settings.autoSaveOnSubmit ?? true,
 						savedAnswers: questionsData.savedAnswers,
+						canGenerate: generateModel !== null,
 					},
 					{
 						onSubmit: (responses) => finish("completed", responses),
@@ -489,6 +837,7 @@ export default function (pi: ExtensionAPI) {
 							reason === "timeout"
 								? finish("timeout", partialResponses ?? [])
 								: finish("cancelled", partialResponses ?? [], reason),
+						onGenerate,
 					}
 				)
 					.then(async (handle) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-interview",
-  "version": "0.5.5",
+  "version": "0.6.1",
   "description": "Interactive interview form extension for pi coding agent",
   "author": "Nico Bailon",
   "license": "MIT",

package/server.ts

@@ -196,11 +196,18 @@ export interface InterviewServerOptions {
 	snapshotDir?: string;
 	autoSaveOnSubmit?: boolean;
 	savedAnswers?: ResponseItem[];
+	canGenerate?: boolean;
 }
 
 export interface InterviewServerCallbacks {
 	onSubmit: (responses: ResponseItem[]) => void;
 	onCancel: (reason?: "timeout" | "user" | "stale", partialResponses?: ResponseItem[]) => void;
+	onGenerate?: (
+		questionId: string,
+		existingOptions: string[],
+		signal: AbortSignal,
+		mode: "add" | "review",
+	) => Promise<{ options: string[]; question?: string }>;
 }
 
 export interface InterviewServerHandle {
@@ -380,6 +387,35 @@ function ensureQuestionId(
 	return { ok: true, question };
 }
 
+function syncRecommendations(question: Question, options: string[]): void {
+	if (!question.recommended) return;
+
+	if (question.type === "single") {
+		if (typeof question.recommended === "string" && options.includes(question.recommended)) {
+			return;
+		}
+		delete question.recommended;
+		delete question.conviction;
+		return;
+	}
+
+	if (question.type !== "multi") {
+		delete question.recommended;
+		delete question.conviction;
+		return;
+	}
+
+	const nextRecommended = (Array.isArray(question.recommended)
+		? question.recommended
+		: [question.recommended]).filter((option) => options.includes(option));
+	if (nextRecommended.length === 0) {
+		delete question.recommended;
+		delete question.conviction;
+		return;
+	}
+	question.recommended = nextRecommended;
+}
+
 // HTML generation for saved interviews
 interface SavedFromMeta {
 	cwd: string;
@@ -882,6 +918,7 @@ export async function startInterviewServer(
 					},
 					savedAnswers: options.savedAnswers,
 					autoSaveOnSubmit: options.autoSaveOnSubmit ?? true,
+					canGenerate: options.canGenerate ?? false,
 				});
 				const html = TEMPLATE
 					.replace("<!-- __CDN_SCRIPTS__ -->", cdnScripts)
@@ -1250,9 +1287,7 @@ export async function startInterviewServer(
 				}
 
 				// Copy local media images to snapshot and rewrite paths
-				const rewrittenQuestions = await copyMediaImages(
-					questions.questions, imagesPath, cwd
-				);
+				const rewrittenQuestions = await copyMediaImages(questions.questions, imagesPath, cwd);
 				const snapshotQuestions: QuestionsFile = {
 					...questions,
 					questions: rewrittenQuestions,
@@ -1283,6 +1318,100 @@ export async function startInterviewServer(
 				return;
 			}
 
+			if (method === "POST" && url.pathname === "/generate") {
+				const body = await parseBodyOrRespond();
+				if (!body) return;
+				if (!validateTokenBody(body, sessionToken, res)) return;
+				if (completed) {
+					sendJson(res, 409, { ok: false, error: "Session closed" });
+					return;
+				}
+
+				if (!callbacks.onGenerate) {
+					sendJson(res, 501, { ok: false, error: "Generation not available" });
+					return;
+				}
+
+				const payload = body as {
+					questionId?: string;
+					existingOptions?: string[];
+					mode?: string;
+				};
+
+				if (typeof payload.questionId !== "string") {
+					sendJson(res, 400, { ok: false, error: "Missing questionId" });
+					return;
+				}
+
+				const question = questionById.get(payload.questionId);
+				if (!question || (question.type !== "single" && question.type !== "multi")) {
+					sendJson(res, 400, { ok: false, error: "Invalid question for generation" });
+					return;
+				}
+				if (question.options.some((option) => typeof option !== "string")) {
+					sendJson(res, 400, { ok: false, error: "Generation is not available for rich options" });
+					return;
+				}
+
+				const existingOptions = Array.isArray(payload.existingOptions)
+					? payload.existingOptions.filter((o): o is string => typeof o === "string")
+					: [];
+
+				const mode = payload.mode === "review" ? "review" : "add";
+
+				const controller = new AbortController();
+				res.on("close", () => {
+					if (!res.writableEnded) controller.abort();
+				});
+				touchHeartbeat();
+
+				try {
+					const result = await callbacks.onGenerate(
+						payload.questionId,
+						existingOptions,
+						controller.signal,
+						mode,
+					);
+
+					const uniqueOptions: string[] = [];
+					const seenOptions = new Set<string>();
+					for (const option of result.options) {
+						const trimmed = option.trim();
+						if (!trimmed) continue;
+						const key = trimmed.toLowerCase();
+						if (seenOptions.has(key)) continue;
+						seenOptions.add(key);
+						uniqueOptions.push(trimmed);
+					}
+
+					const reviewedQuestion = typeof result.question === "string" ? result.question.trim() : undefined;
+					const storedQuestion = questions.questions.find((q) => q.id === payload.questionId);
+					if (storedQuestion) {
+						if (mode === "review" && reviewedQuestion && uniqueOptions.length > 0) {
+							storedQuestion.question = reviewedQuestion;
+							storedQuestion.options = uniqueOptions;
+							syncRecommendations(storedQuestion, uniqueOptions);
+						} else if (mode === "add") {
+							const existingKeys = new Set(existingOptions.map((option) => option.trim().toLowerCase()));
+							const newOptions = uniqueOptions.filter((option) => !existingKeys.has(option.toLowerCase()));
+							if (newOptions.length > 0) {
+								storedQuestion.options = storedQuestion.options.concat(newOptions);
+							}
+						}
+					}
+
+					sendJson(res, 200, { ok: true, options: uniqueOptions, question: reviewedQuestion });
+				} catch (err) {
+					if (controller.signal.aborted) {
+						sendJson(res, 409, { ok: false, error: "Request cancelled" });
+						return;
+					}
+					const message = err instanceof Error ? err.message : "Generation failed";
+					sendJson(res, 500, { ok: false, error: message });
+				}
+				return;
+			}
+
 			sendText(res, 404, "Not found");
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Server error";

package/settings.ts

@@ -19,6 +19,7 @@ export interface InterviewSettings {
 	theme?: InterviewThemeSettings;
 	snapshotDir?: string;      // Default: ~/.pi/interview-snapshots/
 	autoSaveOnSubmit?: boolean; // Default: true
+	generateModel?: string;    // e.g., "anthropic/claude-haiku-4-5"
 }
 
 export function loadSettings(): InterviewSettings {