@quickchatai/quickreview 1.1.0 → 1.3.1

package/extensions/login-route.ts

@@ -0,0 +1,220 @@
+// login-route — a pi that has no usable model login says so, and opens pi's
+// own /login; a pi whose model names one OpenAI provider while the person
+// logged in with the other runs the same model on the login that exists.
+//
+// Loaded by every CLI pi Quickreview starts for a person: the onboarding
+// wizard (registered by extensions/onboarding.ts, which opens the login for
+// the person), the companion, a takeover and a debug round (the env shim
+// extensions/cli/login-route.ts, which prefills it). An SDK session needs none
+// of this: PiHost routes its model the same way (packages/pi-plugin/src/engine/pisdk.ts).
+//
+// Three behaviours, each on pi's own API:
+//   - Model route. On session_start and before every prompt (the `input`
+//     event, which pi runs before it checks the model's credential), a model
+//     whose provider has no credential is switched to its OpenAI twin when the
+//     twin has one and serves the same id (packages/pi-plugin/src/modelroute.ts).
+//     The provider the spec names always wins when its login exists, so an
+//     install that works today is untouched. pi.setModel does not persist the
+//     switch to settings.
+//   - Login hint. When no usable model is left, a widget says exactly what to
+//     do, and pi's input line holds `/login`, so one Enter opens pi's login.
+//     The widget clears once a model is selected (`model_select`).
+//   - Open (the wizard only). pi runs `/login` only from its editor's submit
+//     (an extension cannot call the command), and the one public way to reach
+//     that submit is an editor component: pi wires its own submit handler
+//     onto every editor an extension installs. So the login is opened by
+//     installing a stock CustomEditor for an instant, submitting `/login`
+//     through the handler pi gave it, and restoring the editor that was there.
+//     When that wiring is not found, the prefilled `/login` is the fallback.
+import {
+  CustomEditor,
+  type ExtensionAPI,
+  type ExtensionContext,
+  type ExtensionFactory,
+  type ExtensionUIContext,
+} from "@earendil-works/pi-coding-agent";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { routeProvider, twinProvider } from "@quickchatai/pi-quickreview/src/modelroute.js";
+
+/** The widget key the hint is shown under. */
+export const LOGIN_WIDGET = "qcr-login";
+
+/** The command the hint prefills and the wizard submits: pi's own login,
+ * with every provider it offers. */
+export const LOGIN_COMMAND = "/login";
+
+/** What the person reads above the input line while no model is usable:
+ * which logins work and how to reach them in pi's menu (pi 1.4.0's labels),
+ * then how to (re)open the menu. `opened` says whether the menu is on screen. */
+export function loginHintLines(opened: boolean): string[] {
+  return [
+    "Quickreview needs a model login before it can do anything. Any OpenAI login works:",
+    '  - "Sign in with an account", then "OpenAI" (Sign in with ChatGPT) or "OpenAI Codex (legacy)";',
+    '  - "Sign in with an API key", then type openai, pick "OpenAI" and paste your key (sk-...).',
+    opened
+      ? `pi's login menu is open below. Closed it? Type ${LOGIN_COMMAND} and press Enter.`
+      : `Press Enter to open pi's login menu (${LOGIN_COMMAND} is on the input line).`,
+  ];
+}
+
+/** How a pi opens the login when it needs one. */
+export type LoginOpen = "submit" | "prefill";
+
+export interface LoginRouteConfig {
+  /** "submit" opens pi's login menu; "prefill" leaves `/login` on the input
+   * line for one Enter. */
+  open: LoginOpen;
+}
+
+/** The config the env describes: QCR_LOGIN_OPEN=submit, else prefill. */
+export function loginRouteConfigFromEnv(env: NodeJS.ProcessEnv): LoginRouteConfig {
+  return { open: env.QCR_LOGIN_OPEN === "submit" ? "submit" : "prefill" };
+}
+
+/** What the model route did. */
+export type ModelRouteOutcome =
+  /** The current model's provider has a credential. */
+  | "usable"
+  /** The model was moved to its OpenAI twin, whose login exists. */
+  | "switched"
+  /** There is a model, and neither it nor a twin has a credential. */
+  | "unusable"
+  /** There is no model at all. */
+  | "none";
+
+type Registry = Pick<
+  ExtensionContext["modelRegistry"],
+  "find" | "getAvailable" | "getProviderAuthStatus"
+>;
+
+function hasCredential(registry: Registry, provider: string): boolean {
+  try {
+    return registry.getProviderAuthStatus(provider).configured;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Keep the session's model on a login that exists: the model as it is when its
+ * provider has a credential, else its OpenAI twin when that has one.
+ *
+ * VERIFY-ON-PIN (pi 1.4.0): ModelRegistry.getProviderAuthStatus(p).configured
+ * covers a stored login, a stored or runtime key and an environment key, and
+ * the extension pi.setModel returns false (switching nothing) for a provider
+ * without a credential.
+ */
+export async function routeSessionModel(
+  pi: Pick<ExtensionAPI, "setModel">,
+  ctx: { model: Model<Api> | undefined; modelRegistry: Registry },
+): Promise<ModelRouteOutcome> {
+  const model = ctx.model;
+  if (!model) return "none";
+  const registry = ctx.modelRegistry;
+  if (hasCredential(registry, model.provider)) return "usable";
+  if (twinProvider(model.provider) === undefined) return "unusable";
+  const provider = routeProvider(model.provider, model.id, {
+    hasCredential: (p) => hasCredential(registry, p),
+    hasModel: (p, id) => registry.find(p, id) !== undefined,
+  });
+  if (provider === model.provider) return "unusable";
+  const twin = registry.find(provider, model.id);
+  if (twin && (await pi.setModel(twin))) return "switched";
+  return "unusable";
+}
+
+/** Does this pi need a login: no usable model, and none pi could pick? */
+export function needsLogin(outcome: ModelRouteOutcome, registry: Registry): boolean {
+  if (outcome === "usable" || outcome === "switched") return false;
+  if (outcome === "unusable") return true;
+  try {
+    return registry.getAvailable().length === 0;
+  } catch {
+    return true;
+  }
+}
+
+type EditorUi = Pick<ExtensionUIContext, "setEditorComponent" | "getEditorComponent">;
+type MakeEditor = Parameters<ExtensionUIContext["setEditorComponent"]>[0] & {};
+
+/**
+ * Submit `text` through pi's own editor submit, as if typed and Entered. pi
+ * runs its built-in commands (`/login` among them) only from that handler, and
+ * hands it to every editor component an extension installs: so a stock editor
+ * is installed, its handler taken, and the previous editor (pi's default, or
+ * another extension's) restored before anything renders. Returns false, having
+ * submitted nothing, when pi did not wire a handler.
+ *
+ * VERIFY-ON-PIN (pi 1.4.0, interactive-mode.js setCustomEditorComponent):
+ * `newEditor.onSubmit = this.defaultEditor.onSubmit` runs synchronously inside
+ * setEditorComponent, and setEditorComponent(undefined) restores the default
+ * editor with its text.
+ */
+export function submitThroughEditor(
+  ui: EditorUi,
+  text: string,
+  makeEditor: MakeEditor = (tui, theme, keybindings) => new CustomEditor(tui, theme, keybindings),
+): boolean {
+  let made: { onSubmit?: (text: string) => void } | undefined;
+  const previous = ui.getEditorComponent();
+  try {
+    ui.setEditorComponent((tui, theme, keybindings) => {
+      const editor = makeEditor(tui, theme, keybindings);
+      made = editor;
+      return editor;
+    });
+  } catch {
+    made = undefined;
+  }
+  const submit = made?.onSubmit;
+  ui.setEditorComponent(previous);
+  if (typeof submit !== "function") return false;
+  void Promise.resolve()
+    .then(() => submit(text))
+    .catch(() => undefined);
+  return true;
+}
+
+type HintUi = Pick<ExtensionUIContext, "setWidget" | "setEditorText"> & EditorUi;
+
+/** Show the hint and open (or prefill) pi's login. Returns how it was opened. */
+export function openLogin(ui: HintUi, open: LoginOpen): "submitted" | "prefilled" {
+  if (open === "submit" && submitThroughEditor(ui, LOGIN_COMMAND)) {
+    ui.setWidget(LOGIN_WIDGET, loginHintLines(true), { placement: "aboveEditor" });
+    return "submitted";
+  }
+  ui.setWidget(LOGIN_WIDGET, loginHintLines(false), { placement: "aboveEditor" });
+  ui.setEditorText(LOGIN_COMMAND);
+  return "prefilled";
+}
+
+/** Register the model route and the login hint on `pi`. Exported so a host that
+ * builds its own onboarding extension (over `toolDefinitions`) gets the same
+ * first-run login as the onboarding wizard. */
+export function registerLoginRoute(pi: ExtensionAPI, config: LoginRouteConfig): void {
+  if (typeof pi.on !== "function") return;
+  let shown = false;
+  pi.on("session_start", async (_event, ctx) => {
+    const outcome = await routeSessionModel(pi, ctx);
+    if (!ctx.hasUI || !needsLogin(outcome, ctx.modelRegistry)) return;
+    shown = true;
+    openLogin(ctx.ui, config.open);
+  });
+  // pi checks the model's credential after this event, so a login made inside
+  // the session (its default model stays the spec's provider) is routed here.
+  pi.on("input", async (_event, ctx) => {
+    await routeSessionModel(pi, ctx);
+    return { action: "continue" };
+  });
+  pi.on("model_select", (_event, ctx) => {
+    if (!shown || !ctx.hasUI) return;
+    shown = false;
+    ctx.ui.setWidget(LOGIN_WIDGET, undefined);
+  });
+}
+
+/** The factory, for a pi that loads the route by path (its shim) or a host
+ * that composes factories. */
+export function createLoginRoute(config: LoginRouteConfig): ExtensionFactory {
+  return (pi) => registerLoginRoute(pi, config);
+}

package/extensions/onboarding.ts

@@ -1,6 +1,8 @@
-// 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
+// onboarding — the wizard's tool belt. Loaded ONLY by a pi started with it
+// named by path (its env shim, extensions/cli/onboarding.ts, as `-e` alongside
+// --no-extensions, so no ambient extension rides that session), never
+// registered globally. No qcr verb starts such a session any more: the home
+// runs the wizard's steps itself (src/home/switchon.ts, Advanced). 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).
@@ -11,8 +13,7 @@
 //   - 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.
+//     (state/companion/first-run.json), and triggers pi's deferred shutdown.
 //
 // Convention notes (same shape as companion-guard/tui-view): degrade, never
 // wedge — a pi without registerTool registers nothing and says so; a missing
@@ -38,7 +39,14 @@ import {
   type StepStatusLine,
 } from "../src/onboard/engine.js";
 import { defaultSteps } from "../src/onboard/steps/index.js";
+import { openStepMemoryForward } from "../src/onboard/stepforward.js";
 import { locateConfig } from "../src/install.js";
+import { registerLoginRoute } from "./login-route.js";
+import {
+  ONBOARD_FINISH_TOOL,
+  ONBOARD_STATUS_TOOL,
+  onboardStepToolName,
+} from "../src/onboard/toolnames.js";
 
 const NO_PARAMS = { type: "object", properties: {} } as const;
 
@@ -71,6 +79,7 @@ export function realAdapters(root: string): OnboardAdapters {
     // $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),
+    memoryForward: (req) => openStepMemoryForward(req),
   };
 }
 
@@ -89,7 +98,14 @@ export function renderStatus(
   reconciled: ReconcileReport,
 ): string {
   const rows = lines.map((l) => {
-    const mark = l.status === "done" ? "[done]" : l.status === "disabled" ? "[skipped]" : "[ ]";
+    const mark =
+      l.status === "done"
+        ? "[done]"
+        : l.status === "disabled"
+          ? "[skipped]"
+          : l.optional
+            ? "[after setup]"
+            : "[ ]";
     return `${mark} ${l.id} — ${l.title}${l.note ? ` (${l.note})` : ""}`;
   });
   const demoted = reconciled.demoted.map(
@@ -114,7 +130,7 @@ export function toolDefinitions(
   shutdown: (ctx?: Pick<ExtensionToolContext, "shutdown">) => void,
 ): QcrTool[] {
   const stepTools: QcrTool[] = engine.stepDefs().map((step) => ({
-    name: `onboard_${step.id}`,
+    name: onboardStepToolName(step.id),
     label: step.title,
     description:
       `${step.explain} Deterministic: runs the "${step.id}" onboarding step's real checks and returns one ✓/✗ line per check. ` +
@@ -141,7 +157,7 @@ export function toolDefinitions(
   }));
 
   const status: QcrTool = {
-    name: "onboard_status",
+    name: ONBOARD_STATUS_TOOL,
     label: "Onboarding status",
     description:
       "The checklist: every step in order with its status. Re-verifies each claimed-done step against reality first " +
@@ -155,7 +171,7 @@ export function toolDefinitions(
   };
 
   const finish: QcrTool = {
-    name: "finish_and_exit",
+    name: ONBOARD_FINISH_TOOL,
     label: "Finish onboarding",
     description:
       "Re-run EVERY verification. While anything is red this refuses and returns the failures — it never exits on red. " +
@@ -167,7 +183,7 @@ export function toolDefinitions(
       const result = await engine.finish();
       if (!result.ok) {
         const red = result.results
-          .filter((r) => !r.ok)
+          .filter((r) => !r.ok && !r.optional)
           .map((r) => `✗ ${r.id}: ${r.failures.join("; ") || "not verified"}`);
         return text(
           `Not finished — these verifications are red:\n${red.join("\n")}\n` +
@@ -182,7 +198,8 @@ export function toolDefinitions(
       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.",
+          "This session now shuts down and the TUI opens: the board lists the repository's open pull requests — " +
+          "select one and press R to review it now (dry-run: nothing is posted).",
       );
     },
   };
@@ -208,7 +225,20 @@ export function createOnboarding(config: OnboardingConfig): ExtensionFactory {
   return (pi) => registerOnboarding(pi, config);
 }
 
+/**
+ * The onboarding session's first-run login: when pi has no usable model
+ * login, pi's own /login menu opens with a widget that says which logins work
+ * (any OpenAI one), and an OpenAI model whose provider has no login runs on
+ * the twin login that exists (extensions/login-route.ts). The wizard's
+ * session registers it with the tools; a host that builds its own onboarding
+ * extension over `toolDefinitions` + `registerQcrTool` calls it too.
+ */
+export function registerOnboardingSession(pi: ExtensionAPI): void {
+  registerLoginRoute(pi, { open: "submit" });
+}
+
 function registerOnboarding(pi: ExtensionAPI, config: OnboardingConfig): void {
+  registerOnboardingSession(pi);
   if (typeof pi.registerTool !== "function") {
     // Degrade loudly, never wedge: pi still starts, the guide can only talk.
     console.error(

package/extensions/selfimprove.ts

@@ -0,0 +1,65 @@
+// /selfimprove in the app's own pi (`qcr pi`, src/npmverbs.ts): scan this
+// repo, then have this session's agent fix the findings (src/selfimprove.ts).
+// The plugin, loaded beside it, carries /qcr-review, /qcr-scan and /qcr-setup;
+// this command is the app's (ADR 0001). A factory over its config: the env
+// shim extensions/cli/selfimprove.ts reads the process.
+import {
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import { hostAuth, sessionUi } from "@quickchatai/pi-quickreview/extensions/quickreview.js";
+import type { PluginHost, Runner } from "@quickchatai/pi-quickreview/src/plugin/session.js";
+import { runSelfImproveCommand } from "../src/selfimprove.js";
+
+export interface SelfImproveConfig {
+  /** The process environment, read once by the shim. */
+  env: NodeJS.ProcessEnv;
+  /** The user's home. */
+  home: string;
+  runner: Runner;
+  /** Standard output (pi's print mode shows a command's result there). */
+  print: (text: string) => void;
+  /** Test seams: the running pi's version and its agent dir. */
+  piVersion?: string;
+  agentDir?: string;
+}
+
+/** The extension factory: registers /selfimprove, one run at a time. */
+export function createSelfImprove(config: SelfImproveConfig): (pi: ExtensionAPI) => void {
+  return (pi) => {
+    // The current session's end: a scan in flight stops with it.
+    let shutdown = new AbortController();
+    pi.on("session_start", () => {
+      if (shutdown.signal.aborted) shutdown = new AbortController();
+    });
+    pi.on("session_shutdown", () => shutdown.abort());
+    let busy = false;
+    pi.registerCommand("selfimprove", {
+      description: "QuickReview: scan this repo, then have this session's agent fix the findings",
+      handler: async (args: string, ctx: ExtensionCommandContext) => {
+        if (busy) {
+          ctx.ui.notify("/selfimprove is already running in this session", "warning");
+          return;
+        }
+        busy = true;
+        try {
+          const agentDir = config.agentDir ?? getAgentDir();
+          const host: PluginHost = {
+            cwd: ctx.cwd,
+            env: config.env,
+            home: config.home,
+            piVersion: config.piVersion ?? "",
+            agentDir,
+            auth: hostAuth(ctx, agentDir),
+            runner: config.runner,
+            shutdown: shutdown.signal,
+          };
+          await runSelfImproveCommand(args.trim(), host, sessionUi(pi, ctx, config.print));
+        } finally {
+          busy = false;
+        }
+      },
+    });
+  };
+}