@covibes/zeroshot 5.4.0 → 5.4.1

package/src/providers/anthropic/index.js

@@ -1,204 +0,0 @@
-const BaseProvider = require('../base-provider');
-const { getClaudeCommand, loadSettings } = require('../../../lib/settings');
-const { commandExists, getCommandPath, getHelpOutput } = require('../../../lib/provider-detection');
-const { resolveClaudeAuth } = require('../../../lib/settings/claude-auth');
-const { buildCommand } = require('./cli-builder');
-const { parseEvent } = require('./output-parser');
-const {
-  MODEL_CATALOG,
-  LEVEL_MAPPING,
-  DEFAULT_LEVEL,
-  DEFAULT_MAX_LEVEL,
-  DEFAULT_MIN_LEVEL,
-} = require('./models');
-
-const warned = new Set();
-
-class AnthropicProvider extends BaseProvider {
-  constructor() {
-    super({ name: 'claude', displayName: 'Claude', cliCommand: 'claude' });
-    this._cliFeatures = null;
-  }
-
-  // SDK not implemented - uses CLI only
-  // See BaseProvider for SDK extension point documentation
-
-  isAvailable() {
-    const { command } = getClaudeCommand();
-    return commandExists(command);
-  }
-
-  getCliPath() {
-    const { command } = getClaudeCommand();
-    return getCommandPath(command) || command;
-  }
-
-  getInstallInstructions() {
-    return ['npm install -g @anthropic-ai/claude-code', 'Or (macOS): brew install claude'].join(
-      '\n'
-    );
-  }
-
-  getAuthInstructions() {
-    return 'claude login';
-  }
-
-  getCliFeatures() {
-    if (this._cliFeatures) return this._cliFeatures;
-
-    const { command, args } = getClaudeCommand();
-    const help = getHelpOutput(command, args);
-    const unknown = !help;
-
-    const features = {
-      supportsOutputFormat: unknown ? true : /--output-format/.test(help),
-      supportsStreamJson: unknown ? true : /stream-json/.test(help),
-      supportsJsonSchema: unknown ? true : /--json-schema/.test(help),
-      supportsAutoApprove: unknown ? true : /--dangerously-skip-permissions/.test(help),
-      supportsIncludePartials: unknown ? true : /--include-partial-messages/.test(help),
-      supportsVerbose: unknown ? true : /--verbose/.test(help),
-      supportsModel: unknown ? true : /--model/.test(help),
-      unknown,
-    };
-
-    this._cliFeatures = features;
-    return features;
-  }
-
-  getCredentialPaths() {
-    return ['~/.claude'];
-  }
-
-  /**
-   * Resolve authentication environment variables for Claude CLI.
-   * Handles Bedrock, API key, and OAuth authentication.
-   * @returns {Object} Environment variables for authentication
-   */
-  resolveAuthEnv() {
-    const settings = loadSettings();
-    return resolveClaudeAuth(settings);
-  }
-
-  buildCommand(context, options) {
-    const { command, args } = getClaudeCommand();
-    const cliFeatures = options.cliFeatures || {};
-
-    if (options.jsonSchema && options.outputFormat !== 'json' && !options.strictSchema) {
-      this._warnOnce(
-        'claude-jsonschema-stream',
-        'jsonSchema requested with stream output; schema enforcement will be post-validated.'
-      );
-    }
-
-    if (
-      options.jsonSchema &&
-      options.outputFormat === 'json' &&
-      cliFeatures.supportsJsonSchema === false
-    ) {
-      this._warnOnce(
-        'claude-jsonschema-flag',
-        'Claude CLI does not support --json-schema; skipping schema flag.'
-      );
-    }
-
-    if (options.autoApprove && cliFeatures.supportsAutoApprove === false) {
-      this._warnOnce(
-        'claude-auto-approve',
-        'Claude CLI does not support --dangerously-skip-permissions; continuing without auto-approve.'
-      );
-    }
-
-    const authEnv = this.resolveAuthEnv();
-    const resolvedOptions = { ...options, cliFeatures, authEnv };
-
-    return buildCommand(context, resolvedOptions, { command, args });
-  }
-
-  parseEvent(line) {
-    return parseEvent(line);
-  }
-
-  getModelCatalog() {
-    return MODEL_CATALOG;
-  }
-
-  getLevelMapping() {
-    return LEVEL_MAPPING;
-  }
-
-  getDefaultLevel() {
-    return DEFAULT_LEVEL;
-  }
-
-  getDefaultMaxLevel() {
-    return DEFAULT_MAX_LEVEL;
-  }
-
-  getDefaultMinLevel() {
-    return DEFAULT_MIN_LEVEL;
-  }
-
-  _warnOnce(key, message) {
-    if (warned.has(key)) return;
-    warned.add(key);
-    console.warn(`⚠️ ${message}`);
-  }
-
-  /**
-   * Get default settings including Claude-specific auth fields
-   * @override
-   */
-  getDefaultSettings() {
-    return {
-      ...super.getDefaultSettings(),
-      // Authentication (optional persistent storage)
-      anthropicApiKey: null, // sk-ant-* key
-      bedrockApiKey: null, // AWS_BEARER_TOKEN_BEDROCK value
-      bedrockRegion: null, // AWS_REGION for Bedrock
-    };
-  }
-
-  /**
-   * Validate Claude-specific settings including auth fields
-   * @override
-   */
-  validateSettings(settings) {
-    // First validate base provider settings (levels, etc.)
-    const baseError = super.validateSettings(settings);
-    if (baseError) return baseError;
-
-    // Claude-specific auth field validation
-    const {
-      isValidAnthropicKey,
-      ANTHROPIC_KEY_PREFIX,
-    } = require('../../../lib/settings/claude-auth');
-
-    // Validate string-or-null fields
-    for (const field of ['anthropicApiKey', 'bedrockApiKey', 'bedrockRegion']) {
-      if (
-        settings[field] !== undefined &&
-        settings[field] !== null &&
-        typeof settings[field] !== 'string'
-      ) {
-        return `providerSettings.claude.${field} must be a string or null`;
-      }
-    }
-
-    // Additional prefix validation for Anthropic API key
-    if (settings.anthropicApiKey && !isValidAnthropicKey(settings.anthropicApiKey)) {
-      return `providerSettings.claude.anthropicApiKey must start with ${ANTHROPIC_KEY_PREFIX}`;
-    }
-
-    return null;
-  }
-
-  /**
-   * Get Claude-specific setting field names
-   * @override
-   */
-  getSettingsFields() {
-    return [...super.getSettingsFields(), 'anthropicApiKey', 'bedrockApiKey', 'bedrockRegion'];
-  }
-}
-
-module.exports = AnthropicProvider;

