@covibes/zeroshot 5.2.0 → 5.3.0

package/src/preflight.js

@@ -2,7 +2,7 @@
  * Preflight Validation - Check all dependencies before starting
  *
  * Validates:
- * - Claude CLI installed and authenticated
+ * - Selected provider CLI installed
  * - gh CLI installed and authenticated (if using issue numbers)
  * - Docker available (if using --docker)
  *
@@ -42,13 +42,15 @@ function formatError(title, detail, recovery) {
 }
 
 /**
- * Check if a command exists
+ * Check if a command exists (cross-platform)
  * @param {string} cmd - Command to check
  * @returns {boolean}
  */
 function commandExists(cmd) {
   try {
-    execSync(`which ${cmd}`, { encoding: 'utf8', stdio: 'pipe' });
+    // Windows uses 'where', Unix uses 'which'
+    const checkCmd = process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`;
+    execSync(checkCmd, { encoding: 'utf8', stdio: 'pipe' });
     return true;
   } catch {
     return false;
@@ -280,57 +282,45 @@ function checkDocker() {
  * @param {boolean} options.requireGit - Whether git repo is required (true if using --worktree)
  * @param {boolean} options.quiet - Suppress success messages
  * @param {string} options.claudeCommand - Custom Claude command (from settings)
+ * @param {string} options.provider - Provider override
  * @returns {ValidationResult}
  */
 function runPreflight(options = {}) {
   const errors = [];
   const warnings = [];
 
-  // Get configured Claude command (supports custom commands like 'ccr code')
-  const { getClaudeCommand } = require('../lib/settings.js');
-  const { command, args } = getClaudeCommand();
-  const claudeCommand = options.claudeCommand || [command, ...args].join(' ');
+  const { loadSettings, getClaudeCommand } = require('../lib/settings.js');
+  const { normalizeProviderName } = require('../lib/provider-names');
+  const settings = loadSettings();
+  const providerName = normalizeProviderName(
+    options.provider || settings.defaultProvider || 'claude'
+  );
 
-  // 1. Check Claude CLI installation
-  const claude = getClaudeVersion(claudeCommand);
-  if (!claude.installed) {
-    errors.push(
-      formatError(
-        'Claude command not available',
-        claude.error,
-        claudeCommand === 'claude'
-          ? [
-              'Install Claude CLI: npm install -g @anthropic-ai/claude-code',
-              'Or: brew install claude (macOS)',
-              'Then run: claude --version',
-            ]
-          : [
-              `Command '${claudeCommand}' not found`,
-              'Check settings: zeroshot settings',
-              'Update claudeCommand: zeroshot settings set claudeCommand "your-command"',
-              'Or install the missing command',
-            ]
-      )
-    );
-  } else {
-    // 2. Check Claude CLI authentication
-    const auth = checkClaudeAuth();
-    if (!auth.authenticated) {
+  if (providerName === 'claude') {
+    const { command, args } = getClaudeCommand();
+    const claudeCommand = options.claudeCommand || [command, ...args].join(' ');
+
+    const claude = getClaudeVersion(claudeCommand);
+    if (!claude.installed) {
       errors.push(
         formatError(
-          'Claude CLI not authenticated',
-          auth.error,
-          [
-            'Run: claude login',
-            'Follow the browser prompts to authenticate',
-            `Config directory: ${auth.configDir}`,
-          ]
+          'Claude command not available',
+          claude.error,
+          claudeCommand === 'claude'
+            ? [
+                'Install Claude CLI: npm install -g @anthropic-ai/claude-code',
+                'Or: brew install claude (macOS)',
+                'Then run: claude --version',
+              ]
+            : [
+                `Command '${claudeCommand}' not found`,
+                'Check settings: zeroshot settings',
+                'Update claudeCommand: zeroshot settings set claudeCommand "your-command"',
+                'Or install the missing command',
+              ]
         )
       );
-    }
-
-    // Check version (warn if old)
-    if (claude.version) {
+    } else if (claude.version) {
       const [major, minor] = claude.version.split('.').map(Number);
       if (major < 1 || (major === 1 && minor < 0)) {
         warnings.push(
@@ -338,21 +328,45 @@ function runPreflight(options = {}) {
         );
       }
     }
-  }
 
-  // 3. Check if running as root (blocks --dangerously-skip-permissions)
-  if (process.getuid && process.getuid() === 0) {
+    // Claude CLI refuses --dangerously-skip-permissions when running as root.
+    if (process.getuid && process.getuid() === 0) {
+      errors.push(
+        formatError(
+          'Running as root',
+          'Claude CLI refuses --dangerously-skip-permissions flag when running as root (UID 0)',
+          [
+            'Run as non-root user in Docker: docker run --user 1000:1000 ...',
+            'Or create non-root user: adduser testuser && su - testuser',
+            'Or use existing node user: docker run --user node ...',
+            'Security: Claude CLI blocks this flag as root to prevent privilege escalation',
+          ]
+        )
+      );
+    }
+  } else if (providerName === 'codex') {
+    if (!commandExists('codex')) {
+      errors.push(
+        formatError('Codex CLI not available', 'Command "codex" not installed', [
+          'Install Codex CLI: npm install -g @openai/codex',
+          'Then run: codex --version',
+        ])
+      );
+    }
+  } else if (providerName === 'gemini') {
+    if (!commandExists('gemini')) {
+      errors.push(
+        formatError('Gemini CLI not available', 'Command "gemini" not installed', [
+          'Install Gemini CLI: npm install -g @google/gemini-cli',
+          'Then run: gemini --version',
+        ])
+      );
+    }
+  } else {
     errors.push(
-      formatError(
-        'Running as root',
-        'Claude CLI refuses --dangerously-skip-permissions flag when running as root (UID 0)',
-        [
-          'Run as non-root user in Docker: docker run --user 1000:1000 ...',
-          'Or create non-root user: adduser testuser && su - testuser',
-          'Or use existing node user: docker run --user node ...',
-          'Security: Claude CLI blocks this flag as root to prevent privilege escalation',
-        ]
-      )
+      formatError('Unknown provider', `Provider "${providerName}" is not supported`, [
+        'Use claude, codex, or gemini',
+      ])
     );
   }
 
@@ -361,26 +375,18 @@ function runPreflight(options = {}) {
     const gh = checkGhAuth();
     if (!gh.installed) {
       errors.push(
-        formatError(
-          'GitHub CLI (gh) not installed',
-          'Required for fetching issues by number',
-          [
-            'Install: brew install gh (macOS) or apt install gh (Linux)',
-            'Or download from: https://cli.github.com/',
-          ]
-        )
+        formatError('GitHub CLI (gh) not installed', 'Required for fetching issues by number', [
+          'Install: brew install gh (macOS) or apt install gh (Linux)',
+          'Or download from: https://cli.github.com/',
+        ])
       );
     } else if (!gh.authenticated) {
       errors.push(
-        formatError(
-          'GitHub CLI (gh) not authenticated',
-          gh.error,
-          [
-            'Run: gh auth login',
-            'Select GitHub.com, HTTPS, and authenticate via browser',
-            'Then verify: gh auth status',
-          ]
-        )
+        formatError('GitHub CLI (gh) not authenticated', gh.error, [
+          'Run: gh auth login',
+          'Select GitHub.com, HTTPS, and authenticate via browser',
+          'Then verify: gh auth status',
+        ])
       );
     }
   }
@@ -415,15 +421,11 @@ function runPreflight(options = {}) {
     }
     if (!isGitRepo) {
       errors.push(
-        formatError(
-          'Not in a git repository',
-          'Worktree isolation requires a git repository',
-          [
-            'Run from within a git repository',
-            'Or use --docker instead of --worktree for non-git directories',
-            'Initialize a repo with: git init',
-          ]
-        )
+        formatError('Not in a git repository', 'Worktree isolation requires a git repository', [
+          'Run from within a git repository',
+          'Or use --docker instead of --worktree for non-git directories',
+          'Initialize a repo with: git init',
+        ])
       );
     }
   }
@@ -442,6 +444,7 @@ function runPreflight(options = {}) {
  * @param {boolean} options.requireDocker - Whether Docker is required
  * @param {boolean} options.requireGit - Whether git repo is required
  * @param {boolean} options.quiet - Suppress success messages
+ * @param {string} options.provider - Provider override
  */
 function requirePreflight(options = {}) {
   const result = runPreflight(options);

package/src/providers/anthropic/cli-builder.js

@@ -0,0 +1,45 @@
+function buildCommand(context, options = {}, commandConfig = {}) {
+  const { modelSpec, outputFormat, jsonSchema, autoApprove, cliFeatures = {} } = options;
+
+  const command = commandConfig.command || 'claude';
+  const extraArgs = commandConfig.args || [];
+  const args = [...extraArgs, '--print', '--input-format', 'text'];
+
+  if (outputFormat && cliFeatures.supportsOutputFormat !== false) {
+    args.push('--output-format', outputFormat);
+  }
+
+  if (outputFormat === 'stream-json') {
+    if (cliFeatures.supportsVerbose !== false) {
+      args.push('--verbose');
+    }
+    if (cliFeatures.supportsIncludePartials !== false) {
+      args.push('--include-partial-messages');
+    }
+  }
+
+  if (jsonSchema && outputFormat === 'json' && cliFeatures.supportsJsonSchema !== false) {
+    const schemaString = typeof jsonSchema === 'string' ? jsonSchema : JSON.stringify(jsonSchema);
+    args.push('--json-schema', schemaString);
+  }
+
+  if (modelSpec?.model && cliFeatures.supportsModel !== false) {
+    args.push('--model', modelSpec.model);
+  }
+
+  if (autoApprove && cliFeatures.supportsAutoApprove !== false) {
+    args.push('--dangerously-skip-permissions');
+  }
+
+  args.push(context);
+
+  return {
+    binary: command,
+    args,
+    env: {},
+  };
+}
+
+module.exports = {
+  buildCommand,
+};

package/src/providers/anthropic/index.js

@@ -0,0 +1,134 @@
+const BaseProvider = require('../base-provider');
+const { getClaudeCommand } = require('../../../lib/settings');
+const { commandExists, getCommandPath, getHelpOutput } = require('../../../lib/provider-detection');
+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'];
+  }
+
+  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.'
+      );
+    }
+
+    return buildCommand(context, { ...options, cliFeatures }, { 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}`);
+  }
+}
+
+module.exports = AnthropicProvider;

package/src/providers/anthropic/models.js

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

@@ -0,0 +1,159 @@
+/**
+ * Stream JSON Parser for Claude Code output
+ */
+
+/**
+ * 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') {
+    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,
+    };
+  }
+
+  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) {
+    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,
+};