@cloudstreamsoftware/claude-tools 1.0.0 → 1.1.0

package/scripts/setup-package-manager.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+/**
+ * Package Manager Setup Script
+ *
+ * Interactive script to configure preferred package manager.
+ * Can be run directly or via the /setup-pm command.
+ *
+ * Usage:
+ *   node scripts/setup-package-manager.js [pm-name]
+ *   node scripts/setup-package-manager.js --detect
+ *   node scripts/setup-package-manager.js --global pnpm
+ *   node scripts/setup-package-manager.js --project bun
+ */
+
+const {
+  PACKAGE_MANAGERS,
+  getPackageManager,
+  setPreferredPackageManager,
+  setProjectPackageManager,
+  getAvailablePackageManagers,
+  detectFromLockFile,
+  detectFromPackageJson,
+} = require('./lib/package-manager');
+
+function showHelp() {
+  console.log(`
+Package Manager Setup for Claude Code
+
+Usage:
+  node scripts/setup-package-manager.js [options] [package-manager]
+
+Options:
+  --detect        Detect and show current package manager
+  --global <pm>   Set global preference (saves to ~/.claude/package-manager.json)
+  --project <pm>  Set project preference (saves to .claude/package-manager.json)
+  --list          List available package managers
+  --help          Show this help message
+
+Package Managers:
+  npm             Node Package Manager (default with Node.js)
+  pnpm            Fast, disk space efficient package manager
+  yarn            Classic Yarn package manager
+  bun             All-in-one JavaScript runtime & toolkit
+
+Examples:
+  # Detect current package manager
+  node scripts/setup-package-manager.js --detect
+
+  # Set pnpm as global preference
+  node scripts/setup-package-manager.js --global pnpm
+
+  # Set bun for current project
+  node scripts/setup-package-manager.js --project bun
+
+  # List available package managers
+  node scripts/setup-package-manager.js --list
+`);
+}
+
+function detectAndShow() {
+  const pm = getPackageManager();
+  const available = getAvailablePackageManagers();
+  const fromLock = detectFromLockFile();
+  const fromPkg = detectFromPackageJson();
+
+  console.log('\n=== Package Manager Detection ===\n');
+
+  console.log('Current selection:');
+  console.log(`  Package Manager: ${pm.name}`);
+  console.log(`  Source: ${pm.source}`);
+  console.log('');
+
+  console.log('Detection results:');
+  console.log(`  From package.json: ${fromPkg || 'not specified'}`);
+  console.log(`  From lock file: ${fromLock || 'not found'}`);
+  console.log(`  Environment var: ${process.env.CLAUDE_PACKAGE_MANAGER || 'not set'}`);
+  console.log('');
+
+  console.log('Available package managers:');
+  for (const pmName of Object.keys(PACKAGE_MANAGERS)) {
+    const installed = available.includes(pmName);
+    const indicator = installed ? '✓' : '✗';
+    const current = pmName === pm.name ? ' (current)' : '';
+    console.log(`  ${indicator} ${pmName}${current}`);
+  }
+
+  console.log('');
+  console.log('Commands:');
+  console.log(`  Install: ${pm.config.installCmd}`);
+  console.log(`  Run script: ${pm.config.runCmd} [script-name]`);
+  console.log(`  Execute binary: ${pm.config.execCmd} [binary-name]`);
+  console.log('');
+}
+
+function listAvailable() {
+  const available = getAvailablePackageManagers();
+  const pm = getPackageManager();
+
+  console.log('\nAvailable Package Managers:\n');
+
+  for (const pmName of Object.keys(PACKAGE_MANAGERS)) {
+    const config = PACKAGE_MANAGERS[pmName];
+    const installed = available.includes(pmName);
+    const current = pmName === pm.name ? ' (current)' : '';
+
+    console.log(`${pmName}${current}`);
+    console.log(`  Installed: ${installed ? 'Yes' : 'No'}`);
+    console.log(`  Lock file: ${config.lockFile}`);
+    console.log(`  Install: ${config.installCmd}`);
+    console.log(`  Run: ${config.runCmd}`);
+    console.log('');
+  }
+}
+
+function setGlobal(pmName) {
+  if (!PACKAGE_MANAGERS[pmName]) {
+    console.error(`Error: Unknown package manager "${pmName}"`);
+    console.error(`Available: ${Object.keys(PACKAGE_MANAGERS).join(', ')}`);
+    process.exit(1);
+  }
+
+  const available = getAvailablePackageManagers();
+  if (!available.includes(pmName)) {
+    console.warn(`Warning: ${pmName} is not installed on your system`);
+  }
+
+  try {
+    setPreferredPackageManager(pmName);
+    console.log(`\n✓ Global preference set to: ${pmName}`);
+    console.log('  Saved to: ~/.claude/package-manager.json');
+    console.log('');
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function setProject(pmName) {
+  if (!PACKAGE_MANAGERS[pmName]) {
+    console.error(`Error: Unknown package manager "${pmName}"`);
+    console.error(`Available: ${Object.keys(PACKAGE_MANAGERS).join(', ')}`);
+    process.exit(1);
+  }
+
+  try {
+    setProjectPackageManager(pmName);
+    console.log(`\n✓ Project preference set to: ${pmName}`);
+    console.log('  Saved to: .claude/package-manager.json');
+    console.log('');
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// Main
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+  showHelp();
+  process.exit(0);
+}
+
+if (args.includes('--detect')) {
+  detectAndShow();
+  process.exit(0);
+}
+
+if (args.includes('--list')) {
+  listAvailable();
+  process.exit(0);
+}
+
+const globalIdx = args.indexOf('--global');
+if (globalIdx !== -1) {
+  const pmName = args[globalIdx + 1];
+  if (!pmName) {
+    console.error('Error: --global requires a package manager name');
+    process.exit(1);
+  }
+  setGlobal(pmName);
+  process.exit(0);
+}
+
+const projectIdx = args.indexOf('--project');
+if (projectIdx !== -1) {
+  const pmName = args[projectIdx + 1];
+  if (!pmName) {
+    console.error('Error: --project requires a package manager name');
+    process.exit(1);
+  }
+  setProject(pmName);
+  process.exit(0);
+}
+
+// If just a package manager name is provided, set it globally
+const pmName = args[0];
+if (PACKAGE_MANAGERS[pmName]) {
+  setGlobal(pmName);
+} else {
+  console.error(`Error: Unknown option or package manager "${pmName}"`);
+  showHelp();
+  process.exit(1);
+}

package/scripts/sync-upstream.js

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+/**
+ * Upstream Sync Tool
+ *
+ * Syncs fork with upstream repository while preserving customizations.
+ *
+ * Usage:
+ *   node scripts/sync-upstream.js check     # Preview what would sync
+ *   node scripts/sync-upstream.js dry-run   # Test merge without committing
+ *   node scripts/sync-upstream.js auto      # Full sync + tests + commit
+ *   node scripts/sync-upstream.js abort     # Cancel in-progress merge
+ */
+
+const { execSync, spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Directories to sync from upstream
+const SYNC_DIRS = ['agents/', 'commands/', 'skills/', 'rules/', 'mcp-configs/'];
+
+// Directories that are never synced (user customizations)
+const PROTECTED_DIRS = ['.env', 'personal/', 'private/'];
+
+// ANSI color codes
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+};
+
+// Disable colors if NO_COLOR is set
+const noColor = process.env.NO_COLOR || process.argv.includes('--no-color');
+
+function c(color, text) {
+  if (noColor) return text;
+  return `${colors[color]}${text}${colors.reset}`;
+}
+
+function log(message) {
+  console.log(message);
+}
+
+function error(message) {
+  console.error(c('red', `Error: ${message}`));
+}
+
+function success(message) {
+  console.log(c('green', `✓ ${message}`));
+}
+
+function warn(message) {
+  console.log(c('yellow', `⚠ ${message}`));
+}
+
+function info(message) {
+  console.log(c('cyan', `ℹ ${message}`));
+}
+
+/**
+ * Execute a git command and return output.
+ */
+function git(args, options = {}) {
+  try {
+    const result = execSync(`git ${args}`, {
+      encoding: 'utf8',
+      stdio: options.silent ? ['pipe', 'pipe', 'pipe'] : undefined,
+      ...options,
+    });
+    return { success: true, output: result.trim() };
+  } catch (err) {
+    return {
+      success: false,
+      output: err.stdout?.trim() || '',
+      error: err.stderr?.trim() || err.message,
+    };
+  }
+}
+
+/**
+ * Check if upstream remote is configured.
+ */
+function hasUpstream() {
+  const result = git('remote -v', { silent: true });
+  return result.success && result.output.includes('upstream');
+}
+
+/**
+ * Get current version from package.json.
+ */
+function getCurrentVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+/**
+ * Get upstream version (latest tag or package.json).
+ */
+function getUpstreamVersion() {
+  const result = git('show upstream/main:package.json', { silent: true });
+  if (result.success) {
+    try {
+      const pkg = JSON.parse(result.output);
+      return pkg.version || '0.0.0';
+    } catch {
+      return '0.0.0';
+    }
+  }
+  return '0.0.0';
+}
+
+/**
+ * Check for breaking version change.
+ */
+function isBreakingChange(current, upstream) {
+  const currentMajor = parseInt(current.split('.')[0], 10);
+  const upstreamMajor = parseInt(upstream.split('.')[0], 10);
+  return upstreamMajor > currentMajor;
+}
+
+/**
+ * Check command: Preview what would sync.
+ */
+function cmdCheck() {
+  log(c('bold', '\n=== Upstream Sync Check ===\n'));
+
+  // Verify upstream remote
+  if (!hasUpstream()) {
+    error('Upstream remote not configured.');
+    info('Run: git remote add upstream https://github.com/affaan-m/everything-claude-code.git');
+    process.exit(1);
+  }
+  success('Upstream remote configured');
+
+  // Fetch upstream
+  info('Fetching upstream...');
+  const fetchResult = git('fetch upstream');
+  if (!fetchResult.success) {
+    error(`Failed to fetch upstream: ${fetchResult.error}`);
+    process.exit(1);
+  }
+  success('Fetched upstream');
+
+  // Check version
+  const current = getCurrentVersion();
+  const upstream = getUpstreamVersion();
+  log(`\n${c('bold', 'Versions:')}`);
+  log(`  Current:  ${current}`);
+  log(`  Upstream: ${upstream}`);
+
+  if (isBreakingChange(current, upstream)) {
+    warn(`Breaking change detected (${current} → ${upstream}). Manual review required.`);
+  }
+
+  // Show commits behind
+  const behindResult = git('rev-list --count HEAD..upstream/main', { silent: true });
+  const commitsBehind = parseInt(behindResult.output, 10) || 0;
+
+  log(`\n${c('bold', 'Status:')}`);
+  if (commitsBehind === 0) {
+    success('Already up to date with upstream');
+    return;
+  }
+  log(`  ${commitsBehind} commit(s) behind upstream`);
+
+  // Show what would change
+  log(`\n${c('bold', 'Changed files in upstream:')}`);
+  const diffResult = git('diff --name-only HEAD..upstream/main', { silent: true });
+  if (diffResult.success && diffResult.output) {
+    const files = diffResult.output.split('\n');
+    const syncFiles = files.filter((f) => SYNC_DIRS.some((d) => f.startsWith(d)));
+    const protectedFiles = files.filter(
+      (f) => PROTECTED_DIRS.some((d) => f.startsWith(d)) || f === 'CLAUDE.md'
+    );
+    const otherFiles = files.filter((f) => !syncFiles.includes(f) && !protectedFiles.includes(f));
+
+    if (syncFiles.length > 0) {
+      log(`\n  ${c('green', 'Will sync')} (${syncFiles.length} files):`);
+      syncFiles.slice(0, 10).forEach((f) => log(`    ${f}`));
+      if (syncFiles.length > 10) log(`    ... and ${syncFiles.length - 10} more`);
+    }
+
+    if (protectedFiles.length > 0) {
+      log(`\n  ${c('yellow', 'Protected')} (${protectedFiles.length} files):`);
+      protectedFiles.forEach((f) => log(`    ${f}`));
+    }
+
+    if (otherFiles.length > 0) {
+      log(`\n  ${c('blue', 'Other changes')} (${otherFiles.length} files):`);
+      otherFiles.slice(0, 5).forEach((f) => log(`    ${f}`));
+      if (otherFiles.length > 5) log(`    ... and ${otherFiles.length - 5} more`);
+    }
+  }
+
+  log(`\n${c('bold', 'Next steps:')}`);
+  log('  npm run sync-dry-run  # Test the merge');
+  log('  npm run sync-auto     # Apply the sync');
+}
+
+/**
+ * Dry-run command: Test merge without committing.
+ */
+function cmdDryRun() {
+  log(c('bold', '\n=== Upstream Sync Dry Run ===\n'));
+
+  if (!hasUpstream()) {
+    error('Upstream remote not configured.');
+    process.exit(1);
+  }
+
+  // Fetch upstream
+  info('Fetching upstream...');
+  git('fetch upstream');
+
+  // Check for uncommitted changes
+  const statusResult = git('status --porcelain', { silent: true });
+  if (statusResult.output) {
+    warn('You have uncommitted changes. Commit or stash them first.');
+    log(statusResult.output);
+    process.exit(1);
+  }
+
+  // Try merge with --no-commit
+  info('Testing merge (no commit)...');
+  const mergeArgs = SYNC_DIRS.join(' ');
+  const mergeResult = git(`merge --no-commit --no-ff -X ours upstream/main -- ${mergeArgs}`, {
+    silent: true,
+  });
+
+  if (!mergeResult.success) {
+    if (mergeResult.error.includes('conflict')) {
+      warn('Merge would have conflicts:');
+      const conflictResult = git('diff --name-only --diff-filter=U', { silent: true });
+      if (conflictResult.output) {
+        conflictResult.output.split('\n').forEach((f) => log(`  ${f}`));
+      }
+    } else {
+      error(`Merge test failed: ${mergeResult.error}`);
+    }
+  } else {
+    success('Merge would succeed without conflicts');
+  }
+
+  // Abort the test merge
+  git('merge --abort', { silent: true });
+  success('Test merge aborted (no changes made)');
+
+  log(`\n${c('bold', 'Next steps:')}`);
+  log('  npm run sync-auto   # Apply the sync for real');
+}
+
+/**
+ * Auto command: Full sync with tests.
+ */
+function cmdAuto() {
+  log(c('bold', '\n=== Upstream Sync Auto ===\n'));
+
+  if (!hasUpstream()) {
+    error('Upstream remote not configured.');
+    process.exit(1);
+  }
+
+  // Check for uncommitted changes
+  const statusResult = git('status --porcelain', { silent: true });
+  if (statusResult.output) {
+    error('You have uncommitted changes. Commit or stash them first.');
+    log(statusResult.output);
+    process.exit(1);
+  }
+
+  // Check version for breaking changes
+  git('fetch upstream');
+  const current = getCurrentVersion();
+  const upstream = getUpstreamVersion();
+
+  if (isBreakingChange(current, upstream)) {
+    error(`Breaking change detected (${current} → ${upstream}).`);
+    info('Major version changes require manual review.');
+    info('Review CHANGELOG.md on upstream, then merge manually.');
+    process.exit(1);
+  }
+
+  // Perform merge
+  info('Merging upstream changes...');
+  const mergeArgs = SYNC_DIRS.join(' ');
+  const mergeResult = git(`merge -X ours upstream/main -- ${mergeArgs}`);
+
+  if (!mergeResult.success) {
+    error('Merge failed. Resolve conflicts manually or run: npm run sync-abort');
+    process.exit(1);
+  }
+  success('Merge completed');
+
+  // Run tests
+  info('Running tests to validate...');
+  try {
+    execSync('npm test', { stdio: 'inherit' });
+    success('All tests passed');
+  } catch {
+    error('Tests failed after merge!');
+    warn('You may need to fix issues or run: npm run sync-abort');
+    process.exit(1);
+  }
+
+  // Show summary
+  log(`\n${c('bold', 'Sync completed successfully!')}`);
+  log(`  Version: ${current} → ${upstream}`);
+  log('  Run: git push origin main  # to deploy');
+}
+
+/**
+ * Abort command: Cancel in-progress merge.
+ */
+function cmdAbort() {
+  log(c('bold', '\n=== Abort Sync ===\n'));
+
+  const result = git('merge --abort');
+  if (result.success) {
+    success('Merge aborted successfully');
+  } else if (result.error.includes('no merge')) {
+    info('No merge in progress');
+  } else {
+    error(`Failed to abort: ${result.error}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Show help.
+ */
+function showHelp() {
+  log(`
+${c('bold', 'Upstream Sync Tool')}
+
+Syncs fork with upstream repository while preserving customizations.
+
+${c('bold', 'Commands:')}
+  check     Preview what would sync
+  dry-run   Test merge without committing
+  auto      Full sync + tests + commit
+  abort     Cancel in-progress merge
+
+${c('bold', 'Usage:')}
+  npm run sync-check
+  npm run sync-dry-run
+  npm run sync-auto
+  npm run sync-abort
+
+${c('bold', 'Synced directories:')}
+  ${SYNC_DIRS.join(', ')}
+
+${c('bold', 'Protected (never synced):')}
+  ${PROTECTED_DIRS.join(', ')}, CLAUDE.md
+`);
+}
+
+// Main
+const command = process.argv[2];
+
+switch (command) {
+  case 'check':
+    cmdCheck();
+    break;
+  case 'dry-run':
+    cmdDryRun();
+    break;
+  case 'auto':
+    cmdAuto();
+    break;
+  case 'abort':
+    cmdAbort();
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+    showHelp();
+    break;
+  default:
+    if (command) {
+      error(`Unknown command: ${command}`);
+    }
+    showHelp();
+    process.exit(command ? 1 : 0);
+}

package/scripts/test.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/**
+ * Test script for @cloudstreamsoftware/claude-tools
+ * Validates package structure and basic functionality
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`✓ ${name}`);
+    passed++;
+  } catch (e) {
+    console.log(`✗ ${name}`);
+    console.log(`  Error: ${e.message}`);
+    failed++;
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message || 'Assertion failed');
+}
+
+console.log('Running @cloudstreamsoftware/claude-tools tests...\n');
+
+// Package structure tests
+test('package.json exists', () => {
+  assert(fs.existsSync(path.join(ROOT, 'package.json')));
+});
+
+test('package.json is valid JSON', () => {
+  const pkg = require(path.join(ROOT, 'package.json'));
+  assert(pkg.name === '@cloudstreamsoftware/claude-tools');
+});
+
+test('bin/cloudstream-setup.js exists', () => {
+  assert(fs.existsSync(path.join(ROOT, 'bin', 'cloudstream-setup.js')));
+});
+
+test('bin/postinstall.js exists', () => {
+  assert(fs.existsSync(path.join(ROOT, 'bin', 'postinstall.js')));
+});
+
+test('hooks/hooks.json exists', () => {
+  assert(fs.existsSync(path.join(ROOT, 'hooks', 'hooks.json')));
+});
+
+test('hooks/hooks.json is valid JSON', () => {
+  const hooks = require(path.join(ROOT, 'hooks', 'hooks.json'));
+  assert(hooks.hooks, 'hooks.json should have a "hooks" property');
+});
+
+// Script tests
+test('scripts/hooks/ directory exists', () => {
+  assert(fs.existsSync(path.join(ROOT, 'scripts', 'hooks')));
+});
+
+test('scripts/lib/ directory exists', () => {
+  assert(fs.existsSync(path.join(ROOT, 'scripts', 'lib')));
+});
+
+const requiredHookScripts = [
+  'prompt-router.js',
+  'prompt-analyzer.js',
+  'credential-check.js',
+  'session-start.js',
+  'session-end.js',
+  'quality-gate-enforcer.js',
+  'skill-injector.js',
+];
+
+requiredHookScripts.forEach(script => {
+  test(`scripts/hooks/${script} exists`, () => {
+    assert(fs.existsSync(path.join(ROOT, 'scripts', 'hooks', script)));
+  });
+});
+
+// Build output tests (if dist exists)
+if (fs.existsSync(path.join(ROOT, 'dist'))) {
+  test('dist/index.js exists', () => {
+    assert(fs.existsSync(path.join(ROOT, 'dist', 'index.js')));
+  });
+
+  test('dist/index.js exports expected interface', () => {
+    const pkg = require(path.join(ROOT, 'dist', 'index.js'));
+    assert(pkg.root, 'Should export root path');
+    assert(pkg.paths, 'Should export paths object');
+    assert(typeof pkg.getHooksConfig === 'function', 'Should export getHooksConfig');
+    assert(typeof pkg.getSkills === 'function', 'Should export getSkills');
+    assert(typeof pkg.getAgents === 'function', 'Should export getAgents');
+  });
+}
+
+// Summary
+console.log(`\n${'='.repeat(40)}`);
+console.log(`Tests: ${passed + failed} total, ${passed} passed, ${failed} failed`);
+
+if (failed > 0) {
+  process.exit(1);
+} else {
+  console.log('\n✅ All tests passed!');
+}