@besales/ops-framework 0.1.0

package/bin/providers/external-cli-checker.mjs

@@ -0,0 +1,190 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const DEFAULT_CODEX_COMMAND = 'codex';
+
+export function resolveExternalCliProvider(providerName, config = {}) {
+  const configured = config.checkerProviders?.[providerName] || {};
+  if (providerName === 'codex-cli') {
+    return {
+      command: configured.command || DEFAULT_CODEX_COMMAND,
+      args: configured.args || ['exec', '--sandbox', 'read-only', '--output-last-message', '$OUTPUT_FILE', '--model', '$MODEL', '-'],
+      input: configured.input || 'stdin',
+      output: configured.output || 'file',
+    };
+  }
+  if (providerName === 'claude-cli' || providerName === 'cloud-cli') {
+    return {
+      command: configured.command || (providerName === 'cloud-cli' ? 'cloud' : 'claude'),
+      args: configured.args || ['--print', '--model', '$MODEL'],
+      input: configured.input || 'stdin',
+      output: configured.output || 'stdout',
+    };
+  }
+  if (providerName === 'custom-cli') {
+    if (!configured.command) {
+      const error = new Error('custom-cli requires checkerProviders.custom-cli.command in agents.json.');
+      error.failureReason = 'provider_unavailable';
+      throw error;
+    }
+    return {
+      command: configured.command,
+      args: configured.args || [],
+      input: configured.input || 'stdin',
+      output: configured.output || 'stdout',
+    };
+  }
+
+  return null;
+}
+
+export async function runExternalCliChecker({
+  providerName,
+  providerConfig,
+  model,
+  reasoningEffort,
+  prompt,
+  cwd,
+}) {
+  if (!providerConfig) {
+    const error = new Error(`Unknown external CLI provider: ${providerName}`);
+    error.failureReason = 'provider_unavailable';
+    throw error;
+  }
+
+  if (!isCommandAvailable(providerConfig.command)) {
+    const error = new Error(`Checker CLI command is not available: ${providerConfig.command}`);
+    error.failureReason = 'provider_unavailable';
+    throw error;
+  }
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), `leakengine-checker-${providerName}-`));
+  const outputFile = path.join(tmpDir, 'checker-output.raw.md');
+  const args = providerConfig.args.map((arg) => expandArg(arg, { model, reasoningEffort, outputFile }));
+  const result = spawnSync(providerConfig.command, args, {
+    cwd,
+    input: providerConfig.input === 'stdin' ? prompt : undefined,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024 * 20,
+  });
+
+  if (result.error) {
+    result.error.failureReason = 'provider_unavailable';
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    const error = new Error(`Checker CLI exited with ${result.status}: ${(result.stderr || result.stdout || '').slice(0, 1000)}`);
+    error.failureReason = result.status === 124 ? 'timeout' : 'provider_unavailable';
+    throw error;
+  }
+
+  const rawOutput = providerConfig.output === 'file'
+    ? readRequiredOutputFile(outputFile)
+    : result.stdout;
+
+  try {
+    return {
+      ...parseCheckerOutput(rawOutput),
+      rawOutput,
+    };
+  } catch (error) {
+    error.failureReason = 'invalid_json';
+    error.rawOutput = rawOutput;
+    throw error;
+  }
+}
+
+function parseCheckerOutput(rawOutput) {
+  const trimmed = rawOutput.trim();
+  if (!trimmed) {
+    throw new Error('Checker CLI returned empty output.');
+  }
+
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const fenced = /```json\s*([\s\S]*?)```/.exec(trimmed);
+    if (fenced) {
+      return JSON.parse(fenced[1]);
+    }
+    const embeddedObject = extractFirstJsonObject(trimmed);
+    if (embeddedObject) {
+      return JSON.parse(embeddedObject);
+    }
+    throw new Error('Checker CLI output did not contain a valid JSON object.');
+  }
+}
+
+function extractFirstJsonObject(value) {
+  const start = value.indexOf('{');
+  if (start < 0) {
+    return null;
+  }
+
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (let index = start; index < value.length; index += 1) {
+    const char = value[index];
+
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+
+    if (char === '{') {
+      depth += 1;
+    } else if (char === '}') {
+      depth -= 1;
+      if (depth === 0) {
+        return value.slice(start, index + 1);
+      }
+    }
+  }
+
+  return null;
+}
+
+function readRequiredOutputFile(outputFile) {
+  if (!fs.existsSync(outputFile)) {
+    const error = new Error(`Checker CLI did not create output file: ${outputFile}`);
+    error.failureReason = 'invalid_json';
+    throw error;
+  }
+  return fs.readFileSync(outputFile, 'utf8');
+}
+
+function expandArg(arg, { model, reasoningEffort, outputFile }) {
+  return String(arg)
+    .replaceAll('$MODEL', model || '')
+    .replaceAll('$REASONING_EFFORT', reasoningEffort || 'medium')
+    .replaceAll('$OUTPUT_FILE', outputFile);
+}
+
+function isCommandAvailable(command) {
+  if (command.includes(path.sep)) {
+    return fs.existsSync(command);
+  }
+  const result = spawnSync('sh', ['-lc', `command -v ${shellQuote(command)}`], {
+    encoding: 'utf8',
+  });
+  return result.status === 0;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}

package/bin/providers/openai-checker.mjs

