murmur8 3.5.0

package/src/tools/validation.js

@@ -0,0 +1,83 @@
+/**
+ * Tool Input Validation Utilities
+ * Validates inputs against tool schema constraints
+ */
+
+/**
+ * Validate tool input against a schema
+ * @param {Object} schema - Tool schema with input_schema
+ * @param {Object} input - Input to validate
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+function validateToolInput(schema, input) {
+  const errors = [];
+  const props = schema.input_schema.properties;
+  const required = schema.input_schema.required || [];
+
+  // Check required fields
+  for (const field of required) {
+    if (!(field in input)) {
+      errors.push(`missing required field: ${field}`);
+    }
+  }
+
+  // Validate each field
+  for (const [key, value] of Object.entries(input)) {
+    const propSchema = props[key];
+    if (!propSchema) continue;
+
+    // Type: number with bounds
+    if (propSchema.type === 'number') {
+      if (typeof value !== 'number') {
+        errors.push(`${key} must be number`);
+      } else {
+        if (propSchema.minimum !== undefined && value < propSchema.minimum) {
+          errors.push(`${key} below minimum ${propSchema.minimum}`);
+        }
+        if (propSchema.maximum !== undefined && value > propSchema.maximum) {
+          errors.push(`${key} above maximum ${propSchema.maximum}`);
+        }
+      }
+    }
+
+    // Type: array
+    if (propSchema.type === 'array') {
+      if (!Array.isArray(value)) {
+        errors.push(`${key} must be array`);
+      }
+    }
+
+    // Type: string with maxLength
+    if (propSchema.type === 'string') {
+      if (typeof value !== 'string') {
+        errors.push(`${key} must be string`);
+      } else if (propSchema.maxLength && value.length > propSchema.maxLength) {
+        errors.push(`${key} exceeds maxLength ${propSchema.maxLength}`);
+      }
+    }
+
+    // Enum constraint
+    if (propSchema.enum && !propSchema.enum.includes(value)) {
+      errors.push(`${key} must be one of: ${propSchema.enum.join(', ')}`);
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Normalize feedback input to handle "rec" shorthand for "recommendation"
+ * @param {Object} input - Raw feedback input
+ * @returns {Object} - Normalized input
+ */
+function normalizeFeedbackInput(input) {
+  if (input.rec && !input.recommendation) {
+    return { ...input, recommendation: input.rec };
+  }
+  return input;
+}
+
+module.exports = {
+  validateToolInput,
+  normalizeFeedbackInput
+};

package/src/update.js

@@ -0,0 +1,112 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const TARGET_DIR = process.cwd();
+
+// Directories that contain user content and should NOT be overwritten
+const USER_CONTENT_DIRS = [
+  'features',
+  'system_specification'
+];
+
+// Directories/files that should be updated
+const UPDATABLE = [
+  'agents',
+  'templates',
+  'ways_of_working'
+];
+
+async function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().trim());
+    });
+  });
+}
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+async function update() {
+  const blueprintDest = path.join(TARGET_DIR, '.blueprint');
+  const blueprintSrc = path.join(PACKAGE_ROOT, '.blueprint');
+  const skillSrc = path.join(PACKAGE_ROOT, 'SKILL.md');
+  const skillDest = path.join(TARGET_DIR, 'SKILL.md');
+
+  // Check if .blueprint exists
+  if (!fs.existsSync(blueprintDest)) {
+    console.log('.blueprint directory not found. Run "agent-workflow init" first.');
+    process.exit(1);
+  }
+
+  console.log('Updating agent-workflow...');
+  console.log('(Preserving: features/, system_specification/)\n');
+
+  // Update each updatable directory
+  for (const dir of UPDATABLE) {
+    const srcDir = path.join(blueprintSrc, dir);
+    const destDir = path.join(blueprintDest, dir);
+
+    if (fs.existsSync(srcDir)) {
+      if (fs.existsSync(destDir)) {
+        fs.rmSync(destDir, { recursive: true });
+      }
+      copyDir(srcDir, destDir);
+      console.log(`Updated .blueprint/${dir}/`);
+    }
+  }
+
+  // Update SKILL.md and .claude/commands/implement-feature.md
+  const answer = await prompt('\nUpdate SKILL.md and .claude/commands/implement-feature.md? (Y/n): ');
+  if (answer !== 'n' && answer !== 'no') {
+    fs.copyFileSync(skillSrc, skillDest);
+    console.log('Updated SKILL.md');
+
+    // Also update the Claude Code skill command
+    const skillCommandDest = path.join(TARGET_DIR, '.claude', 'commands', 'implement-feature.md');
+    if (fs.existsSync(path.dirname(skillCommandDest))) {
+      fs.copyFileSync(skillSrc, skillCommandDest);
+      console.log('Updated .claude/commands/implement-feature.md');
+    }
+  }
+
+  console.log(`
+Update complete!
+
+Updated:
+  - .blueprint/agents/
+  - .blueprint/templates/
+  - .blueprint/ways_of_working/
+  - SKILL.md
+  - .claude/commands/implement-feature.md (if exists)
+
+Preserved:
+  - .blueprint/features/
+  - .blueprint/system_specification/
+  - .business_context/
+`);
+}
+
+module.exports = { update };

package/src/validate.js