package/src/providers/anthropic/models.js

@@ -1,23 +0,0 @@
-const MODEL_CATALOG = {
-  haiku: { rank: 1 },
-  sonnet: { rank: 2 },
-  opus: { rank: 3 },
-};
-
-const LEVEL_MAPPING = {
-  level1: { rank: 1, model: 'haiku' },
-  level2: { rank: 2, model: 'sonnet' },
-  level3: { rank: 3, model: 'opus' },
-};
-
-const DEFAULT_LEVEL = 'level2';
-const DEFAULT_MAX_LEVEL = 'level3';
-const DEFAULT_MIN_LEVEL = 'level1';
-
-module.exports = {
-  MODEL_CATALOG,
-  LEVEL_MAPPING,
-  DEFAULT_LEVEL,
-  DEFAULT_MAX_LEVEL,
-  DEFAULT_MIN_LEVEL,
-};

package/src/providers/anthropic/output-parser.js

@@ -1,177 +0,0 @@
-/**
- * Stream JSON Parser for Claude Code output
- */
-
-/**
- * Parse result event type
- * @param {Object} event
- * @returns {Object}
- */
-function parseResultEvent(event) {
-  const usage = event.usage || {};
-  return {
-    type: 'result',
-    success: event.subtype === 'success',
-    result: event.result,
-    error: event.is_error ? event.result : null,
-    cost: event.total_cost_usd,
-    duration: event.duration_ms,
-    inputTokens: usage.input_tokens || 0,
-    outputTokens: usage.output_tokens || 0,
-    cacheReadInputTokens: usage.cache_read_input_tokens || 0,
-    cacheCreationInputTokens: usage.cache_creation_input_tokens || 0,
-    modelUsage: event.modelUsage || null,
-  };
-}
-
-/**
- * Parse a single JSON line and extract displayable content
- * @param {string} line
- * @returns {Object|null}
- */
-function parseEvent(line) {
-  const trimmed = line.trim();
-  if (!trimmed || !trimmed.startsWith('{') || !trimmed.endsWith('}')) {
-    return null;
-  }
-
-  let event;
-  try {
-    event = JSON.parse(trimmed);
-  } catch {
-    return null;
-  }
-
-  if (event.type === 'stream_event' && event.event) {
-    return parseStreamEvent(event.event);
-  }
-
-  if (event.type === 'assistant' && event.message?.content) {
-    return parseAssistantMessage(event.message);
-  }
-
-  if (event.type === 'user' && event.message?.content) {
-    return parseUserMessage(event.message);
-  }
-
-  if (event.type === 'result') {
-    return parseResultEvent(event);
-  }
-
-  if (event.type === 'system') {
-    return null;
-  }
-
-  return null;
-}
-
-function parseStreamEvent(inner) {
-  if (inner.type === 'content_block_delta' && inner.delta) {
-    const delta = inner.delta;
-
-    if (delta.type === 'text_delta' && delta.text) {
-      return {
-        type: 'text',
-        text: delta.text,
-      };
-    }
-
-    if (delta.type === 'thinking_delta' && delta.thinking) {
-      return {
-        type: 'thinking',
-        text: delta.thinking,
-      };
-    }
-  }
-
-  return null;
-}
-
-function parseAssistantMessage(message) {
-  const results = [];
-
-  for (const block of message.content) {
-    // Handle text content blocks (CRITICAL for Haiku/weaker models that return JSON in text)
-    // Issue #52: Haiku returns JSON in type:text blocks, not in result wrapper
-    if (block.type === 'text' && block.text) {
-      results.push({
-        type: 'text',
-        text: block.text,
-      });
-    }
-
-    if (block.type === 'tool_use') {
-      results.push({
-        type: 'tool_call',
-        toolName: block.name,
-        toolId: block.id,
-        input: block.input,
-      });
-    }
-
-    if (block.type === 'thinking' && block.thinking) {
-      results.push({
-        type: 'thinking',
-        text: block.thinking,
-      });
-    }
-  }
-
-  if (results.length === 1) {
-    return results[0];
-  }
-
-  if (results.length > 1) {
-    return results;
-  }
-
-  return null;
-}
-
-function parseUserMessage(message) {
-  const results = [];
-
-  for (const block of message.content) {
-    if (block.type === 'tool_result') {
-      results.push({
-        type: 'tool_result',
-        toolId: block.tool_use_id,
-        content: typeof block.content === 'string' ? block.content : JSON.stringify(block.content),
-        isError: block.is_error || false,
-      });
-    }
-  }
-
-  if (results.length === 1) {
-    return results[0];
-  }
-
-  if (results.length > 1) {
-    return results;
-  }
-
-  return null;
-}
-
-function parseChunk(chunk) {
-  const events = [];
-  const lines = chunk.split('\n');
-
-  for (const line of lines) {
-    const event = parseEvent(line);
-    if (event) {
-      if (Array.isArray(event)) {
-        events.push(...event);
-      } else {
-        events.push(event);
-      }
-    }
-  }
-
-  return events;
-}
-
-module.exports = {
-  parseEvent,
-  parseChunk,
-};

