Release Notes

# Release Notes Configuration
# Defines how commits are categorized and formatted for release notes

version: '1.0'

# Commit type mappings for release notes sections
categories:
    features:
        types: [feat]
        heading: "What's New"
        description: 'New features and capabilities'
        user_facing: true
        icon: '✨'

    fixes:
        types: [fix]
        heading: 'Bug Fixes'
        description: 'Bug fixes and corrections'
        user_facing: true
        icon: '🐛'

    improvements:
        types: [perf, refactor]
        heading: 'Improvements'
        description: 'Performance and code improvements'
        user_facing: true # perf is user-facing, refactor goes to technical
        icon: '⚡'

    docs:
        types: [docs]
        heading: 'Documentation'
        description: 'Documentation updates'
        user_facing: true # Only if scope is not 'internal'
        icon: '📚'

    internal:
        types: [test, ci, build, chore, style]
        heading: 'Internal Changes'
        description: 'Internal maintenance and CI/CD'
        user_facing: false
        icon: '🔧'

# Breaking change detection
breaking:
    indicators:
        - pattern: '^.*!:'
          description: 'Type with ! suffix'
        - pattern: 'BREAKING CHANGE:'
          location: 'body'
          description: 'BREAKING CHANGE in commit body'
        - pattern: 'BREAKING-CHANGE:'
          location: 'footer'
          description: 'BREAKING-CHANGE footer'

# Service boundary detection based on file paths
services:
    backend-api:
        patterns:
            - 'src/Backend/**/*.Api/**'
        label: 'Backend API'
        impact: 'high'

    backend-domain:
        patterns:
            - 'src/Backend/**/*.Domain/**'
        label: 'Domain Model'
        impact: 'high'

    backend-application:
        patterns:
            - 'src/Backend/**/*.Application/**'
        label: 'Application Layer'
        impact: 'medium'

    backend-persistence:
        patterns:
            - 'src/Backend/**/*.Persistence*/**'
        label: 'Persistence'
        impact: 'medium'

    platform-core:
        patterns:
            - 'src/Platform/**'
        label: 'Platform Core'
        impact: 'critical'

    frontend-apps:
        patterns:
            - 'src/Frontend/apps/**'
        label: 'Frontend Apps'
        impact: 'high'

    frontend-libs:
        patterns:
            - 'src/Frontend/libs/**'
        label: 'Frontend Libraries'
        impact: 'medium'

    ai-tools:
        patterns:
            - '.claude/**'
            - '.github/prompts/**'
        label: 'AI Tooling'
        impact: 'low'

    config:
        patterns:
            - '.github/workflows/**'
            - '*.json'
            - '*.yml'
            - '*.yaml'
        label: 'Configuration'
        impact: 'low'

    docs:
        patterns:
            - 'docs/**'
            - '*.md'
        label: 'Documentation'
        impact: 'low'

# Commits to exclude from user-facing notes
exclude:
    types:
        - ci
        - test
        - style
    scopes:
        - deps
        - internal
    patterns:
        - "^chore\\(deps\\):"
        - "^chore\\(config\\):"
        - "\\[skip changelog\\]"
        - "\\[ci skip\\]"

# Output configuration
output:
    directory: 'docs/release-notes'
    filename_format: 'YYMMDD-{version}.md'
    changelog_root: 'CHANGELOG.md'
    per_service_changelog: true

# Template sections
template:
    sections:
        - name: 'summary'
          required: true
        - name: 'features'
          conditional: 'has_features'
        - name: 'improvements'
          conditional: 'has_improvements'
        - name: 'fixes'
          conditional: 'has_fixes'
        - name: 'breaking'
          conditional: 'has_breaking'
        - name: 'technical'
          collapsible: true
        - name: 'contributors'
          required: true

# Version detection
versioning:
    strategy: 'per-service' # or "unified"
    tag_pattern: 'v*.*.*'
    prerelease_patterns:
        - 'alpha'
        - 'beta'
        - 'rc'
    version_file: '.version' # Root version file
    per_service_dir: '.versions' # Per-service version directory
    bump_on_release: true

# Validation settings
validation:
    enabled: true
    min_score: 70 # Default threshold (configurable via --threshold)
    rules:
        summary_exists: { weight: 15 }
        summary_not_empty: { weight: 10 }
        has_version: { weight: 10 }
        has_date: { weight: 5 }
        features_documented: { weight: 10 }
        fixes_documented: { weight: 10 }
        no_broken_links: { weight: 10 }
        no_todo_markers: { weight: 5 }
        contributors_listed: { weight: 10 }
        proper_heading_hierarchy: { weight: 5 }
        no_placeholder_text: { weight: 5 }
        technical_details_collapsed: { weight: 5 }

# LLM transform settings
llm_transforms:
    enabled: true
    model: 'sonnet'
    cache_ttl_hours: 24
    transform_types:
        - summarize
        - business
        - enduser
        - executive
        - technical

#!/usr/bin/env node
/**
 * Bump semantic version based on commit types
 * Usage: node bump-version.cjs [--service name] [--prerelease tag] [--dry-run]
 *
 * Reads commits from stdin or analyzes git history to determine version bump
 * Supports both per-service and root-level versioning
 */

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

const DEFAULT_VERSION = '0.0.0';
const VERSION_FILE = '.version';

/**
 * Parse semantic version string
 */
function parseVersion(versionStr) {
  const match = versionStr.replace(/^v/, '').match(/^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z]+)\.?(\d+)?)?$/);
  if (!match) {
    return { major: 0, minor: 0, patch: 0, prerelease: null, prereleaseNum: 0 };
  }
  return {
    major: parseInt(match[1], 10),
    minor: parseInt(match[2], 10),
    patch: parseInt(match[3], 10),
    prerelease: match[4] || null,
    prereleaseNum: parseInt(match[5], 10) || 0,
  };
}

/**
 * Format version object to string
 */
function formatVersion(v, includeV = true) {
  let version = `${v.major}.${v.minor}.${v.patch}`;
  if (v.prerelease) {
    version += `-${v.prerelease}`;
    if (v.prereleaseNum > 0) {
      version += `.${v.prereleaseNum}`;
    }
  }
  return includeV ? `v${version}` : version;
}

