sumulige-claude 1.5.1 → 1.5.2

package/lib/quality-rules.js

@@ -1,373 +0,0 @@
-/**
- * Quality Rules Registry
- *
- * Pluggable rule system for code quality checks.
- * Rules can be defined in-code or loaded from config files (YAML/JSON).
- *
- * @module lib/quality-rules
- */
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Rule Registry
- * Manages quality check rules
- */
-class RuleRegistry {
-  constructor() {
-    this.rules = new Map();
-    this._registerBuiltInRules();
-  }
-
-  /**
-   * Register a rule
-   * @param {string} id - Rule identifier
-   * @param {Object} definition - Rule definition
-   */
-  register(id, definition) {
-    const rule = {
-      id,
-      name: definition.name || id,
-      description: definition.description || '',
-      severity: definition.severity || 'warn',
-      enabled: definition.enabled !== false,
-      check: definition.check,
-      fix: definition.fix || null,
-      config: definition.config || {}
-    };
-    this.rules.set(id, rule);
-    return rule;
-  }
-
-  /**
-   * Get rule by ID
-   * @param {string} id - Rule identifier
-   * @returns {Object|null} Rule object
-   */
-  get(id) {
-    return this.rules.get(id) || null;
-  }
-
-  /**
-   * Check if rule exists
-   * @param {string} id - Rule identifier
-   * @returns {boolean}
-   */
-  has(id) {
-    return this.rules.has(id);
-  }
-
-  /**
-   * Get all rules, optionally filtered
-   * @param {Object} filter - Filter options
-   * @returns {Array} Array of rules
-   */
-  getAll(filter = {}) {
-    let rules = Array.from(this.rules.values());
-
-    if (filter.severity) {
-      rules = rules.filter(r => r.severity === filter.severity);
-    }
-    if (filter.enabled !== undefined) {
-      rules = rules.filter(r => r.enabled === filter.enabled);
-    }
-    if (filter.category) {
-      rules = rules.filter(r => r.category === filter.category);
-    }
-
-    return rules;
-  }
-
-  /**
-   * Enable/disable a rule
-   * @param {string} id - Rule identifier
-   * @param {boolean} enabled - Enable state
-   */
-  setEnabled(id, enabled) {
-    const rule = this.rules.get(id);
-    if (rule) {
-      rule.enabled = enabled;
-    }
-  }
-
-  /**
-   * Update rule configuration
-   * @param {string} id - Rule identifier
-   * @param {Object} config - New configuration
-   */
-  updateConfig(id, config) {
-    const rule = this.rules.get(id);
-    if (rule) {
-      rule.config = { ...rule.config, ...config };
-    }
-  }
-
-  /**
-   * Load rules from config file
-   * @param {string} filePath - Path to rules config file
-   */
-  loadFromFile(filePath) {
-    if (!fs.existsSync(filePath)) {
-      return;
-    }
-
-    const content = fs.readFileSync(filePath, 'utf-8');
-    let config;
-
-    if (filePath.endsWith('.yaml') || filePath.endsWith('.yml')) {
-      // Try to load YAML parser
-      try {
-        const yaml = require('yaml');
-        config = yaml.parse(content);
-      } catch {
-        console.warn(`YAML parser not available, skipping ${filePath}`);
-        return;
-      }
-    } else {
-      config = JSON.parse(content);
-    }
-
-    // Register rules from config
-    for (const ruleDef of config.rules || []) {
-      if (ruleDef.id) {
-        const existing = this.rules.get(ruleDef.id);
-        if (existing) {
-          // Update existing rule
-          Object.assign(existing, ruleDef);
-        } else {
-          // Register new rule with function check
-          this.register(ruleDef.id, ruleDef);
-        }
-      }
-    }
-  }
-
-  /**
-   * Register built-in rules
-   */
-  _registerBuiltInRules() {
-    // File size rule
-    this.register('file-size-limit', {
-      name: 'File Size Limit',
-      description: 'Ensure files do not exceed size limit',
-      category: 'size',
-      severity: 'warn',
-      enabled: true,
-      config: { maxSize: 800 * 1024 }, // 800KB
-      check: (file, config) => {
-        const stats = fs.statSync(file);
-        const maxSize = config.maxSize || 800 * 1024;
-        if (stats.size > maxSize) {
-          return {
-            pass: false,
-            message: `File size (${(stats.size / 1024).toFixed(0)}KB) exceeds limit (${(maxSize / 1024).toFixed(0)}KB)`,
-            fix: 'Consider splitting the file or removing unused code'
-          };
-        }
-        return { pass: true };
-      }
-    });
-
-    // Line count rule
-    this.register('line-count-limit', {
-      name: 'Line Count Limit',
-      description: 'Ensure files do not exceed line count limit',
-      category: 'size',
-      severity: 'error',
-      enabled: true,
-      config: { maxLines: 800 },
-      check: (file, config) => {
-        const content = fs.readFileSync(file, 'utf-8');
-        const lines = content.split('\n').length;
-        const maxLines = config.maxLines || 800;
-        if (lines > maxLines) {
-          return {
-            pass: false,
-            message: `File (${lines} lines) exceeds line limit (${maxLines})`,
-            fix: 'Consider splitting into smaller modules'
-          };
-        }
-        return { pass: true };
-      }
-    });
-
-    // Console.log detection rule
-    this.register('no-console-logs', {
-      name: 'No Console Logs',
-      description: 'Detect console.log statements in production code',
-      category: 'code-style',
-      severity: 'warn',
-      enabled: false,
-      check: (file) => {
-        const ext = path.extname(file);
-        if (!['.js', '.jsx', '.ts', '.tsx', '.cjs', '.mjs'].includes(ext)) {
-          return { pass: true, skip: true };
-        }
-        const content = fs.readFileSync(file, 'utf-8');
-        // Match console.log/debug/info/warn but not console.error
-        const matches = content.matchAll(/console\.(log|debug|info|warn)\(/g);
-        const count = [...matches].length;
-        if (count > 0) {
-          return {
-            pass: false,
-            message: `Found ${count} console statement(s)`,
-            fix: 'Remove or replace with proper logging library'
-          };
-        }
-        return { pass: true };
-      }
-    });
-
-    // TODO comments rule
-    this.register('todo-comments', {
-      name: 'TODO Comments Check',
-      description: 'Track TODO/FIXME comments in code',
-      category: 'documentation',
-      severity: 'info',
-      enabled: true,
-      check: (file) => {
-        const ext = path.extname(file);
-        if (!['.js', '.jsx', '.ts', '.tsx', '.cjs', '.mjs', '.py', '.go'].includes(ext)) {
-          return { pass: true, skip: true };
-        }
-        const content = fs.readFileSync(file, 'utf-8');
-        const todoRegex = /(?:TODO|FIXME|XXX|HACK|NOTE):?\s*(.+)/gi;
-        const todos = [...content.matchAll(todoRegex)];
-        if (todos.length > 0) {
-          return {
-            pass: true, // Just informational
-            message: `${todos.length} TODO comment(s) found`,
-            details: todos.map(m => m[1].trim())
-          };
-        }
-        return { pass: true };
-      }
-    });
-
-    // Directory depth rule
-    this.register('directory-depth', {
-      name: 'Directory Depth Limit',
-      description: 'Ensure directory structure is not too deep',
-      category: 'structure',
-      severity: 'warn',
-      enabled: true,
-      config: { maxDepth: 6 },
-      check: (file, config) => {
-        const maxDepth = config.maxDepth || 6;
-        const depth = file.split(path.sep).length;
-        if (depth > maxDepth) {
-          return {
-            pass: false,
-            message: `Directory depth (${depth}) exceeds limit (${maxDepth})`,
-            fix: 'Consider flattening the directory structure'
-          };
-        }
-        return { pass: true };
-      }
-    });
-
-    // Empty file rule
-    this.register('no-empty-files', {
-      name: 'No Empty Files',
-      description: 'Detect empty or near-empty files',
-      category: 'quality',
-      severity: 'warn',
-      enabled: true,
-      config: { minLines: 3 },
-      check: (file, config) => {
-        const content = fs.readFileSync(file, 'utf-8');
-        const lines = content.trim().split('\n').filter(l => l.trim());
-        const minLines = config.minLines || 3;
-        if (lines.length < minLines) {
-          return {
-            pass: false,
-            message: `File has only ${lines.length} line(s)`,
-            fix: 'Add content or remove the file'
-          };
-        }
-        return { pass: true };
-      }
-    });
-
-    // Trailing whitespace rule
-    this.register('no-trailing-whitespace', {
-      name: 'No Trailing Whitespace',
-      description: 'Detect trailing whitespace on lines',
-      category: 'code-style',
-      severity: 'warn',
-      enabled: true,
-      check: (file) => {
-        const ext = path.extname(file);
-        if (!['.js', '.jsx', '.ts', '.tsx', '.cjs', '.mjs', '.py', '.md', '.txt'].includes(ext)) {
-          return { pass: true, skip: true };
-        }
-        const content = fs.readFileSync(file, 'utf-8');
-        const lines = content.split('\n');
-        const trailing = [];
-        lines.forEach((line, i) => {
-          if (line !== line.trimEnd()) {
-            trailing.push(i + 1);
-          }
-        });
-        if (trailing.length > 0) {
-          return {
-            pass: false,
-            message: `Trailing whitespace on ${trailing.length} line(s)`,
-            fix: 'Run code formatter to fix',
-            autoFix: true
-          };
-        }
-        return { pass: true };
-      }
-    });
-
-    // Large function rule (basic)
-    this.register('function-length', {
-      name: 'Function Length Limit',
-      description: 'Functions should not exceed line limit',
-      category: 'complexity',
-      severity: 'warn',
-      enabled: false,
-      config: { maxLines: 50 },
-      check: (file, config) => {
-        const ext = path.extname(file);
-        if (!['.js', '.jsx', '.ts', '.tsx', '.cjs', '.mjs'].includes(ext)) {
-          return { pass: true, skip: true };
-        }
-        const content = fs.readFileSync(file, 'utf-8');
-        const maxLines = config.maxLines || 50;
-
-        // Simple function block detection
-        const functionPattern = /(?:function\s+\w+|const\s+\w+\s*=\s*(?:async\s*)?(?:\([^)]*\)\s*=>|\([^)]*\)\s*{))[\s\S]*?\n([\s\S]{30,})\n/g;
-        const matches = [...content.matchAll(functionPattern)];
-
-        if (matches.length > 0) {
-          return {
-            pass: false,
-            message: `Found ${matches.length} function(s) exceeding ${maxLines} lines`,
-            fix: 'Break large functions into smaller ones'
-          };
-        }
-        return { pass: true };
-      }
-    });
-  }
-}
-
-// Global registry instance
-const globalRegistry = new RuleRegistry();
-
-module.exports = {
-  RuleRegistry,
-  registry: globalRegistry,
-
-  // Convenience functions using global registry
-  register: (id, def) => globalRegistry.register(id, def),
-  get: (id) => globalRegistry.get(id),
-  has: (id) => globalRegistry.has(id),
-  getAll: (filter) => globalRegistry.getAll(filter),
-  setEnabled: (id, enabled) => globalRegistry.setEnabled(id, enabled),
-  updateConfig: (id, config) => globalRegistry.updateConfig(id, config),
-  loadFromFile: (path) => globalRegistry.loadFromFile(path)
-};

