ccsetup 1.1.1 → 1.2.0

package/lib/scanner/index.js

@@ -0,0 +1,164 @@
+const path = require('path');
+const fs = require('fs');
+const ProjectDetector = require('./projectDetector');
+const FileAnalyzer = require('./fileAnalyzer');
+
+class RepositoryScanner {
+  constructor(projectPath, options = {}) {
+    this.projectPath = path.resolve(projectPath);
+    this.options = {
+      maxFiles: 1000,
+      timeout: 30000,
+      respectGitignore: true,
+      maxFileSize: 1024 * 1024, // 1MB
+      maxDepth: options.maxDepth || options.depth || 5,
+      ignorePatterns: this.parseIgnorePatterns(options.ignorePatterns || options.ignore),
+      ...options
+    };
+    this.projectDetector = new ProjectDetector(this.projectPath);
+    this.fileAnalyzer = new FileAnalyzer(this.projectPath, this.options);
+  }
+
+  parseIgnorePatterns(patterns) {
+    if (!patterns) return [];
+    if (typeof patterns === 'string') {
+      return patterns.split(',').map(p => p.trim()).filter(Boolean);
+    }
+    if (Array.isArray(patterns)) {
+      return patterns.map(p => String(p).trim()).filter(Boolean);
+    }
+    return [];
+  }
+
+  shouldIgnorePath(filePath) {
+    const relativePath = path.relative(this.projectPath, filePath);
+    const depth = relativePath.split(path.sep).length;
+    
+    if (depth > this.options.maxDepth) {
+      return true;
+    }
+
+    for (const pattern of this.options.ignorePatterns) {
+      try {
+        const minimatch = require('minimatch');
+        if (minimatch(relativePath, pattern)) {
+          return true;
+        }
+      } catch (error) {
+        if (relativePath.includes(pattern)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  async scan(progressReporter = null) {
+    const startTime = Date.now();
+    
+    try {
+      if (progressReporter) {
+        progressReporter.start('Scanning repository...');
+      }
+
+      let projectType, structure, dependencies, commands, patterns;
+
+      if (progressReporter) {
+        progressReporter.phase('Analyzing project structure');
+        structure = await this.analyzeStructure();
+        progressReporter.phaseComplete('Analyzing project structure', `${structure.totalFiles || 0} files`);
+
+        progressReporter.phase('Detecting project type');
+        projectType = await this.detectProjectType();
+        progressReporter.phaseComplete('Detecting project type', projectType?.primary?.type || 'unknown');
+
+        progressReporter.phase('Extracting dependencies');
+        dependencies = await this.extractDependencies();
+        const depCount = dependencies?.runtime?.length || 0;
+        progressReporter.phaseComplete('Extracting dependencies', `${depCount} packages`);
+
+        progressReporter.phase('Extracting commands');
+        commands = await this.extractCommands();
+        const cmdCount = Object.values(commands || {}).reduce((sum, cmds) => sum + cmds.length, 0);
+        progressReporter.phaseComplete('Extracting commands', `${cmdCount} scripts`);
+
+        progressReporter.phase('Detecting patterns');
+        patterns = await this.detectPatterns();
+        const patternCount = Object.values(patterns || {}).reduce((sum, patterns) => sum + patterns.length, 0);
+        progressReporter.phaseComplete('Detecting patterns', `${patternCount} patterns`);
+      } else {
+        [projectType, structure, dependencies, commands, patterns] = await Promise.all([
+          this.detectProjectType(),
+          this.analyzeStructure(),
+          this.extractDependencies(),
+          this.extractCommands(),
+          this.detectPatterns()
+        ]);
+      }
+
+      const scanTime = Date.now() - startTime;
+      
+      const results = {
+        projectType,
+        structure,
+        dependencies,
+        commands,
+        patterns,
+        scanDate: new Date().toISOString(),
+        scanTimeMs: scanTime,
+        projectPath: this.projectPath
+      };
+
+      if (progressReporter) {
+        progressReporter.success('Repository scan completed');
+      }
+
+      return results;
+    } catch (error) {
+      if (progressReporter) {
+        progressReporter.fail(`Repository scan failed: ${error.message}`);
+      }
+      throw new Error(`Repository scan failed: ${error.message}`);
+    }
+  }
+
+  async detectProjectType() {
+    return await this.projectDetector.detect();
+  }
+
+  async analyzeStructure() {
+    return await this.fileAnalyzer.analyzeStructure();
+  }
+
+  async extractDependencies() {
+    return await this.fileAnalyzer.extractDependencies();
+  }
+
+  async extractCommands() {
+    return await this.fileAnalyzer.extractCommands();
+  }
+
+  async detectPatterns() {
+    return await this.fileAnalyzer.detectPatterns();
+  }
+
+  isValidProject() {
+    try {
+      const stats = fs.statSync(this.projectPath);
+      return stats.isDirectory();
+    } catch (error) {
+      return false;
+    }
+  }
+
+  static async quickScan(projectPath) {
+    const scanner = new RepositoryScanner(projectPath, {
+      maxFiles: 100,
+      timeout: 10000
+    });
+    return await scanner.scan();
+  }
+}
+
+module.exports = RepositoryScanner;

package/lib/scanner/patterns.js

@@ -0,0 +1,277 @@
+const PROJECT_TYPES = {
+  nodejs: {
+    indicators: [
+      { type: 'file', file: 'package.json', weight: 30 },
+      { type: 'file', file: 'package-lock.json', weight: 10 },
+      { type: 'file', file: 'yarn.lock', weight: 10 },
+      { type: 'directory', file: 'node_modules', weight: 20 },
+      { type: 'file', file: '.nvmrc', weight: 5 }
+    ]
+  },
+  python: {
+    indicators: [
+      { type: 'file', file: 'requirements.txt', weight: 25 },
+      { type: 'file', file: 'setup.py', weight: 20 },
+      { type: 'file', file: 'pyproject.toml', weight: 20 },
+      { type: 'file', file: 'Pipfile', weight: 15 },
+      { type: 'file', file: 'poetry.lock', weight: 10 },
+      { type: 'directory', file: 'venv', weight: 10 },
+      { type: 'directory', file: '.venv', weight: 10 }
+    ]
+  },
+  go: {
+    indicators: [
+      { type: 'file', file: 'go.mod', weight: 30 },
+      { type: 'file', file: 'go.sum', weight: 15 },
+      { type: 'file', file: 'main.go', weight: 20 },
+      { type: 'directory', file: 'cmd', weight: 10 },
+      { type: 'directory', file: 'pkg', weight: 10 }
+    ]
+  },
+  rust: {
+    indicators: [
+      { type: 'file', file: 'Cargo.toml', weight: 30 },
+      { type: 'file', file: 'Cargo.lock', weight: 15 },
+      { type: 'directory', file: 'src', weight: 20 },
+      { type: 'directory', file: 'target', weight: 10 }
+    ]
+  },
+  java: {
+    indicators: [
+      { type: 'file', file: 'pom.xml', weight: 25 },
+      { type: 'file', file: 'build.gradle', weight: 25 },
+      { type: 'file', file: 'settings.gradle', weight: 10 },
+      { type: 'directory', file: 'src/main/java', weight: 20 },
+      { type: 'directory', file: 'target', weight: 10 },
+      { type: 'directory', file: 'build', weight: 10 }
+    ]
+  },
+  csharp: {
+    indicators: [
+      { type: 'file', file: '*.csproj', weight: 30 },
+      { type: 'file', file: '*.sln', weight: 25 },
+      { type: 'directory', file: 'bin', weight: 10 },
+      { type: 'directory', file: 'obj', weight: 10 }
+    ]
+  },
+  php: {
+    indicators: [
+      { type: 'file', file: 'composer.json', weight: 25 },
+      { type: 'file', file: 'composer.lock', weight: 15 },
+      { type: 'directory', file: 'vendor', weight: 20 },
+      { type: 'file', file: 'index.php', weight: 15 }
+    ]
+  },
+  ruby: {
+    indicators: [
+      { type: 'file', file: 'Gemfile', weight: 25 },
+      { type: 'file', file: 'Gemfile.lock', weight: 15 },
+      { type: 'file', file: 'config.ru', weight: 20 },
+      { type: 'directory', file: 'app', weight: 15 }
+    ]
+  },
+  flutter: {
+    indicators: [
+      { type: 'file', file: 'pubspec.yaml', weight: 30 },
+      { type: 'file', file: 'pubspec.lock', weight: 10 },
+      { type: 'directory', file: 'lib', weight: 20 },
+      { type: 'directory', file: 'android', weight: 15 },
+      { type: 'directory', file: 'ios', weight: 15 }
+    ]
+  },
+  react: {
+    indicators: [
+      { type: 'content', file: 'package.json', pattern: '"react"', weight: 25 },
+      { type: 'directory', file: 'src', weight: 15 },
+      { type: 'directory', file: 'public', weight: 10 },
+      { type: 'file', file: 'src/App.js', weight: 20 },
+      { type: 'file', file: 'src/App.tsx', weight: 20 }
+    ]
+  },
+  vue: {
+    indicators: [
+      { type: 'content', file: 'package.json', pattern: '"vue"', weight: 25 },
+      { type: 'file', file: 'vue.config.js', weight: 15 },
+      { type: 'directory', file: 'src', weight: 15 },
+      { type: 'file', file: 'src/App.vue', weight: 20 }
+    ]
+  },
+  angular: {
+    indicators: [
+      { type: 'file', file: 'angular.json', weight: 30 },
+      { type: 'content', file: 'package.json', pattern: '"@angular/core"', weight: 25 },
+      { type: 'directory', file: 'src/app', weight: 20 },
+      { type: 'file', file: 'src/main.ts', weight: 15 }
+    ]
+  }
+};
+
+const FRAMEWORKS = {
+  nodejs: {
+    express: [
+      { type: 'content', file: 'package.json', pattern: '"express"' }
+    ],
+    nestjs: [
+      { type: 'content', file: 'package.json', pattern: '"@nestjs/core"' }
+    ],
+    fastify: [
+      { type: 'content', file: 'package.json', pattern: '"fastify"' }
+    ],
+    koa: [
+      { type: 'content', file: 'package.json', pattern: '"koa"' }
+    ],
+    next: [
+      { type: 'content', file: 'package.json', pattern: '"next"' },
+      { type: 'file', file: 'next.config.js' }
+    ],
+    nuxt: [
+      { type: 'content', file: 'package.json', pattern: '"nuxt"' },
+      { type: 'file', file: 'nuxt.config.js' }
+    ]
+  },
+  python: {
+    django: [
+      { type: 'content', file: 'requirements.txt', pattern: 'Django' },
+      { type: 'file', file: 'manage.py' }
+    ],
+    flask: [
+      { type: 'content', file: 'requirements.txt', pattern: 'Flask' }
+    ],
+    fastapi: [
+      { type: 'content', file: 'requirements.txt', pattern: 'fastapi' }
+    ]
+  },
+  go: {
+    gin: [
+      { type: 'content', file: 'go.mod', pattern: 'gin-gonic/gin' }
+    ],
+    echo: [
+      { type: 'content', file: 'go.mod', pattern: 'labstack/echo' }
+    ],
+    fiber: [
+      { type: 'content', file: 'go.mod', pattern: 'gofiber/fiber' }
+    ]
+  }
+};
+
+const BUILD_TOOLS = {
+  webpack: [
+    { type: 'file', file: 'webpack.config.js' },
+    { type: 'content', file: 'package.json', pattern: '"webpack"' }
+  ],
+  vite: [
+    { type: 'file', file: 'vite.config.js' },
+    { type: 'file', file: 'vite.config.ts' },
+    { type: 'content', file: 'package.json', pattern: '"vite"' }
+  ],
+  rollup: [
+    { type: 'file', file: 'rollup.config.js' },
+    { type: 'content', file: 'package.json', pattern: '"rollup"' }
+  ],
+  parcel: [
+    { type: 'content', file: 'package.json', pattern: '"parcel"' }
+  ],
+  esbuild: [
+    { type: 'content', file: 'package.json', pattern: '"esbuild"' }
+  ],
+  make: [
+    { type: 'file', file: 'Makefile' }
+  ],
+  cmake: [
+    { type: 'file', file: 'CMakeLists.txt' }
+  ],
+  gradle: [
+    { type: 'file', file: 'build.gradle' },
+    { type: 'file', file: 'settings.gradle' }
+  ],
+  maven: [
+    { type: 'file', file: 'pom.xml' }
+  ]
+};
+
+const KEY_FILES = [
+  'readme.md', 'readme.txt', 'readme.rst',
+  'license', 'license.txt', 'license.md',
+  'changelog.md', 'changelog.txt',
+  'contributing.md', 'contributing.txt',
+  'package.json', 'package-lock.json', 'yarn.lock',
+  'requirements.txt', 'setup.py', 'pyproject.toml',
+  'go.mod', 'go.sum',
+  'cargo.toml', 'cargo.lock',
+  'pom.xml', 'build.gradle',
+  'dockerfile', 'docker-compose.yml',
+  'makefile', 'cmakeLists.txt',
+  '.gitignore', '.env.example', '.env.template',
+  'tsconfig.json', 'jsconfig.json',
+  '.eslintrc.js', '.eslintrc.json',
+  '.prettierrc', 'prettier.config.js'
+];
+
+const CONFIG_FILES = [
+  /.*config\.(js|json|yaml|yml|toml)$/i,
+  /.*\.config\.(js|json|yaml|yml|toml)$/i,
+  /.*rc\.(js|json|yaml|yml)$/i,
+  /^\.(.*rc|.*config)$/i
+];
+
+const FRAMEWORK_PACKAGES = {
+  'express': 'Express.js',
+  '@nestjs/core': 'NestJS',
+  'fastify': 'Fastify',
+  'koa': 'Koa.js',
+  'next': 'Next.js',
+  'nuxt': 'Nuxt.js',
+  'react': 'React',
+  'vue': 'Vue.js',
+  '@angular/core': 'Angular',
+  'svelte': 'Svelte',
+  'solid-js': 'SolidJS',
+  'lit': 'Lit',
+  'astro': 'Astro',
+  'gatsby': 'Gatsby',
+  'remix': 'Remix',
+  'vite': 'Vite',
+  'webpack': 'Webpack',
+  'rollup': 'Rollup',
+  'parcel': 'Parcel',
+  'esbuild': 'esbuild',
+  'typescript': 'TypeScript',
+  'babel': 'Babel',
+  'eslint': 'ESLint',
+  'prettier': 'Prettier',
+  'jest': 'Jest',
+  'vitest': 'Vitest',
+  'cypress': 'Cypress',
+  'playwright': 'Playwright',
+  'storybook': 'Storybook',
+  'tailwindcss': 'Tailwind CSS',
+  'styled-components': 'Styled Components',
+  '@emotion/react': 'Emotion',
+  'sass': 'Sass',
+  'less': 'Less',
+  'prisma': 'Prisma',
+  'mongoose': 'Mongoose',
+  'sequelize': 'Sequelize',
+  'typeorm': 'TypeORM',
+  'apollo-server': 'Apollo Server',
+  'graphql': 'GraphQL',
+  'socket.io': 'Socket.IO',
+  'passport': 'Passport.js',
+  'jsonwebtoken': 'JWT',
+  'bcrypt': 'bcrypt',
+  'lodash': 'Lodash',
+  'moment': 'Moment.js',
+  'dayjs': 'Day.js',
+  'axios': 'Axios',
+  'got': 'Got',
+  'node-fetch': 'node-fetch'
+};
+
+module.exports = {
+  PROJECT_TYPES,
+  FRAMEWORKS,
+  BUILD_TOOLS,
+  KEY_FILES,
+  CONFIG_FILES,
+  FRAMEWORK_PACKAGES
+};

package/lib/scanner/projectDetector.js

@@ -0,0 +1,147 @@
+const fs = require('fs');
+const path = require('path');
+const patterns = require('./patterns');
+
+class ProjectDetector {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+
+  async detect() {
+    const detectionResults = [];
+
+    try {
+      for (const [projectType, config] of Object.entries(patterns.PROJECT_TYPES)) {
+        const confidence = await this.calculateConfidence(projectType, config);
+        if (confidence > 0) {
+          detectionResults.push({
+            type: projectType,
+            confidence,
+            indicators: config.indicators.filter(indicator => 
+              this.checkIndicator(indicator)
+            )
+          });
+        }
+      }
+
+      detectionResults.sort((a, b) => b.confidence - a.confidence);
+      
+      const primaryType = detectionResults[0] || { type: 'unknown', confidence: 0, indicators: [] };
+      const secondaryTypes = detectionResults.slice(1, 3);
+
+      return {
+        primary: primaryType,
+        secondary: secondaryTypes,
+        framework: await this.detectFramework(primaryType.type),
+        language: await this.detectLanguage(),
+        buildTools: await this.detectBuildTools()
+      };
+    } catch (error) {
+      return {
+        primary: { type: 'unknown', confidence: 0, indicators: [] },
+        secondary: [],
+        framework: null,
+        language: 'unknown',
+        buildTools: []
+      };
+    }
+  }
+
+  async calculateConfidence(projectType, config) {
+    let confidence = 0;
+    const maxConfidence = config.indicators.length * 10;
+
+    for (const indicator of config.indicators) {
+      if (this.checkIndicator(indicator)) {
+        confidence += indicator.weight || 10;
+      }
+    }
+
+    return Math.min(100, (confidence / maxConfidence) * 100);
+  }
+
+  checkIndicator(indicator) {
+    const filePath = path.join(this.projectPath, indicator.file);
+    
+    try {
+      if (indicator.type === 'file') {
+        return fs.existsSync(filePath);
+      } else if (indicator.type === 'directory') {
+        const stats = fs.statSync(filePath);
+        return stats.isDirectory();
+      } else if (indicator.type === 'content') {
+        if (!fs.existsSync(filePath)) return false;
+        const content = fs.readFileSync(filePath, 'utf8');
+        return indicator.pattern ? new RegExp(indicator.pattern).test(content) : true;
+      }
+    } catch (error) {
+      return false;
+    }
+    
+    return false;
+  }
+
+  async detectFramework(projectType) {
+    const frameworkPatterns = patterns.FRAMEWORKS[projectType];
+    if (!frameworkPatterns) return null;
+
+    for (const [framework, indicators] of Object.entries(frameworkPatterns)) {
+      let matches = 0;
+      for (const indicator of indicators) {
+        if (this.checkIndicator(indicator)) {
+          matches++;
+        }
+      }
+      if (matches > 0) {
+        return { name: framework, confidence: (matches / indicators.length) * 100 };
+      }
+    }
+
+    return null;
+  }
+
+  async detectLanguage() {
+    const languageIndicators = {
+      javascript: ['package.json', '*.js', '*.mjs'],
+      typescript: ['tsconfig.json', '*.ts', '*.tsx'],
+      python: ['requirements.txt', 'pyproject.toml', '*.py'],
+      go: ['go.mod', 'go.sum', '*.go'],
+      rust: ['Cargo.toml', 'Cargo.lock', '*.rs'],
+      java: ['pom.xml', 'build.gradle', '*.java'],
+      csharp: ['*.csproj', '*.sln'],
+      php: ['composer.json', '*.php'],
+      ruby: ['Gemfile', '*.rb'],
+      cpp: ['CMakeLists.txt', '*.cpp', '*.cc', '*.cxx'],
+      c: ['Makefile', '*.c', '*.h']
+    };
+
+    for (const [language, indicators] of Object.entries(languageIndicators)) {
+      for (const indicator of indicators) {
+        const fullPath = path.join(this.projectPath, indicator);
+        if (fs.existsSync(fullPath)) {
+          return language;
+        }
+      }
+    }
+
+    return 'unknown';
+  }
+
+  async detectBuildTools() {
+    const buildTools = [];
+    const buildToolPatterns = patterns.BUILD_TOOLS;
+
+    for (const [tool, indicators] of Object.entries(buildToolPatterns)) {
+      for (const indicator of indicators) {
+        if (this.checkIndicator(indicator)) {
+          buildTools.push(tool);
+          break;
+        }
+      }
+    }
+
+    return buildTools;
+  }
+}
+
+module.exports = ProjectDetector;