@quickchatai/quickreview 0.0.0-stage → 1.1.0

package/extensions/inline-bash.ts

@@ -0,0 +1,102 @@
+/**
+ * VENDORED VERBATIM from the pinned pi package's shipped example:
+ * @earendil-works/pi-coding-agent examples/extensions/inline-bash.ts
+ * (copied at 0.84.1; byte-identical at 0.84.4).
+ * Copied rather than referenced in-image because the load path must survive a
+ * pi version bump and be guardable host-side like every other /workspace
+ * extension. Re-copy on a pi pin bump (rule 7); do not hand-edit below this
+ * header. Companion QoL only — never loaded by VM sessions.
+ *
+ * Inline Bash Extension - expands inline bash commands in user prompts.
+ *
+ * Start pi with this extension:
+ *   pi -e ./examples/extensions/inline-bash.ts
+ *
+ * Then type prompts with inline bash:
+ *   What's in !{pwd}?
+ *   The current branch is !{git branch --show-current} and status: !{git status --short}
+ *   My node version is !{node --version}
+ *
+ * The !{command} patterns are executed and replaced with their output before
+ * the prompt is sent to the agent.
+ *
+ * Note: Regular !command syntax (whole-line bash) is preserved and works as before.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+	const PATTERN = /!\{([^}]+)\}/g;
+	const TIMEOUT_MS = 30000;
+
+	pi.on("input", async (event, ctx) => {
+		const text = event.text;
+
+		// Don't process if it's a whole-line bash command (starts with !)
+		// This preserves the existing !command behavior
+		if (text.trimStart().startsWith("!") && !text.trimStart().startsWith("!{")) {
+			return { action: "continue" };
+		}
+
+		// Check if there are any inline bash patterns
+		if (!PATTERN.test(text)) {
+			return { action: "continue" };
+		}
+
+		// Reset regex state after test()
+		PATTERN.lastIndex = 0;
+
+		let result = text;
+		const expansions: Array<{ command: string; output: string; error?: string }> = [];
+
+		// Find all matches first (to avoid issues with replacing while iterating)
+		const matches: Array<{ full: string; command: string }> = [];
+		let match = PATTERN.exec(text);
+		while (match) {
+			matches.push({ full: match[0], command: match[1] });
+			match = PATTERN.exec(text);
+		}
+
+		// Execute each command and collect results
+		for (const { full, command } of matches) {
+			try {
+				const bashResult = await pi.exec("bash", ["-c", command], {
+					timeout: TIMEOUT_MS,
+				});
+
+				const output = bashResult.stdout || bashResult.stderr || "";
+				const trimmed = output.trim();
+
+				if (bashResult.code !== 0 && bashResult.stderr) {
+					expansions.push({
+						command,
+						output: trimmed,
+						error: `exit code ${bashResult.code}`,
+					});
+				} else {
+					expansions.push({ command, output: trimmed });
+				}
+
+				result = result.replace(full, trimmed);
+			} catch (err) {
+				const errorMsg = err instanceof Error ? err.message : String(err);
+				expansions.push({ command, output: "", error: errorMsg });
+				result = result.replace(full, `[error: ${errorMsg}]`);
+			}
+		}
+
+		// Show what was expanded (if UI available)
+		if (ctx.hasUI && expansions.length > 0) {
+			const summary = expansions
+				.map((e) => {
+					const status = e.error ? ` (${e.error})` : "";
+					const preview = e.output.length > 50 ? `${e.output.slice(0, 50)}...` : e.output;
+					return `!{${e.command}}${status} -> "${preview}"`;
+				})
+				.join("\n");
+
+			ctx.ui.notify(`Expanded ${expansions.length} inline command(s):\n${summary}`, "info");
+		}
+
+		return { action: "transform", text: result, images: event.images };
+	});
+}

package/extensions/muted-theme.json

@@ -0,0 +1,68 @@
+{
+  "name": "muted",
+  "vars": {
+    "text": "#c8ccd4",
+    "muted": "#7f8794",
+    "dim": "#606773",
+    "accent": "#82a6c9",
+    "border": "#526272",
+    "panel": "#20232a",
+    "panelSoft": "#24272f",
+    "panelError": "#302326"
+  },
+  "colors": {
+    "accent": "accent",
+    "border": "border",
+    "borderAccent": "accent",
+    "borderMuted": "dim",
+    "success": "#8fae9a",
+    "error": "#c78388",
+    "warning": "#c7aa78",
+    "muted": "muted",
+    "dim": "dim",
+    "text": "text",
+    "thinkingText": "muted",
+    "selectedBg": "panelSoft",
+    "scrollbarThumb": "#353a45",
+    "userMessageBg": "#252932",
+    "userMessageText": "text",
+    "customMessageBg": "#27252e",
+    "customMessageText": "text",
+    "customMessageLabel": "#a392bd",
+    "toolPendingBg": "panel",
+    "toolSuccessBg": "panel",
+    "toolErrorBg": "panelError",
+    "toolTitle": "#aeb7c4",
+    "toolOutput": "muted",
+    "mdHeading": "#c5ad82",
+    "mdLink": "accent",
+    "mdLinkUrl": "dim",
+    "mdCode": "#9fb8ba",
+    "mdCodeBlock": "#abb3bd",
+    "mdCodeBlockBorder": "dim",
+    "mdQuote": "muted",
+    "mdQuoteBorder": "border",
+    "mdHr": "dim",
+    "mdListBullet": "accent",
+    "toolDiffAdded": "#88a991",
+    "toolDiffRemoved": "#bd8085",
+    "toolDiffContext": "muted",
+    "syntaxComment": "#6f806f",
+    "syntaxKeyword": "#879fc1",
+    "syntaxFunction": "#b7aa82",
+    "syntaxVariable": "#9db3c5",
+    "syntaxString": "#9caf91",
+    "syntaxNumber": "#ad9dbc",
+    "syntaxType": "#84aaa8",
+    "syntaxOperator": "#aeb3bb",
+    "syntaxPunctuation": "#aeb3bb",
+    "thinkingOff": "dim",
+    "thinkingMinimal": "muted",
+    "thinkingLow": "#718da8",
+    "thinkingMedium": "#829bb5",
+    "thinkingHigh": "#9b8eae",
+    "thinkingXhigh": "#ad88b1",
+    "thinkingMax": "#bd8caf",
+    "bashMode": "#8fae9a"
+  }
+}

package/extensions/muted-theme.ts

@@ -0,0 +1,23 @@
+// The fleet-wide low-contrast pi theme — default for EVERY pi session
+// (companion and the VM per-PR/overseer sessions alike). Tool success
+// intentionally uses the same neutral background as pending tools: command
+// completion must not flash a bright green panel at the operator.
+//
+// VERIFY-ON-PIN: session_start's second argument and ctx.ui.setTheme are the
+// documented 0.84.1 extension API, also exercised by pi's mac-system-theme
+// example.
+import type { ExtensionAPI, ExtensionFactory } from "@earendil-works/pi-coding-agent";
+
+export const MUTED_THEME = "muted";
+
+export function createMutedTheme(): ExtensionFactory {
+  return (pi: ExtensionAPI): void => {
+    pi.on("session_start", (_event, ctx) => {
+      const ui = ctx?.ui as
+        { setTheme?: (theme: string) => { success: boolean; error?: string } } | undefined;
+      const result = ui?.setTheme?.(MUTED_THEME);
+      if (result && !result.success)
+        console.error(`[muted-theme] ${result.error ?? "could not select theme"}`);
+    });
+  };
+}

package/extensions/onboarding.ts

@@ -0,0 +1,233 @@
+// onboarding — the wizard's tool belt. Loaded ONLY by `qcr onboard`
+// (per spawn, `-e`, alongside --no-extensions — no ambient extension rides the
+// onboarding session), never registered globally. pi jiti-loads this TS source
+// on the HOST, so it imports the OnboardingEngine source directly and runs it
+// in-process: pi talks, these deterministic tools act, and the LLM never
+// freestyles a shell command (the built-in belt is read-only by argv).
+//
+// One tool per registered engine step (onboard_<id>), plus:
+//   - onboard_status: reconcile + checklist listing (resume re-verifies every
+//     claimed-done step against reality — the file is never trusted alone);
+//   - finish_and_exit: re-runs the FULL verification; anything red comes back
+//     as the tool result (no exit, ever, while red); all green marks the
+//     checklist complete, writes the companion's first-run marker
+//     (state/companion/first-run.json), and triggers pi's deferred shutdown —
+//     the `qcr onboard` process then opens the TUI.
+//
+// Convention notes (same shape as companion-guard/tui-view): degrade, never
+// wedge — a pi without registerTool registers nothing and says so; a missing
+// ctx.shutdown falls back to telling the operator to /exit.
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type {
+  ExtensionAPI,
+  ExtensionFactory,
+  ExtensionToolContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  registerQcrTool,
+  textResult as text,
+  type QcrTool,
+} from "@quickchatai/pi-quickreview/extensions/pi-tool.js";
+import {
+  OnboardingEngine,
+  type CheckResult,
+  type OnboardAdapters,
+  type ReconcileReport,
+  type StepStatusLine,
+} from "../src/onboard/engine.js";
+import { defaultSteps } from "../src/onboard/steps/index.js";
+import { locateConfig } from "../src/install.js";
+
+const NO_PARAMS = { type: "object", properties: {} } as const;
+
+// ---- real adapters ----------------------------------------------------------
+
+/** The one real adapter assembly. Steps see the host only through this. */
+export function realAdapters(root: string): OnboardAdapters {
+  return {
+    fetch: (input, init) => fetch(input, init),
+    runner: {
+      run: (cmd, args) =>
+        new Promise((resolvePromise) => {
+          execFile(cmd, args, { timeout: 60_000 }, (err, stdout, stderr) => {
+            const code = err === null ? 0 : typeof err.code === "number" ? err.code : 1;
+            resolvePromise({
+              code,
+              stdout: String(stdout),
+              stderr: err && !stderr ? String(err.message) : String(stderr),
+            });
+          });
+        }),
+    },
+    clock: () => new Date(),
+    host: {
+      nodeVersion: process.version,
+      uid: typeof process.getuid === "function" ? process.getuid() : null,
+      inContainer: existsSync("/.dockerenv"),
+    },
+    // The install locator decides which config.toml the wizard edits —
+    // $QCR_CONFIG, else the install's config home (never the checkout's).
+    paths: { stateDir: join(root, "state"), configPath: locateConfig().path },
+    log: (line) => console.error(line),
+  };
+}
+
+export function buildEngine(root: string): OnboardingEngine {
+  return new OnboardingEngine(defaultSteps(), realAdapters(root));
+}
+
+// ---- rendering --------------------------------------------------------------
+
+export function renderChecks(checks: readonly CheckResult[]): string {
+  return checks.map((c) => `${c.ok ? "✓" : "✗"} ${c.name} — ${c.detail}`).join("\n");
+}
+
+export function renderStatus(
+  lines: readonly StepStatusLine[],
+  reconciled: ReconcileReport,
+): string {
+  const rows = lines.map((l) => {
+    const mark = l.status === "done" ? "[done]" : l.status === "disabled" ? "[skipped]" : "[ ]";
+    return `${mark} ${l.id} — ${l.title}${l.note ? ` (${l.note})` : ""}`;
+  });
+  const demoted = reconciled.demoted.map(
+    (d) => `re-verification demoted ${d.id}: ${d.failures.join("; ")}`,
+  );
+  return [
+    "Onboarding checklist (claimed-done steps were just re-verified against reality):",
+    ...rows,
+    ...demoted,
+  ].join("\n");
+}
+
+// ---- tool belt --------------------------------------------------------------
+
+/**
+ * Build the tool definitions over an engine. `shutdown` is injected so tests
+ * assert the finish tool's refusal/exit behaviour without a pi; activate wires
+ * the real ctx probe.
+ */
+export function toolDefinitions(
+  engine: OnboardingEngine,
+  shutdown: (ctx?: Pick<ExtensionToolContext, "shutdown">) => void,
+): QcrTool[] {
+  const stepTools: QcrTool[] = engine.stepDefs().map((step) => ({
+    name: `onboard_${step.id}`,
+    label: step.title,
+    description:
+      `${step.explain} Deterministic: runs the "${step.id}" onboarding step's real checks and returns one ✓/✗ line per check. ` +
+      "Safe to re-run; a failed run leaves the step pending.",
+    promptSnippet: `Run the ${step.id} onboarding step`,
+    // A step that needs the operator's answer declares its own schema; the
+    // params land on the step as ctx.input (the ingress choice is one).
+    // Everything else takes no input at all.
+    parameters: step.parameters ?? NO_PARAMS,
+    execute: async (_id, params) => {
+      const result = await engine.runStep(step.id, params ?? {});
+      if (result.ok)
+        return text(`Step "${step.id}" completed and recorded.\n${renderChecks(result.checks)}`);
+      // A refusal (a disabled or unknown step) runs no checks: its reason is
+      // the engine's failures, and there are no red checks to fix.
+      if (result.checks.length === 0)
+        return text(
+          `Step "${step.id}" REFUSED — ${result.failures.join("; ") || "no reason given"}.`,
+        );
+      return text(
+        `Step "${step.id}" FAILED — fix the red checks and run it again.\n${renderChecks(result.checks)}`,
+      );
+    },
+  }));
+
+  const status: QcrTool = {
+    name: "onboard_status",
+    label: "Onboarding status",
+    description:
+      "The checklist: every step in order with its status. Re-verifies each claimed-done step against reality first " +
+      "(the state file is never trusted alone), so call this at the start of every session and after anything changes outside the tools.",
+    promptSnippet: "Read and re-verify the onboarding checklist",
+    parameters: NO_PARAMS,
+    execute: async () => {
+      const reconciled = await engine.reconcile();
+      return text(renderStatus(engine.list(), reconciled));
+    },
+  };
+
+  const finish: QcrTool = {
+    name: "finish_and_exit",
+    label: "Finish onboarding",
+    description:
+      "Re-run EVERY verification. While anything is red this refuses and returns the failures — it never exits on red. " +
+      "When all green it marks onboarding complete, writes the companion first-run marker, and shuts this session down; " +
+      "the wizard process then opens the TUI.",
+    promptSnippet: "Verify everything and, only when green, finish onboarding",
+    parameters: NO_PARAMS,
+    execute: async (_id, _params, _signal, _onUpdate, ctx) => {
+      const result = await engine.finish();
+      if (!result.ok) {
+        const red = result.results
+          .filter((r) => !r.ok)
+          .map((r) => `✗ ${r.id}: ${r.failures.join("; ") || "not verified"}`);
+        return text(
+          `Not finished — these verifications are red:\n${red.join("\n")}\n` +
+            "Fix them (or run the step tools again), then call finish_and_exit once more.",
+        );
+      }
+      // Green: shut down AFTER this result is returned. The 250ms defer is
+      // belt-and-braces so the model sees the confirmation first.
+      // VERIFY-ON-PIN: ctx.shutdown's own idle-deferral (pi's ExtensionContext) may
+      // make the timer redundant — the onboarding smoke step is the evidence.
+      setTimeout(() => shutdown(ctx), 250);
+      return text(
+        `Every step verified green — onboarding is complete (recorded ${result.completed_at}).\n` +
+          `${result.marker_written ? "First-run marker written for the companion greeting." : "First-run marker already present — left untouched."}\n` +
+          "This session now shuts down and the TUI opens.",
+      );
+    },
+  };
+
+  return [...stepTools, status, finish];
+}
+
+// ---- activation -------------------------------------------------------------
+
+export interface OnboardingConfig {
+  /** The checkout the wizard inspects and writes the install's config for. */
+  root: string;
+}
+
+/** The root the env describes: QCR_ROOT, else `cwd`. */
+export function onboardingConfigFromEnv(env: NodeJS.ProcessEnv, cwd: string): OnboardingConfig {
+  return { root: env.QCR_ROOT ?? cwd };
+}
+
+/** The factory that registers the wizard's tools. The env shim is
+ * extensions/cli/onboarding.ts. */
+export function createOnboarding(config: OnboardingConfig): ExtensionFactory {
+  return (pi) => registerOnboarding(pi, config);
+}
+
+function registerOnboarding(pi: ExtensionAPI, config: OnboardingConfig): void {
+  if (typeof pi.registerTool !== "function") {
+    // Degrade loudly, never wedge: pi still starts, the guide can only talk.
+    console.error(
+      "onboarding: pi.registerTool unavailable — no wizard tools registered; this pi cannot run onboarding.",
+    );
+    return;
+  }
+  const engine = buildEngine(config.root);
+  const shutdown = (ctx?: Pick<ExtensionToolContext, "shutdown">): void => {
+    const fn = ctx?.shutdown ?? (pi as { shutdown?: () => void | Promise<void> }).shutdown;
+    if (typeof fn === "function") {
+      // VERIFY-ON-PIN: deferred clean shutdown with exit code 0 (pi 1.4.0's
+      // ExtensionContext.shutdown). Bound to the named onboarding smoke step.
+      void fn.call(ctx ?? pi);
+    } else {
+      console.error(
+        "onboarding: no shutdown API on this pi — type /exit to leave; the wizard will open the TUI.",
+      );
+    }
+  };
+  for (const def of toolDefinitions(engine, shutdown)) registerQcrTool(pi, def);
+}