bridges-cli 0.0.1 → 0.1.0

package/src/components/__tests__/Messages.test.tsx

@@ -1,7 +1,7 @@
 import { render } from 'ink-testing-library'
 import { describe, expect, it } from 'vitest'
 
-import Messages from '../Messages.tsx'
+import Messages, { legendItems } from '../Messages.tsx'
 
 describe('Messages', () => {
     it('renders the legend', () => {
@@ -9,6 +9,51 @@ describe('Messages', () => {
         expect(lastFrame()).toContain('Controls:')
         expect(lastFrame()).toContain('p: Previous puzzle')
         expect(lastFrame()).toContain('n: Next puzzle')
+        expect(lastFrame()).toContain('s: Show solution')
         expect(lastFrame()).toContain('q: Quit')
     })
+
+    describe('disabled state in selection mode', () => {
+        it('shows n/p/s as enabled when idle', () => {
+            const items = legendItems(true, false)
+            const p = items.find(i => i.key === 'p')
+            const n = items.find(i => i.key === 'n')
+            const s = items.find(i => i.key === 's')
+            expect(p?.disabled).toBe(false)
+            expect(n?.disabled).toBe(false)
+            expect(s?.disabled).toBe(false)
+        })
+
+        it('shows n/p/s as disabled in selecting-node mode', () => {
+            const items = legendItems(true, true)
+            const p = items.find(i => i.key === 'p')
+            const n = items.find(i => i.key === 'n')
+            const s = items.find(i => i.key === 's')
+            expect(p?.disabled).toBe(true)
+            expect(n?.disabled).toBe(true)
+            expect(s?.disabled).toBe(true)
+        })
+
+        it('shows n/p/s as disabled in disambiguation mode', () => {
+            const items = legendItems(true, true)
+            const p = items.find(i => i.key === 'p')
+            const n = items.find(i => i.key === 'n')
+            const s = items.find(i => i.key === 's')
+            expect(p?.disabled).toBe(true)
+            expect(n?.disabled).toBe(true)
+            expect(s?.disabled).toBe(true)
+        })
+
+        it('shows s as disabled when no solution exists', () => {
+            const items = legendItems(false, false)
+            const s = items.find(i => i.key === 's')
+            expect(s?.disabled).toBe(true)
+        })
+
+        it('shows s as enabled when solution exists', () => {
+            const items = legendItems(true, false)
+            const s = items.find(i => i.key === 's')
+            expect(s?.disabled).toBe(false)
+        })
+    })
 })

package/src/demo.tsx

@@ -0,0 +1,20 @@
+#!/usr/bin/env -S bun run
+
+import { render } from 'ink'
+
+import HashiRow from './components/HashiRow.tsx'
+
+render(
+    <HashiRow
+        nodes={[
+            { value: 1 },
+            { value: '-' },
+            { value: 2 },
+            { value: '#' },
+            { value: 2 },
+            { value: 3 },
+        ]}
+        rowIndex={0}
+        highlightedNode={2}
+    />
+)

package/src/index.tsx

@@ -1,13 +1,16 @@
 #!/usr/bin/env -S bun run
 
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
 import { Command } from 'commander'
 import { render } from 'ink'
 
 import Game from './Game.tsx'
-import { type PuzzleData, samplePuzzles } from './utils/samplePuzzles.ts'
+import { type PuzzleData, samplePuzzles } from './utils/puzzle-encoding.ts'
+
+const packageJson = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf8'))
 
 type CliOptions = {
-    stdout: boolean
     puzzle: string | undefined
 }
 
@@ -16,8 +19,25 @@ const program = new Command()
 program
     .name('bridges')
     .description('Bridges (Hashiwokakero) puzzle game')
-    .option('-s, --stdout', 'Output to stdout and exit (for testing)')
-    .option('-p, --puzzle <puzzle>', 'Puzzle shorthand encoding')
+    .version(packageJson.version, '-v, --version')
+    .option(
+        '-p, --puzzle <puzzle>',
+        `Puzzle shorthand encoding
+  Format: "WIDTHxHEIGHT:row1.row2.row3..."
+
+  Node encoding:
+    - Digits (1-8): island with that value
+    - Letters (a-z): space between islands (b=2, etc.)
+
+  Bridge encoding (optional):
+    - "-": single horizontal bridge
+    - "=": double horizontal bridge
+    - "|": single vertical bridge
+    - "#": double vertical bridge
+
+  Example (3x3 with corner islands):
+    --puzzle "3x3:1a2.c.1a2"`
+    )
     .parse(process.argv)
 
 const options = program.opts<CliOptions>()
@@ -29,6 +49,4 @@ if (options.puzzle) {
     puzzles = [{ encoding: options.puzzle }, ...samplePuzzles]
 }
 
-render(
-    <Game puzzles={puzzles} hasCustomPuzzle={hasCustomPuzzle} stdout={options.stdout || false} />
-)
+render(<Game puzzles={puzzles} hasCustomPuzzle={hasCustomPuzzle} />)

package/src/types.ts

@@ -1,3 +1,6 @@
+/**
+ * HashiNode types
+ */
 export type HashiNodeData = {
     value: number | '-' | '=' | '#' | ' ' | '|'
     /** Num lines connected on left, undefined if 0. */
@@ -9,3 +12,34 @@ export type HashiNodeData = {
     /** Num lines connected below, undefined if 0. */
     lineDown?: 1 | 2
 }
+
+export type HashiNodeDisplayMode = 'normal' | 'highlight' | 'dim'
+
+export type HashiNodeOptions = {
+    displayMode?: HashiNodeDisplayMode
+    label?: string
+}
+
+/**
+ * Game operation types
+ */
+export type SelectionMode = 'idle' | 'selecting-node' | 'disambiguation' | 'selected' | 'invalid'
+
+export type Direction = 'h' | 'j' | 'k' | 'l'
+
+export type PlacedBridge = {
+    from: { row: number; col: number }
+    to: { row: number; col: number }
+    count?: number
+}
+
+export type SelectionState = {
+    mode: SelectionMode
+    selectedNumber: number | null
+    direction: Direction | null
+    matchingNodes: { row: number; col: number }[]
+    disambiguationLabels: string[]
+    selectedNode: { row: number; col: number } | null
+    bridgeErased?: boolean
+    isDoubleBridge?: boolean
+}

package/src/utils/__tests__/bridges.test.tsx

@@ -0,0 +1,137 @@
+import { describe, expect, it } from 'vitest'
+import type { HashiNodeData } from '../../types.ts'
+import { constructNode, getDisplayMode } from '../bridges.ts'
+
+// biome-ignore lint/security/noSecrets: false positive
+describe('getDisplayMode()', () => {
+    it('returns normal when highlightedNode is undefined', () => {
+        const node: HashiNodeData = { value: 1 }
+        expect(getDisplayMode(node, undefined)).toBe('normal')
+    })
+
+    it('returns highlight when node value matches highlightedNode', () => {
+        const node: HashiNodeData = { value: 2 }
+        expect(getDisplayMode(node, 2)).toBe('highlight')
+    })
+
+    it('returns dim when node value does not match highlightedNode', () => {
+        const node: HashiNodeData = { value: 1 }
+        expect(getDisplayMode(node, 2)).toBe('dim')
+    })
+
+    it('returns dim for bridge nodes when highlightedNode is set', () => {
+        expect(getDisplayMode({ value: '-' }, 2)).toBe('dim')
+        expect(getDisplayMode({ value: '|' }, 2)).toBe('dim')
+        expect(getDisplayMode({ value: '#' }, 2)).toBe('dim')
+    })
+
+    it('returns highlight for bridge nodes that are the highlighted value', () => {
+        expect(getDisplayMode({ value: '-' }, 2)).toBe('dim')
+    })
+})
+
+describe('constructNode()', () => {
+    describe('empty node', () => {
+        it('renders space value with no lines', () => {
+            const node: HashiNodeData = { value: ' ' }
+            expect(constructNode(node, 0)).toEqual('     ')
+            expect(constructNode(node, 1)).toEqual('     ')
+            expect(constructNode(node, 2)).toEqual('     ')
+        })
+    })
+
+    describe('horizontal line node', () => {
+        it('renders a horizontal line in the middle', () => {
+            const node: HashiNodeData = { value: '-' }
+            expect(constructNode(node, 0)).toEqual('     ')
+            expect(constructNode(node, 1)).toEqual('─────')
+            expect(constructNode(node, 2)).toEqual('     ')
+        })
+
+        it('renders a double horizontal line in the middle', () => {
+            const node: HashiNodeData = { value: '=' }
+            expect(constructNode(node, 0)).toEqual('     ')
+            expect(constructNode(node, 1)).toEqual('═════')
+            expect(constructNode(node, 2)).toEqual('     ')
+        })
+    })
+
+    describe('vertical line node', () => {
+        it('renders a vertical line in the center', () => {
+            const node: HashiNodeData = { value: '|' }
+            expect(constructNode(node, 0)).toEqual('  │  ')
+            expect(constructNode(node, 1)).toEqual('  │  ')
+            expect(constructNode(node, 2)).toEqual('  │  ')
+        })
+
+        it('renders a double vertical line in the center', () => {
+            const node: HashiNodeData = { value: '#' }
+            expect(constructNode(node, 0)).toEqual('  ║  ')
+            expect(constructNode(node, 1)).toEqual('  ║  ')
+            expect(constructNode(node, 2)).toEqual('  ║  ')
+        })
+    })
+
+    describe('node with value', () => {
+        describe('TOP_ROW', () => {
+            it('renders top border', () => {
+                const node: HashiNodeData = { value: 5 }
+                expect(constructNode(node, 0)).toEqual('╭───╮')
+            })
+
+            it('renders border with vertical line up', () => {
+                const node: HashiNodeData = { value: 5, lineUp: 1 }
+                expect(constructNode(node, 0)).toEqual('╭─┴─╮')
+            })
+
+            it('renders border with double vertical line up', () => {
+                const node: HashiNodeData = { value: 5, lineUp: 2 }
+                expect(constructNode(node, 0)).toEqual('╭─╨─╮')
+            })
+        })
+
+        describe('MIDDLE_ROW', () => {
+            it('renders middle row - value with vertical borders', () => {
+                const node: HashiNodeData = { value: 5 }
+                expect(constructNode(node, 1)).toEqual('│ 5 │')
+            })
+
+            it('renders value with horizontal line on left', () => {
+                const node: HashiNodeData = { value: 5, lineLeft: 1 }
+                expect(constructNode(node, 1)).toEqual('┤ 5 │')
+            })
+
+            it('renders value with horizontal line on right', () => {
+                const node: HashiNodeData = { value: 5, lineRight: 1 }
+                expect(constructNode(node, 1)).toEqual('│ 5 ├')
+            })
+
+            it('renders value with horizontal lines on both sides', () => {
+                const node: HashiNodeData = { value: 5, lineLeft: 1, lineRight: 1 }
+                expect(constructNode(node, 1)).toEqual('┤ 5 ├')
+            })
+
+            it('renders value with double horizontal lines on both sides', () => {
+                const node: HashiNodeData = { value: 5, lineLeft: 2, lineRight: 2 }
+                expect(constructNode(node, 1)).toEqual('╡ 5 ╞')
+            })
+        })
+
+        describe('BOTTOM_ROW', () => {
+            it('renders bottom border without lines', () => {
+                const node: HashiNodeData = { value: 5 }
+                expect(constructNode(node, 2)).toEqual('╰───╯')
+            })
+
+            it('renders border with vertical line down', () => {
+                const node: HashiNodeData = { value: 5, lineDown: 1 }
+                expect(constructNode(node, 2)).toEqual('╰─┬─╯')
+            })
+
+            it('renders border with double vertical line down', () => {
+                const node: HashiNodeData = { value: 5, lineDown: 2 }
+                expect(constructNode(node, 2)).toEqual('╰─╥─╯')
+            })
+        })
+    })
+})

package/src/utils/__tests__/findNodeInDirection.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest'
+
+import { findNodeInDirection } from '../usePuzzleInput.ts'
+
+describe('findNodeInDirection', () => {
+    describe('1x2 grid (horizontal)', () => {
+        const grid = [[{ value: 1 }, { value: 2 }]]
+
+        it('finds node to the right', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'l')).toEqual({ row: 0, col: 1 })
+        })
+
+        it('finds node to the left', () => {
+            expect(findNodeInDirection(grid, 0, 1, 'h')).toEqual({ row: 0, col: 0 })
+        })
+
+        it('returns null when no node to the right', () => {
+            expect(findNodeInDirection(grid, 0, 1, 'l')).toBe(null)
+        })
+
+        it('returns null when no node to the left', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'h')).toBe(null)
+        })
+
+        it('returns null for vertical directions (no rows above/below)', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'j')).toBe(null)
+            expect(findNodeInDirection(grid, 0, 0, 'k')).toBe(null)
+        })
+    })
+
+    describe('2x1 grid (vertical)', () => {
+        const grid = [[{ value: 1 }], [{ value: 2 }]]
+
+        it('finds node below', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'j')).toEqual({ row: 1, col: 0 })
+        })
+
+        it('finds node above', () => {
+            expect(findNodeInDirection(grid, 1, 0, 'k')).toEqual({ row: 0, col: 0 })
+        })
+
+        it('returns null when no node below', () => {
+            expect(findNodeInDirection(grid, 1, 0, 'j')).toBe(null)
+        })
+
+        it('returns null when no node above', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'k')).toBe(null)
+        })
+
+        it('returns null for horizontal directions (no cols left/right)', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'h')).toBe(null)
+            expect(findNodeInDirection(grid, 0, 0, 'l')).toBe(null)
+        })
+    })
+
+    describe('3x3 grid with empty cells', () => {
+        const grid: { value: number | '-' | '=' | '#' | ' ' | '|' }[][] = [
+            [{ value: 1 }, { value: ' ' }, { value: 2 }],
+            [{ value: ' ' }, { value: '#' }, { value: ' ' }],
+            [{ value: 3 }, { value: ' ' }, { value: 4 }],
+        ]
+
+        it('finds node across empty cells', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'l')).toEqual({ row: 0, col: 2 })
+        })
+
+        it('finds node across empty cells (down)', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'j')).toEqual({ row: 2, col: 0 })
+        })
+
+        it('returns node when blocked by wall (#) but path around exists', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'j')).toEqual({ row: 2, col: 0 })
+        })
+    })
+})

