Learned Patterns

#!/usr/bin/env node
'use strict';

/**
 * Adjust Confidence Script
 * Boost or penalize pattern confidence
 *
 * Usage:
 *   node adjust-confidence.cjs <pattern-id> boost
 *   node adjust-confidence.cjs <pattern-id> penalize
 */

const {
  loadIndex,
  saveIndex,
  findPatternEntry,
  loadPattern,
  savePattern,
  updateConfidence
} = require('../../../hooks/lib/pattern-storage.cjs');

/**
 * Main adjust function
 */
function main() {
  const patternId = process.argv[2];
  const action = process.argv[3];

  if (!patternId || !action || !['boost', 'penalize'].includes(action)) {
    console.log('\n❌ Usage: node adjust-confidence.cjs <pattern-id> <boost|penalize>\n');
    console.log('Examples:');
    console.log('  node adjust-confidence.cjs pat_abc123 boost      # +10% confidence');
    console.log('  node adjust-confidence.cjs pat_abc123 penalize   # -15% confidence\n');
    process.exit(1);
  }

  const index = loadIndex();
  const entry = findPatternEntry(index, patternId);

  if (!entry) {
    console.log(`\n❌ Pattern not found: ${patternId}\n`);
    console.log('Use /learned-patterns list to see available patterns.\n');
    process.exit(1);
  }

  const pattern = loadPattern(entry.file);

  if (!pattern) {
    console.log(`\n❌ Pattern file not found: ${entry.file}\n`);
    process.exit(1);
  }

  const oldConfidence = pattern.metadata?.confidence || 0.5;

  // Apply adjustment
  const event = action === 'boost' ? 'confirm' : 'conflict';
  updateConfidence(pattern, event);

  const newConfidence = pattern.metadata.confidence;

  // Save updated pattern
  savePattern(pattern, entry.file);

  // Update index
  index.patterns[entry.id].confidence = newConfidence;
  saveIndex(index);

  // Display result
  const actionEmoji = action === 'boost' ? '📈' : '📉';
  const actionVerb = action === 'boost' ? 'Boosted' : 'Penalized';
  const change = ((newConfidence - oldConfidence) * 100).toFixed(0);
  const changeSign = change >= 0 ? '+' : '';

  console.log(`\n${actionEmoji} Confidence ${actionVerb}`);
  console.log('─'.repeat(40));
  console.log(`  Pattern:    ${entry.id}`);
  console.log(`  Before:     ${(oldConfidence * 100).toFixed(0)}%`);
  console.log(`  After:      ${(newConfidence * 100).toFixed(0)}%`);
  console.log(`  Change:     ${changeSign}${change}%`);
  console.log();

  // Warnings
  if (newConfidence < 0.3) {
    console.log('⚠️  Warning: Low confidence. Pattern may be auto-archived soon.\n');
  }

  if (newConfidence >= 0.9) {
    console.log('✨ High confidence pattern. Will be prioritized for injection.\n');
  }
}

main();

#!/usr/bin/env node
'use strict';

/**
 * Archive Pattern Script
 * Archive a pattern (soft delete)
 *
 * Usage:
 *   node archive-pattern.cjs <pattern-id> [reason]
 */

const {
  loadIndex,
  findPatternEntry,
  archivePattern
} = require('../../../hooks/lib/pattern-storage.cjs');

/**
 * Main archive function
 */
function main() {
  const patternId = process.argv[2];
  const reason = process.argv.slice(3).join(' ') || 'user_requested';

  if (!patternId) {
    console.log('\n❌ Usage: node archive-pattern.cjs <pattern-id> [reason]\n');
    console.log('Use /learned-patterns list to see available patterns.\n');
    process.exit(1);
  }

  const index = loadIndex();
  const entry = findPatternEntry(index, patternId);

  if (!entry) {
    console.log(`\n❌ Pattern not found: ${patternId}\n`);
    console.log('Use /learned-patterns list to see available patterns.\n');
    process.exit(1);
  }

  // Confirm action
  console.log('\n⚠️  Archive Pattern');
  console.log('─'.repeat(40));
  console.log(`  Pattern ID: ${entry.id}`);
  console.log(`  File:       ${entry.file}`);
  console.log(`  Reason:     ${reason}`);
  console.log();

  // Perform archive
  const result = archivePattern(entry.id, reason);

  if (result.success) {
    console.log(`✅ ${result.message}\n`);
    console.log('Pattern moved to archive/ directory.');
    console.log('It will no longer be injected into sessions.\n');
  } else {
    console.log(`❌ ${result.message}\n`);
    process.exit(1);
  }
}

