The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
feat: automatic project type and framework detection (#293)
justtrance-web912df24f4a06
diff --git a/scripts/hooks/session-start.js b/scripts/hooks/session-start.jsindex d101798f7..1a044f318 100644--- a/scripts/hooks/session-start.js+++ b/scripts/hooks/session-start.js@@ -20,6 +20,7 @@ const {} = require('../lib/utils');const { getPackageManager, getSelectionPrompt } = require('../lib/package-manager');const { listAliases } = require('../lib/session-aliases');+const { detectProjectType } = require('../lib/project-detect');async function main() {const sessionsDir = getSessionsDir();@@ -71,6 +72,22 @@ async function main() {log(getSelectionPrompt());}+ // Detect project type and frameworks (#293)+ const projectInfo = detectProjectType();+ if (projectInfo.languages.length > 0 || projectInfo.frameworks.length > 0) {+ const parts = [];+ if (projectInfo.languages.length > 0) {+ parts.push(`languages: ${projectInfo.languages.join(', ')}`);+ }+ if (projectInfo.frameworks.length > 0) {+ parts.push(`frameworks: ${projectInfo.frameworks.join(', ')}`);+ }+ log(`[SessionStart] Project detected — ${parts.join('; ')}`);+ output(`Project type: ${JSON.stringify(projectInfo)}`);+ } else {+ log('[SessionStart] No specific project type detected');+ }+process.exit(0);}diff --git a/scripts/lib/project-detect.js b/scripts/lib/project-detect.jsnew file mode 100644index 000000000..9b9bb5b18--- /dev/null+++ b/scripts/lib/project-detect.js@@ -0,0 +1,413 @@+/**+ * Project type and framework detection+ *+ * Cross-platform (Windows, macOS, Linux) project type detection+ * by inspecting files in the working directory.+ *+ * Resolves: https://github.com/affaan-m/everything-claude-code/issues/293+ */++const fs = require('fs');+const path = require('path');++/**+ * Language detection rules.+ * Each rule checks for marker files or glob patterns in the project root.+ */+const LANGUAGE_RULES = [+ {+ type: 'python',+ markers: ['requirements.txt', 'pyproject.toml', 'setup.py', 'setup.cfg', 'Pipfile', 'poetry.lock'],+ extensions: ['.py']+ },+ {+ type: 'typescript',+ markers: ['tsconfig.json', 'tsconfig.build.json'],+ extensions: ['.ts', '.tsx']+ },+ {+ type: 'javascript',+ markers: ['package.json', 'jsconfig.json'],+ extensions: ['.js', '.jsx', '.mjs']+ },+ {+ type: 'golang',+ markers: ['go.mod', 'go.sum'],+ extensions: ['.go']+ },+ {+ type: 'rust',+ markers: ['Cargo.toml', 'Cargo.lock'],+ extensions: ['.rs']+ },+ {+ type: 'ruby',+ markers: ['Gemfile', 'Gemfile.lock', 'Rakefile'],+ extensions: ['.rb']+ },+ {+ type: 'java',+ markers: ['pom.xml', 'build.gradle', 'build.gradle.kts'],+ extensions: ['.java']+ },+ {+ type: 'csharp',+ markers: [],+ extensions: ['.cs', '.csproj', '.sln']+ },+ {+ type: 'swift',+ markers: ['Package.swift'],+ extensions: ['.swift']+ },+ {+ type: 'kotlin',+ markers: [],+ extensions: ['.kt', '.kts']+ },+ {+ type: 'elixir',+ markers: ['mix.exs'],+ extensions: ['.ex', '.exs']+ },+ {+ type: 'php',+ markers: ['composer.json', 'composer.lock'],+ extensions: ['.php']+ }+];++/**+ * Framework detection rules.+ * Checked after language detection for more specific identification.+ */+const FRAMEWORK_RULES = [+ // Python frameworks+ { framework: 'django', language: 'python', markers: ['manage.py'], packageKeys: ['django'] },+ { framework: 'fastapi', language: 'python', markers: [], packageKeys: ['fastapi'] },+ { framework: 'flask', language: 'python', markers: [], packageKeys: ['flask'] },++ // JavaScript/TypeScript frameworks+ { framework: 'nextjs', language: 'typescript', markers: ['next.config.js', 'next.config.mjs', 'next.config.ts'], packageKeys: ['next'] },+ { framework: 'react', language: 'typescript', markers: [], packageKeys: ['react'] },+ { framework: 'vue', language: 'typescript', markers: ['vue.config.js'], packageKeys: ['vue'] },+ { framework: 'angular', language: 'typescript', markers: ['angular.json'], packageKeys: ['@angular/core'] },+ { framework: 'svelte', language: 'typescript', markers: ['svelte.config.js'], packageKeys: ['svelte'] },+ { framework: 'express', language: 'javascript', markers: [], packageKeys: ['express'] },+ { framework: 'nestjs', language: 'typescript', markers: ['nest-cli.json'], packageKeys: ['@nestjs/core'] },+ { framework: 'remix', language: 'typescript', markers: [], packageKeys: ['@remix-run/node', '@remix-run/react'] },+ { framework: 'astro', language: 'typescript', markers: ['astro.config.mjs', 'astro.config.ts'], packageKeys: ['astro'] },+ { framework: 'nuxt', language: 'typescript', markers: ['nuxt.config.js', 'nuxt.config.ts'], packageKeys: ['nuxt'] },+ { framework: 'electron', language: 'typescript', markers: [], packageKeys: ['electron'] },++ // Ruby frameworks+ { framework: 'rails', language: 'ruby', markers: ['config/routes.rb', 'bin/rails'], packageKeys: [] },++ // Go frameworks+ { framework: 'gin', language: 'golang', markers: [], packageKeys: ['github.com/gin-gonic/gin'] },+ { framework: 'echo', language: 'golang', markers: [], packageKeys: ['github.com/labstack/echo'] },++ // Rust frameworks+ { framework: 'actix', language: 'rust', markers: [], packageKeys: ['actix-web'] },+ { framework: 'axum', language: 'rust', markers: [], packageKeys: ['axum'] },++ // Java frameworks+ { framework: 'spring', language: 'java', markers: [], packageKeys: ['spring-boot', 'org.springframework'] },++ // PHP frameworks+ { framework: 'laravel', language: 'php', markers: ['artisan'], packageKeys: ['laravel/framework'] },+ { framework: 'symfony', language: 'php', markers: ['symfony.lock'], packageKeys: ['symfony/framework-bundle'] },++ // Elixir frameworks+ { framework: 'phoenix', language: 'elixir', markers: [], packageKeys: ['phoenix'] }+];++/**+ * Check if a file exists relative to the project directory+ * @param {string} projectDir - Project root directory+ * @param {string} filePath - Relative file path+ * @returns {boolean}+ */+function fileExists(projectDir, filePath) {+ try {+ return fs.existsSync(path.join(projectDir, filePath));+ } catch {+ return false;+ }+}++/**+ * Check if any file with given extension exists in the project root (non-recursive, top-level only)+ * @param {string} projectDir - Project root directory+ * @param {string[]} extensions - File extensions to check+ * @returns {boolean}+ */+function hasFileWithExtension(projectDir, extensions) {+ try {+ const entries = fs.readdirSync(projectDir, { withFileTypes: true });+ return entries.some(entry => {+ if (!entry.isFile()) return false;+ const ext = path.extname(entry.name);+ return extensions.includes(ext);+ });+ } catch {+ return false;+ }+}++/**+ * Read and parse package.json dependencies+ * @param {string} projectDir - Project root directory+ * @returns {string[]} Array of dependency names+ */+function getPackageJsonDeps(projectDir) {+ try {+ const pkgPath = path.join(projectDir, 'package.json');+ if (!fs.existsSync(pkgPath)) return [];+ const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));+ return [+ ...Object.keys(pkg.dependencies || {}),+ ...Object.keys(pkg.devDependencies || {})+ ];+ } catch {+ return [];+ }+}++/**+ * Read requirements.txt or pyproject.toml for Python package names+ * @param {string} projectDir - Project root directory+ * @returns {string[]} Array of dependency names (lowercase)+ */+function getPythonDeps(projectDir) {+ const deps = [];++ // requirements.txt+ try {+ const reqPath = path.join(projectDir, 'requirements.txt');+ if (fs.existsSync(reqPath)) {+ const content = fs.readFileSync(reqPath, 'utf8');+ content.split('\n').forEach(line => {+ const trimmed = line.trim();+ if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('-')) {+ const name = trimmed.split(/[>=<!\[;]/)[0].trim().toLowerCase();+ if (name) deps.push(name);+ }+ });+ }+ } catch { /* ignore */ }++ // pyproject.toml — simple extraction of dependency names+ try {+ const tomlPath = path.join(projectDir, 'pyproject.toml');+ if (fs.existsSync(tomlPath)) {+ const content = fs.readFileSync(tomlPath, 'utf8');+ const depMatches = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);+ if (depMatches) {+ const block = depMatches[1];+ block.match(/"([^"]+)"/g)?.forEach(m => {+ const name = m.replace(/"/g, '').split(/[>=<!\[;]/)[0].trim().toLowerCase();+ if (name) deps.push(name);+ });+ }+ }+ } catch { /* ignore */ }++ return deps;+}++/**+ * Read go.mod for Go module dependencies+ * @param {string} projectDir - Project root directory+ * @returns {string[]} Array of module paths+ */+function getGoDeps(projectDir) {+ try {+ const modPath = path.join(projectDir, 'go.mod');+ if (!fs.existsSync(modPath)) return [];+ const content = fs.readFileSync(modPath, 'utf8');+ const deps = [];+ const requireBlock = content.match(/require\s*\(([\s\S]*?)\)/);+ if (requireBlock) {+ requireBlock[1].split('\n').forEach(line => {+ const trimmed = line.trim();+ if (trimmed && !trimmed.startsWith('//')) {+ const parts = trimmed.split(/\s+/);+ if (parts[0]) deps.push(parts[0]);+ }+ });+ }+ return deps;+ } catch {+ return [];+ }+}++/**+ * Read Cargo.toml for Rust crate dependencies+ * @param {string} projectDir - Project root directory+ * @returns {string[]} Array of crate names+ */+function getRustDeps(projectDir) {+ try {+ const cargoPath = path.join(projectDir, 'Cargo.toml');+ if (!fs.existsSync(cargoPath)) return [];+ const content = fs.readFileSync(cargoPath, 'utf8');+ const deps = [];+ // Match [dependencies] and [dev-dependencies] sections+ const sections = content.match(/\[(dev-)?dependencies\]([\s\S]*?)(?=\n\[|$)/g);+ if (sections) {+ sections.forEach(section => {+ section.split('\n').forEach(line => {+ const match = line.match(/^([a-zA-Z0-9_-]+)\s*=/);+ if (match && !line.startsWith('[')) {+ deps.push(match[1]);+ }+ });+ });+ }+ return deps;+ } catch {+ return [];+ }+}++/**+ * Read composer.json for PHP package dependencies+ * @param {string} projectDir - Project root directory+ * @returns {string[]} Array of package names+ */+function getComposerDeps(projectDir) {+ try {+ const composerPath = path.join(projectDir, 'composer.json');+ if (!fs.existsSync(composerPath)) return [];+ const composer = JSON.parse(fs.readFileSync(composerPath, 'utf8'));+ return [+ ...Object.keys(composer.require || {}),+ ...Object.keys(composer['require-dev'] || {})+ ];+ } catch {+ return [];+ }+}++/**+ * Read mix.exs for Elixir dependencies (simple pattern match)+ * @param {string} projectDir - Project root directory+ * @returns {string[]} Array of dependency atom names+ */+function getElixirDeps(projectDir) {+ try {+ const mixPath = path.join(projectDir, 'mix.exs');+ if (!fs.existsSync(mixPath)) return [];+ const content = fs.readFileSync(mixPath, 'utf8');+ const deps = [];+ const matches = content.match(/\{:(\w+)/g);+ if (matches) {+ matches.forEach(m => deps.push(m.replace('{:', '')));+ }+ return deps;+ } catch {+ return [];+ }+}++/**+ * Detect project languages and frameworks+ * @param {string} [projectDir] - Project directory (defaults to cwd)+ * @returns {{ languages: string[], frameworks: string[], primary: string, projectDir: string }}+ */+function detectProjectType(projectDir) {+ projectDir = projectDir || process.cwd();+ const languages = [];+ const frameworks = [];++ // Step 1: Detect languages+ for (const rule of LANGUAGE_RULES) {+ const hasMarker = rule.markers.some(m => fileExists(projectDir, m));+ const hasExt = rule.extensions.length > 0 && hasFileWithExtension(projectDir, rule.extensions);++ if (hasMarker || hasExt) {+ languages.push(rule.type);+ }+ }++ // Deduplicate: if both typescript and javascript detected, keep typescript+ if (languages.includes('typescript') && languages.includes('javascript')) {+ const idx = languages.indexOf('javascript');+ if (idx !== -1) languages.splice(idx, 1);+ }++ // Step 2: Detect frameworks based on markers and dependencies+ const npmDeps = getPackageJsonDeps(projectDir);+ const pyDeps = getPythonDeps(projectDir);+ const goDeps = getGoDeps(projectDir);+ const rustDeps = getRustDeps(projectDir);+ const composerDeps = getComposerDeps(projectDir);+ const elixirDeps = getElixirDeps(projectDir);++ for (const rule of FRAMEWORK_RULES) {+ // Check marker files+ const hasMarker = rule.markers.some(m => fileExists(projectDir, m));++ // Check package dependencies+ let hasDep = false;+ if (rule.packageKeys.length > 0) {+ let depList = [];+ switch (rule.language) {+ case 'python': depList = pyDeps; break;+ case 'typescript':+ case 'javascript': depList = npmDeps; break;+ case 'golang': depList = goDeps; break;+ case 'rust': depList = rustDeps; break;+ case 'php': depList = composerDeps; break;+ case 'elixir': depList = elixirDeps; break;+ }+ hasDep = rule.packageKeys.some(key =>+ depList.some(dep => dep.toLowerCase().includes(key.toLowerCase()))+ );+ }++ if (hasMarker || hasDep) {+ frameworks.push(rule.framework);+ }+ }++ // Step 3: Determine primary type+ let primary = 'unknown';+ if (frameworks.length > 0) {+ primary = frameworks[0];+ } else if (languages.length > 0) {+ primary = languages[0];+ }++ // Determine if fullstack (both frontend and backend languages)+ const frontendSignals = ['react', 'vue', 'angular', 'svelte', 'nextjs', 'nuxt', 'astro', 'remix'];+ const backendSignals = ['django', 'fastapi', 'flask', 'express', 'nestjs', 'rails', 'spring', 'laravel', 'phoenix', 'gin', 'echo', 'actix', 'axum'];+ const hasFrontend = frameworks.some(f => frontendSignals.includes(f));+ const hasBackend = frameworks.some(f => backendSignals.includes(f));++ if (hasFrontend && hasBackend) {+ primary = 'fullstack';+ }++ return {+ languages,+ frameworks,+ primary,+ projectDir+ };+}++module.exports = {+ detectProjectType,+ LANGUAGE_RULES,+ FRAMEWORK_RULES,+ // Exported for testing+ getPackageJsonDeps,+ getPythonDeps,+ getGoDeps,+ getRustDeps,+ getComposerDeps,+ getElixirDeps+};diff --git a/tests/lib/project-detect.test.js b/tests/lib/project-detect.test.jsnew file mode 100644index 000000000..122940609--- /dev/null+++ b/tests/lib/project-detect.test.js@@ -0,0 +1,418 @@+/**+ * Tests for scripts/lib/project-detect.js+ *+ * Run with: node tests/lib/project-detect.test.js+ */++const assert = require('assert');+const path = require('path');+const fs = require('fs');+const os = require('os');++const {+ detectProjectType,+ LANGUAGE_RULES,+ FRAMEWORK_RULES,+ getPackageJsonDeps,+ getPythonDeps,+ getGoDeps,+ getRustDeps,+ getComposerDeps,+ getElixirDeps+} = require('../../scripts/lib/project-detect');++// Test helper+function test(name, fn) {+ try {+ fn();+ console.log(` \u2713 ${name}`);+ return true;+ } catch (err) {+ console.log(` \u2717 ${name}`);+ console.log(` Error: ${err.message}`);+ return false;+ }+}++// Create a temporary directory for testing+function createTempDir() {+ return fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-test-'));+}++// Clean up temp directory+function cleanupDir(dir) {+ try {+ fs.rmSync(dir, { recursive: true, force: true });+ } catch { /* ignore */ }+}++// Write a file in the temp directory+function writeTestFile(dir, filePath, content = '') {+ const fullPath = path.join(dir, filePath);+ const dirName = path.dirname(fullPath);+ fs.mkdirSync(dirName, { recursive: true });+ fs.writeFileSync(fullPath, content, 'utf8');+}++function runTests() {+ console.log('\n=== Testing project-detect.js ===\n');++ let passed = 0;+ let failed = 0;++ // Rule definitions tests+ console.log('Rule Definitions:');++ if (test('LANGUAGE_RULES is non-empty array', () => {+ assert.ok(Array.isArray(LANGUAGE_RULES));+ assert.ok(LANGUAGE_RULES.length > 0);+ })) passed++; else failed++;++ if (test('FRAMEWORK_RULES is non-empty array', () => {+ assert.ok(Array.isArray(FRAMEWORK_RULES));+ assert.ok(FRAMEWORK_RULES.length > 0);+ })) passed++; else failed++;++ if (test('each language rule has type, markers, and extensions', () => {+ for (const rule of LANGUAGE_RULES) {+ assert.ok(typeof rule.type === 'string', `Missing type`);+ assert.ok(Array.isArray(rule.markers), `Missing markers for ${rule.type}`);+ assert.ok(Array.isArray(rule.extensions), `Missing extensions for ${rule.type}`);+ }+ })) passed++; else failed++;++ if (test('each framework rule has framework, language, markers, packageKeys', () => {+ for (const rule of FRAMEWORK_RULES) {+ assert.ok(typeof rule.framework === 'string', `Missing framework`);+ assert.ok(typeof rule.language === 'string', `Missing language for ${rule.framework}`);+ assert.ok(Array.isArray(rule.markers), `Missing markers for ${rule.framework}`);+ assert.ok(Array.isArray(rule.packageKeys), `Missing packageKeys for ${rule.framework}`);+ }+ })) passed++; else failed++;++ // Empty directory detection+ console.log('\nEmpty Directory:');++ if (test('empty directory returns unknown primary', () => {+ const dir = createTempDir();+ try {+ const result = detectProjectType(dir);+ assert.strictEqual(result.primary, 'unknown');+ assert.deepStrictEqual(result.languages, []);+ assert.deepStrictEqual(result.frameworks, []);+ assert.strictEqual(result.projectDir, dir);+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ // Python detection+ console.log('\nPython Detection:');++ if (test('detects python from requirements.txt', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'requirements.txt', 'flask==3.0.0\nrequests>=2.31');+ const result = detectProjectType(dir);+ assert.ok(result.languages.includes('python'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ if (test('detects python from pyproject.toml', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'pyproject.toml', '[project]\nname = "test"');+ const result = detectProjectType(dir);+ assert.ok(result.languages.includes('python'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ if (test('detects flask framework from requirements.txt', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'requirements.txt', 'flask==3.0.0\nrequests>=2.31');+ const result = detectProjectType(dir);+ assert.ok(result.frameworks.includes('flask'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ if (test('detects django framework from manage.py', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'manage.py', '#!/usr/bin/env python');+ writeTestFile(dir, 'requirements.txt', 'django>=4.2');+ const result = detectProjectType(dir);+ assert.ok(result.frameworks.includes('django'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ if (test('detects fastapi from pyproject.toml dependencies', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'pyproject.toml', '[project]\nname = "test"\ndependencies = [\n "fastapi>=0.100",\n "uvicorn"\n]');+ const result = detectProjectType(dir);+ assert.ok(result.frameworks.includes('fastapi'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ // TypeScript/JavaScript detection+ console.log('\nTypeScript/JavaScript Detection:');++ if (test('detects typescript from tsconfig.json', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'tsconfig.json', '{}');+ writeTestFile(dir, 'package.json', '{"dependencies":{}}');+ const result = detectProjectType(dir);+ assert.ok(result.languages.includes('typescript'));+ // Should NOT also include javascript when TS is detected+ assert.ok(!result.languages.includes('javascript'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ if (test('detects nextjs from next.config.mjs', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'tsconfig.json', '{}');+ writeTestFile(dir, 'next.config.mjs', 'export default {}');+ writeTestFile(dir, 'package.json', '{"dependencies":{"next":"14.0.0","react":"18.0.0"}}');+ const result = detectProjectType(dir);+ assert.ok(result.frameworks.includes('nextjs'));+ assert.ok(result.frameworks.includes('react'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ if (test('detects react from package.json', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'package.json', '{"dependencies":{"react":"18.0.0","react-dom":"18.0.0"}}');+ const result = detectProjectType(dir);+ assert.ok(result.frameworks.includes('react'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ if (test('detects angular from angular.json', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'angular.json', '{}');+ writeTestFile(dir, 'tsconfig.json', '{}');+ writeTestFile(dir, 'package.json', '{"dependencies":{"@angular/core":"17.0.0"}}');+ const result = detectProjectType(dir);+ assert.ok(result.frameworks.includes('angular'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ // Go detection+ console.log('\nGo Detection:');++ if (test('detects golang from go.mod', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'go.mod', 'module github.com/test/app\n\ngo 1.22\n\nrequire (\n\tgithub.com/gin-gonic/gin v1.9.1\n)');+ const result = detectProjectType(dir);+ assert.ok(result.languages.includes('golang'));+ assert.ok(result.frameworks.includes('gin'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ // Rust detection+ console.log('\nRust Detection:');++ if (test('detects rust from Cargo.toml', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'Cargo.toml', '[package]\nname = "test"\n\n[dependencies]\naxum = "0.7"');+ const result = detectProjectType(dir);+ assert.ok(result.languages.includes('rust'));+ assert.ok(result.frameworks.includes('axum'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ // Ruby detection+ console.log('\nRuby Detection:');++ if (test('detects ruby and rails', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'Gemfile', 'source "https://rubygems.org"\ngem "rails"');+ writeTestFile(dir, 'config/routes.rb', 'Rails.application.routes.draw do\nend');+ const result = detectProjectType(dir);+ assert.ok(result.languages.includes('ruby'));+ assert.ok(result.frameworks.includes('rails'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ // PHP detection+ console.log('\nPHP Detection:');++ if (test('detects php and laravel', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'composer.json', '{"require":{"laravel/framework":"^10.0"}}');+ writeTestFile(dir, 'artisan', '#!/usr/bin/env php');+ const result = detectProjectType(dir);+ assert.ok(result.languages.includes('php'));+ assert.ok(result.frameworks.includes('laravel'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ // Fullstack detection+ console.log('\nFullstack Detection:');++ if (test('detects fullstack when frontend + backend frameworks present', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'package.json', '{"dependencies":{"react":"18.0.0","express":"4.18.0"}}');+ const result = detectProjectType(dir);+ assert.ok(result.frameworks.includes('react'));+ assert.ok(result.frameworks.includes('express'));+ assert.strictEqual(result.primary, 'fullstack');+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ // Dependency reader tests+ console.log('\nDependency Readers:');++ if (test('getPackageJsonDeps reads deps and devDeps', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'package.json', '{"dependencies":{"react":"18.0.0"},"devDependencies":{"typescript":"5.0.0"}}');+ const deps = getPackageJsonDeps(dir);+ assert.ok(deps.includes('react'));+ assert.ok(deps.includes('typescript'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ if (test('getPythonDeps reads requirements.txt', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'requirements.txt', 'flask>=3.0\n# comment\nrequests==2.31\n-r other.txt');+ const deps = getPythonDeps(dir);+ assert.ok(deps.includes('flask'));+ assert.ok(deps.includes('requests'));+ assert.ok(!deps.includes('-r'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ if (test('getGoDeps reads go.mod require block', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'go.mod', 'module test\n\ngo 1.22\n\nrequire (\n\tgithub.com/gin-gonic/gin v1.9.1\n\tgithub.com/lib/pq v1.10.9\n)');+ const deps = getGoDeps(dir);+ assert.ok(deps.some(d => d.includes('gin-gonic/gin')));+ assert.ok(deps.some(d => d.includes('lib/pq')));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ if (test('getRustDeps reads Cargo.toml', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'Cargo.toml', '[package]\nname = "test"\n\n[dependencies]\nserde = "1.0"\ntokio = { version = "1.0", features = ["full"] }');+ const deps = getRustDeps(dir);+ assert.ok(deps.includes('serde'));+ assert.ok(deps.includes('tokio'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ if (test('returns empty arrays for missing files', () => {+ const dir = createTempDir();+ try {+ assert.deepStrictEqual(getPackageJsonDeps(dir), []);+ assert.deepStrictEqual(getPythonDeps(dir), []);+ assert.deepStrictEqual(getGoDeps(dir), []);+ assert.deepStrictEqual(getRustDeps(dir), []);+ assert.deepStrictEqual(getComposerDeps(dir), []);+ assert.deepStrictEqual(getElixirDeps(dir), []);+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ // Elixir detection+ console.log('\nElixir Detection:');++ if (test('detects elixir from mix.exs', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'mix.exs', 'defmodule Test.MixProject do\n defp deps do\n [{:phoenix, "~> 1.7"},\n {:ecto, "~> 3.0"}]\n end\nend');+ const result = detectProjectType(dir);+ assert.ok(result.languages.includes('elixir'));+ assert.ok(result.frameworks.includes('phoenix'));+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ // Edge cases+ console.log('\nEdge Cases:');++ if (test('handles non-existent directory gracefully', () => {+ const result = detectProjectType('/tmp/nonexistent-dir-' + Date.now());+ assert.strictEqual(result.primary, 'unknown');+ assert.deepStrictEqual(result.languages, []);+ })) passed++; else failed++;++ if (test('handles malformed package.json', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'package.json', 'not valid json{{{');+ const deps = getPackageJsonDeps(dir);+ assert.deepStrictEqual(deps, []);+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ if (test('handles malformed composer.json', () => {+ const dir = createTempDir();+ try {+ writeTestFile(dir, 'composer.json', '{invalid');+ const deps = getComposerDeps(dir);+ assert.deepStrictEqual(deps, []);+ } finally {+ cleanupDir(dir);+ }+ })) passed++; else failed++;++ // Summary+ console.log(`\n=== Results: ${passed} passed, ${failed} failed ===\n`);+ process.exit(failed > 0 ? 1 : 0);+}++runTests();diff --git a/tests/run-all.js b/tests/run-all.jsindex e1d081449..54d8c212d 100644--- a/tests/run-all.js+++ b/tests/run-all.js@@ -15,6 +15,7 @@ const testFiles = ['lib/package-manager.test.js','lib/session-manager.test.js','lib/session-aliases.test.js',+ 'lib/project-detect.test.js','hooks/hooks.test.js','hooks/evaluate-session.test.js','hooks/suggest-compact.test.js',