package/src/utils/__tests__/{parsePuzzle.test.ts → puzzle-encoding.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import { parsePuzzle } from '../parsePuzzle.ts'
+import { parsePuzzle } from '../puzzle-encoding.ts'
 
 describe('parsePuzzle', () => {
     describe('encodings without the solution (bridges)', () => {

package/src/utils/bridges.ts

@@ -0,0 +1,171 @@
+import type { HashiNodeData, HashiNodeDisplayMode } from '../types.ts'
+
+export const ROW_HEIGHT = 3
+export const NODE_WIDTH = 5
+export const SPACE_BETWEEN = 0
+export const OUTER_PADDING = 1
+
+export const TOP_ROW = 0
+export const MIDDLE_ROW = 1
+export const BOTTOM_ROW = 2
+
+export type HashiGridValidationProps = {
+    rows: HashiNodeData[][]
+    numNodes: number
+}
+
+/**
+ * Ensure the grid data is consistent with a valid Bridges puzzle.
+ */
+export function validateGrid({ rows, numNodes }: HashiGridValidationProps): void {
+    if (!rows || rows.length === 0) {
+        throw new Error('HashiGrid: empty data supplied')
+    }
+
+    let rowCount = 0
+    for (const nodes of rows) {
+        const prefix = `HashiGrid row ${rowCount}: `
+
+        if (nodes.length !== numNodes) {
+            throw new Error(`${prefix}expected ${numNodes} nodes, got ${nodes.length}`)
+        }
+
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i]
+            if (!node) {
+                throw new Error(`${prefix}node at position ${i} is undefined`)
+            }
+            if (
+                typeof node.value !== 'number' &&
+                node.value !== '-' &&
+                node.value !== '=' &&
+                node.value !== ' ' &&
+                node.value !== '#' &&
+                node.value !== '|'
+            ) {
+                throw new Error(`${prefix}node at position ${i} has invalid value: ${node.value}`)
+            }
+        }
+        rowCount++
+    }
+}
+
+/**
+ * Determines the display mode for a node based on the highlighted node value.
+ */
+export function getDisplayMode(
+    node: HashiNodeData,
+    highlightedNode?: number,
+    row?: number,
+    col?: number,
+    selectedNode?: { row: number; col: number } | null,
+    mode?: string
+): HashiNodeDisplayMode {
+    // In selecting-node, selected, or invalid mode, highlight only the specific selected node
+    if (
+        (mode === 'selecting-node' || mode === 'selected' || mode === 'invalid') &&
+        selectedNode &&
+        row !== undefined &&
+        col !== undefined
+    ) {
+        if (row === selectedNode.row && col === selectedNode.col) {
+            return 'highlight'
+        }
+        return 'dim'
+    }
+
+    if (highlightedNode === undefined) {
+        return 'normal'
+    }
+    if (typeof node.value === 'number' && node.value === highlightedNode) {
+        return 'highlight'
+    }
+
+    // Bridge values are strings, so they can never match a number highlightedNode
+    return 'dim'
+}
+
+/**
+ * Build the HashiGrid node with its value and borders. Options:
+ *   - node with a value (always 1 digit)
+ *   - empty node - render just spaces
+ *   - horizontal line - single and double
+ *   - vertical line - single and double
+ */
+export function constructNode(
+    node: HashiNodeData,
+    line: 0 | 1 | 2,
+    displayMode: HashiNodeDisplayMode = 'normal',
+    disambiguationLabel?: string
+): string {
+    // Horizontal line
+    if (node.value === '-') {
+        if (displayMode === 'dim') {
+            return line === MIDDLE_ROW ? `\x1b[2m─────\x1b[22m` : ' '.repeat(NODE_WIDTH)
+        }
+        return line === MIDDLE_ROW ? '─────' : ' '.repeat(NODE_WIDTH)
+    }
+
+    // Double horizontal line
+    if (node.value === '=') {
+        if (displayMode === 'dim') {
+            return line === MIDDLE_ROW ? `\x1b[2m═════\x1b[22m` : ' '.repeat(NODE_WIDTH)
+        }
+        return line === MIDDLE_ROW ? '═════' : ' '.repeat(NODE_WIDTH)
+    }
+
+    // Vertical line
+    if (node.value === '|') {
+        if (displayMode === 'dim') {
+            return `\x1b[2m  │  \x1b[22m`
+        }
+        return '  │  '
+    }
+
+    // Double vertical line
+    if (node.value === '#') {
+        if (displayMode === 'dim') {
+            return `\x1b[2m  ║  \x1b[22m`
+        }
+        return '  ║  '
+    }
+
+    // Node with value to render
+    if (node.value !== ' ') {
+        if (line === TOP_ROW) {
+            const up = node.lineUp === 2 ? '╨' : node.lineUp === 1 ? '┴' : '─'
+            const label = disambiguationLabel ? disambiguationLabel : '─'
+            const border = `╭${label}${up}─╮`
+            if (displayMode === 'highlight') {
+                return `\x1b[1m${border}\x1b[22m`
+            }
+            if (displayMode === 'dim') {
+                return `\x1b[2m${border}\x1b[22m`
+            }
+            return border
+        } else if (line === MIDDLE_ROW) {
+            const left = node.lineLeft === 2 ? '╡' : node.lineLeft === 1 ? '┤' : '│'
+            const right = node.lineRight === 2 ? '╞' : node.lineRight === 1 ? '├' : '│'
+            if (displayMode === 'highlight') {
+                return `\x1b[1m${left} ${node.value} ${right}\x1b[22m`
+            }
+            if (displayMode === 'dim') {
+                return `\x1b[2m${left} ${node.value} ${right}\x1b[22m`
+            }
+            return `${left} ${node.value} ${right}`
+        } else if (line === BOTTOM_ROW) {
+            const down = node.lineDown === 2 ? '╥' : node.lineDown === 1 ? '┬' : '─'
+            const border = `╰─${down}─╯`
+            if (displayMode === 'highlight') {
+                return `\x1b[1m${border}\x1b[22m`
+            }
+            if (displayMode === 'dim') {
+                return `\x1b[2m${border}\x1b[22m`
+            }
+            return border
+        }
+    }
+
+    // Empty node
+    return ' '.repeat(NODE_WIDTH)
+}