project-compass 4.3.6 → 4.3.8

package/src/components/Header.js

@@ -1,60 +1,21 @@
 import React from 'react';
 import { Box, Text } from 'ink';
-import path from 'path';
 
-const SPARKS = ['✦', '✧', '✩', '✪', '✫'];
-
-export default function Header({ projectCountLabel, rootPath, running, toggleHint, orbitHint }) {
-  const time = new Date().toLocaleTimeString('en-US', { hour12: false });
-  const spark = SPARKS[Math.floor(Date.now() / 1000) % SPARKS.length];
-  
+export default function Header({ projectCountLabel, rootPath, running, statusHint, toggleHint, orbitHint, artHint }) {
   return React.createElement(
     Box,
-    { flexDirection: 'column', marginBottom: 1 },
-    // Top bar with logo and status
-    React.createElement(
-      Box,
-      { justifyContent: 'space-between', alignItems: 'center' },
-      React.createElement(
-        Box,
-        { flexDirection: 'row', alignItems: 'center' },
-        React.createElement(Text, { color: 'magenta', bold: true }, '🧭 '),
-        React.createElement(Text, { color: 'magenta', bold: true }, 'PROJECT COMPASS'),
-        React.createElement(Text, { color: 'cyan' }, ` ${spark}`)
-      ),
-      React.createElement(
-        Box,
-        { flexDirection: 'row', alignItems: 'center' },
-        React.createElement(Text, { 
-          color: running ? 'yellow' : 'green', 
-          bold: true 
-        }, running ? '⚡ ACTIVE' : '✓ IDLE'),
-        React.createElement(Text, { dimColor: true }, ` ${time}`)
-      )
-    ),
-    // Info bar
+    { justifyContent: 'space-between' },
     React.createElement(
       Box,
-      { justifyContent: 'space-between', marginTop: 0 },
-      React.createElement(
-        Box,
-        { flexDirection: 'row' },
-        React.createElement(Text, { dimColor: true }, `${spark} `),
-        React.createElement(Text, { color: 'cyan' }, projectCountLabel),
-        React.createElement(Text, { dimColor: true }, ' in '),
-        React.createElement(Text, { color: 'white' }, path.basename(rootPath))
-      ),
-      React.createElement(
-        Box,
-        { flexDirection: 'row' },
-        React.createElement(Text, { dimColor: true }, `${toggleHint} · ${orbitHint}`)
-      )
+      { flexDirection: 'column' },
+      React.createElement(Text, { color: 'magenta', bold: true }, 'Project Compass'),
+      React.createElement(Text, { dimColor: true }, `${projectCountLabel} detected in ${rootPath}`)
     ),
-    // Separator
     React.createElement(
       Box,
-      { marginTop: 0 },
-      React.createElement(Text, { dimColor: true }, '─'.repeat(50))
+      { flexDirection: 'column', alignItems: 'flex-end' },
+      React.createElement(Text, { color: running ? 'yellow' : 'green' }, statusHint),
+      React.createElement(Text, { dimColor: true }, `${toggleHint} · ${orbitHint} · ${artHint} · Shift+Q: Quit`)
     )
   );
 }

package/src/components/Navigator.js

@@ -1,102 +1,48 @@
-/* global setInterval, clearInterval */
-import React, { useMemo, useState, useEffect } from 'react';
+import React, { useMemo } from 'react';
 import { Box, Text } from 'ink';
 import path from 'path';
 
-const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-const SELECTION_BAR = '█';
-
 export default function Navigator({ 
   projects, 
   selectedIndex, 
   rootPath, 
   loading, 
   error, 
-  maxVisibleProjects = 3 
+  maxVisibleProjects = 3
 }) {
-  const [tick, setTick] = useState(0);
-  
-  useEffect(() => {
-    if (!loading) return;
-    const timer = setInterval(() => setTick(t => t + 1), 100);
-    return () => clearInterval(timer);
-  }, [loading]);
-  
   const page = Math.floor(selectedIndex / maxVisibleProjects);
   const start = page * maxVisibleProjects;
   const end = start + maxVisibleProjects;
   const visibleProjects = projects.slice(start, end);
-  
+
   const projectRows = useMemo(() => {
-    if (loading) {
-      const spinner = SPINNER[tick % SPINNER.length];
-      return [React.createElement(
-        Box,
-        { key: 'scanning', flexDirection: 'row', alignItems: 'center' },
-        React.createElement(Text, { color: 'cyan' }, ` ${spinner} `),
-        React.createElement(Text, { dimColor: true }, 'Scanning projects…'),
-        React.createElement(Text, { color: 'cyan' }, ' ●'.repeat(3 + (tick % 3)))
-      )];
-    }
-    if (error) return [React.createElement(
-      Box,
-      { key: 'error', flexDirection: 'row', alignItems: 'center' },
-      React.createElement(Text, { color: 'red', bold: true }, ' ✗ '),
-      React.createElement(Text, { color: 'red' }, `Unable to scan: ${error}`)
-    )];
-    if (projects.length === 0) return [React.createElement(
-      Box,
-      { key: 'empty', flexDirection: 'row', alignItems: 'center' },
-      React.createElement(Text, { color: 'yellow' }, ' ⚠ '),
-      React.createElement(Text, { dimColor: true }, 'No recognizable project manifests found.')
-    )];
+    if (loading) return [React.createElement(Text, { key: 'scanning', dimColor: true }, 'Scanning projects…')];
+    if (error) return [React.createElement(Text, { key: 'error', color: 'red' }, `Unable to scan: ${error}`)];
+    if (projects.length === 0) return [React.createElement(Text, { key: 'empty', dimColor: true }, 'No recognizable project manifests found.')];
 
     return visibleProjects.map((project, index) => {
       const absoluteIndex = start + index;
       const isSelected = absoluteIndex === selectedIndex;
-      const frameworkBadges = (project.frameworks || []).map((frame) => 
-        React.createElement(Text, { key: frame.name, color: 'cyan', dimColor: !isSelected }, ` ${frame.icon}${frame.name}`)
-      );
+      const frameworkBadges = (project.frameworks || []).map((frame) => `${frame.icon} ${frame.name}`).join(', ');
       const hasMissingRuntime = project.missingBinaries && project.missingBinaries.length > 0;
       
       return React.createElement(
         Box,
-        { 
-          key: project.id, 
-          flexDirection: 'column', 
-          marginBottom: 0,
-          borderStyle: isSelected ? 'bold' : 'single',
-          borderColor: isSelected ? 'cyan' : 'gray',
-          paddingX: 1,
-          paddingY: 0
-        },
+        { key: project.id, flexDirection: 'column', marginBottom: 1, padding: 1 },
         React.createElement(
           Box,
-          { flexDirection: 'row', alignItems: 'center' },
-          React.createElement(Text, { 
-            color: isSelected ? 'cyan' : 'white', 
-            bold: isSelected 
-          }, `${isSelected ? SELECTION_BAR + ' ' : '  '}${project.icon} ${project.name}`),
-          hasMissingRuntime && React.createElement(Text, { color: 'red', bold: true }, '  ⚠ Runtime missing')
+          { flexDirection: 'row' },
+          React.createElement(Text, { color: isSelected ? 'cyan' : 'white', bold: isSelected }, `${project.icon} ${project.name}`),
+          hasMissingRuntime && React.createElement(Text, { color: 'red', bold: true }, '  ⚠️ Runtime missing')
         ),
-        React.createElement(
-          Box,
-          { flexDirection: 'row', alignItems: 'center' },
-          React.createElement(Text, { dimColor: true }, `  ${project.type}`),
-          React.createElement(Text, { dimColor: true }, ` · ${path.relative(rootPath, project.path) || '.'}`)
-        ),
-        frameworkBadges.length > 0 && React.createElement(
-          Box,
-          { marginTop: 0 },
-          React.createElement(Text, { dimColor: true }, '  '),
-          ...frameworkBadges
-        )
+        React.createElement(Text, { dimColor: true }, `  ${project.type} · ${path.relative(rootPath, project.path) || '.'}`),
+        frameworkBadges && React.createElement(Text, { dimColor: true }, `   ${frameworkBadges}`)
       );
     });
-  }, [loading, error, projects.length, visibleProjects, selectedIndex, start, rootPath, tick]);
+  }, [loading, error, projects.length, visibleProjects, selectedIndex, start, rootPath]);
 
   const totalPages = Math.ceil(projects.length / maxVisibleProjects);
