project-compass 1.0.10 → 2.0.0

package/src/configPaths.js

@@ -0,0 +1,13 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export const CONFIG_DIR = path.join(os.homedir(), '.project-compass');
+export const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+export const PLUGIN_FILE = path.join(CONFIG_DIR, 'plugins.json');
+
+export function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, {recursive: true});
+  }
+}

package/src/projectDetection.js

@@ -0,0 +1,627 @@
+import fs from 'fs';
+import path from 'path';
+import fastGlob from 'fast-glob';
+import {ensureConfigDir, PLUGIN_FILE} from './configPaths.js';
+
+const IGNORE_PATTERNS = ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**', '**/target/**'];
+
+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);
+}
+
+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);
+}
+
+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}`));
+}
+
+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 [];
+}
+
+class SchemaRegistry {
+  constructor() {
+    this.cache = null;
+  }
+
+  getSchemas() {
+    if (this.cache) {
+      return this.cache;
+    }
+    const schemas = this.buildSchemas();
+    this.cache = schemas;
+    return schemas;
+  }
+
+  buildSchemas() {
+    const schemas = [
+      {
+        type: 'node',
+        label: 'Node.js',
+        icon: '🟢',
+        priority: 100,
+        files: ['package.json'],
+        async build(projectPath, manifest) {
+          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 scripts = pkg.scripts || {};
+          const commands = {};
+          const preferScript = (targetKey, names, label) => {
+            for (const name of names) {
+              if (Object.prototype.hasOwnProperty.call(scripts, name)) {
+                commands[targetKey] = {label, command: ['npm', 'run', name]};
+                break;
+              }
+            }
+          };
+          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: ['npm', 'run', 'lint']};
+          }
+
+          const metadata = {
+            dependencies: gatherNodeDependencies(pkg),
+            scripts,
+            packageJson: pkg
+          };
+
+          const setupHints = [];
+          if (metadata.dependencies.length) {
+            setupHints.push('Run npm install to fetch dependencies.');
+            if (fs.existsSync(path.join(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 || '',
+            extra: {
+              scripts: Object.keys(scripts),
+              setupHints
+            }
+          };
+        }
+      },
+      {
+        type: 'python',
+        label: 'Python',
+        icon: '🐍',
+        priority: 95,
+        files: ['pyproject.toml', 'requirements.txt', 'setup.py', 'Pipfile'],
+        async build(projectPath, manifest) {
+          const commands = {};
+          if (fs.existsSync(path.join(projectPath, 'pyproject.toml'))) {
+            commands.test = {label: 'Pytest', command: ['pytest']};
+          } else {
+            commands.test = {label: 'Unittest', command: ['python', '-m', 'unittest', 'discover']};
+          }
+
+          const entry = this.findPythonEntry(projectPath);
+          if (entry) {
+            commands.run = {label: 'Run', command: ['python', entry]};
+          }
+
+          const metadata = {
+            dependencies: gatherPythonDependencies(projectPath)
+          };
+
+          const setupHints = [];
+          const reqPath = path.join(projectPath, 'requirements.txt');
+          if (fs.existsSync(reqPath)) {
+            setupHints.push('pip install -r requirements.txt');
+          }
+          if (fs.existsSync(path.join(projectPath, 'Pipfile'))) {
+            setupHints.push('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: '',
+            extra: {
+              entry,
+              setupHints
+            }
+          };
+        },
+        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)) {
+              return candidate;
+            }
+          }
+          return null;
+        }
+      },
+      {
+        type: 'rust',
+        label: 'Rust',
+        icon: '🦀',
+        priority: 90,
+        files: ['Cargo.toml'],
+        async build(projectPath, manifest) {
+          return {
+            id: `${projectPath}::rust`,
+            path: projectPath,
+            name: path.basename(projectPath),
+            type: 'Rust',
+            icon: '🦀',
+            priority: this.priority,
+            commands: {
+              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: '',
+            extra: {
+              setupHints: ['cargo fetch', 'Run cargo build before releasing']
+            }
+          };
+        }
+      },
+      {
+        type: 'go',
+        label: 'Go',
+        icon: '🐹',
+        priority: 85,
+        files: ['go.mod'],
+        async build(projectPath, manifest) {
+          return {
+            id: `${projectPath}::go`,
+            path: projectPath,
+            name: path.basename(projectPath),
+            type: 'Go',
+            icon: '🐹',
+            priority: this.priority,
+            commands: {
+              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: '',
+            extra: {
+              setupHints: ['go mod tidy', 'Ensure Go toolchain is installed']
+            }
+          };
+        }
+      },
+      {
+        type: 'java',
+        label: 'Java',
+        icon: '☕️',
+        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 commands = {};
+          if (hasGradlew) {
+            commands.build = {label: 'Gradle build', command: ['./gradlew', 'build']};
+            commands.test = {label: 'Gradle test', command: ['./gradlew', 'test']};
+          } else if (hasMvnw) {
+            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: '',
+            extra: {
+              setupHints: ['Install JDK 17+ and run ./mvnw install / ./gradlew build']
+            }
+          };
+        }
+      },
+      {
+        type: 'scala',
+        label: 'Scala',
+        icon: '🔵',
+        priority: 70,
+        files: ['build.sbt'],
+        async build(projectPath, manifest) {
+          return {
+            id: `${projectPath}::scala`,
+            path: projectPath,
+            name: path.basename(projectPath),
+            type: 'Scala',
+            icon: '🔵',
+            priority: this.priority,
+            commands: {
+              build: {label: 'sbt compile', command: ['sbt', 'compile']},
+              test: {label: 'sbt test', command: ['sbt', 'test']},
+              run: {label: 'sbt run', command: ['sbt', 'run']}
+            },
+            metadata: {},
+            manifest: path.basename(manifest),
+            description: '',
+            extra: {
+              setupHints: ['Ensure sbt is installed', 'Run sbt compile before running your app']
+            }
+          };
+        }
+      },
+      {
+        type: 'php',
+        label: 'PHP',
+        icon: '🐘',
+        priority: 65,
+        files: ['composer.json'],
+        async build(projectPath, manifest) {
+          return {
+            id: `${projectPath}::php`,
+            path: projectPath,
+            name: path.basename(projectPath),
+            type: 'PHP',
+            icon: '🐘',
+            priority: this.priority,
+            commands: {
+              test: {label: 'PHPStorm', command: ['php', '-v']}
+            },
+            metadata: {},
+            manifest: path.basename(manifest),
+            description: '',
+            extra: {
+              setupHints: ['composer install to install dependencies']
+            }
+          };
+        }
+      },
+      {
+        type: 'ruby',
+        label: 'Ruby',
+        icon: '💎',
+        priority: 65,
+        files: ['Gemfile'],
+        async build(projectPath, manifest) {
+          return {
+            id: `${projectPath}::ruby`,
+            path: projectPath,
+            name: path.basename(projectPath),
+            type: 'Ruby',
+            icon: '💎',
+            priority: this.priority,
+            commands: {
+              run: {label: 'Ruby console', command: ['ruby', 'app.rb']},
+              test: {label: 'Ruby test', command: ['bundle', 'exec', 'rspec']}
+            },
+            metadata: {},
+            manifest: path.basename(manifest),
+            description: '',
+            extra: {
+              setupHints: ['bundle install to ensure gems are present']
+            }
+          };
+        }
+      },
+      {
+        type: 'dotnet',
+        label: '.NET',
+        icon: '🔷',
+        priority: 65,
+        files: ['*.csproj'],
+        async build(projectPath, manifest) {
+          return {
+            id: `${projectPath}::dotnet`,
+            path: projectPath,
+            name: path.basename(projectPath),
+            type: '.NET',
+            icon: '🔷',
+            priority: this.priority,
+            commands: {
+              build: {label: 'dotnet build', command: ['dotnet', 'build']},
+              test: {label: 'dotnet test', command: ['dotnet', 'test']},
+              run: {label: 'dotnet run', command: ['dotnet', 'run']}
+            },
+            metadata: {},
+            manifest: path.basename(manifest),
+            description: '',
+            extra: {
+              setupHints: ['Install .NET SDK 8+', 'dotnet restore before running']
+            }
+          };
+        }
+      },
+      {
+        type: 'shell',
+        label: 'Shell / Makefile',
+        icon: '🐚',
+        priority: 50,
+        files: ['Makefile', 'build.sh'],
+        async build(projectPath, manifest) {
+          return {
+            id: `${projectPath}::shell`,
+            path: projectPath,
+            name: path.basename(projectPath),
+            type: 'Shell / Makefile',
+            icon: '🐚',
+            priority: this.priority,
+            commands: {
+              build: {label: 'make build', command: ['make', 'build']},
+              test: {label: 'make test', command: ['make', 'test']}
+            },
+            metadata: {},
+            manifest: path.basename(manifest),
+            description: '',
+            extra: {
+              setupHints: ['Run make install if available', 'Ensure shell scripts are executable']
+            }
+          };
+        }
+      },
+      {
+        type: 'generic',
+        label: 'Custom project',
+        icon: '🧰',
+        priority: 10,
+        files: ['README.md'],
+        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.',
+            extra: {
+              setupHints: ['Read the README for custom build instructions']
+            }
+          };
+        }
+      }
+    ];
+    return schemas;
+  }
+}
+
+const schemaRegistry = new SchemaRegistry();
+
+const builtInFrameworks = [];
+
+
+function loadUserFrameworks() {
+  ensureConfigDir();
+  if (!fs.existsSync(PLUGIN_FILE)) {
+    return [];
+  }
+  try {
+    const payload = JSON.parse(fs.readFileSync(PLUGIN_FILE, 'utf-8') || '{}');
+    const plugins = payload.plugins || [];
+    return plugins.map((entry) => {
+      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);
+        if (!tokens.length) {
+          return;
+        }
+        commands[key] = {
+          label: typeof value === 'object' ? value.label || key : key,
+          command: tokens,
+          source: 'plugin'
+        };
+      });
+      return {
+        id: normalizedId,
+        name: entry.name || normalizedId,
+        icon: entry.icon || '🧩',
+        description: entry.description || '',
+        languages: entry.languages || [],
+        files: entry.files || [],
+        dependencies: entry.dependencies || [],
+        scripts: entry.scripts || [],
+        priority: Number.isFinite(entry.priority) ? entry.priority : 70,
+        commands,
+        match: entry.match
+      };
+    })
+      .filter((plugin) => plugin.name && plugin.commands && Object.keys(plugin.commands).length);
+  } catch (error) {
+    console.error(`Failed to parse plugins.json: ${error.message}`);
+    return [];
+  }
+}
+
+let cachedFrameworkPlugins = null;
+
+function getFrameworkPlugins() {
+  if (cachedFrameworkPlugins) {
+    return cachedFrameworkPlugins;
+  }
+  cachedFrameworkPlugins = [...builtInFrameworks, ...loadUserFrameworks()];
+  return cachedFrameworkPlugins;
+}
+
+function matchesPlugin(project, plugin) {
+  if (plugin.languages && plugin.languages.length > 0 && !plugin.languages.includes(project.type)) {
+    return false;
+  }
+  if (plugin.files && plugin.files.length > 0) {
+    const hit = plugin.files.some((file) => fs.existsSync(path.join(project.path, file)));
+    if (!hit) {
+      return false;
+    }
+  }
+  if (plugin.dependencies && plugin.dependencies.length > 0) {
+    const hit = plugin.dependencies.some((dep) => dependencyMatches(project, dep));
+    if (!hit) {
+      return false;
+    }
+  }
+  if (plugin.scripts && plugin.scripts.length > 0) {
+    const scripts = project.metadata?.scripts || {};
+    const hit = plugin.scripts.some((name) => Object.prototype.hasOwnProperty.call(scripts, name));
+    if (!hit) {
+      return false;
+    }
+  }
+  if (typeof plugin.match === 'function') {
+    if (!plugin.match(project)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function applyFrameworkPlugins(project) {
+  const plugins = getFrameworkPlugins();
+  let commands = {...project.commands};
+  const frameworks = [];
+  let maxPriority = project.priority || 0;
+  for (const plugin of plugins) {
+    if (!matchesPlugin(project, plugin)) {
+      continue;
+    }
+    frameworks.push({id: plugin.id, name: plugin.name, icon: plugin.icon, description: plugin.description});
+    if (plugin.priority && plugin.priority > maxPriority) {
+      maxPriority = plugin.priority;
+    }
+    const pluginCommands = typeof plugin.commands === 'function' ? plugin.commands(project) : plugin.commands;
+    if (pluginCommands) {
+      Object.entries(pluginCommands).forEach(([key, command]) => {
+        if (!Array.isArray(command.command) || command.command.length === 0) {
+          return;
+        }
+        commands = {
+          ...commands,
+          [key]: {
+            ...command,
+            source: command.source || 'framework'
+          }
+        };
+      });
+    }
+  }
+  return {...project, commands, frameworks, priority: maxPriority};
+}
+
+async function discoverProjects(root) {
+  const projectMap = new Map();
+  const schemas = schemaRegistry.getSchemas();
+  for (const schema of schemas) {
+    const patterns = schema.files.map((file) => `**/${file}`);
+    const matches = await fastGlob(patterns, {
+      cwd: root,
+      ignore: IGNORE_PATTERNS,
+      onlyFiles: true,
+      deep: 5
+    });
+
+    for (const match of matches) {
+      const projectDir = path.resolve(root, path.dirname(match));
+      const existing = projectMap.get(projectDir);
+      if (existing && existing.priority >= schema.priority) {
+        continue;
+      }
+      const entry = await schema.build(projectDir, match);
+      if (!entry) {
+        continue;
+      }
+      const withFrameworks = applyFrameworkPlugins(entry);
+      projectMap.set(projectDir, withFrameworks);
+    }
+  }
+  return Array.from(projectMap.values()).sort((a, b) => b.priority - a.priority);
+}
+
+const SCHEMA_GUIDE = schemaRegistry.getSchemas().map((schema) => ({
+  type: schema.type,
+  label: schema.label || schema.type,
+  icon: schema.icon || '⚙',
+  files: schema.files
+}));
+
+export {discoverProjects, SCHEMA_GUIDE};