@the-open-engine/zeroshot 5.4.0

package/lib/start-cluster.js

@@ -0,0 +1,321 @@
+const path = require('path');
+const { spawnSync } = require('child_process');
+const chalk = require('chalk');
+const { normalizeProviderName } = require('./provider-names');
+const { getProvider } = require('../src/providers');
+const TemplateResolver = require('../src/template-resolver');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+function firstTruthy(...values) {
+  return values.find(Boolean);
+}
+function anyTruthy(...values) {
+  return values.some(Boolean);
+}
+function optionalValue(value) {
+  return value || undefined;
+}
+function resolveTargetCwd() {
+  return firstTruthy(process.env.ZEROSHOT_CWD, detectGitRepoRoot());
+}
+
+function detectGitRepoRoot() {
+  try {
+    const result = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (result.status !== 0) {
+      return process.cwd();
+    }
+    return result.stdout.trim();
+  } catch {
+    return process.cwd();
+  }
+}
+
+function resolveOptionalString(value) {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function resolveEnvBool(value) {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed === '1' || trimmed === 'true' || trimmed === 'yes') return true;
+  if (trimmed === '0' || trimmed === 'false' || trimmed === 'no') return false;
+  return undefined;
+}
+
+function resolveCloseIssueMode(value) {
+  const trimmed = resolveOptionalString(value);
+  if (!trimmed) return undefined;
+  const normalized = trimmed.toLowerCase();
+  if (normalized === 'auto' || normalized === 'always' || normalized === 'never') {
+    return normalized;
+  }
+  return undefined;
+}
+
+function parseRunOptionsEnv() {
+  const raw = resolveOptionalString(process.env.ZEROSHOT_RUN_OPTIONS);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object') {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function parseMountSpecs(specs) {
+  return specs.map((spec) => {
+    const parts = spec.split(':');
+    if (parts.length < 2) {
+      throw new Error(`Invalid mount spec: "${spec}". Format: host:container[:ro]`);
+    }
+    const host = parts[0];
+    const container = parts[1];
+    const readonly = parts[2] === 'ro';
+    return { host, container, readonly };
+  });
+}
+
+function buildTextInput(text) {
+  return { text };
+}
+function buildIssueInput(issue) {
+  return { issue };
+}
+function buildFileInput(file) {
+  return { file };
+}
+
+function detectRunInput(inputArg) {
+  const isGitHubUrl = /^https?:\/\/github\.com\/[\w-]+\/[\w-]+\/issues\/\d+/.test(inputArg);
+  const isGitLabUrl = /gitlab\.(com|[\w.-]+)\/[\w-]+\/[\w-]+\/-\/issues\/\d+/.test(inputArg);
+  const isJiraUrl = /(atlassian\.net|jira\.[\w.-]+)\/browse\/[A-Z][A-Z0-9]+-\d+/.test(inputArg);
+  const isAzureUrl =
+    /dev\.azure\.com\/.*\/_workitems\/edit\/\d+/.test(inputArg) ||
+    /visualstudio\.com\/.*\/_workitems\/edit\/\d+/.test(inputArg);
+  const isJiraKey = /^[A-Z][A-Z0-9]+-\d+$/.test(inputArg);
+  const isIssueNumber = /^\d+$/.test(inputArg);
+  const isRepoIssue = /^[\w-]+\/[\w-]+#\d+$/.test(inputArg);
+  const isMarkdownFile = /\.(md|markdown)$/i.test(inputArg);
+
+  if (
+    isGitHubUrl ||
+    isGitLabUrl ||
+    isJiraUrl ||
+    isAzureUrl ||
+    isJiraKey ||
+    isIssueNumber ||
+    isRepoIssue
+  ) {
+    return buildIssueInput(inputArg);
+  }
+  if (isMarkdownFile) {
+    return buildFileInput(inputArg);
+  }
+  return buildTextInput(inputArg);
+}
+
+function resolveProviderOverride(options = {}) {
+  const override = options.provider || options.envProvider || process.env.ZEROSHOT_PROVIDER;
+  if (!override || (typeof override === 'string' && !override.trim())) {
+    return null;
+  }
+  const normalized = normalizeProviderName(override);
+  if (options.validateProvider) {
+    getProvider(normalized);
+  }
+  return normalized;
+}
+
+function resolveConfigPath(configName) {
+  if (path.isAbsolute(configName) || configName.startsWith('./') || configName.startsWith('../')) {
+    return path.resolve(process.cwd(), configName);
+  }
+  if (configName.endsWith('.json')) {
+    return path.join(PACKAGE_ROOT, 'cluster-templates', configName);
+  }
+  return path.join(PACKAGE_ROOT, 'cluster-templates', `${configName}.json`);
+}
+
+function ensureConfigProviderDefaults(config, settings) {
+  if (!config.defaultProvider) {
+    config.defaultProvider = settings.defaultProvider || 'claude';
+  }
+  config.defaultProvider = normalizeProviderName(config.defaultProvider) || 'claude';
+}
+
+function applyProviderOverrideToConfig(config, providerOverride, settings) {
+  const provider = getProvider(providerOverride);
+  const providerSettings = settings.providerSettings?.[providerOverride] || {};
+  config.forceProvider = providerOverride;
+  config.defaultProvider = providerOverride;
+  config.forceLevel = providerSettings.defaultLevel || provider.getDefaultLevel();
+  config.defaultLevel = config.forceLevel;
+  console.log(chalk.dim(`Provider override: ${providerOverride} (all agents)`));
+}
+
+function resolveParameterizedConfigFile(config) {
+  if (!config?.params || Object.keys(config.params).length === 0) {
+    return config;
+  }
+
+  const resolver = new TemplateResolver(path.join(PACKAGE_ROOT, 'cluster-templates'));
+  return resolver.resolveTemplate(config, {});
+}
+
+function loadClusterConfig(orchestrator, configPath, settings = {}, providerOverride) {
+  const config = resolveParameterizedConfigFile(orchestrator.loadConfig(configPath));
+  ensureConfigProviderDefaults(config, settings);
+  if (providerOverride) {
+    applyProviderOverrideToConfig(config, providerOverride, settings);
+  }
+  return config;
+}
+
+function mergeRunOptions(options) {
+  const envRunOptions = parseRunOptionsEnv();
+  return envRunOptions ? { ...envRunOptions, ...options } : options;
+}
+
+function resolveIsolation(mergedOptions, settings) {
+  return mergedOptions.docker || process.env.ZEROSHOT_DOCKER === '1' || settings.defaultDocker;
+}
+
+function resolveMergeQueue(mergedOptions) {
+  if (typeof mergedOptions.mergeQueue === 'boolean') {
+    return mergedOptions.mergeQueue;
+  }
+  return resolveEnvBool(process.env.ZEROSHOT_MERGE_QUEUE);
+}
+
+function resolvePrBase(mergedOptions) {
+  return (
+    resolveOptionalString(mergedOptions.prBase) ||
+    resolveOptionalString(process.env.ZEROSHOT_PR_BASE) ||
+    undefined
+  );
+}
+
+function resolveCloseIssue(mergedOptions) {
+  return (
+    resolveCloseIssueMode(mergedOptions.closeIssue) ||
+    resolveCloseIssueMode(process.env.ZEROSHOT_CLOSE_ISSUE) ||
+    undefined
+  );
+}
+
+function resolveMounts(mergedOptions) {
+  return mergedOptions.mount ? parseMountSpecs(mergedOptions.mount) : undefined;
+}
+
+function buildStartOptions({
+  clusterId,
+  options = {},
+  settings = {},
+  providerOverride,
+  modelOverride,
+  forceProvider,
+}) {
+  const mergedOptions = mergeRunOptions(options);
+  return {
+    clusterId,
+    cwd: resolveTargetCwd(),
+    isolation: resolveIsolation(mergedOptions, settings),
+    isolationImage: firstTruthy(mergedOptions.dockerImage, process.env.ZEROSHOT_DOCKER_IMAGE),
+    worktree: anyTruthy(mergedOptions.worktree, process.env.ZEROSHOT_WORKTREE === '1'),
+    autoPr: anyTruthy(mergedOptions.pr, process.env.ZEROSHOT_PR === '1'),
+    autoMerge: process.env.ZEROSHOT_MERGE === '1',
+    autoPush: process.env.ZEROSHOT_PUSH === '1',
+    modelOverride: optionalValue(modelOverride),
+    providerOverride: optionalValue(providerOverride),
+    noMounts: anyTruthy(mergedOptions.mounts === false, mergedOptions.noMounts === true),
+    mounts: resolveMounts(mergedOptions),
+    containerHome: optionalValue(mergedOptions.containerHome),
+    forceProvider: optionalValue(forceProvider),
+    prBase: resolvePrBase(mergedOptions),
+    mergeQueue: resolveMergeQueue(mergedOptions),
+    closeIssue: resolveCloseIssue(mergedOptions),
+    ship: mergedOptions.ship,
+    requiredQualityGates: mergedOptions.requiredQualityGates,
+    settings,
+  };
+}
+
+function resolveConfigOrThrow({
+  orchestrator,
+  config,
+  configPath,
+  configName,
+  settings,
+  providerOverride,
+}) {
+  if (config) {
+    return config;
+  }
+  const resolvedPath = configPath || (configName ? resolveConfigPath(configName) : null);
+  if (!resolvedPath) {
+    throw new Error('configPath or configName is required when config is not provided');
+  }
+  return loadClusterConfig(orchestrator, resolvedPath, settings, providerOverride);
+}
+
+function startClusterWithInput(args, input) {
+  const { orchestrator, config, configPath, configName, settings, providerOverride } = args;
+  if (!orchestrator) {
+    throw new Error('orchestrator is required');
+  }
+  const resolvedConfig = resolveConfigOrThrow({
+    orchestrator,
+    config,
+    configPath,
+    configName,
+    settings,
+    providerOverride,
+  });
+  const startOptions = buildStartOptions({
+    clusterId: args.clusterId,
+    options: args.options || {},
+    settings,
+    providerOverride,
+    modelOverride: args.modelOverride,
+    forceProvider: args.forceProvider,
+  });
+  return orchestrator.start(resolvedConfig, input, startOptions);
+}
+
+function startClusterFromText(args) {
+  return startClusterWithInput(args, buildTextInput(args.text));
+}
+
+function startClusterFromIssue(args) {
+  return startClusterWithInput(args, buildIssueInput(args.issue));
+}
+
+function startClusterFromFile(args) {
+  return startClusterWithInput(args, buildFileInput(args.file));
+}
+
+module.exports = {
+  buildTextInput,
+  buildIssueInput,
+  buildFileInput,
+  detectRunInput,
+  resolveProviderOverride,
+  resolveConfigPath,
+  loadClusterConfig,
+  buildStartOptions,
+  startClusterFromText,
+  startClusterFromIssue,
+  startClusterFromFile,
+  detectGitRepoRoot,
+};

