pi-simocracy 0.1.1 → 0.2.0

package/src/training/baseline.ts

@@ -0,0 +1,159 @@
+/**
+ * `/sim train baseline` — vote yes/no/abstain on the loaded sim's
+ * baseline proposals, with importance + optional reasoning.
+ *
+ * Web parity: `simocracy-v2/components/sim/training-lab/baseline-tab.tsx`.
+ */
+
+import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+
+import type { LoadedSim } from "../persona.ts";
+import {
+  loadTrainingLabState,
+  saveTrainingLabState,
+} from "./storage.ts";
+import {
+  pickInterviewTemplate,
+  questionSetFromTemplate,
+} from "./question-set.ts";
+import type { BaselineProposal, BaselineVote, Vote } from "./types.ts";
+
+const IMPORTANCE_OPTIONS: Array<{ label: string; value: number }> = [
+  { label: "Negligible (0.1)", value: 0.1 },
+  { label: "Low (0.3)", value: 0.3 },
+  { label: "Medium (0.5)", value: 0.5 },
+  { label: "High (0.7)", value: 0.7 },
+  { label: "Critical (0.9)", value: 0.9 },
+];
+
+const VOTE_OPTIONS: Array<{ label: string; value: Vote | "skip" }> = [
+  { label: "Yes — agree", value: "yes" },
+  { label: "No — disagree", value: "no" },
+  { label: "Abstain — uncertain", value: "abstain" },
+  { label: "Skip — don't vote on this one", value: "skip" },
+];
+
+export async function runBaseline(
+  ctx: ExtensionCommandContext,
+  loadedSim: LoadedSim,
+): Promise<void> {
+  let state = loadTrainingLabState(loadedSim.rkey);
+
+  // Bootstrap or refresh the question set if missing.
+  if (!state.questionSet || state.questionSet.proposals.length === 0) {
+    const picked = await pickInterviewTemplate(ctx);
+    if (!picked) {
+      ctx.ui.notify("Cancelled.", "info");
+      return;
+    }
+    state = {
+      ...state,
+      questionSet: questionSetFromTemplate(picked.template, picked.uri),
+      profile: null,
+      alignment: null,
+    };
+    saveTrainingLabState(loadedSim.rkey, state);
+  }
+
+  const proposals = state.questionSet?.proposals ?? [];
+  if (proposals.length === 0) {
+    ctx.ui.notify("Picked template has no yes/no questions — nothing to vote on.", "warning");
+    return;
+  }
+
+  ctx.ui.notify(
+    `Voting on ${proposals.length} baseline proposals for ${loadedSim.name}. Cancel any prompt to stop early.`,
+    "info",
+  );
+
+  for (let i = 0; i < proposals.length; i++) {
+    const proposal = proposals[i];
+    const existing = state.baselineVotes.find((v) => v.proposalId === proposal.id);
+    const answer = await askVote(ctx, proposal, i, proposals.length, existing);
+    if (answer === null) {
+      ctx.ui.notify("Stopped — votes saved up to this point.", "info");
+      break;
+    }
+    state = {
+      ...state,
+      baselineVotes: recordBaselineVote(state.baselineVotes, proposal.id, answer),
+      // Re-distilling and alignment depend on the votes — clear when votes change.
+      profile: null,
+      alignment: null,
+    };
+    saveTrainingLabState(loadedSim.rkey, state);
+  }
+
+  const cast = state.baselineVotes.filter(
+    (v) => !(v.vote === "abstain" && Math.abs(v.importance - 0.5) < 0.01 && !v.reasoning),
+  ).length;
+  ctx.ui.notify(
+    `Saved ${cast} baseline votes. Run \`/sim train chat\` next, then \`/sim train profile\`.`,
+    "info",
+  );
+}
+
+interface AnsweredVote {
+  vote: Vote;
+  importance: number;
+  reasoning: string;
+}
+
+async function askVote(
+  ctx: ExtensionCommandContext,
+  proposal: BaselineProposal,
+  index: number,
+  total: number,
+  existing: BaselineVote | undefined,
+): Promise<AnsweredVote | null> {
+  const header = existing
+    ? `[${index + 1}/${total}] ${proposal.title} (current: ${existing.vote.toUpperCase()})`
+    : `[${index + 1}/${total}] ${proposal.title}`;
+
+  const voteLabel = await ctx.ui.select(header, VOTE_OPTIONS.map((o) => o.label));
+  if (!voteLabel) return null;
+  const voteEntry = VOTE_OPTIONS.find((o) => o.label === voteLabel);
+  if (!voteEntry) return null;
+
+  // Skip leaves the abstain default at importance 0.5 with no reasoning,
+  // which the prompt-helpers' renderer treats as untouched.
+  if (voteEntry.value === "skip") {
+    return { vote: "abstain", importance: 0.5, reasoning: "" };
+  }
+
+  const importanceLabel = await ctx.ui.select(
+    "How important is this to you?",
+    IMPORTANCE_OPTIONS.map((o) => o.label),
+  );
+  if (!importanceLabel) return null;
+  const importance =
+    IMPORTANCE_OPTIONS.find((o) => o.label === importanceLabel)?.value ?? 0.5;
+
+  const reasoning = await ctx.ui.input(
+    "Optional reasoning (Enter to skip)",
+    `Why did you vote ${voteEntry.value}?`,
+  );
+
+  return {
+    vote: voteEntry.value,
+    importance,
+    reasoning: (reasoning ?? "").trim(),
+  };
+}
+
+function recordBaselineVote(
+  votes: BaselineVote[],
+  proposalId: string,
+  next: AnsweredVote,
+): BaselineVote[] {
+  const without = votes.filter((v) => v.proposalId !== proposalId);
+  return [
+    ...without,
+    {
+      proposalId,
+      vote: next.vote,
+      importance: next.importance,
+      reasoning: next.reasoning,
+    },
+  ];
+}

