tlc-claude-code 1.4.9 → 1.5.2

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

@@ -0,0 +1,139 @@
+/**
+ * Agents Cancel Command
+ * Cancel running agents
+ */
+
+/**
+ * Check if confirmation is required
+ * @param {object} options - Command options
+ * @returns {boolean} True if confirmation needed
+ */
+function requiresConfirmation(options) {
+  return !options.force;
+}
+
+/**
+ * Cancel a single agent
+ * @param {object} agent - Agent to cancel
+ * @param {Function} updateAgent - Function to update agent
+ * @returns {object} Cancelled agent
+ */
+function cancelAgent(agent, updateAgent) {
+  return updateAgent(agent.id, {
+    status: 'cancelled',
+    endTime: new Date(),
+  });
+}
+
+/**
+ * Cancel all running agents
+ * @param {Array} agents - All agents
+ * @param {Function} updateAgent - Function to update agent
+ * @returns {number} Count of cancelled agents
+ */
+function cancelAllRunning(agents, updateAgent) {
+  const running = agents.filter(a => a.status === 'running' || a.status === 'queued');
+  for (const agent of running) {
+    cancelAgent(agent, updateAgent);
+  }
+  return running.length;
+}
+
+/**
+ * Check if agent can be cancelled
+ * @param {object} agent - Agent to check
+ * @returns {object} Result with canCancel and reason
+ */
+function canCancel(agent) {
+  if (!agent) {
+    return { canCancel: false, reason: 'Agent not found' };
+  }
+
+  if (agent.status === 'cancelled') {
+    return { canCancel: false, reason: 'Agent is already cancelled' };
+  }
+
+  if (agent.status === 'completed') {
+    return { canCancel: false, reason: 'Agent is already completed' };
+  }
+
+  if (agent.status === 'failed') {
+    return { canCancel: false, reason: 'Agent has already failed' };
+  }
+
+  return { canCancel: true };
+}
+
+/**
+ * Execute agents cancel command
+ * @param {object} context - Execution context
+ * @returns {Promise<object>} Command result
+ */
+async function execute(context) {
+  const { registry, agentId, options = {}, onCleanup } = context;
+
+  // Handle --all flag
+  if (options.all) {
+    if (requiresConfirmation(options)) {
+      const running = registry.listAgents().filter(a =>
+        a.status === 'running' || a.status === 'queued'
+      );
+      return {
+        success: false,
+        needsConfirmation: true,
+        message: `Cancel ${running.length} running agents?`,
+        count: running.length,
+      };
+    }
+
+    const agents = registry.listAgents();
+    const count = cancelAllRunning(agents, registry.updateAgent.bind(registry));
+
+    if (onCleanup) onCleanup();
+
+    return {
+      success: true,
+      cancelled: count,
+      message: `Cancelled ${count} agents`,
+    };
+  }
+
+  // Single agent cancel
+  const agent = registry.getAgent(agentId);
+  const { canCancel: allowed, reason } = canCancel(agent);
+
+  if (!allowed) {
+    return {
+      success: false,
+      error: reason,
+    };
+  }
+
+  if (requiresConfirmation(options)) {
+    return {
+      success: false,
+      needsConfirmation: true,
+      message: `Cancel agent ${agentId}?`,
+      agent,
+    };
+  }
+
+  cancelAgent(agent, registry.updateAgent.bind(registry));
+
+  if (onCleanup) onCleanup();
+
+  return {
+    success: true,
+    cancelled: 1,
+    message: `Cancelled agent ${agentId}`,
+    agent,
+  };
+}
+
+module.exports = {
+  execute,
+  cancelAgent,
+  cancelAllRunning,
+  requiresConfirmation,
+  canCancel,
+};

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