package/src/providers/base-provider.js

@@ -1,251 +0,0 @@
-/**
- * BaseProvider - Abstract provider interface
- *
- * All providers support two execution paths:
- * 1. SDK (fast) - Direct API calls using provider's SDK (requires API key)
- * 2. CLI (slower) - Spawns provider's CLI tool (uses OAuth/login auth)
- *
- * Use callSimple() for simple prompts - it tries SDK first, falls back to CLI.
- */
-class BaseProvider {
-  constructor(options = {}) {
-    this.name = options.name || 'base';
-    this.displayName = options.displayName || 'Base';
-    this.cliCommand = options.cliCommand || null;
-  }
-
-  // ============================================================================
-  // SDK SUPPORT (Future Extension Point)
-  // ============================================================================
-  //
-  // SDK support is NOT IMPLEMENTED. These methods exist for future extension.
-  // Currently, all providers use CLI (claude, codex, gemini) for execution.
-  //
-  // To add SDK support for a provider:
-  // 1. Override getSDKEnvVar() to return the API key env var
-  // 2. Override callSDK() to implement the actual API call
-  // 3. The callSimple() method will then work automatically
-  //
-  // ============================================================================
-
-  /**
-   * Get the environment variable name for the API key
-   * @returns {string} Environment variable name (e.g., 'ANTHROPIC_API_KEY')
-   */
-  getSDKEnvVar() {
-    throw new Error(`${this.name}: SDK not implemented. Use CLI instead.`);
-  }
-
-  /**
-   * Check if SDK is configured (API key is set)
-   * @returns {boolean} True if API key is available
-   */
-  isSDKConfigured() {
-    try {
-      const envVar = this.getSDKEnvVar();
-      return !!process.env[envVar];
-    } catch {
-      // getSDKEnvVar() throws if not implemented
-      return false;
-    }
-  }
-
-  /**
-   * Make a simple API call via SDK (fast path)
-   * NOT IMPLEMENTED - exists for future extension.
-   *
-   * @param {string} _prompt - The prompt to send
-   * @param {Object} _options - Call options
-   * @returns {Promise<{success: boolean, text: string, usage?: Object, error?: string}>}
-   */
-  callSDK(_prompt, _options) {
-    return Promise.reject(new Error(`${this.name}: SDK not implemented. Use CLI instead.`));
-  }
-
-  /**
-   * Make a simple API call via SDK
-   * NOT IMPLEMENTED - exists for future extension.
-   *
-   * @param {string} _prompt - The prompt to send
-   * @param {Object} _options - Call options
-   * @returns {Promise<{success: boolean, text: string, usage?: Object, error?: string}>}
-   */
-  callSimple(_prompt, _options = {}) {
-    return Promise.reject(new Error(`${this.name}: SDK not implemented. Use CLI instead.`));
-  }
-
-  isAvailable() {
-    throw new Error('Not implemented');
-  }
-
-  getCliPath() {
-    throw new Error('Not implemented');
-  }
-
-  getInstallInstructions() {
-    throw new Error('Not implemented');
-  }
-
-  getAuthInstructions() {
-    throw new Error('Not implemented');
-  }
-
-  getCliFeatures() {
-    throw new Error('Not implemented');
-  }
-
-  getCredentialPaths() {
-    return [];
-  }
-
-  buildCommand(_context, _options) {
-    throw new Error('Not implemented');
-  }
-
-  parseEvent(_line) {
-    throw new Error('Not implemented');
-  }
-
-  getModelCatalog() {
-    throw new Error('Not implemented');
-  }
-
-  getLevelMapping() {
-    throw new Error('Not implemented');
-  }
-
-  resolveModelSpec(level, overrides = {}) {
-    const mapping = this.getLevelMapping();
-    const base = mapping[level] || mapping[this.getDefaultLevel()];
-    if (!base) {
-      throw new Error(`Unknown level "${level}" for provider "${this.name}"`);
-    }
-    const override = overrides[level] || {};
-    return {
-      level,
-      model: override.model || base.model,
-      reasoningEffort: override.reasoningEffort || base.reasoningEffort,
-    };
-  }
-
-  validateLevel(level, minLevel, maxLevel) {
-    const mapping = this.getLevelMapping();
-    const rank = (key) => mapping[key]?.rank;
-
-    if (!mapping[level]) {
-      throw new Error(`Invalid level "${level}" for provider "${this.name}"`);
-    }
-
-    if (minLevel && !mapping[minLevel]) {
-      throw new Error(`Invalid minLevel "${minLevel}" for provider "${this.name}"`);
-    }
-
-    if (maxLevel && !mapping[maxLevel]) {
-      throw new Error(`Invalid maxLevel "${maxLevel}" for provider "${this.name}"`);
-    }
-
-    if (minLevel && maxLevel && rank(minLevel) > rank(maxLevel)) {
-      throw new Error(
-        `minLevel "${minLevel}" exceeds maxLevel "${maxLevel}" for provider "${this.name}"`
-      );
-    }
-
-    if (maxLevel && rank(level) > rank(maxLevel)) {
-      throw new Error(
-        `Level "${level}" exceeds maxLevel "${maxLevel}" for provider "${this.name}"`
-      );
-    }
-
-    if (minLevel && rank(level) < rank(minLevel)) {
-      throw new Error(
-        `Level "${level}" is below minLevel "${minLevel}" for provider "${this.name}"`
-      );
-    }
-
-    return level;
-  }
-
-  validateModelId(modelId) {
-    const catalog = this.getModelCatalog();
-    if (modelId && !catalog[modelId]) {
-      throw new Error(`Invalid model "${modelId}" for provider "${this.name}"`);
-    }
-    return modelId;
-  }
-
-  /**
-   * Resolve a model name to its CLI-compatible identifier.
-   * Override in provider implementations that need model ID transformation
-   * (e.g., Anthropic Bedrock mapping).
-   * @param {string} model - Model name (e.g., 'opus', 'sonnet')
-   * @param {Object} _authEnv - Authentication environment variables
-   * @returns {string} CLI-compatible model identifier
-   */
-  resolveCliModel(model, _authEnv = {}) {
-    return model;
-  }
-
-  getDefaultLevel() {
-    throw new Error('Not implemented');
-  }
-
-  /**
-   * Get default settings for this provider
-   * Override in provider implementations to provide provider-specific defaults
-   * @returns {Object} Default settings object
-   */
-  getDefaultSettings() {
-    return {
-      maxLevel: this.getDefaultMaxLevel?.() || 'level3',
-      minLevel: this.getDefaultMinLevel?.() || 'level1',
-      defaultLevel: this.getDefaultLevel() || 'level2',
-      levelOverrides: {},
-    };
-  }
-
-  /**
-   * Validate provider-specific settings
-   * Override in provider implementations to add custom validation
-   * @param {Object} settings - Settings object to validate
-   * @returns {string|null} Error message if invalid, null if valid
-   */
-  validateSettings(settings) {
-    if (typeof settings !== 'object' || settings === null) {
-      return `providerSettings.${this.name} must be an object`;
-    }
-
-    // Validate level fields
-    const levelMapping = this.getLevelMapping();
-    const validLevels = Object.keys(levelMapping);
-
-    if (settings.maxLevel && !validLevels.includes(settings.maxLevel)) {
-      return `Invalid maxLevel for ${this.name}: ${settings.maxLevel}`;
-    }
-    if (settings.minLevel && !validLevels.includes(settings.minLevel)) {
-      return `Invalid minLevel for ${this.name}: ${settings.minLevel}`;
-    }
-    if (settings.defaultLevel && !validLevels.includes(settings.defaultLevel)) {
-      return `Invalid defaultLevel for ${this.name}: ${settings.defaultLevel}`;
-    }
-
-    if (
-      settings.levelOverrides &&
-      (typeof settings.levelOverrides !== 'object' || Array.isArray(settings.levelOverrides))
-    ) {
-      return `levelOverrides for ${this.name} must be an object`;
-    }
-
-    return null;
-  }
-
-  /**
-   * Get the list of setting field names specific to this provider
-   * Override in provider implementations to declare custom fields
-   * @returns {string[]} Array of field names
-   */
-  getSettingsFields() {
-    return ['maxLevel', 'minLevel', 'defaultLevel', 'levelOverrides'];
-  }
-}
-
-module.exports = BaseProvider;

