@covibes/zeroshot 5.2.1 → 5.3.0

package/lib/settings.js

@@ -7,6 +7,11 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { validateMountConfig, validateEnvPassthrough } = require('./docker-config');
+const {
+  VALID_PROVIDERS,
+  normalizeProviderName,
+  normalizeProviderSettings,
+} = require('./provider-names');
 
 /**
  * Get settings file path (dynamically reads env var for testing)
@@ -14,7 +19,9 @@ const { validateMountConfig, validateEnvPassthrough } = require('./docker-config
  * @returns {string}
  */
 function getSettingsFile() {
-  return process.env.ZEROSHOT_SETTINGS_FILE || path.join(os.homedir(), '.zeroshot', 'settings.json');
+  return (
+    process.env.ZEROSHOT_SETTINGS_FILE || path.join(os.homedir(), '.zeroshot', 'settings.json')
+  );
 }
 
 /**
@@ -28,15 +35,17 @@ const MODEL_HIERARCHY = {
 };
 
 const VALID_MODELS = Object.keys(MODEL_HIERARCHY);
+const LEVEL_RANKS = { level1: 1, level2: 2, level3: 3 };
 
 /**
- * Validate a requested model against the maxModel ceiling
+ * Validate a requested model against the maxModel ceiling and minModel floor
  * @param {string} requestedModel - Model the agent wants to use
  * @param {string} maxModel - Maximum allowed model (cost ceiling)
+ * @param {string|null} minModel - Minimum required model (cost floor)
  * @returns {string} The validated model
- * @throws {Error} If requested model exceeds ceiling
+ * @throws {Error} If requested model exceeds ceiling or falls below floor
  */