main();

#!/usr/bin/env node
'use strict';

/**
 * List Patterns Script
 * Lists all active learned patterns with filtering options
 *
 * Usage:
 *   node list-patterns.cjs [category] [--low|--high]
 *
 * Examples:
 *   node list-patterns.cjs              # List all
 *   node list-patterns.cjs backend      # List backend only
 *   node list-patterns.cjs --low        # List low confidence (< 50%)
 *   node list-patterns.cjs --high       # List high confidence (> 70%)
 */

const path = require('path');

// Load pattern storage utilities
const { loadAllPatterns, loadIndex } = require('../../../hooks/lib/pattern-storage.cjs');
const { PATTERN_CATEGORIES } = require('../../../hooks/lib/pattern-constants.cjs');

/**
 * Format confidence as percentage with color indicator
 * @param {number} confidence - Confidence value (0-1)
 * @returns {string} Formatted string
 */
function formatConfidence(confidence) {
  const pct = (confidence * 100).toFixed(0);
  if (confidence >= 0.7) return `${pct}% ●`;  // High
  if (confidence >= 0.5) return `${pct}% ◐`;  // Medium
  if (confidence >= 0.3) return `${pct}% ○`;  // Low
  return `${pct}% ◌`;  // Very low
}

/**
 * Truncate string to max length
 * @param {string} str - Input string
 * @param {number} max - Max length
 * @returns {string} Truncated string
 */
function truncate(str, max) {
  if (!str) return '';
  return str.length > max ? str.slice(0, max - 3) + '...' : str;
}

/**
 * Main list function
 */
function main() {
  const args = process.argv.slice(2);

  // Parse arguments
  let categoryFilter = null;
  let confidenceFilter = null;

  for (const arg of args) {
    if (arg === '--low') {
      confidenceFilter = 'low';
    } else if (arg === '--high') {
      confidenceFilter = 'high';
    } else if (PATTERN_CATEGORIES.includes(arg)) {
      categoryFilter = arg;
    }
  }

  // Load patterns
  const patterns = loadAllPatterns();

  if (patterns.length === 0) {
    console.log('\n📭 No learned patterns found.\n');
    console.log('Use /learn to teach Claude new patterns:');
    console.log('  /learn always use PlatformValidationResult instead of throwing exceptions\n');
    return;
  }

  // Filter patterns
  let filtered = patterns;

  if (categoryFilter) {
    filtered = filtered.filter(p => p.category === categoryFilter);
  }

  if (confidenceFilter === 'low') {
    filtered = filtered.filter(p => (p.metadata?.confidence || 0.5) < 0.5);
  } else if (confidenceFilter === 'high') {
    filtered = filtered.filter(p => (p.metadata?.confidence || 0.5) >= 0.7);
  }

  // Sort by confidence descending
  filtered.sort((a, b) =>
    (b.metadata?.confidence || 0.5) - (a.metadata?.confidence || 0.5)
  );

  // Display header
  console.log('\n📚 Learned Patterns\n');

  if (categoryFilter) {
    console.log(`Category: ${categoryFilter}`);
  }
  if (confidenceFilter) {
    console.log(`Filter: ${confidenceFilter} confidence`);
  }

  console.log(`Total: ${filtered.length} pattern(s)\n`);

  if (filtered.length === 0) {
    console.log('No patterns match the filter criteria.\n');
    return;
  }

  // Display table header
  console.log('┌────────────────────────────────────────────────────────────────────────────────┐');
  console.log('│ ID           │ Category  │ Type         │ Context                  │ Conf    │');
  console.log('├────────────────────────────────────────────────────────────────────────────────┤');

  // Display patterns
  for (const p of filtered) {
    const id = truncate(p.id || 'unknown', 12).padEnd(12);
    const category = truncate(p.category || 'general', 9).padEnd(9);
    const type = truncate(p.type || 'pattern', 12).padEnd(12);
    const context = truncate(p.trigger?.context || p.content?.right || '', 24).padEnd(24);
    const conf = formatConfidence(p.metadata?.confidence || 0.5).padEnd(7);

    console.log(`│ ${id} │ ${category} │ ${type} │ ${context} │ ${conf} │`);
  }

  console.log('└────────────────────────────────────────────────────────────────────────────────┘');

  // Summary by category
  console.log('\n📊 By Category:');
  const byCategory = {};
  for (const p of patterns) {
    const cat = p.category || 'general';
    byCategory[cat] = (byCategory[cat] || 0) + 1;
  }
  for (const [cat, count] of Object.entries(byCategory)) {
    console.log(`  ${cat}: ${count}`);
  }

  console.log('\n💡 Commands:');
  console.log('  /learned-patterns view <id>      View pattern details');
  console.log('  /learned-patterns archive <id>   Archive a pattern');
  console.log('  /learned-patterns boost <id>     Increase confidence\n');
}

