@phren/agent 0.1.2 → 0.1.4

package/dist/tui/ink-entry.js

@@ -0,0 +1,271 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { createSession, runTurn } from "../agent-loop.js";
+import { useSlashCommands } from "./hooks/useSlashCommands.js";
+import { decodeDiffPayload, DIFF_MARKER } from "../multi/diff-renderer.js";
+import * as os from "os";
+import { execSync } from "node:child_process";
+import * as path from "node:path";
+import { loadInputMode, saveInputMode, savePermissionMode } from "../settings.js";
+import { nextPermissionMode } from "./ansi.js";
+import { App } from "./components/App.js";
+import { createRequire } from "node:module";
+const _require = createRequire(import.meta.url);
+const AGENT_VERSION = _require("../../package.json").version;
+export async function startInkTui(config, spawner) {
+    const contextLimit = config.provider.contextWindow ?? 200_000;
+    const session = createSession(contextLimit);
+    const startTime = Date.now();
+    let inputMode = loadInputMode();
+    let pendingInput = null;
+    const steerQueueBuf = [];
+    const inputHistory = [];
+    let running = false;
+    let msgCounter = 0;
+    // Mutable render state — updated then pushed to React via rerender()
+    const completedMessages = [];
+    let streamingText = "";
+    let thinking = false;
+    let thinkStartTime = 0;
+    let thinkElapsed = null;
+    let currentToolCalls = [];
+    function nextId() {
+        return `msg-${++msgCounter}`;
+    }
+    function getAppState() {
+        return {
+            provider: config.provider.name,
+            project: config.phrenCtx?.project ?? null,
+            turns: session.turns,
+            cost: "",
+            permMode: config.registry.permissionConfig.mode,
+            agentCount: spawner?.listAgents().length ?? 0,
+            version: AGENT_VERSION,
+        };
+    }
+    // Re-render the Ink app with current state
+    let rerender = null;
+    function update() {
+        if (!rerender)
+            return;
+        rerender(_jsx(App, { state: getAppState(), completedMessages: [...completedMessages], streamingText: streamingText, completedToolCalls: [...currentToolCalls], thinking: thinking, thinkStartTime: thinkStartTime, thinkElapsed: thinkElapsed, steerQueue: [...steerQueueBuf], running: running, showBanner: true, inputHistory: [...inputHistory], onSubmit: handleSubmit, onPermissionCycle: handlePermissionCycle, onCancelTurn: handleCancelTurn, onExit: handleExit }));
+    }
+    function handlePermissionCycle() {
+        const next = nextPermissionMode(config.registry.permissionConfig.mode);
+        config.registry.setPermissions({ ...config.registry.permissionConfig, mode: next });
+        savePermissionMode(next);
+        update();
+    }
+    let resolveSession = null;
+    function handleExit() {
+        if (resolveSession)
+            resolveSession(session);
+    }
+    function handleCancelTurn() {
+        // Signal cancellation — the running turn will see this via steering
+        pendingInput = null;
+        steerQueueBuf.length = 0;
+        update();
+    }
+    // Slash command handler — captures stderr and displays as status messages
+    const slashCommands = useSlashCommands({
+        commandContext: {
+            session,
+            contextLimit,
+            undoStack: [],
+            providerName: config.provider.name,
+            currentModel: config.provider.model,
+            provider: config.provider,
+            systemPrompt: config.systemPrompt,
+            spawner,
+            sessionId: config.sessionId,
+            startTime,
+            phrenPath: config.phrenCtx?.phrenPath,
+            phrenCtx: config.phrenCtx,
+            onModelChange: async (result) => {
+                try {
+                    const { resolveProvider } = await import("../providers/resolve.js");
+                    const newProvider = resolveProvider(config.provider.name, result.model);
+                    config.provider = newProvider;
+                    const { buildSystemPrompt } = await import("../system-prompt.js");
+                    config.systemPrompt = buildSystemPrompt(config.systemPrompt.split("\n## Last session")[0], null, { name: newProvider.name, model: result.model });
+                    update();
+                }
+                catch { /* keep current provider */ }
+            },
+        },
+        onOutput: (text) => {
+            completedMessages.push({ id: nextId(), kind: "status", text });
+        },
+    });
+    function handleSubmit(input) {
+        const line = input.trim();
+        if (!line)
+            return;
+        // Track input history (skip duplicates of the last entry)
+        if (inputHistory.length === 0 || inputHistory[inputHistory.length - 1] !== line) {
+            inputHistory.push(line);
+        }
+        // Bash mode: ! prefix
+        if (line.startsWith("!")) {
+            const cmd = line.slice(1).trim();
+            let output = "";
+            if (cmd) {
+                const cdMatch = cmd.match(/^cd\s+(.*)/);
+                if (cdMatch) {
+                    try {
+                        const target = cdMatch[1].trim().replace(/^~/, os.homedir());
+                        process.chdir(path.resolve(process.cwd(), target));
+                        output = process.cwd();
+                    }
+                    catch (err) {
+                        output = err.message;
+                    }
+                }
+                else {
+                    try {
+                        output = execSync(cmd, { encoding: "utf-8", timeout: 30_000, cwd: process.cwd(), stdio: ["ignore", "pipe", "pipe"] });
+                    }
+                    catch (err) {
+                        const e = err;
+                        output = e.stderr || e.message || "Command failed";
+                    }
+                }
+            }
+            if (output) {
+                completedMessages.push({ id: nextId(), kind: "status", text: output.replace(/\n$/, "") });
+            }
+            update();
+            return;
+        }
+        // Slash commands
+        if (line === "/mode") {
+            inputMode = inputMode === "steering" ? "queue" : "steering";
+            saveInputMode(inputMode);
+            completedMessages.push({ id: nextId(), kind: "status", text: `Input mode: ${inputMode}` });
+            update();
+            return;
+        }
+        // Slash commands — capture stderr output and display as status message
+        if (line.startsWith("/")) {
+            if (slashCommands.tryHandleCommand(line)) {
+                update();
+                return;
+            }
+        }
+        // If agent running, queue input for steering
+        if (running) {
+            if (inputMode === "steering") {
+                steerQueueBuf.push(line);
+            }
+            else {
+                pendingInput = line;
+            }
+            update();
+            return;
+        }
+        // Normal user message — add to completed history and run agent turn
+        completedMessages.push({ id: nextId(), kind: "user", text: line });
+        update();
+        runAgentTurn(line);
+    }
+    // TurnHooks bridge — updates mutable state, calls update()
+    const tuiHooks = {
+        onTextDelta: (text) => {
+            thinking = false;
+            streamingText += text;
+            update();
+        },
+        onTextDone: () => {
+            // streaming complete — finalized in runAgentTurn
+        },
+        onTextBlock: (text) => {
+            thinking = false;
+            streamingText += text;
+            update();
+        },
+        onToolStart: (_name, _input, _count) => {
+            thinking = false;
+            update();
+        },
+        onToolEnd: (name, input, output, isError, dur) => {
+            const diffData = (name === "edit_file" || name === "write_file") ? decodeDiffPayload(output) : null;
+            const cleanOutput = diffData ? output.slice(0, output.indexOf(DIFF_MARKER)) : output;
+            currentToolCalls.push({ name, input, output: cleanOutput, isError, durationMs: dur });
+            update();
+        },
+        onStatus: () => { update(); },
+        getSteeringInput: () => {
+            if (steerQueueBuf.length > 0 && inputMode === "steering") {
+                return steerQueueBuf.shift();
+            }
+            if (pendingInput && inputMode === "steering") {
+                const steer = pendingInput;
+                pendingInput = null;
+                return steer;
+            }
+            return null;
+        },
+    };
+    async function runAgentTurn(userInput) {
+        running = true;
+        thinking = true;
+        thinkStartTime = Date.now();
+        thinkElapsed = null;
+        streamingText = "";
+        currentToolCalls = [];
+        update();
+        try {
+            await runTurn(userInput, session, config, tuiHooks);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            streamingText += `\nError: ${msg}`;
+        }
+        // Compute elapsed time
+        const elapsed = ((Date.now() - thinkStartTime) / 1000).toFixed(1);
+        // Finalize: move streaming content + tool calls to completed messages
+        thinking = false;
+        if (streamingText || currentToolCalls.length > 0) {
+            completedMessages.push({
+                id: nextId(),
+                kind: "assistant",
+                text: streamingText,
+                toolCalls: currentToolCalls.length > 0 ? [...currentToolCalls] : undefined,
+            });
+        }
+        streamingText = "";
+        currentToolCalls = [];
+        running = false;
+        thinkElapsed = elapsed;
+        update();
+        // Clear elapsed indicator after a brief display
+        setTimeout(() => {
+            thinkElapsed = null;
+            update();
+        }, 2000);
+        // Process queued input — steer queue first, then pending
+        if (steerQueueBuf.length > 0) {
+            const queued = steerQueueBuf.shift();
+            completedMessages.push({ id: nextId(), kind: "user", text: queued });
+            update();
+            runAgentTurn(queued);
+        }
+        else if (pendingInput) {
+            const queued = pendingInput;
+            pendingInput = null;
+            completedMessages.push({ id: nextId(), kind: "user", text: queued });
+            update();
+            runAgentTurn(queued);
+        }
+    }
+    // Initial render
+    const app = render(_jsx(App, { state: getAppState(), completedMessages: [], streamingText: "", completedToolCalls: [], thinking: false, thinkStartTime: 0, thinkElapsed: null, steerQueue: [], running: false, showBanner: true, inputHistory: [], onSubmit: handleSubmit, onPermissionCycle: handlePermissionCycle, onCancelTurn: handleCancelTurn, onExit: handleExit }), { exitOnCtrlC: false });
+    rerender = app.rerender;
+    const done = new Promise((r) => { resolveSession = r; });
+    app.waitUntilExit().then(() => {
+        if (resolveSession)
+            resolveSession(session);
+    });
+    return done;
+}

