project-compass 2.0.0 → 2.0.1

package/README.md

@@ -81,10 +81,12 @@ Projects and details now occupy the same row, while the output panel takes its o
 
 Press `S` to reveal the structure guide that lists which manifest files trigger each language detection (Node.js looks for `package.json`, Python looks for `pyproject.toml` or `requirements.txt`, Rust needs `Cargo.toml`, etc.). Use `H` to hide the help cards if you need every pixel for your output, then bring them back when you want a refresher.
 
+## Detection & setup hints
 
-## Project detection & setup hints
+Project Compass now has a modular detection engine (`src/projectDetection.js`) that looks at manifests, frameworks, and optional plugins to identify what kind of project you are standing in. Every schema fills `extra.setupHints` (npm install, pip install, go mod tidy, etc.) and those hints show up under the detail view whenever a project needs bootstrapping.
+
+Try the sample Python project at `/mnt/ramdisk/daily_builds/test_python_proj` (includes `pyproject.toml`, `requirements.txt`, and `app.py`) so you can run it via Project Compass and confirm stdin/input behavior.
 
-Project Compass now points at a dedicated detection module (`src/projectDetection.js`). It runs a set of SCHEMAS that look for Node.js, Python, Rust, Go, Java, Scala, PHP, Ruby, .NET, and shell/Makefile projects (plus a generic fallback), and it discovers any plugins you drop under `~/.project-compass/plugins.json`. Each detected project carries `setupHints` (e.g., `npm install`, `pip install -r requirements.txt`, `cargo fetch`) so you know what to do before running the commands listed in the detail view.
 
 
 ## Developer notes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-compass",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Ink-based project explorer that detects local repos and lets you build/test/run them without memorizing commands.",
   "main": "src/cli.js",
   "type": "module",

package/src/projectDetection.js

