@esso0428/pi-subagents 0.15.5 → 0.15.7

package/test/ui/conversation-viewer.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, it, vi } from "vitest";
+import { ConversationViewer, createStaticConversationSource } from "../../src/ui/conversation-viewer.js";
+
+const theme = {
+  fg: (name: string, text: string) => name === "text" ? `\x1b[36m${text}\x1b[39m` : text,
+  bold: (text: string) => `\x1b[1m${text}\x1b[22m`,
+};
+
+function record(extra: Record<string, unknown> = {}): any {
+  return {
+    id: "agent-1",
+    type: "general-purpose",
+    description: "test agent",
+    status: "completed",
+    toolUses: 0,
+    startedAt: 0,
+    lifetimeUsage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    ...extra,
+  };
+}
+
+function tui() {
+  return {
+    terminal: { rows: 30 },
+    requestRender: vi.fn(),
+    stop: vi.fn(),
+    start: vi.fn(),
+  } as any;
+}
+
+describe("ConversationViewer", () => {
+  it("renders assistant fenced code through the Markdown renderer", () => {
+    const ui = tui();
+    const viewer = new ConversationViewer(
+      ui,
+      createStaticConversationSource([
+        { role: "assistant", content: [{ type: "text", text: "```ts\nconst answer: number = 42;\n```" }] },
+      ] as any),
+      record(),
+      undefined,
+      theme,
+      vi.fn(),
+    );
+
+    const rendered = viewer.render(100).join("\n");
+    expect(rendered).toContain("answer");
+    expect(rendered).toMatch(/\x1b\[/);
+  });
+
+  it("toggles compact tool rows without changing the transcript", () => {
+    const ui = tui();
+    const viewer = new ConversationViewer(
+      ui,
+      createStaticConversationSource([
+        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "src/index.ts" } }] },
+        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "contents" }] },
+      ] as any),
+      record(),
+      undefined,
+      theme,
+      vi.fn(),
+    );
+
+    expect(viewer.render(100).join("\n")).toContain("read");
+    viewer.handleInput("t");
+    expect(viewer.render(100).join("\n")).not.toContain("contents");
+    viewer.handleInput("t");
+    expect(viewer.render(100).join("\n")).toContain("contents");
+  });
+
+  it("shows pi-peek hints for live viewers and hides O in history", () => {
+    const live = new ConversationViewer(
+      tui(),
+      createStaticConversationSource([{ role: "assistant", content: "live" }] as any),
+      record({ status: "running", session: {} }),
+      undefined,
+      theme,
+      vi.fn(),
+      vi.fn(),
+      undefined,
+      vi.fn(),
+      { pi: {} as any, ctx: {} as any, readOnly: false },
+    );
+    const liveFooter = live.render(120).join("\n");
+    expect(liveFooter).toContain("j/k · J/K · g/G   t   M o O   /n N   q");
+    expect(liveFooter).toContain("Enter steer");
+    expect(liveFooter).toContain("x stop");
+
+    const history = new ConversationViewer(
+      tui(),
+      createStaticConversationSource([{ role: "assistant", content: "history" }] as any),
+      record({ session: {} }),
+      undefined,
+      theme,
+      vi.fn(),
+      undefined,
+      undefined,
+      undefined,
+      { pi: {} as any, ctx: {} as any, readOnly: true },
+    );
+    const historyFooter = history.render(120).join("\n");
+    expect(historyFooter).toContain("j/k · J/K · g/G   t   M o   /n N   q");
+    expect(historyFooter).not.toContain("M o O");
+  });
+
+  it("shows semantic role headers, effective invocation metadata, and the search row", () => {
+    const semanticTheme = {
+      fg: (name: string, text: string) => `<${name}>${text}</${name}>`,
+      bold: (text: string) => `<bold>${text}</bold>`,
+    };
+    const viewer = new ConversationViewer(
+      tui(),
+      createStaticConversationSource([
+        { role: "user", content: "find model" },
+        { role: "assistant", content: [{ type: "text", text: "model found" }] },
+      ] as any),
+      record({ invocation: { effectiveModelName: "claude-sonnet", effectiveThinking: "high" } }),
+      undefined,
+      semanticTheme,
+      vi.fn(),
+    );
+
+    const initial = viewer.render(120).join("\n");
+    expect(initial).toContain("<userMessageText>USER</userMessageText>");
+    expect(initial).toContain("<accent>ASSISTANT</accent>");
+    expect(initial).toContain("model: claude-sonnet");
+    expect(initial).toContain("thinking: high");
+
+    viewer.handleInput("/");
+    const searchRow = viewer.render(120).join("\n");
+    expect(searchRow).toContain("<accent>/</accent>");
+    expect(searchRow).toContain("Enter apply · Esc cancel");
+    for (const character of "model") viewer.handleInput(character);
+    expect(viewer.render(120).join("\n")).toContain("model");
+  });
+
+  it("focuses and expands a bounded fallback tool card", () => {
+    const viewer = new ConversationViewer(
+      tui(),
+      createStaticConversationSource([
+        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "x" } }] },
+        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "one\ntwo\nthree\nfour\nfive\nsix" }] },
+      ] as any),
+      record(),
+      undefined,
+      theme,
+      vi.fn(),
+    );
+
+    expect(viewer.render(120).join("\n")).not.toContain("six");
+    viewer.handleInput("\t");
+    viewer.handleInput("\r");
+    expect(viewer.render(120).join("\n")).toContain("six");
+  });
+
+  it("keeps historical viewers read-only and closes on Escape", () => {
+    const ui = tui();
+    const steer = vi.fn();
+    const stop = vi.fn();
+    const done = vi.fn();
+    const viewer = new ConversationViewer(
+      ui,
+      createStaticConversationSource([{ role: "assistant", content: "history" }] as any),
+      record({ status: "running", session: {} }),
+      undefined,
+      theme,
+      done,
+      stop,
+      undefined,
+      steer,
+      { pi: {} as any, ctx: {} as any, readOnly: true },
+    );
+
+    viewer.handleInput("\r");
+    viewer.handleInput("x");
+    viewer.handleInput("O");
+    expect(steer).not.toHaveBeenCalled();
+    expect(stop).not.toHaveBeenCalled();
+    viewer.handleInput("\x1b");
+    expect(done).toHaveBeenCalledTimes(1);
+  });
+});

