project-compass 3.6.6 → 3.8.0

package/src/detectors/frameworks.js

@@ -0,0 +1,226 @@
+import { dependencyMatches, hasProjectFile, resolveScriptCommand } from './utils.js';
+
+export const builtInFrameworks = [
+  {
+    id: 'next',
+    name: 'Next.js',
+    icon: '🧭',
+    description: 'React + Next.js (SSR/SSG) apps',
+    languages: ['Node.js'],
+    priority: 115,
+    match(project) {
+      const hasNextConfig = ['next.config.js', 'next.config.mjs', 'next.config.ts'].some(f => hasProjectFile(project.path, f));
+      return dependencyMatches(project, 'next') || hasNextConfig;
+    },
+    commands(project) {
+      const commands = {};
+      const add = (key, label, fallback) => {
+        const tokens = resolveScriptCommand(project, key, fallback);
+        if (tokens) {
+          commands[key] = { label, command: tokens, source: 'framework' };
+        }
+      };
+      add('install', 'Next install', (pm) => [pm, 'install']);
+      add('run', 'Next dev', (pm) => pm === 'npm' ? ['npx', 'next', 'dev'] : [pm, 'next', 'dev']);
+      add('build', 'Next build', (pm) => pm === 'npm' ? ['npx', 'next', 'build'] : [pm, 'next', 'build']);
+      add('test', 'Next test', (pm) => [pm, 'run', 'test']);
+      add('start', 'Next start', (pm) => pm === 'npm' ? ['npx', 'next', 'start'] : [pm, 'next', 'start']);
+      return commands;
+    }
+  },
+  {
+    id: 'react',
+    name: 'React',
+    icon: '⚛️',
+    description: 'React apps (CRA, Vite React)',
+    languages: ['Node.js'],
+    priority: 112,
+    match(project) {
+      return dependencyMatches(project, 'react') && (dependencyMatches(project, 'react-scripts') || dependencyMatches(project, 'vite') || hasProjectFile(project.path, 'vite.config.js') || hasProjectFile(project.path, 'vite.config.ts'));
+    },
+    commands(project) {
+      const commands = {};
+      const add = (key, label, fallback) => {
+        const tokens = resolveScriptCommand(project, key, fallback);
+        if (tokens) {
+          commands[key] = { label, command: tokens, source: 'framework' };
+        }
+      };
+      add('install', 'React install', (pm) => [pm, 'install']);
+      add('run', 'React dev', (pm) => [pm, 'run', 'dev']);
+      add('build', 'React build', (pm) => [pm, 'run', 'build']);
+      add('test', 'React test', (pm) => [pm, 'run', 'test']);
+      return commands;
+    }
+  },
+  {
+    id: 'vue',
+    name: 'Vue.js',
+    icon: '🟩',
+    description: 'Vue CLI or Vite + Vue apps',
+    languages: ['Node.js'],
+    priority: 111,
+    match(project) {
+      return dependencyMatches(project, 'vue') && (hasProjectFile(project.path, 'vue.config.js') || hasProjectFile(project.path, 'vue.config.ts') || dependencyMatches(project, '@vue/cli-service') || dependencyMatches(project, 'vite'));
+    },
+    commands(project) {
+      const commands = {};
+      const add = (key, label, fallback) => {
+        const tokens = resolveScriptCommand(project, key, fallback);
+        if (tokens) {
+          commands[key] = { label, command: tokens, source: 'framework' };
+        }
+      };
+      add('install', 'Vue install', (pm) => [pm, 'install']);
+      add('run', 'Vue dev', (pm) => [pm, 'run', 'dev']);
+      add('build', 'Vue build', (pm) => [pm, 'run', 'build']);
+      add('test', 'Vue test', (pm) => [pm, 'run', 'test']);
+      return commands;
+    }
+  },
+  {
+    id: 'nest',
+    name: 'NestJS',
+    icon: '🛡️',
+    description: 'NestJS backend',
+    languages: ['Node.js'],
+    priority: 110,
+    match(project) {
+      return dependencyMatches(project, '@nestjs/cli') || dependencyMatches(project, '@nestjs/core') || hasProjectFile(project.path, 'nest-cli.json');
+    },
+    commands(project) {
+      const commands = {};
+      const add = (key, label, fallback) => {
+        const tokens = resolveScriptCommand(project, key, fallback);
+        if (tokens) {
+          commands[key] = { label, command: tokens, source: 'framework' };
+        }
+      };
+      add('install', 'Nest install', (pm) => [pm, 'install']);
+      add('run', 'Nest dev', (pm) => [pm, 'run', 'start:dev']);
+      add('build', 'Nest build', (pm) => [pm, 'run', 'build']);
+      add('test', 'Nest test', (pm) => [pm, 'run', 'test']);
+      return commands;
+    }
+  },
+  {
+    id: 'django',
+    name: 'Django',
+    icon: '🌿',
+    description: 'Django web application',
+    languages: ['Python'],
+    priority: 110,
+    match(project) {
+      return dependencyMatches(project, 'django') || hasProjectFile(project.path, 'manage.py');
+    },
+    commands(project) {
+      const commands = {};
+      if (hasProjectFile(project.path, 'requirements.txt')) {
+        commands.install = { label: 'Pip install', command: ['pip', 'install', '-r', 'requirements.txt'], source: 'framework' };
+      }
+      if (hasProjectFile(project.path, 'manage.py')) {
+        commands.run = { label: 'Django runserver', command: ['python', 'manage.py', 'runserver'], source: 'framework' };
+        commands.test = { label: 'Django test', command: ['python', 'manage.py', 'test'], source: 'framework' };
+        commands.migrate = { label: 'Django migrate', command: ['python', 'manage.py', 'migrate'], source: 'framework' };
+      }
+      return commands;
+    }
+  },
+  {
+    id: 'vite',
+    name: 'Vite',
+    icon: '⚡',
+    description: 'Vite-powered frontend',
+    languages: ['Node.js'],
+    priority: 100,
+    match(project) {
+      return hasProjectFile(project.path, 'vite.config.js') || hasProjectFile(project.path, 'vite.config.ts') || dependencyMatches(project, 'vite');
+    },
+    commands(project) {
+      const commands = {};
+      const add = (key, label, fallback) => {
+        const tokens = resolveScriptCommand(project, key, fallback);
+        if (tokens) {
+          commands[key] = { label, command: tokens, source: 'framework' };
+        }
+      };
+      add('install', 'Vite install', (pm) => [pm, 'install']);
+      add('run', 'Vite dev', (pm) => pm === 'npm' ? ['npx', 'vite'] : [pm, 'vite']);
+      add('build', 'Vite build', (pm) => pm === 'npm' ? ['npx', 'vite', 'build'] : [pm, 'vite', 'build']);
+      add('preview', 'Vite preview', (pm) => pm === 'npm' ? ['npx', 'vite', 'preview'] : [pm, 'vite', 'preview']);
+      return commands;
+    }
+  },
+  {
+    id: 'tailwind',
+    name: 'Tailwind CSS',
+    icon: '🎨',
+    description: 'Tailwind utility-first CSS',
+    languages: ['Node.js'],
+    priority: 50,
+    match(project) {
+      return hasProjectFile(project.path, 'tailwind.config.js') || hasProjectFile(project.path, 'tailwind.config.ts') || dependencyMatches(project, 'tailwindcss');
+    },
+    commands(project) {
+      const pm = project.metadata?.packageManager || 'npm';
+      return { install: { label: 'Tailwind install', command: [pm, 'install', '-D', 'tailwindcss'], source: 'framework' } };
+    }
+  },
+  {
+    id: 'prisma',
+    name: 'Prisma',
+    icon: '◮',
+    description: 'Prisma ORM',
+    languages: ['Node.js'],
+    priority: 50,
+    match(project) {
+      return hasProjectFile(project.path, 'prisma/schema.prisma') || dependencyMatches(project, '@prisma/client');
+    },
+    commands(project) {
+      const pm = project.metadata?.packageManager || 'npm';
+      const npxLike = pm === 'npm' ? 'npx' : pm;
+      return {
+        install: { label: 'Prisma install', command: [pm, 'install', '@prisma/client'], source: 'framework' },
+        generate: { label: 'Prisma generate', command: [npxLike, 'prisma', 'generate'], source: 'framework' },
+        studio: { label: 'Prisma studio', command: [npxLike, 'prisma', 'studio'], source: 'framework' }
+      };
+    }
+  },
+  {
+    id: 'rocket',
+    name: 'Rocket',
+    icon: '🚀',
+    description: 'Rocket Rust Web',
+    languages: ['Rust'],
+    priority: 105,
+    match(project) {
+      return dependencyMatches(project, 'rocket');
+    },
+    commands() {
+      return {
+        install: { label: 'Cargo Fetch', command: ['cargo', 'fetch'], source: 'framework' },
+        run: { label: 'Rocket Run', command: ['cargo', 'run'], source: 'framework' },
+        test: { label: 'Rocket Test', command: ['cargo', 'test'], source: 'framework' }
+      };
+    }
+  },
+  {
+    id: 'laravel',
+    name: 'Laravel',
+    icon: '🧡',
+    description: 'Laravel PHP Framework',
+    languages: ['PHP'],
+    priority: 105,
+    match(project) {
+      return hasProjectFile(project.path, 'artisan') || dependencyMatches(project, 'laravel/framework');
+    },
+    commands() {
+      return {
+        install: { label: 'Composer install', command: ['composer', 'install'], source: 'framework' },
+        run: { label: 'Artisan Serve', command: ['php', 'artisan', 'serve'], source: 'framework' },
+        test: { label: 'Artisan Test', command: ['php', 'artisan', 'test'], source: 'framework' },
+        migrate: { label: 'Artisan Migrate', command: ['php', 'artisan', 'migrate'], source: 'framework' }
+      };
+    }
+  }
+];

