Wave Executor

#!/usr/bin/env node
'use strict';
/**
 * wave-executor — Post-Execute Hook
 * Logs wave execution summary to memory.
 */

const fs = require('node:fs');
const path = require('node:path');
const { safeParseJSON } = require('../../../lib/utils/safe-json.cjs');

function findProjectRoot() {
  let dir = __dirname;
  const root = path.parse(dir).root;
  while (dir && dir !== root) {
    if (fs.existsSync(path.join(dir, '.claude'))) return dir;
    dir = path.dirname(dir);
  }
  return process.cwd();
}

function parseInput() {
  const raw = process.argv.length > 2 ? process.argv.slice(2).join(' ') : '{}';
  try {
    return safeParseJSON(raw);
  } catch {
    return {};
  }
}

const input = parseInput();
const projectRoot = findProjectRoot();

// Record execution in learnings
try {
  const learningsPath = path.join(projectRoot, '.claude', 'context', 'memory', 'learnings.md');
  if (fs.existsSync(learningsPath)) {
    const timestamp = new Date().toISOString().slice(0, 10);
    const wavesCompleted = input.wavesCompleted || 0;
    const skillsProcessed = input.skillsProcessed || 0;
    const totalCost = input.totalCost || 'N/A';
    const entry = `\n## Wave Executor Run (${timestamp})\n- Waves completed: ${wavesCompleted}\n- Skills processed: ${skillsProcessed}\n- Cost: ${totalCost}\n`;
    fs.appendFileSync(learningsPath, entry, 'utf8');
  }
} catch {
  // Non-fatal — memory logging is best-effort
}

console.log('[wave-executor] Post-execute: execution logged');

#!/usr/bin/env node
'use strict';
/**
 * wave-executor — Pre-Execute Hook
 * Validates that plan file is provided and the SDK is available.
 */

const fs = require('node:fs');
const path = require('node:path');
const { safeParseJSON } = require('../../../lib/utils/safe-json.cjs');

function parseInput() {
  const raw = process.argv.length > 2 ? process.argv.slice(2).join(' ') : '{}';
  try {
    return safeParseJSON(raw);
  } catch {
    return {};
  }
}

function findProjectRoot() {
  let dir = __dirname;
  const root = path.parse(dir).root;
  while (dir && dir !== root) {
    if (fs.existsSync(path.join(dir, '.claude'))) return dir;
    dir = path.dirname(dir);
  }
  return process.cwd();
}

function validateInput(input) {
  const errors = [];
  const warnings = [];

  if (input && typeof input !== 'object') {
    errors.push('Input must be an object');
    return { errors, warnings };
  }

  // Validate plan file
  if (input.plan) {
    const resolved = path.resolve(input.plan);
    if (!fs.existsSync(resolved)) {
      errors.push(`Plan file not found: ${resolved}`);
    } else {
      try {
        const content = safeParseJSON(fs.readFileSync(resolved, 'utf8'));
        if (!content.waves || !Array.isArray(content.waves)) {
          errors.push('Plan file must contain a "waves" array');
        } else if (content.waves.length === 0) {
          errors.push('Plan file "waves" array is empty');
        } else {
          warnings.push(
            `Plan loaded: ${content.waves.length} waves, ${content.waves.reduce((sum, w) => sum + (w.skills?.length || 0), 0)} total skills`
          );
        }
      } catch (err) {
        errors.push(`Invalid plan file: ${err.message}`);
      }
    }
  }

  // Check SDK availability
  try {
    require.resolve('@anthropic-ai/claude-agent-sdk');
  } catch {
    errors.push('Claude Agent SDK not installed. Run: pnpm add @anthropic-ai/claude-agent-sdk');
  }

  // Check CLI tool exists
  const projectRoot = findProjectRoot();
  const cliTool = path.join(projectRoot, '.claude', 'tools', 'cli', 'wave-executor.mjs');
  if (!fs.existsSync(cliTool)) {
    errors.push(`CLI tool not found: ${cliTool}`);
  }

  return { errors, warnings };
}

const input = parseInput();
const { errors, warnings } = validateInput(input);

if (warnings.length > 0) {
  console.log('[wave-executor] Pre-execute:');
  for (const w of warnings) console.log(`  - ${w}`);
}

if (errors.length > 0) {
  console.error('[wave-executor] Pre-execute validation failed:');
  for (const e of errors) console.error(`  - ${e}`);
  process.exit(1);
}

