@the-open-engine/zeroshot 6.38.1 → 6.39.0

package/src/orchestrator.js

@@ -1847,16 +1847,31 @@ class Orchestrator {
             },
           },
         });
+        const boundary = this._clusterRunBoundaries.get(clusterId);
+        const complete = messageBus.query({
+          cluster_id: clusterId,
+          topic: 'CLUSTER_COMPLETE',
+          limit: 1,
+          ...(boundary === null || boundary === undefined ? {} : { afterId: boundary }),
+        })[0];
+        const failed = this._findCurrentRunClusterFailure(messageBus, clusterId);
+        if (!complete && !failed) {
+          messageBus.publish({
+            cluster_id: clusterId,
+            topic: 'CLUSTER_FAILED',
+            sender: 'orchestrator',
+            content: {
+              text: `Operation chain failed: ${err.message}`,
+              data: { reason: 'cluster_operations_failed' },
+            },
+          });
+        }
 
         this._log(`\n${'='.repeat(80)}`);
         this._log(`❌ CLUSTER_OPERATIONS FAILED - STOPPING CLUSTER`);
         this._log(`${'='.repeat(80)}`);
         this._log(`Error: ${err.message}`);
         this._log(`${'='.repeat(80)}\n`);
-
-        this.stop(clusterId).catch((stopErr) => {
-          console.error(`Failed to stop cluster after operation failure:`, stopErr.message);
-        });
       });
     });
   }

package/src/providers/anthropic/index.js

@@ -1,3 +1,5 @@
+"use strict";
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const { createProviderClass } = require('..');
-
 module.exports = createProviderClass('claude');

package/src/providers/anthropic/index.ts

@@ -0,0 +1,13 @@
+interface ProviderConstructor {
+  new (): { readonly name: string };
+}
+
+interface ProvidersFacade {
+  createProviderClass(name: string): ProviderConstructor;
+}
+
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { createProviderClass }: ProvidersFacade = require('..');
+
+export = createProviderClass('claude');

package/src/providers/capabilities.js

@@ -1,33 +1,25 @@
-const {
-  PROVIDER_CAPABILITIES,
-  normalizeProviderName,
-  providerSupportsCapability,
-} = require('../../lib/provider-names');
-
-const CAPABILITIES = Object.freeze(
-  Object.fromEntries(
-    Object.entries(PROVIDER_CAPABILITIES).map(([provider, capabilities]) => [
-      provider,
-      Object.freeze({ ...capabilities }),
-    ])
-  )
-);
-
+"use strict";
+// The generated CommonJS facade resolves the built provider registry through lib/.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { PROVIDER_CAPABILITIES, normalizeProviderName, providerSupportsCapability } = require('../../lib/provider-names');
+const CAPABILITIES = Object.freeze(Object.fromEntries(Object.entries(PROVIDER_CAPABILITIES).map(([provider, capabilities]) => [
+    provider,
+    Object.freeze({ ...capabilities }),
+])));
 function checkCapability(provider, capability) {
-  if (!provider) return false;
-  return providerSupportsCapability(provider, capability);
+    if (!provider)
+        return false;
+    return providerSupportsCapability(provider, capability);
 }