package/lib/utils.js

@@ -1,150 +0,0 @@
-/**
- * Utils - Common utility functions
- *
- * Extracted from cli.js to eliminate code duplication
- */
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Copy mode for template deployment
- */
-const CopyMode = {
-  SAFE: 'safe',        // Skip existing files (no overwrite, no backup)
-  BACKUP: 'backup',     // Backup then overwrite (default)
-  FORCE: 'force'        // Overwrite without backup
-};
-
-/**
- * Recursively copy directory contents with backup support
- * @param {string} src - Source directory
- * @param {string} dest - Destination directory
- * @param {boolean|string} mode - Copy mode: true/false (legacy) or CopyMode enum
- * @param {string} backupDir - Backup directory path
- * @returns {object} Copy result { copied, skipped, backedup }
- */
-exports.copyRecursive = function(src, dest, mode = CopyMode.BACKUP, backupDir = null) {
-  if (!fs.existsSync(src)) return { copied: 0, skipped: 0, backedup: 0 };
-
-  // Legacy support: convert boolean to CopyMode
-  if (typeof mode === 'boolean') {
-    mode = mode ? CopyMode.FORCE : CopyMode.SAFE;
-  }
-
-  if (!fs.existsSync(dest)) {
-    fs.mkdirSync(dest, { recursive: true });
-  }
-
-  const result = { copied: 0, skipped: 0, backedup: 0 };
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-
-    if (entry.isDirectory()) {
-      const subResult = exports.copyRecursive(
-        srcPath,
-        destPath,
-        mode,
-        backupDir ? path.join(backupDir, entry.name) : null
-      );
-      result.copied += subResult.copied;
-      result.skipped += subResult.skipped;
-      result.backedup += subResult.backedup;
-    } else {
-      const action = copyFile(srcPath, destPath, mode, backupDir);
-      result[action.type === 'copied' ? 'copied' : action.type]++;
-      if (action.type === 'backedup') {
-        result.copied++;
-        result.backedup++;
-      }
-    }
-  }
-  return result;
-};
-
-/**
- * Copy a single file with backup support
- * @param {string} srcPath - Source file path
- * @param {string} destPath - Destination file path
- * @param {string} mode - Copy mode
- * @param {string} backupDir - Backup directory path
- * @returns {object} Action result { type, backupPath }
- */
-function copyFile(srcPath, destPath, mode, backupDir) {
-  // File doesn't exist - just copy
-  if (!fs.existsSync(destPath)) {
-    fs.copyFileSync(srcPath, destPath);
-    setExecutablePermission(destPath);
-    return { type: 'copied' };
-  }
-
-  // File exists - handle based on mode
-  switch (mode) {
-    case CopyMode.SAFE:
-      // Skip existing files
-      return { type: 'skipped' };
-
-    case CopyMode.FORCE:
-      // Overwrite without backup
-      fs.copyFileSync(srcPath, destPath);
-      setExecutablePermission(destPath);
-      return { type: 'copied' };
-
-    case CopyMode.BACKUP:
-    default:
-      // Backup then overwrite
-      if (backupDir) {
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
-        const backupFileName = path.basename(destPath) + '.' + timestamp + '.bak';
-        const backupPath = path.join(backupDir, backupFileName);
-
-        fs.mkdirSync(backupDir, { recursive: true });
-        fs.copyFileSync(destPath, backupPath);
-        setExecutablePermission(backupPath);
-
-        fs.copyFileSync(srcPath, destPath);
-        setExecutablePermission(destPath);
-        return { type: 'backedup', backupPath };
-      } else {
-        // No backup dir, just overwrite
-        fs.copyFileSync(srcPath, destPath);
-        setExecutablePermission(destPath);
-        return { type: 'copied' };
-      }
-  }
-}
-
-/**
- * Set executable permission for script files
- * @param {string} filePath - File path
- */
-function setExecutablePermission(filePath) {
-  if (filePath.endsWith('.sh') || filePath.endsWith('.cjs')) {
-    fs.chmodSync(filePath, 0o755);
-  }
-}
-
-/**
- * Ensure a directory exists
- * @param {string} dir - Directory path
- */
-exports.ensureDir = function(dir) {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-};
-
-/**
- * Convert string to Title Case
- * @param {string} str - Input string
- * @returns {string} Title cased string
- */
-exports.toTitleCase = function(str) {
-  return str.replace(/\b\w/g, char => char.toUpperCase());
-};
-
-// Export CopyMode for use in other modules
-exports.CopyMode = CopyMode;

