@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/legacy-lib/omelette.d.ts

@@ -0,0 +1,15 @@
+declare module 'omelette' {
+  interface CompletionData {
+    line: string;
+    reply(candidates: string[]): void;
+  }
+
+  interface Completion {
+    init(): void;
+    on(event: 'complete', listener: (fragment: string, data: CompletionData) => void): this;
+  }
+
+  function omelette(template: string): Completion;
+
+  export = omelette;
+}

package/src/legacy-lib/path-check.ts

@@ -0,0 +1,89 @@
+/**
+ * Detects whether the npm global bin directory is on PATH, so we can warn
+ * the user when `npm install -g` succeeds but the `zeroshot` binary is
+ * unreachable (e.g. non-standard Node installs whose global bin dir isn't
+ * exported).
+ */
+
+import path = require('path');
+
+interface PathCheckOptions {
+  readonly installPrefix?: string;
+  readonly pathEnv?: string;
+}
+
+interface UpdateCheckerModule {
+  readonly getInstallPrefix: (options: PathCheckOptions) => string;
+}
+
+type PathCheckResult =
+  | { readonly onPath: true; readonly binDir: null }
+  | { readonly onPath: boolean; readonly binDir: string };
+
+function isUpdateCheckerModule(value: unknown): value is UpdateCheckerModule {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'getInstallPrefix' in value &&
+    typeof value.getInstallPrefix === 'function'
+  );
+}
+
+function getGlobalBinDir(installPrefix: string): string {
+  if (process.platform === 'win32') {
+    return installPrefix;
+  }
+
+  return path.join(installPrefix, 'bin');
+}
+
+function isDirOnPath(dir: string, pathEnv: string = process.env.PATH || ''): boolean {
+  const resolvedDir = path.resolve(dir);
+
+  return pathEnv
+    .split(path.delimiter)
+    .filter((entry) => entry.length > 0)
+    .some((entry) => path.resolve(entry) === resolvedDir);
+}
+
+function getPathExportLine(dir: string): string {
+  return `export PATH="${dir}:$PATH"`;
+}
+
+function checkBinDirOnPath(options: PathCheckOptions = {}): PathCheckResult {
+  if (process.platform === 'win32') {
+    return { onPath: true, binDir: null };
+  }
+
+  try {
+    const updateChecker: unknown = require('../cli/lib/update-checker');
+    if (!isUpdateCheckerModule(updateChecker)) {
+      throw new TypeError('update-checker must export getInstallPrefix');
+    }
+    const { getInstallPrefix } = updateChecker;
+    const installPrefix = options.installPrefix || getInstallPrefix(options);
+    const binDir = getGlobalBinDir(installPrefix);
+
+    return { onPath: isDirOnPath(binDir, options.pathEnv), binDir };
+  } catch {
+    return { onPath: true, binDir: null };
+  }
+}
+
+function printPathWarning(binDir: string): void {
+  console.error(
+    `[zeroshot] Warning: ${binDir} is not on your PATH — the 'zeroshot' command may not be found.`
+  );
+  console.error(`  ${getPathExportLine(binDir)}`);
+  console.error(
+    '  Add this line to your shell profile (~/.zshrc, ~/.bashrc, or ~/.profile) to fix this permanently.'
+  );
+}
+
+export = {
+  getGlobalBinDir,
+  isDirOnPath,
+  getPathExportLine,
+  checkBinDirOnPath,
+  printPathWarning,
+};

package/src/legacy-lib/process-liveness.ts

@@ -0,0 +1,36 @@
+/**
+ * Single source of truth for "is this PID actually alive?"
+ *
+ * Previously this check was reimplemented separately in src/orchestrator.js
+ * (_isProcessRunning) and lib/detached-startup.js (isProcessAlive), plus an
+ * inline copy in _getActiveClustersForIssue. Four of those call sites agreed
+ * on the answer; the resume() eligibility guard trusted persisted cluster
+ * state instead of asking the OS, which is what let a dead-PID cluster be
+ * simultaneously reported as "zombie" by status and "still running" by
+ * resume. Consolidating avoids a sixth call site reintroducing that split.
+ */
+
+function hasErrorCode(error: unknown, code: string): boolean {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'code' in error &&
+    error.code === code
+  );
+}
+
+function isProcessRunning(pid: unknown): boolean {
+  if (!pid || typeof pid !== 'number' || !Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    // Signal 0 doesn't kill, just checks if the process exists.
+    process.kill(pid, 0);
+    return true;
+  } catch (error: unknown) {
+    // ESRCH = no such process, EPERM = process exists but we lack permission.
+    return hasErrorCode(error, 'EPERM');
+  }
+}
+
+export = { isProcessRunning };

