talon-agent 4.3.2 → 4.3.3

package/src/frontend/terminal/builtins/model.ts

@@ -0,0 +1,198 @@
+/** `/model` and `/effort` — the per-chat model settings. */
+
+import { getModels } from "../../../core/models/catalog.js";
+import { resolveModelId as resolveModelName } from "../../../core/models/catalog.js";
+import {
+  getChatSettings,
+  setChatModel,
+  setChatEffort,
+} from "../../../storage/chat-settings.js";
+import type { Command, CommandContext } from "../command-registry.js";
+
+type BackendRef = CommandContext["backend"];
+
+async function showCurrentModel(
+  ctx: CommandContext,
+  be: BackendRef,
+  currentModel: string,
+): Promise<void> {
+  const modelInfo = await be?.models?.getRawModelInfo?.(currentModel);
+  const displayName = modelInfo?.displayName ?? currentModel;
+  const details = modelInfo
+    ? [
+        modelInfo.providerName,
+        modelInfo.free ? "free" : undefined,
+        modelInfo.selectable
+          ? "ready"
+          : (modelInfo.unavailableReason ?? "not connected"),
+      ].filter(Boolean)
+    : [];
+  ctx.renderer.writeSystem(
+    `Model: ${displayName}${details.length ? ` · ${details.join(" · ")}` : ""}`,
+  );
+  if (modelInfo?.contextWindow) {
+    ctx.renderer.writeln(
+      `  Context window: ${modelInfo.contextWindow.toLocaleString()}`,
+    );
+  }
+  if (be?.models?.getProviders) {
+    const providers = await be.models?.getProviders();
+    const connected = providers.filter((p) => p.connected);
+    if (connected.length > 0) {
+      ctx.renderer.writeln(
+        `  Providers: ${connected.map((p) => `${p.name} (${p.modelCount})`).join(", ")}`,
+      );
+    }
+  }
+  ctx.renderer.writeln(
+    `  Use /model free, /model all, /model providers, or /model <name>.`,
+  );
+  ctx.reprompt();
+}
+
+async function listModels(
+  ctx: CommandContext,
+  be: BackendRef,
+  lowerArgs: string,
+): Promise<void> {
+  if (be?.models?.listModels) {
+    const filter = lowerArgs === "free" ? "free" : "all";
+    const { models, total } = await be.models.listModels(filter);
+    const list = models.slice(0, 20);
+    ctx.renderer.writeSystem(
+      `${filter === "free" ? "Free" : "Available"} models (${total})`,
+    );
+    for (const model of list) {
+      ctx.renderer.writeln(
+        `  ${model.displayName}  ·  ${model.providerName}${model.contextWindow ? `  ·  ${model.contextWindow.toLocaleString()} ctx` : ""}${model.free ? "  ·  free" : ""}`,
+      );
+    }
+    if (total > list.length) {
+      ctx.renderer.writeln(`  …and ${total - list.length} more`);
+    }
+  } else {
+    const names = getModels()
+      .map((m) => m.aliases[0] ?? m.id)
+      .join(", ");
+    ctx.renderer.writeSystem(`Available: ${names}`);
+  }
+  ctx.reprompt();
+}
+
+async function listProviders(
+  ctx: CommandContext,
+  be: BackendRef,
+): Promise<void> {
+  if (be?.models?.getProviders) {
+    const providers = await be.models?.getProviders();
+    ctx.renderer.writeSystem(`Providers (${providers.length})`);
+    for (const p of providers.slice(0, 20)) {
+      ctx.renderer.writeln(
+        `  ${p.name}  ·  ${p.connected ? "connected" : "not connected"}  ·  ${p.modelCount} models`,
+      );
+    }
+  } else {
+    ctx.renderer.writeSystem("Provider listing not supported.");
+  }
+  ctx.reprompt();
+}
+
+/** Resolve model query via backend (falling back to the static catalog). */
+async function selectModel(
+  ctx: CommandContext,
+  be: BackendRef,
+  trimmedArgs: string,
+): Promise<void> {
+  if (be?.models?.resolveModelInfo) {
+    const resolution = await be.models?.resolveModelInfo(trimmedArgs);
+    if (resolution.kind === "missing") {
+      const msg =
+        be.models?.formatModelError?.(trimmedArgs, resolution) ??
+        `No model matched "${trimmedArgs}".`;
+      ctx.renderer.writeError(msg);
+      ctx.reprompt();
+      return;
+    }
+    if (resolution.kind === "ambiguous") {
+      const preview = resolution.matches
+        .map((m) => `${m.displayName} (${m.providerName})`)
+        .join(", ");
+      ctx.renderer.writeError(`Ambiguous: "${trimmedArgs}" matches ${preview}`);
+      ctx.reprompt();
+      return;
+    }
+    if (!resolution.model.selectable) {
+      ctx.renderer.writeError(
+        resolution.model.unavailableReason ??
+          `${resolution.model.providerName} is not connected.`,
+      );
+      ctx.reprompt();
+      return;
+    }
+    setChatModel(ctx.chatId(), resolution.storedValue);
+    ctx.renderer.writeSystem(
+      `Model → ${resolution.model.displayName} (${resolution.model.providerName}${resolution.model.free ? " · free" : ""})`,
+    );
+  } else {
+    setChatModel(ctx.chatId(), resolveModelName(trimmedArgs));
+    ctx.renderer.writeSystem(`Model → ${resolveModelName(trimmedArgs)}`);
+  }
+  ctx.reprompt();
+}
+
+export const modelCommand: Command = {
+  name: "model",
+  argHint: "[name]",
+  description: "Switch model",
+  async handler(args, ctx) {
+    const currentModel =
+      getChatSettings(ctx.chatId()).model ?? ctx.config.model;
+    const be = ctx.backend;
+
+    const trimmedArgs = args.trim();
+    const lowerArgs = trimmedArgs.toLowerCase();
+
+    if (!trimmedArgs) {
+      return showCurrentModel(ctx, be, currentModel);
+    }
+
+    if (lowerArgs === "reset" || lowerArgs === "default") {
+      setChatModel(ctx.chatId(), undefined);
+      ctx.renderer.writeSystem(`Model → ${ctx.config.model}`);
+      ctx.reprompt();
+      return;
+    }
+
+    if (lowerArgs === "free" || lowerArgs === "list" || lowerArgs === "all") {
+      return listModels(ctx, be, lowerArgs);
+    }
+
+    if (lowerArgs === "providers") {
+      return listProviders(ctx, be);
+    }
+
+    return selectModel(ctx, be, trimmedArgs);
+  },
+};
+
+export const effortCommand: Command = {
+  name: "effort",
+  argHint: "[lvl]",
+  description: "Thinking effort (off/low/medium/high/max)",
+  async handler(args, ctx) {
+    if (!args) {
+      ctx.renderer.writeSystem(
+        `Effort: ${getChatSettings(ctx.chatId()).effort ?? "adaptive"}`,
+      );
+    } else {
+      setChatEffort(
+        ctx.chatId(),
+        args === "adaptive"
+          ? undefined
+          : (args as "off" | "low" | "medium" | "high" | "max"),
+      );
+      ctx.renderer.writeSystem(`Effort → ${args}`);
+    }
+    ctx.reprompt();
+  },
+};