package/src/training/chat.ts

@@ -0,0 +1,131 @@
+/**
+ * `/sim train chat` — adaptive interview turn loop.
+ *
+ * Mirrors `/api/training/next-question` from simocracy-v2 but calls
+ * OpenRouter directly (no pi loop / persona injection). End the chat
+ * by typing `/done` (or cancelling the prompt).
+ */
+
+import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+
+import type { LoadedSim } from "../persona.ts";
+import { openRouterComplete, TRAINING_CHAT_MODEL } from "../openrouter.ts";
+import {
+  loadTrainingLabState,
+  saveTrainingLabState,
+} from "./storage.ts";
+import {
+  clampConstitution,
+  clampTranscript,
+  renderBaselineForPrompt,
+  wrapAsData,
+} from "./prompt-helpers.ts";
+import { buildNextQuestionSystemPrompt } from "./prompts.ts";
+import type { InterviewTurn } from "./types.ts";
+
+export async function runChat(
+  ctx: ExtensionCommandContext,
+  loadedSim: LoadedSim,
+): Promise<void> {
+  let state = loadTrainingLabState(loadedSim.rkey);
+  const proposals = state.questionSet?.proposals ?? [];
+
+  if (proposals.length === 0) {
+    ctx.ui.notify(
+      "Run `/sim train baseline` first — chat needs a baseline questionnaire to ground its questions.",
+      "warning",
+    );
+    return;
+  }
+
+  ctx.ui.notify(
+    `Chatting with ${loadedSim.name}. Type /done to end the conversation.`,
+    "info",
+  );
+
+  // Always print the existing transcript so the user has context.
+  if (state.interviewTurns.length > 0) {
+    ctx.ui.notify(
+      `Loaded ${state.interviewTurns.length} prior turns from disk.`,
+      "info",
+    );
+  }
+
+  // Prime the assistant with the first question if the transcript is empty.
+  if (state.interviewTurns.length === 0) {
+    const reply = await callNextQuestion(loadedSim, state.interviewTurns, state, proposals);
+    if (reply) {
+      console.log(`\n${loadedSim.name}: ${reply}\n`);
+      state = appendTurn(state, { role: "assistant", content: reply });
+      saveTrainingLabState(loadedSim.rkey, state);
+    }
+  }
+
+  for (;;) {
+    const userMessage = await ctx.ui.input(
+      `Reply to ${loadedSim.name} (or /done to finish)`,
+      "Your reply",
+    );
+    if (userMessage === undefined) break;
+    const trimmed = userMessage.trim();
+    if (!trimmed) continue;
+    if (trimmed === "/done" || trimmed === "/exit" || trimmed === "/quit") break;
+
+    state = appendTurn(state, { role: "user", content: trimmed });
+    saveTrainingLabState(loadedSim.rkey, state);
+
+    let reply: string;
+    try {
+      reply = await callNextQuestion(loadedSim, state.interviewTurns, state, proposals);
+    } catch (err) {
+      ctx.ui.notify(`OpenRouter error: ${(err as Error).message}`, "error");
+      break;
+    }
+    if (!reply) {
+      ctx.ui.notify("Empty model response. Try again or /done.", "warning");
+      continue;
+    }
+    console.log(`\n${loadedSim.name}: ${reply}\n`);
+    state = appendTurn(state, { role: "assistant", content: reply });
+    saveTrainingLabState(loadedSim.rkey, state);
+  }
+
+  ctx.ui.notify(
+    `Saved ${state.interviewTurns.length} turns. Run \`/sim train profile\` to distill.`,
+    "info",
+  );
+}
+
+async function callNextQuestion(
+  loadedSim: LoadedSim,
+  transcript: InterviewTurn[],
+  state: ReturnType<typeof loadTrainingLabState>,
+  proposals: { id: string; title: string; summary: string; topic: string }[],
+): Promise<string> {
+  const system = buildNextQuestionSystemPrompt(loadedSim.name, loadedSim.style);
+  const constitution = clampConstitution(loadedSim.description);
+  const baseline = renderBaselineForPrompt(state.baselineVotes, proposals);
+  const clamped = clampTranscript(transcript);
+
+  const userPrompt = [
+    `simName: ${loadedSim.name}`,
+    wrapAsData("existingConstitution", constitution),
+    wrapAsData("baselineQuestionnaire", baseline),
+    wrapAsData("transcript", JSON.stringify(clamped, null, 2)),
+  ].join("\n\n");
+
+  return openRouterComplete(
+    [
+      { role: "system", content: system },
+      { role: "user", content: userPrompt },
+    ],
+    { model: TRAINING_CHAT_MODEL, maxTokens: 600, temperature: 0.6 },
+  );
+}
+
+function appendTurn<T extends { interviewTurns: InterviewTurn[] }>(
+  state: T,
+  turn: InterviewTurn,
+): T {
+  return { ...state, interviewTurns: [...state.interviewTurns, turn] };
+}

