muonroi-cli 1.2.0

package/src/usage/types.ts

@@ -0,0 +1,40 @@
+/**
+ * src/usage/types.ts
+ *
+ * Core types for the reservation ledger and threshold system.
+ * USAGE-02 (thresholds) + USAGE-03 (reservation ledger).
+ */
+
+export interface ReservationToken {
+  id: string;
+  model: string;
+  provider: string;
+  projected_usd: number;
+  est_input_tokens: number;
+  est_output_tokens: number;
+  createdAtMs: number;
+}
+
+export class CapBreachError extends Error {
+  constructor(
+    public readonly current: number,
+    public readonly reserved: number,
+    public readonly projected: number,
+    public readonly cap: number,
+  ) {
+    super(
+      `Cap breach: current=${current.toFixed(4)} reserved=${reserved.toFixed(4)} projected=${projected.toFixed(4)} cap=${cap.toFixed(4)}`,
+    );
+    this.name = "CapBreachError";
+  }
+}
+
+export type ThresholdLevel = 50 | 80 | 100;
+
+export interface ThresholdEvent {
+  level: ThresholdLevel;
+  current_pct: number;
+  current_usd: number;
+  cap_usd: number;
+  atMs: number;
+}

package/src/utils/at-mentions.ts

@@ -0,0 +1,120 @@
+import { existsSync, readFileSync, statSync } from "fs";
+import { isAbsolute, resolve } from "path";
+
+const MAX_FILE_SIZE = 100 * 1024; // 100 KB
+
+const UNQUOTED_AT_RE = /(?:^|\s)@([\w\-./\\~][\w\-./\\~:]*)/g;
+const QUOTED_AT_RE = /(?:^|\s)@"([^"]+)"/g;
+
+export interface AtMentionedFile {
+  raw: string;
+  filePath: string;
+  startLine?: number;
+  endLine?: number;
+}
+
+export interface ProcessedMentions {
+  enhancedMessage: string;
+  mentionedFiles: string[];
+}
+
+function parseLineRange(raw: string): { filePath: string; startLine?: number; endLine?: number } {
+  const hashIdx = raw.lastIndexOf("#");
+  if (hashIdx === -1) return { filePath: raw };
+
+  const filePath = raw.slice(0, hashIdx);
+  const fragment = raw.slice(hashIdx + 1);
+  const rangeMatch = fragment.match(/^L(\d+)(?:-L?(\d+))?$/);
+  if (!rangeMatch) return { filePath: raw };
+
+  const startLine = Number.parseInt(rangeMatch[1]!, 10);
+  const endLine = rangeMatch[2] ? Number.parseInt(rangeMatch[2], 10) : undefined;
+  return { filePath, startLine, endLine };
+}
+
+export function extractAtMentionedFiles(text: string): AtMentionedFile[] {
+  const mentions: AtMentionedFile[] = [];
+  const seen = new Set<string>();
+
+  for (const re of [QUOTED_AT_RE, UNQUOTED_AT_RE]) {
+    re.lastIndex = 0;
+    while (true) {
+      const m = re.exec(text);
+      if (m === null) break;
+      const raw = m[1]!;
+      if (seen.has(raw)) continue;
+      seen.add(raw);
+      const parsed = parseLineRange(raw);
+      mentions.push({ raw, ...parsed });
+    }
+  }
+  return mentions;
+}
+
+function resolvePath(filePath: string, cwd: string): string {
+  return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
+}
+
+function readFileContent(
+  filePath: string,
+  cwd: string,
+  startLine?: number,
+  endLine?: number,
+): { content: string; truncated: boolean; resolvedPath: string } | null {
+  const full = resolvePath(filePath, cwd);
+  if (!existsSync(full)) return null;
+
+  try {
+    const stat = statSync(full);
+    if (stat.isDirectory()) return null;
+
+    const raw = readFileSync(full, "utf-8");
+    const lines = raw.split("\n");
+    const totalLines = lines.length;
+
+    const start = Math.max(0, (startLine ?? 1) - 1);
+    const end = Math.min(totalLines, endLine ?? totalLines);
+    const slice = lines.slice(start, end);
+    const joined = slice.map((line, i) => `${start + i + 1} | ${line}`).join("\n");
+
+    const truncated = raw.length > MAX_FILE_SIZE;
+    const content = truncated ? joined.slice(0, MAX_FILE_SIZE) : joined;
+    const header = `[${full}: lines ${start + 1}-${end} of ${totalLines}]`;
+
+    return { content: `${header}\n${content}`, truncated, resolvedPath: full };
+  } catch {
+    return null;
+  }
+}
+
+export function processAtMentions(text: string, cwd: string): ProcessedMentions {
+  const mentions = extractAtMentionedFiles(text);
+  if (mentions.length === 0) {
+    return { enhancedMessage: text, mentionedFiles: [] };
+  }
+
+  const fileBlocks: string[] = [];
+  const mentionedFiles: string[] = [];
+
+  for (const mention of mentions) {
+    const result = readFileContent(mention.filePath, cwd, mention.startLine, mention.endLine);
+    if (!result) continue;
+
+    mentionedFiles.push(result.resolvedPath);
+    let block = `<file path="${result.resolvedPath}">\n${result.content}\n</file>`;
+    if (result.truncated) {
+      block += `\n<!-- Note: ${result.resolvedPath} was truncated (exceeded ${MAX_FILE_SIZE / 1024}KB). Use read_file for the full content. -->`;
+    }
+    fileBlocks.push(block);
+  }
+
+  if (fileBlocks.length === 0) {
+    return { enhancedMessage: text, mentionedFiles: [] };
+  }
+
+  const attachedBlock = `<attached_files>\n${fileBlocks.join("\n\n")}\n</attached_files>`;
+  return {
+    enhancedMessage: `${attachedBlock}\n\n${text}`,
+    mentionedFiles,
+  };
+}