@@ -0,0 +1,62 @@
+export async function runOpenAiChecker({
+  apiKey,
+  model,
+  messages,
+  temperature = 0,
+}) {
+  if (!apiKey) {
+    const error = new Error('OPENAI_API_KEY is not set.');
+    error.failureReason = 'provider_unavailable';
+    throw error;
+  }
+  if (!model) {
+    const error = new Error('Checker model is not configured.');
+    error.failureReason = 'provider_unavailable';
+    throw error;
+  }
+
+  const response = await fetch('https://api.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      model,
+      messages,
+      temperature,
+      response_format: { type: 'json_object' },
+    }),
+  });
+
+  const responseBody = await response.text();
+  if (!response.ok) {
+    const error = new Error(`OpenAI checker request failed with HTTP ${response.status}: ${responseBody.slice(0, 500)}`);
+    error.failureReason = response.status === 408 || response.status === 429 || response.status >= 500
+      ? 'provider_unavailable'
+      : 'unknown';
+    throw error;
+  }
+
+  let payload;
+  try {
+    payload = JSON.parse(responseBody);
+  } catch (error) {
+    error.failureReason = 'invalid_json';
+    throw error;
+  }
+
+  const content = payload.choices?.[0]?.message?.content;
+  if (!content) {
+    const error = new Error('OpenAI checker response did not include message content.');
+    error.failureReason = 'invalid_json';
+    throw error;
+  }
+
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    error.failureReason = 'invalid_json';
+    throw error;
+  }
+}

package/bin/quality-gates.mjs

@@ -0,0 +1,92 @@
+import path from 'node:path';
+import {
+  computeTaskContextInputs,
+  parseCliArgs,
+  readTaskFile,
+  resolveTaskDir,
+  validateExecutionEvidenceForPlan,
+} from './lib/check-context-utils.mjs';
+
+function main() {
+  const args = parseCliArgs(process.argv.slice(2));
+  const taskArg = args.positional[0];
+  if (!taskArg) {
+    fail('Usage: node ops/agent-pipeline/bin/quality-gates.mjs <TASK-id-or-task-path> [--json]');
+  }
+
+  try {
+    const taskDir = resolveTaskDir(taskArg);
+    const taskId = path.basename(taskDir);
+    const inputs = computeTaskContextInputs(taskDir);
+    const executionIssues = validateExecutionEvidenceForPlan({
+      planContent: readTaskFile(taskDir, 'plan.md'),
+      executionContent: readTaskFile(taskDir, 'execution.md'),
+    });
+    const result = {
+      taskId,
+      riskProfile: inputs.risk.riskProfile,
+      riskTriggers: inputs.risk.riskTriggers,
+      planQuality: {
+        uiRequired: inputs.qualityGates.uiRequired,
+        uiAcceptanceComplete: inputs.qualityGates.uiAcceptance.present,
+        complexityRequired: inputs.qualityGates.complexityRequired,
+        complexityBudgetComplete: inputs.qualityGates.complexityBudget.present,
+        optimizationTier: inputs.qualityGates.optimizationTier,
+        optimizationRequired: inputs.qualityGates.optimizationRequired,
+        optimizationStrategyComplete: inputs.qualityGates.optimizationStrategy.present,
+        productionRolloutRequired: inputs.qualityGates.productionRolloutRequired,
+        productionRolloutComplete: inputs.qualityGates.productionRollout.present,
+        sourceSyncProviderRequired: inputs.qualityGates.sourceSyncProviderRequired,
+        sourceSyncProviderComplete: inputs.qualityGates.sourceSyncProvider.present,
+        missingSignals: inputs.qualityGates.missingSignals,
+      },
+      executionEvidence: {
+        issues: executionIssues,
+      },
+      ok: inputs.qualityGates.missingSignals.length === 0 && executionIssues.length === 0,
+    };
+
+    if (args.flags.has('json')) {
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(result.ok ? 0 : 1);
+    }
+
+    printHuman(result);
+    process.exit(result.ok ? 0 : 1);
+  } catch (error) {
+    fail(error.message);
+  }
+}
+
+function printHuman(result) {
+  console.log(`Quality gates for ${result.taskId}`);
+  console.log(`- riskProfile: ${result.riskProfile}`);
+  console.log(`- riskTriggers: ${result.riskTriggers.join(', ') || 'none'}`);
+  console.log(`- UI acceptance: ${result.planQuality.uiRequired ? result.planQuality.uiAcceptanceComplete ? 'required / complete' : 'required / missing' : 'not required'}`);
+  console.log(`- Complexity budget: ${result.planQuality.complexityRequired ? result.planQuality.complexityBudgetComplete ? 'required / complete' : 'required / missing' : 'not required'}`);
+  console.log(`- Optimization strategy: ${result.planQuality.optimizationRequired ? `${result.planQuality.optimizationTier} required / ${result.planQuality.optimizationStrategyComplete ? 'complete' : 'missing'}` : `${result.planQuality.optimizationTier || 'O0'} / not required`}`);
+  console.log(`- Production rollout: ${result.planQuality.productionRolloutRequired ? result.planQuality.productionRolloutComplete ? 'required / complete' : 'required / missing' : 'not required'}`);
+  console.log(`- Source sync/provider: ${result.planQuality.sourceSyncProviderRequired ? result.planQuality.sourceSyncProviderComplete ? 'required / complete' : 'required / missing' : 'not required'}`);
+  if (result.planQuality.missingSignals.length > 0) {
+    console.log('Plan quality issues:');
+    for (const issue of result.planQuality.missingSignals) {
+      console.log(`- ${issue}`);
+    }
+  }
+  if (result.executionEvidence.issues.length > 0) {
+    console.log('Execution evidence issues:');
+    for (const issue of result.executionEvidence.issues) {
+      console.log(`- ${issue.category}: ${issue.message}`);
+    }
+  }
+  if (result.ok) {
+    console.log('Quality gates ok.');
+  }
+}
+
+function fail(message) {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+}
+
+main();