tinker-agent 1.0.65 → 1.2.0

package/src/tui/app.tsx

@@ -4,8 +4,12 @@ import { TurnCancelledError } from "../agent/turn-cancellation";
 import {
   ContextManagerError,
   type ContextCompactionResult,
+  type ContextRetirementResult,
 } from "../context/context-manager";
 import { ContextBudgetExceededError } from "../model/model-request-preflight";
+import { ModelRequestMediaAggregateError } from "../model/model-client";
+import type { SessionId } from "../ids/runtime-id";
+import { readLastAssistantResponse } from "../session/session-last-response-reader";
 import { visibleTimelineItems } from "./event-store";
 import type { PromptHistory } from "./prompt-history";
 import { Footer } from "./components/footer";
@@ -14,25 +18,44 @@ 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 {
+  PromptInput,
+  type PromptMaintenanceAction,
+  type PromptSubmission,
+  type PromptSubmissionOutcome,
+} from "./components/prompt-input";
+import { createPromptDraft } from "./prompt-draft";
+import { SkillsPanel } from "./components/skills-panel";
+import { McpPanel } from "./components/mcp-panel";
 import {
   ResumeSessionPicker,
   ResumeSessionPickerLoading,
 } from "./components/resume-session-picker";
 import { Timeline } from "./components/timeline";
 import { parseSlashCommand, SLASH_COMMANDS } from "./slash-commands";
+import {
+  resolveProjectSlashCommand,
+  type ProjectSlashCommand,
+} from "./project-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";
+import { writeClipboardText } from "./clipboard";
 
 export type AppProps = {
   sessionController: TuiSessionController;
   readGitBranch?: (workspaceRoot: string) => Promise<string | undefined>;
   history?: PromptHistory;
+  projectSlashCommands?: readonly ProjectSlashCommand[];
   profiles?: ModelProfiles;
   persistDefaultProfile?: (profileName: string) => Promise<void>;
   readViewFile?: (workspaceRoot: string, filePath: string) => Promise<ViewFile>;
+  readLastResponse?: (
+    workspaceRoot: string,
+    sessionId: SessionId,
+  ) => Promise<string | undefined>;
+  writeClipboard?: (markdown: string) => Promise<void>;
   onQuit?: () => void;
 };
 
@@ -72,9 +95,12 @@ export function App(props: AppProps) {
   );
   const [isRunning, setIsRunning] = useState(false);
   const [isSessionOperation, setIsSessionOperation] = useState(false);
+  const [isCopying, setIsCopying] = useState(false);
   const [isCancelling, setIsCancelling] = useState(false);
   const [notice, setNotice] = useState<string | undefined>(undefined);
   const [showStatus, setShowStatus] = useState(false);
+  const [showSkills, setShowSkills] = useState(false);
+  const [showMcp, setShowMcp] = useState(false);
   const [resumePicker, setResumePicker] = useState<ResumePickerState | undefined>(
     undefined,
   );
@@ -97,9 +123,10 @@ export function App(props: AppProps) {
     props.profiles !== undefined &&
     props.profiles.profiles.size > 1;
 
-  const availableCommands = canSwitchModel
-    ? undefined
-    : SLASH_COMMANDS.filter((cmd) => cmd.name !== "model");
+  const builtInCommands = canSwitchModel
+    ? SLASH_COMMANDS
+    : SLASH_COMMANDS.filter((command) => command.name !== "model");
+  const availableCommands = [...builtInCommands, ...(props.projectSlashCommands ?? [])];
 
   const profileList = props.profiles ? [...props.profiles.profiles.values()] : [];
 
@@ -269,102 +296,76 @@ export function App(props: AppProps) {
       });
   };
 
-  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.",
-          );
+  const copyLastResponse = () => {
+    setIsCopying(true);
+    void Promise.resolve()
+      .then(() =>
+        props.readLastResponse === undefined
+          ? readLastAssistantResponse({
+              workspaceRoot,
+              sessionId: binding.sessionId,
+            })
+          : props.readLastResponse(workspaceRoot, binding.sessionId),
+      )
+      .then(async (markdown) => {
+        if (markdown === undefined) {
+          setNotice("No assistant response is available to copy.");
           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;
-    }
+        await (props.writeClipboard ?? writeClipboardText)(markdown);
+        setNotice("Copied last response as Markdown.");
+      })
+      .catch((error: unknown) => {
+        setNotice(`Copy failed: ${errorMessage(error)}`);
+      })
+      .finally(() => setIsCopying(false));
+  };
 
