mu-coding 0.13.0 → 0.16.1

package/src/tui/hooks/useScroll.ts

@@ -1,64 +0,0 @@
-import { useInput, useStdout } from 'ink';
-import { useCallback, useEffect, useRef, useState } from 'react';
-
-const SCROLL_STEP = 3;
-
-export function useScroll(contentHeight: number, viewHeight: number) {
-  const [scrollOffset, setScrollOffset] = useState(0);
-  const autoScrollRef = useRef(true);
-  const maxScroll = Math.max(0, contentHeight - viewHeight);
-
-  // Enable SGR mouse mode (1000 = press/release+wheel only, no drag motion;
-  // 1006 = SGR-encoded coordinates) so wheel sequences arrive through Ink's
-  // input pipeline. Mode 1002 (button-event w/ drag) was previously used but
-  // produced spurious "[<32;...M" drag events that leaked into text inputs.
-  //
-  // On cleanup we defensively disable 1000/1002/1003 — any of them might be
-  // active from a prior session/binary/extension and disabling already-off
-  // modes is a no-op. Without this, mouse tracking can leak into the parent
-  // shell after abort.
-  const { stdout } = useStdout();
-  useEffect(() => {
-    stdout.write('\x1b[?1000h\x1b[?1006h');
-    return () => {
-      stdout.write('\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l');
-    };
-  }, [stdout]);
-
-  useEffect(() => {
-    if (autoScrollRef.current && contentHeight > viewHeight) {
-      setScrollOffset(contentHeight - viewHeight);
-    }
-  }, [contentHeight, viewHeight]);
-
-  const scrollUp = useCallback(() => {
-    autoScrollRef.current = false;
-    setScrollOffset((o) => Math.max(0, o - SCROLL_STEP));
-  }, []);
-
-  const scrollDown = useCallback(() => {
-    setScrollOffset((o) => {
-      const next = Math.min(maxScroll, o + SCROLL_STEP);
-      if (next >= maxScroll) {
-        autoScrollRef.current = true;
-      }
-      return next;
-    });
-  }, [maxScroll]);
-
-  // Detect SGR mouse wheel sequences via Ink's useInput hook.
-  // Ink's parseKeypress doesn't recognize SGR mouse, so raw sequences
-  // pass through with \x1b stripped: [<64;... (up), [<65;... (down)
-  useInput(
-    (input) => {
-      if (input.startsWith('[<64')) {
-        scrollUp();
-      } else if (input.startsWith('[<65')) {
-        scrollDown();
-      }
-    },
-    { isActive: true },
-  );
-
-  return { scrollOffset, onScrollUp: scrollUp, onScrollDown: scrollDown };
-}

package/src/tui/hooks/useTerminal.ts

@@ -1,40 +0,0 @@
-import type { DOMElement } from 'ink';
-import { measureElement, useStdout } from 'ink';
-import { useEffect, useLayoutEffect, useState } from 'react';
-
-export function useTerminalSize() {
-  const { stdout } = useStdout();
-  const [size, setSize] = useState({ width: stdout.columns, height: stdout.rows });
-  useEffect(() => {
-    const onResize = () => setSize({ width: stdout.columns, height: stdout.rows });
-    stdout.on('resize', onResize);
-    return () => {
-      stdout.off('resize', onResize);
-    };
-  }, [stdout]);
-  return size;
-}
-
-export function useMeasure(
-  viewRef: React.RefObject<DOMElement | null>,
-  contentRef: React.RefObject<DOMElement | null>,
-  contentKey?: unknown,
-) {
-  const [viewHeight, setViewHeight] = useState(0);
-  const [contentHeight, setContentHeight] = useState(0);
-
-  // biome-ignore lint/correctness/useExhaustiveDependencies: contentKey triggers re-measure on content changes
-  useLayoutEffect(() => {
-    const timer = setTimeout(() => {
-      if (viewRef.current) {
-        setViewHeight(measureElement(viewRef.current).height);
-      }
-      if (contentRef.current) {
-        setContentHeight(measureElement(contentRef.current).height);
-      }
-    }, 100);
-    return () => clearTimeout(timer);
-  }, [viewRef, contentRef, contentKey]);
-
-  return { viewHeight, contentHeight };
-}

package/src/tui/hooks/useUI.ts

@@ -1,15 +0,0 @@
-import { useEffect, useState } from 'react';
-
-const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-
-export function useSpinner(active: boolean): string {
-  const [frame, setFrame] = useState(0);
-  useEffect(() => {
-    if (!active) {
-      return;
-    }
-    const timer = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), 80);
-    return () => clearInterval(timer);
-  }, [active]);
-  return active ? SPINNER_FRAMES[frame] : '';
-}