package/src/detectors/generic.js

@@ -0,0 +1,28 @@
+import path from 'path';
+
+export default {
+  type: 'generic',
+  label: 'Custom project',
+  icon: '🧰',
+  priority: 10,
+  files: ['README.md', 'Makefile', 'build.sh'],
+  binaries: [],
+  async build(projectPath, manifest) {
+    return {
+      id: `${projectPath}::generic`,
+      path: projectPath,
+      name: path.basename(projectPath),
+      type: 'Custom',
+      icon: '🧰',
+      priority: this.priority,
+      commands: {},
+      metadata: {},
+      manifest: path.basename(manifest),
+      description: 'Detected via README or Makefile layout.',
+      missingBinaries: [],
+      extra: {
+        setupHints: ['Read the README for custom build instructions']
+      }
+    };
+  }
+};

package/src/detectors/go.js

@@ -0,0 +1,35 @@
+import path from 'path';
+import { checkBinary } from './utils.js';
+
+export default {
+  type: 'go',
+  label: 'Go',
+  icon: '🐹',
+  priority: 85,
+  files: ['go.mod'],
+  binaries: ['go'],
+  async build(projectPath, manifest) {
+    const missingBinaries = this.binaries.filter(b => !checkBinary(b));
+    return {
+      id: `${projectPath}::go`,
+      path: projectPath,
+      name: 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', '.'] }
+      },
+      metadata: {},
+      manifest: path.basename(manifest),
+      description: '',
+      missingBinaries,
+      extra: {
+        setupHints: ['go mod tidy', 'Ensure Go toolchain is installed']
+      }
+    };
+  }
+};

