@opensassi/opencode 0.1.2 → 0.1.4

package/dashboard/dashboard.e2e.test.ts

@@ -0,0 +1,247 @@
+import { test, expect } from '@playwright/test';
+import { execSync, spawn, type ChildProcess } from 'node:child_process';
+import { resolve } from 'node:path';
+
+const HARNESS_DIR = resolve(import.meta.dirname ?? '.', '..');
+let server: ChildProcess;
+const PORT = 3099;
+
+test.beforeAll(() => {
+  server = spawn('node', ['scripts/dashboard.js', '--port', String(PORT)], {
+    cwd: HARNESS_DIR,
+    stdio: 'pipe',
+  });
+  // Wait for server to start
+  const maxWait = 10000;
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    try {
+      execSync(`curl -sf http://127.0.0.1:${PORT}/api/health`, { stdio: 'ignore' });
+      break;
+    } catch {
+      execSync('sleep 0.3');
+    }
+  }
+});
+
+test.afterAll(() => {
+  if (server) {
+    server.kill();
+  }
+});
+
+test.describe('API endpoints', () => {
+
+  test('GET /api/health returns ok', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/health`);
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body.status).toBe('ok');
+    expect(body.days_count).toBeGreaterThan(0);
+    expect(body.sessions_count).toBeGreaterThan(0);
+  });
+
+  test('GET /api/days returns day list', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/days`);
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body.days).toBeInstanceOf(Array);
+    expect(body.days.length).toBeGreaterThanOrEqual(4);
+    expect(body.days).toContain('2026-05-16');
+  });
+
+  test('GET /api/days/latest returns latest day', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/days/latest`);
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body.date).toBe('2026-05-16');
+    expect(body.total_sessions).toBe(2);
+    expect(body.session_breakdown).toBeInstanceOf(Array);
+  });
+
+  test('GET /api/days/:date returns specific day', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/days/2026-05-16`);
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body.date).toBe('2026-05-16');
+    expect(body.total_sessions).toBe(2);
+    expect(body.total_prompter_time_hours).toBe(1.5);
+    expect(body.total_sme_time_hours).toBe(14);
+    expect(body.ai_multiplier).toBe(9.3);
+    expect(body.top_subject_areas.length).toBeGreaterThan(0);
+    expect(body.session_breakdown.length).toBe(2);
+  });
+
+  test('GET /api/days/:date 404 on missing date', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/days/2099-01-01`);
+    expect(res.status).toBe(404);
+  });
+
+  test('GET /api/sessions returns paginated sessions', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/sessions`);
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body.total).toBeGreaterThan(0);
+    expect(body.sessions).toBeInstanceOf(Array);
+    expect(body.sessions.length).toBeGreaterThan(0);
+    expect(body.sessions[0]).toHaveProperty('date');
+    expect(body.sessions[0]).toHaveProperty('entry');
+    expect(body.sessions[0].entry).toHaveProperty('session_id');
+    expect(body.sessions[0].entry).toHaveProperty('duration_minutes');
+    expect(body.sessions[0].entry).toHaveProperty('tags');
+  });
+
+  test('GET /api/sessions/:id returns session with detail', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/sessions/2026-05-16-npm-optimizer-skill-revision`);
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body.summary).toBeTruthy();
+    expect(body.summary.entry.session_id).toContain('2026-05-16-npm-optimizer');
+    expect(body.detail).toBeTruthy();
+    expect(body.detail.info).toHaveProperty('title');
+    expect(body.detail.messages).toBeInstanceOf(Array);
+  });
+
+  test('GET /api/sessions/:id 404 on missing session', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/sessions/nonexistent-session`);
+    expect(res.status).toBe(404);
+  });
+
+  test('GET /api/stats returns cross-day aggregates', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/stats`);
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body.total_days).toBe(4);
+    expect(body.total_sessions).toBe(18);
+  });
+
+  test('GET /api/search returns results', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/search?q=opensassi`);
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body.results).toBeInstanceOf(Array);
+    expect(body.results.length).toBeGreaterThan(0);
+    expect(body.results[0]).toHaveProperty('session_id');
+    expect(body.results[0]).toHaveProperty('match_type');
+  });
+
+  test('GET /api/search returns empty for no match', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/search?q=zzz_nonexistent_zzz`);
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body.results).toBeInstanceOf(Array);
+    expect(body.results.length).toBe(0);
+  });
+
+  test('GET /api/git/log returns commits', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/git/log`);
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body.commits).toBeInstanceOf(Array);
+    expect(body.commits.length).toBeGreaterThan(0);
+    expect(body.commits[0]).toHaveProperty('commit');
+    expect(body.commits[0]).toHaveProperty('message');
+  });
+
+  test('GET /api/git/stats returns stats', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/git/stats`);
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body.total_commits).toBeGreaterThan(0);
+    expect(body).toHaveProperty('per_date');
+  });
+
+  test('GET /api/git/commit/:hash returns diff', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/git/commit/HEAD`);
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body.diff).toBeTruthy();
+    expect(body.diff.length).toBeGreaterThan(100);
+  });
+
+  test('GET /api/git/commit/:hash 404 on missing', async () => {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/git/commit/0000000000000000000000000000000000000000`);
+    expect(res.status).toBe(404);
+  });
+});
+
+test.describe('Frontend pages', () => {
+
+  test('serves index.html at /', async ({ page }) => {
+    await page.goto(`http://127.0.0.1:${PORT}/`);
+    await expect(page.locator('nav')).toBeVisible();
+    await expect(page.locator('.nav-brand')).toHaveText('opencode');
+  });
+
+  test('hash routing renders overview page', async ({ page }) => {
+    await page.goto(`http://127.0.0.1:${PORT}/#/`);
+    await expect(page.getByRole('heading', { name: 'Overview' })).toBeVisible();
+  });
+
+  test('navigates to Daily tab', async ({ page }) => {
+    await page.goto(`http://127.0.0.1:${PORT}/`);
+    await page.click('a[href="#/daily"]');
+    await page.waitForSelector('.page-title');
+    await expect(page.locator('.page-title')).toHaveText('Daily Reports');
+  });
+
+  test('opens a daily detail page', async ({ page }) => {
+    await page.goto(`http://127.0.0.1:${PORT}/#/daily/2026-05-16`);
+    await page.waitForSelector('.page-title');
+    await expect(page.locator('.page-title')).toHaveText('2026-05-16');
+    await expect(page.locator('.stats-grid .card-value').first()).toBeVisible();
+  });
+
+  test('opens a session page from daily', async ({ page }) => {
+    await page.goto(`http://127.0.0.1:${PORT}/#/daily/2026-05-16`);
+    await page.waitForSelector('.session-card');
+    await page.click('.session-card');
+    await page.waitForSelector('.page-title');
+    const title = await page.locator('.page-title').textContent();
+    expect(title).toContain('2026-05-16');
+  });
+
+  test('search page works', async ({ page }) => {
+    await page.goto(`http://127.0.0.1:${PORT}/#/search?q=opensassi`);
+    await page.waitForSelector('.page-title');
+    await expect(page.locator('.page-title')).toHaveText('Search');
+    await page.waitForSelector('.session-card');
+    const cards = await page.locator('.session-card').count();
+    expect(cards).toBeGreaterThan(0);
+  });
+
+  test('git page renders commits', async ({ page }) => {
+    await page.goto(`http://127.0.0.1:${PORT}/#/git`);
+    await page.waitForSelector('.page-title');
+    await expect(page.locator('.page-title')).toHaveText('Git Activity');
+    await page.waitForSelector('.session-card');
+    const commits = await page.locator('.session-card').count();
+    expect(commits).toBeGreaterThan(0);
+  });
+
+  test('experiments list page renders', async ({ page }) => {
+    await page.goto(`http://127.0.0.1:${PORT}/#/experiments`);
+    await page.waitForSelector('.page-title');
+    await expect(page.locator('.page-title')).toHaveText('Experiments');
+  });
+
+  test('specs tree renders technical-specification.md first', async ({ page }) => {
+    await page.goto(`http://127.0.0.1:${PORT}/#/specs`);
+    await page.waitForSelector('.page-title');
+    await expect(page.locator('.page-title')).toHaveText('Technical Specifications');
+    // The first link should be technical-specification.md
+    const firstLink = page.locator('a[href*="spec/"]').first();
+    await expect(firstLink).toBeVisible();
+    const text = await firstLink.textContent();
+    expect(text).toBe('technical-specification.md');
+  });
+
+  test('specs tree loads a spec file', async ({ page }) => {
+    await page.goto(`http://127.0.0.1:${PORT}/#/specs`);
+    await page.waitForSelector('.page-title');
+    const firstLink = page.locator('a[href*="spec/"]').first();
+    await firstLink.click();
+    await page.waitForTimeout(500);
+    expect(page.url()).toContain('/spec/');
+  });
+});