package/src/tui/input/InputBox.tsx

@@ -1,6 +0,0 @@
-import { InputBoxView } from './InputBoxView';
-import { type InputBoxProps, useInputBox } from './useInputBox';
-
-export function InputBox(props: InputBoxProps) {
-  return <InputBoxView {...useInputBox(props)} />;
-}

package/src/tui/input/InputBoxView.tsx

@@ -1,293 +0,0 @@
-import { Box, Text } from 'ink';
-import type { InputInfoSegment, MentionCompletion } from 'mu-core';
-import { useTheme } from '../context/ThemeContext';
-import type { Theme } from '../theme/types';
-import type { SlashCommand } from './commands';
-
-interface MentionPickerView {
-  completions: MentionCompletion[];
-  selectedIndex: number;
-  partial: string;
-}
-
-export interface InputBoxViewProps {
-  value: string;
-  cursor: number;
-  commands: SlashCommand[];
-  cmdIndex: number;
-  isCommandMode: boolean;
-  streaming: boolean;
-  isActive: boolean;
-  model: string;
-  infoSegments: InputInfoSegment[];
-  attachmentName: string | null;
-  attachmentError: string | null;
-  mentions: MentionPickerView | null;
-}
-
-function CommandHints({
-  commands,
-  selectedIndex,
-  theme,
-}: {
-  commands: SlashCommand[];
-  selectedIndex: number;
-  theme: Theme;
-}) {
-  if (!commands.length) {
-    return null;
-  }
-  return (
-    <Box flexDirection="column" marginBottom={1}>
-      {commands.map((cmd, i) => (
-        <Box key={cmd.name} paddingX={1}>
-          <Text color={i === selectedIndex ? theme.input.commandHighlight : undefined} bold={i === selectedIndex}>
-            {i === selectedIndex ? '▸ ' : '  '}
-            {cmd.name}
-          </Text>
-          <Text dimColor={true}> {cmd.description}</Text>
-        </Box>
-      ))}
-    </Box>
-  );
-}
-
-/**
- * Render a label with the substring matching `partial` (case-insensitive)
- * highlighted using the same accent color the picker uses for the selected
- * row. Preserves the original casing of the label since we only slice it.
- */
-function renderHighlightedLabel(label: string, partial: string, theme: Theme) {
-  if (!partial) return <>{label}</>;
-  const idx = label.toLowerCase().indexOf(partial.toLowerCase());
-  if (idx < 0) return <>{label}</>;
-  const head = label.slice(0, idx);
-  const match = label.slice(idx, idx + partial.length);
-  const tail = label.slice(idx + partial.length);
-  return (
-    <>
-      {head}
-      <Text color={theme.input.commandHighlight} bold={true}>
-        {match}
-      </Text>
-      {tail}
-    </>
-  );
-}
-
-function MentionHints({ mentions, theme }: { mentions: MentionPickerView; theme: Theme }) {
-  if (!mentions.completions.length) {
-    return null;
-  }
-  // Group completions by category while preserving the global index so
-  // ↑/↓ navigation still maps to the correct entry. When only one
-  // category is present we hide the header to keep the dropdown compact.
-  const grouped = new Map<string, { c: MentionCompletion; i: number }[]>();
-  mentions.completions.forEach((c, i) => {
-    const key = c.category ?? '';
-    const arr = grouped.get(key);
-    if (arr) arr.push({ c, i });
-    else grouped.set(key, [{ c, i }]);
-  });
-  const showHeaders = grouped.size > 1;
-  const sections = Array.from(grouped.entries());
-  return (
-    <Box flexDirection="column" marginBottom={1}>
-      {sections.map(([category, items]) => (
-        <Box key={category || 'default'} flexDirection="column">
-          {showHeaders && category && (
-            <Box paddingX={1}>
-              <Text dimColor={true} bold={true}>
-                {category}
-              </Text>
-            </Box>
-          )}
-          {items.map(({ c, i }) => {
-            const selected = i === mentions.selectedIndex;
-            const labelText = c.label ?? c.value;
-            return (
-              <Box key={`${category}:${c.value}`} paddingX={1}>
-                <Text wrap="truncate-start" color={selected ? theme.input.commandHighlight : undefined} bold={selected}>
-                  {selected ? '▸ @' : '  @'}
-                  {renderHighlightedLabel(labelText, mentions.partial, theme)}
-                </Text>
-                {c.description && <Text dimColor={true}> {c.description}</Text>}
-              </Box>
-            );
-          })}
-        </Box>
-      ))}
-    </Box>
-  );
-}
-
-function InputFooter({
-  model,
-  infoSegments,
-  attachmentName,
-  attachmentError,
-  hasContent,
-  isCommandMode,
-  hasMentions,
-  theme,
-}: {
-  model: string;
-  infoSegments: InputInfoSegment[];
-  attachmentName: string | null;
-  attachmentError: string | null;
-  hasContent: boolean;
-  isCommandMode: boolean;
-  hasMentions: boolean;
-  theme: Theme;
-}) {
-  const hint = hasMentions
-    ? '↑↓ · Tab accept'
-    : hasContent
-      ? isCommandMode
-        ? '↑↓ · Enter run'
-        : ''
-      : '/ commands · @ mentions';
-
-  return (
-    <Box justifyContent="space-between">
-      <Box gap={1}>
-        {infoSegments.map((seg) => (
-          <Text key={seg.key} color={seg.color} bold={seg.bold}>
-            {seg.text}
-          </Text>
-        ))}
-        {model && (
-          <Text color={theme.input.modelLabel} bold={true}>
-            {model}
-          </Text>
-        )}
-        {attachmentName && <Text color={theme.input.attachmentName}>📷 {attachmentName}</Text>}
-        {attachmentError && <Text color={theme.input.attachmentError}>{attachmentError}</Text>}
-      </Box>
-      <Text color={theme.input.footerHint}>{hint}</Text>
-    </Box>
-  );
-}
-
-interface RowProps {
-  line: string;
-  cursorCol: number | null;
-  isCommandLine: boolean;
-  theme: Theme;
-}
-
-/**
- * Render one buffer row, splicing the cursor glyph at `cursorCol` if the
- * cursor lives on this row. Splitting around the cursor (rather than rendering
- * the whole line and overlaying) keeps the layout flowing inside Ink's text
- * wrapping engine.
- */
-function InputRow({ line, cursorCol, isCommandLine, theme }: RowProps) {
-  const colorize = (text: string) => (isCommandLine ? <Text color={theme.input.commandHighlight}>{text}</Text> : text);
-
-  if (cursorCol === null) {
-    return <Text wrap="wrap">{colorize(line)}</Text>;
-  }
-
-  const before = line.slice(0, cursorCol);
-  const after = line.slice(cursorCol);
-  return (
-    <Text wrap="wrap">
-      {colorize(before)}
-      <Text color={theme.input.cursor} inverse={true}>
-        ▎
-      </Text>
-      {colorize(after)}
-    </Text>
-  );
-}
-
-interface DisplayProps {
-  value: string;
-  cursor: number;
-  isCommandMode: boolean;
-  streaming: boolean;
-  isActive: boolean;
-  theme: Theme;
-}
-
-function InputDisplay({ value, cursor, isCommandMode, streaming, isActive, theme }: DisplayProps) {
-  const showCursor = !streaming && isActive;
-  if (!value.length) {
-    return (
-      <Text>
-        {showCursor && (
-          <Text color={theme.input.cursor} inverse={true}>
-            ▎
-          </Text>
-        )}
-      </Text>
-    );
-  }
-  const lines = value.split('\n');
-  // Locate cursor row/col by walking newline offsets.
-  let row = 0;
-  let consumed = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const lineEnd = consumed + lines[i].length;
-    if (cursor <= lineEnd) {
-      row = i;
-      break;
-    }
-    consumed = lineEnd + 1; // +1 for the newline
-    row = i + 1;
-  }
-  const col = cursor - consumed;
-  return (
-    <>
-      {lines.map((line, i) => (
-        <InputRow
-          // biome-ignore lint/suspicious/noArrayIndexKey: static input display lines
-          key={`${i}-${line}`}
-          line={line}
-          cursorCol={showCursor && i === row ? col : null}
-          isCommandLine={i === 0 && isCommandMode}
-          theme={theme}
-        />
-      ))}
-    </>
-  );
-}
-
-export function InputBoxView(props: InputBoxViewProps) {
-  const theme = useTheme();
-  return (
-    <Box
-      flexDirection="column"
-      flexShrink={0}
-      backgroundColor={theme.input.background}
-      paddingX={1}
-      paddingY={1}
-      marginX={1}
-      marginTop={1}
-    >
-      {props.isCommandMode && <CommandHints commands={props.commands} selectedIndex={props.cmdIndex} theme={theme} />}
-      {props.mentions && <MentionHints mentions={props.mentions} theme={theme} />}
-      <Box flexDirection="column" minHeight={2}>
-        <InputDisplay
-          value={props.value}
-          cursor={props.cursor}
-          isCommandMode={props.isCommandMode}
-          streaming={props.streaming}
-          isActive={props.isActive}
-          theme={theme}
-        />
-      </Box>
-      <InputFooter
-        model={props.model}
-        infoSegments={props.infoSegments}
-        attachmentName={props.attachmentName}
-        attachmentError={props.attachmentError}
-        hasContent={props.value.length > 0}
-        isCommandMode={props.isCommandMode}
-        hasMentions={Boolean(props.mentions)}
-        theme={theme}
-      />
-    </Box>
-  );
-}

