tlc-claude-code 1.4.9 → 1.5.2

package/server/lib/agents-list-command.js

@@ -0,0 +1,150 @@
+/**
+ * Agents List Command
+ * Lists all agents with filtering capabilities
+ */
+
+/**
+ * Parse time string to milliseconds
+ * @param {string} timeStr - Time string like '1h', '30m', '2d'
+ * @returns {number} Milliseconds
+ */
+function parseTime(timeStr) {
+  const match = timeStr.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) return 0;
+
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+
+  switch (unit) {
+    case 's': return value * 1000;
+    case 'm': return value * 60 * 1000;
+    case 'h': return value * 60 * 60 * 1000;
+    case 'd': return value * 24 * 60 * 60 * 1000;
+    default: return 0;
+  }
+}
+
+/**
+ * Filter agents by criteria
+ * @param {Array} agents - Agents to filter
+ * @param {object} options - Filter options
+ * @returns {Array} Filtered agents
+ */
+function filterAgents(agents, options = {}) {
+  let result = [...agents];
+
+  if (options.status) {
+    result = result.filter(a => a.status === options.status);
+  }
+
+  if (options.model) {
+    result = result.filter(a => a.model.toLowerCase().includes(options.model.toLowerCase()));
+  }
+
+  if (options.since) {
+    const sinceMs = parseTime(options.since);
+    const cutoff = Date.now() - sinceMs;
+    result = result.filter(a => new Date(a.startTime).getTime() >= cutoff);
+  }
+
+  return result;
+}
+
+/**
+ * Truncate string to max length
+ * @param {string} str - String to truncate
+ * @param {number} maxLen - Maximum length
+ * @returns {string} Truncated string
+ */
+function truncate(str, maxLen) {
+  if (!str) return '';
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 3) + '...';
+}
+
+/**
+ * Format agents as table
+ * @param {Array} agents - Agents to format
+ * @param {object} options - Format options
+ * @returns {string} Formatted table
+ */
+function formatTable(agents, options = {}) {
+  if (!agents || agents.length === 0) {
+    return 'No agents found';
+  }
+
+  const maxWidth = options.maxWidth || 120;
+
+  // Calculate column widths
+  const colWidths = {
+    id: Math.min(15, maxWidth / 5),
+    name: Math.min(20, maxWidth / 4),
+    model: Math.min(12, maxWidth / 6),
+    status: 10,
+    cost: 10,
+  };
+
+  // Header
+  const header = [
+    'ID'.padEnd(colWidths.id),
+    'Name'.padEnd(colWidths.name),
+    'Model'.padEnd(colWidths.model),
+    'Status'.padEnd(colWidths.status),
+    'Cost'.padEnd(colWidths.cost),
+  ].join(' | ');
+
+  const separator = '-'.repeat(header.length);
+
+  // Rows
+  const rows = agents.map(agent => [
+    truncate(agent.id, colWidths.id).padEnd(colWidths.id),
+    truncate(agent.name || '-', colWidths.name).padEnd(colWidths.name),
+    truncate(agent.model, colWidths.model).padEnd(colWidths.model),
+    agent.status.padEnd(colWidths.status),
+    `$${(agent.cost || 0).toFixed(4)}`.padEnd(colWidths.cost),
+  ].join(' | '));
+
+  return [header, separator, ...rows].join('\n');
+}
+
+/**
+ * Format agents as JSON
+ * @param {Array} agents - Agents to format
+ * @returns {string} JSON string
+ */
+function formatJSON(agents) {
+  return JSON.stringify(agents, null, 2);
+}
+
+/**
+ * Execute agents list command
+ * @param {object} context - Execution context
+ * @returns {Promise<object>} Command result
+ */
+async function execute(context) {
+  const { registry, options = {} } = context;
+
+  const allAgents = registry.listAgents();
+  const filtered = filterAgents(allAgents, options);
+
+  let output;
+  if (options.json) {
+    output = formatJSON(filtered);
+  } else {
+    output = formatTable(filtered, { maxWidth: options.width });
+  }
+
+  return {
+    success: true,
+    count: filtered.length,
+    output,
+  };
+}
+
+module.exports = {
+  execute,
+  filterAgents,
+  formatTable,
+  formatJSON,
+  parseTime,
+};