package/lib/stream-json-parser.js

@@ -0,0 +1,67 @@
+/**
+ * Provider-agnostic stream-json parser for `zeroshot logs`.
+ *
+ * Provider parsing is delegated to the helper-backed runtime provider facade.
+ */
+
+const { getProvider } = require('../src/providers');
+
+const providerOrder = ['claude', 'codex', 'opencode', 'gemini'];
+const providerParsers = providerOrder.map((name) => getProvider(name));
+
+function stripTimestampPrefix(line) {
+  if (!line || typeof line !== 'string') return '';
+  let trimmed = line.trim().replace(/\r$/, '');
+  if (!trimmed) return '';
+
+  const tsMatch = trimmed.match(/^\[(\d{13})\](.*)$/);
+  if (tsMatch) trimmed = (tsMatch[2] || '').trimStart();
+
+  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+    const pipeMatch = trimmed.match(/^[^|]{1,40}\|\s*(.*)$/);
+    if (pipeMatch) {
+      const afterPipe = (pipeMatch[1] || '').trimStart();
+      if (afterPipe.startsWith('{') || afterPipe.startsWith('[')) return afterPipe;
+    }
+  }
+
+  return trimmed;
+}
+
+function parseEvent(line) {
+  const content = stripTimestampPrefix(line);
+  if (!content) return null;
+
+  for (const provider of providerParsers) {
+    const event = provider.parseEvent(content);
+    if (event) return event;
+  }
+
+  return null;
+}
+
+function collectEvent(events, event) {
+  if (!event) return;
+  if (Array.isArray(event)) {
+    events.push(...event);
+    return;
+  }
+  events.push(event);
+}
+
+function parseChunk(chunk) {
+  const events = [];
+  const lines = String(chunk || '').split('\n');
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    collectEvent(events, parseEvent(line));
+  }
+
+  return events;
+}
+
+module.exports = {
+  parseEvent,
+  parseChunk,
+};

