@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/lib/process-liveness.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Single source of truth for "is this PID actually alive?"
  *
@@ -9,18 +10,24 @@
  * simultaneously reported as "zombie" by status and "still running" by
  * resume. Consolidating avoids a sixth call site reintroducing that split.
  */
+function hasErrorCode(error, code) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === code);
+}
 function isProcessRunning(pid) {
-  if (!pid || !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) {
-    // ESRCH = no such process, EPERM = process exists but we lack permission.
-    return Boolean(error && error.code === 'EPERM');
-  }
+    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) {
+        // ESRCH = no such process, EPERM = process exists but we lack permission.
+        return hasErrorCode(error, 'EPERM');
+    }
 }
-
 module.exports = { isProcessRunning };

package/lib/provider-credential-path.d.ts

@@ -0,0 +1,16 @@
+type Environment = Readonly<Record<string, string | undefined>>;
+interface ProviderCredentialMetadata {
+    readonly credentialPaths: readonly string[];
+    readonly docker?: {
+        readonly mount?: {
+            readonly hostEnv?: unknown;
+        };
+    };
+}
+declare function expandProviderCredentialPath(value: string, env?: Environment): string | null;
+declare function resolveProviderCredentialPaths(metadata: ProviderCredentialMetadata, env?: Environment): string[];
+declare const _default: {
+    expandProviderCredentialPath: typeof expandProviderCredentialPath;
+    resolveProviderCredentialPaths: typeof resolveProviderCredentialPaths;
+};
+export = _default;

package/lib/provider-credential-path.js

@@ -1,36 +1,38 @@
-const os = require('node:os');
-const path = require('node:path');
-
+"use strict";
+const os = require("node:os");
+const path = require("node:path");
 function expandHome(value) {
-  if (value === '~') return os.homedir();
-  return value.startsWith('~/') ? path.join(os.homedir(), value.slice(2)) : value;
+    if (value === '~')
+        return os.homedir();
+    return value.startsWith('~/') ? path.join(os.homedir(), value.slice(2)) : value;
 }
-
 function expandProviderCredentialPath(value, env = process.env) {
-  const homeExpanded = expandHome(value);
-  if (homeExpanded !== value) return homeExpanded;
-  const variable = value.match(/^\$([A-Z_][A-Z0-9_]*)(\/.*)?$/);
-  if (!variable) return value;
-  const root = env[variable[1]];
-  return typeof root === 'string' && root.trim()
-    ? path.resolve(expandHome(root), `.${variable[2] || ''}`)
-    : 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, env = process.env) {
-  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 !== null);
+    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 !== null);
 }
-
 module.exports = { expandProviderCredentialPath, resolveProviderCredentialPaths };

package/lib/provider-defaults.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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;
+}
+type ProviderDefaults = Record<string, ProviderDefaultSettings>;
+/**
+ * Get or build cached provider defaults
+ */
+declare function getProviderDefaults(): ProviderDefaults;
+/**
+ * Clear the provider defaults cache (primarily for testing)
+ */
+declare function clearProviderDefaultsCache(): void;
+declare const _default: {
+    getProviderDefaults: typeof getProviderDefaults;
+    clearProviderDefaultsCache: typeof clearProviderDefaultsCache;
+};
+export = _default;

package/lib/provider-defaults.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Provider defaults module
  *
@@ -7,67 +8,71 @@
  *
  * CRITICAL: This module should NOT import from settings.js
  */
-
 // Cache provider defaults to avoid repeated instantiation
 let _providerDefaultsCache = 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 } = require('./provider-names');
