prelude-context 1.5.0 → 1.7.0

package/dist/src/core/infer.js

@@ -6,6 +6,134 @@ import { scanSources } from './source-scanner.js';
 // --- ADD THESE CONSTANTS ---
 const PRELUDE_VERSION = "1.0.0";
 const SCHEMA_URL = "https://adjective.us/prelude/schemas/v1";
+// --------------------------
+// --- Minimal pyproject.toml parser ---
+function setNested(obj, table, key, value) {
+    const parts = table ? table.split('.') : [];
+    let current = obj;
+    for (const part of parts) {
+        if (!(part in current))
+            current[part] = {};
+        current = current[part];
+    }
+    current[key] = value;
+}
+function parsePyprojectToml(content) {
+    const result = {};
+    let currentTable = '';
+    let collectingArray = null;
+    let collectingKey = '';
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            if (collectingArray !== null)
+                continue;
+            continue;
+        }
+        // Handle multiline array continuation
+        if (collectingArray !== null) {
+            if (trimmed === ']') {
+                setNested(result, currentTable, collectingKey, collectingArray);
+                collectingArray = null;
+                continue;
+            }
+            // Inline table in array: {key = "value", ...}
+            if (trimmed.startsWith('{')) {
+                const obj = {};
+                const pairPattern = /(\w+)\s*=\s*["']([^"']*)["']/g;
+                let m;
+                while ((m = pairPattern.exec(trimmed)) !== null) {
+                    obj[m[1]] = m[2];
+                }
+                if (Object.keys(obj).length > 0)
+                    collectingArray.push(obj);
+                continue;
+            }
+            // String in array: "value",
+            const strMatch = trimmed.match(/^["']([^"']*)["']/);
+            if (strMatch) {
+                collectingArray.push(strMatch[1]);
+            }
+            continue;
+        }
+        // Table header: [section] or [section.subsection]
+        const tableMatch = trimmed.match(/^\[([^\]]+)\]$/);
+        if (tableMatch) {
+            currentTable = tableMatch[1];
+            continue;
+        }
+        // Key = value
+        const kvMatch = trimmed.match(/^([a-zA-Z_-][a-zA-Z0-9_.-]*)\s*=\s*(.*)$/);
+        if (!kvMatch)
+            continue;
+        const key = kvMatch[1].trim();
+        const rawValue = kvMatch[2].trim();
+        if (rawValue === '[') {
+            collectingArray = [];
+            collectingKey = key;
+        }
+        else if (rawValue.startsWith('[')) {
+            // Inline array
+            const items = [];
+            // Check for inline tables in array
+            const inlineTablePattern = /\{([^}]+)\}/g;
+            let itMatch;
+            while ((itMatch = inlineTablePattern.exec(rawValue)) !== null) {
+                const obj = {};
+                const pairPattern = /(\w+)\s*=\s*["']([^"']*)["']/g;
+                let m;
+                while ((m = pairPattern.exec(itMatch[1])) !== null) {
+                    obj[m[1]] = m[2];
+                }
+                if (Object.keys(obj).length > 0)
+                    items.push(obj);
+            }
+            if (items.length === 0) {
+                // Plain string array
+                const strPattern = /["']([^"']*)["']/g;
+                let m;
+                while ((m = strPattern.exec(rawValue)) !== null) {
+                    items.push(m[1]);
+                }
+            }
+            setNested(result, currentTable, key, items);
+        }
+        else if (rawValue.startsWith('{')) {
+            // Inline table
+            const obj = {};
+            const pairPattern = /(\w+)\s*=\s*["']([^"']*)["']/g;
+            let m;
+            while ((m = pairPattern.exec(rawValue)) !== null) {
+                obj[m[1]] = m[2];
+            }
+            setNested(result, currentTable, key, obj);
+        }
+        else if (rawValue.startsWith('"') || rawValue.startsWith("'")) {
+            const quote = rawValue[0];
+            const endIdx = rawValue.indexOf(quote, 1);
+            if (endIdx > 0) {
+                setNested(result, currentTable, key, rawValue.slice(1, endIdx));
+            }
+        }
+        else if (rawValue === 'true' || rawValue === 'false') {
+            setNested(result, currentTable, key, rawValue === 'true');
+        }
+        else if (/^\d+$/.test(rawValue)) {
+            setNested(result, currentTable, key, parseInt(rawValue, 10));
+        }
+    }
+    return result;
+}
+function extractPyDepName(dep) {
+    return dep.split(/[>=<!~\[;@ ]/)[0].trim().toLowerCase();
+}
+function parseRequirementsTxt(content) {
+    return content.split('\n')
+        .map(line => line.trim())
+        .filter(line => line && !line.startsWith('#') && !line.startsWith('-') && !line.startsWith('git+'))
+        .map(line => extractPyDepName(line))
+        .filter(name => name.length > 0);
+}
 async function scanMonorepoPackages(rootDir) {
     const packages = [];
     // Check common monorepo locations
@@ -95,26 +223,12 @@ export async function inferProjectMetadata(rootDir) {
     if (hasPackageJson) {
         projectData = await readJSON(packageJsonPath);
     }
-    // Try to read README for better description
-    let description = projectData.description || 'No description provided';
-    const readmePath = join(rootDir, 'README.md');
-    if (await fileExists(readmePath)) {
-        try {
-            const readme = await readFile(readmePath, 'utf-8');
-            const lines = readme.split('\n').filter(l => l.trim());
-            // Try to get first meaningful paragraph
-            const firstParagraph = lines.find(l => !l.startsWith('#') && l.length > 20);
-            if (firstParagraph && (!projectData.description || projectData.description === '')) {
-                description = firstParagraph.slice(0, 200);
-            }
-        }
-        catch { }
-    }
-    const name = projectData.name || basename(rootDir);
-    const projectVersion = projectData.version; // Use the renamed field
-    const repository = projectData.repository?.url || projectData.repository;
-    const license = projectData.license;
-    const homepage = projectData.homepage;
+    let name = projectData.name || '';
+    let description = projectData.description || '';
+    let projectVersion = projectData.version;
+    let repository = projectData.repository?.url || projectData.repository;
+    let license = projectData.license;
+    let homepage = projectData.homepage;
     // Detect team info from package.json
     const team = [];
     if (projectData.author) {
@@ -128,12 +242,110 @@ export async function inferProjectMetadata(rootDir) {
     if (projectData.contributors) {
         team.push(...projectData.contributors);
     }
+    // Try pyproject.toml for Python projects
+    const pyprojectPath = join(rootDir, 'pyproject.toml');
+    if (await fileExists(pyprojectPath)) {
+        try {
+            const pyContent = await readFile(pyprojectPath, 'utf-8');
+            const pyproject = parsePyprojectToml(pyContent);
+            const proj = pyproject?.project || {};
+            if (!name && proj.name)
+                name = proj.name;
+            if (!description && proj.description)
+                description = proj.description;
+            if (!projectVersion && proj.version)
+                projectVersion = proj.version;
+            // License from pyproject.toml
+            if (!license) {
+                if (typeof proj.license === 'string')
+                    license = proj.license;
+                else if (proj.license?.text)
+                    license = proj.license.text;
+            }
+            // Authors from pyproject.toml
+            if (team.length === 0 && Array.isArray(proj.authors)) {
+                for (const author of proj.authors) {
+                    if (typeof author === 'object' && author.name) {
+                        team.push({ name: author.name, email: author.email });
+                    }
+                }
+            }
+            // Python version as runtime info
+            if (proj['requires-python']) {
+                // Store for later use but don't set here — stack handles runtime
+            }
+        }
+        catch { }
+    }
+    // Try Cargo.toml for Rust projects
+    const cargoProjectPath = join(rootDir, 'Cargo.toml');
+    if (await fileExists(cargoProjectPath)) {
+        try {
+            const cargoContent = await readFile(cargoProjectPath, 'utf-8');
+            const cargo = parsePyprojectToml(cargoContent);
+            const pkg = cargo?.package || {};
+            if (!name && pkg.name)
+                name = pkg.name;
+            if (!description && pkg.description)
+                description = pkg.description;
+            if (!projectVersion && pkg.version)
+                projectVersion = pkg.version;
+            if (!license && pkg.license)
+                license = pkg.license;
+            if (!repository && pkg.repository)
+                repository = pkg.repository;
+            if (!homepage && pkg.homepage)
+                homepage = pkg.homepage;
+            if (team.length === 0 && Array.isArray(pkg.authors)) {
+                for (const author of pkg.authors) {
+                    if (typeof author === 'string') {
+                        team.push({ name: author.replace(/<.*>/, '').trim() });
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    // Try go.mod for Go projects (module name only)
+    const goModProjectPath = join(rootDir, 'go.mod');
+    if (await fileExists(goModProjectPath) && !name) {
+        try {
+            const goModContent = await readFile(goModProjectPath, 'utf-8');
+            const moduleMatch = goModContent.match(/^module\s+(\S+)/m);
+            if (moduleMatch) {
+                // Use the last segment of the module path as name
+                const parts = moduleMatch[1].split('/');
+                name = parts[parts.length - 1];
+            }
+        }
+        catch { }
+    }
+    // Fall back to directory name for name
+    if (!name)
+        name = basename(rootDir);
+    // Fall back to README for description
+    if (!description) {
+        const readmePath = join(rootDir, 'README.md');
+        if (await fileExists(readmePath)) {
+            try {
+                const readme = await readFile(readmePath, 'utf-8');
+                const lines = readme.split('\n').filter(l => l.trim());
+                const firstParagraph = lines.find(l => !l.startsWith('#') && !l.startsWith('!') && !l.startsWith('[') && !l.startsWith('<') && !l.startsWith('---') && l.length > 20);
+                if (firstParagraph) {
+                    description = firstParagraph.slice(0, 200);
+                }
+            }
+            catch { }
+        }
+    }
+    if (!description)
+        description = 'No description provided';
     return {
         $schema: `${SCHEMA_URL}/project.schema.json`,
         version: PRELUDE_VERSION,
         name,
         description,
-        projectVersion, // Correctly use renamed field
+        projectVersion,
         createdAt: getCurrentTimestamp(),
         updatedAt: getCurrentTimestamp(),
         repository,
@@ -503,24 +715,220 @@ export async function inferStack(rootDir) {
     // Check for Python project
     const requirementsPath = join(rootDir, 'requirements.txt');
     const pyprojectPath = join(rootDir, 'pyproject.toml');
-    if (await fileExists(requirementsPath) || await fileExists(pyprojectPath)) {
+    if (await fileExists(pyprojectPath) || await fileExists(requirementsPath)) {
         stack.language = 'Python';
-        stack.packageManager = await fileExists(pyprojectPath) ? 'poetry' : 'pip';
-        // Check for common Python frameworks
+        const allPyDeps = new Set();
+        // Parse pyproject.toml
+        if (await fileExists(pyprojectPath)) {
+            try {
+                const pyContent = await readFile(pyprojectPath, 'utf-8');
+                const pyproject = parsePyprojectToml(pyContent);
+                // Package manager detection
+                const buildBackend = pyproject?.['build-system']?.['build-backend'] || '';
+                if (buildBackend.includes('poetry')) {
+                    stack.packageManager = 'poetry';
+                }
+                else if (await fileExists(join(rootDir, 'uv.lock'))) {
+                    stack.packageManager = 'uv';
+                }
+                else if (await fileExists(join(rootDir, 'poetry.lock'))) {
+                    stack.packageManager = 'poetry';
+                }
+                else if (await fileExists(join(rootDir, 'Pipfile')) || await fileExists(join(rootDir, 'Pipfile.lock'))) {
+                    stack.packageManager = 'pipenv';
+                }
+                else {
+                    stack.packageManager = 'pip';
+                }
+                // Python version
+                const requiresPython = pyproject?.project?.['requires-python'];
+                if (requiresPython) {
+                    stack.runtime = `Python ${requiresPython}`;
+                }
+                // Collect deps from [project.dependencies]
+                const projDeps = pyproject?.project?.dependencies || [];
+                const depsRecord = {};
+                for (const dep of projDeps) {
+                    const depName = extractPyDepName(dep);
+                    const version = dep.slice(depName.length).replace(/^\[.*?\]/, '').trim() || '*';
+                    depsRecord[depName] = version;
+                    allPyDeps.add(depName);
+                }
+                if (Object.keys(depsRecord).length > 0) {
+                    stack.dependencies = depsRecord;
+                }
+                // Collect dev/optional deps from [project.optional-dependencies]
+                const optDeps = pyproject?.project?.['optional-dependencies'] || {};
+                const devDepsRecord = {};
+                for (const [, groupDeps] of Object.entries(optDeps)) {
+                    if (Array.isArray(groupDeps)) {
+                        for (const dep of groupDeps) {
+                            if (typeof dep === 'string') {
+                                const depName = extractPyDepName(dep);
+                                const version = dep.slice(depName.length).replace(/^\[.*?\]/, '').trim() || '*';
+                                devDepsRecord[depName] = version;
+                                allPyDeps.add(depName);
+                            }
+                        }
+                    }
+                }
+                if (Object.keys(devDepsRecord).length > 0) {
+                    stack.devDependencies = devDepsRecord;
+                }
+                // Also check Poetry-style deps under [tool.poetry.dependencies]
+                const poetryDeps = pyproject?.tool?.poetry?.dependencies;
+                if (poetryDeps && typeof poetryDeps === 'object') {
+                    for (const depName of Object.keys(poetryDeps)) {
+                        if (depName !== 'python')
+                            allPyDeps.add(depName.toLowerCase());
+                    }
+                }
+            }
+            catch { }
+        }
+        // Parse requirements.txt as fallback/supplement
         if (await fileExists(requirementsPath)) {
-            const requirements = await readFile(requirementsPath, 'utf-8');
-            const frameworks = [];
-            if (requirements.includes('django'))
-                frameworks.push('Django');
-            if (requirements.includes('flask'))
-                frameworks.push('Flask');
-            if (requirements.includes('fastapi'))
-                frameworks.push('FastAPI');
-            if (requirements.includes('tornado'))
-                frameworks.push('Tornado');
-            if (requirements.includes('pyramid'))
-                frameworks.push('Pyramid');
-            stack.frameworks = frameworks;
+            try {
+                const reqContent = await readFile(requirementsPath, 'utf-8');
+                const reqDeps = parseRequirementsTxt(reqContent);
+                for (const dep of reqDeps)
+                    allPyDeps.add(dep);
+                if (!stack.dependencies || Object.keys(stack.dependencies).length === 0) {
+                    const depsRecord = {};
+                    for (const dep of reqDeps)
+                        depsRecord[dep] = '*';
+                    stack.dependencies = depsRecord;
+                    stack.packageManager = stack.packageManager || 'pip';
+                }
+            }
+            catch { }
+        }
+        // === FRAMEWORKS ===
+        const pyFrameworks = [];
+        // Web frameworks
+        if (allPyDeps.has('django'))
+            pyFrameworks.push('Django');
+        if (allPyDeps.has('flask'))
+            pyFrameworks.push('Flask');
+        if (allPyDeps.has('fastapi'))
+            pyFrameworks.push('FastAPI');
+        if (allPyDeps.has('starlette'))
+            pyFrameworks.push('Starlette');
+        if (allPyDeps.has('tornado'))
+            pyFrameworks.push('Tornado');
+        if (allPyDeps.has('pyramid'))
+            pyFrameworks.push('Pyramid');
+        if (allPyDeps.has('sanic'))
+            pyFrameworks.push('Sanic');
+        if (allPyDeps.has('falcon'))
+            pyFrameworks.push('Falcon');
+        if (allPyDeps.has('litestar'))
+            pyFrameworks.push('Litestar');
+        // CLI frameworks
+        if (allPyDeps.has('typer'))
+            pyFrameworks.push('Typer');
+        if (allPyDeps.has('click'))
+            pyFrameworks.push('Click');
+        // ML/AI frameworks
+        if (allPyDeps.has('langchain'))
+            pyFrameworks.push('LangChain');
+        if (allPyDeps.has('transformers'))
+            pyFrameworks.push('Hugging Face Transformers');
+        if (allPyDeps.has('torch') || allPyDeps.has('pytorch'))
+            pyFrameworks.push('PyTorch');
+        if (allPyDeps.has('tensorflow'))
+            pyFrameworks.push('TensorFlow');
+        if (allPyDeps.has('scikit-learn') || allPyDeps.has('sklearn'))
+            pyFrameworks.push('scikit-learn');
+        // Data
+        if (allPyDeps.has('pandas'))
+            pyFrameworks.push('pandas');
+        if (allPyDeps.has('numpy'))
+            pyFrameworks.push('NumPy');
+        if (pyFrameworks.length > 0) {
+            stack.frameworks = pyFrameworks;
+            stack.framework = pyFrameworks[0];
+        }
+        // === TESTING ===
+        const pyTesting = [];
+        if (allPyDeps.has('pytest'))
+            pyTesting.push('pytest');
+        if (allPyDeps.has('pytest-cov'))
+            pyTesting.push('pytest-cov');
+        if (allPyDeps.has('hypothesis'))
+            pyTesting.push('Hypothesis');
+        if (allPyDeps.has('tox'))
+            pyTesting.push('tox');
+        if (allPyDeps.has('nox'))
+            pyTesting.push('nox');
+        if (allPyDeps.has('coverage'))
+            pyTesting.push('coverage');
+        if (pyTesting.length > 0) {
+            stack.testingFrameworks = pyTesting;
+        }
+        // === BUILD TOOLS ===
+        const pyBuildTools = [];
+        if (allPyDeps.has('setuptools'))
+            pyBuildTools.push('setuptools');
+        if (allPyDeps.has('wheel'))
+            pyBuildTools.push('wheel');
+        if (allPyDeps.has('cython'))
+            pyBuildTools.push('Cython');
+        if (allPyDeps.has('maturin'))
+            pyBuildTools.push('Maturin');
+        if (pyBuildTools.length > 0) {
+            stack.buildTools = pyBuildTools;
+        }
+        // === ORM/DATABASE ===
+        if (allPyDeps.has('sqlalchemy'))
+            stack.orm = 'SQLAlchemy';
+        else if (allPyDeps.has('tortoise-orm'))
+            stack.orm = 'Tortoise ORM';
+        else if (allPyDeps.has('peewee'))
+            stack.orm = 'Peewee';
+        else if (allPyDeps.has('mongoengine'))
+            stack.orm = 'MongoEngine';
+        else if (allPyDeps.has('django'))
+            stack.orm = 'Django ORM';
+        const pyDatabases = [];
+        if (allPyDeps.has('psycopg2') || allPyDeps.has('psycopg2-binary') || allPyDeps.has('psycopg') || allPyDeps.has('asyncpg'))
+            pyDatabases.push('PostgreSQL');
+        if (allPyDeps.has('pymongo') || allPyDeps.has('motor'))
+            pyDatabases.push('MongoDB');
+        if (allPyDeps.has('redis') || allPyDeps.has('aioredis'))
+            pyDatabases.push('Redis');
+        if (allPyDeps.has('pymysql') || allPyDeps.has('mysqlclient'))
+            pyDatabases.push('MySQL');
+        if (allPyDeps.has('aiosqlite'))
+            pyDatabases.push('SQLite');
+        if (allPyDeps.has('supabase'))
+            pyDatabases.push('Supabase');
+        if (pyDatabases.length > 0) {
+            stack.database = pyDatabases.join(', ');
+        }
+        // === DEPLOYMENT ===
+        if (!stack.deployment) {
+            if (await fileExists(join(rootDir, 'Dockerfile')))
+                stack.deployment = 'Docker';
+            else if (await fileExists(join(rootDir, 'Procfile')))
+                stack.deployment = 'Heroku';
+            else if (await fileExists(join(rootDir, 'fly.toml')))
+                stack.deployment = 'Fly.io';
+            else if (await fileExists(join(rootDir, 'render.yaml')))
+                stack.deployment = 'Render';
+        }
+        // === CI/CD ===
+        if (!stack.cicd || stack.cicd.length === 0) {
+            const cicd = [];
+            if (await fileExists(join(rootDir, '.github/workflows')))
+                cicd.push('GitHub Actions');
+            if (await fileExists(join(rootDir, '.gitlab-ci.yml')))
+                cicd.push('GitLab CI');
+            if (await fileExists(join(rootDir, '.circleci')))
+                cicd.push('CircleCI');
+            if (await fileExists(join(rootDir, 'tox.ini')))
+                cicd.push('tox');
+            stack.cicd = cicd;
         }
     }
     // Check for Rust project
@@ -528,12 +936,255 @@ export async function inferStack(rootDir) {
     if (await fileExists(cargoPath)) {
         stack.language = 'Rust';
         stack.packageManager = 'cargo';
+        try {
+            const cargoContent = await readFile(cargoPath, 'utf-8');
+            const cargo = parsePyprojectToml(cargoContent); // TOML parser works for Cargo.toml too
+            // Rust edition as runtime
+            const edition = cargo?.package?.edition;
+            if (edition) {
+                stack.runtime = `Rust Edition ${edition}`;
+            }
+            // Collect all deps
+            const cargoDeps = cargo?.dependencies || {};
+            const cargoDevDeps = cargo?.['dev-dependencies'] || {};
+            const cargoBuildDeps = cargo?.['build-dependencies'] || {};
+            const allCrateDeps = new Set([
+                ...Object.keys(cargoDeps).map((s) => s.toLowerCase()),
+                ...Object.keys(cargoDevDeps).map((s) => s.toLowerCase()),
+                ...Object.keys(cargoBuildDeps).map((s) => s.toLowerCase()),
+            ]);
+            // Store deps
+            const rustDepsRecord = {};
+            for (const [name, spec] of Object.entries(cargoDeps)) {
+                rustDepsRecord[name] = typeof spec === 'string' ? spec : '*';
+            }
+            if (Object.keys(rustDepsRecord).length > 0)
+                stack.dependencies = rustDepsRecord;
+            const rustDevDepsRecord = {};
+            for (const [name, spec] of Object.entries(cargoDevDeps)) {
+                rustDevDepsRecord[name] = typeof spec === 'string' ? spec : '*';
+            }
+            if (Object.keys(rustDevDepsRecord).length > 0)
+                stack.devDependencies = rustDevDepsRecord;
+            // === FRAMEWORKS ===
+            const rustFrameworks = [];
+            // Web frameworks
+            if (allCrateDeps.has('actix-web'))
+                rustFrameworks.push('Actix Web');
+            if (allCrateDeps.has('axum'))
+                rustFrameworks.push('Axum');
+            if (allCrateDeps.has('rocket'))
+                rustFrameworks.push('Rocket');
+            if (allCrateDeps.has('warp'))
+                rustFrameworks.push('Warp');
+            if (allCrateDeps.has('tide'))
+                rustFrameworks.push('Tide');
+            // Async runtime
+            if (allCrateDeps.has('tokio'))
+                rustFrameworks.push('Tokio');
+            if (allCrateDeps.has('async-std'))
+                rustFrameworks.push('async-std');
+            // CLI
+            if (allCrateDeps.has('clap'))
+                rustFrameworks.push('Clap');
+            if (allCrateDeps.has('structopt'))
+                rustFrameworks.push('StructOpt');
+            // Serialization
+            if (allCrateDeps.has('serde'))
+                rustFrameworks.push('Serde');
+            // GUI
+            if (allCrateDeps.has('tauri'))
+                rustFrameworks.push('Tauri');
+            if (allCrateDeps.has('egui'))
+                rustFrameworks.push('egui');
+            if (allCrateDeps.has('iced'))
+                rustFrameworks.push('Iced');
+            if (rustFrameworks.length > 0) {
+                stack.frameworks = rustFrameworks;
+                stack.framework = rustFrameworks[0];
+            }
+            // === TESTING ===
+            const rustTesting = [];
+            if (allCrateDeps.has('criterion'))
+                rustTesting.push('Criterion (benchmarks)');
+            if (allCrateDeps.has('proptest'))
+                rustTesting.push('proptest');
+            if (allCrateDeps.has('quickcheck'))
+                rustTesting.push('quickcheck');
+            if (allCrateDeps.has('mockall'))
+                rustTesting.push('mockall');
+            if (allCrateDeps.has('rstest'))
+                rustTesting.push('rstest');
+            // Rust has built-in testing
+            rustTesting.unshift('cargo test (built-in)');
+            stack.testingFrameworks = rustTesting;
+            // === ORM/DATABASE ===
+            if (allCrateDeps.has('diesel'))
+                stack.orm = 'Diesel';
+            else if (allCrateDeps.has('sea-orm') || allCrateDeps.has('sea_orm'))
+                stack.orm = 'SeaORM';
+            else if (allCrateDeps.has('sqlx'))
+                stack.orm = 'SQLx';
+            const rustDatabases = [];
+            if (allCrateDeps.has('tokio-postgres') || allCrateDeps.has('sqlx') || allCrateDeps.has('diesel'))
+                rustDatabases.push('PostgreSQL');
+            if (allCrateDeps.has('mongodb'))
+                rustDatabases.push('MongoDB');
+            if (allCrateDeps.has('redis'))
+                rustDatabases.push('Redis');
+            if (allCrateDeps.has('rusqlite'))
+                rustDatabases.push('SQLite');
+            if (rustDatabases.length > 0)
+                stack.database = rustDatabases.join(', ');
+            // === BUILD TOOLS ===
+            const rustBuildTools = [];
+            if (allCrateDeps.has('maturin'))
+                rustBuildTools.push('Maturin');
+            if (allCrateDeps.has('wasm-bindgen'))
+                rustBuildTools.push('wasm-bindgen');
+            if (allCrateDeps.has('napi') || allCrateDeps.has('napi-derive'))
+                rustBuildTools.push('napi-rs');
+            if (rustBuildTools.length > 0)
+                stack.buildTools = rustBuildTools;
+            // === DEPLOYMENT ===
+            if (!stack.deployment) {
+                if (await fileExists(join(rootDir, 'Dockerfile')))
+                    stack.deployment = 'Docker';
+                else if (await fileExists(join(rootDir, 'fly.toml')))
+                    stack.deployment = 'Fly.io';
+                else if (await fileExists(join(rootDir, 'shuttle.toml')) || allCrateDeps.has('shuttle-runtime'))
+                    stack.deployment = 'Shuttle';
+            }
+            // === CI/CD ===
+            if (!stack.cicd || stack.cicd.length === 0) {
+                const cicd = [];
+                if (await fileExists(join(rootDir, '.github/workflows')))
+                    cicd.push('GitHub Actions');
+                if (await fileExists(join(rootDir, '.gitlab-ci.yml')))
+                    cicd.push('GitLab CI');
+                stack.cicd = cicd;
+            }
+        }
+        catch { }
     }
     // Check for Go project
     const goModPath = join(rootDir, 'go.mod');
     if (await fileExists(goModPath)) {
         stack.language = 'Go';
         stack.packageManager = 'go';
+        try {
+            const goModContent = await readFile(goModPath, 'utf-8');
+            // Parse Go version
+            const goVersionMatch = goModContent.match(/^go\s+(\S+)/m);
+            if (goVersionMatch) {
+                stack.runtime = `Go ${goVersionMatch[1]}`;
+            }
+            // Parse module path
+            const moduleMatch = goModContent.match(/^module\s+(\S+)/m);
+            const modulePath = moduleMatch?.[1] || '';
+            // Parse require block
+            const allGoMods = new Set();
+            const depsRecord = {};
+            // Single-line requires: require github.com/foo/bar v1.2.3
+            const singleReqs = goModContent.matchAll(/^require\s+(\S+)\s+(\S+)/gm);
+            for (const m of singleReqs) {
+                const modName = m[1].toLowerCase();
+                allGoMods.add(modName);
+                depsRecord[m[1]] = m[2];
+            }
+            // Block requires
+            const requireBlocks = goModContent.matchAll(/require\s*\(([\s\S]*?)\)/g);
+            for (const block of requireBlocks) {
+                const lines = block[1].split('\n');
+                for (const line of lines) {
+                    const depMatch = line.trim().match(/^(\S+)\s+(\S+)/);
+                    if (depMatch && !depMatch[1].startsWith('//')) {
+                        allGoMods.add(depMatch[1].toLowerCase());
+                        depsRecord[depMatch[1]] = depMatch[2];
+                    }
+                }
+            }
+            if (Object.keys(depsRecord).length > 0)
+                stack.dependencies = depsRecord;
+            // Helper: check if any go module path contains a substring
+            const hasGoMod = (name) => [...allGoMods].some(m => m.includes(name));
+            // === FRAMEWORKS ===
+            const goFrameworks = [];
+            if (hasGoMod('gin-gonic/gin'))
+                goFrameworks.push('Gin');
+            if (hasGoMod('labstack/echo'))
+                goFrameworks.push('Echo');
+            if (hasGoMod('gofiber/fiber'))
+                goFrameworks.push('Fiber');
+            if (hasGoMod('go-chi/chi'))
+                goFrameworks.push('Chi');
+            if (hasGoMod('gorilla/mux'))
+                goFrameworks.push('Gorilla Mux');
+            if (hasGoMod('beego'))
+                goFrameworks.push('Beego');
+            if (hasGoMod('grpc'))
+                goFrameworks.push('gRPC');
+            // CLI
+            if (hasGoMod('spf13/cobra'))
+                goFrameworks.push('Cobra');
+            if (hasGoMod('urfave/cli'))
+                goFrameworks.push('urfave/cli');
+            // Config
+            if (hasGoMod('spf13/viper'))
+                goFrameworks.push('Viper');
+            if (goFrameworks.length > 0) {
+                stack.frameworks = goFrameworks;
+                stack.framework = goFrameworks[0];
+            }
+            // === TESTING ===
+            const goTesting = ['go test (built-in)'];
+            if (hasGoMod('stretchr/testify'))
+                goTesting.push('Testify');
+            if (hasGoMod('onsi/ginkgo'))
+                goTesting.push('Ginkgo');
+            if (hasGoMod('onsi/gomega'))
+                goTesting.push('Gomega');
+            stack.testingFrameworks = goTesting;
+            // === ORM/DATABASE ===
+            if (hasGoMod('gorm.io'))
+                stack.orm = 'GORM';
+            else if (hasGoMod('ent/ent'))
+                stack.orm = 'Ent';
+            else if (hasGoMod('sqlc'))
+                stack.orm = 'sqlc';
+            else if (hasGoMod('jmoiron/sqlx'))
+                stack.orm = 'sqlx';
+            const goDatabases = [];
+            if (hasGoMod('lib/pq') || hasGoMod('jackc/pgx') || hasGoMod('pgx'))
+                goDatabases.push('PostgreSQL');
+            if (hasGoMod('go.mongodb.org') || hasGoMod('mongo-driver'))
+                goDatabases.push('MongoDB');
+            if (hasGoMod('go-redis/redis') || hasGoMod('redis/go-redis'))
+                goDatabases.push('Redis');
+            if (hasGoMod('mattn/go-sqlite3'))
+                goDatabases.push('SQLite');
+            if (hasGoMod('go-sql-driver/mysql'))
+                goDatabases.push('MySQL');
+            if (goDatabases.length > 0)
+                stack.database = goDatabases.join(', ');
+            // === DEPLOYMENT ===
+            if (!stack.deployment) {
+                if (await fileExists(join(rootDir, 'Dockerfile')))
+                    stack.deployment = 'Docker';
+                else if (await fileExists(join(rootDir, 'fly.toml')))
+                    stack.deployment = 'Fly.io';
+            }
+            // === CI/CD ===
+            if (!stack.cicd || stack.cicd.length === 0) {
+                const cicd = [];
+                if (await fileExists(join(rootDir, '.github/workflows')))
+                    cicd.push('GitHub Actions');
+                if (await fileExists(join(rootDir, '.gitlab-ci.yml')))
+                    cicd.push('GitLab CI');
+                stack.cicd = cicd;
+            }
+        }
+        catch { }
     }
     return stack;
 }
@@ -608,23 +1259,141 @@ export async function inferArchitecture(rootDir) {
     const hasPackages = relativeDirs.some(d => d === 'packages');
     const hasApps = relativeDirs.some(d => d === 'apps');
     const hasServices = relativeDirs.some(d => d === 'services');
-    if (hasPackages || hasApps) {
-        architecture.type = 'monorepo';
-    }
-    else if (hasServices) {
-        architecture.type = 'microservices';
+    // Check for Python CLI entry points from pyproject.toml
+    let hasPythonScripts = false;
+    let hasPythonWebFramework = false;
+    const pyprojectArchPath = join(rootDir, 'pyproject.toml');
+    if (await fileExists(pyprojectArchPath)) {
+        try {
+            const pyContent = await readFile(pyprojectArchPath, 'utf-8');
+            const pyproject = parsePyprojectToml(pyContent);
+            // CLI entry points from [project.scripts]
+            const scripts = pyproject?.project?.scripts;
+            if (scripts && typeof scripts === 'object' && Object.keys(scripts).length > 0) {
+                hasPythonScripts = true;
+                for (const [cmdName, entryPoint] of Object.entries(scripts)) {
+                    if (typeof entryPoint === 'string') {
+                        architecture.entryPoints = architecture.entryPoints || [];
+                        architecture.entryPoints.push({
+                            file: entryPoint,
+                            purpose: `CLI command: ${cmdName}`
+                        });
+                    }
+                }
+            }
+            // Check for web framework deps
+            const deps = pyproject?.project?.dependencies || [];
+            const depNames = deps.map(extractPyDepName);
+            hasPythonWebFramework = depNames.some(d => ['django', 'flask', 'fastapi', 'starlette', 'sanic', 'tornado', 'falcon', 'litestar'].includes(d));
+        }
+        catch { }
     }
-    else if (hasApp && hasSrc) {
-        architecture.type = 'fullstack';
+    // Python-specific entry points
+    if (await fileExists(join(rootDir, 'manage.py'))) {
+        architecture.entryPoints = architecture.entryPoints || [];
+        architecture.entryPoints.push({ file: 'manage.py', purpose: 'Django management' });
     }
-    else if (hasLib && !hasApp) {
-        architecture.type = 'library';
+    // Rust architecture detection
+    let hasRustBin = false;
+    let hasRustLib = false;
+    let hasRustWebFramework = false;
+    let hasRustCliFramework = false;
+    const cargoArchPath = join(rootDir, 'Cargo.toml');
+    if (await fileExists(cargoArchPath)) {
+        try {
+            const cargoContent = await readFile(cargoArchPath, 'utf-8');
+            const cargo = parsePyprojectToml(cargoContent);
+            hasRustBin = await fileExists(join(rootDir, 'src/main.rs'));
+            hasRustLib = await fileExists(join(rootDir, 'src/lib.rs'));
+            const cargoDeps = Object.keys(cargo?.dependencies || {}).map(s => s.toLowerCase());
+            hasRustWebFramework = cargoDeps.some(d => ['actix-web', 'axum', 'rocket', 'warp', 'tide'].includes(d));
+            hasRustCliFramework = cargoDeps.some(d => ['clap', 'structopt'].includes(d));
+            // Rust entry points
+            if (hasRustBin) {
+                architecture.entryPoints = architecture.entryPoints || [];
+                architecture.entryPoints.push({ file: 'src/main.rs', purpose: 'Binary entry point' });
+            }
+            if (hasRustLib) {
+                architecture.entryPoints = architecture.entryPoints || [];
+                architecture.entryPoints.push({ file: 'src/lib.rs', purpose: 'Library entry point' });
+            }
+        }
+        catch { }
     }
-    else if (await fileExists(join(rootDir, 'bin'))) {
-        architecture.type = 'cli';
+    // Go architecture detection
+    let hasGoCmd = false;
+    let hasGoWebFramework = false;
+    let hasGoCliFramework = false;
+    const goModArchPath = join(rootDir, 'go.mod');
+    if (await fileExists(goModArchPath)) {
+        try {
+            const goModContent = await readFile(goModArchPath, 'utf-8');
+            hasGoCmd = relativeDirs.some(d => d === 'cmd' || d.startsWith('cmd/'));
+            const goMainExists = await fileExists(join(rootDir, 'main.go'));
+            const goModLower = goModContent.toLowerCase();
+            hasGoWebFramework = ['gin-gonic', 'labstack/echo', 'gofiber/fiber', 'go-chi/chi', 'gorilla/mux'].some(f => goModLower.includes(f));
+            hasGoCliFramework = ['spf13/cobra', 'urfave/cli'].some(f => goModLower.includes(f));
+            // Go entry points
+            if (hasGoCmd) {
+                architecture.entryPoints = architecture.entryPoints || [];
+                architecture.entryPoints.push({ file: 'cmd/', purpose: 'CLI entry points' });
+            }
+            else if (goMainExists) {
+                architecture.entryPoints = architecture.entryPoints || [];
+                architecture.entryPoints.push({ file: 'main.go', purpose: 'Application entry' });
+            }
+        }
+        catch { }
     }
-    else if (hasPages || hasApp) {
-        architecture.type = 'frontend';
+    // === Score-based architecture type detection ===
+    // Each signal contributes to a score for each type
+    const typeScores = {
+        monorepo: 0, microservices: 0, cli: 0, backend: 0,
+        fullstack: 0, library: 0, frontend: 0
+    };
+    // Monorepo signals
+    if (hasPackages || hasApps)
+        typeScores.monorepo += 10;
+    // Microservices signals
+    if (hasServices)
+        typeScores.microservices += 8;
+    // CLI signals
+    if (hasPythonScripts && !hasPythonWebFramework)
+        typeScores.cli += 8;
+    if (hasRustCliFramework && hasRustBin)
+        typeScores.cli += 8;
+    if (hasGoCliFramework || hasGoCmd)
+        typeScores.cli += 8;
+    if (await fileExists(join(rootDir, 'bin')))
+        typeScores.cli += 5;
+    // Backend signals
+    if (hasPythonWebFramework)
+        typeScores.backend += 8;
+    if (hasRustWebFramework)
+        typeScores.backend += 8;
+    if (hasGoWebFramework)
+        typeScores.backend += 8;
+    if (relativeDirs.some(d => d.includes('api')))
+        typeScores.backend += 2;
+    // Fullstack signals
+    if (hasApp && hasSrc)
+        typeScores.fullstack += 5;
+    if (hasPythonWebFramework && relativeDirs.some(d => d.includes('dashboard') || d.includes('frontend')))
+        typeScores.fullstack += 7;
+    // Library signals
+    if (hasLib && !hasApp && !hasPages)
+        typeScores.library += 5;
+    if (hasRustLib && !hasRustBin)
+        typeScores.library += 8;
+    // Frontend signals
+    if (hasPages || (hasApp && !hasSrc && !hasServices))
+        typeScores.frontend += 5;
+    // Pick highest score, with fallback
+    const sortedTypes = Object.entries(typeScores)
+        .filter(([, score]) => score > 0)
+        .sort((a, b) => b[1] - a[1]);
+    if (sortedTypes.length > 0) {
+        architecture.type = sortedTypes[0][0];
     }
     else {
         architecture.type = 'backend';
@@ -700,6 +1469,12 @@ export async function inferArchitecture(rootDir) {
         patterns.push('Feature-based organization');
     if (relativeDirs.some(d => d.includes('modules')))
         patterns.push('Module pattern');
+    if (relativeDirs.some(d => d.includes('agents')))
+        patterns.push('Agent-based architecture');
+    if (relativeDirs.some(d => d.includes('missions') || d.includes('pipelines')))
+        patterns.push('Pipeline pattern');
+    if (relativeDirs.some(d => d.includes('models') && !d.includes('node_modules')))
+        patterns.push('Data models');
     architecture.patterns = patterns;
     // Detect conventions
     const conventions = [];
@@ -718,9 +1493,51 @@ export async function inferArchitecture(rootDir) {
     if (await fileExists(join(rootDir, '.husky'))) {
         conventions.push('Git hooks (Husky)');
     }
+    // Python conventions
+    if (await fileExists(pyprojectArchPath)) {
+        try {
+            const pyContent = await readFile(pyprojectArchPath, 'utf-8');
+            const pyproject = parsePyprojectToml(pyContent);
+            if (pyproject?.tool?.ruff)
+                conventions.push('Ruff code linting');
+            if (pyproject?.tool?.black)
+                conventions.push('Black code formatting');
+            if (pyproject?.tool?.mypy)
+                conventions.push('mypy type checking');
+            if (pyproject?.tool?.isort)
+                conventions.push('isort import sorting');
+            if (pyproject?.tool?.pytest)
+                conventions.push('pytest configuration');
+        }
+        catch { }
+    }
+    if (await fileExists(join(rootDir, '.flake8'))) {
+        conventions.push('flake8 code linting');
+    }
+    if (await fileExists(join(rootDir, 'mypy.ini')) || await fileExists(join(rootDir, '.mypy.ini'))) {
+        conventions.push('mypy type checking');
+    }
+    // Rust conventions
+    if (await fileExists(cargoArchPath)) {
+        if (await fileExists(join(rootDir, 'rustfmt.toml')) || await fileExists(join(rootDir, '.rustfmt.toml'))) {
+            conventions.push('rustfmt code formatting');
+        }
+        if (await fileExists(join(rootDir, 'clippy.toml')) || await fileExists(join(rootDir, '.clippy.toml'))) {
+            conventions.push('Clippy linting');
+        }
+        // Rust always has these by convention
+        conventions.push('cargo fmt / cargo clippy');
+    }
+    // Go conventions
+    if (await fileExists(goModArchPath)) {
+        if (await fileExists(join(rootDir, '.golangci.yml')) || await fileExists(join(rootDir, '.golangci.yaml'))) {
+            conventions.push('golangci-lint');
+        }
+        conventions.push('gofmt / go vet');
+    }
     architecture.conventions = conventions;
-    // Detect entry points
-    const entryPoints = [];
+    // Detect entry points (preserve any already detected, e.g. from pyproject.toml)
+    const entryPoints = architecture.entryPoints || [];
     if (await fileExists(join(rootDir, 'src/index.ts')))
         entryPoints.push({ file: 'src/index.ts', purpose: 'Main entry point' });
     else if (await fileExists(join(rootDir, 'src/index.tsx')))
@@ -847,6 +1664,73 @@ export async function inferConstraints(rootDir) {
             formatter: 'Prettier'
         };
     }
+    // Python code style tools
+    const pyprojectConstraintsPath = join(rootDir, 'pyproject.toml');
+    if (await fileExists(pyprojectConstraintsPath)) {
+        try {
+            const pyContent = await readFile(pyprojectConstraintsPath, 'utf-8');
+            const pyproject = parsePyprojectToml(pyContent);
+            // Linter
+            if (pyproject?.tool?.ruff) {
+                constraints.codeStyle = {
+                    ...constraints.codeStyle,
+                    linter: 'Ruff'
+                };
+                const targetVersion = pyproject.tool.ruff['target-version'];
+                if (targetVersion && typeof targetVersion === 'string') {
+                    // py311 → 3.11, py39 → 3.9
+                    const nums = targetVersion.replace('py', '');
+                    const major = nums[0];
+                    const minor = nums.slice(1);
+                    if (major && minor) {
+                        constraints.mustUse?.push(`Python ${major}.${minor}+`);
+                    }
+                }
+                const lineLength = pyproject.tool.ruff['line-length'];
+                if (lineLength) {
+                    constraints.preferences?.push({
+                        category: 'Code Style',
+                        preference: `Line length: ${lineLength}`,
+                        rationale: 'Ruff configuration'
+                    });
+                }
+            }
+            if (pyproject?.tool?.black) {
+                constraints.codeStyle = {
+                    ...constraints.codeStyle,
+                    formatter: 'Black'
+                };
+            }
+            if (pyproject?.tool?.mypy) {
+                constraints.mustUse?.push('mypy for type checking');
+            }
+            // Python version constraint (only if not already added from Ruff target-version)
+            const requiresPython = pyproject?.project?.['requires-python'];
+            if (requiresPython && !constraints.mustUse?.some(m => m.startsWith('Python '))) {
+                constraints.mustUse?.push(`Python ${requiresPython}`);
+            }
+            // Testing from pyproject
+            const deps = pyproject?.project?.dependencies || [];
+            const optDeps = pyproject?.project?.['optional-dependencies'] || {};
+            const allDepNames = new Set([
+                ...deps.map(extractPyDepName),
+                ...Object.values(optDeps).flat().filter((d) => typeof d === 'string').map(extractPyDepName)
+            ]);
+            if (allDepNames.has('pytest') || pyproject?.tool?.pytest) {
+                constraints.testing = {
+                    required: true,
+                    strategy: 'pytest'
+                };
+            }
+        }
+        catch { }
+    }
+    if (await fileExists(join(rootDir, '.flake8'))) {
+        constraints.codeStyle = {
+            ...constraints.codeStyle,
+            linter: constraints.codeStyle?.linter || 'flake8'
+        };
+    }
     // Check for TypeScript
     if (await fileExists(join(rootDir, 'tsconfig.json'))) {
         constraints.mustUse?.push('TypeScript for type safety');