chati-dev 4.2.2 → 4.3.1

package/scripts/ide-sync.js

@@ -1,326 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * IDE Sync — Synchronizes agent files to IDE-specific locations.
- *
- * Exports:
- *   IDE_CONFIGS — Map of IDE names to their config.
- *   syncToIDE(targetDir, frameworkDir, ideName) → { synced: number, files: [] }
- *   syncAllIDEs(targetDir, frameworkDir, installedIDEs) → { results: { ide: syncResult } }
- *   detectInstalledIDEs(targetDir) → string[]
- *   buildIDEContent(agentContent, format, agentName) → transformed content
- */
-
-import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from 'fs';
-import { join, basename, relative } from 'path';
-
-/**
- * IDE configuration definitions.
- */
-export const IDE_CONFIGS = {
-  'claude-code': {
-    commandDir: '.claude/commands/',
-    extension: '.md',
-    format: 'markdown',
-    description: 'Claude Code (Anthropic)',
-  },
-  cursor: {
-    rulesDir: '.cursor/rules/',
-    extension: '.mdc',
-    format: 'cursor-rules',
-    description: 'Cursor',
-  },
-  windsurf: {
-    rulesDir: '.windsurf/rules/',
-    extension: '.md',
-    format: 'markdown',
-    description: 'Windsurf',
-  },
-  vscode: {
-    configDir: '.vscode/',
-    extension: '.md',
-    format: 'markdown',
-    description: 'Visual Studio Code',
-  },
-  antigravity: {
-    agentsDir: '.antigravity/agents/',
-    extension: '.md',
-    format: 'markdown',
-    description: 'AntiGravity',
-  },
-  'gemini-cli': {
-    commandDir: '.gemini/commands/',
-    extension: '.toml',
-    format: 'toml',
-    description: 'Gemini CLI',
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Internal Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Collect all agent .md files from the framework directory.
- * @param {string} frameworkDir - Path to the framework directory.
- * @returns {object[]} Array of { name, path, content }.
- */
-function collectAgentFiles(frameworkDir) {
-  const agents = [];
-
-  // Collect agents from subdirectories
-  const agentsDir = join(frameworkDir, 'agents');
-  if (existsSync(agentsDir)) {
-    const categories = readdirSync(agentsDir, { withFileTypes: true })
-      .filter(e => e.isDirectory())
-      .map(e => e.name);
-
-    for (const category of categories) {
-      const catDir = join(agentsDir, category);
-      try {
-        const files = readdirSync(catDir).filter(f => f.endsWith('.md'));
-        for (const file of files) {
-          const fullPath = join(catDir, file);
-          agents.push({
-            name: basename(file, '.md'),
-            path: fullPath,
-            content: readFileSync(fullPath, 'utf8'),
-            category,
-          });
-        }
-      } catch {
-        // Skip unreadable directories
-      }
-    }
-  }
-
-  // Collect orchestrator
-  const orchPath = join(frameworkDir, 'orchestrator', 'chati.md');
-  if (existsSync(orchPath)) {
-    agents.push({
-      name: 'chati',
-      path: orchPath,
-      content: readFileSync(orchPath, 'utf8'),
-      category: 'orchestrator',
-    });
-  }
-
-  return agents;
-}
-
-/**
- * Get the target directory path for a specific IDE.
- * @param {string} targetDir - Project root directory.
- * @param {string} ideName - IDE identifier.
- * @returns {string} Target directory for sync.
- */
-function getIDETargetDir(targetDir, ideName) {
-  const config = IDE_CONFIGS[ideName];
-  if (!config) return null;
-
-  // Pick the first defined directory key
-  const dirKey = config.commandDir || config.rulesDir || config.configDir
-    || config.agentsDir || config.instructionsDir;
-
-  return join(targetDir, dirKey);
-}
-
-/**
- * Transform agent markdown content for a specific IDE format.
- * @param {string} agentContent - Raw agent markdown content.
- * @param {string} format - Target format ('markdown' | 'cursor-rules').
- * @param {string} agentName - Agent name for metadata.
- * @returns {string} Transformed content.
- */
-export function buildIDEContent(agentContent, format, agentName = '') {
-  switch (format) {
-    case 'cursor-rules': {
-      // Cursor uses .mdc format with YAML-like frontmatter
-      const lines = [
-        '---',
-        `description: chati.dev agent — ${agentName}`,
-        'globs:',
-        'alwaysApply: false',
-        '---',
-        '',
-        agentContent,
-      ];
-      return lines.join('\n');
-    }
-
-    case 'toml': {
-      // Gemini CLI uses TOML format for commands
-      return `description = "chati.dev agent — ${agentName}"\n\nprompt = """\n${agentContent}\n"""\n`;
-    }
-
-    case 'markdown':
-    default:
-      return agentContent;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Detect which IDEs have existing config directories in the project.
- * @param {string} targetDir - Project root directory.
- * @returns {string[]} Array of detected IDE names.
- */
-export function detectInstalledIDEs(targetDir) {
-  const detected = [];
-
-  for (const [ideName, config] of Object.entries(IDE_CONFIGS)) {
-    const dirKey = config.commandDir || config.rulesDir || config.configDir
-      || config.agentsDir || config.instructionsDir;
-    const checkDir = dirKey.split('/')[0]; // Check first directory component
-
-    if (existsSync(join(targetDir, checkDir))) {
-      detected.push(ideName);
-    }
-  }
-
-  return detected;
-}
-
-/**
- * Sync agent files to a specific IDE's location.
- * @param {string} targetDir - Project root directory.
- * @param {string} frameworkDir - Path to the framework directory.
- * @param {string} ideName - IDE identifier.
- * @returns {{ synced: number, files: string[], errors: string[] }}
- */
-export function syncToIDE(targetDir, frameworkDir, ideName) {
-  const config = IDE_CONFIGS[ideName];
-  if (!config) {
-    return { synced: 0, files: [], errors: [`Unknown IDE: ${ideName}`] };
-  }
-
-  const result = { synced: 0, files: [], errors: [] };
-
-  const ideTargetDir = getIDETargetDir(targetDir, ideName);
-  if (!ideTargetDir) {
-    result.errors.push(`Cannot determine target directory for ${ideName}`);
-    return result;
-  }
-
-  // Collect agent files
-  const agents = collectAgentFiles(frameworkDir);
-  if (agents.length === 0) {
-    result.errors.push('No agent files found in framework directory');
-    return result;
-  }
-
-  // Create target directory
-  mkdirSync(ideTargetDir, { recursive: true });
-
-  // Sync each agent
-  for (const agent of agents) {
-    const targetFileName = `${agent.name}${config.extension}`;
-    const targetPath = join(ideTargetDir, targetFileName);
-
-    try {
-      const content = buildIDEContent(agent.content, config.format, agent.name);
-      writeFileSync(targetPath, content, 'utf8');
-      result.synced++;
-      result.files.push(relative(targetDir, targetPath));
-    } catch (err) {
-      result.errors.push(`Failed to write ${targetFileName}: ${err.message}`);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Sync agent files to all specified IDEs.
- * @param {string} targetDir - Project root directory.
- * @param {string} frameworkDir - Path to the framework directory.
- * @param {string[]} installedIDEs - List of IDE names to sync to.
- * @returns {{ results: object, totalSynced: number, totalErrors: number }}
- */
-export function syncAllIDEs(targetDir, frameworkDir, installedIDEs) {
-  const results = {};
-  let totalSynced = 0;
-  let totalErrors = 0;
-
-  for (const ide of installedIDEs) {
-    const result = syncToIDE(targetDir, frameworkDir, ide);
-    results[ide] = result;
-    totalSynced += result.synced;
-    totalErrors += result.errors.length;
-  }
-
-  return { results, totalSynced, totalErrors };
-}
-
-/**
- * Format sync results as a human-readable string.
- * @param {object} syncResults - Results from syncAllIDEs.
- * @returns {string}
- */
-export function formatSyncReport(syncResults) {
-  const lines = [
-    '=== IDE Sync Report ===',
-    `Total synced: ${syncResults.totalSynced} files`,
-    `Total errors: ${syncResults.totalErrors}`,
-    '',
-  ];
-
-  for (const [ide, result] of Object.entries(syncResults.results)) {
-    const config = IDE_CONFIGS[ide];
-    const desc = config?.description || ide;
-    const symbol = result.errors.length === 0 ? '[OK]' : '[WARN]';
-
-    lines.push(`  ${symbol} ${desc}: ${result.synced} files synced`);
-    for (const file of result.files) {
-      lines.push(`        ${file}`);
-    }
-    for (const err of result.errors) {
-      lines.push(`        ERROR: ${err}`);
-    }
-  }
-
-  lines.push('');
-  lines.push('=== End Report ===');
-  return lines.join('\n');
-}
-
-// ---------------------------------------------------------------------------
-// CLI entrypoint
-// ---------------------------------------------------------------------------
-
-const isMainModule = process.argv[1] && (
-  process.argv[1].endsWith('ide-sync.js') ||
-  process.argv[1].endsWith('ide-sync')
-);
-
-if (isMainModule) {
-  const targetDir = process.argv[2] || process.cwd();
-  const frameworkDir = process.argv[3] || join(targetDir, 'chati.dev');
-  const specificIDE = process.argv[4];
-
-  if (specificIDE) {
-    console.log(`Syncing to ${specificIDE}...`);
-    const result = syncToIDE(targetDir, frameworkDir, specificIDE);
-    console.log(`Synced: ${result.synced} files`);
-    for (const file of result.files) console.log(`  ${file}`);
-    if (result.errors.length > 0) {
-      for (const err of result.errors) console.log(`  ERROR: ${err}`);
-    }
-  } else {
-    console.log('Detecting installed IDEs...');
-    const detected = detectInstalledIDEs(targetDir);
-
-    if (detected.length === 0) {
-      console.log('No IDE configurations detected. Specify IDE: node scripts/ide-sync.js <targetDir> <frameworkDir> <ideName>');
-      console.log(`Available: ${Object.keys(IDE_CONFIGS).join(', ')}`);
-      process.exit(0);
-    }
-
-    console.log(`Detected: ${detected.join(', ')}`);
-    const results = syncAllIDEs(targetDir, frameworkDir, detected);
-    console.log(formatSyncReport(results));
-  }
-}

package/scripts/performance-analyzer.js

@@ -1,325 +0,0 @@
-/**
- * Performance Analyzer — Static analysis of code patterns that affect performance.
- *
- * Scans source files for large files, deep nesting, long functions,
- * excessive imports, and synchronous filesystem operations.
- *
- * @module scripts/performance-analyzer
- */
-
-import { readFileSync, readdirSync, statSync } from 'node:fs';
-import { join, extname } from 'node:path';
-
-/**
- * @typedef {Object} ComplexityResult
- * @property {number} cyclomaticComplexity
- * @property {number} nestingDepth
- * @property {Array<{ name: string, lines: number }>} functionLengths
- */
-
-/**
- * @typedef {Object} FilePerformanceReport
- * @property {string} filePath
- * @property {number} lineCount
- * @property {number} importCount
- * @property {ComplexityResult} complexity
- * @property {boolean} hasSyncFsOps
- * @property {string[]} warnings
- * @property {string[]} errors
- */
-
-/**
- * @typedef {Object} PerformanceReport
- * @property {FilePerformanceReport[]} files
- * @property {{ totalFiles: number, totalWarnings: number, totalErrors: number }} summary
- */
-
-// Thresholds
-const THRESHOLDS = {
-  fileSizeWarning: 500,
-  fileSizeError: 1000,
-  nestingDepth: 4,
-  functionLength: 50,
-  importCount: 15,
-  cyclomaticComplexityWarning: 10,
-  cyclomaticComplexityError: 20,
-};
-
-// Sync fs methods that should be avoided in non-script files
-const SYNC_FS_PATTERN = /\b(?:readFileSync|writeFileSync|appendFileSync|mkdirSync|rmdirSync|unlinkSync|renameSync|copyFileSync|readdirSync|statSync|lstatSync|existsSync|accessSync)\b/g;
-
-/**
- * Collects JS/TS source files recursively (excludes tests, node_modules, .git).
- * @param {string} dir
- * @returns {string[]}
- */
-function collectSourceFiles(dir) {
-  const results = [];
-  const sourceExtensions = new Set(['.js', '.ts', '.mjs', '.mts']);
-
-  function walk(currentDir) {
-    let entries;
-    try {
-      entries = readdirSync(currentDir);
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry === 'node_modules' || entry === '.git' || entry === 'dist' || entry === 'build') continue;
-      const fullPath = join(currentDir, entry);
-      let stat;
-      try {
-        stat = statSync(fullPath);
-      } catch {
-        continue;
-      }
-      if (stat.isDirectory()) {
-        walk(fullPath);
-      } else if (stat.isFile() && sourceExtensions.has(extname(entry))) {
-        // Skip test files
-        if (entry.endsWith('.test.js') || entry.endsWith('.spec.js') ||
-            entry.endsWith('.test.ts') || entry.endsWith('.spec.ts')) {
-          continue;
-        }
-        results.push(fullPath);
-      }
-    }
-  }
-
-  walk(dir);
-  return results.sort();
-}
-
-/**
- * Calculates code complexity metrics for a given source string.
- *
- * @param {string} code
- * @returns {ComplexityResult}
- */
-export function calculateComplexity(code) {
-  const lines = code.split('\n');
-
-  // Cyclomatic complexity: count decision points
-  const decisionPatterns = [
-    /\bif\s*\(/g,
-    /\belse\s+if\s*\(/g,
-    /\bfor\s*\(/g,
-    /\bwhile\s*\(/g,
-    /\bswitch\s*\(/g,
-    /\bcase\s+/g,
-    /\bcatch\s*\(/g,
-    /\?\s*[^:]/g, // ternary
-    /&&/g,
-    /\|\|/g,
-  ];
-
-  let cyclomaticComplexity = 1; // base complexity
-  for (const pattern of decisionPatterns) {
-    const matches = code.match(pattern);
-    if (matches) cyclomaticComplexity += matches.length;
-    pattern.lastIndex = 0;
-  }
-
-  // Max nesting depth
-  let maxNesting = 0;
-  let currentNesting = 0;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    // Skip comments and strings (simple heuristic)
-    if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*')) continue;
-
-    const opens = (trimmed.match(/\{/g) || []).length;
-    const closes = (trimmed.match(/\}/g) || []).length;
-    currentNesting += opens - closes;
-    if (currentNesting > maxNesting) maxNesting = currentNesting;
-    if (currentNesting < 0) currentNesting = 0;
-  }
-
-  // Function lengths
-  const functionLengths = [];
-  const funcStartRegex = /(?:(?:export\s+)?(?:async\s+)?function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>|(\w+)\s*\([^)]*\)\s*\{)/;
-
-  let funcName = null;
-  let funcStartLine = 0;
-  let braceDepth = 0;
-  let inFunction = false;
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const trimmed = line.trim();
-
-    if (!inFunction) {
-      const match = trimmed.match(funcStartRegex);
-      if (match) {
-        funcName = match[1] || match[2] || match[3] || 'anonymous';
-        funcStartLine = i;
-        inFunction = true;
-        braceDepth = 0;
-      }
-    }
-
-    if (inFunction) {
-      const opens = (trimmed.match(/\{/g) || []).length;
-      const closes = (trimmed.match(/\}/g) || []).length;
-      braceDepth += opens - closes;
-
-      if (braceDepth <= 0 && i > funcStartLine) {
-        const length = i - funcStartLine + 1;
-        functionLengths.push({ name: funcName, lines: length });
-        inFunction = false;
-        funcName = null;
-      }
-    }
-  }
-
-  return {
-    cyclomaticComplexity,
-    nestingDepth: maxNesting,
-    functionLengths,
-  };
-}
-
-/**
- * Analyzes a single file for performance-related patterns.
- *
- * @param {string} filePath
- * @returns {FilePerformanceReport}
- */
-export function analyzeFile(filePath) {
-  let content;
-  try {
-    content = readFileSync(filePath, 'utf-8');
-  } catch (err) {
-    return {
-      filePath,
-      lineCount: 0,
-      importCount: 0,
-      complexity: { cyclomaticComplexity: 0, nestingDepth: 0, functionLengths: [] },
-      hasSyncFsOps: false,
-      warnings: [`Cannot read file: ${err.message}`],
-      errors: [],
-    };
-  }
-
-  const lines = content.split('\n');
-  const lineCount = lines.length;
-  const warnings = [];
-  const errors = [];
-
-  // Count imports
-  const importMatches = content.match(/\b(?:import\s+|require\s*\()/g) || [];
-  const importCount = importMatches.length;
-
-  // Check sync fs operations (only flag in non-script files)
-  const isScript = filePath.includes('/scripts/') || filePath.includes('/bin/');
-  const syncMatches = content.match(SYNC_FS_PATTERN) || [];
-  const hasSyncFsOps = syncMatches.length > 0;
-
-  // Calculate complexity
-  const complexity = calculateComplexity(content);
-
-  // Generate warnings and errors
-  if (lineCount > THRESHOLDS.fileSizeError) {
-    errors.push(`File has ${lineCount} lines (threshold: ${THRESHOLDS.fileSizeError})`);
-  } else if (lineCount > THRESHOLDS.fileSizeWarning) {
-    warnings.push(`File has ${lineCount} lines (threshold: ${THRESHOLDS.fileSizeWarning})`);
-  }
-
-  if (complexity.nestingDepth > THRESHOLDS.nestingDepth) {
-    warnings.push(`Max nesting depth: ${complexity.nestingDepth} (threshold: ${THRESHOLDS.nestingDepth})`);
-  }
-
-  if (importCount > THRESHOLDS.importCount) {
-    warnings.push(`${importCount} imports (threshold: ${THRESHOLDS.importCount})`);
-  }
-
-  if (hasSyncFsOps && !isScript) {
-    warnings.push(`${syncMatches.length} synchronous filesystem operation(s) in non-script file`);
-  }
-
-  for (const func of complexity.functionLengths) {
-    if (func.lines > THRESHOLDS.functionLength) {
-      warnings.push(`Function "${func.name}" is ${func.lines} lines (threshold: ${THRESHOLDS.functionLength})`);
-    }
-  }
-
-  if (complexity.cyclomaticComplexity > THRESHOLDS.cyclomaticComplexityError) {
-    errors.push(`Cyclomatic complexity: ${complexity.cyclomaticComplexity} (threshold: ${THRESHOLDS.cyclomaticComplexityError})`);
-  } else if (complexity.cyclomaticComplexity > THRESHOLDS.cyclomaticComplexityWarning) {
-    warnings.push(`Cyclomatic complexity: ${complexity.cyclomaticComplexity} (threshold: ${THRESHOLDS.cyclomaticComplexityWarning})`);
-  }
-
-  return {
-    filePath,
-    lineCount,
-    importCount,
-    complexity,
-    hasSyncFsOps,
-    warnings,
-    errors,
-  };
-}
-
-/**
- * Analyzes all source files in a directory.
- *
- * @param {string} srcDir
- * @returns {PerformanceReport}
- */
-export function analyzePerformance(srcDir) {
-  const sourceFiles = collectSourceFiles(srcDir);
-  const files = sourceFiles.map((f) => analyzeFile(f));
-
-  const totalWarnings = files.reduce((s, f) => s + f.warnings.length, 0);
-  const totalErrors = files.reduce((s, f) => s + f.errors.length, 0);
-
-  return {
-    files,
-    summary: {
-      totalFiles: files.length,
-      totalWarnings,
-      totalErrors,
-    },
-  };
-}
-
-/**
- * Formats the performance report as a human-readable string.
- *
- * @param {PerformanceReport} report
- * @returns {string}
- */
-export function formatPerformanceReport(report) {
-  const lines = [];
-
-  lines.push('=== Performance Analysis Report ===');
-  lines.push('');
-  lines.push(`Files analyzed  : ${report.summary.totalFiles}`);
-  lines.push(`Total warnings  : ${report.summary.totalWarnings}`);
-  lines.push(`Total errors    : ${report.summary.totalErrors}`);
-  lines.push('');
-
-  const filesWithIssues = report.files.filter(
-    (f) => f.warnings.length > 0 || f.errors.length > 0
-  );
-
-  if (filesWithIssues.length === 0) {
-    lines.push('No performance issues detected.');
-    return lines.join('\n');
-  }
-
-  for (const file of filesWithIssues) {
-    lines.push(`--- ${file.filePath} ---`);
-    lines.push(`  Lines: ${file.lineCount} | Imports: ${file.importCount} | Complexity: ${file.complexity.cyclomaticComplexity} | Nesting: ${file.complexity.nestingDepth}`);
-
-    for (const err of file.errors) {
-      lines.push(`  [ERR] ${err}`);
-    }
-    for (const warn of file.warnings) {
-      lines.push(`  [WRN] ${warn}`);
-    }
-    lines.push('');
-  }
-
-  return lines.join('\n');
-}