indusagi-coding-agent 0.2.8 → 0.2.9

package/src/console/input/complete.ts

@@ -0,0 +1,127 @@
+/**
+ * Completion source — structured suggestions for the composer's prompt line.
+ */
+import type { SlashRegistry } from "../contract.js";
+
+export type CompletionKind = "slash" | "path" | "none";
+
+export interface Suggestion {
+  readonly value: string;
+  readonly label: string;
+  readonly detail: string;
+  readonly isDir: boolean;
+}
+
+export interface TokenSpan {
+  readonly start: number;
+  readonly end: number;
+}
+
+export interface CompletionResult {
+  readonly kind: CompletionKind;
+  readonly span: TokenSpan;
+  readonly suggestions: readonly Suggestion[];
+}
+
+export interface DirEntry {
+  readonly name: string;
+  readonly isDir: boolean;
+}
+
+export type DirReader = (dirPath: string) => readonly DirEntry[];
+
+function noCompletion(caret: number): CompletionResult {
+  return {
+    kind: "none",
+    span: { start: caret, end: caret },
+    suggestions: []
+  };
+}
+
+function isBoundary(ch: string) {
+  return ch === " " || ch === "\t" || ch === "\n";
+}
+
+function activeToken(buffer: string, caret: number): { span: TokenSpan; stem: string } {
+  let start = caret;
+  while (start > 0 && !isBoundary(buffer[start - 1])) start--;
+  let end = caret;
+  while (end < buffer.length && !isBoundary(buffer[end])) end++;
+  return { span: { start, end }, stem: buffer.slice(start, caret) };
+}
+
+function completeSlash(stem: string, registry: SlashRegistry): Suggestion[] {
+  const needle = stem.slice(1).toLowerCase();
+  const exact: Suggestion[] = [];
+  const prefix: Suggestion[] = [];
+  for (const cmd of registry.commands) {
+    const names = [cmd.name, ...(cmd.aliases ?? [])];
+    const hit = names.find((n) => n.toLowerCase().startsWith(needle));
+    if (hit === void 0) continue;
+    const value = cmd.takesArgs ? `/${cmd.name} ` : `/${cmd.name}`;
+    const suggestion: Suggestion = {
+      value,
+      label: `/${cmd.name}`,
+      detail: cmd.summary,
+      isDir: false
+    };
+    if (hit.toLowerCase() === needle) exact.push(suggestion);
+    else prefix.push(suggestion);
+  }
+  return [...exact, ...prefix];
+}
+
+function splitPathStem(stem: string) {
+  const sigil = stem.startsWith("@") ? "@" : "";
+  const body = stem.slice(sigil.length);
+  const slash = body.lastIndexOf("/");
+  if (slash < 0) return { dir: ".", leaf: body, sigil };
+  return { dir: body.slice(0, slash) || ".", leaf: body.slice(slash + 1), sigil };
+}
+
+function completePath(stem: string, readDir: DirReader): Suggestion[] {
+  const { dir, leaf, sigil } = splitPathStem(stem);
+  const lowerLeaf = leaf.toLowerCase();
+  const prefix = dir === "." ? "" : `${dir}/`;
+  const matches = readDir(dir)
+    .filter((e) => e.name.toLowerCase().startsWith(lowerLeaf))
+    .sort((a, b) => {
+      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+      return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+    });
+  return matches.map((e) => {
+    const tail = e.isDir ? "/" : "";
+    return {
+      value: `${sigil}${prefix}${e.name}${tail}`,
+      label: `${e.name}${tail}`,
+      detail: e.isDir ? "directory" : "file",
+      isDir: e.isDir
+    };
+  });
+}
+
+function looksLikePath(stem: string) {
+  return stem.startsWith("@") || stem.includes("/");
+}
+
+/**
+ * Compute the completion offering at a caret position.
+ */
+export function completeAt(buffer: string, caret: number, registry: SlashRegistry, readDir: DirReader): CompletionResult {
+  const { span, stem } = activeToken(buffer, caret);
+  if (stem.startsWith("/") && span.start === 0) {
+    return { kind: "slash", span, suggestions: completeSlash(stem, registry) };
+  }
+  if (looksLikePath(stem)) {
+    return { kind: "path", span, suggestions: completePath(stem, readDir) };
+  }
+  return noCompletion(caret);
+}
+
+/**
+ * Splice an accepted suggestion back into the buffer.
+ */
+export function applySuggestion(buffer: string, span: TokenSpan, suggestion: Suggestion): { buffer: string; caret: number } {
+  const next = buffer.slice(0, span.start) + suggestion.value + buffer.slice(span.end);
+  return { buffer: next, caret: span.start + suggestion.value.length };
+}

