pi-lens 2.2.9 → 3.0.0

package/clients/project-metadata.js

@@ -0,0 +1,531 @@
+/**
+ * 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);
+}