tinker-agent 1.0.65

package/src/tui/app.tsx

@@ -0,0 +1,497 @@
+import { Box, Text, useApp, useInput } from "ink";
+import { useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { TurnCancelledError } from "../agent/turn-cancellation";
+import {
+  ContextManagerError,
+  type ContextCompactionResult,
+} from "../context/context-manager";
+import { ContextBudgetExceededError } from "../model/model-request-preflight";
+import { visibleTimelineItems } from "./event-store";
+import type { PromptHistory } from "./prompt-history";
+import { Footer } from "./components/footer";
+import { ContextStatus } from "./components/context-status";
+import { BackgroundTasks } from "./components/background-tasks";
+import { Header } from "./components/header";
+import { ModelPicker } from "./components/model-picker";
+import { FileViewer, FileViewerLoading } from "./components/file-viewer";
+import { PromptInput } from "./components/prompt-input";
+import {
+  ResumeSessionPicker,
+  ResumeSessionPickerLoading,
+} from "./components/resume-session-picker";
+import { Timeline } from "./components/timeline";
+import { parseSlashCommand, SLASH_COMMANDS } from "./slash-commands";
+import type { TuiSessionController } from "./tui-session-controller";
+import type { SessionSummary } from "../session/session-catalog";
+import type { ModelProfile, ModelProfiles } from "../cli/model-profiles";
+import { loadViewFile, type ViewFile } from "./view-file";
+
+export type AppProps = {
+  sessionController: TuiSessionController;
+  readGitBranch?: (workspaceRoot: string) => Promise<string | undefined>;
+  history?: PromptHistory;
+  profiles?: ModelProfiles;
+  persistDefaultProfile?: (profileName: string) => Promise<void>;
+  readViewFile?: (workspaceRoot: string, filePath: string) => Promise<ViewFile>;
+  onQuit?: () => void;
+};
+
+type ResumePickerState =
+  | { status: "loading" }
+  | {
+      status: "ready";
+      sessions: readonly SessionSummary[];
+      isResuming: boolean;
+      error?: string;
+    };
+
+type ModelPickerState = {
+  isSwitching: boolean;
+  error?: string;
+};
+
+type FileViewState =
+  | { status: "loading"; filePath: string }
+  | { status: "ready"; file: ViewFile };
+
+export function App(props: AppProps) {
+  const { exit } = useApp();
+  const binding = useSyncExternalStore(
+    props.sessionController.subscribe,
+    props.sessionController.getBinding,
+    props.sessionController.getBinding,
+  );
+  const { readGitBranch, workspaceRoot } = {
+    readGitBranch: props.readGitBranch,
+    workspaceRoot: binding.workspaceRoot,
+  };
+  const state = useSyncExternalStore(
+    binding.projectionStore.subscribe,
+    binding.projectionStore.getSnapshot,
+    binding.projectionStore.getSnapshot,
+  );
+  const [isRunning, setIsRunning] = useState(false);
+  const [isSessionOperation, setIsSessionOperation] = useState(false);
+  const [isCancelling, setIsCancelling] = useState(false);
+  const [notice, setNotice] = useState<string | undefined>(undefined);
+  const [showStatus, setShowStatus] = useState(false);
+  const [resumePicker, setResumePicker] = useState<ResumePickerState | undefined>(
+    undefined,
+  );
+  const [showModelPicker, setShowModelPicker] = useState(false);
+  const [modelPickerState, setModelPickerState] = useState<
+    ModelPickerState | undefined
+  >(undefined);
+  const [fileView, setFileView] = useState<FileViewState | undefined>(undefined);
+  const [viewError, setViewError] = useState<string | undefined>(undefined);
+  const [gitBranch, setGitBranch] = useState<string | undefined>(undefined);
+  const [gitBranchRefresh, setGitBranchRefresh] = useState(0);
+  const gitBranchReadQueue = useRef<Promise<void>>(Promise.resolve());
+  const activeController = useRef<AbortController | undefined>(undefined);
+  const resumePickerRequest = useRef(0);
+  const fileViewRequest = useRef(0);
+
+  const canSwitchModel =
+    state.recentTurns.length === 0 &&
+    state.activeTurn === undefined &&
+    props.profiles !== undefined &&
+    props.profiles.profiles.size > 1;
+
+  const availableCommands = canSwitchModel
+    ? undefined
+    : SLASH_COMMANDS.filter((cmd) => cmd.name !== "model");
+
+  const profileList = props.profiles ? [...props.profiles.profiles.values()] : [];
+
+  useEffect(() => {
+    if (readGitBranch === undefined) {
+      return;
+    }
+
+    let isCurrent = true;
+    const read = gitBranchReadQueue.current.then(() => readGitBranch(workspaceRoot));
+    gitBranchReadQueue.current = read.then(
+      (branch) => {
+        if (isCurrent) {
+          setGitBranch(branch);
+        }
+      },
+      () => {
+        if (isCurrent) {
+          setGitBranch(undefined);
+        }
+      },
+    );
+
+    return () => {
+      isCurrent = false;
+    };
+  }, [readGitBranch, workspaceRoot, gitBranchRefresh]);
+
+  useInput(
+    (_input, key) => {
+      if (!key.escape) {
+        return;
+      }
+
+      const controller = activeController.current;
+      if (controller === undefined || controller.signal.aborted) {
+        return;
+      }
+
+      controller.abort(new TurnCancelledError("user"));
+      setIsCancelling(true);
+      setNotice("Cancelling current turn...");
+    },
+    { isActive: isRunning },
+  );
+
+  const closeResumePicker = () => {
+    resumePickerRequest.current += 1;
+    setResumePicker(undefined);
+    setIsSessionOperation(false);
+    setNotice(undefined);
+  };
+
+  const openResumePicker = () => {
+    const requestId = resumePickerRequest.current + 1;
+    resumePickerRequest.current = requestId;
+    setNotice(undefined);
+    setResumePicker({ status: "loading" });
+    setIsSessionOperation(true);
+    void props.sessionController
+      .listSessions()
+      .then((sessions) => {
+        if (resumePickerRequest.current !== requestId) {
+          return;
+        }
+        if (sessions.length === 0) {
+          setResumePicker(undefined);
+          setNotice("No stored sessions found for this workspace.");
+          return;
+        }
+        setResumePicker({ status: "ready", sessions, isResuming: false });
+      })
+      .catch((error: unknown) => {
+        if (resumePickerRequest.current === requestId) {
+          setResumePicker(undefined);
+          setNotice(`Session operation failed: ${errorMessage(error)}`);
+        }
+      })
+      .finally(() => {
+        if (resumePickerRequest.current === requestId) {
+          setIsSessionOperation(false);
+        }
+      });
+  };
+
+  const resumeSelectedSession = (session: SessionSummary) => {
+    setResumePicker((current) =>
+      current?.status === "ready"
+        ? { ...current, isResuming: true, error: undefined }
+        : current,
+    );
+    setIsSessionOperation(true);
+    void props.sessionController
+      .resume(session.sessionId)
+      .then(() => {
+        setResumePicker(undefined);
+        setNotice(`Resumed session ${session.sessionId}.`);
+      })
+      .catch((error: unknown) => {
+        setResumePicker((current) =>
+          current?.status === "ready"
+            ? {
+                ...current,
+                isResuming: false,
+                error: errorMessage(error),
+              }
+            : current,
+        );
+      })
+      .finally(() => setIsSessionOperation(false));
+  };
+
+  const closeModelPicker = () => {
+    setShowModelPicker(false);
+    setModelPickerState(undefined);
+    setNotice(undefined);
+  };
+
+  const doSwitchModel = (profile: ModelProfile) => {
+    setShowModelPicker(false);
+    setModelPickerState(undefined);
+    setNotice(undefined);
+    setIsSessionOperation(true);
+    void props.sessionController
+      .switchModel(profile)
+      .then(async () => {
+        setGitBranchRefresh((current) => current + 1);
+        try {
+          await props.persistDefaultProfile?.(profile.name);
+          setNotice(`Switched to model profile "${profile.name}" (${profile.model}).`);
+        } catch (error) {
+          setNotice(
+            `Switched to model profile "${profile.name}" (${profile.model}), but failed to save it as the default: ${errorMessage(error)}`,
+          );
+        }
+      })
+      .catch((error: unknown) => {
+        setNotice(`Model switch failed: ${errorMessage(error)}`);
+      })
+      .finally(() => setIsSessionOperation(false));
+  };
+
+  const closeFileView = () => {
+    fileViewRequest.current += 1;
+    setFileView(undefined);
+  };
+
+  const openFileView = (filePath: string) => {
+    const requestId = fileViewRequest.current + 1;
+    fileViewRequest.current = requestId;
+    setNotice(undefined);
+    setViewError(undefined);
+    setFileView({ status: "loading", filePath });
+
+    void Promise.resolve()
+      .then(() => (props.readViewFile ?? loadViewFile)(workspaceRoot, filePath))
+      .then((file) => {
+        if (fileViewRequest.current === requestId) {
+          setFileView({ status: "ready", file });
+        }
+      })
+      .catch((error: unknown) => {
+        if (fileViewRequest.current === requestId) {
+          setFileView(undefined);
+          setViewError(`View failed: ${errorMessage(error)}`);
+        }
+      });
+  };
+
+  const onSubmit = (prompt: string) => {
+    const trimmed = prompt.trim();
+    setShowStatus(false);
+    setViewError(undefined);
+
+    if (trimmed.startsWith("/")) {
+      let command;
+      try {
+        command = parseSlashCommand(trimmed);
+      } catch (error) {
+        setNotice(errorMessage(error));
+        return;
+      }
+
+      setNotice(undefined);
+
+      if (command.type === "view") {
+        openFileView(command.filePath);
+        return;
+      }
+      if (command.type === "status") {
+        setShowStatus(true);
+        return;
+      }
+      if (command.type === "compact") {
+        setIsSessionOperation(true);
+        void props.sessionController
+          .compact()
+          .then((result) => setNotice(formatContextCompactionNotice(result)))
+          .catch((error: unknown) => {
+            setNotice(formatContextCompactionFailureNotice(error));
+          })
+          .finally(() => setIsSessionOperation(false));
+        return;
+      }
+      if (command.type === "quit") {
+        props.onQuit?.();
+        exit();
+        return;
+      }
+      if (command.type === "model" || command.type === "model_switch") {
+        if (!canSwitchModel) {
+          setNotice(
+            "Cannot switch models after the session has turns or while running.",
+          );
+          return;
+        }
+        if (command.type === "model_switch") {
+          const targetProfile = props.profiles?.profiles.get(command.profileName);
+          if (targetProfile === undefined) {
+            setNotice(`Unknown model profile: ${command.profileName}`);
+            return;
+          }
+          void doSwitchModel(targetProfile);
+        } else {
+          setModelPickerState({ isSwitching: false });
+          setShowModelPicker(true);
+        }
+        return;
+      }
+      if (command.type === "resume_list") {
+        openResumePicker();
+        return;
+      }
+      setIsSessionOperation(true);
+      const operation =
+        command.type === "resume"
+          ? props.sessionController
+              .resume(command.sessionId)
+              .then(() => setNotice(`Resumed session ${command.sessionId}.`))
+          : props.sessionController
+              .delete(command.sessionId)
+              .then(() => setNotice(`Deleted session ${command.sessionId}.`));
+      void operation
+        .catch((error: unknown) => {
+          setNotice(`Session operation failed: ${errorMessage(error)}`);
+        })
+        .finally(() => setIsSessionOperation(false));
+      return;
+    }
+
+    if (trimmed === "" || isRunning) {
+      return;
+    }
+
+    setNotice(undefined);
+    setIsRunning(true);
+    setIsCancelling(false);
+    const controller = new AbortController();
+    activeController.current = controller;
+    void props.history?.append(trimmed).catch(() => undefined);
+    let retainNotice = false;
+    void Promise.resolve()
+      .then(() => binding.executeTurn(trimmed, controller.signal))
+      .catch((error: unknown) => {
+        retainNotice = true;
+        setNotice(
+          error instanceof ContextBudgetExceededError
+            ? error.message
+            : `Runtime failed: ${errorMessage(error)}`,
+        );
+      })
+      .finally(() => {
+        if (activeController.current === controller) {
+          activeController.current = undefined;
+          setIsRunning(false);
+          setIsCancelling(false);
+          if (!retainNotice) {
+            setNotice(undefined);
+          }
+          setGitBranchRefresh((current) => current + 1);
+        }
+      });
+  };
+
+  return (
+    <Box flexDirection="column">
+      {fileView?.status === "loading" ? (
+        <FileViewerLoading filePath={fileView.filePath} onCancel={closeFileView} />
+      ) : fileView?.status === "ready" ? (
+        <FileViewer file={fileView.file} onClose={closeFileView} />
+      ) : resumePicker?.status === "loading" ? (
+        <ResumeSessionPickerLoading onCancel={closeResumePicker} />
+      ) : resumePicker?.status === "ready" ? (
+        <ResumeSessionPicker
+          sessions={resumePicker.sessions}
+          isResuming={resumePicker.isResuming}
+          error={resumePicker.error}
+          onCancel={closeResumePicker}
+          onSelect={resumeSelectedSession}
+        />
+      ) : (
+        <>
+          <Header
+            key={binding.sessionId}
+            modelName={binding.modelName}
+            workspaceRoot={binding.workspaceRoot}
+            sessionId={binding.sessionId}
+          />
+          <Box marginTop={1} flexDirection="column">
+            <Timeline items={visibleTimelineItems(state)} />
+          </Box>
+          {state.backgroundTasks.length === 0 ? null : (
+            <Box marginTop={1}>
+              <BackgroundTasks tasks={state.backgroundTasks} />
+            </Box>
+          )}
+          {showStatus ? (
+            <Box marginTop={1}>
+              <ContextStatus state={state} />
+            </Box>
+          ) : null}
+          <Box marginTop={1}>
+            <Footer
+              status={isCancelling ? "cancelling" : state.status}
+              workedForMs={state.workedForMs}
+            />
+          </Box>
+          <Box marginTop={1} flexDirection="column">
+            {showModelPicker ? (
+              <ModelPicker
+                profiles={profileList}
+                currentProfileName={binding.profileName}
+                isSwitching={modelPickerState?.isSwitching}
+                error={modelPickerState?.error}
+                onCancel={closeModelPicker}
+                onSelect={doSwitchModel}
+              />
+            ) : (
+              <PromptInput
+                modelName={binding.modelName}
+                workspaceRoot={binding.workspaceRoot}
+                gitBranch={gitBranch}
+                contextUsage={state.contextUsage}
+                isDisabled={isRunning || isSessionOperation}
+                history={props.history}
+                commands={availableCommands}
+                onSubmit={onSubmit}
+                placeholder='Enter a coding request, or "/" for commands'
+              />
+            )}
+            {viewError === undefined ? null : <Text color="red">{viewError}</Text>}
+            {notice === undefined ? null : <Text color="yellow">{notice}</Text>}
+          </Box>
+        </>
+      )}
+    </Box>
+  );
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function formatContextCompactionNotice(result: ContextCompactionResult): string {
+  if (result.status === "unchanged") {
+    if (result.outcome === "below_target") {
+      return `Context is already below the compact target (${result.guardedTokensBefore.toLocaleString("en-US")} <= ${result.targetTokens.toLocaleString("en-US")} estimated tokens).`;
+    }
+    return "No eligible historical tool observations can be compacted.";
+  }
+  const before = result.guardedTokensBefore.toLocaleString("en-US");
+  const after = result.guardedTokensAfter.toLocaleString("en-US");
+  if (result.outcome === "insufficient_candidates") {
+    return `Context compacted: ${result.addedOverrideCount} observations swapped, ${before} -> ${after} estimated tokens; target ${result.targetTokens.toLocaleString("en-US")} was not reached.`;
+  }
+  const reduction =
+    result.guardedTokensBefore === 0
+      ? "0.0"
+      : (
+          ((result.guardedTokensBefore - result.guardedTokensAfter) /
+            result.guardedTokensBefore) *
+          100
+        ).toFixed(1);
+  return `Context compacted: revision ${result.previousRevisionNumber} -> ${result.revisionNumber}, ${result.addedOverrideCount} observations swapped, ${before} -> ${after} estimated tokens (-${reduction}%).`;
+}
+
+export function formatContextCompactionFailureNotice(error: unknown): string {
+  if (!(error instanceof ContextManagerError)) {
+    return "Context compaction failed.";
+  }
+  const code = /^[A-Za-z0-9_]+$/.test(error.code)
+    ? error.code
+    : "CONTEXT_COMPACTION_FAILED";
+  return `Context compaction failed at ${error.stage} (${code}).`;
+}

package/src/tui/components/assistant-markdown.tsx

@@ -0,0 +1,47 @@
+import {
+  MarkdownText,
+  type RenderOptions,
+  useShikiHighlighter,
+} from "@assistant-ui/react-ink-markdown";
+
+export type AssistantMarkdownProps = {
+  text: string;
+};
+
+const highlightedLanguages = [
+  "typescript",
+  "javascript",
+  "tsx",
+  "jsx",
+  "json",
+  "bash",
+  "shellscript",
+  "python",
+  "markdown",
+  "html",
+  "css",
+  "yaml",
+  "diff",
+];
+
+const tableOptions = {
+  tableTruncate: false,
+} satisfies Pick<RenderOptions, "tableTruncate">;
+
+export function AssistantMarkdown(props: AssistantMarkdownProps) {
+  const highlighter = useShikiHighlighter({
+    theme: "github-dark",
+    langs: highlightedLanguages,
+  });
+
+  return (
+    <MarkdownText
+      {...tableOptions}
+      text={props.text}
+      highlighter={highlighter}
+      codeBox
+      codeWrap
+      tableBorder="unicode"
+    />
+  );
+}

package/src/tui/components/background-tasks.tsx

@@ -0,0 +1,92 @@
+import { Box, Text } from "ink";
+import type { ShellTaskSnapshot, ShellTaskStatus } from "../../tools/bash-task";
+
+export type BackgroundTasksProps = {
+  tasks: ShellTaskSnapshot[];
+};
+
+export function BackgroundTasks(props: BackgroundTasksProps) {
+  if (props.tasks.length === 0) {
+    return null;
+  }
+
+  const runningCount = props.tasks.filter(
+    (task) => task.status === "running" || task.status === "stopping",
+  ).length;
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>
+        Background tasks · {runningCount} running / {props.tasks.length} total
+      </Text>
+      {props.tasks.map((task) => (
+        <Box key={task.taskId} flexDirection="column">
+          <Text color={colorForStatus(task.status)}>
+            {symbolForStatus(task.status)} {task.status} {taskDescription(task)}
+            {taskResult(task) === undefined ? "" : ` ${taskResult(task)}`}
+          </Text>
+          <Text dimColor>{taskTiming(task)}</Text>
+        </Box>
+      ))}
+    </Box>
+  );
+}
+
+function taskDescription(task: ShellTaskSnapshot): string {
+  const description = task.description.trim();
+  return description === "" ? task.command.replace(/\s+/g, " ").trim() : description;
+}
+
+function taskResult(task: ShellTaskSnapshot): string | undefined {
+  if (task.signal !== undefined) {
+    return `signal=${task.signal}`;
+  }
+
+  if (task.exitCode !== undefined) {
+    return `exit=${task.exitCode}`;
+  }
+
+  return task.error;
+}
+
+function taskTiming(task: ShellTaskSnapshot): string {
+  const timing = [`id=${task.taskId}`, `started=${task.startedAt}`];
+  if (task.endedAt === undefined) {
+    return timing.join(" · ");
+  }
+
+  timing.push(`ended=${task.endedAt}`);
+  return timing.join(" · ");
+}
+
+function colorForStatus(status: ShellTaskStatus): string {
+  if (status === "completed") {
+    return "green";
+  }
+
+  if (status === "failed") {
+    return "red";
+  }
+
+  if (status === "killed") {
+    return "gray";
+  }
+
+  return "yellow";
+}
+
+function symbolForStatus(status: ShellTaskStatus): string {
+  if (status === "completed") {
+    return "✔";
+  }
+
+  if (status === "failed") {
+    return "✘";
+  }
+
+  if (status === "killed") {
+    return "■";
+  }
+
+  return "…";
+}

package/src/tui/components/bash-result-view.tsx

@@ -0,0 +1,47 @@
+import { Box, Text } from "ink";
+import type { BashDisplayDetail } from "../../events/bash-result-detail";
+
+export type BashResultViewProps = {
+  detail: BashDisplayDetail;
+  maxCommandLines?: number;
+};
+
+const DEFAULT_MAX_COMMAND_LINES = 2;
+
+export function BashResultView(props: BashResultViewProps) {
+  const maxCommandLines = props.maxCommandLines ?? DEFAULT_MAX_COMMAND_LINES;
+  const commandLines = props.detail.command.split("\n");
+  const visibleCommandLines = commandLines.slice(0, maxCommandLines);
+  const hiddenCommandLines = commandLines.length - visibleCommandLines.length;
+  const outputLines = props.detail.outputPreview ?? [];
+  const omittedLines = props.detail.omittedOutputLines ?? 0;
+
+  return (
+    <Box flexDirection="column" paddingLeft={2}>
+      {visibleCommandLines.map((line, index) => (
+        <Text key={`command-${index}`} color="cyan" wrap="truncate-end">
+          {index === 0 ? "$ " : "  "}
+          {line}
+        </Text>
+      ))}
+      {hiddenCommandLines > 0 ? (
+        <Text color="cyan">
+          {"  "}… +{hiddenCommandLines} more line{hiddenCommandLines === 1 ? "" : "s"}
+        </Text>
+      ) : null}
+      {outputLines.map((line, index) => (
+        <Text key={`output-${index}`} color="gray" wrap="truncate-end">
+          {line === "" ? " " : line}
+        </Text>
+      ))}
+      {omittedLines > 0 ? (
+        <Text color="gray">
+          … +{omittedLines} line{omittedLines === 1 ? "" : "s"}
+          {props.detail.outputFilePath === undefined
+            ? ""
+            : ` (full output: ${props.detail.outputFilePath})`}
+        </Text>
+      ) : null}
+    </Box>
+  );
+}