package/src/detectors/java.js

@@ -0,0 +1,46 @@
+import path from 'path';
+import { checkBinary, hasProjectFile } from './utils.js';
+
+export default {
+  type: 'java',
+  label: 'Java',
+  icon: '☕️',
+  priority: 80,
+  files: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+  binaries: ['java', 'javac'],
+  async build(projectPath, manifest) {
+    const missingBinaries = this.binaries.filter(b => !checkBinary(b));
+    const hasMvnw = hasProjectFile(projectPath, 'mvnw');
+    const hasGradlew = hasProjectFile(projectPath, 'gradlew');
+    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'] };
+    } else {
+      commands.build = { label: 'Maven package', command: ['mvn', 'package'] };
+      commands.test = { label: 'Maven test', command: ['mvn', 'test'] };
+    }
+
+    return {
+      id: `${projectPath}::java`,
+      path: projectPath,
+      name: path.basename(projectPath),
+      type: 'Java',
+      icon: '☕️',
+      priority: this.priority,
+      commands,
+      metadata: {},
+      manifest: path.basename(manifest),
+      description: '',
+      missingBinaries,
+      extra: {
+        setupHints: ['Install JDK 17+ and run ./mvnw install or ./gradlew build']
+      }
+    };
+  }
+};

package/src/detectors/node.js

