@huseynsnmz/pi-suite 0.0.0-stage → 0.2.0

package/src/index.ts

@@ -0,0 +1,156 @@
+// One package, seven parts. A part that's off isn't even imported, so it adds no tools, prompts or start-up time.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+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";
+
+function loadPart(part: Part): Promise<{ default: (pi: ExtensionAPI) => void | Promise<void> }> {
+  return import(new URL(`../packages/${part}/src/index.ts`, import.meta.url).href);
+}
+
+/** Skills are found through this event rather than the manifest, so a part that's off doesn't offer them. */
+const SKILLS: Partial<Record<Part, string>> = { modes: "modes", memory: "memory" };
+
+const MODES_OFF = "plan, read-only and auto aren't enforced, and Pi runs tools with no mode checks";
+
+const ROOT = fileURLToPath(new URL("..", import.meta.url));
+
+export default async function piSuite(pi: ExtensionAPI): Promise<void> {
+  const agentDir = getAgentDir();
+  const settings = loadSettings(agentDir);
+  const notices: string[] = 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}`);
+
+  for (const part of PART_NAMES) {
+    if (settings.off.has(part)) continue;
+    try {
+      await (await loadPart(part)).default(pi);
+      loaded.add(part);
+    } catch (error) {
+      // Modes enforces plan and read-only, so Pi must not go on without it. Pi's own loader then reports this and stops.
+      if (part === "modes") throw error;
+      failed.add(part);
+      notices.push(`pi-suite: ${part} failed to load, and may be partly working: ${(error as Error).message}`);
+    }
+  }
+
+  pi.on("resources_discover", () => ({
+    skillPaths: PART_NAMES.filter((part) => loaded.has(part) && SKILLS[part] !== undefined).map((part) => join(ROOT, "packages", SKILLS[part] as string, "skills")),
+  }));
+
+  pi.on("session_start", (_event, ctx) => {
+    for (const notice of notices.splice(0)) {
+      if (ctx.hasUI) ctx.ui.notify(notice, "error");
+      else console.error(notice);
+    }
+    if (!ctx.hasUI) return;
+    let packages: unknown;
+    try {
+      packages = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf8")).packages;
+    } catch {
+      return;
+    }
+    const twice = separateInstalls(packages);
+    if (twice.length > 0) ctx.ui.notify(`pi-suite already includes these, so remove them with pi remove: ${twice.join(", ")}`, "warning");
+  });
+
+  /** What's saved can differ from what's running, until the next /reload. */
+  function currentOff(): Set<Part> {
+    return new Set(loadSettings(agentDir).off);
+  }
+
+  async function setPart(part: Part, on: boolean, ctx: ExtensionCommandContext): Promise<boolean> {
+    const off = currentOff();
+    if (off.has(part) === !on) return false;
+    if (!on && part === "modes") {
+      // Nobody can agree to it here, and a script could be passing on someone else's text.
+      if (!ctx.hasUI) {
+        console.error("pi-suite: /suite off modes needs someone to confirm it, so nothing changed.");
+        return false;
+      }
+      if (!(await ctx.ui.confirm("Turn off modes?", `With it off, ${MODES_OFF}.`))) return false;
+    }
+    if (on) off.delete(part);
+    else off.add(part);
+    saveSettings(agentDir, off);
+    if (!on && part === "router") await leaveRouter(ctx);
+    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;
+    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");
+    if (next === undefined) return;
+    await pi.setModel(next);
+    if (ctx.hasUI) ctx.ui.notify(`Now on ${next.provider}/${next.id}.`, "info");
+  }
+
+  async function finish(changed: boolean, ctx: ExtensionCommandContext): Promise<void> {
+    if (!changed) return;
+    if (ctx.hasUI && (await ctx.ui.confirm("Reload Pi now?", "Your changes apply after a reload."))) await ctx.reload();
+    else if (ctx.hasUI) ctx.ui.notify("Saved. Run /reload to apply it.", "info");
+  }
+
+  function status(): string {
+    const off = currentOff();
+    return PART_NAMES.map((part) => {
+      if (failed.has(part)) return `${part}: failed to load  ${PARTS[part]}`;
+      const now = loaded.has(part);
+      const next = !off.has(part);
+      const pending = now === next ? "" : ` (${next ? "on" : "off"} after /reload)`;
+      return `${part}: ${now ? "on" : "off"}${pending}  ${PARTS[part]}`;
+    }).join("\n");
+  }
+
+  pi.registerCommand("suite", {
+    description: "Turn parts of pi-suite 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}`])];
+      const found = options.filter((option) => option.startsWith(typed) && option !== typed);
+      return found.length === 0 ? null : found.map((value) => ({ value, label: value }));
+    },
+    handler: async (args, ctx) => {
+      const [verb, name, ...rest] = args.trim().toLowerCase().split(/\s+/).filter(Boolean);
+      if (verb === "list") {
+        if (ctx.hasUI) ctx.ui.notify(status(), "info");
+        else console.log(status());
+        return;
+      }
+      if (verb === "on" || verb === "off") {
+        if (name === undefined || !isPart(name) || rest.length > 0) {
+          ctx.ui.notify(`Use /suite ${verb} with one of: ${PART_NAMES.join(", ")}`, "error");
+          return;
+        }
+        await finish(await setPart(name, verb === "on", ctx), ctx);
+        return;
+      }
+      if (verb !== undefined) {
+        ctx.ui.notify("Use /suite, /suite list, /suite on <part> or /suite off <part>", "error");
+        return;
+      }
+      if (!ctx.hasUI) return;
+      let changed = false;
+      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);
+        if (row === undefined) break;
+        const part = PART_NAMES[rows.indexOf(row)] as Part;
+        if (await setPart(part, off.has(part), ctx)) changed = true;
+      }
+      await finish(changed, ctx);
+    },
+  });
+}

