tlc-claude-code 0.6.1 → 0.6.3

package/dashboard/dist/components/GitHubPane.test.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render } from 'ink-testing-library';
+import { GitHubPane } from './GitHubPane.js';
+// Mock child_process to avoid actual gh calls
+vi.mock('child_process', () => ({
+    exec: vi.fn((cmd, opts, cb) => {
+        if (typeof opts === 'function') {
+            cb = opts;
+        }
+        // Simulate gh CLI not available by default
+        const error = new Error('gh not found');
+        if (cb)
+            cb(error, '', '');
+        return { stdout: null, stderr: null };
+    }),
+}));
+vi.mock('util', async () => {
+    const actual = await vi.importActual('util');
+    return {
+        ...actual,
+        promisify: (fn) => async (...args) => {
+            return new Promise((resolve, reject) => {
+                fn(...args, (err, stdout, stderr) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve({ stdout, stderr });
+                });
+            });
+        },
+    };
+});
+describe('GitHubPane', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('loading state', () => {
+        it('shows loading message initially', () => {
+            const { lastFrame } = render(_jsx(GitHubPane, { isActive: false }));
+            const output = lastFrame();
+            expect(output).toContain('Loading issues...');
+        });
+    });
+    describe('error state', () => {
+        it('shows error when gh CLI fails', async () => {
+            const { lastFrame } = render(_jsx(GitHubPane, { isActive: false }));
+            // Wait for effect to run
+            await new Promise(resolve => setTimeout(resolve, 100));
+            const output = lastFrame();
+            expect(output).toContain('gh CLI not available');
+        });
+        it('shows install hint on error', async () => {
+            const { lastFrame } = render(_jsx(GitHubPane, { isActive: false }));
+            await new Promise(resolve => setTimeout(resolve, 100));
+            const output = lastFrame();
+            expect(output).toContain('Make sure gh CLI is installed');
+        });
+    });
+    describe('controls', () => {
+        it('shows controls when active and has issues', async () => {
+            // This test would need proper mocking of successful gh response
+            // For now, we test that the component doesn't crash
+            const { lastFrame } = render(_jsx(GitHubPane, { isActive: true }));
+            await new Promise(resolve => setTimeout(resolve, 100));
+            const output = lastFrame();
+            // Either shows controls or error state
+            expect(output).toBeDefined();
+        });
+    });
+    describe('callback', () => {
+        it('accepts onAssignToAgent callback', () => {
+            const mockCallback = vi.fn();
+            const { lastFrame } = render(_jsx(GitHubPane, { isActive: true, onAssignToAgent: mockCallback }));
+            // Component should render without error
+            expect(lastFrame()).toBeDefined();
+        });
+    });
+});

package/dashboard/dist/components/PhasesPane.d.ts

@@ -0,0 +1,8 @@
+interface Phase {
+    number: number;
+    name: string;
+    status: 'completed' | 'in_progress' | 'pending';
+}
+export declare function PhasesPane(): import("react/jsx-runtime").JSX.Element;
+export declare function parseRoadmap(content: string): Phase[];
+export {};