package/package.json

@@ -0,0 +1,162 @@
+{
+  "name": "@the-open-engine/zeroshot",
+  "version": "5.4.0",
+  "description": "Multi-agent orchestration engine for Claude, Codex, and Gemini",
+  "main": "src/orchestrator.js",
+  "bin": {
+    "zeroshot": "./cli/index.js",
+    "zeroshot-agent-provider": "./lib/agent-cli-provider/executable.js"
+  },
+  "directories": {
+    "example": "examples",
+    "test": "tests"
+  },
+  "scripts": {
+    "pretest": "npm run build:agent-cli-provider",
+    "test": "node tests/run-tests.js",
+    "test:unit": "node tests/run-tests.js",
+    "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",
+    "typecheck:agent-cli-provider": "tsc --project tsconfig.agent-cli-provider.json",
+    "lint:agent-cli-provider": "eslint \"src/agent-cli-provider/**/*.ts\" \"tests/agent-cli-provider/**/*.ts\"",
+    "build:agent-cli-provider": "tsc --project tsconfig.agent-cli-provider.build.json",
+    "test:agent-cli-provider": "node --test tests/agent-cli-provider/*.test.js",
+    "check:agent-cli-provider:ci": "npm run typecheck:agent-cli-provider && npm run lint:agent-cli-provider && npm run build:agent-cli-provider && npm run test:agent-cli-provider",
+    "dev:link": "npm link",
+    "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",
+    "deadcode:files": "unimported",
+    "deadcode:deps": "depcheck",
+    "deadcode:all": "npm run deadcode && npm run deadcode:files && npm run deadcode:deps",
+    "dupcheck": "jscpd src/ --min-lines 5 --min-tokens 50 --threshold 5",
+    "check": "npm run typecheck && npm run lint",
+    "check:all": "npm run check && npm run deadcode:all",
+    "release": "semantic-release",
+    "prepublishOnly": "npm run lint && npm run typecheck && npm run check:agent-cli-provider:ci",
+    "prepare": "npm run build:agent-cli-provider && husky"
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "lcov",
+      "html"
+    ],
+    "include": [
+      "src/**/*.js",
+      "lib/**/*.js",
+      "cli/**/*.js"
+    ],
+    "exclude": [
+      "**/*.test.js",
+      "**/tests/**"
+    ],
+    "all": true
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "multi-agent",
+    "orchestration",
+    "claude",
+    "codex",
+    "gemini",
+    "automation"
+  ],
+  "author": "Covibes",
+  "license": "MIT",
+  "homepage": "https://github.com/the-open-engine/zeroshot",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/the-open-engine/zeroshot.git"
+  },
+  "bugs": {
+    "url": "https://github.com/the-open-engine/zeroshot/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "src/",
+    "lib/",
+    "cli/",
+    "task-lib/",
+    "cluster-templates/",
+    "hooks/",
+    "docker/",
+    "scripts/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "ajv": "^8.18.0",
+    "ansi-to-html": "^0.7.2",
+    "better-sqlite3": "^12.6.2",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.2",
+    "node-pty": "^1.1.0",
+    "omelette": "^0.4.17",
+    "pidusage": "^4.0.1",
+    "puppeteer": "^24.34.0",
+    "proper-lockfile": "^4.1.2"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.6",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.0.3",
+    "c8": "^10.1.3",
+    "chai": "^6.2.1",
+    "depcheck": "^1.4.7",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-security": "^3.0.1",
+    "eslint-plugin-sonarjs": "^3.0.5",
+    "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",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.59.4",
+    "unimported": "^1.31.0"
+  },
+  "overrides": {
+    "cosmiconfig": {
+      "js-yaml": "4.2.0"
+    },
+    "xml2js": "^0.5.0",
+    "diff": ">=8.0.3",
+    "tar": ">=7.5.8",
+    "undici": ">=7.18.2",
+    "minimatch": ">=10.2.1",
+    "lodash": ">=4.17.24",
+    "marked": ">=15.0.7"
+  },
+  "lint-staged": {
+    "*.{js,mjs,cjs}": [
+      "eslint --fix"
+    ],
+    "*.{js,mjs,cjs,json,md}": [
+      "prettier --write"
+    ]
+  }
+}