-function validateModelAgainstMax(requestedModel, maxModel) {
+function validateModelAgainstMax(requestedModel, maxModel, minModel = null) {
   if (!requestedModel) return maxModel; // Default to ceiling if unspecified
 
   if (!VALID_MODELS.includes(requestedModel)) {
@@ -52,12 +61,50 @@ function validateModelAgainstMax(requestedModel, maxModel) {
         `Either lower agent's model or raise maxModel.`
     );
   }
+
+  if (minModel) {
+    if (!VALID_MODELS.includes(minModel)) {
+      throw new Error(`Invalid minModel "${minModel}". Valid: ${VALID_MODELS.join(', ')}`);
+    }
+    if (MODEL_HIERARCHY[minModel] > MODEL_HIERARCHY[maxModel]) {
+      throw new Error(`minModel "${minModel}" cannot be higher than maxModel "${maxModel}".`);
+    }
+    if (MODEL_HIERARCHY[requestedModel] < MODEL_HIERARCHY[minModel]) {
+      throw new Error(
+        `Agent requests "${requestedModel}" but minModel is "${minModel}". ` +
+          `Either raise agent's model or lower minModel.`
+      );
+    }
+  }
+
   return requestedModel;
 }
 
 // Default settings
 const DEFAULT_SETTINGS = {
   maxModel: 'opus', // Cost ceiling - agents cannot use models above this
+  minModel: null, // Cost floor - agents cannot use models below this (null = no minimum)
+  defaultProvider: 'claude',
+  providerSettings: {
+    claude: {
+      maxLevel: 'level3',
+      minLevel: 'level1',
+      defaultLevel: 'level2',
+      levelOverrides: {},
+    },
+    codex: {
+      maxLevel: 'level3',
+      minLevel: 'level1',
+      defaultLevel: 'level2',
+      levelOverrides: {},
+    },
+    gemini: {
+      maxLevel: 'level3',
+      minLevel: 'level1',
+      defaultLevel: 'level2',
+      levelOverrides: {},
+    },
+  },
   defaultConfig: 'conductor-bootstrap',
   defaultDocker: false,
   strictSchema: true, // true = reliable json output (default), false = live streaming (may crash - see bold-meadow-11)
@@ -70,7 +117,7 @@ const DEFAULT_SETTINGS = {
   // Example: 'ccr code' for claude-code-router integration
   claudeCommand: 'claude',
   // Docker isolation mounts - preset names or {host, container, readonly?} objects
-  // Valid presets: gh, git, ssh, aws, azure, kube, terraform, gcloud
+  // Valid presets: gh, git, ssh, aws, azure, kube, terraform, gcloud, claude, codex, gemini
   dockerMounts: ['gh', 'git', 'ssh'],
   // Extra env vars to pass to Docker container (in addition to preset-implied ones)
   // Supports: VAR (if set), VAR_* (pattern), VAR=value (forced), VAR= (empty)
@@ -80,6 +127,75 @@ const DEFAULT_SETTINGS = {
   dockerContainerHome: '/home/node',
 };
 
+function mapLegacyModelToLevel(model) {
+  switch (model) {
+    case 'haiku':
+      return 'level1';
+    case 'sonnet':
+      return 'level2';
+    case 'opus':
+      return 'level3';
+    default:
+      return null;
+  }
+}
+
+function mergeProviderSettings(current, overrides) {
+  const merged = { ...current };
+  for (const provider of VALID_PROVIDERS) {
+    merged[provider] = {
+      ...current[provider],
+      ...(overrides?.[provider] || {}),
+    };
+    if (!merged[provider].levelOverrides) {
+      merged[provider].levelOverrides = {};
+    }
+  }
+  return merged;
+}
+
+function applyLegacyModelBounds(settings) {
+  if (!settings.providerSettings) return settings;
+  const claude = settings.providerSettings.claude || {};
+  const legacyMaxLevel = mapLegacyModelToLevel(settings.maxModel);
+  const legacyMinLevel = mapLegacyModelToLevel(settings.minModel);
+
+  if (legacyMaxLevel) {
+    claude.maxLevel = legacyMaxLevel;
+  }
+
+  if (legacyMinLevel) {
+    claude.minLevel = legacyMinLevel;
+  }
+
+  const minRank = LEVEL_RANKS[claude.minLevel] || LEVEL_RANKS.level1;
+  const maxRank = LEVEL_RANKS[claude.maxLevel] || LEVEL_RANKS.level3;
+  const defaultRank = LEVEL_RANKS[claude.defaultLevel] || LEVEL_RANKS.level2;
+
+  if (minRank > maxRank) {
+    claude.minLevel = 'level1';
+    claude.maxLevel = 'level3';
+  } else if (defaultRank < minRank) {
+    claude.defaultLevel = claude.minLevel;
+  } else if (defaultRank > maxRank) {
+    claude.defaultLevel = claude.maxLevel;
+  }
+
+  settings.providerSettings.claude = claude;
+  return settings;
+}
+
+function normalizeLoadedSettings(parsed) {
+  const normalized = { ...parsed };
+  if (parsed.defaultProvider) {
+    normalized.defaultProvider = normalizeProviderName(parsed.defaultProvider);
+  }
+  if (parsed.providerSettings) {
+    normalized.providerSettings = normalizeProviderSettings(parsed.providerSettings);
+  }
+  return normalized;
+}
+
 /**
  * Load settings from disk, merging with defaults
  */
@@ -90,7 +206,15 @@ function loadSettings() {
   }
   try {
     const data = fs.readFileSync(settingsFile, 'utf8');
-    return { ...DEFAULT_SETTINGS, ...JSON.parse(data) };
+    const parsed = normalizeLoadedSettings(JSON.parse(data));
+    const merged = { ...DEFAULT_SETTINGS, ...parsed };
+    merged.defaultProvider =
+      normalizeProviderName(merged.defaultProvider) || DEFAULT_SETTINGS.defaultProvider;
+    merged.providerSettings = mergeProviderSettings(
+      DEFAULT_SETTINGS.providerSettings,
+      parsed.providerSettings
+    );
+    return applyLegacyModelBounds(merged);
   } catch {
     console.error('Warning: Could not load settings, using defaults');
     return { ...DEFAULT_SETTINGS };
@@ -122,6 +246,10 @@ function validateSetting(key, value) {
     return `Invalid model: ${value}. Valid models: ${VALID_MODELS.join(', ')}`;
   }
 
+  if (key === 'minModel' && value !== null && !VALID_MODELS.includes(value)) {
+    return `Invalid model: ${value}. Valid models: ${VALID_MODELS.join(', ')}, null`;
+  }
+
   if (key === 'logLevel' && !['quiet', 'normal', 'verbose'].includes(value)) {
     return `Invalid log level: ${value}. Valid levels: quiet, normal, verbose`;
   }
@@ -135,6 +263,43 @@ function validateSetting(key, value) {
     }
   }
 
+  if (key === 'defaultProvider') {
+    const normalized = normalizeProviderName(value);
+    if (!VALID_PROVIDERS.includes(normalized)) {
+      return `Invalid provider: ${value}. Valid providers: ${VALID_PROVIDERS.join(', ')}`;
+    }
+  }
+
+  if (key === 'providerSettings') {
+    const normalizedSettings = normalizeProviderSettings(value);
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+      return 'providerSettings must be an object';
+    }
+    for (const [provider, settings] of Object.entries(normalizedSettings || {})) {
+      if (!VALID_PROVIDERS.includes(provider)) {
+        return `Unknown provider in providerSettings: ${provider}`;
+      }
+      if (typeof settings !== 'object' || settings === null) {
+        return `providerSettings.${provider} must be an object`;
+      }
+      if (settings.maxLevel && !LEVEL_RANKS[settings.maxLevel]) {
+        return `Invalid maxLevel for ${provider}: ${settings.maxLevel}`;
+      }
+      if (settings.minLevel && !LEVEL_RANKS[settings.minLevel]) {
+        return `Invalid minLevel for ${provider}: ${settings.minLevel}`;
+      }
+      if (settings.defaultLevel && !LEVEL_RANKS[settings.defaultLevel]) {
+        return `Invalid defaultLevel for ${provider}: ${settings.defaultLevel}`;
+      }
+      if (
+        settings.levelOverrides &&
+        (typeof settings.levelOverrides !== 'object' || Array.isArray(settings.levelOverrides))
+      ) {
+        return `levelOverrides for ${provider} must be an object`;
+      }
+    }
+  }
+
   if (key === 'dockerMounts') {
     return validateMountConfig(value);
   }
@@ -152,6 +317,11 @@ function validateSetting(key, value) {
 function coerceValue(key, value) {
   const defaultValue = DEFAULT_SETTINGS[key];
 
+  // Handle null values for minModel
+  if (key === 'minModel' && (value === 'null' || value === null)) {
+    return null;
+  }
+
   if (typeof defaultValue === 'boolean') {
     return value === 'true' || value === '1' || value === 'yes' || value === true;
   }
@@ -183,6 +353,21 @@ function coerceValue(key, value) {
     return value;
   }
 
+  if (key === 'providerSettings') {
+    if (typeof value === 'string') {
+      try {
+        return normalizeProviderSettings(JSON.parse(value));
+      } catch {
+        throw new Error(`Invalid JSON for providerSettings: ${value}`);
+      }
+    }
+    return normalizeProviderSettings(value);
+  }
+
+  if (key === 'defaultProvider') {
+    return normalizeProviderName(value);
+  }
+
   return value;
 }
 

package/lib/stream-json-parser.js

@@ -1,244 +1,10 @@
 /**
- * Stream JSON Parser for Claude Code output
- *
- * Parses NDJSON (newline-delimited JSON) streaming output from Claude Code.
- * Extracts: text output, tool calls, tool results, thinking, errors.
- *
- * Event types from Claude Code stream-json format:
- * - system: Session initialization
- * - stream_event: Real-time streaming (content_block_start, content_block_delta, etc.)
- * - assistant: Complete assistant message with content array
- * - user: Tool results
- * - result: Final task result
+ * Compatibility wrapper for Claude stream-json parsing.
+ * Prefer provider-specific parsers in src/providers.
  */
-
-/**
- * Parse a single JSON line and extract displayable content
- * @param {string} line - Single line of NDJSON
- * @returns {Object|null} Parsed event with type and content, or null if not displayable
- */
-function parseStreamLine(line) {
-  const trimmed = line.trim();
-  if (!trimmed || !trimmed.startsWith('{') || !trimmed.endsWith('}')) {
-    return null;
-  }
-
-  let event;
-  try {
-    event = JSON.parse(trimmed);
-  } catch {
-    return null;
-  }
-
-  // stream_event - real-time streaming updates
-  if (event.type === 'stream_event' && event.event) {
-    return parseStreamEvent(event.event);
-  }
-
-  // assistant - complete message with content blocks
-  if (event.type === 'assistant' && event.message?.content) {
-    return parseAssistantMessage(event.message);
-  }
-
-  // user - tool result
-  if (event.type === 'user' && event.message?.content) {
-    return parseUserMessage(event.message);
-  }
-
-  // result - final task result (includes token usage and cost)
-  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,
-      // Token usage from Claude API
-      inputTokens: usage.input_tokens || 0,
-      outputTokens: usage.output_tokens || 0,
-      cacheReadInputTokens: usage.cache_read_input_tokens || 0,
-      cacheCreationInputTokens: usage.cache_creation_input_tokens || 0,
-      // Per-model breakdown (for multi-model tasks)
-      modelUsage: event.modelUsage || null,
-    };
-  }
-
-  // system - session init (skip, not user-facing)
-  if (event.type === 'system') {
-    return null;
-  }
-
-  return null;
-}
-
-/**
- * Parse stream_event inner event
- */
-function parseStreamEvent(inner) {
-  // content_block_start - tool use or text block starting
-  if (inner.type === 'content_block_start' && inner.content_block) {
-    const block = inner.content_block;
-
-    if (block.type === 'tool_use') {
-      return {
-        type: 'tool_start',
-        toolName: block.name,
-        toolId: block.id,
-      };
-    }
-
-    if (block.type === 'thinking') {
-      return {
-        type: 'thinking_start',
-      };
-    }
-
-    // text block start - usually empty, skip
-    return null;
-  }
-
-  // content_block_delta - incremental content
-  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,
-      };
-    }
-
-    if (delta.type === 'input_json_delta' && delta.partial_json) {
-      return {
-        type: 'tool_input',
-        json: delta.partial_json,
-      };
-    }
-  }
-
-  // content_block_stop - block ended
-  if (inner.type === 'content_block_stop') {
-    return {
-      type: 'block_end',
-      index: inner.index,
-    };
-  }
-
-  // message_start - skip text extraction here since it will come via text_delta events
-  // (extracting here causes duplicate text output)
-
-  return null;
-}
-
-/**
- * Parse assistant message content blocks
- * NOTE: Skip text blocks here since they were already streamed via text_delta events.
- * Extracting text here would cause duplicate output.
- */
-function parseAssistantMessage(message) {
-  const results = [];
-
-  for (const block of message.content) {
-    // Skip text blocks - already streamed via text_delta events
-    // Extracting here causes duplicate output
-
-    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) {
-      // Skip thinking blocks too - already streamed via thinking_delta
-      // But keep for non-streaming contexts (direct API responses)
-      // Only emit if we haven't seen streaming deltas (detected by having results already)
-    }
-  }
-
-  if (results.length === 1) {
-    return results[0];
-  }
-
-  if (results.length > 1) {
-    return {
-      type: 'multi',
-      events: results,
-    };
-  }
-
-  return null;
-}
-
-/**
- * Parse user message (tool results)
- */
-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 {
-      type: 'multi',
-      events: results,
-    };
-  }
-
-  return null;
-}
-
-/**
- * Parse multiple lines of NDJSON
- * @param {string} chunk - Chunk of text potentially containing multiple JSON lines
- * @returns {Array} Array of parsed events
- */
-function parseChunk(chunk) {
-  const events = [];
-  const lines = chunk.split('\n');
-
-  for (const line of lines) {
-    const event = parseStreamLine(line);
-    if (event) {
-      if (event.type === 'multi') {
-        events.push(...event.events);
-      } else {
-        events.push(event);
-      }
-    }
-  }
-
-  return events;
-}
+const { parseEvent, parseChunk } = require('../src/providers/anthropic/output-parser');
 
 module.exports = {
-  parseStreamLine,
+  parseEvent,
   parseChunk,
-  parseStreamEvent,
-  parseAssistantMessage,
-  parseUserMessage,
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@covibes/zeroshot",
-  "version": "5.2.1",
-  "description": "Multi-agent orchestration engine for Claude - cluster coordinator and CLI",
+  "version": "5.3.0",
+  "description": "Multi-agent orchestration engine for Claude, Codex, and Gemini",
   "main": "src/orchestrator.js",
   "bin": {
     "zeroshot": "./cli/index.js"
@@ -11,14 +11,18 @@
     "test": "tests"
   },
   "scripts": {
-    "test": "mocha 'tests/**/*.test.js'",
-    "test:coverage": "c8 npm test",
-    "test:coverage:report": "c8 --reporter=html npm test && echo 'Coverage report generated at coverage/index.html'",
+    "test": "mocha 'tests/unit/**/*.test.js' 'tests/*.test.js' --parallel",
+    "test:unit": "mocha 'tests/unit/**/*.test.js' 'tests/*.test.js' --parallel",
+    "test:slow": "mocha 'tests/integration/**/*.test.js' --timeout 180000",
+    "test:all": "npm run test && npm run test:slow",
+    "test:coverage": "c8 npm run test:unit",
+    "test:coverage:report": "c8 --reporter=html npm run test:unit && echo 'Coverage report generated at coverage/index.html'",
     "postinstall": "node scripts/fix-node-pty-permissions.js",
     "start": "node cli/index.js",
     "typecheck": "tsc --noEmit",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
+    "validate:templates": "node scripts/validate-templates.js",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "deadcode": "ts-prune --skip node_modules",
@@ -55,6 +59,8 @@
     "multi-agent",
     "orchestration",
     "claude",
+    "codex",
+    "gemini",
     "automation"
   ],
   "author": "Covibes",
@@ -115,7 +121,9 @@
     "eslint-plugin-unused-imports": "^4.3.0",
     "husky": "^9.1.7",
     "jscpd": "^3.5.10",
+    "lint-staged": "^16.2.7",
     "mocha": "^11.7.5",
+    "prettier": "^3.7.4",
     "semantic-release": "^25.0.2",
     "sinon": "^21.0.0",
     "ts-prune": "^0.10.3",
@@ -124,5 +132,13 @@
   },
   "overrides": {
     "xml2js": "^0.5.0"
+  },
+  "lint-staged": {
+    "*.{js,mjs,cjs}": [
+      "eslint --fix"
+    ],
+    "*.{js,mjs,cjs,json,md}": [
+      "prettier --write"
+    ]
   }
 }

