pi-simocracy 0.1.1 → 0.2.0

package/src/simocracy.ts

@@ -10,6 +10,7 @@ const DEFAULT_INDEXER_URL = "https://simocracy-indexer-production.up.railway.app
 const COLLECTION_SIM = "org.simocracy.sim";
 const COLLECTION_AGENTS = "org.simocracy.agents";
 const COLLECTION_STYLE = "org.simocracy.style";
+const COLLECTION_INTERVIEW_TEMPLATE = "org.simocracy.interviewTemplate";
 
 export interface SpriteSettings {
   selectedOptions: Record<string, string>;
@@ -253,6 +254,37 @@ export async function listRecordsFromPds<T>(did: string, collection: string): Pr
   return out;
 }
 
+/**
+ * List every `org.simocracy.sim` record owned by `did`, mapped onto the
+ * same `SimMatch` shape that `searchSimsByName` produces so the rest of
+ * the extension's load/hydrate pipeline accepts these without a second
+ * code path. Sorted by `createdAt` descending (most recently created
+ * first), since that's how simocracy.org's My Sims carousel surfaces
+ * them and it's the most useful ordering when the user types `/sim my 1`.
+ */
+export async function fetchSimsForDid(did: string): Promise<SimMatch[]> {
+  const records = await listRecordsFromPds<SimRecord>(did, COLLECTION_SIM);
+  return records
+    .filter((r) => r.value && typeof r.value.name === "string")
+    .map((r) => {
+      const rkey = r.uri.split("/").pop() ?? "";
+      return {
+        uri: r.uri,
+        cid: r.cid,
+        did,
+        rkey,
+        sim: r.value,
+      } satisfies SimMatch;
+    })
+    .sort((a, b) => {
+      // Most recent first; fall back to rkey (TIDs are roughly monotonic).
+      const ta = a.sim.createdAt || "";
+      const tb = b.sim.createdAt || "";
+      if (ta && tb) return tb.localeCompare(ta);
+      return b.rkey.localeCompare(a.rkey);
+    });
+}
+
 /** Find the agents record for a sim by scanning the owner's PDS (sim-1:1-agents). */
 export async function fetchAgentsForSim(simUri: string): Promise<AgentsRecord | null> {
   const { did } = parseAtUri(simUri);
@@ -275,6 +307,95 @@ export async function fetchStyleForSim(simUri: string): Promise<StyleRecord | nu
   }
 }
 
