bridges-cli 0.0.1 → 0.2.0

package/AGENTS.md

@@ -5,20 +5,22 @@ This is a CLI renderer for Hashiwokakero (Bridges) puzzles. It renders a grid of
 ## Commands
 
 - `bun start` - Run the puzzle (interactive mode)
-- `bun start --stdout` - Run puzzle and output to stdout (for testing)
 - `bun start --puzzle <encoding>` - Run with a specific puzzle encoding
 - `bun run test` - Run unit tests
-- `bun run typehceck` - typescript typechecker
+- `bun run typecheck` - typescript typechecker
 - `bun run lint` - Lint and format
 
 ## Testing
 
-Tests use Vitest with `@testing-library/react` patterns via `ink-testing-library`.
+- Tests use Vitest with `@testing-library/react` patterns via `ink-testing-library`.
+- The output is a grid drawn with ascii, and tests often do exact matches. When nodes are
+highlighted, they have ANSI codes to appear as bold/dim or red/green. The tests will put
+these codes directly in the test expectation around the nodes.
 
 ## Code Style
 
-- Biome is configured in `biome.json`
-- Run linting before committing
-- No custom ESLint/Prettier config - Biome handles everything
+- Run linting before committing - the lint command uses Biome.js
 - Add comments to separate code blocks. Don't remove existing comments.
+- Add a comment above functions that explain the intention of the function.
+- Don't re-export imports - no barrel files
 

package/README.md

@@ -1,23 +1,30 @@
 # BridgesCLI
-A CLI-based Bridges (Hashiwokakero) puzzle renderer built with React and Ink. This exists mostly to
-gain more experience with an agent-based workflow.
+A CLI-based Bridges puzzle renderer built with React and Ink. This exists mostly to
+gain more experience using an agent-based workflow.
 
-## What is Hashiwokakero?
-Hashiwokakero (橋をかけろ, "build bridges") is a logic puzzle where you connect islands with bridges.
+## What is Bridges?
+Bridges (also known as Hashiwokakero) is a logic puzzle where you connect islands with bridges.
 Each island has a number indicating how many bridges must connect to it.
 
 ![Demo](docs/readme-demo-1.png)
 
-## Run the puzzle (interactive mode - press q to quit)
+## Run the game
+``` bash
+npm install -g bridges-cli
+bridges
+```
+
+## Local Development
+Clone the repo then run:
 ``` bash
 bun start
 ```
 
 ### CLI Options
-- `-s, --stdout` - Output to stdout and exit immediately (for testing)
 - `-p, --puzzle <identifier>` - Render a puzzle via shorthand encoding (see `samplePuzzles.ts`)
+- `--enable-solutions` - Enable the show solution toggle in the game (disabled by default)
 