package/dist/tui/menu-mode.js

@@ -0,0 +1,86 @@
+import { ESC, s } from "./ansi.js";
+let menuMod = null;
+export async function loadMenuModule() {
+    if (!menuMod) {
+        try {
+            menuMod = await import("@phren/cli/shell/render-api");
+        }
+        catch {
+            menuMod = null;
+        }
+    }
+    return menuMod;
+}
+export async function renderMenu(ctx) {
+    const mod = await loadMenuModule();
+    if (!mod || !ctx.phrenCtx)
+        return;
+    const result = await mod.renderMenuFrame(ctx.phrenCtx.phrenPath, ctx.phrenCtx.profile, ctx.menuState);
+    ctx.onStateChange(ctx.menuState, result.listCount, ctx.menuFilterActive, ctx.menuFilterBuf);
+    // Full-screen write: single write to avoid flicker
+    ctx.w.write(`${ESC}?25l${ESC}H${ESC}2J${result.output}${ESC}?25h`);
+}
+export function enterMenuMode(ctx) {
+    if (!ctx.phrenCtx) {
+        ctx.w.write(s.yellow("  phren not configured — menu unavailable\n"));
+        return;
+    }
+    ctx.menuState.project = ctx.phrenCtx.project ?? ctx.menuState.project;
+    ctx.w.write("\x1b[?1049h"); // enter alternate screen
+    renderMenu(ctx);
+}
+export function exitMenuMode(ctx) {
+    ctx.onStateChange(ctx.menuState, ctx.menuListCount, false, "");
+    ctx.w.write("\x1b[?1049l"); // leave alternate screen (restores chat)
+    ctx.onExit();
+}
+export async function handleMenuKeypress(key, ctx) {
+    // Filter input mode: capture text for / search
+    if (ctx.menuFilterActive) {
+        if (key.name === "escape") {
+            ctx.menuState = { ...ctx.menuState, filter: undefined, cursor: 0, scroll: 0 };
+            ctx.onStateChange(ctx.menuState, ctx.menuListCount, false, "");
+            renderMenu(ctx);
+            return;
+        }
+        if (key.name === "return") {
+            const filter = ctx.menuFilterBuf || undefined;
+            ctx.menuState = { ...ctx.menuState, filter, cursor: 0, scroll: 0 };
+            ctx.onStateChange(ctx.menuState, ctx.menuListCount, false, "");
+            renderMenu(ctx);
+            return;
+        }
+        if (key.name === "backspace") {
+            const buf = ctx.menuFilterBuf.slice(0, -1);
+            ctx.menuState = { ...ctx.menuState, filter: buf || undefined, cursor: 0 };
+            ctx.onStateChange(ctx.menuState, ctx.menuListCount, ctx.menuFilterActive, buf);
+            renderMenu(ctx);
+            return;
+        }
+        if (key.sequence && !key.ctrl && !key.meta) {
+            const buf = ctx.menuFilterBuf + key.sequence;
+            ctx.menuState = { ...ctx.menuState, filter: buf, cursor: 0 };
+            ctx.onStateChange(ctx.menuState, ctx.menuListCount, ctx.menuFilterActive, buf);
+            renderMenu(ctx);
+        }
+        return;
+    }
+    // "/" starts filter input
+    if (key.sequence === "/") {
+        ctx.onStateChange(ctx.menuState, ctx.menuListCount, true, "");
+        return;
+    }
+    const mod = await loadMenuModule();
+    if (!mod) {
+        exitMenuMode(ctx);
+        return;
+    }
+    const newState = mod.handleMenuKey(ctx.menuState, key.name ?? "", ctx.menuListCount, ctx.phrenCtx?.phrenPath, ctx.phrenCtx?.profile);
+    if (newState === null) {
+        exitMenuMode(ctx);
+    }
+    else {
+        ctx.menuState = newState;
+        renderMenu(ctx);
+    }
+}