@@ -0,0 +1,172 @@
+const fs = require('fs');
+const path = require('path');
+
+const REQUIRED_DIRS = ['.blueprint', '.business_context', '.claude/commands'];
+const AGENT_FILES = [
+  'AGENT_SPECIFICATION_ALEX.md',
+  'AGENT_BA_CASS.md',
+  'AGENT_TESTER_NIGEL.md',
+  'AGENT_DEVELOPER_CODEY.md'
+];
+const SYSTEM_SPEC_PATH = '.blueprint/system_specification/SYSTEM_SPEC.md';
+const SKILL_PATH = '.claude/commands/implement-feature.md';
+const MIN_NODE_VERSION = 18;
+
+function checkDirectories() {
+  const missing = REQUIRED_DIRS.filter(dir => !fs.existsSync(dir));
+  const passed = missing.length === 0;
+  return {
+    name: 'Required directories',
+    passed,
+    message: passed
+      ? 'All required directories exist'
+      : `Missing directories: ${missing.join(', ')}`,
+    fix: passed ? null : 'Run `murmur8 init` to initialize project'
+  };
+}
+
+function checkSystemSpec() {
+  const exists = fs.existsSync(SYSTEM_SPEC_PATH);
+  return {
+    name: 'System specification',
+    passed: exists,
+    message: exists
+      ? 'System specification exists'
+      : `Missing: ${SYSTEM_SPEC_PATH}`,
+    fix: exists ? null : 'Run `murmur8 init` to create system specification'
+  };
+}
+
+function checkAgentSpecs() {
+  const agentsDir = '.blueprint/agents';
+  if (!fs.existsSync(agentsDir)) {
+    return {
+      name: 'agent specifications',
+      passed: false,
+      message: 'Missing: .blueprint/agents directory',
+      fix: 'Run `murmur8 init` to create agent specification files'
+    };
+  }
+
+  const missing = AGENT_FILES.filter(f => !fs.existsSync(path.join(agentsDir, f)));
+  const passed = missing.length === 0;
+  return {
+    name: 'agent specifications',
+    passed,
+    message: passed
+      ? 'All agent specifications exist'
+      : `Missing agent files: ${missing.join(', ')}`,
+    fix: passed ? null : 'Run `murmur8 init` to create agent specification files'
+  };
+}
+
+function checkBusinessContext() {
+  const dir = '.business_context';
+  if (!fs.existsSync(dir)) {
+    return {
+      name: 'business context',
+      passed: false,
+      message: 'Missing: .business_context directory',
+      fix: 'Run `murmur8 init` to create .business_context directory'
+    };
+  }
+
+  let files;
+  try {
+    files = fs.readdirSync(dir).filter(f => !f.startsWith('.'));
+  } catch {
+    files = [];
+  }
+
+  const passed = files.length > 0;
+  return {
+    name: 'business context',
+    passed,
+    message: passed
+      ? 'Business context directory has content'
+      : 'Business context directory is empty',
+    fix: passed ? null : 'Add at least one file to `.business_context/` directory'
+  };
+}
+
+function checkSkillsInstalled() {
+  const exists = fs.existsSync(SKILL_PATH);
+  return {
+    name: 'skills installed',
+    passed: exists,
+    message: exists
+      ? 'Required skills are installed'
+      : `Missing: ${SKILL_PATH}`,
+    fix: exists ? null : 'Run `murmur8 init` to install required skills'
+  };
+}
+
+function checkNodeVersion() {
+  const versionStr = process.version;
+  const majorVersion = parseInt(versionStr.slice(1).split('.')[0], 10);
+  const passed = majorVersion >= MIN_NODE_VERSION;
+  return {
+    name: 'Node.js version',
+    passed,
+    message: passed
+      ? `Node.js ${majorVersion} meets minimum requirement (>=${MIN_NODE_VERSION})`
+      : `Node.js ${majorVersion} is below minimum requirement (>=${MIN_NODE_VERSION})`,
+    fix: passed ? null : `Upgrade Node.js to version ${MIN_NODE_VERSION} or higher`,
+    detectedVersion: versionStr
+  };
+}
+
+async function validate() {
+  const checks = [
+    checkDirectories(),
+    checkSystemSpec(),
+    checkAgentSpecs(),
+    checkBusinessContext(),
+    checkSkillsInstalled(),
+    checkNodeVersion()
+  ];
+
+  const success = checks.every(c => c.passed);
+  const exitCode = success ? 0 : 1;
+
+  return { success, exitCode, checks };
+}
+
+function formatOutput(result, useColor = false) {
+  const lines = [];
+
+  const green = useColor ? '\x1b[32m' : '';
+  const red = useColor ? '\x1b[31m' : '';
+  const reset = useColor ? '\x1b[0m' : '';
+
+  const passIndicator = useColor ? `${green}\u2713${reset}` : '[PASS]';
+  const failIndicator = useColor ? `${red}\u2717${reset}` : '[FAIL]';
+
+  for (const check of result.checks) {
+    const indicator = check.passed ? passIndicator : failIndicator;
+    lines.push(`${indicator} ${check.name}: ${check.message}`);
+    if (!check.passed && check.fix) {
+      lines.push(`  Fix: ${check.fix}`);
+    }
+  }
+
+  lines.push('');
+  if (result.success) {
+    lines.push(useColor
+      ? `${green}All checks passed. Project is ready.${reset}`
+      : 'All checks passed. Project is ready.');
+  } else {
+    const failedCount = result.checks.filter(c => !c.passed).length;
+    lines.push(useColor
+      ? `${red}${failedCount} check(s) failed.${reset}`
+      : `${failedCount} check(s) failed.`);
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  validate,
+  formatOutput,
+  checkNodeVersion
+};