+  const submitAgentPrompt = async (
+    submission: PromptSubmission,
+    admissionSignal: AbortSignal,
+  ): Promise<PromptSubmissionOutcome> => {
+    if (isRunning) return false;
     setNotice(undefined);
-    setIsRunning(true);
     setIsCancelling(false);
     const controller = new AbortController();
+    const forwardAbort = () => controller.abort(admissionSignal.reason);
+    if (admissionSignal.aborted) {
+      forwardAbort();
+    } else {
+      admissionSignal.addEventListener("abort", forwardAbort, { once: true });
+    }
+
+    let accepted;
+    try {
+      if (binding.admitTurn === undefined) {
+        throw new Error("TUI session binding does not implement turn admission.");
+      }
+      accepted = await binding.admitTurn(submission.userMessage, controller.signal);
+    } catch (error) {
+      admissionSignal.removeEventListener("abort", forwardAbort);
+      if (
+        error instanceof ContextBudgetExceededError ||
+        error instanceof ModelRequestMediaAggregateError
+      ) {
+        return {
+          kind: "maintenance_offer",
+          reason:
+            error instanceof ContextBudgetExceededError ? "budget" : "media_aggregate",
+          message: error.message,
+        };
+      }
+      setNotice(`Turn was not accepted: ${errorMessage(error)}`);
+      return false;
+    }
+
     activeController.current = controller;
-    void props.history?.append(trimmed).catch(() => undefined);
-    let retainNotice = false;
-    void Promise.resolve()
-      .then(() => binding.executeTurn(trimmed, controller.signal))
+    setIsRunning(true);
+    void props.history?.append(submission.draft).catch((error: unknown) => {
+      setNotice(`Prompt history write failed: ${errorMessage(error)}`);
+    });
+    void accepted.completion
       .catch((error: unknown) => {
-        retainNotice = true;
         setNotice(
           error instanceof ContextBudgetExceededError
             ? error.message
@@ -376,12 +377,202 @@ export function App(props: AppProps) {
           activeController.current = undefined;
           setIsRunning(false);
           setIsCancelling(false);
-          if (!retainNotice) {
-            setNotice(undefined);
-          }
+          setNotice((current) =>
+            current === "Cancelling current turn..." ? undefined : current,
+          );
           setGitBranchRefresh((current) => current + 1);
         }
+        admissionSignal.removeEventListener("abort", forwardAbort);
       });
+    return true;
+  };
+
+  const onMaintenance = async (
+    action: PromptMaintenanceAction,
+    signal: AbortSignal,
+  ): Promise<void> => {
+    signal.throwIfAborted();
+    setIsSessionOperation(true);
+    try {
+      if (action === "compact") {
+        const result = await props.sessionController.compact();
+        signal.throwIfAborted();
+        setNotice(formatContextCompactionNotice(result));
+        return;
+      }
+      if (action === "retire") {
+        const result = await props.sessionController.retire();
+        signal.throwIfAborted();
+        setNotice(formatContextRetirementNotice(result));
+        return;
+      }
+      await props.sessionController.clear();
+      signal.throwIfAborted();
+      const sessionId = props.sessionController.getBinding().sessionId;
+      setGitBranchRefresh((current) => current + 1);
+      setNotice(
+        `Started new session ${sessionId}. The image Prompt was preserved and was not submitted.`,
+      );
+    } finally {
+      setIsSessionOperation(false);
+    }
+  };
+
+  const onSubmit = (
+    submission: PromptSubmission,
+    signal: AbortSignal,
+  ): PromptSubmissionOutcome | Promise<PromptSubmissionOutcome> => {
+    const { userMessage } = submission;
+    const trimmed = userMessage.content.trim();
+    setShowStatus(false);
+    setShowSkills(false);
+    setShowMcp(false);
+    setViewError(undefined);
+
+    if (userMessage.attachments === undefined && trimmed.startsWith("/")) {
+      try {
+        const projectCommand = resolveProjectSlashCommand(
+          trimmed,
+          props.projectSlashCommands ?? [],
+        );
+        if (projectCommand !== undefined) {
+          return submitAgentPrompt(
+            {
+              draft: createPromptDraft(projectCommand.prompt),
+              userMessage: { role: "user", content: projectCommand.prompt },
+            },
+            signal,
+          );
+        }
+
+        const command = parseSlashCommand(trimmed);
+        setNotice(undefined);
+
+        if (command.type === "view") {
+          openFileView(command.filePath);
+          return true;
+        }
+        if (command.type === "copy") {
+          copyLastResponse();
+          return true;
+        }
+        if (command.type === "status") {
+          setShowStatus(true);
+          return true;
+        }
+        if (command.type === "skills") {
+          setShowSkills(true);
+          return true;
+        }
+        if (command.type === "mcp") {
+          setShowMcp(true);
+          return true;
+        }
+        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 true;
+        }
+        if (command.type === "compact_retire") {
+          setIsSessionOperation(true);
+          void props.sessionController
+            .retire()
+            .then((result) => setNotice(formatContextRetirementNotice(result)))
+            .catch((error: unknown) => {
+              setNotice(formatContextRetirementFailureNotice(error));
+            })
+            .finally(() => setIsSessionOperation(false));
+          return true;
+        }
+        if (command.type === "clear") {
+          setIsSessionOperation(true);
+          void props.sessionController
+            .clear()
+            .then(() => {
+              const sessionId = props.sessionController.getBinding().sessionId;
+              setGitBranchRefresh((current) => current + 1);
+              setNotice(
+                `Started new session ${sessionId}. Previous session remains available via /resume.`,
+              );
+            })
+            .catch((error: unknown) => {
+              setNotice(`Clear failed: ${errorMessage(error)}`);
+            })
+            .finally(() => setIsSessionOperation(false));
+          return true;
+        }
+        if (command.type === "fork") {
+          setIsSessionOperation(true);
+          void props.sessionController
+            .fork()
+            .then((sessionId) => {
+              setGitBranchRefresh((current) => current + 1);
+              setNotice(
+                `Cloned current session as ${sessionId}. Previous session remains available via /resume.`,
+              );
+            })
+            .catch((error: unknown) => {
+              setNotice(`Fork failed: ${errorMessage(error)}`);
+            })
+            .finally(() => setIsSessionOperation(false));
+          return true;
+        }
+        if (command.type === "quit") {
+          props.onQuit?.();
+          exit();
+          return true;
+        }
+        if (command.type === "model" || command.type === "model_switch") {
+          if (!canSwitchModel) {
+            setNotice(
+              "Cannot switch models after the session has turns or while running.",
+            );
+            return false;
+          }
+          if (command.type === "model_switch") {
+            const targetProfile = props.profiles?.profiles.get(command.profileName);
+            if (targetProfile === undefined) {
+              setNotice(`Unknown model profile: ${command.profileName}`);
+              return false;
+            }
+            void doSwitchModel(targetProfile);
+          } else {
+            setModelPickerState({ isSwitching: false });
+            setShowModelPicker(true);
+          }
+          return true;
+        }
+        if (command.type === "resume_list") {
+          openResumePicker();
+          return true;
+        }
+        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));
+      } catch (error) {
+        setNotice(errorMessage(error));
+        return false;
+      }
+      return true;
+    }
+    return submitAgentPrompt(submission, signal);
   };
 
   return (
@@ -421,6 +612,16 @@ export function App(props: AppProps) {
               <ContextStatus state={state} />
             </Box>
           ) : null}
