indusagi-coding-agent 0.2.5 → 0.2.9

package/src/console/overlays/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Overlays subsystem — public barrel.
+ */
+export { OverlayHost, type OverlayHostProps } from "./host.js";
+export { PickerOverlays, type OverlayGroupProps } from "./pickers.js";
+export { SessionOverlays } from "./sessions.js";
+export { AuthOverlays } from "./auth.js";
+export {
+  ApprovalOverlays,
+  choiceFromId,
+  readApprovalPayload,
+  summarizeInput,
+  APPROVAL_CHOICES,
+  DISMISS_CHOICE,
+  type ApprovalRequest,
+  type ApprovalPayload
+} from "./approval.js";
+export {
+  approvalQueueReducer,
+  activeApproval,
+  modeReleasesApprovals,
+  EMPTY_APPROVAL_QUEUE,
+  type ApprovalEntry,
+  type ApprovalQueueState,
+  type ApprovalQueueEvent
+} from "./approval-queue.js";

package/src/console/overlays/pickers.ts

@@ -0,0 +1,258 @@
+/**
+ * Picker overlays — the selection dialogs raised over the transcript.
+ */
+import { useEffect, useState } from "indusagi/react-host";
+import { ScopedModelsDialog, ThemeDialog, type Model } from "indusagi/react-ink";
+import { jsx } from "indusagi/react-host/jsx-runtime";
+import type { ConsoleDispatch, InkThemeAdapter, ModalState, OverlayServices } from "../contract.js";
+import { DEFAULT_SCHEME, isThemeScheme } from "../contract.js";
+import { useAuthenticatedProviders } from "../auth-status.js";
+import { isDeliveryMode, DELIVERY_MODES } from "../../settings/index.js";
+import { THEME_SCHEMES } from "../theme/index.js";
+import { ModelBoard, SettingsBoard } from "./boards.js";
+
+const TOGGLE_VALUES = ["on", "off"];
+
+function refToModel(ref: any): Model<any> {
+  return {
+    id: ref.id,
+    name: ref.name,
+    api: "",
+    provider: ref.provider,
+    baseUrl: "",
+    reasoning: ref.reasoning,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 0,
+    maxTokens: 0
+  };
+}
+
+function listModels(services: OverlayServices): Model<any>[] {
+  try {
+    return services.conductor.availableModels().map(refToModel);
+  } catch {
+    return [];
+  }
+}
+
+function ModelPicker(props: OverlayGroupProps) {
+  const { services, theme, closeModal } = props;
+  const authed = useAuthenticatedProviders(services);
+  if (!services) return null;
+  const all = listModels(services);
+  const models = authed === null ? all : all.filter((model) => authed.has(model.provider));
+  return jsx(ModelBoard, {
+    theme,
+    models,
+    onSelect: (model: Model<any>) => {
+      try {
+        services.conductor.selectModel(model.id);
+      } catch {
+        // ignore
+      }
+      closeModal();
+    },
+    onClose: closeModal
+  });
+}
+
+function readScopedPayload(payload: unknown): { focus?: string; intent?: string } {
+  if (payload === null || typeof payload !== "object") return {};
+  const record = payload as any;
+  const out: any = {};
+  if (record.focus === "summary") out.focus = "summary";
+  if (record.intent === "reset") out.intent = "reset";
+  return out;
+}
+
+function ScopedModelPicker(props: OverlayGroupProps) {
+  const { services, dispatch, closeModal, modal } = props;
+  const payload = readScopedPayload(modal.payload);
+  useEffect(() => {
+    if (!services || payload.intent !== "reset") return;
+    try {
+      services.settings.set("enabledModels", []);
+      services.settings.save();
+      dispatch({
+        type: "status:set",
+        status: { kind: "info", text: "Per-scope model overrides cleared." }
+      });
+    } catch {
+      dispatch({
+        type: "status:set",
+        status: { kind: "error", text: "Could not clear per-scope model overrides." }
+      });
+    }
+    closeModal();
+  }, []);
+  if (!services) return null;
+  if (payload.intent === "reset") return null;
+  const models = listModels(services);
+  let enabled: string[] = [];
+  try {
+    enabled = services.settings.get("enabledModels");
+  } catch {
+    enabled = [];
+  }
+  const selectedIds = enabled.length > 0 ? enabled : models.map((model) => model.id);
+  return jsx(ScopedModelsDialog, {
+    models,
+    selectedIds,
+    onSave: (ids: string[]) => {
+      try {
+        const all = models.map((model) => model.id);
+        const next = ids.length === all.length ? [] : ids;
+        services.settings.set("enabledModels", next);
+        services.settings.save();
+      } catch {
+        // ignore
+      }
+      closeModal();
+    },
+    onClose: closeModal
+  });
+}
+
+function currentScheme(services: OverlayServices): string {
+  try {
+    const stored = services.settings.get("colourScheme");
+    if (typeof stored === "string" && isThemeScheme(stored)) return stored;
+  } catch {
+    // ignore
+  }
+  return DEFAULT_SCHEME;
+}
+
+function ThemePicker(props: OverlayGroupProps) {
+  const { services, dispatch, closeModal } = props;
+  const [originalScheme] = useState(() => (services ? currentScheme(services) : null));
+  if (!services) return null;
+  const revert = () => {
+    if (originalScheme) dispatch({ type: "scheme:set", scheme: originalScheme });
+    closeModal();
+  };
+  return jsx(ThemeDialog, {
+    themes: [...THEME_SCHEMES],
+    onSelect: (name: string) => {
+      if (isThemeScheme(name)) {
+        dispatch({ type: "scheme:set", scheme: name });
+        try {
+          services.settings.set("colourScheme", name);
+          services.settings.save();
+        } catch {
+          // ignore
+        }
+      }
+      closeModal();
+    },
+    onClose: revert
+  });
+}
+
+function SettingsPicker(props: OverlayGroupProps) {
+  const { services, theme, dispatch, closeModal } = props;
+  if (!services) return null;
+  const settings = services.settings;
+  const [, setVersion] = useState(0);
+  const bump = () => setVersion((n) => n + 1);
+  const onOff = (flag: boolean) => (flag ? "on" : "off");
+  const toggleRow = (id: string, key: string, label: string, description: string, live?: () => void) => ({
+    id,
+    label,
+    description,
+    value: onOff(settings.get(key) as boolean),
+    values: [...TOGGLE_VALUES],
+    onChange: (value: string) => {
+      settings.set(key, value === "on");
+      settings.save();
+      live?.();
+      bump();
+    }
+  });
+  const deliveryRow = (id: string, key: string, label: string, description: string) => ({
+    id,
+    label,
+    description,
+    value: settings.get(key) as string,
+    values: [...DELIVERY_MODES],
+    onChange: (value: string) => {
+      if (isDeliveryMode(value)) {
+        settings.set(key, value);
+        settings.save();
+      }
+      bump();
+    }
+  });
+  const items: any[] = [];
+  try {
+    items.push({
+      id: "colour-scheme",
+      label: "Colour scheme",
+      description: "The terminal colour scheme the console renders in.",
+      value: settings.get("colourScheme") as string,
+      values: [...THEME_SCHEMES],
+      onChange: (value: string) => {
+        settings.set("colourScheme", value);
+        settings.save();
+        if (isThemeScheme(value)) dispatch({ type: "scheme:set", scheme: value });
+        bump();
+      }
+    });
+    items.push(toggleRow("show-images", "showImages", "Show images", "Render inline image content in the transcript.", () => dispatch({ type: "toggle:images" })));
+    items.push(toggleRow("image-auto-resize", "imageAutoResize", "Auto-resize images", "Shrink oversized images to fit before handing them to a provider."));
+    items.push(toggleRow("block-images", "blockImages", "Block images", "Withhold image content from providers entirely."));
+    items.push(toggleRow("show-reasoning", "showReasoning", "Show reasoning", "Stream the model's reasoning / thinking text as it arrives.", () => dispatch({ type: "toggle:reasoning" })));
+    items.push(toggleRow("skill-commands", "enableSkillCommands", "Skill commands", "Surface discovered skills as their own slash commands."));
+    items.push(deliveryRow("steering-mode", "steeringMode", "Steering mode", "Whether queued steering corrections release one at a time or all at once."));
+    items.push(deliveryRow("follow-up-mode", "followUpMode", "Follow-up mode", "Whether queued follow-up prompts release one at a time or all at once."));
+    items.push(toggleRow("auto-compact", "autoCompact", "Auto-compact", "Condense the transcript automatically as it nears the window."));
+    items.push(toggleRow("collapse-changelog", "collapseChangelog", "Collapse changelog", "Prefer a condensed changelog after the console updates itself."));
+    items.push(toggleRow("quiet-startup", "quietStartup", "Quiet startup", "Suppress the banner and tips shown on a normal interactive launch."));
+    items.push(toggleRow("logo-sweep", "logoSweep", "Logo sweep", "Tint the startup wordmark and emblem along a static colour gradient."));
+    items.push(toggleRow("reduced-motion", "reducedMotion", "Reduced motion", "Suppress motion-flavoured flourishes such as the logo colour sweep."));
+    items.push(toggleRow("hardware-cursor", "showHardwareCursor", "Hardware cursor", "Reveal the terminal's own cursor instead of the software-drawn caret."));
+    items.push({
+      id: "editor-padding",
+      label: "Editor padding",
+      description: "Horizontal padding, in columns, around the prompt editor.",
+      value: String(settings.get("editorPaddingX")),
+      values: ["0", "1", "2", "3"],
+      onChange: (value: string) => {
+        const parsed = Number.parseInt(value, 10);
+        if (Number.isFinite(parsed)) {
+          settings.set("editorPaddingX", parsed);
+          settings.save();
+        }
+        bump();
+      }
+    });
+  } catch {
+    return null;
+  }
+  return jsx(SettingsBoard, { theme, items, onClose: closeModal });
+}
+
+/** The props every overlay group receives. */
+export interface OverlayGroupProps {
+  readonly modal: ModalState;
+  readonly services?: OverlayServices;
+  readonly theme: InkThemeAdapter;
+  readonly dispatch: ConsoleDispatch;
+  readonly closeModal: () => void;
+}
+
+export function PickerOverlays(props: OverlayGroupProps) {
+  switch (props.modal.kind) {
+    case "models":
+      return jsx(ModelPicker, { ...props });
+    case "scopedModels":
+      return jsx(ScopedModelPicker, { ...props });
+    case "theme":
+      return jsx(ThemePicker, { ...props });
+    case "settings":
+      return jsx(SettingsPicker, { ...props });
+    default:
+      return null;
+  }
+}