package/src/tui/input/commands.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it, mock } from 'bun:test';
-import { BUILTIN_COMMANDS, fromPluginCommand, matchCommands } from './commands';
-import type { InputActions } from './useInputHandler';
-
-describe('matchCommands', () => {
-  it('returns no matches for input that does not start with /', () => {
-    expect(matchCommands('model', BUILTIN_COMMANDS)).toEqual([]);
-  });
-
-  it('filters by prefix case-insensitively', () => {
-    const result = matchCommands('/MOD', BUILTIN_COMMANDS);
-    expect(result.map((c) => c.name)).toEqual(['/model']);
-  });
-
-  it('returns all commands when input is just /', () => {
-    const result = matchCommands('/', BUILTIN_COMMANDS);
-    expect(result.length).toBe(BUILTIN_COMMANDS.length);
-  });
-});
-
-describe('BUILTIN_COMMANDS', () => {
-  it('each builtin invokes the expected action', () => {
-    const onTogglePicker = mock(() => undefined);
-    const onToggleSessionPicker = mock(() => undefined);
-    const onNew = mock(() => undefined);
-    const onCompact = mock(() => undefined);
-    const onShowContext = mock(() => undefined);
-    const onUpdate = mock(() => undefined);
-    const actions: InputActions = {
-      onTogglePicker,
-      onToggleSessionPicker,
-      onNew,
-      onCompact,
-      onShowContext,
-      onUpdate,
-    };
-
-    for (const cmd of BUILTIN_COMMANDS) {
-      cmd.invoke?.(actions, '');
-    }
-
-    expect(onTogglePicker).toHaveBeenCalledTimes(1);
-    expect(onToggleSessionPicker).toHaveBeenCalledTimes(1);
-    expect(onNew).toHaveBeenCalledTimes(1);
-    expect(onCompact).toHaveBeenCalledTimes(1);
-    expect(onShowContext).toHaveBeenCalledTimes(1);
-    expect(onUpdate).toHaveBeenCalledTimes(1);
-  });
-
-  it('/update forwards args to onUpdate', () => {
-    const onUpdate = mock(() => undefined);
-    const actions: InputActions = { onUpdate };
-    const cmd = BUILTIN_COMMANDS.find((c) => c.name === '/update');
-    expect(cmd).toBeDefined();
-    cmd?.invoke?.(actions, 'plugins');
-    expect(onUpdate).toHaveBeenCalledWith('plugins');
-  });
-});
-
-describe('fromPluginCommand', () => {
-  it('prepends a slash and forwards args/context to execute', async () => {
-    const execute = mock(async () => 'ok');
-    const wrapped = fromPluginCommand(
-      { name: 'foo', description: 'plugin', execute },
-      { messages: [], cwd: '/tmp', config: { baseUrl: '', maxTokens: 0, temperature: 0, streamTimeoutMs: 0 } },
-    );
-    expect(wrapped.name).toBe('/foo');
-    await wrapped.execute?.('hello');
-    expect(execute).toHaveBeenCalledWith('hello', expect.any(Object));
-  });
-});