package/test/ui/fleet-list.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  calculateFleetAgentWindow,
+  FLEET_MAX_RENDER_ROWS,
+  FleetList,
+} from "../../src/ui/fleet-list.js";
+import { canOpenActiveAgent } from "../../src/agent-history-list.js";
+
+const theme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+function makeAgents(count: number): any[] {
+  return Array.from({ length: count }, (_, i) => ({
+    id: `agent-${i}`,
+    type: "Explore",
+    description: `agent ${i}`,
+    status: "running",
+    session: { messages: [], subscribe: () => () => {} },
+    toolUses: 0,
+    startedAt: i + 1,
+    lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
+    compactionCount: 0,
+  }));
+}
+
+function createFleetHarness(records: any[]) {
+  const manager: any = {
+    records,
+    listAgents() { return this.records; },
+    abort: vi.fn(() => false),
+    steer: vi.fn(() => false),
+  };
+  const tui = { terminal: { rows: 24 }, requestRender: vi.fn() } as any;
+  let terminalInput: ((data: string) => { consume?: boolean } | undefined) | undefined;
+  let factory: any;
+  const ui: any = {
+    setWidget: vi.fn((_key: string, content: any) => { factory = content; }),
+    onTerminalInput: (handler: typeof terminalInput) => {
+      terminalInput = handler;
+      return () => { terminalInput = undefined; };
+    },
+    getEditorText: () => "",
+    notify: vi.fn(),
+    custom: vi.fn(async () => undefined),
+  };
+  const fleet = new FleetList(manager, new Map());
+  fleet.setUICtx(ui);
+  fleet.update();
+  const render = (width = 120) => factory ? factory(tui, theme).render(width) : [];
+  const input = (data: string) => terminalInput?.(data);
+  render(); // The real TUI invokes the widget factory before keyboard input arrives.
+  return { manager, fleet, tui, ui, render, input };
+}
+
+describe("canOpenActiveAgent", () => {
+  it("does not treat terminal records as active FleetView rows", () => {
+    expect(canOpenActiveAgent({ status: "completed", session: {} } as any)).toBe(false);
+    expect(canOpenActiveAgent({ status: "error", session: {} } as any)).toBe(false);
+    expect(canOpenActiveAgent({ status: "running", session: {} } as any)).toBe(true);
+    expect(canOpenActiveAgent({ status: "queued", session: undefined } as any)).toBe(false);
+  });
+});
+
+describe("FleetList bounded window", () => {
+  it("keeps every FleetView state within six total rows", () => {
+    for (const agentCount of [0, 1, 2, 4, 5, 12]) {
+      for (let selected = 0; selected <= agentCount; selected++) {
+        const window = calculateFleetAgentWindow(agentCount, selected);
+        const rows = 2 + (window.hiddenAbove > 0 ? 1 : 0)
+          + (window.end - window.start)
+          + (window.hiddenBelow > 0 ? 1 : 0);
+        expect(rows).toBeLessThanOrEqual(FLEET_MAX_RENDER_ROWS);
+        if (agentCount > 0 && selected > 0) {
+          expect(selected - 1).toBeGreaterThanOrEqual(window.start);
+          expect(selected - 1).toBeLessThan(window.end);
+        }
+      }
+    }
+  });
+
+  it("reserves indicator rows while keeping the selected middle agent visible", () => {
+    const window = calculateFleetAgentWindow(12, 6);
+    expect(window.hiddenAbove).toBeGreaterThan(0);
+    expect(window.hiddenBelow).toBeGreaterThan(0);
+    expect(5).toBeGreaterThanOrEqual(window.start);
+    expect(5).toBeLessThan(window.end);
+  });
+
+  it("slides the visible window while navigating the full roster", () => {
+    const { render, input } = createFleetHarness(makeAgents(12));
+    input("\u001b[B");
+    for (let i = 0; i < 6; i++) input("\u001b[B");
+    const middle = render();
+    expect(middle.length).toBeLessThanOrEqual(FLEET_MAX_RENDER_ROWS);
+    expect(middle.some(line => /↑ \d+ more/.test(line))).toBe(true);
+    expect(middle.some(line => /↓ \d+ more/.test(line))).toBe(true);
+    expect(middle.some(line => line.includes("●"))).toBe(true);
+
+    input("\u001b[A");
+    const afterUp = render();
+    expect(afterUp.length).toBeLessThanOrEqual(FLEET_MAX_RENDER_ROWS);
+    expect(afterUp.some(line => line.includes("●"))).toBe(true);
+  });
+
+  it("keeps the first and last windows bounded", () => {
+    const { render, input } = createFleetHarness(makeAgents(12));
+    expect(render().length).toBeLessThanOrEqual(FLEET_MAX_RENDER_ROWS);
+    input("\u001b[B");
+    for (let i = 0; i < 12; i++) input("\u001b[B");
+    const last = render();
+    expect(last.length).toBeLessThanOrEqual(FLEET_MAX_RENDER_ROWS);
+    expect(last.some(line => /↓ \d+ more/.test(line))).toBe(false);
+  });
+
+  it("forces a full render once when the active roster changes", () => {
+    const { manager, fleet, tui } = createFleetHarness(makeAgents(5));
+    tui.requestRender.mockClear();
+    manager.records.pop();
+    fleet.update();
+    expect(tui.requestRender).toHaveBeenCalledWith(true);
+  });
+
+  it("clears the widget when the active roster becomes empty", () => {
+    const { manager, fleet, ui } = createFleetHarness(makeAgents(1));
+    manager.records.splice(0);
+    fleet.update();
+    expect(ui.setWidget).toHaveBeenLastCalledWith("fleet", undefined);
+  });
+});