package/scripts/fix-node-pty-permissions.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+/**
+ * Fix node-pty spawn-helper permissions.
+ *
+ * node-pty prebuilds ship with spawn-helper lacking execute permission (mode 644).
+ * This causes "posix_spawnp failed" errors on macOS/Linux.
+ *
+ * Upstream bug: https://github.com/microsoft/node-pty/issues/XXX
+ * (File issue if not already reported)
+ *
+ * This script runs as postinstall to fix it automatically.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Skip on Windows - chmod doesn't apply
+if (process.platform === 'win32') {
+  process.exit(0);
+}
+
+const prebuildsDir = path.join(__dirname, '..', 'node_modules', 'node-pty', 'prebuilds');
+
+if (!fs.existsSync(prebuildsDir)) {
+  // node-pty not installed yet or using compiled version
+  process.exit(0);
+}
+
+let fixed = 0;
+let errors = 0;
+
+try {
+  const platforms = fs.readdirSync(prebuildsDir).filter((f) => {
+    try {
+      return fs.statSync(path.join(prebuildsDir, f)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+
+  for (const platform of platforms) {
+    // Only fix Unix platforms (darwin, linux)
+    if (!platform.startsWith('darwin') && !platform.startsWith('linux')) {
+      continue;
+    }
+
+    const helper = path.join(prebuildsDir, platform, 'spawn-helper');
+    try {
+      if (!fs.existsSync(helper)) continue;
+
+      const stat = fs.statSync(helper);
+      // Check if not executable (missing user execute bit)
+      if (!(stat.mode & 0o100)) {
+        fs.chmodSync(helper, 0o755);
+        fixed++;
+      }
+    } catch (err) {
+      // Log but don't fail install - permission fix is best-effort
+      console.warn(`[postinstall] Warning: Could not fix ${helper}: ${err.message}`);
+      errors++;
+    }
+  }
+} catch (err) {
+  // Don't fail install on unexpected errors
+  console.warn(`[postinstall] Warning: node-pty permission fix failed: ${err.message}`);
+  process.exit(0);
+}
+
+if (fixed > 0) {
+  console.log(`[postinstall] Fixed node-pty spawn-helper permissions (${fixed} platform(s))`);
+}
+
+if (errors > 0) {
+  console.warn(`[postinstall] ${errors} platform(s) could not be fixed - may need manual chmod`);
+}