pi-advisor-flow 0.6.0 → 0.8.0

package/src/ui/jev-setup-submenu.ts

@@ -0,0 +1,350 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import type { Component, Focusable } from "@earendil-works/pi-tui";
+import { noul } from "@typesafe-ai/sdk";
+
+import { jevClientFromCredentials } from "../jev/client.ts";
+import {
+  clearKeyTypeSafeKey,
+  consumePlaintextKeyWarning,
+  removeTypeSafeKeyFromAdvisorJson,
+  writeKeyTypeSafeKey,
+} from "../jev/key-store.ts";
+import type { JevKeyStoreResult } from "../jev/key-store.ts";
+import { resolveJevTransport } from "../jev/transport.ts";
+import type { JevCredentials } from "../jev/transport.ts";
+import { MaskedInput } from "./masked-input.ts";
+import type { RenderRequester } from "./types.ts";
+
+export interface JevSetupSubmenuOptions {
+  currentValue: string;
+  done: (selectedValue?: string) => void;
+  theme: Theme;
+  tui: RenderRequester;
+}
+
+export interface JevSetupDeps {
+  clearStoredKey?: () => Promise<JevKeyStoreResult>;
+  removePlaintextKey?: () => JevKeyStoreResult;
+  resolveTransport?: () => Promise<JevCredentials | undefined>;
+  verify?: (credentials: JevCredentials) => Promise<JevFailureLike>;
+  writeKey?: (key: string) => Promise<JevKeyStoreResult>;
+}
+
+interface JevFailureLike {
+  message?: string;
+  ok: boolean;
+}
+
+type SetupMode = "menu" | "key-entry" | "verifying";
+type SetupAction =
+  | "verify-enable"
+  | "verify-again"
+  | "disable"
+  | "disable-clear"
+  | "enter-key"
+  | "done";
+
+const ACTION_LABELS: Record<SetupAction, string> = {
+  disable: "Disable",
+  "disable-clear": "Disable and clear stored key",
+  done: "Done",
+  "enter-key": "Enter a TypeSafe API key",
+  "verify-again": "Verify again",
+  "verify-enable": "Verify and enable",
+};
+
+const fireAndForget = async (action: Promise<unknown>): Promise<void> => {
+  try {
+    await action;
+  } catch {
+    // Background setup actions surface their own notices.
+  }
+};
+
+const transportLabel = (credentials: JevCredentials): string => {
+  if (credentials.transport === "openrouter") {
+    return "OpenRouter (reusing pi login)";
+  }
+  switch (credentials.source) {
+    case "advisor-json": {
+      return "TypeSafe (key: advisor.json — plaintext, not recommended)";
+    }
+    case "bun-secrets": {
+      return "TypeSafe (key: Bun.secrets)";
+    }
+    case "file": {
+      return "TypeSafe (key: stored file, mode 0600)";
+    }
+    default: {
+      return "TypeSafe (key: TYPESAFE_API_KEY)";
+    }
+  }
+};
+
+const defaultVerify = async (credentials: JevCredentials) => {
+  const client = jevClientFromCredentials(credentials);
+  try {
+    await client.ask(
+      { purpose: "pi-advisor setup verification" },
+      { verified: noul("Answer yes.") }
+    );
+    return { ok: true };
+  } catch (error) {
+    return {
+      message: error instanceof Error ? error.message : String(error),
+      ok: false,
+    };
+  }
+};
+
+/** Guided Jev credentials setup: detects a reusable login, verifies live
+ * before enabling, and never echoes an entered key back. */
+export class JevSetupSubmenu implements Component, Focusable {
+  private readonly options: JevSetupSubmenuOptions;
+  private readonly deps: JevSetupDeps;
+  private readonly maskedInput: MaskedInput;
+  private credentials: JevCredentials | undefined;
+  private mode: SetupMode = "menu";
+  private notice: string | undefined;
+  private selectedIndex = 0;
+  private _focused = true;
+
+  constructor(options: JevSetupSubmenuOptions, deps: JevSetupDeps = {}) {
+    this.options = options;
+    this.deps = {
+      clearStoredKey: deps.clearStoredKey ?? clearKeyTypeSafeKey,
+      removePlaintextKey:
+        deps.removePlaintextKey ?? removeTypeSafeKeyFromAdvisorJson,
+      resolveTransport: deps.resolveTransport ?? (() => resolveJevTransport()),
+      verify: deps.verify ?? defaultVerify,
+      writeKey: deps.writeKey ?? writeKeyTypeSafeKey,
+    };
+    this.maskedInput = new MaskedInput({
+      onEscape: () => this.options.done(),
+      onSubmit: (value) => this.submitEnteredKey(value),
+      placeholder: "Paste a TypeSafe API key",
+    });
+    void fireAndForget(this.refresh());
+  }
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.maskedInput.focused = value;
+  }
+
+  invalidate(): void {
+    this.maskedInput.invalidate();
+  }
+
+  handleInput(keyData: string): void {
+    if (this.mode === "key-entry") {
+      this.maskedInput.handleInput(keyData);
+      this.options.tui.requestRender();
+      return;
+    }
+    if (this.mode !== "menu") {
+      return;
+    }
+    const actions = this.actions();
+    if (
+      matchesKey(keyData, Key.down) ||
+      keyData === "\u001B[B" ||
+      keyData === "\u001BOB"
+    ) {
+      this.selectedIndex = (this.selectedIndex + 1) % actions.length;
+    } else if (
+      matchesKey(keyData, Key.up) ||
+      keyData === "\u001B[A" ||
+      keyData === "\u001BOA"
+    ) {
+      this.selectedIndex =
+        (this.selectedIndex - 1 + actions.length) % actions.length;
+    } else if (matchesKey(keyData, Key.enter) || keyData === "\r") {
+      this.activate(actions[this.selectedIndex]);
+    } else {
+      return;
+    }
+    this.options.tui.requestRender();
+  }
+
+  render(width: number): string[] {
+    const { theme } = this.options;
+    const enabled = this.options.currentValue === "On";
+    const lines = [
+      theme.fg("accent", theme.bold("  Jev consultation filter")),
+      "",
+    ];
+    if (this.credentials) {
+      lines.push(
+        `  Transport: ${transportLabel(this.credentials)}`,
+        `  Filter: ${enabled ? "On" : "Off"}`
+      );
+    } else if (this.mode === "verifying") {
+      lines.push("  Checking available Jev credentials…");
+    } else {
+      lines.push(
+        "  No Jev credentials found. Enter a TypeSafe API key below, or add",
+        "  an OpenRouter login in pi; it is reused automatically."
+      );
+    }
+    if (this.notice) {
+      lines.push("", theme.fg("warning", `  ${this.notice}`));
+    }
+    lines.push("");
+    if (this.mode === "verifying") {
+      lines.push("  Verifying with a live Jev call…");
+    } else if (this.mode === "key-entry") {
+      lines.push(
+        `  ${this.maskedInput.render(Math.max(10, width - 4))[0] ?? ""}`,
+        theme.fg("dim", "  Enter: verify · Esc: cancel")
+      );
+    } else {
+      for (const [index, label] of this.labels().entries()) {
+        const prefix = index === this.selectedIndex ? "→ " : "  ";
+        lines.push(`${prefix}${label}`);
+      }
+    }
+    return lines.map((line) => truncateToWidth(line, width));
+  }
+
+  private actions(): SetupAction[] {
+    if (!this.credentials) {
+      return ["enter-key", "done"];
+    }
+    const enabled = this.options.currentValue === "On";
+    const actions: SetupAction[] = [enabled ? "verify-again" : "verify-enable"];
+    actions.push("disable");
+    if (
+      this.credentials.source === "bun-secrets" ||
+      this.credentials.source === "file"
+    ) {
+      actions.push("disable-clear");
+    }
+    actions.push("done");
+    return actions;
+  }
+
+  private labels(): string[] {
+    return this.actions().map((action) => ACTION_LABELS[action]);
+  }
+
+  private async refresh(): Promise<void> {
+    const wasVerifying = this.mode === "verifying";
+    this.mode = "verifying";
+    if (!wasVerifying) {
+      this.options.tui.requestRender();
+    }
+    this.credentials = await this.deps.resolveTransport?.();
+    this.mode = "menu";
+    this.selectedIndex = 0;
+    if (this.credentials?.source === "advisor-json") {
+      this.notice ??= consumePlaintextKeyWarning();
+    }
+    this.options.tui.requestRender();
+  }
+
+  private activate(action: SetupAction): void {
+    if (action === "done") {
+      this.options.done();
+      return;
+    }
+    if (action === "enter-key") {
+      this.mode = "key-entry";
+      return;
+    }
+    if (action === "disable") {
+      this.notice = undefined;
+      this.options.done("Off");
+      return;
+    }
+    if (action === "disable-clear") {
+      void fireAndForget(this.disableAndClear());
+      return;
+    }
+    if (action === "verify-again" || action === "verify-enable") {
+      void fireAndForget(this.verifyAndEnable());
+    }
+  }
+
+  private async disableAndClear(): Promise<void> {
+    const clear = this.deps.clearStoredKey;
+    if (!clear) {
+      return;
+    }
+    const result = await clear();
+    this.credentials = undefined;
+    this.notice = result.message;
+    this.options.done("Off");
+  }
+
+  private async verifyAndEnable(): Promise<void> {
+    const { credentials } = this;
+    if (!(credentials && this.deps.verify)) {
+      return;
+    }
+    this.mode = "verifying";
+    this.notice = undefined;
+    this.options.tui.requestRender();
+    const outcome = await this.deps.verify(credentials);
+    this.mode = "menu";
+    if (!outcome.ok) {
+      this.notice = `Verification failed: ${outcome.message ?? "unknown error"}`;
+      this.options.tui.requestRender();
+      return;
+    }
+    if (
+      credentials.transport === "typesafe" &&
+      credentials.source === "advisor-json"
+    ) {
+      const stored = await this.deps.writeKey?.(credentials.apiKey);
+      if (!stored?.ok) {
+        this.notice =
+          stored?.message ??
+          "Storing the key failed; the plaintext advisor.json key keeps working.";
+        this.options.tui.requestRender();
+        return;
+      }
+      const removed = this.deps.removePlaintextKey?.();
+      this.notice = removed?.ok
+        ? "Key moved from advisor.json into the secure store."
+        : `Stored securely, but ${removed?.message ?? "removing the plaintext copy failed; remove it yourself."}`;
+    }
+    this.options.done("On");
+  }
+
+  private async submitEnteredKey(value: string): Promise<void> {
+    const key = value.trim();
+    if (!key) {
+      return;
+    }
+    if (!this.deps.verify) {
+      return;
+    }
+    this.mode = "verifying";
+    this.options.tui.requestRender();
+    const outcome = await this.deps.verify({
+      apiKey: key,
+      transport: "typesafe",
+    });
+    this.mode = "menu";
+    if (!outcome.ok) {
+      this.notice = `Verification failed: ${outcome.message ?? "unknown error"}`;
+      this.options.tui.requestRender();
+      return;
+    }
+    const stored = await this.deps.writeKey?.(key);
+    if (!stored?.ok) {
+      this.notice = stored?.message ?? "Storing the key failed.";
+      this.options.tui.requestRender();
+      return;
+    }
+    this.notice = `${stored.message} Verification succeeded.`;
+    await this.refresh();
+    this.options.done("On");
+  }
+}

