tinker-agent 1.5.0 → 1.6.0

package/src/tui/shiki-highlighter.ts

@@ -0,0 +1,104 @@
+import type { BundledLanguage, BundledTheme } from "shiki";
+
+export type TuiShikiHighlighter = (code: string, language?: string) => string;
+
+type ShikiToken = {
+  readonly content: string;
+  readonly color?: string;
+};
+
+export type TuiShikiTokenizer = {
+  codeToTokensBase(
+    code: string,
+    options: { readonly lang: string; readonly theme: string },
+  ): readonly (readonly ShikiToken[])[];
+};
+
+const THEME = "github-dark";
+const HIGHLIGHTED_LANGUAGES = [
+  "typescript",
+  "javascript",
+  "tsx",
+  "jsx",
+  "json",
+  "bash",
+  "shellscript",
+  "python",
+  "markdown",
+  "html",
+  "css",
+  "yaml",
+  "diff",
+] as const;
+
+let preparation: Promise<void> | undefined;
+let highlighter: TuiShikiHighlighter | undefined;
+
+export function prepareShikiHighlighter(): Promise<void> {
+  preparation ??= createTuiShikiHighlighter(async () => {
+    const { createHighlighter } = await import("shiki");
+    const tokenizer = await createHighlighter({
+      themes: [THEME],
+      langs: [...HIGHLIGHTED_LANGUAGES],
+    });
+    return {
+      codeToTokensBase: (code, options) =>
+        tokenizer.codeToTokensBase(code, {
+          lang: options.lang as BundledLanguage,
+          theme: options.theme as BundledTheme,
+        }),
+    };
+  }).then((prepared) => {
+    highlighter = prepared;
+  });
+  return preparation;
+}
+
+export function getPreparedShikiHighlighter(): TuiShikiHighlighter | undefined {
+  return highlighter;
+}
+
+export async function createTuiShikiHighlighter(
+  createTokenizer: () => Promise<TuiShikiTokenizer>,
+): Promise<TuiShikiHighlighter | undefined> {
+  try {
+    const tokenizer = await createTokenizer();
+    return (code, language) => {
+      if (language === undefined || language === "") {
+        return code;
+      }
+      try {
+        return tokenizer
+          .codeToTokensBase(code, { lang: language, theme: THEME })
+          .map((line) =>
+            line
+              .map((token) => {
+                const ansi = tokenColorToAnsi(token.color);
+                return ansi === undefined
+                  ? token.content
+                  : `${ansi}${token.content}\u001b[39m`;
+              })
+              .join(""),
+          )
+          .join("\n");
+      } catch {
+        return code;
+      }
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function tokenColorToAnsi(color: string | undefined): string | undefined {
+  if (color === undefined || !color.startsWith("#") || color.length < 7) {
+    return undefined;
+  }
+  const red = Number.parseInt(color.slice(1, 3), 16);
+  const green = Number.parseInt(color.slice(3, 5), 16);
+  const blue = Number.parseInt(color.slice(5, 7), 16);
+  if ([red, green, blue].some((component) => Number.isNaN(component))) {
+    return undefined;
+  }
+  return `\u001b[38;2;${red};${green};${blue}m`;
+}

package/src/tui/slash-commands.ts

@@ -24,6 +24,11 @@ export const SLASH_COMMANDS: readonly BuiltInSlashCommand[] = [
     usage: "/mcp",
     description: "Show MCP servers and runtime tools",
   },
+  {
+    name: "yolo",
+    usage: "/yolo [on|off]",
+    description: "Show or change destructive Bash confirmation",
+  },
   {
     name: "memory",
     usage: "/memory",
@@ -34,6 +39,11 @@ export const SLASH_COMMANDS: readonly BuiltInSlashCommand[] = [
     usage: "/compact [retire]",
     description: "Swap tool output or retire a cold history prefix",
   },
+  {
+    name: "undo",
+    usage: "/undo",
+    description: "Undo the latest Write/Edit/Delete turn",
+  },
   {
     name: "clear",
     usage: "/clear",
@@ -70,11 +80,14 @@ export const SLASH_COMMANDS: readonly BuiltInSlashCommand[] = [
 
 export type ParsedSlashCommand =
   | { type: "status" }
+  | { type: "yolo_status" }
+  | { type: "yolo"; enabled: boolean }
   | { type: "skills" }
   | { type: "mcp" }
   | { type: "memory" }
   | { type: "compact" }
   | { type: "compact_retire" }
+  | { type: "undo" }
   | { type: "clear" }
   | { type: "fork" }
   | { type: "view"; filePath: string }
@@ -111,6 +124,15 @@ export function parseSlashCommand(input: string): ParsedSlashCommand {
   if (command === "/status" && tokens.length === 1) {
     return { type: "status" };
   }
+  if (command === "/yolo") {
+    if (tokens.length === 1) {
+      return { type: "yolo_status" };
+    }
+    if (tokens.length === 2 && (tokens[1] === "on" || tokens[1] === "off")) {
+      return { type: "yolo", enabled: tokens[1] === "on" };
+    }
+    throw slashCommandUsageError("yolo");
+  }
   if (command === "/skills" && tokens.length === 1) {
     return { type: "skills" };
   }
@@ -135,6 +157,12 @@ export function parseSlashCommand(input: string): ParsedSlashCommand {
     }
     throw slashCommandUsageError("compact");
   }
+  if (command === "/undo") {
+    if (tokens.length === 1) {
+      return { type: "undo" };
+    }
+    throw slashCommandUsageError("undo");
+  }
   if (command === "/clear") {
     if (tokens.length === 1) {
       return { type: "clear" };

package/src/tui/tui-projection-store.ts

@@ -1,8 +1,16 @@
 import type { EventSink } from "../events/event-sink";
 import type { AgentEvent } from "../events/types";
+import type {
+  AssistantTextDeltaSink,
+  AssistantTextDeltaUpdate,
+} from "../agent/assistant-text-delta";
 import {
   createInitialTuiProjectionState,
+  firstRunningIndex,
   reduceTuiProjection,
+  timelineStreamItems,
+  visibleTimelineItems,
+  type TimelineItem,
   type TuiProjectionState,
 } from "./event-store";
 import {
@@ -10,6 +18,7 @@ import {
   type TuiProjectionPolicy,
   validateTuiProjectionPolicy,
 } from "./tui-projection-policy";
+import { MarkdownSectionFramer } from "./assistant-markdown-section-framer";
 
 export type TuiProjectionStoreInput = {
   sessionId: string;
@@ -19,11 +28,49 @@ export type TuiProjectionStoreInput = {
   initialSnapshot?: TuiProjectionState;
 };
 
-export class TuiProjectionStore implements EventSink {
+export type AssistantStreamSectionItem = Readonly<{
+  kind: "assistant-stream-section";
+  id: string;
+  iterationId: string;
+  attemptNumber: number;
+  sectionNumber: number;
+  markdown: string;
+  showAssistantLabel: boolean;
+}>;
+
+export type TuiCommittedItem = TimelineItem | AssistantStreamSectionItem;
+
+export function isAssistantStreamSectionItem(
+  item: TuiCommittedItem,
+): item is AssistantStreamSectionItem {
+  return "kind" in item && item.kind === "assistant-stream-section";
+}
+
+export type TuiTimelineLog = Readonly<{
+  committed: readonly TuiCommittedItem[];
+  live: readonly TimelineItem[];
+}>;
+
+type AssistantStreamAttempt = {
+  readonly sessionId: string;
+  readonly turnId: string;
+  readonly turnNumber: number;
+  readonly iterationId: string;
+  readonly iterationNumber: number;
+  readonly attemptNumber: number;
+  readonly framer: MarkdownSectionFramer;
+  sectionCount: number;
+};
+
+export class TuiProjectionStore implements EventSink, AssistantTextDeltaSink {
   readonly name = "tui-projection-store";
   private readonly listeners = new Set<() => void>();
   private readonly policy: TuiProjectionPolicy;
+  private readonly printed = new Set<string>();
+  private readonly physicallyAdoptedIterations = new Map<string, string>();
   private snapshot: TuiProjectionState;
+  private log: TuiTimelineLog = { committed: [], live: [] };
+  private assistantStreamAttempt?: AssistantStreamAttempt;
 
   constructor(input: TuiProjectionStoreInput) {
     this.policy = validateTuiProjectionPolicy(
@@ -33,10 +80,15 @@ export class TuiProjectionStore implements EventSink {
       input.initialSnapshot === undefined
         ? createInitialTuiProjectionState(input)
         : validateInitialSnapshot(input, input.initialSnapshot, this.policy);
+    if (input.initialSnapshot !== undefined) {
+      this.refreshLog(visibleTimelineItems(this.snapshot));
+    }
   }
 
   readonly getSnapshot = (): TuiProjectionState => this.snapshot;
 
+  readonly getLogSnapshot = (): TuiTimelineLog => this.log;
+
   readonly subscribe = (listener: () => void): (() => void) => {
     this.listeners.add(listener);
     return () => {
@@ -46,14 +98,40 @@ export class TuiProjectionStore implements EventSink {
 
   async append(event: AgentEvent): Promise<void> {
     const next = reduceTuiProjection(this.snapshot, event, this.policy);
-    if (next === this.snapshot) {
+    const snapshotChanged = next !== this.snapshot;
+    this.snapshot = next;
+    const presentationChanged = this.applyAssistantStreamEvent(event);
+    if (!snapshotChanged && !presentationChanged) {
       return;
     }
 
-    this.snapshot = next;
-    for (const listener of this.listeners) {
-      listener();
+    if (snapshotChanged) {
+      this.refreshLog();
+    }
+    this.notifyListeners();
+  }
+
+  updateAssistantTextDelta(update: AssistantTextDeltaUpdate): void {
+    const attempt = this.assistantStreamAttempt;
+    if (
+      attempt === undefined ||
+      update.content === "" ||
+      !sameAssistantStreamAttempt(attempt, update)
+    ) {
+      return;
+    }
+
+    const frames = attempt.framer.push(update.content);
+    if (frames.length === 0) {
+      return;
     }
+    const committed = [...this.log.committed];
+    for (const frame of frames) {
+      attempt.sectionCount += 1;
+      committed.push(this.sectionItem(attempt, frame.markdown));
+    }
+    this.log = { committed, live: this.log.live };
+    this.notifyListeners();
   }
 
   hydrate(snapshot: TuiProjectionState): void {
@@ -73,10 +151,204 @@ export class TuiProjectionStore implements EventSink {
       snapshot,
       this.policy,
     );
+    this.refreshLog(visibleTimelineItems(this.snapshot));
+    this.notifyListeners();
+  }
+
+  private applyAssistantStreamEvent(event: AgentEvent): boolean {
+    switch (event.type) {
+      case "model.request.started":
+        this.assistantStreamAttempt = assistantStreamAttempt(event);
+        return false;
+      case "model.request.failed":
+        return this.failAssistantStreamAttempt(event);
+      case "model.request.finished":
+        return this.finishAssistantStreamAttempt(event);
+      case "assistant.progress":
+        if (
+          event.iterationId !== undefined &&
+          this.physicallyAdoptedIterations.has(event.iterationId)
+        ) {
+          this.printed.add(`assistant-${event.iterationId}-${event.eventSequence}`);
+        }
+        return false;
+      case "turn.finished": {
+        const adopted = this.physicallyAdoptedIterations.has(
+          event.data.lastIteration.iterationId,
+        );
+        if (adopted) {
+          this.printed.add(`turn-${event.turnId}-final-${event.eventSequence}`);
+        }
+        this.clearAdoptedTurn(event.turnId);
+        this.assistantStreamAttempt = undefined;
+        return false;
+      }
+      case "turn.failed":
+      case "turn.cancelled":
+        this.clearAdoptedTurn(event.turnId);
+        this.assistantStreamAttempt = undefined;
+        return false;
+      case "session.finished":
+        this.physicallyAdoptedIterations.clear();
+        this.assistantStreamAttempt = undefined;
+        return false;
+      default:
+        return false;
+    }
+  }
+
+  private failAssistantStreamAttempt(
+    event: Extract<AgentEvent, { type: "model.request.failed" }>,
+  ): boolean {
+    const attempt = this.assistantStreamAttempt;
+    if (attempt === undefined || !sameAssistantStreamEvent(attempt, event)) {
+      return false;
+    }
+    this.assistantStreamAttempt = undefined;
+    if (event.data.retryDisposition !== "scheduled" || attempt.sectionCount === 0) {
+      return false;
+    }
+    this.appendCommitted({
+      id: `assistant-stream-retry-${attempt.iterationId}-${attempt.attemptNumber}`,
+      text: "assistant response interrupted · retrying",
+      status: "info",
+    });
+    return true;
+  }
+
+  private finishAssistantStreamAttempt(
+    event: Extract<AgentEvent, { type: "model.request.finished" }>,
+  ): boolean {
+    const attempt = this.assistantStreamAttempt;
+    if (attempt === undefined || !sameAssistantStreamEvent(attempt, event)) {
+      return false;
+    }
+    this.assistantStreamAttempt = undefined;
+    const result = attempt.framer.finish();
+    if (
+      attempt.sectionCount === 0 ||
+      result.content !== (event.data.output.message.content ?? "")
+    ) {
+      return false;
+    }
+
+    this.printed.add(`model-${attempt.iterationId}`);
+    this.physicallyAdoptedIterations.set(attempt.iterationId, attempt.turnId);
+    if (result.tail === "") {
+      return false;
+    }
+    attempt.sectionCount += 1;
+    this.appendCommitted(this.sectionItem(attempt, result.tail));
+    return true;
+  }
+
+  private sectionItem(
+    attempt: AssistantStreamAttempt,
+    markdown: string,
+  ): AssistantStreamSectionItem {
+    return Object.freeze({
+      kind: "assistant-stream-section",
+      id: `assistant-stream-${attempt.iterationId}-${attempt.attemptNumber}-${attempt.sectionCount}`,
+      iterationId: attempt.iterationId,
+      attemptNumber: attempt.attemptNumber,
+      sectionNumber: attempt.sectionCount,
+      markdown,
+      showAssistantLabel: attempt.sectionCount === 1,
+    });
+  }
+
+  private appendCommitted(item: TuiCommittedItem): void {
+    this.log = {
+      committed: [...this.log.committed, item],
+      live: this.log.live,
+    };
+  }
+
+  private clearAdoptedTurn(turnId: string | undefined): void {
+    if (turnId === undefined) {
+      return;
+    }
+    for (const [iterationId, adoptedTurnId] of this.physicallyAdoptedIterations) {
+      if (adoptedTurnId === turnId) {
+        this.physicallyAdoptedIterations.delete(iterationId);
+      }
+    }
+  }
+
+  private notifyListeners(): void {
     for (const listener of this.listeners) {
       listener();
     }
   }
+
+  private refreshLog(stream = timelineStreamItems(this.snapshot)): void {
+    const settledEnd = firstRunningIndex(stream);
+    const pending = stream
+      .slice(0, settledEnd)
+      .filter((item) => !this.printed.has(item.id));
+    for (const item of pending) {
+      this.printed.add(item.id);
+    }
+    this.log = {
+      committed:
+        pending.length === 0 ? this.log.committed : [...this.log.committed, ...pending],
+      live: stream.slice(settledEnd),
+    };
+  }
+}
+
+function assistantStreamAttempt(
+  event: Extract<AgentEvent, { type: "model.request.started" }>,
+): AssistantStreamAttempt | undefined {
+  if (
+    event.turnId === undefined ||
+    event.turnNumber === undefined ||
+    event.iterationId === undefined ||
+    event.iterationNumber === undefined
+  ) {
+    return undefined;
+  }
+  return {
+    sessionId: event.sessionId,
+    turnId: event.turnId,
+    turnNumber: event.turnNumber,
+    iterationId: event.iterationId,
+    iterationNumber: event.iterationNumber,
+    attemptNumber: event.data.attemptNumber,
+    framer: new MarkdownSectionFramer(),
+    sectionCount: 0,
+  };
+}
+
+function sameAssistantStreamAttempt(
+  attempt: AssistantStreamAttempt,
+  update: AssistantTextDeltaUpdate,
+): boolean {
+  return (
+    attempt.sessionId === update.sessionId &&
+    attempt.turnId === update.turnId &&
+    attempt.turnNumber === update.turnNumber &&
+    attempt.iterationId === update.iterationId &&
+    attempt.iterationNumber === update.iterationNumber &&
+    attempt.attemptNumber === update.attemptNumber
+  );
+}
+
+function sameAssistantStreamEvent(
+  attempt: AssistantStreamAttempt,
+  event: Extract<
+    AgentEvent,
+    { type: "model.request.failed" | "model.request.finished" }
+  >,
+): boolean {
+  return (
+    attempt.sessionId === event.sessionId &&
+    attempt.turnId === event.turnId &&
+    attempt.turnNumber === event.turnNumber &&
+    attempt.iterationId === event.iterationId &&
+    attempt.iterationNumber === event.iterationNumber &&
+    attempt.attemptNumber === event.data.attemptNumber
+  );
 }
 
 function validateInitialSnapshot(

package/src/tui/tui-session-controller.ts

@@ -5,11 +5,13 @@ import type {
 import type {
   ExecuteTurnInput,
   AcceptedTurn,
+  BashGuardSnapshot,
   RuntimeSession,
   RuntimeSkillsSnapshot,
   SessionDisposeReason,
 } from "../agent/runtime-session";
 import type { RunAgentResult, UserMessage } from "../agent/types";
+import type { TurnUndoResult } from "../tools/turn-undo-manager";
 import type { ImageAssetRef } from "../image/image-types";
 import type { ImportedImageAsset } from "../image/image-asset-store";
 import type { SessionId } from "../ids/runtime-id";
@@ -39,6 +41,10 @@ export type TuiSessionBinding = {
   ) => Promise<void>;
   admitTurn?: (userMessage: UserMessage, signal: AbortSignal) => Promise<AcceptedTurn>;
   executeTurn(userMessage: UserMessage, signal: AbortSignal): Promise<RunAgentResult>;
+  bashGuard(): BashGuardSnapshot;
+  subscribeBashGuard(listener: () => void): () => void;
+  setYoloMode(enabled: boolean): void;
+  resolveBashConfirmation(decision: "allow" | "deny"): Promise<void>;
 };
 
 export type TuiSessionController = {
@@ -47,11 +53,12 @@ export type TuiSessionController = {
   listSessions: () => Promise<readonly SessionSummary[]>;
   compact: () => Promise<ContextCompactionResult>;
   retire: () => Promise<ContextRetirementResult>;
-  fork: () => Promise<SessionId>;
-  clear: () => Promise<void>;
-  resume: (sessionId: SessionId) => Promise<void>;
+  undo: () => Promise<TurnUndoResult>;
+  fork: (beforeCommit?: () => void) => Promise<SessionId>;
+  clear: (beforeCommit?: () => void) => Promise<void>;
+  resume: (sessionId: SessionId, beforeCommit?: () => void) => Promise<void>;
   delete: (sessionId: SessionId) => Promise<void>;
-  switchModel: (profile: ModelProfile) => Promise<void>;
+  switchModel: (profile: ModelProfile, beforeCommit?: () => void) => Promise<void>;
 };
 
 export type ManagedTuiSessionBinding = TuiSessionBinding & {
@@ -100,7 +107,13 @@ export class DefaultTuiSessionController implements TuiSessionController {
     return this.serialize(() => this.binding.runtimeSession.retireContext());
   }
 
-  fork(): Promise<SessionId> {
+  undo(): Promise<TurnUndoResult> {
+    return this.serialize(() =>
+      this.binding.runtimeSession.undoLatestFileMutationTurn(),
+    );
+  }
+
+  fork(beforeCommit?: () => void): Promise<SessionId> {
     return this.serialize(async () => {
       const targetSessionId = createUuidV7() as SessionId;
       await this.replaceSession(
@@ -109,21 +122,23 @@ export class DefaultTuiSessionController implements TuiSessionController {
           await current.runtimeSession.cloneSession(targetSessionId);
           return this.openSession(targetSessionId);
         },
+        beforeCommit,
       );
       return targetSessionId;
     });
   }
 
-  clear(): Promise<void> {
+  clear(beforeCommit?: () => void): Promise<void> {
     return this.serialize(() =>
       this.replaceSession(
         "Cannot clear the session while a turn, context operation, or background task is active.",
         (current) => this.createFreshSession(current),
+        beforeCommit,
       ),
     );
   }
 
-  resume(sessionId: SessionId): Promise<void> {
+  resume(sessionId: SessionId, beforeCommit?: () => void): Promise<void> {
     return this.serialize(async () => {
       if (sessionId === this.binding.sessionId) {
         throw new Error(`Session ${sessionId} is already current.`);
@@ -131,6 +146,7 @@ export class DefaultTuiSessionController implements TuiSessionController {
       await this.replaceSession(
         "Cannot switch sessions while a turn or background task is active.",
         () => this.openSession(sessionId),
+        beforeCommit,
       );
     });
   }
@@ -139,11 +155,12 @@ export class DefaultTuiSessionController implements TuiSessionController {
     return this.serialize(() => this.catalog.delete(sessionId, this.binding.sessionId));
   }
 
-  switchModel(profile: ModelProfile): Promise<void> {
+  switchModel(profile: ModelProfile, beforeCommit?: () => void): Promise<void> {
     return this.serialize(() =>
       this.replaceSession(
         "Cannot switch models while a turn or background task is active.",
         () => this.createSessionWithProfile(profile),
+        beforeCommit,
       ),
     );
   }
@@ -157,6 +174,7 @@ export class DefaultTuiSessionController implements TuiSessionController {
     createTarget: (
       current: ManagedTuiSessionBinding,
     ) => Promise<ManagedTuiSessionBinding>,
+    beforeCommit?: () => void,
   ): Promise<void> {
     const current = this.binding;
     if (!current.runtimeSession.canSwitchSession()) {
@@ -172,6 +190,7 @@ export class DefaultTuiSessionController implements TuiSessionController {
         .catch(() => undefined);
       throw error;
     }
+    beforeCommit?.();
     this.binding = target;
     for (const listener of this.listeners) {
       listener();
@@ -224,6 +243,11 @@ export function managedTuiBinding(input: {
         userMessage,
         signal,
       } satisfies ExecuteTurnInput),
+    bashGuard: () => input.runtimeSession.bashGuard(),
+    subscribeBashGuard: (listener) => input.runtimeSession.subscribeBashGuard(listener),
+    setYoloMode: (enabled) => input.runtimeSession.setYoloMode(enabled),
+    resolveBashConfirmation: (decision) =>
+      input.runtimeSession.resolveBashConfirmation(decision),
   };
 }