tinker-agent 1.0.65

package/src/cli/model-profiles.ts

@@ -0,0 +1,289 @@
+import path from "node:path";
+import { readFile, rename, unlink, writeFile } from "node:fs/promises";
+import {
+  createModelContextProfile,
+  type ModelContextProfile,
+} from "../model/model-context-profile";
+
+export type ModelProfile = {
+  readonly name: string;
+  readonly model: string;
+  readonly apiBase: string;
+  readonly apiKey: string;
+  readonly contextWindowTokens: number;
+  readonly maxSupportedOutputTokens: number;
+  readonly includeReasoningContent: boolean;
+};
+
+export type ModelProfiles = {
+  readonly defaultProfile: string;
+  readonly profiles: ReadonlyMap<string, ModelProfile>;
+};
+
+export function modelsConfigPath(
+  env: NodeJS.ProcessEnv = process.env,
+): string | undefined {
+  const value = env.TINKER_MODELS;
+  if (value === undefined || value.trim() === "") {
+    return undefined;
+  }
+  return path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
+}
+
+export async function loadModelProfiles(
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<ModelProfiles | undefined> {
+  const configPath = modelsConfigPath(env);
+  if (configPath === undefined) {
+    return undefined;
+  }
+
+  let raw: string;
+  try {
+    raw = await readFile(configPath, "utf8");
+  } catch (error) {
+    throw new Error(
+      `Failed to read model profiles at ${configPath}: ${errorMessage(error)}`,
+      { cause: error },
+    );
+  }
+
+  return parseModelProfiles(raw, configPath);
+}
+
+export async function persistDefaultProfile(
+  profileName: string,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  const configPath = modelsConfigPath(env);
+  if (configPath === undefined) {
+    return;
+  }
+
+  let raw: string;
+  try {
+    raw = await readFile(configPath, "utf8");
+  } catch (error) {
+    throw new Error(
+      `Failed to read model profiles at ${configPath}: ${errorMessage(error)}`,
+      { cause: error },
+    );
+  }
+
+  const json = JSON.parse(raw) as Record<string, unknown>;
+  if (json.default === profileName) {
+    return;
+  }
+
+  const profileValues = json.profiles;
+  if (!isRecord(profileValues) || profileValues[profileName] === undefined) {
+    const available = isRecord(profileValues) ? Object.keys(profileValues) : [];
+    throw unknownProfileNamesError(profileName, available);
+  }
+  json.default = profileName;
+  parseModelProfiles(JSON.stringify(json), configPath);
+  const temporaryPath = `${configPath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify(json, null, 2)}\n`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 0o600,
+    });
+    await rename(temporaryPath, configPath);
+  } catch (error) {
+    await unlink(temporaryPath).catch(() => undefined);
+    throw new Error(
+      `Failed to persist default model profile at ${configPath}: ${errorMessage(error)}`,
+      { cause: error },
+    );
+  }
+}
+
+export function parseModelProfiles(raw: string, sourcePath: string): ModelProfiles {
+  let json: unknown;
+
+  try {
+    json = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `Invalid JSON in model profiles ${sourcePath}: ${errorMessage(error)}`,
+      { cause: error },
+    );
+  }
+
+  if (!isRecord(json)) {
+    throw new Error(`Model profiles ${sourcePath} must be a JSON object.`);
+  }
+
+  const defaultProfile = json.default;
+  if (typeof defaultProfile !== "string" || defaultProfile.trim() === "") {
+    throw new Error(
+      `Model profiles ${sourcePath} requires a non-empty string "default" field.`,
+    );
+  }
+
+  const profilesValue = json.profiles;
+  if (!isRecord(profilesValue)) {
+    throw new Error(
+      `Model profiles ${sourcePath} requires an object "profiles" field.`,
+    );
+  }
+
+  if (profilesValue[defaultProfile] === undefined) {
+    throw new Error(
+      `Model profiles ${sourcePath}: default profile "${defaultProfile}" is not defined in "profiles".`,
+    );
+  }
+
+  const profiles = new Map<string, ModelProfile>();
+
+  for (const [profileName, profileValue] of Object.entries(profilesValue)) {
+    profiles.set(profileName, parseProfile(profileName, profileValue, sourcePath));
+  }
+
+  return { defaultProfile, profiles };
+}
+
+export function resolveModelProfile(
+  profiles: ModelProfiles | undefined,
+  profileName: string | undefined,
+): ModelProfile | undefined {
+  if (profiles === undefined) {
+    return undefined;
+  }
+
+  const name = profileName ?? profiles.defaultProfile;
+  return profiles.profiles.get(name);
+}
+
+export function resolveSessionProfileName(
+  profiles: ModelProfiles,
+  session: { profileName?: string; modelName: string },
+): string {
+  if (session.profileName !== undefined) {
+    if (!profiles.profiles.has(session.profileName)) {
+      throw unknownProfileError(session.profileName, profiles);
+    }
+    return session.profileName;
+  }
+
+  const matches = [...profiles.profiles.values()].filter(
+    (profile) => profile.model === session.modelName,
+  );
+  if (matches.length === 1) {
+    return matches[0].name;
+  }
+  if (matches.length === 0) {
+    throw new Error(
+      `Legacy session model ${JSON.stringify(session.modelName)} does not match any configured profile.`,
+    );
+  }
+  throw new Error(
+    `Legacy session model ${JSON.stringify(session.modelName)} matches multiple profiles: ${matches.map((profile) => profile.name).join(", ")}.`,
+  );
+}
+
+export function unknownProfileError(
+  profileName: string,
+  profiles: ModelProfiles,
+): Error {
+  return unknownProfileNamesError(profileName, [...profiles.profiles.keys()]);
+}
+
+function unknownProfileNamesError(
+  profileName: string,
+  profileNames: readonly string[],
+): Error {
+  const available = profileNames.join(", ");
+  return new Error(
+    `Unknown model profile ${JSON.stringify(profileName)}. Available profiles: ${available}.`,
+  );
+}
+
+export function profileToContextProfile(profile: ModelProfile): ModelContextProfile {
+  return createModelContextProfile({
+    contextWindowTokens: profile.contextWindowTokens,
+    maxSupportedOutputTokens: profile.maxSupportedOutputTokens,
+  });
+}
+
+function parseProfile(
+  profileName: string,
+  value: unknown,
+  sourcePath: string,
+): ModelProfile {
+  const where = `Model profiles ${sourcePath}: profile "${profileName}"`;
+
+  if (profileName.trim() === "") {
+    throw new Error(`${where} has an empty name.`);
+  }
+
+  if (!isRecord(value)) {
+    throw new Error(`${where} must be an object.`);
+  }
+
+  const model = requireString(value.model, `${where}: "model"`);
+  const apiBase = requireString(value.apiBase, `${where}: "apiBase"`);
+  const apiKey = requireString(value.apiKey, `${where}: "apiKey"`);
+
+  const contextWindowTokens = requirePositiveInteger(
+    value.contextWindowTokens,
+    `${where}: "contextWindowTokens"`,
+  );
+  const maxSupportedOutputTokens = requirePositiveInteger(
+    value.maxSupportedOutputTokens,
+    `${where}: "maxSupportedOutputTokens"`,
+  );
+
+  const includeReasoningContent =
+    value.includeReasoningContent === undefined
+      ? false
+      : parseBoolean(
+          value.includeReasoningContent,
+          `${where}: "includeReasoningContent"`,
+        );
+
+  createModelContextProfile({
+    contextWindowTokens,
+    maxSupportedOutputTokens,
+  });
+
+  return Object.freeze({
+    name: profileName,
+    model,
+    apiBase,
+    apiKey,
+    contextWindowTokens,
+    maxSupportedOutputTokens,
+    includeReasoningContent,
+  });
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function requireString(value: unknown, name: string): string {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${name} must be a non-empty string.`);
+  }
+  return value;
+}
+
+function requirePositiveInteger(value: unknown, name: string): number {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`${name} must be a positive integer.`);
+  }
+  return value;
+}
+
+function parseBoolean(value: unknown, name: string): boolean {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  throw new Error(`${name} must be a boolean.`);
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/cli/run-runner.ts

@@ -0,0 +1,107 @@
+import {
+  createRuntimeSession,
+  type RuntimeSession,
+  type SessionDisposeReason,
+} from "../agent/runtime-session";
+import { StdoutEventPrinter, type WritableLike } from "../events/stdout-event-printer";
+import type { ModelClient } from "../model/model-client";
+import {
+  buildSystemPrompt,
+  loadProjectInstructions,
+  projectInstructionManifest,
+} from "../instructions/project-instructions";
+import {
+  createRunnerModelClient,
+  createWebFetchRefinerFromEnv,
+  readRunnerConfig,
+  RUNTIME_INSTRUCTIONS,
+  type RunnerConfigOverrides,
+} from "./config";
+import { loadModelProfiles } from "./model-profiles";
+import { realpath } from "node:fs/promises";
+
+export type RunOneShotOptions = RunnerConfigOverrides & {
+  modelClient?: ModelClient;
+  stdout?: WritableLike;
+  stderr?: WritableLike;
+  eventLogPath?: string | false;
+};
+
+export async function runOneShot(
+  userPrompt: string,
+  options: RunOneShotOptions = {},
+): Promise<number> {
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  let session: RuntimeSession | undefined;
+  let disposeReason: SessionDisposeReason = { type: "oneshot_complete" };
+  let primaryError: unknown;
+  let exitCode = 1;
+
+  try {
+    const profiles =
+      options.modelClient === undefined ? await loadModelProfiles() : undefined;
+    const config = readRunnerConfig(options, profiles);
+    const workspaceRoot = await realpath(config.workspaceRoot);
+    const projectInstructions = await loadProjectInstructions(workspaceRoot);
+    const systemPrompt = buildSystemPrompt({
+      workspaceRoot,
+      runtimeInstructions: RUNTIME_INSTRUCTIONS(workspaceRoot),
+      projectInstructions,
+    });
+    const modelClient = createRunnerModelClient(config, options.modelClient);
+    session = await createRuntimeSession({
+      selection: { mode: "new", sessionId: config.sessionId },
+      workspaceRoot,
+      modelName: config.modelName,
+      profileName: config.profileName,
+      maxIterations: config.maxIterations,
+      includeReasoningContent: config.includeReasoningContent,
+      contextProfile: config.contextProfile,
+      contextBudget: config.contextBudget,
+      systemPrompt,
+      projectInstruction: projectInstructionManifest(projectInstructions),
+      modelClient,
+      presentationSinks: [new StdoutEventPrinter(stdout, stderr)],
+      persistence:
+        options.eventLogPath === false ? false : { eventLogPath: options.eventLogPath },
+      webFetchRefiner: createWebFetchRefinerFromEnv(config),
+    });
+
+    const result = await session.executeTurn({
+      userPrompt,
+      signal: new AbortController().signal,
+    });
+    if (result.status === "completed") {
+      stdout.write(`\n${result.finalText}\n`);
+      exitCode = 0;
+    }
+  } catch (error) {
+    primaryError = error;
+    disposeReason = { type: "runner_failed", error: errorMessage(error) };
+    stderr.write(`Runtime failed: ${errorMessage(error)}\n`);
+  } finally {
+    if (session !== undefined) {
+      try {
+        await session.dispose(disposeReason);
+      } catch (error) {
+        exitCode = 1;
+        if (primaryError === undefined) {
+          stderr.write(`Runtime cleanup failed: ${errorMessage(error)}\n`);
+        } else {
+          const combined = new AggregateError(
+            [primaryError, error],
+            "Runtime execution and cleanup failed.",
+          );
+          stderr.write(`Runtime cleanup failed: ${errorMessage(combined)}\n`);
+        }
+      }
+    }
+  }
+
+  return exitCode;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/cli/tui-runner.tsx

@@ -0,0 +1,290 @@
+import { render } from "ink";
+import { realpath } from "node:fs/promises";
+import {
+  createRuntimeSession,
+  type RuntimeSession,
+  type SessionDisposeReason,
+} from "../agent/runtime-session";
+import type { EventSink } from "../events/event-sink";
+import type { AgentEvent } from "../events/types";
+import { createUuidV7 } from "../ids/uuid-v7";
+import type { SessionId } from "../ids/runtime-id";
+import {
+  buildSystemPrompt,
+  loadProjectInstructions,
+  projectInstructionManifest,
+} from "../instructions/project-instructions";
+import { ResumeProjectionReader } from "../session/resume-projection";
+import { SessionCatalog } from "../session/session-catalog";
+import { App } from "../tui/app";
+import { readCurrentGitBranch } from "../tui/git-branch";
+import { PromptHistory } from "../tui/prompt-history";
+import { TuiProjectionStore } from "../tui/tui-projection-store";
+import {
+  DefaultTuiSessionController,
+  managedTuiBinding,
+  type ManagedTuiSessionBinding,
+} from "../tui/tui-session-controller";
+import {
+  createRunnerModelClient,
+  createWebFetchRefinerFromEnv,
+  promptHistoryPath,
+  readRunnerConfig,
+  RUNTIME_INSTRUCTIONS,
+  type RunnerConfig,
+} from "./config";
+import {
+  loadModelProfiles,
+  persistDefaultProfile,
+  resolveSessionProfileName,
+  type ModelProfile,
+} from "./model-profiles";
+
+export async function runTui(options: { profileName?: string } = {}): Promise<void> {
+  const profiles = await loadModelProfiles();
+  const config = readRunnerConfig(
+    options.profileName !== undefined ? { profileName: options.profileName } : {},
+    profiles,
+  );
+  const workspaceRoot = await realpath(config.workspaceRoot);
+  let controller: DefaultTuiSessionController | undefined;
+  let instance: ReturnType<typeof render> | undefined;
+  let disposeReason: SessionDisposeReason = { type: "tui_exit" };
+  let primaryError: unknown;
+  let quitRequested = false;
+
+  try {
+    const createSessionForConfig = async (
+      sessionConfig: RunnerConfig,
+      mode: "new" | "resume",
+      sessionId: SessionId,
+      sink: EventSink,
+    ): Promise<RuntimeSession> => {
+      const modelClient = createRunnerModelClient(sessionConfig);
+      const common = {
+        workspaceRoot,
+        modelName: sessionConfig.modelName,
+        profileName: sessionConfig.profileName,
+        maxIterations: sessionConfig.maxIterations,
+        includeReasoningContent: sessionConfig.includeReasoningContent,
+        contextProfile: sessionConfig.contextProfile,
+        contextBudget: sessionConfig.contextBudget,
+        modelClient,
+        presentationSinks: [sink],
+        webFetchRefiner: createWebFetchRefinerFromEnv(sessionConfig),
+      };
+      if (mode === "resume") {
+        return createRuntimeSession({
+          ...common,
+          selection: { mode, sessionId },
+        });
+      }
+
+      const projectInstructions = await loadProjectInstructions(workspaceRoot);
+      return createRuntimeSession({
+        ...common,
+        selection: { mode, sessionId },
+        systemPrompt: buildSystemPrompt({
+          workspaceRoot,
+          runtimeInstructions: RUNTIME_INSTRUCTIONS(workspaceRoot),
+          projectInstructions,
+        }),
+        projectInstruction: projectInstructionManifest(projectInstructions),
+      });
+    };
+
+    const projectionStore = new TuiProjectionStore({
+      sessionId: config.sessionId,
+      modelName: config.modelName,
+      workspaceRoot,
+    });
+    const initialSession = await createSessionForConfig(
+      config,
+      "new",
+      config.sessionId,
+      projectionStore,
+    );
+    const promptHistory = await PromptHistory.load(promptHistoryPath(workspaceRoot));
+    const catalog = new SessionCatalog({ workspaceRoot });
+
+    const openStoredSession = async (
+      sessionId: SessionId,
+    ): Promise<ManagedTuiSessionBinding> => {
+      const deferred = new DeferredProjectionSink();
+      const summary = await catalog.get(sessionId);
+      const resumeConfig =
+        profiles === undefined
+          ? { ...config, sessionId }
+          : readRunnerConfig(
+              {
+                sessionId,
+                profileName: resolveSessionProfileName(profiles, summary),
+                workspaceRoot: config.workspaceRoot,
+                maxIterations: config.maxIterations,
+              },
+              profiles,
+            );
+      const runtimeSession = await createSessionForConfig(
+        resumeConfig,
+        "resume",
+        sessionId,
+        deferred,
+      );
+      const targetProjection = new TuiProjectionStore({
+        sessionId,
+        modelName: resumeConfig.modelName,
+        workspaceRoot,
+      });
+      try {
+        targetProjection.hydrate(
+          await ResumeProjectionReader.read({
+            workspaceRoot,
+            sessionId,
+            modelName: resumeConfig.modelName,
+          }),
+        );
+        await deferred.attach(targetProjection);
+      } catch (error) {
+        await runtimeSession
+          .dispose({ type: "runner_failed", error: errorMessage(error) })
+          .catch(() => undefined);
+        throw error;
+      }
+      return managedTuiBinding({
+        runtimeSession,
+        modelName: resumeConfig.modelName,
+        workspaceRoot,
+        profileName: resumeConfig.profileName,
+        projectionStore: targetProjection,
+      });
+    };
+
+    const createSessionWithProfile = async (
+      profile: ModelProfile,
+    ): Promise<ManagedTuiSessionBinding> => {
+      if (profiles === undefined) {
+        throw new Error("Model profiles are not configured.");
+      }
+      const profileConfig = readRunnerConfig(
+        {
+          sessionId: createUuidV7() as SessionId,
+          workspaceRoot: config.workspaceRoot,
+          profileName: profile.name,
+          maxIterations: config.maxIterations,
+        },
+        profiles,
+      );
+      const profileProjectionStore = new TuiProjectionStore({
+        sessionId: profileConfig.sessionId,
+        modelName: profileConfig.modelName,
+        workspaceRoot,
+      });
+      const runtimeSession = await createSessionForConfig(
+        profileConfig,
+        "new",
+        profileConfig.sessionId,
+        profileProjectionStore,
+      );
+      return managedTuiBinding({
+        runtimeSession,
+        modelName: profileConfig.modelName,
+        workspaceRoot,
+        profileName: profile.name,
+        projectionStore: profileProjectionStore,
+      });
+    };
+
+    controller = new DefaultTuiSessionController(
+      managedTuiBinding({
+        runtimeSession: initialSession,
+        modelName: config.modelName,
+        workspaceRoot,
+        profileName: config.profileName,
+        projectionStore,
+      }),
+      catalog,
+      openStoredSession,
+      createSessionWithProfile,
+    );
+
+    instance = render(
+      <App
+        sessionController={controller}
+        readGitBranch={readCurrentGitBranch}
+        history={promptHistory}
+        profiles={profiles}
+        persistDefaultProfile={persistDefaultProfile}
+        onQuit={() => {
+          quitRequested = true;
+        }}
+      />,
+    );
+    await instance.waitUntilExit();
+  } catch (error) {
+    primaryError = error;
+    disposeReason = { type: "runner_failed", error: errorMessage(error) };
+  } finally {
+    instance?.unmount();
+    restoreStdin();
+    if (controller !== undefined) {
+      try {
+        await controller.dispose(disposeReason);
+      } catch (error) {
+        primaryError =
+          primaryError === undefined
+            ? error
+            : new AggregateError(
+                [primaryError, error],
+                "TUI runtime and cleanup failed.",
+              );
+      }
+    }
+  }
+
+  if (primaryError !== undefined) {
+    throw asError(primaryError);
+  }
+  if (quitRequested) {
+    process.exit(0);
+  }
+}
+
+class DeferredProjectionSink implements EventSink {
+  readonly name = "deferred-tui-projection";
+  private target?: TuiProjectionStore;
+  private readonly buffered: AgentEvent[] = [];
+
+  async append(event: AgentEvent): Promise<void> {
+    if (this.target === undefined) {
+      this.buffered.push(event);
+      return;
+    }
+    await this.target.append(event);
+  }
+
+  async attach(target: TuiProjectionStore): Promise<void> {
+    if (this.target !== undefined) {
+      throw new Error("Deferred projection sink is already attached.");
+    }
+    this.target = target;
+    for (const event of this.buffered) {
+      await target.append(event);
+    }
+    this.buffered.length = 0;
+  }
+}
+
+function restoreStdin(): void {
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(false);
+  }
+  process.stdin.pause();
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function asError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(String(error));
+}