chati-dev 1.4.0 → 2.0.2

package/scripts/commit-message-generator.js

@@ -0,0 +1,167 @@
+/**
+ * Commit Message Generator — Produces conventional commit messages from staged changes.
+ *
+ * Analyzes changed file paths to determine type and scope, then builds
+ * a properly formatted conventional commit string.
+ *
+ * @module scripts/commit-message-generator
+ */
+
+import { dirname, basename, extname } from 'node:path';
+
+/**
+ * Path-based rules for detecting commit type.
+ * Order matters: first match wins.
+ *
+ * @type {Array<{ pattern: RegExp, type: string }>}
+ */
+const TYPE_RULES = [
+  { pattern: /\.github\/|\.gitlab-ci|Jenkinsfile|\.circleci/i, type: 'ci' },
+  { pattern: /\.test\.|\.spec\.|__tests__|test\/|tests\//i, type: 'test' },
+  { pattern: /docs\/|\.md$/i, type: 'docs' },
+  { pattern: /package\.json$|package-lock\.json$|yarn\.lock$|pnpm-lock/i, type: 'chore' },
+  { pattern: /\.eslint|\.prettier|tsconfig|\.editorconfig|\.gitignore/i, type: 'chore' },
+  { pattern: /Dockerfile|docker-compose|\.dockerignore/i, type: 'ci' },
+  { pattern: /webpack|rollup|vite\.config|esbuild|babel\.config/i, type: 'build' },
+];
+
+/**
+ * Detects the conventional commit type from a list of changed files.
+ *
+ * @param {string[]} files — array of file paths (relative)
+ * @returns {string}
+ */
+export function detectCommitType(files) {
+  if (!files || files.length === 0) return 'chore';
+
+  const typeCounts = {};
+
+  for (const file of files) {
+    let detected = null;
+    for (const rule of TYPE_RULES) {
+      if (rule.pattern.test(file)) {
+        detected = rule.type;
+        break;
+      }
+    }
+    // Default to 'feat' for unmatched source files
+    if (!detected) {
+      detected = 'feat';
+    }
+    typeCounts[detected] = (typeCounts[detected] || 0) + 1;
+  }
+
+  // Pick the type that covers most files
+  let maxType = 'chore';
+  let maxCount = 0;
+  for (const [type, count] of Object.entries(typeCounts)) {
+    if (count > maxCount) {
+      maxCount = count;
+      maxType = type;
+    }
+  }
+
+  return maxType;
+}
+
+/**
+ * Detects the scope from file paths.
+ * Uses the common parent directory or module name.
+ *
+ * @param {string[]} files — array of file paths (relative)
+ * @returns {string}
+ */
+export function detectScope(files) {
+  if (!files || files.length === 0) return '';
+
+  // Normalize paths and extract directory parts
+  const dirParts = files.map((f) => {
+    const dir = dirname(f);
+    return dir.split(/[/\\]/).filter(Boolean);
+  });
+
+  if (dirParts.length === 0) return '';
+
+  // Single file: use its immediate parent directory
+  if (files.length === 1) {
+    const parts = dirParts[0];
+    if (parts.length === 0 || (parts.length === 1 && parts[0] === '.')) return '';
+    return parts[parts.length - 1];
+  }
+
+  // Multiple files: find common prefix
+  const shortest = Math.min(...dirParts.map((p) => p.length));
+  let commonDepth = 0;
+  for (let i = 0; i < shortest; i++) {
+    const segment = dirParts[0][i];
+    if (dirParts.every((p) => p[i] === segment)) {
+      commonDepth = i + 1;
+    } else {
+      break;
+    }
+  }
+
+  if (commonDepth === 0) return '';
+
+  const commonParts = dirParts[0].slice(0, commonDepth);
+  // Skip generic top-level directories for the scope name
+  const skipDirs = new Set(['src', 'lib', 'packages', 'apps', 'modules']);
+  const meaningful = commonParts.filter((p) => !skipDirs.has(p));
+
+  if (meaningful.length === 0 && commonParts.length > 0) {
+    // If all parts are generic, use the deepest one
+    return commonParts[commonParts.length - 1];
+  }
+
+  return meaningful.length > 0 ? meaningful[meaningful.length - 1] : '';
+}
+
+/**
+ * Formats a conventional commit message.
+ *
+ * @param {string} type
+ * @param {string} scope
+ * @param {string} description
+ * @returns {string}
+ */
+export function formatCommitMessage(type, scope, description) {
+  const scopePart = scope ? `(${scope})` : '';
+  return `${type}${scopePart}: ${description}`;
+}
+
+/**
+ * Generates a conventional commit message from options.
+ *
+ * @param {Object} options
+ * @param {string[]} options.files       — list of changed file paths
+ * @param {string}   [options.diff]      — git diff string (used for description hints)
+ * @param {string}   [options.type]      — override commit type
+ * @returns {string}
+ */
+export function generateCommitMessage(options = {}) {
+  const { files = [], type: overrideType } = options;
+
+  if (files.length === 0) {
+    return 'chore: update files';
+  }
+
+  const type = overrideType || detectCommitType(files);
+  const scope = detectScope(files);
+
+  // Generate description from file names
+  let description;
+  if (files.length === 1) {
+    const name = basename(files[0], extname(files[0]));
+    const verb = type === 'feat' ? 'add' : type === 'fix' ? 'fix' : 'update';
+    description = `${verb} ${name}`;
+  } else if (files.length <= 3) {
+    const names = files.map((f) => basename(f, extname(f)));
+    const verb = type === 'feat' ? 'add' : type === 'fix' ? 'fix' : 'update';
+    description = `${verb} ${names.join(', ')}`;
+  } else {
+    const verb = type === 'feat' ? 'add' : type === 'fix' ? 'fix' : 'update';
+    description = `${verb} ${files.length} files`;
+  }
+
+  return formatCommitMessage(type, scope, description);
+}

package/scripts/coverage-analyzer.js

@@ -0,0 +1,260 @@
+/**
+ * Coverage Analyzer — Identifies code coverage gaps by mapping source to test files.
+ *
+ * Uses naming conventions to correlate source files with their test counterparts,
+ * detects uncovered exports, and generates human-readable reports.
+ *
+ * @module scripts/coverage-analyzer
+ */
+
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { join, relative, extname } from 'node:path';
+
+/**
+ * @typedef {Object} CoverageReport
+ * @property {string[]} coveredFiles    — source files with corresponding tests
+ * @property {string[]} uncoveredFiles  — source files without tests
+ * @property {string[]} orphanedTests   — test files without corresponding source
+ * @property {number} coverageRatio
+ * @property {number} totalSourceFiles
+ * @property {number} totalTestFiles
+ */
+
+/**
+ * Recursively collects JS files from a directory, excluding node_modules and .git.
+ * @param {string} dir
+ * @param {string} [ext='.js']
+ * @returns {string[]}
+ */
+function collectFiles(dir, ext = '.js') {
+  const results = [];
+
+  function walk(currentDir) {
+    let entries;
+    try {
+      entries = readdirSync(currentDir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry === 'node_modules' || entry === '.git') continue;
+      const fullPath = join(currentDir, entry);
+      let stat;
+      try {
+        stat = statSync(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        walk(fullPath);
+      } else if (stat.isFile() && fullPath.endsWith(ext)) {
+        results.push(fullPath);
+      }
+    }
+  }
+
+  walk(dir);
+  return results.sort();
+}
+
+/**
+ * Derives the expected test file path for a source file.
+ * Convention: src/foo/bar.js -> test/foo/bar.test.js
+ *
+ * @param {string} srcFile   — absolute path to source file
+ * @param {string} srcDir    — root source directory
+ * @param {string} testDir   — root test directory
+ * @returns {string}
+ */
+function expectedTestPath(srcFile, srcDir, testDir) {
+  const rel = relative(srcDir, srcFile);
+  const ext = extname(rel);
+  const withoutExt = rel.slice(0, -ext.length);
+  return join(testDir, `${withoutExt}.test${ext}`);
+}
+
+/**
+ * Derives the expected source file path for a test file.
+ * Convention: test/foo/bar.test.js -> src/foo/bar.js
+ *
+ * @param {string} testFile
+ * @param {string} srcDir
+ * @param {string} testDir
+ * @returns {string}
+ */
+function expectedSourcePath(testFile, srcDir, testDir) {
+  const rel = relative(testDir, testFile);
+  const noTest = rel.replace(/\.test\./, '.').replace(/\.spec\./, '.');
+  return join(srcDir, noTest);
+}
+
+/**
+ * Analyzes coverage by mapping source files to test files.
+ *
+ * @param {string} srcDir
+ * @param {string} testDir
+ * @returns {CoverageReport}
+ */
+export function analyzeCoverage(srcDir, testDir) {
+  const sourceFiles = collectFiles(srcDir, '.js').filter(
+    (f) => !f.endsWith('.test.js') && !f.endsWith('.spec.js')
+  );
+  const testFiles = collectFiles(testDir, '.js').filter(
+    (f) => f.endsWith('.test.js') || f.endsWith('.spec.js')
+  );
+
+  const coveredFiles = [];
+  const uncoveredFiles = [];
+
+  for (const src of sourceFiles) {
+    const expected = expectedTestPath(src, srcDir, testDir);
+    if (existsSync(expected)) {
+      coveredFiles.push(relative(srcDir, src));
+    } else {
+      uncoveredFiles.push(relative(srcDir, src));
+    }
+  }
+
+  const orphanedTests = [];
+  for (const test of testFiles) {
+    const expected = expectedSourcePath(test, srcDir, testDir);
+    if (!existsSync(expected)) {
+      orphanedTests.push(relative(testDir, test));
+    }
+  }
+
+  const totalSourceFiles = sourceFiles.length;
+  const coverageRatio =
+    totalSourceFiles > 0
+      ? Math.round((coveredFiles.length / totalSourceFiles) * 10000) / 10000
+      : 0;
+
+  return {
+    coveredFiles,
+    uncoveredFiles,
+    orphanedTests,
+    coverageRatio,
+    totalSourceFiles,
+    totalTestFiles: testFiles.length,
+  };
+}
+
+/**
+ * Parses exported function names from a source file via regex heuristics.
+ * Handles: export function, export const/let, export default, module.exports.
+ *
+ * @param {string} srcFilePath
+ * @returns {string[]}
+ */
+export function getUncoveredFunctions(srcFilePath, testFilePath) {
+  let srcContent;
+  try {
+    srcContent = readFileSync(srcFilePath, 'utf-8');
+  } catch {
+    return [];
+  }
+
+  // Extract exported function/const names
+  const exportedNames = new Set();
+
+  // ESM: export function foo(
+  const exportFuncRe = /export\s+(?:async\s+)?function\s+(\w+)/g;
+  let m;
+  while ((m = exportFuncRe.exec(srcContent)) !== null) {
+    exportedNames.add(m[1]);
+  }
+
+  // ESM: export const foo = / export let foo =
+  const exportConstRe = /export\s+(?:const|let|var)\s+(\w+)\s*=/g;
+  while ((m = exportConstRe.exec(srcContent)) !== null) {
+    exportedNames.add(m[1]);
+  }
+
+  // ESM: export class Foo
+  const exportClassRe = /export\s+class\s+(\w+)/g;
+  while ((m = exportClassRe.exec(srcContent)) !== null) {
+    exportedNames.add(m[1]);
+  }
+
+  // ESM: export { foo, bar }
+  const exportBracketRe = /export\s*\{([^}]+)\}/g;
+  while ((m = exportBracketRe.exec(srcContent)) !== null) {
+    const names = m[1].split(',').map((n) => n.trim().split(/\s+as\s+/)[0].trim());
+    for (const name of names) {
+      if (name) exportedNames.add(name);
+    }
+  }
+
+  if (exportedNames.size === 0) return [];
+
+  // If no test file, all exported names are uncovered
+  if (!testFilePath) {
+    return [...exportedNames];
+  }
+
+  let testContent;
+  try {
+    testContent = readFileSync(testFilePath, 'utf-8');
+  } catch {
+    return [...exportedNames];
+  }
+
+  // Check which names appear in the test file
+  const uncovered = [];
+  for (const name of exportedNames) {
+    // Look for the name being referenced in tests (import, call, etc.)
+    const nameRegex = new RegExp(`\\b${name}\\b`);
+    if (!nameRegex.test(testContent)) {
+      uncovered.push(name);
+    }
+  }
+
+  return uncovered;
+}
+
+/**
+ * Generates a formatted coverage report string.
+ *
+ * @param {string} srcDir
+ * @param {string} testDir
+ * @returns {string}
+ */
+export function generateCoverageReport(srcDir, testDir) {
+  const report = analyzeCoverage(srcDir, testDir);
+  const lines = [];
+
+  lines.push('=== Coverage Analysis Report ===');
+  lines.push('');
+  lines.push(`Source directory : ${srcDir}`);
+  lines.push(`Test directory   : ${testDir}`);
+  lines.push(`Source files     : ${report.totalSourceFiles}`);
+  lines.push(`Test files       : ${report.totalTestFiles}`);
+  lines.push(`Coverage ratio   : ${(report.coverageRatio * 100).toFixed(1)}%`);
+  lines.push('');
+
+  if (report.coveredFiles.length > 0) {
+    lines.push(`--- Covered (${report.coveredFiles.length}) ---`);
+    for (const f of report.coveredFiles) {
+      lines.push(`  [OK] ${f}`);
+    }
+    lines.push('');
+  }
+
+  if (report.uncoveredFiles.length > 0) {
+    lines.push(`--- Uncovered (${report.uncoveredFiles.length}) ---`);
+    for (const f of report.uncoveredFiles) {
+      lines.push(`  [!!] ${f}`);
+    }
+    lines.push('');
+  }
+
+  if (report.orphanedTests.length > 0) {
+    lines.push(`--- Orphaned Tests (${report.orphanedTests.length}) ---`);
+    for (const f of report.orphanedTests) {
+      lines.push(`  [??] ${f}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}

package/scripts/dependency-analyzer.js

@@ -0,0 +1,280 @@
+/**
+ * Dependency Analyzer — Inspects project dependencies for issues and metrics.
+ *
+ * Reads package.json and optional lock files to produce a comprehensive
+ * dependency report including counts, version patterns, and potential problems.
+ *
+ * @module scripts/dependency-analyzer
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * @typedef {Object} Issue
+ * @property {string} severity — 'error' | 'warning' | 'info'
+ * @property {string} name     — dependency name
+ * @property {string} message
+ */
+
+/**
+ * @typedef {Object} DependencyStats
+ * @property {number} total
+ * @property {number} prod
+ * @property {number} dev
+ * @property {number} peer
+ * @property {number} optional
+ */
+
+/**
+ * @typedef {Object} DependencyReport
+ * @property {DependencyStats} stats
+ * @property {Issue[]} issues
+ * @property {string[]} prodDeps
+ * @property {string[]} devDeps
+ * @property {string[]} peerDeps
+ * @property {string[]} optionalDeps
+ * @property {string[]} duplicatesAcrossGroups
+ * @property {boolean} hasLockFile
+ */
+
+/**
+ * Safely reads and parses a JSON file.
+ * @param {string} filePath
+ * @returns {Object|null}
+ */
+function readJSON(filePath) {
+  try {
+    const raw = readFileSync(filePath, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Gets basic dependency counts from a target directory.
+ *
+ * @param {string} targetDir
+ * @returns {DependencyStats}
+ */
+export function getDependencyStats(targetDir) {
+  const pkg = readJSON(join(targetDir, 'package.json'));
+  if (!pkg) {
+    return { total: 0, prod: 0, dev: 0, peer: 0, optional: 0 };
+  }
+
+  const prod = Object.keys(pkg.dependencies || {}).length;
+  const dev = Object.keys(pkg.devDependencies || {}).length;
+  const peer = Object.keys(pkg.peerDependencies || {}).length;
+  const optional = Object.keys(pkg.optionalDependencies || {}).length;
+
+  return {
+    total: prod + dev + peer + optional,
+    prod,
+    dev,
+    peer,
+    optional,
+  };
+}
+
+/**
+ * Checks dependencies for common issues.
+ *
+ * @param {Record<string, string>} deps — name-to-version map
+ * @param {string} group — group label ('prod', 'dev', etc.)
+ * @returns {Issue[]}
+ */
+export function checkForIssues(deps, group = 'prod') {
+  const issues = [];
+
+  for (const [name, version] of Object.entries(deps)) {
+    // Wildcard version
+    if (version === '*' || version === 'latest') {
+      issues.push({
+        severity: 'error',
+        name,
+        message: `${group} dependency "${name}" uses wildcard version "${version}" — pin to a specific range`,
+      });
+    }
+
+    // URL-based version (git, http)
+    if (/^(git|http|https|ssh|file):/.test(version) || version.includes('github.com')) {
+      issues.push({
+        severity: 'warning',
+        name,
+        message: `${group} dependency "${name}" uses a URL-based version — may cause reproducibility issues`,
+      });
+    }
+
+    // Very broad range (>= without upper bound)
+    if (/^>=/.test(version) && !version.includes('<') && !version.includes(' ')) {
+      issues.push({
+        severity: 'warning',
+        name,
+        message: `${group} dependency "${name}" has an unbounded lower version "${version}"`,
+      });
+    }
+
+    // Version 0.x (potentially unstable)
+    if (/^[\^~]?0\./.test(version)) {
+      issues.push({
+        severity: 'info',
+        name,
+        message: `${group} dependency "${name}" is pre-1.0 (${version}) — API may be unstable`,
+      });
+    }
+
+    // Empty version
+    if (!version || version.trim() === '') {
+      issues.push({
+        severity: 'error',
+        name,
+        message: `${group} dependency "${name}" has an empty version`,
+      });
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Full dependency analysis for a target directory.
+ *
+ * @param {string} targetDir
+ * @returns {DependencyReport}
+ */
+export function analyzeDependencies(targetDir) {
+  const pkg = readJSON(join(targetDir, 'package.json'));
+  if (!pkg) {
+    return {
+      stats: { total: 0, prod: 0, dev: 0, peer: 0, optional: 0 },
+      issues: [{ severity: 'error', name: '-', message: 'No package.json found' }],
+      prodDeps: [],
+      devDeps: [],
+      peerDeps: [],
+      optionalDeps: [],
+      duplicatesAcrossGroups: [],
+      hasLockFile: false,
+    };
+  }
+
+  const prodDeps = pkg.dependencies || {};
+  const devDeps = pkg.devDependencies || {};
+  const peerDeps = pkg.peerDependencies || {};
+  const optionalDeps = pkg.optionalDependencies || {};
+
+  const stats = getDependencyStats(targetDir);
+
+  // Collect issues from all groups
+  const issues = [
+    ...checkForIssues(prodDeps, 'prod'),
+    ...checkForIssues(devDeps, 'dev'),
+    ...checkForIssues(peerDeps, 'peer'),
+    ...checkForIssues(optionalDeps, 'optional'),
+  ];
+
+  // Find duplicates across prod and dev
+  const prodNames = new Set(Object.keys(prodDeps));
+  const devNames = new Set(Object.keys(devDeps));
+  const duplicatesAcrossGroups = [...prodNames].filter((n) => devNames.has(n));
+
+  if (duplicatesAcrossGroups.length > 0) {
+    for (const dup of duplicatesAcrossGroups) {
+      issues.push({
+        severity: 'warning',
+        name: dup,
+        message: `"${dup}" appears in both dependencies and devDependencies`,
+      });
+    }
+  }
+
+  // Check for lock file
+  const hasLockFile =
+    existsSync(join(targetDir, 'package-lock.json')) ||
+    existsSync(join(targetDir, 'yarn.lock')) ||
+    existsSync(join(targetDir, 'pnpm-lock.yaml')) ||
+    existsSync(join(targetDir, 'bun.lockb'));
+
+  if (!hasLockFile) {
+    issues.push({
+      severity: 'warning',
+      name: '-',
+      message: 'No lock file found — builds may not be reproducible',
+    });
+  }
+
+  return {
+    stats,
+    issues,
+    prodDeps: Object.keys(prodDeps).sort(),
+    devDeps: Object.keys(devDeps).sort(),
+    peerDeps: Object.keys(peerDeps).sort(),
+    optionalDeps: Object.keys(optionalDeps).sort(),
+    duplicatesAcrossGroups,
+    hasLockFile,
+  };
+}
+
+/**
+ * Formats a dependency report as a human-readable string.
+ *
+ * @param {DependencyReport} report
+ * @returns {string}
+ */
+export function formatDependencyReport(report) {
+  const lines = [];
+
+  lines.push('=== Dependency Analysis Report ===');
+  lines.push('');
+  lines.push(`Total dependencies : ${report.stats.total}`);
+  lines.push(`  Production       : ${report.stats.prod}`);
+  lines.push(`  Development      : ${report.stats.dev}`);
+  lines.push(`  Peer             : ${report.stats.peer}`);
+  lines.push(`  Optional         : ${report.stats.optional}`);
+  lines.push(`Lock file          : ${report.hasLockFile ? 'Yes' : 'No'}`);
+  lines.push('');
+
+  if (report.duplicatesAcrossGroups.length > 0) {
+    lines.push(`--- Duplicates (prod & dev) ---`);
+    for (const dup of report.duplicatesAcrossGroups) {
+      lines.push(`  [DUP] ${dup}`);
+    }
+    lines.push('');
+  }
+
+  const errors = report.issues.filter((i) => i.severity === 'error');
+  const warnings = report.issues.filter((i) => i.severity === 'warning');
+  const infos = report.issues.filter((i) => i.severity === 'info');
+
+  if (errors.length > 0) {
+    lines.push(`--- Errors (${errors.length}) ---`);
+    for (const issue of errors) {
+      lines.push(`  [ERR] ${issue.message}`);
+    }
+    lines.push('');
+  }
+
+  if (warnings.length > 0) {
+    lines.push(`--- Warnings (${warnings.length}) ---`);
+    for (const issue of warnings) {
+      lines.push(`  [WRN] ${issue.message}`);
+    }
+    lines.push('');
+  }
+
+  if (infos.length > 0) {
+    lines.push(`--- Info (${infos.length}) ---`);
+    for (const issue of infos) {
+      lines.push(`  [INF] ${issue.message}`);
+    }
+    lines.push('');
+  }
+
+  if (report.issues.length === 0) {
+    lines.push('No issues found.');
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}