package/src/training/feedback.ts

@@ -0,0 +1,81 @@
+/**
+ * `/sim train feedback` — free-form chat with the loaded sim about
+ * its constitution. Same pattern as `/sim train chat` but uses the
+ * regular sim persona prompt (`buildSimPrompt`) — i.e., the sim
+ * speaks in character — so the user gets real feedback on how the
+ * sim sounds, then can use the transcript to inform an Apply step.
+ *
+ * Web parity: `simocracy-v2/components/sim/training-lab/feedback-tab.tsx`.
+ */
+
+import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+
+import { buildSimPrompt, type LoadedSim } from "../persona.ts";
+import { openRouterComplete, TRAINING_CHAT_MODEL } from "../openrouter.ts";
+import {
+  loadTrainingLabState,
+  saveTrainingLabState,
+} from "./storage.ts";
+import type { FeedbackTurn } from "./types.ts";
+
+export async function runFeedback(
+  ctx: ExtensionCommandContext,
+  loadedSim: LoadedSim,
+): Promise<void> {
+  let state = loadTrainingLabState(loadedSim.rkey);
+  let turns: FeedbackTurn[] = state.feedbackTurns ?? [];
+
+  ctx.ui.notify(
+    `Free-form chat with ${loadedSim.name}. Type /done to end. Transcript persists for the Apply step.`,
+    "info",
+  );
+  if (turns.length > 0) {
+    ctx.ui.notify(`Loaded ${turns.length} prior feedback turns from disk.`, "info");
+  }
+
+  for (;;) {
+    const userMessage = await ctx.ui.input(
+      `Ask ${loadedSim.name} (or /done to finish)`,
+      "Your message",
+    );
+    if (userMessage === undefined) break;
+    const trimmed = userMessage.trim();
+    if (!trimmed) continue;
+    if (trimmed === "/done" || trimmed === "/exit" || trimmed === "/quit") break;
+
+    turns = [...turns, { role: "user", content: trimmed }];
+    state = { ...state, feedbackTurns: turns };
+    saveTrainingLabState(loadedSim.rkey, state);
+
+    let reply: string;
+    try {
+      reply = await callSimChat(loadedSim, turns);
+    } catch (err) {
+      ctx.ui.notify(`OpenRouter error: ${(err as Error).message}`, "error");
+      break;
+    }
+    if (!reply) {
+      ctx.ui.notify("Empty model response. Try again or /done.", "warning");
+      continue;
+    }
+    console.log(`\n${loadedSim.name}: ${reply}\n`);
+    turns = [...turns, { role: "assistant", content: reply }];
+    state = { ...state, feedbackTurns: turns };
+    saveTrainingLabState(loadedSim.rkey, state);
+  }
+
+  ctx.ui.notify(`Saved ${turns.length} feedback turns.`, "info");
+}
+
+async function callSimChat(loadedSim: LoadedSim, turns: FeedbackTurn[]): Promise<string> {
+  const systemPrompt = buildSimPrompt(loadedSim);
+  const messages = [
+    { role: "system" as const, content: systemPrompt },
+    ...turns.map((t) => ({ role: t.role, content: t.content })),
+  ];
+  return openRouterComplete(messages, {
+    model: TRAINING_CHAT_MODEL,
+    maxTokens: 600,
+    temperature: 0.7,
+  });
+}

