bridges-cli 0.1.0 → 0.2.0

package/src/components/HashiGrid.tsx

@@ -30,12 +30,18 @@ type HashiGridProps = {
     hasSolution?: boolean
     /** Whether to show the solution */
     showSolution?: boolean
+    /** Whether to enable the solution feature */
+    enableSolutions?: boolean
     /** Current selection state for highlighting */
     selectionState?: SelectionState
     /** Minimum number value in the puzzle */
     minNumber?: number
     /** Maximum number value in the puzzle */
     maxNumber?: number
+    /** Whether the puzzle solution has been reached */
+    solutionReached?: boolean
+    /** Whether the grid is not fully connected but all nodes are filled */
+    gridNotConnected?: boolean
 }
 
 export default function HashiGrid({
@@ -47,9 +53,12 @@ export default function HashiGrid({
     isCustomPuzzle = false,
     hasSolution = false,
     showSolution = false,
+    enableSolutions = false,
     selectionState,
     minNumber,
     maxNumber,
+    solutionReached = false,
+    gridNotConnected = false,
 }: HashiGridProps) {
     validateGrid({ rows, numNodes })
 
@@ -85,11 +94,18 @@ export default function HashiGrid({
                         rowIndex={i}
                         highlightedNode={selectionState?.selectedNumber ?? undefined}
                         selectionState={selectionState}
+                        showSolution={showSolution}
                     />
                 ))}
             </Box>
             {showInstructions ? (
-                <Messages hasSolution={hasSolution} selectionState={selectionState} />
+                <Messages
+                    hasSolution={hasSolution}
+                    enableSolutions={enableSolutions}
+                    selectionState={selectionState}
+                    solutionReached={solutionReached}
+                    gridNotConnected={gridNotConnected}
+                />
             ) : null}
         </Box>
     )

package/src/components/HashiRow.tsx

@@ -5,6 +5,7 @@ import type { HashiNodeData, SelectionState } from '../types.ts'
 import {
     constructNode,
     getDisplayMode,
+    getNodeFilledState,
     NODE_WIDTH,
     OUTER_PADDING,
     ROW_HEIGHT,
@@ -16,6 +17,7 @@ type HashiRowProps = {
     highlightedNode?: number
     rowIndex: number
     selectionState?: SelectionState
+    showSolution?: boolean
 }
 
 export default function HashiRow({
@@ -23,6 +25,7 @@ export default function HashiRow({
     highlightedNode,
     rowIndex,
     selectionState,
+    showSolution,
 }: HashiRowProps) {
     // Each row consists of multiple lines of terminal output
     const lines: React.ReactNode[] = []
@@ -60,7 +63,17 @@ export default function HashiRow({
                 selectionState?.mode
             )
             const label = disambiguationMap[i]
-            rowItems.push(constructNode(node, line as 0 | 1 | 2, displayMode, label))
+            const filledState = getNodeFilledState(node)
+            rowItems.push(
+                constructNode(
+                    node,
+                    line as 0 | 1 | 2,
+                    displayMode,
+                    label,
+                    filledState,
+                    showSolution
+                )
+            )
 
             // Add space between columns except the last
             if (i < nodes.length - 1) {

package/src/components/Messages.tsx

@@ -8,27 +8,60 @@ type LegendItem = {
     disabled?: boolean
 }
 
-export function legendItems(hasSolution: boolean, isSelecting: boolean): LegendItem[] {
-    return [
+export function legendItems(
+    hasSolution: boolean,
+    enableSolutions: boolean,
+    isSelecting: boolean
+): LegendItem[] {
+    const items: LegendItem[] = [
         { key: 'p', description: 'Previous puzzle', disabled: isSelecting },
         { key: 'n', description: 'Next puzzle', disabled: isSelecting },
-        { key: 's', description: 'Show solution', disabled: isSelecting || !hasSolution },
-        { key: 'q', description: 'Quit' },
     ]
+
+    if (enableSolutions) {
+        items.push({
+            key: 's',
+            description: 'Show solution',
+            disabled: isSelecting || !hasSolution,
+        })
+    }
+
+    items.push({ key: 'q', description: 'Quit' })
+
+    return items
 }
 
 type MessagesProps = {
     hasSolution?: boolean
+    enableSolutions?: boolean
     selectionState?: SelectionState
+    solutionReached?: boolean
+    gridNotConnected?: boolean
 }
 
-export default function Messages({ hasSolution = false, selectionState }: MessagesProps) {
+export default function Messages({
+    hasSolution = false,
+    enableSolutions = false,
+    selectionState,
+    solutionReached = false,
+    gridNotConnected = false,
+}: MessagesProps) {
     const isSelecting = selectionState !== undefined && selectionState.mode !== 'idle'
 
     return (
         <Box flexDirection="column" marginTop={1}>
+            {solutionReached ? (
+                <Text bold color="green">
+                    Solution reached!
+                </Text>
+            ) : null}
+            {gridNotConnected ? (
+                <Text bold color="yellow">
+                    Grid is not fully connected
+                </Text>
+            ) : null}
             <Text bold>Controls:</Text>
-            {legendItems(hasSolution, isSelecting).map(item => (
+            {legendItems(hasSolution, enableSolutions, isSelecting).map(item => (
                 <Box key={item.key}>
                     <Text bold color={item.disabled ? 'gray' : undefined}>
                         {item.key}

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

@@ -22,9 +22,9 @@ describe('HashiRow component', () => {
                 rowIndex={0}
             />
         )
-        expect(lastFrame()).toEqual(` ╭───╮     ╭───╮
- │ 1 ├─────┤ 3 │
- ╰───╯     ╰───╯`)
+        expect(lastFrame()).toEqual(` \x1b[32m╭───╮\x1b[39m     ╭───╮
+ \x1b[32m│ 1 ├\x1b[39m─────┤ 3 │
+ \x1b[32m╰───╯\x1b[39m     ╰───╯`)
     })
 
     it('renders a vertical node', () => {
@@ -140,4 +140,29 @@ describe('HashiRow component', () => {
             )
         })
     })
+
+    describe('validation state colors', () => {
+        it('shows green on valid nodes in selected mode', () => {
+            const selectionState: SelectionState = {
+                mode: 'selected',
+                selectedNumber: 1,
+                direction: 'h',
+                matchingNodes: [{ row: 0, col: 0 }],
+                disambiguationLabels: [],
+                selectedNode: { row: 0, col: 0 },
+            }
+            const { lastFrame } = render(
+                <HashiRow
+                    nodes={[{ value: 1, lineRight: 1 }, { value: ' ' }, { value: 1, lineLeft: 1 }]}
+                    rowIndex={0}
+                    selectionState={selectionState}
+                />
+            )
+            expect(lastFrame()).toEqual(
+                ` \x1b[32m\x1b[1m╭───╮\x1b[22m\x1b[39m     \x1b[32m\x1b[2m╭───╮\x1b[22m\x1b[39m
+ \x1b[32m\x1b[1m│ 1 ├\x1b[22m\x1b[39m     \x1b[32m\x1b[2m┤ 1 │\x1b[22m\x1b[39m
+ \x1b[32m\x1b[1m╰───╯\x1b[22m\x1b[39m     \x1b[32m\x1b[2m╰───╯\x1b[22m\x1b[39m`
+            )
+        })
+    })
 })

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

@@ -4,8 +4,17 @@ import { describe, expect, it } from 'vitest'
 import Messages, { legendItems } from '../Messages.tsx'
 
 describe('Messages', () => {
-    it('renders the legend', () => {
-        const { lastFrame } = render(<Messages />)
+    it('does not show solution option when enableSolutions is false', () => {
+        const { lastFrame } = render(<Messages enableSolutions={false} />)
+        expect(lastFrame()).toContain('Controls:')
+        expect(lastFrame()).toContain('p: Previous puzzle')
+        expect(lastFrame()).toContain('n: Next puzzle')
+        expect(lastFrame()).not.toContain('s: Show solution')
+        expect(lastFrame()).toContain('q: Quit')
+    })
+
+    it('shows solution option when enableSolutions is true', () => {
+        const { lastFrame } = render(<Messages enableSolutions={true} />)
         expect(lastFrame()).toContain('Controls:')
         expect(lastFrame()).toContain('p: Previous puzzle')
         expect(lastFrame()).toContain('n: Next puzzle')
@@ -13,47 +22,61 @@ describe('Messages', () => {
         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)
-        })
+    describe('legendItems', () => {
+        describe('when enableSolutions is false', () => {
+            it('shows n/p as enabled when idle', () => {
+                const items = legendItems(true, false, 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).toBeUndefined()
+            })
 
-        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 as disabled in selecting-node mode', () => {
+                const items = legendItems(true, false, 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).toBeUndefined()
+            })
         })
 
-        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)
-        })
+        describe('when enableSolutions is true', () => {
+            it('shows n/p/s as enabled when idle', () => {
+                const items = legendItems(true, 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 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 n/p/s as disabled in selecting-node mode', () => {
+                const items = legendItems(true, 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, true, 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)
+            it('shows s as enabled when solution exists', () => {
+                const items = legendItems(true, true, false)
+                const s = items.find(i => i.key === 's')
+                expect(s?.disabled).toBe(false)
+            })
         })
     })
 })

package/src/index.tsx

@@ -12,6 +12,7 @@ const packageJson = JSON.parse(readFileSync(resolve(__dirname, '../package.json'
 
 type CliOptions = {
     puzzle: string | undefined
+    enableSolutions: boolean
 }
 
 const program = new Command()
@@ -38,6 +39,7 @@ program
   Example (3x3 with corner islands):
     --puzzle "3x3:1a2.c.1a2"`
     )
+    .option('--enable-solutions', 'Enable the solution viewing feature', false)
     .parse(process.argv)
 
 const options = program.opts<CliOptions>()
@@ -49,4 +51,10 @@ if (options.puzzle) {
     puzzles = [{ encoding: options.puzzle }, ...samplePuzzles]
 }
 
-render(<Game puzzles={puzzles} hasCustomPuzzle={hasCustomPuzzle} />)
+render(
+    <Game
+        puzzles={puzzles}
+        hasCustomPuzzle={hasCustomPuzzle}
+        enableSolutions={options.enableSolutions}
+    />
+)

package/src/utils/bridges.ts

@@ -1,5 +1,7 @@
 import type { HashiNodeData, HashiNodeDisplayMode } from '../types.ts'
 
+export type NodeFilledState = 'valid' | 'invalid' | 'incomplete'
+
 export const ROW_HEIGHT = 3
 export const NODE_WIDTH = 5
 export const SPACE_BETWEEN = 0
@@ -50,6 +52,170 @@ export function validateGrid({ rows, numNodes }: HashiGridValidationProps): void
     }
 }
 
+/**
+ * Check if the puzzle is solved - all numbered nodes have the correct number of bridges
+ * and all nodes form a connected graph.
+ */
+export function checkSolution(rows: HashiNodeData[][]): boolean {
+    for (const row of rows) {
+        for (const node of row) {
+            const state = getNodeFilledState(node)
+            if (state !== null && state !== 'valid') {
+                return false
+            }
+        }
+    }
+
+    if (!isGraphConnected(rows)) {
+        return false
+    }
+
+    return true
+}
+
+/**
+ * Check if all numbered nodes have the correct number of bridges (regardless of connectivity).
+ */
+export function areAllNodesFilled(rows: HashiNodeData[][]): boolean {
+    for (const row of rows) {
+        for (const node of row) {
+            const state = getNodeFilledState(node)
+            if (state !== null && state !== 'valid') {
+                return false
+            }
+        }
+    }
+    return true
+}
+
+/**
+ * Check if the graph is connected (regardless of whether nodes have correct bridge counts).
+ */
+export function isConnected(rows: HashiNodeData[][]): boolean {
+    return isGraphConnected(rows)
+}
+
+/**
+ * Check if all numbered nodes form a connected graph using BFS.
+ */
+function isGraphConnected(rows: HashiNodeData[][]): boolean {
+    const numRows = rows.length
+    if (numRows === 0) return true
+    const numCols = rows[0].length
+
+    const numberedNodes: [number, number][] = []
+    for (let r = 0; r < numRows; r++) {
+        for (let c = 0; c < numCols; c++) {
+            if (typeof rows[r][c].value === 'number') {
+                numberedNodes.push([r, c])
+            }
+        }
+    }
+
+    if (numberedNodes.length === 0) return true
+
+    const visited = new Set<string>()
+    const queue: [number, number][] = [[numberedNodes[0][0], numberedNodes[0][1]]]
+    visited.add(`${numberedNodes[0][0]},${numberedNodes[0][1]}`)
+
+    while (queue.length > 0) {
+        const next = queue.shift()
+        if (!next) continue
+        const [r, c] = next
+        const node = rows[r]?.[c]
+        if (!node) continue
+
+        if (node.lineRight === 1 || node.lineRight === 2) {
+            const dest = findNodeInDirection(rows, r, c, 0, 1)
+            if (dest) {
+                const key = `${dest[0]},${dest[1]}`
+                if (!visited.has(key)) {
+                    visited.add(key)
+                    queue.push(dest)
+                }
+            }
+        }
+
+        if (node.lineLeft === 1 || node.lineLeft === 2) {
+            const dest = findNodeInDirection(rows, r, c, 0, -1)
+            if (dest) {
+                const key = `${dest[0]},${dest[1]}`
+                if (!visited.has(key)) {
+                    visited.add(key)
+                    queue.push(dest)
+                }
+            }
+        }
+
+        if (node.lineDown === 1 || node.lineDown === 2) {
+            const dest = findNodeInDirection(rows, r, c, 1, 0)
+            if (dest) {
+                const key = `${dest[0]},${dest[1]}`
+                if (!visited.has(key)) {
+                    visited.add(key)
+                    queue.push(dest)
+                }
+            }
+        }
+
+        if (node.lineUp === 1 || node.lineUp === 2) {
+            const dest = findNodeInDirection(rows, r, c, -1, 0)
+            if (dest) {
+                const key = `${dest[0]},${dest[1]}`
+                if (!visited.has(key)) {
+                    visited.add(key)
+                    queue.push(dest)
+                }
+            }
+        }
+    }
+
+    return visited.size === numberedNodes.length
+}
+
+function findNodeInDirection(
+    rows: HashiNodeData[][],
+    startR: number,
+    startC: number,
+    dRow: number,
+    dCol: number
+): [number, number] | null {
+    const numRows = rows.length
+    const numCols = rows[0].length
+    let r = startR + dRow
+    let c = startC + dCol
+
+    while (r >= 0 && r < numRows && c >= 0 && c < numCols) {
+        if (typeof rows[r][c].value === 'number') {
+            return [r, c]
+        }
+        r += dRow
+        c += dCol
+    }
+
+    return null
+}
+
+/**
+ * Determines if a node has the correct number of bridges, too many, or too few.
+ */
+export function getNodeFilledState(node: HashiNodeData): NodeFilledState | null {
+    if (typeof node.value !== 'number') {
+        return null
+    }
+
+    const bridges =
+        (node.lineUp ?? 0) + (node.lineDown ?? 0) + (node.lineLeft ?? 0) + (node.lineRight ?? 0)
+
+    if (bridges === node.value) {
+        return 'valid'
+    }
+    if (bridges > node.value) {
+        return 'invalid'
+    }
+    return 'incomplete'
+}
+
 /**
  * Determines the display mode for a node based on the highlighted node value.
  */
@@ -96,14 +262,35 @@ export function constructNode(
     node: HashiNodeData,
     line: 0 | 1 | 2,
     displayMode: HashiNodeDisplayMode = 'normal',
-    disambiguationLabel?: string
+    disambiguationLabel?: string,
+    validationState?: NodeFilledState | null,
+    showSolution?: boolean
 ): string {
+    // Determine color prefix based on validation state
+    const getColorPrefix = (): string => {
+        if (validationState === 'valid') {
+            return '\x1b[32m' // green
+        }
+        if (validationState === 'invalid') {
+            return '\x1b[31m' // red
+        }
+        return ''
+    }
+
+    const colorReset = '\x1b[39m'
+    const colorPrefix = displayMode === 'dim' ? '' : getColorPrefix()
+    const useColor = colorPrefix !== ''
+
     // 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)
+        const content = line === MIDDLE_ROW ? '─────' : ' '.repeat(NODE_WIDTH)
+        if (showSolution) {
+            return `\x1b[32m${content}\x1b[39m`
+        }
+        return useColor ? `${getColorPrefix()}${content}${colorReset}` : content
     }
 
     // Double horizontal line
@@ -111,7 +298,11 @@ export function constructNode(
         if (displayMode === 'dim') {
             return line === MIDDLE_ROW ? `\x1b[2m═════\x1b[22m` : ' '.repeat(NODE_WIDTH)
         }
-        return line === MIDDLE_ROW ? '═════' : ' '.repeat(NODE_WIDTH)
+        const content = line === MIDDLE_ROW ? '═════' : ' '.repeat(NODE_WIDTH)
+        if (showSolution) {
+            return `\x1b[32m${content}\x1b[39m`
+        }
+        return useColor ? `${getColorPrefix()}${content}${colorReset}` : content
     }
 
     // Vertical line
@@ -119,7 +310,11 @@ export function constructNode(
         if (displayMode === 'dim') {
             return `\x1b[2m  │  \x1b[22m`
         }
-        return '  │  '
+        const content = '  │  '
+        if (showSolution) {
+            return `\x1b[32m${content}\x1b[39m`
+        }
+        return useColor ? `${getColorPrefix()}${content}${colorReset}` : content
     }
 
     // Double vertical line
@@ -127,7 +322,11 @@ export function constructNode(
         if (displayMode === 'dim') {
             return `\x1b[2m  ║  \x1b[22m`
         }
-        return '  ║  '
+        const content = '  ║  '
+        if (showSolution) {
+            return `\x1b[32m${content}\x1b[39m`
+        }
+        return useColor ? `${getColorPrefix()}${content}${colorReset}` : content
     }
 
     // Node with value to render
@@ -137,32 +336,57 @@ export function constructNode(
             const label = disambiguationLabel ? disambiguationLabel : '─'
             const border = `╭${label}${up}─╮`
             if (displayMode === 'highlight') {
-                return `\x1b[1m${border}\x1b[22m`
+                const highlighted = `\x1b[1m${border}\x1b[22m`
+                if (validationState === 'valid' || validationState === 'invalid') {
+                    return `${getColorPrefix()}${highlighted}${colorReset}`
+                }
+                return highlighted
             }
             if (displayMode === 'dim') {
-                return `\x1b[2m${border}\x1b[22m`
+                const dimmedBorder = `\x1b[2m${border}\x1b[22m`
+                if (validationState === 'valid' || validationState === 'invalid') {
+                    return `${getColorPrefix()}${dimmedBorder}${colorReset}`
+                }
+                return dimmedBorder
             }
-            return border
+            return useColor ? `${getColorPrefix()}${border}${colorReset}` : border
         } else if (line === MIDDLE_ROW) {
             const left = node.lineLeft === 2 ? '╡' : node.lineLeft === 1 ? '┤' : '│'
             const right = node.lineRight === 2 ? '╞' : node.lineRight === 1 ? '├' : '│'
+            const content = `${left} ${node.value} ${right}`
             if (displayMode === 'highlight') {
-                return `\x1b[1m${left} ${node.value} ${right}\x1b[22m`
+                const highlighted = `\x1b[1m${content}\x1b[22m`
+                if (validationState === 'valid' || validationState === 'invalid') {
+                    return `${getColorPrefix()}${highlighted}${colorReset}`
+                }
+                return highlighted
             }
             if (displayMode === 'dim') {
-                return `\x1b[2m${left} ${node.value} ${right}\x1b[22m`
+                const dimmedContent = `\x1b[2m${content}\x1b[22m`
+                if (validationState === 'valid' || validationState === 'invalid') {
+                    return `${getColorPrefix()}${dimmedContent}${colorReset}`
+                }
+                return dimmedContent
             }
-            return `${left} ${node.value} ${right}`
+            return useColor ? `${getColorPrefix()}${content}${colorReset}` : content
         } 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`
+                const highlighted = `\x1b[1m${border}\x1b[22m`
+                if (validationState === 'valid' || validationState === 'invalid') {
+                    return `${getColorPrefix()}${highlighted}${colorReset}`
+                }
+                return highlighted
             }
             if (displayMode === 'dim') {
-                return `\x1b[2m${border}\x1b[22m`
+                const dimmedBorder = `\x1b[2m${border}\x1b[22m`
+                if (validationState === 'valid' || validationState === 'invalid') {
+                    return `${getColorPrefix()}${dimmedBorder}${colorReset}`
+                }
+                return dimmedBorder
             }
-            return border
+            return useColor ? `${getColorPrefix()}${border}${colorReset}` : border
         }
     }