Recommend Evolution

#!/usr/bin/env node

/**
 * Recommend Evolution - Post-Execute Hook
 * Runs after the skill executes for cleanup, logging, or follow-up actions.
 *
 * This hook receives the skill execution result as JSON in process.argv[2]
 */

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

// Parse hook input
const result = safeParseJSON(process.argv[2] || '{}');

console.log('📝 [RECOMMEND-EVOLUTION] Post-execute processing...');

/**
 * Process execution result
 */
function processResult(_result) {
  // TODO: Add your post-processing logic here
  // Examples:
  // - Log execution to audit file
  // - Send notifications
  // - Update memory files
  // - Trigger follow-up actions

  return { success: true };
}

// Run post-processing
const outcome = processResult(result);

if (outcome.success) {
  console.log('✅ [RECOMMEND-EVOLUTION] Post-processing complete');
  process.exit(0);
} else {
  console.error('⚠️  [RECOMMEND-EVOLUTION] Post-processing had issues');
  process.exit(0); // Don't fail the skill for post-processing issues
}

#!/usr/bin/env node
'use strict';

const { ALLOWED_TRIGGERS } = require('../scripts/main.cjs');
const { safeParseJSON } = require('../../../lib/utils/safe-json.cjs');

function validateInput(input) {
  const errors = [];
  const trigger = String(input.trigger || '').trim();
  if (!trigger) {
    errors.push('Missing required field: trigger');
  } else if (!ALLOWED_TRIGGERS.has(trigger)) {
    errors.push(`Invalid trigger: ${trigger}`);
  }

  if (trigger === 'stale_skill') {
    const evidence = String(input.evidence || '').trim();
    if (!evidence) {
      errors.push('stale_skill requires evidence text');
    }
  }

  return errors;
}

function main(rawInput) {
  const input = rawInput || {};
  const errors = validateInput(input);
  return {
    ok: errors.length === 0,
    errors,
  };
}

if (require.main === module) {
  const input = safeParseJSON(process.argv[2] || '{}');
  const outcome = main(input);
  if (!outcome.ok) {
    console.error(JSON.stringify(outcome, null, 2));
    process.exit(1);
  }
  console.log(JSON.stringify(outcome));
  process.exit(0);
}

module.exports = {
  validateInput,
  main,
};

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "recommend-evolution Input Schema",
  "description": "Input validation schema for recommend-evolution skill",
  "type": "object",
  "required": ["trigger"],
  "properties": {
    "trigger": {
      "type": "string",
      "enum": [
        "repeated_error",
        "no_agent",
        "integration_gap",
        "user_request",
        "rubric_regression",
        "stale_skill",
        "other"
      ]
    },
    "evidence": {
      "type": "string",
      "minLength": 1
    },
    "summary": {
      "type": "string",
      "minLength": 1
    },
    "source": {
      "type": "string",
      "minLength": 1
    },
    "suggestedArtifactType": {
      "type": "string",
      "enum": ["skill", "agent", "workflow", "hook", "schema", "command"]
    }
  },
  "allOf": [
    {
      "if": {
        "properties": {
          "trigger": {
            "const": "stale_skill"
          }
        }
      },
      "then": {
        "required": ["evidence"]
      }
    }
  ],
  "additionalProperties": true
}

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "recommend-evolution Output Schema",
  "description": "Output validation schema for recommend-evolution skill",
  "type": "object",
  "required": ["success"],
  "properties": {
    "success": {
      "type": "boolean",
      "description": "Whether the skill executed successfully"
    },
    "result": {
      "type": "object",
      "description": "The skill execution result",
      "additionalProperties": true
    },
    "error": {
      "type": "string",
      "description": "Error message if execution failed"
    }
  },
  "additionalProperties": true
}

#!/usr/bin/env node
'use strict';

const fs = require('node:fs');
const path = require('node:path');
const crypto = require('node:crypto');

const ALLOWED_TRIGGERS = new Set([
  'repeated_error',
  'no_agent',
  'integration_gap',
  'user_request',
  'rubric_regression',
  'stale_skill',
  'other',
]);

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

const PROJECT_ROOT = findProjectRoot();
const EVOLUTION_QUEUE_PATH = path.join(
  PROJECT_ROOT,
  '.claude',
  'context',
  'runtime',
  'evolution-requests.jsonl'
);

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

function normalizeTrigger(trigger) {
  const value = String(trigger || '').trim();
  return ALLOWED_TRIGGERS.has(value) ? value : null;
}

function toText(value, fallback = '') {
  const text = String(value == null ? '' : value).trim();
  return text || fallback;
}

function ensureQueueDir(queuePath = EVOLUTION_QUEUE_PATH) {
  fs.mkdirSync(path.dirname(queuePath), { recursive: true });
}

function buildRequest(options = {}) {
  const trigger = normalizeTrigger(options.trigger);
  if (!trigger) {
    return { ok: false, error: 'Invalid or missing --trigger' };
  }

  const suggestedArtifactType = toText(
    options.suggestedArtifactType || options.suggested_artifact_type,
    null
  );
  const source = toText(options.source, 'recommend-evolution');
  const evidence = toText(
    options.evidence,
    trigger === 'stale_skill' ? 'Stale artifact detected by audit.' : 'No evidence provided.'
  );
  const summary = toText(
    options.summary,
    'Recommend capability evolution based on repeated signals.'
  );
  const now = new Date().toISOString();
  const idInput = `${trigger}|${suggestedArtifactType || 'unknown'}|${summary}|${evidence}`;
  // M-03: non-security use (cache key / content addressing / UUID namespace); MD5/SHA-1 acceptable
  const id = `evo_${crypto.createHash('sha1').update(idInput).digest('hex').slice(0, 12)}`;

  return {
    ok: true,
    request: {
      id,
      timestamp: now,
      source,
      trigger,
      evidence,
      suggestedArtifactType: suggestedArtifactType || null,
      summary,
      status: 'proposed',
    },
  };
}

function appendQueueEntry(entry, queuePath = EVOLUTION_QUEUE_PATH) {
  ensureQueueDir(queuePath);
  const line = `${JSON.stringify(entry)}\n`;
  fs.appendFileSync(queuePath, line, 'utf8');
  return queuePath;
}

function main(input = null) {
  const options = input || parseArgs(process.argv.slice(2));
  if (options.help) {
    return {
      success: true,
      usage:
        'node .claude/skills/recommend-evolution/scripts/main.cjs --trigger <type> [--suggestedArtifactType skill|agent|workflow|hook|schema|command] [--summary <text>] [--evidence <text>] [--source <text>]',
    };
  }

  const built = buildRequest(options);
  if (!built.ok) {
    return {
      success: false,
      error: built.error,
    };
  }

  const queuePath = appendQueueEntry(built.request, EVOLUTION_QUEUE_PATH);
  return {
    success: true,
    result: {
      request: built.request,
      queuePath: path.relative(PROJECT_ROOT, queuePath).replace(/\\/g, '/'),
    },
  };
}

if (require.main === module) {
  const result = main();
  if (result.usage) {
    console.log(result.usage);
    process.exit(0);
  }
  console.log(JSON.stringify(result, null, 2));
  process.exit(result.success ? 0 : 1);
}

module.exports = {
  ALLOWED_TRIGGERS,
  parseArgs,
  normalizeTrigger,
  buildRequest,
  appendQueueEntry,
  main,
  EVOLUTION_QUEUE_PATH,
};