package/src/frontend/terminal/builtins/session.ts

@@ -0,0 +1,101 @@
+/** `/reset`, `/resume`, `/rename` — session lifecycle. */
+
+import pc from "picocolors";
+import { formatTimeAgo } from "../renderer.js";
+import { isTerminalChatId } from "../../../util/chat-id.js";
+import { resolveModel as coreResolveModel } from "../../../core/models/catalog.js";
+import {
+  getAllSessions,
+  getSession,
+  setSessionName,
+} from "../../../storage/sessions.js";
+import type { Command } from "../command-registry.js";
+
+export const resetCommand: Command = {
+  name: "reset",
+  description: "Start a fresh session",
+  async handler(_args, ctx) {
+    ctx.initNewChat();
+    ctx.renderer.writeSystem("Session cleared.");
+    ctx.reprompt();
+  },
+};
+
+export const resumeCommand: Command = {
+  name: "resume",
+  description: "List & resume a past session",
+  async handler(_args, ctx) {
+    const sessions = getAllSessions()
+      .filter(
+        (s) =>
+          isTerminalChatId(s.chatId) &&
+          s.chatId !== ctx.chatId() &&
+          s.info.turns > 0,
+      )
+      .sort((a, b) => b.info.lastActive - a.info.lastActive)
+      .slice(0, 10);
+
+    if (sessions.length === 0) {
+      ctx.renderer.writeSystem("No previous sessions to resume.");
+      ctx.reprompt();
+      return;
+    }
+
+    ctx.renderer.writeln();
+    ctx.renderer.writeln(`  ${pc.bold("Past sessions")}`);
+    for (let i = 0; i < sessions.length; i++) {
+      const s = sessions[i]!;
+      const name = s.info.sessionName
+        ? `"${s.info.sessionName}"`
+        : pc.dim("(unnamed)");
+      const turns = `${s.info.turns} turn${s.info.turns !== 1 ? "s" : ""}`;
+      const ago = formatTimeAgo(s.info.lastActive);
+      const model = s.info.lastModel
+        ? (coreResolveModel(s.info.lastModel)?.displayName ?? s.info.lastModel)
+        : "";
+      ctx.renderer.writeln(
+        `  ${pc.green(String(i + 1))}. ${name}  ${pc.dim(`${turns}  ·  ${ago}${model ? `  ·  ${model}` : ""}`)}`,
+      );
+    }
+    ctx.renderer.writeln();
+    ctx.renderer.writeln(
+      `  ${pc.dim("Enter number to resume (Esc to cancel):")}`,
+    );
+
+    const input = await ctx.waitForInput();
+    const num = parseInt(input, 10);
+    if (num >= 1 && num <= sessions.length) {
+      const selected = sessions[num - 1]!;
+      ctx.initNewChat(selected.chatId);
+      const name = selected.info.sessionName
+        ? `"${selected.info.sessionName}"`
+        : `(${selected.info.turns} turns)`;
+      ctx.renderer.writeSystem(`Resumed: ${name}`);
+    } else {
+      ctx.renderer.writeSystem("Cancelled.");
+    }
+    ctx.reprompt();
+  },
+};
+
+export const renameCommand: Command = {
+  name: "rename",
+  argHint: "[name]",
+  description: "Name the current session",
+  async handler(args, ctx) {
+    // Ensure session exists in store (auto-creates if needed)
+    getSession(ctx.chatId());
+    if (!args) {
+      const session = getSession(ctx.chatId());
+      ctx.renderer.writeSystem(
+        session.sessionName
+          ? `Session name: "${session.sessionName}"`
+          : "Session has no name.",
+      );
+    } else {
+      setSessionName(ctx.chatId(), args);
+      ctx.renderer.writeSystem(`Session renamed to "${args}"`);
+    }
+    ctx.reprompt();
+  },
+};