package/src/utils/clipboard-image.ts

@@ -0,0 +1,114 @@
+/**
+ * Read image data from the OS clipboard.
+ * Returns base64-encoded image or null if clipboard has no image.
+ *
+ * - Windows: PowerShell Get-Clipboard -Format Image → save to temp PNG → read
+ * - macOS: osascript to check pasteboard type, then pngpaste/screencapture
+ * - Linux: xclip -selection clipboard -t image/png
+ */
+
+import { execSync, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export interface ClipboardImage {
+  base64: string;
+  mediaType: string;
+}
+
+export function readClipboardImage(): ClipboardImage | null {
+  const platform = os.platform();
+
+  if (platform === "win32") return readWin32();
+  if (platform === "darwin") return readDarwin();
+  if (platform === "linux") return readLinux();
+
+  return null;
+}
+
+function readWin32(): ClipboardImage | null {
+  const tmpFile = path.join(os.tmpdir(), `muonroi-clip-${Date.now()}.png`);
+  try {
+    const ps = `
+      Add-Type -AssemblyName System.Windows.Forms
+      $img = [System.Windows.Forms.Clipboard]::GetImage()
+      if ($img) { $img.Save('${tmpFile.replace(/\\/g, "\\\\")}', [System.Drawing.Imaging.ImageFormat]::Png) }
+    `;
+    spawnSync("powershell", ["-NoProfile", "-Command", ps], { timeout: 5000 });
+    if (!fs.existsSync(tmpFile)) return null;
+    const buf = fs.readFileSync(tmpFile);
+    if (buf.length < 100) return null;
+    return { base64: buf.toString("base64"), mediaType: "image/png" };
+  } catch {
+    return null;
+  } finally {
+    try { fs.unlinkSync(tmpFile); } catch { /* ignore */ }
+  }
+}
+
+function readDarwin(): ClipboardImage | null {
+  try {
+    const check = execSync(
+      "osascript -e 'clipboard info' 2>/dev/null",
+      { timeout: 3000, encoding: "utf8" },
+    );
+    if (!check.includes("«class PNGf»") && !check.includes("public.png") && !check.includes("TIFF")) {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+
+  const tmpFile = path.join(os.tmpdir(), `muonroi-clip-${Date.now()}.png`);
+  try {
+    const pngpaste = spawnSync("pngpaste", [tmpFile], { timeout: 5000 });
+    if (pngpaste.status !== 0) {
+      spawnSync("screencapture", ["-c", "-x"]);
+      const osascript = `
+        set imgData to the clipboard as «class PNGf»
+        set f to open for access POSIX file "${tmpFile}" with write permission
+        write imgData to f
+        close access f
+      `;
+      spawnSync("osascript", ["-e", osascript], { timeout: 5000 });
+    }
+    if (!fs.existsSync(tmpFile)) return null;
+    const buf = fs.readFileSync(tmpFile);
+    if (buf.length < 100) return null;
+    return { base64: buf.toString("base64"), mediaType: "image/png" };
+  } catch {
+    return null;
+  } finally {
+    try { fs.unlinkSync(tmpFile); } catch { /* ignore */ }
+  }
+}
+
+function readLinux(): ClipboardImage | null {
+  try {
+    const targets = execSync("xclip -selection clipboard -t TARGETS -o 2>/dev/null", {
+      timeout: 3000, encoding: "utf8",
+    });
+    if (!targets.includes("image/png")) return null;
+
+    const buf = execSync("xclip -selection clipboard -t image/png -o 2>/dev/null", {
+      timeout: 5000, maxBuffer: 50 * 1024 * 1024,
+    });
+    if (buf.length < 100) return null;
+    return { base64: buf.toString("base64"), mediaType: "image/png" };
+  } catch {
+    // Try wl-paste for Wayland
+    if (process.env.WAYLAND_DISPLAY) {
+      try {
+        const buf = execSync("wl-paste -t image/png 2>/dev/null", {
+          timeout: 5000, maxBuffer: 50 * 1024 * 1024,
+        });
+        if (buf.length < 100) return null;
+        return { base64: buf.toString("base64"), mediaType: "image/png" };
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}

package/src/utils/file-index.ts

@@ -0,0 +1,152 @@
+import { execSync } from "child_process";
+import { basename, resolve } from "path";
+import { findGitRoot } from "./git-root.js";
+
+const REFRESH_TTL_MS = 30_000;
+const BINARY_EXTENSIONS = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".bmp",
+  ".tiff",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".mkv",
+  ".flac",
+  ".ogg",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".7z",
+  ".rar",
+  ".xz",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".o",
+  ".a",
+  ".pyc",
+  ".class",
+  ".wasm",
+]);
+
+function isBinaryPath(filePath: string): boolean {
+  const ext = filePath.lastIndexOf(".");
+  if (ext === -1) return false;
+  return BINARY_EXTENSIONS.has(filePath.slice(ext).toLowerCase());
+}
+
+function collectFiles(cwd: string): string[] {
+  const gitRoot = findGitRoot(cwd);
+  try {
+    const cmd = gitRoot
+      ? "git ls-files --cached --others --exclude-standard"
+      : "find . -type f -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' | head -5000";
+    const raw = execSync(cmd, {
+      cwd: gitRoot ?? cwd,
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: 5000,
+    });
+    return raw
+      .split("\n")
+      .map((l) => l.trim())
+      .filter((l) => l.length > 0 && !isBinaryPath(l));
+  } catch {
+    return [];
+  }
+}
+
+function scoreMatch(filePath: string, query: string): number {
+  const lowerPath = filePath.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+  if (!lowerPath.includes(lowerQuery)) return -1;
+
+  let score = 0;
+  const name = basename(filePath).toLowerCase();
+
+  if (name === lowerQuery) score += 100;
+  else if (name.startsWith(lowerQuery)) score += 60;
+  else if (name.includes(lowerQuery)) score += 30;
+
+  if (lowerPath.startsWith(lowerQuery)) score += 20;
+
+  const idx = lowerPath.indexOf(lowerQuery);
+  score -= idx * 0.1;
+
+  score -= filePath.length * 0.05;
+
+  return score;
+}
+
+export class FileIndex {
+  private files: string[] = [];
+  private cwd: string;
+  private baseDir: string;
+  private lastRefresh = 0;
+
+  constructor(cwd: string) {
+    this.cwd = cwd;
+    this.baseDir = findGitRoot(cwd) ?? cwd;
+  }
+
+  async refresh(): Promise<void> {
+    this.files = collectFiles(this.cwd);
+    this.lastRefresh = Date.now();
+  }
+
+  updateCwd(cwd: string): void {
+    if (cwd !== this.cwd) {
+      this.cwd = cwd;
+      this.baseDir = findGitRoot(cwd) ?? cwd;
+      this.lastRefresh = 0;
+    }
+  }
+
+  private async ensureFresh(): Promise<void> {
+    if (Date.now() - this.lastRefresh > REFRESH_TTL_MS) {
+      await this.refresh();
+    }
+  }
+
+  async match(query: string, maxResults = 10): Promise<string[]> {
+    await this.ensureFresh();
+    if (!query) return this.files.slice(0, maxResults);
+
+    const scored: { path: string; score: number }[] = [];
+    for (const f of this.files) {
+      const s = scoreMatch(f, query);
+      if (s >= 0) scored.push({ path: f, score: s });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, maxResults).map((s) => s.path);
+  }
+
+  get size(): number {
+    return this.files.length;
+  }
+
+  resolvePath(filePath: string): string {
+    return resolve(this.baseDir, filePath);
+  }
+}

package/src/utils/git-root.ts

@@ -0,0 +1,17 @@
+import fs from "fs";
+import path from "path";
+
+export function findGitRoot(start: string): string | null {
+  let current = start;
+
+  while (true) {
+    const gitPath = path.join(current, ".git");
+    if (fs.existsSync(gitPath)) {
+      return current;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}

package/src/utils/host-clipboard.ts

@@ -0,0 +1,30 @@
+import { spawnSync } from "node:child_process";
+import os from "node:os";
+
+/**
+ * Put plain text on the OS clipboard (OpenCode-style fallback when OSC 52 is not enough).
+ */
+export function copyTextToHostClipboard(text: string): void {
+  const platform = os.platform();
+
+  if (platform === "darwin") {
+    const r = spawnSync("pbcopy", [], { input: text });
+    if (r.status === 0) return;
+  }
+
+  if (platform === "linux") {
+    if (process.env.WAYLAND_DISPLAY) {
+      const w = spawnSync("wl-copy", [], { input: text });
+      if (w.status === 0) return;
+    }
+    const x = spawnSync("xclip", ["-selection", "clipboard"], { input: text });
+    if (x.status === 0) return;
+    const s = spawnSync("xsel", ["--clipboard", "--input"], { input: text });
+    if (s.status === 0) return;
+  }
+
+  if (platform === "win32") {
+    const clip = spawnSync("clip", [], { input: text });
+    if (clip.status === 0) return;
+  }
+}

package/src/utils/install-manager.test.ts

@@ -0,0 +1,167 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  buildScriptUninstallPlan,
+  getInstallMetadataPath,
+  getReleaseTargetForPlatform,
+  getScriptInstallContext,
+  getScriptInstallDir,
+  loadScriptInstallMetadata,
+  parseChecksumsFile,
+  saveScriptInstallMetadata,
+} from "./install-manager";
+
+let tempDirs: string[] = [];
+
+afterEach(() => {
+  for (const dir of tempDirs) fs.rmSync(dir, { recursive: true, force: true });
+  tempDirs = [];
+});
+
+function createTempDir(prefix: string): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+}
+
+describe("getReleaseTargetForPlatform", () => {
+  it("maps supported platforms to release asset names", () => {
+    expect(getReleaseTargetForPlatform("darwin", "arm64")?.assetName).toBe("muonroi-cli-darwin-arm64");
+    expect(getReleaseTargetForPlatform("darwin", "x64")?.assetName).toBe("muonroi-cli-darwin-arm64");
+    expect(getReleaseTargetForPlatform("linux", "x64")?.assetName).toBe("muonroi-cli-linux-x64");
+    expect(getReleaseTargetForPlatform("win32", "x64")?.assetName).toBe("muonroi-cli-windows-x64.exe");
+    expect(getReleaseTargetForPlatform("linux", "arm64")).toBeNull();
+  });
+});
+
+describe("parseChecksumsFile", () => {
+  it("parses standard and BSD-style checksum entries", () => {
+    const checksums = parseChecksumsFile(
+      [
+        "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa  muonroi-cli-darwin-arm64",
+        "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb *muonroi-cli-windows-x64.exe",
+      ].join("\n"),
+    );
+    expect(checksums.get("muonroi-cli-darwin-arm64")).toBe(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+    );
+    expect(checksums.get("muonroi-cli-windows-x64.exe")).toBe(
+      "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+    );
+  });
+});
+
+describe("script install metadata", () => {
+  it("round-trips metadata through write and load", () => {
+    const homeDir = createTempDir("muonroi-cli-meta-");
+    const installDir = getScriptInstallDir(homeDir);
+    const metadata = {
+      schemaVersion: 1,
+      installMethod: "script" as const,
+      version: "1.2.3",
+      repo: "muonroi/muonroi-cli",
+      binaryPath: path.join(installDir, "muonroi-cli"),
+      installDir,
+      assetName: "muonroi-cli-darwin-arm64",
+      target: "darwin-arm64" as const,
+      installedAt: "2026-04-03T00:00:00.000Z",
+      shellConfigPath: path.join(homeDir, ".zshrc"),
+      pathCommand: `export PATH=${installDir}:$PATH`,
+    };
+
+    saveScriptInstallMetadata(metadata, homeDir);
+    expect(loadScriptInstallMetadata(homeDir)).toEqual(metadata);
+    expect(fs.existsSync(getInstallMetadataPath(homeDir))).toBe(true);
+  });
+
+  it("returns null when no metadata file exists", () => {
+    expect(loadScriptInstallMetadata(createTempDir("muonroi-cli-empty-"))).toBeNull();
+  });
+});
+
+describe("getScriptInstallContext", () => {
+  it("returns context when metadata exists", () => {
+    const homeDir = createTempDir("muonroi-cli-ctx-");
+    const installDir = getScriptInstallDir(homeDir);
+    const currentTarget = getReleaseTargetForPlatform();
+    expect(currentTarget).not.toBeNull();
+
+    saveScriptInstallMetadata(
+      {
+        schemaVersion: 1,
+        installMethod: "script" as const,
+        version: "1.2.3",
+        repo: "muonroi/muonroi-cli",
+        binaryPath: path.join(installDir, currentTarget!.binaryName),
+        installDir,
+        assetName: currentTarget!.assetName,
+        target: currentTarget!.key,
+        installedAt: "2026-04-03T00:00:00.000Z",
+      },
+      homeDir,
+    );
+
+    const ctx = getScriptInstallContext(homeDir);
+    expect(ctx?.metadata.installMethod).toBe("script");
+    expect(ctx?.binaryPath).toBe(path.join(installDir, currentTarget!.binaryName));
+  });
+
+  it("returns null when no metadata exists", () => {
+    expect(getScriptInstallContext(createTempDir("muonroi-cli-no-ctx-"))).toBeNull();
+  });
+});
+
+describe("buildScriptUninstallPlan", () => {
+  it("removes the full ~/.muonroi-cli directory by default", () => {
+    const homeDir = createTempDir("muonroi-cli-uninstall-");
+    const installDir = getScriptInstallDir(homeDir);
+    const currentTarget = getReleaseTargetForPlatform()!;
+    fs.mkdirSync(installDir, { recursive: true });
+
+    saveScriptInstallMetadata(
+      {
+        schemaVersion: 1,
+        installMethod: "script" as const,
+        version: "1.2.3",
+        repo: "muonroi/muonroi-cli",
+        binaryPath: path.join(installDir, currentTarget.binaryName),
+        installDir,
+        assetName: currentTarget.assetName,
+        target: currentTarget.key,
+        installedAt: "2026-04-03T00:00:00.000Z",
+      },
+      homeDir,
+    );
+
+    const plan = buildScriptUninstallPlan({}, homeDir);
+    expect(plan?.removePaths).toContain(path.join(homeDir, ".muonroi-cli"));
+  });
+
+  it("keeps config and data when requested", () => {
+    const homeDir = createTempDir("muonroi-cli-keep-");
+    const installDir = getScriptInstallDir(homeDir);
+    const currentTarget = getReleaseTargetForPlatform()!;
+    fs.mkdirSync(installDir, { recursive: true });
+
+    saveScriptInstallMetadata(
+      {
+        schemaVersion: 1,
+        installMethod: "script" as const,
+        version: "1.2.3",
+        repo: "muonroi/muonroi-cli",
+        binaryPath: path.join(installDir, currentTarget.binaryName),
+        installDir,
+        assetName: currentTarget.assetName,
+        target: currentTarget.key,
+        installedAt: "2026-04-03T00:00:00.000Z",
+      },
+      homeDir,
+    );
+
+    const plan = buildScriptUninstallPlan({ keepConfig: true, keepData: true }, homeDir);
+    expect(plan?.removePaths).not.toContain(path.join(homeDir, ".muonroi-cli"));
+    expect(plan?.removePaths).toContain(path.join(installDir, currentTarget.binaryName));
+  });
+});