@colmbus72/yeehaw 0.1.0

package/dist/views/NightSkyView.js

@@ -0,0 +1,441 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+// Easing function for smooth transitions (ease-in-out cubic)
+function easeInOutCubic(t) {
+    return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+}
+// Static star characters (dimmer, always visible)
+const STATIC_STAR_CHARS = ['.', '·', '+'];
+// Test messages for cloud demo
+const TEST_MESSAGES = [
+    'Hello from the desert!',
+    'New commit pushed',
+    'Build succeeded',
+    'PR #42 merged',
+    'Deploy complete',
+    'Tests passing',
+];
+// Cactus templates - block-style saguaros
+const CACTUS_TEMPLATES = [
+    // Tall saguaro with both arms
+    [
+        '  █  ',
+        '█ █  ',
+        '  █ █',
+        '  █  ',
+        '  █  ',
+    ],
+    // Medium saguaro with left arm
+    [
+        '  █  ',
+        '█ █  ',
+        '  █  ',
+        '  █  ',
+    ],
+    // Medium saguaro with right arm
+    [
+        '  █  ',
+        '  █ █',
+        '  █  ',
+        '  █  ',
+    ],
+    // Small saguaro
+    [
+        '  █  ',
+        '  █  ',
+        '  █  ',
+    ],
+    // Tiny cactus
+    [
+        ' █ ',
+        ' █ ',
+    ],
+];
+// Green gradient colors for cacti - all vibrant greens (lighter top to darker bottom)
+const CACTUS_COLORS = ['#5fa33a', '#4a9030', '#3d8028', '#307020'];
+// Animation parameters
+const FRAME_INTERVAL = 50; // 20 FPS
+const TARGET_WINKING_STARS = { min: 5, max: 10 };
+const STATIC_STAR_COUNT = { min: 30, max: 50 };
+const SPAWN_CHANCE = 0.05;
+const LANDSCAPE_HEIGHT = 9; // Taller to fit full saguaros
+function randomFloat(min, max) {
+    return Math.random() * (max - min) + min;
+}
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function createWinkingStar(width, height, existingStars) {
+    const maxAttempts = 20;
+    for (let i = 0; i < maxAttempts; i++) {
+        const x = randomInt(0, width - 1);
+        const y = randomInt(0, height - 1);
+        const occupied = existingStars.some((s) => s.x === x && s.y === y);
+        if (!occupied) {
+            return {
+                type: 'winking',
+                x,
+                y,
+                progress: 0,
+                speed: randomFloat(0.025, 0.06),
+                holdDuration: randomFloat(0.3, 0.8),
+            };
+        }
+    }
+    return null;
+}
+function createStaticStar(width, height, existingStars) {
+    const maxAttempts = 30;
+    for (let i = 0; i < maxAttempts; i++) {
+        const x = randomInt(0, width - 1);
+        const y = randomInt(0, height - 1);
+        const occupied = existingStars.some((s) => s.x === x && s.y === y);
+        if (!occupied) {
+            return {
+                type: 'static',
+                x,
+                y,
+                char: STATIC_STAR_CHARS[randomInt(0, STATIC_STAR_CHARS.length - 1)],
+                baseBrightness: randomFloat(0.2, 0.6),
+                pulsePhase: randomFloat(0, Math.PI * 2),
+                pulseSpeed: randomFloat(0.04, 0.12),
+                pulseAmount: randomFloat(0.05, 0.2),
+            };
+        }
+    }
+    return null;
+}
+function createMessageCloud(text, width, skyHeight) {
+    const startX = randomInt(5, Math.max(6, width - text.length - 10));
+    const startY = randomInt(2, Math.max(3, Math.floor(skyHeight / 2)));
+    return {
+        text,
+        x: startX,
+        y: startY,
+        targetX: startX + randomInt(-5, 5),
+        targetY: startY + randomInt(-2, 2),
+        progress: 0,
+        speed: 0.012,
+    };
+}
+function generateCacti(width) {
+    const cacti = [];
+    let pos = randomInt(15, 30);
+    while (pos < width - 15) {
+        // Only use the tall saguaro templates (first 3)
+        const templateIndex = randomInt(0, 2);
+        const template = CACTUS_TEMPLATES[templateIndex];
+        const colorIndex = randomInt(0, CACTUS_COLORS.length - 1);
+        // Random vertical offset: some cacti sit higher, some lower
+        const yOffset = randomInt(-1, 1);
+        cacti.push({ x: pos, yOffset, template, colorIndex });
+        pos += randomInt(25, 45);
+    }
+    return cacti;
+}
+function generateGround(width, height) {
+    const rows = [];
+    const groundLineY = 5; // Ground line - leaves room for tall cacti above
+    for (let y = 0; y < height; y++) {
+        const row = [];
+        for (let x = 0; x < width; x++) {
+            if (y === groundLineY) {
+                // Ground line - simple texture
+                const r = Math.random();
+                row.push(r < 0.6 ? '~' : r < 0.8 ? '-' : r < 0.95 ? '_' : '.');
+            }
+            else if (y > groundLineY) {
+                // Below ground line - sparse sand specs
+                const r = Math.random();
+                row.push(r < 0.03 ? '.' : r < 0.05 ? ',' : ' ');
+            }
+            else {
+                // Above ground line (cactus area)
+                row.push(' ');
+            }
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+function initializeStars(width, skyHeight) {
+    const staticCount = randomInt(STATIC_STAR_COUNT.min, STATIC_STAR_COUNT.max);
+    const stars = [];
+    for (let i = 0; i < staticCount; i++) {
+        const star = createStaticStar(width, skyHeight, stars);
+        if (star)
+            stars.push(star);
+    }
+    return stars;
+}
+export function NightSkyView({ onExit }) {
+    const { stdout } = useStdout();
+    const width = stdout?.columns || 80;
+    const height = (stdout?.rows || 24) - 1;
+    const skyHeight = height - LANDSCAPE_HEIGHT;
+    // Single state object for all animated elements
+    const [state, setState] = useState(() => ({
+        stars: initializeStars(width, skyHeight),
+        clouds: [],
+    }));
+    const [isPaused, setIsPaused] = useState(false);
+    const dimsRef = useRef({ width, skyHeight });
+    dimsRef.current = { width, skyHeight };
+    // Generate landscape elements once
+    const cacti = useMemo(() => generateCacti(width), [width]);
+    const groundBase = useMemo(() => generateGround(width, LANDSCAPE_HEIGHT), [width]);
+    // Reinitialize stars when dimensions change
+    useEffect(() => {
+        setState(prev => ({
+            ...prev,
+            stars: initializeStars(width, skyHeight),
+        }));
+    }, [width, skyHeight]);
+    const randomize = useCallback(() => {
+        const { width, skyHeight } = dimsRef.current;
+        setState({
+            stars: initializeStars(width, skyHeight),
+            clouds: [],
+        });
+    }, []);
+    const spawnCloud = useCallback(() => {
+        const { width, skyHeight } = dimsRef.current;
+        const message = TEST_MESSAGES[randomInt(0, TEST_MESSAGES.length - 1)];
+        const cloud = createMessageCloud(message, width, skyHeight);
+        setState(prev => ({
+            ...prev,
+            clouds: [...prev.clouds, cloud],
+        }));
+    }, []);
+    useInput((input, key) => {
+        if (key.escape) {
+            onExit();
+        }
+        else if (input === 'r') {
+            randomize();
+        }
+        else if (input === 'c') {
+            spawnCloud();
+        }
+        else if (input === ' ') {
+            setIsPaused(p => !p);
+        }
+    });
+    // Single animation loop with batched state update
+    useEffect(() => {
+        if (isPaused)
+            return;
+        const interval = setInterval(() => {
+            const { width, skyHeight } = dimsRef.current;
+            setState(prev => {
+                // Update stars
+                const updatedStars = [];
+                for (const star of prev.stars) {
+                    if (star.type === 'static') {
+                        updatedStars.push({
+                            ...star,
+                            pulsePhase: star.pulsePhase + star.pulseSpeed,
+                        });
+                    }
+                    else {
+                        const newProgress = star.progress + star.speed;
+                        if (newProgress < 2 + star.holdDuration) {
+                            updatedStars.push({ ...star, progress: newProgress });
+                        }
+                    }
+                }
+                // Spawn new winking stars
+                const winkingCount = updatedStars.filter(s => s.type === 'winking').length;
+                if (winkingCount < TARGET_WINKING_STARS.min && Math.random() < SPAWN_CHANCE) {
+                    const newStar = createWinkingStar(width, skyHeight, updatedStars);
+                    if (newStar)
+                        updatedStars.push(newStar);
+                }
+                // Update clouds
+                const updatedClouds = prev.clouds
+                    .map(cloud => {
+                    const newProgress = cloud.progress + cloud.speed;
+                    let newX = cloud.x;
+                    let newY = cloud.y;
+                    if (newProgress > 0.5 && newProgress < 2.5) {
+                        newX += (cloud.targetX - cloud.x) * 0.02;
+                        newY += (cloud.targetY - cloud.y) * 0.02;
+                    }
+                    return { ...cloud, x: newX, y: newY, progress: newProgress };
+                })
+                    .filter(cloud => cloud.progress < 3);
+                return {
+                    stars: updatedStars,
+                    clouds: updatedClouds,
+                };
+            });
+        }, FRAME_INTERVAL);
+        return () => clearInterval(interval);
+    }, [isPaused]);
+    // Rendering helpers
+    const getWinkingStarDisplay = (star) => {
+        const { progress, holdDuration } = star;
+        let brightness;
+        if (progress < 1) {
+            brightness = easeInOutCubic(progress);
+        }
+        else if (progress < 1 + holdDuration) {
+            brightness = 1;
+        }
+        else {
+            brightness = 1 - easeInOutCubic(progress - 1 - holdDuration);
+        }
+        const chars = [' ', '.', '·', '+', '*'];
+        return { char: chars[Math.round(brightness * 4)], dim: brightness < 0.5 };
+    };
+    const getStaticStarDisplay = (star) => {
+        const brightness = star.baseBrightness + Math.sin(star.pulsePhase) * star.pulseAmount;
+        return { char: star.char, dim: brightness < 0.4 };
+    };
+    // Cloud display - simple opacity-based fading
+    const getCloudOpacity = (cloud) => {
+        const { progress } = cloud;
+        if (progress < 0.3) {
+            // Fading in - dim
+            return { dim: true, visible: true };
+        }
+        else if (progress < 2.7) {
+            // Fully visible
+            return { dim: false, visible: true };
+        }
+        else {
+            // Fading out - dim
+            return { dim: true, visible: true };
+        }
+    };
+    // Render sky
+    const skyRows = [];
+    for (let y = 0; y < skyHeight; y++) {
+        let rowChars = ' '.repeat(width).split('');
+        let rowDims = new Array(width).fill(false);
+        let rowColors = new Array(width).fill(undefined);
+        // Place stars
+        for (const star of state.stars) {
+            if (star.y === y && star.x >= 0 && star.x < width) {
+                const display = star.type === 'winking' ? getWinkingStarDisplay(star) : getStaticStarDisplay(star);
+                if (display.char !== ' ') {
+                    rowChars[star.x] = display.char;
+                    rowDims[star.x] = display.dim;
+                }
+            }
+        }
+        // Place clouds
+        for (const cloud of state.clouds) {
+            const display = getCloudOpacity(cloud);
+            if (!display.visible)
+                continue;
+            const cloudY = Math.round(cloud.y);
+            const cloudX = Math.round(cloud.x);
+            // Simple box cloud
+            const textLen = cloud.text.length + 2;
+            const lines = [
+                '╭' + '─'.repeat(textLen) + '╮',
+                '│ ' + cloud.text + ' │',
+                '╰' + '─'.repeat(textLen) + '╯',
+            ];
+            const lineIdx = y - cloudY;
+            if (lineIdx >= 0 && lineIdx < 3) {
+                const line = lines[lineIdx];
+                for (let lx = 0; lx < line.length; lx++) {
+                    const cellX = cloudX + lx;
+                    if (cellX >= 0 && cellX < width) {
+                        rowChars[cellX] = line[lx];
+                        rowDims[cellX] = display.dim;
+                        rowColors[cellX] = '#87CEEB';
+                    }
+                }
+            }
+        }
+        // Build segments for efficient rendering
+        const segments = [];
+        let seg = { text: rowChars[0], dim: rowDims[0], color: rowColors[0] };
+        for (let x = 1; x < width; x++) {
+            if (rowDims[x] === seg.dim && rowColors[x] === seg.color) {
+                seg.text += rowChars[x];
+            }
+            else {
+                segments.push(seg);
+                seg = { text: rowChars[x], dim: rowDims[x], color: rowColors[x] };
+            }
+        }
+        segments.push(seg);
+        skyRows.push(_jsx(Text, { children: segments.map((s, i) => (_jsx(Text, { color: s.color || 'white', dimColor: s.dim, children: s.text }, i))) }, y));
+    }
+    // Render landscape with cacti and ground
+    const renderLandscape = () => {
+        const GROUND_LINE_Y = 5; // Ground line position in landscape
+        // Create ground grid
+        const ground = groundBase.map(row => [...row]);
+        // Place cacti - they sit on the ground line with vertical variation
+        for (const cactus of cacti) {
+            const cactusHeight = cactus.template.length;
+            // Cactus bottom aligns with ground line, plus offset for depth variation
+            const cactusStartY = GROUND_LINE_Y - cactusHeight + 1 + cactus.yOffset;
+            for (let cy = 0; cy < cactusHeight; cy++) {
+                const groundY = cactusStartY + cy;
+                if (groundY >= 0 && groundY < LANDSCAPE_HEIGHT) {
+                    const line = cactus.template[cy];
+                    for (let cx = 0; cx < line.length; cx++) {
+                        const groundX = cactus.x + cx;
+                        if (groundX >= 0 && groundX < width && line[cx] !== ' ') {
+                            ground[groundY][groundX] = line[cx];
+                        }
+                    }
+                }
+            }
+        }
+        // Render ground rows with coloring
+        const rows = [];
+        for (let y = 0; y < LANDSCAPE_HEIGHT; y++) {
+            const segments = [];
+            let currentColor = '#C2B280';
+            let currentDim = false;
+            let currentText = '';
+            for (let x = 0; x < width; x++) {
+                const char = ground[y][x];
+                let charColor = '#C2B280'; // Sand/dirt color
+                let charDim = y > GROUND_LINE_Y; // Dim the sand specs below ground
+                // Check if this char is part of a cactus (█ character)
+                if (char === '█') {
+                    // Find which cactus this belongs to for gradient
+                    for (const cactus of cacti) {
+                        const cactusHeight = cactus.template.length;
+                        const cactusStartY = GROUND_LINE_Y - cactusHeight + 1 + cactus.yOffset;
+                        const relY = y - cactusStartY;
+                        const relX = x - cactus.x;
+                        if (relY >= 0 && relY < cactusHeight && relX >= 0 && relX < cactus.template[relY].length) {
+                            if (cactus.template[relY][relX] === '█') {
+                                // Gradient: lighter at top, darker at bottom
+                                const gradientIndex = Math.min(CACTUS_COLORS.length - 1, Math.floor(relY / cactusHeight * CACTUS_COLORS.length));
+                                charColor = CACTUS_COLORS[gradientIndex];
+                                charDim = false;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (charColor === currentColor && charDim === currentDim) {
+                    currentText += char;
+                }
+                else {
+                    if (currentText)
+                        segments.push({ text: currentText, color: currentColor, dim: currentDim });
+                    currentText = char;
+                    currentColor = charColor;
+                    currentDim = charDim;
+                }
+            }
+            if (currentText)
+                segments.push({ text: currentText, color: currentColor, dim: currentDim });
+            rows.push(_jsx(Text, { children: segments.map((s, i) => (_jsx(Text, { color: s.color, dimColor: s.dim, children: s.text }, i))) }, `land-${y}`));
+        }
+        return rows;
+    };
+    return (_jsxs(Box, { flexDirection: "column", height: height, children: [_jsx(Box, { flexDirection: "column", children: skyRows }), _jsx(Box, { flexDirection: "column", children: renderLandscape() })] }));
+}

package/dist/views/ProjectContext.d.ts

@@ -0,0 +1,18 @@
+import type { Project, Barn, Livestock } from '../types.js';
+import { type TmuxWindow } from '../lib/tmux.js';
+interface ProjectContextProps {
+    project: Project;
+    barns: Barn[];
+    windows: TmuxWindow[];
+    onBack: () => void;
+    onNewClaude: () => void;
+    onSelectWindow: (window: TmuxWindow) => void;
+    onSelectLivestock: (livestock: Livestock, barn: Barn | null) => void;
+    onOpenLivestockSession: (livestock: Livestock, barn: Barn | null) => void;
+    onUpdateProject: (project: Project) => void;
+    onDeleteProject: (projectName: string) => void;
+    onOpenWiki: () => void;
+    onOpenIssues: () => void;
+}
+export declare function ProjectContext({ project, barns, windows, onBack, onNewClaude, onSelectWindow, onSelectLivestock, onOpenLivestockSession, onUpdateProject, onDeleteProject, onOpenWiki, onOpenIssues, }: ProjectContextProps): import("react/jsx-runtime").JSX.Element;
+export {};