-  
+
   return React.createElement(
     Box,
     { flexDirection: 'column' },
@@ -104,7 +50,7 @@ export default function Navigator({
     projects.length > maxVisibleProjects && React.createElement(
       Box,
       { marginTop: 1, justifyContent: 'center' },
-      React.createElement(Text, { dimColor: true }, `${'-'.repeat(3)} Page ${page + 1}/${totalPages} (${projects.length} projects) ${'-'.repeat(3)}`)
+      React.createElement(Text, { dimColor: true }, `Page ${page + 1} of ${totalPages} (Total: ${projects.length})`)
     )
   );
 }

package/src/components/PackageRegistry.js

@@ -88,11 +88,12 @@ const PackageRegistry = memo(({selectedProject, projects = [], onRunCommand, Cur
       return;
     }
 
-    if (inputStr.toLowerCase() === 'a') { setMode('add'); setInput(''); setCursor(0); }
-    if (inputStr.toLowerCase() === 'r') { setMode('remove'); setInput(''); setCursor(0); }
-    if (inputStr.toLowerCase() === 's') { setView('select'); }
+    if (inputStr.toLowerCase() === 'a') { setMode('add'); setInput(''); setCursor(0); return; }
+    if (inputStr.toLowerCase() === 'r') { setMode('remove'); setInput(''); setCursor(0); return; }
+    if (inputStr.toLowerCase() === 's') { setView('select'); return; }
     if (inputStr.toLowerCase() === 'v' && projectType === 'Python') {
       onRunCommand({label: 'Create venv', command: ['python3', '-m', 'venv', '.venv']}, activeProject);
+      return;
     }
   });
 

package/src/components/ProjectArchitect.js

@@ -20,7 +20,12 @@ const ProjectArchitect = memo(({rootPath, onRunCommand, CursorText, onReturn}) =
     {name: 'Rust (Binary)', cmd: (p, n) => ['cargo', 'new', path.join(p, n)]},
     {name: 'Django Project', cmd: (p, n) => ['django-admin', 'startproject', n, path.join(p, n)]},
     {name: 'Python (Basic)', cmd: (p, n) => ['mkdir', '-p', path.join(p, n)]},
-    {name: 'Go Module', cmd: (p, n) => ['mkdir', '-p', path.join(p, n), '&&', 'cd', path.join(p, n), '&&', 'go', 'mod', 'init', n]}
+    {name: 'Go Module', cmd: (p, n) => {
+      const dir = path.join(p, n);
+      return process.platform === 'win32'
+        ? ['cmd', '/c', `mkdir "${dir}" && cd /d "${dir}" && go mod init ${n}`]
+        : ['sh', '-c', `mkdir -p "${dir}" && cd "${dir}" && go mod init ${n}`];
+    }}
   ];
 
   useInput((inputStr, key) => {

package/src/components/TaskManager.js

@@ -2,80 +2,22 @@ import React, {memo} from 'react';
 import {Box, Text} from 'ink';
 
 const create = React.createElement;
-const STATUC_COLORS = { running: 'green', finished: 'cyan', failed: 'red', killed: 'yellow' };
 
 const TaskManager = memo(({tasks, activeTaskId, renameMode, renameInput, renameCursor, CursorText}) => {
-  const activeTask = tasks.find(t => t.id === activeTaskId);
-  const logLines = activeTask?.logs || [];
-  const visibleLogs = logLines.slice(-5);
-  
   return create(
     Box,
-    {flexDirection: 'column', borderStyle: 'double', borderColor: 'yellow', padding: 1, height: '100%'},
-    // Header
-    create(Box, {flexDirection: 'row', justifyContent: 'space-between', marginBottom: 1},
-      create(Box, {flexDirection: 'row', alignItems: 'center'},
-        create(Text, {bold: true, color: 'yellow'}, '🛰️ '),
-        create(Text, {bold: true, color: 'yellow'}, 'Orbit Task Manager'),
-        create(Text, {dimColor: true}, ` | ${tasks.length} task${tasks.length !== 1 ? 's' : ''}`)
-      ),
-      tasks.length > 0 && create(Text, {color: 'cyan', bold: true}, 
-        `[${tasks.filter(t => t.status === 'running').length} ACTIVE]`)
-    ),
-    
-    // Task List
-    create(Box, {flexDirection: 'column', flexGrow: 1},
-      ...tasks.map((t, idx) => {
-        const isActive = t.id === activeTaskId;
-        const color = STATUC_COLORS[t.status] || 'white';
-        return create(
-          Box,
-          {key: t.id, marginBottom: 0, 
-           borderStyle: isActive ? 'bold' : 'single',
-           borderColor: isActive ? color : 'gray',
-           paddingX: 1, paddingY: 0},
-          create(Box, {flexDirection: 'column'},
-            // Task header
-            isActive && renameMode 
-              ? create(Box, {flexDirection: 'row'}, 
-                  create(Text, {color: 'cyan'}, '→ Rename: '), 
-                  create(CursorText, {value: renameInput, cursorIndex: renameCursor}))
-              : create(Box, {flexDirection: 'row', justifyContent: 'space-between'},
-                  create(Box, {flexDirection: 'row', alignItems: 'center'},
-                    create(Text, {color: isActive ? color : 'white', bold: isActive}, 
-                      `${isActive ? '→ ' : '  '}[${t.status.toUpperCase()}] ${t.name}`),
-                    t.status === 'running' && create(Text, {color: 'green'}, ' ⚡'),
-                    t.status === 'failed' && create(Text, {color: 'red'}, ' ✗'),
-                    t.status === 'killed' && create(Text, {color: 'yellow'}, ' ⚠')
-                  ),
-                  create(Text, {dimColor: true}, `#${idx + 1}`)
-                ),
-            // Mini log preview for active task
-            isActive && logLines.length > 0 && create(
-              Box, {marginTop: 0, paddingLeft: 2},
-              ...visibleLogs.map((line, i) => 
-                create(Text, {key: i, dimColor: true}, 
-                  `${i === visibleLogs.length - 1 ? '>' : '·'} ${line.slice(0, 60)}`)
-              )
-            )
-          )
-        );
-      }),
-      !tasks.length && create(
-        Box, {alignItems: 'center', justifyContent: 'center', flexGrow: 1},
-        create(Text, {dimColor: true, bold: true}, 'No active tasks'),
-        create(Text, {dimColor: true}, 'Run a command to see it here!')
-      )
-    ),
-    
-    // Footer
-    create(Box, {marginTop: 1, flexDirection: 'column'},
-      create(Box, {flexDirection: 'row', justifyContent: 'space-between'},
-        create(Text, {dimColor: true}, '↑/↓: Navigate | Enter: Select'),
-        create(Text, {dimColor: true}, 'Shift+K: Kill | Shift+R: Rename')
-      ),
-      create(Text, {dimColor: true}, 'Press Enter or Shift+T to return to Navigator.')
-    )
+    {flexDirection: 'column', borderStyle: 'round', borderColor: 'yellow', padding: 1},
+    create(Text, {bold: true, color: 'yellow'}, '🛰️ Orbit Task Manager | Background Processes'),
+    create(Text, {dimColor: true, marginBottom: 1}, 'Up/Down: focus, Shift+K: Force Kill, Shift+R: Rename'),
+    ...tasks.map(t => create(
+      Box,
+      {key: t.id, marginBottom: 0, flexDirection: 'column'},
+      t.id === activeTaskId && renameMode 
+        ? create(Box, {flexDirection: 'row'}, create(Text, {color: 'cyan'}, '→ Rename to: '), create(CursorText, {value: renameInput, cursorIndex: renameCursor}))
+        : create(Text, {color: t.id === activeTaskId ? 'cyan' : 'white', bold: t.id === activeTaskId}, `${t.id === activeTaskId ? '→' : ' '} [${t.status.toUpperCase()}] ${t.name}`)
+    )),
+    !tasks.length && create(Text, {dimColor: true}, 'No active or background tasks.'),
+    create(Text, {marginTop: 1, dimColor: true}, 'Press Enter or Shift+T to return to Navigator.')
   );
 });
 

package/src/detectors/dotnet.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { checkBinary, hasProjectFile } from './utils.js';
+import { checkBinary } from './utils.js';
 
 function parseCsProj(content) {
   const metadata = {
@@ -78,7 +78,8 @@ export default {
       publish: { label: 'Dotnet publish', command: ['dotnet', 'publish'], source: 'builtin' }
     };
     
-    if (hasProjectFile(projectPath, '*.sln')) {
+    const hasSln = fs.readdirSync(projectPath).some(f => f.endsWith('.sln'));
+    if (hasSln) {
       commands['restore-sl'] = { label: 'Restore Solution', command: ['dotnet', 'restore'], source: 'builtin' };
     }
 

package/src/detectors/frameworks.js

@@ -73,7 +73,7 @@ export const builtInFrameworks = [
     languages: ['Node.js'],
     priority: 106,
     match(project) {
-      return dependencyMatches(project, 'koa') && !dependencyMatches(project, 'koa-router');
+      return dependencyMatches(project, 'koa');
     },
     commands(project) {
       const pm = project.metadata?.packageManager || 'npm';
@@ -324,9 +324,9 @@ export const builtInFrameworks = [
     description: 'Modern fast web framework for Python',
     languages: ['Python'],
     priority: 112,
-    match(project) {
-      return dependencyMatches(project, 'fastapi') || hasProjectFile(project.path, 'main.py');
-    },
+     match(project) {
+       return dependencyMatches(project, 'fastapi');
+     },
     commands(project) {
       const pm = project.metadata?.packageManager || 'pip';
       const isUV = pm === 'uv';
@@ -366,9 +366,9 @@ export const builtInFrameworks = [
     description: 'Django web application',
     languages: ['Python'],
     priority: 110,
-    match(project) {
-      return dependencyMatches(project, 'django') || hasProjectFile(project.path, 'manage.py');
-    },
+     match(project) {
+       return dependencyMatches(project, 'django');
+     },
     commands(project) {
       const pm = project.metadata?.packageManager || 'pip';
       const isUV = pm === 'uv';
@@ -636,9 +636,9 @@ export const builtInFrameworks = [
     description: 'Spring Boot Java framework',
     languages: ['Java'],
     priority: 115,
-    match(project) {
-      return dependencyMatches(project, 'spring-boot') || dependencyMatches(project, 'org.springframework.boot') || hasProjectFile(project.path, 'pom.xml') || hasProjectFile(project.path, 'build.gradle');
-    },
+     match(project) {
+       return dependencyMatches(project, 'spring-boot') || dependencyMatches(project, 'org.springframework.boot');
+     },
     commands(project) {
       if (hasProjectFile(project.path, 'pom.xml')) {
         return {
@@ -665,9 +665,9 @@ export const builtInFrameworks = [
     description: 'Kubernetes Native Java stack',
     languages: ['Java'],
     priority: 108,
-    match(project) {
-      return dependencyMatches(project, 'quarkus') || hasProjectFile(project.path, 'pom.xml');
-    },
+     match(project) {
+       return dependencyMatches(project, 'quarkus') || dependencyMatches(project, 'io.quarkus');
+     },
     commands() {
       return {
         run: { label: 'Quarkus Dev', command: ['mvn', 'quarkus:dev'], source: 'framework' },
@@ -683,9 +683,9 @@ export const builtInFrameworks = [
     description: 'Modern JVM-based framework',
     languages: ['Java'],
     priority: 106,
-    match(project) {
-      return dependencyMatches(project, 'micronaut') || hasProjectFile(project.path, 'pom.xml');
-    },
+     match(project) {
+       return dependencyMatches(project, 'micronaut') || dependencyMatches(project, 'io.micronaut');
+     },
     commands() {
       return {
         run: { label: 'Micronaut Run', command: ['./mvnw', 'run'], source: 'framework' },
@@ -757,9 +757,9 @@ export const builtInFrameworks = [
     description: 'Ruby on Rails framework',
     languages: ['Ruby'],
     priority: 110,
-    match(project) {
-      return hasProjectFile(project.path, 'bin/rails') || hasProjectFile(project.path, 'config/application.rb') || hasProjectFile(project.path, 'Gemfile.lock');
-    },
+     match(project) {
+       return dependencyMatches(project, 'rails') || hasProjectFile(project.path, 'bin/rails');
+     },
     commands() {
       return {
         install: { label: 'Bundle install', command: ['bundle', 'install'], source: 'framework' },
@@ -776,9 +776,9 @@ export const builtInFrameworks = [
     description: 'Sinatra DSL for quickly creating web applications',
     languages: ['Ruby'],
     priority: 105,
-    match(project) {
-      return dependencyMatches(project, 'sinatra') || hasProjectFile(project.path, 'config.ru');
-    },
+     match(project) {
+       return dependencyMatches(project, 'sinatra');
+     },
     commands() {
       return {
         install: { label: 'Bundle install', command: ['bundle', 'install'], source: 'framework' },
@@ -795,9 +795,9 @@ export const builtInFrameworks = [
     description: 'ASP.NET Core web framework',
     languages: ['.NET'],
     priority: 110,
-    match(project) {
-      return hasProjectFile(project.path, 'Program.cs') && (hasProjectFile(project.path, '*.csproj') || hasProjectFile(project.path, '*.fsproj'));
-    },
+     match(project) {
+       return dependencyMatches(project, 'Microsoft.AspNetCore') || dependencyMatches(project, 'Microsoft.AspNetCore.App');
+     },
     commands() {
       return {
         install: { label: 'Dotnet restore', command: ['dotnet', 'restore'], source: 'framework' },
@@ -814,9 +814,9 @@ export const builtInFrameworks = [
     description: 'Blazor interactive web UI with .NET',
     languages: ['.NET'],
     priority: 105,
-    match(project) {
-      return dependencyMatches(project, 'Microsoft.AspNetCore.Components.Web') || hasProjectFile(project.path, '*.csproj');
-    },
+     match(project) {
+       return dependencyMatches(project, 'Microsoft.AspNetCore.Components.Web') || dependencyMatches(project, 'Blazor');
+     },
     commands() {
       return {
         run: { label: 'Blazor Run', command: ['dotnet', 'run'], source: 'framework' },

package/src/detectors/go.js

@@ -46,16 +46,16 @@ 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 (/\bgin\b/.test(depStr) || depStr.includes('gin-gonic')) frameworks.push({ name: 'Gin', icon: '🍸' });
+  if (depStr.includes('labstack/echo')) frameworks.push({ name: 'Echo', icon: '🔊' });
+  if (depStr.includes('gofiber')) frameworks.push({ name: 'Fiber', icon: '🔥' });
+  if (depStr.includes('go-chi/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('iris-go')) 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: '🔌' });
+  if (depStr.includes('/grpc')) frameworks.push({ name: 'gRPC', icon: '🔌' });
   
   return frameworks;
 }

package/src/detectors/java.js

@@ -122,7 +122,8 @@ export default {
       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' };
+      const isSpring = frameworks.some(f => f.name === 'Spring Boot');
+      commands.run = { label: isSpring ? 'Maven spring-boot:run' : 'Maven compile', command: isSpring ? [...mvnCmd, 'spring-boot:run'] : [...mvnCmd, 'compile'], source: 'builtin' };
       commands.clean = { label: 'Maven clean', command: [...mvnCmd, 'clean'], source: 'builtin' };
     }
 

package/src/detectors/node.js

@@ -29,7 +29,6 @@ function detectNodeProjectType(pkg) {
   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: '🟢' };
 }
 
@@ -117,6 +116,8 @@ export default {
       setupHints.push('This is a monorepo with workspaces: ' + workspaces.join(', '));
     }
 
+    const detectedFrameworks = projectType.type !== 'Node.js' ? [{ name: projectType.type, icon: projectType.icon }] : [];
+
     return {
       id: `${projectPath}::node`,
       path: projectPath,
@@ -129,7 +130,7 @@ export default {
       manifest: path.basename(manifest),
       description: pkg.description || projectType.type,
       missingBinaries,
-      frameworks: [{ name: projectType.type, icon: projectType.icon }],
+      frameworks: detectedFrameworks,
       extra: {
         scripts: Object.keys(scripts),
         setupHints,

package/src/detectors/php.js

@@ -55,7 +55,7 @@ export default {
     
     const commands = {
       install: { label: 'Composer install', command: ['composer', 'install'], source: 'builtin' },
-      update: { label: 'Composer update', command: ['composer', 'update'], source: 'builtin' }
+      update: { label: 'Composer update all', command: ['composer', 'update'], source: 'builtin' }
     };
     
     if (hasProjectFile(projectPath, 'artisan')) {

package/src/detectors/python.js

@@ -123,10 +123,17 @@ export default {
   icon: '🐍',
   priority: 95,
   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);
+  binaries: ['python3', 'python', 'uv'],
+   async build(projectPath, manifest) {
+     const hasPython3 = checkBinary('python3');
+     const hasPython = checkBinary('python');
+     const hasUv = checkBinary('uv');
+     const hasRuntime = hasPython3 || hasPython || hasUv;
+     const missingBinaries = [];
+     if (!hasRuntime) {
+       missingBinaries.push('python');
+     }
+     const pkgManager = getPythonPackageManager(projectPath);
     const isUV = pkgManager === 'uv';
     const isPoetry = pkgManager === 'poetry';
     const isPipenv = pkgManager === 'pipenv';

package/src/detectors/ruby.js

@@ -58,7 +58,7 @@ export default {
     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' }
+      console: { label: 'Ruby console', command: ['irb'], source: 'builtin' }
     };
     
     if (hasProjectFile(projectPath, 'bin/rails')) {

package/src/detectors/rust.js

@@ -40,8 +40,8 @@ function parseCargoToml(content) {
     }
     
     if (inDependencies && trimmed && !trimmed.startsWith('#')) {
-      const depName = trimmed.split('=')[0]?.trim() || trimmed.split('{')[0]?.trim();
-      if (depName) metadata.dependencies.push(depName);
+      const depName = trimmed.split(/[={]/)[0]?.trim();
+      if (depName && !depName.startsWith('#')) metadata.dependencies.push(depName);
     }
     
     if (inBin && trimmed.startsWith('name')) {

package/src/detectors/utils.js

@@ -98,13 +98,12 @@ export function dependencyMatches(project, needle) {
     return '';
   }).filter(Boolean);
   const target = needle.toLowerCase();
-  return dependencies.some((value) => 
-    value === target || 
-    value.startsWith(`${target}@`) || 
-    value.includes(`/${target}`) ||
-    value.startsWith(`${target}/`) ||
-    value.endsWith(`/${target}`)
-  );
+  return dependencies.some((value) => {
+    if (value === target) return true;
+    if (value.startsWith(`${target}@`) || value.startsWith(`${target}==`) || value.startsWith(`${target}>=`) || value.startsWith(`${target}~=`)) return true;
+    if (value.startsWith(`${target}/`) || value.endsWith(`/${target}`)) return true;
+    return false;
+  });
 }
 
 export function parseCommandTokens(value) {