package/dashboard/dist/components/PhasesPane.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useState, useEffect } from 'react';
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+export function PhasesPane() {
+    const [phases, setPhases] = useState([]);
+    const [loading, setLoading] = useState(true);
+    useEffect(() => {
+        async function loadPhases() {
+            const roadmapPath = join(process.cwd(), '.planning', 'ROADMAP.md');
+            if (!existsSync(roadmapPath)) {
+                setPhases([]);
+                setLoading(false);
+                return;
+            }
+            try {
+                const content = await readFile(roadmapPath, 'utf-8');
+                const parsed = parseRoadmap(content);
+                setPhases(parsed);
+            }
+            catch (e) {
+                setPhases([]);
+            }
+            setLoading(false);
+        }
+        loadPhases();
+        const interval = setInterval(loadPhases, 5000);
+        return () => clearInterval(interval);
+    }, []);
+    if (loading) {
+        return (_jsx(Box, { padding: 1, children: _jsx(Text, { color: "gray", children: "Loading..." }) }));
+    }
+    if (phases.length === 0) {
+        return (_jsxs(Box, { padding: 1, flexDirection: "column", children: [_jsx(Text, { color: "gray", children: "No roadmap found." }), _jsx(Text, { color: "gray", dimColor: true, children: "Run /tdd:new-project or /tdd:init" })] }));
+    }
+    return (_jsx(Box, { padding: 1, flexDirection: "column", children: phases.map((phase) => (_jsxs(Box, { children: [_jsx(Text, { color: phase.status === 'completed' ? 'green' :
+                        phase.status === 'in_progress' ? 'yellow' :
+                            'gray', children: phase.status === 'completed' ? ' [x] ' :
+                        phase.status === 'in_progress' ? ' [>] ' :
+                            ' [ ] ' }), _jsxs(Text, { color: phase.status === 'in_progress' ? 'cyan' : 'white', children: [phase.number, ". ", phase.name] })] }, phase.number))) }));
+}
+export function parseRoadmap(content) {
+    const phases = [];
+    const lines = content.split('\n');
+    for (const line of lines) {
+        // Match patterns like "## Phase 1: Setup" or "### 1. Auth System"
+        const match = line.match(/^#+\s*(?:Phase\s+)?(\d+)[.:]?\s*(.+)/i);
+        if (match) {
+            const num = parseInt(match[1], 10);
+            const name = match[2].replace(/\[.*?\]/g, '').trim();
+            // Determine status from markers
+            let status = 'pending';
+            if (line.includes('[x]') || line.includes('[completed]')) {
+                status = 'completed';
+            }
+            else if (line.includes('[>]') || line.includes('[in progress]') || line.includes('[current]')) {
+                status = 'in_progress';
+            }
+            phases.push({ number: num, name, status });
+        }
+    }
+    return phases;
+}

package/dashboard/dist/components/PhasesPane.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dashboard/dist/components/PhasesPane.test.js

@@ -0,0 +1,119 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render } from 'ink-testing-library';
+import { PhasesPane, parseRoadmap } from './PhasesPane.js';
+import { vol } from 'memfs';
+// Mock fs modules
+vi.mock('fs', async () => {
+    const memfs = await import('memfs');
+    return memfs.fs;
+});
+vi.mock('fs/promises', async () => {
+    const memfs = await import('memfs');
+    return memfs.fs.promises;
+});
+describe('PhasesPane', () => {
+    beforeEach(() => {
+        vol.reset();
+    });
+    describe('parseRoadmap', () => {
+        it('parses "## Phase N: Name" format', () => {
+            const content = `# Roadmap
+
+## Phase 1: Setup
+Initial setup
+
+## Phase 2: Core Features
+Build the main stuff`;
+            const phases = parseRoadmap(content);
+            expect(phases).toHaveLength(2);
+            expect(phases[0]).toEqual({ number: 1, name: 'Setup', status: 'pending' });
+            expect(phases[1]).toEqual({ number: 2, name: 'Core Features', status: 'pending' });
+        });
+        it('parses "### N. Name" format', () => {
+            const content = `# Roadmap
+
+### 1. Auth System
+### 2. User Dashboard
+### 3. Reports`;
+            const phases = parseRoadmap(content);
+            expect(phases).toHaveLength(3);
+            expect(phases[0].name).toBe('Auth System');
+            expect(phases[2].number).toBe(3);
+        });
+        it('detects completed status from [x]', () => {
+            const content = `## Phase 1: Setup [x]
+## Phase 2: Build`;
+            const phases = parseRoadmap(content);
+            expect(phases[0].status).toBe('completed');
+            expect(phases[1].status).toBe('pending');
+        });
+        it('detects completed status from [completed]', () => {
+            const content = `## Phase 1: Setup [completed]`;
+            const phases = parseRoadmap(content);
+            expect(phases[0].status).toBe('completed');
+        });
+        it('detects in_progress status from [>]', () => {
+            const content = `## Phase 1: Setup [x]
+## Phase 2: Build [>]
+## Phase 3: Deploy`;
+            const phases = parseRoadmap(content);
+            expect(phases[0].status).toBe('completed');
+            expect(phases[1].status).toBe('in_progress');
+            expect(phases[2].status).toBe('pending');
+        });
+        it('detects in_progress from [in progress]', () => {
+            const content = `## Phase 1: Build [in progress]`;
+            const phases = parseRoadmap(content);
+            expect(phases[0].status).toBe('in_progress');
+        });
+        it('detects in_progress from [current]', () => {
+            const content = `## Phase 1: Build [current]`;
+            const phases = parseRoadmap(content);
+            expect(phases[0].status).toBe('in_progress');
+        });
+        it('returns empty array for content with no phases', () => {
+            const content = `# Just a readme
+
+Some text without phases.`;
+            const phases = parseRoadmap(content);
+            expect(phases).toEqual([]);
+        });
+        it('strips status markers from name', () => {
+            const content = `## Phase 1: Setup [completed]`;
+            const phases = parseRoadmap(content);
+            expect(phases[0].name).toBe('Setup');
+        });
+    });
+    describe('component rendering', () => {
+        it('shows loading initially', () => {
+            const { lastFrame } = render(_jsx(PhasesPane, {}));
+            expect(lastFrame()).toContain('Loading...');
+        });
+        it('shows no roadmap message when file missing', async () => {
+            const { lastFrame } = render(_jsx(PhasesPane, {}));
+            await new Promise(resolve => setTimeout(resolve, 100));
+            const output = lastFrame();
+            expect(output).toContain('No roadmap found');
+            expect(output).toContain('/tdd:new-project');
+        });
+        it('renders phases from roadmap file', async () => {
+            // Create mock roadmap file
+            vol.fromJSON({
+                [process.cwd() + '/.planning/ROADMAP.md']: `# Roadmap
+
+## Phase 1: Auth [x]
+## Phase 2: Dashboard [>]
+## Phase 3: Reports`
+            });
+            const { lastFrame } = render(_jsx(PhasesPane, {}));
+            await new Promise(resolve => setTimeout(resolve, 100));
+            const output = lastFrame();
+            expect(output).toContain('1. Auth');
+            expect(output).toContain('2. Dashboard');
+            expect(output).toContain('3. Reports');
+            expect(output).toContain('[x]');
+            expect(output).toContain('[>]');
+        });
+    });
+});

