project-compass 4.2.1 → 4.3.1

package/src/detectors/python.js

@@ -2,42 +2,96 @@ import fs from 'fs';
 import path from 'path';
 import { checkBinary, hasProjectFile } from './utils.js';
 
-const PYTHON_ENTRY_FILES = ['main.py', 'app.py', 'src/main.py', 'src/app.py'];
+const PYTHON_ENTRY_FILES = [
+  'main.py', 'app.py', 'src/main.py', 'src/app.py',
+  'manage.py', 'wsgi.py', 'asgi.py', 'api.py', 'run.py'
+];
 
 function findPythonEntry(projectPath) {
   return PYTHON_ENTRY_FILES.find((file) => hasProjectFile(projectPath, file)) || null;
 }
 
+function getPythonPackageManager(projectPath) {
+  if (hasProjectFile(projectPath, 'uv.lock') || hasProjectFile(projectPath, 'pyproject.toml')) {
+    if (checkBinary('uv')) return 'uv';
+  }
+  if (hasProjectFile(projectPath, 'Pipfile.lock')) return 'pipenv';
+  if (hasProjectFile(projectPath, 'poetry.lock')) return 'poetry';
+  if (hasProjectFile(projectPath, 'requirements.txt')) return 'pip';
+  return 'pip';
+}
+
 function gatherPythonDependencies(projectPath) {
-  const set = new Set();
-  const addFromFile = (filePath) => {
-    if (!fs.existsSync(filePath)) {
-      return;
-    }
+  const deps = new Set();
+  const addFromRequirements = (filePath) => {
+    if (!fs.existsSync(filePath)) return;
     const raw = fs.readFileSync(filePath, 'utf-8');
     raw.split(/\r?\n/).forEach((line) => {
       const clean = line.trim().split('#')[0].trim();
-      if (clean) {
-        const token = clean.split(/[>=<=~!]/)[0].trim().toLowerCase();
-        if (token) {
-          set.add(token);
-        }
-      }
+      if (!clean || clean.startsWith('-') || clean.startsWith('"') || clean.startsWith("'")) return;
+      const match = clean.match(/^([a-zA-Z0-9_.-]+)/);
+      if (match) deps.add(match[1].toLowerCase());
     });
   };
-  addFromFile(path.join(projectPath, 'requirements.txt'));
-  addFromFile(path.join(projectPath, 'Pipfile'));
+
+  addFromRequirements(path.join(projectPath, 'requirements.txt'));
+  addFromRequirements(path.join(projectPath, 'requirements-dev.txt'));
+
   const pyproject = path.join(projectPath, 'pyproject.toml');
   if (fs.existsSync(pyproject)) {
-    const content = fs.readFileSync(pyproject, 'utf-8').toLowerCase();
-    const matches = content.match(/\b[a-z0-9-_/.]+\b/g);
-    (matches || []).forEach((match) => {
-      if (match) {
-        set.add(match);
-      }
-    });
+    const content = fs.readFileSync(pyproject, 'utf-8');
+    const depSection = content.match(/(?:dependencies|requires)\s*=\s*\[([^\]]+)\]/g);
+    if (depSection) {
+      depSection.forEach((section) => {
+        const matches = section.match(/["']([^"']+)["']/g);
+        if (matches) {
+          matches.forEach((m) => {
+            const dep = m.replace(/["']/g, '').split(/[>=<=~!]/)[0].trim();
+            if (dep) deps.add(dep.toLowerCase());
+          });
+        }
+      });
+    }
+  }
+
+  const pipfile = path.join(projectPath, 'Pipfile');
+  if (fs.existsSync(pipfile)) {
+    const content = fs.readFileSync(pipfile, 'utf-8');
+    const matches = content.match(/["']([^"']+)["']/g);
+    if (matches) {
+      matches.forEach((m) => {
+        const dep = m.replace(/["']/g, '').split(/[>=<=~!]/)[0].trim();
+        if (dep) deps.add(dep.toLowerCase());
+      });
+    }
   }
-  return Array.from(set);
+
+  return Array.from(deps);
+}
+
+function detectPythonFramework(deps) {
+  const frameworks = [];
+  const depStr = deps.join(' ').toLowerCase();
+  
+  if (depStr.includes('fastapi')) frameworks.push({ name: 'FastAPI', icon: '⚡' });
+  if (depStr.includes('flask')) frameworks.push({ name: 'Flask', icon: '🌶️' });
+  if (depStr.includes('django')) frameworks.push({ name: 'Django', icon: '🌿' });
+  if (depStr.includes('tornado')) frameworks.push({ name: 'Tornado', icon: '🌪️' });
+  if (depStr.includes('aiohttp')) frameworks.push({ name: 'AioHTTP', icon: '🔄' });
+  if (depStr.includes('sanic')) frameworks.push({ name: 'Sanic', icon: '🚀' });
+  if (depStr.includes('pyramid')) frameworks.push({ name: 'Pyramid', icon: '🔺' });
+  if (depStr.includes('falcon')) frameworks.push({ name: 'Falcon', icon: '🦅' });
+  if (depStr.includes('starlette')) frameworks.push({ name: 'Starlette', icon: '⭐' });
+  if (depStr.includes('pandas')) frameworks.push({ name: 'Pandas', icon: '🐼' });
+  if (depStr.includes('numpy')) frameworks.push({ name: 'NumPy', icon: '🔢' });
+  if (depStr.includes('scipy')) frameworks.push({ name: 'SciPy', icon: '🔬' });
+  if (depStr.includes('torch') || depStr.includes('pytorch')) frameworks.push({ name: 'PyTorch', icon: '🔥' });
+  if (depStr.includes('tensorflow')) frameworks.push({ name: 'TensorFlow', icon: '🧠' });
+  if (depStr.includes('sqlalchemy')) frameworks.push({ name: 'SQLAlchemy', icon: '🗄️' });
+  if (depStr.includes('pytest')) frameworks.push({ name: 'Pytest', icon: '✅' });
+  if (depStr.includes('celery')) frameworks.push({ name: 'Celery', icon: '🥬' });
+  
+  return frameworks;
 }
 
 export default {
@@ -45,36 +99,78 @@ export default {
   label: 'Python',
   icon: '🐍',
   priority: 95,
-  files: ['pyproject.toml', 'requirements.txt', 'setup.py', 'Pipfile'],
-  binaries: [process.platform === 'win32' ? 'python' : 'python3', 'pip'],
+  files: ['pyproject.toml', 'requirements.txt', 'setup.py', 'Pipfile', 'manage.py'],
+  binaries: ['python3', 'python', 'uv'].filter(Boolean),
   async build(projectPath, manifest) {
     const missingBinaries = this.binaries.filter(b => !checkBinary(b));
+    const pkgManager = getPythonPackageManager(projectPath);
+    const isUV = pkgManager === 'uv';
+    const isPoetry = pkgManager === 'poetry';
+    const isPipenv = pkgManager === 'pipenv';
+    
     const commands = {};
-    if (hasProjectFile(projectPath, 'requirements.txt')) {
-      commands.install = { label: 'Pip Install', command: ['pip', 'install', '-r', 'requirements.txt'] };
+
+    if (isUV) {
+      commands.install = { label: 'UV Sync', command: ['uv', 'sync'], source: 'builtin' };
+      commands.add = { label: 'UV Add', command: ['uv', 'add'], source: 'builtin' };
+      commands.run = { label: 'UV Run', command: ['uv', 'run', 'python'], source: 'builtin' };
+    } else if (isPoetry) {
+      commands.install = { label: 'Poetry Install', command: ['poetry', 'install'], source: 'builtin' };
+      commands.add = { label: 'Poetry Add', command: ['poetry', 'add'], source: 'builtin' };
+      commands.run = { label: 'Poetry Run', command: ['poetry', 'run', 'python'], source: 'builtin' };
+    } else if (isPipenv) {
+      commands.install = { label: 'Pipenv Install', command: ['pipenv', 'install'], source: 'builtin' };
+      commands.run = { label: 'Pipenv Run', command: ['pipenv', 'run', 'python'], source: 'builtin' };
+    } else {
+      commands.install = { label: 'Pip Install', command: ['pip', 'install', '-r', 'requirements.txt'], source: 'builtin' };
     }
-    if (hasProjectFile(projectPath, 'pyproject.toml')) {
-      commands.test = { label: 'Pytest', command: ['pytest'] };
+
+    if (hasProjectFile(projectPath, 'pyproject.toml') || hasProjectFile(projectPath, 'setup.py')) {
+      commands.test = { label: 'Pytest', command: [isUV ? 'uv' : 'python', ...(isUV ? ['run'] : []), 'pytest'], source: 'builtin' };
     } else {
-      commands.test = { label: 'Unittest', command: ['python', '-m', 'unittest', 'discover'] };
+      commands.test = { label: 'Unittest', command: ['python', '-m', 'unittest', 'discover'], source: 'builtin' };
     }
 
     const entry = findPythonEntry(projectPath);
     if (entry) {
-      commands.run = { label: 'Run', command: ['python', entry] };
+      const runCmd = isUV ? ['uv', 'run', 'python', entry] :
+                     isPoetry ? ['poetry', 'run', 'python', entry] :
+                     isPipenv ? ['pipenv', 'run', 'python', entry] :
+                     ['python', entry];
+      commands.run = { label: 'Run', command: runCmd, source: 'builtin' };
+    }
+
+    if (hasProjectFile(projectPath, 'manage.py')) {
+      const djangoCmd = isUV ? ['uv', 'run', 'python', 'manage.py'] :
+                        isPoetry ? ['poetry', 'run', 'python', 'manage.py'] :
+                        ['python', 'manage.py'];
+      commands['runserver'] = { label: 'Django Runserver', command: [...djangoCmd, 'runserver'], source: 'builtin' };
+      commands['migrate'] = { label: 'Django Migrate', command: [...djangoCmd, 'migrate'], source: 'builtin' };
+      commands['test'] = { label: 'Django Test', command: [...djangoCmd, 'test'], source: 'builtin' };
+    }
+
+    if (hasProjectFile(projectPath, 'fastapi') || hasProjectFile(projectPath, 'main.py')) {
+      if (hasProjectFile(projectPath, 'main.py')) {
+        const fastapiCmd = isUV ? ['uv', 'run', 'uvicorn', 'main:app', '--reload'] :
+                          ['uvicorn', 'main:app', '--reload'];
+        commands['dev'] = { label: 'FastAPI Dev', command: fastapiCmd, source: 'builtin' };
+      }
     }
 
+    const allDeps = gatherPythonDependencies(projectPath);
+    const detectedFrameworks = detectPythonFramework(allDeps);
+
     const metadata = {
-      dependencies: gatherPythonDependencies(projectPath)
+      dependencies: allDeps,
+      packageManager: pkgManager,
+      frameworks: detectedFrameworks
     };
 
     const setupHints = [];
-    if (hasProjectFile(projectPath, 'requirements.txt')) {
-      setupHints.push('pip install -r requirements.txt');
-    }
-    if (hasProjectFile(projectPath, 'Pipfile')) {
-      setupHints.push('Use pipenv install --dev or poetry install');
-    }
+    if (isUV) setupHints.push('uv sync');
+    else if (isPoetry) setupHints.push('poetry install');
+    else if (isPipenv) setupHints.push('pipenv install');
+    else if (hasProjectFile(projectPath, 'requirements.txt')) setupHints.push('pip install -r requirements.txt');
 
     return {
       id: `${projectPath}::python`,
@@ -86,11 +182,13 @@ export default {
       commands,
       metadata,
       manifest: path.basename(manifest),
-      description: '',
+      description: detectedFrameworks.map(f => f.name).join(', '),
       missingBinaries,
+      frameworks: detectedFrameworks,
       extra: {
         entry,
-        setupHints
+        setupHints,
+        packageManager: pkgManager
       }
     };
   }

package/src/detectors/ruby.js

@@ -1,13 +1,113 @@
+import fs from 'fs';
 import path from 'path';
-import { checkBinary } from './utils.js';
+import { checkBinary, hasProjectFile } from './utils.js';
+
+function parseGemfile(content) {
+  const gems = [];
+  const lines = content.split('\n');
+  
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('gem ') || trimmed.startsWith('gem(')) {
+      const match = trimmed.match(/gem\s+['"]([^'"]+)['"]/);
+      if (match) gems.push(match[1]);
+    }
+  }
+  
+  return gems;
+}
+
+function detectRubyFrameworks(gems) {
+  const frameworks = [];
+  const gemStr = gems.join(' ').toLowerCase();
+  
+  if (gemStr.includes('rails')) frameworks.push({ name: 'Ruby on Rails', icon: '🛤️' });
+  if (gemStr.includes('sinatra')) frameworks.push({ name: 'Sinatra', icon: '🎷' });
+  if (gemStr.includes('padrino')) frameworks.push({ name: 'Padrino', icon: '🎩' });
+  if (gemStr.includes('hanami') || gemStr.includes('lotus')) frameworks.push({ name: 'Hanami', icon: '🌸' });
+  if (gemStr.includes('grape')) frameworks.push({ name: 'Grape', icon: '🍇' });
+  if (gemStr.includes('roda')) frameworks.push({ name: 'Roda', icon: '🎣' });
+  if (gemStr.includes('cuba')) frameworks.push({ name: 'Cuba', icon: '🎵' });
+  if (gemStr.includes('rspec')) frameworks.push({ name: 'RSpec', icon: '✅' });
+  if (gemStr.includes('minitest')) frameworks.push({ name: 'MiniTest', icon: '🔬' });
+  if (gemStr.includes('sidekiq')) frameworks.push({ name: 'Sidekiq', icon: '🥬' });
+  if (gemStr.includes('activerecord')) frameworks.push({ name: 'ActiveRecord', icon: '🗄️' });
+  
+  return frameworks;
+}
+
 export default {
-  type: 'ruby', label: 'Ruby', icon: '💎', priority: 65, files: ['Gemfile'], binaries: ['ruby', 'bundle'],
+  type: 'ruby',
+  label: 'Ruby',
+  icon: '💎',
+  priority: 65,
+  files: ['Gemfile', 'Gemfile.lock'],
+  binaries: ['ruby', 'bundle'],
   async build(projectPath, manifest) {
     const missingBinaries = this.binaries.filter(b => !checkBinary(b));
+    let gems = [];
+    let frameworks = [];
+    
+    const gemfilePath = path.join(projectPath, 'Gemfile');
+    if (fs.existsSync(gemfilePath)) {
+      const content = fs.readFileSync(gemfilePath, 'utf-8');
+      gems = parseGemfile(content);
+      frameworks = detectRubyFrameworks(gems);
+    }
+    
+    const commands = {
+      install: { label: 'Bundle install', command: ['bundle', 'install'], source: 'builtin' },
+      update: { label: 'Bundle update', command: ['bundle', 'update'], source: 'builtin' },
+      console: { label: 'Ruby console', command: ['ruby', '-e', 'puts "IRB"'], source: 'builtin' }
+    };
+    
+    if (hasProjectFile(projectPath, 'bin/rails')) {
+      commands.run = { label: 'Rails server', command: ['bin/rails', 'server'], source: 'builtin' };
+      commands.test = { label: 'Rails test', command: ['bin/rails', 'test'], source: 'builtin' };
+      commands.migrate = { label: 'Rails migrate', command: ['bin/rails', 'db:migrate'], source: 'builtin' };
+      commands.console = { label: 'Rails console', command: ['bin/rails', 'console'], source: 'builtin' };
+    }
+    
+    if (hasProjectFile(projectPath, 'config.ru') && !hasProjectFile(projectPath, 'bin/rails')) {
+      commands.run = { label: 'Rackup', command: ['rackup'], source: 'builtin' };
+    }
+    
+    if (gems.includes('rspec')) {
+      commands.test = { label: 'RSpec', command: ['bundle', 'exec', 'rspec'], source: 'builtin' };
+    }
+
+    const setupHints = [];
+    if (missingBinaries.includes('bundle')) {
+      setupHints.push('Install Bundler: gem install bundler');
+    }
+    if (gems.length > 0) {
+      setupHints.push('Run bundle install to fetch dependencies');
+    }
+    if (hasProjectFile(projectPath, '.ruby-version')) {
+      const version = fs.readFileSync(path.join(projectPath, '.ruby-version'), 'utf-8').trim();
+      setupHints.push(`Requires Ruby ${version}`);
+    }
+
     return {
-      id: `${projectPath}::ruby`, path: projectPath, name: path.basename(projectPath), type: 'Ruby', icon: '💎',
-      priority: this.priority, commands: { install: { label: 'Bundle install', command: ['bundle', 'install'] } },
-      metadata: {}, manifest: path.basename(manifest), description: '', missingBinaries, extra: {}
+      id: `${projectPath}::ruby`,
+      path: projectPath,
+      name: path.basename(projectPath),
+      type: 'Ruby',
+      icon: '💎',
+      priority: this.priority,
+      commands,
+      metadata: {
+        dependencies: gems,
+        packageManager: 'bundler'
+      },
+      manifest: path.basename(manifest),
+      description: frameworks.map(f => f.name).join(', '),
+      missingBinaries,
+      frameworks,
+      extra: {
+        setupHints,
+        gems
+      }
     };
   }
 };

package/src/detectors/rust.js

@@ -1,5 +1,75 @@
+import fs from 'fs';
 import path from 'path';
-import { checkBinary } from './utils.js';
+import { checkBinary, hasProjectFile } from './utils.js';
+
+function parseCargoToml(content) {
+  const metadata = {
+    name: '',
+    version: '',
+    description: '',
+    dependencies: [],
+    binaries: []
+  };
+  
+  const lines = content.split('\n');
+  let inDependencies = false;
+  let inBin = false;
+  
+  for (const line of lines) {
+    const trimmed = line.trim();
+    
+    if (trimmed.startsWith('name') && !inDependencies && !inBin) {
+      metadata.name = trimmed.split('=')[1]?.replace(/"/g, '').trim() || '';
+    }
+    if (trimmed.startsWith('version') && !inDependencies && !inBin) {
+      metadata.version = trimmed.split('=')[1]?.replace(/"/g, '').trim() || '';
+    }
+    if (trimmed.startsWith('description') && !inDependencies && !inBin) {
+      metadata.description = trimmed.split('=')[1]?.replace(/"/g, '').trim() || '';
+    }
+    
+    if (trimmed === '[dependencies]') {
+      inDependencies = true;
+      inBin = false;
+      continue;
+    }
+    if (trimmed.startsWith('[')) {
+      inDependencies = false;
+      inBin = trimmed === '[bin]';
+      continue;
+    }
+    
+    if (inDependencies && trimmed && !trimmed.startsWith('#')) {
+      const depName = trimmed.split('=')[0]?.trim() || trimmed.split('{')[0]?.trim();
+      if (depName) metadata.dependencies.push(depName);
+    }
+    
+    if (inBin && trimmed.startsWith('name')) {
+      const binName = trimmed.split('=')[1]?.replace(/"/g, '').trim();
+      if (binName) metadata.binaries.push(binName);
+    }
+  }
+  
+  return metadata;
+}
+
+function detectRustFrameworks(deps) {
+  const frameworks = [];
+  const depStr = deps.join(' ').toLowerCase();
+  
+  if (depStr.includes('actix-web')) frameworks.push({ name: 'Actix Web', icon: '🎭' });
+  if (depStr.includes('rocket')) frameworks.push({ name: 'Rocket', icon: '🚀' });
+  if (depStr.includes('axum')) frameworks.push({ name: 'Axum', icon: '🗡️' });
+  if (depStr.includes('warp')) frameworks.push({ name: 'Warp', icon: '🌀' });
+  if (depStr.includes('tokio')) frameworks.push({ name: 'Tokio', icon: '⚡' });
+  if (depStr.includes('serde')) frameworks.push({ name: 'Serde', icon: '🔄' });
+  if (depStr.includes('sqlx')) frameworks.push({ name: 'SQLx', icon: '🗄️' });
+  if (depStr.includes('diesel')) frameworks.push({ name: 'Diesel', icon: '🛢️' });
+  if (depStr.includes('tonic')) frameworks.push({ name: 'Tonic', icon: '🎵' });
+  if (depStr.includes('tower')) frameworks.push({ name: 'Tower', icon: '🏰' });
+  
+  return frameworks;
+}
 
 export default {
   type: 'rust',
@@ -10,25 +80,56 @@ export default {
   binaries: ['cargo', 'rustc'],
   async build(projectPath, manifest) {
     const missingBinaries = this.binaries.filter(b => !checkBinary(b));
+    const cargoPath = path.join(projectPath, 'Cargo.toml');
+    let metadata = { name: '', version: '', description: '', dependencies: [], binaries: [] };
+    let frameworks = [];
+    
+    if (fs.existsSync(cargoPath)) {
+      const content = fs.readFileSync(cargoPath, 'utf-8');
+      metadata = parseCargoToml(content);
+      frameworks = detectRustFrameworks(metadata.dependencies);
+    }
+    
+    const commands = {
+      install: { label: 'Cargo fetch', command: ['cargo', 'fetch'], source: 'builtin' },
+      build: { label: 'Cargo build', command: ['cargo', 'build'], source: 'builtin' },
+      test: { label: 'Cargo test', command: ['cargo', 'test'], source: 'builtin' },
+      run: { label: 'Cargo run', command: ['cargo', 'run'], source: 'builtin' },
+      check: { label: 'Cargo check', command: ['cargo', 'check'], source: 'builtin' },
+      doc: { label: 'Cargo doc', command: ['cargo', 'doc', '--open'], source: 'builtin' }
+    };
+    
+    if (hasProjectFile(projectPath, 'Cargo.toml')) {
+      commands.update = { label: 'Cargo update', command: ['cargo', 'update'], source: 'builtin' };
+    }
+
+    const setupHints = [];
+    if (missingBinaries.length > 0) {
+      setupHints.push('Install Rust: curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh');
+    }
+    if (metadata.dependencies.length > 0) {
+      setupHints.push('Run cargo fetch to download dependencies');
+    }
+
     return {
       id: `${projectPath}::rust`,
       path: projectPath,
-      name: path.basename(projectPath),
+      name: metadata.name || path.basename(projectPath),
       type: 'Rust',
       icon: '🦀',
       priority: this.priority,
-      commands: {
-        install: { label: 'Cargo fetch', command: ['cargo', 'fetch'] },
-        build: { label: 'Cargo build', command: ['cargo', 'build'] },
-        test: { label: 'Cargo test', command: ['cargo', 'test'] },
-        run: { label: 'Cargo run', command: ['cargo', 'run'] }
+      commands,
+      metadata: {
+        ...metadata,
+        packageManager: 'cargo'
       },
-      metadata: {},
       manifest: path.basename(manifest),
-      description: '',
+      description: metadata.description || frameworks.map(f => f.name).join(', '),
       missingBinaries,
+      frameworks,
       extra: {
-        setupHints: ['cargo fetch', 'Run cargo build before releasing']
+        setupHints,
+        binaries: metadata.binaries
       }
     };
   }

package/src/detectors/utils.js

@@ -16,16 +16,72 @@ export function hasProjectFile(projectPath, file) {
   return fs.existsSync(path.join(projectPath, file));
 }
 
-export function getPackageManager(projectPath) {
-  if (hasProjectFile(projectPath, 'bun.lockb') || hasProjectFile(projectPath, 'bun.lock')) return 'bun';
-  if (hasProjectFile(projectPath, 'pnpm-lock.yaml')) return 'pnpm';
-  if (hasProjectFile(projectPath, 'yarn.lock')) return 'yarn';
+export function hasProjectFilePattern(projectPath, pattern) {
+  try {
+    const files = fs.readdirSync(projectPath);
+    return files.some(f => new RegExp(pattern).test(f));
+  } catch {
+    return false;
+  }
+}
+
+export function getPackageManager(projectPath, language = 'node') {
+  // Node.js package managers
+  if (language === 'node' || language === 'Node.js') {
+    if (hasProjectFile(projectPath, 'bun.lockb') || hasProjectFile(projectPath, 'bun.lock')) return 'bun';
+    if (hasProjectFile(projectPath, 'pnpm-lock.yaml')) return 'pnpm';
+    if (hasProjectFile(projectPath, 'yarn.lock')) return 'yarn';
+    if (hasProjectFile(projectPath, 'package-lock.json')) return 'npm';
+    return 'npm';
+  }
+  
+  // Python package managers
+  if (language === 'python' || language === 'Python') {
+    if (hasProjectFile(projectPath, 'uv.lock') && checkBinary('uv')) return 'uv';
+    if (hasProjectFile(projectPath, 'poetry.lock')) return 'poetry';
+    if (hasProjectFile(projectPath, 'Pipfile.lock')) return 'pipenv';
+    if (hasProjectFile(projectPath, 'requirements.txt')) return 'pip';
+    return 'pip';
+  }
+  
+  // Go - uses go modules
+  if (language === 'go' || language === 'Go') {
+    return 'go';
+  }
+  
+  // Rust - uses cargo
+  if (language === 'rust' || language === 'Rust') {
+    return 'cargo';
+  }
+  
+  // Java - maven or gradle
+  if (language === 'java' || language === 'Java') {
+    if (hasProjectFile(projectPath, 'pom.xml')) return 'maven';
+    if (hasProjectFile(projectPath, 'build.gradle') || hasProjectFile(projectPath, 'build.gradle.kts')) return 'gradle';
+    return 'maven';
+  }
+  
+  // PHP - uses composer
+  if (language === 'php' || language === 'PHP') {
+    return 'composer';
+  }
+  
+  // Ruby - uses bundler
+  if (language === 'ruby' || language === 'Ruby') {
+    return 'bundler';
+  }
+  
+  // .NET - uses dotnet
+  if (language === '.net' || language === '.NET') {
+    return 'dotnet';
+  }
+  
   return 'npm';
 }
 
 export function resolveScriptCommand(project, scriptName, fallback = null) {
   const scripts = project.metadata?.scripts || {};
-  const pm = project.metadata?.packageManager || 'npm';
+  const pm = project.metadata?.packageManager || getPackageManager(project.path, project.type);
   if (Object.prototype.hasOwnProperty.call(scripts, scriptName)) {
     return [pm, 'run', scriptName];
   }
@@ -36,9 +92,19 @@ export function resolveScriptCommand(project, scriptName, fallback = null) {
 }
 
 export function dependencyMatches(project, needle) {
-  const dependencies = (project.metadata?.dependencies || []).map((dep) => dep.toLowerCase());
+  const dependencies = (project.metadata?.dependencies || []).map((dep) => {
+    if (typeof dep === 'string') return dep.toLowerCase();
+    if (dep && typeof dep === 'object' && dep.name) return dep.name.toLowerCase();
+    return '';
+  }).filter(Boolean);
   const target = needle.toLowerCase();
-  return dependencies.some((value) => value === target || value.startsWith(`${target}@`) || value.includes(`/${target}`));
+  return dependencies.some((value) => 
+    value === target || 
+    value.startsWith(`${target}@`) || 
+    value.includes(`/${target}`) ||
+    value.startsWith(`${target}/`) ||
+    value.endsWith(`/${target}`)
+  );
 }
 
 export function parseCommandTokens(value) {
@@ -58,3 +124,25 @@ export function parseCommandTokens(value) {
   }
   return [];
 }
+
+export function getLockfileInfo(projectPath) {
+  const lockfiles = [
+    { file: 'package-lock.json', pm: 'npm' },
+    { file: 'yarn.lock', pm: 'yarn' },
+    { file: 'pnpm-lock.yaml', pm: 'pnpm' },
+    { file: 'bun.lockb', pm: 'bun' },
+    { file: 'uv.lock', pm: 'uv' },
+    { file: 'poetry.lock', pm: 'poetry' },
+    { file: 'Pipfile.lock', pm: 'pipenv' },
+    { file: 'composer.lock', pm: 'composer' },
+    { file: 'Cargo.lock', pm: 'cargo' },
+    { file: 'go.sum', pm: 'go' }
+  ];
+  
+  for (const { file, pm } of lockfiles) {
+    if (hasProjectFile(projectPath, file)) {
+      return { lockfile: file, packageManager: pm };
+    }
+  }
+  return { lockfile: null, packageManager: null };
+}