main();

#!/usr/bin/env node
'use strict';

/**
 * Pattern Statistics Script
 * Display statistics about the learned patterns library
 *
 * Usage:
 *   node pattern-stats.cjs
 */

const fs = require('fs');
const path = require('path');

const { loadAllPatterns, loadIndex, getPatternsDir } = require('../../../hooks/lib/pattern-storage.cjs');
const { PATTERN_CATEGORIES } = require('../../../hooks/lib/pattern-constants.cjs');

/**
 * Calculate average
 * @param {number[]} values - Array of numbers
 * @returns {number} Average
 */
function average(values) {
  if (values.length === 0) return 0;
  return values.reduce((a, b) => a + b, 0) / values.length;
}

/**
 * Count files in directory recursively
 * @param {string} dir - Directory path
 * @returns {number} File count
 */
function countFiles(dir) {
  if (!fs.existsSync(dir)) return 0;

  let count = 0;
  const entries = fs.readdirSync(dir, { withFileTypes: true });

  for (const entry of entries) {
    if (entry.isFile() && entry.name.endsWith('.yaml')) {
      count++;
    } else if (entry.isDirectory() && entry.name !== 'archive') {
      count += countFiles(path.join(dir, entry.name));
    }
  }

  return count;
}

/**
 * Count archived patterns
 * @returns {number} Archived count
 */
function countArchived() {
  const archiveDir = path.join(getPatternsDir(), 'archive');
  return countFiles(archiveDir);
}

/**
 * Main stats function
 */