package/server/lib/agents-list-command.test.js

@@ -0,0 +1,149 @@
+const { describe, it, beforeEach, mock } = require('node:test');
+const assert = require('node:assert');
+const {
+  execute,
+  filterAgents,
+  formatTable,
+  formatJSON,
+} = require('./agents-list-command.js');
+
+describe('agents-list-command', () => {
+  describe('execute', () => {
+    const mockAgents = [
+      { id: 'agent-1', name: 'Builder', model: 'claude', status: 'running', startTime: new Date(), cost: 0.05 },
+      { id: 'agent-2', name: 'Reviewer', model: 'gpt-4', status: 'completed', startTime: new Date(Date.now() - 3600000), cost: 0.10 },
+      { id: 'agent-3', name: 'Tester', model: 'claude', status: 'failed', startTime: new Date(Date.now() - 7200000), cost: 0.02 },
+    ];
+
+    it('lists all agents', async () => {
+      const result = await execute({ registry: { listAgents: () => mockAgents } });
+      assert.ok(result.output);
+      assert.ok(result.output.includes('agent-1'));
+      assert.ok(result.output.includes('agent-2'));
+      assert.ok(result.output.includes('agent-3'));
+    });
+
+    it('filters by status', async () => {
+      const result = await execute({
+        registry: { listAgents: () => mockAgents },
+        options: { status: 'running' },
+      });
+      assert.ok(result.output.includes('agent-1'));
+      assert.ok(!result.output.includes('agent-2'));
+    });
+
+    it('filters by model', async () => {
+      const result = await execute({
+        registry: { listAgents: () => mockAgents },
+        options: { model: 'claude' },
+      });
+      assert.ok(result.output.includes('agent-1'));
+      assert.ok(result.output.includes('agent-3'));
+      assert.ok(!result.output.includes('Reviewer'));
+    });
+
+    it('filters by time', async () => {
+      const result = await execute({
+        registry: { listAgents: () => mockAgents },
+        options: { since: '30m' },
+      });
+      assert.ok(result.output.includes('agent-1'));
+      assert.ok(!result.output.includes('agent-3'));
+    });
+
+    it('handles empty list', async () => {
+      const result = await execute({ registry: { listAgents: () => [] } });
+      assert.ok(result.output.includes('No agents found'));
+    });
+
+    it('shows helpful headers', async () => {
+      const result = await execute({ registry: { listAgents: () => mockAgents } });
+      assert.ok(result.output.includes('ID'));
+      assert.ok(result.output.includes('Status'));
+      assert.ok(result.output.includes('Model'));
+    });
+  });
+
+  describe('filterAgents', () => {
+    const agents = [
+      { id: '1', status: 'running', model: 'claude', startTime: new Date() },
+      { id: '2', status: 'completed', model: 'gpt-4', startTime: new Date(Date.now() - 3600000) },
+    ];
+
+    it('filters by status', () => {
+      const result = filterAgents(agents, { status: 'running' });
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].id, '1');
+    });
+
+    it('filters by model', () => {
+      const result = filterAgents(agents, { model: 'gpt-4' });
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].id, '2');
+    });
+
+    it('filters by time since', () => {
+      const result = filterAgents(agents, { since: '30m' });
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].id, '1');
+    });
+
+    it('returns all when no filters', () => {
+      const result = filterAgents(agents, {});
+      assert.strictEqual(result.length, 2);
+    });
+  });
+
+  describe('formatTable', () => {
+    const agents = [
+      { id: 'agent-1', name: 'Builder', model: 'claude', status: 'running', cost: 0.05 },
+      { id: 'agent-2', name: 'Very Long Agent Name That Exceeds Normal Width', model: 'gpt-4', status: 'completed', cost: 0.10 },
+    ];
+
+    it('creates readable output', () => {
+      const result = formatTable(agents);
+      assert.ok(result.includes('agent-1'));
+      assert.ok(result.includes('running'));
+    });
+
+    it('truncates long values', () => {
+      const result = formatTable(agents, { maxWidth: 80 });
+      assert.ok(!result.includes('Very Long Agent Name That Exceeds Normal Width'));
+      assert.ok(result.includes('...') || result.includes('Very Long'));
+    });
+
+    it('respects terminal width', () => {
+      const result = formatTable(agents, { maxWidth: 60 });
+      const lines = result.split('\n');
+      const maxLine = Math.max(...lines.map(l => l.length));
+      assert.ok(maxLine <= 80); // Some buffer for formatting
+    });
+
+    it('handles empty list', () => {
+      const result = formatTable([]);
+      assert.ok(result.includes('No agents'));
+    });
+  });
+
+  describe('formatJSON', () => {
+    const agents = [
+      { id: 'agent-1', name: 'Builder', model: 'claude', status: 'running' },
+    ];
+
+    it('creates valid JSON', () => {
+      const result = formatJSON(agents);
+      const parsed = JSON.parse(result);
+      assert.ok(Array.isArray(parsed));
+      assert.strictEqual(parsed[0].id, 'agent-1');
+    });
+
+    it('includes all fields', () => {
+      const result = formatJSON(agents);
+      const parsed = JSON.parse(result);
+      assert.ok('id' in parsed[0]);
+      assert.ok('name' in parsed[0]);
+      assert.ok('model' in parsed[0]);
+      assert.ok('status' in parsed[0]);
+    });
+  });
+});

