tinker-agent 1.0.65

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

@@ -0,0 +1,170 @@
+import type { ContextCompactionResult } from "../context/context-manager";
+import type {
+  ExecuteTurnInput,
+  RuntimeSession,
+  SessionDisposeReason,
+} from "../agent/runtime-session";
+import type { RunAgentResult } from "../agent/types";
+import type { SessionId } from "../ids/runtime-id";
+import type { ModelProfile } from "../cli/model-profiles";
+import { SessionCatalog, type SessionSummary } from "../session/session-catalog";
+import type { TuiProjectionStore } from "./tui-projection-store";
+
+export type TuiSessionBinding = {
+  sessionId: SessionId;
+  modelName: string;
+  workspaceRoot: string;
+  profileName?: string;
+  projectionStore: TuiProjectionStore;
+  executeTurn(userPrompt: string, signal: AbortSignal): Promise<RunAgentResult>;
+};
+
+export type TuiSessionController = {
+  getBinding: () => TuiSessionBinding;
+  subscribe: (listener: () => void) => () => void;
+  listSessions: () => Promise<readonly SessionSummary[]>;
+  compact: () => Promise<ContextCompactionResult>;
+  resume: (sessionId: SessionId) => Promise<void>;
+  delete: (sessionId: SessionId) => Promise<void>;
+  switchModel: (profile: ModelProfile) => Promise<void>;
+};
+
+export type ManagedTuiSessionBinding = TuiSessionBinding & {
+  runtimeSession: RuntimeSession;
+};
+
+export class DefaultTuiSessionController implements TuiSessionController {
+  private readonly listeners = new Set<() => void>();
+  private binding: ManagedTuiSessionBinding;
+  private operation?: Promise<unknown>;
+
+  constructor(
+    initial: ManagedTuiSessionBinding,
+    private readonly catalog: SessionCatalog,
+    private readonly openSession: (
+      sessionId: SessionId,
+    ) => Promise<ManagedTuiSessionBinding>,
+    private readonly createSessionWithProfile: (
+      profile: ModelProfile,
+    ) => Promise<ManagedTuiSessionBinding>,
+  ) {
+    this.binding = initial;
+  }
+
+  readonly getBinding = (): TuiSessionBinding => this.binding;
+
+  readonly subscribe = (listener: () => void): (() => void) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+
+  listSessions(): Promise<readonly SessionSummary[]> {
+    return this.catalog.list(this.binding.sessionId);
+  }
+
+  compact(): Promise<ContextCompactionResult> {
+    return this.serialize(() => this.binding.runtimeSession.compactContext());
+  }
+
+  resume(sessionId: SessionId): Promise<void> {
+    return this.serialize(async () => {
+      const current = this.binding;
+      if (sessionId === current.sessionId) {
+        throw new Error(`Session ${sessionId} is already current.`);
+      }
+      if (!current.runtimeSession.canSwitchSession()) {
+        throw new Error(
+          "Cannot switch sessions while a turn or background task is active.",
+        );
+      }
+
+      const target = await this.openSession(sessionId);
+      try {
+        await current.runtimeSession.dispose({ type: "session_switch" });
+      } catch (error) {
+        await target.runtimeSession
+          .dispose({ type: "runner_failed", error: errorMessage(error) })
+          .catch(() => undefined);
+        throw error;
+      }
+      this.binding = target;
+      for (const listener of this.listeners) {
+        listener();
+      }
+    });
+  }
+
+  delete(sessionId: SessionId): Promise<void> {
+    return this.serialize(() => this.catalog.delete(sessionId, this.binding.sessionId));
+  }
+
+  switchModel(profile: ModelProfile): Promise<void> {
+    return this.serialize(async () => {
+      const current = this.binding;
+      if (!current.runtimeSession.canSwitchSession()) {
+        throw new Error(
+          "Cannot switch models while a turn or background task is active.",
+        );
+      }
+
+      const target = await this.createSessionWithProfile(profile);
+      try {
+        await current.runtimeSession.dispose({ type: "session_switch" });
+      } catch (error) {
+        await target.runtimeSession
+          .dispose({ type: "runner_failed", error: errorMessage(error) })
+          .catch(() => undefined);
+        throw error;
+      }
+      this.binding = target;
+      for (const listener of this.listeners) {
+        listener();
+      }
+    });
+  }
+
+  dispose(reason: SessionDisposeReason): Promise<void> {
+    return this.binding.runtimeSession.dispose(reason);
+  }
+
+  private serialize<T>(operation: () => Promise<T>): Promise<T> {
+    if (this.operation !== undefined) {
+      return Promise.reject(new Error("Another session operation is already running."));
+    }
+    const pending = operation().finally(() => {
+      if (this.operation === pending) {
+        this.operation = undefined;
+      }
+    });
+    this.operation = pending;
+    return pending;
+  }
+}
+
+export function managedTuiBinding(input: {
+  runtimeSession: RuntimeSession;
+  modelName: string;
+  workspaceRoot: string;
+  profileName?: string;
+  projectionStore: TuiProjectionStore;
+}): ManagedTuiSessionBinding {
+  return {
+    sessionId: input.runtimeSession.sessionId,
+    modelName: input.modelName,
+    workspaceRoot: input.workspaceRoot,
+    profileName: input.profileName,
+    projectionStore: input.projectionStore,
+    runtimeSession: input.runtimeSession,
+    executeTurn: (userPrompt, signal) =>
+      input.runtimeSession.executeTurn({
+        userPrompt,
+        signal,
+      } satisfies ExecuteTurnInput),
+  };
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/tui/view-file.ts

@@ -0,0 +1,122 @@
+import { readFile, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+
+export type ViewFile = {
+  absolutePath: string;
+  displayPath: string;
+  lines: readonly string[];
+  sizeBytes: number;
+};
+
+export async function loadViewFile(
+  workspaceRoot: string,
+  inputPath: string,
+): Promise<ViewFile> {
+  if (inputPath.trim() === "") {
+    throw new Error("Path is required.");
+  }
+
+  const root = await realpath(workspaceRoot);
+  const absoluteInput = path.isAbsolute(inputPath);
+  const resolvedPath = absoluteInput
+    ? path.resolve(inputPath)
+    : path.resolve(root, inputPath);
+
+  if (!absoluteInput && !isWithin(root, resolvedPath)) {
+    throw new Error("Relative path escapes the workspace.");
+  }
+
+  let absolutePath: string;
+  try {
+    absolutePath = await realpath(resolvedPath);
+  } catch (error) {
+    throw viewFileSystemError(resolvedPath, error);
+  }
+
+  if (!absoluteInput && !isWithin(root, absolutePath)) {
+    throw new Error("Relative path resolves outside the workspace.");
+  }
+
+  let info;
+  try {
+    info = await stat(absolutePath);
+  } catch (error) {
+    throw viewFileSystemError(absolutePath, error);
+  }
+  if (!info.isFile()) {
+    throw new Error(`Path is not a regular file: ${absolutePath}`);
+  }
+
+  let bytes: Uint8Array;
+  try {
+    bytes = await readFile(absolutePath);
+  } catch (error) {
+    throw viewFileSystemError(absolutePath, error);
+  }
+
+  const text = decodeText(bytes, absolutePath);
+  return {
+    absolutePath,
+    displayPath: absoluteInput ? absolutePath : path.relative(root, absolutePath),
+    lines: splitLines(text),
+    sizeBytes: bytes.byteLength,
+  };
+}
+
+function decodeText(bytes: Uint8Array, absolutePath: string): string {
+  let text: string;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new Error(`File is not valid UTF-8 text: ${absolutePath}`);
+  }
+
+  for (const character of text) {
+    const codePoint = character.charCodeAt(0);
+    const unsafeC0 =
+      codePoint < 32 && codePoint !== 9 && codePoint !== 10 && codePoint !== 13;
+    const unsafeC1 = codePoint >= 127 && codePoint <= 159;
+    if (unsafeC0 || unsafeC1) {
+      throw new Error(`File contains non-text control characters: ${absolutePath}`);
+    }
+  }
+
+  return text;
+}
+
+function splitLines(text: string): string[] {
+  if (text === "") {
+    return [];
+  }
+
+  const lines = text.split(/\r\n|\n|\r/);
+  if (text.endsWith("\n") || text.endsWith("\r")) {
+    lines.pop();
+  }
+  return lines;
+}
+
+function isWithin(root: string, candidate: string): boolean {
+  return candidate === root || candidate.startsWith(root + path.sep);
+}
+
+function viewFileSystemError(filePath: string, error: unknown): Error {
+  const code = fileSystemErrorCode(error);
+  if (code === "ENOENT") {
+    return new Error(`File does not exist: ${filePath}`);
+  }
+  if (code === "EACCES" || code === "EPERM") {
+    return new Error(`File is not readable: ${filePath}`);
+  }
+  return new Error(`Unable to read file ${filePath}: ${errorMessage(error)}`);
+}
+
+function fileSystemErrorCode(error: unknown): string | undefined {
+  return typeof error === "object" && error !== null && "code" in error
+    ? String(error.code)
+    : undefined;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}