/**
 * Determine bump type from commits
 */
function determineBumpType(commits) {
  let hasBreaking = false;
  let hasFeature = false;
  let hasFix = false;

  for (const commit of commits) {
    if (commit.breaking) {
      hasBreaking = true;
    }
    if (commit.type === 'feat') {
      hasFeature = true;
    }
    if (commit.type === 'fix' || commit.type === 'perf') {
      hasFix = true;
    }
  }

  if (hasBreaking) return 'major';
  if (hasFeature) return 'minor';
  if (hasFix) return 'patch';
  return 'patch'; // Default to patch for other changes
}

/**
 * Bump version based on type
 */
function bumpVersion(current, bumpType, prerelease = null) {
  const v = { ...current };

  // If adding prerelease to existing version
  if (prerelease && !v.prerelease) {
    v.prerelease = prerelease;
    v.prereleaseNum = 1;
    // Bump the appropriate version first
    if (bumpType === 'major') {
      v.major++;
      v.minor = 0;
      v.patch = 0;
    } else if (bumpType === 'minor') {
      v.minor++;
      v.patch = 0;
    } else {
      v.patch++;
    }
    return v;
  }

  // If already in prerelease, bump prerelease number
  if (v.prerelease && prerelease === v.prerelease) {
    v.prereleaseNum++;
    return v;
  }

  // If releasing from prerelease, remove prerelease
  if (v.prerelease && !prerelease) {
    v.prerelease = null;
    v.prereleaseNum = 0;
    return v;
  }

  // Normal version bump
  v.prerelease = prerelease;
  v.prereleaseNum = prerelease ? 1 : 0;

  if (bumpType === 'major') {
    v.major++;
    v.minor = 0;
    v.patch = 0;
  } else if (bumpType === 'minor') {
    v.minor++;
    v.patch = 0;
  } else {
    v.patch++;
  }

  return v;
}

/**
 * Get version file path for service or root
 */
function getVersionFilePath(service = null) {
  if (service) {
    // Per-service version file
    const servicePath = path.join(process.cwd(), '.versions', `${service}.version`);
    return servicePath;
  }
  // Root version file
  return path.join(process.cwd(), VERSION_FILE);
}

/**
 * Read current version from file
 */
function readVersion(service = null) {
  const filePath = getVersionFilePath(service);

  try {
    if (fs.existsSync(filePath)) {
      const content = fs.readFileSync(filePath, 'utf-8').trim();
      return parseVersion(content);
    }
  } catch (error) {
    console.error(`Warning: Could not read version file: ${error.message}`);
  }

  // Try to get latest git tag as fallback
  try {
    const tagPattern = service ? `${service}-v*` : 'v*';
    const latestTag = execSync(`git describe --tags --match "${tagPattern}" --abbrev=0 2>/dev/null || echo ""`, {
      encoding: 'utf-8',
    }).trim();

    if (latestTag) {
      const versionPart = service ? latestTag.replace(`${service}-`, '') : latestTag;
      return parseVersion(versionPart);
    }
  } catch {
    // Ignore git errors
  }

  return parseVersion(DEFAULT_VERSION);
}

/**
 * Write version to file
 */
function writeVersion(version, service = null) {
  const filePath = getVersionFilePath(service);
  const dir = path.dirname(filePath);

  // Ensure directory exists
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir, { recursive: true });
  }

  const versionStr = formatVersion(version, false);
  fs.writeFileSync(filePath, versionStr + '\n');

  return filePath;
}

/**
 * Parse command line arguments
 */
function parseArgs(args) {
  const options = {
    service: null,
    prerelease: null,
    bumpType: null,
    dryRun: false,
    inputFile: null,
  };

  for (let i = 0; i < args.length; i++) {
    if (args[i] === '--service' && args[i + 1]) {
      options.service = args[++i];
    } else if (args[i] === '--prerelease' && args[i + 1]) {
      options.prerelease = args[++i];
    } else if (args[i] === '--bump' && args[i + 1]) {
      options.bumpType = args[++i];
    } else if (args[i] === '--dry-run') {
      options.dryRun = true;
    } else if (!args[i].startsWith('--') && fs.existsSync(args[i])) {
      options.inputFile = args[i];
    }
  }

  return options;
}

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

  let commits = [];
  let inputData = null;

  // Read commits from stdin or file
  if (!process.stdin.isTTY) {
    const input = fs.readFileSync(0, 'utf-8');
    try {
      inputData = JSON.parse(input);
      if (inputData.commits && !Array.isArray(inputData.commits)) {
        console.error('Error: "commits" must be an array');
        process.exit(1);
      }
      commits = inputData.commits || [];
    } catch (error) {
      console.error(`Warning: Could not parse JSON input (${error.message}), using bump type only`);
    }
  } else if (options.inputFile) {
    const input = fs.readFileSync(options.inputFile, 'utf-8');
    try {
      inputData = JSON.parse(input);
      if (inputData.commits && !Array.isArray(inputData.commits)) {
        console.error('Error: "commits" must be an array');
        process.exit(1);
      }
      commits = inputData.commits || [];
    } catch (error) {
      console.error(`Warning: Could not parse JSON input (${error.message}), using bump type only`);
    }
  }

  // Get current version
  const currentVersion = readVersion(options.service);
  const currentStr = formatVersion(currentVersion);

  // Determine bump type
  const bumpType = options.bumpType || determineBumpType(commits);

  // Calculate new version
  const newVersion = bumpVersion(currentVersion, bumpType, options.prerelease);
  const newStr = formatVersion(newVersion);

  // Output result
  const result = {
    current: currentStr,
    new: newStr,
    bumpType,
    service: options.service,
    prerelease: options.prerelease,
    commits: commits.length,
    dryRun: options.dryRun,
  };

  // Write version file (unless dry run)
  if (!options.dryRun) {
    const filePath = writeVersion(newVersion, options.service);
    result.versionFile = filePath;
    console.error(`Version bumped: ${currentStr} → ${newStr}`);
    console.error(`Version file: ${filePath}`);
  } else {
    console.error(`[DRY RUN] Would bump: ${currentStr} → ${newStr}`);
  }

  // If we have input data, pass it through with version info added
  if (inputData) {
    inputData.version = {
      current: currentStr,
      new: newStr,
      bumpType,
      service: options.service,
    };
    console.log(JSON.stringify(inputData, null, 2));
  } else {
    console.log(JSON.stringify(result, null, 2));
  }
}