-## Run tests and linter
+### Run tests and linter
 ``` bash
 bun run typecheck
 bun run test

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "bridges-cli",
-    "version": "0.0.1",
-    "description": "Hashiwokakero (Bridges) CLI puzzle game",
-    "main": "index.js",
+    "version": "0.2.0",
+    "description": "Bridges CLI puzzle game",
     "bin": {
         "bridges": "src/index.tsx"
     },
     "scripts": {
         "start": "bun src/index.tsx",
+        "demo": "bun src/demo.tsx",
         "test": "vitest",
         "typecheck": "tsc --noEmit",
         "lint": "biome check --write"
@@ -15,7 +15,7 @@
     "keywords": [
         "game",
         "puzzle",
-        "hashi",
+        "hashiwokakero",
         "bridges",
         "cli"
     ],

package/src/Game.tsx

@@ -1,37 +1,137 @@
-import { useCallback, useState } from 'react'
+import { useCallback, useMemo, useState } from 'react'
 
 import HashiGrid from './components/HashiGrid.tsx'
-import { parsePuzzle } from './utils/parsePuzzle.ts'
-import type { PuzzleData } from './utils/samplePuzzles.ts'
+import type { HashiNodeData, PlacedBridge } from './types.ts'
+import { areAllNodesFilled, isConnected } from './utils/bridges.ts'
+import { type PuzzleData, parsePuzzle } from './utils/puzzle-encoding.ts'
 import usePuzzleInput from './utils/usePuzzleInput.ts'
 
 type GameProps = {
     puzzles: PuzzleData[]
     hasCustomPuzzle: boolean
-    stdout: boolean
+    enableSolutions: boolean
 }
 
-export default function Game({ puzzles, hasCustomPuzzle, stdout }: GameProps) {
+// Compares two bridges for equality, treating bridges in either direction as equivalent.
+// A bridge from A→B is considered equal to a bridge from B→A.
+function bridgesEqual(a: PlacedBridge, b: PlacedBridge): boolean {
+    return (
+        (a.from.row === b.from.row &&
+            a.from.col === b.from.col &&
+            a.to.row === b.to.row &&
+            a.to.col === b.to.col) ||
+        (a.from.row === b.to.row &&
+            a.from.col === b.to.col &&
+            a.to.row === b.from.row &&
+            a.to.col === b.from.col)
+    )
+}
+
+// Toggles a bridge: removes it if it already exists, otherwise adds it.
+// Returns true if bridge was erased, false if it was added.
+function toggleBridge(
+    bridges: PlacedBridge[],
+    bridge: PlacedBridge
+): { bridges: PlacedBridge[]; erased: boolean } {
+    const exists = bridges.some(b => bridgesEqual(b, bridge))
+    if (exists) {
+        return { bridges: bridges.filter(b => !bridgesEqual(b, bridge)), erased: true }
+    }
+    return { bridges: [...bridges, bridge], erased: false }
+}
+
+// Merges user-placed bridges with the original puzzle rows.
+// Creates a new grid with both original bridges (from solution) and user-drawn bridges.
+// This preserves the original puzzle state for undo/reset functionality.
+function mergeBridges(originalRows: HashiNodeData[][], bridges: PlacedBridge[]): HashiNodeData[][] {
+    // Deep clone the rows
+    const rows = originalRows.map(row => row.map(cell => ({ ...cell })))
+
+    // Apply each bridge
+    for (const bridge of bridges) {
+        const { from, to } = bridge
+        const bridgeCount = bridge.count || 1
+
+        if (from.row === to.row) {
+            // Horizontal bridge
+            const row = rows[from.row]
+            if (!row) continue
+            const minCol = Math.min(from.col, to.col)
+            const maxCol = Math.max(from.col, to.col)
+
+            // Set lineRight on the left node
+            if (minCol >= 0 && minCol < row.length) {
+                const cell = row[minCol]
+                if (cell) cell.lineRight = bridgeCount as 1 | 2
+            }
+            // Set lineLeft on the right node
+            if (maxCol >= 0 && maxCol < row.length) {
+                const cell = row[maxCol]
+                if (cell) cell.lineLeft = bridgeCount as 1 | 2
+            }
+            // Fill in bridge cells
+            for (let c = minCol + 1; c < maxCol; c++) {
+                if (c >= 0 && c < row.length) {
+                    const cell = row[c]
+                    if (cell) cell.value = bridgeCount === 2 ? '=' : '-'
+                }
+            }
+        } else if (from.col === to.col) {
+            // Vertical bridge
+            const minRow = Math.min(from.row, to.row)
+            const maxRow = Math.max(from.row, to.row)
+
+            // Set lineDown on the top node
+            const topNode = rows[minRow]?.[from.col]
+            if (topNode) topNode.lineDown = bridgeCount as 1 | 2
+
+            // Set lineUp on the bottom node
+            const bottomNode = rows[maxRow]?.[from.col]
+            if (bottomNode) bottomNode.lineUp = bridgeCount as 1 | 2
+
+            // Fill in bridge cells
+            for (let r = minRow + 1; r < maxRow; r++) {
+                if (r >= 0 && r < rows.length) {
+                    const rowNode = rows[r]?.[from.col]
+                    if (rowNode) rowNode.value = bridgeCount === 2 ? '#' : '|'
+                }
+            }
+        }
+    }
+
+    return rows
+}
+
+export default function Game({ puzzles, hasCustomPuzzle, enableSolutions }: GameProps) {
     const [puzzleIndex, setPuzzleIndex] = useState(0)
     const [showSolution, setShowSolution] = useState(false)
+    const [userBridges, setUserBridges] = useState<PlacedBridge[]>([])
+    const [solutionReached, setSolutionReached] = useState(false)
+    const [gridNotConnected, setGridNotConnected] = useState(false)
 
     const handlePrev = useCallback(() => {
         setPuzzleIndex(i => i - 1)
         setShowSolution(false)
+        setSolutionReached(false)
+        setGridNotConnected(false)
     }, [])
     const handleNext = useCallback(() => {
         setPuzzleIndex(i => i + 1)
         setShowSolution(false)
+        setSolutionReached(false)
+        setGridNotConnected(false)
     }, [])
     const handleToggleSolution = useCallback(() => {
-        setShowSolution(s => !s)
+        setShowSolution(s => {
+            if (!s) {
+                setUserBridges([])
+                setSolutionReached(false)
+                setGridNotConnected(false)
+            }
+            return !s
+        })
     }, [])
 
-    const canUseInput = Boolean(process.stdin.isTTY) && !stdout
-    if (canUseInput) {
-        usePuzzleInput(puzzleIndex, puzzles.length, handlePrev, handleNext, handleToggleSolution)
-    }
-
     const puzzle = puzzles[puzzleIndex]
     if (!puzzle) throw new Error('HashiGrid: no puzzle found')
 
@@ -39,16 +139,72 @@ export default function Game({ puzzles, hasCustomPuzzle, stdout }: GameProps) {
     const dimensions = encoding.split(':')[0] ?? '5x5'
     const numNodes = Number(dimensions.split('x')[0]) || 5
 
+    const originalRows = useMemo(() => parsePuzzle(encoding), [encoding])
+
+    const rows = useMemo(() => mergeBridges(originalRows, userBridges), [originalRows, userBridges])
+
+    const handleBridgePlaced = useCallback(
+        (bridge: PlacedBridge) => {
+            const result = toggleBridge(userBridges, bridge)
+            setUserBridges(result.bridges)
+
+            const mergedRows = mergeBridges(originalRows, result.bridges)
+            const allFilled = areAllNodesFilled(mergedRows)
+            const connected = isConnected(mergedRows)
+            setSolutionReached(allFilled && connected)
+            setGridNotConnected(allFilled && !connected)
+
+            return result.erased
+        },
+        [userBridges, originalRows]
+    )
+
+    // Compute min and max numbers in the puzzle
+    const { minNumber, maxNumber } = useMemo(() => {
+        let min = 9
+        let max = 1
+        for (const row of rows) {
+            for (const node of row) {
+                if (typeof node.value === 'number') {
+                    if (node.value < min) min = node.value
+                    if (node.value > max) max = node.value
+                }
+            }
+        }
+        return { minNumber: min, maxNumber: max }
+    }, [rows])
+
+    const canUseInput = Boolean(process.stdin.isTTY)
+    const { selectionState } = canUseInput
+        ? usePuzzleInput({
+              puzzleIndex,
+              puzzlesLength: puzzles.length,
+              rows: rows,
+              showSolution,
+              enableSolutions,
+              onPrev: handlePrev,
+              onNext: handleNext,
+              onToggleSolution: handleToggleSolution,
+              onBridgePlaced: handleBridgePlaced,
+          })
+        : { selectionState: undefined }
+
     return (
         <HashiGrid
             numNodes={numNodes}
-            rows={parsePuzzle(encoding)}
-            showInstructions={!stdout}
+            rows={rows}
+            showInstructions={true}
             puzzleIndex={puzzleIndex}
             puzzle={encoding}
             isCustomPuzzle={hasCustomPuzzle && puzzleIndex === 0}
             hasSolution={!!puzzle.solution}
             showSolution={showSolution}
+            enableSolutions={enableSolutions}
+            selectionState={selectionState}
+            minNumber={minNumber}
+            maxNumber={maxNumber}
+            solutionReached={solutionReached}
+            gridNotConnected={gridNotConnected}
         />
     )
 }