@lousy-agents/cli 2.5.3 → 2.6.1

package/dist/mcp-server.js

@@ -42587,6 +42587,60 @@ var yaml_dist = __webpack_require__(1198);
     return new FileSystemAgentFileGateway();
 }
 
+;// CONCATENATED MODULE: ./src/gateways/claude-file-gateway.ts
+/**
+ * Gateway interface for Claude Code file operations.
+ * Handles reading and writing .claude/settings.json and CLAUDE.md files.
+ */ 
+
+
+/**
+ * File system implementation of ClaudeFileGateway
+ */ class FileSystemClaudeFileGateway {
+    async readSettings(targetDir) {
+        const settingsPath = (0,external_node_path_.join)(targetDir, ".claude", "settings.json");
+        if (!await file_system_utils_fileExists(settingsPath)) {
+            return null;
+        }
+        try {
+            const content = await (0,promises_.readFile)(settingsPath, "utf-8");
+            return JSON.parse(content);
+        } catch  {
+            // If JSON parsing fails, treat as if file doesn't exist
+            return null;
+        }
+    }
+    async writeSettings(targetDir, settings) {
+        const claudeDir = (0,external_node_path_.join)(targetDir, ".claude");
+        const settingsPath = (0,external_node_path_.join)(claudeDir, "settings.json");
+        // Ensure .claude directory exists
+        await (0,promises_.mkdir)(claudeDir, {
+            recursive: true
+        });
+        // Write with 2-space indentation and trailing newline
+        const content = `${JSON.stringify(settings, null, 2)}\n`;
+        await (0,promises_.writeFile)(settingsPath, content, "utf-8");
+    }
+    async readDocumentation(targetDir) {
+        const docPath = (0,external_node_path_.join)(targetDir, "CLAUDE.md");
+        if (!await file_system_utils_fileExists(docPath)) {
+            return null;
+        }
+        return (0,promises_.readFile)(docPath, "utf-8");
+    }
+    async writeDocumentation(targetDir, content) {
+        const docPath = (0,external_node_path_.join)(targetDir, "CLAUDE.md");
+        // Ensure content has trailing newline
+        const normalizedContent = content.endsWith("\n") ? content : `${content}\n`;
+        await (0,promises_.writeFile)(docPath, normalizedContent, "utf-8");
+    }
+}
+/**
+ * Factory function to create a Claude file gateway
+ */ function createClaudeFileGateway() {
+    return new FileSystemClaudeFileGateway();
+}
+
 ;// CONCATENATED MODULE: ./src/entities/copilot-setup.ts
 /**
  * Core domain entities for the Copilot Setup Steps feature.
@@ -45979,6 +46033,7 @@ async function watchConfig(options) {
 
 
 
+
 ;// CONCATENATED MODULE: ./src/mcp/tools/types.ts
 /**
  * Shared types and utilities for MCP tool handlers.
@@ -46091,6 +46146,441 @@ async function watchConfig(options) {
     });
 };
 
+;// CONCATENATED MODULE: ./src/use-cases/claude-setup.ts
+/**
+ * Use cases for Claude Code Web Environment Setup feature.
+ * This module handles the logic of building SessionStart hooks from environment detection,
+ * merging settings, and generating documentation.
+ */ 
+/**
+ * List of allowed version filenames.
+ * Using a hardcoded allowlist prevents command injection via malicious filenames
+ * in user-customizable config files.
+ */ const ALLOWED_VERSION_FILENAMES = [
+    ".nvmrc",
+    ".node-version",
+    ".python-version",
+    ".java-version",
+    ".ruby-version",
+    ".go-version"
+];
+/**
+ * Validates that a filename is in the allowlist of known version files.
+ * Prevents command injection by only allowing hardcoded safe filenames.
+ *
+ * @param filename The filename to validate
+ * @returns true if filename is in the allowlist
+ */ function isValidVersionFilename(filename) {
+    return ALLOWED_VERSION_FILENAMES.includes(filename);
+}
+/**
+ * Builds SessionStart hooks from detected environment.
+ * Transforms environment configuration into Claude Code SessionStart commands.
+ *
+ * @param environment The detected environment configuration
+ * @param config Optional copilot-setup configuration (for package manager mappings)
+ * @returns Array of SessionStart hooks
+ */ async function buildSessionStartHooks(environment, config) {
+    const loadedConfig = config || await loadCopilotSetupConfig();
+    const hooks = [];
+    // If mise.toml is present, add mise install
+    if (environment.hasMise) {
+        hooks.push({
+            command: "mise install",
+            description: "Install runtimes from mise.toml"
+        });
+        // After mise install, add package manager install hooks
+        const packageManagerHooks = buildPackageManagerHooks(environment.packageManagers, loadedConfig);
+        hooks.push(...packageManagerHooks);
+        return hooks;
+    }
+    // Otherwise, add runtime installation hooks for each version file
+    const runtimeHooks = buildRuntimeHooks(environment.versionFiles);
+    hooks.push(...runtimeHooks);
+    // Add package manager install hooks
+    const packageManagerHooks = buildPackageManagerHooks(environment.packageManagers, loadedConfig);
+    hooks.push(...packageManagerHooks);
+    return hooks;
+}
+/**
+ * Builds runtime installation hooks from version files.
+ * Maps version files to appropriate runtime manager commands (nvm, pyenv, etc.)
+ *
+ * @param versionFiles Array of detected version files
+ * @returns Array of runtime installation hooks
+ */ function buildRuntimeHooks(versionFiles) {
+    const hooks = [];
+    const addedTypes = new Set();
+    for (const versionFile of versionFiles){
+        // Deduplicate by type (e.g., .nvmrc and .node-version both use nvm)
+        if (addedTypes.has(versionFile.type)) {
+            continue;
+        }
+        addedTypes.add(versionFile.type);
+        const hook = getRuntimeHookForType(versionFile.type, versionFile);
+        if (hook) {
+            hooks.push(hook);
+        }
+    }
+    return hooks;
+}
+/**
+ * Gets the runtime installation hook for a specific version file type.
+ *
+ * @param type The version file type
+ * @param versionFile The version file metadata
+ * @returns SessionStart hook or null if not supported
+ */ function getRuntimeHookForType(type, versionFile) {
+    const versionInfo = versionFile.version ? ` (${versionFile.version})` : "";
+    if (!isValidVersionFilename(versionFile.filename)) {
+        return null;
+    }
+    switch(type){
+        case "node":
+            return {
+                command: "nvm install",
+                description: `Install Node.js from ${versionFile.filename}${versionInfo}`
+            };
+        case "python":
+            return {
+                command: `pyenv install -s $(cat ${versionFile.filename})`,
+                description: `Install Python from ${versionFile.filename}${versionInfo}`
+            };
+        case "ruby":
+            return {
+                command: `rbenv install -s $(cat ${versionFile.filename})`,
+                description: `Install Ruby from ${versionFile.filename}${versionInfo}`
+            };
+        case "java":
+            return null;
+        case "go":
+            // Go version management typically handled by asdf or gvm
+            // For now, document but don't generate command as it's environment-specific
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Builds package manager installation hooks from detected package managers.
+ *
+ * @param packageManagers Array of detected package managers
+ * @param config Configuration for package manager mappings
+ * @returns Array of package manager installation hooks
+ */ function buildPackageManagerHooks(packageManagers, config) {
+    const hooks = [];
+    const addedTypes = new Set();
+    for (const pm of packageManagers){
+        // Skip if we've already added this package manager type
+        if (addedTypes.has(pm.type)) {
+            continue;
+        }
+        addedTypes.add(pm.type);
+        // Find the config for this package manager
+        const pmConfig = config.packageManagers.find((c)=>c.type === pm.type);
+        if (!pmConfig) {
+            continue;
+        }
+        const description = getPackageManagerDescription(pm.type, pm);
+        hooks.push({
+            command: pmConfig.installCommand,
+            description
+        });
+    }
+    return hooks;
+}
+/**
+ * Gets a description for a package manager hook.
+ */ function getPackageManagerDescription(packageManagerType, pm) {
+    const lockfileInfo = pm.lockfile ? ` with ${pm.lockfile}` : "";
+    const descriptions = {
+        npm: `Install Node.js dependencies${lockfileInfo}`,
+        yarn: `Install Node.js dependencies${lockfileInfo}`,
+        pnpm: `Install Node.js dependencies${lockfileInfo}`,
+        pip: `Install Python dependencies from ${pm.filename}`,
+        pipenv: `Install Python dependencies${lockfileInfo}`,
+        poetry: `Install Python dependencies${lockfileInfo}`,
+        bundler: `Install Ruby dependencies${lockfileInfo}`,
+        cargo: `Build Rust project`,
+        composer: `Install PHP dependencies${lockfileInfo}`,
+        maven: `Install Java dependencies`,
+        gradle: `Build Gradle project`,
+        gomod: `Download Go dependencies`,
+        pub: `Install Dart dependencies`
+    };
+    return descriptions[packageManagerType] || `Install dependencies from ${pm.filename}`;
+}
+/**
+ * Merges SessionStart hooks into existing Claude settings.
+ * Preserves existing settings while adding or updating hooks without duplication.
+ *
+ * @param existing Existing Claude settings or null if none exist
+ * @param hooks Array of SessionStart hooks to merge
+ * @returns Merged Claude settings
+ */ function mergeClaudeSettings(existing, hooks) {
+    // If no existing settings, create new with hooks
+    if (!existing) {
+        return {
+            // biome-ignore lint/style/useNamingConvention: SessionStart is the Claude Code API property name
+            SessionStart: hooks.map((h)=>h.command)
+        };
+    }
+    // Preserve all existing settings
+    const merged = {
+        ...existing
+    };
+    // Get existing SessionStart commands or empty array
+    const existingCommands = existing.SessionStart || [];
+    // Merge new hooks with existing commands in deterministic order:
+    // 1) tool-generated commands (from hooks) in their original order
+    // 2) any existing commands not already included, preserving their order
+    const newCommands = hooks.map((h)=>h.command);
+    const mergedCommands = [];
+    for (const command of newCommands){
+        if (!mergedCommands.includes(command)) {
+            mergedCommands.push(command);
+        }
+    }
+    for (const command of existingCommands){
+        if (!mergedCommands.includes(command)) {
+            mergedCommands.push(command);
+        }
+    }
+    merged.SessionStart = mergedCommands;
+    return merged;
+}
+/**
+ * Generates an Environment Setup section for CLAUDE.md documentation.
+ * Creates markdown documenting the detected environment and SessionStart hooks.
+ *
+ * @param environment The detected environment configuration
+ * @param hooks Array of SessionStart hooks
+ * @returns Markdown content for Environment Setup section
+ */ function generateEnvironmentSetupSection(environment, hooks) {
+    const lines = [];
+    lines.push("## Environment Setup");
+    lines.push("");
+    // Document detected configuration
+    if (environment.hasMise) {
+        lines.push("This project uses [mise](https://mise.jdx.dev/) for runtime management.");
+        lines.push("");
+    }
+    if (environment.versionFiles.length > 0) {
+        lines.push("### Detected Runtimes");
+        lines.push("");
+        for (const vf of environment.versionFiles){
+            const versionInfo = vf.version ? ` (${vf.version})` : "";
+            lines.push(`- **${vf.type}**: ${vf.filename}${versionInfo}`);
+        }
+        lines.push("");
+    }
+    if (environment.packageManagers.length > 0) {
+        lines.push("### Package Managers");
+        lines.push("");
+        for (const pm of environment.packageManagers){
+            const lockfileInfo = pm.lockfile ? ` with ${pm.lockfile}` : "";
+            lines.push(`- **${pm.type}**: ${pm.filename}${lockfileInfo}`);
+        }
+        lines.push("");
+    }
+    // Document SessionStart hooks
+    if (hooks.length > 0) {
+        lines.push("### SessionStart Hooks");
+        lines.push("");
+        lines.push("The following commands run automatically when a Claude Code session starts:");
+        lines.push("");
+        for (const hook of hooks){
+            lines.push("```bash");
+            lines.push(hook.command);
+            lines.push("```");
+            if (hook.description) {
+                lines.push(`*${hook.description}*`);
+            }
+            lines.push("");
+        }
+    } else {
+        lines.push("No environment-specific configuration detected. If this project requires specific runtimes or dependencies, add version files (e.g., `.nvmrc`, `.python-version`) or dependency manifests (e.g., `package.json`, `requirements.txt`) to enable automated setup.");
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Merges an Environment Setup section into existing CLAUDE.md documentation.
+ * Replaces existing section if found, or appends if not present.
+ *
+ * @param existing Existing CLAUDE.md content or null if file doesn't exist
+ * @param setupSection The Environment Setup section content
+ * @returns Updated CLAUDE.md content
+ */ function mergeClaudeDocumentation(existing, setupSection) {
+    // If no existing documentation, create new with setup section
+    if (!existing) {
+        return `# Claude Code Environment\n\n${setupSection}`;
+    }
+    // Split content into lines and find Environment Setup section
+    const lines = existing.split("\n");
+    let inEnvSetup = false;
+    let envSetupStartLine = -1;
+    let envSetupEndLine = -1;
+    for(let i = 0; i < lines.length; i++){
+        const line = lines[i];
+        if (line === "## Environment Setup") {
+            inEnvSetup = true;
+            envSetupStartLine = i;
+            continue;
+        }
+        if (inEnvSetup && (line.startsWith("## ") || line.startsWith("# "))) {
+            // Found next section
+            envSetupEndLine = i;
+            break;
+        }
+    }
+    // If we found Environment Setup section
+    if (envSetupStartLine >= 0) {
+        // If we didn't find an end, it goes to the end of file
+        if (envSetupEndLine === -1) {
+            envSetupEndLine = lines.length;
+        }
+        // Replace the section
+        const before = lines.slice(0, envSetupStartLine).join("\n");
+        const after = lines.slice(envSetupEndLine).join("\n");
+        const parts = [
+            before.trimEnd()
+        ];
+        if (before.trim()) {
+            parts.push("\n\n");
+        }
+        parts.push(setupSection.trimEnd());
+        if (after.trim()) {
+            parts.push("\n\n");
+            parts.push(after);
+        }
+        return parts.join("");
+    }
+    // Append section to end
+    const trimmedExisting = existing.trimEnd();
+    return `${trimmedExisting}\n\n${setupSection}`;
+}
+
+;// CONCATENATED MODULE: ./src/mcp/tools/create-claude-code-web-setup.ts
+/**
+ * MCP tool handler for creating or updating Claude Code Web Environment Setup.
+ */ 
+
+
+
+/**
+ * Creates or updates Claude Code web environment setup files.
+ */ const createClaudeCodeWebSetupHandler = async (args)=>{
+    const dir = args.targetDir || process.cwd();
+    if (!await file_system_utils_fileExists(dir)) {
+        return types_errorResponse(`Target directory does not exist: ${dir}`);
+    }
+    const environmentGateway = createEnvironmentGateway();
+    const claudeGateway = createClaudeFileGateway();
+    // Detect environment configuration
+    const environment = await environmentGateway.detectEnvironment(dir);
+    // Build SessionStart hooks from environment
+    const hooks = await buildSessionStartHooks(environment);
+    // Read existing settings
+    const existingSettings = await claudeGateway.readSettings(dir);
+    // Merge settings
+    const mergedSettings = mergeClaudeSettings(existingSettings, hooks);
+    // Check if settings changed (normalize JSON for comparison)
+    const settingsChanged = JSON.stringify(existingSettings, null, 2) !== JSON.stringify(mergedSettings, null, 2);
+    // Read existing documentation
+    const existingDocs = await claudeGateway.readDocumentation(dir);
+    // Generate environment setup section
+    const setupSection = generateEnvironmentSetupSection(environment, hooks);
+    // Merge documentation
+    const mergedDocs = mergeClaudeDocumentation(existingDocs, setupSection);
+    // Check if documentation changed (normalize for comparison - trim and ensure trailing newline)
+    const normalizeDoc = (doc)=>doc ? `${doc.trimEnd()}\n` : null;
+    const docsChanged = normalizeDoc(existingDocs) !== normalizeDoc(mergedDocs);
+    // Determine action before writing
+    let action;
+    if (!settingsChanged && !docsChanged) {
+        action = "no_changes_needed";
+    } else if (!existingSettings && !existingDocs) {
+        action = "created";
+    } else {
+        action = "updated";
+    }
+    // Only write if there are changes
+    if (settingsChanged) {
+        await claudeGateway.writeSettings(dir, mergedSettings);
+    }
+    if (docsChanged) {
+        await claudeGateway.writeDocumentation(dir, mergedDocs);
+    }
+    const settingsPath = (0,external_node_path_.join)(dir, ".claude", "settings.json");
+    const documentationPath = (0,external_node_path_.join)(dir, "CLAUDE.md");
+    // Build result
+    const result = {
+        hooks,
+        environment,
+        settingsPath,
+        documentationPath,
+        action,
+        recommendations: buildRecommendations(environment)
+    };
+    // Format message
+    const message = buildResultMessage(result);
+    return successResponse({
+        ...result,
+        message,
+        // Make hooks serializable for JSON response
+        hooks: hooks.map((h)=>({
+                command: h.command,
+                description: h.description
+            }))
+    });
+};
+/**
+ * Builds recommendations for UI-level environment configuration.
+ */ function buildRecommendations(environment) {
+    const recommendations = [];
+    // If package managers detected, recommend network access
+    if (environment.packageManagers && environment.packageManagers.length > 0) {
+        recommendations.push({
+            type: "network_access",
+            description: "Enable internet access in Claude Code environment settings to allow package installation"
+        });
+    }
+    return recommendations.length > 0 ? recommendations : undefined;
+}
+/**
+ * Builds a human-readable result message.
+ */ function buildResultMessage(result) {
+    const lines = [];
+    if (result.action === "created") {
+        lines.push(`Created Claude Code environment setup with ${result.hooks.length} SessionStart hook(s)`);
+    } else if (result.action === "updated") {
+        lines.push(`Updated Claude Code environment setup with ${result.hooks.length} SessionStart hook(s)`);
+    } else {
+        lines.push("No changes needed - environment setup is already current");
+    }
+    if (result.hooks.length > 0) {
+        lines.push("");
+        lines.push("SessionStart hooks:");
+        for (const hook of result.hooks){
+            lines.push(`  - ${hook.command}`);
+            if (hook.description) {
+                lines.push(`    ${hook.description}`);
+            }
+        }
+    }
+    if (result.recommendations && result.recommendations.length > 0) {
+        lines.push("");
+        lines.push("Recommendations:");
+        for (const rec of result.recommendations){
+            lines.push(`  - ${rec.description}`);
+        }
+    }
+    lines.push("");
+    lines.push(`Files: ${result.settingsPath}, ${result.documentationPath}`);
+    return lines.join("\n");
+}
+
 ;// CONCATENATED MODULE: ./src/use-cases/action-resolution.ts
 /**
  * Use case for building action resolution metadata.
@@ -47476,6 +47966,7 @@ function getGlobalWacContext() {
 
 
 
+
 ;// CONCATENATED MODULE: ./src/mcp/server.ts
 /**
  * MCP Server for Copilot Setup Steps workflow management.
@@ -47551,6 +48042,12 @@ function getGlobalWacContext() {
         handler: createCopilotSetupWorkflowHandler,
         inputSchema: createWorkflowInputSchema
     },
+    {
+        name: "create_claude_code_web_setup",
+        description: "Create or update Claude Code web environment setup (.claude/settings.json with SessionStart hooks and CLAUDE.md documentation) based on detected environment configuration.",
+        handler: createClaudeCodeWebSetupHandler,
+        inputSchema: targetDirInputSchema
+    },
     {
         name: "analyze_action_versions",
         description: "Analyze GitHub Action versions used across all workflow files in a target directory",