aw-ecc 1.4.21

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 || pmName.startsWith('-')) {
+    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 || pmName.startsWith('-')) {
+    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/skill-create-output.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+/**
+ * Skill Creator - Pretty Output Formatter
+ *
+ * Creates beautiful terminal output for the /skill-create command
+ * similar to @mvanhorn's /last30days skill
+ */
+
+// ANSI color codes - no external dependencies
+const chalk = {
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  magenta: (s) => `\x1b[35m${s}\x1b[0m`,
+  gray: (s) => `\x1b[90m${s}\x1b[0m`,
+  white: (s) => `\x1b[37m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  bgCyan: (s) => `\x1b[46m${s}\x1b[0m`,
+};
+
+// Box drawing characters
+const BOX = {
+  topLeft: '╭',
+  topRight: '╮',
+  bottomLeft: '╰',
+  bottomRight: '╯',
+  horizontal: '─',
+  vertical: '│',
+  verticalRight: '├',
+  verticalLeft: '┤',
+};
+
+// Progress spinner frames
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+// Helper functions
+function box(title, content, width = 60) {
+  const lines = content.split('\n');
+  const top = `${BOX.topLeft}${BOX.horizontal} ${chalk.bold(chalk.cyan(title))} ${BOX.horizontal.repeat(Math.max(0, width - title.length - 5))}${BOX.topRight}`;
+  const bottom = `${BOX.bottomLeft}${BOX.horizontal.repeat(width - 2)}${BOX.bottomRight}`;
+  const middle = lines.map(line => {
+    const padding = width - 4 - stripAnsi(line).length;
+    return `${BOX.vertical} ${line}${' '.repeat(Math.max(0, padding))} ${BOX.vertical}`;
+  }).join('\n');
+  return `${top}\n${middle}\n${bottom}`;
+}
+
+function stripAnsi(str) {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function progressBar(percent, width = 30) {
+  const filled = Math.min(width, Math.max(0, Math.round(width * percent / 100)));
+  const empty = width - filled;
+  const bar = chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+  return `${bar} ${chalk.bold(percent)}%`;
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function animateProgress(label, steps, callback) {
+  process.stdout.write(`\n${chalk.cyan('⏳')} ${label}...\n`);
+
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    process.stdout.write(`   ${chalk.gray(SPINNER[i % SPINNER.length])} ${step.name}`);
+    await sleep(step.duration || 500);
+    process.stdout.clearLine?.(0) || process.stdout.write('\r');
+    process.stdout.cursorTo?.(0) || process.stdout.write('\r');
+    process.stdout.write(`   ${chalk.green('✓')} ${step.name}\n`);
+    if (callback) callback(step, i);
+  }
+}
+
+// Main output formatter
+class SkillCreateOutput {
+  constructor(repoName, options = {}) {
+    this.repoName = repoName;
+    this.options = options;
+    this.width = options.width || 70;
+  }
+
+  header() {
+    const subtitle = `Extracting patterns from ${chalk.cyan(this.repoName)}`;
+
+    console.log('\n');
+    console.log(chalk.bold(chalk.magenta('╔════════════════════════════════════════════════════════════════╗')));
+    console.log(chalk.bold(chalk.magenta('║')) + chalk.bold('  🔮 ECC Skill Creator                                          ') + chalk.bold(chalk.magenta('║')));
+    console.log(chalk.bold(chalk.magenta('║')) + `     ${subtitle}${' '.repeat(Math.max(0, 59 - stripAnsi(subtitle).length))}` + chalk.bold(chalk.magenta('║')));
+    console.log(chalk.bold(chalk.magenta('╚════════════════════════════════════════════════════════════════╝')));
+    console.log('');
+  }
+
+  async analyzePhase(data) {
+    const steps = [
+      { name: 'Parsing git history...', duration: 300 },
+      { name: `Found ${chalk.yellow(data.commits)} commits`, duration: 200 },
+      { name: 'Analyzing commit patterns...', duration: 400 },
+      { name: 'Detecting file co-changes...', duration: 300 },
+      { name: 'Identifying workflows...', duration: 400 },
+      { name: 'Extracting architecture patterns...', duration: 300 },
+    ];
+
+    await animateProgress('Analyzing Repository', steps);
+  }
+
+  analysisResults(data) {
+    console.log('\n');
+    console.log(box('📊 Analysis Results', `
+${chalk.bold('Commits Analyzed:')} ${chalk.yellow(data.commits)}
+${chalk.bold('Time Range:')}       ${chalk.gray(data.timeRange)}
+${chalk.bold('Contributors:')}     ${chalk.cyan(data.contributors)}
+${chalk.bold('Files Tracked:')}    ${chalk.green(data.files)}
+`));
+  }
+
+  patterns(patterns) {
+    console.log('\n');
+    console.log(chalk.bold(chalk.cyan('🔍 Key Patterns Discovered:')));
+    console.log(chalk.gray('─'.repeat(50)));
+
+    patterns.forEach((pattern, i) => {
+      const confidence = pattern.confidence ?? 0.8;
+      const confidenceBar = progressBar(Math.round(confidence * 100), 15);
+      console.log(`
+  ${chalk.bold(chalk.yellow(`${i + 1}.`))} ${chalk.bold(pattern.name)}
+     ${chalk.gray('Trigger:')} ${pattern.trigger}
+     ${chalk.gray('Confidence:')} ${confidenceBar}
+     ${chalk.dim(pattern.evidence)}`);
+    });
+  }
+
+  instincts(instincts) {
+    console.log('\n');
+    console.log(box('🧠 Instincts Generated', instincts.map((inst, i) =>
+      `${chalk.yellow(`${i + 1}.`)} ${chalk.bold(inst.name)} ${chalk.gray(`(${Math.round(inst.confidence * 100)}%)`)}`
+    ).join('\n')));
+  }
+
+  output(skillPath, instinctsPath) {
+    console.log('\n');
+    console.log(chalk.bold(chalk.green('✨ Generation Complete!')));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(`
+  ${chalk.green('📄')} ${chalk.bold('Skill File:')}
+     ${chalk.cyan(skillPath)}
+
+  ${chalk.green('🧠')} ${chalk.bold('Instincts File:')}
+     ${chalk.cyan(instinctsPath)}
+`);
+  }
+
+  nextSteps() {
+    console.log(box('📋 Next Steps', `
+${chalk.yellow('1.')} Review the generated SKILL.md
+${chalk.yellow('2.')} Import instincts: ${chalk.cyan('/instinct-import <path>')}
+${chalk.yellow('3.')} View learned patterns: ${chalk.cyan('/instinct-status')}
+${chalk.yellow('4.')} Evolve into skills: ${chalk.cyan('/evolve')}
+`));
+    console.log('\n');
+  }
+
+  footer() {
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.dim(`  Powered by Everything Claude Code • ecc.tools`));
+    console.log(chalk.dim(`  GitHub App: github.com/apps/skill-creator`));
+    console.log('\n');
+  }
+}
+
+// Demo function to show the output
+async function demo() {
+  const output = new SkillCreateOutput('PMX');
+
+  output.header();
+
+  await output.analyzePhase({
+    commits: 200,
+  });
+
+  output.analysisResults({
+    commits: 200,
+    timeRange: 'Nov 2024 - Jan 2025',
+    contributors: 4,
+    files: 847,
+  });
+
+  output.patterns([
+    {
+      name: 'Conventional Commits',
+      trigger: 'when writing commit messages',
+      confidence: 0.85,
+      evidence: 'Found in 150/200 commits (feat:, fix:, refactor:)',
+    },
+    {
+      name: 'Client/Server Component Split',
+      trigger: 'when creating Next.js pages',
+      confidence: 0.90,
+      evidence: 'Observed in markets/, premarkets/, portfolio/',
+    },
+    {
+      name: 'Service Layer Architecture',
+      trigger: 'when adding backend logic',
+      confidence: 0.85,
+      evidence: 'Business logic in services/, not routes/',
+    },
+    {
+      name: 'TDD with E2E Tests',
+      trigger: 'when adding features',
+      confidence: 0.75,
+      evidence: '9 E2E test files, test(e2e) commits common',
+    },
+  ]);
+
+  output.instincts([
+    { name: 'pmx-conventional-commits', confidence: 0.85 },
+    { name: 'pmx-client-component-pattern', confidence: 0.90 },
+    { name: 'pmx-service-layer', confidence: 0.85 },
+    { name: 'pmx-e2e-test-location', confidence: 0.90 },
+    { name: 'pmx-package-manager', confidence: 0.95 },
+    { name: 'pmx-hot-path-caution', confidence: 0.90 },
+  ]);
+
+  output.output(
+    '.claude/skills/pmx-patterns/SKILL.md',
+    '.claude/homunculus/instincts/inherited/pmx-instincts.yaml'
+  );
+
+  output.nextSteps();
+  output.footer();
+}
+
+// Export for use in other scripts
+module.exports = { SkillCreateOutput, demo };
+
+// Run demo if executed directly
+if (require.main === module) {
+  demo().catch(console.error);
+}

package/scripts/status.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+'use strict';
+
+const { createStateStore } = require('./lib/state-store');
+
+function showHelp(exitCode = 0) {
+  console.log(`
+Usage: node scripts/status.js [--db <path>] [--json] [--limit <n>]
+
+Query the ECC SQLite state store for active sessions, recent skill runs,
+install health, and pending governance events.
+`);
+  process.exit(exitCode);
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const parsed = {
+    dbPath: null,
+    json: false,
+    help: false,
+    limit: 5,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--db') {
+      parsed.dbPath = args[index + 1] || null;
+      index += 1;
+    } else if (arg === '--json') {
+      parsed.json = true;
+    } else if (arg === '--limit') {
+      parsed.limit = args[index + 1] || null;
+      index += 1;
+    } else if (arg === '--help' || arg === '-h') {
+      parsed.help = true;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  return parsed;
+}
+
+function printActiveSessions(section) {
+  console.log(`Active sessions: ${section.activeCount}`);
+  if (section.sessions.length === 0) {
+    console.log('  - none');
+    return;
+  }
+
+  for (const session of section.sessions) {
+    console.log(`  - ${session.id} [${session.harness}/${session.adapterId}] ${session.state}`);
+    console.log(`    Repo: ${session.repoRoot || '(unknown)'}`);
+    console.log(`    Started: ${session.startedAt || '(unknown)'}`);
+    console.log(`    Workers: ${session.workerCount}`);
+  }
+}
+
+function printSkillRuns(section) {
+  const summary = section.summary;
+  const successRate = summary.successRate === null ? 'n/a' : `${summary.successRate}%`;
+  const failureRate = summary.failureRate === null ? 'n/a' : `${summary.failureRate}%`;
+
+  console.log(`Skill runs (last ${section.windowSize}):`);
+  console.log(`  Success: ${summary.successCount}`);
+  console.log(`  Failure: ${summary.failureCount}`);
+  console.log(`  Unknown: ${summary.unknownCount}`);
+  console.log(`  Success rate: ${successRate}`);
+  console.log(`  Failure rate: ${failureRate}`);
+
+  if (section.recent.length === 0) {
+    console.log('  Recent runs: none');
+    return;
+  }
+
+  console.log('  Recent runs:');
+  for (const skillRun of section.recent.slice(0, 5)) {
+    console.log(`  - ${skillRun.id} ${skillRun.outcome} ${skillRun.skillId}@${skillRun.skillVersion}`);
+  }
+}
+
+function printInstallHealth(section) {
+  console.log(`Install health: ${section.status}`);
+  console.log(`  Targets recorded: ${section.totalCount}`);
+  console.log(`  Healthy: ${section.healthyCount}`);
+  console.log(`  Warning: ${section.warningCount}`);
+
+  if (section.installations.length === 0) {
+    console.log('  Installations: none');
+    return;
+  }
+
+  console.log('  Installations:');
+  for (const installation of section.installations.slice(0, 5)) {
+    console.log(`  - ${installation.targetId} ${installation.status}`);
+    console.log(`    Root: ${installation.targetRoot}`);
+    console.log(`    Profile: ${installation.profile || '(custom)'}`);
+    console.log(`    Modules: ${installation.moduleCount}`);
+    console.log(`    Source version: ${installation.sourceVersion || '(unknown)'}`);
+  }
+}
+
+function printGovernance(section) {
+  console.log(`Pending governance events: ${section.pendingCount}`);
+  if (section.events.length === 0) {
+    console.log('  - none');
+    return;
+  }
+
+  for (const event of section.events) {
+    console.log(`  - ${event.id} ${event.eventType}`);
+    console.log(`    Session: ${event.sessionId || '(none)'}`);
+    console.log(`    Created: ${event.createdAt}`);
+  }
+}
+
+function printHuman(payload) {
+  console.log('ECC status\n');
+  console.log(`Database: ${payload.dbPath}\n`);
+  printActiveSessions(payload.activeSessions);
+  console.log();
+  printSkillRuns(payload.skillRuns);
+  console.log();
+  printInstallHealth(payload.installHealth);
+  console.log();
+  printGovernance(payload.governance);
+}
+
+async function main() {
+  let store = null;
+
+  try {
+    const options = parseArgs(process.argv);
+    if (options.help) {
+      showHelp(0);
+    }
+
+    store = await createStateStore({
+      dbPath: options.dbPath,
+      homeDir: process.env.HOME,
+    });
+
+    const payload = {
+      dbPath: store.dbPath,
+      ...store.getStatus({
+        activeLimit: options.limit,
+        recentSkillRunLimit: 20,
+        pendingLimit: options.limit,
+      }),
+    };
+
+    if (options.json) {
+      console.log(JSON.stringify(payload, null, 2));
+    } else {
+      printHuman(payload);
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  } finally {
+    if (store) {
+      store.close();
+    }
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  main,
+  parseArgs,
+};