package/scripts/validate-templates.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+/**
+ * Validate all cluster templates for config errors
+ * Run in CI to prevent broken templates from being merged
+ *
+ * Usage: node scripts/validate-templates.js
+ * Exit codes: 0 = all valid, 1 = validation errors found
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { validateConfig } = require('../src/config-validator');
+
+const TEMPLATES_DIR = path.join(__dirname, '../cluster-templates');
+
+function findJsonFiles(dir) {
+  const files = [];
+  if (!fs.existsSync(dir)) return files;
+
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findJsonFiles(fullPath));
+    } else if (entry.name.endsWith('.json')) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+function validateTemplate(filePath) {
+  const relativePath = path.relative(process.cwd(), filePath);
+
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const config = JSON.parse(content);
+
+    // Skip non-cluster configs (like package.json)
+    if (!config.agents && !config.name) {
+      return { valid: true, skipped: true };
+    }
+
+    const result = validateConfig(config);
+
+    if (!result.valid) {
+      console.error(`\n❌ ${relativePath}`);
+      for (const error of result.errors) {
+        console.error(`   ERROR: ${error}`);
+      }
+    } else if (result.warnings.length > 0) {
+      console.warn(`\n⚠️  ${relativePath}`);
+      for (const warning of result.warnings) {
+        console.warn(`   WARN: ${warning}`);
+      }
+    } else {
+      console.log(`✓ ${relativePath}`);
+    }
+
+    return result;
+  } catch (err) {
+    console.error(`\n❌ ${relativePath}`);
+    console.error(`   PARSE ERROR: ${err.message}`);
+    return { valid: false, errors: [err.message], warnings: [] };
+  }
+}
+
+function main() {
+  console.log('Validating cluster templates...\n');
+
+  const templateFiles = [...findJsonFiles(TEMPLATES_DIR)];
+
+  let hasErrors = false;
+  let validated = 0;
+  let skipped = 0;
+
+  for (const file of templateFiles) {
+    const result = validateTemplate(file);
+    if (result.skipped) {
+      skipped++;
+    } else {
+      validated++;
+      if (!result.valid) {
+        hasErrors = true;
+      }
+    }
+  }
+
+  console.log(`\n${'='.repeat(60)}`);
+  console.log(`Validated: ${validated} templates, Skipped: ${skipped} files`);
+
+  if (hasErrors) {
+    console.error('\n❌ VALIDATION FAILED - Fix errors above before merging\n');
+    process.exit(1);
+  } else {
+    console.log('\n✓ All templates valid\n');
+    process.exit(0);
+  }
+}
+
+main();