package/src/console/overlays/sessions.ts

@@ -0,0 +1,190 @@
+/**
+ * Session overlays — the transcript navigation dialogs.
+ */
+import { useEffect, useState } from "indusagi/react-host";
+import { SessionDialog, TreeDialog, UserMessageDialog } from "indusagi/react-ink";
+import { jsx } from "indusagi/react-host/jsx-runtime";
+import type { OverlayGroupProps } from "./pickers.js";
+
+function toSessionInfo(row: any) {
+  const lastModified = row.lastModified ?? 0;
+  return {
+    id: row.id,
+    path: row.path,
+    name: row.name,
+    modified: new Date(lastModified),
+    lastModified,
+    size: row.size,
+    messageCount: row.messageCount,
+    firstMessage: row.preview
+  };
+}
+
+function SessionPicker(props: OverlayGroupProps) {
+  const { services, closeModal } = props;
+  const [sessions, setSessions] = useState<any[]>([]);
+  useEffect(() => {
+    let live = true;
+    void (async () => {
+      try {
+        const rows = await services!.sessions.list();
+        if (live) setSessions(rows.map(toSessionInfo));
+      } catch {
+        if (live) setSessions([]);
+      }
+    })();
+    return () => {
+      live = false;
+    };
+  }, [services]);
+  const currentPath = services!.sessions.pathOf(services!.conductor.snapshot().head.sessionId);
+  return jsx(SessionDialog, {
+    currentSessions: sessions,
+    currentSessionPath: currentPath,
+    onSelect: async (session: any) => {
+      try {
+        await services!.conductor.resume(session.id);
+      } catch {
+        // ignore
+      }
+      closeModal();
+    },
+    onLoadAllSessions: async () => {
+      try {
+        const rows = await services!.sessions.list({ deep: true });
+        const mapped = rows.map(toSessionInfo);
+        setSessions(mapped);
+        return mapped;
+      } catch {
+        return [];
+      }
+    },
+    onDeleteSession: async (session: any) => {
+      try {
+        await services!.sessions.remove(session.id);
+        setSessions((prev) => prev.filter((row) => row.id !== session.id));
+      } catch {
+        // ignore
+      }
+    },
+    onRenameSession: async (session: any, name: string) => {
+      try {
+        await services!.sessions.rename(session.id, name);
+        const rows = await services!.sessions.list();
+        setSessions(rows.map(toSessionInfo));
+      } catch {
+        // ignore
+      }
+    },
+    onClose: closeModal
+  });
+}
+
+function BranchTree(props: OverlayGroupProps) {
+  const { services, closeModal } = props;
+  const [items, setItems] = useState<any[]>([]);
+  useEffect(() => {
+    let live = true;
+    void (async () => {
+      try {
+        const sessionId = services!.conductor.snapshot().head.sessionId;
+        const store = await services!.sessions.open(sessionId);
+        if (store === null) {
+          if (live) setItems([]);
+          return;
+        }
+        const nodes = services!.sessions.tree(store).map((node: any) => ({
+          id: node.id,
+          label: node.label,
+          depth: node.depth,
+          isLeaf: node.isLeaf,
+          isCurrent: node.isCurrent
+        }));
+        if (live) setItems(nodes);
+      } catch {
+        if (live) setItems([]);
+      }
+    })();
+    return () => {
+      live = false;
+    };
+  }, [services]);
+  return jsx(TreeDialog, {
+    items,
+    onSelect: async (node: any) => {
+      if (node.id !== null) {
+        try {
+          await services!.conductor.navigateTree(node.id);
+          const info = await services!.conductor.codeRestoreInfo(node.id);
+          if (info.canRestore) {
+            await services!.conductor.restoreCode(node.id);
+          }
+        } catch {
+          // ignore
+        }
+      }
+      closeModal();
+    },
+    onClose: closeModal
+  });
+}
+
+function PriorTurns(props: OverlayGroupProps) {
+  const { services, closeModal } = props;
+  const [items, setItems] = useState<any[]>([]);
+  useEffect(() => {
+    let live = true;
+    void (async () => {
+      try {
+        const sessionId = services!.conductor.snapshot().head.sessionId;
+        const store = await services!.sessions.open(sessionId);
+        if (store === null) {
+          if (live) setItems([]);
+          return;
+        }
+        const turns = services!.sessions.priorTurns(store).map((turn: any) => ({
+          entryId: turn.entryId,
+          text: turn.text,
+          preview: turn.preview
+        }));
+        if (live) setItems(turns);
+      } catch {
+        if (live) setItems([]);
+      }
+    })();
+    return () => {
+      live = false;
+    };
+  }, [services]);
+  return jsx(UserMessageDialog, {
+    items,
+    onSelect: async (turn: any) => {
+      try {
+        await services!.conductor.fork(turn.entryId);
+        const info = await services!.conductor.codeRestoreInfo(turn.entryId);
+        if (info.canRestore) {
+          await services!.conductor.restoreCode(turn.entryId);
+        }
+      } catch {
+        // ignore
+      }
+      closeModal();
+    },
+    onClose: closeModal
+  });
+}
+
+export function SessionOverlays(props: OverlayGroupProps) {
+  const { modal, services, closeModal } = props;
+  if (services === void 0) return null;
+  switch (modal.kind) {
+    case "sessions":
+      return jsx(SessionPicker, { ...props, services, closeModal });
+    case "tree":
+      return jsx(BranchTree, { ...props, services, closeModal });
+    case "userTurns":
+      return jsx(PriorTurns, { ...props, services, closeModal });
+    default:
+      return null;
+  }
+}

