project-compass 4.2.1 → 4.3.0

package/src/detectors/go.js

@@ -1,5 +1,72 @@
+import fs from 'fs';
 import path from 'path';
-import { checkBinary } from './utils.js';
+import { checkBinary, hasProjectFile } from './utils.js';
+
+function parseGoMod(content) {
+  const metadata = {
+    module: '',
+    goVersion: '',
+    dependencies: []
+  };
+  
+  const lines = content.split('\n');
+  let inRequire = false;
+  
+  for (const line of lines) {
+    const trimmed = line.trim();
+    
+    if (trimmed.startsWith('module ')) {
+      metadata.module = trimmed.split(/\s+/)[1]?.replace(/"/g, '') || '';
+    }
+    if (trimmed.startsWith('go ')) {
+      metadata.goVersion = trimmed.split(/\s+/)[1] || '';
+    }
+    
+    if (trimmed === 'require (') {
+      inRequire = true;
+      continue;
+    }
+    if (trimmed === ')') {
+      inRequire = false;
+      continue;
+    }
+    
+    if (inRequire || (trimmed.includes(' ') && !trimmed.startsWith('//'))) {
+      const parts = trimmed.split(/\s+/);
+      if (parts[0] && !parts[0].startsWith('//')) {
+        metadata.dependencies.push(parts[0].replace(/"/g, ''));
+      }
+    }
+  }
+  
+  return metadata;
+}
+
+function detectGoFrameworks(deps) {
+  const frameworks = [];
+  const depStr = deps.join(' ').toLowerCase();
+  
+  if (depStr.includes('gin') || depStr.includes('gin-gonic')) frameworks.push({ name: 'Gin', icon: '🍸' });
+  if (depStr.includes('echo') || depStr.includes('labstack/echo')) frameworks.push({ name: 'Echo', icon: '🔊' });
+  if (depStr.includes('fiber') || depStr.includes('gofiber')) frameworks.push({ name: 'Fiber', icon: '🔥' });
+  if (depStr.includes('chi')) frameworks.push({ name: 'Chi', icon: '🤝' });
+  if (depStr.includes('gorilla')) frameworks.push({ name: 'Gorilla', icon: '🦍' });
+  if (depStr.includes('iris')) frameworks.push({ name: 'Iris', icon: '🌺' });
+  if (depStr.includes('beego')) frameworks.push({ name: 'Beego', icon: '🐝' });
+  if (depStr.includes('revel')) frameworks.push({ name: 'Revel', icon: '🎉' });
+  if (depStr.includes('gqlgen')) frameworks.push({ name: 'GQLGen', icon: '◼️' });
+  if (depStr.includes('grpc')) frameworks.push({ name: 'gRPC', icon: '🔌' });
+  
+  return frameworks;
+}
+
+function findGoEntry(projectPath) {
+  const possibleEntries = ['main.go', 'cmd/main.go', 'app.go', 'server.go'];
+  for (const entry of possibleEntries) {
+    if (hasProjectFile(projectPath, entry)) return entry;
+  }
+  return 'main.go';
+}
 
 export default {
   type: 'go',
@@ -10,25 +77,59 @@ export default {
   binaries: ['go'],
   async build(projectPath, manifest) {
     const missingBinaries = this.binaries.filter(b => !checkBinary(b));
+    let metadata = { module: '', goVersion: '', dependencies: [] };
+    let frameworks = [];
+    let entryPoint = 'main.go';
+    
+    const goModPath = path.join(projectPath, 'go.mod');
+    if (fs.existsSync(goModPath)) {
+      const content = fs.readFileSync(goModPath, 'utf-8');
+      metadata = parseGoMod(content);
+      frameworks = detectGoFrameworks(metadata.dependencies);
+    }
+    
+    entryPoint = findGoEntry(projectPath);
+    
+    const commands = {
+      install: { label: 'Go tidy', command: ['go', 'mod', 'tidy'], source: 'builtin' },
+      build: { label: 'Go build', command: ['go', 'build', '-o', 'app', '.'], source: 'builtin' },
+      test: { label: 'Go test', command: ['go', 'test', './...'], source: 'builtin' },
+      run: { label: 'Go run', command: ['go', 'run', entryPoint], source: 'builtin' },
+      fmt: { label: 'Go fmt', command: ['go', 'fmt', './...'], source: 'builtin' },
+      vet: { label: 'Go vet', command: ['go', 'vet', './...'], source: 'builtin' }
+    };
+
+    const setupHints = [];
+    if (missingBinaries.length > 0) {
+      setupHints.push('Install Go from https://go.dev/dl/');
+    }
+    if (metadata.dependencies.length > 0) {
+      setupHints.push('Run go mod tidy to ensure dependencies');
+    }
+    if (metadata.goVersion) {
+      setupHints.push(`Requires Go ${metadata.goVersion}+`);
+    }
+
     return {
       id: `${projectPath}::go`,
       path: projectPath,
-      name: path.basename(projectPath),
+      name: metadata.module || path.basename(projectPath),
       type: 'Go',
       icon: '🐹',
       priority: this.priority,
-      commands: {
-        install: { label: 'Go tidy', command: ['go', 'mod', 'tidy'] },
-        build: { label: 'Go build', command: ['go', 'build', './...'] },
-        test: { label: 'Go test', command: ['go', 'test', './...'] },
-        run: { label: 'Go run', command: ['go', 'run', '.'] }
+      commands,
+      metadata: {
+        ...metadata,
+        packageManager: 'go',
+        entryPoint
       },
-      metadata: {},
       manifest: path.basename(manifest),
-      description: '',
+      description: frameworks.map(f => f.name).join(', ') || `Go ${metadata.goVersion || ''}`,
       missingBinaries,
+      frameworks,
       extra: {
-        setupHints: ['go mod tidy', 'Ensure Go toolchain is installed']
+        setupHints,
+        entryPoint
       }
     };
   }

package/src/detectors/java.js

@@ -1,6 +1,79 @@
+import fs from 'fs';
 import path from 'path';
 import { checkBinary, hasProjectFile } from './utils.js';
 
+function parsePomXml(content) {
+  const metadata = {
+    groupId: '',
+    artifactId: '',
+    version: '',
+    name: '',
+    description: '',
+    dependencies: []
+  };
+  
+  const groupIdMatch = content.match(/<groupId>([^<]+)<\/groupId>/);
+  if (groupIdMatch) metadata.groupId = groupIdMatch[1];
+  
+  const artifactIdMatch = content.match(/<artifactId>([^<]+)<\/artifactId>/);
+  if (artifactIdMatch) metadata.artifactId = artifactIdMatch[1];
+  
+  const versionMatch = content.match(/<version>([^<]+)<\/version>/);
+  if (versionMatch) metadata.version = versionMatch[1];
+  
+  const nameMatch = content.match(/<name>([^<]+)<\/name>/);
+  if (nameMatch) metadata.name = nameMatch[1];
+  
+  const descMatch = content.match(/<description>([^<]+)<\/description>/);
+  if (descMatch) metadata.description = descMatch[1];
+  
+  const depMatches = content.matchAll(/<dependency>[\s\S]*?<artifactId>([^<]+)<\/artifactId>[\s\S]*?<\/dependency>/g);
+  for (const match of depMatches) {
+    if (match[1]) metadata.dependencies.push(match[1]);
+  }
+  
+  return metadata;
+}
+
+function parseGradleBuild(content) {
+  const metadata = {
+    name: '',
+    version: '',
+    description: '',
+    dependencies: []
+  };
+  
+  const nameMatch = content.match(/rootProject\.name\s*=\s*['"]([^'"]+)['"]/);
+  if (nameMatch) metadata.name = nameMatch[1];
+  
+  const versionMatch = content.match(/version\s*=\s*['"]([^'"]+)['"]/);
+  if (versionMatch) metadata.version = versionMatch[1];
+  
+  const depMatches = content.matchAll(/implementation\s+['"]([^'"]+)['"]/g);
+  for (const match of depMatches) {
+    if (match[1]) metadata.dependencies.push(match[1].split(':')[1] || match[1]);
+  }
+  
+  return metadata;
+}
+
+function detectJavaFrameworks(deps) {
+  const frameworks = [];
+  const depStr = deps.join(' ').toLowerCase();
+  
+  if (depStr.includes('spring-boot') || depStr.includes('springframework')) frameworks.push({ name: 'Spring Boot', icon: '🍃' });
+  if (depStr.includes('quarkus')) frameworks.push({ name: 'Quarkus', icon: '⚡' });
+  if (depStr.includes('micronaut')) frameworks.push({ name: 'Micronaut', icon: '🚀' });
+  if (depStr.includes('play')) frameworks.push({ name: 'Play Framework', icon: '🎭' });
+  if (depStr.includes('vertx')) frameworks.push({ name: 'Vert.x', icon: '🔋' });
+  if (depStr.includes('dropwizard')) frameworks.push({ name: 'Dropwizard', icon: '📊' });
+  if (depStr.includes(('hibernate'))) frameworks.push({ name: 'Hibernate', icon: '🗄️' });
+  if (depStr.includes('junit')) frameworks.push({ name: 'JUnit', icon: '✅' });
+  if (depStr.includes('lombok')) frameworks.push({ name: 'Lombok', icon: '🔧' });
+  
+  return frameworks;
+}
+
 export default {
   type: 'java',
   label: 'Java',
@@ -12,34 +85,76 @@ export default {
     const missingBinaries = this.binaries.filter(b => !checkBinary(b));
     const hasMvnw = hasProjectFile(projectPath, 'mvnw');
     const hasGradlew = hasProjectFile(projectPath, 'gradlew');
+    const isMaven = hasProjectFile(projectPath, 'pom.xml');
+    const isGradle = hasProjectFile(projectPath, 'build.gradle') || hasProjectFile(projectPath, 'build.gradle.kts');
+    
+    let metadata = { name: '', version: '', description: '', dependencies: [] };
+    let frameworks = [];
+    let buildTool = isGradle ? 'gradle' : 'maven';
+    
+    if (isMaven) {
+      const pomPath = path.join(projectPath, 'pom.xml');
+      if (fs.existsSync(pomPath)) {
+        const content = fs.readFileSync(pomPath, 'utf-8');
+        metadata = parsePomXml(content);
+        frameworks = detectJavaFrameworks(metadata.dependencies);
+      }
+    } else if (isGradle) {
+      const gradleFile = hasProjectFile(projectPath, 'build.gradle.kts') ? 'build.gradle.kts' : 'build.gradle';
+      const gradlePath = path.join(projectPath, gradleFile);
+      if (fs.existsSync(gradlePath)) {
+        const content = fs.readFileSync(gradlePath, 'utf-8');
+        metadata = parseGradleBuild(content);
+        frameworks = detectJavaFrameworks(metadata.dependencies);
+      }
+    }
+    
     const commands = {};
-    if (hasGradlew) {
-      commands.install = { label: 'Gradle resolve', command: ['./gradlew', 'dependencies'] };
-      commands.build = { label: 'Gradle build', command: ['./gradlew', 'build'] };
-      commands.test = { label: 'Gradle test', command: ['./gradlew', 'test'] };
-    } else if (hasMvnw) {
-      commands.install = { label: 'Maven install', command: ['./mvnw', 'install'] };
-      commands.build = { label: 'Maven package', command: ['./mvnw', 'package'] };
-      commands.test = { label: 'Maven test', command: ['./mvnw', 'test'] };
+    if (isGradle) {
+      const gradleCmd = hasGradlew ? ['./gradlew'] : ['gradle'];
+      commands.install = { label: 'Gradle dependencies', command: [...gradleCmd, 'dependencies'], source: 'builtin' };
+      commands.build = { label: 'Gradle build', command: [...gradleCmd, 'build'], source: 'builtin' };
+      commands.test = { label: 'Gradle test', command: [...gradleCmd, 'test'], source: 'builtin' };
+      commands.run = { label: 'Gradle run', command: [...gradleCmd, 'run'], source: 'builtin' };
+      commands.clean = { label: 'Gradle clean', command: [...gradleCmd, 'clean'], source: 'builtin' };
     } else {
-      commands.build = { label: 'Maven package', command: ['mvn', 'package'] };
-      commands.test = { label: 'Maven test', command: ['mvn', 'test'] };
+      const mvnCmd = hasMvnw ? ['./mvnw'] : ['mvn'];
+      commands.install = { label: 'Maven install', command: [...mvnCmd, 'install'], source: 'builtin' };
+      commands.build = { label: 'Maven package', command: [...mvnCmd, 'package'], source: 'builtin' };
+      commands.test = { label: 'Maven test', command: [...mvnCmd, 'test'], source: 'builtin' };
+      commands.run = { label: 'Maven spring-boot:run', command: [...mvnCmd, 'spring-boot:run'], source: 'builtin' };
+      commands.clean = { label: 'Maven clean', command: [...mvnCmd, 'clean'], source: 'builtin' };
+    }
+
+    const setupHints = [];
+    if (missingBinaries.length > 0) {
+      setupHints.push('Install JDK 17+ from https://adoptium.net/');
+    }
+    if (isMaven) {
+      setupHints.push('Run ' + (hasMvnw ? './mvnw install' : 'mvn install') + ' to build');
+    } else if (isGradle) {
+      setupHints.push('Run ' + (hasGradlew ? './gradlew build' : 'gradle build') + ' to build');
     }
 
     return {
       id: `${projectPath}::java`,
       path: projectPath,
-      name: path.basename(projectPath),
+      name: metadata.name || metadata.artifactId || path.basename(projectPath),
       type: 'Java',
       icon: '☕',
       priority: this.priority,
       commands,
-      metadata: {},
+      metadata: {
+        ...metadata,
+        packageManager: buildTool
+      },
       manifest: path.basename(manifest),
-      description: '',
+      description: metadata.description || frameworks.map(f => f.name).join(', '),
       missingBinaries,
+      frameworks,
       extra: {
-        setupHints: ['Install JDK 17+ and run ./mvnw install or ./gradlew build']
+        setupHints,
+        buildTool
       }
     };
   }

package/src/detectors/node.js

@@ -9,7 +9,43 @@ function gatherNodeDependencies(pkg) {
       Object.keys(pkg[key]).forEach((name) => deps.add(name));
     }
   });
-  return Array.from(deps);
+  return Array.from(deps).map(dep => ({ name: dep, version: pkg.dependencies?.[dep] || pkg.devDependencies?.[dep] || 'latest' }));
+}
+
+function detectNodeProjectType(pkg) {
+  const deps = pkg.dependencies || {};
+  const devDeps = pkg.devDependencies || {};
+  const allDeps = { ...deps, ...devDeps };
+  
+  if (allDeps['next']) return { type: 'Next.js', icon: '🧭' };
+  if (allDeps['react'] && (allDeps['react-scripts'] || allDeps['vite'])) return { type: 'React', icon: '⚛️' };
+  if (allDeps['vue']) return { type: 'Vue.js', icon: '🟩' };
+  if (allDeps['@nestjs/core']) return { type: 'NestJS', icon: '🛡️' };
+  if (allDeps['express']) return { type: 'Express', icon: '🚂' };
+  if (allDeps['fastify']) return { type: 'Fastify', icon: '⚡' };
+  if (allDeps['koa']) return { type: 'Koa', icon: '🎋' };
+  if (allDeps['@sveltejs/kit'] || allDeps['svelte']) return { type: 'Svelte', icon: '🧡' };
+  if (allDeps['astro']) return { type: 'Astro', icon: '🚀' };
+  if (allDeps['nuxt']) return { type: 'Nuxt', icon: '🟢' };
+  if (allDeps['vite']) return { type: 'Vite', icon: '⚡' };
+  if (allDeps['electron']) return { type: 'Electron', icon: '⚛️' };
+  if (allDeps['typescript']) return { type: 'TypeScript', icon: '🔷' };
+  return { type: 'Node.js', icon: '🟢' };
+}
+
+function findEntryPoint(projectPath, pkg) {
+  const possibleEntries = [
+    'src/index.js', 'src/index.ts', 'index.js', 'index.ts',
+    'src/main.js', 'src/main.ts', 'main.js', 'main.ts',
+    'app.js', 'app.ts', 'server.js', 'server.ts'
+  ];
+  
+  for (const entry of possibleEntries) {
+    if (hasProjectFile(projectPath, entry)) return entry;
+  }
+  
+  if (pkg.main) return pkg.main;
+  return null;
 }
 
 export default {
@@ -29,53 +65,75 @@ export default {
     const pkg = JSON.parse(content);
     const pm = getPackageManager(projectPath);
     const scripts = pkg.scripts || {};
+    const projectType = detectNodeProjectType(pkg);
+    const entryPoint = findEntryPoint(projectPath, pkg);
+    
     const commands = {};
     const preferScript = (targetKey, names, labelText) => {
       for (const name of names) {
         if (Object.prototype.hasOwnProperty.call(scripts, name)) {
-          commands[targetKey] = { label: labelText, command: [pm, 'run', name] };
+          commands[targetKey] = { label: labelText, command: [pm, 'run', name], source: 'builtin' };
           break;
         }
       }
     };
-    commands.install = { label: 'Install', command: [pm, 'install'] };
+    
+    commands.install = { label: `${pm} install`, command: [pm, 'install'], source: 'builtin' };
     preferScript('build', ['build', 'compile', 'dist'], 'Build');
     preferScript('test', ['test', 'check', 'spec'], 'Test');
-    preferScript('run', ['start', 'dev', 'serve', 'run'], 'Start');
+    preferScript('dev', ['dev', 'start:dev'], 'Dev');
+    preferScript('run', ['start', 'serve', 'run'], 'Start');
+    
+    if (entryPoint && !commands.run && !commands.dev) {
+      commands.run = { label: 'Run', command: ['node', entryPoint], source: 'builtin' };
+    }
+    
     if (Object.prototype.hasOwnProperty.call(scripts, 'lint')) {
-      commands.lint = { label: 'Lint', command: [pm, 'run', 'lint'] };
+      commands.lint = { label: 'Lint', command: [pm, 'run', 'lint'], source: 'builtin' };
+    }
+    if (Object.prototype.hasOwnProperty.call(scripts, 'format')) {
+      commands.format = { label: 'Format', command: [pm, 'run', 'format'], source: 'builtin' };
     }
 
     const metadata = {
       dependencies: gatherNodeDependencies(pkg),
       scripts,
       packageJson: pkg,
-      packageManager: getPackageManager(projectPath)
+      packageManager: pm,
+      projectType: projectType.type,
+      entryPoint
     };
 
     const setupHints = [];
     if (metadata.dependencies.length) {
-      setupHints.push('Run npm install to fetch dependencies.');
-      if (hasProjectFile(projectPath, 'yarn.lock')) {
+      setupHints.push(`Run ${pm} install to fetch dependencies.`);
+      if (pm === 'npm' && hasProjectFile(projectPath, 'yarn.lock')) {
         setupHints.push('Or run yarn install if you prefer Yarn.');
       }
     }
+    
+    const workspaces = pkg.workspaces || [];
+    if (workspaces.length > 0) {
+      setupHints.push('This is a monorepo with workspaces: ' + workspaces.join(', '));
+    }
 
     return {
       id: `${projectPath}::node`,
       path: projectPath,
       name: pkg.name || path.basename(projectPath),
       type: 'Node.js',
-      icon: '🟢',
+      icon: projectType.icon,
       priority: this.priority,
       commands,
       metadata,
       manifest: path.basename(manifest),
-      description: pkg.description || '',
+      description: pkg.description || projectType.type,
       missingBinaries,
+      frameworks: [{ name: projectType.type, icon: projectType.icon }],
       extra: {
         scripts: Object.keys(scripts),
-        setupHints
+        setupHints,
+        workspaces
       }
     };
   }

package/src/detectors/php.js

@@ -1,13 +1,106 @@
+import fs from 'fs';
 import path from 'path';
-import { checkBinary } from './utils.js';
+import { checkBinary, hasProjectFile } from './utils.js';
+
+function parseComposerJson(content) {
+  try {
+    const pkg = JSON.parse(content);
+    return {
+      name: pkg.name || '',
+      description: pkg.description || '',
+      dependencies: [
+        ...Object.keys(pkg.require || {}),
+        ...Object.keys(pkg['require-dev'] || {})
+      ],
+      scripts: pkg.scripts || {}
+    };
+  } catch {
+    return { name: '', description: '', dependencies: [], scripts: {} };
+  }
+}
+
+function detectPhpFrameworks(deps) {
+  const frameworks = [];
+  const depStr = deps.join(' ').toLowerCase();
+  
+  if (depStr.includes('laravel/framework')) frameworks.push({ name: 'Laravel', icon: '🧡' });
+  if (depStr.includes('symfony/symfony') || depStr.includes('symfony/framework-bundle')) frameworks.push({ name: 'Symfony', icon: '🎵' });
+  if (depStr.includes('codeigniter4/framework')) frameworks.push({ name: 'CodeIgniter', icon: '🔥' });
+  if (depStr.includes('cakephp/cakephp')) frameworks.push({ name: 'CakePHP', icon: '🍰' });
+  if (depStr.includes('slim/slim')) frameworks.push({ name: 'Slim', icon: '🍃' });
+  if (depStr.includes('lumen')) frameworks.push({ name: 'Lumen', icon: '💡' });
+  if (depStr.includes('phpunit/phpunit')) frameworks.push({ name: 'PHPUnit', icon: '✅' });
+  if (depStr.includes('laravel/octane')) frameworks.push({ name: 'Laravel Octane', icon: '🚀' });
+  return frameworks;
+}
+
 export default {
-  type: 'php', label: 'PHP', icon: '🐘', priority: 65, files: ['composer.json'], binaries: ['php', 'composer'],
+  type: 'php',
+  label: 'PHP',
+  icon: '🐘',
+  priority: 65,
+  files: ['composer.json'],
+  binaries: ['php', 'composer'],
   async build(projectPath, manifest) {
     const missingBinaries = this.binaries.filter(b => !checkBinary(b));
+    let metadata = { name: '', description: '', dependencies: [], scripts: {} };
+    let frameworks = [];
+    
+    const composerPath = path.join(projectPath, 'composer.json');
+    if (fs.existsSync(composerPath)) {
+      const content = fs.readFileSync(composerPath, 'utf-8');
+      metadata = parseComposerJson(content);
+      frameworks = detectPhpFrameworks(metadata.dependencies);
+    }
+    
+    const commands = {
+      install: { label: 'Composer install', command: ['composer', 'install'], source: 'builtin' },
+      update: { label: 'Composer update', command: ['composer', 'update'], source: 'builtin' }
+    };
+    
+    if (hasProjectFile(projectPath, 'artisan')) {
+      commands.run = { label: 'Artisan serve', command: ['php', 'artisan', 'serve'], source: 'builtin' };
+      commands.test = { label: 'Artisan test', command: ['php', 'artisan', 'test'], source: 'builtin' };
+      commands.migrate = { label: 'Artisan migrate', command: ['php', 'artisan', 'migrate'], source: 'builtin' };
+    }
+    
+    if (hasProjectFile(projectPath, 'bin/phpunit') || metadata.dependencies.includes('phpunit/phpunit')) {
+      commands.test = { label: 'PHPUnit', command: ['php', 'bin/phpunit'], source: 'builtin' };
+    }
+    
+    if (hasProjectFile(projectPath, 'symfony.lock')) {
+      commands.run = { label: 'Symfony server', command: ['symfony', 'server:start'], source: 'builtin' };
+      commands.test = { label: 'Symfony test', command: ['php', 'bin/phpunit'], source: 'builtin' };
+    }
+
+    const setupHints = [];
+    if (missingBinaries.includes('composer')) {
+      setupHints.push('Install Composer: https://getcomposer.org/');
+    }
+    if (metadata.dependencies.length > 0) {
+      setupHints.push('Run composer install to fetch dependencies');
+    }
+
     return {
-      id: `${projectPath}::php`, path: projectPath, name: path.basename(projectPath), type: 'PHP', icon: '🐘',
-      priority: this.priority, commands: { install: { label: 'Composer install', command: ['composer', 'install'] } },
-      metadata: {}, manifest: path.basename(manifest), description: '', missingBinaries, extra: {}
+      id: `${projectPath}::php`,
+      path: projectPath,
+      name: metadata.name || path.basename(projectPath),
+      type: 'PHP',
+      icon: '🐘',
+      priority: this.priority,
+      commands,
+      metadata: {
+        ...metadata,
+        packageManager: 'composer'
+      },
+      manifest: path.basename(manifest),
+      description: metadata.description || frameworks.map(f => f.name).join(', '),
+      missingBinaries,
+      frameworks,
+      extra: {
+        setupHints,
+        scripts: Object.keys(metadata.scripts)
+      }
     };
   }
 };