function main() {
  const patterns = loadAllPatterns();
  const index = loadIndex();

  console.log('\n' + '═'.repeat(60));
  console.log('📊 Learned Patterns Statistics');
  console.log('═'.repeat(60) + '\n');

  // Overview
  console.log('📌 Overview');
  console.log('─'.repeat(40));
  console.log(`  Total active patterns:  ${patterns.length}`);
  console.log(`  Archived patterns:      ${countArchived()}`);
  console.log(`  Index version:          ${index.version || 1}`);
  console.log(`  Last updated:           ${index.last_updated || 'N/A'}`);
  console.log();

  if (patterns.length === 0) {
    console.log('No patterns to analyze. Use /learn to teach patterns.\n');
    return;
  }

  // By category
  console.log('📂 By Category');
  console.log('─'.repeat(40));

  const byCategory = {};
  for (const cat of PATTERN_CATEGORIES) {
    byCategory[cat] = { count: 0, confidences: [] };
  }

  for (const p of patterns) {
    const cat = p.category || 'general';
    if (!byCategory[cat]) {
      byCategory[cat] = { count: 0, confidences: [] };
    }
    byCategory[cat].count++;
    byCategory[cat].confidences.push(p.metadata?.confidence || 0.5);
  }

  for (const [cat, data] of Object.entries(byCategory)) {
    if (data.count > 0) {
      const avgConf = (average(data.confidences) * 100).toFixed(0);
      console.log(`  ${cat.padEnd(12)} ${String(data.count).padStart(3)} patterns (avg ${avgConf}% conf)`);
    }
  }
  console.log();

  // By type
  console.log('📋 By Type');
  console.log('─'.repeat(40));

  const byType = {};
  for (const p of patterns) {
    const type = p.type || 'pattern';
    byType[type] = (byType[type] || 0) + 1;
  }

  for (const [type, count] of Object.entries(byType).sort((a, b) => b[1] - a[1])) {
    console.log(`  ${type.padEnd(15)} ${count}`);
  }
  console.log();

  // Confidence distribution
  console.log('📈 Confidence Distribution');
  console.log('─'.repeat(40));

  const confBuckets = {
    high: 0,    // >= 70%
    medium: 0,  // 50-69%
    low: 0,     // 30-49%
    veryLow: 0  // < 30%
  };

  const allConfidences = [];

  for (const p of patterns) {
    const conf = p.metadata?.confidence || 0.5;
    allConfidences.push(conf);

    if (conf >= 0.7) confBuckets.high++;
    else if (conf >= 0.5) confBuckets.medium++;
    else if (conf >= 0.3) confBuckets.low++;
    else confBuckets.veryLow++;
  }

  console.log(`  High (≥70%):     ${confBuckets.high} patterns`);
  console.log(`  Medium (50-69%): ${confBuckets.medium} patterns`);
  console.log(`  Low (30-49%):    ${confBuckets.low} patterns`);
  console.log(`  Very Low (<30%): ${confBuckets.veryLow} patterns`);
  console.log();

  const avgConfidence = (average(allConfidences) * 100).toFixed(0);
  console.log(`  Average confidence: ${avgConfidence}%`);
  console.log();

  // Source distribution
  console.log('🔍 By Source');
  console.log('─'.repeat(40));

  const bySource = {};
  for (const p of patterns) {
    const source = p.metadata?.source || 'unknown';
    bySource[source] = (bySource[source] || 0) + 1;
  }

  for (const [source, count] of Object.entries(bySource)) {
    console.log(`  ${source.padEnd(20)} ${count}`);
  }
  console.log();

  // Feedback metrics
  console.log('👍 Feedback Metrics');
  console.log('─'.repeat(40));

  let totalConfirmations = 0;
  let totalConflicts = 0;
  let totalOccurrences = 0;

  for (const p of patterns) {
    totalConfirmations += p.metadata?.confirmations || 0;
    totalConflicts += p.metadata?.conflicts || 0;
    totalOccurrences += p.metadata?.occurrences || 1;
  }

  console.log(`  Total occurrences:   ${totalOccurrences}`);
  console.log(`  Total confirmations: ${totalConfirmations}`);
  console.log(`  Total conflicts:     ${totalConflicts}`);

  if (totalConfirmations + totalConflicts > 0) {
    const confirmRate = ((totalConfirmations / (totalConfirmations + totalConflicts)) * 100).toFixed(0);
    console.log(`  Confirmation rate:   ${confirmRate}%`);
  }
  console.log();

  // Action items
  if (confBuckets.veryLow > 0 || confBuckets.low > 0) {
    console.log('⚠️  Action Items');
    console.log('─'.repeat(40));

    if (confBuckets.veryLow > 0) {
      console.log(`  ${confBuckets.veryLow} pattern(s) with very low confidence - review for archival`);
    }

    if (confBuckets.low > 0) {
      console.log(`  ${confBuckets.low} pattern(s) with low confidence - consider boosting or archiving`);
    }

    console.log('\n  Run: /learned-patterns list --low\n');
  }
}

main();

#!/usr/bin/env node
'use strict';

/**
 * View Pattern Script
 * Display detailed information about a specific pattern
 *
 * Usage:
 *   node view-pattern.cjs <pattern-id>
 */

const path = require('path');

const {
  loadIndex,
  loadPattern,
  findPatternEntry
} = require('../../../hooks/lib/pattern-storage.cjs');

/**
 * Format date for display
 * @param {string} dateStr - ISO date string
 * @returns {string} Formatted date
 */
function formatDate(dateStr) {
  if (!dateStr) return 'N/A';
  try {
    const date = new Date(dateStr);
    return date.toLocaleDateString('en-US', {
      year: 'numeric',
      month: 'short',
      day: 'numeric'
    });
  } catch {
    return dateStr;
  }
}

/**
 * Main view function
 */