// Run if executed directly
if (require.main === module) {
  main();
}

module.exports = {
  parseVersion,
  formatVersion,
  determineBumpType,
  bumpVersion,
  readVersion,
  writeVersion,
};

#!/usr/bin/env node
/**
 * Categorize commits for release notes
 * Usage: node categorize-commits.cjs < commits.json
 *
 * Reads parsed commits from stdin and categorizes them into release note sections
 */

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

// Category mappings (fallback if config not available)
const DEFAULT_CATEGORIES = {
  features: {
    types: ['feat'],
    heading: "What's New",
    userFacing: true,
  },
  fixes: {
    types: ['fix'],
    heading: 'Bug Fixes',
    userFacing: true,
  },
  improvements: {
    types: ['perf'],
    heading: 'Improvements',
    userFacing: true,
  },
  docs: {
    types: ['docs'],
    heading: 'Documentation',
    userFacing: true,
  },
  refactoring: {
    types: ['refactor'],
    heading: 'Refactoring',
    userFacing: false,
  },
  internal: {
    types: ['test', 'ci', 'build', 'chore', 'style'],
    heading: 'Internal Changes',
    userFacing: false,
  },
};

// Types/scopes to exclude from user-facing notes
const EXCLUDE_PATTERNS = [
  /^chore\(deps\)/,
  /^chore\(config\)/,
  /^ci:/,
  /^test:/,
  /^style:/,
  /\[skip changelog\]/i,
  /\[ci skip\]/i,
];

/**
 * Check if a commit should be excluded from user-facing notes
 */
function shouldExclude(commit) {
  const subject = commit.subject || '';
  return EXCLUDE_PATTERNS.some(pattern => pattern.test(subject));
}

/**
 * Transform commit to user-friendly format
 */
function transformForUser(commit) {
  // Create user-friendly description
  let userDescription = commit.description;

  // Capitalize first letter
  userDescription = userDescription.charAt(0).toUpperCase() + userDescription.slice(1);

  // Add scope context if present
  const scopeLabel = commit.scope ? ` (${formatScope(commit.scope)})` : '';

  return {
    hash: commit.shortHash,
    description: userDescription,
    scope: commit.scope,
    scopeLabel,
    author: commit.author,
    date: commit.date,
    breaking: commit.breaking,
    original: commit,
  };
}

/**
 * Format scope for display
 */
function formatScope(scope) {
  const scopeLabels = {
    api: 'API',
    ui: 'UI',
    auth: 'Auth',
    deps: 'Dependencies',
    'ai-tools': 'AI Tools',
    frontend: 'Frontend',
    backend: 'Backend',
  };

  return scopeLabels[scope] || scope.charAt(0).toUpperCase() + scope.slice(1);
}

/**
 * Categorize commits into sections
 */
function categorizeCommits(commits, categories = DEFAULT_CATEGORIES) {
  const result = {
    features: [],
    fixes: [],
    improvements: [],
    docs: [],
    breaking: [],
    internal: [],
    other: [],
  };

  commits.forEach(commit => {
    // Always track breaking changes separately
    if (commit.breaking) {
      result.breaking.push(transformForUser(commit));
    }

    // Skip excluded commits for user-facing sections
    const excluded = shouldExclude(commit);

    // Categorize by type
    let categorized = false;
    for (const [category, config] of Object.entries(categories)) {
      if (config.types.includes(commit.type)) {
        if (excluded || !config.userFacing) {
          result.internal.push(transformForUser(commit));
        } else {
          result[category] = result[category] || [];
          result[category].push(transformForUser(commit));
        }
        categorized = true;
        break;
      }
    }

    // Handle uncategorized (non-conventional) commits
    if (!categorized) {
      result.other.push(transformForUser(commit));
    }
  });

  return result;
}

/**
 * Generate summary statistics
 */
function generateSummary(categorized, stats) {
  const userFacingCount =
    categorized.features.length +
    categorized.fixes.length +
    categorized.improvements.length;

  const sentences = [];

  if (categorized.features.length > 0) {
    sentences.push(`${categorized.features.length} new feature${categorized.features.length > 1 ? 's' : ''}`);
  }

  if (categorized.improvements.length > 0) {
    sentences.push(`${categorized.improvements.length} improvement${categorized.improvements.length > 1 ? 's' : ''}`);
  }

  if (categorized.fixes.length > 0) {
    sentences.push(`${categorized.fixes.length} bug fix${categorized.fixes.length > 1 ? 'es' : ''}`);
  }

  if (categorized.breaking.length > 0) {
    sentences.push(`${categorized.breaking.length} breaking change${categorized.breaking.length > 1 ? 's' : ''}`);
  }

  const summary = sentences.length > 0
    ? `This release includes ${sentences.join(', ')}.`
    : 'This release includes various internal improvements and maintenance updates.';

  return {
    text: summary,
    userFacingCount,
    totalCommits: stats.total,
    breakingCount: categorized.breaking.length,
    hasFeatures: categorized.features.length > 0,
    hasFixes: categorized.fixes.length > 0,
    hasImprovements: categorized.improvements.length > 0,
    hasBreaking: categorized.breaking.length > 0,
  };
}

/**
 * Main function
 */