package/lib/version-check.js

@@ -1,169 +0,0 @@
-/**
- * Version Check - Check for updates from npm registry
- *
- * Implements lazy checking with local caching to minimize
- * network requests and performance impact.
- */
-
-const fs = require('fs');
-const path = require('path');
-const https = require('https');
-
-const CONFIG_DIR = path.join(process.env.HOME, '.claude');
-const CHECK_FILE = path.join(CONFIG_DIR, '.last-update-check');
-const ONE_DAY = 24 * 60 * 60 * 1000;
-
-// Current version from package.json
-const CURRENT_VERSION = require('../package.json').version;
-const PACKAGE_NAME = 'sumulige-claude';
-
-/**
- * Get timestamp of last update check
- * @returns {number} Timestamp of last check, or 0 if never checked
- */
-function getLastCheckTime() {
-  try {
-    const content = fs.readFileSync(CHECK_FILE, 'utf-8');
-    return parseInt(content, 10) || 0;
-  } catch {
-    return 0;
-  }
-}
-
-/**
- * Save timestamp of current update check
- * @param {number} timestamp - Timestamp to save
- */
-function saveLastCheckTime(timestamp = Date.now()) {
-  try {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    fs.writeFileSync(CHECK_FILE, timestamp.toString());
-  } catch {
-    // Ignore errors
-  }
-}
-
-/**
- * Fetch latest version from npm registry
- * @returns {Promise<string|null>} Latest version or null if failed
- */
-function fetchLatestVersion() {
-  return new Promise((resolve) => {
-    const options = {
-      hostname: 'registry.npmjs.org',
-      path: `/${PACKAGE_NAME}`,
-      timeout: 5000, // 5 second timeout
-      headers: {
-        'User-Agent': `${PACKAGE_NAME}/${CURRENT_VERSION}`
-      }
-    };
-
-    const req = https.get(options, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        try {
-          const pkg = JSON.parse(data);
-          resolve(pkg['dist-tags']?.latest || null);
-        } catch {
-          resolve(null);
-        }
-      });
-    });
-
-    req.on('error', () => resolve(null));
-    req.on('timeout', () => {
-      req.destroy();
-      resolve(null);
-    });
-    req.setTimeout(5000);
-  });
-}
-
-/**
- * Check for updates (with caching)
- * @param {Object} options - Check options
- * @param {boolean} options.force - Force check even if within cache period
- * @param {boolean} options.silent - Don't print messages
- * @returns {Promise<Object>} Check result { current, latest, updateAvailable }
- */
-async function checkUpdate(options = {}) {
-  const { force = false, silent = false } = options;
-  const now = Date.now();
-  const lastCheck = getLastCheckTime();
-  const shouldCheck = force || (now - lastCheck > ONE_DAY);
-
-  if (!shouldCheck) {
-    return {
-      current: CURRENT_VERSION,
-      latest: null,
-      updateAvailable: false,
-      cached: true
-    };
-  }
-
-  const latest = await fetchLatestVersion();
-  saveLastCheckTime(now);
-
-  // Only show update if remote version is NEWER than current
-  const updateAvailable = latest && compareVersions(latest, CURRENT_VERSION) > 0;
-  const result = {
-    current: CURRENT_VERSION,
-    latest,
-    updateAvailable,
-    cached: false
-  };
-
-  if (!silent && updateAvailable) {
-    console.log('');
-    console.log(`💡 新版本 v${latest} 可用 (当前: v${CURRENT_VERSION})`);
-    console.log(`   运行: npm update -g ${PACKAGE_NAME}`);
-    console.log('');
-  }
-
-  return result;
-}
-
-/**
- * Get current version
- * @returns {string} Current version
- */
-function getCurrentVersion() {
-  return CURRENT_VERSION;
-}
-
-/**
- * Parse version string to comparable array
- * @param {string} version - Version string (e.g., "1.2.3")
- * @returns {number[]} Comparable array [major, minor, patch]
- */
-function parseVersion(version) {
-  return version.split('.').map(Number).filter(n => !isNaN(n));
-}
-
-/**
- * Compare two versions
- * @param {string} v1 - First version
- * @param {string} v2 - Second version
- * @returns {number} -1 if v1 < v2, 0 if equal, 1 if v1 > v2
- */
-function compareVersions(v1, v2) {
-  const parts1 = parseVersion(v1);
-  const parts2 = parseVersion(v2);
-  const maxLen = Math.max(parts1.length, parts2.length);
-
-  for (let i = 0; i < maxLen; i++) {
-    const p1 = parts1[i] || 0;
-    const p2 = parts2[i] || 0;
-    if (p1 < p2) return -1;
-    if (p1 > p2) return 1;
-  }
-  return 0;
-}
-
-exports.checkUpdate = checkUpdate;
-exports.getCurrentVersion = getCurrentVersion;
-exports.compareVersions = compareVersions;
-exports.getLastCheckTime = getLastCheckTime;
-exports.saveLastCheckTime = saveLastCheckTime;
-exports.CURRENT_VERSION = CURRENT_VERSION;