fix(links): preserve wrapped configuration filenames

test/file-path-link-forms.test.ts

@@ -52,13 +52,13 @@ const { findFilePathLinks, resolveLinkedFilePath, terminalPathLine } = loadHelpe
 const paths = (text: string) => findFilePathLinks(text).map((f) => f.path);
 
 /** An xterm buffer stand-in: hard-broken rows (no `isWrapped`), as Claude Code emits them. */
-function buffer(lines: string[], cols = 80) {
+function buffer(lines: string[], cols = 80, wrappedRows = new Set<number>()) {
   return {
     length: lines.length,
     getLine: (row: number) =>
       row >= 0 && row < lines.length
         ? {
-            isWrapped: false,
+            isWrapped: wrappedRows.has(row),
             translateToString: (trim?: boolean) => (trim ? lines[row].replace(/\s+$/, '') : lines[row].padEnd(cols)),
           }
         : undefined,
@@ -157,6 +157,10 @@ describe('terminalPathLine', () => {
     // A path that already ended, and a next line opening a new rooted path.
     expect(terminalPathLine(buffer(['see /tmp/a/b.png', 'c/d.png']), 0, 80)).toMatchObject({ endRow: 0 });
     expect(terminalPathLine(buffer(['/home/joe/dir/', '/home/x.png']), 0, 80)).toMatchObject({ endRow: 0 });
+    expect(terminalPathLine(buffer(['see (/mnt/raid1/folder)', '  file.conf)']), 0, 80)).toMatchObject({ endRow: 0 });
+    expect(terminalPathLine(buffer(['see (/mnt/raid1/folder', '  /mnt/other/file.conf)']), 0, 80)).toMatchObject({
+      endRow: 0,
+    });
   });
 
   // `git ls-files`, `find` and `ls -R` print one path per row. An extensionless
@@ -241,9 +245,9 @@ function loadApp() {
   return app;
 }
 
-function linksOn(lines: string[], row: number) {
+function linksOn(lines: string[], row: number, cols = 80, wrappedRows = new Set<number>()) {
   const app = loadApp();
-  app.terminal = { cols: 80, registerLinkProvider: vi.fn(), buffer: { active: buffer(lines) } };
+  app.terminal = { cols, registerLinkProvider: vi.fn(), buffer: { active: buffer(lines, cols, wrappedRows) } };
   const provider = app.registerFilePathLinkProvider() as Provider;
   let out: Link[] = [];
   provider.provideLinks(row, (links) => {
@@ -253,6 +257,36 @@ function linksOn(lines: string[], row: number) {
 }
 
 describe('terminal link provider', () => {
+  it('retains the filename space when the CLI word-wraps a parenthesised path', () => {
+    const path = '/mnt/user/Scratch/Kobo/Set-KoboCovers/Kobo eReader.conf';
+    const rows = [
+      'Found it: I prepared a corrected configuration (/mnt/user/Scratch/Kobo/Set-KoboCovers/Kobo',
+      '  eReader.conf).',
+    ];
+    for (const row of [1, 2]) {
+      const { app, links } = linksOn(rows, row, 120);
+      expect(links.map((link) => link.text)).toEqual([path]);
+      expect(links[0].range.end).toEqual({ x: '  eReader.conf'.length + 1, y: 2 });
+      links[0].activate({}, links[0].text);
+      expect(app.openLogViewerWindow).toHaveBeenCalledWith(path, 's1');
+    }
+  });
+
+  it('opens the complete parenthesised configuration path from either wrapped row', () => {
+    const path = '/mnt/user/Scratch/Kobo/Set-KoboCovers/Kobo eReader.conf';
+    const text = `Found it: I prepared a corrected configuration (${path}).`;
+    const split = text.indexOf(' eReader') + 1;
+    const rows = [text.slice(0, split), text.slice(split)];
+    for (const row of [1, 2]) {
+      const { app, links } = linksOn(rows, row, split, new Set([1]));
+      expect(links.map((link) => link.text)).toEqual([path]);
+      expect(links[0].range.start).toEqual({ x: text.indexOf(path) + 1, y: 1 });
+      expect(links[0].range.end).toEqual({ x: 'eReader.conf'.length + 1, y: 2 });
+      links[0].activate({}, links[0].text);
+      expect(app.openLogViewerWindow).toHaveBeenCalledWith(path, 's1');
+    }
+  });
+
   it('links a broken path once, across both rows, and opens the whole path', () => {
     const { app, links } = linksOn(BROKEN, 2);
     expect(links.map((l) => l.text)).toEqual([BROKEN_PATH]);

test/response-viewer-file-links.test.ts

@@ -78,6 +78,15 @@ function linkify(html: string): HTMLElement {
 const paths = (root: HTMLElement) => Array.from(root.querySelectorAll('a.rv-path'));
 
 describe('response viewer file-path linkifier', () => {
+  it('links a parenthesised configuration filename with spaces without changing the prose', () => {
+    const path = '/mnt/user/Scratch/Kobo/Set-KoboCovers/Kobo eReader.conf';
+    const text = `Prepared a corrected configuration (${path}).`;
+    const root = linkify(`<p>${text}</p>`);
+    expect(paths(root).map((a) => a.dataset.path)).toEqual([path]);
+    expect(paths(root)[0].dataset.folder).toBeUndefined();
+    expect(root.textContent).toBe(text);
+  });
+
   it.each([
     ['- 03 Attachments/Build SIPOC Design/Build-SIPOC.pptx', ['Design/Build-SIPOC.pptx']],
     ['- notes/a b/c.md', ['b/c.md']],

test/spaced-file-path-links.test.ts

@@ -28,6 +28,20 @@ const LONG =
   '/mnt/c/Users/someone/OneDrive - Contoso/01_Projects/Other/kb/out/deliverables/fy27-messaging-market-story.docx';
 
 describe('spaced file paths', () => {
+  it('keeps a parenthesised configuration filename whole inside a sentence', () => {
+    const path = '/mnt/user/Scratch/Kobo/Set-KoboCovers/Kobo eReader.conf';
+    const text = `Prepared a corrected configuration (${path}).`;
+    expect(findFilePathLinks(text)).toEqual([{ path, index: text.indexOf(path) }]);
+  });
+
+  it('keeps separate parenthesised paths and the surrounding prose separate', () => {
+    const first = '/mnt/data/Kobo/Kobo eReader.conf';
+    const second = '/home/me/My Docs/notes.md';
+    expect(paths(`Updated (${first}) and (${second}).`)).toEqual([first, second]);
+    expect(paths('Do not link (/etc/private files/settings.conf).')).toEqual([]);
+    expect(paths('Do not link (/mnt/data/../private files/settings.conf).')).toEqual([]);
+  });
+
   it('links an own-line absolute path with spaces whole', () => {
     expect(paths(LONG)).toEqual([LONG]);
     expect(paths('/mnt/c/proj/My Big Docs/report.docx')).toEqual(['/mnt/c/proj/My Big Docs/report.docx']);

test/wrapped-file-paths.browser.test.ts

@@ -0,0 +1,82 @@
+/** Real xterm clicks must open the complete spaced filename from either wrapped row. */
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { chromium, type Browser } from 'playwright';
+
+const publicDir = resolve(import.meta.dirname, '../src/web/public');
+const path = '/mnt/user/Scratch/Kobo/Set-KoboCovers/Kobo eReader.conf';
+
+describe('wrapped configuration file links (Chromium)', () => {
+  let browser: Browser;
+  beforeAll(async () => {
+    browser = await chromium.launch({ headless: true });
+  });
+  afterAll(async () => {
+    await browser.close();
+  });
+
+  it.each(['soft', 'hard'])('opens the complete file from both rows of a %s wrap', async (wrap) => {
+    const page = await browser.newPage({ viewport: { width: 1920, height: 600 } });
+    try {
+      await page.setContent('<div id="terminal"></div>');
+      await page.addStyleTag({ path: resolve(publicDir, '../../../node_modules/@xterm/xterm/css/xterm.css') });
+      await page.addScriptTag({ path: resolve(publicDir, '../../../node_modules/@xterm/xterm/lib/xterm.js') });
+      await page.addScriptTag({ content: 'window.CodemanApp = class CodemanApp {};' });
+      for (const file of ['constants.js', 'terminal-ui.js']) {
+        await page.addScriptTag({ content: readFileSync(resolve(publicDir, file), 'utf8') });
+      }
+      await page.evaluate(
+        async ({ path, wrap }) => {
+          const w = window as any;
+          const first = `Found it: prepared a corrected configuration (${path.slice(0, -' eReader.conf'.length)}`;
+          const terminal = new w.Terminal({ cols: first.length + (wrap === 'soft' ? 1 : 20), rows: 6 });
+          terminal.open(document.getElementById('terminal'));
+          w.opened = [];
+          w.app = Object.assign(new w.CodemanApp(), {
+            terminal,
+            activeSessionId: 'fixture',
+            sessions: new Map([['fixture', { workingDir: '/workspace' }]]),
+            _isExternalPreviewPath: () => true,
+            openFilePreview: (file: string) => w.opened.push(file),
+            openLogViewerWindow: (file: string) => w.opened.push(`log:${file}`),
+            openFolderGrid: (file: string) => w.opened.push(`folder:${file}`),
+          });
+          w.app.registerFilePathLinkProvider();
+          const text = `${first}${wrap === 'soft' ? ' ' : '\r\n  '}eReader.conf).`;
+          await new Promise<void>((done) => terminal.write(text, done));
+          await new Promise<void>((done) => requestAnimationFrame(() => requestAnimationFrame(() => done())));
+        },
+        { path, wrap }
+      );
+
+      for (const row of [0, 1]) {
+        const point = await page.evaluate(
+          async ({ path, row }) => {
+            const app = (window as any).app;
+            const terminal = app.terminal;
+            const links = await new Promise<any[]>((done) => app._terminalLinkProvider.provideLinks(row + 1, done));
+            const link = links.find((candidate) => candidate.text === path);
+            if (!link) throw new Error(`The complete filename is not linked on row ${row + 1}`);
+            const text = terminal.buffer.active.getLine(row).translateToString(true);
+            const col = row === 0 ? link.range.start.x : text.indexOf('eReader') + 1;
+            const box = terminal.element.querySelector('.xterm-screen').getBoundingClientRect();
+            return {
+              x: box.left + (col - 0.5) * (box.width / terminal.cols),
+              y: box.top + (row + 0.5) * (box.height / terminal.rows),
+            };
+          },
+          { path, row }
+        );
+        await page.mouse.move(point.x, point.y);
+        await page.waitForFunction(() => (window as any).app._linkHovered === true);
+        await page.mouse.click(point.x, point.y);
+        await page.waitForFunction((count) => (window as any).opened.length === count, row + 1);
+        expect(await page.evaluate(() => (window as any).opened)).toEqual(Array(row + 1).fill(path));
+        await page.mouse.move(0, 0);
+      }
+    } finally {
+      await page.close();
+    }
+  });
+});