@the-open-engine/zeroshot 6.38.1 → 6.39.1

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

@@ -0,0 +1,281 @@
+type RunIsolation = 'none' | 'worktree' | 'docker';
+type RunDelivery = 'none' | 'pr' | 'ship';
+
+interface RunPlan {
+  isolation: RunIsolation;
+  delivery: RunDelivery;
+  autoMerge: boolean;
+}
+
+interface Settings extends Record<string, unknown> {
+  defaultIsolation?: string;
+  defaultDelivery?: string;
+}
+
+interface RunOptions extends Record<string, unknown> {
+  autoMerge?: unknown;
+  autoPush?: unknown;
+  closeIssue?: unknown;
+  containerHome?: unknown;
+  cwd?: unknown;
+  docker?: unknown;
+  dockerImage?: unknown;
+  isolation?: unknown;
+  mergeQueue?: unknown;
+  mount?: readonly string[] | null;
+  mounts?: unknown;
+  noIsolation?: unknown;
+  noMounts?: unknown;
+  pr?: unknown;
+  prBase?: unknown;
+  prBody?: unknown;
+  preparedWorktree?: unknown;
+  requiredQualityGates?: unknown;
+  ship?: unknown;
+  worktree?: unknown;
+}
+
+interface RunPlanFacade {
+  resolveRunPlan(options?: RunOptions): Readonly<RunPlan>;
+}
+
+interface RunModeFacade {
+  runModeFromPlan(plan: RunPlan): string | null;
+}
+
+interface EnvironmentFacade {
+  firstTruthy<T>(...values: T[]): T | undefined;
+  anyTruthy(...values: unknown[]): boolean;
+  optionalValue<T>(value: T): T | undefined;
+  detectGitRepoRoot(): string;
+  resolveTargetCwd(): string | undefined;
+  resolveEnvBool(value: unknown): boolean | undefined;
+  mergeRunOptions(options: RunOptions): RunOptions;
+  resolveMergeQueue(options: RunOptions): boolean | undefined;
+  resolvePrBase(options: RunOptions): string | undefined;
+  resolveCloseIssue(options: RunOptions): 'auto' | 'always' | 'never' | undefined;
+  resolveMounts(options: RunOptions):
+    | Array<{ host: string; container: string; readonly: boolean }>
+    | undefined;
+}
+
+interface BuildStartOptionsArgs {
+  clusterId?: unknown;
+  options?: RunOptions;
+  settings?: Settings;
+  providerOverride?: unknown;
+  modelOverride?: unknown;
+  forceProvider?: unknown;
+}
+
+interface BuildTrustedStartOptionsArgs extends BuildStartOptionsArgs {
+  plan?: RunPlan | null;
+}
+
+interface BuildStartOptionsFromPlanArgs extends BuildStartOptionsArgs {
+  plan: RunPlan;
+  options: RunOptions;
+  settings: Settings;
+  preparedWorktree?: unknown;
+  environment: boolean;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const runPlan: RunPlanFacade = require('./run-plan');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const runMode: RunModeFacade = require('./run-mode');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const environmentHelpers: EnvironmentFacade = require('./start-cluster-environment');
+
+const { resolveRunPlan } = runPlan;
+const { runModeFromPlan } = runMode;
+const {
+  firstTruthy,
+  anyTruthy,
+  optionalValue,
+  detectGitRepoRoot,
+  resolveTargetCwd,
+  resolveEnvBool,
+  mergeRunOptions,
+  resolveMergeQueue,
+  resolvePrBase,
+  resolveCloseIssue,
+  resolveMounts,
+} = environmentHelpers;
+
+function isRunIsolation(value: string): value is RunIsolation {
+  return value === 'none' || value === 'worktree' || value === 'docker';
+}
+
+function isRunDelivery(value: string): value is RunDelivery {
+  return value === 'none' || value === 'pr' || value === 'ship';
+}
+
+function validateSavedRunModes(settings: Settings): {
+  isolation: RunIsolation;
+  delivery: RunDelivery;
+} {
+  const isolation = settings.defaultIsolation || 'none';
+  const delivery = settings.defaultDelivery || 'none';
+  if (!isRunIsolation(isolation)) {
+    throw new Error(`Invalid saved isolation mode: ${isolation}`);
+  }
+  if (!isRunDelivery(delivery)) {
+    throw new Error(`Invalid saved delivery mode: ${delivery}`);
+  }
+  return { isolation, delivery };
+}
+
+function resolveEffectiveIsolation(options: RunOptions, savedIsolation: RunIsolation): RunIsolation {
+  if (options.noIsolation === true || options.isolation === false) return 'none';
+  if (options.docker === true) return 'docker';
+  if (options.worktree === true || options.pr === true || options.ship === true) return 'worktree';
+  if (resolveEnvBool(process.env.ZEROSHOT_DOCKER) === true) return 'docker';
+  if (resolveEnvBool(process.env.ZEROSHOT_WORKTREE) === true) return 'worktree';
+  return savedIsolation;
+}
+
+function resolveEffectiveDelivery(options: RunOptions, savedDelivery: RunDelivery): RunDelivery {
+  if (options.ship === true || options.autoMerge === true) return 'ship';
+  if (options.pr === true || resolveEnvBool(process.env.ZEROSHOT_PR) === true) return 'pr';
+  return savedDelivery;
+}
+
+function resolveEffectiveRunPlan(
+  options: RunOptions = {},
+  settings: Settings = {}
+): Readonly<RunPlan> {
+  const mergedOptions = mergeRunOptions(options);
+  const noIsolation = mergedOptions.noIsolation === true || mergedOptions.isolation === false;
+  const conflicts = ['docker', 'worktree', 'pr', 'ship'].filter(
+    (key) => mergedOptions[key] === true
+  );
+  if (noIsolation && conflicts.length > 0) {
+    throw new Error(`--no-isolation conflicts with --${conflicts.join(', --')}`);
+  }
+
+  const saved = validateSavedRunModes(settings);
+  let isolation = resolveEffectiveIsolation(mergedOptions, saved.isolation);
+  const delivery = resolveEffectiveDelivery(mergedOptions, saved.delivery);
+  if (delivery !== 'none' && isolation === 'none') {
+    if (noIsolation) {
+      throw new Error(`--no-isolation conflicts with saved delivery mode "${delivery}"`);
+    }
+    isolation = 'worktree';
+  }
+  return resolveRunPlan({
+    docker: isolation === 'docker',
+    worktree: isolation === 'worktree',
+    pr: delivery === 'pr',
+    ship: delivery === 'ship',
+  });
+}
+
+function buildStartOptionsFromPlan({
+  clusterId,
+  plan,
+  options,
+  settings,
+  providerOverride,
+  modelOverride,
+  forceProvider,
+  preparedWorktree,
+  environment,
+}: BuildStartOptionsFromPlanArgs): Readonly<Record<string, unknown>> {
+  const targetCwd = environment ? resolveTargetCwd() : options.cwd;
+  return Object.freeze({
+    clusterId,
+    cwd: targetCwd,
+    isolation: plan.isolation === 'docker',
+    isolationImage: environment
+      ? firstTruthy(options.dockerImage, process.env.ZEROSHOT_DOCKER_IMAGE)
+      : optionalValue(options.dockerImage),
+    worktree: plan.isolation === 'worktree',
+    preparedWorktree: preparedWorktree || undefined,
+    autoPr: plan.delivery !== 'none',
+    autoMerge: plan.autoMerge,
+    autoPush: environment ? process.env.ZEROSHOT_PUSH === '1' : options.autoPush === true,
+    modelOverride: optionalValue(modelOverride),
+    providerOverride: optionalValue(providerOverride),
+    noMounts: anyTruthy(options.mounts === false, options.noMounts === true),
+    mounts: resolveMounts(options),
+    containerHome: optionalValue(options.containerHome),
+    forceProvider: optionalValue(forceProvider),
+    prBase: environment ? resolvePrBase(options) : optionalValue(options.prBase),
+    prBody: typeof options.prBody === 'string' ? options.prBody : undefined,
+    mergeQueue: environment ? resolveMergeQueue(options) : optionalValue(options.mergeQueue),
+    closeIssue: environment ? resolveCloseIssue(options) : optionalValue(options.closeIssue),
+    ship: plan.delivery === 'ship',
+    runMode: runModeFromPlan(plan),
+    requiredQualityGates: options.requiredQualityGates,
+    settings,
+  });
+}
+
+function buildStartOptions({
+  clusterId,
+  options = {},
+  settings = {},
+  providerOverride,
+  modelOverride,
+  forceProvider,
+}: BuildStartOptionsArgs): Readonly<Record<string, unknown>> {
+  const mergedOptions = mergeRunOptions(options);
+  const plan = resolveEffectiveRunPlan(options, settings);
+  return buildStartOptionsFromPlan({
+    clusterId,
+    plan,
+    options: mergedOptions,
+    settings,
+    providerOverride,
+    modelOverride,
+    forceProvider,
+    environment: true,
+  });
+}
+
+function buildTrustedStartOptions({
+  clusterId,
+  plan,
+  options = {},
+  settings = {},
+  providerOverride,
+  modelOverride,
+  forceProvider,
+}: BuildTrustedStartOptionsArgs): Readonly<Record<string, unknown>> {
+  if (!plan || !Object.isFrozen(plan)) {
+    throw new Error('Trusted start requires a frozen canonical run plan');
+  }
+  const canonical = resolveRunPlan({
+    docker: plan.isolation === 'docker',
+    worktree: plan.isolation === 'worktree',
+    pr: plan.delivery === 'pr',
+    ship: plan.delivery === 'ship',
+  });
+  if (
+    canonical.isolation !== plan.isolation ||
+    canonical.delivery !== plan.delivery ||
+    canonical.autoMerge !== plan.autoMerge
+  ) {
+    throw new Error('Trusted start plan is not canonical');
+  }
+  if (canonical.isolation === 'none') {
+    throw new Error('Trusted worker start requires worktree or docker isolation');
+  }
+  if (options.preparedWorktree && canonical.isolation !== 'worktree') {
+    throw new Error('Prepared worktree requires canonical worktree isolation');
+  }
+  return buildStartOptionsFromPlan({
+    clusterId,
+    plan: canonical,
+    options,
+    settings,
+    providerOverride,
+    modelOverride,
+    forceProvider,
+    preparedWorktree: options.preparedWorktree,
+    environment: false,
+  });
+}
+
+export = { buildStartOptions, buildTrustedStartOptions, resolveEffectiveRunPlan, detectGitRepoRoot };

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 };