package/dist/tui/tool-render.js

@@ -0,0 +1,43 @@
+/**
+ * Tool call rendering: duration formatting, input preview, compact output.
+ */
+import { s, cols } from "./ansi.js";
+export const COMPACT_LINES = 3;
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const mins = Math.floor(ms / 60_000);
+    const secs = Math.round((ms % 60_000) / 1000);
+    return `${mins}m ${secs}s`;
+}
+export function formatToolInput(name, input) {
+    switch (name) {
+        case "read_file":
+        case "write_file":
+        case "edit_file": return input.file_path ?? "";
+        case "shell": return (input.command ?? "").slice(0, 60);
+        case "glob": return input.pattern ?? "";
+        case "grep": return `/${input.pattern ?? ""}/ ${input.path ?? ""}`;
+        case "git_commit": return (input.message ?? "").slice(0, 50);
+        case "phren_search": return input.query ?? "";
+        case "phren_add_finding": return (input.finding ?? "").slice(0, 50);
+        default: return JSON.stringify(input).slice(0, 60);
+    }
+}
+export function renderToolCall(name, input, output, isError, durationMs) {
+    const preview = formatToolInput(name, input);
+    const dur = formatDuration(durationMs);
+    const icon = isError ? s.red("✗") : s.green("→");
+    const header = `  ${icon} ${s.bold(name)} ${s.gray(preview)}  ${s.dim(dur)}`;
+    // Compact: show first 3 lines only, with overflow count
+    const allLines = output.split("\n").filter(Boolean);
+    if (allLines.length === 0)
+        return header;
+    const shown = allLines.slice(0, COMPACT_LINES);
+    const body = shown.map((l) => s.dim(`    ${l.slice(0, cols() - 6)}`)).join("\n");
+    const overflow = allLines.length - COMPACT_LINES;
+    const more = overflow > 0 ? `\n${s.dim(`    ... +${overflow} lines`)}` : "";
+    return `${header}\n${body}${more}`;
+}