function main() {
  let input = '';

  // Read from stdin
  if (!process.stdin.isTTY) {
    input = fs.readFileSync(0, 'utf-8');
  } else {
    // Read from file argument
    const args = process.argv.slice(2);
    if (args.length > 0 && fs.existsSync(args[0])) {
      input = fs.readFileSync(args[0], 'utf-8');
    } else {
      console.error('Usage: node categorize-commits.cjs < commits.json');
      console.error('       node categorize-commits.cjs commits.json');
      process.exit(1);
    }
  }

  let data;
  try {
    data = JSON.parse(input);
  } catch (error) {
    console.error(`Error parsing JSON input: ${error.message}`);
    console.error('Ensure upstream script outputs valid JSON');
    process.exit(1);
  }

  if (!data.commits || !Array.isArray(data.commits)) {
    console.error('Error: Missing or invalid "commits" array in input');
    process.exit(1);
  }
  const commits = data.commits || [];
  const stats = data.stats || { total: commits.length };

  const categorized = categorizeCommits(commits);
  const summary = generateSummary(categorized, stats);

  const result = {
    base: data.base,
    head: data.head,
    summary,
    categories: categorized,
    contributors: stats.authors || [],
    dateRange: stats.dateRange || {},
  };

  console.log(JSON.stringify(result, null, 2));
}

// Run if executed directly
if (require.main === module) {
  main();
}

module.exports = { categorizeCommits, transformForUser, shouldExclude };

#!/usr/bin/env node
/**
 * Generate contributor statistics from commits
 * Usage: node contributor-stats.cjs < commits.json
 *
 * Analyzes commits to generate contributor statistics and formatting
 */

const fs = require('fs');
const { validateInputNotEmpty } = require('./utils.cjs');

// Map author names to GitHub usernames (optional mapping)
const AUTHOR_GITHUB_MAP = {
  // Add mappings like:
  // 'John Doe': 'johndoe',
  // 'DOMAIN\\user': 'github-user',
};

/**
 * Normalize author name for GitHub mention
 */
function normalizeAuthorName(author) {
  // Check manual mapping first
  if (AUTHOR_GITHUB_MAP[author]) {
    return AUTHOR_GITHUB_MAP[author];
  }

  // Remove domain prefix (DOMAIN\user -> user)
  let normalized = author.replace(/^.*\\/, '');

  // Remove common suffixes
  normalized = normalized.replace(/\s*\(.*\)$/, '');

  // Convert to GitHub-friendly format (lowercase, no spaces)
  normalized = normalized.toLowerCase().replace(/\s+/g, '-');

  return normalized;
}

/**
 * Analyze contributor statistics
 */
function analyzeContributors(commits) {
  const contributorMap = new Map();

  commits.forEach(commit => {
    const author = commit.author;
    if (!author) return;

    if (!contributorMap.has(author)) {
      contributorMap.set(author, {
        name: author,
        githubUsername: normalizeAuthorName(author),
        email: commit.email,
        commits: 0,
        features: 0,
        fixes: 0,
        improvements: 0,
        docs: 0,
        other: 0,
        firstCommit: commit.date,
        lastCommit: commit.date,
      });
    }

    const stats = contributorMap.get(author);
    stats.commits++;

    // Track by type
    switch (commit.type) {
      case 'feat':
        stats.features++;
        break;
      case 'fix':
        stats.fixes++;
        break;
      case 'perf':
      case 'refactor':
        stats.improvements++;
        break;
      case 'docs':
        stats.docs++;
        break;
      default:
        stats.other++;
    }

    // Update date range
    if (commit.date < stats.firstCommit) stats.firstCommit = commit.date;
    if (commit.date > stats.lastCommit) stats.lastCommit = commit.date;
  });

  // Convert to array and sort by commit count
  return Array.from(contributorMap.values()).sort((a, b) => b.commits - a.commits);
}

/**
 * Format contributors for release notes
 */
function formatContributors(contributors, options = {}) {
  const { showStats = false, maxContributors = 20 } = options;

  const limited = contributors.slice(0, maxContributors);

  if (showStats) {
    return limited.map(c => ({
      mention: `@${c.githubUsername}`,
      name: c.name,
      commits: c.commits,
      highlights: getContributorHighlights(c),
    }));
  }

  return limited.map(c => `@${c.githubUsername}`);
}

/**
 * Get contributor highlights (main contribution types)
 */
function getContributorHighlights(contributor) {
  const highlights = [];

  if (contributor.features > 0) {
    highlights.push(`${contributor.features} feature${contributor.features > 1 ? 's' : ''}`);
  }
  if (contributor.fixes > 0) {
    highlights.push(`${contributor.fixes} fix${contributor.fixes > 1 ? 'es' : ''}`);
  }
  if (contributor.improvements > 0) {
    highlights.push(`${contributor.improvements} improvement${contributor.improvements > 1 ? 's' : ''}`);
  }

  return highlights.join(', ');
}

/**
 * Generate contributor summary
 */
function generateContributorSummary(contributors) {
  const total = contributors.length;

  if (total === 0) {
    return {
      total: 0,
      text: 'No contributors found.',
    };
  }

  const totalCommits = contributors.reduce((sum, c) => sum + c.commits, 0);
  const topContributor = contributors[0];

  let text = `${total} contributor${total > 1 ? 's' : ''} with ${totalCommits} commit${totalCommits > 1 ? 's' : ''}.`;

  if (total > 1) {
    text += ` Top contributor: ${topContributor.name} (${topContributor.commits} commits)`;
  }

  return {
    total,
    totalCommits,
    topContributor: topContributor.name,
    text,
  };
}

/**
 * Process contributor data for release notes
 */
function processContributors(data) {
  const commits = data.commits || [];
  const contributors = analyzeContributors(commits);
  const formatted = formatContributors(contributors);
  const summary = generateContributorSummary(contributors);

  return {
    ...data,
    contributorStats: {
      summary,
      contributors: contributors.map(c => ({
        name: c.name,
        githubUsername: c.githubUsername,
        commits: c.commits,
        features: c.features,
        fixes: c.fixes,
        improvements: c.improvements,
        dateRange: {
          first: c.firstCommit,
          last: c.lastCommit,
        },
      })),
      formatted,
      markdown: formatted.map(c => `- ${c}`).join('\n'),
    },
  };
}

/**
 * Main function
 */