package/test/write-execution.test.ts

@@ -0,0 +1,83 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  executeWriteWithMetadata,
+  MAX_DURABLE_DIFF_BYTES,
+  WriteExecutionMetadataStore,
+} from "../src/write-execution.js";
+
+const tempDirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+async function tempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "pi-subagents-write-test-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+describe("executeWriteWithMetadata", () => {
+  it("writes a new file and returns a durable display diff and patch", async () => {
+    const cwd = await tempDir();
+    const store = new WriteExecutionMetadataStore();
+    const result = await executeWriteWithMetadata(store, "call-new", {
+      path: "nested/file.txt",
+      content: "new\n",
+    }, undefined, cwd);
+
+    expect(await readFile(join(cwd, "nested/file.txt"), "utf8")).toBe("new\n");
+    expect(result.content[0]?.text).toContain("Successfully wrote to nested/file.txt");
+    expect(result.details?.diff).toContain("+1 new");
+    expect(result.details?.patch).toContain("+new");
+    expect(store.get("call-new")?.diff).toBe(result.details?.diff);
+  });
+
+  it("returns durable details that remain independent of later file changes", async () => {
+    const cwd = await tempDir();
+    await writeFile(join(cwd, "file.txt"), "old\n", "utf8");
+    const store = new WriteExecutionMetadataStore();
+    const result = await executeWriteWithMetadata(store, "call-existing", {
+      path: "file.txt",
+      content: "new\n",
+    }, undefined, cwd);
+    const persisted = { ...result.details };
+
+    await writeFile(join(cwd, "file.txt"), "later\n", "utf8");
+
+    expect(persisted.diff).toContain("-1 old");
+    expect(persisted.diff).toContain("+1 new");
+    expect(persisted.patch).toContain("-old");
+    expect(persisted.patch).toContain("+new");
+    expect(persisted).not.toHaveProperty("previousContent");
+  });
+
+  it("writes successfully but marks an oversized durable diff unavailable", async () => {
+    const cwd = await tempDir();
+    const store = new WriteExecutionMetadataStore();
+    const content = "x".repeat(MAX_DURABLE_DIFF_BYTES + 1);
+    const result = await executeWriteWithMetadata(store, "call-large", {
+      path: "large.txt",
+      content,
+    }, undefined, cwd);
+
+    expect((await readFile(join(cwd, "large.txt"), "utf8")).length).toBe(content.length);
+    expect(result.details?.diffUnavailableReason).toContain("durable diff exceeds");
+    expect(result.details).not.toHaveProperty("diff");
+    expect(store.get("call-large")?.previousContent).toBe("");
+  });
+
+  it("does not fabricate metadata when the write fails", async () => {
+    const cwd = await tempDir();
+    const store = new WriteExecutionMetadataStore();
+
+    await expect(executeWriteWithMetadata(store, "call-fail", {
+      path: "/dev/null/pi-subagents-impossible/file.txt",
+      content: "nope",
+    }, undefined, cwd)).rejects.toBeTruthy();
+    expect(store.get("call-fail")).toBeUndefined();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "rootDir": "src",
+    "outDir": "dist",
+    "skipLibCheck": true,
+    "noEmitOnError": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/vitest.temp.config.mts

@@ -0,0 +1,6 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  resolve: { alias: { string_decoder: "node:string_decoder" } },
+  test: { include: ["test/**/*.test.ts"] },
+});