+// ---------------------------------------------------------------------------
+// Interview templates (org.simocracy.interviewTemplate)
+// ---------------------------------------------------------------------------
+
+export interface InterviewQuestionRecord {
+  id: string;
+  type: "open" | "text" | "yesNo";
+  prompt: string;
+  required?: boolean;
+}
+
+export interface InterviewTemplateValue {
+  $type: "org.simocracy.interviewTemplate";
+  name: string;
+  description?: string;
+  questions: InterviewQuestionRecord[];
+  createdAt: string;
+}
+
+export interface LoadedInterviewTemplate {
+  uri: string;
+  cid: string;
+  did: string;
+  rkey: string;
+  template: InterviewTemplateValue;
+}
+
+/**
+ * List interview templates from the Simocracy indexer. Mirrors
+ * `fetchInterviewTemplates` in simocracy-v2's `lib/indexer.ts` (sans
+ * the PDS fallback against the facilitator — pi-simocracy doesn't
+ * know the facilitator DID, and an empty list is a soft failure
+ * handled by the caller via the built-in fallback template).
+ */
+export async function searchInterviewTemplates(
+  limit = 100,
+  opts: { indexerUrl?: string } = {},
+): Promise<LoadedInterviewTemplate[]> {
+  const indexerUrl = opts.indexerUrl ?? DEFAULT_INDEXER_URL;
+  const results: LoadedInterviewTemplate[] = [];
+  let cursor: string | null = null;
+  for (let page = 0; page < 10 && results.length < limit; page++) {
+    const { nodes, hasNextPage, endCursor } = await fetchRecords(
+      COLLECTION_INTERVIEW_TEMPLATE,
+      Math.min(100, limit - results.length),
+      cursor,
+      indexerUrl,
+    );
+    for (const node of nodes) {
+      const value = node.value as unknown as InterviewTemplateValue;
+      if (!value?.name || !Array.isArray(value.questions)) continue;
+      results.push({
+        uri: node.uri,
+        cid: node.cid,
+        did: node.did,
+        rkey: node.rkey,
+        template: value,
+      });
+    }
+    if (!hasNextPage || !endCursor) break;
+    cursor = endCursor;
+  }
+  return results;
+}
+
+/**
+ * Fetch a single interview template directly from the owner's PDS by
+ * AT-URI. Returns null on any failure — callers fall through to the
+ * built-in template.
+ */
+export async function fetchInterviewTemplateByUri(
+  templateUri: string,
+): Promise<LoadedInterviewTemplate | null> {
+  try {
+    const { did, collection, rkey } = parseAtUri(templateUri);
+    if (collection !== COLLECTION_INTERVIEW_TEMPLATE) return null;
+    const value = await getRecordFromPds<InterviewTemplateValue>(did, collection, rkey);
+    return {
+      uri: templateUri,
+      cid: "",
+      did,
+      rkey,
+      template: value,
+    };
+  } catch {
+    return null;
+  }
+}
+
 /** Resolve handle of a DID via Bluesky AppView (best-effort). */
 export async function resolveHandle(did: string): Promise<string | null> {
   try {

package/src/training/alignment.ts

@@ -0,0 +1,259 @@
+/**
+ * `/sim train alignment` — score the sim against the user's hidden
+ * baseline votes. Mirrors `/api/training/alignment-test` from
+ * simocracy-v2.
+ *
+ * Calls the alignment prompt once per proposal with concurrency 4,
+ * then prints a per-proposal table + overall match percentage and
+ * weak-area summary.
+ */
+
+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, wrapAsData } from "./prompt-helpers.ts";
+import { TRAINING_ALIGNMENT_TEST_SYSTEM_PROMPT } from "./prompts.ts";
+import { bar } from "./profile.ts";
+import type {
+  AlignmentResult,
+  BaselineProposal,
+  TrainingProfile,
+  Vote,
+} from "./types.ts";
+
+const MIN_VOTES = 5;
+const CONCURRENCY = 4;
+
+export async function runAlignment(
+  ctx: ExtensionCommandContext,
+  loadedSim: LoadedSim,
+): Promise<AlignmentResult | null> {
+  let state = loadTrainingLabState(loadedSim.rkey);
+  if (!state.profile) {
+    ctx.ui.notify("Need a profile first — run `/sim train profile`.", "warning");
+    return null;
+  }
+  const proposals = state.questionSet?.proposals ?? [];
+  const cast = state.baselineVotes.filter(
+    (v) => !(v.vote === "abstain" && Math.abs(v.importance - 0.5) < 0.01 && !v.reasoning),
+  );
+  if (cast.length < MIN_VOTES) {
+    ctx.ui.notify(
+      `Need at least ${MIN_VOTES} cast baseline votes to run alignment (you have ${cast.length}).`,
+      "warning",
+    );
+    return null;
+  }
+
+  const aligned = proposals
+    .map((proposal) => {
+      const userVote = state.baselineVotes.find((v) => v.proposalId === proposal.id);
+      if (!userVote) return null;
+      if (
+        userVote.vote === "abstain" &&
+        Math.abs(userVote.importance - 0.5) < 0.01 &&
+        !userVote.reasoning
+      ) {
+        return null;
+      }
+      return { proposal, userVote: userVote.vote };
+    })
+    .filter((entry): entry is { proposal: BaselineProposal; userVote: Vote } => entry !== null);
+
+  ctx.ui.notify(
+    `Running alignment test on ${aligned.length} proposals (concurrency ${CONCURRENCY})…`,
+    "info",
+  );
+
+  let alignment: AlignmentResult;
+  try {
+    alignment = await scoreAlignment(loadedSim, state.profile, aligned);
+  } catch (err) {
+    ctx.ui.notify(`Alignment failed: ${(err as Error).message}`, "error");
+    return null;
+  }
+
+  state = { ...state, alignment };
+  saveTrainingLabState(loadedSim.rkey, state);
+  printAlignment(alignment, aligned);
+  return alignment;
+}
+
+export async function scoreAlignment(
+  loadedSim: LoadedSim,
+  profile: TrainingProfile,
+  aligned: Array<{ proposal: BaselineProposal; userVote: Vote }>,
+): Promise<AlignmentResult> {
+  const simVotes = await mapWithConcurrency(aligned, CONCURRENCY, async (entry) =>
+    askSimVote(loadedSim, profile, entry.proposal),
+  );
+
+  const results = aligned.map((entry, index) => {
+    const sv = simVotes[index];
+    return {
+      proposalId: entry.proposal.id,
+      userVote: entry.userVote,
+      simVote: sv?.simVote ?? "abstain",
+      matched: entry.userVote === sv?.simVote,
+      confidence: sv?.confidence ?? 0,
+      explanation: sv?.explanation ?? "No explanation returned.",
+    };
+  });
+
+  const matchedCount = results.filter((r) => r.matched).length;
+  const weakAreas = Array.from(
+    new Set(
+      results
+        .filter((r) => !r.matched)
+        .map((r) => aligned.find((a) => a.proposal.id === r.proposalId)?.proposal.topic)
+        .filter((topic): topic is string => typeof topic === "string"),
+    ),
+  ).slice(0, 4);
+
+  return {
+    matchedCount,
+    totalCount: results.length,
+    results,
+    weakAreas,
+  };
+}
+
+interface SimVote {
+  simVote: Vote;
+  confidence: number;
+  explanation: string;
+}
+
+async function askSimVote(
+  loadedSim: LoadedSim,
+  profile: TrainingProfile,
+  proposal: BaselineProposal,
+): Promise<SimVote> {
+  const userPrompt = [
+    `simName: ${loadedSim.name}`,
+    wrapAsData("existingConstitution", clampConstitution(loadedSim.description)),
+    wrapAsData("trainingProfile", JSON.stringify(profile, null, 2)),
+    wrapAsData(
+      "proposal",
+      JSON.stringify(
+        { id: proposal.id, title: proposal.title, summary: proposal.summary, topic: proposal.topic },
+        null,
+        2,
+      ),
+    ),
+    "Output shape: { vote: 'yes' | 'no' | 'abstain', confidence: 0-1, explanation: <280 chars }",
+  ].join("\n\n");
+
+  const content = await openRouterComplete(
+    [
+      { role: "system", content: TRAINING_ALIGNMENT_TEST_SYSTEM_PROMPT },
+      { role: "user", content: userPrompt },
+    ],
+    { model: TRAINING_CHAT_MODEL, maxTokens: 350, temperature: 0.2 },
+  );
+
+  const parsed = parseJsonObject(content);
+  const simVote = normalizeVote(parsed?.vote);
+  const confidence = toUnit(parsed?.confidence);
+  const explanation =
+    typeof parsed?.explanation === "string" ? parsed.explanation.trim().slice(0, 280) : "";
+  if (!simVote || confidence === null || !explanation) {
+    throw new Error("Could not parse alignment vote from model output");
+  }
+  return { simVote, confidence, explanation };
+}
+
+async function mapWithConcurrency<T, U>(
+  items: T[],
+  limit: number,
+  mapper: (item: T, index: number) => Promise<U>,
+): Promise<U[]> {
+  const results: U[] = [];
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < items.length) {
+      const i = nextIndex++;
+      const item = items[i];
+      if (item !== undefined) {
+        results[i] = await mapper(item, i);
+      }
+    }
+  }
+  const workerCount = Math.min(limit, items.length);
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  return results;
+}
+
+// -----------------------------------------------------------------
+// JSON parsing — same shape as profile.ts
+// -----------------------------------------------------------------
+
+function parseJsonObject(content: string): Record<string, unknown> | null {
+  const trimmed = content.trim();
+  try {
+    const parsed: unknown = JSON.parse(trimmed);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start === -1 || end === -1 || end <= start) return null;
+    try {
+      const parsed: unknown = JSON.parse(trimmed.slice(start, end + 1));
+      return isRecord(parsed) ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function toUnit(value: unknown): number | null {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return Math.min(1, Math.max(0, value));
+}
+
+function normalizeVote(value: unknown): Vote | null {
+  if (value === "yes" || value === "no" || value === "abstain") return value;
+  if (typeof value !== "string") return null;
+  const normalized = value.toLowerCase();
+  return normalized === "yes" || normalized === "no" || normalized === "abstain"
+    ? (normalized as Vote)
+    : null;
+}
+
+// -----------------------------------------------------------------
+// Rendering
+// -----------------------------------------------------------------
+
+export function printAlignment(
+  alignment: AlignmentResult,
+  aligned: Array<{ proposal: BaselineProposal; userVote: Vote }>,
+): void {
+  const lines: string[] = [""];
+  for (const r of alignment.results) {
+    const prop = aligned.find((a) => a.proposal.id === r.proposalId)?.proposal;
+    const title = prop?.title ?? r.proposalId;
+    const symbol = r.matched ? "✓" : "✗";
+    const u = r.userVote.padEnd(7, " ");
+    const s = r.simVote.padEnd(7, " ");
+    lines.push(`${symbol}  user:${u} ↔ sim:${s} ${bar(r.confidence)}  ${title}`);
+  }
+  lines.push("");
+  const pct =
+    alignment.totalCount > 0
+      ? Math.round((alignment.matchedCount / alignment.totalCount) * 100)
+      : 0;
+  lines.push(`Match: ${alignment.matchedCount}/${alignment.totalCount} (${pct}%)`);
+  if (alignment.weakAreas.length) {
+    lines.push(`Weak areas: ${alignment.weakAreas.join(", ")}`);
+  }
+  console.log(lines.join("\n"));
+}

package/src/training/apply.ts

@@ -0,0 +1,271 @@
+/**
+ * `/sim train apply` — merge the distilled profile into the sim's
+ * existing constitution + short description. PR 2 prints the result
+ * and copies it to the system clipboard so the user can paste it
+ * into simocracy.org. PR 3 will write to the user's PDS when
+ * `--apply` is passed and the user is signed in.
+ *
+ * Mirrors `/api/training/merge-constitution` from simocracy-v2.
+ */
+
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+
+import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+
+import type { LoadedSim } from "../persona.ts";
+import { openRouterComplete, TRAINING_REASONING_MODEL } from "../openrouter.ts";
+import { readAuth } from "../auth/storage.ts";
+import { resolveHandle } from "../simocracy.ts";
+import {
+  createAgents,
+  findRkeyForSim,
+  getAuthenticatedAgent,
+  NotSignedInError,
+  updateAgents,
+} from "../writes.ts";
+import {
+  loadTrainingLabState,
+  saveTrainingLabState,
+} from "./storage.ts";
+import { clampConstitution, wrapAsData } from "./prompt-helpers.ts";
+import { TRAINING_MERGE_CONSTITUTION_SYSTEM_PROMPT } from "./prompts.ts";
+import type { TrainingProfile } from "./types.ts";
+
+export interface MergeOutput {
+  shortDescription: string;
+  description: string;
+}
+
+export async function runApply(
+  ctx: ExtensionCommandContext,
+  loadedSim: LoadedSim,
+  opts: { apply?: boolean } = {},
+): Promise<MergeOutput | null> {
+  const state = loadTrainingLabState(loadedSim.rkey);
+  if (!state.profile) {
+    ctx.ui.notify("Need a profile first — run `/sim train profile`.", "warning");
+    return null;
+  }
+
+  ctx.ui.notify("Merging profile into constitution (this may take a few seconds)…", "info");
+  let merged: MergeOutput;
+  try {
+    merged = await mergeConstitution(loadedSim, state.profile);
+  } catch (err) {
+    ctx.ui.notify(`Merge failed: ${(err as Error).message}`, "error");
+    return null;
+  }
+
+  // Re-save state so the updatedAt bumps for /sim train status; the
+  // canonical record still lives on the user's PDS.
+  saveTrainingLabState(loadedSim.rkey, state);
+
+  console.log("");
+  console.log(`Short description:`);
+  console.log(merged.shortDescription);
+  console.log("");
+  console.log(`Constitution (markdown):`);
+  console.log(merged.description);
+  console.log("");
+
+  if (opts.apply) {
+    const written = await writeAgentsToPds(ctx, loadedSim, merged);
+    if (written) return merged;
+    return null;
+  }
+
+  const clipboardPayload = formatClipboard(merged);
+  const copied = await copyToClipboard(clipboardPayload);
+  if (copied) {
+    ctx.ui.notify(
+      `Copied to clipboard. Paste into the constitution editor at https://simocracy.org/sims/${loadedSim.did}/${loadedSim.rkey}, or re-run with --apply once you've signed in via /sim login.`,
+      "info",
+    );
+  } else {
+    ctx.ui.notify(
+      "Could not copy to clipboard — copy the printed output manually, or sign in via /sim login and re-run with --apply.",
+      "warning",
+    );
+  }
+  return merged;
+}
+
+/**
+ * Write the merged constitution to the user's PDS via OAuth. Enforces
+ * the owner check (loaded sim's DID must match the signed-in DID).
+ * Returns true on success.
+ */
+async function writeAgentsToPds(
+  ctx: ExtensionCommandContext,
+  loadedSim: LoadedSim,
+  merged: MergeOutput,
+): Promise<boolean> {
+  const auth = readAuth();
+  if (!auth) {
+    ctx.ui.notify("Not signed into ATProto. Run `/sim login <handle>` first (e.g. `/sim login alice.bsky.social`).", "error");
+    return false;
+  }
+  if (auth.did !== loadedSim.did) {
+    const ownerHandle =
+      loadedSim.handle ?? (await resolveHandle(loadedSim.did).catch(() => null));
+    ctx.ui.notify(
+      `You can only apply to sims you own. Loaded sim is owned by ${
+        ownerHandle ? `@${ownerHandle}` : loadedSim.did
+      } — your signed-in DID is ${auth.did}.`,
+      "error",
+    );
+    return false;
+  }
+
+  let agent;
+  try {
+    ({ agent } = await getAuthenticatedAgent());
+  } catch (err) {
+    if (err instanceof NotSignedInError) {
+      ctx.ui.notify(err.message, "error");
+    } else {
+      ctx.ui.notify(`Auth failed: ${(err as Error).message}`, "error");
+    }
+    return false;
+  }
+
+  const existingRkey = await findRkeyForSim(
+    agent,
+    auth.did,
+    "org.simocracy.agents",
+    loadedSim.uri,
+  ).catch(() => null);
+
+  ctx.ui.notify(
+    existingRkey
+      ? `Updating org.simocracy.agents (${existingRkey})…`
+      : "Creating org.simocracy.agents…",
+    "info",
+  );
+  try {
+    if (existingRkey) {
+      await updateAgents({
+        agent,
+        did: auth.did,
+        rkey: existingRkey,
+        simUri: loadedSim.uri,
+        simCid: "", // CID required by lexicon validators is permissive — empty is acceptable for a fresh write here.
+        shortDescription: merged.shortDescription,
+        description: merged.description,
+      });
+    } else {
+      await createAgents({
+        agent,
+        did: auth.did,
+        simUri: loadedSim.uri,
+        simCid: "",
+        shortDescription: merged.shortDescription,
+        description: merged.description,
+      });
+    }
+  } catch (err) {
+    ctx.ui.notify(`PDS write failed: ${(err as Error).message}`, "error");
+    return false;
+  }
+
+  ctx.ui.notify(
+    `Wrote constitution to ${auth.handle ? `@${auth.handle}` : auth.did}'s PDS. Refresh https://simocracy.org/sims/${loadedSim.did}/${loadedSim.rkey} to see it.`,
+    "info",
+  );
+  return true;
+}
+
+export async function mergeConstitution(
+  loadedSim: LoadedSim,
+  profile: TrainingProfile,
+): Promise<MergeOutput> {
+  const userPrompt = [
+    `simName: ${loadedSim.name}`,
+    wrapAsData(
+      "existingConstitution",
+      loadedSim.description?.trim()
+        ? clampConstitution(loadedSim.description)
+        : "(empty — write one from scratch using the profile)",
+    ),
+    wrapAsData(
+      "existingShortDescription",
+      loadedSim.shortDescription?.trim() || "(none)",
+    ),
+    wrapAsData("speakingStyle", loadedSim.style?.trim() || "(none)"),
+    wrapAsData("trainingProfile", JSON.stringify(profile, null, 2)),
+  ].join("\n\n");
+
+  const content = await openRouterComplete(
+    [
+      { role: "system", content: TRAINING_MERGE_CONSTITUTION_SYSTEM_PROMPT },
+      { role: "user", content: userPrompt },
+    ],
+    { model: TRAINING_REASONING_MODEL, maxTokens: 4000, temperature: 0.4 },
+  );
+
+  return parseMergeOutput(content, profile);
+}
+
+/**
+ * Mirrors `parseMergeOutput` in
+ * `simocracy-v2/app/api/training/merge-constitution/route.ts`. Tolerates
+ * a missing separator (uses profile.summary as the short description).
+ */
+export function parseMergeOutput(
+  content: string,
+  profile: TrainingProfile,
+): MergeOutput {
+  const lines = content.split("\n");
+  const separatorIdx = lines.findIndex((line) => line.trim() === "---");
+
+  let shortDescription: string;
+  let description: string;
+  if (separatorIdx > 0) {
+    shortDescription = lines.slice(0, separatorIdx).join("\n").trim();
+    description = lines.slice(separatorIdx + 1).join("\n").trim();
+  } else {
+    description = content.trim();
+    shortDescription = profile.summary?.trim() || "";
+  }
+
+  if (shortDescription.length > 300) {
+    shortDescription = `${shortDescription.slice(0, 297).trimEnd()}…`;
+  }
+  return { shortDescription, description };
+}
+
+function formatClipboard(merged: MergeOutput): string {
+  return [
+    "## Short description",
+    merged.shortDescription,
+    "",
+    "## Constitution",
+    merged.description,
+  ].join("\n");
+}
+
+/** Best-effort clipboard copy. No new npm deps — shells out per-OS. */
+async function copyToClipboard(text: string): Promise<boolean> {
+  const cmd = clipboardCommand();
+  if (!cmd) return false;
+  return new Promise((resolve) => {
+    try {
+      const child = spawn(cmd.command, cmd.args, { stdio: ["pipe", "ignore", "ignore"] });
+      child.on("error", () => resolve(false));
+      child.on("close", (code) => resolve(code === 0));
+      child.stdin?.end(text);
+    } catch {
+      resolve(false);
+    }
+  });
+}
+
+function clipboardCommand(): { command: string; args: string[] } | null {
+  const os = platform();
+  if (os === "darwin") return { command: "pbcopy", args: [] };
+  if (os === "win32") return { command: "clip", args: [] };
+  // Linux — try xclip, then xsel, then wl-copy. We only return one;
+  // callers fall back to "couldn't copy" if it fails to run.
+  return { command: "xclip", args: ["-selection", "clipboard"] };
+}