function main() {
  let input = '';

  // Read from stdin or file
  if (!process.stdin.isTTY) {
    input = fs.readFileSync(0, 'utf-8');
  } else {
    const args = process.argv.slice(2);
    if (args.length > 0 && fs.existsSync(args[0])) {
      input = fs.readFileSync(args[0], 'utf-8');
    } else {
      console.error('Usage: node contributor-stats.cjs < commits.json');
      console.error('       node contributor-stats.cjs commits.json');
      process.exit(1);
    }
  }

  // Validate input not empty
  validateInputNotEmpty(input, 'contributor-stats');

  let data;
  try {
    data = JSON.parse(input);
  } catch (error) {
    console.error(`Error parsing JSON input: ${error.message}`);
    console.error('Ensure upstream script outputs valid JSON');
    process.exit(1);
  }

  if (!data.commits || !Array.isArray(data.commits)) {
    console.error('Error: Missing or invalid "commits" array in input');
    process.exit(1);
  }
  const result = processContributors(data);

  console.log(JSON.stringify(result, null, 2));
}

// Run if executed directly
if (require.main === module) {
  main();
}

module.exports = {
  normalizeAuthorName,
  analyzeContributors,
  formatContributors,
  processContributors,
};

#!/usr/bin/env node
/**
 * Detect breaking changes from commits
 * Usage: node detect-breaking.cjs < categorized.json
 *
 * Enhances breaking change detection with migration info extraction
 */

const fs = require('fs');

// Breaking change patterns in commit body/footer
const BREAKING_PATTERNS = [
  /BREAKING[ -]CHANGE:\s*(.+?)(?=\n\n|\n[A-Z]|$)/is,
  /BREAKING:\s*(.+?)(?=\n\n|\n[A-Z]|$)/is,
];

// Migration keywords to extract
const MIGRATION_KEYWORDS = [
  'migration guide',
  'migration:',
  'migrate:',
  'migration steps',
  'to migrate',
  'upgrade guide',
  'upgrade:',
];

/**
 * Extract breaking change details from commit body
 */
function extractBreakingDetails(body) {
  if (!body) return null;

  for (const pattern of BREAKING_PATTERNS) {
    const match = body.match(pattern);
    if (match) {
      return {
        description: match[1].trim(),
        raw: match[0],
      };
    }
  }

  return null;
}

/**
 * Extract migration info from commit body
 */
function extractMigrationInfo(body) {
  if (!body) return null;

  const lines = body.split('\n');
  const migrationLines = [];
  let capturing = false;

  for (const line of lines) {
    const lowerLine = line.toLowerCase();

    // Start capturing on migration keyword
    if (MIGRATION_KEYWORDS.some(k => lowerLine.includes(k))) {
      capturing = true;
      migrationLines.push(line);
      continue;
    }

    // Continue capturing indented/list lines
    if (capturing) {
      if (line.match(/^[\s\-\*\d\.]/)) {
        migrationLines.push(line);
      } else if (line.trim() === '') {
        migrationLines.push('');
      } else {
        // Stop capturing on non-indented, non-empty line
        break;
      }
    }
  }

  return migrationLines.length > 0 ? migrationLines.join('\n').trim() : null;
}

/**
 * Analyze impact severity of breaking change
 */
function analyzeBreakingImpact(commit, services) {
  // Check if affects critical services
  const affectedServices = services?.affected || [];
  const hasCriticalImpact = affectedServices.some(s => s.impact === 'critical');
  const hasHighImpact = affectedServices.some(s => s.impact === 'high');

  // Check scope for impact hints
  const criticalScopes = ['api', 'domain', 'auth', 'platform'];
  const isCriticalScope = criticalScopes.includes(commit.scope?.toLowerCase());

  // Determine severity
  if (hasCriticalImpact || isCriticalScope) {
    return 'critical';
  } else if (hasHighImpact) {
    return 'high';
  }

  return 'medium';
}

/**
 * Process breaking changes with enhanced details
 */
function processBreakingChanges(data) {
  const { categories, services } = data;
  const breakingCommits = categories?.breaking || [];

  const enhanced = breakingCommits.map(commit => {
    const body = commit.original?.body || '';

    // Extract details from body
    const breakingDetails = extractBreakingDetails(body);
    const migrationInfo = extractMigrationInfo(body);
    const severity = analyzeBreakingImpact(commit, services);

    return {
      ...commit,
      breaking: {
        severity,
        description: breakingDetails?.description || commit.description,
        migration: migrationInfo,
        requiresAction: severity === 'critical' || severity === 'high',
      },
    };
  });

  return {
    ...data,
    categories: {
      ...categories,
      breaking: enhanced,
    },
    breakingSummary: generateBreakingSummary(enhanced),
  };
}

/**
 * Generate breaking changes summary
 */
function generateBreakingSummary(breakingCommits) {
  if (breakingCommits.length === 0) {
    return {
      hasBreaking: false,
      count: 0,
      critical: 0,
      high: 0,
      medium: 0,
      requiresUserAction: false,
    };
  }

  const critical = breakingCommits.filter(c => c.breaking.severity === 'critical').length;
  const high = breakingCommits.filter(c => c.breaking.severity === 'high').length;
  const medium = breakingCommits.filter(c => c.breaking.severity === 'medium').length;

  return {
    hasBreaking: true,
    count: breakingCommits.length,
    critical,
    high,
    medium,
    requiresUserAction: critical > 0 || high > 0,
    items: breakingCommits.map(c => ({
      description: c.description,
      severity: c.breaking.severity,
      hasMigration: !!c.breaking.migration,
    })),
  };
}

/**
 * Main function
 */