package/dist/ui/markdown-result.d.ts

@@ -1,3 +0,0 @@
-import { type Component } from "@earendil-works/pi-tui";
-import type { Theme } from "./agent-widget.js";
-export declare function createMarkdownResult(text: string, theme: Theme, maxLines: number): Component;

package/dist/ui/markdown-result.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMarkdownResult = createMarkdownResult;
-const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
-const pi_tui_1 = require("@earendil-works/pi-tui");
-const TRUNCATION_MARKER = "… (more output available)";
-/**
- * Render a child result as Markdown while keeping notification output bounded.
- *
- * Markdown is rendered at paint time so the TUI's current width controls wrapping.
- * If the host's Markdown implementation is unavailable or throws, the original
- * text is rendered through Text instead of making the result disappear.
- */
-class CappedMarkdownResult {
-    text;
-    theme;
-    maxLines;
-    markdown;
-    constructor(text, theme, maxLines) {
-        this.text = text;
-        this.theme = theme;
-        this.maxLines = Math.max(0, Math.floor(maxLines));
-        try {
-            this.markdown = new pi_tui_1.Markdown(text, 0, 0, (0, pi_coding_agent_1.getMarkdownTheme)());
-        }
-        catch {
-            // A mismatched host Pi version should still leave the child output visible.
-        }
-    }
-    invalidate() {
-        this.markdown?.invalidate();
-    }
-    render(width) {
-        let lines;
-        try {
-            lines = this.markdown?.render(width) ?? new pi_tui_1.Text(this.text, 0, 0).render(width);
-        }
-        catch {
-            lines = new pi_tui_1.Text(this.text, 0, 0).render(width);
-        }
-        if (lines.length <= this.maxLines)
-            return lines;
-        if (this.maxLines === 0)
-            return [];
-        return [
-            ...lines.slice(0, this.maxLines - 1),
-            this.theme.fg("muted", TRUNCATION_MARKER),
-        ];
-    }
-}
-function createMarkdownResult(text, theme, maxLines) {
-    return new CappedMarkdownResult(text, theme, maxLines);
-}