@@ -5,6 +5,21 @@ import {ensureConfigDir, PLUGIN_FILE} from './configPaths.js';
 
 const IGNORE_PATTERNS = ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**', '**/target/**'];
 
+function hasProjectFile(projectPath, file) {
+  return fs.existsSync(path.join(projectPath, file));
+}
+
+function resolveScriptCommand(project, scriptName, fallback = null) {
+  const scripts = project.metadata?.scripts || {};
+  if (Object.prototype.hasOwnProperty.call(scripts, scriptName)) {
+    return ['npm', 'run', scriptName];
+  }
+  if (typeof fallback === 'function') {
+    return fallback();
+  }
+  return fallback;
+}
+
 function gatherNodeDependencies(pkg) {
   const deps = new Set();
   ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'].forEach((key) => {
@@ -71,6 +86,286 @@ function parseCommandTokens(value) {
   return [];
 }
 
+const builtInFrameworks = [
+  {
+    id: 'next',
+    name: 'Next.js',
+    icon: '🧭',
+    description: 'React + Next.js (SSR/SSG) apps',
+    languages: ['Node.js'],
+    priority: 115,
+    match(project) {
+      const hasNextConfig = hasProjectFile(project.path, 'next.config.js');
+      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'};
+        }
+      };
+      const buildFallback = () => ['npx', 'next', 'build'];
+      const startFallback = () => ['npx', 'next', 'start'];
+      const devFallback = () => ['npx', 'next', 'dev'];
+      add('run', 'Next dev', devFallback);
+      add('build', 'Next build', buildFallback);
+      add('test', 'Next test', () => ['npm', 'run', 'test']);
+      add('start', 'Next start', startFallback);
+      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'));
+    },
+    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('run', 'React dev', () => ['npm', 'run', 'dev']);
+      add('build', 'React build', () => ['npm', 'run', 'build']);
+      add('test', 'React test', () => ['npm', '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') || 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('run', 'Vue dev', () => ['npm', 'run', 'dev']);
+      add('build', 'Vue build', () => ['npm', 'run', 'build']);
+      add('test', 'Vue test', () => ['npm', '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');
+    },
+    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('run', 'Nest dev', () => ['npm', 'run', 'start:dev']);
+      add('build', 'Nest build', () => ['npm', 'run', 'build']);
+      add('test', 'Nest test', () => ['npm', 'run', 'test']);
+      return commands;
+    }
+  },
+  {
+    id: 'angular',
+    name: 'Angular',
+    icon: '🅰️',
+    description: 'Angular CLI projects',
+    languages: ['Node.js'],
+    priority: 109,
+    match(project) {
+      return hasProjectFile(project.path, 'angular.json') || dependencyMatches(project, '@angular/cli');
+    },
+    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('run', 'Angular serve', () => ['npm', 'run', 'start']);
+      add('build', 'Angular build', () => ['npm', 'run', 'build']);
+      add('test', 'Angular test', () => ['npm', 'run', 'test']);
+      return commands;
+    }
+  },
+  {
+    id: 'sveltekit',
+    name: 'SvelteKit',
+    icon: '🌀',
+    description: 'SvelteKit apps',
+    languages: ['Node.js'],
+    priority: 108,
+    match(project) {
+      return hasProjectFile(project.path, 'svelte.config.js') || dependencyMatches(project, '@sveltejs/kit');
+    },
+    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('run', 'SvelteKit dev', () => ['npm', 'run', 'dev']);
+      add('build', 'SvelteKit build', () => ['npm', 'run', 'build']);
+      add('test', 'SvelteKit test', () => ['npm', 'run', 'test']);
+      add('preview', 'SvelteKit preview', () => ['npm', 'run', 'preview']);
+      return commands;
+    }
+  },
+  {
+    id: 'nuxt',
+    name: 'Nuxt',
+    icon: '🪄',
+    description: 'Nuxt.js / Vue SSR',
+    languages: ['Node.js'],
+    priority: 107,
+    match(project) {
+      return hasProjectFile(project.path, 'nuxt.config.js') || dependencyMatches(project, 'nuxt');
+    },
+    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('run', 'Nuxt dev', () => ['npm', 'run', 'dev']);
+      add('build', 'Nuxt build', () => ['npm', 'run', 'build']);
+      add('start', 'Nuxt start', () => ['npm', 'run', 'start']);
+      return commands;
+    }
+  },
+  {
+    id: 'astro',
+    name: 'Astro',
+    icon: '✨',
+    description: 'Astro static sites',
+    languages: ['Node.js'],
+    priority: 106,
+    match(project) {
+      const matches = ['astro.config.mjs', 'astro.config.ts'].some((file) => hasProjectFile(project.path, file));
+      return matches || dependencyMatches(project, 'astro');
+    },
+    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('run', 'Astro dev', () => ['npm', 'run', 'dev']);
+      add('build', 'Astro build', () => ['npm', 'run', 'build']);
+      add('preview', 'Astro preview', () => ['npm', 'run', 'preview']);
+      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 managePath = path.join(project.path, 'manage.py');
+      if (!fs.existsSync(managePath)) {
+        return {};
+      }
+      return {
+        run: {label: 'Django runserver', command: ['python', 'manage.py', 'runserver'], source: 'framework'},
+        test: {label: 'Django test', command: ['python', 'manage.py', 'test'], source: 'framework'},
+        migrate: {label: 'Django migrate', command: ['python', 'manage.py', 'migrate'], source: 'framework'}
+      };
+    }
+  },
+  {
+    id: 'flask',
+    name: 'Flask',
+    icon: '🍶',
+    description: 'Flask microservices',
+    languages: ['Python'],
+    priority: 105,
+    match(project) {
+      return dependencyMatches(project, 'flask') || hasProjectFile(project.path, 'app.py');
+    },
+    commands(project) {
+      const entry = hasProjectFile(project.path, 'app.py') ? 'app.py' : 'main.py';
+      return {
+        run: {label: 'Flask app', command: ['python', entry], source: 'framework'},
+        test: {label: 'Pytest', command: ['pytest'], source: 'framework'}
+      };
+    }
+  },
+  {
+    id: 'fastapi',
+    name: 'FastAPI',
+    icon: '⚡',
+    description: 'FastAPI + Uvicorn',
+    languages: ['Python'],
+    priority: 105,
+    match(project) {
+      return dependencyMatches(project, 'fastapi');
+    },
+    commands(project) {
+      const entry = hasProjectFile(project.path, 'main.py') ? 'main.py' : 'app.py';
+      return {
+        run: {label: 'Uvicorn reload', command: ['uvicorn', `${entry.split('.')[0]}:app`, '--reload'], source: 'framework'},
+        test: {label: 'Pytest', command: ['pytest'], source: 'framework'}
+      };
+    }
+  },
+  {
+    id: 'spring',
+    name: 'Spring Boot',
+    icon: '🌱',
+    description: 'Spring Boot apps',
+    languages: ['Java'],
+    priority: 105,
+    match(project) {
+      return dependencyMatches(project, 'spring-boot-starter') || hasProjectFile(project.path, 'src/main/java');
+    },
+    commands(project) {
+      const hasMvnw = hasProjectFile(project.path, 'mvnw');
+      const base = hasMvnw ? './mvnw' : 'mvn';
+      return {
+        run: {label: 'Spring Boot run', command: [base, 'spring-boot:run'], source: 'framework'},
+        build: {label: 'Maven package', command: [base, 'package'], source: 'framework'},
+        test: {label: 'Maven test', command: [base, 'test'], source: 'framework'}
+      };
+    }
+  }
+];
+
 class SchemaRegistry {
   constructor() {
     this.cache = null;
@@ -102,10 +397,10 @@ class SchemaRegistry {
           const pkg = JSON.parse(content);
           const scripts = pkg.scripts || {};
           const commands = {};
-          const preferScript = (targetKey, names, label) => {
+          const preferScript = (targetKey, names, labelText) => {
             for (const name of names) {
               if (Object.prototype.hasOwnProperty.call(scripts, name)) {
-                commands[targetKey] = {label, command: ['npm', 'run', name]};
+                commands[targetKey] = {label: labelText, command: ['npm', 'run', name]};
                 break;
               }
             }
@@ -126,7 +421,7 @@ class SchemaRegistry {
           const setupHints = [];
           if (metadata.dependencies.length) {
             setupHints.push('Run npm install to fetch dependencies.');
-            if (fs.existsSync(path.join(projectPath, 'yarn.lock'))) {
+            if (hasProjectFile(projectPath, 'yarn.lock')) {
               setupHints.push('Or run yarn install if you prefer Yarn.');
             }
           }
@@ -157,7 +452,7 @@ class SchemaRegistry {
         files: ['pyproject.toml', 'requirements.txt', 'setup.py', 'Pipfile'],
         async build(projectPath, manifest) {
           const commands = {};
-          if (fs.existsSync(path.join(projectPath, 'pyproject.toml'))) {
+          if (hasProjectFile(projectPath, 'pyproject.toml')) {
             commands.test = {label: 'Pytest', command: ['pytest']};
           } else {
             commands.test = {label: 'Unittest', command: ['python', '-m', 'unittest', 'discover']};
@@ -173,12 +468,11 @@ class SchemaRegistry {
           };
 
           const setupHints = [];
-          const reqPath = path.join(projectPath, 'requirements.txt');
-          if (fs.existsSync(reqPath)) {
+          if (hasProjectFile(projectPath, 'requirements.txt')) {
             setupHints.push('pip install -r requirements.txt');
           }
-          if (fs.existsSync(path.join(projectPath, 'Pipfile'))) {
-            setupHints.push('pipenv install --dev or poetry install');
+          if (hasProjectFile(projectPath, 'Pipfile')) {
+            setupHints.push('Use pipenv install --dev or poetry install');
           }
 
           return {
@@ -201,8 +495,7 @@ class SchemaRegistry {
         findPythonEntry(projectPath) {
           const candidates = ['main.py', 'app.py', 'src/main.py', 'src/app.py'];
           for (const candidate of candidates) {
-            const candidatePath = path.join(projectPath, candidate);
-            if (fs.existsSync(candidatePath)) {
+            if (hasProjectFile(projectPath, candidate)) {
               return candidate;
             }
           }
@@ -272,8 +565,8 @@ class SchemaRegistry {
         priority: 80,
         files: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
         async build(projectPath, manifest) {
-          const hasMvnw = fs.existsSync(path.join(projectPath, 'mvnw'));
-          const hasGradlew = fs.existsSync(path.join(projectPath, 'gradlew'));
+          const hasMvnw = hasProjectFile(projectPath, 'mvnw');
+          const hasGradlew = hasProjectFile(projectPath, 'gradlew');
           const commands = {};
           if (hasGradlew) {
             commands.build = {label: 'Gradle build', command: ['./gradlew', 'build']};
@@ -285,6 +578,7 @@ class SchemaRegistry {
             commands.build = {label: 'Maven package', command: ['mvn', 'package']};
             commands.test = {label: 'Maven test', command: ['mvn', 'test']};
           }
+
           return {
             id: `${projectPath}::java`,
             path: projectPath,
@@ -297,7 +591,7 @@ class SchemaRegistry {
             manifest: path.basename(manifest),
             description: '',
             extra: {
-              setupHints: ['Install JDK 17+ and run ./mvnw install / ./gradlew build']
+              setupHints: ['Install JDK 17+ and run ./mvnw install or ./gradlew build']
             }
           };
         }
@@ -345,7 +639,7 @@ class SchemaRegistry {
             icon: '🐘',
             priority: this.priority,
             commands: {
-              test: {label: 'PHPStorm', command: ['php', '-v']}
+              test: {label: 'PHP -v', command: ['php', '-v']}
             },
             metadata: {},
             manifest: path.basename(manifest),
@@ -469,9 +763,6 @@ class SchemaRegistry {
 
 const schemaRegistry = new SchemaRegistry();
 
-const builtInFrameworks = [];
-
-
 function loadUserFrameworks() {
   ensureConfigDir();
   if (!fs.existsSync(PLUGIN_FILE)) {
@@ -484,7 +775,7 @@ function loadUserFrameworks() {
       const normalizedId = entry.id || (entry.name ? entry.name.toLowerCase().replace(/\s+/g, '-') : `plugin-${Math.random().toString(36).slice(2, 8)}`);
       const commands = {};
       Object.entries(entry.commands || {}).forEach(([key, value]) => {
-        const tokens = parseCommandTokens(value);
+        const tokens = parseCommandTokens(typeof value === 'object' ? value.command : value);
         if (!tokens.length) {
           return;
         }
@@ -507,8 +798,7 @@ function loadUserFrameworks() {
         commands,
         match: entry.match
       };
-    })
-      .filter((plugin) => plugin.name && plugin.commands && Object.keys(plugin.commands).length);
+    }).filter((plugin) => plugin.name && plugin.commands && Object.keys(plugin.commands).length);
   } catch (error) {
     console.error(`Failed to parse plugins.json: ${error.message}`);
     return [];
@@ -530,7 +820,7 @@ function matchesPlugin(project, plugin) {
     return false;
   }
   if (plugin.files && plugin.files.length > 0) {
-    const hit = plugin.files.some((file) => fs.existsSync(path.join(project.path, file)));
+    const hit = plugin.files.some((file) => hasProjectFile(project.path, file));
     if (!hit) {
       return false;
     }