-
 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`);
-  }
+    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,
+    CAPABILITIES,
+    checkCapability,
+    warnIfExperimental,
 };

package/src/providers/capabilities.ts

@@ -0,0 +1,44 @@
+type ProviderCapabilityState = boolean | 'experimental';
+type ProviderCapabilities = Readonly<Record<string, ProviderCapabilityState>>;
+
+interface ProviderNamesFacade {
+  readonly PROVIDER_CAPABILITIES: Readonly<Record<string, ProviderCapabilities>>;
+  normalizeProviderName(provider: string): string;
+  providerSupportsCapability(provider: string, capability: string): boolean;
+}
+
+// The generated CommonJS facade resolves the built provider registry through lib/.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { PROVIDER_CAPABILITIES, normalizeProviderName, providerSupportsCapability }:
+  ProviderNamesFacade = require('../../lib/provider-names');
+
+const CAPABILITIES: Readonly<Record<string, ProviderCapabilities>> = Object.freeze(
+  Object.fromEntries(
+    Object.entries(PROVIDER_CAPABILITIES).map(([provider, capabilities]) => [
+      provider,
+      Object.freeze({ ...capabilities }),
+    ])
+  )
+);
+
+function checkCapability(
+  provider: string | null | undefined,
+  capability: string
+): boolean {
+  if (!provider) return false;
+  return providerSupportsCapability(provider, capability);
+}
+
+function warnIfExperimental(provider: string, capability: string): void {
+  const normalized = normalizeProviderName(provider);
+  const caps = CAPABILITIES[normalized];
+  if (caps?.[capability] === 'experimental') {
+    console.warn(`⚠️ ${capability} is experimental for ${normalized} and may not work reliably`);
+  }
+}
+
+export = {
+  CAPABILITIES,
+  checkCapability,
+  warnIfExperimental,
+};

package/src/providers/google/index.js

@@ -1,3 +1,5 @@
+"use strict";
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const { createProviderClass } = require('..');
-
 module.exports = createProviderClass('gemini');

package/src/providers/google/index.ts

@@ -0,0 +1,13 @@
+interface ProviderConstructor {
+  new (): { readonly name: string };
+}
+
+interface ProvidersFacade {
+  createProviderClass(name: string): ProviderConstructor;
+}
+
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { createProviderClass }: ProvidersFacade = require('..');
+
+export = createProviderClass('gemini');

package/src/providers/openai/index.js

@@ -1,3 +1,5 @@
+"use strict";
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const { createProviderClass } = require('..');
-
 module.exports = createProviderClass('codex');

package/src/providers/openai/index.ts

@@ -0,0 +1,13 @@
+interface ProviderConstructor {
+  new (): { readonly name: string };
+}
+
+interface ProvidersFacade {
+  createProviderClass(name: string): ProviderConstructor;
+}
+
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { createProviderClass }: ProvidersFacade = require('..');
+
+export = createProviderClass('codex');

package/src/providers/opencode/index.js

@@ -1,3 +1,5 @@
+"use strict";
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const { createProviderClass } = require('..');
-
 module.exports = createProviderClass('opencode');

package/src/providers/opencode/index.ts

@@ -0,0 +1,13 @@
+interface ProviderConstructor {
+  new (): { readonly name: string };
+}
+
+interface ProvidersFacade {
+  createProviderClass(name: string): ProviderConstructor;
+}
+
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { createProviderClass }: ProvidersFacade = require('..');
+
+export = createProviderClass('opencode');

package/src/quality-gates.js

@@ -1,148 +1,88 @@
-const { readRepoSettings } = require('../lib/repo-settings');
-
-function hasOwn(value, key) {
-  return Object.prototype.hasOwnProperty.call(value || {}, key);
-}
-
-function hasDefinedOwn(value, key) {
-  return hasOwn(value, key) && value[key] !== undefined;
-}
-
+"use strict";
+const repoSettingsAccess = require("./repo-settings-access");
+const { isRecord, propertyValue, readRepoSettingsValue, selectOwnProperty } = repoSettingsAccess;
 function getGateId(gate) {
-  if (typeof gate.id === 'string' && gate.id.trim()) {
-    return gate.id.trim();
-  }
-
-  if (typeof gate.name === 'string' && gate.name.trim()) {
-    return gate.name.trim();
-  }
-
-  return null;
+    if (typeof gate.id === 'string' && gate.id.trim()) {
+        return gate.id.trim();
+    }
+    if (typeof gate.name === 'string' && gate.name.trim()) {
+        return gate.name.trim();
+    }
+    return null;
 }
-
 function normalizeStringGate(gate) {
-  const id = gate.trim();
-  return id ? { id } : null;
+    const id = gate.trim();
+    return id ? { id } : null;
 }
-
 function setOptionalString(target, source, key) {
-  if (typeof source[key] === 'string' && source[key].trim()) {
-    target[key] = source[key].trim();
-  }
+    const value = source[key];
+    if (typeof value === 'string' && value.trim()) {
+        target[key] = value.trim();
+    }
 }
-
 function normalizeObjectGate(gate) {
-  if (!gate || typeof gate !== 'object') {
-    return null;
-  }
-
-  const id = getGateId(gate);
-  if (!id) {
-    return null;
-  }
-
-  const normalized = { id };
-  setOptionalString(normalized, gate, 'scope');
-  setOptionalString(normalized, gate, 'description');
-  setOptionalString(normalized, gate, 'command');
-  setOptionalString(normalized, gate, 'profile');
-  setOptionalString(normalized, gate, 'proofProfile');
-  if (gate.commandProof === true) {
-    normalized.commandProof = true;
-  }
-  return normalized;
+    if (!isRecord(gate)) {
+        return null;
+    }
+    const id = getGateId(gate);
+    if (!id) {
+        return null;
+    }
+    const normalized = { id };
+    setOptionalString(normalized, gate, 'scope');
+    setOptionalString(normalized, gate, 'description');
+    setOptionalString(normalized, gate, 'command');
+    setOptionalString(normalized, gate, 'profile');
+    setOptionalString(normalized, gate, 'proofProfile');
+    if (gate.commandProof === true) {
+        normalized.commandProof = true;
+    }
+    return normalized;
+}
+function isRequiredQualityGate(gate) {
+    return gate !== null;
 }
-
 function normalizeRequiredQualityGates(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-
-  return value
-    .map((gate) => {
-      if (typeof gate === 'string') {
-        return normalizeStringGate(gate);
-      }
-      return normalizeObjectGate(gate);
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((gate) => {
+        if (typeof gate === 'string') {
+            return normalizeStringGate(gate);
+        }
+        return normalizeObjectGate(gate);
     })
-    .filter(Boolean);
+        .filter(isRequiredQualityGate);
 }
-
 function getRequiredQualityGateSource(options, repoSettings) {
-  if (hasDefinedOwn(options, 'requiredQualityGates')) {
-    return options.requiredQualityGates;
-  }
-
-  if (
-    options.ship &&
-    typeof options.ship === 'object' &&
-    hasDefinedOwn(options.ship, 'requiredQualityGates')
-  ) {
-    return options.ship.requiredQualityGates;
-  }
-
-  const settingsShip = repoSettings?.ship;
-  if (
-    settingsShip &&
-    typeof settingsShip === 'object' &&
-    hasOwn(settingsShip, 'requiredQualityGates')
-  ) {
-    return settingsShip.requiredQualityGates;
-  }
-
-  if (hasOwn(repoSettings, 'requiredQualityGates')) {
-    return repoSettings.requiredQualityGates;
-  }
-
-  return [];
+    const explicitSource = selectOwnProperty('requiredQualityGates', [options, propertyValue(options, 'ship')], { skipUndefined: true });
+    if (explicitSource !== undefined) {
+        return explicitSource;
+    }
+    const repoSource = selectOwnProperty('requiredQualityGates', [
+        propertyValue(repoSettings, 'ship'),
+        repoSettings,
+    ]);
+    return repoSource === undefined ? [] : repoSource;
 }
-
 function resolveRequiredQualityGates(options = {}) {
-  const repoSettingsResult = readRepoSettings(options.cwd || process.cwd());
-  const repoSettings = repoSettingsResult.settings || {};
-  const source = getRequiredQualityGateSource(options, repoSettings);
-  return normalizeRequiredQualityGates(source);
+    const repoSettings = readRepoSettingsValue(options.cwd || process.cwd());
+    const source = getRequiredQualityGateSource(options, repoSettings);
+    return normalizeRequiredQualityGates(source);
 }
-
 function getClusterRequiredQualityGateSource(config, options) {
-  if (hasDefinedOwn(options, 'requiredQualityGates')) {
-    return options.requiredQualityGates;
-  }
-
-  if (
-    options.ship &&
-    typeof options.ship === 'object' &&
-    hasDefinedOwn(options.ship, 'requiredQualityGates')
-  ) {
-    return options.ship.requiredQualityGates;
-  }
-
-  if (
-    config?.ship &&
-    typeof config.ship === 'object' &&
-    hasDefinedOwn(config.ship, 'requiredQualityGates')
-  ) {
-    return config.ship.requiredQualityGates;
-  }
-
-  if (hasDefinedOwn(config, 'requiredQualityGates')) {
-    return config.requiredQualityGates;
-  }
-
-  return undefined;
+    return selectOwnProperty('requiredQualityGates', [options, propertyValue(options, 'ship'), propertyValue(config, 'ship'), config], { skipUndefined: true });
 }
-
 function resolveClusterRequiredQualityGates(config = {}, options = {}) {
-  const configuredSource = getClusterRequiredQualityGateSource(config, options);
-  if (configuredSource !== undefined) {
-    return normalizeRequiredQualityGates(configuredSource);
-  }
-
-  return resolveRequiredQualityGates({ ...options, cwd: options.cwd || process.cwd() });
+    const configuredSource = getClusterRequiredQualityGateSource(config, options);
+    if (configuredSource !== undefined) {
+        return normalizeRequiredQualityGates(configuredSource);
+    }
+    return resolveRequiredQualityGates({ ...options, cwd: options.cwd || process.cwd() });
 }
-
 module.exports = {
-  normalizeRequiredQualityGates,
-  resolveRequiredQualityGates,
-  resolveClusterRequiredQualityGates,
+    normalizeRequiredQualityGates,
+    resolveRequiredQualityGates,
+    resolveClusterRequiredQualityGates,
 };

package/src/quality-gates.ts

@@ -0,0 +1,149 @@
+import repoSettingsAccess = require('./repo-settings-access');
+
+type StringGateField = 'scope' | 'description' | 'command' | 'profile' | 'proofProfile';
+
+interface RequiredQualityGate {
+  id: string;
+  scope?: string;
+  description?: string;
+  command?: string;
+  profile?: string;
+  proofProfile?: string;
+  commandProof?: true;
+}
+
+interface QualityGateOptions {
+  cwd?: string;
+  requiredQualityGates?: unknown;
+  ship?: unknown;
+  [key: string]: unknown;
+}
+
+interface QualityGateConfig {
+  requiredQualityGates?: unknown;
+  ship?: unknown;
+  [key: string]: unknown;
+}
+
+const { isRecord, propertyValue, readRepoSettingsValue, selectOwnProperty } = repoSettingsAccess;
+
+function getGateId(gate: Record<string, unknown>): string | null {
+  if (typeof gate.id === 'string' && gate.id.trim()) {
+    return gate.id.trim();
+  }
+
+  if (typeof gate.name === 'string' && gate.name.trim()) {
+    return gate.name.trim();
+  }
+
+  return null;
+}
+
+function normalizeStringGate(gate: string): RequiredQualityGate | null {
+  const id = gate.trim();
+  return id ? { id } : null;
+}
+
+function setOptionalString(
+  target: RequiredQualityGate,
+  source: Record<string, unknown>,
+  key: StringGateField
+): void {
+  const value = source[key];
+  if (typeof value === 'string' && value.trim()) {
+    target[key] = value.trim();
+  }
+}
+
+function normalizeObjectGate(gate: unknown): RequiredQualityGate | null {
+  if (!isRecord(gate)) {
+    return null;
+  }
+
+  const id = getGateId(gate);
+  if (!id) {
+    return null;
+  }
+
+  const normalized: RequiredQualityGate = { id };
+  setOptionalString(normalized, gate, 'scope');
+  setOptionalString(normalized, gate, 'description');
+  setOptionalString(normalized, gate, 'command');
+  setOptionalString(normalized, gate, 'profile');
+  setOptionalString(normalized, gate, 'proofProfile');
+  if (gate.commandProof === true) {
+    normalized.commandProof = true;
+  }
+  return normalized;
+}
+
+function isRequiredQualityGate(gate: RequiredQualityGate | null): gate is RequiredQualityGate {
+  return gate !== null;
+}
+
+function normalizeRequiredQualityGates(value: unknown): RequiredQualityGate[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value
+    .map((gate) => {
+      if (typeof gate === 'string') {
+        return normalizeStringGate(gate);
+      }
+      return normalizeObjectGate(gate);
+    })
+    .filter(isRequiredQualityGate);
+}
+
+function getRequiredQualityGateSource(options: QualityGateOptions, repoSettings: unknown): unknown {
+  const explicitSource = selectOwnProperty(
+    'requiredQualityGates',
+    [options, propertyValue(options, 'ship')],
+    { skipUndefined: true }
+  );
+  if (explicitSource !== undefined) {
+    return explicitSource;
+  }
+
+  const repoSource = selectOwnProperty('requiredQualityGates', [
+    propertyValue(repoSettings, 'ship'),
+    repoSettings,
+  ]);
+  return repoSource === undefined ? [] : repoSource;
+}
+
+function resolveRequiredQualityGates(options: QualityGateOptions = {}): RequiredQualityGate[] {
+  const repoSettings = readRepoSettingsValue(options.cwd || process.cwd());
+  const source = getRequiredQualityGateSource(options, repoSettings);
+  return normalizeRequiredQualityGates(source);
+}
+
+function getClusterRequiredQualityGateSource(
+  config: QualityGateConfig,
+  options: QualityGateOptions
+): unknown {
+  return selectOwnProperty(
+    'requiredQualityGates',
+    [options, propertyValue(options, 'ship'), propertyValue(config, 'ship'), config],
+    { skipUndefined: true }
+  );
+}
+
+function resolveClusterRequiredQualityGates(
+  config: QualityGateConfig = {},
+  options: QualityGateOptions = {}
+): RequiredQualityGate[] {
+  const configuredSource = getClusterRequiredQualityGateSource(config, options);
+  if (configuredSource !== undefined) {
+    return normalizeRequiredQualityGates(configuredSource);
+  }
+
+  return resolveRequiredQualityGates({ ...options, cwd: options.cwd || process.cwd() });
+}
+
+export = {
+  normalizeRequiredQualityGates,
+  resolveRequiredQualityGates,
+  resolveClusterRequiredQualityGates,
+};

package/src/repo-settings-access.js

@@ -0,0 +1,40 @@
+"use strict";
+function isRepoSettingsModule(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'readRepoSettings' in value &&
+        typeof value.readRepoSettings === 'function');
+}
+const repoSettingsModule = require('../lib/repo-settings');
+if (!isRepoSettingsModule(repoSettingsModule)) {
+    throw new TypeError('repo-settings must export readRepoSettings');
+}
+const readRepoSettings = repoSettingsModule.readRepoSettings;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function propertyValue(value, key) {
+    return isRecord(value) ? value[key] : undefined;
+}
+function selectOwnProperty(key, candidates, options = {}) {
+    for (const candidate of candidates) {
+        if (!Object.prototype.hasOwnProperty.call(candidate || {}, key)) {
+            continue;
+        }
+        const value = propertyValue(candidate, key);
+        if (options.skipUndefined && value === undefined) {
+            continue;
+        }
+        return value;
+    }
+    return undefined;
+}
+function readRepoSettingsValue(startDir) {
+    return readRepoSettings(startDir).settings || {};
+}
+module.exports = {
+    isRecord,
+    propertyValue,
+    readRepoSettingsValue,
+    selectOwnProperty,
+};