package/src/console/reducer.ts

@@ -0,0 +1,182 @@
+/**
+ * Console reducer — the single pure fold over {@link ConsoleState}.
+ *
+ * The whole terminal surface is reduced from one immutable {@link ConsoleState}
+ * value, mutated only by dispatching a {@link ConsoleEvent} into
+ * {@link consoleReducer}. This module is the one place those transitions live:
+ * it is a pure function (no React, no I/O, no timers) that, given a prior state
+ * and an event, returns a *fresh* state — it never mutates its input. That makes
+ * every transition unit-testable in isolation and keeps the surface component a
+ * thin shell that only wires events in and renders the result out.
+ */
+import { EMPTY_CONSOLE_STATE, NO_MODAL, transitionModal, type ConsoleEvent, type ConsoleState } from "./contract.js";
+
+function clamp(offset: number, max: number) {
+  if (offset < 0) return 0;
+  if (offset > max) return max;
+  return offset;
+}
+
+function spliceAt(text: string, at: number, insert: string) {
+  return text.slice(0, at) + insert + text.slice(at);
+}
+
+function withBuffer(state: ConsoleState, text: string, caret: number) {
+  return { ...state, buffer: text, caret: clamp(caret, text.length) };
+}
+
+function setBuffer(state: ConsoleState, text: string) {
+  return withBuffer(state, text, text.length);
+}
+
+function insertBuffer(state: ConsoleState, text: string) {
+  if (text.length === 0) return state;
+  const at = clamp(state.caret, state.buffer.length);
+  return withBuffer(state, spliceAt(state.buffer, at, text), at + text.length);
+}
+
+function erasePrev(state: ConsoleState) {
+  const at = clamp(state.caret, state.buffer.length);
+  if (at === 0) return state;
+  const next = state.buffer.slice(0, at - 1) + state.buffer.slice(at);
+  return withBuffer(state, next, at - 1);
+}
+
+function eraseNext(state: ConsoleState) {
+  const at = clamp(state.caret, state.buffer.length);
+  if (at >= state.buffer.length) return state;
+  const next = state.buffer.slice(0, at) + state.buffer.slice(at + 1);
+  return withBuffer(state, next, at);
+}
+
+function pushHistory(state: ConsoleState, text: string) {
+  const trimmed = text.trim();
+  const base = { ...state, historyAt: null, stash: "" };
+  if (trimmed.length === 0) return base;
+  const last = state.history[state.history.length - 1];
+  if (last === text) return base;
+  return { ...base, history: [...state.history, text] };
+}
+
+function historyBack(state: ConsoleState) {
+  if (state.history.length === 0) return state;
+  const atEnd = state.historyAt === null;
+  const index = atEnd ? state.history.length - 1 : Math.max(0, state.historyAt - 1);
+  const stash = atEnd ? state.buffer : state.stash;
+  const recalled = state.history[index];
+  return { ...withBuffer(state, recalled, recalled.length), historyAt: index, stash };
+}
+
+function historyForward(state: ConsoleState) {
+  if (state.historyAt === null) return state;
+  const next = state.historyAt + 1;
+  if (next >= state.history.length) {
+    const stash = state.stash;
+    return { ...withBuffer(state, stash, stash.length), historyAt: null, stash: "" };
+  }
+  const recalled = state.history[next];
+  return { ...withBuffer(state, recalled, recalled.length), historyAt: next };
+}
+
+function appendRow(state: ConsoleState, row: ConsoleState["rows"][number]) {
+  return { ...state, rows: [...state.rows, row] };
+}
+
+function patchRow(state: ConsoleState, id: string, text: string) {
+  let found = false;
+  const rows = state.rows.map((row) => {
+    if (row.id !== id) return row;
+    found = true;
+    return { ...row, text };
+  });
+  return found ? { ...state, rows } : state;
+}
+
+/**
+ * Fold a {@link ConsoleEvent} into a {@link ConsoleState}, returning a fresh state.
+ */
+export function consoleReducer(state: ConsoleState, event: ConsoleEvent): ConsoleState {
+  switch (event.type) {
+    // Composer buffer & caret
+    case "buffer:set":
+      return setBuffer(state, event.text);
+    case "buffer:insert":
+      return insertBuffer(state, event.text);
+    case "buffer:replaceSpan": {
+      const at = state.buffer.indexOf(event.find);
+      if (at < 0) return state;
+      const buffer = state.buffer.slice(0, at) + event.replaceWith + state.buffer.slice(at + event.find.length);
+      const spanEnd = at + event.find.length;
+      const caret = state.caret >= spanEnd
+        ? state.caret + (event.replaceWith.length - event.find.length)
+        : state.caret > at
+        ? at + event.replaceWith.length
+        : state.caret;
+      return { ...state, buffer, caret: clamp(caret, buffer.length) };
+    }
+    case "buffer:erasePrev":
+      return erasePrev(state);
+    case "buffer:eraseNext":
+      return eraseNext(state);
+    case "caret:move":
+      return { ...state, caret: clamp(state.caret + event.delta, state.buffer.length) };
+    case "caret:jump":
+      return { ...state, caret: clamp(event.offset, state.buffer.length) };
+    // History ring
+    case "history:push":
+      return pushHistory(state, event.text);
+    case "history:back":
+      return historyBack(state);
+    case "history:forward":
+      return historyForward(state);
+    // Transcript view
+    case "rows:set":
+      return { ...state, rows: [...event.rows] };
+    case "rows:append":
+      return appendRow(state, event.row);
+    case "rows:patch":
+      return patchRow(state, event.id, event.text);
+    case "block:append":
+      return { ...state, blocks: [...state.blocks, event.block] };
+    case "blocks:clear":
+      return state.blocks.length === 0 ? state : { ...state, blocks: [] };
+    // Overlays, status, theme, toggles, busy
+    case "modal:open":
+      return { ...state, modal: transitionModal(event.kind, event.payload) };
+    case "modal:close":
+      return { ...state, modal: NO_MODAL };
+    case "status:set":
+      return { ...state, status: event.status };
+    case "status:clear": {
+      if (state.status === void 0) return state;
+      const { status: _drop, ...rest } = state;
+      return rest;
+    }
+    case "scheme:set":
+      return { ...state, scheme: event.scheme };
+    case "toggle:reasoning":
+      return { ...state, showReasoning: !state.showReasoning };
+    case "toggle:images":
+      return { ...state, showImages: !state.showImages };
+    case "busy:set": {
+      if (event.busy) {
+        const { status: _drop, ...rest } = state;
+        return { ...rest, busy: true };
+      }
+      return { ...state, busy: false };
+    }
+    case "tick":
+      return { ...state, tick: state.tick + 1 };
+    default: {
+      const _never = event;
+      return _never;
+    }
+  }
+}
+
+/**
+ * Build the initial {@link ConsoleState} a console mounts with.
+ */
+export function initConsoleState(overrides?: Partial<ConsoleState>): ConsoleState {
+  return overrides === void 0 ? EMPTY_CONSOLE_STATE : { ...EMPTY_CONSOLE_STATE, ...overrides };
+}