package/dashboard/dist/index.d.ts

@@ -0,0 +1,9 @@
+export interface DashboardOptions {
+    port: number;
+    sessionsDir: string;
+    repoDir: string;
+    experimentsDir?: string;
+    host: string;
+    gitSince?: string;
+}
+export declare function startDashboard(opts?: Partial<DashboardOptions>): void;

package/dashboard/dist/index.js

@@ -0,0 +1,36 @@
+import express from 'express';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
+import { createApiRouter } from './routes/api.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export function startDashboard(opts = {}) {
+    const port = opts.port ?? (parseInt(process.env.DEEPENC_DASHBOARD_PORT ?? '') || 3000);
+    const host = opts.host ?? '127.0.0.1';
+    const repoDir = opts.repoDir ?? process.cwd();
+    const sessionsDir = opts.sessionsDir ?? resolve(repoDir, 'sessions');
+    const experimentsDir = opts.experimentsDir ?? resolve(repoDir, 'perf', 'experiments');
+    const specsDir = resolve(repoDir);
+    const gitSince = opts.gitSince;
+    const app = express();
+    const publicDir = join(__dirname, '..', 'public');
+    app.use(express.static(publicDir));
+    app.use('/api', createApiRouter(sessionsDir, repoDir, experimentsDir, gitSince, specsDir));
+    app.get('/{*path}', (_req, res) => {
+        res.sendFile(join(publicDir, 'index.html'));
+    });
+    const server = app.listen(port, host, () => {
+        console.log(`opencode dashboard running at http://${host}:${port}`);
+        const hasData = existsSync(join(sessionsDir, 'daily'));
+        if (!hasData) {
+            console.log(`  (sessions directory not found at ${sessionsDir})`);
+        }
+    });
+    const shutdown = () => {
+        console.log('\nShutting down dashboard...');
+        server.close(() => process.exit(0));
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}

