tinker-agent 1.0.65

package/src/tui/git-branch.ts

@@ -0,0 +1,23 @@
+export async function readCurrentGitBranch(
+  workspaceRoot: string,
+): Promise<string | undefined> {
+  try {
+    const subprocess = Bun.spawn(
+      ["git", "-C", workspaceRoot, "symbolic-ref", "--quiet", "--short", "HEAD"],
+      { stdout: "pipe", stderr: "ignore" },
+    );
+    const [exitCode, stdout] = await Promise.all([
+      subprocess.exited,
+      new Response(subprocess.stdout).text(),
+    ]);
+
+    if (exitCode !== 0) {
+      return undefined;
+    }
+
+    const branch = stdout.trim();
+    return branch === "" ? undefined : branch;
+  } catch {
+    return undefined;
+  }
+}

package/src/tui/line-editor.ts

@@ -0,0 +1,157 @@
+export type LineEditorState = {
+  value: string;
+  cursor: number;
+  preferredColumn?: number;
+};
+
+export function createLineEditorState(value = ""): LineEditorState {
+  return { value, cursor: codePointLength(value) };
+}
+
+export function insert(state: LineEditorState, text: string): LineEditorState {
+  if (text === "") {
+    return state;
+  }
+
+  const chars = [...state.value];
+  const inserted = [...text];
+  chars.splice(state.cursor, 0, ...inserted);
+  return { value: chars.join(""), cursor: state.cursor + inserted.length };
+}
+
+export function backspace(state: LineEditorState): LineEditorState {
+  if (state.cursor === 0) {
+    return state;
+  }
+
+  const chars = [...state.value];
+  chars.splice(state.cursor - 1, 1);
+  return { value: chars.join(""), cursor: state.cursor - 1 };
+}
+
+export function deleteForward(state: LineEditorState): LineEditorState {
+  const chars = [...state.value];
+  if (state.cursor >= chars.length) {
+    return state;
+  }
+
+  chars.splice(state.cursor, 1);
+  return { value: chars.join(""), cursor: state.cursor };
+}
+
+export function deleteToLineStart(state: LineEditorState): LineEditorState {
+  const chars = [...state.value];
+  const lineStart = currentLineStart(chars, state.cursor);
+
+  if (state.cursor > lineStart) {
+    chars.splice(lineStart, state.cursor - lineStart);
+    return { value: chars.join(""), cursor: lineStart };
+  }
+
+  if (lineStart === 0) {
+    return state;
+  }
+
+  chars.splice(lineStart - 1, 1);
+  return { value: chars.join(""), cursor: lineStart - 1 };
+}
+
+export function moveLeft(state: LineEditorState): LineEditorState {
+  return state.cursor === 0 ? state : { value: state.value, cursor: state.cursor - 1 };
+}
+
+export function moveRight(state: LineEditorState): LineEditorState {
+  return state.cursor >= codePointLength(state.value)
+    ? state
+    : { value: state.value, cursor: state.cursor + 1 };
+}
+
+export function moveUp(state: LineEditorState): LineEditorState {
+  const chars = [...state.value];
+  const lineStart = currentLineStart(chars, state.cursor);
+  const preferredColumn = state.preferredColumn ?? state.cursor - lineStart;
+
+  if (lineStart === 0) {
+    return state.cursor === 0 ? state : { ...state, cursor: 0, preferredColumn };
+  }
+
+  const previousLineEnd = lineStart - 1;
+  const previousLineStart = currentLineStart(chars, previousLineEnd);
+  const cursor =
+    previousLineStart + Math.min(preferredColumn, previousLineEnd - previousLineStart);
+
+  return { ...state, cursor, preferredColumn };
+}
+
+export function moveDown(state: LineEditorState): LineEditorState {
+  const chars = [...state.value];
+  const lineStart = currentLineStart(chars, state.cursor);
+  const preferredColumn = state.preferredColumn ?? state.cursor - lineStart;
+  const lineEnd = chars.indexOf("\n", state.cursor);
+
+  if (lineEnd === -1) {
+    return state.cursor === chars.length
+      ? state
+      : { ...state, cursor: chars.length, preferredColumn };
+  }
+
+  const nextLineStart = lineEnd + 1;
+  const nextLineBreak = chars.indexOf("\n", nextLineStart);
+  const nextLineEnd = nextLineBreak === -1 ? chars.length : nextLineBreak;
+  const cursor = nextLineStart + Math.min(preferredColumn, nextLineEnd - nextLineStart);
+
+  return { ...state, cursor, preferredColumn };
+}
+
+export function moveToLineStart(state: LineEditorState): LineEditorState {
+  const chars = [...state.value];
+  const lineStart = currentLineStart(chars, state.cursor);
+
+  if (state.cursor !== lineStart || lineStart === 0) {
+    return state.cursor === lineStart
+      ? state
+      : { value: state.value, cursor: lineStart };
+  }
+
+  return {
+    value: state.value,
+    cursor: lineStart === 1 ? 0 : chars.lastIndexOf("\n", lineStart - 2) + 1,
+  };
+}
+
+export function moveToLineEnd(state: LineEditorState): LineEditorState {
+  const chars = [...state.value];
+  const lineBreak = chars.indexOf("\n", state.cursor);
+  const lineEnd = lineBreak === -1 ? chars.length : lineBreak;
+
+  if (state.cursor !== lineEnd || lineEnd === chars.length) {
+    return state.cursor === lineEnd ? state : { value: state.value, cursor: lineEnd };
+  }
+
+  const nextLineBreak = chars.indexOf("\n", lineEnd + 1);
+  return {
+    value: state.value,
+    cursor: nextLineBreak === -1 ? chars.length : nextLineBreak,
+  };
+}
+
+export function splitAtCursor(state: LineEditorState): {
+  before: string;
+  at: string;
+  after: string;
+} {
+  const chars = [...state.value];
+  return {
+    before: chars.slice(0, state.cursor).join(""),
+    at: chars[state.cursor] ?? " ",
+    after: chars.slice(state.cursor + 1).join(""),
+  };
+}
+
+function currentLineStart(chars: string[], cursor: number): number {
+  return cursor === 0 ? 0 : chars.lastIndexOf("\n", cursor - 1) + 1;
+}
+
+function codePointLength(value: string): number {
+  return [...value].length;
+}

