@mewbleh/purrx 1.0.8

package/src/ui/tui.js

@@ -0,0 +1,317 @@
+import chalk from "chalk";
+import { input, select } from "@inquirer/prompts";
+import { runTurn } from "../core/agent.js";
+import { createApprovalManager } from "../core/approval.js";
+import { saveSession, createSession } from "../core/session.js";
+import { listModels } from "../api/models.js";
+import { ToolRegistry } from "../tools/registry.js";
+import { listSkills, loadMemories } from "../core/context.js";
+import { estimateTokens, maybeCompact } from "../core/compact.js";
+import { CONTEXT_LIMIT } from "../config.js";
+import { c, sym, box } from "./theme.js";
+
+const ACCENT = "#a78bfa";
+
+/**
+ * Start the interactive TUI session.
+ * @param {import("../types.js").AuthInfo} authInfo
+ * @param {Object} [options]
+ */
+export async function startTui(authInfo, options = {}) {
+  const cwd = process.cwd();
+
+  const session =
+    options.session || createSession({ cwd, model: options.model });
+  if (options.model) session.model = options.model;
+  const history = session.history;
+
+  const state = {
+    approval: createApprovalManager(options.policy || "suggest"),
+  };
+
+  const registry = new ToolRegistry();
+  await registry.init({
+    onLog: (msg) => console.log(c.dim(`  ${sym.bullet} ${msg}`)),
+    webSearch: options.webSearch !== false,
+  });
+
+  const persist = () => {
+    try {
+      saveSession(session);
+    } catch (err) {
+      if (process.env.PURRX_DEBUG) console.error(`save failed: ${err.message}`);
+    }
+  };
+
+  // Approval prompt powered by inquirer select (arrow-key menu) for a nicer UX
+  // than typed y/n. We override the manager's prompt path.
+  state.approval.setPrompter(async (toolName, description) => {
+    const choice = await select({
+      message: `${chalk.yellow("approve")} ${description}`,
+      choices: [
+        { name: "yes, once", value: "approve" },
+        { name: `always allow ${toolName} this session`, value: "always" },
+        { name: "no, skip it", value: "reject" },
+      ],
+    });
+    return choice;
+  });
+
+  printHeader(authInfo, session, state.approval, registry, cwd);
+
+  // Main input loop.
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    let line;
+    try {
+      line = await input({
+        message: chalk.hex(ACCENT)("❯"),
+        theme: {
+          prefix: "",
+          style: { answer: (s) => chalk.white(s) },
+        },
+      });
+    } catch (err) {
+      // Ctrl+C / Ctrl+D throw an ExitPromptError.
+      break;
+    }
+
+    const text = (line || "").trim();
+    if (!text) continue;
+
+    if (text.startsWith("/")) {
+      const result = await handleCommand(text, {
+        session,
+        authInfo,
+        state,
+        registry,
+        cwd,
+      });
+      if (result === "close") break;
+      continue;
+    }
+
+    try {
+      await runTurn({
+        authInfo,
+        history,
+        userMessage: text,
+        cwd,
+        model: session.model,
+        registry,
+        approval: state.approval,
+        onChange: persist,
+      });
+    } catch (err) {
+      console.log(box(chalk.red(err.message), { title: "error", borderColor: "red" }));
+    }
+    console.log();
+  }
+
+  persist();
+  registry.shutdown();
+  console.log(c.dim(`\nsession saved: ${session.id}`));
+  console.log(c.dim("the cat curls up. see you next time."));
+  process.exit(0);
+}
+
+function printHeader(authInfo, session, approval, registry, cwd) {
+  const wordmark = chalk.hex(ACCENT).bold("purrx");
+  const tagline = chalk.dim("your terminal's coding companion");
+  const mode = authInfo.mode === "chatgpt" ? "ChatGPT account" : "API key";
+  const skills = listSkills(cwd).length;
+  const memories = loadMemories().length;
+
+  const lines = [
+    `${wordmark}  ${tagline}`,
+    "",
+    `${c.dim("model")}    ${session.model}`,
+    `${c.dim("auth")}     ${mode}`,
+    `${c.dim("approval")} ${approval.policy}`,
+    `${c.dim("context")}  ${registry.mcpServerCount()} mcp · ${skills} skills · ${memories} memories`,
+  ];
+  console.log(box(lines.join("\n"), { borderColor: "magenta" }));
+  console.log(
+    c.dim("  /help for commands · /exit to quit · Ctrl+C to interrupt\n")
+  );
+}
+
+async function handleCommand(text, ctx) {
+  const [cmd, ...args] = text.slice(1).split(/\s+/);
+  switch (cmd) {
+    case "exit":
+    case "quit":
+      return "close";
+
+    case "help":
+      console.log(
+        box(
+          [
+            `${c.accent("/help")}        show this help`,
+            `${c.accent("/model")} [id]  show or pick the model`,
+            `${c.accent("/models")}      list models your account can use`,
+            `${c.accent("/approval")}    pick approval policy`,
+            `${c.accent("/tools")}       list available tools`,
+            `${c.accent("/skills")}      list available skills`,
+            `${c.accent("/memory")}      show stored memories`,
+            `${c.accent("/context")}     show context-window usage`,
+            `${c.accent("/compact")}     summarize older history now`,
+            `${c.accent("/reset")}       clear conversation history`,
+            `${c.accent("/session")}     show session info`,
+            `${c.accent("/exit")}        quit`,
+          ].join("\n"),
+          { title: "commands", borderColor: "gray" }
+        )
+      );
+      break;
+
+    case "model":
+      if (args[0]) {
+        ctx.session.model = args[0];
+        console.log(c.dim(`model set to ${args[0]}`));
+      } else {
+        const models = await listModels(ctx.authInfo).catch(() => []);
+        if (!models.length) {
+          console.log(c.dim("could not retrieve models."));
+          break;
+        }
+        const picked = await select({
+          message: "pick a model",
+          choices: models.map((m) => ({ name: m, value: m })),
+          default: ctx.session.model,
+        }).catch(() => null);
+        if (picked) {
+          ctx.session.model = picked;
+          console.log(c.dim(`model set to ${picked}`));
+        }
+      }
+      break;
+
+    case "models": {
+      const models = await listModels(ctx.authInfo).catch(() => []);
+      if (!models.length) {
+        console.log(c.dim("could not retrieve models."));
+        break;
+      }
+      console.log(
+        models
+          .map((m) => `  ${m === ctx.session.model ? sym.ok : sym.bullet} ${m}`)
+          .join("\n")
+      );
+      break;
+    }
+
+    case "approval": {
+      const picked = await select({
+        message: "approval policy",
+        choices: [
+          { name: "suggest (ask before writes & commands)", value: "suggest" },
+          { name: "auto-edit (auto files, ask for commands)", value: "auto-edit" },
+          { name: "full-auto (never ask)", value: "full-auto" },
+        ],
+        default: ctx.state.approval.policy,
+      }).catch(() => null);
+      if (picked) {
+        const prompter = ctx.state.approval.getPrompter?.();
+        ctx.state.approval = createApprovalManager(picked);
+        if (prompter) ctx.state.approval.setPrompter(prompter);
+        ctx.session.policy = picked;
+        console.log(c.dim(`approval policy set to ${picked}`));
+      }
+      break;
+    }
+
+    case "tools": {
+      const defs = ctx.registry.definitions();
+      console.log(c.dim(`${defs.length} tools available:`));
+      for (const d of defs) {
+        const name = d.name || d.type;
+        const desc = d.description
+          ? c.dim(` ${d.description.slice(0, 56)}`)
+          : "";
+        console.log(`  ${sym.tool} ${name}${desc}`);
+      }
+      break;
+    }
+
+    case "skills": {
+      const skills = listSkills(ctx.cwd);
+      if (!skills.length) {
+        console.log(c.dim("no skills found. add SKILL.md files to enable them."));
+        break;
+      }
+      for (const s of skills) {
+        console.log(`  ${c.accent(s.name)} ${c.dim(s.description || "")}`);
+      }
+      break;
+    }
+
+    case "memory": {
+      const mems = loadMemories();
+      if (!mems.length) {
+        console.log(c.dim("no memories yet. the agent saves them with the remember tool."));
+        break;
+      }
+      for (const m of mems) {
+        console.log(box(m.content, { title: m.name, borderColor: "gray" }));
+      }
+      break;
+    }
+
+    case "reset":
+      ctx.session.history.length = 0;
+      console.log(c.dim("history cleared."));
+      break;
+
+    case "compact": {
+      const before = ctx.session.history.length;
+      const did = await maybeCompact({
+        authInfo: ctx.authInfo,
+        history: ctx.session.history,
+        model: ctx.session.model,
+        usedTokens: CONTEXT_LIMIT, // force compaction regardless of size
+        onInfo: (msg) => console.log(c.dim(`  ${sym.bullet} ${msg}`)),
+      }).catch((err) => {
+        console.log(c.dim(`compaction failed: ${err.message}`));
+        return false;
+      });
+      if (!did) {
+        console.log(c.dim("nothing to compact yet."));
+      } else {
+        console.log(
+          c.dim(`compacted ${before} -> ${ctx.session.history.length} items.`)
+        );
+      }
+      break;
+    }
+
+    case "context": {
+      const est = estimateTokens(ctx.session.history);
+      const pct = Math.min(100, Math.round((est / CONTEXT_LIMIT) * 100));
+      console.log(
+        c.dim(
+          `~${est.toLocaleString()} / ${CONTEXT_LIMIT.toLocaleString()} tokens (${pct}%) · ${ctx.session.history.length} items`
+        )
+      );
+      break;
+    }
+
+    case "session":
+      console.log(
+        box(
+          [
+            `id       ${ctx.session.id}`,
+            `created  ${ctx.session.created_at}`,
+            `cwd      ${ctx.session.cwd}`,
+            `messages ${ctx.session.history.length} items`,
+          ].join("\n"),
+          { title: "session", borderColor: "gray" }
+        )
+      );
+      break;
+
+    default:
+      console.log(c.dim(`unknown command: /${cmd} (try /help)`));
+  }
+  return "ok";
+}