@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/scripts/test-memory-retrieval.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+/**
+ * Memory Retrieval Integration Test
+ *
+ * Tests the Memory Supervisor agent with all 4 engineers:
+ * - postgres-n8n-specialist
+ * - redis-architect
+ * - n8n-workflow-architect
+ * - github-expert
+ *
+ * Requirements:
+ * - Query: "authentication work"
+ * - Show results from all 4 engineers
+ * - Display timing (must be <5s)
+ * - Show aggregation stats
+ *
+ * Usage: node scripts/test-memory-retrieval.js
+ */
+
+import { queryMemorySupervisor, getMemoryCacheStats } from '../lib/agents/memory-supervisor.js';
+import { formatResults, getAggregationStats } from '../lib/memory-result-aggregator.js';
+
+const TEST_QUERY = 'authentication work';
+const MAX_RESULTS = 10;
+const TIMEOUT_MS = 5000;
+
+/**
+ * Format duration in human-readable format
+ */
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+
+/**
+ * Display results in readable format
+ */
+function displayResults(response) {
+  console.log('\n' + '='.repeat(80));
+  console.log('MEMORY RETRIEVAL TEST RESULTS');
+  console.log('='.repeat(80));
+
+  console.log(`\nQuery: "${response.query}"`);
+  console.log(`Cache Hit: ${response.cache_hit ? 'YES' : 'NO'}`);
+  console.log(`Query Time: ${formatDuration(response.query_time_ms)} ${response.query_time_ms < TIMEOUT_MS ? '✅' : '❌ TIMEOUT'}`);
+  console.log(`Timestamp: ${response.timestamp}`);
+
+  console.log('\n' + '-'.repeat(80));
+  console.log('ENGINEER STATUS');
+  console.log('-'.repeat(80));
+
+  response.engineers_queried.forEach(eng => {
+    const status = eng.error ? `❌ ${eng.error}` : `✅ ${eng.result_count} results`;
+    console.log(`  ${eng.name.padEnd(30)} [${eng.domain.padEnd(10)}] ${status}`);
+  });
+
+  console.log('\n' + '-'.repeat(80));
+  console.log(`TOP ${response.results.length} AGGREGATED RESULTS (of ${response.total_results} total)`);
+  console.log('-'.repeat(80));
+
+  if (response.results.length === 0) {
+    console.log('\n  No results found.');
+  } else {
+    response.results.forEach((result, idx) => {
+      console.log(`\n  [${idx + 1}] Score: ${result.relevance?.toFixed(3) || 'N/A'} | Source: ${result.source}`);
+      console.log(`      Engineer: ${result.engineer}`);
+      console.log(`      Title: ${result.title}`);
+      console.log(`      URL: ${result.url}`);
+      if (result.labels && result.labels.length > 0) {
+        console.log(`      Labels: ${result.labels.join(', ')}`);
+      }
+      if (result.summary) {
+        const summaryPreview = result.summary.substring(0, 100);
+        console.log(`      Summary: ${summaryPreview}${result.summary.length > 100 ? '...' : ''}`);
+      }
+    });
+  }
+}
+
+/**
+ * Display aggregation statistics
+ */
+function displayAggregationStats(response) {
+  console.log('\n' + '-'.repeat(80));
+  console.log('AGGREGATION STATISTICS');
+  console.log('-'.repeat(80));
+
+  // Count results by source
+  const bySource = response.results.reduce((acc, r) => {
+    acc[r.source] = (acc[r.source] || 0) + 1;
+    return acc;
+  }, {});
+
+  console.log('\nResults by Source:');
+  Object.entries(bySource).forEach(([source, count]) => {
+    console.log(`  ${source}: ${count}`);
+  });
+
+  // Calculate average relevance
+  const scores = response.results.map(r => r.relevance || 0);
+  const avgScore = scores.length > 0
+    ? scores.reduce((a, b) => a + b, 0) / scores.length
+    : 0;
+
+  console.log('\nRelevance Scores:');
+  console.log(`  Average: ${avgScore.toFixed(3)}`);
+  console.log(`  Highest: ${scores.length > 0 ? Math.max(...scores).toFixed(3) : 'N/A'}`);
+  console.log(`  Lowest: ${scores.length > 0 ? Math.min(...scores).toFixed(3) : 'N/A'}`);
+}
+
+/**
+ * Display cache statistics
+ */
+async function displayCacheStats() {
+  try {
+    const stats = await getMemoryCacheStats();
+
+    console.log('\n' + '-'.repeat(80));
+    console.log('REDIS CACHE STATISTICS');
+    console.log('-'.repeat(80));
+
+    console.log(`\nTotal Cached Queries: ${stats.total_cached_queries}`);
+
+    if (stats.cache_keys.length > 0) {
+      console.log('\nCached Queries:');
+      stats.cache_keys.forEach(cache => {
+        console.log(`\n  Query: "${cache.query}"`);
+        console.log(`  Results: ${cache.result_count}`);
+        console.log(`  TTL: ${formatDuration(cache.ttl_remaining * 1000)}`);
+        console.log(`  Cached At: ${cache.cached_at}`);
+      });
+    }
+  } catch (err) {
+    console.log('\n⚠️  Could not retrieve cache stats:', err.message);
+  }
+}
+
+/**
+ * Main test function
+ */
+async function runTest() {
+  console.log('\n🧪 Starting Memory Retrieval Integration Test...\n');
+  console.log(`Testing query: "${TEST_QUERY}"`);
+  console.log(`Timeout threshold: ${formatDuration(TIMEOUT_MS)}`);
+  console.log(`Max results: ${MAX_RESULTS}`);
+
+  try {
+    // First run: Fresh query (cache miss expected)
+    console.log('\n📊 Test Run 1: Fresh Query (Cache Miss Expected)\n');
+    const response1 = await queryMemorySupervisor(TEST_QUERY, {
+      timeout: TIMEOUT_MS,
+      limit: MAX_RESULTS,
+      useCache: true
+    });
+
+    displayResults(response1);
+    displayAggregationStats(response1);
+
+    // Second run: Should hit cache
+    console.log('\n\n📊 Test Run 2: Repeat Query (Cache Hit Expected)\n');
+    const response2 = await queryMemorySupervisor(TEST_QUERY, {
+      timeout: TIMEOUT_MS,
+      limit: MAX_RESULTS,
+      useCache: true
+    });
+
+    displayResults(response2);
+
+    // Display cache stats
+    await displayCacheStats();
+
+    // Final summary
+    console.log('\n' + '='.repeat(80));
+    console.log('TEST SUMMARY');
+    console.log('='.repeat(80));
+
+    const test1Pass = response1.query_time_ms < TIMEOUT_MS;
+    const test2Pass = response2.query_time_ms < TIMEOUT_MS && response2.cache_hit;
+
+    console.log(`\n  Run 1 (Fresh Query):`);
+    console.log(`    Timing: ${formatDuration(response1.query_time_ms)} ${test1Pass ? '✅ PASS' : '❌ FAIL'}`);
+    console.log(`    Results: ${response1.results.length} / ${response1.total_results}`);
+    console.log(`    Engineers: ${response1.engineers_queried.filter(e => !e.error).length} / ${response1.engineers_queried.length} succeeded`);
+
+    console.log(`\n  Run 2 (Cached Query):`);
+    console.log(`    Timing: ${formatDuration(response2.query_time_ms)} ${test2Pass ? '✅ PASS' : '❌ FAIL'}`);
+    console.log(`    Cache Hit: ${response2.cache_hit ? '✅ YES' : '❌ NO'}`);
+
+    console.log(`\n  Overall: ${test1Pass && test2Pass ? '✅ ALL TESTS PASSED' : '❌ SOME TESTS FAILED'}\n`);
+
+    process.exit(test1Pass && test2Pass ? 0 : 1);
+
+  } catch (err) {
+    console.error('\n❌ Test failed with error:', err.message);
+    console.error(err.stack);
+    process.exit(1);
+  }
+}
+
+// Run the test
+runTest();