package/src/tui/prompt-history.ts

@@ -0,0 +1,94 @@
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+
+const DEFAULT_MAX_ENTRIES = 200;
+
+export type PromptHistoryOptions = {
+  filePath?: string;
+  entries?: string[];
+  maxEntries?: number;
+};
+
+export class PromptHistory {
+  readonly filePath?: string;
+  private readonly maxEntries: number;
+  private items: string[];
+
+  constructor(options: PromptHistoryOptions = {}) {
+    this.filePath = options.filePath;
+    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    this.items = trimToMax(options.entries ?? [], this.maxEntries);
+  }
+
+  static async load(
+    filePath: string,
+    options: { maxEntries?: number } = {},
+  ): Promise<PromptHistory> {
+    let content: string;
+    try {
+      content = await readFile(filePath, "utf8");
+    } catch (error) {
+      if (isFileNotFound(error)) {
+        return new PromptHistory({ filePath, maxEntries: options.maxEntries });
+      }
+      throw error;
+    }
+
+    const entries: string[] = [];
+    for (const line of content.split("\n")) {
+      if (line.trim() === "") {
+        continue;
+      }
+
+      const parsed = parsePromptLine(line);
+      if (parsed !== undefined) {
+        entries.push(parsed);
+      }
+    }
+
+    return new PromptHistory({ filePath, entries, maxEntries: options.maxEntries });
+  }
+
+  get entries(): readonly string[] {
+    return this.items;
+  }
+
+  async append(prompt: string): Promise<void> {
+    if (prompt === "" || this.items.at(-1) === prompt) {
+      return;
+    }
+
+    this.items = trimToMax([...this.items, prompt], this.maxEntries);
+
+    if (this.filePath === undefined) {
+      return;
+    }
+
+    await mkdir(path.dirname(this.filePath), { recursive: true });
+    await appendFile(this.filePath, `${JSON.stringify(prompt)}\n`, "utf8");
+  }
+}
+
+function parsePromptLine(line: string): string | undefined {
+  try {
+    const parsed: unknown = JSON.parse(line);
+    return typeof parsed === "string" && parsed !== "" ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function trimToMax(entries: string[], maxEntries: number): string[] {
+  return entries.length > maxEntries
+    ? entries.slice(entries.length - maxEntries)
+    : entries;
+}
+
+function isFileNotFound(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    error.code === "ENOENT"
+  );
+}

package/src/tui/slash-commands.ts

@@ -0,0 +1,126 @@
+export type SlashCommand = {
+  name: string;
+  description: string;
+};
+
+export const SLASH_COMMANDS: readonly SlashCommand[] = [
+  { name: "status", description: "Show session and context details" },
+  { name: "compact", description: "Compact eligible historical tool output" },
+  { name: "view", description: "View a local UTF-8 text file" },
+  { name: "model", description: "Switch model profile (new session)" },
+  { name: "resume", description: "Choose or resume a session" },
+  { name: "session", description: "Manage stored sessions" },
+  { name: "quit", description: "Exit the TUI" },
+];
+
+export type ParsedSlashCommand =
+  | { type: "status" }
+  | { type: "compact" }
+  | { type: "view"; filePath: string }
+  | { type: "quit" }
+  | { type: "model" }
+  | { type: "model_switch"; profileName: string }
+  | { type: "resume_list" }
+  | { type: "resume"; sessionId: SessionId }
+  | { type: "session_delete"; sessionId: SessionId };
+
+export class SlashCommandError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "SlashCommandError";
+  }
+}
+
+export function parseSlashCommand(input: string): ParsedSlashCommand {
+  const trimmed = input.trim();
+  if (trimmed === "/view") {
+    throw new SlashCommandError("Usage: /view <path>");
+  }
+  if (trimmed.startsWith("/view ") || trimmed.startsWith("/view\t")) {
+    const filePath = trimmed.slice(5).trim();
+    if (filePath === "") {
+      throw new SlashCommandError("Usage: /view <path>");
+    }
+    return { type: "view", filePath };
+  }
+
+  const tokens = trimmed.split(/\s+/);
+  const command = tokens[0];
+  if (command === "/status" && tokens.length === 1) {
+    return { type: "status" };
+  }
+  if (command === "/compact") {
+    if (tokens.length === 1) {
+      return { type: "compact" };
+    }
+    throw new SlashCommandError("Usage: /compact");
+  }
+  if (command === "/quit" && tokens.length === 1) {
+    return { type: "quit" };
+  }
+  if (command === "/model") {
+    if (tokens.length === 1) {
+      return { type: "model" };
+    }
+    if (tokens.length === 2) {
+      return { type: "model_switch", profileName: tokens[1] };
+    }
+    throw new SlashCommandError("Usage: /model [profile-name]");
+  }
+  if (command === "/resume") {
+    if (tokens.length === 1) {
+      return { type: "resume_list" };
+    }
+    if (tokens.length === 2) {
+      return { type: "resume", sessionId: parsePublicSessionId(tokens[1]) };
+    }
+    throw new SlashCommandError("Usage: /resume [session-id]");
+  }
+  if (command === "/session") {
+    if (tokens.length === 4 && tokens[1] === "delete" && tokens[3] === "--confirm") {
+      return {
+        type: "session_delete",
+        sessionId: parsePublicSessionId(tokens[2]),
+      };
+    }
+    throw new SlashCommandError("Usage: /session delete <session-id> --confirm");
+  }
+  throw new SlashCommandError(`Unknown command: ${trimmed}`);
+}
+
+export function matchSlashCommands(
+  input: string,
+  commands: readonly SlashCommand[] = SLASH_COMMANDS,
+): SlashCommand[] {
+  if (!input.startsWith("/")) {
+    return [];
+  }
+
+  const query = input.slice(1);
+  if (/\s/.test(query)) {
+    return [];
+  }
+
+  return commands.filter((command) => command.name.startsWith(query));
+}
+
+export function findSlashCommand(
+  input: string,
+  commands: readonly SlashCommand[] = SLASH_COMMANDS,
+): SlashCommand | undefined {
+  if (!input.startsWith("/")) {
+    return undefined;
+  }
+
+  const [name = ""] = input.slice(1).split(/\s+/, 1);
+  return commands.find((command) => command.name === name);
+}
+
+function parsePublicSessionId(value: string): SessionId {
+  try {
+    return parseSessionId(value);
+  } catch {
+    throw new SlashCommandError(`Invalid session ID: ${value}`);
+  }
+}
+import { parseSessionId, type SessionId } from "../ids/runtime-id";

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

