steward-cli 0.26.1 → 0.27.0

package/dist/cli.js

@@ -41285,7 +41285,7 @@ var require_dist = __commonJS(function(exports) {
 });
 
 // src/app/app.ts
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 
 // src/packages/tui/src/engine/HistoryStore.ts
 class HistoryStore {
@@ -56001,7 +56001,7 @@ import { isIP } from "node:net";
 // package.json
 var package_default = {
   name: "steward-cli",
-  version: "0.26.1",
+  version: "0.27.0",
   description: "Interactive AI engineering assistant for the terminal.",
   author: "sapirrior",
   license: "MIT",
@@ -59556,6 +59556,449 @@ var copyCommand = {
   }
 };
 
+// src/app/commands/export/index.ts
+import { spawn as spawn4 } from "node:child_process";
+import { existsSync as existsSync18, mkdirSync as mkdirSync10, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname7, isAbsolute as isAbsolute8, resolve as resolve11 } from "node:path";
+function stripAnsi2(str) {
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+function stripLogoFromLine(str) {
+  return str.replace(/^[ ▄▀▙█▟▝▘]{6,8}\s*/, "");
+}
+async function copyToClipboard2(text) {
+  const isTermux = Boolean(process.env.TERMUX_VERSION || existsSync18("/data/data/com.termux/files/usr/bin/termux-clipboard-set"));
+  const [cmd, ...args] = isTermux ? ["termux-clipboard-set"] : process.platform === "darwin" ? ["pbcopy"] : process.platform === "win32" ? ["clip.exe"] : process.env.WAYLAND_DISPLAY ? ["wl-copy"] : ["xclip", "-selection", "clipboard"];
+  const sendOSC52 = () => {
+    try {
+      process.stdout.write(`\x1B]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  return new Promise((resolvePromise) => {
+    let resolved = false;
+    const finish = (ok) => {
+      if (resolved)
+        return;
+      resolved = true;
+      clearTimeout(timer);
+      resolvePromise(ok || sendOSC52());
+    };
+    const timer = setTimeout(() => finish(false), 1200);
+    try {
+      const proc = spawn4(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
+      proc.on("error", () => finish(false));
+      proc.on("close", (code) => finish(code === 0));
+      proc.stdin?.on("error", () => finish(false));
+      proc.stdin?.end(text);
+    } catch {
+      finish(false);
+    }
+  });
+}
+function formatToolArgs(args) {
+  if (!args || typeof args !== "object")
+    return "";
+  if (args.command)
+    return String(args.command);
+  if (args.path || args.filePath || args.targetFile) {
+    return String(args.path || args.filePath || args.targetFile);
+  }
+  if (args.pattern)
+    return String(args.pattern);
+  if (args.url)
+    return String(args.url);
+  if (args.query)
+    return String(args.query);
+  const firstVal = Object.values(args)[0];
+  if (typeof firstVal === "string")
+    return firstVal;
+  return "";
+}
+function formatToolOutput(output) {
+  if (output === undefined || output === null)
+    return [];
+  let text = "";
+  if (typeof output === "string") {
+    text = output;
+  } else if (typeof output === "object") {
+    text = output.message || output.output || JSON.stringify(output);
+  } else {
+    text = String(output);
+  }
+  const lines = text.split(/\r?\n/).filter((l) => l.trim().length > 0);
+  if (lines.length === 0)
+    return [];
+  const preview = lines.slice(0, 5);
+  return preview.map((l, idx) => idx === 0 ? `  └ ${l}` : `    ${l}`);
+}
+function generateTranscriptFromSession(sessionData, cwd = process.cwd()) {
+  const model = sessionData.model;
+  const modelTag = model ? `${model.provider}/${model.modelId}` : "ai/model";
+  const lines = [`Steward`, `${modelTag} · API Usage Billing`, `${cwd}`, ``];
+  const turns = sessionData.turns ?? [];
+  for (let turnIdx = 0;turnIdx < turns.length; turnIdx++) {
+    const turn = turns[turnIdx];
+    if (turnIdx > 0) {
+      lines.push(``);
+    }
+    const messages = turn.messages ?? [];
+    for (const msg of messages) {
+      if (msg.role === "user") {
+        const text = typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? msg.content.map((c) => c.text || "").join(`
+`) : "";
+        lines.push(`❯ ${text}`);
+        lines.push(``);
+      } else if (msg.role === "assistant") {
+        if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === "thinking" && block.thinking) {
+              lines.push(`  Thought for ${Math.max(1, Math.round(block.thinking.length / 500))}s`);
+              lines.push(``);
+            } else if (block.type === "tool-call") {
+              const argPreview = formatToolArgs(block.arguments);
+              lines.push(`● ${block.name}${argPreview ? `(${argPreview})` : "()"}`);
+            } else if (block.type === "text" && block.text) {
+              const textLines = block.text.trim().split(/\r?\n/);
+              for (let i = 0;i < textLines.length; i++) {
+                lines.push(i === 0 ? `● ${textLines[i]}` : `  ${textLines[i]}`);
+              }
+              lines.push(``);
+            }
+          }
+        } else if (typeof msg.content === "string" && msg.content.trim()) {
+          const textLines = msg.content.trim().split(/\r?\n/);
+          for (let i = 0;i < textLines.length; i++) {
+            lines.push(i === 0 ? `● ${textLines[i]}` : `  ${textLines[i]}`);
+          }
+          lines.push(``);
+        }
+      } else if (msg.role === "tool") {
+        if (Array.isArray(msg.content)) {
+          for (const toolRes of msg.content) {
+            const formatted = formatToolOutput(toolRes.output);
+            for (const l of formatted) {
+              lines.push(l);
+            }
+          }
+          lines.push(``);
+        }
+      }
+    }
+    if (turn.timestamp) {
+      const timeStr = new Date(turn.timestamp).toLocaleTimeString([], {
+        hour: "2-digit",
+        minute: "2-digit"
+      });
+      lines.push(`✻ Done · ${timeStr}`);
+    }
+  }
+  return lines.join(`
+`).trim() + `
+`;
+}
+var exportCommand = {
+  name: "export",
+  description: "Exports the exact 1:1 UI conversation text to the clipboard or a file",
+  usage: "/export [filename]",
+  async execute(args, context) {
+    if (context.session.isBusy) {
+      return { handled: true, message: "Cannot export while the agent is generating a response." };
+    }
+    let transcript = "";
+    if (typeof context.getScreenLines === "function") {
+      const screenLines = context.getScreenLines();
+      if (screenLines && screenLines.length > 0) {
+        transcript = screenLines.map((l) => stripLogoFromLine(stripAnsi2(l))).join(`
+`).trim() + `
+`;
+      }
+    }
+    if (!transcript.trim()) {
+      const sessionData = context.session.session;
+      transcript = generateTranscriptFromSession(sessionData, context.cwd || process.cwd());
+    }
+    if (!transcript.trim()) {
+      return { handled: true, message: "No conversation messages found to export." };
+    }
+    const targetArg = args.join(" ").trim();
+    if (!targetArg) {
+      await copyToClipboard2(transcript);
+      return {
+        handled: true,
+        message: "Copied conversation transcript to clipboard."
+      };
+    }
+    try {
+      const cwd = context.cwd || process.cwd();
+      const filePath = isAbsolute8(targetArg) ? targetArg : resolve11(cwd, targetArg);
+      const targetPath = filePath.endsWith(".txt") || filePath.endsWith(".md") ? filePath : `${filePath}.txt`;
+      mkdirSync10(dirname7(targetPath), { recursive: true });
+      writeFileSync4(targetPath, transcript, "utf-8");
+      return {
+        handled: true,
+        message: `Conversation transcript exported to ${targetPath}`
+      };
+    } catch (err) {
+      return {
+        handled: true,
+        message: `Failed to export transcript: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+};
+
+// src/app/commands/init/index.ts
+import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "node:fs";
+import { basename, join as join17 } from "node:path";
+function generateAgentsMd(cwd) {
+  const projectName = basename(cwd);
+  let stack = "General";
+  let commandsSection = "- `make test`: Run test suite";
+  if (existsSync19(join17(cwd, "package.json"))) {
+    try {
+      const pkg = JSON.parse(readFileSync14(join17(cwd, "package.json"), "utf-8"));
+      const scripts = pkg.scripts ? Object.keys(pkg.scripts) : [];
+      stack = "Node.js / TypeScript";
+      if (scripts.length > 0) {
+        commandsSection = scripts.map((s) => `- \`npm run ${s}\` (or \`bun run ${s}\`)`).join(`
+`);
+      }
+    } catch {
+      stack = "Node.js";
+    }
+  } else if (existsSync19(join17(cwd, "Cargo.toml"))) {
+    stack = "Rust";
+    commandsSection = "- `cargo build`: Build project\n- `cargo test`: Run tests";
+  } else if (existsSync19(join17(cwd, "pyproject.toml")) || existsSync19(join17(cwd, "requirements.txt"))) {
+    stack = "Python";
+    commandsSection = "- `pytest`: Run tests\n- `python main.py`: Run application";
+  } else if (existsSync19(join17(cwd, "go.mod"))) {
+    stack = "Go";
+    commandsSection = "- `go build ./...`: Build packages\n- `go test ./...`: Run test suite";
+  }
+  return `# AGENTS.md
+
+Operational guidelines and architectural context for AI engineering assistants working in \`${projectName}\`.
+
+## 1. Project Overview & Tech Stack
+
+- **Project:** \`${projectName}\`
+- **Primary Stack:** ${stack}
+
+## 2. Common Commands
+
+${commandsSection}
+
+## 3. Architecture & Guidelines
+
+- **Code Style:** Follow established project formatting and idioms.
+- **Verification:** Run relevant tests before finalizing changes.
+- **Safety:** Verify file paths and permissions before applying destructive edits.
+`;
+}
+var DUMMY_HOOKS_JSON = JSON.stringify({
+  version: 1,
+  hooks: {
+    SessionStart: [
+      {
+        name: "sample-session-start",
+        command: 'echo "Steward session started"',
+        enabled: false,
+        description: "Runs when a session starts or resumes"
+      }
+    ],
+    BeforeToolUse: [
+      {
+        name: "sample-tool-guard",
+        command: 'echo "Checking tool call"',
+        matcher: "bash",
+        enabled: false,
+        description: "Runs before specific tool executions"
+      }
+    ]
+  }
+}, null, 2);
+var initCommand = {
+  name: "init",
+  description: "Initializes project with AGENTS.md, .steward/hooks.json, and .agents/ directory",
+  usage: "/init",
+  async execute(_args, context) {
+    const cwd = context.cwd || process.cwd();
+    const created = [];
+    const skipped = [];
+    try {
+      const agentsMdPath = join17(cwd, "AGENTS.md");
+      if (!existsSync19(agentsMdPath)) {
+        writeFileSync5(agentsMdPath, generateAgentsMd(cwd), "utf-8");
+        created.push("AGENTS.md");
+      } else {
+        skipped.push("AGENTS.md (already exists)");
+      }
+      const stewardDir = join17(cwd, ".steward");
+      if (!existsSync19(stewardDir)) {
+        mkdirSync11(stewardDir, { recursive: true });
+      }
+      const hooksPath = join17(stewardDir, "hooks.json");
+      if (!existsSync19(hooksPath)) {
+        writeFileSync5(hooksPath, DUMMY_HOOKS_JSON, "utf-8");
+        created.push(".steward/hooks.json");
+      } else {
+        skipped.push(".steward/hooks.json (already exists)");
+      }
+      const skillsDir = join17(cwd, ".agents", "skills");
+      if (!existsSync19(skillsDir)) {
+        mkdirSync11(skillsDir, { recursive: true });
+        created.push(".agents/skills/");
+      } else {
+        skipped.push(".agents/skills/ (already exists)");
+      }
+      const summaryParts = [];
+      if (created.length > 0) {
+        summaryParts.push(`Created: ${created.join(", ")}`);
+      }
+      if (skipped.length > 0) {
+        summaryParts.push(`Preserved: ${skipped.join(", ")}`);
+      }
+      return {
+        handled: true,
+        message: `Project initialized successfully!
+${summaryParts.join(`
+`)}`
+      };
+    } catch (err) {
+      return {
+        handled: true,
+        message: `Failed to initialize project: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+};
+
+// src/app/commands/usage/index.ts
+function formatNumber(num) {
+  return (num ?? 0).toLocaleString();
+}
+function formatDuration(isoDateString) {
+  if (!isoDateString)
+    return "0s";
+  const start = new Date(isoDateString).getTime();
+  if (isNaN(start))
+    return "0s";
+  const elapsedSec = Math.max(0, Math.floor((Date.now() - start) / 1000));
+  const hrs = Math.floor(elapsedSec / 3600);
+  const mins = Math.floor(elapsedSec % 3600 / 60);
+  const secs = elapsedSec % 60;
+  if (hrs > 0)
+    return `${hrs}h ${mins}m ${secs}s`;
+  if (mins > 0)
+    return `${mins}m ${secs}s`;
+  return `${secs}s`;
+}
+function getContextWindowLimit(modelId, provider) {
+  const m = modelId.toLowerCase();
+  const p = provider.toLowerCase();
+  if (p === "gemini" || m.includes("gemini"))
+    return 1e6;
+  if (p === "anthropic" || m.includes("claude"))
+    return 200000;
+  if (m.includes("deepseek"))
+    return 64000;
+  if (m.includes("gpt-4") || m.includes("o1") || m.includes("o3") || m.includes("llama"))
+    return 128000;
+  return 128000;
+}
+function renderProgressBar(current, max, length = 16) {
+  if (max <= 0)
+    return `[${"░".repeat(length)}] 0%`;
+  const ratio = Math.min(Math.max(current / max, 0), 1);
+  const percent = Math.round(ratio * 100);
+  const filled = Math.round(ratio * length);
+  const empty = length - filled;
+  return `[${"█".repeat(filled)}${"░".repeat(empty)}] ${percent}%`;
+}
+function estimateUniversalCost(usage, modelId, provider) {
+  const p = provider.toLowerCase();
+  const m = modelId.toLowerCase();
+  if (p === "ollama" || m.includes("local")) {
+    return "$0.00 USD [Local / Offline]";
+  }
+  const isLightweight = m.includes("flash") || m.includes("mini") || m.includes("haiku") || m.includes("8b") || m.includes("deepseek");
+  const inputPerMillion = isLightweight ? 0.15 : 3;
+  const outputPerMillion = isLightweight ? 0.6 : 15;
+  const cachePerMillion = isLightweight ? 0.075 : 0.3;
+  const baseCost = usage.inputTokens * inputPerMillion / 1e6;
+  const outputCost = usage.outputTokens * outputPerMillion / 1e6;
+  const cacheCost = (usage.cacheReadTokens ?? 0) * cachePerMillion / 1e6;
+  const total = baseCost + outputCost + cacheCost;
+  if (total === 0) {
+    return "$0.00 USD [estimated]";
+  }
+  const formatted = total < 0.005 ? "< $0.01" : `$${total.toFixed(2)}`;
+  return `~${formatted} USD [estimated benchmark]`;
+}
+var usageCommand = {
+  name: "usage",
+  description: "Displays token usage metrics and statistics for the current session",
+  usage: "/usage",
+  async execute(_args, context) {
+    const sessionData = context.session.session;
+    const model = context.session.getModel();
+    const usage = context.session.getUsage();
+    const turns = sessionData?.turns ?? [];
+    const turnsCount = turns.length;
+    let toolCallsCount = 0;
+    for (const turn of turns) {
+      if (Array.isArray(turn.messages)) {
+        for (const msg of turn.messages) {
+          if (msg.role === "tool") {
+            toolCallsCount++;
+          } else if (msg.role === "assistant" && Array.isArray(msg.content)) {
+            toolCallsCount += msg.content.filter((c) => c?.type === "tool-call").length;
+          }
+        }
+      }
+    }
+    const contextLimit = getContextWindowLimit(model.modelId, model.provider);
+    const contextBar = renderProgressBar(usage.totalTokens, contextLimit);
+    const duration = formatDuration(sessionData?.createdAt);
+    const costEstimate = estimateUniversalCost(usage, model.modelId, model.provider);
+    const lines = [
+      `Session Usage & Analytics:`,
+      `• Active Model: ${model.modelId} (${model.provider}${model.effort !== "medium" ? `, effort: ${model.effort}` : ""})`,
+      `• Session Duration: ${duration}`,
+      `• Activity: ${formatNumber(turnsCount)} turns (${formatNumber(toolCallsCount)} tool executions)`,
+      `• Context Window: ${contextBar} (${formatNumber(usage.totalTokens)} / ${formatNumber(contextLimit)} tokens)`,
+      ``,
+      `Token Breakdown:`,
+      `• Input Tokens: ${formatNumber(usage.inputTokens)}`,
+      `• Output Tokens: ${formatNumber(usage.outputTokens)}`
+    ];
+    if (usage.reasoningTokens && usage.reasoningTokens > 0) {
+      lines.push(`• Reasoning Tokens: ${formatNumber(usage.reasoningTokens)}`);
+    }
+    if (usage.cacheReadTokens && usage.cacheReadTokens > 0) {
+      const totalIn = (usage.inputTokens || 0) + (usage.cacheReadTokens || 0);
+      const hitRate = totalIn > 0 ? Math.round(usage.cacheReadTokens / totalIn * 100) : 0;
+      lines.push(`• Cache Read Tokens: ${formatNumber(usage.cacheReadTokens)} (${hitRate}% hit rate)`);
+    }
+    if (usage.cacheWriteTokens && usage.cacheWriteTokens > 0) {
+      lines.push(`• Cache Write Tokens: ${formatNumber(usage.cacheWriteTokens)}`);
+    }
+    lines.push(`• Total Tokens: ${formatNumber(usage.totalTokens)}`);
+    lines.push(``);
+    lines.push(`Estimated Cost:`);
+    lines.push(`• Session Spend: ${costEstimate}`);
+    return {
+      handled: true,
+      message: lines.join(`
+`)
+    };
+  }
+};
+
 // src/app/commands/effort/index.ts
 var EFFORT_HELP = `Reasoning Effort Levels:
   none   : disable reasoning/thinking
@@ -60025,7 +60468,10 @@ class CommandRegistry {
   }
 }
 var builtInCommands = [
+  initCommand,
   copyCommand,
+  exportCommand,
+  usageCommand,
   rewindCommand,
   modelCommand,
   loginCommand,
@@ -62174,7 +62620,7 @@ var pn = x.lex;
 
 // src/packages/tui/src/format/highlight.ts
 var import_cli_highlight = __toESM(require_dist(), 1);
-import { extname, basename } from "node:path";
+import { extname, basename as basename2 } from "node:path";
 var EXTENSION_MAP = {
   ".ts": "typescript",
   ".tsx": "typescript",
@@ -62219,7 +62665,7 @@ var FILENAME_MAP = {
 function detectLanguageFromPath(filePath) {
   if (!filePath)
     return;
-  const name = basename(filePath).toLowerCase();
+  const name = basename2(filePath).toLowerCase();
   if (FILENAME_MAP[name])
     return FILENAME_MAP[name];
   const ext = extname(filePath).toLowerCase();
@@ -64151,13 +64597,13 @@ class UpdateCheckerService {
   }
 }
 // src/app/utils/open-url.ts
-import { spawn as spawn4 } from "node:child_process";
-import { existsSync as existsSync18 } from "node:fs";
+import { spawn as spawn5 } from "node:child_process";
+import { existsSync as existsSync20 } from "node:fs";
 function openUrl(url) {
   const platform = process.platform;
   try {
-    if (process.env.TERMUX_VERSION || existsSync18("/data/data/com.termux/files/usr/bin/termux-open-url")) {
-      const child = spawn4("termux-open-url", [url], {
+    if (process.env.TERMUX_VERSION || existsSync20("/data/data/com.termux/files/usr/bin/termux-open-url")) {
+      const child = spawn5("termux-open-url", [url], {
         detached: true,
         stdio: "ignore"
       });
@@ -64165,7 +64611,7 @@ function openUrl(url) {
       return;
     }
     if (platform === "win32") {
-      const child = spawn4("cmd.exe", ["/c", "start", '""', url], {
+      const child = spawn5("cmd.exe", ["/c", "start", '""', url], {
         detached: true,
         stdio: "ignore"
       });
@@ -64173,14 +64619,14 @@ function openUrl(url) {
       return;
     }
     if (platform === "darwin") {
-      const child = spawn4("open", [url], {
+      const child = spawn5("open", [url], {
         detached: true,
         stdio: "ignore"
       });
       child.unref();
       return;
     }
-    const child = spawn4("xdg-open", [url], {
+    const child = spawn5("xdg-open", [url], {
       detached: true,
       stdio: "ignore"
     });
@@ -65974,7 +66420,7 @@ async function applyCommandResult(text, cmdResult, ctx) {
 }
 
 // src/app/utils/bash.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 async function executeDirectBash(options) {
   const { command, cwd = process.cwd(), abortSignal, onChunk } = options;
   const { shell, args } = getPlatformShell();
@@ -65987,7 +66433,7 @@ async function executeDirectBash(options) {
     let output = "";
     let isSettled = false;
     try {
-      child = spawn5(shell, childArgs, {
+      child = spawn6(shell, childArgs, {
         cwd,
         env: process.env,
         stdio: ["pipe", "pipe", "pipe"],
@@ -66206,7 +66652,7 @@ class TUIApp {
       source: this.session.session.turns.length > 0 ? "resume" : "startup"
     });
     const logPath = getSessionLogPath(this.session.session.date, this.session.session.id);
-    if (this.session.session.turns.length > 0 || existsSync19(logPath)) {
+    if (this.session.session.turns.length > 0 || existsSync21(logPath)) {
       renderTranscript(this.engine, this.session.session, this.header);
     } else {
       this.engine.commit("header", this.header.render());
@@ -66312,7 +66758,8 @@ class TUIApp {
     if (defaultCommandRegistry.isCommand(text)) {
       const cmdResult = await defaultCommandRegistry.execute(text, {
         session: this.session,
-        cwd: this.cwd
+        cwd: this.cwd,
+        getScreenLines: () => this.engine.history.getEntries().filter((e) => e.kind !== "logo").flatMap((e) => e.lines)
       });
       await applyCommandResult(text, cmdResult, {
         engine: this.engine,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "steward-cli",
-  "version": "0.26.1",
+  "version": "0.27.0",
   "description": "Interactive AI engineering assistant for the terminal.",
   "license": "MIT",
   "author": "sapirrior",