package/src/frontend/terminal/builtins/status.ts

@@ -0,0 +1,202 @@
+/** `/status` — session stats, enriched from the backend when available. */
+
+import pc from "picocolors";
+import {
+  buildCacheDisplay,
+  buildContextDisplay,
+  buildPlanDisplay,
+} from "../../shared/status-context.js";
+import {
+  formatDuration,
+  formatTokenCount,
+  formatUsd,
+} from "../../shared/format.js";
+import { getChatSettings } from "../../../storage/chat-settings.js";
+import { getSessionInfo } from "../../../storage/sessions.js";
+import { getLoadedPlugins } from "../../../core/plugin/index.js";
+import { getPooledBackend } from "../../../core/engine/backend-controller/index.js";
+import type { Command, CommandContext } from "../command-registry.js";
+
+type BackendRef = CommandContext["backend"];
+type SessionInfo = ReturnType<typeof getSessionInfo>;
+
+type UsageTotals = {
+  inputTokens: number;
+  outputTokens: number;
+  cacheRead: number;
+  cacheWrite: number;
+};
+
+/** Stored totals, replaced by the backend's live snapshot when available. */
+async function liveUsageTotals(
+  be: BackendRef,
+  info: SessionInfo,
+): Promise<UsageTotals> {
+  const u = info.usage;
+  let displayInputTokens = u.totalInputTokens;
+  let displayOutputTokens = u.totalOutputTokens;
+  let displayCacheRead = u.totalCacheRead;
+  let displayCacheWrite = u.totalCacheWrite;
+
+  // Enrich from backend when available
+  if (be?.usage?.getSessionSnapshot && info.sessionId) {
+    const snap = await be.usage
+      ?.getSessionSnapshot(info.sessionId)
+      .catch(() => undefined);
+    if (snap) {
+      displayInputTokens = snap.inputTokens ?? displayInputTokens;
+      displayOutputTokens = snap.outputTokens ?? displayOutputTokens;
+      displayCacheRead = snap.cacheRead ?? displayCacheRead;
+      displayCacheWrite = snap.cacheWrite ?? displayCacheWrite;
+    }
+  }
+  return {
+    inputTokens: displayInputTokens,
+    outputTokens: displayOutputTokens,
+    cacheRead: displayCacheRead,
+    cacheWrite: displayCacheWrite,
+  };
+}
+
+/** The backend's model line, plus its context window if the store had none. */
+async function backendModelSummary(
+  be: BackendRef,
+  activeModel: string,
+  contextWindow: number,
+): Promise<{ line: string; contextWindow: number }> {
+  let backendModelLine = "";
+  if (be?.models?.getRawModelInfo) {
+    const modelInfo = await be.models
+      ?.getRawModelInfo(activeModel)
+      .catch(() => undefined);
+    const label = be.label ?? "Backend";
+    if (modelInfo) {
+      backendModelLine = `  ${pc.bold(label)}  ${modelInfo.displayName}  ·  ${modelInfo.providerName}${modelInfo.free ? " · free" : ""}`;
+      if (modelInfo.contextWindow) {
+        contextWindow ||= modelInfo.contextWindow;
+      }
+    }
+  }
+  return { line: backendModelLine, contextWindow };
+}
+
+function writeSessionAndContext(
+  ctx: CommandContext,
+  info: SessionInfo,
+  totals: UsageTotals,
+  cache: ReturnType<typeof buildCacheDisplay>,
+  contextWindow: number,
+): void {
+  const u = info.usage;
+  const nameStr = info.sessionName ? `"${info.sessionName}"  ·  ` : "";
+  const context = buildContextDisplay({
+    contextTokens: u.contextTokens,
+    lastPromptTokens: u.lastPromptTokens,
+    contextWindow,
+  });
+  const contextUsed = context.known
+    ? formatTokenCount(context.used)
+    : "unknown";
+  const contextMax = context.max ? formatTokenCount(context.max) : "unknown";
+  const avgResponseMs =
+    info.turns > 0 && u.totalResponseMs
+      ? Math.round(u.totalResponseMs / info.turns)
+      : 0;
+  const fastestResponseMs =
+    Number.isFinite(u.fastestResponseMs) && u.fastestResponseMs > 0
+      ? u.fastestResponseMs
+      : 0;
+
+  ctx.renderer.writeln(
+    `  ${pc.bold("Session")}  ${nameStr}turns ${info.turns}${cache ? `  ·  ${cache.hitPct}% cache` : ""}`,
+  );
+  ctx.renderer.writeln(
+    `  ${pc.dim(`in ${totals.inputTokens.toLocaleString()}  ·  out ${totals.outputTokens.toLocaleString()} tokens`)}`,
+  );
+  ctx.renderer.writeln();
+  ctx.renderer.writeln(
+    `  ${pc.bold("Context")}  ${contextUsed} / ${contextMax} (${context.known ? `${context.pct}%` : "unknown"})${context.warn ? pc.yellow("  nearing limit") : ""}`,
+  );
+  ctx.renderer.writeln(
+    `  ${context.warn ? pc.yellow(context.bar) : pc.dim(context.bar)}`,
+  );
+  ctx.renderer.writeln(
+    `  ${pc.dim(`response last ${u.lastResponseMs ? formatDuration(u.lastResponseMs) : "—"}  ·  avg ${avgResponseMs ? formatDuration(avgResponseMs) : "—"}  ·  best ${fastestResponseMs ? formatDuration(fastestResponseMs) : "—"}`)}`,
+  );
+  if (u.estimatedCostUsd > 0) {
+    ctx.renderer.writeln(
+      `  ${pc.dim(`estimated session cost ${formatUsd(u.estimatedCostUsd)}`)}`,
+    );
+  }
+}
+
+async function writePlan(ctx: CommandContext, be: BackendRef): Promise<void> {
+  const planSource = be?.usage?.getPlanUsage ? be : getPooledBackend("claude");
+  const plan = buildPlanDisplay(
+    await planSource?.usage?.getPlanUsage?.().catch(() => undefined),
+  );
+  if (plan) {
+    ctx.renderer.writeln();
+    ctx.renderer.writeln(
+      `  ${pc.bold("Plan")}${plan.plan ? `  ${plan.plan}` : ""}${plan.ageLabel ? pc.dim(`  (${plan.ageLabel})`) : ""}`,
+    );
+    for (const w of plan.windows) {
+      ctx.renderer.writeln(
+        `  ${w.label.padEnd(6)}${pc.dim(w.bar)} ${String(w.percent).padStart(3)}%${w.resetLabel ? pc.dim(`  reset ${w.resetLabel}`) : ""}`,
+      );
+    }
+  }
+}
+
+function writePlugins(ctx: CommandContext): void {
+  const plugins = getLoadedPlugins();
+  if (plugins.length > 0) {
+    ctx.renderer.writeln();
+    ctx.renderer.writeln(`  ${pc.bold("Plugins")}`);
+    for (const p of plugins) {
+      const ver = p.plugin.version ? pc.dim(` v${p.plugin.version}`) : "";
+      const desc = p.plugin.description
+        ? `  ${pc.dim(p.plugin.description)}`
+        : "";
+      const tools = p.plugin.mcpServerPath
+        ? pc.green("mcp")
+        : pc.dim("actions only");
+      ctx.renderer.writeln(
+        `  ${pc.green("●")} ${p.plugin.name}${ver}  ${tools}${desc}`,
+      );
+    }
+  }
+}
+
+export const statusCommand: Command = {
+  name: "status",
+  description: "Session stats",
+  async handler(_args, ctx) {
+    const info = getSessionInfo(ctx.chatId());
+    const be = ctx.backend;
+    const activeModel = getChatSettings(ctx.chatId()).model ?? ctx.config.model;
+    ctx.renderer.writeln();
+
+    const totals = await liveUsageTotals(be, info);
+    const cache = buildCacheDisplay({
+      cacheMetrics: be?.cacheMetrics,
+      inputTokens: totals.inputTokens,
+      cacheRead: totals.cacheRead,
+      cacheWrite: totals.cacheWrite,
+    });
+    const model = await backendModelSummary(
+      be,
+      activeModel,
+      info.usage.contextWindow,
+    );
+
+    writeSessionAndContext(ctx, info, totals, cache, model.contextWindow);
+    await writePlan(ctx, be);
+    if (model.line) {
+      ctx.renderer.writeln();
+      ctx.renderer.writeln(model.line);
+    }
+    writePlugins(ctx);
+    ctx.reprompt();
+  },
+};