+          {showSkills ? (
+            <Box marginTop={1}>
+              <SkillsPanel snapshot={binding.skills()} />
+            </Box>
+          ) : null}
+          {showMcp ? (
+            <Box marginTop={1}>
+              <McpPanel snapshot={binding.mcp()} />
+            </Box>
+          ) : null}
           <Box marginTop={1}>
             <Footer
               status={isCancelling ? "cancelling" : state.status}
@@ -443,10 +644,13 @@ export function App(props: AppProps) {
                 workspaceRoot={binding.workspaceRoot}
                 gitBranch={gitBranch}
                 contextUsage={state.contextUsage}
-                isDisabled={isRunning || isSessionOperation}
+                isDisabled={isRunning || isSessionOperation || isCopying}
                 history={props.history}
                 commands={availableCommands}
+                importImage={binding.importImage}
+                verifyImageAssets={binding.verifyImageAssets}
                 onSubmit={onSubmit}
+                onMaintenance={onMaintenance}
                 placeholder='Enter a coding request, or "/" for commands'
               />
             )}
@@ -495,3 +699,36 @@ export function formatContextCompactionFailureNotice(error: unknown): string {
     : "CONTEXT_COMPACTION_FAILED";
   return `Context compaction failed at ${error.stage} (${code}).`;
 }