package/src/tui/input/commands.ts

@@ -1,55 +0,0 @@
-import type { CommandContext, SlashCommand as PluginSlashCommand } from 'mu-core';
-import type { InputActions } from './useInputHandler';
-
-/**
- * A slash command can either:
- *  - run via `invoke(actions, args)` — for builtins that just toggle UI state
- *    (most ignore `args`), or
- *  - run via `execute(args)` — for plugin-supplied commands that produce
- *    side-effects through the agent runtime.
- *
- * Exactly one of `invoke` / `execute` should be set per command.
- */
-export interface SlashCommand {
-  name: string;
-  description: string;
-  invoke?: (actions: InputActions, args: string) => void;
-  execute?: (args: string) => Promise<string | undefined>;
-}
-
-export const BUILTIN_COMMANDS: SlashCommand[] = [
-  { name: '/model', description: 'Select a model', invoke: (a) => a.onTogglePicker?.() },
-  { name: '/sessions', description: 'List project sessions', invoke: (a) => a.onToggleSessionPicker?.() },
-  { name: '/new', description: 'New conversation', invoke: (a) => a.onNew?.() },
-  {
-    name: '/compact',
-    description: 'Summarize the conversation and replace history with the summary (frees context)',
-    invoke: (a) => a.onCompact?.(),
-  },
-  {
-    name: '/context',
-    description: 'Show the LLM context (system prompt, messages, tools) as plain text',
-    invoke: (a) => a.onShowContext?.(),
-  },
-  {
-    name: '/update',
-    description: 'Update mu and installed npm plugins. Args: "plugins" | "self" (default: all)',
-    invoke: (a, args) => a.onUpdate?.(args),
-  },
-];
-
-export function fromPluginCommand(command: PluginSlashCommand, context: CommandContext): SlashCommand {
-  return {
-    name: `/${command.name}`,
-    description: command.description,
-    execute: (args: string) => command.execute(args, context),
-  };
-}
-
-export function matchCommands(input: string, commands: SlashCommand[]): SlashCommand[] {
-  if (!input.startsWith('/')) {
-    return [];
-  }
-  const q = input.toLowerCase();
-  return commands.filter((cmd) => cmd.name.startsWith(q));
-}