package/src/providers/capabilities.js

@@ -1,60 +0,0 @@
-const { normalizeProviderName } = require('../../lib/provider-names');
-
-const CAPABILITIES = {
-  claude: {
-    dockerIsolation: true,
-    worktreeIsolation: true,
-    mcpServers: true,
-    jsonSchema: true,
-    streamJson: true,
-    thinkingMode: true,
-    reasoningEffort: false,
-  },
-  codex: {
-    dockerIsolation: true,
-    worktreeIsolation: true,
-    mcpServers: true,
-    jsonSchema: true,
-    streamJson: true,
-    thinkingMode: true,
-    reasoningEffort: true,
-  },
-  gemini: {
-    dockerIsolation: true,
-    worktreeIsolation: true,
-    mcpServers: true,
-    jsonSchema: 'experimental',
-    streamJson: true,
-    thinkingMode: true,
-    reasoningEffort: false,
-  },
-  opencode: {
-    dockerIsolation: true,
-    worktreeIsolation: true,
-    mcpServers: true,
-    jsonSchema: 'experimental',
-    streamJson: true,
-    thinkingMode: true,
-    reasoningEffort: true,
-  },
-};
-
-function checkCapability(provider, capability) {
-  const caps = CAPABILITIES[normalizeProviderName(provider)];
-  if (!caps) return false;
-  return caps[capability] === true;
-}
-
-function warnIfExperimental(provider, capability) {
-  const normalized = normalizeProviderName(provider);
-  const caps = CAPABILITIES[normalized];
-  if (caps?.[capability] === 'experimental') {
-    console.warn(`⚠️ ${capability} is experimental for ${normalized} and may not work reliably`);
-  }
-}
-
-module.exports = {
-  CAPABILITIES,
-  checkCapability,
-  warnIfExperimental,
-};