@cloudstreamsoftware/claude-tools 1.0.0 → 1.2.0

package/scripts/generate-weekly-digest.js

@@ -0,0 +1,393 @@
+#!/usr/bin/env node
+/**
+ * Weekly Digest Generator
+ *
+ * Generates human-readable weekly summary of patterns, trends, and recommendations.
+ *
+ * Usage:
+ *   node scripts/generate-weekly-digest.js [--days=7] [--email]
+ *
+ * Options:
+ *   --days    Analysis window in days (default: 7)
+ *   --email   Send digest via email (if configured)
+ */
+
+const path = require('path');
+const fs = require('fs');
+const {
+  getClaudeDir,
+  ensureDir,
+  writeFile,
+  getDateString,
+  getDateTimeString,
+  log,
+} = require('./lib/utils');
+
+const {
+  analyzeAllSessions,
+  detectCrossSessionPatterns,
+  analyzeByTechnology,
+  analyzeTrends,
+  buildSkillCorrectionMatrix,
+  getAggregatedData,
+} = require('./lib/cross-session-patterns');
+
+const { getSessionStartRecommendations } = require('./lib/recommendation-engine');
+
+// Parse command line arguments
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    days: 7,
+    email: false,
+  };
+
+  for (const arg of args) {
+    if (arg.startsWith('--days=')) {
+      options.days = parseInt(arg.split('=')[1], 10) || 7;
+    } else if (arg === '--email') {
+      options.email = true;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Calculate week range string
+ */
+function getWeekRange(days) {
+  const end = new Date();
+  const start = new Date(end.getTime() - days * 24 * 60 * 60 * 1000);
+
+  const formatDate = (d) => {
+    const months = [
+      'Jan',
+      'Feb',
+      'Mar',
+      'Apr',
+      'May',
+      'Jun',
+      'Jul',
+      'Aug',
+      'Sep',
+      'Oct',
+      'Nov',
+      'Dec',
+    ];
+    return `${months[d.getMonth()]} ${d.getDate()}`;
+  };
+
+  return `${formatDate(start)} - ${formatDate(end)}, ${end.getFullYear()}`;
+}
+
+/**
+ * Truncate string for display
+ */
+function truncate(str, length) {
+  if (!str) return '';
+  if (str.length <= length) return str;
+  return str.substring(0, length - 3) + '...';
+}
+
+/**
+ * Get trend emoji
+ */
+function getTrendEmoji(percentChange) {
+  if (percentChange <= -25) return '\u2B07\uFE0F'; // Down arrow
+  if (percentChange >= 25) return '\u2B06\uFE0F'; // Up arrow
+  return '\u27A1\uFE0F'; // Right arrow (stable)
+}
+
+/**
+ * Generate the weekly digest markdown
+ */
+function generateDigest(data, options) {
+  const weekRange = getWeekRange(options.days);
+
+  let md = `# Weekly Knowledge Digest: ${weekRange}\n\n`;
+  md += `*Generated: ${getDateTimeString()}*\n\n`;
+  md += `---\n\n`;
+
+  // Summary Section
+  md += `## Summary\n\n`;
+  md += `| Metric | Value |\n`;
+  md += `|--------|-------|\n`;
+  md += `| Sessions analyzed | ${data.summary.sessionCount} |\n`;
+  md += `| Corrections recorded | ${data.summary.correctionCount} |\n`;
+  md += `| Patterns detected | ${data.patterns.highConfidence.length + data.patterns.emerging.length} |\n`;
+  md += `| Skills applied | ${data.skillApplications || 'N/A'} |\n\n`;
+
+  // Top Patterns This Week
+  if (data.patterns.highConfidence.length > 0 || data.patterns.emerging.length > 0) {
+    md += `## Top Patterns This Week\n\n`;
+    md += `| Pattern | Category | Occurrences | Trend |\n`;
+    md += `|---------|----------|-------------|-------|\n`;
+
+    const allPatterns = [...data.patterns.highConfidence, ...data.patterns.emerging]
+      .sort((a, b) => b.totalOccurrences - a.totalOccurrences)
+      .slice(0, 10);
+
+    for (const p of allPatterns) {
+      const trend = data.trends.improving.find((t) => t.original === p.original)
+        ? '\u2193 improving'
+        : data.trends.worsening.find((t) => t.original === p.original)
+          ? '\u2191 worsening'
+          : '\u2192 stable';
+
+      md += `| ${truncate(p.original, 40)} | ${p.category} | ${p.totalOccurrences} | ${trend} |\n`;
+    }
+    md += '\n';
+  }
+
+  // Improvements Section
+  if (data.trends.improving.length > 0) {
+    md += `## Improvements \u{1F389}\n\n`;
+    md += `Great progress on these patterns:\n\n`;
+
+    for (const t of data.trends.improving.slice(0, 5)) {
+      md += `- **${truncate(t.original, 50)}** down ${Math.abs(t.percentChange)}%`;
+      if (t.linkedSkill) {
+        md += ` (${t.linkedSkill} helping)`;
+      }
+      md += '\n';
+    }
+    md += '\n';
+  }
+
+  // Concerns Section
+  if (data.trends.worsening.length > 0) {
+    md += `## Concerns \u26A0\uFE0F\n\n`;
+    md += `These patterns need attention:\n\n`;
+
+    for (const t of data.trends.worsening.slice(0, 5)) {
+      md += `- **${truncate(t.original, 50)}** up ${t.percentChange}%`;
+
+      // Suggest action
+      if (t.percentChange > 50) {
+        md += ` - consider adding to quality gates`;
+      }
+      md += '\n';
+    }
+    md += '\n';
+  }
+
+  // New Patterns Section
+  if (data.trends.new && data.trends.new.length > 0) {
+    md += `## New Patterns\n\n`;
+    md += `First observed this week:\n\n`;
+
+    for (const t of data.trends.new.slice(0, 5)) {
+      md += `- ${truncate(t.original, 50)} (${t.occurrences} occurrences)\n`;
+    }
+    md += '\n';
+  }
+
+  // Skill Insights Section
+  if (Object.keys(data.skillMatrix).length > 0) {
+    md += `## Skill Insights\n\n`;
+
+    // Find most effective skill
+    let mostEffective = null;
+    let highestEffectiveness = 0;
+
+    // Find most used skill
+    let mostUsed = null;
+    let highestUsage = 0;
+
+    // Find skill needing improvement
+    let needsImprovement = null;
+    let lowestEffectiveness = 1;
+
+    for (const [skill, metrics] of Object.entries(data.skillMatrix)) {
+      if (metrics.effectiveness > highestEffectiveness) {
+        highestEffectiveness = metrics.effectiveness;
+        mostEffective = { name: skill, ...metrics };
+      }
+      if (metrics.applications > highestUsage) {
+        highestUsage = metrics.applications;
+        mostUsed = { name: skill, ...metrics };
+      }
+      if (metrics.effectiveness < lowestEffectiveness && metrics.applications > 2) {
+        lowestEffectiveness = metrics.effectiveness;
+        needsImprovement = { name: skill, ...metrics };
+      }
+    }
+
+    if (mostEffective) {
+      md += `- **Most Effective:** ${mostEffective.name} (${Math.round(mostEffective.effectiveness * 100)}%)\n`;
+    }
+    if (mostUsed) {
+      md += `- **Most Used:** ${mostUsed.name} (${mostUsed.applications} applications)\n`;
+    }
+    if (needsImprovement) {
+      md += `- **Needs Improvement:** ${needsImprovement.name} (${Math.round(needsImprovement.effectiveness * 100)}%)\n`;
+    }
+    md += '\n';
+  }
+
+  // Technology Breakdown
+  if (Object.keys(data.techPatterns).length > 0) {
+    md += `## Technology Breakdown\n\n`;
+    md += `| Technology | Sessions | Correction Rate | Top Issue |\n`;
+    md += `|------------|----------|-----------------|----------|\n`;
+
+    for (const [tech, techData] of Object.entries(data.techPatterns)) {
+      const topIssue = techData.topIssues[0]
+        ? truncate(techData.topIssues[0].original, 30)
+        : 'None';
+
+      md += `| ${tech} | ${techData.sessionCount} | ${techData.correctionRate.toFixed(1)}/session | ${topIssue} |\n`;
+    }
+    md += '\n';
+  }
+
+  // Recommendations Section
+  if (data.recommendations.length > 0) {
+    md += `## Recommendations\n\n`;
+
+    for (let i = 0; i < Math.min(5, data.recommendations.length); i++) {
+      const rec = data.recommendations[i];
+      const emoji =
+        rec.priority === 'high'
+          ? '\u{1F534}'
+          : rec.priority === 'medium'
+            ? '\u{1F7E0}'
+            : '\u{1F7E1}';
+
+      md += `${i + 1}. ${emoji} **${rec.title}**\n`;
+      md += `   ${rec.message}\n`;
+      if (rec.action) {
+        md += `   *Action: \`${rec.action}\`*\n`;
+      }
+      md += '\n';
+    }
+  }
+
+  // Quick Stats
+  md += `## Quick Stats\n\n`;
+  md += `\`\`\`\n`;
+  md += `High-confidence patterns: ${data.patterns.highConfidence.length}\n`;
+  md += `Emerging patterns:        ${data.patterns.emerging.length}\n`;
+  md += `Trends improving:         ${data.trends.improving.length}\n`;
+  md += `Trends worsening:         ${data.trends.worsening.length}\n`;
+  md += `Active recommendations:   ${data.recommendations.length}\n`;
+  md += `\`\`\`\n\n`;
+
+  // Footer
+  md += `---\n\n`;
+  md += `*This digest was automatically generated by the CloudStream knowledge aggregation system.*\n`;
+  md += `*Run \`/aggregate\` to refresh data or \`/recommendations\` for full list.*\n`;
+
+  return md;
+}
+
+/**
+ * Save digest to file
+ */
+function saveDigest(content, options) {
+  const reportsDir = path.join(getClaudeDir(), 'knowledge', 'reports');
+  ensureDir(reportsDir);
+
+  const date = getDateString();
+  const filename = `weekly-digest-${date}.md`;
+  const filepath = path.join(reportsDir, filename);
+
+  writeFile(filepath, content);
+
+  return filepath;
+}
+
+/**
+ * Load aggregated data or run fresh analysis
+ */
+function loadOrAnalyze(options) {
+  // Try to load existing aggregated data
+  const existing = getAggregatedData();
+
+  if (existing && existing.patternLibrary) {
+    log('[Digest] Using existing aggregated data');
+
+    return {
+      summary: existing.summary || { sessionCount: 0, correctionCount: 0 },
+      patterns: existing.patternLibrary || { highConfidence: [], emerging: [] },
+      trends: existing.trendAnalysis || { improving: [], worsening: [], new: [] },
+      skillMatrix: existing.skillCorrectionMatrix || {},
+      techPatterns: existing.contextPatterns?.techPatterns || {},
+      recommendations: existing.recommendations || [],
+      skillApplications: 'N/A',
+    };
+  }
+
+  // Run fresh analysis
+  log('[Digest] Running fresh analysis...');
+
+  const { sessions, corrections, summary } = analyzeAllSessions();
+
+  if (summary.insufficient) {
+    return null;
+  }
+
+  const patterns = detectCrossSessionPatterns(3);
+  const trends = analyzeTrends(options.days);
+  const skillMatrix = buildSkillCorrectionMatrix();
+  const techPatterns = analyzeByTechnology();
+  const recommendations = getSessionStartRecommendations(10);
+
+  return {
+    summary,
+    patterns,
+    trends,
+    skillMatrix,
+    techPatterns,
+    recommendations,
+    skillApplications: 'N/A',
+  };
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const options = parseArgs();
+
+  log(`[Digest] Generating weekly digest (${options.days} day window)...`);
+
+  // Load or analyze data
+  const data = loadOrAnalyze(options);
+
+  if (!data) {
+    log('[Digest] Insufficient data for digest. Need at least 5 sessions.');
+    return;
+  }
+
+  // Generate digest content
+  const content = generateDigest(data, options);
+
+  // Save to file
+  const filepath = saveDigest(content, options);
+  log(`[Digest] Saved to: ${filepath}`);
+
+  // Output to console as well
+  console.log('\n' + '='.repeat(60));
+  console.log(content);
+  console.log('='.repeat(60) + '\n');
+
+  // Email notification (if configured and requested)
+  if (options.email) {
+    log('[Digest] Email notification not yet implemented');
+    // Future: integrate with notification system
+  }
+
+  log('[Digest] Done');
+}
+
+// Run if called directly
+if (require.main === module) {
+  main().catch((err) => {
+    log(`[Digest] Error: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = { generateDigest, saveDigest, loadOrAnalyze };

package/scripts/health-check.js

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+
+/**
+ * Health Check Script for Everything Claude Code
+ * Verifies system configuration and reports status
+ */
+
+const fs = require('fs');
+const path = require('path');
+const {
+  getClaudeDir,
+  getHomeDir,
+  commandExists,
+  runCommand,
+  readFile,
+  log,
+  isWindows,
+} = require('./lib/utils');
+
+// Status indicators
+const OK = '[OK]';
+const WARN = '[WARN]';
+const FAIL = '[FAIL]';
+const SKIP = '[SKIP]';
+
+// Track overall status
+let overallStatus = 'PASS';
+const issues = [];
+
+function setStatus(status) {
+  if (status === 'FAIL') overallStatus = 'FAIL';
+  else if (status === 'WARN' && overallStatus !== 'FAIL') overallStatus = 'WARN';
+}
+
+function check(name, condition, warnOnly = false) {
+  if (condition.success) {
+    return { status: OK, message: condition.message || 'OK' };
+  } else {
+    const status = warnOnly ? WARN : FAIL;
+    setStatus(warnOnly ? 'WARN' : 'FAIL');
+    issues.push(`${name}: ${condition.message}`);
+    return { status, message: condition.message };
+  }
+}
+
+function padRight(str, len) {
+  return str.padEnd(len);
+}
+
+// Environment Checks
+function checkNodeVersion() {
+  const version = process.version;
+  const major = parseInt(version.slice(1).split('.')[0], 10);
+  return {
+    success: major >= 18,
+    message: major >= 18 ? version : `${version} (requires 18+)`,
+  };
+}
+
+function checkPackageManager() {
+  if (commandExists('npm')) {
+    return { success: true, message: 'npm' };
+  } else if (commandExists('yarn')) {
+    return { success: true, message: 'yarn' };
+  } else if (commandExists('pnpm')) {
+    return { success: true, message: 'pnpm' };
+  }
+  return { success: false, message: 'No package manager found' };
+}
+
+function checkGitRepo() {
+  const result = runCommand('git rev-parse --git-dir');
+  if (!result.success) {
+    return { success: true, message: 'Not a git repo (OK)' };
+  }
+  const statusResult = runCommand('git status --porcelain');
+  if (statusResult.success) {
+    const changes = statusResult.output.trim();
+    if (changes === '') {
+      return { success: true, message: 'Clean' };
+    }
+    const lines = changes.split('\n').filter(Boolean);
+    return { success: true, message: `${lines.length} uncommitted changes` };
+  }
+  return { success: true, message: 'OK' };
+}
+
+// Claude State Checks
+function checkClaudeDir() {
+  const claudeDir = getClaudeDir();
+  if (!fs.existsSync(claudeDir)) {
+    return { success: false, message: 'Directory not found' };
+  }
+  try {
+    const testFile = path.join(claudeDir, '.health-check-test');
+    fs.writeFileSync(testFile, 'test');
+    fs.unlinkSync(testFile);
+    return { success: true, message: 'Writable' };
+  } catch {
+    return { success: false, message: 'Not writable' };
+  }
+}
+
+function checkSessionMemory() {
+  const memoryFile = path.join(getClaudeDir(), 'memory', 'session-memory.json');
+  if (!fs.existsSync(memoryFile)) {
+    return { success: true, message: 'Not created yet (OK)' };
+  }
+  try {
+    const content = readFile(memoryFile);
+    JSON.parse(content);
+    return { success: true, message: 'Valid' };
+  } catch {
+    return { success: false, message: 'Invalid JSON' };
+  }
+}
+
+function checkHooks() {
+  const hooksFile = path.join(process.cwd(), 'hooks', 'hooks.json');
+  if (!fs.existsSync(hooksFile)) {
+    return { success: false, message: 'hooks.json not found' };
+  }
+  try {
+    const content = readFile(hooksFile);
+    const hooks = JSON.parse(content);
+    const count = hooks.hooks ? hooks.hooks.length : 0;
+    return { success: true, message: `${count} configured` };
+  } catch {
+    return { success: false, message: 'Invalid JSON' };
+  }
+}
+
+// Plugin State Checks
+function checkDirectory(name, dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    return { success: false, message: 'Not found' };
+  }
+  try {
+    const files = fs.readdirSync(dirPath).filter((f) => f.endsWith('.md'));
+    return { success: true, message: `${files.length} found` };
+  } catch {
+    return { success: false, message: 'Cannot read' };
+  }
+}
+
+// MCP Checks (optional)
+function checkMCPConfig(mcpName) {
+  const claudeDir = getClaudeDir();
+  const settingsFiles = [
+    path.join(claudeDir, 'settings.json'),
+    path.join(claudeDir, 'claude_desktop_config.json'),
+  ];
+
+  for (const settingsFile of settingsFiles) {
+    if (fs.existsSync(settingsFile)) {
+      try {
+        const content = readFile(settingsFile);
+        const settings = JSON.parse(content);
+        if (settings.mcpServers && settings.mcpServers[mcpName]) {
+          return { success: true, message: 'Configured' };
+        }
+      } catch {
+        // Continue checking other files
+      }
+    }
+  }
+  return { success: false, message: 'Not configured' };
+}
+
+function runHealthCheck(options = {}) {
+  const { quick = false, verbose = false } = options;
+
+  log('');
+  log('Running health check...');
+  log('');
+
+  // Environment
+  log('Environment:');
+  const nodeResult = check('Node.js', checkNodeVersion());
+  log(`  ${padRight('Node.js:', 16)} ${nodeResult.status} ${nodeResult.message}`);
+
+  const pkgResult = check('Package Manager', checkPackageManager());
+  log(`  ${padRight('Package Mgr:', 16)} ${pkgResult.status} ${pkgResult.message}`);
+
+  if (!quick) {
+    const gitResult = check('Git Repo', checkGitRepo(), true);
+    log(`  ${padRight('Git Repo:', 16)} ${gitResult.status} ${gitResult.message}`);
+  }
+
+  log('');
+
+  // Claude State
+  log('Claude State:');
+  const claudeDirResult = check('~/.claude/', checkClaudeDir());
+  log(`  ${padRight('~/.claude/:', 16)} ${claudeDirResult.status} ${claudeDirResult.message}`);
+
+  const memoryResult = check('Session Memory', checkSessionMemory(), true);
+  log(`  ${padRight('Session Memory:', 16)} ${memoryResult.status} ${memoryResult.message}`);
+
+  const hooksResult = check('Hooks', checkHooks());
+  log(`  ${padRight('Hooks:', 16)} ${hooksResult.status} ${hooksResult.message}`);
+
+  log('');
+
+  // Plugin State
+  if (!quick) {
+    log('Plugin:');
+    const commandsDir = path.join(process.cwd(), 'commands');
+    const commandsResult = check('Commands', checkDirectory('Commands', commandsDir));
+    log(`  ${padRight('Commands:', 16)} ${commandsResult.status} ${commandsResult.message}`);
+
+    const skillsDir = path.join(process.cwd(), 'skills');
+    const skillsResult = check('Skills', checkDirectory('Skills', skillsDir));
+    log(`  ${padRight('Skills:', 16)} ${skillsResult.status} ${skillsResult.message}`);
+
+    const agentsDir = path.join(process.cwd(), 'agents');
+    const agentsResult = check('Agents', checkDirectory('Agents', agentsDir));
+    log(`  ${padRight('Agents:', 16)} ${agentsResult.status} ${agentsResult.message}`);
+
+    log('');
+  }
+
+  // MCPs (optional - warnings only)
+  if (!quick) {
+    log('MCPs (optional):');
+    const memoryMCP = check('memory MCP', checkMCPConfig('memory'), true);
+    log(`  ${padRight('memory:', 16)} ${memoryMCP.status} ${memoryMCP.message}`);
+
+    const context7MCP = check('context7 MCP', checkMCPConfig('context7'), true);
+    log(`  ${padRight('context7:', 16)} ${context7MCP.status} ${context7MCP.message}`);
+
+    log('');
+  }
+
+  // Summary
+  log('─'.repeat(50));
+  log('');
+
+  if (overallStatus === 'PASS') {
+    log('HEALTH CHECK: PASS');
+    log('');
+    log('All systems operational. Ready to use Everything Claude Code.');
+  } else if (overallStatus === 'WARN') {
+    log('HEALTH CHECK: WARN');
+    log('');
+    log('System is functional but has warnings:');
+    issues.forEach((issue) => log(`  - ${issue}`));
+  } else {
+    log('HEALTH CHECK: FAIL');
+    log('');
+    log('Critical issues found:');
+    issues.forEach((issue) => log(`  - ${issue}`));
+    log('');
+    log('Run /diagnose for detailed troubleshooting.');
+  }
+
+  log('');
+
+  // Exit with appropriate code for CI/CD
+  process.exit(overallStatus === 'FAIL' ? 1 : 0);
+}
+
+// Parse arguments
+const args = process.argv.slice(2);
+const options = {
+  quick: args.includes('--quick'),
+  verbose: args.includes('--verbose'),
+};
+
+runHealthCheck(options);