package/src/frontend/terminal/command-registry.ts

@@ -0,0 +1,80 @@
+/**
+ * Terminal command registry — the `Command` shape and the name/alias index
+ * `tryRunCommand` resolves against.
+ */
+
+import type { TalonConfig } from "../../util/config.js";
+import type { Backend } from "../../core/agent-runtime/capabilities.js";
+import type { Renderer } from "./renderer.js";
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export type CommandContext = {
+  /** Current chat ID (getter — may change on /resume). */
+  chatId: () => string;
+  config: TalonConfig;
+  renderer: Renderer;
+  reprompt: () => void;
+  initNewChat: (id?: string) => void;
+  waitForInput: () => Promise<string>;
+  /** Close the terminal (for /quit). */
+  close: () => void;
+  /** AI backend (available after bootstrap). */
+  backend?: Backend | null;
+};
+
+type CommandHandler = (args: string, ctx: CommandContext) => Promise<void>;
+
+export type Command = {
+  name: string;
+  aliases?: string[];
+  argHint?: string;
+  description: string;
+  handler: CommandHandler;
+};
+
+// ── Registry ─────────────────────────────────────────────────────────────────
+
+const commands: Command[] = [];
+const nameIndex = new Map<string, Command>();
+
+export function registerCommand(cmd: Command): void {
+  commands.push(cmd);
+  nameIndex.set(cmd.name, cmd);
+  if (cmd.aliases) {
+    for (const alias of cmd.aliases) {
+      nameIndex.set(alias, cmd);
+    }
+  }
+}
+
+/** Try to run a slash command. Returns true if handled, false if not a command. */
+export async function tryRunCommand(
+  text: string,
+  ctx: CommandContext,
+): Promise<boolean> {
+  if (!text.startsWith("/")) return false;
+
+  const spaceIdx = text.indexOf(" ");
+  const cmdName = (spaceIdx === -1 ? text : text.slice(0, spaceIdx))
+    .slice(1)
+    .toLowerCase();
+  const args = spaceIdx === -1 ? "" : text.slice(spaceIdx + 1).trim();
+
+  const cmd = nameIndex.get(cmdName);
+  if (!cmd) return false;
+
+  await cmd.handler(args, ctx);
+  return true;
+}
+
+/** Get all registered commands (for /help rendering). */
+export function getCommands(): readonly Command[] {
+  return commands;
+}
+
+/** Clear all registered commands (for testing). */
+export function clearCommands(): void {
+  commands.length = 0;
+  nameIndex.clear();
+}