package/dashboard/dist/components/PlanSync.d.ts

@@ -0,0 +1,13 @@
+interface Task {
+    id: string;
+    title: string;
+    description: string;
+    phase: number;
+}
+export declare function parseTasksFromPlan(planPath: string): Promise<Task[]>;
+export declare function syncPlanToGitHub(tasks: Task[], phaseNumber: number, phaseName: string): Promise<Map<string, number>>;
+export declare function markIssueInProgress(issueNumber: number): Promise<void>;
+export declare function markIssueComplete(issueNumber: number): Promise<void>;
+export declare function isPlanApproved(planPath: string): Promise<boolean>;
+export declare function approvePlan(planPath: string): Promise<void>;
+export {};

package/dashboard/dist/components/PlanSync.js

@@ -0,0 +1,89 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+const execAsync = promisify(exec);
+// Parse tasks from a PLAN.md file
+export async function parseTasksFromPlan(planPath) {
+    if (!existsSync(planPath))
+        return [];
+    const content = await readFile(planPath, 'utf-8');
+    const tasks = [];
+    // Match task blocks like:
+    // ## Task 1: Setup auth
+    // or <task id="01-01">
+    const taskRegex = /(?:##\s*Task\s*(\d+)[:\s]+(.+)|<task\s+id="([^"]+)"[^>]*>)/gi;
+    let match;
+    while ((match = taskRegex.exec(content)) !== null) {
+        const id = match[3] || `task-${match[1]}`;
+        const title = match[2] || id;
+        // Get description (text until next heading or task tag)
+        const startIdx = match.index + match[0].length;
+        const nextMatch = content.slice(startIdx).match(/(?:##\s*Task|<task\s|<\/task>)/);
+        const endIdx = nextMatch ? startIdx + nextMatch.index : startIdx + 500;
+        const description = content.slice(startIdx, endIdx).trim().slice(0, 500);
+        tasks.push({ id, title, description, phase: 0 });
+    }
+    return tasks;
+}
+// Push approved plan tasks to GitHub Issues
+export async function syncPlanToGitHub(tasks, phaseNumber, phaseName) {
+    const taskToIssue = new Map();
+    for (const task of tasks) {
+        try {
+            const body = `## Phase ${phaseNumber}: ${phaseName}
+
+### Task: ${task.title}
+
+${task.description}
+
+---
+*Created by TDD Dashboard*
+*Task ID: ${task.id}*`;
+            const { stdout } = await execAsync(`gh issue create --title "[Phase ${phaseNumber}] ${task.title}" --body "${body.replace(/"/g, '\\"')}" --label "tdd,phase-${phaseNumber}"`, { cwd: process.cwd() });
+            // Extract issue number from output
+            const issueMatch = stdout.match(/issues\/(\d+)/);
+            if (issueMatch) {
+                taskToIssue.set(task.id, parseInt(issueMatch[1], 10));
+            }
+        }
+        catch (e) {
+            console.error(`Failed to create issue for task ${task.id}:`, e);
+        }
+    }
+    return taskToIssue;
+}
+// Mark issue as in-progress when agent starts
+export async function markIssueInProgress(issueNumber) {
+    try {
+        await execAsync(`gh issue edit ${issueNumber} --add-label "in-progress" --remove-label "tdd"`, { cwd: process.cwd() });
+    }
+    catch (e) {
+        // Ignore - label might not exist
+    }
+}
+// Mark issue as complete when agent finishes
+export async function markIssueComplete(issueNumber) {
+    try {
+        await execAsync(`gh issue close ${issueNumber} --comment "Completed by TDD agent"`, { cwd: process.cwd() });
+    }
+    catch (e) {
+        // Ignore errors
+    }
+}
+// Check if plan is approved (has APPROVED marker or user confirmed)
+export async function isPlanApproved(planPath) {
+    if (!existsSync(planPath))
+        return false;
+    const content = await readFile(planPath, 'utf-8');
+    return content.includes('[APPROVED]') || content.includes('Status: Approved');
+}
+// Mark plan as approved
+export async function approvePlan(planPath) {
+    if (!existsSync(planPath))
+        return;
+    const content = await readFile(planPath, 'utf-8');
+    const updatedContent = content.replace(/^(#.+)$/m, '$1\n\n> **Status: Approved** - Tasks synced to GitHub');
+    const { writeFile } = await import('fs/promises');
+    await writeFile(planPath, updatedContent);
+}

package/dashboard/dist/components/PlanSync.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dashboard/dist/components/PlanSync.test.js

@@ -0,0 +1,117 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { parseTasksFromPlan, isPlanApproved, approvePlan } from './PlanSync.js';
+import { vol } from 'memfs';
+// Mock fs modules
+vi.mock('fs', async () => {
+    const memfs = await import('memfs');
+    return memfs.fs;
+});
+vi.mock('fs/promises', async () => {
+    const memfs = await import('memfs');
+    return memfs.fs.promises;
+});
+describe('PlanSync', () => {
+    beforeEach(() => {
+        vol.reset();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('parseTasksFromPlan', () => {
+        it('returns empty array for non-existent file', async () => {
+            const tasks = await parseTasksFromPlan('/fake/path.md');
+            expect(tasks).toEqual([]);
+        });
+        it('parses markdown task format (## Task N: Title)', async () => {
+            vol.fromJSON({
+                '/plan.md': `# Phase 1 Plan
+
+## Task 1: Setup authentication
+Configure JWT tokens and session management.
+
+## Task 2: Create login endpoint
+Build POST /api/login route.
+`
+            });
+            const tasks = await parseTasksFromPlan('/plan.md');
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0]).toMatchObject({
+                id: 'task-1',
+                title: 'Setup authentication',
+            });
+            expect(tasks[0].description).toContain('Configure JWT');
+            expect(tasks[1]).toMatchObject({
+                id: 'task-2',
+                title: 'Create login endpoint',
+            });
+        });
+        it('parses XML task format (<task id="...">)', async () => {
+            vol.fromJSON({
+                '/plan.md': `# Phase 1
+
+<task id="01-01">
+Setup the database connection
+</task>
+
+<task id="01-02">
+Create user model
+</task>
+`
+            });
+            const tasks = await parseTasksFromPlan('/plan.md');
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0].id).toBe('01-01');
+            expect(tasks[1].id).toBe('01-02');
+        });
+        it('truncates description to 500 chars', async () => {
+            const longDescription = 'A'.repeat(600);
+            vol.fromJSON({
+                '/plan.md': `## Task 1: Long task\n${longDescription}`
+            });
+            const tasks = await parseTasksFromPlan('/plan.md');
+            expect(tasks[0].description.length).toBeLessThanOrEqual(500);
+        });
+    });
+    describe('isPlanApproved', () => {
+        it('returns false for non-existent file', async () => {
+            const result = await isPlanApproved('/fake/plan.md');
+            expect(result).toBe(false);
+        });
+        it('returns true when file contains [APPROVED]', async () => {
+            vol.fromJSON({
+                '/plan.md': `# Plan [APPROVED]\n\nSome content`
+            });
+            const result = await isPlanApproved('/plan.md');
+            expect(result).toBe(true);
+        });
+        it('returns true when file contains Status: Approved', async () => {
+            vol.fromJSON({
+                '/plan.md': `# Plan\n\n> **Status: Approved**\n\nContent`
+            });
+            const result = await isPlanApproved('/plan.md');
+            expect(result).toBe(true);
+        });
+        it('returns false when not approved', async () => {
+            vol.fromJSON({
+                '/plan.md': `# Plan\n\nNot yet approved.`
+            });
+            const result = await isPlanApproved('/plan.md');
+            expect(result).toBe(false);
+        });
+    });
+    describe('approvePlan', () => {
+        it('does nothing for non-existent file', async () => {
+            await approvePlan('/fake/plan.md');
+            // No error thrown
+        });
+        it('adds approval status after first heading', async () => {
+            vol.fromJSON({
+                '/plan.md': `# My Plan\n\n## Task 1: Something`
+            });
+            await approvePlan('/plan.md');
+            const content = vol.readFileSync('/plan.md', 'utf-8');
+            expect(content).toContain('Status: Approved');
+            expect(content).toContain('Tasks synced to GitHub');
+        });
+    });
+});

package/dashboard/dist/components/PreviewPane.d.ts

@@ -0,0 +1,6 @@
+interface PreviewPaneProps {
+    isActive: boolean;
+    isTTY?: boolean;
+}
+export declare function PreviewPane({ isActive, isTTY }: PreviewPaneProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dashboard/dist/components/PreviewPane.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import { useState, useCallback } from 'react';
+import Spinner from 'ink-spinner';
+export function PreviewPane({ isActive, isTTY = true }) {
+    const [status, setStatus] = useState('stopped');
+    const [url, setUrl] = useState(null);
+    const [error, setError] = useState(null);
+    const startContainer = useCallback(async () => {
+        setStatus('starting');
+        setError(null);
+        try {
+            // TODO: Integrate with dockerode
+            // For now, simulate container start
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            setStatus('running');
+            setUrl('http://localhost:3000');
+        }
+        catch (e) {
+            setStatus('error');
+            setError(e instanceof Error ? e.message : 'Failed to start container');
+        }
+    }, []);
+    const stopContainer = useCallback(async () => {
+        setStatus('stopped');
+        setUrl(null);
+    }, []);
+    useInput((input, key) => {
+        if (!isActive)
+            return;
+        if (input === 's' && status === 'stopped') {
+            startContainer();
+        }
+        else if (input === 'x' && status === 'running') {
+            stopContainer();
+        }
+        else if (input === 'r' && status === 'running') {
+            // Restart
+            stopContainer().then(startContainer);
+        }
+    }, { isActive: isTTY });
+    return (_jsxs(Box, { padding: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { children: "Status: " }), status === 'stopped' && _jsx(Text, { color: "gray", children: "Stopped" }), status === 'starting' && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { color: "yellow", children: " Starting..." })] })), status === 'running' && _jsx(Text, { color: "green", children: "Running" }), status === 'error' && _jsx(Text, { color: "red", children: "Error" })] }), url && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "cyan", children: url }) })), error && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "red", children: error }) })), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsxs(Text, { dimColor: true, children: [status === 'stopped' && isActive && '[s] Start', status === 'running' && isActive && '[x] Stop | [r] Restart', !isActive && 'Tab to this pane for controls'] }) })] }));
+}