@@ -0,0 +1,82 @@
+import fs from 'fs';
+import path from 'path';
+import { getPackageManager, checkBinary, hasProjectFile } from './utils.js';
+
+function gatherNodeDependencies(pkg) {
+  const deps = new Set();
+  ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'].forEach((key) => {
+    if (pkg[key]) {
+      Object.keys(pkg[key]).forEach((name) => deps.add(name));
+    }
+  });
+  return Array.from(deps);
+}
+
+export default {
+  type: 'node',
+  label: 'Node.js',
+  icon: '🟢',
+  priority: 100,
+  files: ['package.json'],
+  binaries: ['node', 'npm'],
+  async build(projectPath, manifest) {
+    const missingBinaries = this.binaries.filter(b => !checkBinary(b));
+    const pkgPath = path.join(projectPath, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+      return null;
+    }
+    const content = await fs.promises.readFile(pkgPath, 'utf-8');
+    const pkg = JSON.parse(content);
+    const pm = getPackageManager(projectPath);
+    const scripts = pkg.scripts || {};
+    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] };
+          break;
+        }
+      }
+    };
+    commands.install = { label: 'Install', command: [pm, 'install'] };
+    preferScript('build', ['build', 'compile', 'dist'], 'Build');
+    preferScript('test', ['test', 'check', 'spec'], 'Test');
+    preferScript('run', ['start', 'dev', 'serve', 'run'], 'Start');
+    if (Object.prototype.hasOwnProperty.call(scripts, 'lint')) {
+      commands.lint = { label: 'Lint', command: [pm, 'run', 'lint'] };
+    }
+
+    const metadata = {
+      dependencies: gatherNodeDependencies(pkg),
+      scripts,
+      packageJson: pkg,
+      packageManager: getPackageManager(projectPath)
+    };
+
+    const setupHints = [];
+    if (metadata.dependencies.length) {
+      setupHints.push('Run npm install to fetch dependencies.');
+      if (hasProjectFile(projectPath, 'yarn.lock')) {
+        setupHints.push('Or run yarn install if you prefer Yarn.');
+      }
+    }
+
+    return {
+      id: `${projectPath}::node`,
+      path: projectPath,
+      name: pkg.name || path.basename(projectPath),
+      type: 'Node.js',
+      icon: '🟢',
+      priority: this.priority,
+      commands,
+      metadata,
+      manifest: path.basename(manifest),
+      description: pkg.description || '',
+      missingBinaries,
+      extra: {
+        scripts: Object.keys(scripts),
+        setupHints
+      }
+    };
+  }
+};

package/src/detectors/python.js