package/src/tui/input/cursor.test.ts

@@ -1,136 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import {
-  cursorRowCol,
-  deleteBackward,
-  deleteForward,
-  deleteWordBackward,
-  insertAt,
-  killToLineEnd,
-  killToLineStart,
-  moveLeft,
-  moveLineDown,
-  moveLineEnd,
-  moveLineHome,
-  moveLineUp,
-  moveRight,
-  moveWordLeft,
-  moveWordRight,
-  positionAt,
-} from './cursor';
-
-const s = (value: string, cursor: number) => ({ value, cursor });
-
-describe('insertAt', () => {
-  it('inserts at the cursor and advances it', () => {
-    expect(insertAt(s('hello', 5), '!')).toEqual({ value: 'hello!', cursor: 6 });
-    expect(insertAt(s('helo', 2), 'l')).toEqual({ value: 'hello', cursor: 3 });
-  });
-  it('is a no-op for empty text', () => {
-    expect(insertAt(s('a', 1), '')).toEqual({ value: 'a', cursor: 1 });
-  });
-  it('clamps an out-of-range cursor', () => {
-    expect(insertAt(s('abc', 99), 'x')).toEqual({ value: 'abcx', cursor: 4 });
-  });
-});
-
-describe('deleteBackward', () => {
-  it('removes the char left of the cursor', () => {
-    expect(deleteBackward(s('hello', 5))).toEqual({ value: 'hell', cursor: 4 });
-    expect(deleteBackward(s('hello', 1))).toEqual({ value: 'ello', cursor: 0 });
-  });
-  it('is a no-op at position 0', () => {
-    expect(deleteBackward(s('hello', 0))).toEqual({ value: 'hello', cursor: 0 });
-  });
-});
-
-describe('deleteForward', () => {
-  it('removes the char at the cursor', () => {
-    expect(deleteForward(s('hello', 0))).toEqual({ value: 'ello', cursor: 0 });
-    expect(deleteForward(s('hello', 4))).toEqual({ value: 'hell', cursor: 4 });
-  });
-  it('is a no-op at end of buffer', () => {
-    expect(deleteForward(s('hello', 5))).toEqual({ value: 'hello', cursor: 5 });
-  });
-});
-
-describe('deleteWordBackward', () => {
-  it('eats the previous word', () => {
-    expect(deleteWordBackward(s('hello world', 11))).toEqual({ value: 'hello ', cursor: 6 });
-    expect(deleteWordBackward(s('hello   world', 13))).toEqual({ value: 'hello   ', cursor: 8 });
-  });
-  it('eats trailing whitespace before the word', () => {
-    expect(deleteWordBackward(s('foo bar  ', 9))).toEqual({ value: 'foo ', cursor: 4 });
-  });
-  it('is a no-op at start', () => {
-    expect(deleteWordBackward(s('foo', 0))).toEqual({ value: 'foo', cursor: 0 });
-  });
-});
-
-describe('killToLineEnd / killToLineStart', () => {
-  it('kills from cursor to end of line', () => {
-    expect(killToLineEnd(s('hello\nworld', 3))).toEqual({ value: 'hel\nworld', cursor: 3 });
-  });
-  it('eats the newline when cursor sits at line end', () => {
-    expect(killToLineEnd(s('hello\nworld', 5))).toEqual({ value: 'helloworld', cursor: 5 });
-  });
-  it('kills from start of line to cursor', () => {
-    expect(killToLineStart(s('hello\nworld', 3))).toEqual({ value: 'lo\nworld', cursor: 0 });
-    expect(killToLineStart(s('hello\nworld', 8))).toEqual({ value: 'hello\nrld', cursor: 6 });
-  });
-});
-
-describe('horizontal movement', () => {
-  it('moveLeft / moveRight respect bounds', () => {
-    expect(moveLeft(s('abc', 0))).toEqual({ value: 'abc', cursor: 0 });
-    expect(moveLeft(s('abc', 2))).toEqual({ value: 'abc', cursor: 1 });
-    expect(moveRight(s('abc', 3))).toEqual({ value: 'abc', cursor: 3 });
-    expect(moveRight(s('abc', 1))).toEqual({ value: 'abc', cursor: 2 });
-  });
-  it('moveWordLeft / moveWordRight jump across word boundaries', () => {
-    expect(moveWordLeft(s('foo bar baz', 11))).toEqual({ value: 'foo bar baz', cursor: 8 });
-    expect(moveWordLeft(s('foo bar baz', 8))).toEqual({ value: 'foo bar baz', cursor: 4 });
-    expect(moveWordRight(s('foo bar baz', 0))).toEqual({ value: 'foo bar baz', cursor: 3 });
-    expect(moveWordRight(s('foo bar baz', 3))).toEqual({ value: 'foo bar baz', cursor: 7 });
-  });
-  it('Home/End operate on the current line', () => {
-    expect(moveLineHome(s('hello\nworld', 8))).toEqual({ value: 'hello\nworld', cursor: 6 });
-    expect(moveLineEnd(s('hello\nworld', 6))).toEqual({ value: 'hello\nworld', cursor: 11 });
-  });
-});
-
-describe('vertical movement', () => {
-  it('moveLineUp returns null on first line', () => {
-    expect(moveLineUp(s('one\ntwo', 1), null)).toBeNull();
-  });
-  it('moveLineDown returns null on last line', () => {
-    expect(moveLineDown(s('one\ntwo', 5), null)).toBeNull();
-  });
-  it('preserves desired column across short lines', () => {
-    // Cursor on line 0 col 5 → down to line 1 (3 chars) clamps to 3 → down again to line 2 (10 chars) restores 5.
-    const start = { value: 'hello\nfoo\nlonglineee', cursor: 5 };
-    const down1 = moveLineDown(start, 5);
-    expect(down1).toEqual({ value: start.value, cursor: 9 }); // end of "foo"
-    const down2 = moveLineDown(down1 as { value: string; cursor: number }, 5);
-    expect(down2).toEqual({ value: start.value, cursor: 15 }); // 10 + 5
-  });
-  it('round-trips up then down to the same offset when desired column is preserved', () => {
-    const state = { value: 'aaaa\nbbbb\ncccc', cursor: 12 }; // line 2, col 2
-    const up = moveLineUp(state, 2);
-    expect(up).toEqual({ value: state.value, cursor: 7 });
-    const down = moveLineDown(up as { value: string; cursor: number }, 2);
-    expect(down).toEqual({ value: state.value, cursor: 12 });
-  });
-});
-
-describe('cursorRowCol / positionAt', () => {
-  it('reports row and col correctly', () => {
-    expect(cursorRowCol('hello\nworld', 0)).toEqual({ row: 0, col: 0 });
-    expect(cursorRowCol('hello\nworld', 5)).toEqual({ row: 0, col: 5 });
-    expect(cursorRowCol('hello\nworld', 6)).toEqual({ row: 1, col: 0 });
-    expect(cursorRowCol('hello\nworld', 11)).toEqual({ row: 1, col: 5 });
-  });
-  it('positionAt clamps to line length', () => {
-    expect(positionAt('hello\nfoo', 1, 99)).toBe(9);
-    expect(positionAt('hello\nfoo', 0, 2)).toBe(2);
-  });
-});