@the-open-engine/zeroshot 5.4.0

package/src/template-validation/simulate-two-stage-validation.js

@@ -0,0 +1,270 @@
+const assert = require('node:assert');
+
+const Ledger = require('../ledger');
+const MessageBus = require('../message-bus');
+const LogicEngine = require('../logic-engine');
+const { executeHook } = require('../agent/agent-hook-executor');
+const { parseResultOutput } = require('../agent/agent-task-executor');
+
+function createSimAgent({ agentConfig, cluster, messageBus }) {
+  const simAgent = {
+    id: agentConfig.id,
+    role: agentConfig.role,
+    iteration: 1,
+    cluster,
+    messageBus,
+    config: agentConfig,
+    currentTaskId: 'sim-task',
+    workingDirectory: process.cwd(),
+    _log: () => {},
+    _resolveProvider: () => 'claude',
+    _parseResultOutput: (output) => parseResultOutput(simAgent, output),
+    _publish: (message) => {
+      const receiver = message.receiver || 'broadcast';
+      return messageBus.publish({
+        ...message,
+        receiver,
+        cluster_id: cluster.id,
+        sender: simAgent.id,
+      });
+    },
+  };
+  return simAgent;
+}
+
+async function simulateQuickValidation({ config }) {
+  const cluster = {
+    id: 'quick-sim',
+    agents: config.agents.map((a) => ({ id: a.id, role: a.role })),
+  };
+
+  const coordinator = config.agents.find((a) => a.id === 'consensus-coordinator');
+  assert.ok(coordinator, 'quick-validation: consensus-coordinator missing');
+
+  const trigger = coordinator.triggers.find((t) => t.topic === 'QUICK_VALIDATION_RESULT');
+  assert.ok(trigger?.logic?.script, 'quick-validation: coordinator trigger logic missing');
+  assert.ok(coordinator.hooks?.onComplete, 'quick-validation: coordinator onComplete missing');
+
+  const failures = [];
+
+  const runScenario = async (allApproved) => {
+    const ledger = new Ledger(':memory:');
+    const messageBus = new MessageBus(ledger);
+    const logicEngine = new LogicEngine(messageBus, cluster);
+
+    // Stage start
+    const now = Date.now();
+    messageBus.publish({
+      cluster_id: cluster.id,
+      topic: 'IMPLEMENTATION_READY',
+      sender: 'worker',
+      timestamp: now,
+    });
+
+    // Validator outputs (stage 1)
+    messageBus.publish({
+      cluster_id: cluster.id,
+      topic: 'QUICK_VALIDATION_RESULT',
+      sender: 'validator-requirements',
+      timestamp: now + 10,
+      content: { data: { approved: true, errors: ['req-error'] } },
+    });
+    messageBus.publish({
+      cluster_id: cluster.id,
+      topic: 'QUICK_VALIDATION_RESULT',
+      sender: 'validator-code',
+      timestamp: now + 20,
+      content: { data: { approved: true, errors: ['code-error'] } },
+    });
+
+    const gateOk = logicEngine.evaluate(
+      trigger.logic.script,
+      { id: 'consensus-coordinator', cluster_id: cluster.id },
+      { topic: 'QUICK_VALIDATION_RESULT' }
+    );
+    if (!gateOk) {
+      ledger.close();
+      return { ok: false, error: 'quick-validation: gate did not open after both validators' };
+    }
+
+    const simAgent = createSimAgent({ agentConfig: coordinator, cluster, messageBus });
+    const triggeringMessage = messageBus.findLast({
+      cluster_id: cluster.id,
+      topic: 'QUICK_VALIDATION_RESULT',
+    });
+
+    try {
+      await executeHook({
+        hook: coordinator.hooks.onComplete,
+        agent: simAgent,
+        message: triggeringMessage,
+        result: {
+          output: JSON.stringify({ allApproved, summary: allApproved ? 'ok' : 'nope' }),
+          success: true,
+          taskId: 'sim-task',
+        },
+        messageBus,
+        cluster,
+      });
+    } catch (err) {
+      ledger.close();
+      return { ok: false, error: `quick-validation: onComplete failed: ${err.message}` };
+    }
+
+    const passed = messageBus.findLast({
+      cluster_id: cluster.id,
+      topic: 'QUICK_VALIDATION_PASSED',
+    });
+    const validationResult = messageBus.findLast({
+      cluster_id: cluster.id,
+      topic: 'VALIDATION_RESULT',
+    });
+
+    ledger.close();
+
+    if (allApproved) {
+      if (!passed)
+        return { ok: false, error: 'quick-validation: expected QUICK_VALIDATION_PASSED' };
+      return { ok: true };
+    }
+
+    if (!validationResult) {
+      return { ok: false, error: 'quick-validation: expected VALIDATION_RESULT on rejection' };
+    }
+
+    const errors = validationResult.content?.data?.errors || [];
+    if (!errors.includes('req-error') || !errors.includes('code-error')) {
+      return { ok: false, error: 'quick-validation: rejection did not aggregate validator errors' };
+    }
+
+    return { ok: true };
+  };
+
+  for (const allApproved of [true, false]) {
+    const res = await runScenario(allApproved);
+    if (!res.ok) failures.push(res.error);
+  }
+
+  return failures;
+}
+
+async function simulateHeavyValidation({ config }) {
+  const cluster = {
+    id: 'heavy-sim',
+    agents: config.agents.map((a) => ({ id: a.id, role: a.role })),
+  };
+
+  const coordinator = config.agents.find((a) => a.id === 'consensus-coordinator');
+  assert.ok(coordinator, 'heavy-validation: consensus-coordinator missing');
+
+  const trigger = coordinator.triggers.find((t) => t.topic === 'HEAVY_VALIDATION_RESULT');
+  assert.ok(trigger?.logic?.script, 'heavy-validation: coordinator trigger logic missing');
+  assert.ok(coordinator.hooks?.onComplete, 'heavy-validation: coordinator onComplete missing');
+
+  const failures = [];
+
+  const runScenario = async (allApproved) => {
+    const ledger = new Ledger(':memory:');
+    const messageBus = new MessageBus(ledger);
+    const logicEngine = new LogicEngine(messageBus, cluster);
+
+    const now = Date.now();
+    messageBus.publish({
+      cluster_id: cluster.id,
+      topic: 'QUICK_VALIDATION_PASSED',
+      sender: 'consensus-coordinator',
+      timestamp: now,
+    });
+
+    messageBus.publish({
+      cluster_id: cluster.id,
+      topic: 'HEAVY_VALIDATION_RESULT',
+      sender: 'validator-security',
+      timestamp: now + 10,
+      content: { data: { approved: true, errors: ['sec-error'] } },
+    });
+    messageBus.publish({
+      cluster_id: cluster.id,
+      topic: 'HEAVY_VALIDATION_RESULT',
+      sender: 'validator-tester',
+      timestamp: now + 20,
+      content: { data: { approved: true, errors: ['test-error'] } },
+    });
+
+    const gateOk = logicEngine.evaluate(
+      trigger.logic.script,
+      { id: 'consensus-coordinator', cluster_id: cluster.id },
+      { topic: 'HEAVY_VALIDATION_RESULT' }
+    );
+    if (!gateOk) {
+      ledger.close();
+      return { ok: false, error: 'heavy-validation: gate did not open after both validators' };
+    }
+
+    const simAgent = createSimAgent({ agentConfig: coordinator, cluster, messageBus });
+    const triggeringMessage = messageBus.findLast({
+      cluster_id: cluster.id,
+      topic: 'HEAVY_VALIDATION_RESULT',
+    });
+
+    try {
+      await executeHook({
+        hook: coordinator.hooks.onComplete,
+        agent: simAgent,
+        message: triggeringMessage,
+        result: {
+          output: JSON.stringify({ allApproved, summary: allApproved ? 'ok' : 'nope' }),
+          success: true,
+          taskId: 'sim-task',
+        },
+        messageBus,
+        cluster,
+      });
+    } catch (err) {
+      ledger.close();
+      return { ok: false, error: `heavy-validation: onComplete failed: ${err.message}` };
+    }
+
+    const validationResult = messageBus.findLast({
+      cluster_id: cluster.id,
+      topic: 'VALIDATION_RESULT',
+    });
+    ledger.close();
+
+    if (!validationResult) {
+      return { ok: false, error: 'heavy-validation: expected VALIDATION_RESULT' };
+    }
+
+    const errors = validationResult.content?.data?.errors || [];
+    if (!errors.includes('sec-error') || !errors.includes('test-error')) {
+      return { ok: false, error: 'heavy-validation: did not aggregate validator errors' };
+    }
+
+    return { ok: true };
+  };
+
+  for (const allApproved of [true, false]) {
+    const res = await runScenario(allApproved);
+    if (!res.ok) failures.push(res.error);
+  }
+
+  return failures;
+}
+
+/**
+ * Deep sim: run deterministic two-stage validation scenarios for base templates.
+ * Returns an array of error strings.
+ */
+function simulateTwoStageValidation({ templateId, config }) {
+  if (templateId === 'quick-validation') {
+    return simulateQuickValidation({ config });
+  }
+  if (templateId === 'heavy-validation') {
+    return simulateHeavyValidation({ config });
+  }
+  return Promise.resolve([]);
+}
+
+module.exports = {
+  simulateTwoStageValidation,
+};