@@ -0,0 +1,180 @@
+const { describe, it, beforeEach, mock } = require('node:test');
+const assert = require('node:assert');
+const {
+  execute,
+  cancelAgent,
+  cancelAllRunning,
+  requiresConfirmation,
+} = require('./agents-cancel-command.js');
+
+describe('agents-cancel-command', () => {
+  describe('execute', () => {
+    const createMockRegistry = (agents = []) => ({
+      getAgent: (id) => agents.find(a => a.id === id),
+      listAgents: () => agents,
+      updateAgent: (id, updates) => {
+        const agent = agents.find(a => a.id === id);
+        if (agent) Object.assign(agent, updates);
+        return agent;
+      },
+    });
+
+    it('cancels agent', async () => {
+      const agents = [
+        { id: 'agent-1', status: 'running' },
+      ];
+      const result = await execute({
+        registry: createMockRegistry(agents),
+        agentId: 'agent-1',
+        options: { force: true },
+      });
+      assert.ok(result.success);
+      assert.strictEqual(agents[0].status, 'cancelled');
+    });
+
+    it('shows confirmation prompt', async () => {
+      const agents = [{ id: 'agent-1', status: 'running' }];
+      const result = await execute({
+        registry: createMockRegistry(agents),
+        agentId: 'agent-1',
+        options: {},
+      });
+      assert.ok(result.needsConfirmation);
+    });
+
+    it('with --force skips prompt', async () => {
+      const agents = [{ id: 'agent-1', status: 'running' }];
+      const result = await execute({
+        registry: createMockRegistry(agents),
+        agentId: 'agent-1',
+        options: { force: true },
+      });
+      assert.ok(result.success);
+      assert.ok(!result.needsConfirmation);
+    });
+
+    it('--all cancels all running', async () => {
+      const agents = [
+        { id: 'agent-1', status: 'running' },
+        { id: 'agent-2', status: 'running' },
+        { id: 'agent-3', status: 'completed' },
+      ];
+      const result = await execute({
+        registry: createMockRegistry(agents),
+        options: { all: true, force: true },
+      });
+      assert.ok(result.success);
+      assert.strictEqual(result.cancelled, 2);
+    });
+
+    it('handles unknown agent ID', async () => {
+      const result = await execute({
+        registry: createMockRegistry([]),
+        agentId: 'unknown',
+        options: { force: true },
+      });
+      assert.strictEqual(result.success, false);
+      assert.ok(result.error.includes('not found'));
+    });
+
+    it('handles already cancelled', async () => {
+      const agents = [{ id: 'agent-1', status: 'cancelled' }];
+      const result = await execute({
+        registry: createMockRegistry(agents),
+        agentId: 'agent-1',
+        options: { force: true },
+      });
+      assert.strictEqual(result.success, false);
+      assert.ok(result.error.includes('already'));
+    });
+
+    it('handles already completed', async () => {
+      const agents = [{ id: 'agent-1', status: 'completed' }];
+      const result = await execute({
+        registry: createMockRegistry(agents),
+        agentId: 'agent-1',
+        options: { force: true },
+      });
+      assert.strictEqual(result.success, false);
+      assert.ok(result.error.includes('already') || result.error.includes('completed'));
+    });
+
+    it('shows result message', async () => {
+      const agents = [{ id: 'agent-1', status: 'running' }];
+      const result = await execute({
+        registry: createMockRegistry(agents),
+        agentId: 'agent-1',
+        options: { force: true },
+      });
+      assert.ok(result.message);
+      assert.ok(result.message.includes('cancelled') || result.message.includes('Cancelled'));
+    });
+
+    it('updates agent state', async () => {
+      const agents = [{ id: 'agent-1', status: 'running' }];
+      await execute({
+        registry: createMockRegistry(agents),
+        agentId: 'agent-1',
+        options: { force: true },
+      });
+      assert.strictEqual(agents[0].status, 'cancelled');
+    });
+
+    it('triggers cleanup', async () => {
+      let cleanupCalled = false;
+      const agents = [{ id: 'agent-1', status: 'running' }];
+      await execute({
+        registry: createMockRegistry(agents),
+        agentId: 'agent-1',
+        options: { force: true },
+        onCleanup: () => { cleanupCalled = true; },
+      });
+      assert.ok(cleanupCalled);
+    });
+  });
+
+  describe('cancelAgent', () => {
+    it('sets status to cancelled', () => {
+      const agent = { id: 'agent-1', status: 'running' };
+      const updateAgent = (id, updates) => Object.assign(agent, updates);
+      cancelAgent(agent, updateAgent);
+      assert.strictEqual(agent.status, 'cancelled');
+    });
+
+    it('sets end time', () => {
+      const agent = { id: 'agent-1', status: 'running' };
+      const updateAgent = (id, updates) => Object.assign(agent, updates);
+      cancelAgent(agent, updateAgent);
+      assert.ok(agent.endTime);
+    });
+  });
+
+  describe('cancelAllRunning', () => {
+    it('cancels only running agents', () => {
+      const agents = [
+        { id: '1', status: 'running' },
+        { id: '2', status: 'completed' },
+        { id: '3', status: 'running' },
+      ];
+      const updateAgent = (id, updates) => {
+        const agent = agents.find(a => a.id === id);
+        Object.assign(agent, updates);
+      };
+      const count = cancelAllRunning(agents, updateAgent);
+      assert.strictEqual(count, 2);
+      assert.strictEqual(agents[0].status, 'cancelled');
+      assert.strictEqual(agents[1].status, 'completed');
+      assert.strictEqual(agents[2].status, 'cancelled');
+    });
+  });
+
+  describe('requiresConfirmation', () => {
+    it('returns true without force', () => {
+      assert.strictEqual(requiresConfirmation({}), true);
+    });
+
+    it('returns false with force', () => {
+      assert.strictEqual(requiresConfirmation({ force: true }), false);
+    });
+  });
+});

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

