@huseynsnmz/pi-suite 0.2.1 → 0.2.3

package/src/index.ts

@@ -5,7 +5,8 @@ import { fileURLToPath } from "node:url";
 
 import { type ExtensionAPI, type ExtensionCommandContext, getAgentDir } from "@earendil-works/pi-coding-agent";
 
-import { isPart, loadSettings, type Part, PART_NAMES, PARTS, saveSettings, separateInstalls } from "./settings.ts";
+import { checkSection, type Field, FIELDS, shownValue, typedValue } from "./settings-ui.ts";
+import { isPart, loadSettings, moveOldSettings, type Part, PART_NAMES, PARTS, readSection, saveSettings, separateInstalls, writeSection } from "./settings.ts";
 
 function loadPart(part: Part): Promise<{ default: (pi: ExtensionAPI) => void | Promise<void> }> {
   return import(new URL(`../packages/${part}/src/index.ts`, import.meta.url).href);
@@ -20,8 +21,9 @@ const ROOT = fileURLToPath(new URL("..", import.meta.url));
 
 export default async function piSuite(pi: ExtensionAPI): Promise<void> {
   const agentDir = getAgentDir();
+  const moveProblems = moveOldSettings(agentDir);
   const settings = loadSettings(agentDir);
-  const notices: string[] = settings.problem === undefined ? [] : [`pi-suite: ${settings.problem}`];
+  const notices: string[] = [...moveProblems, ...(settings.problem === undefined ? [] : [`pi-suite: ${settings.problem}`])];
   const loaded = new Set<Part>();
   const failed = new Set<Part>();
   if (settings.off.has("modes")) notices.push(`pi-suite: modes is off, so ${MODES_OFF}`);
@@ -77,20 +79,26 @@ export default async function piSuite(pi: ExtensionAPI): Promise<void> {
     }
     if (on) off.delete(part);
     else off.add(part);
-    saveSettings(agentDir, off);
-    if (!on && part === "router") await leaveRouter(ctx);
+    try {
+      saveSettings(agentDir, off);
+    } catch (error) {
+      ctx.ui.notify(`Nothing changed: ${(error as Error).message}`, "error");
+      return false;
+    }
+    if (!on && part === "router") await leaveModels(ctx, "pi-virtual");
+    if (!on && part === "subscription") await leaveModels(ctx, "claude-agent-sdk");
     return true;
   }
 
   /** The session would otherwise stay on a model that's gone after the reload, and every prompt would fail. */
-  async function leaveRouter(ctx: ExtensionCommandContext): Promise<void> {
-    if (ctx.model?.api !== "pi-virtual") return;
+  async function leaveModels(ctx: ExtensionCommandContext, api: string): Promise<void> {
+    if (ctx.model?.api !== api) return;
     const lastAnswer = ctx.sessionManager
       .getBranch()
       .flatMap((entry) => (entry.type === "message" && entry.message.role === "assistant" && entry.message.stopReason !== "error" && entry.message.stopReason !== "aborted" ? [entry.message] : []))
       .at(-1);
     const answered = lastAnswer && ctx.modelRegistry.find(lastAnswer.provider, lastAnswer.model);
-    const next = answered ?? ctx.modelRegistry.getAvailable().find((model) => model.api !== "pi-virtual");
+    const next = (answered?.api === api ? undefined : answered) ?? ctx.modelRegistry.getAvailable().find((model) => model.api !== "pi-virtual" && model.api !== api);
     if (next === undefined) return;
     await pi.setModel(next);
     if (ctx.hasUI) ctx.ui.notify(`Now on ${next.provider}/${next.id}.`, "info");
@@ -102,6 +110,80 @@ export default async function piSuite(pi: ExtensionAPI): Promise<void> {
     else if (ctx.hasUI) ctx.ui.notify("Saved. Run /reload to apply it.", "info");
   }
 
+  /** Asks for a new value. True if one was saved. */
+  async function editField(part: Part, field: Field, ctx: ExtensionCommandContext): Promise<boolean> {
+    const section = readSection(agentDir, part);
+    const current = section[field.key];
+    let value: unknown;
+    const prompt = `${part}: ${field.label}`;
+    if (field.kind === "boolean" || field.kind === "choice" || field.kind === "model") {
+      const options =
+        field.kind === "boolean"
+          ? ["on", "off"]
+          : field.kind === "choice"
+            ? [...field.options, "default"]
+            : ["default", ...ctx.modelRegistry.getAvailable().filter((model) => model.api !== "pi-virtual").map((model) => `${model.provider}/${model.id}`)];
+      const picked = await ctx.ui.select(prompt, options);
+      if (picked === undefined) return false;
+      value = field.kind === "boolean" ? (picked === "on" ? true : undefined) : picked === "default" ? undefined : picked;
+    } else {
+      const shown = Array.isArray(current) ? current.join(", ") : current === undefined ? "" : String(current);
+      const typed = await ctx.ui.input(`${prompt}${field.kind === "list" ? " (separate with commas, empty clears)" : " (empty clears)"}`, shown);
+      if (typed === undefined) return false;
+      value = typedValue(field, typed);
+    }
+    const next = { ...section };
+    if (value === undefined) delete next[field.key];
+    else next[field.key] = value;
+    checkSection(part, next);
+    writeSection(agentDir, part, next);
+    return true;
+  }
+
+  /** One part: on or off, then its settings. True if anything was saved. */
+  async function partMenu(part: Part, ctx: ExtensionCommandContext): Promise<boolean> {
+    let changed = false;
+    const fields = FIELDS[part] ?? [];
+    for (;;) {
+      let section: Record<string, unknown> = {};
+      try {
+        section = readSection(agentDir, part);
+      } catch (error) {
+        ctx.ui.notify((error as Error).message, "error");
+      }
+      const off = currentOff();
+      const toggle = off.has(part) ? "Turned off. Enter turns it on" : "Turned on. Enter turns it off";
+      const extra = part === "router" ? ["Models and reasoning"] : part === "frame" ? ["Icons, frame style and more"] : [];
+      const rows = [toggle, ...extra, ...fields.map((field) => `${field.label}: ${shownValue(part, field, section)}`)];
+      const row = await ctx.ui.select(`${part}: ${PARTS[part]} (Esc to go back)`, rows);
+      if (row === undefined) return changed;
+      const index = rows.indexOf(row);
+      if (index === 0) {
+        if (await setPart(part, off.has(part), ctx)) changed = true;
+        continue;
+      }
+      if (extra.includes(row)) {
+        if (part === "frame") {
+          ctx.ui.notify("Press Ctrl+S in the editor for the frame's settings, or use /harness with the frame off.", "info");
+          continue;
+        }
+        const probe: { open?: (ctx: ExtensionCommandContext) => Promise<void> } = {};
+        pi.events.emit("pi-suite:router-settings", probe);
+        if (probe.open === undefined) ctx.ui.notify("Turn router on and reload first.", "warning");
+        else {
+          await probe.open(ctx);
+        }
+        continue;
+      }
+      const field = fields[index - 1 - extra.length] as Field;
+      try {
+        if (await editField(part, field, ctx)) changed = true;
+      } catch (error) {
+        ctx.ui.notify(`Not saved: ${(error as Error).message}`, "error");
+      }
+    }
+  }
+
   function status(): string {
     const off = currentOff();
     return PART_NAMES.map((part) => {
@@ -114,7 +196,7 @@ export default async function piSuite(pi: ExtensionAPI): Promise<void> {
   }
 
   pi.registerCommand("suite", {
-    description: "Turn parts of pi-suite on or off: /suite, /suite on web, /suite off board, /suite list",
+    description: "Settings for pi-suite, and turning its parts on or off: /suite, /suite on web, /suite off board, /suite list",
     getArgumentCompletions: (prefix) => {
       const typed = prefix.trimStart().toLowerCase();
       const options = ["list", ...PART_NAMES.flatMap((part) => [`on ${part}`, `off ${part}`])];
@@ -145,10 +227,10 @@ export default async function piSuite(pi: ExtensionAPI): Promise<void> {
       for (;;) {
         const off = currentOff();
         const rows = PART_NAMES.map((part) => `${off.has(part) ? "[ ]" : "[x]"} ${part}  ${PARTS[part]}`);
-        const row = await ctx.ui.select("pi-suite: Enter turns a part on or off (Esc when done)", rows);
+        const row = await ctx.ui.select("pi-suite: pick a part (Esc when done)", rows);
         if (row === undefined) break;
         const part = PART_NAMES[rows.indexOf(row)] as Part;
-        if (await setPart(part, off.has(part), ctx)) changed = true;
+        if (await partMenu(part, ctx)) changed = true;
       }
       await finish(changed, ctx);
     },

package/src/settings-ui.ts

@@ -0,0 +1,63 @@
+// What /suite can change in each part's section of suite.json. Each part still checks its own values when it loads.
+import { parseConfig as parseWeb } from "../packages/web/src/config.ts";
+import type { Part } from "./settings.ts";
+
+export type Field =
+  | { key: string; label: string; kind: "boolean" | "text" | "list" | "model" }
+  | { key: string; label: string; kind: "choice"; options: readonly string[] }
+  | { key: string; label: string; kind: "number"; min: number; max: number };
+
+const MODES_ALLOWED = ["normal", "auto", "plan", "read-only"];
+/** Yolo has to be asked for each time, so it can't be a default. */
+export const FIELDS: Partial<Record<Part, readonly Field[]>> = {
+  modes: [{ key: "defaultMode", label: "Mode for new sessions", kind: "choice", options: MODES_ALLOWED }],
+  web: [
+    { key: "companySearch", label: "Allow searching through a company's service", kind: "boolean" },
+    { key: "provider", label: "Search with", kind: "choice", options: ["searxng", "markdown.new"] },
+    { key: "searxngUrl", label: "Your SearXNG server", kind: "text" },
+    { key: "readerModel", label: "Model that reads pages", kind: "model" },
+    { key: "allowDomains", label: "Only fetch from these sites", kind: "list" },
+    { key: "denyDomains", label: "Never fetch from these sites", kind: "list" },
+    { key: "trustedDomains", label: "Sites it can write its own addresses on", kind: "list" },
+    { key: "privateWords", label: "Words a search can never hold", kind: "list" },
+    { key: "askNewDomains", label: "Ask before the first fetch from each site", kind: "boolean" },
+    { key: "strictUrls", label: "Ask about every address nobody gave it", kind: "boolean" },
+    { key: "minConfidence", label: "Withhold answers the reader scores below", kind: "number", min: 1, max: 10 },
+    { key: "dnsFilter", label: "Block sites using a DNS filter", kind: "choice", options: ["cloudflare-family", "cloudflare-security", "off"] },
+  ],
+  subscription: [
+    { key: "promptMode", label: "System prompt", kind: "choice", options: ["claude", "pi"] },
+    { key: "pathToClaudeCodeExecutable", label: "Claude Code program", kind: "text" },
+    { key: "maxSessions", label: "Claude Code processes to keep", kind: "number", min: 1, max: 16 },
+    { key: "idleMinutes", label: "Close an idle process after, in minutes", kind: "number", min: 1, max: 1440 },
+  ],
+};
+
+/** The value /suite shows when nothing's been chosen. */
+const UNSET_WEB: Readonly<Record<string, string>> = { minConfidence: "4", dnsFilter: "cloudflare-family", provider: "automatic" };
+
+export function shownValue(part: Part, field: Field, section: Record<string, unknown>): string {
+  const value = section[field.key];
+  if (value === undefined) return part === "web" ? (UNSET_WEB[field.key] ?? (field.kind === "boolean" ? "off" : "not set")) : field.kind === "boolean" ? "off" : "default";
+  if (typeof value === "boolean") return value ? "on" : "off";
+  if (Array.isArray(value)) return value.length === 0 ? "not set" : value.join(", ");
+  return String(value);
+}
+
+/** What was typed, as the value to save. Undefined clears the setting. Throws if it can't be used. */
+export function typedValue(field: Field, typed: string): unknown {
+  const text = typed.trim();
+  if (text === "") return undefined;
+  if (field.kind === "list") return text.split(",").map((item) => item.trim()).filter(Boolean);
+  if (field.kind === "number") {
+    const number = Number(text);
+    if (!Number.isInteger(number) || number < field.min || number > field.max) throw new Error(`${field.label} must be a whole number from ${field.min} to ${field.max}`);
+    return number;
+  }
+  return text;
+}
+
+/** Throws rather than save what the part would refuse when it loads. */
+export function checkSection(part: Part, section: Record<string, unknown>): void {
+  if (part === "web") parseWeb(section);
+}

package/src/settings.ts

@@ -1,4 +1,5 @@
-// ~/.pi/agent/suite.json: which parts are off. Everything is on unless it's listed.
+// ~/.pi/agent/suite.json: which parts are off, and each part's settings under its own name.
+// Global only: a repository must not choose where your code or searches go, or which program runs.
 import { existsSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
@@ -10,6 +11,7 @@ export const PARTS = {
   frame: "The start card, framed editor, tool boxes, footer and todo list",
   board: "The board of agent sessions",
   commands: "/clear and /security-review",
+  subscription: "Claude models on your Claude login, asking before anything is billed as extra usage",
 } as const;
 
 export type Part = keyof typeof PARTS;
@@ -20,33 +22,44 @@ export function settingsPath(agentDir: string): string {
   return join(agentDir, "suite.json");
 }
 
+/** Off until asked for: it adds models that count as logged in, and its README says what using them risks. */
+const OFF_BY_DEFAULT: readonly Part[] = ["subscription"];
+
 export function isPart(name: string): name is Part {
   return (PART_NAMES as string[]).includes(name);
 }
 
 export interface Loaded {
   off: ReadonlySet<Part>;
-  /** Everything stays on when the file can't be understood, so a typo can't turn off plan mode. */
+  /** Every part keeps its default when the file can't be understood, so a typo can't turn off plan mode. */
   problem?: string;
 }
 
+function defaults(problem?: string): Loaded {
+  return { off: new Set(OFF_BY_DEFAULT), ...(problem === undefined ? {} : { problem }) };
+}
+
 export function parseSettings(text: string): Loaded {
   let raw: unknown;
   try {
     raw = JSON.parse(text);
   } catch {
-    return { off: new Set(), problem: "suite.json isn't valid JSON, so everything is on" };
+    return defaults("suite.json isn't valid JSON, so every part is at its default");
   }
-  const off = (raw as { off?: unknown } | null)?.off;
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw) || (off !== undefined && !Array.isArray(off))) {
-    return { off: new Set(), problem: 'suite.json should look like { "off": ["board"] }, so everything is on' };
+  const { off, on } = (raw ?? {}) as { off?: unknown; on?: unknown };
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw) || (off !== undefined && !Array.isArray(off)) || (on !== undefined && !Array.isArray(on))) {
+    return defaults('suite.json should look like { "off": ["board"], "on": ["subscription"] }, so every part is at its default');
   }
-  const names = (off ?? []) as unknown[];
-  const unknown = names.filter((name) => typeof name !== "string" || !isPart(name));
+  const offNames = (off ?? []) as unknown[];
+  const onNames = (on ?? []) as unknown[];
+  const unknown = [...offNames, ...onNames].filter((name) => typeof name !== "string" || !isPart(name));
   if (unknown.length > 0) {
-    return { off: new Set(), problem: `suite.json names ${unknown.join(", ")}, which isn't one of ${PART_NAMES.join(", ")}, so everything is on` };
+    return defaults(`suite.json names ${unknown.join(", ")}, which isn't one of ${PART_NAMES.join(", ")}, so every part is at its default`);
   }
-  return { off: new Set(names as Part[]) };
+  // Saying off wins, in case a part is in both.
+  const result = new Set<Part>(OFF_BY_DEFAULT.filter((name) => !onNames.includes(name)));
+  for (const name of offNames as Part[]) result.add(name);
+  return { off: result };
 }
 
 export function loadSettings(agentDir: string): Loaded {
@@ -54,21 +67,109 @@ export function loadSettings(agentDir: string): Loaded {
   try {
     text = readFileSync(settingsPath(agentDir), "utf8");
   } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return { off: new Set() };
-    return { off: new Set(), problem: `suite.json can't be read, so everything is on: ${(error as Error).message}` };
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return defaults();
+    return defaults(`suite.json can't be read, so every part is at its default: ${(error as Error).message}`);
   }
   return parseSettings(text);
 }
 
 export function saveSettings(agentDir: string, off: ReadonlySet<Part>): void {
-  // A linked file, as in a dotfiles setup, stays linked.
+  const turnedOn = OFF_BY_DEFAULT.filter((name) => !off.has(name));
+  const { on: _on, ...raw } = readAll(agentDir);
+  writeAll(agentDir, { ...raw, off: PART_NAMES.filter((name) => off.has(name) && !OFF_BY_DEFAULT.includes(name)), ...(turnedOn.length > 0 ? { on: turnedOn } : {}) });
+}
+
+type Raw = Record<string, unknown>;
+
+const isObject = (value: unknown): value is Raw => value !== null && typeof value === "object" && !Array.isArray(value);
+
+/** Throws on a file it can't understand, so a broken one can't quietly mean "no allow list". */
+function readAll(agentDir: string): Raw {
+  let text: string;
+  try {
+    text = readFileSync(settingsPath(agentDir), "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    throw error;
+  }
+  let raw: unknown;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    throw new Error("suite.json isn't valid JSON");
+  }
+  if (!isObject(raw)) throw new Error("suite.json must hold a JSON object");
+  return raw;
+}
+
+/** Only you can read it, as it can hold private words. A linked file, as in a dotfiles setup, stays linked. */
+function writeAll(agentDir: string, raw: Raw): void {
   const named = settingsPath(agentDir);
   const path = existsSync(named) ? realpathSync(named) : named;
-  const temp = `${path}.${process.pid}.tmp`;
-  writeFileSync(temp, `${JSON.stringify({ off: PART_NAMES.filter((name) => off.has(name)) }, null, 2)}\n`);
+  const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(temp, `${JSON.stringify(raw, null, 2)}\n`, { mode: 0o600 });
   renameSync(temp, path);
 }
 
+/** Where each part kept its settings before they moved here. */
+const OLD_FILES: Readonly<Record<string, string>> = {
+  router: "router.json",
+  web: "web.json",
+  subscription: "claude-sdk.json",
+  modes: join("extensions", "pi-modes", "config.json"),
+  frame: join("extensions", "pi-harness", "settings.json"),
+};
+
+/** Moves one old file in, keeping it as .bak. What's already here wins. A broken file stays put and throws. */
+function moveOldFile(agentDir: string, section: string): void {
+  const name = OLD_FILES[section];
+  if (name === undefined) return;
+  const path = join(agentDir, name);
+  if (!existsSync(path)) return;
+  let old: unknown;
+  try {
+    old = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new Error(`${path} can't be read, so it wasn't moved to suite.json. Fix or delete it: ${(error as Error).message}`);
+  }
+  if (!isObject(old)) throw new Error(`${path} must hold a JSON object, so it wasn't moved to suite.json. Fix or delete it`);
+  const raw = readAll(agentDir);
+  // The frame's file already has its settings under their own names.
+  const moved = section === "frame" ? old : { [section]: old };
+  writeAll(agentDir, { ...moved, ...raw });
+  renameSync(path, `${path}.bak`);
+}
+
+/** Before any part loads. A file that can't move is reported here and refused again by its part. */
+export function moveOldSettings(agentDir: string): string[] {
+  const problems: string[] = [];
+  for (const section of Object.keys(OLD_FILES)) {
+    try {
+      moveOldFile(agentDir, section);
+    } catch (error) {
+      problems.push(`pi-suite: ${(error as Error).message}`);
+    }
+  }
+  return problems;
+}
+
+/** One part's settings. Throws if they can't be understood, for the part to refuse or report. */
+export function readSection(agentDir: string, section: string): Raw {
+  moveOldFile(agentDir, section);
+  const value = readAll(agentDir)[section];
+  if (value === undefined) return {};
+  if (!isObject(value)) throw new Error(`${section} in suite.json must be an object`);
+  return value;
+}
+
+/** Reads the file again first, as another session may have changed another part. */
+export function writeSection(agentDir: string, section: string, value: Raw): void {
+  const raw = readAll(agentDir);
+  if (Object.keys(value).length === 0) delete raw[section];
+  else raw[section] = value;
+  writeAll(agentDir, raw);
+}
+
 /** Separate installs of what's now in here would register everything twice. */
 export function separateInstalls(packages: unknown): string[] {
   if (!Array.isArray(packages)) return [];