@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/command-proofs.js

@@ -1,169 +1,138 @@
-const { readRepoSettings } = require('../lib/repo-settings');
-
+"use strict";
+const repoSettingsAccess = require("./repo-settings-access");
+const { propertyValue, readRepoSettingsValue, selectOwnProperty } = repoSettingsAccess;
 const PROOF_BLOCK_PATTERN = /^```zeroshot-command-proofs\s*\n([\s\S]*?)^```/m;
-
-function hasOwn(value, key) {
-  return Object.prototype.hasOwnProperty.call(value || {}, key);
-}
-
 function trimString(value) {
-  return typeof value === 'string' && value.trim() ? value.trim() : null;
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
-
 function setOptionalString(target, source, key) {
-  const value = trimString(source[key]);
-  if (value) {
-    target[key] = value;
-  }
+    const value = trimString(propertyValue(source, key));
+    if (value) {
+        target[key] = value;
+    }
 }
-
 function normalizeCommandProof(proof) {
-  if (!proof || typeof proof !== 'object') {
-    return null;
-  }
-
-  const id = trimString(proof.id || proof.name);
-  const profile = trimString(proof.profile || proof.proofProfile);
-  const command = trimString(proof.command);
-  if (!id || !profile || !command) {
-    return null;
-  }
-
-  const normalized = { id, profile, command };
-  setOptionalString(normalized, proof, 'scope');
-  setOptionalString(normalized, proof, 'description');
-  return normalized;
+    if (!proof || typeof proof !== 'object') {
+        return null;
+    }
+    const id = trimString(propertyValue(proof, 'id') || propertyValue(proof, 'name'));
+    const profile = trimString(propertyValue(proof, 'profile') || propertyValue(proof, 'proofProfile'));
+    const command = trimString(propertyValue(proof, 'command'));
+    if (!id || !profile || !command) {
+        return null;
+    }
+    const normalized = { id, profile, command };
+    setOptionalString(normalized, proof, 'scope');
+    setOptionalString(normalized, proof, 'description');
+    return normalized;
+}
+function isCommandProof(proof) {
+    return proof !== null;
 }
-
 function normalizeCommandProofs(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value.map(normalizeCommandProof).filter(Boolean);
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map(normalizeCommandProof).filter(isCommandProof);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
 }
-
 function parseCommandProofsFromText(text) {
-  if (typeof text !== 'string' || text.trim() === '') {
-    return [];
-  }
-
-  const match = text.match(PROOF_BLOCK_PATTERN);
-  if (!match) {
-    return [];
-  }
-
-  let parsed;
-  try {
-    parsed = JSON.parse(match[1]);
-  } catch (error) {
-    throw new Error(`Invalid zeroshot-command-proofs JSON: ${error.message}`);
-  }
-
-  return normalizeCommandProofs(parsed);
+    if (typeof text !== 'string' || text.trim() === '') {
+        return [];
+    }
+    const match = PROOF_BLOCK_PATTERN.exec(text);
+    const payload = match?.[1];
+    if (payload === undefined) {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch (error) {
+        throw new Error(`Invalid zeroshot-command-proofs JSON: ${errorMessage(error)}`);
+    }
+    return normalizeCommandProofs(parsed);
 }
-
 function mergeCommandProofs(...sources) {
-  const byId = new Map();
-  const order = [];
-
-  for (const source of sources) {
-    for (const proof of normalizeCommandProofs(source)) {
-      if (!byId.has(proof.id)) {
-        order.push(proof.id);
-      }
-      byId.set(proof.id, proof);
+    const byId = new Map();
+    const order = [];
+    for (const source of sources) {
+        for (const proof of normalizeCommandProofs(source)) {
+            if (!byId.has(proof.id)) {
+                order.push(proof.id);
+            }
+            byId.set(proof.id, proof);
+        }
+    }
+    const merged = [];
+    for (const id of order) {
+        const proof = byId.get(id);
+        if (proof) {
+            merged.push(proof);
+        }
     }
-  }
-
-  return order.map((id) => byId.get(id));
+    return merged;
 }
-
 function commandProofToQualityGate(proof) {
-  const normalized = normalizeCommandProof(proof);
-  if (!normalized) {
-    return null;
-  }
-
-  const gate = {
-    id: normalized.id,
-    profile: normalized.profile,
-    command: normalized.command,
-    commandProof: true,
-  };
-  setOptionalString(gate, normalized, 'scope');
-  setOptionalString(gate, normalized, 'description');
-  return gate;
+    const normalized = normalizeCommandProof(proof);
+    if (!normalized) {
+        return null;
+    }
+    const gate = {
+        id: normalized.id,
+        profile: normalized.profile,
+        command: normalized.command,
+        commandProof: true,
+    };
+    setOptionalString(gate, normalized, 'scope');
+    setOptionalString(gate, normalized, 'description');
+    return gate;
 }
-
 function getCommandProofSource(options, repoSettings) {
-  if (hasOwn(options, 'commandProofs')) {
-    return options.commandProofs;
-  }
-
-  if (options.ship && typeof options.ship === 'object' && hasOwn(options.ship, 'commandProofs')) {
-    return options.ship.commandProofs;
-  }
-
-  const settingsShip = repoSettings?.ship;
-  if (settingsShip && typeof settingsShip === 'object' && hasOwn(settingsShip, 'commandProofs')) {
-    return settingsShip.commandProofs;
-  }
-
-  if (hasOwn(repoSettings, 'commandProofs')) {
-    return repoSettings.commandProofs;
-  }
-
-  return [];
+    const source = selectOwnProperty('commandProofs', [
+        options,
+        propertyValue(options, 'ship'),
+        propertyValue(repoSettings, 'ship'),
+        repoSettings,
+    ]);
+    return source === undefined ? [] : source;
 }
-
 function getClusterCommandProofSource(config, options) {
-  if (hasOwn(options, 'commandProofs')) {
-    return options.commandProofs;
-  }
-
-  if (options.ship && typeof options.ship === 'object' && hasOwn(options.ship, 'commandProofs')) {
-    return options.ship.commandProofs;
-  }
-
-  if (config?.ship && typeof config.ship === 'object' && hasOwn(config.ship, 'commandProofs')) {
-    return config.ship.commandProofs;
-  }
-
-  if (hasOwn(config, 'commandProofs')) {
-    return config.commandProofs;
-  }
-
-  return undefined;
+    return selectOwnProperty('commandProofs', [
+        options,
+        propertyValue(options, 'ship'),
+        propertyValue(config, 'ship'),
+        config,
+    ]);
 }
-
 function resolveConfiguredCommandProofs(config = {}, options = {}) {
-  const configuredSource = getClusterCommandProofSource(config, options);
-  if (configuredSource !== undefined) {
-    return normalizeCommandProofs(configuredSource);
-  }
-
-  const repoSettingsResult = readRepoSettings(options.cwd || process.cwd());
-  const repoSettings = repoSettingsResult.settings || {};
-  return normalizeCommandProofs(getCommandProofSource(options, repoSettings));
+    const configuredSource = getClusterCommandProofSource(config, options);
+    if (configuredSource !== undefined) {
+        return normalizeCommandProofs(configuredSource);
+    }
+    const repoSettings = readRepoSettingsValue(options.cwd || process.cwd());
+    return normalizeCommandProofs(getCommandProofSource(options, repoSettings));
 }
-
 function resolveClusterCommandProofs(config = {}, options = {}, inputText = '') {
-  return mergeCommandProofs(
-    resolveConfiguredCommandProofs(config, options),
-    parseCommandProofsFromText(inputText)
-  );
+    return mergeCommandProofs(resolveConfiguredCommandProofs(config, options), parseCommandProofsFromText(inputText));
+}
+function isCommandProofQualityGate(gate) {
+    return gate !== null;
 }
-
 function commandProofsToQualityGates(commandProofs) {
-  return normalizeCommandProofs(commandProofs).map(commandProofToQualityGate).filter(Boolean);
+    return normalizeCommandProofs(commandProofs)
+        .map(commandProofToQualityGate)
+        .filter(isCommandProofQualityGate);
 }
-
 module.exports = {
-  commandProofToQualityGate,
-  commandProofsToQualityGates,
-  mergeCommandProofs,
-  normalizeCommandProofs,
-  parseCommandProofsFromText,
-  resolveClusterCommandProofs,
-  resolveConfiguredCommandProofs,
+    commandProofToQualityGate,
+    commandProofsToQualityGates,
+    mergeCommandProofs,
+    normalizeCommandProofs,
+    parseCommandProofsFromText,
+    resolveClusterCommandProofs,
+    resolveConfiguredCommandProofs,
 };

package/src/command-proofs.ts

@@ -0,0 +1,216 @@
+import repoSettingsAccess = require('./repo-settings-access');
+
+type ProofStringField = 'scope' | 'description';
+
+interface CommandProof {
+  id: string;
+  profile: string;
+  command: string;
+  scope?: string;
+  description?: string;
+}
+
+interface CommandProofQualityGate {
+  id: string;
+  profile: string;
+  command: string;
+  commandProof: true;
+  scope?: string;
+  description?: string;
+}
+
+interface CommandProofOptions {
+  cwd?: string;
+  commandProofs?: unknown;
+  ship?: unknown;
+  [key: string]: unknown;
+}
+
+interface CommandProofConfig {
+  commandProofs?: unknown;
+  ship?: unknown;
+  [key: string]: unknown;
+}
+
+const { propertyValue, readRepoSettingsValue, selectOwnProperty } = repoSettingsAccess;
+
+const PROOF_BLOCK_PATTERN = /^```zeroshot-command-proofs\s*\n([\s\S]*?)^```/m;
+
+function trimString(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function setOptionalString(
+  target: CommandProof | CommandProofQualityGate,
+  source: unknown,
+  key: ProofStringField
+): void {
+  const value = trimString(propertyValue(source, key));
+  if (value) {
+    target[key] = value;
+  }
+}
+
+function normalizeCommandProof(proof: unknown): CommandProof | null {
+  if (!proof || typeof proof !== 'object') {
+    return null;
+  }
+
+  const id = trimString(propertyValue(proof, 'id') || propertyValue(proof, 'name'));
+  const profile = trimString(
+    propertyValue(proof, 'profile') || propertyValue(proof, 'proofProfile')
+  );
+  const command = trimString(propertyValue(proof, 'command'));
+  if (!id || !profile || !command) {
+    return null;
+  }
+
+  const normalized: CommandProof = { id, profile, command };
+  setOptionalString(normalized, proof, 'scope');
+  setOptionalString(normalized, proof, 'description');
+  return normalized;
+}
+
+function isCommandProof(proof: CommandProof | null): proof is CommandProof {
+  return proof !== null;
+}
+
+function normalizeCommandProofs(value: unknown): CommandProof[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map(normalizeCommandProof).filter(isCommandProof);
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function parseCommandProofsFromText(text: unknown): CommandProof[] {
+  if (typeof text !== 'string' || text.trim() === '') {
+    return [];
+  }
+
+  const match = PROOF_BLOCK_PATTERN.exec(text);
+  const payload = match?.[1];
+  if (payload === undefined) {
+    return [];
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(payload);
+  } catch (error) {
+    throw new Error(`Invalid zeroshot-command-proofs JSON: ${errorMessage(error)}`);
+  }
+
+  return normalizeCommandProofs(parsed);
+}
+
+function mergeCommandProofs(...sources: unknown[]): CommandProof[] {
+  const byId = new Map<string, CommandProof>();
+  const order: string[] = [];
+
+  for (const source of sources) {
+    for (const proof of normalizeCommandProofs(source)) {
+      if (!byId.has(proof.id)) {
+        order.push(proof.id);
+      }
+      byId.set(proof.id, proof);
+    }
+  }
+
+  const merged: CommandProof[] = [];
+  for (const id of order) {
+    const proof = byId.get(id);
+    if (proof) {
+      merged.push(proof);
+    }
+  }
+  return merged;
+}
+
+function commandProofToQualityGate(proof: unknown): CommandProofQualityGate | null {
+  const normalized = normalizeCommandProof(proof);
+  if (!normalized) {
+    return null;
+  }
+
+  const gate: CommandProofQualityGate = {
+    id: normalized.id,
+    profile: normalized.profile,
+    command: normalized.command,
+    commandProof: true,
+  };
+  setOptionalString(gate, normalized, 'scope');
+  setOptionalString(gate, normalized, 'description');
+  return gate;
+}
+
+function getCommandProofSource(options: CommandProofOptions, repoSettings: unknown): unknown {
+  const source = selectOwnProperty('commandProofs', [
+    options,
+    propertyValue(options, 'ship'),
+    propertyValue(repoSettings, 'ship'),
+    repoSettings,
+  ]);
+  return source === undefined ? [] : source;
+}
+
+function getClusterCommandProofSource(
+  config: CommandProofConfig,
+  options: CommandProofOptions
+): unknown {
+  return selectOwnProperty('commandProofs', [
+    options,
+    propertyValue(options, 'ship'),
+    propertyValue(config, 'ship'),
+    config,
+  ]);
+}
+
+function resolveConfiguredCommandProofs(
+  config: CommandProofConfig = {},
+  options: CommandProofOptions = {}
+): CommandProof[] {
+  const configuredSource = getClusterCommandProofSource(config, options);
+  if (configuredSource !== undefined) {
+    return normalizeCommandProofs(configuredSource);
+  }
+
+  const repoSettings = readRepoSettingsValue(options.cwd || process.cwd());
+  return normalizeCommandProofs(getCommandProofSource(options, repoSettings));
+}
+
+function resolveClusterCommandProofs(
+  config: CommandProofConfig = {},
+  options: CommandProofOptions = {},
+  inputText: unknown = ''
+): CommandProof[] {
+  return mergeCommandProofs(
+    resolveConfiguredCommandProofs(config, options),
+    parseCommandProofsFromText(inputText)
+  );
+}
+
+function isCommandProofQualityGate(
+  gate: CommandProofQualityGate | null
+): gate is CommandProofQualityGate {
+  return gate !== null;
+}
+
+function commandProofsToQualityGates(commandProofs: unknown): CommandProofQualityGate[] {
+  return normalizeCommandProofs(commandProofs)
+    .map(commandProofToQualityGate)
+    .filter(isCommandProofQualityGate);
+}
+
+export = {
+  commandProofToQualityGate,
+  commandProofsToQualityGates,
+  mergeCommandProofs,
+  normalizeCommandProofs,
+  parseCommandProofsFromText,
+  resolveClusterCommandProofs,
+  resolveConfiguredCommandProofs,
+};

package/src/config-router.js

@@ -1,89 +1,97 @@
+"use strict";
 /**
  * Config Router - Maps 2D classification to parameterized templates
  *
  * Single source of truth for: Complexity × TaskType → { base, params }
  * Used by both logic-engine.js (trigger evaluation) and agent-wrapper.js (transform scripts)
  */
-
-const { DEFAULT_MAX_ITERATIONS } = require('./agent/agent-config');
-
+function isAgentConfigModule(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'DEFAULT_MAX_ITERATIONS' in value &&
+        typeof value.DEFAULT_MAX_ITERATIONS === 'number');
+}
+const agentConfig = require('./agent/agent-config');
+if (!isAgentConfigModule(agentConfig)) {
+    throw new TypeError('agent-config must export a numeric DEFAULT_MAX_ITERATIONS');
+}
+const { DEFAULT_MAX_ITERATIONS } = agentConfig;
 /**
  * Get cluster config based on complexity and task type
- * @param {string} complexity - TRIVIAL, SIMPLE, STANDARD, CRITICAL
- * @param {string} taskType - INQUIRY, TASK, DEBUG
- * @param {object} [options]
- * @param {boolean} [options.autoPr] - Whether the cluster will inject git-pusher/PR flow
- * @returns {{ base: string, params: object }}
  */
 function getConfig(complexity, taskType, options = {}) {
-  const isPrMode = options.autoPr === true || process.env.ZEROSHOT_PR === '1';
-
-  const getBase = () => {
-    if (taskType === 'DEBUG' && complexity !== 'TRIVIAL') {
-      return 'debug-workflow';
+    const isPrMode = options.autoPr === true || process.env.ZEROSHOT_PR === '1';
+    const getBase = () => {
+        if (taskType === 'DEBUG' && complexity !== 'TRIVIAL') {
+            return 'debug-workflow';
+        }
+        if (complexity === 'TRIVIAL' && isPrMode && taskType !== 'INQUIRY') {
+            return 'worker-validator';
+        }
+        if (complexity === 'TRIVIAL') {
+            return 'single-worker';
+        }
+        if (complexity === 'SIMPLE') {
+            return 'worker-validator';
+        }
+        return 'full-workflow';
+    };
+    const getLevel = (role) => {
+        if (complexity === 'CRITICAL' && role === 'planner')
+            return 'level3';
+        if (complexity === 'TRIVIAL')
+            return 'level1';
+        return 'level2';
+    };
+    const getValidatorCount = () => {
+        if (complexity === 'TRIVIAL')
+            return 0;
+        if (complexity === 'SIMPLE')
+            return 1;
+        if (complexity === 'STANDARD')
+            return 2;
+        // CRITICAL uses two-stage validation pipeline (validators loaded dynamically via meta-coordinator)
+        // Setting validator_count=0 signals that inline validators should be skipped
+        if (complexity === 'CRITICAL')
+            return 0;
+        return 1;
+    };
+    const getMaxTokens = () => {
+        if (complexity === 'TRIVIAL')
+            return 50000;
+        if (complexity === 'SIMPLE')
+            return 100000;
+        if (complexity === 'STANDARD')
+            return 100000;
+        if (complexity === 'CRITICAL')
+            return 150000;
+        return 100000;
+    };
+    const base = getBase();
+    const params = {
+        task_type: taskType,
+        complexity,
+        max_tokens: getMaxTokens(),
+        max_iterations: DEFAULT_MAX_ITERATIONS,
+    };
+    if (base === 'single-worker') {
+        params.worker_level = getLevel('worker');
     }
-    if (complexity === 'TRIVIAL' && isPrMode && taskType !== 'INQUIRY') {
-      return 'worker-validator';
+    else if (base === 'worker-validator') {
+        params.worker_level = getLevel('worker');
+        params.validator_level = getLevel('validator');
     }
-    if (complexity === 'TRIVIAL') {
-      return 'single-worker';
+    else if (base === 'debug-workflow') {
+        params.investigator_level = getLevel('planner');
+        params.fixer_level = getLevel('worker');
+        params.tester_level = getLevel('validator');
     }
-    if (complexity === 'SIMPLE') {
-      return 'worker-validator';
+    else if (base === 'full-workflow') {
+        params.planner_level = getLevel('planner');
+        params.worker_level = getLevel('worker');
+        params.validator_level = getLevel('validator');
+        params.validator_count = getValidatorCount();
     }
-    return 'full-workflow';
-  };
-
-  const getLevel = (role) => {
-    if (complexity === 'CRITICAL' && role === 'planner') return 'level3';
-    if (complexity === 'TRIVIAL') return 'level1';
-    return 'level2';
-  };
-
-  const getValidatorCount = () => {
-    if (complexity === 'TRIVIAL') return 0;
-    if (complexity === 'SIMPLE') return 1;
-    if (complexity === 'STANDARD') return 2;
-    // CRITICAL uses two-stage validation pipeline (validators loaded dynamically via meta-coordinator)
-    // Setting validator_count=0 signals that inline validators should be skipped
-    if (complexity === 'CRITICAL') return 0;
-    return 1;
-  };
-
-  const getMaxTokens = () => {
-    if (complexity === 'TRIVIAL') return 50000;
-    if (complexity === 'SIMPLE') return 100000;
-    if (complexity === 'STANDARD') return 100000;
-    if (complexity === 'CRITICAL') return 150000;
-    return 100000;
-  };
-
-  const base = getBase();
-
-  const params = {
-    task_type: taskType,
-    complexity,
-    max_tokens: getMaxTokens(),
-    max_iterations: DEFAULT_MAX_ITERATIONS,
-  };
-
-  if (base === 'single-worker') {
-    params.worker_level = getLevel('worker');
-  } else if (base === 'worker-validator') {
-    params.worker_level = getLevel('worker');
-    params.validator_level = getLevel('validator');
-  } else if (base === 'debug-workflow') {
-    params.investigator_level = getLevel('planner');
-    params.fixer_level = getLevel('worker');
-    params.tester_level = getLevel('validator');
-  } else if (base === 'full-workflow') {
-    params.planner_level = getLevel('planner');
-    params.worker_level = getLevel('worker');
-    params.validator_level = getLevel('validator');
-    params.validator_count = getValidatorCount();
-  }
-
-  return { base, params };
+    return { base, params };
 }
-
 module.exports = { getConfig };