+
+export function formatContextRetirementNotice(result: ContextRetirementResult): string {
+  if (result.status === "unchanged") {
+    if (result.outcome === "below_target") {
+      return `Context is already below the retirement target (${result.guardedTokensBefore.toLocaleString("en-US")} <= ${result.targetTokens.toLocaleString("en-US")} estimated tokens).`;
+    }
+    return "No complete cold prefix can be retired; the most recent 8 completed turns are protected.";
+  }
+  const before = result.guardedTokensBefore.toLocaleString("en-US");
+  const after = result.guardedTokensAfter.toLocaleString("en-US");
+  if (result.outcome === "retirement_floor") {
+    return `Context prefix retired: revision ${result.previousRevisionNumber} -> ${result.revisionNumber}, ${result.retiredTurnCount} turns removed from the active request, ${before} -> ${after} estimated tokens; target ${result.targetTokens.toLocaleString("en-US")} was not reached. Run /compact first when retained tool output is still eligible. Older history remains available through Recall.`;
+  }
+  const reduction =
+    result.guardedTokensBefore === 0
+      ? "0.0"
+      : (
+          ((result.guardedTokensBefore - result.guardedTokensAfter) /
+            result.guardedTokensBefore) *
+          100
+        ).toFixed(1);
+  return `Context prefix retired: revision ${result.previousRevisionNumber} -> ${result.revisionNumber}, ${result.retiredTurnCount} turns removed from the active request, ${before} -> ${after} estimated tokens (-${reduction}%). Older history remains available through Recall.`;
+}
+
+export function formatContextRetirementFailureNotice(error: unknown): string {
+  if (!(error instanceof ContextManagerError)) {
+    return "Context prefix retirement failed.";
+  }
+  const code = /^[A-Za-z0-9_]+$/.test(error.code)
+    ? error.code
+    : "CONTEXT_RETIREMENT_FAILED";
+  return `Context prefix retirement failed at ${error.stage} (${code}).`;
+}

package/src/tui/clipboard.ts

@@ -0,0 +1,5 @@
+import clipboard from "clipboardy";
+
+export async function writeClipboardText(text: string): Promise<void> {
+  await clipboard.write(text);
+}

package/src/tui/components/mcp-panel.tsx

@@ -0,0 +1,28 @@
+import { Box, Text } from "ink";
+import type { McpInventorySnapshot } from "../../mcp/mcp-manager";
+
+export function McpPanel(props: { snapshot: McpInventorySnapshot }) {
+  return (
+    <Box flexDirection="column">
+      <Text bold>MCP Tools</Text>
+      {props.snapshot.servers.length === 0 ? (
+        <Text color="yellow"> no MCP servers configured</Text>
+      ) : (
+        props.snapshot.servers.map((server) => (
+          <Box key={server.name} flexDirection="column">
+            <Text>
+              {" "}
+              <Text bold>{server.name}</Text>
+              {` (connected, ${server.tools.length} tool${server.tools.length === 1 ? "" : "s"})`}
+            </Text>
+            <Text dimColor>
+              {server.tools.length === 0
+                ? "  no tools available"
+                : `  ${server.tools.join(", ")}`}
+            </Text>
+          </Box>
+        ))
+      )}
+    </Box>
+  );
+}