package/server/lib/agents-logs-command.js

@@ -0,0 +1,126 @@
+/**
+ * Agents Logs Command
+ * View agent output and logs
+ */
+
+/**
+ * Format a single log line
+ * @param {object} entry - Log entry
+ * @param {object} options - Format options
+ * @returns {string} Formatted line
+ */
+function formatLogLine(entry, options = {}) {
+  const parts = [];
+
+  if (options.timestamps) {
+    const time = new Date(entry.timestamp).toLocaleTimeString();
+    parts.push(`[${time}]`);
+  }
+
+  if (entry.stream === 'stderr') {
+    parts.push('[ERR]');
+  }
+
+  parts.push(entry.message);
+
+  return parts.join(' ');
+}
+
+/**
+ * Format all logs
+ * @param {Array} logs - Log entries
+ * @param {object} options - Format options
+ * @returns {string} Formatted output
+ */
+function formatLogs(logs, options = {}) {
+  if (!logs || logs.length === 0) {
+    return 'No logs available';
+  }
+
+  return logs.map(entry => formatLogLine(entry, options)).join('\n');
+}
+
+/**
+ * Get last n log entries
+ * @param {Array} logs - All logs
+ * @param {number} n - Number of entries
+ * @returns {Array} Last n entries
+ */
+function tailLogs(logs, n) {
+  if (!logs || logs.length === 0) return [];
+  if (logs.length <= n) return logs;
+  return logs.slice(-n);
+}
+
+/**
+ * Setup streaming for live logs
+ * @param {object} agent - Agent to stream
+ * @returns {object} Streaming info
+ */
+function streamLogs(agent) {
+  return {
+    streaming: true,
+    agentId: agent.id,
+    status: agent.status,
+    currentLogs: agent.logs || [],
+  };
+}
+
+/**
+ * Execute agents logs command
+ * @param {object} context - Execution context
+ * @returns {Promise<object>} Command result
+ */
+async function execute(context) {
+  const { registry, agentId, options = {} } = context;
+
+  const agent = registry.getAgent(agentId);
+
+  if (!agent) {
+    return {
+      success: false,
+      error: `Agent not found: ${agentId}`,
+    };
+  }
+
+  // Handle streaming mode
+  if (options.follow && agent.status === 'running') {
+    return {
+      success: true,
+      ...streamLogs(agent),
+      output: formatLogs(agent.logs || [], options),
+    };
+  }
+
+  // Get logs
+  let logs = agent.logs || [];
+
+  // Apply tail
+  if (options.tail) {
+    logs = tailLogs(logs, options.tail);
+  }
+
+  // Format output
+  const output = formatLogs(logs, {
+    timestamps: options.timestamps !== false,
+    color: options.color,
+  });
+
+  return {
+    success: true,
+    agent: {
+      id: agent.id,
+      status: agent.status,
+    },
+    logCount: logs.length,
+    output,
+  };
+}
+
+module.exports = {
+  execute,
+  formatLogLine,
+  formatLogs,
+  streamLogs,
+  tailLogs,
+};

