tinker-agent 1.5.1 → 1.6.0

package/src/tools/types.ts

@@ -72,6 +72,13 @@ export type EditFileRawResult = {
   error?: string;
 };
 
+export type DeleteFileRawResult = {
+  ok: boolean;
+  filePath: string;
+  absolutePath?: string;
+  error?: string;
+};
+
 export type GlobRawResult = {
   ok: boolean;
   pattern: string;
@@ -313,6 +320,7 @@ export type ToolRawResultByKind = {
   read: ReadFileRawResult;
   write: WriteFileRawResult;
   edit: EditFileRawResult;
+  delete: DeleteFileRawResult;
   glob: GlobRawResult;
   grep: GrepRawResult;
   bash: BashRawResult;
@@ -367,6 +375,11 @@ export function defineToolExecutor<TKind extends ToolRawResultKind>(
 
 export type ToolExecutionContext = {
   signal: AbortSignal;
+  confirmBashCommand?: (request: {
+    command: string;
+    reason: string;
+  }) => Promise<"allow" | "deny">;
+  bashGuardSurface?: "tui" | "one-shot";
 };
 
 export class ToolExecutionFatalError extends Error {

package/src/tools/write.ts

@@ -5,6 +5,7 @@ import { computeFilePatch } from "./file-diff";
 import { ensureParentDirectory } from "./ensure-parent-directory";
 import { sha256Bytes, sha256Text } from "./hash";
 import { resolveWorkspacePath } from "./path-safety";
+import type { TurnUndoManager } from "./turn-undo-manager";
 import { defineToolExecutor } from "./types";
 import type {
   FileSnapshotStore,
@@ -21,6 +22,7 @@ type WriteArgs = {
 export type WriteToolOptions = {
   workspaceRoot: string;
   snapshots: FileSnapshotStore;
+  undoManager?: TurnUndoManager;
 };
 
 export function createWriteToolExecutor(options: WriteToolOptions): ToolExecutor {
@@ -47,7 +49,7 @@ export function createWriteToolExecutor(options: WriteToolOptions): ToolExecutor
     },
     async execute(
       args,
-      _call,
+      call,
       context: ToolExecutionContext,
     ): Promise<WriteFileRawResult> {
       throwIfTurnCancelled(context.signal);
@@ -118,10 +120,24 @@ export function createWriteToolExecutor(options: WriteToolOptions): ToolExecutor
         oldContent = target.content;
       }
 
+      const undoCapture = await options.undoManager?.captureBeforeMutation({
+        turnId: call.turnId,
+        turnNumber: call.turnNumber,
+        absolutePath,
+        displayPath: input.file_path,
+        loadBefore: async () =>
+          target.exists
+            ? { state: "present", bytes: target.bytes }
+            : { state: "absent" },
+      });
+
       throwIfTurnCancelled(context.signal);
       try {
         await ensureParentDirectory(absolutePath);
       } catch (error) {
+        if (undoCapture !== undefined) {
+          await options.undoManager?.recordMutationFailure(undoCapture);
+        }
         return {
           ok: false,
           filePath: input.file_path,
@@ -129,15 +145,39 @@ export function createWriteToolExecutor(options: WriteToolOptions): ToolExecutor
           error: `Failed to create parent directory: ${errorMessage(error)}`,
         };
       }
-      throwIfTurnCancelled(context.signal);
-      await writeFile(absolutePath, input.content, "utf8");
-      const newSha256 = sha256Text(input.content);
-      const writtenInfo = await stat(absolutePath);
-      options.snapshots.set(absolutePath, {
-        sha256: newSha256,
-        mtimeMs: writtenInfo.mtimeMs,
-        source: "write",
-      });
+      let newSha256: string;
+      try {
+        throwIfTurnCancelled(context.signal);
+        await writeFile(absolutePath, input.content, "utf8");
+        const expectedSha256 = sha256Text(input.content);
+        const written = await targetFileState(absolutePath);
+        if (!written.ok) {
+          throw new Error(`Failed to verify written file: ${written.error}`);
+        }
+        if (!written.exists) {
+          throw new Error("Failed to verify written file: File does not exist.");
+        }
+        if (written.sha256 !== expectedSha256) {
+          throw new Error("File changed while Write was being verified.");
+        }
+        newSha256 = written.sha256;
+        if (undoCapture !== undefined) {
+          options.undoManager?.recordMutationResult(undoCapture, {
+            state: "present",
+            sha256: newSha256,
+          });
+        }
+        options.snapshots.set(absolutePath, {
+          sha256: newSha256,
+          mtimeMs: written.mtimeMs,
+          source: "write",
+        });
+      } catch (error) {
+        if (undoCapture !== undefined) {
+          await options.undoManager?.recordMutationFailure(undoCapture);
+        }
+        throw error;
+      }
 
       const patch = computeFilePatch({
         filePath: input.file_path,
@@ -184,11 +224,16 @@ function parseWriteArgs(
   };
 }
 
-async function targetFileState(
-  absolutePath: string,
-): Promise<
+async function targetFileState(absolutePath: string): Promise<
   | { ok: true; exists: false }
-  | { ok: true; exists: true; sha256: string; content: string }
+  | {
+      ok: true;
+      exists: true;
+      sha256: string;
+      content: string;
+      bytes: Buffer;
+      mtimeMs: number;
+    }
   | { ok: false; error: string }
 > {
   try {
@@ -198,11 +243,17 @@ async function targetFileState(
     }
 
     const bytes = await readFile(absolutePath);
+    const currentInfo = await stat(absolutePath);
+    if (currentInfo.mtimeMs > info.mtimeMs) {
+      return { ok: false, error: "File changed while it was being read." };
+    }
     return {
       ok: true,
       exists: true,
       sha256: sha256Bytes(bytes),
       content: bytes.toString("utf8"),
+      bytes,
+      mtimeMs: currentInfo.mtimeMs,
     };
   } catch (error) {
     if (isNotFound(error)) {

package/src/tui/app.tsx

@@ -19,12 +19,12 @@ 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 type { TimelineItem } from "./event-store";
 import type { PromptHistory } from "./prompt-history";
 import { Footer } from "./components/footer";
 import { AssistantMarkdownProvider } from "./components/assistant-markdown";
 import { ContextStatus } from "./components/context-status";
 import { BackgroundTasks } from "./components/background-tasks";
+import { BashConfirmation } from "./components/bash-confirmation";
 import { Header } from "./components/header";
 import { ModelPicker } from "./components/model-picker";
 import { FileViewer, FileViewerLoading } from "./components/file-viewer";
@@ -42,7 +42,11 @@ import {
   ResumeSessionPicker,
   ResumeSessionPickerLoading,
 } from "./components/resume-session-picker";
-import { Timeline, TimelineRow } from "./components/timeline";
+import {
+  AssistantStreamSectionRow,
+  Timeline,
+  TimelineRow,
+} from "./components/timeline";
 import { parseSlashCommand, SLASH_COMMANDS } from "./slash-commands";
 import {
   resolveProjectSlashCommand,
@@ -54,6 +58,11 @@ import type { ModelProfile, ModelProfiles } from "../cli/model-profiles";
 import { loadViewFile, type ViewFile } from "./view-file";
 import { writeClipboardText } from "./clipboard";
 import type { WorkspaceFileLister } from "./workspace-file-search";
+import type { TurnUndoBarrierReason, TurnUndoResult } from "../tools/turn-undo-manager";
+import {
+  isAssistantStreamSectionItem,
+  type TuiCommittedItem,
+} from "./tui-projection-store";
 
 export type AppProps = {
   sessionController: TuiSessionController;
@@ -122,6 +131,11 @@ export function App(props: AppProps) {
     binding.projectionStore.getLogSnapshot,
     binding.projectionStore.getLogSnapshot,
   );
+  const bashGuard = useSyncExternalStore(
+    (listener) => binding.subscribeBashGuard(listener),
+    () => binding.bashGuard(),
+    () => binding.bashGuard(),
+  );
   const [isRunning, setIsRunning] = useState(false);
   const [isSessionOperation, setIsSessionOperation] = useState(false);
   const [isCopying, setIsCopying] = useState(false);
@@ -156,7 +170,7 @@ export function App(props: AppProps) {
     write(clearTerminal);
     setStaticRenderEpoch((current) => current + 1);
   }, [write]);
-  const staticItems = useMemo<Array<typeof STATIC_HEADER | TimelineItem>>(
+  const staticItems = useMemo<Array<typeof STATIC_HEADER | TuiCommittedItem>>(
     () => [STATIC_HEADER, ...log.committed],
     [log.committed],
   );
@@ -549,6 +563,19 @@ export function App(props: AppProps) {
           setShowStatus(true);
           return true;
         }
+        if (command.type === "yolo_status") {
+          setNotice(`Bash guard: ${bashGuard.mode} (source: ${bashGuard.source}).`);
+          return true;
+        }
+        if (command.type === "yolo") {
+          binding.setYoloMode(command.enabled);
+          setNotice(
+            command.enabled
+              ? "YOLO enabled for this session; dangerous Bash commands will run without confirmation."
+              : "YOLO disabled; dangerous Bash commands require confirmation.",
+          );
+          return true;
+        }
         if (command.type === "skills") {
           setShowSkills(true);
           return true;
@@ -579,6 +606,22 @@ export function App(props: AppProps) {
             .finally(() => setIsSessionOperation(false));
           return true;
         }
+        if (command.type === "undo") {
+          setIsSessionOperation(true);
+          void props.sessionController
+            .undo()
+            .then((result) => {
+              if (result.status === "restored" || result.status === "incomplete") {
+                setGitBranchRefresh((current) => current + 1);
+              }
+              setNotice(formatTurnUndoNotice(result));
+            })
+            .catch((error: unknown) => {
+              setNotice(errorMessage(error));
+            })
+            .finally(() => setIsSessionOperation(false));
+          return true;
+        }
         if (command.type === "clear") {
           setIsSessionOperation(true);
           void props.sessionController
@@ -676,6 +719,8 @@ export function App(props: AppProps) {
                 workspaceRoot={binding.workspaceRoot}
                 sessionId={binding.sessionId}
               />
+            ) : isAssistantStreamSectionItem(item) ? (
+              <AssistantStreamSectionRow key={item.id} item={item} />
             ) : (
               <TimelineRow key={item.id} item={item} />
             )
@@ -700,55 +745,71 @@ export function App(props: AppProps) {
         ) : (
           <Box
             flexDirection="column"
-            maxHeight={
-              state.status === "running" ? Math.max(1, windowSize.rows - 1) : undefined
-            }
-            overflow={state.status === "running" ? "hidden" : "visible"}
+            maxHeight={Math.max(1, windowSize.rows - 1)}
+            overflow="hidden"
           >
-            <Box marginTop={1} flexDirection="column">
-              <Box
-                maxHeight={
-                  state.backgroundTasks.length === 0
-                    ? LIVE_TIMELINE_MAX_ROWS
-                    : LIVE_TIMELINE_WITH_TASKS_MAX_ROWS
-                }
-                overflow="hidden"
-              >
-                <Timeline items={log.live} />
+            <Box flexDirection="column" flexShrink={1} minHeight={0} overflow="hidden">
+              <Box flexDirection="column" flexShrink={0}>
+                <Box marginTop={1} flexDirection="column" flexShrink={0}>
+                  <Box
+                    maxHeight={
+                      state.backgroundTasks.length === 0
+                        ? LIVE_TIMELINE_MAX_ROWS
+                        : LIVE_TIMELINE_WITH_TASKS_MAX_ROWS
+                    }
+                    overflow="hidden"
+                  >
+                    <Timeline items={log.live} />
+                  </Box>
+                </Box>
+                {state.backgroundTasks.length === 0 ? null : (
+                  <Box
+                    marginTop={1}
+                    maxHeight={BACKGROUND_TASKS_MAX_ROWS}
+                    overflow="hidden"
+                    flexShrink={0}
+                  >
+                    <BackgroundTasks tasks={state.backgroundTasks} />
+                  </Box>
+                )}
+                {showStatus ? (
+                  <Box marginTop={1} flexShrink={0}>
+                    <ContextStatus state={state} bashGuard={bashGuard} />
+                  </Box>
+                ) : null}
+                {showSkills ? (
+                  <Box marginTop={1} flexShrink={0}>
+                    <SkillsPanel snapshot={binding.skills()} />
+                  </Box>
+                ) : null}
+                {showMcp ? (
+                  <Box marginTop={1} flexShrink={0}>
+                    <McpPanel snapshot={binding.mcp()} />
+                  </Box>
+                ) : null}
               </Box>
             </Box>
-            {state.backgroundTasks.length === 0 ? null : (
-              <Box
-                marginTop={1}
-                maxHeight={BACKGROUND_TASKS_MAX_ROWS}
-                overflow="hidden"
-              >
-                <BackgroundTasks tasks={state.backgroundTasks} />
-              </Box>
-            )}
-            {showStatus ? (
-              <Box marginTop={1}>
-                <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}>
+            <Box marginTop={1} flexShrink={0}>
               <Footer
                 status={isCancelling ? "cancelling" : state.status}
                 workedForMs={state.workedForMs}
+                yolo={bashGuard.mode === "yolo"}
               />
             </Box>
-            <Box marginTop={1} flexDirection="column">
-              {showModelPicker ? (
+            <Box marginTop={1} flexDirection="column" flexShrink={0}>
+              {bashGuard.pending !== undefined ? (
+                <BashConfirmation
+                  command={bashGuard.pending.command}
+                  reason={bashGuard.pending.reason}
+                  onDecision={(decision) => {
+                    void binding
+                      .resolveBashConfirmation(decision)
+                      .catch((error: unknown) =>
+                        setNotice(`Bash confirmation failed: ${errorMessage(error)}`),
+                      );
+                  }}
+                />
+              ) : showModelPicker ? (
                 <ModelPicker
                   profiles={profileList}
                   currentProfileName={binding.profileName}
@@ -763,7 +824,12 @@ export function App(props: AppProps) {
                   workspaceRoot={binding.workspaceRoot}
                   gitBranch={gitBranch}
                   contextUsage={state.contextUsage}
-                  isDisabled={isRunning || isSessionOperation || isCopying}
+                  isDisabled={
+                    isRunning ||
+                    isSessionOperation ||
+                    isCopying ||
+                    bashGuard.pending !== undefined
+                  }
                   history={props.history}
                   commands={availableCommands}
                   fileLister={props.fileLister}
@@ -811,6 +877,56 @@ export function formatContextCompactionNotice(result: ContextCompactionResult):
   return `Context compacted: revision ${result.previousRevisionNumber} -> ${result.revisionNumber}, ${result.addedOverrideCount} observations swapped, ${before} -> ${after} estimated tokens (-${reduction}%).`;
 }
 
+export function formatTurnUndoNotice(result: TurnUndoResult): string {
+  if (result.status === "nothing") {
+    return "Nothing to undo in this active session.";
+  }
+  if (result.status === "unavailable") {
+    return `Cannot undo turn ${result.turnNumber}: ${formatUndoBarrierReason(result.reason)}`;
+  }
+  if (result.status === "refused") {
+    const count = result.conflicts.length;
+    return [
+      `Undo refused: ${count} ${count === 1 ? "file" : "files"} changed after turn ${result.turnNumber}.`,
+      ...result.conflicts.map(
+        (conflict) => `- ${conflict.displayPath}: ${conflict.detail}`,
+      ),
+    ].join("\n");
+  }
+  if (result.status === "incomplete") {
+    return `Undo incomplete for turn ${result.turnNumber}: ${formatPartialUndoCount(result)} before ${result.failedPath} failed: ${sentenceDetail(result.detail)}\nRun /undo again to retry.`;
+  }
+  return `Restored workspace to before turn ${result.turnNumber}: ${formatFileCount(result.restoredFileCount)} restored, ${formatFileCount(result.deletedFileCount)} deleted.`;
+}
+
+function formatUndoBarrierReason(reason: TurnUndoBarrierReason): string {
+  if (reason.kind === "file-too-large" || reason.kind === "turn-too-large") {
+    return "undo snapshot capacity was exceeded.";
+  }
+  return `undo snapshot could not be captured for ${reason.displayPath}: ${sentenceDetail(reason.detail)}`;
+}
+
+function formatPartialUndoCount(
+  result: Extract<TurnUndoResult, { status: "incomplete" }>,
+): string {
+  const completed: string[] = [];
+  if (result.restoredFileCount > 0) {
+    completed.push(`${formatFileCount(result.restoredFileCount)} restored`);
+  }
+  if (result.deletedFileCount > 0) {
+    completed.push(`${formatFileCount(result.deletedFileCount)} deleted`);
+  }
+  return completed.length === 0 ? "no files restored" : completed.join(" and ");
+}
+
+function formatFileCount(count: number): string {
+  return `${count} ${count === 1 ? "file" : "files"}`;
+}
+
+function sentenceDetail(detail: string): string {
+  return /[.!?]$/.test(detail) ? detail : `${detail}.`;
+}
+
 export function formatContextCompactionFailureNotice(error: unknown): string {
   if (!(error instanceof ContextManagerError)) {
     return "Context compaction failed.";

package/src/tui/assistant-markdown-section-framer.ts

@@ -0,0 +1,135 @@
+import { lexer, walkTokens, type Token } from "marked";
+
+export type MarkdownSectionFrame = Readonly<{
+  markdown: string;
+  start: number;
+  end: number;
+}>;
+
+export type MarkdownSectionFramerResult = Readonly<{
+  content: string;
+  tail: string;
+  sealedEnd: number;
+  framingStopped: boolean;
+}>;
+
+const ATX_HEADING_LINE = /^ {0,3}#{1,6}(?:[\t ]+|$)/u;
+
+export class MarkdownSectionFramer {
+  private source = "";
+  private scanOffset = 0;
+  private sealedEnd = 0;
+  private framingStopped = false;
+
+  push(content: string): readonly MarkdownSectionFrame[] {
+    if (content === "") {
+      return [];
+    }
+    this.source += content;
+    if (this.framingStopped) {
+      return [];
+    }
+
+    const frames: MarkdownSectionFrame[] = [];
+    while (true) {
+      const newline = this.source.indexOf("\n", this.scanOffset);
+      if (newline === -1) {
+        break;
+      }
+      const lineStart = this.scanOffset;
+      const lineEnd = newline + 1;
+      this.scanOffset = lineEnd;
+      const line = this.source.slice(lineStart, newline).replace(/\r$/u, "");
+      if (!ATX_HEADING_LINE.test(line) || !this.isTopLevelHeading(lineStart, lineEnd)) {
+        continue;
+      }
+
+      const section = this.source.slice(this.sealedEnd, lineStart);
+      if (section.trim() === "") {
+        continue;
+      }
+      if (hasDocumentLevelMarkdownDependency(section)) {
+        this.framingStopped = true;
+        break;
+      }
+
+      frames.push(
+        Object.freeze({
+          markdown: section,
+          start: this.sealedEnd,
+          end: lineStart,
+        }),
+      );
+      this.sealedEnd = lineStart;
+    }
+    return frames;
+  }
+
+  finish(): MarkdownSectionFramerResult {
+    return Object.freeze({
+      content: this.source,
+      tail: this.source.slice(this.sealedEnd),
+      sealedEnd: this.sealedEnd,
+      framingStopped: this.framingStopped,
+    });
+  }
+
+  reset(): void {
+    this.source = "";
+    this.scanOffset = 0;
+    this.sealedEnd = 0;
+    this.framingStopped = false;
+  }
+
+  private isTopLevelHeading(lineStart: number, lineEnd: number): boolean {
+    const markdown = normalizeMarkedSource(this.source.slice(this.sealedEnd, lineEnd));
+    const candidateOffset = normalizeMarkedSource(
+      this.source.slice(this.sealedEnd, lineStart),
+    ).length;
+    let tokenOffset = 0;
+    for (const token of lexer(markdown, { gfm: true })) {
+      if (tokenOffset === candidateOffset && token.type === "heading") {
+        return true;
+      }
+      tokenOffset += token.raw.length;
+    }
+    return false;
+  }
+}
+
+function normalizeMarkedSource(source: string): string {
+  return source.replace(/\r\n|\r/gu, "\n");
+}
+
+function hasDocumentLevelMarkdownDependency(markdown: string): boolean {
+  let found = false;
+  void walkTokens(lexer(markdown, { gfm: true }), (token: Token) => {
+    if (found) {
+      return;
+    }
+    if (token.type === "def") {
+      found = true;
+      return;
+    }
+    if (
+      (token.type === "text" || token.type === "link" || token.type === "image") &&
+      containsReferenceSyntax(token.raw)
+    ) {
+      found = true;
+    }
+  });
+  return found;
+}
+
+function containsReferenceSyntax(source: string): boolean {
+  const bracket = /!?\[(?:\\.|[^\]\\\n])+\](?:[\t ]*\[(?:\\.|[^\]\\\n])*\])?/gu;
+  for (const match of source.matchAll(bracket)) {
+    const value = match[0];
+    const end = (match.index ?? 0) + value.length;
+    const hasSecondLabel = /\][\t ]*\[/u.test(value);
+    if (hasSecondLabel || !/^[\t ]*\(/u.test(source.slice(end))) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/tui/components/bash-confirmation.tsx

@@ -0,0 +1,27 @@
+import { Box, Text, useInput } from "ink";
+
+export type BashConfirmationProps = {
+  command: string;
+  reason: string;
+  onDecision(decision: "allow" | "deny"): void;
+};
+
+export function BashConfirmation(props: BashConfirmationProps) {
+  useInput((input) => {
+    const normalized = input.toLowerCase();
+    if (normalized === "y") {
+      props.onDecision("allow");
+    } else if (normalized === "n") {
+      props.onDecision("deny");
+    }
+  });
+
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="yellow" paddingX={1}>
+      <Text color="yellow">Dangerous Bash command</Text>
+      <Text>{props.command}</Text>
+      <Text dimColor>{props.reason}</Text>
+      <Text>y allow / n deny / Esc cancel turn</Text>
+    </Box>
+  );
+}

package/src/tui/components/context-status.tsx

@@ -1,8 +1,12 @@
 import { Box, Text } from "ink";
+import type { BashGuardSnapshot } from "../../agent/runtime-session";
 import type { TuiProjectionState } from "../event-store";
 import { formatContextUsageLine, formatTokenCount } from "../context-format";
 
-export function ContextStatus(props: { state: TuiProjectionState }) {
+export function ContextStatus(props: {
+  state: TuiProjectionState;
+  bashGuard: BashGuardSnapshot;
+}) {
   const usage = props.state.contextUsage;
   const profile = props.state.contextProfile;
   const budget = props.state.contextBudget;
@@ -14,6 +18,12 @@ export function ContextStatus(props: { state: TuiProjectionState }) {
       <Text> model: {props.state.modelName}</Text>
       <Text> workspace: {props.state.workspaceRoot}</Text>
       <Text> </Text>
+      <Text bold>Bash guard</Text>
+      <Text>
+        {" mode: "}
+        {props.bashGuard.mode} (source: {props.bashGuard.source})
+      </Text>
+      <Text> </Text>
       <Text bold>Context</Text>
       {usage === undefined || profile === undefined || budget === undefined ? (
         <Text color="yellow"> measurement unavailable</Text>