pi-lens 3.6.3 → 3.6.4

package/clients/project-metadata.js

@@ -1,531 +0,0 @@
-/**
- * Project Metadata Detection for pi-lens
- *
- * Extracts project configuration from common config files:
- * - package.json (Node.js/npm/pnpm/yarn/bun)
- * - pyproject.toml (Python)
- * - Cargo.toml (Rust)
- * - go.mod (Go)
- * - composer.json (PHP)
- * - Gemfile (Ruby)
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-// --- Detection Functions ---
-/**
- * Detect project metadata from a target directory.
- * Reads common config files and extracts structured information.
- */
-export function detectProjectMetadata(targetPath) {
-    const metadata = {
-        type: "unknown",
-        scripts: {},
-        languages: [],
-        hasTests: false,
-        hasLinting: false,
-        hasFormatting: false,
-        hasTypeScript: false,
-        configFiles: [],
-    };
-    // Check for Node.js project
-    const nodeMeta = detectNodeProject(targetPath);
-    if (nodeMeta) {
-        Object.assign(metadata, nodeMeta);
-    }
-    // Check for Python project
-    const pythonMeta = detectPythonProject(targetPath);
-    if (pythonMeta && metadata.type === "unknown") {
-        Object.assign(metadata, pythonMeta);
-    }
-    // Check for Rust project
-    const rustMeta = detectRustProject(targetPath);
-    if (rustMeta && metadata.type === "unknown") {
-        Object.assign(metadata, rustMeta);
-    }
-    // Check for Go project
-    const goMeta = detectGoProject(targetPath);
-    if (goMeta && metadata.type === "unknown") {
-        Object.assign(metadata, goMeta);
-    }
-    // Check for PHP project
-    const phpMeta = detectPhpProject(targetPath);
-    if (phpMeta && metadata.type === "unknown") {
-        Object.assign(metadata, phpMeta);
-    }
-    // Check for Ruby project
-    const rubyMeta = detectRubyProject(targetPath);
-    if (rubyMeta && metadata.type === "unknown") {
-        Object.assign(metadata, rubyMeta);
-    }
-    // Multi-project detection: if multiple types found
-    const types = [nodeMeta, pythonMeta, rustMeta, goMeta, phpMeta, rubyMeta]
-        .filter(Boolean)
-        .map(m => m.type);
-    if (types.length > 1) {
-        metadata.type = "multi";
-        metadata.languages = [...new Set(types)];
-    }
-    return metadata;
-}
-/**
- * Detect Node.js project from package.json and lockfiles
- */
-function detectNodeProject(targetPath) {
-    const packageJsonPath = path.join(targetPath, "package.json");
-    if (!fs.existsSync(packageJsonPath)) {
-        return null;
-    }
-    let packageJson;
-    try {
-        packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-    const metadata = {
-        type: "node",
-        name: typeof packageJson.name === "string" ? packageJson.name : undefined,
-        version: typeof packageJson.version === "string" ? packageJson.version : undefined,
-        packageManager: detectNodePackageManager(targetPath),
-        scripts: typeof packageJson.scripts === "object" && packageJson.scripts !== null
-            ? packageJson.scripts
-            : {},
-        languages: ["javascript"],
-        hasTests: false,
-        hasLinting: false,
-        hasFormatting: false,
-        hasTypeScript: fs.existsSync(path.join(targetPath, "tsconfig.json")),
-        configFiles: ["package.json"],
-    };
-    // Detect TypeScript
-    if (metadata.hasTypeScript) {
-        metadata.languages.push("typescript");
-        metadata.configFiles.push("tsconfig.json");
-    }
-    // Detect tests from scripts or config files
-    const scripts = Object.keys(metadata.scripts).join(" ").toLowerCase();
-    if (scripts.includes("test") || scripts.includes("spec")) {
-        metadata.hasTests = true;
-    }
-    // Detect test frameworks from dependencies
-    const allDeps = {
-        ...(packageJson.dependencies || {}),
-        ...(packageJson.devDependencies || {}),
-    };
-    if (allDeps["vitest"]) {
-        metadata.hasTests = true;
-        metadata.testFramework = "vitest";
-    }
-    else if (allDeps["jest"]) {
-        metadata.hasTests = true;
-        metadata.testFramework = "jest";
-    }
-    else if (allDeps["mocha"]) {
-        metadata.hasTests = true;
-        metadata.testFramework = "mocha";
-    }
-    else if (allDeps["ava"]) {
-        metadata.hasTests = true;
-        metadata.testFramework = "ava";
-    }
-    else if (allDeps["tap"]) {
-        metadata.hasTests = true;
-        metadata.testFramework = "tap";
-    }
-    else if (allDeps["node:test"]) {
-        metadata.hasTests = true;
-        metadata.testFramework = "node:test";
-    }
-    // Detect linting
-    if (allDeps["eslint"] || fs.existsSync(path.join(targetPath, ".eslintrc")) ||
-        fs.existsSync(path.join(targetPath, ".eslintrc.js")) ||
-        fs.existsSync(path.join(targetPath, "eslint.config.js")) ||
-        fs.existsSync(path.join(targetPath, "eslint.config.mjs"))) {
-        metadata.hasLinting = true;
-        metadata.linter = "eslint";
-        metadata.configFiles.push("eslint config");
-    }
-    if (allDeps["@biomejs/biome"] || fs.existsSync(path.join(targetPath, "biome.json"))) {
-        metadata.hasLinting = true;
-        metadata.linter = metadata.linter ? `${metadata.linter}, biome` : "biome";
-        metadata.configFiles.push("biome.json");
-    }
-    // Detect formatting
-    if (allDeps["prettier"] || fs.existsSync(path.join(targetPath, ".prettierrc")) ||
-        fs.existsSync(path.join(targetPath, ".prettierrc.json"))) {
-        metadata.hasFormatting = true;
-        metadata.formatter = metadata.formatter ? `${metadata.formatter}, prettier` : "prettier";
-        metadata.configFiles.push("prettier config");
-    }
-    if (allDeps["@biomejs/biome"]) {
-        metadata.hasFormatting = true;
-        metadata.formatter = metadata.formatter ? `${metadata.formatter}, biome` : "biome";
-    }
-    return metadata;
-}
-/**
- * Detect Node.js package manager from lockfiles
- */
-function detectNodePackageManager(targetPath) {
-    if (fs.existsSync(path.join(targetPath, "bun.lockb")) || fs.existsSync(path.join(targetPath, "bun.lock"))) {
-        return "bun";
-    }
-    if (fs.existsSync(path.join(targetPath, "pnpm-lock.yaml"))) {
-        return "pnpm";
-    }
-    if (fs.existsSync(path.join(targetPath, "yarn.lock"))) {
-        return "yarn";
-    }
-    if (fs.existsSync(path.join(targetPath, "package-lock.json"))) {
-        return "npm";
-    }
-    return undefined;
-}
-/**
- * Detect Python project from pyproject.toml, setup.py, requirements.txt
- */
-function detectPythonProject(targetPath) {
-    const pyprojectPath = path.join(targetPath, "pyproject.toml");
-    const setupPyPath = path.join(targetPath, "setup.py");
-    const requirementsPath = path.join(targetPath, "requirements.txt");
-    if (!fs.existsSync(pyprojectPath) && !fs.existsSync(setupPyPath) && !fs.existsSync(requirementsPath)) {
-        return null;
-    }
-    const metadata = {
-        type: "python",
-        packageManager: detectPythonPackageManager(targetPath),
-        scripts: {},
-        languages: ["python"],
-        hasTests: false,
-        hasLinting: false,
-        hasFormatting: false,
-        hasTypeScript: false,
-        configFiles: [],
-    };
-    // Read pyproject.toml if available
-    if (fs.existsSync(pyprojectPath)) {
-        metadata.configFiles.push("pyproject.toml");
-        try {
-            const content = fs.readFileSync(pyprojectPath, "utf-8");
-            // Extract project name
-            const nameMatch = content.match(/\[project\][\s\S]*?name\s*=\s*["']([^"']+)["']/);
-            if (nameMatch)
-                metadata.name = nameMatch[1];
-            // Extract version
-            const versionMatch = content.match(/\[project\][\s\S]*?version\s*=\s*["']([^"']+)["']/);
-            if (versionMatch)
-                metadata.version = versionMatch[1];
-            // Detect test framework
-            if (content.includes("pytest") || fs.existsSync(path.join(targetPath, "pytest.ini"))) {
-                metadata.hasTests = true;
-                metadata.testFramework = "pytest";
-            }
-            // Detect linting
-            if (content.includes("ruff") || fs.existsSync(path.join(targetPath, "ruff.toml"))) {
-                metadata.hasLinting = true;
-                metadata.linter = "ruff";
-                metadata.hasFormatting = true;
-                metadata.formatter = "ruff";
-            }
-            else if (content.includes("pylint") || content.includes("flake8")) {
-                metadata.hasLinting = true;
-                metadata.linter = content.includes("pylint") ? "pylint" : "flake8";
-            }
-        }
-        catch {
-            // Ignore parse errors
-        }
-    }
-    if (fs.existsSync(setupPyPath))
-        metadata.configFiles.push("setup.py");
-    if (fs.existsSync(requirementsPath))
-        metadata.configFiles.push("requirements.txt");
-    return metadata;
-}
-/**
- * Detect Python package manager
- */
-function detectPythonPackageManager(targetPath) {
-    if (fs.existsSync(path.join(targetPath, "uv.lock"))) {
-        return "uv";
-    }
-    if (fs.existsSync(path.join(targetPath, "poetry.lock"))) {
-        return "poetry";
-    }
-    if (fs.existsSync(path.join(targetPath, "Pipfile.lock")) || fs.existsSync(path.join(targetPath, "Pipfile"))) {
-        return "pip"; // pipenv uses Pipfile
-    }
-    if (fs.existsSync(path.join(targetPath, "requirements.txt"))) {
-        return "pip";
-    }
-    return undefined;
-}
-/**
- * Detect Rust project from Cargo.toml
- */
-function detectRustProject(targetPath) {
-    const cargoPath = path.join(targetPath, "Cargo.toml");
-    if (!fs.existsSync(cargoPath)) {
-        return null;
-    }
-    const metadata = {
-        type: "rust",
-        packageManager: "cargo",
-        scripts: {},
-        languages: ["rust"],
-        hasTests: true, // Cargo has built-in test support
-        hasLinting: false,
-        hasFormatting: false,
-        hasTypeScript: false,
-        configFiles: ["Cargo.toml"],
-    };
-    // Read Cargo.toml
-    try {
-        const content = fs.readFileSync(cargoPath, "utf-8");
-        // Extract package name
-        const nameMatch = content.match(/\[package\][\s\S]*?name\s*=\s*["']([^"']+)["']/);
-        if (nameMatch)
-            metadata.name = nameMatch[1];
-        // Extract version
-        const versionMatch = content.match(/\[package\][\s\S]*?version\s*=\s*["']([^"']+)["']/);
-        if (versionMatch)
-            metadata.version = versionMatch[1];
-    }
-    catch {
-        // Ignore parse errors
-    }
-    // Check for clippy (linter)
-    if (fs.existsSync(path.join(targetPath, ".clippy.toml")) ||
-        fs.existsSync(path.join(targetPath, "clippy.toml"))) {
-        metadata.hasLinting = true;
-        metadata.linter = "clippy";
-    }
-    // Check for rustfmt
-    if (fs.existsSync(path.join(targetPath, ".rustfmt.toml")) ||
-        fs.existsSync(path.join(targetPath, "rustfmt.toml"))) {
-        metadata.hasFormatting = true;
-        metadata.formatter = "rustfmt";
-    }
-    return metadata;
-}
-/**
- * Detect Go project from go.mod
- */
-function detectGoProject(targetPath) {
-    const goModPath = path.join(targetPath, "go.mod");
-    if (!fs.existsSync(goModPath)) {
-        return null;
-    }
-    const metadata = {
-        type: "go",
-        packageManager: "gomod",
-        scripts: {},
-        languages: ["go"],
-        hasTests: true, // Go has built-in test support
-        hasLinting: false,
-        hasFormatting: false,
-        hasTypeScript: false,
-        configFiles: ["go.mod"],
-    };
-    // Read go.mod
-    try {
-        const content = fs.readFileSync(goModPath, "utf-8");
-        // Extract module name (first line: module example.com/module)
-        const moduleMatch = content.match(/^module\s+(\S+)/m);
-        if (moduleMatch)
-            metadata.name = moduleMatch[1];
-        // Extract go version
-        const versionMatch = content.match(/^go\s+(\S+)/m);
-        if (versionMatch)
-            metadata.version = versionMatch[1];
-    }
-    catch {
-        // Ignore parse errors
-    }
-    // Check for golangci-lint
-    if (fs.existsSync(path.join(targetPath, ".golangci.yml")) ||
-        fs.existsSync(path.join(targetPath, ".golangci.yaml"))) {
-        metadata.hasLinting = true;
-        metadata.linter = "golangci-lint";
-    }
-    return metadata;
-}
-/**
- * Detect PHP project from composer.json
- */
-function detectPhpProject(targetPath) {
-    const composerPath = path.join(targetPath, "composer.json");
-    if (!fs.existsSync(composerPath)) {
-        return null;
-    }
-    let composerJson;
-    try {
-        composerJson = JSON.parse(fs.readFileSync(composerPath, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-    const metadata = {
-        type: "php",
-        packageManager: "composer",
-        name: typeof composerJson.name === "string" ? composerJson.name : undefined,
-        scripts: typeof composerJson.scripts === "object" && composerJson.scripts !== null
-            ? composerJson.scripts
-            : {},
-        languages: ["php"],
-        hasTests: false,
-        hasLinting: false,
-        hasFormatting: false,
-        hasTypeScript: false,
-        configFiles: ["composer.json"],
-    };
-    // Detect tests from scripts
-    const scripts = Object.keys(metadata.scripts).join(" ").toLowerCase();
-    if (scripts.includes("test") || scripts.includes("phpunit")) {
-        metadata.hasTests = true;
-        metadata.testFramework = "phpunit";
-    }
-    return metadata;
-}
-/**
- * Detect Ruby project from Gemfile
- */
-function detectRubyProject(targetPath) {
-    const gemfilePath = path.join(targetPath, "Gemfile");
-    const gemspecPath = fs.readdirSync(targetPath).find(f => f.endsWith(".gemspec"));
-    if (!fs.existsSync(gemfilePath) && !gemspecPath) {
-        return null;
-    }
-    const metadata = {
-        type: "ruby",
-        packageManager: "bundler",
-        scripts: {},
-        languages: ["ruby"],
-        hasTests: false,
-        hasLinting: false,
-        hasFormatting: false,
-        hasTypeScript: false,
-        configFiles: [],
-    };
-    if (fs.existsSync(gemfilePath))
-        metadata.configFiles.push("Gemfile");
-    if (gemspecPath)
-        metadata.configFiles.push(gemspecPath);
-    // Check for Rakefile to get tasks
-    const rakefilePath = path.join(targetPath, "Rakefile");
-    if (fs.existsSync(rakefilePath)) {
-        metadata.configFiles.push("Rakefile");
-    }
-    // Check for test framework
-    if (fs.existsSync(path.join(targetPath, "spec"))) {
-        metadata.hasTests = true;
-        metadata.testFramework = "rspec";
-    }
-    else if (fs.existsSync(path.join(targetPath, "test"))) {
-        metadata.hasTests = true;
-        metadata.testFramework = "minitest";
-    }
-    // Check for rubocop
-    if (fs.existsSync(path.join(targetPath, ".rubocop.yml"))) {
-        metadata.hasLinting = true;
-        metadata.linter = "rubocop";
-        metadata.configFiles.push(".rubocop.yml");
-    }
-    return metadata;
-}
-// --- Formatting Utilities ---
-/**
- * Format project metadata for display in reports
- */
-export function formatProjectMetadata(metadata) {
-    const lines = [];
-    // Header
-    const name = metadata.name ? `**${metadata.name}**` : "Project";
-    const type = metadata.type !== "unknown" ? `(${capitalize(metadata.type)})` : "";
-    lines.push(`📊 ${name} ${type}`.trim());
-    // Package manager
-    if (metadata.packageManager) {
-        lines.push(`📦 Package Manager: ${capitalize(metadata.packageManager)}`);
-    }
-    // Languages
-    if (metadata.languages.length > 0) {
-        lines.push(`📝 Languages: ${metadata.languages.map(capitalize).join(", ")}`);
-    }
-    // Tools
-    const tools = [];
-    if (metadata.hasTests) {
-        tools.push(metadata.testFramework ? `🧪 ${metadata.testFramework}` : "🧪 tests");
-    }
-    if (metadata.hasLinting) {
-        tools.push(metadata.linter ? `🔍 ${metadata.linter}` : "🔍 linting");
-    }
-    if (metadata.hasFormatting) {
-        tools.push(metadata.formatter ? `✨ ${metadata.formatter}` : "✨ formatting");
-    }
-    if (tools.length > 0) {
-        lines.push(tools.join(" | "));
-    }
-    // Config files (limited)
-    if (metadata.configFiles.length > 0) {
-        const limited = metadata.configFiles.slice(0, 5);
-        const more = metadata.configFiles.length > 5 ? ` (+${metadata.configFiles.length - 5} more)` : "";
-        lines.push(`⚙️ Config: ${limited.join(", ")}${more}`);
-    }
-    return lines.join("\n");
-}
-/**
- * Get available commands for a project (build, test, lint, etc.)
- */
-export function getAvailableCommands(metadata) {
-    const commands = [];
-    // Node.js projects - use npm scripts
-    if (metadata.type === "node" && Object.keys(metadata.scripts).length > 0) {
-        const scriptPriority = ["test", "build", "lint", "format", "dev", "start", "typecheck"];
-        for (const priority of scriptPriority) {
-            const matching = Object.entries(metadata.scripts).find(([name]) => name.toLowerCase().includes(priority));
-            if (matching) {
-                const runCmd = metadata.packageManager === "bun" ? "bun run" :
-                    metadata.packageManager === "pnpm" ? "pnpm" :
-                        metadata.packageManager === "yarn" ? "yarn" :
-                            "npm run";
-                commands.push({
-                    action: priority,
-                    command: `${runCmd} ${matching[0]}`,
-                });
-            }
-        }
-    }
-    // Python projects
-    if (metadata.type === "python") {
-        if (metadata.hasTests) {
-            const testCmd = metadata.packageManager === "poetry" ? "poetry run pytest" :
-                metadata.packageManager === "uv" ? "uv run pytest" :
-                    "pytest";
-            commands.push({ action: "test", command: testCmd });
-        }
-        if (metadata.linter?.includes("ruff")) {
-            commands.push({ action: "lint", command: "ruff check ." });
-            commands.push({ action: "format", command: "ruff format ." });
-        }
-    }
-    // Rust projects
-    if (metadata.type === "rust") {
-        commands.push({ action: "build", command: "cargo build" });
-        commands.push({ action: "test", command: "cargo test" });
-        if (metadata.hasLinting) {
-            commands.push({ action: "lint", command: "cargo clippy" });
-        }
-    }
-    // Go projects
-    if (metadata.type === "go") {
-        commands.push({ action: "build", command: "go build" });
-        commands.push({ action: "test", command: "go test ./..." });
-        if (metadata.hasLinting) {
-            commands.push({ action: "lint", command: "golangci-lint run" });
-        }
-    }
-    return commands;
-}
-function capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}