@standardagents/code 0.0.2-dev.b3cdaaf → 0.1.1

package/src/markdown.ts

@@ -1,226 +0,0 @@
-/**
- * A light-touch Markdown → ANSI formatter for the transcript. Deliberately not a
- * full Markdown engine: it adds color/emphasis hints (bold, inline code,
- * headings, links), tidy list bullets, basic aligned tables, and fenced code
- * gutters — enough to make agent replies readable without fighting the terminal.
- * Zero dependencies; returns an array of ready-to-print lines.
- */
-
-const ESC = "\x1b[";
-const R = ESC + "0m";
-const BOLD = ESC + "1m";
-const DIM = ESC + "2m";
-const ITAL = ESC + "3m";
-const UNDER = ESC + "4m";
-const TEAL = ESC + "38;5;37m";
-const CYAN = ESC + "36m";
-const GRAY = ESC + "90m";
-
-/** Visible width of a string, ignoring ANSI SGR sequences. */
-// eslint-disable-next-line no-control-regex
-const ANSI = /\x1b\[[0-9;]*m/g;
-function visibleWidth(s: string): number {
-  return s.replace(ANSI, "").length;
-}
-function padEndVisible(s: string, width: number): string {
-  const pad = width - visibleWidth(s);
-  return pad > 0 ? s + " ".repeat(pad) : s;
-}
-
-/** Apply inline emphasis: code spans, links, bold, italic, strikethrough. */
-function inline(s: string): string {
-  // Protect inline code first so its contents aren't re-formatted. NUL sentinels
-  // never appear in real text, so they can't collide with digits in the prose.
-  const codes: string[] = [];
-  s = s.replace(/`([^`]+)`/g, (_, code) => {
-    codes.push(code);
-    return "\x00" + (codes.length - 1) + "\x00";
-  });
-  // Links: [text](url) → underlined text + dim url.
-  s = s.replace(
-    /\[([^\]]+)\]\(([^)\s]+)\)/g,
-    (_, text, url) => `${CYAN}${UNDER}${text}${R} ${DIM}${url}${R}`
-  );
-  // Bold then italic (asterisk forms only — underscores are common in code/ids).
-  s = s.replace(/\*\*([^*]+)\*\*/g, (_, t) => `${BOLD}${t}${R}`);
-  s = s.replace(/\*([^*\n]+)\*/g, (_, t) => `${ITAL}${t}${R}`);
-  s = s.replace(/~~([^~]+)~~/g, (_, t) => `${DIM}${t}${R}`);
-  // Restore code spans in teal. Spaces inside a code span become non-breaking
-  // (NBSP) so word-wrapping never splits a command/path like `curl | bash`.
-  // eslint-disable-next-line no-control-regex
-  s = s.replace(/\x00(\d+)\x00/g, (_, i) => `${TEAL}${codes[+i].replace(/ /g, String.fromCharCode(160))}${R}`);
-  return s;
-}
-
-/**
- * Word-wrap styled text to a visible width. ANSI-aware (escape sequences don't
- * count toward width), splits only on regular spaces (so NBSP-protected code
- * spans stay intact). A single word longer than the width is left to overflow
- * rather than split mid-token.
- */
-function wrapStyled(text: string, width: number): string[] {
-  if (width < 4 || visibleWidth(text) <= width) return [text];
-  const words = text.split(" ");
-  const lines: string[] = [];
-  let cur = "";
-  let curLen = 0;
-  for (const w of words) {
-    const wLen = visibleWidth(w);
-    if (cur === "") {
-      cur = w;
-      curLen = wLen;
-    } else if (curLen + 1 + wLen <= width) {
-      cur += " " + w;
-      curLen += 1 + wLen;
-    } else {
-      lines.push(cur);
-      cur = w;
-      curLen = wLen;
-    }
-  }
-  if (cur !== "" || lines.length === 0) lines.push(cur);
-  return lines;
-}
-
-/**
- * Emit a block (paragraph/list item/quote) word-wrapped to `cols`, with a lead
- * on the first line and an aligned hanging indent of the same visible width on
- * the rest. `leadWidth` is the visible width of both leads.
- */
-function wrapBlock(
-  out: string[],
-  cols: number,
-  leadFirst: string,
-  leadRest: string,
-  leadWidth: number,
-  text: string
-): void {
-  const wrapped = wrapStyled(text, Math.max(8, cols - leadWidth));
-  wrapped.forEach((ln, idx) => out.push((idx === 0 ? leadFirst : leadRest) + ln));
-}
-
-/** Split a table row "| a | b |" into trimmed cells. */
-function tableCells(row: string): string[] {
-  let r = row.trim();
-  if (r.startsWith("|")) r = r.slice(1);
-  if (r.endsWith("|")) r = r.slice(0, -1);
-  return r.split("|").map((c) => c.trim());
-}
-
-const SEPARATOR = /^[\s|:-]+$/;
-function isTableSeparator(line: string): boolean {
-  return SEPARATOR.test(line) && line.includes("-") && line.includes("|");
-}
-
-/** Render a collected table block (header row + body rows) as aligned columns. */
-function renderTable(rows: string[][]): string[] {
-  const cols = Math.max(...rows.map((r) => r.length));
-  const widths: number[] = [];
-  for (let c = 0; c < cols; c++) {
-    widths[c] = Math.max(...rows.map((r) => visibleWidth(inline(r[c] ?? ""))));
-  }
-  const sep = `${GRAY} │ ${R}`;
-  const out: string[] = [];
-  rows.forEach((r, ri) => {
-    const cells = [];
-    for (let c = 0; c < cols; c++) {
-      const raw = r[c] ?? "";
-      const styled = ri === 0 ? `${BOLD}${inline(raw)}${R}` : inline(raw);
-      cells.push(padEndVisible(styled, widths[c]));
-    }
-    out.push(("  " + cells.join(sep)).replace(/\s+$/, ""));
-    if (ri === 0) {
-      // A thin underline beneath the header row.
-      const rule = widths.map((w) => `${GRAY}${"─".repeat(w)}${R}`).join(`${GRAY}─┼─${R}`);
-      out.push("  " + rule);
-    }
-  });
-  return out;
-}
-
-/** Format Markdown source into an array of ANSI-styled, word-wrapped terminal lines. */
-export function renderMarkdown(src: string, cols = 80): string[] {
-  const lines = src.replace(/\r\n/g, "\n").split("\n");
-  const out: string[] = [];
-  let inFence = false;
-  let i = 0;
-
-  while (i < lines.length) {
-    const line = lines[i];
-
-    // Fenced code block: render with a dim gutter, no inline formatting.
-    if (/^\s*```/.test(line)) {
-      inFence = !inFence;
-      i++;
-      continue;
-    }
-    if (inFence) {
-      out.push(`${GRAY}│${R} ${line}`);
-      i++;
-      continue;
-    }
-
-    // Table: a row containing "|" immediately followed by a separator row.
-    if (line.includes("|") && i + 1 < lines.length && isTableSeparator(lines[i + 1])) {
-      const block: string[][] = [tableCells(line)];
-      i += 2; // skip header + separator
-      while (i < lines.length && lines[i].includes("|") && lines[i].trim()) {
-        block.push(tableCells(lines[i]));
-        i++;
-      }
-      out.push(...renderTable(block));
-      continue;
-    }
-
-    // Heading.
-    const heading = line.match(/^(#{1,6})\s+(.*)$/);
-    if (heading) {
-      for (const ln of wrapStyled(heading[2].trim(), cols)) out.push(`${BOLD}${TEAL}${ln}${R}`);
-      i++;
-      continue;
-    }
-
-    // Horizontal rule → a short, subtle divider (never full width).
-    if (/^\s*([-*_])(\s*\1){2,}\s*$/.test(line)) {
-      out.push(`${GRAY}──────${R}`);
-      i++;
-      continue;
-    }
-
-    // Blockquote.
-    const quote = line.match(/^\s*>\s?(.*)$/);
-    if (quote) {
-      for (const ln of wrapStyled(inline(quote[1]), Math.max(8, cols - 2))) {
-        out.push(`${GRAY}│${R} ${DIM}${ln}${R}`);
-      }
-      i++;
-      continue;
-    }
-
-    // Bullet list (-, *, +) with indentation preserved; continuation hangs under the text.
-    const bullet = line.match(/^(\s*)[-*+]\s+(.*)$/);
-    if (bullet) {
-      const leadWidth = bullet[1].length + 2;
-      wrapBlock(out, cols, `${bullet[1]}${TEAL}•${R} `, " ".repeat(leadWidth), leadWidth, inline(bullet[2]));
-      i++;
-      continue;
-    }
-
-    // Numbered list — keep the number, embolden the marker.
-    const numbered = line.match(/^(\s*)(\d+)([.)])\s+(.*)$/);
-    if (numbered) {
-      const marker = `${numbered[2]}${numbered[3]}`;
-      const leadWidth = numbered[1].length + marker.length + 1;
-      wrapBlock(out, cols, `${numbered[1]}${BOLD}${marker}${R} `, " ".repeat(leadWidth), leadWidth, inline(numbered[4]));
-      i++;
-      continue;
-    }
-
-    // Plain paragraph line (blank lines pass through as spacing).
-    if (line.trim()) wrapBlock(out, cols, "", "", 0, inline(line));
-    else out.push("");
-    i++;
-  }
-
-  return out;
-}