package/server/lib/agents-logs-command.test.js

@@ -0,0 +1,198 @@
+const { describe, it, beforeEach, mock } = require('node:test');
+const assert = require('node:assert');
+const {
+  execute,
+  formatLogLine,
+  formatLogs,
+  streamLogs,
+  tailLogs,
+} = require('./agents-logs-command.js');
+
+describe('agents-logs-command', () => {
+  const agentWithLogs = {
+    id: 'agent-1',
+    status: 'completed',
+    logs: [
+      { timestamp: new Date('2024-01-01T10:00:00'), stream: 'stdout', message: 'Starting task...' },
+      { timestamp: new Date('2024-01-01T10:00:01'), stream: 'stdout', message: 'Processing...' },
+      { timestamp: new Date('2024-01-01T10:00:02'), stream: 'stderr', message: 'Warning: rate limit' },
+      { timestamp: new Date('2024-01-01T10:00:03'), stream: 'stdout', message: 'Complete!' },
+    ],
+  };
+
+  describe('execute', () => {
+    const createMockRegistry = (agents = []) => ({
+      getAgent: (id) => agents.find(a => a.id === id),
+    });
+
+    it('shows agent output', async () => {
+      const result = await execute({
+        registry: createMockRegistry([agentWithLogs]),
+        agentId: 'agent-1',
+      });
+      assert.ok(result.success);
+      assert.ok(result.output.includes('Starting'));
+      assert.ok(result.output.includes('Complete'));
+    });
+
+    it('with --follow streams', async () => {
+      const result = await execute({
+        registry: createMockRegistry([{ ...agentWithLogs, status: 'running' }]),
+        agentId: 'agent-1',
+        options: { follow: true },
+      });
+      assert.ok(result.streaming || result.output);
+    });
+
+    it('with --tail limits lines', async () => {
+      const result = await execute({
+        registry: createMockRegistry([agentWithLogs]),
+        agentId: 'agent-1',
+        options: { tail: 2 },
+      });
+      const lines = result.output.split('\n').filter(l => l.trim());
+      assert.ok(lines.length <= 2);
+    });
+
+    it('shows stdout content', async () => {
+      const result = await execute({
+        registry: createMockRegistry([agentWithLogs]),
+        agentId: 'agent-1',
+      });
+      assert.ok(result.output.includes('Starting task'));
+    });
+
+    it('shows stderr content', async () => {
+      const result = await execute({
+        registry: createMockRegistry([agentWithLogs]),
+        agentId: 'agent-1',
+      });
+      assert.ok(result.output.includes('Warning'));
+    });
+
+    it('timestamps are prefixed', async () => {
+      const result = await execute({
+        registry: createMockRegistry([agentWithLogs]),
+        agentId: 'agent-1',
+        options: { timestamps: true },
+      });
+      assert.ok(result.output.includes('10:00') || result.output.includes(':'));
+    });
+
+    it('errors are colored red', async () => {
+      const result = await execute({
+        registry: createMockRegistry([agentWithLogs]),
+        agentId: 'agent-1',
+        options: { color: true },
+      });
+      // Check for ANSI red code or stderr marker
+      assert.ok(result.output.includes('stderr') || result.output.includes('\x1b[31m') || result.output.includes('Warning'));
+    });
+
+    it('handles completed agent', async () => {
+      const result = await execute({
+        registry: createMockRegistry([agentWithLogs]),
+        agentId: 'agent-1',
+      });
+      assert.ok(result.success);
+    });
+
+    it('handles no output yet', async () => {
+      const result = await execute({
+        registry: createMockRegistry([{ id: 'agent-1', status: 'running', logs: [] }]),
+        agentId: 'agent-1',
+      });
+      assert.ok(result.output.includes('No logs') || result.output === '');
+    });
+
+    it('handles unknown agent ID', async () => {
+      const result = await execute({
+        registry: createMockRegistry([]),
+        agentId: 'unknown',
+      });
+      assert.strictEqual(result.success, false);
+      assert.ok(result.error.includes('not found'));
+    });
+  });
+
+  describe('formatLogLine', () => {
+    it('formats with timestamp', () => {
+      const line = formatLogLine({
+        timestamp: new Date('2024-01-01T10:00:00'),
+        stream: 'stdout',
+        message: 'Test',
+      }, { timestamps: true });
+      assert.ok(line.includes('10:00'));
+      assert.ok(line.includes('Test'));
+    });
+
+    it('formats without timestamp', () => {
+      const line = formatLogLine({
+        timestamp: new Date(),
+        stream: 'stdout',
+        message: 'Test',
+      }, { timestamps: false });
+      assert.strictEqual(line, 'Test');
+    });
+
+    it('marks stderr', () => {
+      const line = formatLogLine({
+        timestamp: new Date(),
+        stream: 'stderr',
+        message: 'Error',
+      }, { timestamps: true });
+      assert.ok(line.includes('stderr') || line.includes('[ERR]'));
+    });
+  });
+
+  describe('formatLogs', () => {
+    it('formats all log lines', () => {
+      const logs = [
+        { timestamp: new Date(), stream: 'stdout', message: 'Line 1' },
+        { timestamp: new Date(), stream: 'stdout', message: 'Line 2' },
+      ];
+      const result = formatLogs(logs, {});
+      assert.ok(result.includes('Line 1'));
+      assert.ok(result.includes('Line 2'));
+    });
+
+    it('returns empty message for no logs', () => {
+      const result = formatLogs([], {});
+      assert.ok(result.includes('No logs') || result === '');
+    });
+  });
+
+  describe('tailLogs', () => {
+    const logs = [
+      { message: 'Line 1' },
+      { message: 'Line 2' },
+      { message: 'Line 3' },
+      { message: 'Line 4' },
+    ];
+
+    it('returns last n entries', () => {
+      const result = tailLogs(logs, 2);
+      assert.strictEqual(result.length, 2);
+      assert.strictEqual(result[0].message, 'Line 3');
+      assert.strictEqual(result[1].message, 'Line 4');
+    });
+
+    it('returns all if fewer than n', () => {
+      const result = tailLogs(logs, 10);
+      assert.strictEqual(result.length, 4);
+    });
+  });
+
+  describe('streamLogs', () => {
+    it('returns stream info', () => {
+      const result = streamLogs({ id: 'agent-1', status: 'running' });
+      assert.ok(result.streaming);
+      assert.ok(result.agentId);
+    });
+
+    it('includes current logs', () => {
+      const result = streamLogs({ id: 'agent-1', status: 'running', logs: [{ message: 'test' }] });
+      assert.ok(result.currentLogs);
+    });
+  });
+});