package/src/training/index.ts

@@ -0,0 +1,142 @@
+/**
+ * `/sim train …` command dispatcher.
+ *
+ * Sub-commands mirror the five tabs of the Training Lab in
+ * simocracy-v2 plus `status` / `reset`. Run `/sim train` (no arg) for
+ * usage. All flows operate on the currently-loaded sim and persist
+ * state to `~/.local/share/pi-simocracy/training/<rkey>.json`.
+ */
+
+import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+
+import type { LoadedSim } from "../persona.ts";
+import { runBaseline } from "./baseline.ts";
+import { runChat } from "./chat.ts";
+import { runProfile } from "./profile.ts";
+import { runFeedback } from "./feedback.ts";
+import { runAlignment } from "./alignment.ts";
+import { runApply } from "./apply.ts";
+import {
+  clearTrainingLabState,
+  loadTrainingLabState,
+  trainingFilePath,
+} from "./storage.ts";
+
+const HELP = [
+  "Usage: /sim train <subcommand>",
+  "",
+  "  baseline   Vote yes/no/abstain on the loaded sim's baseline proposals.",
+  "  chat       Adaptive interview with the sim — fill gaps in your stance.",
+  "  profile    Distill baseline + transcript into a TrainingProfile.",
+  "  feedback   Free-form chat with the sim about its constitution.",
+  "  alignment  Score the sim against your hidden baseline votes.",
+  "  apply      Merge the profile into the constitution (clipboard copy in PR 2).",
+  "  status     Print local state path + counts.",
+  "  reset      Delete local training data for this sim.",
+].join("\n");
+
+export async function runTrainCommand(
+  ctx: ExtensionCommandContext,
+  arg: string,
+  loadedSim: LoadedSim | null,
+): Promise<void> {
+  const tokens = arg.trim().split(/\s+/).filter(Boolean);
+  const sub = tokens[0] ?? "";
+  const flags = new Set(tokens.slice(1));
+
+  if (!sub || sub === "help" || sub === "--help") {
+    ctx.ui.notify(HELP, "info");
+    return;
+  }
+
+  if (sub === "status") {
+    await runStatus(ctx, loadedSim);
+    return;
+  }
+  if (sub === "reset") {
+    await runReset(ctx, loadedSim);
+    return;
+  }
+
+  if (!loadedSim) {
+    ctx.ui.notify(
+      "No sim loaded. Run `/sim <name>` first, then `/sim train …`.",
+      "error",
+    );
+    return;
+  }
+
+  switch (sub) {
+    case "baseline":
+      await runBaseline(ctx, loadedSim);
+      return;
+    case "chat":
+      await runChat(ctx, loadedSim);
+      return;
+    case "profile":
+      await runProfile(ctx, loadedSim);
+      return;
+    case "feedback":
+      await runFeedback(ctx, loadedSim);
+      return;
+    case "alignment":
+      await runAlignment(ctx, loadedSim);
+      return;
+    case "apply":
+      await runApply(ctx, loadedSim, { apply: flags.has("--apply") });
+      return;
+    default:
+      ctx.ui.notify(`Unknown subcommand: ${sub}\n\n${HELP}`, "error");
+      return;
+  }
+}
+
+async function runStatus(
+  ctx: ExtensionCommandContext,
+  loadedSim: LoadedSim | null,
+): Promise<void> {
+  if (!loadedSim) {
+    ctx.ui.notify("No sim loaded.", "info");
+    return;
+  }
+  const path = trainingFilePath(loadedSim.rkey);
+  const state = loadTrainingLabState(loadedSim.rkey);
+  const cast = state.baselineVotes.filter(
+    (v) => !(v.vote === "abstain" && Math.abs(v.importance - 0.5) < 0.01 && !v.reasoning),
+  ).length;
+  const lines = [
+    `Sim:        ${loadedSim.name} (${loadedSim.uri})`,
+    `State file: ${path}`,
+    `Updated:    ${state.updatedAt}`,
+    `Baseline:   ${cast}/${state.baselineVotes.length} cast votes`,
+    `Interview:  ${state.interviewTurns.length} turns`,
+    `Feedback:   ${(state.feedbackTurns ?? []).length} turns`,
+    `Profile:    ${state.profile ? "yes" : "no"}`,
+    `Alignment:  ${state.alignment ? `${state.alignment.matchedCount}/${state.alignment.totalCount}` : "no"}`,
+    `Question set: ${state.questionSet?.source === "template" ? state.questionSet.templateName : "(none)"}`,
+  ];
+  console.log("\n" + lines.join("\n") + "\n");
+}
+
+async function runReset(
+  ctx: ExtensionCommandContext,
+  loadedSim: LoadedSim | null,
+): Promise<void> {
+  if (!loadedSim) {
+    ctx.ui.notify("No sim loaded.", "info");
+    return;
+  }
+  const confirmed = await ctx.ui.confirm(
+    "Reset training data?",
+    `Delete all local training data for ${loadedSim.name}?`,
+  );
+  if (!confirmed) {
+    ctx.ui.notify("Cancelled.", "info");
+    return;
+  }
+  const removed = clearTrainingLabState(loadedSim.rkey);
+  ctx.ui.notify(
+    removed ? `Training data reset for ${loadedSim.name}.` : "No training data on disk.",
+    "info",
+  );
+}