tinker-agent 1.0.65 → 1.2.0

package/node_modules/markdansi/README.md

@@ -0,0 +1,167 @@
+# 🎨 Markdansi: Wraps, colors, links—no baggage.
+
+<p align="center">
+  <img src="./markdansi.png" alt="Markdansi README header" width="1100">
+</p>
+
+![npm](https://img.shields.io/npm/v/markdansi) ![license MIT](https://img.shields.io/badge/license-MIT-blue.svg) ![node >=22](https://img.shields.io/badge/node-%3E%3D22-brightgreen) ![tests vitest](https://img.shields.io/badge/tests-vitest-blue?logo=vitest)
+
+Tiny, dependency-light Markdown → ANSI renderer and CLI for modern Node (>=22). Focuses on readable terminal output with sensible wrapping, GFM support (tables, task lists, strikethrough), optional OSC‑8 hyperlinks, and zero built‑in syntax highlighting (pluggable hook). Written in TypeScript, ships ESM.
+
+Published on npm as `markdansi`.
+
+## Install
+
+Grab it from npm; no native deps, so install is instant on Node 22+.
+
+```bash
+bun add markdansi
+# or
+pnpm add markdansi
+# or
+npm install markdansi
+```
+
+## CLI
+
+Quick one-shot renderer: pipe Markdown in, ANSI comes out. Flags let you pick width, wrap, colors, links, and table/list styling.
+
+```bash
+markdansi [FILE] [--in FILE] [--out FILE] [--width N] [--no-wrap] [--no-color] [--no-links] [--theme default|dim|bright]
+[--list-indent N] [--quote-prefix STR]
+```
+
+- Input: positional `FILE`, `--in FILE`, or stdin when neither is given (use `--in -` for stdin explicitly).
+- Output: stdout unless `--out` provided.
+- Wrapping: on by default; `--no-wrap` disables hard wrapping.
+- Links: OSC‑8 when supported; `--no-links` disables.
+- Lists/quotes: `--list-indent` sets spaces per nesting level (default 2); `--quote-prefix` sets blockquote prefix (default `│ `).
+
+## Library
+
+Use the renderer directly in Node/TS for customizable theming, optional syntax highlighting hooks, and OSC‑8 link control.
+
+### ESM / CommonJS
+
+Markdansi ships ESM (`"type":"module"`). If you’re in CommonJS (or a tool like `tsx` running your script as CJS), prefer dynamic import:
+
+```js
+const { render } = await import("markdansi");
+console.log(render("# hello"));
+```
+
+### Streaming (recommended: hybrid blocks)
+
+If you’re streaming Markdown (LLM output), keep scrollback safe by emitting **completed fragments only**
+and writing them once (append-only; no in-place redraw).
+
+Hybrid mode streams regular lines as they complete, but buffers multi-line constructs that need context:
+
+- Fenced code blocks (``` / ~~~) — flushed only after the closing fence
+- Tables — flushed only after the header separator row + until the table ends
+
+```js
+import { createMarkdownStreamer, render } from "markdansi";
+
+const streamer = createMarkdownStreamer({
+  render: (md) => render(md, { width: process.stdout.columns ?? 80 }),
+  spacing: "single", // collapse consecutive blank lines
+});
+
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (delta) => {
+  const chunk = streamer.push(delta);
+  if (chunk) process.stdout.write(chunk);
+});
+process.stdin.on("end", () => {
+  const tail = streamer.finish();
+  if (tail) process.stdout.write(tail);
+});
+```
+
+````js
+import { render, createRenderer, strip, themes } from "markdansi";
+
+const ansi = render("# Hello **world**", { width: 60 });
+
+const renderNoWrap = createRenderer({ wrap: false });
+const out = renderNoWrap("A very long line...");
+
+// Plain text (no ANSI/OSC)
+const plain = strip("link to [x](https://example.com)");
+
+// Custom theme and highlighter hook
+const custom = createRenderer({
+  theme: {
+    ...themes.default,
+    code: { color: "cyan", dim: true }, // fallback used for inline/block
+    inlineCode: { color: "red" },
+    blockCode: { color: "green" },
+  },
+  highlighter: (code, lang) => code.toUpperCase(),
+});
+console.log(custom("`inline`\n\n```\nblock code\n```"));
+
+// Example: real syntax highlighting with Shiki (TS + Swift)
+import { bundledLanguages, bundledThemes, createHighlighter } from "shiki";
+
+const shiki = await createHighlighter({
+  themes: [bundledThemes["github-dark"]],
+  langs: [bundledLanguages.typescript, bundledLanguages.swift],
+});
+
+const highlighted = createRenderer({
+  highlighter: (code, lang) => {
+    if (!lang) return code;
+    const normalized = lang.toLowerCase();
+    if (!["ts", "typescript", "swift"].includes(normalized)) return code;
+    const { tokens } = shiki.codeToTokens(code, {
+      lang: normalized === "swift" ? "swift" : "ts",
+      theme: "github-dark",
+    });
+    return tokens
+      .map((line) =>
+        line
+          .map((token) =>
+            token.color
+              ? `\u001b[38;2;${parseInt(token.color.slice(1, 3), 16)};${parseInt(
+                  token.color.slice(3, 5),
+                  16,
+                )};${parseInt(token.color.slice(5, 7), 16)}m${token.content}\u001b[39m`
+              : token.content,
+          )
+          .join(""),
+      )
+      .join("\n");
+  },
+});
+console.log(highlighted("```ts\nconst x: number = 1\n```\n```swift\nlet x = 1\n```"));
+````
+
+### Options
+
+- `wrap` (default `true`): if `false`, no hard wrapping anywhere.
+- `width`: used only when `wrap===true`; default TTY columns or 80.
+- `color` (default TTY): `false` removes all ANSI/OSC.
+- `hyperlinks` (default auto): enable/disable OSC‑8 links.
+- `theme`: `default | dim | bright | solarized | monochrome | contrast` or custom theme object.
+- `listIndent`: spaces per nesting level (default 2).
+- `quotePrefix`: blockquote line prefix (default `│ `).
+- `tableBorder`: `unicode` (default) | `ascii` | `none`.
+- `tablePadding`: spaces inside cells (default 1); `tableDense` drops extra separators.
+- `tableTruncate`: cap cells to column width (default `true`, ellipsis `…`).
+- `codeBox`: draw a box around fenced code (default true); `codeGutter` shows line numbers; `codeWrap` wraps code lines by default.
+- `highlighter(code, lang)`: optional hook to recolor code blocks; must not add/remove newlines.
+
+## Notes
+
+- Code blocks wrap to the render width by default; disable with `codeWrap=false`. If `lang` is present, a faint `[lang]` label is shown and boxes use unicode borders.
+- Link/reference definitions that spill their titles onto indented lines are merged back into one line so copied notes don’t turn into boxed code.
+- Tables use unicode borders by default, include padding, respect GFM alignment, and truncate long cells with `…` so layouts stay tidy. Turn off truncation with `tableTruncate=false`.
+- Tight vs loose lists follow GFM; task items render `[ ]` / `[x]`.
+
+See [`docs/spec.md`](docs/spec.md) for full behavior details.
+
+Looking for the Swift port? Check out [Swiftdansi](https://github.com/steipete/Swiftdansi).
+
+MIT license.

package/node_modules/markdansi/dist/ast.d.ts

@@ -0,0 +1,99 @@
+export type Position = unknown;
+type Node = {
+    type: string;
+    position?: Position;
+};
+export type Text = Node & {
+    type: "text";
+    value: string;
+};
+export type Emphasis = Node & {
+    type: "emphasis";
+    children: InlineNode[];
+};
+export type Strong = Node & {
+    type: "strong";
+    children: InlineNode[];
+};
+export type Delete = Node & {
+    type: "delete";
+    children: InlineNode[];
+};
+export type InlineCode = Node & {
+    type: "inlineCode";
+    value: string;
+};
+export type Link = Node & {
+    type: "link";
+    url: string;
+    title?: string | null | undefined;
+    children: InlineNode[];
+};
+export type Break = Node & {
+    type: "break";
+};
+export type Html = Node & {
+    type: "html";
+    value: string;
+};
+export type InlineNode = Text | Emphasis | Strong | Delete | InlineCode | Link | Break | Html;
+export type Paragraph = Node & {
+    type: "paragraph";
+    children: InlineNode[];
+};
+export type Heading = Node & {
+    type: "heading";
+    depth: number;
+    children: InlineNode[];
+};
+export type ThematicBreak = Node & {
+    type: "thematicBreak";
+};
+export type Blockquote = Node & {
+    type: "blockquote";
+    children: BlockNode[];
+};
+export type List = Node & {
+    type: "list";
+    ordered?: boolean | undefined;
+    start?: number | null | undefined;
+    spread?: boolean | undefined;
+    children: ListItem[];
+};
+export type ListItem = Node & {
+    type: "listItem";
+    checked?: boolean | null | undefined;
+    spread?: boolean | undefined;
+    children: BlockNode[];
+};
+export type Code = Node & {
+    type: "code";
+    value: string;
+    lang?: string | null | undefined;
+    meta?: string | null | undefined;
+};
+export type TableCell = Node & {
+    type: "tableCell";
+    children: InlineNode[];
+};
+export type TableRow = Node & {
+    type: "tableRow";
+    children: TableCell[];
+};
+export type Table = Node & {
+    type: "table";
+    align?: Array<"left" | "right" | "center" | null> | undefined;
+    children: TableRow[];
+};
+export type Definition = Node & {
+    type: "definition";
+    identifier: string;
+    url?: string | undefined;
+    title?: string | null | undefined;
+};
+export type BlockNode = Paragraph | Heading | ThematicBreak | Blockquote | List | ListItem | Code | Table | Definition;
+export type Root = Node & {
+    type: "root";
+    children: BlockNode[];
+};
+export {};

package/node_modules/markdansi/dist/ast.js

@@ -0,0 +1 @@
+export {};

package/node_modules/markdansi/dist/cli.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import type { RenderOptions } from "./types.js";
+type CliArgs = Partial<RenderOptions> & {
+    in?: string;
+    out?: string;
+    help?: boolean;
+};
+/**
+ * Ignore EPIPE when downstream (e.g., `head`) closes early.
+ */
+export declare function handleStdoutEpipe(): void;
+/**
+ * Parse CLI arguments into RenderOptions-ish object (plus in/out paths).
+ */
+export declare function parseArgs(argv: string[]): CliArgs;
+export declare function isDirectCliInvocation(metaUrl: string, argv1?: string): boolean;
+export {};

package/node_modules/markdansi/dist/cli.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { render } from "./index.js";
+function readOptionValue(argv, index, option, allowLeadingDashes = false) {
+    const value = argv[index + 1];
+    if (value === undefined || (!allowLeadingDashes && value.startsWith("--"))) {
+        throw new Error(`${option} requires a value`);
+    }
+    return value;
+}
+function parseIntegerOption(option, value, minimum) {
+    const parsed = Number(value);
+    if (!/^\d+$/u.test(value) || !Number.isSafeInteger(parsed) || parsed < minimum) {
+        const range = minimum === 0 ? "a non-negative integer" : "a positive integer";
+        throw new Error(`${option} must be ${range}`);
+    }
+    return parsed;
+}
+function parseTheme(value) {
+    if (value === "default" || value === "dim" || value === "bright")
+        return value;
+    throw new Error("--theme must be default, dim, or bright");
+}
+function parseTableBorder(value) {
+    if (value === "unicode" || value === "ascii" || value === "none")
+        return value;
+    throw new Error("--table-border must be unicode, ascii, or none");
+}
+/**
+ * Ignore EPIPE when downstream (e.g., `head`) closes early.
+ */
+export function handleStdoutEpipe() {
+    process.stdout.on("error", (err) => {
+        if (err && err.code === "EPIPE") {
+            process.exit(0);
+            return;
+        }
+        // For other stdout errors, fail fast but don't throw unhandled.
+        console.error(err instanceof Error ? err.message : err);
+        process.exit(1);
+    });
+}
+/**
+ * Parse CLI arguments into RenderOptions-ish object (plus in/out paths).
+ */
+export function parseArgs(argv) {
+    const args = {};
+    for (let i = 2; i < argv.length; i += 1) {
+        const a = argv[i];
+        if (!a)
+            continue;
+        if (a === "--no-wrap")
+            args.wrap = false;
+        else if (a === "--no-color")
+            args.color = false;
+        else if (a === "--no-links")
+            args.hyperlinks = false;
+        else if (a === "--code-wrap")
+            args.codeWrap = true;
+        else if (a === "--code-wrap=false")
+            args.codeWrap = false;
+        else if (a === "--code-wrap=true")
+            args.codeWrap = true;
+        else if (a === "--code-box")
+            args.codeBox = true;
+        else if (a === "--code-box=false")
+            args.codeBox = false;
+        else if (a === "--code-box=true")
+            args.codeBox = true;
+        else if (a === "--code-gutter")
+            args.codeGutter = true;
+        else if (a === "--code-gutter=true")
+            args.codeGutter = true;
+        else if (a === "--code-gutter=false")
+            args.codeGutter = false;
+        else if (a.startsWith("--table-border=")) {
+            args.tableBorder = parseTableBorder(a.slice("--table-border=".length));
+        }
+        else if (a === "--table-border") {
+            args.tableBorder = parseTableBorder(readOptionValue(argv, i, a));
+            i += 1;
+        }
+        else if (a === "--table-dense")
+            args.tableDense = true;
+        else if (a === "--table-truncate")
+            args.tableTruncate = true;
+        else if (a === "--table-truncate=false")
+            args.tableTruncate = false;
+        else if (a === "--table-truncate=true")
+            args.tableTruncate = true;
+        else if (a === "--table-padding") {
+            const next = readOptionValue(argv, i, a);
+            args.tablePadding = parseIntegerOption(a, next, 0);
+            i += 1;
+        }
+        else if (a === "--table-ellipsis") {
+            args.tableEllipsis = readOptionValue(argv, i, a, true);
+            i += 1;
+        }
+        else if (a === "--in") {
+            args.in = readOptionValue(argv, i, a, true);
+            i += 1;
+        }
+        else if (a === "--out") {
+            args.out = readOptionValue(argv, i, a, true);
+            i += 1;
+        }
+        else if (a === "--width") {
+            const next = readOptionValue(argv, i, a);
+            args.width = parseIntegerOption(a, next, 1);
+            i += 1;
+        }
+        else if (a.startsWith("--theme=")) {
+            args.theme = parseTheme(a.slice("--theme=".length));
+        }
+        else if (a === "--theme") {
+            args.theme = parseTheme(readOptionValue(argv, i, a));
+            i += 1;
+        }
+        else if (a === "--list-indent") {
+            const next = readOptionValue(argv, i, a);
+            args.listIndent = parseIntegerOption(a, next, 0);
+            i += 1;
+        }
+        else if (a === "--quote-prefix") {
+            args.quotePrefix = readOptionValue(argv, i, a, true);
+            i += 1;
+        }
+        else if (a === "--help" || a === "-h")
+            args.help = true;
+        else if (a.startsWith("-"))
+            throw new Error(`unknown option: ${a}`);
+        else if (!args.in)
+            args.in = a;
+        else
+            throw new Error(`unexpected positional argument: ${a}`);
+    }
+    return args;
+}
+/**
+ * CLI entrypoint.
+ */
+function main() {
+    handleStdoutEpipe();
+    const { in: inputPath, out: outputPath, help, ...renderOptions } = parseArgs(process.argv);
+    if (help) {
+        process.stdout.write(`markdansi [FILE] [options]
+
+  markdansi file.md            Render file
+  markdansi --in file.md       Same (explicit)
+  cat file.md | markdansi      Read from stdin
+
+Options:
+  --in FILE           Input file (default: stdin)
+  --out FILE          Output file (default: stdout)
+  --width N           Wrap width (default: TTY cols or 80)
+  --no-wrap           Disable hard wrapping
+  --no-color          Disable ANSI/OSC output
+  --no-links          Disable OSC-8 hyperlinks
+  --theme NAME        Theme (default|dim|bright)
+  --list-indent N     Spaces per list nesting level (default: 2)
+  --quote-prefix STR  Prefix for blockquotes (default: "│ ")
+  --table-border STR  unicode|ascii|none
+  --table-padding N   Spaces around table cell content
+  --table-dense       Fewer separator rows
+  --table-truncate    Default true; pass --table-truncate=false to disable
+  --table-ellipsis STR  Ellipsis text for truncation
+  --code-wrap[=true|false]   Wrap code lines (default true)
+  --code-box[=true|false]    Box code blocks (default true)
+  --code-gutter[=true|false] Show code line numbers (default false)
+`);
+        process.exit(0);
+    }
+    const input = inputPath && inputPath !== "-"
+        ? fs.readFileSync(path.resolve(inputPath), "utf8")
+        : fs.readFileSync(0, "utf8");
+    const output = render(input, renderOptions);
+    if (outputPath) {
+        fs.writeFileSync(path.resolve(outputPath), output, "utf8");
+    }
+    else {
+        process.stdout.write(output);
+    }
+}
+export function isDirectCliInvocation(metaUrl, argv1) {
+    if (!argv1)
+        return false;
+    try {
+        const entry = fs.realpathSync(argv1);
+        const self = fs.realpathSync(fileURLToPath(metaUrl));
+        return entry === self;
+    }
+    catch {
+        return false;
+    }
+}
+// Only run the CLI when executed directly, not when imported for tests.
+if (isDirectCliInvocation(import.meta.url, process.argv[1])) {
+    try {
+        main();
+    }
+    catch (error) {
+        console.error(`markdansi: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+}

package/node_modules/markdansi/dist/hyperlink.d.ts

@@ -0,0 +1,9 @@
+import type { WriteStream } from "node:tty";
+/**
+ * Detect OSC-8 hyperlink support for a given stream (defaults to stdout).
+ */
+export declare function hyperlinkSupported(stream?: WriteStream): boolean;
+/**
+ * Build an OSC-8 hyperlink sequence.
+ */
+export declare function osc8(url: string, text: string): string;

package/node_modules/markdansi/dist/hyperlink.js

@@ -0,0 +1,26 @@
+import supportsHyperlinks from "supports-hyperlinks";
+/**
+ * Detect OSC-8 hyperlink support for a given stream (defaults to stdout).
+ */
+export function hyperlinkSupported(stream = process.stdout) {
+    const helper = supportsHyperlinks;
+    try {
+        if (typeof supportsHyperlinks === "function") {
+            return Boolean(supportsHyperlinks(stream));
+        }
+        if (helper.stdout)
+            return Boolean(helper.stdout(stream));
+        if (helper.default && typeof helper.default === "function")
+            return Boolean(helper.default(stream));
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+/**
+ * Build an OSC-8 hyperlink sequence.
+ */
+export function osc8(url, text) {
+    return `\u001B]8;;${url}\u0007${text}\u001B]8;;\u0007`;
+}

package/node_modules/markdansi/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { createRenderer, render as renderMarkdown } from "./render.js";
+import { createMarkdownStreamer } from "./stream.js";
+import { themes } from "./theme.js";
+import type { RenderOptions, Theme, ThemeName } from "./types.js";
+export { createMarkdownStreamer, createRenderer, renderMarkdown as render, themes };
+export type { RenderOptions, Theme, ThemeName };
+/**
+ * Render Markdown to plain text (no ANSI, no hyperlinks) while preserving layout/wrapping.
+ */
+export declare function strip(markdown: string, options?: RenderOptions): string;

package/node_modules/markdansi/dist/index.js

@@ -0,0 +1,16 @@
+import { createRenderer, render as renderMarkdown } from "./render.js";
+import { createMarkdownStreamer } from "./stream.js";
+import { themes } from "./theme.js";
+export { createMarkdownStreamer, createRenderer, renderMarkdown as render, themes };
+/**
+ * Render Markdown to plain text (no ANSI, no hyperlinks) while preserving layout/wrapping.
+ */
+export function strip(markdown, options = {}) {
+    return renderMarkdown(markdown, {
+        ...options,
+        color: false,
+        hyperlinks: false,
+        // ensure flags like codeWrap/tableTruncate not lost
+        wrap: options.wrap ?? true,
+    });
+}

package/node_modules/markdansi/dist/parser.d.ts

@@ -0,0 +1,2 @@
+import type { Root } from "./ast.js";
+export declare function parse(markdown: string): Root;