@the-open-engine/zeroshot 6.38.1 → 6.39.0

package/src/legacy-lib/start-cluster.ts

@@ -0,0 +1,237 @@
+interface Settings extends Record<string, unknown> {}
+
+interface ClusterConfig extends Record<string, unknown> {}
+
+interface ClusterInput extends Record<string, string> {}
+
+interface OrchestratorFacade {
+  loadConfig(configPath: string): ClusterConfig;
+  start(config: ClusterConfig, input: ClusterInput, options: unknown): unknown;
+}
+
+interface ProviderNamesFacade {
+  normalizeProviderName(name: string): string;
+}
+
+interface ProvidersFacade {
+  getProvider(providerId: string): unknown;
+}
+
+interface IssueProvidersFacade {
+  detectProvider(input: string, settings: Settings, forceProvider: string | null): unknown;
+}
+
+interface ConfigHelpersFacade {
+  resolveConfigPath(configName: string): string;
+  prepareClusterConfig(
+    config: ClusterConfig,
+    settings?: Settings,
+    providerOverride?: string | null
+  ): ClusterConfig;
+  loadClusterConfig(
+    orchestrator: OrchestratorFacade,
+    configPath: string,
+    settings?: Settings,
+    providerOverride?: string | null
+  ): ClusterConfig;
+}
+
+interface RunOptionsHelpersFacade {
+  buildStartOptions(args: Record<string, unknown>): unknown;
+  buildTrustedStartOptions(args: Record<string, unknown>): unknown;
+  resolveEffectiveRunPlan(options?: Record<string, unknown>, settings?: Settings): unknown;
+  detectGitRepoRoot(): string;
+}
+
+interface ProviderOverrideOptions {
+  provider?: string | null;
+  envProvider?: string | null;
+  validateProvider?: unknown;
+}
+
+interface StartClusterArgs extends Record<string, unknown> {
+  orchestrator?: OrchestratorFacade;
+  config?: ClusterConfig | null;
+  configPath?: string | null;
+  configName?: string | null;
+  settings?: Settings;
+  providerOverride?: string | null;
+  modelOverride?: unknown;
+  forceProvider?: unknown;
+  clusterId?: unknown;
+  options?: Record<string, unknown>;
+  text: string;
+  issue: string;
+  file: string;
+}
+
+interface ResolveConfigArgs {
+  orchestrator: OrchestratorFacade;
+  config?: ClusterConfig | null | undefined;
+  configPath?: string | null | undefined;
+  configName?: string | null | undefined;
+  settings?: Settings | undefined;
+  providerOverride?: string | null | undefined;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const providerNames: ProviderNamesFacade = require('./provider-names');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const providers: ProvidersFacade = require('../src/providers');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const issueProviders: IssueProvidersFacade = require('../src/issue-providers');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const configHelpers: ConfigHelpersFacade = require('./start-cluster-config');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const runOptionsHelpers: RunOptionsHelpersFacade = require('./start-cluster-run-options');
+
+const { normalizeProviderName } = providerNames;
+const { getProvider } = providers;
+const { detectProvider } = issueProviders;
+const { resolveConfigPath, prepareClusterConfig, loadClusterConfig } = configHelpers;
+const { buildStartOptions, buildTrustedStartOptions, resolveEffectiveRunPlan, detectGitRepoRoot } =
+  runOptionsHelpers;
+
+function buildTextInput(text: string): ClusterInput {
+  return { text };
+}
+
+function buildIssueInput(issue: string): ClusterInput {
+  return { issue };
+}
+
+function buildFileInput(file: string): ClusterInput {
+  return { file };
+}
+
+function detectRunInput(
+  inputArg: string,
+  settings: Settings = {},
+  forceProvider: string | null = null
+): ClusterInput {
+  const isMarkdownFile = /\.(md|markdown)$/i.test(inputArg);
+  if (isMarkdownFile) {
+    return buildFileInput(inputArg);
+  }
+
+  const ProviderClass = detectProvider(inputArg, settings, forceProvider);
+  if (ProviderClass) {
+    return buildIssueInput(inputArg);
+  }
+
+  return buildTextInput(inputArg);
+}
+
+const STDIN_MARKER = '-';
+
+function isStdinInput(inputArg: string): boolean {
+  return inputArg === STDIN_MARKER;
+}
+
+async function readStdinText(
+  stream: AsyncIterable<string | Uint8Array> = process.stdin
+): Promise<string> {
+  const chunks: Array<string | Uint8Array> = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks.map((chunk) => (Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))))
+    .toString('utf8')
+    .trim();
+}
+
+function encodeStdinEnv(text: string): string {
+  return Buffer.from(text, 'utf8').toString('base64');
+}
+
+function decodeStdinEnv(value: string): string {
+  return Buffer.from(value, 'base64').toString('utf8');
+}
+
+function resolveProviderOverride(options: ProviderOverrideOptions = {}): string | null {
+  const override = options.provider || options.envProvider || process.env.ZEROSHOT_PROVIDER;
+  if (!override || !override.trim()) {
+    return null;
+  }
+  const normalized = normalizeProviderName(override);
+  if (options.validateProvider) {
+    getProvider(normalized);
+  }
+  return normalized;
+}
+
+function resolveConfigOrThrow({
+  orchestrator,
+  config,
+  configPath,
+  configName,
+  settings,
+  providerOverride,
+}: ResolveConfigArgs): ClusterConfig {
+  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: StartClusterArgs, input: ClusterInput): unknown {
+  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: StartClusterArgs): unknown {
+  return startClusterWithInput(args, buildTextInput(args.text));
+}
+
+function startClusterFromIssue(args: StartClusterArgs): unknown {
+  return startClusterWithInput(args, buildIssueInput(args.issue));
+}
+
+function startClusterFromFile(args: StartClusterArgs): unknown {
+  return startClusterWithInput(args, buildFileInput(args.file));
+}
+
+export = {
+  buildTextInput,
+  buildIssueInput,
+  buildFileInput,
+  detectRunInput,
+  isStdinInput,
+  readStdinText,
+  encodeStdinEnv,
+  decodeStdinEnv,
+  resolveProviderOverride,
+  resolveConfigPath,
+  prepareClusterConfig,
+  loadClusterConfig,
+  buildStartOptions,
+  buildTrustedStartOptions,
+  resolveEffectiveRunPlan,
+  startClusterFromText,
+  startClusterFromIssue,
+  startClusterFromFile,
+  detectGitRepoRoot,
+};