function main() {
  const patternId = process.argv[2];

  if (!patternId) {
    console.log('\n❌ Usage: node view-pattern.cjs <pattern-id>\n');
    console.log('Use /learned-patterns list to see available patterns.\n');
    process.exit(1);
  }

  const index = loadIndex();
  const entry = findPatternEntry(index, patternId);

  if (!entry) {
    console.log(`\n❌ Pattern not found: ${patternId}\n`);
    console.log('Use /learned-patterns list to see available patterns.\n');
    process.exit(1);
  }

  const pattern = loadPattern(entry.file);

  if (!pattern) {
    console.log(`\n❌ Pattern file not found: ${entry.file}\n`);
    process.exit(1);
  }

  // Display pattern details
  console.log('\n' + '═'.repeat(80));
  console.log(`📋 Pattern: ${entry.id}`);
  console.log('═'.repeat(80) + '\n');

  // Basic info
  console.log('📌 Basic Information');
  console.log('─'.repeat(40));
  console.log(`  Category:    ${pattern.category || 'general'}`);
  console.log(`  Type:        ${pattern.type || 'pattern'}`);
  console.log(`  Source:      ${pattern.metadata?.source || 'unknown'}`);
  console.log(`  File:        ${entry.file}`);
  console.log();

  // Content
  console.log('📝 Content');
  console.log('─'.repeat(40));

  if (pattern.content?.wrong) {
    console.log('  ❌ AVOID:');
    console.log(`     ${pattern.content.wrong}`);
  }

  if (pattern.content?.right) {
    console.log('  ✅ USE:');
    console.log(`     ${pattern.content.right}`);
  }

  if (pattern.content?.rationale && typeof pattern.content.rationale === 'string' && pattern.content.rationale.trim()) {
    console.log('  💡 Rationale:');
    console.log(`     ${pattern.content.rationale}`);
  }
  console.log();

  // Trigger info
  console.log('🎯 Trigger');
  console.log('─'.repeat(40));

  if (pattern.trigger?.context) {
    console.log(`  Context:     ${pattern.trigger.context}`);
  }

  if (pattern.trigger?.keywords?.length > 0) {
    console.log(`  Keywords:    ${pattern.trigger.keywords.join(', ')}`);
  }

  if (pattern.trigger?.file_patterns?.length > 0) {
    console.log(`  Files:       ${pattern.trigger.file_patterns.join(', ')}`);
  }
  console.log();

  // Metadata
  console.log('📊 Metrics');
  console.log('─'.repeat(40));

  const confidence = pattern.metadata?.confidence || 0.5;
  const confPct = (confidence * 100).toFixed(0);
  let confLevel = 'Medium';
  if (confidence >= 0.7) confLevel = 'High';
  else if (confidence < 0.5) confLevel = 'Low';
  else if (confidence < 0.3) confLevel = 'Very Low';

  console.log(`  Confidence:  ${confPct}% (${confLevel})`);
  console.log(`  First seen:  ${formatDate(pattern.metadata?.first_seen)}`);
  console.log(`  Last used:   ${formatDate(pattern.metadata?.last_confirmed)}`);
  console.log(`  Occurrences: ${pattern.metadata?.occurrences || 1}`);
  console.log(`  Confirms:    ${pattern.metadata?.confirmations || 0}`);
  console.log(`  Conflicts:   ${pattern.metadata?.conflicts || 0}`);
  console.log();

  // Tags
  if (pattern.tags?.length > 0) {
    console.log('🏷️  Tags');
    console.log('─'.repeat(40));
    console.log(`  ${pattern.tags.join(', ')}`);
    console.log();
  }

  // Related files
  if (pattern.metadata?.related_files?.length > 0) {
    console.log('📁 Related Files');
    console.log('─'.repeat(40));
    for (const file of pattern.metadata.related_files.slice(0, 5)) {
      console.log(`  ${file}`);
    }
    if (pattern.metadata.related_files.length > 5) {
      console.log(`  ... and ${pattern.metadata.related_files.length - 5} more`);
    }
    console.log();
  }

  // Actions
  console.log('⚡ Actions');
  console.log('─'.repeat(40));
  console.log(`  /learned-patterns boost ${entry.id}      Increase confidence`);
  console.log(`  /learned-patterns penalize ${entry.id}   Decrease confidence`);
  console.log(`  /learned-patterns archive ${entry.id}    Archive pattern`);
  console.log();
}

main();