package/src/legacy-lib/provider-credential-path.ts

@@ -0,0 +1,57 @@
+import os = require('node:os');
+import path = require('node:path');
+
+type Environment = Readonly<Record<string, string | undefined>>;
+
+interface ProviderCredentialMetadata {
+  readonly credentialPaths: readonly string[];
+  readonly docker?: {
+    readonly mount?: {
+      readonly hostEnv?: unknown;
+    };
+  };
+}
+
+function expandHome(value: string): string {
+  if (value === '~') return os.homedir();
+  return value.startsWith('~/') ? path.join(os.homedir(), value.slice(2)) : value;
+}
+
+function expandProviderCredentialPath(
+  value: string,
+  env: Environment = process.env
+): string | null {
+  const homeExpanded = expandHome(value);
+  if (homeExpanded !== value) return homeExpanded;
+  const variable = /^\$([A-Z_][A-Z0-9_]*)(\/.*)?$/.exec(value);
+  if (!variable) return value;
+  const variableName = variable[1];
+  if (!variableName) return value;
+  const root = env[variableName];
+  return typeof root === 'string' && root.trim()
+    ? path.resolve(expandHome(root), `.${variable[2] || ''}`)
+    : null;
+}
+
+function resolveProviderCredentialPaths(
+  metadata: ProviderCredentialMetadata,
+  env: Environment = process.env
+): string[] {
+  const overrideName = metadata.docker?.mount?.hostEnv;
+  const overrideSet =
+    typeof overrideName === 'string' &&
+    typeof env[overrideName] === 'string' &&
+    env[overrideName].trim();
+  const candidates = overrideName
+    ? metadata.credentialPaths.filter((value) =>
+        overrideSet
+          ? value.startsWith(`$${overrideName}/`)
+          : !value.startsWith(`$${overrideName}/`)
+      )
+    : metadata.credentialPaths;
+  return candidates
+    .map((value) => expandProviderCredentialPath(value, env))
+    .filter((value): value is string => value !== null);
+}
+
+export = { expandProviderCredentialPath, resolveProviderCredentialPaths };

package/src/legacy-lib/provider-defaults.ts

@@ -0,0 +1,114 @@
+/**
+ * Provider defaults module
+ *
+ * Separated from settings.js to break circular dependency:
+ * - settings.js requires provider defaults
+ * - providers require settings.js (for loadSettings, getClaudeCommand, etc.)
+ *
+ * CRITICAL: This module should NOT import from settings.js
+ */
+
+interface ProviderDefaultSettings {
+  defaultLevel?: string;
+  levelOverrides?: Record<string, string>;
+  maxLevel?: string;
+  minLevel?: string;
+  [key: string]: unknown;
+}
+
+interface ProviderMetadata {
+  defaultLevels: {
+    default: string;
+    max: string;
+    min: string;
+  };
+}
+
+interface ProviderNamesFacade {
+  VALID_PROVIDERS: readonly string[];
+  getProviderMetadata(name: string): ProviderMetadata;
+}
+
+interface ProviderFacade {
+  getDefaultSettings(): ProviderDefaultSettings;
+}
+
+interface ProvidersFacade {
+  getProvider(name: string): ProviderFacade;
+  listProviders(): string[];
+}
+
+type ProviderDefaults = Record<string, ProviderDefaultSettings>;
+
+// Cache provider defaults to avoid repeated instantiation
+let _providerDefaultsCache: ProviderDefaults | null = null;
+// The emitted CommonJS module resolves this maintained JavaScript facade from lib/.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { VALID_PROVIDERS, getProviderMetadata }: ProviderNamesFacade = require('./provider-names');
+
+function errorMessage(error: unknown): string | undefined {
+  if (typeof error !== 'object' || error === null || !('message' in error)) {
+    return undefined;
+  }
+  return typeof error.message === 'string' ? error.message : String(error.message);
+}
+
+/**
+ * Build provider default settings by instantiating each provider
+ * and calling getDefaultSettings()
+ */
+function buildProviderDefaults(): ProviderDefaults {
+  // Keep this require lazy to preserve the settings/provider circular-dependency boundary.
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const { listProviders, getProvider }: ProvidersFacade = require('../src/providers');
+
+  const defaults: ProviderDefaults = {};
+  for (const providerName of listProviders()) {
+    try {
+      const provider = getProvider(providerName);
+      defaults[providerName] = provider.getDefaultSettings();
+    } catch (error: unknown) {
+      const metadata = getProviderMetadata(providerName);
+      console.warn(`Warning: Could not get defaults for ${providerName}: ${errorMessage(error)}`);
+      defaults[providerName] = {
+        maxLevel: metadata.defaultLevels.max,
+        minLevel: metadata.defaultLevels.min,
+        defaultLevel: metadata.defaultLevels.default,
+        levelOverrides: {},
+      };
+    }
+  }
+  for (const providerName of VALID_PROVIDERS) {
+    if (defaults[providerName]) continue;
+    const metadata = getProviderMetadata(providerName);
+    defaults[providerName] = {
+      maxLevel: metadata.defaultLevels.max,
+      minLevel: metadata.defaultLevels.min,
+      defaultLevel: metadata.defaultLevels.default,
+      levelOverrides: {},
+    };
+  }
+  return defaults;
+}
+
+/**
+ * Get or build cached provider defaults
+ */
+function getProviderDefaults(): ProviderDefaults {
+  if (!_providerDefaultsCache) {
+    _providerDefaultsCache = buildProviderDefaults();
+  }
+  return _providerDefaultsCache;
+}
+
+/**
+ * Clear the provider defaults cache (primarily for testing)
+ */
+function clearProviderDefaultsCache(): void {
+  _providerDefaultsCache = null;
+}
+
+export = {
+  getProviderDefaults,
+  clearProviderDefaultsCache,
+};

