fix: prevent padding of multi-pipe connector lines (#6)

Lines with multiple │ characters that form connectors between
side-by-side boxes were incorrectly classified as content lines
and padded, breaking diagrams like:

    │             │             │

Add isConnectorLine() function to detect lines with more than 2
vertical bars where all segments between them are whitespace-only.
Modify isContentLine() to exclude these connector lines.

Fixes issue reported in soderlind/admin-coach-tours@4c0d1de

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: kmelve

src/diagram-detector.ts

@@ -101,6 +101,48 @@ export function isBoundaryLine(line: string): boolean {
   return false;
 }
 
+/**
+ * Check if a line is a connector line between multiple boxes
+ * Connector lines have more than 2 vertical bars with only whitespace between them
+ * Example: "│   │   │" (connector) vs "│ foo │ bar │" (table row with content)
+ */
+export function isConnectorLine(line: string): boolean {
+  const trimmed = line.trim();
+  if (trimmed.length < 3) return false;
+
+  const verticalChars: string[] = [...BOX_CHARS.vertical, ...BOX_CHARS.asciiVertical];
+
+  // Split by vertical chars and collect segments
+  const segments: string[] = [];
+  let current = "";
+
+  for (const char of trimmed) {
+    if (verticalChars.includes(char)) {
+      segments.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  segments.push(current); // last segment after final pipe
+
+  // Count vertical chars (segments.length - 1)
+  const pipeCount = segments.length - 1;
+
+  // Need more than 2 vertical chars to be a connector line
+  if (pipeCount <= 2) return false;
+
+  // Check interior segments (skip first and last as they can be empty)
+  // All interior segments must be whitespace-only
+  for (let i = 1; i < segments.length - 1; i++) {
+    if (segments[i].trim() !== "") {
+      return false; // Has non-whitespace content
+    }
+  }
+
+  return true;
+}
+
 /**
  * Check if a line is a content line that should be normalized
  * Content lines both START and END with a vertical border character
@@ -118,6 +160,11 @@ export function isContentLine(line: string): boolean {
   const firstChar = trimmed[0];
   const lastChar = trimmed[trimmed.length - 1];
 
+  // Exclude connector lines (multiple pipes with only whitespace between)
+  if (isConnectorLine(line)) {
+    return false;
+  }
+
   return verticalChars.includes(firstChar) && verticalChars.includes(lastChar);
 }
 

src/index.ts

@@ -5,6 +5,6 @@
 
 export { boxfix, boxfixDiagram } from "./boxfix.js";
 export { boxfixMarkdown } from "./markdown.js";
-export { isDiagram, isBoundaryLine, isContentLine, isTreeLine } from "./diagram-detector.js";
+export { isDiagram, isBoundaryLine, isContentLine, isConnectorLine, isTreeLine } from "./diagram-detector.js";
 export { getDisplayWidth, expandTabs } from "./width.js";
 export type { BoxfixResult, BoxfixStats, CodeBlock } from "./types.js";

test/boxfix.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect } from "vitest";
 import { boxfix, boxfixDiagram } from "../src/boxfix.js";
 import { boxfixMarkdown } from "../src/markdown.js";
 import { getDisplayWidth, expandTabs, sliceByDisplayColumn, mapDisplayColumnToCharIndex } from "../src/width.js";
-import { isDiagram, isBoundaryLine, isContentLine, isTreeLine, hasInnerBoundary } from "../src/diagram-detector.js";
+import { isDiagram, isBoundaryLine, isContentLine, isTreeLine, hasInnerBoundary, isConnectorLine } from "../src/diagram-detector.js";
 import { extractFilePath } from "../src/cli.js";
 
 describe("getDisplayWidth", () => {
@@ -76,6 +76,37 @@ describe("isBoundaryLine", () => {
   });
 });
 
+describe("isConnectorLine", () => {
+  it("detects connector line with 3 pipes and whitespace", () => {
+    expect(isConnectorLine("│   │   │")).toBe(true);
+  });
+
+  it("detects connector line with spaces and indentation", () => {
+    expect(isConnectorLine("                    │                 │                 │")).toBe(true);
+  });
+
+  it("detects ASCII connector line", () => {
+    expect(isConnectorLine("|   |   |")).toBe(true);
+  });
+
+  it("rejects table row with content between pipes", () => {
+    expect(isConnectorLine("│ foo │ bar │")).toBe(false);
+  });
+
+  it("rejects line with only 2 pipes (normal content)", () => {
+    expect(isConnectorLine("│ content │")).toBe(false);
+  });
+
+  it("rejects line with only 2 pipes and whitespace", () => {
+    expect(isConnectorLine("│   │")).toBe(false);
+  });
+
+  it("rejects short lines", () => {
+    expect(isConnectorLine("│")).toBe(false);
+    expect(isConnectorLine("││")).toBe(false);
+  });
+});
+
 describe("isContentLine", () => {
   it("detects line ending with │", () => {
     expect(isContentLine("│ content │")).toBe(true);
@@ -88,6 +119,11 @@ describe("isContentLine", () => {
   it("rejects boundary line", () => {
     expect(isContentLine("┌───┐")).toBe(false);
   });
+
+  it("rejects connector line with multiple pipes", () => {
+    expect(isConnectorLine("│   │   │")).toBe(true);
+    expect(isContentLine("│   │   │")).toBe(false);
+  });
 });
 
 describe("hasInnerBoundary", () => {
@@ -289,6 +325,27 @@ describe("boxfixDiagram", () => {
     const { result } = boxfixDiagram(input);
     expect(result).toBe(expected);
   });
+
+  it("does not modify connector lines between side-by-side boxes", () => {
+    // Regression test: connector lines with multiple pipes should not be padded
+    const input = `┌─────────────┐ ┌─────────────┐ ┌─────────────┐
+│ Box 1       │ │ Box 2       │ │ Box 3       │
+└─────────────┘ └─────────────┘ └─────────────┘
+                │             │             │
+                └─────────────┴─────────────┘`;
+    const { result, linesFixed } = boxfixDiagram(input);
+    expect(result).toBe(input);
+    expect(linesFixed).toBe(0);
+  });
+
+  it("does not modify spaced connector lines (real-world bug)", () => {
+    // Regression test from soderlind/admin-coach-tours
+    // The line "│                 │                 │" should not be padded
+    const input = `                    │                 │                 │`;
+    // This line should not be treated as a content line
+    expect(isContentLine(input)).toBe(false);
+    expect(isConnectorLine(input)).toBe(true);
+  });
 });
 
 describe("boxfix", () => {