/**

 * Types and utilities for compact paste placeholders in the coder composer.

 */

export const PASTE_TEXT_THRESHOLD = 800;

export const PASTE_MAX_LINES = 1;

export interface PastedTextContent {

  readonly id: number;

  readonly content: string;

}

/**

 * Return line count difference or line count for reference tokens.

 * "line1\nline2" has 1 additional line (+1 line).

 */

export function getPastedTextRefNumLines(text: string): number {

  return (text.match(/\r\n|\r|\n/g) ?? []).length;

}

/**

 * Format reference token: `[Pasted text #1]` or `[Pasted text #1 +10 lines]`.

 */

export function formatPastedTextRef(id: number, numLines: number): string {

  if (numLines <= 0) {

    return `[Pasted text #${id}]`;

  }

  return `[Pasted text #${id} +${numLines} ${numLines === 1 ? "line" : "lines"}]`;

}

/**

 * Regex matching reference tokens: `[Pasted text #1]`, `[Pasted text #1 +1 line]`, `[Pasted text #1 +10 lines]`.

 */

export const PASTED_TEXT_REF_REGEX = /\[Pasted text #(\d+)(?: \+\d+ lines?)?\]/g;

/**

 * Replace all `[Pasted text #N]` references with their actual content.

 */

export function expandPastedTextRefs(

  input: string,

  pastedContents: ReadonlyMap<number, PastedTextContent> | Record<number, PastedTextContent>,

): string {

  const isMap = pastedContents instanceof Map;

  const getEntry = (id: number): PastedTextContent | undefined => {

    if (isMap) {

      return (pastedContents as ReadonlyMap<number, PastedTextContent>).get(id);

    }

    return (pastedContents as Record<number, PastedTextContent>)[id];

  };

  const matches = [...input.matchAll(PASTED_TEXT_REF_REGEX)];

  let expanded = input;

  for (let i = matches.length - 1; i >= 0; i--) {

    const match = matches[i];

    if (match === undefined || match.index === undefined) continue;

    const id = parseInt(match[1] ?? "0", 10);

    const entry = getEntry(id);

    if (entry !== undefined) {

      expanded =

        expanded.slice(0, match.index) +

        entry.content +

        expanded.slice(match.index + match[0].length);

    }

  }

  return expanded;

}

/**

 * Check if a pasted string qualifies for compact placeholder representation.

 */

export function shouldCollapsePaste(text: string, maxLines = PASTE_MAX_LINES): boolean {

  const numLines = getPastedTextRefNumLines(text);

  return text.length > PASTE_TEXT_THRESHOLD || numLines > maxLines;

}

/**

 * Remove trailing reference token if the backspace lands on it.

 */

export function backspaceComposer(composer: string): string {

  const trailingToken = /\[Pasted text #\d+(?: \+\d+ lines?)?\]$/.exec(composer);

  if (trailingToken !== null) {

    return composer.slice(0, -trailingToken[0].length);

  }

  return composer.slice(0, -1);

}

import type { CoderTask, CoderTaskStatus } from "./coder-tasks.js";

import { coderTierLabel } from "./coder-tiers.js";

import { RELOAD_EXIT_CODE, sourceCheckout } from "./coder-reload.js";

import {

  backspaceComposer,

  expandPastedTextRefs,

  formatPastedTextRef,

  getPastedTextRefNumLines,

  type PastedTextContent,

  shouldCollapsePaste,

} from "./coder-paste.js";

import type { SkillSelection } from "./coder-skills.js";

const ALT_SCREEN_ON = "\x1b[?1049h";

  let pendingEscape = "";

  /** A paste whose end has not arrived yet. */

  let pendingPaste = "";

  const pastedContents = new Map<number, PastedTextContent>();

  let nextPasteId = 1;

  let escapeTimer: NodeJS.Timeout | undefined;

  const write = (text: string) => {

    };

    const submit = (mode: "steer" | "queue" = "steer") => {

      const prompt = composer;

      const prompt = expandPastedTextRefs(composer, pastedContents);

      composer = "";

      pastedContents.clear();

      anchor = undefined;

      // Only when a turn actually begins. Resetting on every submission made

      // `/export` mid-turn put the elapsed clock back to zero, which reads as

      // reader looking at a settled reply with no way to tell whether the key

      // did anything, which reads as the key not working.

      if (session.interrupt()) session.notice("Interrupted.");

      else composer = "";

      else {

        composer = "";

        pastedContents.clear();

      }

      render();

    };

            pendingPaste = text.slice(index);

            break;

          }

          composer += text.slice(from, to);

          const pastedText = text.slice(from, to);

          if (shouldCollapsePaste(pastedText)) {

            const pasteId = nextPasteId++;

            pastedContents.set(pasteId, { id: pasteId, content: pastedText });

            const numLines = getPastedTextRefNumLines(pastedText);

            composer += formatPastedTextRef(pasteId, numLines);

          } else {

            composer += pastedText;

          }

          index = to + PASTE_END.length;

          dirty = true;

          continue;

        }

        if (char === "\x7f" || char === "\b") {

          composer = composer.slice(0, -1);

          composer = backspaceComposer(composer);

          dirty = true;

          index += 1;

          continue;

        if (char === "\x15") {

          composer = "";

          pastedContents.clear();

          dirty = true;

          index += 1;

          continue;

import { EventEmitter } from "node:events";

import { describe, expect, it } from "vitest";

import {

  backspaceComposer,

  expandPastedTextRefs,

  formatPastedTextRef,

  getPastedTextRefNumLines,

  PASTE_MAX_LINES,

  PASTE_TEXT_THRESHOLD,

  shouldCollapsePaste,

} from "../src/coder-paste.js";

import { CoderSession, type ReplySource } from "../src/coder-session.js";

import { runCoderUi } from "../src/coder-ui.js";

  }

}

