@covibes/zeroshot 5.2.1 → 5.4.0

package/src/process-metrics.js

@@ -13,7 +13,7 @@
  * - macOS: ps + lsof
  */
 
-const { execSync } = require('child_process');
+const { execSync } = require('./lib/safe-exec'); // Enforces timeouts
 const fs = require('fs');
 
 const PLATFORM = process.platform;
@@ -56,41 +56,13 @@ function getChildPids(pid) {
   const children = [];
 
   try {
-    if (PLATFORM === 'darwin') {
-      // macOS: Use pgrep with -P flag
-      const output = execSync(`pgrep -P ${escapeShell(String(pid))} 2>/dev/null`, {
-        encoding: 'utf8',
-        timeout: 2000,
-      });
-      const pids = output.trim().split('\n').filter(Boolean).map(Number);
-      children.push(...pids);
-
-      // Recursively get grandchildren
-      for (const childPid of pids) {
-        children.push(...getChildPids(childPid));
-      }
-    } else {
-      // Linux: Read /proc/{pid}/task/{tid}/children
-      const taskPath = `/proc/${pid}/task`;
-      if (fs.existsSync(taskPath)) {
-        const tids = fs.readdirSync(taskPath);
-        for (const tid of tids) {
-          const childrenPath = `/proc/${pid}/task/${tid}/children`;
-          if (fs.existsSync(childrenPath)) {
-            const childPids = fs.readFileSync(childrenPath, 'utf8')
-              .trim()
-              .split(/\s+/)
-              .filter(Boolean)
-              .map(Number);
-            children.push(...childPids);
-
-            // Recursively get grandchildren
-            for (const childPid of childPids) {
-              children.push(...getChildPids(childPid));
-            }
-          }
-        }
-      }
+    const childPids =
+      PLATFORM === 'darwin' ? collectDarwinChildPids(pid) : collectLinuxChildPids(pid);
+    children.push(...childPids);
+
+    // Recursively get grandchildren
+    for (const childPid of childPids) {
+      children.push(...getChildPids(childPid));
     }
   } catch {
     // Ignore errors (process may have exited)
@@ -99,6 +71,45 @@ function getChildPids(pid) {
   return [...new Set(children)]; // Dedupe
 }
 
+function collectDarwinChildPids(pid) {
+  const output = execSync(`pgrep -P ${escapeShell(String(pid))} 2>/dev/null`, {
+    encoding: 'utf8',
+    timeout: 2000,
+  });
+
+  return output.trim().split('\n').filter(Boolean).map(Number);
+}
+
+function collectLinuxChildPids(pid) {
+  const taskPath = `/proc/${pid}/task`;
+  if (!fs.existsSync(taskPath)) {
+    return [];
+  }
+
+  const tids = fs.readdirSync(taskPath);
+  const childPids = [];
+
+  for (const tid of tids) {
+    const childrenPath = `/proc/${pid}/task/${tid}/children`;
+    childPids.push(...readChildPidFile(childrenPath));
+  }
+
+  return childPids;
+}
+
+function readChildPidFile(childrenPath) {
+  if (!fs.existsSync(childrenPath)) {
+    return [];
+  }
+
+  const raw = fs.readFileSync(childrenPath, 'utf8').trim();
+  if (!raw) {
+    return [];
+  }
+
+  return raw.split(/\s+/).filter(Boolean).map(Number);
+}
+
 /**
  * Get metrics for a single process (Linux)
  * @param {number} pid - Process ID
@@ -187,17 +198,20 @@ function getNetworkStateLinux(pid) {
     hasActivity: false,
     sendQueueBytes: 0,
     recvQueueBytes: 0,
-    bytesSent: 0,      // Cumulative bytes sent across all sockets
-    bytesReceived: 0,  // Cumulative bytes received across all sockets
+    bytesSent: 0, // Cumulative bytes sent across all sockets
+    bytesReceived: 0, // Cumulative bytes received across all sockets
   };
 
   try {
     // Use ss -tip to get extended TCP info with bytes_sent/bytes_received
     // -t = TCP only, -i = show internal TCP info, -p = show process
-    const output = execSync(`ss -tip 2>/dev/null | grep -A1 "pid=${escapeShell(String(pid))}," || true`, {
-      encoding: 'utf8',
-      timeout: 3000,
-    });
+    const output = execSync(
+      `ss -tip 2>/dev/null | grep -A1 "pid=${escapeShell(String(pid))}," || true`,
+      {
+        encoding: 'utf8',
+        timeout: 3000,
+      }
+    );
 
     if (!output.trim()) {
       return result;
@@ -261,8 +275,8 @@ function getNetworkStateDarwin(pid) {
     hasActivity: false,
     sendQueueBytes: 0,
     recvQueueBytes: 0,
-    bytesSent: 0,      // Not available on macOS without root/dtrace
-    bytesReceived: 0,  // Not available on macOS without root/dtrace
+    bytesSent: 0, // Not available on macOS without root/dtrace
+    bytesReceived: 0, // Not available on macOS without root/dtrace
   };
 
   try {
@@ -281,7 +295,7 @@ function getNetworkStateDarwin(pid) {
     for (const line of lines) {
       const parts = line.split(/\s+/);
       // Look for ESTABLISHED connections
-      if (parts.includes('ESTABLISHED') || parts.some(p => p.includes('->'))) {
+      if (parts.includes('ESTABLISHED') || parts.some((p) => p.includes('->'))) {
         result.established++;
         result.hasActivity = true; // lsof doesn't show queue sizes, assume activity
       }
@@ -334,14 +348,21 @@ async function getProcessMetricsLinuxAggregated(pid, samplePeriodMs) {
       memoryMB: 0,
       state: 'X',
       threads: 0,
-      network: { established: 0, hasActivity: false, sendQueueBytes: 0, recvQueueBytes: 0, bytesSent: 0, bytesReceived: 0 },
+      network: {
+        established: 0,
+        hasActivity: false,
+        sendQueueBytes: 0,
+        recvQueueBytes: 0,
+        bytesSent: 0,
+        bytesReceived: 0,
+      },
       childCount: 0,
       timestamp: Date.now(),
     };
   }
 
   // Wait for sample period
-  await new Promise(r => setTimeout(r, samplePeriodMs));
+  await new Promise((r) => setTimeout(r, samplePeriodMs));
 
   // Get second CPU sample
   const t1Metrics = {};
@@ -385,7 +406,14 @@ async function getProcessMetricsLinuxAggregated(pid, samplePeriodMs) {
   const cpuPercent = Math.min(100, rawCpuPercent / cpuCores);
 
   // Get network state for all processes
-  let network = { established: 0, hasActivity: false, sendQueueBytes: 0, recvQueueBytes: 0, bytesSent: 0, bytesReceived: 0 };
+  let network = {
+    established: 0,
+    hasActivity: false,
+    sendQueueBytes: 0,
+    recvQueueBytes: 0,
+    bytesSent: 0,
+    bytesReceived: 0,
+  };
   for (const p of Object.keys(t1Metrics)) {
     const netState = getNetworkStateLinux(parseInt(p, 10));
     network.established += netState.established;
@@ -451,7 +479,14 @@ function getProcessMetricsDarwinAggregated(pid) {
   }
 
   // Get network state
-  let network = { established: 0, hasActivity: false, sendQueueBytes: 0, recvQueueBytes: 0, bytesSent: 0, bytesReceived: 0 };
+  let network = {
+    established: 0,
+    hasActivity: false,
+    sendQueueBytes: 0,
+    recvQueueBytes: 0,
+    bytesSent: 0,
+    bytesReceived: 0,
+  };
   for (const p of allPids) {
     const netState = getNetworkStateDarwin(p);
     network.established += netState.established;
@@ -518,13 +553,20 @@ function formatMetrics(metrics) {
  */
 function getStateIcon(state) {
   switch (state) {
-    case 'R': return '🟢'; // Running
-    case 'S': return '🔵'; // Sleeping
-    case 'D': return '🟡'; // Disk wait
-    case 'Z': return '💀'; // Zombie
-    case 'T': return '⏸️'; // Stopped
-    case 'X': return '❌'; // Dead
-    default: return '⚪';
+    case 'R':
+      return '🟢'; // Running
+    case 'S':
+      return '🔵'; // Sleeping
+    case 'D':
+      return '🟡'; // Disk wait
+    case 'Z':
+      return '💀'; // Zombie
+    case 'T':
+      return '⏸️'; // Stopped
+    case 'X':
+      return '❌'; // Dead
+    default:
+      return '⚪';
   }
 }
 

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

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

package/src/providers/anthropic/index.js

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

@@ -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,177 @@
+/**
+ * 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,
+};