package/dashboard/dist/routes/api.d.ts

@@ -0,0 +1,2 @@
+import { Router } from 'express';
+export declare function createApiRouter(sessionsDir: string, repoDir: string, experimentsDir?: string, gitSince?: string, specsRoot?: string): Router;

package/dashboard/dist/routes/api.js

@@ -0,0 +1,215 @@
+import { Router } from 'express';
+import { extname } from 'node:path';
+import { SessionsService } from '../services/sessions.js';
+import { GitService } from '../services/git.js';
+import { ExperimentsService } from '../services/experiments.js';
+import { TechSpecService } from '../services/specs.js';
+function qs(v) {
+    if (typeof v === 'string')
+        return v;
+    if (Array.isArray(v) && v.length > 0)
+        return String(v[0]);
+    return undefined;
+}
+export function createApiRouter(sessionsDir, repoDir, experimentsDir, gitSince, specsRoot) {
+    const router = Router();
+    const sessions = new SessionsService(sessionsDir);
+    const git = new GitService(repoDir, gitSince);
+    const experiments = experimentsDir ? new ExperimentsService(experimentsDir) : null;
+    const specs = specsRoot ? new TechSpecService(specsRoot) : null;
+    router.get('/health', (_req, res) => {
+        const days = sessions.listDays();
+        const flat = sessions.getAllSessionsFlat();
+        const health = {
+            status: days.length > 0 ? 'ok' : 'error',
+            days_count: days.length,
+            sessions_count: flat.length,
+            sessions_path: sessionsDir,
+        };
+        res.json(health);
+    });
+    router.get('/days', (_req, res) => {
+        const days = sessions.listDays();
+        res.json({ days });
+    });
+    router.get('/days/latest', (_req, res) => {
+        const days = sessions.listDays();
+        if (days.length === 0) {
+            res.status(404).json({ error: 'No daily data found' });
+            return;
+        }
+        const day = sessions.getDay(days[days.length - 1]);
+        res.json(day);
+    });
+    router.get('/days/:date', (req, res) => {
+        const date = String(req.params.date);
+        const day = sessions.getDay(date);
+        if (day.total_sessions === 0 && day.top_subject_areas.length === 0) {
+            res.status(404).json({ error: `No data for date: ${date}` });
+            return;
+        }
+        res.json(day);
+    });
+    router.get('/sessions', (req, res) => {
+        const flat = sessions.getAllSessionsFlat();
+        const page = parseInt(qs(req.query.page) ?? '') || 1;
+        const limit = parseInt(qs(req.query.limit) ?? '') || 50;
+        const start = (page - 1) * limit;
+        const paginated = flat.slice(start, start + limit);
+        res.json({ sessions: paginated, total: flat.length, page, limit });
+    });
+    router.get('/sessions/:sessionId/summary', (req, res) => {
+        const sessionId = String(req.params.sessionId);
+        const flat = sessions.getAllSessionsFlat();
+        const summary = flat.find(s => s.entry.session_id === sessionId);
+        if (!summary) {
+            res.status(404).json({ error: `Session not found: ${sessionId}` });
+            return;
+        }
+        const md = sessions.getSessionSummary(sessionId);
+        if (!md) {
+            res.status(404).json({ error: 'No summary file found for this session' });
+            return;
+        }
+        res.json({ summary, markdown: md });
+    });
+    router.get('/sessions/:sessionId', (req, res) => {
+        const sessionId = String(req.params.sessionId);
+        const flat = sessions.getAllSessionsFlat();
+        const summary = flat.find(s => s.entry.session_id === sessionId);
+        if (!summary) {
+            res.status(404).json({ error: `Session not found: ${sessionId}` });
+            return;
+        }
+        const detail = sessions.getSessionDetail(sessionId);
+        res.json({ summary, detail });
+    });
+    router.get('/stats', (_req, res) => {
+        const days = sessions.listDays();
+        const normalizedDays = days.map(d => sessions.getDay(d));
+        let totalSessions = 0;
+        let totalPrompter = 0;
+        let totalSme = 0;
+        let multiplierSum = 0;
+        let multiplierCount = 0;
+        for (const day of normalizedDays) {
+            totalSessions += day.total_sessions;
+            totalPrompter += day.total_prompter_time_hours;
+            totalSme += day.total_sme_time_hours;
+            if (day.ai_multiplier > 0) {
+                multiplierSum += day.ai_multiplier;
+                multiplierCount++;
+            }
+        }
+        const stats = {
+            total_days: days.length,
+            total_sessions: totalSessions,
+            total_prompter_time_hours: Math.round(totalPrompter * 10) / 10,
+            total_sme_time_hours: Math.round(totalSme * 10) / 10,
+            avg_multiplier: multiplierCount > 0 ? Math.round((multiplierSum / multiplierCount) * 10) / 10 : 0,
+            per_day: normalizedDays,
+        };
+        res.json(stats);
+    });
+    router.get('/search', (req, res) => {
+        const query = qs(req.query.q) ?? '';
+        if (!query.trim()) {
+            res.json({ results: [] });
+            return;
+        }
+        const results = sessions.search(query.trim());
+        res.json({ results });
+    });
+    router.get('/refresh', (_req, res) => {
+        sessions.refresh();
+        res.json({ status: 'refreshed' });
+    });
+    router.get('/git/log', (req, res) => {
+        const since = qs(req.query.since);
+        const until = qs(req.query.until);
+        const forkRange = git.detectForkPoint();
+        const range = since ? undefined : git.getRange(forkRange);
+        const commits = git.getLog(since, until, range);
+        res.json({ commits, forkRange });
+    });
+    router.get('/git/stats', (_req, res) => {
+        const forkRange = git.detectForkPoint();
+        const range = git.getRange(forkRange);
+        const stats = git.getStats(range);
+        res.json(stats);
+    });
+    router.get('/git/commit/:hash', (req, res) => {
+        const diff = git.getCommitDiff(String(req.params.hash));
+        if (!diff) {
+            res.status(404).json({ error: 'Commit not found' });
+            return;
+        }
+        res.json({ diff });
+    });
+    if (specs) {
+        router.get('/specs', (_req, res) => {
+            const tree = specs.getTree();
+            res.json(tree);
+        });
+        router.get('/specs/read', (req, res) => {
+            const specPath = qs(req.query.path);
+            if (!specPath) {
+                res.status(400).json({ error: 'path query parameter required' });
+                return;
+            }
+            const content = specs.readSpec(specPath);
+            if (content === null) {
+                res.status(404).json({ error: 'Spec not found' });
+                return;
+            }
+            res.json({ path: specPath, content });
+        });
+    }
+    if (experiments) {
+        router.get('/experiments', (_req, res) => {
+            const entries = experiments.listExperiments();
+            res.json({ experiments: entries });
+        });
+        router.get('/experiments/:name', (req, res) => {
+            const detail = experiments.getExperiment(String(req.params.name));
+            if (!detail) {
+                res.status(404).json({ error: 'Experiment not found' });
+                return;
+            }
+            res.json(detail);
+        });
+        router.get('/experiments/:name/read', (req, res) => {
+            const filePath = qs(req.query.path);
+            const raw = qs(req.query.raw);
+            if (!filePath) {
+                res.status(400).json({ error: 'path query parameter required' });
+                return;
+            }
+            if (raw === 'true') {
+                const buf = experiments.readFileRaw(filePath);
+                if (!buf) {
+                    res.status(404).json({ error: 'File not found' });
+                    return;
+                }
+                const ext = extname(filePath).toLowerCase();
+                const mime = {
+                    '.png': 'image/png',
+                    '.jpg': 'image/jpeg',
+                    '.jpeg': 'image/jpeg',
+                    '.gif': 'image/gif',
+                    '.svg': 'image/svg+xml',
+                    '.html': 'text/html; charset=utf-8',
+                };
+                res.type(mime[ext] ?? 'application/octet-stream').send(buf);
+                return;
+            }
+            const content = experiments.readFile(filePath);
+            if (content === null) {
+                res.status(404).json({ error: 'File not found' });
+                return;
+            }
+            res.json({ path: filePath, content });
+        });
+    }
+    return router;
+}