package/dashboard/dist/components/PreviewPane.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dashboard/dist/components/PreviewPane.test.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect } from 'vitest';
+import { render } from 'ink-testing-library';
+import { PreviewPane } from './PreviewPane.js';
+describe('PreviewPane', () => {
+    describe('initial state', () => {
+        it('shows stopped status initially', () => {
+            const { lastFrame } = render(_jsx(PreviewPane, { isActive: false }));
+            const output = lastFrame();
+            expect(output).toContain('Status:');
+            expect(output).toContain('Stopped');
+        });
+    });
+    describe('controls', () => {
+        it('shows start control when active and stopped', () => {
+            const { lastFrame } = render(_jsx(PreviewPane, { isActive: true }));
+            const output = lastFrame();
+            expect(output).toContain('[s] Start');
+        });
+        it('shows hint when inactive', () => {
+            const { lastFrame } = render(_jsx(PreviewPane, { isActive: false }));
+            const output = lastFrame();
+            expect(output).toContain('Tab to this pane');
+        });
+    });
+    describe('render states', () => {
+        it('renders without error when active', () => {
+            const { lastFrame } = render(_jsx(PreviewPane, { isActive: true }));
+            expect(lastFrame()).toBeDefined();
+        });
+        it('renders without error when inactive', () => {
+            const { lastFrame } = render(_jsx(PreviewPane, { isActive: false }));
+            expect(lastFrame()).toBeDefined();
+        });
+    });
+});