package/src/console/input/dir-reader.ts

@@ -0,0 +1,34 @@
+/**
+ * Directory reader — the live `fs`-backed implementation of {@link DirReader}.
+ */
+import { readdirSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import type { DirReader } from "./complete.js";
+
+function entryIsDir(base: string, name: string, isDirent: boolean, isSymlink: boolean) {
+  if (isDirent) return true;
+  if (!isSymlink) return false;
+  try {
+    return statSync(resolve(base, name)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Build a live {@link DirReader} rooted at `cwd`.
+ */
+export function createDirReader(cwd: string = process.cwd()): DirReader {
+  return (dirPath: string) => {
+    const target = resolve(cwd, dirPath);
+    try {
+      const dirents = readdirSync(target, { withFileTypes: true });
+      return dirents.map((d) => ({
+        name: d.name,
+        isDir: entryIsDir(target, d.name, d.isDirectory(), d.isSymbolicLink())
+      }));
+    } catch {
+      return [];
+    }
+  };
+}

package/src/console/input/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Console input — public barrel for the pure composer-input modules.
+ */
+export type { KeyChord, ConsoleVerb, ConsoleIntent, ChordOutcome, ChordLatch, ChordStep } from "./keymap.js";
+export { NO_INTENT, readKey, NO_CHORD, advanceChord } from "./keymap.js";
+export type { PasteThresholds, PasteVault, PasteCapture } from "./paste.js";
+export {
+  PASTE_THRESHOLDS,
+  PASTE_BURST_GAP_MS,
+  PASTE_CONTINUATION_MS,
+  PASTE_MARKER_LINE_CAP,
+  EMPTY_PASTE_VAULT,
+  pasteMarker,
+  classifyPaste,
+  coalescePaste,
+  appendToPaste,
+  pasteLines,
+  expandMarkers,
+  hasMarkers
+} from "./paste.js";
+export type { CompletionKind, Suggestion, TokenSpan, CompletionResult, DirEntry, DirReader } from "./complete.js";
+export { completeAt, applySuggestion } from "./complete.js";
+export { createDirReader } from "./dir-reader.js";

package/src/console/input/keymap.ts

@@ -0,0 +1,159 @@
+/**
+ * Keymap — pure translation of raw terminal key events into console intents.
+ */
+import type { ModalKind } from "../contract.js";
+
+export interface KeyChord {
+  readonly upArrow: boolean;
+  readonly downArrow: boolean;
+  readonly leftArrow: boolean;
+  readonly rightArrow: boolean;
+  readonly pageUp: boolean;
+  readonly pageDown: boolean;
+  readonly return: boolean;
+  readonly escape: boolean;
+  readonly ctrl: boolean;
+  readonly shift: boolean;
+  readonly tab: boolean;
+  readonly backspace: boolean;
+  readonly delete: boolean;
+  readonly meta: boolean;
+}
+
+export type ConsoleVerb =
+  | "text:type"
+  | "text:newline"
+  | "edit:erasePrev"
+  | "edit:eraseNext"
+  | "edit:clearLine"
+  | "nav:left"
+  | "nav:right"
+  | "nav:home"
+  | "nav:end"
+  | "nav:up"
+  | "nav:down"
+  | "flow:submit"
+  | "flow:dismiss"
+  | "flow:accept"
+  | "flow:interrupt"
+  | "flow:suspend"
+  | "flow:cycleModel"
+  | "model:cycleThinking"
+  | "mode:cyclePermission"
+  | "mode:togglePlan"
+  | "queue:dequeue"
+  | "queue:steer"
+  | "input:pasteImage"
+  | "input:externalEditor"
+  | "overlay:open"
+  | "view:expandTools"
+  | "view:toggleReasoning"
+  | "none";
+
+export interface ConsoleIntent {
+  readonly verb: ConsoleVerb;
+  readonly text?: string;
+  readonly overlay?: ModalKind;
+}
+
+/** The inert intent — a keystroke the console ignores. */
+export const NO_INTENT: ConsoleIntent = { verb: "none" };
+
+function typed(text: string): ConsoleIntent {
+  const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return normalized.length === 0 ? NO_INTENT : { verb: "text:type", text: normalized };
+}
+
+function isPrintable(input: string) {
+  if (input.length === 0) return false;
+  if (input.length > 1) return true;
+  const code = input.charCodeAt(0);
+  return code >= 32 && code !== 127;
+}
+
+/**
+ * Classify one raw key event into a single {@link ConsoleIntent}.
+ */
+export function readKey(input: string, key: KeyChord): ConsoleIntent {
+  if (key.ctrl && !key.meta) {
+    switch (input) {
+      case "c":
+        return { verb: "flow:interrupt" };
+      case "z":
+        return { verb: "flow:suspend" };
+      case "u":
+        return { verb: "edit:clearLine" };
+      case "a":
+        return { verb: "nav:home" };
+      case "e":
+        return { verb: "nav:end" };
+      case "j":
+        return { verb: "text:newline" };
+      case "n":
+        return { verb: "flow:cycleModel" };
+      case "p":
+        return { verb: "flow:cycleModel" };
+      case "t":
+        return { verb: "view:toggleReasoning" };
+      case "v":
+        return { verb: "input:pasteImage" };
+      case "g":
+        return { verb: "input:externalEditor" };
+      case "r":
+        return { verb: "overlay:open", overlay: "sessions" };
+      case "x":
+        return { verb: "queue:steer" };
+      case "l":
+        return { verb: "overlay:open", overlay: "models" };
+      case "o":
+        return { verb: "view:expandTools" };
+      default:
+        return NO_INTENT;
+    }
+  }
+  if (key.meta && key.upArrow) return { verb: "queue:dequeue" };
+  if (key.return) {
+    return key.shift ? { verb: "text:newline" } : { verb: "flow:submit" };
+  }
+  if (key.escape) return { verb: "flow:dismiss" };
+  if (key.tab) return key.shift ? { verb: "mode:cyclePermission" } : { verb: "flow:accept" };
+  if (key.backspace || key.delete || input === "\x7F" || input === "\b") {
+    return { verb: "edit:erasePrev" };
+  }
+  if (key.leftArrow) return { verb: "nav:left" };
+  if (key.rightArrow) return { verb: "nav:right" };
+  if (key.upArrow) return { verb: "nav:up" };
+  if (key.downArrow) return { verb: "nav:down" };
+  if (key.pageUp) return { verb: "nav:home" };
+  if (key.pageDown) return { verb: "nav:end" };
+  return isPrintable(input) ? typed(input) : NO_INTENT;
+}
+
+export type ChordOutcome = "dismiss×2" | "clear×2";
+
+export interface ChordLatch {
+  readonly armed: string | null;
+}
+
+export const NO_CHORD: ChordLatch = { armed: null };
+
+export interface ChordStep {
+  readonly next: ChordLatch;
+  readonly fired: ChordOutcome | null;
+}
+
+const CHORD_VERBS: Partial<Record<ConsoleVerb, ChordOutcome>> = {
+  "flow:dismiss": "dismiss×2",
+  "edit:clearLine": "clear×2"
+};
+
+export function advanceChord(latch: ChordLatch, intent: ConsoleIntent): ChordStep {
+  const outcome = CHORD_VERBS[intent.verb];
+  if (outcome === void 0) {
+    return { next: NO_CHORD, fired: null };
+  }
+  if (latch.armed === intent.verb) {
+    return { next: NO_CHORD, fired: outcome };
+  }
+  return { next: { armed: intent.verb }, fired: null };
+}

package/src/console/input/paste.ts

@@ -0,0 +1,104 @@
+/**
+ * Paste coalescing — collapse a large clipboard burst into one compact marker.
+ */
+
+export interface PasteThresholds {
+  readonly lines: number;
+  readonly chars: number;
+}
+
+export const PASTE_THRESHOLDS: PasteThresholds = { lines: 10, chars: 1001 };
+export const PASTE_BURST_GAP_MS = 24;
+export const PASTE_CONTINUATION_MS = 250;
+export const PASTE_MARKER_LINE_CAP = 1000;
+
+/** The console's own placeholder format for a hidden paste body. */
+export function pasteMarker(ordinal: number, lineCount: number): string {
+  return `[Pasted text #${ordinal}${lineCount > 0 ? ` +${lineCount} lines` : ""}]`;
+}
+
+function markerScanner() {
+  return /\[Pasted text #(\d+)(?: \+\d+ lines)?\]/g;
+}
+
+function lineBreaks(chunk: string) {
+  let count = 0;
+  for (let i = 0; i < chunk.length; i++) {
+    if (chunk.charCodeAt(i) === 10) count++;
+  }
+  return count;
+}
+
+/**
+ * Decide whether a pasted chunk is large enough to hide behind a marker.
+ */
+export function classifyPaste(chunk: string, thresholds: PasteThresholds = PASTE_THRESHOLDS): "inline" | "coalesce" {
+  if (chunk.length >= thresholds.chars) return "coalesce";
+  if (lineBreaks(chunk) >= thresholds.lines) return "coalesce";
+  return "inline";
+}
+
+export interface PasteVault {
+  readonly bodies: ReadonlyMap<number, string>;
+  readonly minted: number;
+}
+
+export const EMPTY_PASTE_VAULT: PasteVault = { bodies: new Map(), minted: 0 };
+
+export interface PasteCapture {
+  readonly marker: string;
+  readonly vault: PasteVault;
+}
+
+/**
+ * Mint a marker for a large paste and record its body in a fresh vault.
+ */
+export function coalescePaste(body: string, vault: PasteVault = EMPTY_PASTE_VAULT): PasteCapture {
+  const ordinal = vault.minted + 1;
+  const lineCount = body.length === 0 ? 0 : lineBreaks(body) + 1;
+  const marker = pasteMarker(ordinal, lineCount);
+  const bodies = new Map(vault.bodies);
+  bodies.set(ordinal, body);
+  return { marker, vault: { bodies, minted: ordinal } };
+}
+
+/**
+ * Grow an existing paste body with a follow-on chunk, reminting its marker.
+ */
+export function appendToPaste(ordinal: number, extra: string, vault: PasteVault): PasteCapture {
+  const body = (vault.bodies.get(ordinal) ?? "") + extra;
+  const lineCount = body.length === 0 ? 0 : lineBreaks(body) + 1;
+  const marker = pasteMarker(ordinal, lineCount);
+  const bodies = new Map(vault.bodies);
+  bodies.set(ordinal, body);
+  return { marker, vault: { bodies, minted: vault.minted } };
+}
+
+/**
+ * The line count of an ordinal's stored body.
+ */
+export function pasteLines(vault: PasteVault, ordinal: number): number {
+  const body = vault.bodies.get(ordinal);
+  if (body === void 0 || body.length === 0) return 0;
+  return lineBreaks(body) + 1;
+}
+
+/**
+ * Rewrite every paste marker in a buffer back to the text it stands for.
+ */
+export function expandMarkers(buffer: string, vault: PasteVault): string {
+  if (vault.bodies.size === 0) return buffer;
+  return buffer.replace(markerScanner(), (match, ordinalStr) => {
+    const ordinal = parseInt(ordinalStr, 10);
+    const body = vault.bodies.get(ordinal);
+    return body === void 0 ? match : body;
+  });
+}
+
+/**
+ * Report whether a buffer still contains any minted paste marker.
+ */
+export function hasMarkers(buffer: string, vault: PasteVault): boolean {
+  if (vault.bodies.size === 0) return false;
+  return markerScanner().test(buffer);
+}

package/src/console/mount.ts

@@ -0,0 +1,56 @@
+/**
+ * Console mount — render the interactive surface and resolve on exit.
+ */
+import { createElement } from "indusagi/react-host";
+import { render } from "indusagi/react-host/ink";
+import { TerminalConsole } from "./components/TerminalConsole.js";
+import { DEFAULT_SLASH_REGISTRY } from "./slash/index.js";
+import { resolveTheme } from "./theme/index.js";
+import type { OverlayServices, SessionConductor, SlashRegistry } from "./contract.js";
+
+/**
+ * Options for {@link mountConsole}.
+ */
+export interface MountConsoleOptions {
+  readonly scheme?: string | null;
+  readonly slash?: SlashRegistry;
+  readonly initialInput?: string;
+  readonly initialImages?: readonly string[];
+  readonly verbose?: boolean;
+  readonly services?: OverlayServices;
+}
+
+/**
+ * The handle a {@link mountConsole} call resolves with once the surface exits.
+ */
+export interface MountResult {
+  readonly clean: boolean;
+}
+
+/**
+ * Render the interactive console for a session and resolve when it exits.
+ */
+export async function mountConsole(
+  conductor: SessionConductor,
+  opts: MountConsoleOptions = {}
+): Promise<MountResult> {
+  const theme = resolveTheme(opts.scheme ?? null);
+  const slash = opts.slash ?? DEFAULT_SLASH_REGISTRY;
+  let exited = false;
+  const props = {
+    conductor,
+    theme,
+    slash,
+    initialInput: opts.initialInput,
+    initialImages: opts.initialImages,
+    verbose: opts.verbose,
+    services: opts.services,
+    onExit: () => {
+      exited = true;
+      instance.unmount();
+    }
+  };
+  const instance = render(createElement(TerminalConsole, props));
+  await instance.waitUntilExit();
+  return { clean: exited };
+}

package/src/console/overlays/approval-queue.ts

@@ -0,0 +1,57 @@
+/**
+ * Approval queue — the headless, pure serializer behind the approval overlay.
+ */
+import type { ApprovalChoice, PermissionMode } from "../../conductor/index.js";
+import type { ApprovalRequest } from "./approval.js";
+
+/** One parked approval request awaiting the user's choice. */
+export interface ApprovalEntry {
+  readonly id: string;
+  readonly request: ApprovalRequest;
+  readonly resolve: (choice: ApprovalChoice) => void;
+}
+
+/** The immutable queue state. */
+export interface ApprovalQueueState {
+  readonly entries: readonly ApprovalEntry[];
+}
+
+/** The empty queue — no approval prompt pending. */
+export const EMPTY_APPROVAL_QUEUE: ApprovalQueueState = { entries: [] };
+
+export type ApprovalQueueEvent =
+  | { readonly type: "enqueue"; readonly entry: ApprovalEntry }
+  | { readonly type: "settle"; readonly id: string }
+  | { readonly type: "clear" };
+
+/**
+ * Fold one {@link ApprovalQueueEvent} over the queue, returning a fresh state.
+ */
+export function approvalQueueReducer(state: ApprovalQueueState, event: ApprovalQueueEvent): ApprovalQueueState {
+  switch (event.type) {
+    case "enqueue":
+      return { entries: [...state.entries, event.entry] };
+    case "settle": {
+      const next = state.entries.filter((entry) => entry.id !== event.id);
+      return next.length === state.entries.length ? state : { entries: next };
+    }
+    case "clear":
+      return state.entries.length === 0 ? state : EMPTY_APPROVAL_QUEUE;
+    default:
+      return state;
+  }
+}
+
+/**
+ * The active prompt — the head entry — or `undefined` when the queue is empty.
+ */
+export function activeApproval(state: ApprovalQueueState): ApprovalEntry | undefined {
+  return state.entries[0];
+}
+
+/**
+ * Whether switching INTO `mode` mid-prompt should release every PARKED approval request.
+ */
+export function modeReleasesApprovals(mode: PermissionMode): boolean {
+  return mode === "bypass" || mode === "bypassPermissions";
+}

package/src/console/overlays/approval.ts

@@ -0,0 +1,130 @@
+/**
+ * Approval overlay — the interactive tool-permission prompt.
+ */
+import { Box, Text } from "indusagi/react-host/ink";
+import { ThemeDialog, type ThemeDialogItem } from "indusagi/react-ink";
+import { jsx, jsxs } from "indusagi/react-host/jsx-runtime";
+import type { ApprovalChoice } from "../../conductor/index.js";
+import type { OverlayGroupProps } from "./pickers.js";
+
+export interface ApprovalRequest {
+  readonly toolName: string;
+  readonly input: unknown;
+  readonly suggestions?: readonly string[];
+}
+
+export interface ApprovalPayload {
+  readonly request: ApprovalRequest;
+  readonly resolve: (choice: ApprovalChoice) => void;
+}
+
+export const APPROVAL_CHOICES: readonly (ThemeDialogItem & { id: ApprovalChoice })[] = [
+  { id: "allow-once", label: "Allow once", description: "run this one call" },
+  {
+    id: "allow-always",
+    label: "Allow always",
+    description: "run it and remember this action for the session"
+  },
+  { id: "deny", label: "Deny", description: "block this call" }
+];
+
+export const DISMISS_CHOICE: ApprovalChoice = "deny";
+
+export function choiceFromId(id: string): ApprovalChoice {
+  const match = APPROVAL_CHOICES.find((choice) => choice.id === id);
+  return (match?.id ?? DISMISS_CHOICE) as ApprovalChoice;
+}
+
+export function readApprovalPayload(payload: unknown): ApprovalPayload | undefined {
+  if (payload === null || typeof payload !== "object") return void 0;
+  const bag = payload as any;
+  if (typeof bag.resolve !== "function") return void 0;
+  const request = bag.request;
+  if (request === null || typeof request !== "object") return void 0;
+  const req = request as any;
+  if (typeof req.toolName !== "string") return void 0;
+  const suggestions = Array.isArray(req.suggestions) ? req.suggestions.filter((s: unknown) => typeof s === "string") : void 0;
+  return {
+    request: {
+      toolName: req.toolName,
+      input: req.input,
+      ...(suggestions !== void 0 && suggestions.length > 0 ? { suggestions } : {})
+    },
+    resolve: bag.resolve
+  };
+}
+
+const ARG_PREVIEW_LIMIT = 200;
+
+export function summarizeInput(input: unknown): string {
+  let text: string;
+  if (input === null || input === void 0) {
+    text = "";
+  } else if (typeof input === "string") {
+    text = input;
+  } else if (typeof input === "object") {
+    const bag = input as any;
+    if (typeof bag.command === "string") {
+      text = bag.command;
+    } else {
+      try {
+        text = JSON.stringify(bag);
+      } catch {
+        text = "[unserialisable arguments]";
+      }
+    }
+  } else {
+    text = String(input);
+  }
+  text = text.replace(/\s+/g, " ").trim();
+  if (text.length > ARG_PREVIEW_LIMIT) {
+    return `${text.slice(0, ARG_PREVIEW_LIMIT)}…`;
+  }
+  return text;
+}
+
+function ApprovalDialog(props: { payload: ApprovalPayload; closeModal: () => void }) {
+  const { payload, closeModal } = props;
+  const { request, resolve } = payload;
+  let settled = false;
+  const settle = (choice: ApprovalChoice) => {
+    if (settled) return;
+    settled = true;
+    resolve(choice);
+    closeModal();
+  };
+  const args = summarizeInput(request.input);
+  const suggestion = request.suggestions?.[0];
+  return jsxs(Box, {
+    flexDirection: "column",
+    children: [
+      jsxs(Text, {
+        children: ["Allow ", jsx(Text, { bold: true, children: request.toolName }), " to run?"]
+      }),
+      args.length > 0 ? jsx(Text, { dimColor: true, children: args }) : null,
+      suggestion !== void 0
+        ? jsxs(Text, {
+            dimColor: true,
+            children: ["Allow-always remembers: ", suggestion]
+          })
+        : null,
+      jsx(ThemeDialog, {
+        themes: APPROVAL_CHOICES.map((choice) => ({
+          id: choice.id,
+          label: choice.label,
+          description: choice.description
+        })),
+        onSelect: (id: string) => settle(choiceFromId(id)),
+        onClose: () => settle(DISMISS_CHOICE)
+      })
+    ]
+  });
+}
+
+export function ApprovalOverlays(props: OverlayGroupProps) {
+  const { modal, closeModal } = props;
+  if (modal.kind !== "approval") return null;
+  const payload = readApprovalPayload(modal.payload);
+  if (payload === void 0) return null;
+  return jsx(ApprovalDialog, { payload, closeModal });
+}