@ocis/myagent-cli 0.2.0

package/dist/runtime.js

@@ -0,0 +1,166 @@
+// ---------------------------------------------------------------------------
+// Runtime shims: Bun APIs on Bun, node: equivalents on Node.
+//
+// The CLI runs on both runtimes. Bun's file/spawn/stdin/which globals have no
+// Node counterpart, so every call site goes through this module instead of
+// touching `Bun.*` directly. The Bun branches are guarded by `typeof Bun`, so
+// the emitted JS never touches the `Bun` global on Node.
+//
+// The subprocess shim normalizes both runtimes to one `ProcessHandle` (Web
+// ReadableStreams for stdout/stderr, a FileSink-like stdin, `.pid`, `.kill()`,
+// `.exited`) — the same shape `Bun.spawn` returns, so the shell/git/grep tools
+// run unchanged on either runtime.
+// ---------------------------------------------------------------------------
+import { spawn } from "node:child_process";
+import { realpathSync, statSync } from "node:fs";
+import { readFile, stat, writeFile as writeFileFs } from "node:fs/promises";
+import { Buffer } from "node:buffer";
+import { delimiter, join } from "node:path";
+import { Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
+export const isBun = typeof Bun !== "undefined";
+// --- files -----------------------------------------------------------------
+export async function fileExists(path) {
+    if (isBun)
+        return Bun.file(path).exists();
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export async function readTextFile(path) {
+    if (isBun)
+        return Bun.file(path).text();
+    return readFile(path, "utf8");
+}
+export async function readJsonFile(path) {
+    return JSON.parse(await readTextFile(path));
+}
+export async function writeFile(path, data) {
+    if (isBun) {
+        await Bun.write(path, data);
+        return;
+    }
+    await writeFileFs(path, data);
+}
+// --- which -----------------------------------------------------------------
+/** Resolve an executable on PATH (Bun.which on Bun, a PATH scan on Node). */
+export function which(cmd) {
+    if (isBun && Bun.which)
+        return Bun.which(cmd);
+    const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+    const exts = process.platform === "win32"
+        ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean)
+        : [""];
+    const names = cmd.includes(".") ? [cmd] : exts.map((ext) => cmd + ext);
+    for (const dir of dirs) {
+        for (const name of names) {
+            const candidate = join(dir, name);
+            try {
+                if (statSync(candidate).isFile())
+                    return candidate;
+            }
+            catch {
+                /* keep looking */
+            }
+        }
+    }
+    return null;
+}
+// --- stdin -----------------------------------------------------------------
+/** Read all of stdin as UTF-8 text. Callers check `process.stdin.isTTY` first. */
+export async function readStdinText() {
+    if (isBun)
+        return new Response(Bun.stdin.stream()).text();
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
+}
+// --- entry detection -------------------------------------------------------
+/**
+ * True when the caller's module is the process entry point. `import.meta` is
+ * module-scoped, so the caller must pass its own (`isMainModule(import.meta)`).
+ * Bun and Node ≥24.2 expose `import.meta.main`; older Node falls back to
+ * comparing the resolved entry path (realpath, so npm/bun bin symlinks match).
+ */
+export function isMainModule(meta) {
+    const main = meta.main;
+    if (typeof main === "boolean")
+        return main;
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    try {
+        return realpathSync(entry) === realpathSync(fileURLToPath(meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+export function spawnProcess(args, opts) {
+    return isBun ? spawnBun(args, opts) : spawnNode(args, opts);
+}
+function spawnBun(args, opts) {
+    const proc = Bun.spawn(args, {
+        cwd: opts?.cwd,
+        env: opts?.env ? { ...process.env, ...opts.env } : undefined,
+        stdin: opts?.stdin === "pipe" ? "pipe" : "ignore",
+        stdout: opts?.stdout === "pipe" ? "pipe" : "ignore",
+        stderr: opts?.stderr === "pipe" ? "pipe" : "ignore",
+        detached: opts?.detached,
+    });
+    return {
+        pid: proc.pid,
+        stdout: proc.stdout,
+        stderr: proc.stderr,
+        stdin: {
+            write: (data) => { proc.stdin.write(data); },
+            end: () => { proc.stdin.end(); },
+        },
+        exited: proc.exited,
+        kill: (signal) => { try {
+            proc.kill(signal);
+        }
+        catch { /* already gone */ } },
+    };
+}
+function spawnNode(args, opts) {
+    const child = spawn(args[0], args.slice(1), {
+        cwd: opts?.cwd,
+        env: opts?.env ? { ...process.env, ...opts.env } : process.env,
+        stdio: [
+            opts?.stdin === "pipe" ? "pipe" : "ignore",
+            opts?.stdout === "pipe" ? "pipe" : "ignore",
+            opts?.stderr === "pipe" ? "pipe" : "ignore",
+        ],
+        detached: opts?.detached ?? false,
+    });
+    // First of close/error wins: a spawn failure (ENOENT) may emit only `error`.
+    const exited = new Promise((resolve) => {
+        child.once("close", (code) => resolve(code ?? 0));
+        child.once("error", () => resolve(-1));
+    });
+    return {
+        pid: child.pid ?? 0,
+        stdout: child.stdout
+            ? Readable.toWeb(child.stdout)
+            : new ReadableStream(),
+        stderr: child.stderr
+            ? Readable.toWeb(child.stderr)
+            : new ReadableStream(),
+        stdin: {
+            write: (data) => { if (child.stdin)
+                child.stdin.write(Buffer.from(data)); },
+            end: () => { if (child.stdin)
+                child.stdin.end(); },
+        },
+        exited,
+        kill: (signal) => { try {
+            child.kill(signal);
+        }
+        catch { /* already dead */ } },
+    };
+}

package/dist/sanitize.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeForTerminal(text: string): string;

package/dist/sanitize.js

@@ -0,0 +1,21 @@
+// ---------------------------------------------------------------------------
+// Terminal-sequence sanitizing for untrusted text rendered into the TUI.
+//
+// Tool output and file content come from the workspace (an untrusted repo the
+// agent is working on) and are written to the user's real terminal — embedded
+// OSC/CSI/C0 sequences could otherwise move the cursor, rewrite the title, or
+// clear the screen. Shared by the git status parser (remote-controlled path
+// names) and the tool-call renderer (raw output/file bodies).
+// ---------------------------------------------------------------------------
+export function sanitizeForTerminal(text) {
+    return text
+        .replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)?/g, "") // OSC … (BEL / ST)
+        // CSI: parameter + intermediate bytes then a final byte. SPACE (0x20) is a
+        // legal intermediate (`CSI Ps SP q` sets the cursor shape), so it belongs
+        // in the class — without it that sequence's tail leaked through as noise.
+        .replace(/\u001b\[[ 0-9;:?<=>!"#$%&'()*+,\-./]*[@-~]/g, "") // CSI sequences
+        .replace(/\u001b[@-Z\\\-_]/g, "") // remaining two-byte escapes
+        // Stray C0/C1 controls. \t is kept — a literal tab in a filename is
+        // visible and harmless, and \n cannot survive line-based output anyway.
+        .replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, "");
+}

package/dist/skills/discovery.d.ts

@@ -0,0 +1,24 @@
+export interface LocalSkill {
+    name: string;
+    description: string;
+    dir: string;
+    files: string[];
+    /** Full SKILL.md text, read once during discovery. */
+    md: string;
+}
+/** Parse the leading `--- ... ---` frontmatter for name/description. */
+export declare function parseFrontmatter(md: string): {
+    name?: string;
+    description?: string;
+};
+/** Discover skills across the given directories; earlier dirs win. */
+export declare function discoverSkills(dirs: string[]): Promise<LocalSkill[]>;
+/** One-line-per-skill listing (tool output + `myagent skills`). */
+export declare function formatSkillList(skills: LocalSkill[]): string;
+/** `<available_skills>` block for the system prompt (empty when no skills). */
+export declare function buildSkillsCatalog(skills: LocalSkill[]): string;
+/**
+ * Resolve the ordered, existing skill search paths. The global dir is created
+ * if missing; the others are included only when they already exist.
+ */
+export declare function resolveSkillDirs(workspace: string, configDirPath: string, extraDirs?: string[]): Promise<string[]>;

package/dist/skills/discovery.js

@@ -0,0 +1,109 @@
+// -------------------------------------------------------------------
+// Local skills: SKILL.md discovery on the user's machine.
+//
+// A skill is a directory with a SKILL.md (YAML frontmatter name/description +
+// instructions) that the agent loads on demand via load_local_skill. Search
+// paths, in priority order (earlier wins on a name collision):
+//   1. --skills-dir values (resolved absolute)
+//   2. <workspace>/.myagent/skills
+//   3. <configDir>/skills (created on first run so there's always a home)
+// -------------------------------------------------------------------
+import { mkdir, readdir, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { readTextFile } from "../runtime.js";
+/** Parse the leading `--- ... ---` frontmatter for name/description. */
+export function parseFrontmatter(md) {
+    const match = md.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return {};
+    const out = {};
+    for (const line of match[1].split("\n")) {
+        const m = line.match(/^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/);
+        if (m)
+            out[m[1]] = m[2].trim().replace(/^["']|["']$/g, "");
+    }
+    return { name: out.name, description: out.description };
+}
+async function loadSkillDir(dir, fallbackName) {
+    let md;
+    try {
+        md = await readTextFile(join(dir, "SKILL.md"));
+    }
+    catch {
+        return null;
+    }
+    const fm = parseFrontmatter(md);
+    const files = (await readdir(dir).catch(() => []));
+    return {
+        name: fm.name || fallbackName,
+        description: fm.description || "(no description)",
+        dir,
+        files,
+        md,
+    };
+}
+/** Discover skills across the given directories; earlier dirs win. */
+export async function discoverSkills(dirs) {
+    const skills = [];
+    const seen = new Set();
+    for (const root of dirs) {
+        let entries;
+        try {
+            entries = await readdir(root, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        const loaded = await Promise.all(entries.filter((e) => e.isDirectory()).map((e) => loadSkillDir(join(root, e.name), e.name)));
+        for (const skill of loaded) {
+            if (!skill || seen.has(skill.name))
+                continue;
+            seen.add(skill.name);
+            skills.push(skill);
+        }
+    }
+    return skills;
+}
+/** One-line-per-skill listing (tool output + `myagent skills`). */
+export function formatSkillList(skills) {
+    if (skills.length === 0)
+        return "(no local skills installed)";
+    return skills.map((s) => `- ${s.name}: ${s.description}`).join("\n");
+}
+/** `<available_skills>` block for the system prompt (empty when no skills). */
+export function buildSkillsCatalog(skills) {
+    if (skills.length === 0)
+        return "";
+    return [
+        "<available_skills>",
+        "Load a skill on demand with load_local_skill when a task matches:",
+        ...skills.map((s) => `  - ${s.name}: ${s.description}`),
+        "</available_skills>",
+    ].join("\n");
+}
+/**
+ * Resolve the ordered, existing skill search paths. The global dir is created
+ * if missing; the others are included only when they already exist.
+ */
+export async function resolveSkillDirs(workspace, configDirPath, extraDirs = []) {
+    const globalDir = join(configDirPath, "skills");
+    await mkdir(globalDir, { recursive: true }).catch((err) => {
+        process.stderr.write(`[warn] Could not create global skills dir ${globalDir}: ${err instanceof Error ? err.message : String(err)}\n`);
+    });
+    const ordered = [
+        ...extraDirs.map((d) => resolve(d)),
+        join(workspace, ".myagent", "skills"),
+        globalDir,
+    ];
+    const dirs = [];
+    const seen = new Set();
+    for (const dir of ordered) {
+        if (seen.has(dir))
+            continue;
+        seen.add(dir);
+        const st = await stat(dir).catch(() => null);
+        if (st?.isDirectory())
+            dirs.push(dir);
+    }
+    return dirs;
+}

package/dist/tools/binary.d.ts

@@ -0,0 +1,2 @@
+/** True when the buffer looks like binary content (NUL byte or invalid UTF-8). */
+export declare function isBinaryBuffer(buffer: Buffer): boolean;

package/dist/tools/binary.js

@@ -0,0 +1,22 @@
+// ---------------------------------------------------------------------------
+// Shared binary sniffing for local file tools.
+//
+// One implementation for every caller (local_read/local_edit and
+// local_transfer_files) so they cannot drift: a file is binary when it
+// contains a NUL byte or is not valid UTF-8 — the same rule the server's
+// workspace API applies to uploads.
+// ---------------------------------------------------------------------------
+/** True when the buffer looks like binary content (NUL byte or invalid UTF-8). */
+export function isBinaryBuffer(buffer) {
+    for (const byte of buffer) {
+        if (byte === 0)
+            return true;
+    }
+    try {
+        new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}

package/dist/tools/diff.d.ts

@@ -0,0 +1 @@
+export declare function generateDiff(path: string, oldText: string, newText: string): string;

package/dist/tools/diff.js

@@ -0,0 +1,49 @@
+// ---------------------------------------------------------------------------
+// Simplified unified diff for edit results and the transcript.
+//
+// Single hunk with 3 lines of context (trim common prefix/suffix once) — the
+// same shape the myagent-studio SDK produces: enough for a human/model to see
+// what changed without implementing a full Myers diff. Display colorization is
+// applied by the UI, not here.
+// ---------------------------------------------------------------------------
+const CONTEXT = 3;
+export function generateDiff(path, oldText, newText) {
+    if (oldText === newText)
+        return "";
+    const oldLines = oldText.split("\n");
+    const newLines = newText.split("\n");
+    // A trailing newline yields a final empty element on both sides — drop it
+    // only when BOTH sides have it, or the hunk ends with a phantom context
+    // line that matches no real file line. When only ONE side ends with a
+    // newline the difference is real and survives as an explicit +/- empty
+    // line (dropping it on one side alone would make the arrays compare equal
+    // and silently hide the change).
+    if (oldLines[oldLines.length - 1] === "" && newLines[newLines.length - 1] === "") {
+        oldLines.pop();
+        newLines.pop();
+    }
+    let prefix = 0;
+    while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix]) {
+        prefix++;
+    }
+    let suffix = 0;
+    while (suffix < oldLines.length - prefix &&
+        suffix < newLines.length - prefix &&
+        oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]) {
+        suffix++;
+    }
+    const contextStart = Math.max(0, prefix - CONTEXT);
+    const contextEndOld = Math.min(oldLines.length, oldLines.length - suffix + CONTEXT);
+    const contextEndNew = Math.min(newLines.length, newLines.length - suffix + CONTEXT);
+    const removed = oldLines.slice(prefix, oldLines.length - suffix);
+    const added = newLines.slice(prefix, newLines.length - suffix);
+    const header = `--- a/${path}\n+++ b/${path}\n`;
+    const hunk = `@@ -${contextStart + 1},${contextEndOld - contextStart} +${contextStart + 1},${contextEndNew - contextStart} @@\n`;
+    const body = [
+        ...oldLines.slice(contextStart, prefix).map((l) => ` ${l}`),
+        ...removed.map((l) => `-${l}`),
+        ...added.map((l) => `+${l}`),
+        ...oldLines.slice(oldLines.length - suffix, contextEndOld).map((l) => ` ${l}`),
+    ].join("\n");
+    return header + hunk + body;
+}

package/dist/tools/find.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from "./types.js";
+export declare const findToolInstance: ToolHandler;

package/dist/tools/find.js

@@ -0,0 +1,61 @@
+// ---------------------------------------------------------------------------
+// local_find — glob-based file discovery.
+// ---------------------------------------------------------------------------
+import { readdir } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { defineTool, optionalString, requireString } from "./types.js";
+import { resolveToolPath } from "./paths.js";
+import { matchGlob } from "./glob.js";
+import { SKIP_DIRS } from "./grep.js";
+const MAX_RESULTS = 500;
+const MAX_DEPTH = 15;
+const findTool = defineTool({
+    name: "local_find",
+    description: "Find files by glob pattern (supports *, ?, **, {a,b}). Returns workspace-relative paths, capped at 500. Common build/VCS directories are skipped.",
+    parameters: {
+        type: "object",
+        properties: {
+            pattern: { type: "string", description: "Glob pattern, e.g. \"src/**/*.test.ts\"." },
+            path: { type: "string", description: "Directory to search from (default: workspace root)." },
+        },
+        required: ["pattern"],
+    },
+    summarize: (args) => `find ${String(args.pattern ?? "")}`,
+    run: async (args, ctx) => {
+        const pattern = requireString(args, "pattern");
+        const path = optionalString(args, "path") ?? ".";
+        const absolute = await resolveToolPath(path, ctx);
+        const results = [];
+        async function walk(dir, depth) {
+            if (results.length >= MAX_RESULTS || depth > MAX_DEPTH || ctx.signal?.aborted)
+                return;
+            let entries;
+            try {
+                entries = await readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (results.length >= MAX_RESULTS)
+                    return;
+                if (entry.isDirectory()) {
+                    if (SKIP_DIRS.has(entry.name) || entry.name.startsWith("."))
+                        continue;
+                    await walk(join(dir, entry.name), depth + 1);
+                    continue;
+                }
+                const full = join(dir, entry.name);
+                const rel = relative(absolute, full) || entry.name;
+                if (matchGlob(pattern, rel) || matchGlob(pattern, entry.name)) {
+                    results.push(relative(ctx.workspace, full) || full);
+                }
+            }
+        }
+        await walk(absolute, 0);
+        if (results.length === 0)
+            return "No files matched.";
+        return results.sort().join("\n") + (results.length >= MAX_RESULTS ? `\n… (capped at ${MAX_RESULTS} results)` : "");
+    },
+});
+export const findToolInstance = findTool;

package/dist/tools/fs.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from "./types.js";
+export declare const fsTools: ToolHandler[];