package/src/legacy-lib/stream-json-parser.ts

@@ -0,0 +1,88 @@
+/**
+ * Provider-agnostic stream-json parser for `zeroshot logs`.
+ *
+ * Provider parsing is delegated to the helper-backed runtime provider facade.
+ */
+
+type ParsedEvent = Readonly<Record<string, unknown>>;
+type ProviderEvent = ParsedEvent | ParsedEvent[] | null;
+
+interface ProviderParser {
+  parseEvent(line: string): ProviderEvent;
+}
+
+interface ProviderFacade {
+  getProvider(name: string): ProviderParser;
+  listProviders(): string[];
+}
+
+// The runtime facade is maintained JavaScript; keep its original emitted require path.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { getProvider, listProviders }: ProviderFacade = require('../src/providers');
+
+function createProviderParsers(): ProviderParser[] {
+  return listProviders().map((name) => getProvider(name));
+}
+
+function stripTimestampPrefix(line: unknown): string {
+  if (!line || typeof line !== 'string') return '';
+  let trimmed = line.trim().replace(/\r$/, '');
+  if (!trimmed) return '';
+
+  const tsMatch = /^\[(\d{13})\](.*)$/.exec(trimmed);
+  if (tsMatch) trimmed = (tsMatch[2] || '').trimStart();
+
+  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+    const pipeMatch = /^[^|]{1,40}\|\s*(.*)$/.exec(trimmed);
+    if (pipeMatch) {
+      const afterPipe = (pipeMatch[1] || '').trimStart();
+      if (afterPipe.startsWith('{') || afterPipe.startsWith('[')) return afterPipe;
+    }
+  }
+
+  return trimmed;
+}
+
+// The provider protocol intentionally permits one event, an event batch, or no event.
+// eslint-disable-next-line sonarjs/function-return-type
+function parseEvent(
+  line: unknown,
+  providerParsers: readonly ProviderParser[] = createProviderParsers()
+): ProviderEvent {
+  const content = stripTimestampPrefix(line);
+  let result: ProviderEvent = null;
+  if (content) {
+    for (const provider of providerParsers) {
+      const event = provider.parseEvent(content);
+      if (event) {
+        result = event;
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+function collectEvent(events: ParsedEvent[], event: ProviderEvent): void {
+  if (!event) return;
+  if (Array.isArray(event)) {
+    events.push(...event);
+    return;
+  }
+  events.push(event);
+}
+
+function parseChunk(chunk: unknown): ParsedEvent[] {
+  const events: ParsedEvent[] = [];
+  const lines = String(chunk || '').split('\n');
+  const providerParsers = createProviderParsers();
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    collectEvent(events, parseEvent(line, providerParsers));
+  }
+
+  return events;
+}
+
+export = { parseEvent, parseChunk };

package/src/message-buffer.js

@@ -1,81 +1,65 @@
+"use strict";
 /**
- * Message buffering helper
- *
- * Ensures trigger-matching messages are never dropped just because an agent/subcluster is busy.
- * Dropped workflow signals (e.g. VALIDATION_RESULT) can wedge clusters in "running" state.
+ * Ensures trigger-matching messages are never dropped just because an
+ * agent or subcluster is busy.
  */
-
 function bufferMessage(target, message, options = {}) {
-  const maxBuffered = options.maxBuffered ?? 200;
-
-  if (!target._bufferedMessages) {
-    target._bufferedMessages = [];
-  }
-
-  if (target._bufferedMessages.length >= maxBuffered) {
-    target._bufferedMessages.shift();
-  }
-
-  target._bufferedMessages.push(message);
+    const maxBuffered = options.maxBuffered ?? 200;
+    if (!target._bufferedMessages) {
+        target._bufferedMessages = [];
+    }
+    if (target._bufferedMessages.length >= maxBuffered) {
+        target._bufferedMessages.shift();
+    }
+    target._bufferedMessages.push(message);
 }
-
 function scheduleDrain(target, drainFn, options = {}) {
-  if (target._bufferDrainScheduled) {
-    return;
-  }
-
-  target._bufferDrainScheduled = true;
-
-  const label = options.label || 'MessageBuffer';
-  const id = target.id || 'unknown';
-
-  const run = () => {
-    target._bufferDrainScheduled = false;
-    drainFn().catch((error) => {
-      console.error(`\n${'='.repeat(80)}`);
-      console.error(`🔴 FATAL: ${label} drain crashed (${id})`);
-      console.error(`${'='.repeat(80)}`);
-      console.error(`Error: ${error.message}`);
-      console.error(`Stack: ${error.stack}`);
-      console.error(`${'='.repeat(80)}\n`);
-      setImmediate(() => {
-        throw error;
-      });
-    });
-  };
-
-  const current = target._currentExecution;
-  if (current && typeof current.finally === 'function') {
-    current.finally(() => setImmediate(run));
-    return;
-  }
-
-  setImmediate(run);
+    if (target._bufferDrainScheduled) {
+        return;
+    }
+    target._bufferDrainScheduled = true;
+    const label = options.label || 'MessageBuffer';
+    const id = target.id || 'unknown';
+    const run = () => {
+        target._bufferDrainScheduled = false;
+        drainFn().catch((error) => {
+            console.error(`\n${'='.repeat(80)}`);
+            console.error(`🔴 FATAL: ${label} drain crashed (${id})`);
+            console.error(`${'='.repeat(80)}`);
+            console.error(`Error: ${error.message}`);
+            console.error(`Stack: ${error.stack}`);
+            console.error(`${'='.repeat(80)}\n`);
+            setImmediate(() => {
+                throw error;
+            });
+        });
+    };
+    const current = target._currentExecution;
+    if (current && typeof current.finally === 'function') {
+        current.finally(() => setImmediate(run));
+        return;
+    }
+    setImmediate(run);
 }
-
 async function drainBufferedMessages(target, handleFn, options = {}) {
-  if (!target.running) {
-    return;
-  }
-
-  const buffer = target._bufferedMessages;
-  if (!buffer || buffer.length === 0) {
-    return;
-  }
-
-  if (target.state !== 'idle') {
-    scheduleDrain(target, () => drainBufferedMessages(target, handleFn, options), options);
-    return;
-  }
-
-  while (target.running && target.state === 'idle' && buffer.length > 0) {
-    const next = buffer.shift();
-    await handleFn(next);
-  }
+    if (!target.running) {
+        return;
+    }
+    const buffer = target._bufferedMessages;
+    if (!buffer || buffer.length === 0) {
+        return;
+    }
+    if (target.state !== 'idle') {
+        scheduleDrain(target, () => drainBufferedMessages(target, handleFn, options), options);
+        return;
+    }
+    while (target.running && target.state === 'idle' && buffer.length > 0) {
+        const next = buffer.shift();
+        await handleFn(next);
+    }
 }
-
 module.exports = {
-  bufferMessage,
-  scheduleDrain,
-  drainBufferedMessages,
+    bufferMessage,
+    scheduleDrain,
+    drainBufferedMessages,
 };

package/src/message-buffer.ts

@@ -0,0 +1,107 @@
+interface MessageBufferTarget {
+  _bufferedMessages?: unknown[];
+  _bufferDrainScheduled?: boolean;
+  _currentExecution?: Promise<unknown> | null;
+  id?: string;
+  running: boolean;
+  state: string;
+}
+
+interface MessageBufferOptions {
+  maxBuffered?: number;
+  label?: string;
+}
+
+type DrainFunction = () => Promise<unknown>;
+type MessageHandler = (message: unknown) => Promise<unknown> | unknown;
+
+/**
+ * Ensures trigger-matching messages are never dropped just because an
+ * agent or subcluster is busy.
+ */
+function bufferMessage(
+  target: MessageBufferTarget,
+  message: unknown,
+  options: MessageBufferOptions = {}
+): void {
+  const maxBuffered = options.maxBuffered ?? 200;
+
+  if (!target._bufferedMessages) {
+    target._bufferedMessages = [];
+  }
+
+  if (target._bufferedMessages.length >= maxBuffered) {
+    target._bufferedMessages.shift();
+  }
+
+  target._bufferedMessages.push(message);
+}
+
+function scheduleDrain(
+  target: MessageBufferTarget,
+  drainFn: DrainFunction,
+  options: MessageBufferOptions = {}
+): void {
+  if (target._bufferDrainScheduled) {
+    return;
+  }
+
+  target._bufferDrainScheduled = true;
+
+  const label = options.label || 'MessageBuffer';
+  const id = target.id || 'unknown';
+
+  const run = (): void => {
+    target._bufferDrainScheduled = false;
+    drainFn().catch((error: Error) => {
+      console.error(`\n${'='.repeat(80)}`);
+      console.error(`🔴 FATAL: ${label} drain crashed (${id})`);
+      console.error(`${'='.repeat(80)}`);
+      console.error(`Error: ${error.message}`);
+      console.error(`Stack: ${error.stack}`);
+      console.error(`${'='.repeat(80)}\n`);
+      setImmediate(() => {
+        throw error;
+      });
+    });
+  };
+
+  const current = target._currentExecution;
+  if (current && typeof current.finally === 'function') {
+    current.finally(() => setImmediate(run));
+    return;
+  }
+
+  setImmediate(run);
+}
+
+async function drainBufferedMessages(
+  target: MessageBufferTarget,
+  handleFn: MessageHandler,
+  options: MessageBufferOptions = {}
+): Promise<void> {
+  if (!target.running) {
+    return;
+  }
+
+  const buffer = target._bufferedMessages;
+  if (!buffer || buffer.length === 0) {
+    return;
+  }
+
+  if (target.state !== 'idle') {
+    scheduleDrain(target, () => drainBufferedMessages(target, handleFn, options), options);
+    return;
+  }
+
+  while (target.running && target.state === 'idle' && buffer.length > 0) {
+    const next = buffer.shift();
+    await handleFn(next);
+  }
+}
+
+export = {
+  bufferMessage,
+  scheduleDrain,
+  drainBufferedMessages,
+};