@soleri/forge 5.14.0 → 5.14.2

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

@@ -1 +0,0 @@
-{"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/intelligence-loader.d.ts

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

package/dist/templates/intelligence-loader.js

@@ -1,43 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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

package/dist/templates/intelligence-types.js

@@ -1,24 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,7 +0,0 @@
-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

@@ -1,300 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,7 +0,0 @@
-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

@@ -1,211 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

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