package/dashboard/dist/services/cache.d.ts

@@ -0,0 +1,13 @@
+export interface CacheEntry<T> {
+    value: T;
+    expiresAt: number;
+}
+export declare class TTLCache<T> {
+    private store;
+    private defaultTTL;
+    constructor(defaultTTLMs?: number);
+    get(key: string): T | undefined;
+    set(key: string, value: T, ttlMs?: number): void;
+    invalidate(key: string): void;
+    invalidateAll(): void;
+}

package/dashboard/dist/services/cache.js

@@ -0,0 +1,29 @@
+export class TTLCache {
+    store = new Map();
+    defaultTTL;
+    constructor(defaultTTLMs = 60_000) {
+        this.defaultTTL = defaultTTLMs;
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() > entry.expiresAt) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value, ttlMs) {
+        this.store.set(key, {
+            value,
+            expiresAt: Date.now() + (ttlMs ?? this.defaultTTL),
+        });
+    }
+    invalidate(key) {
+        this.store.delete(key);
+    }
+    invalidateAll() {
+        this.store.clear();
+    }
+}

package/dashboard/dist/services/experiments.d.ts

@@ -0,0 +1,11 @@
+import type { ExperimentEntry, ExperimentDetail } from '../types.js';
+export declare class ExperimentsService {
+    private experimentsDir;
+    constructor(experimentsDir: string);
+    listExperiments(): ExperimentEntry[];
+    getExperiment(directory: string): ExperimentDetail | null;
+    readFile(filePath: string): string | null;
+    readFileRaw(filePath: string): Buffer | null;
+    private listFilesRecursive;
+    private parseTable;
+}