package/dashboard/dist/components/StatusPane.d.ts

@@ -0,0 +1 @@
+export declare function StatusPane(): import("react/jsx-runtime").JSX.Element;

package/dashboard/dist/components/StatusPane.js

@@ -0,0 +1,32 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useState, useEffect } from 'react';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export function StatusPane() {
+    const [tests, setTests] = useState(null);
+    const [lastRun, setLastRun] = useState('Never');
+    useEffect(() => {
+        async function checkTests() {
+            try {
+                // Try to detect test framework and get status
+                // This is a simplified version - real implementation would parse test output
+                const { stdout } = await execAsync('npm test -- --reporter=json 2>/dev/null || echo "{}"', {
+                    timeout: 30000,
+                    cwd: process.cwd()
+                });
+                // For now, show placeholder
+                setTests({ total: 0, passed: 0, failed: 0, pending: 0 });
+                setLastRun(new Date().toLocaleTimeString());
+            }
+            catch (e) {
+                // Tests not configured or failed to run
+                setTests(null);
+            }
+        }
+        // Check on mount
+        checkTests();
+    }, []);
+    return (_jsx(Box, { padding: 1, flexDirection: "column", children: tests ? (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsxs(Text, { color: "green", children: ["Passed: ", tests.passed] }), _jsx(Text, { children: " | " }), _jsxs(Text, { color: "red", children: ["Failed: ", tests.failed] }), _jsx(Text, { children: " | " }), _jsxs(Text, { color: "yellow", children: ["Pending: ", tests.pending] })] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "gray", children: ["Total: ", tests.total] }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Last run: ", lastRun] }) })] })) : (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "gray", children: "No test results." }), _jsx(Text, { dimColor: true, children: "Run tests to see status." })] })) }));
+}

package/dashboard/dist/components/StatusPane.test.d.ts

@@ -0,0 +1 @@
+export {};