package/src/worktree-claude-config.js

@@ -0,0 +1,135 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { resolveWorktreeRoot } = require('./worktree-tooling-env');
+
+const CLAUDE_DIRNAME = '.claude';
+const SETTINGS_BASENAME = 'settings.json';
+const MCP_BASENAME = '.mcp.json';
+
+function isPlainObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readJsonIfExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function mergeJson(baseValue, overrideValue) {
+  if (Array.isArray(baseValue) && Array.isArray(overrideValue)) {
+    const seen = new Set();
+    const merged = [];
+
+    for (const entry of [...baseValue, ...overrideValue]) {
+      const key = JSON.stringify(entry);
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      merged.push(entry);
+    }
+
+    return merged;
+  }
+
+  if (isPlainObject(baseValue) && isPlainObject(overrideValue)) {
+    const merged = { ...baseValue };
+    for (const [key, value] of Object.entries(overrideValue)) {
+      if (Object.prototype.hasOwnProperty.call(merged, key)) {
+        merged[key] = mergeJson(merged[key], value);
+      } else {
+        merged[key] = value;
+      }
+    }
+    return merged;
+  }
+
+  return overrideValue === undefined ? baseValue : overrideValue;
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function copyIfExists(sourcePath, destPath) {
+  if (!fs.existsSync(sourcePath)) {
+    return;
+  }
+
+  ensureDir(path.dirname(destPath));
+  fs.copyFileSync(sourcePath, destPath);
+}
+
+function resolveRepoClaudeConfig(worktreeRoot) {
+  const configDir = path.join(worktreeRoot, CLAUDE_DIRNAME);
+  const settingsPath = path.join(configDir, SETTINGS_BASENAME);
+  const mcpPath = path.join(configDir, MCP_BASENAME);
+
+  if (!fs.existsSync(settingsPath) && !fs.existsSync(mcpPath)) {
+    return null;
+  }
+
+  return {
+    configDir,
+    settingsPath,
+    mcpPath,
+  };
+}
+
+function prepareClaudeConfigDir(options = {}) {
+  const worktreeRoot = resolveWorktreeRoot(options.worktreePath || options.cwd);
+  if (!worktreeRoot) {
+    return null;
+  }
+
+  const repoConfig = resolveRepoClaudeConfig(worktreeRoot);
+  if (!repoConfig) {
+    return null;
+  }
+
+  const sourceDir =
+    options.sourceDir || process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), CLAUDE_DIRNAME);
+  const tempRoot = path.join(os.tmpdir(), 'zeroshot-claude-configs');
+  ensureDir(tempRoot);
+
+  const overlayDir = fs.mkdtempSync(path.join(tempRoot, 'config-'));
+  ensureDir(path.join(overlayDir, 'hooks'));
+  ensureDir(path.join(overlayDir, 'projects'));
+
+  copyIfExists(
+    path.join(sourceDir, '.credentials.json'),
+    path.join(overlayDir, '.credentials.json')
+  );
+
+  const sourceSettings = readJsonIfExists(path.join(sourceDir, SETTINGS_BASENAME)) || {};
+  const repoSettings = readJsonIfExists(repoConfig.settingsPath) || {};
+  const mergedSettings = mergeJson(sourceSettings, repoSettings);
+  if (Object.keys(mergedSettings).length > 0) {
+    fs.writeFileSync(
+      path.join(overlayDir, SETTINGS_BASENAME),
+      JSON.stringify(mergedSettings, null, 2)
+    );
+  }
+
+  const sourceMcp = readJsonIfExists(path.join(sourceDir, MCP_BASENAME)) || {};
+  const repoMcp = readJsonIfExists(repoConfig.mcpPath) || {};
+  const mergedMcp = mergeJson(sourceMcp, repoMcp);
+  if (Object.keys(mergedMcp).length > 0) {
+    fs.writeFileSync(path.join(overlayDir, MCP_BASENAME), JSON.stringify(mergedMcp, null, 2));
+  }
+
+  return overlayDir;
+}
+
+module.exports = {
+  prepareClaudeConfigDir,
+};