package/dashboard/dist/services/experiments.js

@@ -0,0 +1,108 @@
+import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { join, resolve, relative } from 'node:path';
+export class ExperimentsService {
+    experimentsDir;
+    constructor(experimentsDir) {
+        this.experimentsDir = resolve(experimentsDir);
+    }
+    listExperiments() {
+        const indexPath = join(this.experimentsDir, 'README.md');
+        if (!existsSync(indexPath))
+            return [];
+        const content = readFileSync(indexPath, 'utf-8');
+        return this.parseTable(content);
+    }
+    getExperiment(directory) {
+        const entries = this.listExperiments();
+        const entry = entries.find(e => e.directory === directory || e.directory.replace(/\/$/, '') === directory.replace(/\/$/, ''));
+        if (!entry)
+            return null;
+        const dirPath = join(this.experimentsDir, entry.directory.replace(/\/$/, ''));
+        if (!existsSync(dirPath))
+            return null;
+        let readme = null;
+        const readmePath = join(dirPath, 'README.md');
+        if (existsSync(readmePath)) {
+            readme = readFileSync(readmePath, 'utf-8');
+        }
+        const subdirs = [];
+        const allFiles = [];
+        const expPrefix = entry.directory.replace(/\/$/, '');
+        const items = readdirSync(dirPath);
+        for (const item of items) {
+            const itemPath = join(dirPath, item);
+            const stat = statSync(itemPath);
+            if (stat.isDirectory()) {
+                const files = this.listFilesRecursive(itemPath, this.experimentsDir);
+                subdirs.push({ name: item, files });
+                allFiles.push(...files);
+            }
+            else {
+                const file = {
+                    path: relative(this.experimentsDir, itemPath),
+                    name: item,
+                    size: stat.size,
+                };
+                if (item !== 'README.md') {
+                    allFiles.push(file);
+                }
+            }
+        }
+        return { entry, readme, subdirs, allFiles };
+    }
+    readFile(filePath) {
+        const fullPath = join(this.experimentsDir, filePath);
+        if (!existsSync(fullPath))
+            return null;
+        return readFileSync(fullPath, 'utf-8');
+    }
+    readFileRaw(filePath) {
+        const fullPath = join(this.experimentsDir, filePath);
+        if (!existsSync(fullPath))
+            return null;
+        return readFileSync(fullPath);
+    }
+    listFilesRecursive(dirPath, rootDir) {
+        const files = [];
+        const items = readdirSync(dirPath);
+        for (const item of items) {
+            const itemPath = join(dirPath, item);
+            const stat = statSync(itemPath);
+            if (stat.isDirectory()) {
+                files.push(...this.listFilesRecursive(itemPath, rootDir));
+            }
+            else {
+                files.push({
+                    path: relative(rootDir, itemPath),
+                    name: item,
+                    size: stat.size,
+                });
+            }
+        }
+        return files;
+    }
+    parseTable(content) {
+        const entries = [];
+        const lines = content.split('\n');
+        let inTable = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('|') && trimmed.includes('---')) {
+                inTable = true;
+                continue;
+            }
+            if (!trimmed.startsWith('|') || !inTable)
+                continue;
+            const cells = trimmed.split('|').slice(1, -1).map(c => c.trim());
+            if (cells.length < 5)
+                continue;
+            const date = cells[0].trim();
+            const dirCell = cells[1].replace(/^`|`$/g, '').replace(/\/$/, '').trim();
+            const desc = cells[2].replace(/^`|`$/g, '').trim();
+            const outcome = cells[3].replace(/\*\*/g, '').trim();
+            const agent = cells[4].replace(/^`|`$/g, '').trim();
+            entries.push({ date, directory: dirCell, description: desc, outcome, agent });
+        }
+        return entries;
+    }
+}