@@ -0,0 +1,35 @@
+export type TuiProjectionPolicy = Readonly<{
+  recentTurnLimit: number;
+  itemLimitPerTurn: number;
+  sessionNoticeLimit: number;
+  completedTaskLimit: number;
+}>;
+
+export const defaultTuiProjectionPolicy: TuiProjectionPolicy = Object.freeze({
+  recentTurnLimit: 8,
+  itemLimitPerTurn: 40,
+  sessionNoticeLimit: 12,
+  completedTaskLimit: 12,
+});
+
+export function validateTuiProjectionPolicy(
+  policy: TuiProjectionPolicy,
+): TuiProjectionPolicy {
+  requireNonNegativeInteger(policy.recentTurnLimit, "recentTurnLimit");
+  requireMinimumInteger(policy.itemLimitPerTurn, 2, "itemLimitPerTurn");
+  requireNonNegativeInteger(policy.sessionNoticeLimit, "sessionNoticeLimit");
+  requireNonNegativeInteger(policy.completedTaskLimit, "completedTaskLimit");
+  return policy;
+}
+
+function requireMinimumInteger(value: number, minimum: number, name: string): void {
+  if (!Number.isInteger(value) || value < minimum) {
+    throw new Error(`TUI projection ${name} must be at least ${minimum}.`);
+  }
+}
+
+function requireNonNegativeInteger(value: number, name: string): void {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`TUI projection ${name} must be a non-negative integer.`);
+  }
+}

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

