hostwares-cli 2.4.1 → 2.4.2

package/dist/ui/render.js

@@ -1,355 +0,0 @@
-import { c, glyph } from "./theme.js";
-/**
- * Terminal output: streaming text, activity rows, and the status line.
- *
- * The streaming writer is the part that needs care. Text arrives token by
- * token, and an activity row ("Running df -h") can need to be printed in the
- * middle of it. Writing the row straight to stdout would splice it into the
- * middle of a sentence, so `beginStream`/`endStream` track whether a partial
- * line is on screen and insert a newline first.
- */
-// ── streaming text ──────────────────────────────────────────────────────────
-let atLineStart = true;
-export function write(text) {
-    if (!text)
-        return;
-    process.stdout.write(text);
-    atLineStart = text.endsWith("\n");
-}
-export function line(text = "") {
-    if (!atLineStart)
-        process.stdout.write("\n");
-    process.stdout.write(`${text}\n`);
-    atLineStart = true;
-}
-/** Ensure anything printed next starts on a fresh line. */
-export function breakLine() {
-    if (!atLineStart) {
-        process.stdout.write("\n");
-        atLineStart = true;
-    }
-}
-// ── spinner ─────────────────────────────────────────────────────────────────
-/**
- * A single-line spinner used while waiting for the first token.
- *
- * It writes nothing at all when stdout is not a TTY: a spinner in a CI log is
- * thousands of lines of carriage returns.
- */
-export class Spinner {
-    timer = null;
-    frame = 0;
-    text = "";
-    active = false;
-    start(text) {
-        this.text = text;
-        if (!process.stdout.isTTY)
-            return;
-        if (this.active) {
-            this.update(text);
-            return;
-        }
-        breakLine();
-        this.active = true;
-        this.timer = setInterval(() => {
-            const f = glyph.spinner[this.frame++ % glyph.spinner.length];
-            process.stdout.write(`\r${c.green(f)} ${c.dim(this.text)}\x1b[K`);
-        }, 80);
-        // Never hold the event loop open just to animate.
-        this.timer.unref?.();
-    }
-    update(text) { this.text = text; }
-    /** Stop and erase the line, leaving the cursor where the spinner began. */
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-        const erased = this.active && process.stdout.isTTY === true;
-        if (erased)
-            process.stdout.write("\r\x1b[K");
-        this.active = false;
-        // Only claim the cursor is at line start if we actually erased the line.
-        // Asserting it unconditionally made the NEXT writer skip its leading
-        // newline, so streamed text and the activity row that followed it ran
-        // together: "Building your todo app.  ⟳ Get System Info".
-        if (erased)
-            atLineStart = true;
-    }
-}
-// ── activity rows ───────────────────────────────────────────────────────────
-//
-// Cloned from Kiro's CLI output, adapted to the HW green palette (never
-// purple — platform rule). Each tool action renders as:
-//
-//   I will run the following command: <command>     (using tool: shell)
-//   Purpose: <one line, from the model>
-//
-//   <full command output>
-//    — Completed in 12ms
-//
-// File-mutating tools use "Updating: <path>" / "Creating: <path>" /
-// "Reading file: <path>" headers, exactly like Kiro. The "Purpose:" line is
-// produced by the model (see the tool-use prompt), not the renderer.
-/** The tool bucket named in the "(using tool: X)" suffix, Kiro-style. */
-function toolBucket(name) {
-    if (["run_command", "start_process", "stop_process", "open_browser", "wait_for_url", "ssh_run", "ssh_upload", "ssh_download", "docker_exec", "docker_ps", "docker_logs", "install_package", "kill_process", "check_port", "list_processes", "get_process_output", "curl_request", "check_github_auth"].includes(name))
-        return "shell";
-    if (["read_file", "write_file", "str_replace_file", "append_file", "delete_path", "list_directory", "file_search"].includes(name))
-        return "fs";
-    if (["git_status", "git_diff", "git_log", "git_add", "git_commit", "git_push", "git_pull", "git_branch", "git_clone"].includes(name))
-        return "git";
-    if (["search_files"].includes(name))
-        return "code";
-    if (["web_search", "web_fetch"].includes(name))
-        return "web";
-    if (["spawn_subagents"].includes(name))
-        return "agent";
-    if (["todo_list"].includes(name))
-        return "session";
-    return name;
-}
-/**
- * Shorten a path for display: workspace-relative when it's under the cwd, and
- * ~ for home. The absolute path repeated three times was most of the line width.
- */
-function shortPath(p) {
-    if (!p)
-        return "";
-    const cwd = process.cwd();
-    if (p.startsWith(cwd + "/"))
-        return p.slice(cwd.length + 1);
-    const home = process.env.HOME;
-    if (home && p.startsWith(home + "/"))
-        return "~/" + p.slice(home.length + 1);
-    return p;
-}
-/**
- * The header line for a tool. Mirrors Kiro's wording:
- *  - shell tools:  "I will run the following command: <cmd>"
- *  - file writes:  "Writing: <path>" (completion says Created/Updated)
- *  - file reads:   "Reading file: <path>" / "Reading directory: <path>"
- *  - search/misc:  a short present-tense phrase
- * Returns { head, command } — command is echoed on its own coloured line.
- */
-function headerFor(name, target) {
-    switch (name) {
-        // shell — command echoed verbatim
-        case "run_command": return { head: "I will run the following command:", command: target };
-        case "ssh_run": return { head: `I will run the following command${target ? ` on ${target}` : ""}:`, command: target };
-        case "docker_exec": return { head: `I will run the following command in ${target ?? "the container"}:`, command: target };
-        case "curl_request": return { head: "Making an HTTP request", command: target };
-        case "install_package": return { head: `Installing package: ${target ?? ""}`.trimEnd() };
-        case "kill_process": return { head: `Stopping process: ${target ?? ""}`.trimEnd() };
-        // background processes
-        case "start_process": return { head: "I will start the following in the background:", command: target };
-        case "stop_process": return { head: `Stopping background process: ${target ?? ""}`.trimEnd() };
-        case "get_process_output": return { head: `Reading process output${target ? `: ${target}` : ""}` };
-        case "open_browser": return { head: `Opening in the browser: ${target ?? ""}`.trimEnd() };
-        case "wait_for_url": return { head: `Waiting for ${target ?? "the server"} to respond` };
-        // file writes — one neutral verb before; the completion line says created/updated
-        case "write_file": return { head: `Writing: ${shortPath(target)}`.trimEnd() };
-        case "str_replace_file": return { head: `Editing: ${shortPath(target)}`.trimEnd() };
-        case "append_file": return { head: `Appending to: ${shortPath(target)}`.trimEnd() };
-        case "delete_path": return { head: `Deleting: ${shortPath(target)}`.trimEnd() };
-        // file reads
-        case "read_file": return { head: `Reading file: ${shortPath(target)}`.trimEnd() };
-        case "list_directory": return { head: `Reading directory: ${shortPath(target) || "."}` };
-        case "search_files": return { head: `Searching for: ${target ?? ""}`.trimEnd() };
-        case "file_search": return { head: `Searching for files: ${target ?? ""}`.trimEnd() };
-        // inspection
-        case "get_system_info": return { head: "Inspecting the system" };
-        case "check_port": return { head: `Checking port${target ? ` ${target}` : ""}` };
-        case "list_processes": return { head: "Listing running processes" };
-        // git
-        case "git_status": return { head: "Checking git status" };
-        case "git_diff": return { head: "Reading the git diff" };
-        case "git_log": return { head: "Reading the git log" };
-        case "git_add": return { head: `Staging${target ? ` ${target}` : " changes"}` };
-        case "git_commit": return { head: "Creating a commit" };
-        case "git_push": return { head: "Pushing to the remote" };
-        case "git_pull": return { head: "Pulling from the remote" };
-        case "git_branch": return { head: "Managing branches" };
-        case "git_clone": return { head: `Cloning ${target ?? "repository"}` };
-        case "check_github_auth": return { head: "Checking GitHub auth" };
-        // docker
-        case "docker_ps": return { head: "Listing containers" };
-        case "docker_logs": return { head: `Reading container logs${target ? `: ${target}` : ""}` };
-        // ssh transfer
-        case "ssh_upload": return { head: `Uploading to ${target ?? "the remote host"}` };
-        case "ssh_download": return { head: `Downloading from ${target ?? "the remote host"}` };
-        // web
-        case "web_search": return { head: `Searching the web for: ${target ?? ""}`.trimEnd() };
-        case "web_fetch": return { head: `Fetching: ${target ?? ""}`.trimEnd() };
-        case "todo_list": return { head: "Updating the task list" };
-        case "spawn_subagents": return { head: "Running independent tasks in parallel" };
-        default: return { head: humanTool(name) };
-    }
-}
-export function toolRunning(name, target) {
-    breakLine();
-    const { head, command } = headerFor(name, target);
-    const suffix = c.dim(` (using tool: ${toolBucket(name)})`);
-    if (command) {
-        // Kiro prints: "I will run the following command: <cmd>  (using tool: shell)"
-        process.stdout.write(`${c.bold(head)} ${c.cyan(command)}${suffix}\n`);
-    }
-    else {
-        process.stdout.write(`${c.bold(head)}${suffix}\n`);
-    }
-    atLineStart = true;
-}
-export function toolDone(name, status, durationMs, effect, bytes) {
-    breakLine();
-    const time = durationMs !== undefined ? formatMs(durationMs) : "0ms";
-    if (status === "success" || status === "executed") {
-        const patch = effect?.patch;
-        if (patch) {
-            for (const l of patch.lines) {
-                if (l.kind === "ctx") {
-                    const nums = `${String(l.oldLine ?? "").padStart(3)},${String(l.newLine ?? "").padStart(3)}:`;
-                    process.stdout.write(`  ${c.dim(nums)} ${c.dim(l.text)}\n`);
-                }
-                else if (l.kind === "del") {
-                    const nums = `-${String(l.oldLine ?? "").padStart(3)}   :`;
-                    process.stdout.write(`  ${c.red(nums)} ${c.red(l.text)}\n`);
-                }
-                else if (l.kind === "add") {
-                    const nums = `+${String(l.newLine ?? "").padStart(3)}   :`;
-                    process.stdout.write(`  ${c.green(nums)} ${c.green(l.text)}\n`);
-                }
-            }
-            if (patch.truncated)
-                process.stdout.write(`  ${c.dim(`… +${patch.truncated} more lines`)}\n`);
-        }
-        if (effect && (effect.kind === "wrote" || effect.kind === "modified" || effect.kind === "deleted")) {
-            const verb = effect.kind === "wrote" ? "Created" : effect.kind === "modified" ? "Updated" : "Deleted";
-            const size = bytes && effect.kind !== "deleted" ? ` ${formatBytes(bytes)}` : "";
-            process.stdout.write(c.dim(` — ${verb}${size} in ${time}\n`));
-        }
-        else {
-            process.stdout.write(c.dim(` — Completed in ${time}\n`));
-        }
-    }
-    else if (status === "queued") {
-        process.stdout.write(`  ${c.yellow(glyph.caret)} ${c.dim("Queued for approval")}\n`);
-    }
-    else {
-        process.stdout.write(`  ${c.red(glyph.cross)} ${c.red("Failed")} ${c.dim(`after ${time}`)}\n`);
-    }
-    atLineStart = true;
-}
-/**
- * One line of live output from a running tool, shown so the user watches it
- * work. Kiro prints raw tool output between the command and the "Completed in"
- * line; we indent it two spaces and dim it so it reads as subordinate.
- */
-export function toolOutputLine(line) {
-    breakLine();
-    const trimmed = line.length > 200 ? `${line.slice(0, 197)}…` : line;
-    process.stdout.write(`  ${c.dim(trimmed)}\n`);
-    atLineStart = true;
-}
-/** Re-exported so the activity renderer can dim a line without importing theme. */
-export function dim(text) { return c.dim(text); }
-/**
- * A file chip: what changed, not what it contains.
- *
- * The whole reason this exists is that "write a todo app" used to print the
- * entire generated HTML document to the terminal, because the tool result was
- * the file and nothing decided what to show in its place.
- */
-export function fileChip(effect, bytes) {
-    if (!effect.path)
-        return;
-    const size = bytes ? ` ${c.dim(formatBytes(bytes))}` : "";
-    breakLine();
-    if (effect.kind === "wrote")
-        process.stdout.write(`  ${c.green(glyph.tick)} ${c.dim("Written:")} ${effect.path}${size}\n`);
-    else if (effect.kind === "modified")
-        process.stdout.write(`  ${c.yellow(glyph.tick)} ${c.dim("Modified:")} ${effect.path}${size}\n`);
-    else if (effect.kind === "deleted")
-        process.stdout.write(`  ${c.red(glyph.cross)} ${c.dim("Deleted:")} ${effect.path}\n`);
-    else
-        return;
-    atLineStart = true;
-}
-function formatBytes(n) {
-    if (n < 1024)
-        return `${n}B`;
-    if (n < 1024 * 1024)
-        return `${(n / 1024).toFixed(1)}KB`;
-    return `${(n / 1024 / 1024).toFixed(1)}MB`;
-}
-export function toolSkipped(name) {
-    breakLine();
-    process.stdout.write(`  ${c.dim(glyph.skip)} ${c.dim(`${humanTool(name)} — skipped`)}\n`);
-    atLineStart = true;
-}
-export function note(text) { line(c.dim(`  ${text}`)); }
-export function warn(text) { line(`${c.yellow(glyph.warn)} ${text}`); }
-export function error(text) { line(`${c.red(glyph.cross)} ${text}`); }
-export function success(text) { line(`${c.green(glyph.tick)} ${text}`); }
-/** snake_case tool name -> "Title Case", for humans. */
-export function humanTool(name) {
-    return name.split("_").map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-}
-function formatMs(ms) {
-    if (ms < 1000)
-        return `${ms}ms`;
-    if (ms < 60_000)
-        return `${(ms / 1000).toFixed(1)}s`;
-    return `${Math.round(ms / 60_000)}m`;
-}
-/**
- * The line under each reply.
- *
- * Two corrections from the old version, both of which made it misleading:
- *
- *  - It printed `Credits: 73.00` from the balance field, so the label said
- *    "credits" while the number meant "credits remaining". Both are shown now,
- *    and each is named.
- *  - The context gauge was computed locally from the CLI's own history array
- *    (characters / 4 / 180000), which excluded the ~11k system prompt and tool
- *    schemas and ignored the server's real transcript entirely. It read
- *    `0.0K (0%)` on every turn. The number now comes from the server's
- *    `usage.promptTokens`, which counts cached prefix tokens too.
- */
-export function statusLine(s) {
-    const parts = [
-        `${c.dim("cost")} ${s.turnCredits.toFixed(2)}`,
-        `${c.dim("left")} ${s.balance.toFixed(2)}`,
-        `${c.dim("took")} ${formatMs(s.elapsedMs)}`,
-    ];
-    const ctx = s.context;
-    if (ctx?.promptTokens !== undefined && ctx.usagePercent !== undefined) {
-        const k = (ctx.promptTokens / 1000).toFixed(1);
-        const pct = ctx.usagePercent;
-        const gauge = `${k}K (${pct}%)`;
-        parts.push(`${c.dim("ctx")} ${pct >= 75 ? c.yellow(gauge) : c.dim(gauge)}`);
-    }
-    if (s.model)
-        parts.push(c.dim(shortModel(s.model)));
-    breakLine();
-    process.stdout.write(`${c.dim(`  ${glyph.caret} `)}${parts.join(c.dim(" · "))}\n\n`);
-    atLineStart = true;
-}
-/** "claude-sonnet-5" -> "sonnet-5". The vendor prefix is noise in a status line. */
-function shortModel(id) {
-    return id.replace(/^claude-/, "").replace(/-\d{8}$/, "");
-}
-// ── markdown-ish ────────────────────────────────────────────────────────────
-/**
- * Apply inline emphasis to a completed line of model output.
- *
- * Deliberately minimal and applied only to whole lines. The model streams
- * token by token, so a `**` can arrive split across two chunks; anything
- * cleverer than this needs a real incremental parser, and a half-parsed bold
- * marker looks worse than no formatting at all.
- */
-export function styleLine(text) {
-    return text
-        .replace(/\*\*([^*]+)\*\*/g, (_, s) => c.bold(s))
-        .replace(/(^|\s)`([^`]+)`/g, (_, pre, s) => `${pre}${c.cyan(s)}`)
-        .replace(/^(\s*)[-*] /, (_, indent) => `${indent}${c.dim(glyph.bullet)} `);
-}

package/dist/ui/theme.js

@@ -1,49 +0,0 @@
-/**
- * Terminal styling.
- *
- * Colour is opt-out, not unconditional: a CLI whose output is piped into a file
- * or a CI log should emit plain text, and NO_COLOR is the cross-tool convention
- * for asking it to. The old version hardcoded escape sequences everywhere, so
- * `hw ask ... > notes.txt` produced a file full of `\x1b[32m`.
- */
-const useColor = process.env.NO_COLOR === undefined &&
-    process.env.TERM !== "dumb" &&
-    process.stdout.isTTY === true;
-const wrap = (open, close) => (s) => (useColor ? `\x1b[${open}m${s}\x1b[${close}m` : s);
-export const c = {
-    reset: "\x1b[0m",
-    bold: wrap("1", "22"),
-    dim: wrap("2", "22"),
-    italic: wrap("3", "23"),
-    under: wrap("4", "24"),
-    // Brand green, matching the web product. Never violet - see the platform
-    // design rules; the old banner used purple in install.sh and green in the CLI.
-    green: wrap("32", "39"),
-    cyan: wrap("36", "39"),
-    yellow: wrap("33", "39"),
-    red: wrap("31", "39"),
-    gray: wrap("90", "39"),
-    white: wrap("37", "39"),
-};
-export const hasColor = useColor;
-/** Glyphs degrade to ASCII where UTF-8 is unlikely to render (Windows cmd). */
-const unicode = process.platform !== "win32" || process.env.WT_SESSION !== undefined;
-export const glyph = {
-    tick: unicode ? "✓" : "OK",
-    cross: unicode ? "✗" : "X",
-    arrow: unicode ? "→" : "->",
-    bullet: unicode ? "•" : "*",
-    run: unicode ? "⟳" : "~",
-    skip: unicode ? "⊘" : "-",
-    warn: unicode ? "⚠" : "!",
-    caret: unicode ? "▸" : ">",
-    spinner: unicode ? ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] : ["|", "/", "-", "\\"],
-};
-export const BANNER_LINES = [
-    "██╗  ██╗██╗    ██╗",
-    "██║  ██║██║    ██║",
-    "███████║██║ █╗ ██║",
-    "██╔══██║██║███╗██║",
-    "██║  ██║╚███╔███╔╝",
-    "╚═╝  ╚═╝ ╚══╝╚══╝ ",
-];