package/src/ui/manual-dialog-render.ts

@@ -3,6 +3,7 @@ import {
   visibleWidth,
   wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
+
 import type { GitContextLevel } from "../git.ts";
 import type { ManualAdvisorDialogView } from "./types.ts";
 

package/src/ui/manual-dialog.ts

@@ -1,29 +1,34 @@
-import {
-  type Component,
-  Editor,
-  type EditorTheme,
-  type Focusable,
-  Key,
-  type Keybindings,
-  type KeyId,
-  matchesKey,
+import { Editor, Key, matchesKey } from "@earendil-works/pi-tui";
+import type {
+  Component,
+  EditorTheme,
+  Focusable,
+  Keybindings,
+  KeyId,
 } from "@earendil-works/pi-tui";
-import {
-  clampGitContextLevel,
-  GIT_CONTEXT_LEVELS,
-  type GitContextLevel,
-} from "../git.ts";
+
+import { clampGitContextLevel, GIT_CONTEXT_LEVELS } from "../git.ts";
+import type { GitContextLevel } from "../git.ts";
 import { renderManualAdvisorDialog } from "./manual-dialog-render.ts";
 import type {
   ManualAdvisorDialogOptions,
   ManualAdvisorFocus,
+  ManualAdvisorRequest,
 } from "./types.ts";
 
-// Keep the keybinding components separate from Socket's URL-string heuristic.
+// SAFETY: the joined literal is exactly the registered "tui.input.tab" keybinding path.
 const TUI_INPUT_TAB: keyof Keybindings = ["tui", "input", "tab"].join(
   "."
 ) as keyof Keybindings;
 
+interface ManualDialogState {
+  completed: boolean;
+  focused: boolean;
+}
+
+const isShiftTab = (keyData: string): boolean =>
+  matchesKey(keyData, Key.shift("tab"));
+
 /** The small, non-persistent /advisor-manual form; callers own budget and consultation decisions. */
 export class ManualAdvisorDialog implements Component, Focusable {
   private readonly options: ManualAdvisorDialogOptions;
@@ -32,7 +37,7 @@ export class ManualAdvisorDialog implements Component, Focusable {
   private gitIndex: number;
   private actionIndex = 0;
   private focusTarget: ManualAdvisorFocus = "editor";
-  private readonly state: { completed: boolean; focused: boolean } = {
+  private readonly state: ManualDialogState = {
     completed: false,
     focused: false,
   };
@@ -54,7 +59,7 @@ export class ManualAdvisorDialog implements Component, Focusable {
     // while the configured level remains the hard ceiling.
     this.gitLevels = GIT_CONTEXT_LEVELS.filter(
       (level) => clampGitContextLevel(level, options.gitContext) === level
-    ).reverse();
+    ).toReversed();
     this.gitIndex = Math.max(0, this.gitLevels.indexOf(options.gitContext));
 
     const editorTheme: EditorTheme = {
@@ -90,7 +95,7 @@ export class ManualAdvisorDialog implements Component, Focusable {
       this.cancel();
       return;
     }
-    if (this.isShiftTab(keyData)) {
+    if (isShiftTab(keyData)) {
       this.changeFocus(-1);
       return;
     }
@@ -98,24 +103,12 @@ export class ManualAdvisorDialog implements Component, Focusable {
       this.changeFocus(1);
       return;
     }
-
-    switch (this.focusTarget) {
-      case "editor":
-        // Editor owns Enter/Shift+Enter and all cursor/editing semantics. Its
-        // onSubmit callback above is the sole editor submission path. At the
-        // edge of the message, a directional key also moves to the adjacent
-        // form control so the Git selector is reachable without Tab.
-        this.handleEditorInput(keyData);
-        return;
-      case "git":
-        this.handleGitInput(keyData);
-        return;
-      case "actions":
-        this.handleActionInput(keyData);
-        return;
-      default:
-        return;
-    }
+    const handlers: Record<ManualAdvisorFocus, (keyData: string) => void> = {
+      actions: (key) => this.handleActionInput(key),
+      editor: (key) => this.handleEditorInput(key),
+      git: (key) => this.handleGitInput(key),
+    };
+    handlers[this.focusTarget](keyData);
   }
 
   render(width: number): string[] {
@@ -137,6 +130,10 @@ export class ManualAdvisorDialog implements Component, Focusable {
   }
 
   private handleEditorInput(keyData: string): void {
+    // Editor owns Enter/Shift+Enter and all cursor/editing semantics. Its
+    // onSubmit callback above is the sole editor submission path. At the
+    // edge of the message, a directional key also moves to the adjacent
+    // form control so the Git selector is reachable without Tab.
     let direction: -1 | 1 | undefined;
     if (this.matches(keyData, "tui.editor.cursorDown", Key.down)) {
       direction = 1;
@@ -257,10 +254,6 @@ export class ManualAdvisorDialog implements Component, Focusable {
     );
   }
 
-  private isShiftTab(keyData: string): boolean {
-    return matchesKey(keyData, Key.shift("tab"));
-  }
-
   private isCancel(keyData: string): boolean {
     return (
       matchesKey(keyData, Key.escape) ||
@@ -284,10 +277,13 @@ export class ManualAdvisorDialog implements Component, Focusable {
       return;
     }
     this.state.completed = true;
-    this.options.onSubmit({
+    const request: ManualAdvisorRequest = {
       gitContext: this.gitLevels[this.gitIndex] ?? "off",
-      ...(message ? { message } : {}),
-    });
+    };
+    if (message) {
+      request.message = message;
+    }
+    this.options.onSubmit(request);
   }
 
   private cancel(): void {

package/src/ui/masked-input.ts

@@ -0,0 +1,62 @@
+import { Input, truncateToWidth } from "@earendil-works/pi-tui";
+import type { Component, Focusable } from "@earendil-works/pi-tui";
+
+export interface MaskedInputOptions {
+  onEscape?: () => void;
+  onSubmit?: (value: string) => void;
+  placeholder?: string;
+}
+
+type InputWithCursor = Input & { cursor: number };
+
+/** Single-line secret input rendering bullets; the value never reaches the screen. */
+export class MaskedInput implements Component, Focusable {
+  private readonly input: Input;
+  private readonly options: MaskedInputOptions;
+  private _focused = true;
+
+  constructor(options: MaskedInputOptions = {}) {
+    this.options = options;
+    this.input = new Input({ placeholder: options.placeholder });
+    this.input.focused = true;
+    this.input.onSubmit = (value) => options.onSubmit?.(value);
+    this.input.onEscape = () => options.onEscape?.();
+  }
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.input.focused = value;
+  }
+
+  getValue(): string {
+    return this.input.getValue();
+  }
+
+  setValue(value: string): void {
+    this.input.setValue(value);
+  }
+
+  handleInput(keyData: string): void {
+    this.input.handleInput(keyData);
+  }
+
+  invalidate(): void {
+    this.input.invalidate();
+  }
+
+  render(width: number): string[] {
+    const value = this.input.getValue();
+    // SAFETY: compatibility-only read of Input's private cursor; Input does not expose it.
+    const { cursor } = this.input as InputWithCursor;
+    const masked = `${"•".repeat(Math.min(cursor, value.length))}█${"•".repeat(Math.max(0, value.length - cursor))}`;
+    const placeholder =
+      value.length === 0 && this.options.placeholder
+        ? this.options.placeholder
+        : masked;
+    return [truncateToWidth(placeholder, Math.max(1, width))];
+  }
+}

package/src/ui/model-multi-selector.ts

@@ -0,0 +1,9 @@
+import { ModelSelectorAdapter } from "./model-selector-adapter.ts";
+import { SearchableModelList } from "./searchable-model-list.ts";
+import type { SearchableModelMultiSelectorOptions } from "./types.ts";
+
+export class SearchableModelMultiSelector extends ModelSelectorAdapter {
+  constructor(options: SearchableModelMultiSelectorOptions) {
+    super(new SearchableModelList(options));
+  }
+}

package/src/ui/model-selector-adapter.ts

@@ -0,0 +1,31 @@
+import type { Component, Focusable } from "@earendil-works/pi-tui";
+
+import type { SearchableModelList } from "./searchable-model-list.ts";
+
+export class ModelSelectorAdapter implements Component, Focusable {
+  protected readonly list: SearchableModelList;
+
+  constructor(list: SearchableModelList) {
+    this.list = list;
+  }
+
+  get focused(): boolean {
+    return this.list.focused;
+  }
+
+  set focused(value: boolean) {
+    this.list.focused = value;
+  }
+
+  invalidate(): void {
+    this.list.invalidate();
+  }
+
+  render(width: number): string[] {
+    return this.list.render(width);
+  }
+
+  handleInput(keyData: string): void {
+    this.list.handleInput(keyData);
+  }
+}