function main() {
  let input = '';

  // Read from stdin or file
  if (!process.stdin.isTTY) {
    input = fs.readFileSync(0, 'utf-8');
  } else {
    const args = process.argv.slice(2);
    if (args.length > 0 && fs.existsSync(args[0])) {
      input = fs.readFileSync(args[0], 'utf-8');
    } else {
      console.error('Usage: node detect-breaking.cjs < categorized.json');
      console.error('       node detect-breaking.cjs categorized.json');
      process.exit(1);
    }
  }

  let data;
  try {
    data = JSON.parse(input);
  } catch (error) {
    console.error(`Error parsing JSON input: ${error.message}`);
    console.error('Ensure upstream script outputs valid JSON');
    process.exit(1);
  }

  if (!data.categories) {
    console.error('Error: Missing "categories" object in input');
    process.exit(1);
  }
  const result = processBreakingChanges(data);

  console.log(JSON.stringify(result, null, 2));
}

// Run if executed directly
if (require.main === module) {
  main();
}

module.exports = {
  extractBreakingDetails,
  extractMigrationInfo,
  analyzeBreakingImpact,
  processBreakingChanges,
};

#!/usr/bin/env node
/**
 * Detect service boundaries from commit file changes
 * Usage: node detect-services.cjs < commits-with-files.json
 *
 * Analyzes file paths to determine affected services
 */

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