package/src/mcp-config.ts

@@ -1,137 +0,0 @@
-/**
- * MCP server configuration — the list of Model Context Protocol servers this
- * CLI can launch locally and negotiate with. Stored in `~/.standardagents/mcp.json`
- * so it persists across sessions and machines (per-user, not per-thread).
- *
- * Each server is a local process the CLI spawns and speaks JSON-RPC 2.0 to over
- * stdio (see `mcp.ts`). The CLI is the MCP *host*: it owns the connection, does
- * the capability handshake, and forwards the agent's tool calls to the server.
- */
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-
-const DIR = path.join(os.homedir(), ".standardagents");
-const FILE = path.join(DIR, "mcp.json");
-
-/** A locally-launchable MCP server (stdio transport). */
-export interface McpServerConfig {
-  /** Stable, human-readable id (used to namespace tools, e.g. `mcp:<name>/<tool>`). */
-  name: string;
-  /** Executable to spawn (e.g. `node`, `npx`, `uvx`, an absolute path). */
-  command: string;
-  /** Arguments passed to the command. */
-  args: string[];
-  /** Extra environment variables for the server process (merged over the CLI's env). */
-  env?: Record<string, string>;
-  /** Working directory for the server process (defaults to the project dir). */
-  cwd?: string;
-  /** When false, the server is remembered but not connected on startup. */
-  enabled: boolean;
-}
-
-export interface McpConfigFile {
-  servers: Record<string, McpServerConfig>;
-}
-
-export function loadMcpConfig(): McpConfigFile {
-  try {
-    const raw = fs.readFileSync(FILE, "utf8");
-    const parsed = JSON.parse(raw) as McpConfigFile;
-    if (!parsed.servers || typeof parsed.servers !== "object") parsed.servers = {};
-    return parsed;
-  } catch {
-    return { servers: {} };
-  }
-}
-
-export function listMcpServers(): McpServerConfig[] {
-  const cfg = loadMcpConfig();
-  return Object.values(cfg.servers).sort((a, b) => a.name.localeCompare(b.name));
-}
-
-export function saveMcpServer(server: McpServerConfig): void {
-  const cfg = loadMcpConfig();
-  cfg.servers[server.name] = server;
-  write(cfg);
-}
-
-export function removeMcpServer(name: string): void {
-  const cfg = loadMcpConfig();
-  delete cfg.servers[name];
-  write(cfg);
-}
-
-export function setMcpServerEnabled(name: string, enabled: boolean): void {
-  const cfg = loadMcpConfig();
-  const s = cfg.servers[name];
-  if (!s) return;
-  s.enabled = enabled;
-  write(cfg);
-}
-
-function write(cfg: McpConfigFile): void {
-  fs.mkdirSync(DIR, { recursive: true });
-  fs.writeFileSync(FILE, JSON.stringify(cfg, null, 2), { mode: 0o600 });
-}
-
-/**
- * Parse a server definition from a CLI-style command string, e.g.
- *   `weather: npx -y @modelcontextprotocol/server-weather`
- * The part before the first `:` is the server name; the rest is the command +
- * args. Returns null if the shape is unusable.
- */
-export function parseServerSpec(spec: string): McpServerConfig | null {
-  const trimmed = spec.trim();
-  const colon = trimmed.indexOf(":");
-  if (colon <= 0) return null;
-  const name = trimmed.slice(0, colon).trim();
-  const rest = trimmed.slice(colon + 1).trim();
-  if (!name || !rest) return null;
-  const parts = tokenize(rest);
-  if (!parts.length) return null;
-  const [command, ...args] = parts;
-  return { name, command, args, enabled: true };
-}
-
-/**
- * Build a server config from a short name + a full command line, e.g.
- *   serverFromCommand("playwright", "npx -y @playwright/mcp@latest")
- * Returns null if the name or command is unusable.
- */
-export function serverFromCommand(
-  name: string,
-  commandLine: string,
-  env?: Record<string, string>
-): McpServerConfig | null {
-  const cleanName = name.trim();
-  const parts = tokenize(commandLine.trim());
-  if (!cleanName || !parts.length) return null;
-  const [command, ...args] = parts;
-  return { name: cleanName, command, args, env, enabled: true };
-}
-
-/** Minimal shell-ish tokenizer that honours single/double quotes (no expansion). */
-function tokenize(input: string): string[] {
-  const out: string[] = [];
-  let cur = "";
-  let quote: '"' | "'" | null = null;
-  for (let i = 0; i < input.length; i++) {
-    const ch = input[i];
-    if (quote) {
-      if (ch === quote) quote = null;
-      else cur += ch;
-    } else if (ch === '"' || ch === "'") {
-      quote = ch;
-    } else if (/\s/.test(ch)) {
-      if (cur) {
-        out.push(cur);
-        cur = "";
-      }
-    } else {
-      cur += ch;
-    }
-  }
-  if (cur) out.push(cur);
-  return out;
-}