@@ -0,0 +1,97 @@
+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'];
+
+function findPythonEntry(projectPath) {
+  return PYTHON_ENTRY_FILES.find((file) => hasProjectFile(projectPath, file)) || null;
+}
+
+function gatherPythonDependencies(projectPath) {
+  const set = new Set();
+  const addFromFile = (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);
+        }
+      }
+    });
+  };
+  addFromFile(path.join(projectPath, 'requirements.txt'));
+  addFromFile(path.join(projectPath, 'Pipfile'));
+  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);
+      }
+    });
+  }
+  return Array.from(set);
+}
+
+export default {
+  type: 'python',
+  label: 'Python',
+  icon: '🐍',
+  priority: 95,
+  files: ['pyproject.toml', 'requirements.txt', 'setup.py', 'Pipfile'],
+  binaries: [process.platform === 'win32' ? 'python' : 'python3', 'pip'],
+  async build(projectPath, manifest) {
+    const missingBinaries = this.binaries.filter(b => !checkBinary(b));
+    const commands = {};
+    if (hasProjectFile(projectPath, 'requirements.txt')) {
+      commands.install = { label: 'Pip Install', command: ['pip', 'install', '-r', 'requirements.txt'] };
+    }
+    if (hasProjectFile(projectPath, 'pyproject.toml')) {
+      commands.test = { label: 'Pytest', command: ['pytest'] };
+    } else {
+      commands.test = { label: 'Unittest', command: ['python', '-m', 'unittest', 'discover'] };
+    }
+
+    const entry = findPythonEntry(projectPath);
+    if (entry) {
+      commands.run = { label: 'Run', command: ['python', entry] };
+    }
+
+    const metadata = {
+      dependencies: gatherPythonDependencies(projectPath)
+    };
+
+    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');
+    }
+
+    return {
+      id: `${projectPath}::python`,
+      path: projectPath,
+      name: path.basename(projectPath),
+      type: 'Python',
+      icon: '🐍',
+      priority: this.priority,
+      commands,
+      metadata,
+      manifest: path.basename(manifest),
+      description: '',
+      missingBinaries,
+      extra: {
+        entry,
+        setupHints
+      }
+    };
+  }
+};

package/src/detectors/rust.js

@@ -0,0 +1,35 @@
+import path from 'path';
+import { checkBinary } from './utils.js';
+
+export default {
+  type: 'rust',
+  label: 'Rust',
+  icon: '🦀',
+  priority: 90,
+  files: ['Cargo.toml'],
+  binaries: ['cargo', 'rustc'],
+  async build(projectPath, manifest) {
+    const missingBinaries = this.binaries.filter(b => !checkBinary(b));
+    return {
+      id: `${projectPath}::rust`,
+      path: projectPath,
+      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'] }
+      },
+      metadata: {},
+      manifest: path.basename(manifest),
+      description: '',
+      missingBinaries,
+      extra: {
+        setupHints: ['cargo fetch', 'Run cargo build before releasing']
+      }
+    };
+  }
+};

package/src/detectors/utils.js

@@ -0,0 +1,60 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+export function checkBinary(name) {
+  try {
+    const cmd = process.platform === 'win32' ? `where ${name}` : `which ${name}`;
+    execSync(cmd, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+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';
+  return 'npm';
+}
+
+export function resolveScriptCommand(project, scriptName, fallback = null) {
+  const scripts = project.metadata?.scripts || {};
+  const pm = project.metadata?.packageManager || 'npm';
+  if (Object.prototype.hasOwnProperty.call(scripts, scriptName)) {
+    return [pm, 'run', scriptName];
+  }
+  if (typeof fallback === 'function') {
+    return fallback(pm);
+  }
+  return fallback;
+}
+
+export function dependencyMatches(project, needle) {
+  const dependencies = (project.metadata?.dependencies || []).map((dep) => dep.toLowerCase());
+  const target = needle.toLowerCase();
+  return dependencies.some((value) => value === target || value.startsWith(`${target}@`) || value.includes(`/${target}`));
+}
+
+export function parseCommandTokens(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (value && typeof value === 'object') {
+    if (Array.isArray(value.command)) {
+      return value.command;
+    }
+    if (typeof value.command === 'string') {
+      return value.command.trim().split(/\s+/).filter(Boolean);
+    }
+  }
+  if (typeof value === 'string') {
+    return value.trim().split(/\s+/).filter(Boolean);
+  }
+  return [];
+}