// Service patterns from config (hardcoded for performance)
// NOTE: Update these regex patterns to match your project's directory structure
const SERVICE_PATTERNS = {
  'backend-api': {
    patterns: [/src\/.*ExampleApp\/.*\.Api\//],
    label: 'Backend API',
    impact: 'high',
  },
  'backend-domain': {
    patterns: [/src\/.*ExampleApp\/.*\.Domain\//],
    label: 'Domain Model',
    impact: 'high',
  },
  'backend-application': {
    patterns: [/src\/.*ExampleApp\/.*\.Application\//],
    label: 'Application Layer',
    impact: 'medium',
  },
  'backend-persistence': {
    patterns: [/src\/.*ExampleApp\/.*\.Persistence.*\//],
    label: 'Persistence',
    impact: 'medium',
  },
  'framework-core': {
    patterns: [/src\/.*Framework.*\//],
    label: 'Framework Core',
    impact: 'critical',
  },
  'frontend-apps': {
    patterns: [/src\/.*ExampleAppWeb\/apps\//],
    label: 'Frontend Apps',
    impact: 'high',
  },
  'frontend-libs': {
    patterns: [/src\/.*ExampleAppWeb\/libs\//],
    label: 'Frontend Libraries',
    impact: 'medium',
  },
  'ai-tools': {
    patterns: [/\.claude\//, /\.github\/prompts\//],
    label: 'AI Tooling',
    impact: 'low',
  },
  config: {
    patterns: [/\.github\/workflows\//, /\.json$/, /\.ya?ml$/],
    label: 'Configuration',
    impact: 'low',
  },
  docs: {
    patterns: [/docs\//, /\.md$/],
    label: 'Documentation',
    impact: 'low',
  },
};

/**
 * Match a file path to services
 */
function matchServices(filePath) {
  const matched = [];

  for (const [serviceId, config] of Object.entries(SERVICE_PATTERNS)) {
    for (const pattern of config.patterns) {
      if (pattern.test(filePath)) {
        matched.push({
          id: serviceId,
          label: config.label,
          impact: config.impact,
        });
        break;
      }
    }
  }

  return matched;
}

/**
 * Analyze commits to determine service impacts
 */
function analyzeServiceImpact(commits) {
  const serviceMap = new Map();

  commits.forEach(commit => {
    if (!commit.files) return;

    commit.files.forEach(file => {
      const services = matchServices(file.path);

      services.forEach(service => {
        if (!serviceMap.has(service.id)) {
          serviceMap.set(service.id, {
            ...service,
            commits: [],
            fileCount: 0,
            changes: { added: 0, modified: 0, deleted: 0 },
          });
        }

        const entry = serviceMap.get(service.id);

        // Track commit if not already tracked
        if (!entry.commits.includes(commit.shortHash)) {
          entry.commits.push(commit.shortHash);
        }

        entry.fileCount++;

        // Track change types
        switch (file.status) {
          case 'A':
            entry.changes.added++;
            break;
          case 'M':
            entry.changes.modified++;
            break;
          case 'D':
            entry.changes.deleted++;
            break;
        }
      });
    });
  });

  // Convert to array and sort by impact
  const impactOrder = { critical: 0, high: 1, medium: 2, low: 3 };
  return Array.from(serviceMap.values()).sort(
    (a, b) => impactOrder[a.impact] - impactOrder[b.impact]
  );
}

/**
 * Generate service summary
 */
function generateServiceSummary(services) {
  const impactGroups = {
    critical: [],
    high: [],
    medium: [],
    low: [],
  };

  services.forEach(s => {
    impactGroups[s.impact].push(s.label);
  });

  const parts = [];

  if (impactGroups.critical.length > 0) {
    parts.push(`**Critical:** ${impactGroups.critical.join(', ')}`);
  }
  if (impactGroups.high.length > 0) {
    parts.push(`**High:** ${impactGroups.high.join(', ')}`);
  }
  if (impactGroups.medium.length > 0) {
    parts.push(`**Medium:** ${impactGroups.medium.join(', ')}`);
  }
  if (impactGroups.low.length > 0) {
    parts.push(`Low: ${impactGroups.low.join(', ')}`);
  }

  return parts.join(' | ') || 'No service boundaries detected';
}

/**
 * Main function
 */
function main() {
  let input = '';

  // Read from stdin or file
  if (!process.stdin.isTTY) {
    input = fs.readFileSync(0, 'utf-8');
  } else {
    const args = process.argv.slice(2);
    if (args.length > 0 && fs.existsSync(args[0])) {
      input = fs.readFileSync(args[0], 'utf-8');
    } else {
      console.error('Usage: node detect-services.cjs < commits-with-files.json');
      console.error('       node detect-services.cjs commits-with-files.json');
      console.error('');
      console.error('Note: Run parse-commits.cjs with --with-files flag first');
      process.exit(1);
    }
  }

  let data;
  try {
    data = JSON.parse(input);
  } catch (error) {
    console.error(`Error parsing JSON input: ${error.message}`);
    console.error('Ensure upstream script outputs valid JSON');
    process.exit(1);
  }

  if (!data.commits || !Array.isArray(data.commits)) {
    console.error('Error: Missing or invalid "commits" array in input');
    process.exit(1);
  }
  const commits = data.commits || [];

  const services = analyzeServiceImpact(commits);
  const summary = generateServiceSummary(services);

  const result = {
    ...data,
    services: {
      affected: services,
      summary,
      hasBreakingServiceChange: services.some(s => s.impact === 'critical'),
    },
  };

  console.log(JSON.stringify(result, null, 2));
}

// Run if executed directly
if (require.main === module) {
  main();
}

module.exports = { matchServices, analyzeServiceImpact, generateServiceSummary };

#!/usr/bin/env node
/**
 * Extract PR metadata from commits
 * Usage: node extract-pr-metadata.cjs < commits.json [--fetch-gh]
 *
 * Extracts PR numbers from commit messages and optionally fetches GitHub PR details
 */

const fs = require('fs');
const { execSync } = require('child_process');

// PR reference patterns
const PR_PATTERNS = [
  /\(#(\d+)\)/g, // (PR #123)
  /Merge pull request #(\d+)/gi, // Merge PR
  /closes?\s*#(\d+)/gi, // Closes #123
  /fixes?\s*#(\d+)/gi, // Fixes #123
  /resolves?\s*#(\d+)/gi, // Resolves #123
  /#(\d+)\b/g, // Generic #123 reference
];

/**
 * Extract PR numbers from commit message
 */
function extractPRNumbers(commit) {
  const text = `${commit.subject} ${commit.body || ''}`;
  const prNumbers = new Set();

  for (const pattern of PR_PATTERNS) {
    // Reset lastIndex for global patterns
    pattern.lastIndex = 0;
    let match;
    while ((match = pattern.exec(text)) !== null) {
      prNumbers.add(parseInt(match[1], 10));
    }
  }

  return Array.from(prNumbers);
}

/**
 * Fetch PR details from GitHub using gh CLI
 */
function fetchPRDetails(prNumber) {
  try {
    const cmd = `gh pr view ${prNumber} --json title,body,labels,author,mergedAt,additions,deletions,changedFiles`;
    const output = execSync(cmd, { encoding: 'utf-8', timeout: 10000 });
    return JSON.parse(output);
  } catch (error) {
    // PR not found or gh CLI error
    return null;
  }
}

/**
 * Extract labels from PR data
 */
function extractLabels(prData) {
  if (!prData?.labels) return [];
  return prData.labels.map(l => (typeof l === 'string' ? l : l.name));
}

/**
 * Determine PR type from labels
 */
function determinePRType(labels) {
  const labelSet = new Set(labels.map(l => l.toLowerCase()));

  if (labelSet.has('breaking') || labelSet.has('breaking-change')) {
    return 'breaking';
  }
  if (labelSet.has('feature') || labelSet.has('enhancement')) {
    return 'feature';
  }
  if (labelSet.has('bug') || labelSet.has('bugfix')) {
    return 'fix';
  }
  if (labelSet.has('documentation') || labelSet.has('docs')) {
    return 'docs';
  }
  if (labelSet.has('performance')) {
    return 'perf';
  }

  return 'other';
}

/**
 * Process commits to extract PR metadata
 */
function extractPRMetadata(data, options = {}) {
  const { fetchGitHub = false } = options;
  const commits = data.commits || [];

  const prMap = new Map();

  commits.forEach(commit => {
    const prNumbers = extractPRNumbers(commit);

    prNumbers.forEach(prNum => {
      if (!prMap.has(prNum)) {
        prMap.set(prNum, {
          number: prNum,
          commits: [],
          details: null,
        });
      }

      prMap.get(prNum).commits.push(commit.shortHash);
    });
  });

  // Optionally fetch GitHub details
  if (fetchGitHub) {
    for (const [prNum, prData] of prMap) {
      const details = fetchPRDetails(prNum);
      if (details) {
        const labels = extractLabels(details);
        prData.details = {
          title: details.title,
          author: details.author?.login,
          labels,
          type: determinePRType(labels),
          mergedAt: details.mergedAt,
          stats: {
            additions: details.additions,
            deletions: details.deletions,
            files: details.changedFiles,
          },
        };
      }
    }
  }

  // Convert to array
  const pullRequests = Array.from(prMap.values());

  return {
    ...data,
    pullRequests: {
      count: pullRequests.length,
      items: pullRequests,
      hasLinkedPRs: pullRequests.length > 0,
    },
  };
}

/**
 * Generate PR summary
 */
function generatePRSummary(pullRequests) {
  if (!pullRequests?.items?.length) {
    return 'No linked pull requests found.';
  }

  const withDetails = pullRequests.items.filter(pr => pr.details);

  if (withDetails.length === 0) {
    return `${pullRequests.count} pull request(s) referenced.`;
  }

  const byType = {};
  withDetails.forEach(pr => {
    const type = pr.details.type || 'other';
    byType[type] = (byType[type] || 0) + 1;
  });

  const parts = [];
  if (byType.feature) parts.push(`${byType.feature} feature(s)`);
  if (byType.fix) parts.push(`${byType.fix} fix(es)`);
  if (byType.breaking) parts.push(`${byType.breaking} breaking change(s)`);
  if (byType.docs) parts.push(`${byType.docs} doc update(s)`);

  return parts.length > 0 ? parts.join(', ') : `${pullRequests.count} pull request(s)`;
}

/**
 * Parse command line arguments
 */
function parseArgs(args) {
  return {
    fetchGitHub: args.includes('--fetch-gh') || args.includes('--fetch-github'),
    inputFile: args.find(a => !a.startsWith('--') && fs.existsSync(a)),
  };
}

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

  let input = '';

  // Read from stdin or file
  if (!process.stdin.isTTY) {
    input = fs.readFileSync(0, 'utf-8');
  } else if (options.inputFile) {
    input = fs.readFileSync(options.inputFile, 'utf-8');
  } else {
    console.error('Usage: node extract-pr-metadata.cjs < commits.json [--fetch-gh]');
    console.error('       node extract-pr-metadata.cjs commits.json --fetch-gh');
    console.error('');
    console.error('Options:');
    console.error('  --fetch-gh   Fetch PR details from GitHub using gh CLI');
    process.exit(1);
  }

  let data;
  try {
    data = JSON.parse(input);
  } catch (error) {
    console.error(`Error parsing JSON input: ${error.message}`);
    console.error('Ensure upstream script outputs valid JSON');
    process.exit(1);
  }

  if (!data.commits || !Array.isArray(data.commits)) {
    console.error('Error: Missing or invalid "commits" array in input');
    process.exit(1);
  }
  const result = extractPRMetadata(data, { fetchGitHub: options.fetchGitHub });
  result.pullRequests.summary = generatePRSummary(result.pullRequests);

  console.log(JSON.stringify(result, null, 2));
}

// Run if executed directly
if (require.main === module) {
  main();
}

module.exports = {
  extractPRNumbers,
  fetchPRDetails,
  extractPRMetadata,
  generatePRSummary,
};

#!/usr/bin/env node
/**
 * Parse git commits between two refs into structured JSON
 * Usage: node parse-commits.cjs <base> <head> [--json]
 *
 * Parses conventional commit format: type(scope): description
 */

const { execSync } = require('child_process');

// Conventional commit regex
const COMMIT_PATTERN = /^(?<type>\w+)(?:\((?<scope>[^)]+)\))?(?<breaking>!)?\s*:\s*(?<description>.+)$/;

/**
 * Parse a single commit message into structured data
 */
function parseCommitMessage(subject) {
  const match = subject.match(COMMIT_PATTERN);

  if (!match) {
    return {
      type: 'other',
      scope: null,
      breaking: false,
      description: subject,
      conventional: false,
    };
  }

  return {
    type: match.groups.type,
    scope: match.groups.scope || null,
    breaking: !!match.groups.breaking,
    description: match.groups.description,
    conventional: true,
  };
}

/**
 * Sanitize git ref to prevent command injection
 * Allows: alphanumeric, dots, dashes, underscores, tildes, carets, slashes
 */
function sanitizeGitRef(ref) {
  return ref.replace(/[^a-zA-Z0-9._\-~^\/]/g, '');
}

/**
 * Get commits between two refs using git log
 */
function getCommits(base, head) {
  // Use unique delimiter to separate commits (unlikely to appear in content)
  const COMMIT_DELIMITER = '<<<COMMIT_END>>>';
  const FIELD_DELIMITER = '<<<FIELD>>>';

  const format = [
    '%H',  // Full hash
    '%h',  // Short hash
    '%an', // Author name
    '%ae', // Author email
    '%ad', // Author date
    '%s',  // Subject
    '%b',  // Body
  ].join(FIELD_DELIMITER);

  // Sanitize refs to prevent command injection
  const safeBase = sanitizeGitRef(base);
  const safeHead = sanitizeGitRef(head);

  const cmd = `git log "${safeBase}..${safeHead}" --pretty=format:"${format}${COMMIT_DELIMITER}" --date=short`;

  try {
    const output = execSync(cmd, {
      encoding: 'utf-8',
      maxBuffer: 50 * 1024 * 1024,
      timeout: 60000  // 60 second timeout for large repos
    });

    if (!output.trim()) {
      return [];
    }

    const rawCommits = output.split(COMMIT_DELIMITER).filter(c => c.trim());

    return rawCommits.map(raw => {
      const parts = raw.split(FIELD_DELIMITER);
      // Handle leading newline from previous commit separator
      const hash = (parts[0] || '').replace(/^[\r\n]+/, '').trim();
      const shortHash = (parts[1] || '').trim();
      const author = (parts[2] || '').trim();
      const email = (parts[3] || '').trim();
      const date = (parts[4] || '').trim();
      const subject = (parts[5] || '').trim();
      const body = (parts[6] || '').trim();

      const parsed = parseCommitMessage(subject);

      // Check for BREAKING CHANGE in body
      const hasBreakingInBody = body && /BREAKING[ -]CHANGE:/i.test(body);

      return {
        hash,
        shortHash,
        author,
        email,
        date,
        subject,
        body,
        ...parsed,
        breaking: parsed.breaking || hasBreakingInBody,
      };
    });
  } catch (error) {
    console.error('Error executing git log:', error.message);
    return [];
  }
}

/**
 * Get file changes for each commit
 */
function getCommitFiles(hash) {
  try {
    const cmd = `git diff-tree --no-commit-id --name-status -r ${hash}`;
    const output = execSync(cmd, { encoding: 'utf-8' });

    return output
      .trim()
      .split('\n')
      .filter(line => line.trim())
      .map(line => {
        const [status, ...pathParts] = line.split('\t');
        return {
          status: status.trim(),
          path: pathParts.join('\t').trim(),
        };
      });
  } catch {
    return [];
  }
}

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

  if (args.length < 2) {
    console.error('Usage: node parse-commits.cjs <base> <head> [--with-files]');
    process.exit(1);
  }

  const [base, head] = args;
  const withFiles = args.includes('--with-files');

  const commits = getCommits(base, head);

  // Optionally add file changes
  if (withFiles) {
    commits.forEach(commit => {
      commit.files = getCommitFiles(commit.hash);
    });
  }

  // Calculate stats
  const stats = {
    total: commits.length,
    conventional: commits.filter(c => c.conventional).length,
    breaking: commits.filter(c => c.breaking).length,
    byType: {},
    authors: [...new Set(commits.map(c => c.author))],
    dateRange: {
      from: commits.length ? commits[commits.length - 1].date : null,
      to: commits.length ? commits[0].date : null,
    },
  };

  // Count by type
  commits.forEach(c => {
    stats.byType[c.type] = (stats.byType[c.type] || 0) + 1;
  });

  const result = {
    base,
    head,
    commits,
    stats,
  };

  console.log(JSON.stringify(result, null, 2));
}

// Run if executed directly
if (require.main === module) {
  main();
}

module.exports = { parseCommitMessage, getCommits, getCommitFiles };