package/src/ui/markdown-result.ts

@@ -1,56 +0,0 @@
-import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { Markdown, Text, type Component } from "@earendil-works/pi-tui";
-import type { Theme } from "./agent-widget.js";
-
-const TRUNCATION_MARKER = "… (more output available)";
-
-/**
- * Render a child result as Markdown while keeping notification output bounded.
- *
- * Markdown is rendered at paint time so the TUI's current width controls wrapping.
- * If the host's Markdown implementation is unavailable or throws, the original
- * text is rendered through Text instead of making the result disappear.
- */
-class CappedMarkdownResult implements Component {
-  private readonly text: string;
-  private readonly theme: Theme;
-  private readonly maxLines: number;
-  private markdown: Component | undefined;
-
-  constructor(text: string, theme: Theme, maxLines: number) {
-    this.text = text;
-    this.theme = theme;
-    this.maxLines = Math.max(0, Math.floor(maxLines));
-
-    try {
-      this.markdown = new Markdown(text, 0, 0, getMarkdownTheme());
-    } catch {
-      // A mismatched host Pi version should still leave the child output visible.
-    }
-  }
-
-  invalidate(): void {
-    this.markdown?.invalidate();
-  }
-
-  render(width: number): string[] {
-    let lines: string[];
-    try {
-      lines = this.markdown?.render(width) ?? new Text(this.text, 0, 0).render(width);
-    } catch {
-      lines = new Text(this.text, 0, 0).render(width);
-    }
-
-    if (lines.length <= this.maxLines) return lines;
-    if (this.maxLines === 0) return [];
-
-    return [
-      ...lines.slice(0, this.maxLines - 1),
-      this.theme.fg("muted", TRUNCATION_MARKER),
-    ];
-  }
-}
-
-export function createMarkdownResult(text: string, theme: Theme, maxLines: number): Component {
-  return new CappedMarkdownResult(text, theme, maxLines);
-}

package/test/agent-history.test.ts