package/scripts/validate-exports.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+/**
+ * Validate that all exports are properly importable
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packagePath = path.join(__dirname, '../package.json');
+const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+
+console.log('\n=== Validating Exports ===\n');
+
+if (!pkg.exports) {
+  console.log('⚠ No exports field found in package.json');
+  process.exit(0);
+}
+
+const errors = [];
+const warnings = [];
+
+for (const [exportKey, exportPath] of Object.entries(pkg.exports)) {
+  if (typeof exportPath === 'string') {
+    const fullPath = path.join(__dirname, '..', exportPath);
+    if (!fs.existsSync(fullPath)) {
+      errors.push(`Export "${exportKey}" -> "${exportPath}" does not exist`);
+    } else {
+      // Try to validate it's valid JavaScript/JSON
+      try {
+        const content = fs.readFileSync(fullPath, 'utf8');
+        if (content.length === 0) {
+          warnings.push(`Export "${exportKey}" is empty`);
+        } else {
+          console.log(`✓ ${exportKey} -> ${exportPath}`);
+        }
+      } catch (e) {
+        errors.push(`Export "${exportKey}": failed to read - ${e.message}`);
+      }
+    }
+  } else if (typeof exportPath === 'object') {
+    // Handle conditional exports
+    for (const [condition, condPath] of Object.entries(exportPath)) {
+      const fullPath = path.join(__dirname, '..', condPath);
+      if (!fs.existsSync(fullPath)) {
+        errors.push(`Export "${exportKey}[${condition}]" -> "${condPath}" does not exist`);
+      } else {
+        console.log(`✓ ${exportKey}[${condition}] -> ${condPath}`);
+      }
+    }
+  }
+}
+
+if (errors.length > 0) {
+  console.log('\nERRORS:\n');
+  errors.forEach(e => console.log(`  ✗ ${e}`));
+  process.exit(1);
+}
+
+if (warnings.length > 0) {
+  console.log('\nWARNINGS:\n');
+  warnings.forEach(w => console.log(`  ⚠ ${w}`));
+}
+
+console.log('\n✓ All exports are valid!\n');
+process.exit(0);

package/scripts/validate-package.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+/**
+ * Validate package.json is ready for npm publishing
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packagePath = path.join(__dirname, '../package.json');
+const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+
+const errors = [];
+const warnings = [];
+
+// Required fields for scoped packages
+const required = ['name', 'version', 'description', 'main', 'license', 'repository'];
+for (const field of required) {
+  if (!pkg[field]) {
+    errors.push(`Missing required field: ${field}`);
+  }
+}
+
+// Check name format
+if (pkg.name && !pkg.name.startsWith('@cpretzinger/')) {
+  errors.push(`Invalid scoped package name. Expected format: @cpretzinger/<name>, got: ${pkg.name}`);
+}
+
+// Check version format (semver)
+if (pkg.version && !/^\d+\.\d+\.\d+/.test(pkg.version)) {
+  errors.push(`Invalid version format. Expected semver, got: ${pkg.version}`);
+}
+
+// Check files field
+if (!pkg.files || pkg.files.length === 0) {
+  errors.push('Missing or empty "files" field - this limits what gets published');
+}
+
+// Check bin configuration
+if (!pkg.bin || Object.keys(pkg.bin).length === 0) {
+  warnings.push('No bin entries found - package cannot be used as CLI tool');
+}
+
+// Check main entry point exists
+if (pkg.main) {
+  const mainPath = path.join(__dirname, '..', pkg.main);
+  if (!fs.existsSync(mainPath)) {
+    errors.push(`Main entry point not found: ${pkg.main}`);
+  }
+}
+
+// Check all bin entries exist
+if (pkg.bin) {
+  for (const [name, location] of Object.entries(pkg.bin)) {
+    const binPath = path.join(__dirname, '..', location);
+    if (!fs.existsSync(binPath)) {
+      errors.push(`Bin file not found: ${location}`);
+    }
+  }
+}
+
+// Check exports field
+if (pkg.exports) {
+  for (const [key, location] of Object.entries(pkg.exports)) {
+    const exportPath = path.join(__dirname, '..', location);
+    if (!fs.existsSync(exportPath)) {
+      errors.push(`Export path not found: ${location} (${key})`);
+    }
+  }
+}
+
+// Check dependencies
+if (!pkg.dependencies || Object.keys(pkg.dependencies).length === 0) {
+  warnings.push('No dependencies specified');
+}
+
+// Check engines
+if (!pkg.engines || !pkg.engines.node) {
+  warnings.push('No Node.js version requirement specified in engines');
+}
+
+// Print results
+console.log('\n=== NPM Package Validation ===\n');
+
+if (errors.length === 0) {
+  console.log('✓ All required fields present');
+  console.log('✓ Package name format valid');
+  console.log('✓ Version format valid (semver)');
+  console.log('✓ Main entry point accessible');
+  console.log('✓ All bin files accessible');
+  console.log('✓ All export paths accessible');
+  console.log('✓ Files field properly configured');
+} else {
+  console.log('ERRORS FOUND:\n');
+  errors.forEach(e => console.log(`  ✗ ${e}`));
+}
+
+if (warnings.length > 0) {
+  console.log('\nWARNINGS:\n');
+  warnings.forEach(w => console.log(`  ⚠ ${w}`));
+}
+
+console.log('\n=== Package Summary ===\n');
+console.log(`Name:     ${pkg.name}`);
+console.log(`Version:  ${pkg.version}`);
+console.log(`Main:     ${pkg.main}`);
+console.log(`Type:     ${pkg.type || 'commonjs'}`);
+console.log(`License:  ${pkg.license}`);
+console.log(`Files:    ${pkg.files.length} entries`);
+console.log(`Bin:      ${Object.keys(pkg.bin || {}).length} entries`);
+console.log(`Exports:  ${Object.keys(pkg.exports || {}).length} entries`);
+
+if (errors.length > 0) {
+  process.exit(1);
+}
+
+console.log('\n✓ Package is ready for publishing!\n');
+process.exit(0);

package/scripts/verify-onyx-deployment.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+/**
+ * ONYX HOOKS DEPLOYMENT VERIFICATION
+ *
+ * Quick verification script to ensure all components are ready
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.dirname(__dirname);
+
+console.log(chalk.blue('\n🔍 ONYX HOOKS DEPLOYMENT VERIFICATION\n'));
+console.log(chalk.dim('═'.repeat(80)));
+
+const checks = [];
+
+/**
+ * Verification checks
+ */
+
+// Check 1: Core module files exist
+async function checkCoreFiles() {
+  const files = [
+    'lib/onyx-tool-interceptor.js',
+    'lib/onyx-wrapper.js',
+    'bin/onyx-guard.js',
+    '.claude-hooks/onyx-pre-hook.json',
+    'scripts/install-onyx-hooks.js',
+    'examples/onyx-hooks-demo.js',
+    'test/onyx-hooks.test.js',
+    'docs/ONYX-HOOKS-SYSTEM.md'
+  ];
+
+  const results = [];
+
+  for (const file of files) {
+    const filePath = path.join(projectRoot, file);
+    try {
+      await fs.access(filePath);
+      results.push({ file, exists: true });
+    } catch (error) {
+      results.push({ file, exists: false });
+    }
+  }
+
+  const allExist = results.every(r => r.exists);
+
+  checks.push({
+    name: 'Core module files',
+    passed: allExist,
+    details: results
+  });
+
+  return allExist;
+}
+
+// Check 2: Configuration is valid
+async function checkConfiguration() {
+  const configPath = path.join(projectRoot, '.claude-hooks', 'onyx-pre-hook.json');
+
+  try {
+    const content = await fs.readFile(configPath, 'utf-8');
+    const config = JSON.parse(content);
+
+    const hasRequired =
+      config.name &&
+      config.version &&
+      config.agent === 'ONYX' &&
+      config.interceptor &&
+      config.rules &&
+      config.rules.forbiddenTools &&
+      config.rules.allowedTools &&
+      config.logging;
+
+    checks.push({
+      name: 'Configuration structure',
+      passed: hasRequired,
+      details: {
+        enabled: config.enabled,
+        agent: config.agent,
+        forbiddenTools: config.rules.forbiddenTools.length,
+        allowedTools: config.rules.allowedTools.length
+      }
+    });
+
+    return hasRequired;
+  } catch (error) {
+    checks.push({
+      name: 'Configuration structure',
+      passed: false,
+      error: error.message
+    });
+    return false;
+  }
+}
+
+// Check 3: Package exports are configured
+async function checkPackageExports() {
+  const packagePath = path.join(projectRoot, 'package.json');
+
+  try {
+    const content = await fs.readFile(packagePath, 'utf-8');
+    const pkg = JSON.parse(content);
+
+    const hasExports =
+      pkg.exports['./onyx-tool-interceptor'] &&
+      pkg.exports['./onyx-wrapper'] &&
+      pkg.bin['onyx-guard'];
+
+    checks.push({
+      name: 'Package exports configured',
+      passed: hasExports,
+      details: {
+        interceptor: !!pkg.exports['./onyx-tool-interceptor'],
+        wrapper: !!pkg.exports['./onyx-wrapper'],
+        cli: !!pkg.bin['onyx-guard']
+      }
+    });
+
+    return hasExports;
+  } catch (error) {
+    checks.push({
+      name: 'Package exports configured',
+      passed: false,
+      error: error.message
+    });
+    return false;
+  }
+}
+
+// Check 4: NPM scripts are available
+async function checkNpmScripts() {
+  const packagePath = path.join(projectRoot, 'package.json');
+
+  try {
+    const content = await fs.readFile(packagePath, 'utf-8');
+    const pkg = JSON.parse(content);
+
+    const requiredScripts = [
+      'install:onyx-hooks',
+      'uninstall:onyx-hooks',
+      'verify:onyx-hooks',
+      'test:onyx-hooks',
+      'test:onyx-guard',
+      'demo:onyx-hooks'
+    ];
+
+    const scriptResults = requiredScripts.map(script => ({
+      script,
+      exists: !!pkg.scripts[script]
+    }));
+
+    const allExist = scriptResults.every(r => r.exists);
+
+    checks.push({
+      name: 'NPM scripts configured',
+      passed: allExist,
+      details: scriptResults
+    });
+
+    return allExist;
+  } catch (error) {
+    checks.push({
+      name: 'NPM scripts configured',
+      passed: false,
+      error: error.message
+    });
+    return false;
+  }
+}
+
+// Check 5: Modules can be imported
+async function checkModuleImports() {
+  try {
+    const { OnyxToolInterceptor } = await import('../lib/onyx-tool-interceptor.js');
+    const { OnyxWrapper } = await import('../lib/onyx-wrapper.js');
+
+    const interceptorValid = typeof OnyxToolInterceptor === 'function';
+    const wrapperValid = typeof OnyxWrapper === 'function';
+
+    checks.push({
+      name: 'Module imports work',
+      passed: interceptorValid && wrapperValid,
+      details: {
+        interceptor: interceptorValid,
+        wrapper: wrapperValid
+      }
+    });
+
+    return interceptorValid && wrapperValid;
+  } catch (error) {
+    checks.push({
+      name: 'Module imports work',
+      passed: false,
+      error: error.message
+    });
+    return false;
+  }
+}
+
+// Check 6: File permissions (executables)
+async function checkFilePermissions() {
+  const executables = [
+    'bin/onyx-guard.js',
+    'lib/onyx-tool-interceptor.js',
+    'lib/onyx-wrapper.js'
+  ];
+
+  const results = [];
+
+  for (const file of executables) {
+    const filePath = path.join(projectRoot, file);
+    try {
+      const stats = await fs.stat(filePath);
+      const isExecutable = (stats.mode & 0o111) !== 0;
+      results.push({ file, executable: isExecutable });
+    } catch (error) {
+      results.push({ file, executable: false, error: error.message });
+    }
+  }
+
+  const allExecutable = results.every(r => r.executable);
+
+  checks.push({
+    name: 'File permissions (executable)',
+    passed: allExecutable,
+    details: results
+  });
+
+  return allExecutable;
+}
+
+/**
+ * Run all checks
+ */
+async function runVerification() {
+  const startTime = Date.now();
+
+  try {
+    await checkCoreFiles();
+    await checkConfiguration();
+    await checkPackageExports();
+    await checkNpmScripts();
+    await checkModuleImports();
+    await checkFilePermissions();
+
+    const duration = Date.now() - startTime;
+    const totalChecks = checks.length;
+    const passedChecks = checks.filter(c => c.passed).length;
+    const failedChecks = totalChecks - passedChecks;
+
+    // Display results
+    console.log('\n');
+    checks.forEach((check, index) => {
+      const icon = check.passed ? chalk.green('✓') : chalk.red('✗');
+      console.log(`${icon} ${check.name}`);
+
+      if (!check.passed && check.error) {
+        console.log(chalk.dim(`  Error: ${check.error}`));
+      }
+
+      if (check.details && !check.passed) {
+        console.log(chalk.dim(`  Details: ${JSON.stringify(check.details, null, 2)}`));
+      }
+    });
+
+    console.log(chalk.dim('\n' + '═'.repeat(80)));
+    console.log(chalk.white(`\nVerification Summary:`));
+    console.log(chalk.green(`  Passed: ${passedChecks}/${totalChecks}`));
+
+    if (failedChecks > 0) {
+      console.log(chalk.red(`  Failed: ${failedChecks}/${totalChecks}`));
+    }
+
+    console.log(chalk.dim(`  Duration: ${duration}ms\n`));
+
+    if (passedChecks === totalChecks) {
+      console.log(chalk.green('✅ ONYX Hooks System: READY\n'));
+      console.log(chalk.white('Next steps:'));
+      console.log(chalk.dim('  1. Run: npm run test:onyx-hooks'));
+      console.log(chalk.dim('  2. Run: npm run demo:onyx-hooks'));
+      console.log(chalk.dim('  3. Test CLI: npx onyx-guard check Read'));
+      console.log(chalk.dim('  4. Integrate into ONYX workflow\n'));
+      process.exit(0);
+    } else {
+      console.log(chalk.red('❌ ONYX Hooks System: INCOMPLETE\n'));
+      console.log(chalk.white('Action required:'));
+      console.log(chalk.dim('  1. Run: npm run install:onyx-hooks'));
+      console.log(chalk.dim('  2. Fix failed checks above'));
+      console.log(chalk.dim('  3. Re-run: node scripts/verify-onyx-deployment.js\n'));
+      process.exit(1);
+    }
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Verification failed:'), error.message);
+    if (error.stack) {
+      console.error(chalk.dim(error.stack));
+    }
+    process.exit(1);
+  }
+}
+
+// Run verification
+runVerification();