package/src/legacy-lib/provider-detection.ts

@@ -0,0 +1,67 @@
+import * as childProcess from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const { execSync, spawnSync } = childProcess;
+
+function commandExists(command: string): boolean {
+  if (!command) return false;
+  if (command.includes(path.sep)) {
+    return fs.existsSync(command);
+  }
+  const probe = process.platform === 'win32' ? `where ${command}` : `command -v ${command}`;
+  try {
+    execSync(probe, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getCommandPath(command: string): string | null {
+  if (!command) return null;
+  if (command.includes(path.sep)) {
+    return fs.existsSync(command) ? command : null;
+  }
+  const probe = process.platform === 'win32' ? `where ${command}` : `command -v ${command}`;
+  try {
+    const output = execSync(probe, { encoding: 'utf8', stdio: 'pipe' });
+    // `where` can return multiple matches (one per line); take the first.
+    const [firstMatch = ''] = output.split(/\r?\n/);
+    return firstMatch.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function getHelpOutput(command: string, args: string[] = []): string {
+  if (!commandExists(command)) return '';
+
+  const attempt = (flag: string): string => {
+    const result = spawnSync(command, [...args, flag], { encoding: 'utf8' });
+    if (result.status !== 0) return '';
+    const output = `${result.stdout || ''}${result.stderr || ''}`;
+    return output.trim();
+  };
+
+  const help = attempt('--help');
+  if (help) return help;
+
+  const alt = attempt('-h');
+  return alt || '';
+}
+
+function getVersionOutput(command: string, args: string[] = []): string {
+  if (!commandExists(command)) return '';
+  const result = spawnSync(command, [...args, '--version'], { encoding: 'utf8' });
+  if (result.status !== 0) return '';
+  const output = `${result.stdout || ''}${result.stderr || ''}`;
+  return output.trim();
+}
+
+export = {
+  commandExists,
+  getCommandPath,
+  getHelpOutput,
+  getVersionOutput,
+};

package/src/legacy-lib/provider-names.ts

@@ -0,0 +1,126 @@
+type ProviderCapabilityState = boolean | 'experimental';
+type ProviderCapabilities = Readonly<Record<string, ProviderCapabilityState>>;
+
+interface ProviderRegistryEntry {
+  readonly capabilities: ProviderCapabilities;
+  readonly docker: {
+    readonly envPassthrough: readonly string[];
+  };
+  readonly id: string;
+  readonly [key: string]: unknown;
+}
+
+interface ProviderRegistryFacade {
+  getDefaultProviderId(): string;
+  getProviderRegistryEntry(name: string): ProviderRegistryEntry;
+  knownProviderNames: readonly string[];
+  listProviderRegistryEntries(): readonly ProviderRegistryEntry[];
+  normalizeProviderName(name: string): string;
+  providerAliasMap: Readonly<Record<string, string>>;
+  providerIds: readonly string[];
+  resolveProviderCommand(name: string): {
+    readonly args: readonly string[];
+    readonly command: string;
+  };
+  supportsProviderCapability(name: string, capability: string): boolean;
+  supportsProviderOutputReformatting(name: string): boolean;
+}
+
+// The emitted CommonJS facade resolves the built registry beside this module.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const registry: ProviderRegistryFacade = require('./agent-cli-provider/provider-registry');
+
+const VALID_PROVIDERS = [...registry.providerIds];
+const KNOWN_PROVIDER_NAMES = [...registry.knownProviderNames];
+const PROVIDER_ALIASES = Object.freeze({ ...registry.providerAliasMap });
+const PROVIDER_CAPABILITIES: Readonly<Record<string, ProviderCapabilities>> = Object.freeze(
+  Object.fromEntries(
+    registry.listProviderRegistryEntries().map((entry) => [entry.id, entry.capabilities])
+  )
+);
+
+// Non-string legacy inputs intentionally pass through unchanged.
+// eslint-disable-next-line sonarjs/function-return-type
+function normalizeProviderName<T>(name: T): T | string {
+  if (!name || typeof name !== 'string') return name;
+  return registry.normalizeProviderName(name);
+}
+
+// Non-record legacy settings intentionally pass through unchanged.
+// eslint-disable-next-line sonarjs/function-return-type
+function normalizeProviderSettings<T>(providerSettings: T): T | Record<string, unknown> {
+  if (
+    !providerSettings ||
+    typeof providerSettings !== 'object' ||
+    Array.isArray(providerSettings)
+  ) {
+    return providerSettings;
+  }
+
+  const normalized: Record<string, unknown> = {};
+  const entries = Object.entries(providerSettings);
+  entries.sort(([left], [right]) => {
+    const leftIsCanonical = normalizeProviderName(left) === left;
+    const rightIsCanonical = normalizeProviderName(right) === right;
+    if (leftIsCanonical === rightIsCanonical) return 0;
+    return leftIsCanonical ? 1 : -1;
+  });
+  const aliasFirst = entries;
+
+  for (const [key, value] of aliasFirst) {
+    const canonical = normalizeProviderName(key);
+    if (!VALID_PROVIDERS.includes(canonical)) {
+      normalized[key] = value;
+      continue;
+    }
+    // Preserve JavaScript object-spread coercion for malformed legacy values.
+    normalized[canonical] = {
+      ...Object(normalized[canonical] || {}),
+      ...Object(value || {}),
+    };
+  }
+
+  return normalized;
+}
+
+function getProviderMetadata(name: string): ProviderRegistryEntry {
+  return registry.getProviderRegistryEntry(name);
+}
+
+function listProviderMetadata(): readonly ProviderRegistryEntry[] {
+  return registry.listProviderRegistryEntries();
+}
+
+function resolveProviderCommand(name: string): {
+  readonly args: readonly string[];
+  readonly command: string;
+} {
+  return registry.resolveProviderCommand(name);
+}
+
+function providerSupportsCapability(name: string, capability: string): boolean {
+  return registry.supportsProviderCapability(name, capability);
+}
+
+function providerSupportsOutputReformatting(name: string): boolean {
+  return registry.supportsProviderOutputReformatting(name);
+}
+
+function getDefaultProviderId(): string {
+  return registry.getDefaultProviderId();
+}
+
+export = {
+  KNOWN_PROVIDER_NAMES,
+  PROVIDER_ALIASES,
+  PROVIDER_CAPABILITIES,
+  VALID_PROVIDERS,
+  getDefaultProviderId,
+  getProviderMetadata,
+  listProviderMetadata,
+  normalizeProviderName,
+  normalizeProviderSettings,
+  providerSupportsCapability,
+  providerSupportsOutputReformatting,
+  resolveProviderCommand,
+};

package/src/legacy-lib/repo-settings.ts

@@ -0,0 +1,88 @@
+/**
+ * Repo-local settings for zeroshot
+ *
+ * Optional per-repository config file:
+ *   <repoRoot>/.zeroshot/settings.json
+ *
+ * This complements the global user settings at:
+ *   ~/.zeroshot/settings.json
+ */
+
+import * as childProcess from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const { execSync } = childProcess;
+
+type RepoSettings = object;
+
+interface RepoSettingsResult {
+  repoRoot: string | null;
+  settings: RepoSettings | null;
+  settingsPath: string | null;
+}
+
+function safeJsonParse(text: string): unknown | null {
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function getGitRoot(dir: string): string | null {
+  try {
+    return execSync('git rev-parse --show-toplevel', {
+      cwd: dir,
+      encoding: 'utf8',
+      stdio: 'pipe',
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function readSettingsFile(filePath: string): RepoSettings | null {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed = safeJsonParse(raw);
+    if (!parsed || typeof parsed !== 'object') {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read repo-local settings if present.
+ */
+function readRepoSettings(startDir: string): RepoSettingsResult {
+  const repoRoot = getGitRoot(startDir);
+  if (!repoRoot) {
+    return { repoRoot: null, settings: null, settingsPath: null };
+  }
+
+  const settingsPath = path.join(repoRoot, '.zeroshot', 'settings.json');
+  if (!fs.existsSync(settingsPath)) {
+    return { repoRoot, settings: null, settingsPath };
+  }
+
+  const settings = readSettingsFile(settingsPath);
+  return { repoRoot, settings, settingsPath };
+}
+
+/**
+ * Write repo-local settings.
+ */
+function writeRepoSettings(repoRoot: string, settings: object): string {
+  const settingsPath = path.join(repoRoot, '.zeroshot', 'settings.json');
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+  const serialized = JSON.stringify(settings, null, 2);
+  fs.writeFileSync(settingsPath, serialized, 'utf8');
+  return settingsPath;
+}
+
+export = { readRepoSettings, writeRepoSettings };

package/src/legacy-lib/run-mode.ts

@@ -0,0 +1,58 @@
+import runPlan = require('./run-plan');
+
+type RunMode =
+  | 'ship'
+  | 'ship+docker'
+  | 'pr'
+  | 'pr+docker'
+  | 'docker'
+  | 'worktree'
+  | null;
+interface RunModePlan {
+  isolation: 'none' | 'worktree' | 'docker';
+  delivery: 'none' | 'pr' | 'ship';
+}
+interface RunModeOptions {
+  worktree?: unknown;
+  docker?: unknown;
+  pr?: unknown;
+  ship?: unknown;
+  autoMerge?: unknown;
+}
+
+const { resolveRunPlan } = runPlan as {
+  resolveRunPlan(options?: RunModeOptions): Readonly<RunModePlan & { autoMerge: boolean }>;
+};
+
+// The run-mode label is a VIEW of the canonical plan, never an independent
+// cascade. Deriving it from the plan is what keeps the user-facing label and the
+// actual isolation/delivery/autoMerge behavior from drifting apart. Callers that
+// already hold a plan (e.g. the effective plan with env/settings folded in) use
+// runModeFromPlan directly so the label reflects the SAME plan as behavior.
+function runModeFromPlan({ isolation, delivery }: RunModePlan): RunMode {
+  const dockerSuffix = isolation === 'docker' ? '+docker' : '';
+  if (delivery === 'ship') return `ship${dockerSuffix}`;
+  if (delivery === 'pr') return `pr${dockerSuffix}`;
+  if (isolation === 'docker') return 'docker';
+  if (isolation === 'worktree') return 'worktree';
+  return null;
+}
+
+function resolveRunMode(options?: RunModeOptions): RunMode {
+  return runModeFromPlan(resolveRunPlan(options));
+}
+
+const RUN_MODE_LABELS: Partial<Record<PropertyKey, string>> = {
+  ship: 'ship (worktree + PR + auto-merge)',
+  'ship+docker': 'ship (docker + PR + auto-merge)',
+  pr: 'pr (worktree + PR)',
+  'pr+docker': 'pr (docker + PR)',
+  docker: 'docker (isolated container)',
+  worktree: 'worktree (isolated branch)',
+};
+
+function describeRunMode(mode: PropertyKey | null | undefined): string {
+  return RUN_MODE_LABELS[mode ?? ''] || 'local (no isolation)';
+}
+
+export = { resolveRunMode, runModeFromPlan, describeRunMode };