@@ -0,0 +1,159 @@
+/**
+ * Agents Get Command
+ * Show detailed agent information
+ */
+
+/**
+ * Format timestamp
+ * @param {Date} date - Date to format
+ * @returns {string} Formatted timestamp
+ */
+function formatTimestamp(date) {
+  if (!date) return '-';
+  return new Date(date).toLocaleString();
+}
+
+/**
+ * Format state history
+ * @param {Array} history - State history entries
+ * @returns {string} Formatted history
+ */
+function formatStateHistory(history) {
+  if (!history || history.length === 0) {
+    return 'No state history';
+  }
+
+  return history.map(entry =>
+    `  ${formatTimestamp(entry.timestamp)} → ${entry.state}`
+  ).join('\n');
+}
+
+/**
+ * Format token breakdown
+ * @param {object} tokens - Token counts
+ * @returns {string} Formatted breakdown
+ */
+function formatTokenBreakdown(tokens) {
+  if (!tokens) return 'No token data';
+
+  const input = tokens.input || 0;
+  const output = tokens.output || 0;
+  const total = input + output;
+
+  return [
+    `  Input:  ${input.toLocaleString()}`,
+    `  Output: ${output.toLocaleString()}`,
+    `  Total:  ${total.toLocaleString()}`,
+  ].join('\n');
+}
+
+/**
+ * Format cost breakdown
+ * @param {number} cost - Total cost
+ * @returns {string} Formatted cost
+ */
+function formatCostBreakdown(cost) {
+  if (cost === undefined || cost === null) return 'No cost data';
+  return `  Total: $${cost.toFixed(4)}`;
+}
+
+/**
+ * Format quality scores
+ * @param {object} quality - Quality data
+ * @returns {string} Formatted quality
+ */
+function formatQualityScores(quality) {
+  if (!quality) return 'No quality data';
+
+  const lines = [`  Score: ${quality.score}%`];
+
+  if (quality.dimensions) {
+    for (const [dim, score] of Object.entries(quality.dimensions)) {
+      lines.push(`    ${dim}: ${score}%`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format full agent details
+ * @param {object} agent - Agent to format
+ * @returns {string} Formatted details
+ */
+function formatDetails(agent) {
+  const sections = [];
+
+  // Header
+  sections.push(`Agent: ${agent.id}`);
+  sections.push('='.repeat(50));
+
+  // Metadata
+  sections.push('\n📋 Metadata');
+  sections.push(`  ID:     ${agent.id}`);
+  sections.push(`  Name:   ${agent.name || '-'}`);
+  sections.push(`  Model:  ${agent.model}`);
+  sections.push(`  Status: ${agent.status}`);
+  sections.push(`  Start:  ${formatTimestamp(agent.startTime)}`);
+  if (agent.endTime) {
+    sections.push(`  End:    ${formatTimestamp(agent.endTime)}`);
+  }
+
+  // State History
+  sections.push('\n📜 State History');
+  sections.push(formatStateHistory(agent.stateHistory));
+
+  // Tokens
+  sections.push('\n🔢 Tokens');
+  sections.push(formatTokenBreakdown(agent.tokens));
+
+  // Cost
+  sections.push('\n💰 Cost');
+  sections.push(formatCostBreakdown(agent.cost));
+
+  // Quality
+  sections.push('\n📊 Quality');
+  sections.push(formatQualityScores(agent.quality));
+
+  return sections.join('\n');
+}
+
+/**
+ * Execute agents get 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}`,
+    };
+  }
+
+  let output;
+  if (options.json) {
+    output = JSON.stringify(agent, null, 2);
+  } else {
+    output = formatDetails(agent);
+  }
+
+  return {
+    success: true,
+    agent,
+    output,
+  };
+}
+
+module.exports = {
+  execute,
+  formatDetails,
+  formatStateHistory,
+  formatTokenBreakdown,
+  formatCostBreakdown,
+  formatQualityScores,
+};

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

@@ -0,0 +1,167 @@
+const { describe, it, beforeEach, mock } = require('node:test');
+const assert = require('node:assert');
+const {
+  execute,
+  formatDetails,
+  formatStateHistory,
+  formatTokenBreakdown,
+  formatCostBreakdown,
+  formatQualityScores,
+} = require('./agents-get-command.js');
+
+describe('agents-get-command', () => {
+  const mockAgent = {
+    id: 'agent-123',
+    name: 'Code Builder',
+    model: 'claude-3-opus',
+    status: 'completed',
+    startTime: new Date(Date.now() - 120000),
+    endTime: new Date(),
+    tokens: { input: 5000, output: 2500 },
+    cost: 0.25,
+    quality: { score: 85, dimensions: { correctness: 90, completeness: 80 } },
+    stateHistory: [
+      { state: 'queued', timestamp: new Date(Date.now() - 180000) },
+      { state: 'running', timestamp: new Date(Date.now() - 120000) },
+      { state: 'completed', timestamp: new Date() },
+    ],
+  };
+
+  describe('execute', () => {
+    it('shows agent details', async () => {
+      const result = await execute({
+        registry: { getAgent: () => mockAgent },
+        agentId: 'agent-123',
+      });
+      assert.ok(result.output);
+      assert.ok(result.output.includes('agent-123'));
+    });
+
+    it('shows metadata section', async () => {
+      const result = await execute({
+        registry: { getAgent: () => mockAgent },
+        agentId: 'agent-123',
+      });
+      assert.ok(result.output.includes('claude-3-opus'));
+      assert.ok(result.output.includes('completed'));
+    });
+
+    it('shows state history', async () => {
+      const result = await execute({
+        registry: { getAgent: () => mockAgent },
+        agentId: 'agent-123',
+      });
+      assert.ok(result.output.includes('queued') || result.output.includes('running'));
+    });
+
+    it('shows token breakdown', async () => {
+      const result = await execute({
+        registry: { getAgent: () => mockAgent },
+        agentId: 'agent-123',
+      });
+      assert.ok(result.output.includes('5000') || result.output.includes('5,000') || result.output.includes('Input'));
+    });
+
+    it('shows cost breakdown', async () => {
+      const result = await execute({
+        registry: { getAgent: () => mockAgent },
+        agentId: 'agent-123',
+      });
+      assert.ok(result.output.includes('0.25') || result.output.includes('$'));
+    });
+
+    it('shows quality scores', async () => {
+      const result = await execute({
+        registry: { getAgent: () => mockAgent },
+        agentId: 'agent-123',
+      });
+      assert.ok(result.output.includes('85') || result.output.includes('Quality'));
+    });
+
+    it('handles unknown agent ID', async () => {
+      const result = await execute({
+        registry: { getAgent: () => null },
+        agentId: 'unknown',
+      });
+      assert.strictEqual(result.success, false);
+      assert.ok(result.error.includes('not found') || result.error.includes('Unknown'));
+    });
+
+    it('includes timestamps', async () => {
+      const result = await execute({
+        registry: { getAgent: () => mockAgent },
+        agentId: 'agent-123',
+      });
+      assert.ok(result.output.includes(':') || result.output.includes('Time'));
+    });
+
+    it('JSON output option works', async () => {
+      const result = await execute({
+        registry: { getAgent: () => mockAgent },
+        agentId: 'agent-123',
+        options: { json: true },
+      });
+      const parsed = JSON.parse(result.output);
+      assert.strictEqual(parsed.id, 'agent-123');
+    });
+  });
+
+  describe('formatDetails', () => {
+    it('creates sections', () => {
+      const result = formatDetails(mockAgent);
+      assert.ok(result.includes('Agent:') || result.includes('ID:'));
+      assert.ok(result.includes('Model:') || result.includes('claude'));
+    });
+  });
+
+  describe('formatStateHistory', () => {
+    it('shows state transitions', () => {
+      const result = formatStateHistory(mockAgent.stateHistory);
+      assert.ok(result.includes('queued'));
+      assert.ok(result.includes('running'));
+      assert.ok(result.includes('completed'));
+    });
+
+    it('handles empty history', () => {
+      const result = formatStateHistory([]);
+      assert.ok(result.includes('No') || result === '');
+    });
+  });
+
+  describe('formatTokenBreakdown', () => {
+    it('shows input and output', () => {
+      const result = formatTokenBreakdown({ input: 5000, output: 2500 });
+      assert.ok(result.includes('5000') || result.includes('5,000'));
+      assert.ok(result.includes('2500') || result.includes('2,500'));
+    });
+
+    it('shows total', () => {
+      const result = formatTokenBreakdown({ input: 5000, output: 2500 });
+      assert.ok(result.includes('7500') || result.includes('7,500') || result.includes('Total'));
+    });
+  });
+
+  describe('formatCostBreakdown', () => {
+    it('shows cost', () => {
+      const result = formatCostBreakdown(0.25);
+      assert.ok(result.includes('0.25') || result.includes('$'));
+    });
+  });
+
+  describe('formatQualityScores', () => {
+    it('shows main score', () => {
+      const result = formatQualityScores({ score: 85, dimensions: {} });
+      assert.ok(result.includes('85'));
+    });
+
+    it('shows dimensions', () => {
+      const result = formatQualityScores({ score: 85, dimensions: { correctness: 90 } });
+      assert.ok(result.includes('90') || result.includes('correctness'));
+    });
+
+    it('handles no quality data', () => {
+      const result = formatQualityScores(null);
+      assert.ok(result.includes('No') || result === '');
+    });
+  });
+});