@soleri/forge 5.1.2 → 5.2.0

package/dist/templates/facade-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facade-types.js","sourceRoot":"","sources":["../../src/templates/facade-types.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,mBAAmB;IACjC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CR,CAAC;AACF,CAAC"}

package/dist/templates/inject-claude-md.js

@@ -80,6 +80,42 @@ export function generateInjectClaudeMd(config) {
         '}',
         '',
         '/**',
+        ' * Remove agent section from a specific CLAUDE.md file.',
+        ' * Returns true if the section was found and removed.',
+        ' */',
+        'function removeFromFile(filePath: string): { removed: boolean; path: string } {',
+        '  if (!existsSync(filePath)) return { removed: false, path: filePath };',
+        "  const existing = readFileSync(filePath, 'utf-8');",
+        '  const marker = getClaudeMdMarker();',
+        `  const startMarker = '<!-- ' + marker + ' -->';`,
+        `  const endMarker = '<!-- /' + marker + ' -->';`,
+        '  const startIdx = existing.indexOf(startMarker);',
+        '  if (startIdx === -1) return { removed: false, path: filePath };',
+        '  const endIdx = existing.indexOf(endMarker);',
+        '  if (endIdx === -1) return { removed: false, path: filePath };',
+        "  const before = existing.slice(0, startIdx).replace(/\\n+$/, '');",
+        "  const after = existing.slice(endIdx + endMarker.length).replace(/^\\n+/, '');",
+        "  const cleaned = before + (before && after ? '\\n\\n' : '') + after;",
+        "  writeFileSync(filePath, cleaned || '', 'utf-8');",
+        '  return { removed: true, path: filePath };',
+        '}',
+        '',
+        '/**',
+        ' * Remove agent section from the global ~/.claude/CLAUDE.md.',
+        ' * Called on deactivation to clean up after test agents.',
+        ' */',
+        'export function removeClaudeMdGlobal(): { removed: boolean; path: string } {',
+        "  return removeFromFile(join(homedir(), '.claude', 'CLAUDE.md'));",
+        '}',
+        '',
+        '/**',
+        ' * Remove agent section from a project CLAUDE.md.',
+        ' */',
+        'export function removeClaudeMd(projectPath: string): { removed: boolean; path: string } {',
+        "  return removeFromFile(join(projectPath, 'CLAUDE.md'));",
+        '}',
+        '',
+        '/**',
         ' * Check if the agent marker exists in a CLAUDE.md file.',
         ' */',
         'export function hasAgentMarker(filePath: string): boolean {',

package/dist/templates/inject-claude-md.js.map

@@ -1 +1 @@
-{"version":3,"file":"inject-claude-md.js","sourceRoot":"","sources":["../../src/templates/inject-claude-md.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,UAAU,sBAAsB,CAAC,MAAmB;IACxD,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,EAAE,OAAO,CAAC;IAEnC,OAAO;QACL,+EAA+E;QAC/E,oCAAoC;QACpC,mCAAmC;QACnC,iFAAiF;QACjF,EAAE;QACF,iCAAiC;QACjC,sBAAsB;QACtB,iBAAiB;QACjB,+CAA+C;QAC/C,GAAG;QACH,EAAE;QACF,KAAK;QACL,gDAAgD;QAChD,8DAA8D;QAC9D,KAAK;QACL,2DAA2D;QAC3D,yCAAyC;QACzC,uCAAuC;QACvC,kDAAkD;QAClD,iDAAiD;QACjD,EAAE;QACF,gCAAgC;QAChC,wDAAwD;QACxD,mEAAmE;QACnE,KAAK;QACL,EAAE;QACF,qDAAqD;QACrD,EAAE;QACF,yCAAyC;QACzC,qDAAqD;QACrD,iDAAiD;QACjD,0BAA0B;QAC1B,sHAAsH;QACtH,kDAAkD;QAClD,qEAAqE;QACrE,OAAO;QACP,wGAAwG;QACxG,gDAAgD;QAChD,mEAAmE;QACnE,KAAK;QACL,EAAE;QACF,kEAAkE;QAClE,6EAA6E;QAC7E,kEAAkE;QAClE,GAAG;QACH,EAAE;QACF,KAAK;QACL,mDAAmD;QACnD,0CAA0C;QAC1C,+DAA+D;QAC/D,4CAA4C;QAC5C,KAAK;QACL,qEAAqE;QACrE,0DAA0D;QAC1D,GAAG;QACH,EAAE;QACF,KAAK;QACL,wEAAwE;QACxE,sDAAsD;QACtD,0DAA0D;QAC1D,KAAK;QACL,wDAAwD;QACxD,iDAAiD;QACjD,iCAAiC;QACjC,gDAAgD;QAChD,KAAK;QACL,wDAAwD;QACxD,GAAG;QACH,EAAE;QACF,KAAK;QACL,0DAA0D;QAC1D,KAAK;QACL,6DAA6D;QAC7D,4CAA4C;QAC5C,oDAAoD;QACpD,mCAAmC,MAAM,SAAS;QAClD,GAAG;KACJ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}
+{"version":3,"file":"inject-claude-md.js","sourceRoot":"","sources":["../../src/templates/inject-claude-md.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,UAAU,sBAAsB,CAAC,MAAmB;IACxD,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,EAAE,OAAO,CAAC;IAEnC,OAAO;QACL,+EAA+E;QAC/E,oCAAoC;QACpC,mCAAmC;QACnC,iFAAiF;QACjF,EAAE;QACF,iCAAiC;QACjC,sBAAsB;QACtB,iBAAiB;QACjB,+CAA+C;QAC/C,GAAG;QACH,EAAE;QACF,KAAK;QACL,gDAAgD;QAChD,8DAA8D;QAC9D,KAAK;QACL,2DAA2D;QAC3D,yCAAyC;QACzC,uCAAuC;QACvC,kDAAkD;QAClD,iDAAiD;QACjD,EAAE;QACF,gCAAgC;QAChC,wDAAwD;QACxD,mEAAmE;QACnE,KAAK;QACL,EAAE;QACF,qDAAqD;QACrD,EAAE;QACF,yCAAyC;QACzC,qDAAqD;QACrD,iDAAiD;QACjD,0BAA0B;QAC1B,sHAAsH;QACtH,kDAAkD;QAClD,qEAAqE;QACrE,OAAO;QACP,wGAAwG;QACxG,gDAAgD;QAChD,mEAAmE;QACnE,KAAK;QACL,EAAE;QACF,kEAAkE;QAClE,6EAA6E;QAC7E,kEAAkE;QAClE,GAAG;QACH,EAAE;QACF,KAAK;QACL,mDAAmD;QACnD,0CAA0C;QAC1C,+DAA+D;QAC/D,4CAA4C;QAC5C,KAAK;QACL,qEAAqE;QACrE,0DAA0D;QAC1D,GAAG;QACH,EAAE;QACF,KAAK;QACL,wEAAwE;QACxE,sDAAsD;QACtD,0DAA0D;QAC1D,KAAK;QACL,wDAAwD;QACxD,iDAAiD;QACjD,iCAAiC;QACjC,gDAAgD;QAChD,KAAK;QACL,wDAAwD;QACxD,GAAG;QACH,EAAE;QACF,KAAK;QACL,yDAAyD;QACzD,uDAAuD;QACvD,KAAK;QACL,iFAAiF;QACjF,yEAAyE;QACzE,qDAAqD;QACrD,uCAAuC;QACvC,kDAAkD;QAClD,iDAAiD;QACjD,mDAAmD;QACnD,mEAAmE;QACnE,+CAA+C;QAC/C,iEAAiE;QACjE,oEAAoE;QACpE,iFAAiF;QACjF,uEAAuE;QACvE,oDAAoD;QACpD,6CAA6C;QAC7C,GAAG;QACH,EAAE;QACF,KAAK;QACL,8DAA8D;QAC9D,0DAA0D;QAC1D,KAAK;QACL,8EAA8E;QAC9E,mEAAmE;QACnE,GAAG;QACH,EAAE;QACF,KAAK;QACL,mDAAmD;QACnD,KAAK;QACL,2FAA2F;QAC3F,0DAA0D;QAC1D,GAAG;QACH,EAAE;QACF,KAAK;QACL,0DAA0D;QAC1D,KAAK;QACL,6DAA6D;QAC7D,4CAA4C;QAC5C,oDAAoD;QACpD,mCAAmC,MAAM,SAAS;QAClD,GAAG;KACJ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

package/dist/templates/intelligence-loader.d.ts

@@ -0,0 +1 @@
+export declare function generateIntelligenceLoader(): string;

package/dist/templates/intelligence-loader.js

@@ -0,0 +1,43 @@
+export function generateIntelligenceLoader() {
+    return `import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import type { IntelligenceBundle, IntelligenceEntry } from './types.js';
+
+export function loadIntelligenceData(dataDir: string): IntelligenceEntry[] {
+  const entries: IntelligenceEntry[] = [];
+  let files: string[];
+  try {
+    files = readdirSync(dataDir).filter((f) => f.endsWith('.json'));
+  } catch {
+    console.warn('Intelligence data directory not found: ' + dataDir);
+    return entries;
+  }
+
+  for (const file of files) {
+    try {
+      const raw = readFileSync(join(dataDir, file), 'utf-8');
+      const bundle = JSON.parse(raw) as IntelligenceBundle;
+      if (!bundle.entries || !Array.isArray(bundle.entries)) continue;
+      for (const entry of bundle.entries) {
+        if (validateEntry(entry)) entries.push(entry);
+      }
+    } catch (err) {
+      console.warn('Failed to load ' + file + ': ' + (err instanceof Error ? err.message : err));
+    }
+  }
+  return entries;
+}
+
+function validateEntry(entry: IntelligenceEntry): boolean {
+  return (
+    typeof entry.id === 'string' && entry.id.length > 0 &&
+    ['pattern', 'anti-pattern', 'rule'].includes(entry.type) &&
+    typeof entry.title === 'string' && entry.title.length > 0 &&
+    typeof entry.description === 'string' && entry.description.length > 0 &&
+    ['critical', 'warning', 'suggestion'].includes(entry.severity) &&
+    Array.isArray(entry.tags)
+  );
+}
+`;
+}
+//# sourceMappingURL=intelligence-loader.js.map

package/dist/templates/intelligence-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence-loader.js","sourceRoot":"","sources":["../../src/templates/intelligence-loader.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,0BAA0B;IACxC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCR,CAAC;AACF,CAAC"}

package/dist/templates/intelligence-types.d.ts

@@ -0,0 +1 @@
+export declare function generateIntelligenceTypes(): string;

package/dist/templates/intelligence-types.js

@@ -0,0 +1,24 @@
+export function generateIntelligenceTypes() {
+    return `export interface IntelligenceEntry {
+  id: string;
+  type: 'pattern' | 'anti-pattern' | 'rule';
+  domain: string;
+  title: string;
+  severity: 'critical' | 'warning' | 'suggestion';
+  description: string;
+  context?: string;
+  example?: string;
+  counterExample?: string;
+  why?: string;
+  tags: string[];
+  appliesTo?: string[];
+}
+
+export interface IntelligenceBundle {
+  domain: string;
+  version: string;
+  entries: IntelligenceEntry[];
+}
+`;
+}
+//# sourceMappingURL=intelligence-types.js.map

package/dist/templates/intelligence-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence-types.js","sourceRoot":"","sources":["../../src/templates/intelligence-types.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,yBAAyB;IACvC,OAAO;;;;;;;;;;;;;;;;;;;;CAoBR,CAAC;AACF,CAAC"}

package/dist/templates/llm-client.d.ts

@@ -0,0 +1,7 @@
+import type { AgentConfig } from '../types.js';
+/**
+ * Generate the LLM client file for a new agent.
+ * Contains LLMClient (OpenAI fetch + Anthropic SDK) and ModelRouter (inlined).
+ * Uses config.id to resolve ~/.{agentId}/model-routing.json.
+ */
+export declare function generateLLMClient(config: AgentConfig): string;

package/dist/templates/llm-client.js

@@ -0,0 +1,300 @@
+/**
+ * Generate the LLM client file for a new agent.
+ * Contains LLMClient (OpenAI fetch + Anthropic SDK) and ModelRouter (inlined).
+ * Uses config.id to resolve ~/.{agentId}/model-routing.json.
+ */
+export function generateLLMClient(config) {
+    return `/**
+ * LLM Client — Unified OpenAI/Anthropic caller with key pool rotation
+ * Generated by Soleri — do not edit manually.
+ */
+
+import Anthropic from '@anthropic-ai/sdk';
+import { SecretString, LLMError, CircuitBreaker, retry, parseRateLimitHeaders } from '@soleri/core';
+import type {
+  LLMCallOptions,
+  LLMCallResult,
+  RouteEntry,
+  RoutingConfig,
+  KeyPool,
+} from '@soleri/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+
+// =============================================================================
+// CONSTANTS
+// =============================================================================
+
+const OPENAI_API_URL = 'https://api.openai.com/v1/chat/completions';
+
+// =============================================================================
+// MODEL ROUTER (inlined)
+// =============================================================================
+
+function loadRoutingConfig(): RoutingConfig {
+  const defaultConfig: RoutingConfig = {
+    routes: [],
+    defaultOpenAIModel: 'gpt-4o-mini',
+    defaultAnthropicModel: 'claude-sonnet-4-20250514',
+  };
+
+  const configPath = path.join(
+    homedir(),
+    '.${config.id}',
+    'model-routing.json',
+  );
+
+  try {
+    if (fs.existsSync(configPath)) {
+      const data = JSON.parse(fs.readFileSync(configPath, 'utf-8')) as Partial<RoutingConfig>;
+      if (data.routes && Array.isArray(data.routes)) {
+        defaultConfig.routes = data.routes;
+      }
+      if (data.defaultOpenAIModel) {
+        defaultConfig.defaultOpenAIModel = data.defaultOpenAIModel;
+      }
+      if (data.defaultAnthropicModel) {
+        defaultConfig.defaultAnthropicModel = data.defaultAnthropicModel;
+      }
+    }
+  } catch {
+    // Config not available — use defaults
+  }
+
+  return defaultConfig;
+}
+
+function inferProvider(model: string): 'openai' | 'anthropic' {
+  if (model.startsWith('claude-') || model.startsWith('anthropic/')) {
+    return 'anthropic';
+  }
+  return 'openai';
+}
+
+class ModelRouter {
+  private config: RoutingConfig;
+
+  constructor(config?: RoutingConfig) {
+    this.config = config || loadRoutingConfig();
+  }
+
+  resolve(
+    caller: string,
+    task?: string,
+    originalModel?: string,
+  ): { model: string; provider: 'openai' | 'anthropic' } {
+    if (task) {
+      const exactMatch = this.config.routes.find(
+        (r) => r.caller === caller && r.task === task,
+      );
+      if (exactMatch) {
+        return { model: exactMatch.model, provider: exactMatch.provider };
+      }
+    }
+
+    const callerMatch = this.config.routes.find(
+      (r) => r.caller === caller && !r.task,
+    );
+    if (callerMatch) {
+      return { model: callerMatch.model, provider: callerMatch.provider };
+    }
+
+    if (originalModel) {
+      const provider = inferProvider(originalModel);
+      return { model: originalModel, provider };
+    }
+
+    return { model: this.config.defaultOpenAIModel, provider: 'openai' };
+  }
+
+  getRoutes(): RouteEntry[] {
+    return [...this.config.routes];
+  }
+}
+
+// =============================================================================
+// LLM CLIENT
+// =============================================================================
+
+export class LLMClient {
+  private openaiKeyPool: KeyPool;
+  private anthropicKeyPool: KeyPool;
+  private anthropicClient: Anthropic | null = null;
+  private anthropicBreaker: CircuitBreaker;
+  private anthropicKeyFingerprint: string = '';
+  private router: ModelRouter;
+
+  constructor(openaiKeyPool: KeyPool, anthropicKeyPool: KeyPool) {
+    this.openaiKeyPool = openaiKeyPool;
+    this.anthropicKeyPool = anthropicKeyPool;
+    this.anthropicBreaker = new CircuitBreaker({
+      name: 'llm-anthropic',
+      failureThreshold: 5,
+      resetTimeoutMs: 60_000,
+    });
+    this.router = new ModelRouter();
+  }
+
+  async complete(options: LLMCallOptions): Promise<LLMCallResult> {
+    const routed = this.router.resolve(
+      options.caller,
+      options.task,
+      options.model,
+    );
+    const resolvedOptions = { ...options, model: routed.model, provider: routed.provider };
+
+    return resolvedOptions.provider === 'anthropic'
+      ? this.callAnthropic(resolvedOptions)
+      : this.callOpenAI(resolvedOptions);
+  }
+
+  isAvailable(): { openai: boolean; anthropic: boolean } {
+    return {
+      openai: this.openaiKeyPool.hasKeys,
+      anthropic: this.anthropicKeyPool.hasKeys,
+    };
+  }
+
+  getRoutes(): RouteEntry[] {
+    return this.router.getRoutes();
+  }
+
+  // ===========================================================================
+  // OPENAI
+  // ===========================================================================
+
+  private async callOpenAI(options: LLMCallOptions): Promise<LLMCallResult> {
+    const keyPool = this.openaiKeyPool.hasKeys ? this.openaiKeyPool : null;
+
+    if (!keyPool) {
+      throw new LLMError('OpenAI API key not configured', { retryable: false });
+    }
+
+    const start = Date.now();
+
+    const doRequest = async (): Promise<LLMCallResult> => {
+      const apiKey = keyPool.getActiveKey().expose();
+      const keyIndex = keyPool.activeKeyIndex;
+
+      const response = await fetch(OPENAI_API_URL, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: \`Bearer \${apiKey}\`,
+        },
+        body: JSON.stringify({
+          model: options.model,
+          messages: [
+            { role: 'system', content: options.systemPrompt },
+            { role: 'user', content: options.userPrompt },
+          ],
+          temperature: options.temperature ?? 0.3,
+          max_completion_tokens: options.maxTokens ?? 500,
+        }),
+      });
+
+      if (response.headers) {
+        const rateLimits = parseRateLimitHeaders(response.headers);
+        if (rateLimits.remaining !== null) {
+          keyPool.updateQuota(keyIndex, rateLimits.remaining);
+          keyPool.rotatePreemptive();
+        }
+      }
+
+      if (!response.ok) {
+        if (response.status === 429 && keyPool.poolSize > 1) {
+          keyPool.rotateOnError();
+        }
+
+        const errorBody = await response.text();
+        throw new LLMError(
+          \`OpenAI API error: \${response.status} - \${errorBody}\`,
+          { retryable: response.status === 429 || response.status >= 500, statusCode: response.status },
+        );
+      }
+
+      const data = (await response.json()) as {
+        choices: Array<{ message: { content: string } }>;
+        usage?: { prompt_tokens?: number; completion_tokens?: number };
+      };
+
+      return {
+        text: data.choices[0]?.message?.content || '',
+        model: options.model,
+        provider: 'openai' as const,
+        inputTokens: data.usage?.prompt_tokens,
+        outputTokens: data.usage?.completion_tokens,
+        durationMs: Date.now() - start,
+      };
+    };
+
+    return retry(doRequest, { maxAttempts: 3 });
+  }
+
+  // ===========================================================================
+  // ANTHROPIC
+  // ===========================================================================
+
+  private async callAnthropic(options: LLMCallOptions): Promise<LLMCallResult> {
+    const client = this.getAnthropicClient();
+    if (!client) {
+      throw new LLMError('Anthropic API key not configured', { retryable: false });
+    }
+
+    const start = Date.now();
+
+    return this.anthropicBreaker.call(() =>
+      retry(
+        async () => {
+          const response = await client.messages.create(
+            {
+              model: options.model,
+              max_tokens: options.maxTokens ?? 1024,
+              system: options.systemPrompt,
+              messages: [{ role: 'user', content: options.userPrompt }],
+            },
+            { timeout: 60_000 },
+          );
+
+          const text = response.content
+            .filter(
+              (block): block is Anthropic.TextBlock => block.type === 'text',
+            )
+            .map((block) => block.text)
+            .join('\\n');
+
+          return {
+            text,
+            model: options.model,
+            provider: 'anthropic' as const,
+            inputTokens: response.usage?.input_tokens,
+            outputTokens: response.usage?.output_tokens,
+            durationMs: Date.now() - start,
+          };
+        },
+        { maxAttempts: 2 },
+      ),
+    );
+  }
+
+  private getAnthropicClient(): Anthropic | null {
+    if (!this.anthropicKeyPool.hasKeys) return null;
+
+    const currentKey = this.anthropicKeyPool.getActiveKey().expose();
+    const currentFingerprint = currentKey.slice(-8);
+
+    if (currentFingerprint !== this.anthropicKeyFingerprint) {
+      this.anthropicClient = null;
+      this.anthropicKeyFingerprint = currentFingerprint;
+    }
+
+    if (this.anthropicClient) return this.anthropicClient;
+
+    this.anthropicClient = new Anthropic({ apiKey: currentKey });
+    return this.anthropicClient;
+  }
+}
+`;
+}
+//# sourceMappingURL=llm-client.js.map

package/dist/templates/llm-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-client.js","sourceRoot":"","sources":["../../src/templates/llm-client.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAmB;IACnD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqCD,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8PhB,CAAC;AACF,CAAC"}

package/dist/templates/llm-key-pool.d.ts

@@ -0,0 +1,7 @@
+import type { AgentConfig } from '../types.js';
+/**
+ * Generate the LLM key pool file for a new agent.
+ * KeyPool manages multiple API keys with per-key circuit breakers.
+ * Uses config.id to resolve ~/.{agentId}/keys.json.
+ */
+export declare function generateLLMKeyPool(config: AgentConfig): string;

package/dist/templates/llm-key-pool.js

@@ -0,0 +1,211 @@
+/**
+ * Generate the LLM key pool file for a new agent.
+ * KeyPool manages multiple API keys with per-key circuit breakers.
+ * Uses config.id to resolve ~/.{agentId}/keys.json.
+ */
+export function generateLLMKeyPool(config) {
+    return `/**
+ * Key Pool — Multi-key management with auto-rotation
+ * Generated by Soleri — do not edit manually.
+ *
+ * Key loading priority:
+ * 1. ~/.${config.id}/keys.json → { "openai": ["sk-..."], "anthropic": ["sk-ant-..."] }
+ * 2. Fallback: OPENAI_API_KEY / ANTHROPIC_API_KEY env vars
+ * 3. Empty pool → graceful degradation
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+import { SecretString } from './types.js';
+import type { KeyPoolConfig, KeyStatus } from './types.js';
+import { CircuitBreaker } from './utils.js';
+
+// =============================================================================
+// CONSTANTS
+// =============================================================================
+
+const DEFAULT_PREEMPTIVE_THRESHOLD = 50;
+
+// =============================================================================
+// KEY POOL
+// =============================================================================
+
+class RateLimitRotationError extends Error {
+  retryable = true;
+  constructor() {
+    super('Rate limit rotation');
+    this.name = 'RateLimitRotationError';
+  }
+}
+
+export class KeyPool {
+  private keys: SecretString[];
+  private activeIndex: number = 0;
+  private keyBreakers: Map<number, CircuitBreaker> = new Map();
+  private remainingQuota: Map<number, number> = new Map();
+  private readonly preemptiveThreshold: number;
+
+  constructor(config: KeyPoolConfig) {
+    this.keys = config.keys
+      .filter((k) => k.length > 0)
+      .map((k) => new SecretString(k));
+    this.preemptiveThreshold =
+      config.preemptiveThreshold ?? DEFAULT_PREEMPTIVE_THRESHOLD;
+
+    for (let i = 0; i < this.keys.length; i++) {
+      this.keyBreakers.set(
+        i,
+        new CircuitBreaker({
+          name: \`key-pool-\${i}\`,
+          failureThreshold: 3,
+          resetTimeoutMs: 30_000,
+        }),
+      );
+    }
+
+    if (this.keys.length > 1) {
+      console.error(\`[LLM] KeyPool initialized with \${this.keys.length} keys\`);
+    }
+  }
+
+  get hasKeys(): boolean {
+    return this.keys.length > 0;
+  }
+
+  getActiveKey(): SecretString {
+    return this.keys[this.activeIndex];
+  }
+
+  get activeKeyIndex(): number {
+    return this.activeIndex;
+  }
+
+  get poolSize(): number {
+    return this.keys.length;
+  }
+
+  get exhausted(): boolean {
+    if (this.keys.length === 0) return true;
+    for (let i = 0; i < this.keys.length; i++) {
+      const breaker = this.keyBreakers.get(i)!;
+      if (!breaker.isOpen()) return false;
+    }
+    return true;
+  }
+
+  rotateOnError(): SecretString | null {
+    const breaker = this.keyBreakers.get(this.activeIndex);
+    if (breaker) {
+      breaker.recordFailure();
+    }
+    return this.findNextHealthyKey();
+  }
+
+  rotatePreemptive(): boolean {
+    const previousIndex = this.activeIndex;
+    const remaining = this.remainingQuota.get(previousIndex);
+    if (remaining !== undefined && remaining < this.preemptiveThreshold) {
+      const next = this.findNextHealthyKey();
+      if (next) {
+        console.error(
+          \`[LLM] KeyPool preemptive rotation: key \${previousIndex} remaining=\${remaining} < threshold=\${this.preemptiveThreshold}\`,
+        );
+        return true;
+      }
+    }
+    return false;
+  }
+
+  updateQuota(keyIndex: number, remaining: number): void {
+    this.remainingQuota.set(keyIndex, remaining);
+  }
+
+  getStatus(): {
+    poolSize: number;
+    activeKeyIndex: number;
+    exhausted: boolean;
+    perKeyStatus: KeyStatus[];
+  } {
+    const perKeyStatus: KeyStatus[] = [];
+    for (let i = 0; i < this.keys.length; i++) {
+      perKeyStatus.push({
+        index: i,
+        circuitState: this.keyBreakers.get(i)!.getState(),
+        remainingQuota: this.remainingQuota.get(i) ?? null,
+      });
+    }
+    return {
+      poolSize: this.poolSize,
+      activeKeyIndex: this.activeIndex,
+      exhausted: this.exhausted,
+      perKeyStatus,
+    };
+  }
+
+  private findNextHealthyKey(): SecretString | null {
+    const startIndex = this.activeIndex;
+    for (let offset = 1; offset <= this.keys.length; offset++) {
+      const candidateIndex = (startIndex + offset) % this.keys.length;
+      const breaker = this.keyBreakers.get(candidateIndex)!;
+      if (!breaker.isOpen()) {
+        this.activeIndex = candidateIndex;
+        return this.keys[candidateIndex];
+      }
+    }
+    console.error('[LLM] KeyPool: all keys exhausted — no healthy key available');
+    return null;
+  }
+}
+
+// =============================================================================
+// KEY LOADING
+// =============================================================================
+
+export interface KeyPoolFiles {
+  openai: KeyPoolConfig;
+  anthropic: KeyPoolConfig;
+}
+
+export function loadKeyPoolConfig(): KeyPoolFiles {
+  const keysFilePath = path.join(
+    homedir(),
+    '.${config.id}',
+    'keys.json',
+  );
+
+  let openaiKeys: string[] = [];
+  let anthropicKeys: string[] = [];
+
+  try {
+    if (fs.existsSync(keysFilePath)) {
+      const data = JSON.parse(fs.readFileSync(keysFilePath, 'utf-8'));
+      if (data?.openai && Array.isArray(data.openai)) {
+        openaiKeys = data.openai;
+      }
+      if (data?.anthropic && Array.isArray(data.anthropic)) {
+        anthropicKeys = data.anthropic;
+      }
+    }
+  } catch {
+    console.error('[LLM] Could not read keys.json, falling back to env vars');
+  }
+
+  // Fallback: environment variables
+  if (openaiKeys.length === 0) {
+    const envKey = process.env.OPENAI_API_KEY || '';
+    if (envKey) openaiKeys = [envKey];
+  }
+  if (anthropicKeys.length === 0) {
+    const envKey = process.env.ANTHROPIC_API_KEY || '';
+    if (envKey) anthropicKeys = [envKey];
+  }
+
+  return {
+    openai: { keys: openaiKeys },
+    anthropic: { keys: anthropicKeys },
+  };
+}
+`;
+}
+//# sourceMappingURL=llm-key-pool.js.map

package/dist/templates/llm-key-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-key-pool.js","sourceRoot":"","sources":["../../src/templates/llm-key-pool.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAmB;IACpD,OAAO;;;;;WAKE,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiKZ,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoChB,CAAC;AACF,CAAC"}

package/dist/templates/llm-types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generate the LLM types file for a new agent.
+ * Contains all types, LLMError class, and SecretString class.
+ */
+export declare function generateLLMTypes(): string;