-
+function errorMessage(error) {
+    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()
- * @returns {Object} Map of provider name to default settings
  */
 function buildProviderDefaults() {
-  const { listProviders, getProvider } = require('../src/providers');
-
-  const defaults = {};
-  for (const providerName of listProviders()) {
-    try {
-      const provider = getProvider(providerName);
-      defaults[providerName] = provider.getDefaultSettings();
-    } catch (error) {
-      const metadata = getProviderMetadata(providerName);
-      console.warn(`Warning: Could not get defaults for ${providerName}: ${error.message}`);
-      defaults[providerName] = {
-        maxLevel: metadata.defaultLevels.max,
-        minLevel: metadata.defaultLevels.min,
-        defaultLevel: metadata.defaultLevels.default,
-        levelOverrides: {},
-      };
+    // Keep this require lazy to preserve the settings/provider circular-dependency boundary.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const { listProviders, getProvider } = require('../src/providers');
+    const defaults = {};
+    for (const providerName of listProviders()) {
+        try {
+            const provider = getProvider(providerName);
+            defaults[providerName] = provider.getDefaultSettings();
+        }
+        catch (error) {
+            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;
+    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
- * @returns {Object} Provider defaults
  */
 function getProviderDefaults() {
-  if (!_providerDefaultsCache) {
-    _providerDefaultsCache = buildProviderDefaults();
-  }
-  return _providerDefaultsCache;
+    if (!_providerDefaultsCache) {
+        _providerDefaultsCache = buildProviderDefaults();
+    }
+    return _providerDefaultsCache;
 }
-
 /**
  * Clear the provider defaults cache (primarily for testing)
  */
 function clearProviderDefaultsCache() {
-  _providerDefaultsCache = null;
+    _providerDefaultsCache = null;
 }
-
 module.exports = {
-  getProviderDefaults,
-  clearProviderDefaultsCache,
+    getProviderDefaults,
+    clearProviderDefaultsCache,
 };

package/lib/provider-detection.d.ts

@@ -0,0 +1,11 @@
+declare function commandExists(command: string): boolean;
+declare function getCommandPath(command: string): string | null;
+declare function getHelpOutput(command: string, args?: string[]): string;
+declare function getVersionOutput(command: string, args?: string[]): string;
+declare const _default: {
+    commandExists: typeof commandExists;
+    getCommandPath: typeof getCommandPath;
+    getHelpOutput: typeof getHelpOutput;
+    getVersionOutput: typeof getVersionOutput;
+};
+export = _default;

package/lib/provider-detection.js

@@ -1,64 +1,101 @@
-const { execSync, spawnSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+const childProcess = __importStar(require("child_process"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const { execSync, spawnSync } = childProcess;
 function commandExists(command) {
-  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;
-  }
+    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) {
-  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.
-    return output.split(/\r?\n/)[0].trim() || null;
-  } catch {
-    return 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, args = []) {
-  if (!commandExists(command)) return '';
-
-  const attempt = (flag) => {
-    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 || '';
+    if (!commandExists(command))
+        return '';
+    const attempt = (flag) => {
+        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, args = []) {
-  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();
+    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();
 }
-
 module.exports = {
-  commandExists,
-  getCommandPath,
-  getHelpOutput,
-  getVersionOutput,
+    commandExists,
+    getCommandPath,
+    getHelpOutput,
+    getVersionOutput,
 };

package/lib/provider-names.d.ts

@@ -0,0 +1,38 @@
+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;
+}
+declare function normalizeProviderName<T>(name: T): T | string;
+declare function normalizeProviderSettings<T>(providerSettings: T): T | Record<string, unknown>;
+declare function getProviderMetadata(name: string): ProviderRegistryEntry;
+declare function listProviderMetadata(): readonly ProviderRegistryEntry[];
+declare function resolveProviderCommand(name: string): {
+    readonly args: readonly string[];
+    readonly command: string;
+};
+declare function providerSupportsCapability(name: string, capability: string): boolean;
+declare function providerSupportsOutputReformatting(name: string): boolean;
+declare function getDefaultProviderId(): string;
+declare const _default: {
+    KNOWN_PROVIDER_NAMES: string[];
+    PROVIDER_ALIASES: Readonly<{
+        [x: string]: string;
+    }>;
+    PROVIDER_CAPABILITIES: Readonly<Record<string, Readonly<Record<string, ProviderCapabilityState>>>>;
+    VALID_PROVIDERS: string[];
+    getDefaultProviderId: typeof getDefaultProviderId;
+    getProviderMetadata: typeof getProviderMetadata;
+    listProviderMetadata: typeof listProviderMetadata;
+    normalizeProviderName: typeof normalizeProviderName;
+    normalizeProviderSettings: typeof normalizeProviderSettings;
+    providerSupportsCapability: typeof providerSupportsCapability;
+    providerSupportsOutputReformatting: typeof providerSupportsOutputReformatting;
+    resolveProviderCommand: typeof resolveProviderCommand;
+};
+export = _default;

package/lib/provider-names.js

@@ -1,87 +1,79 @@
+"use strict";
+// The emitted CommonJS facade resolves the built registry beside this module.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const registry = 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 = Object.freeze(
-  Object.fromEntries(
-    registry.listProviderRegistryEntries().map((entry) => [entry.id, entry.capabilities])
-  )
-);
-
+const PROVIDER_CAPABILITIES = 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(name) {
-  if (!name || typeof name !== 'string') return name;
-  return registry.normalizeProviderName(name);
+    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(providerSettings) {
-  if (
-    !providerSettings ||
-    typeof providerSettings !== 'object' ||
-    Array.isArray(providerSettings)
-  ) {
-    return providerSettings;
-  }
-
-  const normalized = {};
-  const entries = Object.entries(providerSettings);
-  const aliasFirst = entries.sort(([left], [right]) => {
-    const leftIsCanonical = normalizeProviderName(left) === left;
-    const rightIsCanonical = normalizeProviderName(right) === right;
-    if (leftIsCanonical === rightIsCanonical) return 0;
-    return leftIsCanonical ? 1 : -1;
-  });
-
-  for (const [key, value] of aliasFirst) {
-    const canonical = normalizeProviderName(key);
-    if (!VALID_PROVIDERS.includes(canonical)) {
-      normalized[key] = value;
-      continue;
+    if (!providerSettings ||
+        typeof providerSettings !== 'object' ||
+        Array.isArray(providerSettings)) {
+        return providerSettings;
     }
-    normalized[canonical] = {
-      ...(normalized[canonical] || {}),
-      ...(value || {}),
-    };
-  }
-
-  return normalized;
+    const normalized = {};
+    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) {
-  return registry.getProviderRegistryEntry(name);
+    return registry.getProviderRegistryEntry(name);
 }
-
 function listProviderMetadata() {
-  return registry.listProviderRegistryEntries();
+    return registry.listProviderRegistryEntries();
 }
-
 function resolveProviderCommand(name) {
-  return registry.resolveProviderCommand(name);
+    return registry.resolveProviderCommand(name);
 }
-
 function providerSupportsCapability(name, capability) {
-  return registry.supportsProviderCapability(name, capability);
+    return registry.supportsProviderCapability(name, capability);
 }
-
 function providerSupportsOutputReformatting(name) {
-  return registry.supportsProviderOutputReformatting(name);
+    return registry.supportsProviderOutputReformatting(name);
 }
-
 function getDefaultProviderId() {
-  return registry.getDefaultProviderId();
+    return registry.getDefaultProviderId();
 }
-
 module.exports = {
-  KNOWN_PROVIDER_NAMES,
-  PROVIDER_ALIASES,
-  PROVIDER_CAPABILITIES,
-  VALID_PROVIDERS,
-  getDefaultProviderId,
-  getProviderMetadata,
-  listProviderMetadata,
-  normalizeProviderName,
-  normalizeProviderSettings,
-  providerSupportsCapability,
-  providerSupportsOutputReformatting,
-  resolveProviderCommand,
+    KNOWN_PROVIDER_NAMES,
+    PROVIDER_ALIASES,
+    PROVIDER_CAPABILITIES,
+    VALID_PROVIDERS,
+    getDefaultProviderId,
+    getProviderMetadata,
+    listProviderMetadata,
+    normalizeProviderName,
+    normalizeProviderSettings,
+    providerSupportsCapability,
+    providerSupportsOutputReformatting,
+    resolveProviderCommand,
 };

package/lib/repo-settings.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Repo-local settings for zeroshot
+ *
+ * Optional per-repository config file:
+ *   <repoRoot>/.zeroshot/settings.json
+ *
+ * This complements the global user settings at:
+ *   ~/.zeroshot/settings.json
+ */
+type RepoSettings = object;
+interface RepoSettingsResult {
+    repoRoot: string | null;
+    settings: RepoSettings | null;
+    settingsPath: string | null;
+}
+/**
+ * Read repo-local settings if present.
+ */
+declare function readRepoSettings(startDir: string): RepoSettingsResult;
+/**
+ * Write repo-local settings.
+ */
+declare function writeRepoSettings(repoRoot: string, settings: object): string;
+declare const _default: {
+    readRepoSettings: typeof readRepoSettings;
+    writeRepoSettings: typeof writeRepoSettings;
+};
+export = _default;