console.log('[wave-executor] Pre-execute validation passed');

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "wave-executor Input Schema",
  "description": "Input contract for wave-executor skill — fresh-process batch orchestration",
  "type": "object",
  "required": ["plan"],
  "properties": {
    "plan": {
      "type": "string",
      "minLength": 1,
      "description": "Path to wave plan JSON file containing wave definitions."
    },
    "model": {
      "type": "string",
      "default": "claude-sonnet-4-6",
      "description": "Claude model to use for wave execution."
    },
    "maxTurnsPerWave": {
      "type": "integer",
      "default": 50,
      "minimum": 5,
      "maximum": 200,
      "description": "Maximum conversation turns per wave before forcing completion."
    },
    "dryRun": {
      "type": "boolean",
      "default": false,
      "description": "Preview plan without executing waves."
    },
    "startFromWave": {
      "type": "integer",
      "minimum": 1,
      "description": "Resume execution from a specific wave ID."
    }
  },
  "additionalProperties": false
}

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "wave-executor Output Schema",
  "description": "Output contract for wave-executor skill execution",
  "type": "object",
  "required": ["success", "wavesCompleted", "wavesTotal"],
  "properties": {
    "success": {
      "type": "boolean",
      "description": "True when all waves completed without errors."
    },
    "wavesCompleted": {
      "type": "integer",
      "minimum": 0,
      "description": "Number of waves successfully completed."
    },
    "wavesTotal": {
      "type": "integer",
      "minimum": 0,
      "description": "Total number of waves in the plan."
    },
    "skillsProcessed": {
      "type": "integer",
      "minimum": 0,
      "description": "Total number of skills processed across all waves."
    },
    "totalCost": {
      "type": "string",
      "description": "Total cost in USD format (e.g. '$4.20')."
    },
    "inventoryPath": {
      "type": "string",
      "description": "Path to the inventory JSON file for resume support."
    },
    "errors": {
      "type": "array",
      "items": { "type": "string" },
      "description": "List of error messages from failed waves."
    }
  },
  "additionalProperties": false
}

#!/usr/bin/env node
'use strict';
/**
 * wave-executor — Skill Entry Point
 * Validates inputs and delegates to the CLI tool.
 */

const fs = require('node:fs');
const path = require('node:path');
const { spawnSync } = require('node:child_process');

function findProjectRoot() {
  let dir = __dirname;
  while (dir !== path.parse(dir).root) {
    if (fs.existsSync(path.join(dir, '.claude'))) return dir;
    dir = path.dirname(dir);
  }
  return process.cwd();
}

function parseArgs(argv) {
  const options = {};
  for (let i = 0; i < argv.length; i++) {
    if (!argv[i].startsWith('--')) continue;
    const key = argv[i].slice(2);
    const value = argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[++i] : true;
    options[key] = value;
  }
  return options;
}

function main() {
  const options = parseArgs(process.argv.slice(2));

  if (options.help) {
    console.log(`
wave-executor — Fresh-process orchestration for EPIC-tier batch pipelines

Usage:
  node main.cjs --plan <path> [--model <model>] [--dry-run] [--json]
  node main.cjs --help
`);
    process.exit(0);
  }

  const projectRoot = findProjectRoot();
  const planPath = options.plan;

  // Validate plan file exists
  if (!planPath) {
    console.error('Missing required --plan argument');
    process.exit(1);
  }

  const resolvedPlan = path.resolve(planPath);
  if (!fs.existsSync(resolvedPlan)) {
    console.error(`Plan file not found: ${resolvedPlan}`);
    process.exit(1);
  }

  // Build args for the CLI tool
  const cliTool = path.join(projectRoot, '.claude', 'tools', 'cli', 'wave-executor.mjs');
  const args = [cliTool, '--plan', resolvedPlan];

  if (options.model) args.push('--model', options.model);
  if (options['dry-run']) args.push('--dry-run');
  if (options.json) args.push('--json');
  if (options['start-from']) args.push('--start-from', options['start-from']);
  if (options['max-turns']) args.push('--max-turns', options['max-turns']);

  const result = spawnSync(process.execPath, args, {
    cwd: projectRoot,
    encoding: 'utf8',
    stdio: 'inherit',
    shell: false,
    windowsHide: true,
  });

  process.exitCode = result.status || 0;
}

main();