tlc-claude-code 1.4.8 → 1.4.9

package/server/lib/dashboard/notes-api.js

@@ -0,0 +1,234 @@
+/**
+ * Notes API Module
+ * PROJECT.md and BUGS.md management
+ */
+import { promises as defaultFs } from 'fs';
+import path from 'path';
+
+/**
+ * Get notes (PROJECT.md) content
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Notes data
+ */
+export async function getNotes(options = {}) {
+  const fs = options.fs || defaultFs;
+  const basePath = options.basePath || process.cwd();
+
+  const filePath = path.join(basePath, 'PROJECT.md');
+
+  let content = '';
+  let exists = true;
+  let lastModified = null;
+
+  try {
+    content = await fs.readFile(filePath, 'utf-8');
+  } catch {
+    content = '';
+    exists = false;
+  }
+
+  try {
+    if (fs.stat) {
+      const stats = await fs.stat(filePath);
+      lastModified = stats.mtime;
+    }
+  } catch {
+    // Ignore stat errors
+  }
+
+  return {
+    content,
+    type: 'project',
+    exists,
+    lastModified
+  };
+}
+
+/**
+ * Update notes (PROJECT.md)
+ * @param {string} content - New content
+ * @param {Object} options - Options
+ * @returns {Promise<void>}
+ */
+export async function updateNotes(content, options = {}) {
+  const fs = options.fs || defaultFs;
+  const basePath = options.basePath || process.cwd();
+  const backup = options.backup || false;
+  const validate = options.validate || false;
+
+  if (validate && (!content || !content.trim())) {
+    throw new Error('Content cannot be empty');
+  }
+
+  const filePath = path.join(basePath, 'PROJECT.md');
+
+  // Create backup if requested
+  if (backup) {
+    try {
+      const oldContent = await fs.readFile(filePath, 'utf-8');
+      const backupPath = path.join(basePath, `PROJECT.md.backup.${Date.now()}`);
+      await fs.writeFile(backupPath, oldContent);
+    } catch {
+      // Ignore backup errors for missing files
+    }
+  }
+
+  await fs.writeFile(filePath, content);
+}
+
+/**
+ * Get bugs (BUGS.md) content
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Bugs data
+ */
+export async function getBugs(options = {}) {
+  const fs = options.fs || defaultFs;
+  const basePath = options.basePath || process.cwd();
+  const parse = options.parse || false;
+
+  const filePath = path.join(basePath, '.planning', 'BUGS.md');
+
+  let content = '';
+  let exists = true;
+
+  try {
+    content = await fs.readFile(filePath, 'utf-8');
+  } catch {
+    content = '';
+    exists = false;
+  }
+
+  const result = {
+    content,
+    exists
+  };
+
+  if (parse) {
+    result.entries = parseBugEntries(content);
+  }
+
+  return result;
+}
+
+/**
+ * Parse bug entries from BUGS.md content
+ * @param {string} content - BUGS.md content
+ * @returns {Array} Bug entries
+ */
+function parseBugEntries(content) {
+  const entries = [];
+  const lines = content.split('\n');
+
+  let currentBug = null;
+
+  for (const line of lines) {
+    // Match bug header: ## Bug: Title
+    const bugMatch = line.match(/^##\s+Bug:\s*(.+)$/);
+    if (bugMatch) {
+      if (currentBug) {
+        entries.push(currentBug);
+      }
+      currentBug = {
+        title: bugMatch[1].trim(),
+        severity: null,
+        status: null
+      };
+      continue;
+    }
+
+    if (currentBug) {
+      // Match severity: **Severity:** Value
+      const severityMatch = line.match(/^\*\*Severity:\*\*\s*(.+)$/);
+      if (severityMatch) {
+        currentBug.severity = severityMatch[1].trim();
+      }
+
+      // Match status: **Status:** Value
+      const statusMatch = line.match(/^\*\*Status:\*\*\s*(.+)$/);
+      if (statusMatch) {
+        currentBug.status = statusMatch[1].trim();
+      }
+    }
+  }
+
+  if (currentBug) {
+    entries.push(currentBug);
+  }
+
+  return entries;
+}
+
+/**
+ * Add a bug to BUGS.md
+ * @param {Object} bugData - Bug data
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Created bug
+ */
+export async function addBug(bugData, options = {}) {
+  if (!bugData.title) {
+    throw new Error('Title is required');
+  }
+
+  const fs = options.fs || defaultFs;
+  const basePath = options.basePath || process.cwd();
+
+  const filePath = path.join(basePath, '.planning', 'BUGS.md');
+
+  let content = '';
+  try {
+    content = await fs.readFile(filePath, 'utf-8');
+  } catch {
+    content = '# Bugs\n\n';
+  }
+
+  // Create bug entry
+  const timestamp = new Date().toISOString().split('T')[0];
+  const severity = bugData.severity || 'Medium';
+  const description = bugData.description || '';
+
+  const bugEntry = `
+## Bug: ${bugData.title}
+**Severity:** ${severity}
+**Status:** Open
+**Date:** ${timestamp}
+
+${description}
+`;
+
+  const newContent = content + bugEntry;
+  await fs.writeFile(filePath, newContent);
+
+  return {
+    title: bugData.title,
+    severity,
+    status: 'Open',
+    date: timestamp
+  };
+}
+
+/**
+ * Create Notes API handlers
+ * @param {Object} options - Options
+ * @returns {Object} API handlers
+ */
+export function createNotesApi(options = {}) {
+  const { basePath = process.cwd(), fs: fileSystem = defaultFs } = options;
+
+  return {
+    async getNotes(opts = {}) {
+      return getNotes({ fs: fileSystem, basePath, ...opts });
+    },
+
+    async updateNotes(content, opts = {}) {
+      return updateNotes(content, { fs: fileSystem, basePath, ...opts });
+    },
+
+    async getBugs(opts = {}) {
+      return getBugs({ fs: fileSystem, basePath, ...opts });
+    },
+
+    async addBug(bugData, opts = {}) {
+      return addBug(bugData, { fs: fileSystem, basePath, ...opts });
+    }
+  };
+}

package/server/lib/dashboard/notes-api.test.js

@@ -0,0 +1,134 @@
+/**
+ * Notes API Module Tests
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { getNotes, updateNotes, getBugs, addBug, createNotesApi } from './notes-api.js';
+
+describe('notes-api', () => {
+  describe('getNotes', () => {
+    it('returns PROJECT.md content', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue('# Project\n\nDescription')
+      };
+      const notes = await getNotes({ fs: mockFs, basePath: '/test' });
+      expect(notes.content).toContain('Project');
+      expect(notes.type).toBe('project');
+    });
+
+    it('includes last modified time', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue('content'),
+        stat: vi.fn().mockResolvedValue({ mtime: new Date() })
+      };
+      const notes = await getNotes({ fs: mockFs, basePath: '/test' });
+      expect(notes.lastModified).toBeDefined();
+    });
+
+    it('handles missing file', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockRejectedValue(new Error('ENOENT'))
+      };
+      const notes = await getNotes({ fs: mockFs, basePath: '/test' });
+      expect(notes.content).toBe('');
+      expect(notes.exists).toBe(false);
+    });
+  });
+
+  describe('updateNotes', () => {
+    it('writes PROJECT.md content', async () => {
+      const mockFs = {
+        writeFile: vi.fn().mockResolvedValue(undefined)
+      };
+      await updateNotes('# Updated', { fs: mockFs, basePath: '/test' });
+      expect(mockFs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('PROJECT.md'),
+        '# Updated'
+      );
+    });
+
+    it('creates backup before update', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue('old content'),
+        writeFile: vi.fn().mockResolvedValue(undefined)
+      };
+      await updateNotes('new content', { fs: mockFs, basePath: '/test', backup: true });
+      expect(mockFs.writeFile).toHaveBeenCalledTimes(2); // backup + main
+    });
+
+    it('validates markdown format', async () => {
+      const mockFs = { writeFile: vi.fn() };
+      await expect(updateNotes('', { fs: mockFs, validate: true }))
+        .rejects.toThrow(/empty/i);
+    });
+  });
+
+  describe('getBugs', () => {
+    it('returns BUGS.md content', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue('## Bug 1\nDescription')
+      };
+      const bugs = await getBugs({ fs: mockFs, basePath: '/test' });
+      expect(bugs.content).toContain('Bug 1');
+    });
+
+    it('parses bug entries', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue(`
+## Bug: Login fails
+**Severity:** High
+**Status:** Open
+
+## Bug: Slow load
+**Severity:** Low
+**Status:** Fixed
+`)
+      };
+      const bugs = await getBugs({ fs: mockFs, basePath: '/test', parse: true });
+      expect(bugs.entries.length).toBe(2);
+      expect(bugs.entries[0].title).toBe('Login fails');
+      expect(bugs.entries[0].severity).toBe('High');
+    });
+  });
+
+  describe('addBug', () => {
+    it('appends bug to BUGS.md', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue('# Bugs\n'),
+        writeFile: vi.fn().mockResolvedValue(undefined)
+      };
+      await addBug({
+        title: 'New bug',
+        description: 'Bug description',
+        severity: 'High'
+      }, { fs: mockFs, basePath: '/test' });
+      const content = mockFs.writeFile.mock.calls[0][1];
+      expect(content).toContain('New bug');
+      expect(content).toContain('High');
+    });
+
+    it('validates required fields', async () => {
+      await expect(addBug({ description: 'No title' }, {}))
+        .rejects.toThrow(/title.*required/i);
+    });
+
+    it('adds timestamp', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue(''),
+        writeFile: vi.fn().mockResolvedValue(undefined)
+      };
+      await addBug({ title: 'Bug', severity: 'Low' }, { fs: mockFs, basePath: '/test' });
+      const content = mockFs.writeFile.mock.calls[0][1];
+      expect(content).toMatch(/\d{4}-\d{2}-\d{2}/); // date format
+    });
+  });
+
+  describe('createNotesApi', () => {
+    it('creates API handlers', () => {
+      const api = createNotesApi({ basePath: '/test' });
+      expect(api.getNotes).toBeDefined();
+      expect(api.updateNotes).toBeDefined();
+      expect(api.getBugs).toBeDefined();
+      expect(api.addBug).toBeDefined();
+    });
+  });
+});

package/server/lib/dashboard/router-api.js

@@ -0,0 +1,176 @@
+/**
+ * Router Status API
+ * Multi-LLM router status API
+ */
+
+/**
+ * Get router status
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Router status
+ */
+export async function getRouterStatus(options = {}) {
+  const { router } = options;
+
+  if (!router) {
+    return {
+      providers: [],
+      overall: 'unknown'
+    };
+  }
+
+  const providers = router.getProviders();
+
+  // Determine overall status
+  const hasError = providers.some(p => p.status === 'error');
+  const allActive = providers.every(p => p.status === 'active');
+
+  let overall;
+  if (providers.length === 0) {
+    overall = 'unknown';
+  } else if (allActive) {
+    overall = 'healthy';
+  } else if (hasError) {
+    overall = 'degraded';
+  } else {
+    overall = 'healthy';
+  }
+
+  return {
+    providers,
+    overall,
+    timestamp: new Date().toISOString()
+  };
+}
+
+/**
+ * Get provider statistics
+ * @param {Object} data - Data containing requests
+ * @returns {Object} Provider stats
+ */
+export function getProviderStats(data = {}) {
+  const { requests = [] } = data;
+  const stats = {};
+
+  // Group requests by provider
+  const byProvider = {};
+  for (const req of requests) {
+    if (!byProvider[req.provider]) {
+      byProvider[req.provider] = [];
+    }
+    byProvider[req.provider].push(req);
+  }
+
+  // Calculate stats for each provider
+  for (const [provider, providerReqs] of Object.entries(byProvider)) {
+    const requestCount = providerReqs.length;
+
+    // Calculate error rate
+    const errors = providerReqs.filter(r => r.error === true).length;
+    const errorRate = requestCount > 0 ? errors / requestCount : 0;
+
+    // Calculate average latency
+    const latencies = providerReqs.filter(r => r.latency !== undefined).map(r => r.latency);
+    const avgLatency = latencies.length > 0
+      ? latencies.reduce((sum, l) => sum + l, 0) / latencies.length
+      : 0;
+
+    stats[provider] = {
+      requests: requestCount,
+      errorRate,
+      avgLatency
+    };
+  }
+
+  return stats;
+}
+
+/**
+ * Calculate costs from requests
+ * @param {Array} requests - Request array
+ * @param {Object} pricing - Pricing per provider
+ * @returns {Object} Cost breakdown
+ */
+export function calculateCosts(requests, pricing = {}) {
+  const byProvider = {};
+  let total = 0;
+
+  for (const req of requests) {
+    const provider = req.provider;
+    const providerPricing = pricing[provider];
+
+    if (!byProvider[provider]) {
+      byProvider[provider] = 0;
+    }
+
+    if (providerPricing) {
+      const inputCost = (req.inputTokens || 0) * (providerPricing.input || 0) / 1000;
+      const outputCost = (req.outputTokens || 0) * (providerPricing.output || 0) / 1000;
+      const cost = inputCost + outputCost;
+      byProvider[provider] += cost;
+      total += cost;
+    } else {
+      // No pricing available
+      byProvider[provider] = 0;
+    }
+  }
+
+  return {
+    total,
+    byProvider
+  };
+}
+
+/**
+ * Filter requests by time range
+ * @param {Array} requests - Requests to filter
+ * @param {Object} range - Time range with start and optional end
+ * @returns {Array} Filtered requests
+ */
+export function filterByTimeRange(requests, range = {}) {
+  const { start, end } = range;
+
+  return requests.filter(req => {
+    const timestamp = req.timestamp;
+
+    if (start !== undefined && timestamp < start) {
+      return false;
+    }
+
+    if (end !== undefined && timestamp > end) {
+      return false;
+    }
+
+    return true;
+  });
+}
+
+/**
+ * Create Router API handler
+ * @param {Object} options - Options
+ * @returns {Object} API handlers
+ */
+export function createRouterApi(options = {}) {
+  const { router, requestStore } = options;
+
+  return {
+    async getStatus() {
+      return getRouterStatus({ router });
+    },
+
+    getStats(timeRange) {
+      let requests = requestStore?.getRequests() || [];
+      if (timeRange) {
+        requests = filterByTimeRange(requests, timeRange);
+      }
+      return getProviderStats({ requests });
+    },
+
+    getCosts(pricing, timeRange) {
+      let requests = requestStore?.getRequests() || [];
+      if (timeRange) {
+        requests = filterByTimeRange(requests, timeRange);
+      }
+      return calculateCosts(requests, pricing);
+    }
+  };
+}

package/server/lib/dashboard/router-api.test.js

@@ -0,0 +1,132 @@
+/**
+ * Router Status API Tests
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { getRouterStatus, getProviderStats, calculateCosts, filterByTimeRange, createRouterApi } from './router-api.js';
+
+describe('router-api', () => {
+  describe('getRouterStatus', () => {
+    it('returns all provider statuses', async () => {
+      const mockRouter = {
+        getProviders: vi.fn().mockReturnValue([
+          { name: 'openai', status: 'active' },
+          { name: 'anthropic', status: 'active' }
+        ])
+      };
+      const status = await getRouterStatus({ router: mockRouter });
+      expect(status.providers.length).toBe(2);
+      expect(status.providers[0].name).toBe('openai');
+    });
+
+    it('includes overall status', async () => {
+      const mockRouter = {
+        getProviders: vi.fn().mockReturnValue([
+          { name: 'openai', status: 'active' }
+        ])
+      };
+      const status = await getRouterStatus({ router: mockRouter });
+      expect(status.overall).toBe('healthy');
+    });
+
+    it('reports degraded when providers down', async () => {
+      const mockRouter = {
+        getProviders: vi.fn().mockReturnValue([
+          { name: 'openai', status: 'error' },
+          { name: 'anthropic', status: 'active' }
+        ])
+      };
+      const status = await getRouterStatus({ router: mockRouter });
+      expect(status.overall).toBe('degraded');
+    });
+  });
+
+  describe('getProviderStats', () => {
+    it('returns request counts', () => {
+      const stats = getProviderStats({
+        requests: [
+          { provider: 'openai', timestamp: Date.now() },
+          { provider: 'openai', timestamp: Date.now() },
+          { provider: 'anthropic', timestamp: Date.now() }
+        ]
+      });
+      expect(stats.openai.requests).toBe(2);
+      expect(stats.anthropic.requests).toBe(1);
+    });
+
+    it('calculates error rates', () => {
+      const stats = getProviderStats({
+        requests: [
+          { provider: 'openai', error: false },
+          { provider: 'openai', error: true }
+        ]
+      });
+      expect(stats.openai.errorRate).toBe(0.5);
+    });
+
+    it('tracks latency', () => {
+      const stats = getProviderStats({
+        requests: [
+          { provider: 'openai', latency: 100 },
+          { provider: 'openai', latency: 200 }
+        ]
+      });
+      expect(stats.openai.avgLatency).toBe(150);
+    });
+  });
+
+  describe('calculateCosts', () => {
+    it('calculates total costs', () => {
+      const requests = [
+        { provider: 'openai', inputTokens: 1000, outputTokens: 500 },
+        { provider: 'anthropic', inputTokens: 2000, outputTokens: 1000 }
+      ];
+      const costs = calculateCosts(requests, {
+        openai: { input: 0.01, output: 0.03 },
+        anthropic: { input: 0.008, output: 0.024 }
+      });
+      expect(costs.total).toBeGreaterThan(0);
+      expect(costs.byProvider.openai).toBeDefined();
+    });
+
+    it('handles missing pricing', () => {
+      const requests = [{ provider: 'unknown', inputTokens: 1000 }];
+      const costs = calculateCosts(requests, {});
+      expect(costs.byProvider.unknown).toBe(0);
+    });
+  });
+
+  describe('filterByTimeRange', () => {
+    it('filters by date range', () => {
+      const now = Date.now();
+      const requests = [
+        { timestamp: now - 1000 },
+        { timestamp: now - 100000 },
+        { timestamp: now - 1000000 }
+      ];
+      const filtered = filterByTimeRange(requests, { start: now - 50000 });
+      expect(filtered.length).toBe(1);
+    });
+
+    it('supports end date', () => {
+      const now = Date.now();
+      const requests = [
+        { timestamp: now - 1000 },
+        { timestamp: now - 5000 }
+      ];
+      const filtered = filterByTimeRange(requests, {
+        start: now - 10000,
+        end: now - 3000
+      });
+      expect(filtered.length).toBe(1);
+    });
+  });
+
+  describe('createRouterApi', () => {
+    it('creates API handler', () => {
+      const api = createRouterApi({});
+      expect(api.getStatus).toBeDefined();
+      expect(api.getStats).toBeDefined();
+      expect(api.getCosts).toBeDefined();
+    });
+  });
+});