describe("pasting", () => {

  it("keeps a multi-line paste as one message", async () => {

describe("coder-paste utilities", () => {

  it("counts additional lines accurately", () => {

    expect(getPastedTextRefNumLines("one line")).toBe(0);

    expect(getPastedTextRefNumLines("line 1\nline 2")).toBe(1);

    expect(getPastedTextRefNumLines("line 1\r\nline 2\r\nline 3")).toBe(2);

  });

  it("formats reference placeholders", () => {

    expect(formatPastedTextRef(1, 0)).toBe("[Pasted text #1]");

    expect(formatPastedTextRef(2, 1)).toBe("[Pasted text #2 +1 line]");

    expect(formatPastedTextRef(3, 15)).toBe("[Pasted text #3 +15 lines]");

  });

  it("identifies when paste should collapse", () => {

    expect(shouldCollapsePaste("short text")).toBe(false);

    expect(shouldCollapsePaste("line 1\nline 2\nline 3")).toBe(true);

    expect(shouldCollapsePaste("a".repeat(PASTE_TEXT_THRESHOLD + 1))).toBe(true);

  });

  it("expands single and multiple pasted text references", () => {

    const pasted = new Map([

      [1, { id: 1, content: "full contents of first paste\nwith lines" }],

      [2, { id: 2, content: "second paste content" }],

    ]);

    const input = "Please inspect [Pasted text #1 +1 line] and also [Pasted text #2] carefully.";

    const expanded = expandPastedTextRefs(input, pasted);

    expect(expanded).toBe(

      "Please inspect full contents of first paste\nwith lines and also second paste content carefully.",

    );

  });

  it("deletes placeholder token atomically on backspace", () => {

    const composerWithToken = "prefix [Pasted text #1 +5 lines]";

    expect(backspaceComposer(composerWithToken)).toBe("prefix ");

    const composerWithSingleLineToken = "prefix [Pasted text #2]";

    expect(backspaceComposer(composerWithSingleLineToken)).toBe("prefix ");

    const normalComposer = "normal text";

    expect(backspaceComposer(normalComposer)).toBe("normal tex");

  });

});

describe("pasting in coder UI", () => {

  it("keeps a multi-line paste as a compact placeholder in UI and expands on submit", async () => {

    const sent: string[] = [];

    const src: ReplySource = {

      model: "m",

    await running;

  });

  it("shows a paste as a blob rather than as its last line", async () => {

  it("shows large paste as a placeholder token in the composer", async () => {

    const src: ReplySource = {

      model: "m",

      async *reply() {

    const ESC = String.fromCharCode(27);

    stdin.emit("data", `${ESC}[200~first line\nsecond\nthird${ESC}[201~`);

    // The reader needs to know how much is there and that it goes as one

    // message, not to read all of it in a one-row composer.

    // The reader sees a compact placeholder token

    const painted = stdout.written.split(new RegExp(`${ESC}\\[[0-9;]*m`)).join("");

    expect(painted).toContain("first line [+2 more lines]");

    expect(painted).toContain("[Pasted text #1 +2 lines]");

    expect(painted).not.toContain("second");

    // Ctrl+D quits only an empty composer, which is why escape comes first.