@ocis/myagent-cli 0.2.0

package/dist/ui/tool-view.js

@@ -0,0 +1,326 @@
+// -------------------------------------------------------------------
+// Tool-call presentation: per-tool argument summaries and expanded bodies.
+//
+// The transcript shows only meaningful args (a path, a command) instead of raw
+// JSON, and results are rendered by kind: syntax-highlighted file reads,
+// side-by-side diffs for edits, command + tail for bash.
+// -------------------------------------------------------------------
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { GRAY_COLOR, diffAdd, diffDel, style, toolOutputColor } from "./colors.js";
+import { parseDiffLines, renderPairRows } from "./diff.js";
+import { formatTodoArgs } from "./format.js";
+import { highlightLine, languageForPath } from "./highlight.js";
+import { sanitizeForTerminal } from "../sanitize.js";
+/** Bash output lines kept in the expanded body (older lines collapse). */
+export const SHELL_TAIL_LINES = 30;
+/**
+ * Read bodies keep their head (line numbers stay aligned with the file);
+ * 500 is far beyond what a human scans in an expanded card — narrower views
+ * should use the tool's offset/limit instead of rendering everything.
+ */
+const READ_HEAD_LINES = 500;
+/** Generic (no custom renderer) tool outputs keep their tail, like shell. */
+const OUTPUT_TAIL_LINES = 200;
+/** Widest one-line inline summary (visible columns). */
+const INLINE_SUMMARY_MAX_WIDTH = 80;
+/** Caps for one parameter value in the expanded params block. */
+const PARAM_VALUE_MAX_CHARS = 2000;
+const PARAM_VALUE_MAX_LINES = 20;
+/** Parse tool arguments whether they arrived as a JSON string or an object. */
+export function parseToolArgs(raw) {
+    if (typeof raw === "string") {
+        try {
+            const parsed = JSON.parse(raw);
+            return typeof parsed === "object" && parsed !== null ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    return typeof raw === "object" && raw !== null ? raw : {};
+}
+/** `local_read` → `read`, `load_local_skill` → `load_skill`. */
+export function displayToolName(name) {
+    return name.replace("local_", "");
+}
+function stringArg(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+/**
+ * Sanitize every top-level string value in an args object before it reaches
+ * the terminal. Tool arguments are model-generated and can echo untrusted
+ * content (a path from a malicious repo, a `content` argument carrying file
+ * bytes) — the same OSC/CSI/C0 risk as tool output, which toolBody already
+ * sanitizes. Nested values are covered by paramValueLines' stringify pass.
+ */
+function sanitizeArgs(args) {
+    const out = {};
+    for (const [key, value] of Object.entries(args)) {
+        out[key] = typeof value === "string" ? sanitizeForTerminal(value) : value;
+    }
+    return out;
+}
+function numberArg(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/** First line, clipped — the one-line header form for a single value. */
+function inlineSummary(text) {
+    const [first = "", ...rest] = text.split("\n");
+    // Clip by VISIBLE width, not UTF-16 code units: a CJK/emoji summary would
+    // otherwise be cut at the wrong column (or mid surrogate pair).
+    const clipped = visibleWidth(first) > INLINE_SUMMARY_MAX_WIDTH
+        ? truncateToWidth(first, INLINE_SUMMARY_MAX_WIDTH, "…")
+        : first;
+    return rest.length > 0 ? `${clipped} …` : clipped;
+}
+/**
+ * One-line argument summary shown after the tool name — important parameters
+ * only, never raw JSON. Tools without a curated summary fall back to a single
+ * parameter shown inline; a call with several parameters shows no summary.
+ *
+ * The result is sanitized: the summary is always visible (collapsed header)
+ * and its values come from model-generated arguments.
+ */
+export function toolSummary(name, args) {
+    return sanitizeForTerminal(toolSummaryRaw(name, args));
+}
+function toolSummaryRaw(name, args) {
+    switch (displayToolName(name)) {
+        case "read": {
+            const path = stringArg(args.path) ?? "";
+            const offset = numberArg(args.offset);
+            const limit = numberArg(args.limit);
+            const start = offset ?? 1;
+            const range = limit !== undefined
+                ? `lines ${start}–${start + limit - 1}`
+                : offset !== undefined ? `from line ${start}` : "";
+            return [path, range].filter(Boolean).join(" · ");
+        }
+        case "write":
+            return [stringArg(args.path) ?? "", args.append === true ? "append" : ""].filter(Boolean).join(" · ");
+        case "edit": {
+            const edits = Array.isArray(args.edits) ? args.edits.length : 0;
+            const flags = [edits > 0 ? `${edits} edits` : "", args.replace_all === true ? "replace all" : ""];
+            return [stringArg(args.path) ?? "", ...flags.filter(Boolean)].join(" · ");
+        }
+        case "ls": {
+            const flags = [
+                args.recursive === true ? "recursive" : "",
+                stringArg(args.pattern) ?? "",
+            ];
+            return [stringArg(args.path) ?? ".", ...flags.filter(Boolean)].join(" · ");
+        }
+        case "shell":
+        case "bash": // legacy `local_bash` calls in replayed history
+            return inlineSummary(stringArg(args.command) ?? "");
+        case "grep": {
+            const include = stringArg(args.include);
+            return [
+                stringArg(args.pattern) ?? "",
+                stringArg(args.path) ? `in ${stringArg(args.path)}` : "",
+                include ? `· ${include}` : "",
+            ].filter(Boolean).join(" ");
+        }
+        case "find": {
+            const from = stringArg(args.path);
+            return [stringArg(args.pattern) ?? "", from ? `in ${from}` : ""].filter(Boolean).join(" · ");
+        }
+        case "load_skill":
+            return stringArg(args.name) ?? "";
+        case "update_todo":
+            return `${Array.isArray(args.todos) ? args.todos.length : 0} items`;
+        case "transfer_files": {
+            const direction = stringArg(args.direction) ?? "";
+            if (direction === "list")
+                return `list ${stringArg(args.path) ?? "/"}`;
+            const from = stringArg(args.from) ?? "";
+            const to = stringArg(args.to);
+            return to ? `${direction} ${from} → ${to}` : `${direction} ${from}`;
+        }
+        default: {
+            // Generic fallback: a call with exactly one parameter shows it inline.
+            const entries = Object.entries(args);
+            if (entries.length !== 1)
+                return "";
+            const [key, value] = entries[0];
+            if (typeof value === "string" && value.length > 0)
+                return inlineSummary(value);
+            if (typeof value === "number" || typeof value === "boolean")
+                return `${key}=${String(value)}`;
+            return "";
+        }
+    }
+}
+/** Result-line style: errors are red, normal output uses the muted tool tone. */
+function paintOutput(isError) {
+    return isError ? style.red : toolOutputColor;
+}
+function outputLines(output, isError) {
+    if (output.length === 0)
+        return [];
+    const all = output.split("\n");
+    const lines = all.length > OUTPUT_TAIL_LINES
+        ? [style.dim(`... skipped ${all.length - OUTPUT_TAIL_LINES} lines`), ...all.slice(-OUTPUT_TAIL_LINES)]
+        : all;
+    return lines.map(paintOutput(isError));
+}
+/** `local_read` results carry `N: text` lines; highlight the code, keep the gutter. */
+function readBody(args, output, isError) {
+    const language = languageForPath(stringArg(args.path) ?? "");
+    const rows = [];
+    // Track the max line number incrementally and stop storing rows past the
+    // head cap: a 10MB file of short lines can carry millions of rows, and
+    // `Math.max(...numbers)` on that many arguments throws a RangeError that
+    // would take the whole render down.
+    let maxNumber = 0;
+    let hasNumbered = false;
+    let totalRows = 0;
+    for (const line of output.split("\n")) {
+        totalRows++;
+        const match = /^(\d+): ?(.*)$/.exec(line);
+        if (match) {
+            hasNumbered = true;
+            const number = Number(match[1]);
+            if (number > maxNumber)
+                maxNumber = number;
+            if (rows.length < READ_HEAD_LINES)
+                rows.push({ number, code: match[2] });
+        }
+        else if (rows.length < READ_HEAD_LINES) {
+            rows.push({ plain: line });
+        }
+    }
+    if (!hasNumbered)
+        return outputLines(output, isError);
+    // Keep the head — the line numbers stay aligned with the file, and the note
+    // points at the tool's offset/limit for the rest.
+    const clipped = totalRows > READ_HEAD_LINES;
+    const gutter = String(maxNumber).length;
+    const lines = rows.map((row) => "number" in row
+        ? `${style.dim(`${String(row.number).padStart(gutter)} │`)} ${highlightLine(language, row.code, toolOutputColor)}`
+        : style.dim(row.plain));
+    if (clipped)
+        lines.push(style.dim(`... ${totalRows - READ_HEAD_LINES} more lines — re-read with offset/limit for the rest`));
+    return lines;
+}
+/** Pair cells drop the `+`/`-`/space marker — the columns and colors carry it. */
+function paintPairLine(line) {
+    if (line.kind === "add")
+        return diffAdd(line.text.slice(1));
+    if (line.kind === "del")
+        return diffDel(line.text.slice(1));
+    if (line.kind === "context")
+        return toolOutputColor(line.text.slice(1));
+    return line.text;
+}
+/** Side-by-side rows with old/new line-number gutters (meta/hunk lines hidden). */
+function renderPairDiff(lines, width) {
+    const content = lines.filter((line) => line.kind !== "meta" && line.kind !== "hunk");
+    if (content.length === 0)
+        return [];
+    return renderPairRows(content, width, paintPairLine);
+}
+/** The edit result is "Applied …" (or an error) followed by a unified diff. */
+function editBody(output, isError, width) {
+    const lines = output.split("\n");
+    const start = lines.findIndex((line) => line.startsWith("--- ") || line.startsWith("@@"));
+    const head = (start === -1 ? lines : lines.slice(0, start)).filter((line) => line.trim().length > 0);
+    const body = head.map((line) => (isError ? style.red(line) : style.dim(line)));
+    if (start === -1)
+        return body;
+    body.push(...renderPairDiff(parseDiffLines(lines.slice(start).join("\n")), width));
+    return body;
+}
+/** `$ command` plus the last {@link SHELL_TAIL_LINES} result lines. */
+function shellBody(args, output, isError) {
+    const command = stringArg(args.command) ?? "";
+    const lines = [`${style.dim("$")} ${GRAY_COLOR(command)}`];
+    const all = output.length > 0 ? output.split("\n") : [];
+    if (all.length > SHELL_TAIL_LINES) {
+        lines.push(style.dim(`... skipped ${all.length - SHELL_TAIL_LINES} lines`));
+    }
+    lines.push(...all.slice(-SHELL_TAIL_LINES).map(paintOutput(isError)));
+    return lines;
+}
+function todoBody(args, output, isError) {
+    return [...formatTodoArgs(args).map(toolOutputColor), ...outputLines(output, isError)];
+}
+/** One parameter value as display lines, wrapped to `width` and capped. */
+function paramValueLines(value, width) {
+    const raw = typeof value === "string"
+        ? value
+        : typeof value === "object" && value !== null
+            ? JSON.stringify(value)
+            : String(value);
+    // Untrusted values (a path, a file body echoed into an argument) must not
+    // carry terminal escapes into the params block.
+    const safe = sanitizeForTerminal(raw);
+    const truncatedChars = safe.length > PARAM_VALUE_MAX_CHARS;
+    // The cap bounds payload size (code units), but the cut must not split a
+    // surrogate pair — a lone half renders as U+FFFD.
+    let body = truncatedChars ? safe.slice(0, PARAM_VALUE_MAX_CHARS) : safe;
+    if (truncatedChars && /[\uD800-\uDBFF]$/.test(body))
+        body = body.slice(0, -1);
+    let lines = body.split("\n");
+    const hiddenLines = lines.length > PARAM_VALUE_MAX_LINES ? lines.length - PARAM_VALUE_MAX_LINES : 0;
+    if (hiddenLines > 0)
+        lines = lines.slice(0, PARAM_VALUE_MAX_LINES);
+    const wrapped = lines.flatMap((line) => wrapTextWithAnsi(line, Math.max(1, width)));
+    if (truncatedChars)
+        wrapped.push(`… (+${safe.length - PARAM_VALUE_MAX_CHARS} chars)`);
+    if (hiddenLines > 0)
+        wrapped.push(`… (+${hiddenLines} lines)`);
+    return wrapped.length > 0 ? wrapped : [""];
+}
+/**
+ * Every argument of a call as an indented `key: value` block — the expanded
+ * body for tools without a custom renderer (write, ls, grep, find, transfer,
+ * server tools, …), so the full parameters are always inspectable.
+ */
+function paramsBlock(args, width) {
+    const entries = Object.entries(args);
+    if (entries.length === 0)
+        return [];
+    const lines = [];
+    for (const [key, value] of entries) {
+        const label = style.dim(`${key}: `);
+        const valueLines = paramValueLines(value, Math.max(1, width - visibleWidth(label) - 2));
+        if (valueLines.length === 1) {
+            lines.push(`${label}${toolOutputColor(valueLines[0])}`);
+        }
+        else {
+            lines.push(style.dim(`${key}:`));
+            lines.push(...valueLines.map((line) => `  ${toolOutputColor(line)}`));
+        }
+    }
+    return lines;
+}
+/**
+ * Expanded body lines for a tool call, rendered for the available `width`
+ * (pair diffs use it for their columns). Callers add the transcript indent.
+ */
+export function toolBody(name, args, output, isError, width) {
+    // Tool output and file content come from the workspace (an untrusted repo)
+    // and land on the user's real terminal — strip everything but our own SGR
+    // styling, which is applied after this point. Arguments get the same
+    // treatment: they are model-generated and can echo untrusted content.
+    output = sanitizeForTerminal(output);
+    args = sanitizeArgs(args);
+    switch (displayToolName(name)) {
+        case "read":
+            return readBody(args, output, isError);
+        case "edit":
+            return editBody(output, isError, width);
+        case "shell":
+        case "bash": // legacy `local_bash` calls in replayed history
+            return shellBody(args, output, isError);
+        case "update_todo":
+            return todoBody(args, output, isError);
+        default: {
+            // No custom renderer: show the full parameters, then the result.
+            const params = paramsBlock(args, width);
+            const result = outputLines(output, isError);
+            return params.length > 0 && result.length > 0 ? [...params, "", ...result] : [...params, ...result];
+        }
+    }
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@ocis/myagent-cli",
+  "version": "0.2.0",
+  "description": "Terminal coding agent for your local repository, powered by a remote MyAgent server",
+  "type": "module",
+  "bin": {
+    "myagent": "./dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "skills"
+  ],
+  "engines": {
+    "node": ">=22.19.0",
+    "bun": ">=1.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "start": "bun run src/index.ts",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json && bun run scripts/fix-esm.ts",
+    "prepack": "bun run build",
+    "build:binary": "bun build src/index.ts --compile --outfile dist/myagent",
+    "build:linux-x64": "bun build src/index.ts --compile --minify --target=bun-linux-x64 --outfile dist/myagent-linux-x64",
+    "build:linux-arm64": "bun build src/index.ts --compile --minify --target=bun-linux-arm64 --outfile dist/myagent-linux-arm64",
+    "build:darwin-x64": "bun build src/index.ts --compile --minify --target=bun-darwin-x64 --outfile dist/myagent-darwin-x64",
+    "build:darwin-arm64": "bun build src/index.ts --compile --minify --target=bun-darwin-arm64 --outfile dist/myagent-darwin-arm64",
+    "build:windows-x64": "bun build src/index.ts --compile --minify --target=bun-windows-x64 --outfile dist/myagent-windows-x64.exe",
+    "build:all": "bun run build:linux-x64 && bun run build:linux-arm64 && bun run build:darwin-x64 && bun run build:darwin-arm64 && bun run build:windows-x64"
+  },
+  "devDependencies": {
+    "bun-types": "1.3.11",
+    "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "@earendil-works/pi-tui": "0.85.1"
+  }
+}

package/skills/git-commit/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: git-commit
+description: Stage and commit local changes with a clean, conventional message.
+---
+
+# git-commit
+
+A playbook for committing the user's local changes safely.
+
+## Steps
+
+1. Run `local_bash` with `git status --short` and `git diff --stat` to see what
+   changed. If there are no changes, tell the user and stop.
+2. Run `git diff` (and `git diff --staged`) to understand the actual edits.
+3. Propose a commit message:
+   - First line: `<type>: <summary>` (≤ 72 chars), where type is one of
+     feat, fix, refactor, docs, test, chore.
+   - Optional body explaining *why*, wrapped at 72 columns.
+4. Stage the relevant files with `git add` (prefer explicit paths over `-A`).
+5. Commit with `git commit -m "..."`. Show the user the resulting
+   `git log -1 --stat`.
+
+## Rules
+
+- Never commit secrets, large binaries, or unrelated changes.
+- Do not push unless the user explicitly asks.
+- If pre-commit hooks fail, report the output and stop rather than bypassing them.