@@ -1,63 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  agentHistoryLocator,
-  createAgentHistoryPath,
-  ensureSubagentsGitignore,
-  hasAgentHistory,
-  readAgentHistory,
-  resolveAgentHistoryPath,
-} from "../src/agent-history.js";
-import { writeInitialEntry } from "../src/output-file.js";
-
-const tempDirectories: string[] = [];
-
-afterEach(() => {
-  for (const directory of tempDirectories.splice(0)) {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-function tempProject(): string {
-  const path = mkdtempSync(join(tmpdir(), "pi-subagents-history-test-"));
-  tempDirectories.push(path);
-  return path;
-}
-
-describe("project-local subagent history", () => {
-  it("creates a gitignore rule and preserves existing rules", () => {
-    const cwd = tempProject();
-    const root = join(cwd, ".pi-subagents");
-    const gitignore = join(root, ".gitignore");
-    const path = ensureSubagentsGitignore(cwd);
-
-    expect(path).toBe(gitignore);
-    expect(readFileSync(gitignore, "utf8")).toBe("*\n");
-
-    writeFileSync(gitignore, "keep-this\n", "utf8");
-    ensureSubagentsGitignore(cwd);
-    ensureSubagentsGitignore(cwd);
-    expect(readFileSync(gitignore, "utf8")).toBe("keep-this\n*\n");
-  });
-
-  it("creates a bounded project-relative transcript locator", () => {
-    const cwd = tempProject();
-    const historyPath = createAgentHistoryPath(cwd, "agent-1", "Explore");
-    const locator = agentHistoryLocator(cwd, historyPath);
-
-    expect(locator).toBe(".pi-subagents/agent-transcripts/agent-1_Explore_transcript.jsonl");
-    expect(resolveAgentHistoryPath(cwd, locator)).toBe(historyPath);
-    expect(hasAgentHistory(cwd, locator)).toBe(false);
-    expect(hasAgentHistory(cwd, ".pi-subagents/other.jsonl")).toBe(false);
-    expect(resolveAgentHistoryPath(cwd, ".pi-subagents/other.jsonl")).toBeUndefined();
-    expect(resolveAgentHistoryPath(cwd, ".pi-subagents/agent-transcripts/../other.jsonl")).toBeUndefined();
-
-    writeInitialEntry(historyPath, "agent-1", "hello", cwd);
-    expect(hasAgentHistory(cwd, locator)).toBe(true);
-    const messages = readAgentHistory(cwd, locator);
-    expect(messages).toHaveLength(1);
-    expect(messages?.[0]).toMatchObject({ role: "user", content: "hello" });
-  });
-});

package/test/ui/markdown-result.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createMarkdownResult } from "../../src/ui/markdown-result.js";
-
-const theme = {
-  fg: (_name: string, text: string) => text,
-  bold: (text: string) => text,
-};
-
-describe("createMarkdownResult", () => {
-  it("renders headings, lists, inline code, and fenced code", () => {
-    const component = createMarkdownResult(
-      [
-        "# Result",
-        "",
-        "- first",
-        "- `inline()`",
-        "",
-        "```ts",
-        "const answer: number = 42;",
-        "```",
-      ].join("\n"),
-      theme,
-      50,
-    );
-
-    const rendered = component.render(100).join("\n");
-    expect(rendered).toContain("Result");
-    expect(rendered).toContain("first");
-    expect(rendered).toContain("inline()");
-    expect(rendered).toContain("answer");
-  });
-
-  it("caps rendered lines and adds a truncation marker", () => {
-    const component = createMarkdownResult("line\n".repeat(20), theme, 5);
-    const rendered = component.render(80);
-
-    expect(rendered).toHaveLength(5);
-    expect(rendered.at(-1)).toContain("more");
-  });
-
-  it("keeps unlabelled code blocks safe without language guessing", () => {
-    const component = createMarkdownResult("```\nplain text\n```", theme, 20);
-    expect(component.render(80).join("\n")).toContain("plain text");
-  });
-});