aemeathcli 1.0.0

package/dist/chunk-DAHGLHNR.js

@@ -0,0 +1,657 @@
+import { getEventBus } from './chunk-YL5XFHR3.js';
+import { estimateTokenCount, createTokenUsage, formatCost } from './chunk-CGEV3ARR.js';
+import { isCommandBlocked } from './chunk-CS5X3BWX.js';
+import { SUPPORTED_MODELS } from './chunk-HCIHOHLX.js';
+import { ModelNotFoundError } from './chunk-ZGOHARPV.js';
+import { logger } from './chunk-JAXXTYID.js';
+
+// src/core/model-router.ts
+var ModelRouter = class {
+  config;
+  userOverride;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Set a temporary user override that takes highest priority.
+   */
+  setUserOverride(modelId) {
+    if (modelId !== void 0) {
+      this.validateModel(modelId);
+    }
+    this.userOverride = modelId;
+  }
+  /**
+   * Resolve the best model for a given role through the priority pipeline.
+   */
+  resolve(role) {
+    if (this.userOverride) {
+      const info = this.getModelInfo(this.userOverride);
+      return {
+        modelId: this.userOverride,
+        provider: info.provider,
+        source: "user_override",
+        role
+      };
+    }
+    if (role) {
+      const roleConfig = this.config.roles[role];
+      if (roleConfig) {
+        if (this.isModelAvailable(roleConfig.primary)) {
+          const info = this.getModelInfo(roleConfig.primary);
+          return {
+            modelId: roleConfig.primary,
+            provider: info.provider,
+            source: "role_config",
+            role
+          };
+        }
+        for (const fallbackModel of roleConfig.fallback) {
+          if (this.isModelAvailable(fallbackModel)) {
+            const info = this.getModelInfo(fallbackModel);
+            logger.info(
+              { role, primary: roleConfig.primary, fallback: fallbackModel },
+              "Using fallback model for role"
+            );
+            return {
+              modelId: fallbackModel,
+              provider: info.provider,
+              source: "fallback_chain",
+              role
+            };
+          }
+        }
+      }
+    }
+    const defaultModel = this.config.defaultModel;
+    if (this.isModelAvailable(defaultModel)) {
+      const info = this.getModelInfo(defaultModel);
+      return {
+        modelId: defaultModel,
+        provider: info.provider,
+        source: "system_default",
+        role
+      };
+    }
+    const anyAvailable = this.getAvailableModels()[0];
+    if (anyAvailable) {
+      return {
+        modelId: anyAvailable.id,
+        provider: anyAvailable.provider,
+        source: "system_default",
+        role
+      };
+    }
+    throw new ModelNotFoundError(defaultModel);
+  }
+  /**
+   * Check if a model is available (provider is enabled and model is known).
+   */
+  isModelAvailable(modelId) {
+    const info = SUPPORTED_MODELS[modelId];
+    if (!info) {
+      return false;
+    }
+    return this.config.enabledProviders.includes(info.provider);
+  }
+  /**
+   * Get model info by ID. Throws if not found.
+   */
+  getModelInfo(modelId) {
+    const info = SUPPORTED_MODELS[modelId];
+    if (!info) {
+      throw new ModelNotFoundError(modelId);
+    }
+    return info;
+  }
+  /**
+   * Get all available models (from enabled providers).
+   */
+  getAvailableModels() {
+    return Object.values(SUPPORTED_MODELS).filter(
+      (model) => this.config.enabledProviders.includes(model.provider)
+    );
+  }
+  /**
+   * List models recommended for a specific role.
+   */
+  getModelsForRole(role) {
+    return this.getAvailableModels().filter(
+      (model) => model.supportedRoles.includes(role)
+    );
+  }
+  /**
+   * Validate that a model ID exists. Throws ModelNotFoundError if not.
+   */
+  validateModel(modelId) {
+    if (!SUPPORTED_MODELS[modelId]) {
+      throw new ModelNotFoundError(modelId);
+    }
+  }
+};
+function createModelRouter(config) {
+  const enabledProviders = Object.entries(config.providers).filter(([, providerConfig]) => providerConfig?.enabled).map(([name]) => name);
+  return new ModelRouter({
+    defaultModel: config.defaultModel,
+    roles: config.roles,
+    enabledProviders
+  });
+}
+
+// src/core/context-manager.ts
+var CONTEXT_BUDGET_RATIO = 0.85;
+var SYSTEM_PROMPT_RESERVE = 4e3;
+var ContextManager = class {
+  maxTokens;
+  budgetTokens;
+  fileContext = /* @__PURE__ */ new Map();
+  currentTokenCount = 0;
+  constructor(modelInfo) {
+    this.maxTokens = modelInfo.contextWindow;
+    this.budgetTokens = Math.floor(this.maxTokens * CONTEXT_BUDGET_RATIO);
+  }
+  /**
+   * Get the available token budget for new content.
+   */
+  getAvailableBudget() {
+    return Math.max(0, this.budgetTokens - this.currentTokenCount - SYSTEM_PROMPT_RESERVE);
+  }
+  /**
+   * Get total context usage.
+   */
+  getUsage() {
+    return {
+      used: this.currentTokenCount,
+      budget: this.budgetTokens,
+      max: this.maxTokens,
+      percentage: Math.round(this.currentTokenCount / this.budgetTokens * 100)
+    };
+  }
+  /**
+   * Trim messages to fit within the context window.
+   * Preserves system prompt and most recent messages.
+   */
+  trimMessages(messages, systemPrompt) {
+    const systemTokens = systemPrompt ? estimateTokenCount(systemPrompt) : 0;
+    const availableTokens = this.budgetTokens - systemTokens - SYSTEM_PROMPT_RESERVE;
+    if (availableTokens <= 0) {
+      logger.warn("System prompt alone exceeds context budget");
+      return [];
+    }
+    const result = [];
+    let usedTokens = 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (!msg) {
+        continue;
+      }
+      const msgTokens = estimateTokenCount(msg.content);
+      if (usedTokens + msgTokens > availableTokens) {
+        break;
+      }
+      result.unshift(msg);
+      usedTokens += msgTokens;
+    }
+    this.currentTokenCount = usedTokens + systemTokens;
+    if (result.length < messages.length) {
+      logger.info(
+        {
+          original: messages.length,
+          trimmed: result.length,
+          droppedMessages: messages.length - result.length
+        },
+        "Trimmed conversation to fit context window"
+      );
+    }
+    return result;
+  }
+  /**
+   * Track a file being added to context.
+   */
+  addFileContext(filePath, content) {
+    const tokenCount = estimateTokenCount(content);
+    this.fileContext.set(filePath, {
+      filePath,
+      tokenCount,
+      lastAccessedAt: Date.now()
+    });
+    this.currentTokenCount += tokenCount;
+  }
+  /**
+   * Touch a file (update last accessed time).
+   */
+  touchFile(filePath) {
+    const entry = this.fileContext.get(filePath);
+    if (entry) {
+      entry.lastAccessedAt = Date.now();
+    }
+  }
+  /**
+   * Remove a file from context.
+   */
+  removeFileContext(filePath) {
+    const entry = this.fileContext.get(filePath);
+    if (entry) {
+      this.currentTokenCount -= entry.tokenCount;
+      this.fileContext.delete(filePath);
+    }
+  }
+  /**
+   * Evict least-recently-used files to free space.
+   */
+  evictLRU(tokensNeeded) {
+    const evicted = [];
+    const sorted = [...this.fileContext.entries()].sort(
+      ([, a], [, b]) => a.lastAccessedAt - b.lastAccessedAt
+    );
+    let freedTokens = 0;
+    for (const [filePath, entry] of sorted) {
+      if (freedTokens >= tokensNeeded) {
+        break;
+      }
+      this.removeFileContext(filePath);
+      freedTokens += entry.tokenCount;
+      evicted.push(filePath);
+    }
+    if (evicted.length > 0) {
+      logger.info(
+        { evicted, freedTokens },
+        "Evicted files from context to free space"
+      );
+    }
+    return evicted;
+  }
+  /**
+   * Get all tracked files.
+   */
+  getTrackedFiles() {
+    return [...this.fileContext.values()];
+  }
+  /**
+   * Reset context tracking (for model switch).
+   */
+  reset() {
+    this.fileContext.clear();
+    this.currentTokenCount = 0;
+  }
+};
+
+// src/core/cost-tracker.ts
+var CostTracker = class {
+  entries = [];
+  budgetConfig;
+  warningEmitted = false;
+  constructor(budgetConfig) {
+    this.budgetConfig = budgetConfig;
+  }
+  /**
+   * Record a cost entry from a model response.
+   */
+  record(provider, model, inputTokens, outputTokens, role) {
+    const usage = createTokenUsage(model, inputTokens, outputTokens);
+    const entry = {
+      provider,
+      model,
+      role,
+      usage,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.entries.push(entry);
+    const total = this.getSessionTotal();
+    const eventBus = getEventBus();
+    eventBus.emit("cost:updated", {
+      total,
+      provider,
+      delta: usage.costUsd
+    });
+    if (total >= this.budgetConfig.budgetWarning && !this.warningEmitted) {
+      this.warningEmitted = true;
+      eventBus.emit("cost:warning", {
+        current: total,
+        limit: this.budgetConfig.budgetWarning
+      });
+      logger.warn(
+        { current: formatCost(total), warning: formatCost(this.budgetConfig.budgetWarning) },
+        "Budget warning threshold reached"
+      );
+    }
+    if (total >= this.budgetConfig.budgetHardStop) {
+      eventBus.emit("cost:exceeded", {
+        current: total,
+        limit: this.budgetConfig.budgetHardStop
+      });
+      logger.error(
+        { current: formatCost(total), limit: formatCost(this.budgetConfig.budgetHardStop) },
+        "Budget hard stop reached"
+      );
+    }
+    return usage;
+  }
+  /**
+   * Get total session cost.
+   */
+  getSessionTotal() {
+    return this.entries.reduce((sum, entry) => sum + entry.usage.costUsd, 0);
+  }
+  /**
+   * Get total token counts.
+   */
+  getSessionTokens() {
+    const input = this.entries.reduce((sum, e) => sum + e.usage.inputTokens, 0);
+    const output = this.entries.reduce((sum, e) => sum + e.usage.outputTokens, 0);
+    return { input, output, total: input + output };
+  }
+  /**
+   * Get cost breakdown by provider, model, and role.
+   */
+  getBreakdown() {
+    const byProvider = {};
+    const byModel = {};
+    const byRole = {};
+    for (const entry of this.entries) {
+      byProvider[entry.provider] = (byProvider[entry.provider] ?? 0) + entry.usage.costUsd;
+      byModel[entry.model] = (byModel[entry.model] ?? 0) + entry.usage.costUsd;
+      if (entry.role) {
+        byRole[entry.role] = (byRole[entry.role] ?? 0) + entry.usage.costUsd;
+      }
+    }
+    return { byProvider, byModel, byRole };
+  }
+  /**
+   * Check if budget hard stop has been exceeded.
+   */
+  isBudgetExceeded() {
+    return this.getSessionTotal() >= this.budgetConfig.budgetHardStop;
+  }
+  /**
+   * Get formatted session summary.
+   */
+  getSummary() {
+    const total = this.getSessionTotal();
+    const tokens = this.getSessionTokens();
+    return `${formatCost(total)} (${tokens.total.toLocaleString()} tokens)`;
+  }
+  /**
+   * Get all cost entries (for export).
+   */
+  getEntries() {
+    return this.entries;
+  }
+  /**
+   * Reset cost tracking for a new session.
+   */
+  reset() {
+    this.entries.length = 0;
+    this.warningEmitted = false;
+  }
+};
+
+// src/core/permission-manager.ts
+var DANGEROUS_COMMANDS = [
+  "rm -rf",
+  "git push --force",
+  "git reset --hard",
+  "git checkout .",
+  "git clean -f",
+  "git branch -D",
+  "drop table",
+  "drop database",
+  "truncate",
+  "format c:",
+  "del /f /s /q"
+];
+var PermissionManager = class {
+  mode;
+  allowedPaths;
+  blockedCommands;
+  approvedOperations = /* @__PURE__ */ new Set();
+  constructor(mode, allowedPaths, blockedCommands) {
+    this.mode = mode;
+    this.allowedPaths = allowedPaths;
+    this.blockedCommands = blockedCommands;
+  }
+  /**
+   * Check if an operation is permitted.
+   */
+  check(request) {
+    if (request.command && this.isDangerousCommand(request.command)) {
+      return {
+        allowed: false,
+        reason: `Dangerous command detected: "${request.command}"`,
+        requiresUserApproval: true
+      };
+    }
+    if (request.command && isCommandBlocked(request.command, this.blockedCommands)) {
+      return {
+        allowed: false,
+        reason: `Command is on the blocked list`,
+        requiresUserApproval: true
+      };
+    }
+    const opKey = this.getOperationKey(request);
+    if (this.approvedOperations.has(opKey)) {
+      return { allowed: true, requiresUserApproval: false };
+    }
+    switch (this.mode) {
+      case "permissive":
+        return { allowed: true, requiresUserApproval: false };
+      case "standard":
+        return this.checkStandardMode(request);
+      case "strict":
+        return this.checkStrictMode(request);
+    }
+  }
+  /**
+   * Record that the user has approved an operation.
+   */
+  approve(request) {
+    const opKey = this.getOperationKey(request);
+    this.approvedOperations.add(opKey);
+    logger.info({ operation: opKey }, "Operation approved by user");
+  }
+  /**
+   * Update permission mode.
+   */
+  setMode(mode) {
+    this.mode = mode;
+    this.approvedOperations.clear();
+    logger.info({ mode }, "Permission mode changed");
+  }
+  /**
+   * Get current mode.
+   */
+  getMode() {
+    return this.mode;
+  }
+  checkStandardMode(request) {
+    if (this.isReadOperation(request)) {
+      return { allowed: true, requiresUserApproval: false };
+    }
+    return {
+      allowed: false,
+      reason: `${request.operation} requires approval in standard mode`,
+      requiresUserApproval: true
+    };
+  }
+  checkStrictMode(request) {
+    return {
+      allowed: false,
+      reason: `${request.operation} requires approval in strict mode`,
+      requiresUserApproval: true
+    };
+  }
+  isReadOperation(request) {
+    const readTools = ["read", "glob", "grep", "web-search", "web-fetch"];
+    return readTools.includes(request.toolName);
+  }
+  isDangerousCommand(command) {
+    const lower = command.toLowerCase().trim();
+    return DANGEROUS_COMMANDS.some((dangerous) => lower.includes(dangerous));
+  }
+  getOperationKey(request) {
+    return `${request.toolName}:${request.operation}:${request.resource ?? ""}`;
+  }
+};
+
+// src/core/task-orchestrator.ts
+var nextTaskId = 1;
+function generateTaskId() {
+  return String(nextTaskId++);
+}
+var TaskOrchestrator = class {
+  tasks = /* @__PURE__ */ new Map();
+  /**
+   * Create a new task.
+   */
+  createTask(subject, description, options) {
+    const id = generateTaskId();
+    const now = /* @__PURE__ */ new Date();
+    const task = {
+      id,
+      subject,
+      description,
+      status: "pending",
+      owner: options?.owner,
+      model: options?.model,
+      role: options?.role,
+      blocks: [],
+      blockedBy: options?.blockedBy ? [...options.blockedBy] : [],
+      createdAt: now,
+      updatedAt: now
+    };
+    this.tasks.set(id, task);
+    if (options?.blockedBy) {
+      for (const blockerId of options.blockedBy) {
+        const blocker = this.tasks.get(blockerId);
+        if (blocker && !blocker.blocks.includes(id)) {
+          blocker.blocks.push(id);
+        }
+      }
+    }
+    getEventBus().emit("task:created", { taskId: id, subject });
+    logger.info({ taskId: id, subject }, "Task created");
+    return task;
+  }
+  /**
+   * Update task status.
+   */
+  updateStatus(taskId, status) {
+    const task = this.getTask(taskId);
+    task.status = status;
+    task.updatedAt = /* @__PURE__ */ new Date();
+    getEventBus().emit("task:updated", { taskId, status });
+    if (status === "completed") {
+      getEventBus().emit("task:completed", { taskId });
+      this.resolveBlockedTasks(taskId);
+    }
+    logger.info({ taskId, status }, "Task status updated");
+  }
+  /**
+   * Assign a task to an agent.
+   */
+  assignTask(taskId, owner, model) {
+    const task = this.getTask(taskId);
+    task.owner = owner;
+    if (model) {
+      task.model = model;
+    }
+    task.updatedAt = /* @__PURE__ */ new Date();
+    logger.info({ taskId, owner, model }, "Task assigned");
+  }
+  /**
+   * Get a task by ID. Throws if not found.
+   */
+  getTask(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    return task;
+  }
+  /**
+   * Get all tasks.
+   */
+  getAllTasks() {
+    return [...this.tasks.values()];
+  }
+  /**
+   * Get tasks by status.
+   */
+  getTasksByStatus(status) {
+    return [...this.tasks.values()].filter((t) => t.status === status);
+  }
+  /**
+   * Get tasks assigned to an agent.
+   */
+  getTasksByOwner(owner) {
+    return [...this.tasks.values()].filter((t) => t.owner === owner);
+  }
+  /**
+   * Get tasks that are ready to be worked on (pending, not blocked).
+   */
+  getAvailableTasks() {
+    return [...this.tasks.values()].filter(
+      (t) => t.status === "pending" && !t.owner && t.blockedBy.every((blockerId) => {
+        const blocker = this.tasks.get(blockerId);
+        return blocker?.status === "completed";
+      })
+    );
+  }
+  /**
+   * Check if all tasks are completed.
+   */
+  isAllComplete() {
+    return [...this.tasks.values()].every((t) => t.status === "completed");
+  }
+  /**
+   * Get progress summary.
+   */
+  getProgress() {
+    const tasks = [...this.tasks.values()];
+    return {
+      total: tasks.length,
+      completed: tasks.filter((t) => t.status === "completed").length,
+      inProgress: tasks.filter((t) => t.status === "in_progress").length,
+      pending: tasks.filter((t) => t.status === "pending").length,
+      blocked: tasks.filter((t) => t.status === "blocked").length
+    };
+  }
+  /**
+   * Delete a task.
+   */
+  deleteTask(taskId) {
+    const task = this.tasks.get(taskId);
+    if (task) {
+      for (const [, otherTask] of this.tasks) {
+        otherTask.blockedBy = otherTask.blockedBy.filter((id) => id !== taskId);
+        otherTask.blocks = otherTask.blocks.filter((id) => id !== taskId);
+      }
+      this.tasks.delete(taskId);
+    }
+  }
+  /**
+   * When a task completes, check if any blocked tasks can now proceed.
+   */
+  resolveBlockedTasks(completedTaskId) {
+    for (const [, task] of this.tasks) {
+      if (task.status === "blocked" || task.status === "pending") {
+        const allDepsComplete = task.blockedBy.every((depId) => {
+          const dep = this.tasks.get(depId);
+          return dep?.status === "completed";
+        });
+        if (allDepsComplete && task.status === "blocked") {
+          task.status = "pending";
+          task.updatedAt = /* @__PURE__ */ new Date();
+          logger.info(
+            { taskId: task.id, unblockedBy: completedTaskId },
+            "Task unblocked"
+          );
+        }
+      }
+    }
+  }
+};
+
+export { ContextManager, CostTracker, ModelRouter, PermissionManager, TaskOrchestrator, createModelRouter };
+//# sourceMappingURL=chunk-DAHGLHNR.js.map
+//# sourceMappingURL=chunk-DAHGLHNR.js.map