@@ -0,0 +1,123 @@
+import type { EventSink } from "../events/event-sink";
+import type { AgentEvent } from "../events/types";
+import {
+  createInitialTuiProjectionState,
+  reduceTuiProjection,
+  type TuiProjectionState,
+} from "./event-store";
+import {
+  defaultTuiProjectionPolicy,
+  type TuiProjectionPolicy,
+  validateTuiProjectionPolicy,
+} from "./tui-projection-policy";
+
+export type TuiProjectionStoreInput = {
+  sessionId: string;
+  modelName: string;
+  workspaceRoot: string;
+  policy?: TuiProjectionPolicy;
+  initialSnapshot?: TuiProjectionState;
+};
+
+export class TuiProjectionStore implements EventSink {
+  readonly name = "tui-projection-store";
+  private readonly listeners = new Set<() => void>();
+  private readonly policy: TuiProjectionPolicy;
+  private snapshot: TuiProjectionState;
+
+  constructor(input: TuiProjectionStoreInput) {
+    this.policy = validateTuiProjectionPolicy(
+      input.policy ?? defaultTuiProjectionPolicy,
+    );
+    this.snapshot =
+      input.initialSnapshot === undefined
+        ? createInitialTuiProjectionState(input)
+        : validateInitialSnapshot(input, input.initialSnapshot, this.policy);
+  }
+
+  readonly getSnapshot = (): TuiProjectionState => this.snapshot;
+
+  readonly subscribe = (listener: () => void): (() => void) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+
+  async append(event: AgentEvent): Promise<void> {
+    const next = reduceTuiProjection(this.snapshot, event, this.policy);
+    if (next === this.snapshot) {
+      return;
+    }
+
+    this.snapshot = next;
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+
+  hydrate(snapshot: TuiProjectionState): void {
+    if (
+      this.snapshot.activeTurn !== undefined ||
+      this.snapshot.recentTurns.length !== 0 ||
+      this.snapshot.notices.length !== 0
+    ) {
+      throw new Error("TUI projection can only be hydrated before live events.");
+    }
+    this.snapshot = validateInitialSnapshot(
+      {
+        sessionId: this.snapshot.sessionId,
+        modelName: this.snapshot.modelName,
+        workspaceRoot: this.snapshot.workspaceRoot,
+      },
+      snapshot,
+      this.policy,
+    );
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+}
+
+function validateInitialSnapshot(
+  input: Pick<TuiProjectionStoreInput, "sessionId" | "modelName" | "workspaceRoot">,
+  snapshot: TuiProjectionState,
+  policy: TuiProjectionPolicy,
+): TuiProjectionState {
+  if (
+    snapshot.sessionId !== input.sessionId ||
+    snapshot.modelName !== input.modelName ||
+    snapshot.workspaceRoot !== input.workspaceRoot
+  ) {
+    throw new Error("Hydrated TUI projection identity does not match its store.");
+  }
+  if (
+    snapshot.activeTurn !== undefined ||
+    snapshot.status === "running" ||
+    snapshot.backgroundTasks.length !== 0
+  ) {
+    throw new Error("Hydrated TUI projection must be terminal and have no tasks.");
+  }
+  if (
+    snapshot.recentTurns.length > policy.recentTurnLimit ||
+    snapshot.notices.length > policy.sessionNoticeLimit ||
+    snapshot.recentTurns.some(
+      (turn) =>
+        turn.status === "running" || turn.items.length > policy.itemLimitPerTurn,
+    )
+  ) {
+    throw new Error("Hydrated TUI projection exceeds its bounded policy.");
+  }
+  return Object.freeze({
+    ...snapshot,
+    recentTurns: Object.freeze(
+      snapshot.recentTurns.map((turn) =>
+        Object.freeze({ ...turn, items: Object.freeze([...turn.items]) }),
+      ),
+    ) as unknown as TuiProjectionState["recentTurns"],
+    notices: Object.freeze([
+      ...snapshot.notices,
+    ]) as unknown as TuiProjectionState["notices"],
+    backgroundTasks: [],
+  });
+}