package/src/worktree-tooling-env.js

@@ -0,0 +1,150 @@
+const fs = require('fs');
+const path = require('path');
+
+const TOOLING_METADATA_RELATIVE_PATH = path.join('.zeroshot', 'tooling-env.json');
+const DEFAULT_TOOL_BIN_RELATIVE_PATHS = ['.zeroshot/bin', '.worktree-tool-bin'];
+const FALLBACK_BIN_PREFIX = '.worktree-tool-bin.';
+
+function pathKeyForEnv(env) {
+  return Object.keys(env).find((key) => key.toUpperCase() === 'PATH') || 'PATH';
+}
+
+function resolveExistingRealPath(candidatePath) {
+  try {
+    return fs.realpathSync(candidatePath);
+  } catch {
+    return null;
+  }
+}
+
+function isWithinRoot(candidatePath, rootPath) {
+  const candidateRealPath = resolveExistingRealPath(candidatePath);
+  const rootRealPath = resolveExistingRealPath(rootPath);
+  if (!candidateRealPath || !rootRealPath) {
+    return false;
+  }
+
+  return (
+    candidateRealPath === rootRealPath || candidateRealPath.startsWith(`${rootRealPath}${path.sep}`)
+  );
+}
+
+function dedupePaths(entries) {
+  const seen = new Set();
+  const orderedEntries = [];
+
+  for (const entry of entries) {
+    if (!entry || seen.has(entry)) {
+      continue;
+    }
+    seen.add(entry);
+    orderedEntries.push(entry);
+  }
+
+  return orderedEntries;
+}
+
+function hasToolingMetadata(dirPath) {
+  return fs.existsSync(path.join(dirPath, TOOLING_METADATA_RELATIVE_PATH));
+}
+
+function hasGitEntry(dirPath) {
+  return fs.existsSync(path.join(dirPath, '.git'));
+}
+
+function resolveWorktreeRoot(startDir) {
+  if (!startDir) {
+    return null;
+  }
+
+  let currentDir = path.resolve(startDir);
+  let nearestGitRoot = null;
+  while (true) {
+    if (hasToolingMetadata(currentDir)) {
+      return currentDir;
+    }
+    if (!nearestGitRoot && hasGitEntry(currentDir)) {
+      nearestGitRoot = currentDir;
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return nearestGitRoot;
+    }
+    currentDir = parentDir;
+  }
+}
+
+function readToolingMetadata(worktreeRoot) {
+  const metadataPath = path.join(worktreeRoot, TOOLING_METADATA_RELATIVE_PATH);
+  if (!fs.existsSync(metadataPath)) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+    if (!parsed || typeof parsed !== 'object') {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function listFallbackBinDirectories(worktreeRoot) {
+  try {
+    return fs
+      .readdirSync(worktreeRoot, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name.startsWith(FALLBACK_BIN_PREFIX))
+      .map((entry) => path.join(worktreeRoot, entry.name));
+  } catch {
+    return [];
+  }
+}
+
+function resolveWorktreeToolBinEntries(options = {}) {
+  const worktreeRoot = resolveWorktreeRoot(options.worktreePath || options.cwd);
+  if (!worktreeRoot) {
+    return [];
+  }
+
+  const metadata = readToolingMetadata(worktreeRoot);
+  const hasExplicitWorktreePath =
+    typeof options.worktreePath === 'string' && options.worktreePath.trim().length > 0;
+  if (!metadata && !hasExplicitWorktreePath) {
+    return [];
+  }
+
+  const candidates = [];
+  if (typeof metadata?.toolBinDir === 'string' && metadata.toolBinDir.trim()) {
+    candidates.push(metadata.toolBinDir.trim());
+  }
+
+  for (const relativePath of DEFAULT_TOOL_BIN_RELATIVE_PATHS) {
+    candidates.push(path.join(worktreeRoot, relativePath));
+  }
+  candidates.push(...listFallbackBinDirectories(worktreeRoot));
+
+  return dedupePaths(candidates).filter((candidatePath) =>
+    isWithinRoot(candidatePath, worktreeRoot)
+  );
+}
+
+function prependWorktreeToolBinToEnv(env, options = {}) {
+  const toolBinEntries = resolveWorktreeToolBinEntries(options);
+  if (toolBinEntries.length === 0) {
+    return env;
+  }
+
+  const pathKey = pathKeyForEnv(env);
+  const existingEntries = (env[pathKey] || '').split(path.delimiter).filter(Boolean);
+  env[pathKey] = dedupePaths([...toolBinEntries, ...existingEntries]).join(path.delimiter);
+  return env;
+}
+
+module.exports = {
+  prependWorktreeToolBinToEnv,
+  resolveWorktreeRoot,
+  resolveWorktreeToolBinEntries,
+};