package/src/settings.ts

@@ -0,0 +1,79 @@
+// ~/.pi/agent/suite.json: which parts are off. Everything is on unless it's listed.
+import { existsSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export const PARTS = {
+  modes: "Modes and permissions: plan, auto, read-only, yolo, submit_plan, ask_questions",
+  router: "router/auto: one model to plan, another to build, and one each for the reader, judge and subagents",
+  web: "web_fetch and web_search, read by a separate model with no tools",
+  memory: "Memory the agent keeps between sessions",
+  frame: "The start card, framed editor, tool boxes, footer and todo list",
+  board: "The board of agent sessions",
+  commands: "/clear and /security-review",
+} as const;
+
+export type Part = keyof typeof PARTS;
+/** The order they load in. Modes goes first so its checks run before anything else sees a tool call. */
+export const PART_NAMES = Object.keys(PARTS) as Part[];
+
+export function settingsPath(agentDir: string): string {
+  return join(agentDir, "suite.json");
+}
+
+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. */
+  problem?: string;
+}
+
+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" };
+  }
+  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 names = (off ?? []) as unknown[];
+  const unknown = names.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 { off: new Set(names as Part[]) };
+}
+
+export function loadSettings(agentDir: string): Loaded {
+  let text: string;
+  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}` };
+  }
+  return parseSettings(text);
+}
+
+export function saveSettings(agentDir: string, off: ReadonlySet<Part>): void {
+  // A linked file, as in a dotfiles setup, stays linked.
+  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`);
+  renameSync(temp, path);
+}
+
+/** Separate installs of what's now in here would register everything twice. */
+export function separateInstalls(packages: unknown): string[] {
+  if (!Array.isArray(packages)) return [];
+  const pattern = new RegExp(`@huseynsnmz/pi-(?:${PART_NAMES.join("|")})\\b`);
+  return packages
+    .map((entry) => String((entry as { source?: unknown } | null)?.source ?? entry))
+    .filter((source) => pattern.test(source));
+}