tlc-claude-code 1.4.9 → 1.5.2

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

@@ -0,0 +1,117 @@
+/**
+ * Agents Retry Command
+ * Retry failed agents
+ */
+
+/**
+ * Check if agent can be retried
+ * @param {object} agent - Agent to check
+ * @returns {object} Result with canRetry and reason
+ */
+function canRetry(agent) {
+  if (!agent) {
+    return { canRetry: false, reason: 'Agent not found' };
+  }
+
+  if (agent.status === 'failed' || agent.status === 'cancelled') {
+    return { canRetry: true };
+  }
+
+  return {
+    canRetry: false,
+    reason: `Cannot retry agent with status '${agent.status}'. Only failed or cancelled agents can be retried.`,
+  };
+}
+
+/**
+ * Get retry context from failed agent
+ * @param {object} agent - Failed agent
+ * @returns {string} Context string
+ */
+function getRetryContext(agent) {
+  const parts = [];
+
+  if (agent.error?.message) {
+    parts.push(`Previous error: ${agent.error.message}`);
+  }
+
+  if (agent.retryCount) {
+    parts.push(`Previous retries: ${agent.retryCount}`);
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Create retry agent from failed agent
+ * @param {object} parent - Parent agent that failed
+ * @param {object} options - Retry options
+ * @returns {object} New agent data
+ */
+function createRetryAgent(parent, options = {}) {
+  return {
+    parentId: parent.id,
+    model: options.model || parent.model,
+    prompt: parent.prompt,
+    status: 'queued',
+    startTime: new Date(),
+    tokens: { input: 0, output: 0 },
+    cost: 0,
+    retryCount: (parent.retryCount || 0) + 1,
+    retryContext: getRetryContext(parent),
+  };
+}
+
+/**
+ * Execute agents retry 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}`,
+    };
+  }
+
+  const { canRetry: allowed, reason } = canRetry(agent);
+
+  if (!allowed) {
+    return {
+      success: false,
+      error: reason,
+    };
+  }
+
+  // Check budget
+  if (registry.budget && registry.budget.remaining <= 0) {
+    return {
+      success: false,
+      error: 'Budget exhausted. Cannot retry.',
+    };
+  }
+
+  // Create new agent
+  const retryData = createRetryAgent(agent, options);
+  const newAgent = registry.createAgent(retryData);
+
+  return {
+    success: true,
+    newAgentId: newAgent.id,
+    parentId: agent.id,
+    model: newAgent.model,
+    message: `Created retry agent ${newAgent.id} (from ${agent.id})`,
+  };
+}
+
+module.exports = {
+  execute,
+  createRetryAgent,
+  canRetry,
+  getRetryContext,
+};

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

@@ -0,0 +1,192 @@
+const { describe, it, beforeEach, mock } = require('node:test');
+const assert = require('node:assert');
+const {
+  execute,
+  createRetryAgent,
+  canRetry,
+  getRetryContext,
+} = require('./agents-retry-command.js');
+
+describe('agents-retry-command', () => {
+  const failedAgent = {
+    id: 'agent-failed',
+    name: 'Failed Builder',
+    model: 'gpt-4',
+    status: 'failed',
+    prompt: 'Build the feature',
+    error: { message: 'Rate limit exceeded' },
+    cost: 0.10,
+  };
+
+  describe('execute', () => {
+    const createMockRegistry = (agents = [], budget = { remaining: 100 }) => ({
+      getAgent: (id) => agents.find(a => a.id === id),
+      createAgent: (data) => {
+        const newAgent = { id: `agent-${Date.now()}`, ...data };
+        agents.push(newAgent);
+        return newAgent;
+      },
+      budget,
+    });
+
+    it('retries failed agent', async () => {
+      const agents = [{ ...failedAgent }];
+      const result = await execute({
+        registry: createMockRegistry(agents),
+        agentId: 'agent-failed',
+      });
+      assert.ok(result.success);
+      assert.ok(result.newAgentId);
+    });
+
+    it('creates new agent', async () => {
+      const agents = [{ ...failedAgent }];
+      const registry = createMockRegistry(agents);
+      const result = await execute({
+        registry,
+        agentId: 'agent-failed',
+      });
+      assert.strictEqual(agents.length, 2);
+    });
+
+    it('includes failure context', async () => {
+      const agents = [{ ...failedAgent }];
+      const registry = createMockRegistry(agents);
+      const result = await execute({
+        registry,
+        agentId: 'agent-failed',
+      });
+      const newAgent = agents.find(a => a.id === result.newAgentId);
+      assert.ok(newAgent.retryContext || newAgent.parentId);
+    });
+
+    it('with --model overrides', async () => {
+      const agents = [{ ...failedAgent }];
+      const registry = createMockRegistry(agents);
+      const result = await execute({
+        registry,
+        agentId: 'agent-failed',
+        options: { model: 'claude-3-opus' },
+      });
+      const newAgent = agents.find(a => a.id === result.newAgentId);
+      assert.strictEqual(newAgent.model, 'claude-3-opus');
+    });
+
+    it('handles not failed agent', async () => {
+      const agents = [{ id: 'agent-1', status: 'running' }];
+      const result = await execute({
+        registry: createMockRegistry(agents),
+        agentId: 'agent-1',
+      });
+      assert.strictEqual(result.success, false);
+      assert.ok(result.error.includes('not failed') || result.error.includes('Cannot retry'));
+    });
+
+    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'));
+    });
+
+    it('shows new agent ID', async () => {
+      const agents = [{ ...failedAgent }];
+      const result = await execute({
+        registry: createMockRegistry(agents),
+        agentId: 'agent-failed',
+      });
+      assert.ok(result.newAgentId);
+      assert.ok(result.message.includes(result.newAgentId));
+    });
+
+    it('tracks retry parent', async () => {
+      const agents = [{ ...failedAgent }];
+      const registry = createMockRegistry(agents);
+      const result = await execute({
+        registry,
+        agentId: 'agent-failed',
+      });
+      const newAgent = agents.find(a => a.id === result.newAgentId);
+      assert.strictEqual(newAgent.parentId, 'agent-failed');
+    });
+
+    it('inherits original prompt', async () => {
+      const agents = [{ ...failedAgent }];
+      const registry = createMockRegistry(agents);
+      const result = await execute({
+        registry,
+        agentId: 'agent-failed',
+      });
+      const newAgent = agents.find(a => a.id === result.newAgentId);
+      assert.strictEqual(newAgent.prompt, 'Build the feature');
+    });
+
+    it('respects budget limits', async () => {
+      const agents = [{ ...failedAgent }];
+      const result = await execute({
+        registry: createMockRegistry(agents, { remaining: 0 }),
+        agentId: 'agent-failed',
+      });
+      assert.strictEqual(result.success, false);
+      assert.ok(result.error.includes('budget') || result.error.includes('Budget'));
+    });
+  });
+
+  describe('createRetryAgent', () => {
+    it('creates agent with parent reference', () => {
+      const parent = { id: 'parent-1', model: 'gpt-4', prompt: 'test' };
+      const agent = createRetryAgent(parent, {});
+      assert.strictEqual(agent.parentId, 'parent-1');
+    });
+
+    it('uses parent model by default', () => {
+      const parent = { id: 'parent-1', model: 'gpt-4', prompt: 'test' };
+      const agent = createRetryAgent(parent, {});
+      assert.strictEqual(agent.model, 'gpt-4');
+    });
+
+    it('allows model override', () => {
+      const parent = { id: 'parent-1', model: 'gpt-4', prompt: 'test' };
+      const agent = createRetryAgent(parent, { model: 'claude' });
+      assert.strictEqual(agent.model, 'claude');
+    });
+  });
+
+  describe('canRetry', () => {
+    it('returns true for failed agent', () => {
+      const result = canRetry({ status: 'failed' });
+      assert.ok(result.canRetry);
+    });
+
+    it('returns true for cancelled agent', () => {
+      const result = canRetry({ status: 'cancelled' });
+      assert.ok(result.canRetry);
+    });
+
+    it('returns false for running agent', () => {
+      const result = canRetry({ status: 'running' });
+      assert.strictEqual(result.canRetry, false);
+    });
+
+    it('returns false for completed agent', () => {
+      const result = canRetry({ status: 'completed' });
+      assert.strictEqual(result.canRetry, false);
+    });
+  });
+
+  describe('getRetryContext', () => {
+    it('includes error message', () => {
+      const agent = { error: { message: 'Rate limit' } };
+      const context = getRetryContext(agent);
+      assert.ok(context.includes('Rate limit'));
+    });
+
+    it('includes retry count', () => {
+      const agent = { retryCount: 2 };
+      const context = getRetryContext(agent);
+      assert.ok(context.includes('2'));
+    });
+  });
+});

package/server/lib/budget-limits.js

@@ -0,0 +1,222 @@
+/**
+ * Budget Limits Module
+ *
+ * Configurable budget limits with enforcement
+ */
+
+/**
+ * Create a budget manager instance
+ * @returns {Object} Budget manager
+ */
+function createBudgetManager() {
+  return {
+    daily: null,
+    monthly: null,
+    byModel: {},
+    warnThresholds: [0.5, 0.8],
+  };
+}
+
+/**
+ * Set a budget limit
+ * @param {Object} manager - Budget manager instance
+ * @param {Object} options - Budget options
+ * @param {string} options.type - Budget type: 'daily', 'monthly', or 'model'
+ * @param {number} options.limit - Budget limit in dollars
+ * @param {string} [options.model] - Model name (for model budgets)
+ * @param {number[]} [options.warnAt] - Warning thresholds (e.g., [0.5, 0.8])
+ */
+function setBudget(manager, options) {
+  const { type, limit, model, warnAt } = options;
+
+  if (type === 'daily') {
+    manager.daily = limit;
+  } else if (type === 'monthly') {
+    manager.monthly = limit;
+  } else if (type === 'model' && model) {
+    manager.byModel[model] = limit;
+  }
+
+  if (warnAt) {
+    manager.warnThresholds = warnAt;
+  }
+}
+
+/**
+ * Check budget status
+ * @param {Object} manager - Budget manager instance
+ * @param {Object} options - Check options
+ * @param {number} options.currentSpend - Current spend amount
+ * @param {string} [options.type='daily'] - Budget type to check
+ * @param {string} [options.model] - Model to check (for model budgets)
+ * @returns {Object} Status result
+ */
+function checkBudget(manager, options) {
+  const { currentSpend, type = 'daily', model } = options;
+
+  let limit;
+  if (type === 'model' && model) {
+    limit = manager.byModel[model];
+  } else if (type === 'monthly') {
+    limit = manager.monthly;
+  } else {
+    limit = manager.daily;
+  }
+
+  if (limit === null || limit === undefined) {
+    return { status: 'ok', message: 'No budget set' };
+  }
+
+  const percentage = currentSpend / limit;
+
+  if (percentage >= 1) {
+    return {
+      status: 'exceeded',
+      message: `Budget exceeded: $${currentSpend.toFixed(2)} / $${limit.toFixed(2)}`,
+      percentage: percentage * 100,
+    };
+  }
+
+  // Check warning thresholds (in reverse order to get highest matching)
+  for (let i = manager.warnThresholds.length - 1; i >= 0; i--) {
+    const threshold = manager.warnThresholds[i];
+    if (percentage >= threshold) {
+      return {
+        status: 'warning',
+        message: `${Math.round(threshold * 100)}% of budget used: $${currentSpend.toFixed(2)} / $${limit.toFixed(2)}`,
+        percentage: percentage * 100,
+      };
+    }
+  }
+
+  return {
+    status: 'ok',
+    message: `Under budget: $${currentSpend.toFixed(2)} / $${limit.toFixed(2)}`,
+    percentage: percentage * 100,
+  };
+}
+
+/**
+ * Enforce budget (determine if operation should proceed)
+ * @param {Object} manager - Budget manager instance
+ * @param {Object} options - Enforcement options
+ * @param {number} options.currentSpend - Current spend
+ * @param {number} options.projectedCost - Cost of planned operation
+ * @param {boolean} [options.override] - Admin override flag
+ * @param {string} [options.type='daily'] - Budget type
+ * @returns {Object} Enforcement result
+ */
+function enforceBudget(manager, options) {
+  const { currentSpend, projectedCost, override, type = 'daily' } = options;
+
+  if (override) {
+    return { allowed: true, reason: 'Admin override' };
+  }
+
+  let limit;
+  if (type === 'monthly') {
+    limit = manager.monthly;
+  } else {
+    limit = manager.daily;
+  }
+
+  if (limit === null || limit === undefined) {
+    return { allowed: true, reason: 'No budget set' };
+  }
+
+  const totalAfter = currentSpend + projectedCost;
+
+  if (currentSpend >= limit) {
+    return {
+      allowed: false,
+      reason: `Daily budget exceeded: $${currentSpend.toFixed(2)} >= $${limit.toFixed(2)}`,
+    };
+  }
+
+  if (totalAfter > limit) {
+    return {
+      allowed: false,
+      reason: `Operation would exceed budget: $${totalAfter.toFixed(2)} > $${limit.toFixed(2)}`,
+    };
+  }
+
+  return { allowed: true, reason: 'Within budget' };
+}
+
+/**
+ * Get daily budget limit
+ * @param {Object} manager - Budget manager instance
+ * @returns {number|null} Daily budget or null if not set
+ */
+function getDailyBudget(manager) {
+  return manager.daily;
+}
+
+/**
+ * Get monthly budget limit
+ * @param {Object} manager - Budget manager instance
+ * @returns {number|null} Monthly budget or null if not set
+ */
+function getMonthlyBudget(manager) {
+  return manager.monthly;
+}
+
+/**
+ * Get budget for a specific model
+ * @param {Object} manager - Budget manager instance
+ * @param {string} model - Model name
+ * @returns {number|null} Model budget or null if not set
+ */
+function getModelBudget(manager, model) {
+  return manager.byModel[model] || null;
+}
+
+/**
+ * Reset budget spend tracking
+ * @param {Object} manager - Budget manager instance
+ * @param {Object} options - Reset options
+ * @param {string} options.type - Budget type to reset
+ */
+function resetBudget(manager, options) {
+  // Note: The tracker handles actual spend tracking
+  // This is mainly for admin operations
+  const { type } = options;
+
+  // Budgets themselves remain, just the tracking resets
+  // This is handled by the cost tracker, not here
+}
+
+/**
+ * Calculate remaining budget
+ * @param {Object} manager - Budget manager instance
+ * @param {Object} options - Options with current spend
+ * @param {number} options.currentSpend - Current spend amount
+ * @returns {Object} Remaining amounts
+ */
+function budgetRemaining(manager, options) {
+  const { currentSpend } = options;
+
+  const result = {};
+
+  if (manager.daily !== null) {
+    result.daily = Math.max(0, manager.daily - currentSpend);
+  }
+
+  if (manager.monthly !== null) {
+    result.monthly = Math.max(0, manager.monthly - currentSpend);
+  }
+
+  return result;
+}
+
+module.exports = {
+  createBudgetManager,
+  setBudget,
+  checkBudget,
+  enforceBudget,
+  getDailyBudget,
+  getMonthlyBudget,
+  getModelBudget,
+  resetBudget,
+  budgetRemaining,
+};