makit 0.0.139 → 0.0.140

data/lib/makit/cli/project_commands.rb

@@ -1,868 +1,868 @@
-# frozen_string_literal: true
-
-require "clamp"
-require "fileutils"
-require "erb"
-
-module Makit
-  module Cli
-    # Consolidated project management commands
-    # Combines: new, init, setup, work functionality
-    class ProjectCommand < Clamp::Command
-      self.description = <<~DESC
-        Manage project creation, initialization, and workspace setup.
-
-        Available operations:
-          new    - Create new project from template
-          init   - Initialize existing directory as project
-          setup  - Setup project dependencies and configuration#{"  "}
-          work   - Open project in IDE or navigate to directory
-      DESC
-    end
-
-    # Create new project from template
-    class NewProjectCommand < Clamp::Command
-      self.description = <<~DESC
-        Create a new project from available templates.
-
-        Examples:
-          makit project new my-app --type ruby
-          makit project new WebApp --type dotnet --framework net8.0
-          makit project new api-service --type node
-      DESC
-
-      parameter "PROJECT_NAME", "Name of the new project", attribute_name: :project_name, required: true
-      option ["--type", "-t"], "TYPE", "Project type (ruby, dotnet, node, rust)", default: "ruby"
-      option ["--framework"], "FRAMEWORK", "Target framework (for .NET projects)", default: "net8.0"
-      option ["--template"], "TEMPLATE", "Specific template to use"
-      option ["--directory", "-d"], "DIR", "Parent directory for new project", default: Dir.pwd
-      option ["--dry-run"], :flag, "Show what would be created without actually creating"
-      option ["--verbose"], :flag, "Show verbose output"
-
-      def execute
-        validate_project_name
-        validate_project_type
-
-        project_dir = File.join(directory, project_name)
-
-        if Dir.exist?(project_dir)
-          puts "Error: Project directory already exists: #{project_dir}"
-          exit 1
-        end
-
-        puts "Creating #{type} project: #{project_name}"
-        puts "Location: #{project_dir}"
-        puts "Template: #{selected_template}" if verbose?
-
-        return if dry_run?
-
-        create_project_structure(project_dir)
-        puts "✅ Successfully created #{type} project: #{project_name}"
-        puts "📁 Project location: #{project_dir}"
-        puts "\nNext steps:"
-        puts "  cd #{project_name}"
-        puts "  makit project setup    # Setup dependencies"
-        puts "  makit project work     # Open in IDE"
-      end
-
-      private
-
-      def validate_project_name
-        if project_name.nil? || project_name.strip.empty?
-          puts "Error: Project name cannot be empty"
-          exit 1
-        end
-
-        # Check for valid project name characters
-        return if project_name.match?(/\A[a-zA-Z0-9][a-zA-Z0-9._-]*\z/)
-
-        puts "Error: Project name must start with letter/number and contain only letters, numbers, dots, hyphens, and underscores"
-        exit 1
-      end
-
-      def validate_project_type
-        valid_types = %w[ruby dotnet node rust]
-        return if valid_types.include?(type)
-
-        puts "Error: Invalid project type '#{type}'. Valid types: #{valid_types.join(", ")}"
-        exit 1
-      end
-
-      def selected_template
-        return template if template
-
-        case type
-        when "ruby" then "ruby-gem"
-        when "dotnet" then "dotnet-console"
-        when "node" then "node-express"
-        when "rust" then "rust-binary"
-        else "basic"
-        end
-      end
-
-      def create_project_structure(project_dir)
-        FileUtils.mkdir_p(project_dir)
-
-        case type
-        when "ruby"
-          create_ruby_project(project_dir)
-        when "dotnet"
-          create_dotnet_project(project_dir)
-        when "node"
-          create_node_project(project_dir)
-        when "rust"
-          create_rust_project(project_dir)
-        end
-      end
-
-      def create_ruby_project(project_dir)
-        # Create basic Ruby gem structure
-        FileUtils.mkdir_p(File.join(project_dir, "lib", project_name.tr("-", "_")))
-        FileUtils.mkdir_p(File.join(project_dir, "test"))
-        FileUtils.mkdir_p(File.join(project_dir, "bin"))
-
-        # Create main library file
-        lib_file = File.join(project_dir, "lib", "#{project_name.tr("-", "_")}.rb")
-        write_template_file(lib_file, ruby_main_template)
-
-        # Create version file
-        version_file = File.join(project_dir, "lib", project_name.tr("-", "_"), "version.rb")
-        write_template_file(version_file, ruby_version_template)
-
-        # Create gemspec
-        gemspec_file = File.join(project_dir, "#{project_name}.gemspec")
-        write_template_file(gemspec_file, ruby_gemspec_template)
-
-        # Create Gemfile
-        gemfile = File.join(project_dir, "Gemfile")
-        write_template_file(gemfile, ruby_gemfile_template)
-
-        # Create Rakefile
-        rakefile = File.join(project_dir, "Rakefile")
-        write_template_file(rakefile, ruby_rakefile_template)
-
-        # Create test file
-        test_file = File.join(project_dir, "test", "test_#{project_name.tr("-", "_")}.rb")
-        write_template_file(test_file, ruby_test_template)
-
-        # Create README
-        readme_file = File.join(project_dir, "README.md")
-        write_template_file(readme_file, readme_template)
-
-        puts "  ✅ Created Ruby gem structure" if verbose?
-      end
-
-      def create_dotnet_project(project_dir)
-        # Create .NET console application structure
-        FileUtils.mkdir_p(File.join(project_dir, "src"))
-
-        # Create project file
-        csproj_file = File.join(project_dir, "src", "#{project_name}.csproj")
-        write_template_file(csproj_file, dotnet_csproj_template)
-
-        # Create Program.cs
-        program_file = File.join(project_dir, "src", "Program.cs")
-        write_template_file(program_file, dotnet_program_template)
-
-        # Create solution file
-        sln_file = File.join(project_dir, "#{project_name}.sln")
-        write_template_file(sln_file, dotnet_solution_template)
-
-        # Create README
-        readme_file = File.join(project_dir, "README.md")
-        write_template_file(readme_file, readme_template)
-
-        puts "  ✅ Created .NET #{framework} project structure" if verbose?
-      end
-
-      def create_node_project(project_dir)
-        # Create Node.js project structure
-        FileUtils.mkdir_p(File.join(project_dir, "src"))
-        FileUtils.mkdir_p(File.join(project_dir, "test"))
-
-        # Create package.json
-        package_file = File.join(project_dir, "package.json")
-        write_template_file(package_file, node_package_template)
-
-        # Create main application file
-        main_file = File.join(project_dir, "src", "index.js")
-        write_template_file(main_file, node_main_template)
-
-        # Create test file
-        test_file = File.join(project_dir, "test", "index.test.js")
-        write_template_file(test_file, node_test_template)
-
-        # Create README
-        readme_file = File.join(project_dir, "README.md")
-        write_template_file(readme_file, readme_template)
-
-        puts "  ✅ Created Node.js project structure" if verbose?
-      end
-
-      def create_rust_project(project_dir)
-        # Create Rust project structure
-        FileUtils.mkdir_p(File.join(project_dir, "src"))
-
-        # Create Cargo.toml
-        cargo_file = File.join(project_dir, "Cargo.toml")
-        write_template_file(cargo_file, rust_cargo_template)
-
-        # Create main.rs
-        main_file = File.join(project_dir, "src", "main.rs")
-        write_template_file(main_file, rust_main_template)
-
-        # Create README
-        readme_file = File.join(project_dir, "README.md")
-        write_template_file(readme_file, readme_template)
-
-        puts "  ✅ Created Rust project structure" if verbose?
-      end
-
-      def write_template_file(file_path, template_content)
-        FileUtils.mkdir_p(File.dirname(file_path))
-        processed_content = ERB.new(template_content).result(binding)
-        File.write(file_path, processed_content)
-        puts "    Created: #{file_path}" if verbose?
-      end
-
-      # Template methods
-      def ruby_main_template
-        <<~RUBY
-          # frozen_string_literal: true
-
-          require_relative "<%= project_name.tr("-", "_") %>/version"
-
-          module <%= project_name.split(/[-_]/).map(&:capitalize).join %>
-            class Error < StandardError; end
-          #{"  "}
-            def self.hello
-              "Hello from <%= project_name %>!"
-            end
-          end
-        RUBY
-      end
-
-      def ruby_version_template
-        <<~RUBY
-          # frozen_string_literal: true
-
-          module <%= project_name.split(/[-_]/).map(&:capitalize).join %>
-            VERSION = "0.1.0"
-          end
-        RUBY
-      end
-
-      def ruby_gemspec_template
-        <<~RUBY
-          # frozen_string_literal: true
-
-          require_relative "lib/<%= project_name.tr("-", "_") %>/version"
-
-          Gem::Specification.new do |spec|
-            spec.name = "<%= project_name %>"
-            spec.version = <%= project_name.split(/[-_]/).map(&:capitalize).join %>::VERSION
-            spec.authors = ["Your Name"]
-            spec.email = ["your.email@example.com"]
-
-            spec.summary = "A new Ruby gem"
-            spec.description = "A longer description of your new gem"
-            spec.homepage = "https://github.com/yourusername/<%= project_name %>"
-            spec.license = "MIT"
-
-            spec.required_ruby_version = ">= 3.0.0"
-
-            spec.files = Dir.glob("lib/**/*") + ["README.md"]
-            spec.require_paths = ["lib"]
-
-            spec.add_development_dependency "minitest", "~> 5.0"
-            spec.add_development_dependency "rake", "~> 13.0"
-          end
-        RUBY
-      end
-
-      def ruby_gemfile_template
-        <<~RUBY
-          # frozen_string_literal: true
-
-          source "https://rubygems.org"
-
-          gemspec
-        RUBY
-      end
-
-      def ruby_rakefile_template
-        <<~RUBY
-          # frozen_string_literal: true
-
-          require "bundler/gem_tasks"
-          require "rake/testtask"
-
-          Rake::TestTask.new(:test) do |t|
-            t.libs << "test"
-            t.libs << "lib"
-            t.test_files = FileList["test/**/test_*.rb"]
-          end
-
-          task default: :test
-        RUBY
-      end
-
-      def ruby_test_template
-        <<~RUBY
-          # frozen_string_literal: true
-
-          require "test_helper"
-          require "<%= project_name.tr("-", "_") %>"
-
-          class Test<%= project_name.split(/[-_]/).map(&:capitalize).join %> < Minitest::Test
-            def test_version
-              refute_nil <%= project_name.split(/[-_]/).map(&:capitalize).join %>::VERSION
-            end
-
-            def test_hello
-              assert_equal "Hello from <%= project_name %>!", <%= project_name.split(/[-_]/).map(&:capitalize).join %>.hello
-            end
-          end
-        RUBY
-      end
-
-      def dotnet_csproj_template
-        <<~XML
-          <Project Sdk="Microsoft.NET.Sdk">
-
-            <PropertyGroup>
-              <OutputType>Exe</OutputType>
-              <TargetFramework><%= framework %></TargetFramework>
-              <ImplicitUsings>enable</ImplicitUsings>
-              <Nullable>enable</Nullable>
-            </PropertyGroup>
-
-          </Project>
-        XML
-      end
-
-      def dotnet_program_template
-        <<~CSHARP
-          namespace <%= project_name.split(/[-_]/).map(&:capitalize).join %>;
-
-          class Program
-          {
-              static void Main(string[] args)
-              {
-                  Console.WriteLine("Hello from <%= project_name %>!");
-              }
-          }
-        CSHARP
-      end
-
-      def dotnet_solution_template
-        <<~TEXT
-          Microsoft Visual Studio Solution File, Format Version 12.00
-          # Visual Studio Version 17
-          VisualStudioVersion = 17.0.31903.59
-          MinimumVisualStudioVersion = 10.0.40219.1
-          Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "<%= project_name %>", "src\\<%= project_name %>.csproj", "{<%= SecureRandom.uuid.upcase %>}"
-          EndProject
-          Global
-          	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-          		Debug|Any CPU = Debug|Any CPU
-          		Release|Any CPU = Release|Any CPU
-          	EndGlobalSection
-          	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-          		{<%= SecureRandom.uuid.upcase %>}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-          		{<%= SecureRandom.uuid.upcase %>}.Debug|Any CPU.Build.0 = Debug|Any CPU
-          		{<%= SecureRandom.uuid.upcase %>}.Release|Any CPU.ActiveCfg = Release|Any CPU
-          		{<%= SecureRandom.uuid.upcase %>}.Release|Any CPU.Build.0 = Release|Any CPU
-          	EndGlobalSection
-          EndGlobal
-        TEXT
-      end
-
-      def node_package_template
-        <<~JSON
-          {
-            "name": "<%= project_name %>",
-            "version": "1.0.0",
-            "description": "A new Node.js project",
-            "main": "src/index.js",
-            "scripts": {
-              "start": "node src/index.js",
-              "test": "jest",
-              "dev": "nodemon src/index.js"
-            },
-            "keywords": [],
-            "author": "Your Name",
-            "license": "MIT",
-            "dependencies": {
-              "express": "^4.18.0"
-            },
-            "devDependencies": {
-              "jest": "^29.0.0",
-              "nodemon": "^2.0.0"
-            }
-          }
-        JSON
-      end
-
-      def node_main_template
-        <<~JAVASCRIPT
-          const express = require('express');
-          const app = express();
-          const port = process.env.PORT || 3000;
-
-          app.get('/', (req, res) => {
-            res.json({ message: 'Hello from <%= project_name %>!' });
-          });
-
-          app.listen(port, () => {
-            console.log(`<%= project_name %> listening on port ${port}`);
-          });
-
-          module.exports = app;
-        JAVASCRIPT
-      end
-
-      def node_test_template
-        <<~JAVASCRIPT
-          const request = require('supertest');
-          const app = require('../src/index');
-
-          describe('GET /', () => {
-            it('should return hello message', async () => {
-              const res = await request(app)
-                .get('/')
-                .expect('Content-Type', /json/)
-                .expect(200);
-          #{"    "}
-              expect(res.body.message).toBe('Hello from <%= project_name %>!');
-            });
-          });
-        JAVASCRIPT
-      end
-
-      def rust_cargo_template
-        <<~TOML
-          [package]
-          name = "<%= project_name %>"
-          version = "0.1.0"
-          edition = "2021"
-          authors = ["Your Name <your.email@example.com>"]
-          description = "A new Rust project"
-          license = "MIT"
-
-          [dependencies]
-        TOML
-      end
-
-      def rust_main_template
-        <<~RUST
-          fn main() {
-              println!("Hello from <%= project_name %>!");
-          }
-
-          #[cfg(test)]
-          mod tests {
-              use super::*;
-
-              #[test]
-              fn it_works() {
-                  assert_eq!(2 + 2, 4);
-              }
-          }
-        RUST
-      end
-
-      def readme_template
-        <<~MARKDOWN
-          # <%= project_name.split(/[-_]/).map(&:capitalize).join(" ") %>
-
-          A new <%= type %> project created with Makit.
-
-          ## Getting Started
-
-          <% case type %>
-          <% when "ruby" %>
-          ```bash
-          # Install dependencies
-          bundle install
-
-          # Run tests
-          rake test
-
-          # Build gem
-          rake build
-          ```
-          <% when "dotnet" %>
-          ```bash
-          # Build project
-          dotnet build
-
-          # Run project
-          dotnet run --project src/<%= project_name %>.csproj
-
-          # Test project
-          dotnet test
-          ```
-          <% when "node" %>
-          ```bash
-          # Install dependencies
-          npm install
-
-          # Start development server
-          npm run dev
-
-          # Run tests
-          npm test
-          ```
-          <% when "rust" %>
-          ```bash
-          # Build project
-          cargo build
-
-          # Run project
-          cargo run
-
-          # Test project
-          cargo test
-          ```
-          <% end %>
-
-          ## Contributing
-
-          1. Fork the repository
-          2. Create your feature branch (`git checkout -b feature/amazing-feature`)
-          3. Commit your changes (`git commit -am 'Add amazing feature'`)
-          4. Push to the branch (`git push origin feature/amazing-feature`)
-          5. Create a Pull Request
-
-          ## License
-
-          This project is licensed under the MIT License - see the LICENSE file for details.
-        MARKDOWN
-      end
-    end
-
-    # Initialize existing directory as project
-    class InitProjectCommand < Clamp::Command
-      self.description = <<~DESC
-        Initialize an existing directory as a Makit-managed project.
-
-        Examples:
-          makit project init
-          makit project init --type ruby
-          makit project init /path/to/existing/project
-      DESC
-
-      parameter "PATH", "Path to initialize (default: current directory)", attribute_name: :path, default: Dir.pwd
-      option ["--type", "-t"], "TYPE", "Project type (ruby, dotnet, node, rust)", default: "auto"
-      option ["--force"], :flag, "Force initialization even if project files exist"
-
-      def execute
-        init_path = File.expand_path(path)
-
-        unless Dir.exist?(init_path)
-          puts "Error: Directory does not exist: #{init_path}"
-          exit 1
-        end
-
-        detected_type = detect_project_type(init_path)
-        actual_type = type == "auto" ? detected_type : type
-
-        if actual_type == "unknown"
-          puts "Error: Could not detect project type. Please specify --type explicitly."
-          exit 1
-        end
-
-        puts "Initializing #{actual_type} project in: #{init_path}"
-
-        if has_project_files?(init_path, actual_type) && !force?
-          puts "Error: Project files already exist. Use --force to overwrite."
-          exit 1
-        end
-
-        initialize_project(init_path, actual_type)
-        puts "✅ Successfully initialized #{actual_type} project"
-      end
-
-      private
-
-      def detect_project_type(dir)
-        return "ruby" if File.exist?(File.join(dir, "Gemfile")) || File.exist?(File.join(dir, ".gemspec"))
-        return "dotnet" if Dir.glob(File.join(dir, "*.csproj")).any? || Dir.glob(File.join(dir, "*.sln")).any?
-        return "node" if File.exist?(File.join(dir, "package.json"))
-        return "rust" if File.exist?(File.join(dir, "Cargo.toml"))
-
-        "unknown"
-      end
-
-      def has_project_files?(dir, project_type)
-        case project_type
-        when "ruby"
-          File.exist?(File.join(dir, "Rakefile"))
-        when "dotnet"
-          Dir.glob(File.join(dir, "*.csproj")).any?
-        when "node"
-          File.exist?(File.join(dir, "package.json"))
-        when "rust"
-          File.exist?(File.join(dir, "Cargo.toml"))
-        else
-          false
-        end
-      end
-
-      def initialize_project(dir, project_type)
-        case project_type
-        when "ruby"
-          initialize_ruby_project(dir)
-        when "dotnet"
-          initialize_dotnet_project(dir)
-        when "node"
-          initialize_node_project(dir)
-        when "rust"
-          initialize_rust_project(dir)
-        end
-      end
-
-      def initialize_ruby_project(dir)
-        File.write(File.join(dir, "Rakefile"), basic_ruby_rakefile) unless File.exist?(File.join(dir, "Rakefile"))
-
-        return if Dir.exist?(File.join(dir, "test"))
-
-        FileUtils.mkdir_p(File.join(dir, "test"))
-      end
-
-      def initialize_dotnet_project(_dir)
-        # Add any .NET-specific initialization if needed
-        puts "  ✅ .NET project initialized"
-      end
-
-      def initialize_node_project(_dir)
-        # Add any Node.js-specific initialization if needed
-        puts "  ✅ Node.js project initialized"
-      end
-
-      def initialize_rust_project(_dir)
-        # Add any Rust-specific initialization if needed
-        puts "  ✅ Rust project initialized"
-      end
-
-      def basic_ruby_rakefile
-        <<~RUBY
-          # frozen_string_literal: true
-
-          require "rake/testtask"
-
-          Rake::TestTask.new(:test) do |t|
-            t.libs << "test"
-            t.libs << "lib"
-            t.test_files = FileList["test/**/test_*.rb"]
-          end
-
-          task default: :test
-        RUBY
-      end
-    end
-
-    # Setup project dependencies and configuration
-    class SetupProjectCommand < Clamp::Command
-      self.description = <<~DESC
-        Setup project dependencies and development environment.
-
-        Examples:
-          makit project setup
-          makit project setup --skip-deps
-          makit project setup /path/to/project
-      DESC
-
-      parameter "PATH", "Path to project (default: current directory)", attribute_name: :path, default: Dir.pwd
-      option ["--skip-deps"], :flag, "Skip dependency installation"
-      option ["--verbose"], :flag, "Show verbose output"
-
-      def execute
-        project_path = File.expand_path(path)
-
-        unless Dir.exist?(project_path)
-          puts "Error: Directory does not exist: #{project_path}"
-          exit 1
-        end
-
-        project_type = detect_project_type(project_path)
-
-        if project_type == "unknown"
-          puts "Error: Could not detect project type in: #{project_path}"
-          exit 1
-        end
-
-        puts "Setting up #{project_type} project dependencies..."
-
-        Dir.chdir(project_path) do
-          setup_project(project_type)
-        end
-
-        puts "✅ Project setup completed successfully"
-      end
-
-      private
-
-      def detect_project_type(dir)
-        return "ruby" if File.exist?(File.join(dir, "Gemfile"))
-        return "dotnet" if Dir.glob(File.join(dir, "*.csproj")).any? || Dir.glob(File.join(dir, "*.sln")).any?
-        return "node" if File.exist?(File.join(dir, "package.json"))
-        return "rust" if File.exist?(File.join(dir, "Cargo.toml"))
-
-        "unknown"
-      end
-
-      def setup_project(project_type)
-        case project_type
-        when "ruby"
-          setup_ruby_project
-        when "dotnet"
-          setup_dotnet_project
-        when "node"
-          setup_node_project
-        when "rust"
-          setup_rust_project
-        end
-      end
-
-      def setup_ruby_project
-        unless skip_deps?
-          puts "  Installing Ruby dependencies..."
-          system("bundle install") || puts("Warning: bundle install failed")
-        end
-
-        puts "  ✅ Ruby project setup complete"
-      end
-
-      def setup_dotnet_project
-        unless skip_deps?
-          puts "  Restoring .NET dependencies..."
-          system("dotnet restore") || puts("Warning: dotnet restore failed")
-        end
-
-        puts "  ✅ .NET project setup complete"
-      end
-
-      def setup_node_project
-        unless skip_deps?
-          puts "  Installing Node.js dependencies..."
-          if File.exist?("package-lock.json")
-            system("npm ci") || puts("Warning: npm ci failed")
-          else
-            system("npm install") || puts("Warning: npm install failed")
-          end
-        end
-
-        puts "  ✅ Node.js project setup complete"
-      end
-
-      def setup_rust_project
-        unless skip_deps?
-          puts "  Building Rust project..."
-          system("cargo build") || puts("Warning: cargo build failed")
-        end
-
-        puts "  ✅ Rust project setup complete"
-      end
-    end
-
-    # Open project in IDE or navigate to directory
-    class WorkProjectCommand < Clamp::Command
-      self.description = <<~DESC
-        Open project in your preferred IDE or navigate to project directory.
-
-        Examples:
-          makit project work
-          makit project work /path/to/project
-          makit project work --editor code
-      DESC
-
-      parameter "PATH", "Path to project (default: current directory)", attribute_name: :path, default: Dir.pwd
-      option ["--editor"], "EDITOR", "Preferred editor (code, subl, atom, vim)", default: "auto"
-      option ["--list-editors"], :flag, "List available editors"
-
-      def execute
-        if list_editors?
-          show_available_editors
-          return
-        end
-
-        project_path = File.expand_path(path)
-
-        unless Dir.exist?(project_path)
-          puts "Error: Directory does not exist: #{project_path}"
-          exit 1
-        end
-
-        editor_cmd = determine_editor
-
-        if editor_cmd
-          puts "Opening project in #{editor_cmd}..."
-          launch_editor(editor_cmd, project_path)
-        else
-          puts "No suitable editor found. Available editors:"
-          show_available_editors
-          puts "\nNavigating to project directory: #{project_path}"
-          puts "Run: cd #{project_path}"
-        end
-      end
-
-      private
-
-      def show_available_editors
-        editors = {
-          "code" => "Visual Studio Code",
-          "subl" => "Sublime Text",
-          "atom" => "Atom",
-          "vim" => "Vim",
-          "nvim" => "Neovim",
-          "emacs" => "Emacs",
-        }
-
-        puts "Available editors:"
-        editors.each do |cmd, name|
-          available = system("which #{cmd} > /dev/null 2>&1")
-          status = available ? "✅" : "❌"
-          puts "  #{status} #{name} (#{cmd})"
-        end
-      end
-
-      def determine_editor
-        return editor if editor != "auto" && editor_available?(editor)
-
-        # Try to detect available editors in preference order
-        preferred_editors = %w[code subl atom vim nvim]
-        preferred_editors.find { |ed| editor_available?(ed) }
-      end
-
-      def editor_available?(editor_name)
-        system("which #{editor_name} > /dev/null 2>&1")
-      end
-
-      def launch_editor(editor_cmd, project_path)
-        case editor_cmd
-        when "code"
-          system("code '#{project_path}'")
-        when "subl"
-          system("subl '#{project_path}'")
-        when "atom"
-          system("atom '#{project_path}'")
-        when "vim", "nvim"
-          system("#{editor_cmd} '#{project_path}'")
-        when "emacs"
-          system("emacs '#{project_path}' &")
-        else
-          puts "Unknown editor: #{editor_cmd}"
-          exit 1
-        end
-      end
-    end
-
-    # Add subcommand declarations after all classes are defined
-    ProjectCommand.subcommand "new", "Create new project from template", NewProjectCommand
-    ProjectCommand.subcommand "init", "Initialize existing directory as project", InitProjectCommand
-    ProjectCommand.subcommand "setup", "Setup project dependencies", SetupProjectCommand
-    ProjectCommand.subcommand "work", "Open project in IDE", WorkProjectCommand
-  end
-end
+# frozen_string_literal: true
+
+require "clamp"
+require "fileutils"
+require "erb"
+
+module Makit
+  module Cli
+    # Consolidated project management commands
+    # Combines: new, init, setup, work functionality
+    class ProjectCommand < Clamp::Command
+      self.description = <<~DESC
+        Manage project creation, initialization, and workspace setup.
+
+        Available operations:
+          new    - Create new project from template
+          init   - Initialize existing directory as project
+          setup  - Setup project dependencies and configuration#{"  "}
+          work   - Open project in IDE or navigate to directory
+      DESC
+    end
+
+    # Create new project from template
+    class NewProjectCommand < Clamp::Command
+      self.description = <<~DESC
+        Create a new project from available templates.
+
+        Examples:
+          makit project new my-app --type ruby
+          makit project new WebApp --type dotnet --framework net8.0
+          makit project new api-service --type node
+      DESC
+
+      parameter "PROJECT_NAME", "Name of the new project", attribute_name: :project_name, required: true
+      option ["--type", "-t"], "TYPE", "Project type (ruby, dotnet, node, rust)", default: "ruby"
+      option ["--framework"], "FRAMEWORK", "Target framework (for .NET projects)", default: "net8.0"
+      option ["--template"], "TEMPLATE", "Specific template to use"
+      option ["--directory", "-d"], "DIR", "Parent directory for new project", default: Dir.pwd
+      option ["--dry-run"], :flag, "Show what would be created without actually creating"
+      option ["--verbose"], :flag, "Show verbose output"
+
+      def execute
+        validate_project_name
+        validate_project_type
+
+        project_dir = File.join(directory, project_name)
+
+        if Dir.exist?(project_dir)
+          puts "Error: Project directory already exists: #{project_dir}"
+          exit 1
+        end
+
+        puts "Creating #{type} project: #{project_name}"
+        puts "Location: #{project_dir}"
+        puts "Template: #{selected_template}" if verbose?
+
+        return if dry_run?
+
+        create_project_structure(project_dir)
+        puts "✅ Successfully created #{type} project: #{project_name}"
+        puts "📁 Project location: #{project_dir}"
+        puts "\nNext steps:"
+        puts "  cd #{project_name}"
+        puts "  makit project setup    # Setup dependencies"
+        puts "  makit project work     # Open in IDE"
+      end
+
+      private
+
+      def validate_project_name
+        if project_name.nil? || project_name.strip.empty?
+          puts "Error: Project name cannot be empty"
+          exit 1
+        end
+
+        # Check for valid project name characters
+        return if project_name.match?(/\A[a-zA-Z0-9][a-zA-Z0-9._-]*\z/)
+
+        puts "Error: Project name must start with letter/number and contain only letters, numbers, dots, hyphens, and underscores"
+        exit 1
+      end
+
+      def validate_project_type
+        valid_types = %w[ruby dotnet node rust]
+        return if valid_types.include?(type)
+
+        puts "Error: Invalid project type '#{type}'. Valid types: #{valid_types.join(", ")}"
+        exit 1
+      end
+
+      def selected_template
+        return template if template
+
+        case type
+        when "ruby" then "ruby-gem"
+        when "dotnet" then "dotnet-console"
+        when "node" then "node-express"
+        when "rust" then "rust-binary"
+        else "basic"
+        end
+      end
+
+      def create_project_structure(project_dir)
+        FileUtils.mkdir_p(project_dir)
+
+        case type
+        when "ruby"
+          create_ruby_project(project_dir)
+        when "dotnet"
+          create_dotnet_project(project_dir)
+        when "node"
+          create_node_project(project_dir)
+        when "rust"
+          create_rust_project(project_dir)
+        end
+      end
+
+      def create_ruby_project(project_dir)
+        # Create basic Ruby gem structure
+        FileUtils.mkdir_p(File.join(project_dir, "lib", project_name.tr("-", "_")))
+        FileUtils.mkdir_p(File.join(project_dir, "test"))
+        FileUtils.mkdir_p(File.join(project_dir, "bin"))
+
+        # Create main library file
+        lib_file = File.join(project_dir, "lib", "#{project_name.tr("-", "_")}.rb")
+        write_template_file(lib_file, ruby_main_template)
+
+        # Create version file
+        version_file = File.join(project_dir, "lib", project_name.tr("-", "_"), "version.rb")
+        write_template_file(version_file, ruby_version_template)
+
+        # Create gemspec
+        gemspec_file = File.join(project_dir, "#{project_name}.gemspec")
+        write_template_file(gemspec_file, ruby_gemspec_template)
+
+        # Create Gemfile
+        gemfile = File.join(project_dir, "Gemfile")
+        write_template_file(gemfile, ruby_gemfile_template)
+
+        # Create Rakefile
+        rakefile = File.join(project_dir, "Rakefile")
+        write_template_file(rakefile, ruby_rakefile_template)
+
+        # Create test file
+        test_file = File.join(project_dir, "test", "test_#{project_name.tr("-", "_")}.rb")
+        write_template_file(test_file, ruby_test_template)
+
+        # Create README
+        readme_file = File.join(project_dir, "README.md")
+        write_template_file(readme_file, readme_template)
+
+        puts "  ✅ Created Ruby gem structure" if verbose?
+      end
+
+      def create_dotnet_project(project_dir)
+        # Create .NET console application structure
+        FileUtils.mkdir_p(File.join(project_dir, "src"))
+
+        # Create project file
+        csproj_file = File.join(project_dir, "src", "#{project_name}.csproj")
+        write_template_file(csproj_file, dotnet_csproj_template)
+
+        # Create Program.cs
+        program_file = File.join(project_dir, "src", "Program.cs")
+        write_template_file(program_file, dotnet_program_template)
+
+        # Create solution file
+        sln_file = File.join(project_dir, "#{project_name}.sln")
+        write_template_file(sln_file, dotnet_solution_template)
+
+        # Create README
+        readme_file = File.join(project_dir, "README.md")
+        write_template_file(readme_file, readme_template)
+
+        puts "  ✅ Created .NET #{framework} project structure" if verbose?
+      end
+
+      def create_node_project(project_dir)
+        # Create Node.js project structure
+        FileUtils.mkdir_p(File.join(project_dir, "src"))
+        FileUtils.mkdir_p(File.join(project_dir, "test"))
+
+        # Create package.json
+        package_file = File.join(project_dir, "package.json")
+        write_template_file(package_file, node_package_template)
+
+        # Create main application file
+        main_file = File.join(project_dir, "src", "index.js")
+        write_template_file(main_file, node_main_template)
+
+        # Create test file
+        test_file = File.join(project_dir, "test", "index.test.js")
+        write_template_file(test_file, node_test_template)
+
+        # Create README
+        readme_file = File.join(project_dir, "README.md")
+        write_template_file(readme_file, readme_template)
+
+        puts "  ✅ Created Node.js project structure" if verbose?
+      end
+
+      def create_rust_project(project_dir)
+        # Create Rust project structure
+        FileUtils.mkdir_p(File.join(project_dir, "src"))
+
+        # Create Cargo.toml
+        cargo_file = File.join(project_dir, "Cargo.toml")
+        write_template_file(cargo_file, rust_cargo_template)
+
+        # Create main.rs
+        main_file = File.join(project_dir, "src", "main.rs")
+        write_template_file(main_file, rust_main_template)
+
+        # Create README
+        readme_file = File.join(project_dir, "README.md")
+        write_template_file(readme_file, readme_template)
+
+        puts "  ✅ Created Rust project structure" if verbose?
+      end
+
+      def write_template_file(file_path, template_content)
+        FileUtils.mkdir_p(File.dirname(file_path))
+        processed_content = ERB.new(template_content).result(binding)
+        File.write(file_path, processed_content)
+        puts "    Created: #{file_path}" if verbose?
+      end
+
+      # Template methods
+      def ruby_main_template
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require_relative "<%= project_name.tr("-", "_") %>/version"
+
+          module <%= project_name.split(/[-_]/).map(&:capitalize).join %>
+            class Error < StandardError; end
+          #{"  "}
+            def self.hello
+              "Hello from <%= project_name %>!"
+            end
+          end
+        RUBY
+      end
+
+      def ruby_version_template
+        <<~RUBY
+          # frozen_string_literal: true
+
+          module <%= project_name.split(/[-_]/).map(&:capitalize).join %>
+            VERSION = "0.1.0"
+          end
+        RUBY
+      end
+
+      def ruby_gemspec_template
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require_relative "lib/<%= project_name.tr("-", "_") %>/version"
+
+          Gem::Specification.new do |spec|
+            spec.name = "<%= project_name %>"
+            spec.version = <%= project_name.split(/[-_]/).map(&:capitalize).join %>::VERSION
+            spec.authors = ["Your Name"]
+            spec.email = ["your.email@example.com"]
+
+            spec.summary = "A new Ruby gem"
+            spec.description = "A longer description of your new gem"
+            spec.homepage = "https://github.com/yourusername/<%= project_name %>"
+            spec.license = "MIT"
+
+            spec.required_ruby_version = ">= 3.0.0"
+
+            spec.files = Dir.glob("lib/**/*") + ["README.md"]
+            spec.require_paths = ["lib"]
+
+            spec.add_development_dependency "minitest", "~> 5.0"
+            spec.add_development_dependency "rake", "~> 13.0"
+          end
+        RUBY
+      end
+
+      def ruby_gemfile_template
+        <<~RUBY
+          # frozen_string_literal: true
+
+          source "https://rubygems.org"
+
+          gemspec
+        RUBY
+      end
+
+      def ruby_rakefile_template
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require "bundler/gem_tasks"
+          require "rake/testtask"
+
+          Rake::TestTask.new(:test) do |t|
+            t.libs << "test"
+            t.libs << "lib"
+            t.test_files = FileList["test/**/test_*.rb"]
+          end
+
+          task default: :test
+        RUBY
+      end
+
+      def ruby_test_template
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require "test_helper"
+          require "<%= project_name.tr("-", "_") %>"
+
+          class Test<%= project_name.split(/[-_]/).map(&:capitalize).join %> < Minitest::Test
+            def test_version
+              refute_nil <%= project_name.split(/[-_]/).map(&:capitalize).join %>::VERSION
+            end
+
+            def test_hello
+              assert_equal "Hello from <%= project_name %>!", <%= project_name.split(/[-_]/).map(&:capitalize).join %>.hello
+            end
+          end
+        RUBY
+      end
+
+      def dotnet_csproj_template
+        <<~XML
+          <Project Sdk="Microsoft.NET.Sdk">
+
+            <PropertyGroup>
+              <OutputType>Exe</OutputType>
+              <TargetFramework><%= framework %></TargetFramework>
+              <ImplicitUsings>enable</ImplicitUsings>
+              <Nullable>enable</Nullable>
+            </PropertyGroup>
+
+          </Project>
+        XML
+      end
+
+      def dotnet_program_template
+        <<~CSHARP
+          namespace <%= project_name.split(/[-_]/).map(&:capitalize).join %>;
+
+          class Program
+          {
+              static void Main(string[] args)
+              {
+                  Console.WriteLine("Hello from <%= project_name %>!");
+              }
+          }
+        CSHARP
+      end
+
+      def dotnet_solution_template
+        <<~TEXT
+          Microsoft Visual Studio Solution File, Format Version 12.00
+          # Visual Studio Version 17
+          VisualStudioVersion = 17.0.31903.59
+          MinimumVisualStudioVersion = 10.0.40219.1
+          Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "<%= project_name %>", "src\\<%= project_name %>.csproj", "{<%= SecureRandom.uuid.upcase %>}"
+          EndProject
+          Global
+          	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+          		Debug|Any CPU = Debug|Any CPU
+          		Release|Any CPU = Release|Any CPU
+          	EndGlobalSection
+          	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+          		{<%= SecureRandom.uuid.upcase %>}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+          		{<%= SecureRandom.uuid.upcase %>}.Debug|Any CPU.Build.0 = Debug|Any CPU
+          		{<%= SecureRandom.uuid.upcase %>}.Release|Any CPU.ActiveCfg = Release|Any CPU
+          		{<%= SecureRandom.uuid.upcase %>}.Release|Any CPU.Build.0 = Release|Any CPU
+          	EndGlobalSection
+          EndGlobal
+        TEXT
+      end
+
+      def node_package_template
+        <<~JSON
+          {
+            "name": "<%= project_name %>",
+            "version": "1.0.0",
+            "description": "A new Node.js project",
+            "main": "src/index.js",
+            "scripts": {
+              "start": "node src/index.js",
+              "test": "jest",
+              "dev": "nodemon src/index.js"
+            },
+            "keywords": [],
+            "author": "Your Name",
+            "license": "MIT",
+            "dependencies": {
+              "express": "^4.18.0"
+            },
+            "devDependencies": {
+              "jest": "^29.0.0",
+              "nodemon": "^2.0.0"
+            }
+          }
+        JSON
+      end
+
+      def node_main_template
+        <<~JAVASCRIPT
+          const express = require('express');
+          const app = express();
+          const port = process.env.PORT || 3000;
+
+          app.get('/', (req, res) => {
+            res.json({ message: 'Hello from <%= project_name %>!' });
+          });
+
+          app.listen(port, () => {
+            console.log(`<%= project_name %> listening on port ${port}`);
+          });
+
+          module.exports = app;
+        JAVASCRIPT
+      end
+
+      def node_test_template
+        <<~JAVASCRIPT
+          const request = require('supertest');
+          const app = require('../src/index');
+
+          describe('GET /', () => {
+            it('should return hello message', async () => {
+              const res = await request(app)
+                .get('/')
+                .expect('Content-Type', /json/)
+                .expect(200);
+          #{"    "}
+              expect(res.body.message).toBe('Hello from <%= project_name %>!');
+            });
+          });
+        JAVASCRIPT
+      end
+
+      def rust_cargo_template
+        <<~TOML
+          [package]
+          name = "<%= project_name %>"
+          version = "0.1.0"
+          edition = "2021"
+          authors = ["Your Name <your.email@example.com>"]
+          description = "A new Rust project"
+          license = "MIT"
+
+          [dependencies]
+        TOML
+      end
+
+      def rust_main_template
+        <<~RUST
+          fn main() {
+              println!("Hello from <%= project_name %>!");
+          }
+
+          #[cfg(test)]
+          mod tests {
+              use super::*;
+
+              #[test]
+              fn it_works() {
+                  assert_eq!(2 + 2, 4);
+              }
+          }
+        RUST
+      end
+
+      def readme_template
+        <<~MARKDOWN
+          # <%= project_name.split(/[-_]/).map(&:capitalize).join(" ") %>
+
+          A new <%= type %> project created with Makit.
+
+          ## Getting Started
+
+          <% case type %>
+          <% when "ruby" %>
+          ```bash
+          # Install dependencies
+          bundle install
+
+          # Run tests
+          rake test
+
+          # Build gem
+          rake build
+          ```
+          <% when "dotnet" %>
+          ```bash
+          # Build project
+          dotnet build
+
+          # Run project
+          dotnet run --project src/<%= project_name %>.csproj
+
+          # Test project
+          dotnet test
+          ```
+          <% when "node" %>
+          ```bash
+          # Install dependencies
+          npm install
+
+          # Start development server
+          npm run dev
+
+          # Run tests
+          npm test
+          ```
+          <% when "rust" %>
+          ```bash
+          # Build project
+          cargo build
+
+          # Run project
+          cargo run
+
+          # Test project
+          cargo test
+          ```
+          <% end %>
+
+          ## Contributing
+
+          1. Fork the repository
+          2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+          3. Commit your changes (`git commit -am 'Add amazing feature'`)
+          4. Push to the branch (`git push origin feature/amazing-feature`)
+          5. Create a Pull Request
+
+          ## License
+
+          This project is licensed under the MIT License - see the LICENSE file for details.
+        MARKDOWN
+      end
+    end
+
+    # Initialize existing directory as project
+    class InitProjectCommand < Clamp::Command
+      self.description = <<~DESC
+        Initialize an existing directory as a Makit-managed project.
+
+        Examples:
+          makit project init
+          makit project init --type ruby
+          makit project init /path/to/existing/project
+      DESC
+
+      parameter "PATH", "Path to initialize (default: current directory)", attribute_name: :path, default: Dir.pwd
+      option ["--type", "-t"], "TYPE", "Project type (ruby, dotnet, node, rust)", default: "auto"
+      option ["--force"], :flag, "Force initialization even if project files exist"
+
+      def execute
+        init_path = File.expand_path(path)
+
+        unless Dir.exist?(init_path)
+          puts "Error: Directory does not exist: #{init_path}"
+          exit 1
+        end
+
+        detected_type = detect_project_type(init_path)
+        actual_type = type == "auto" ? detected_type : type
+
+        if actual_type == "unknown"
+          puts "Error: Could not detect project type. Please specify --type explicitly."
+          exit 1
+        end
+
+        puts "Initializing #{actual_type} project in: #{init_path}"
+
+        if has_project_files?(init_path, actual_type) && !force?
+          puts "Error: Project files already exist. Use --force to overwrite."
+          exit 1
+        end
+
+        initialize_project(init_path, actual_type)
+        puts "✅ Successfully initialized #{actual_type} project"
+      end
+
+      private
+
+      def detect_project_type(dir)
+        return "ruby" if File.exist?(File.join(dir, "Gemfile")) || File.exist?(File.join(dir, ".gemspec"))
+        return "dotnet" if Dir.glob(File.join(dir, "*.csproj")).any? || Dir.glob(File.join(dir, "*.sln")).any?
+        return "node" if File.exist?(File.join(dir, "package.json"))
+        return "rust" if File.exist?(File.join(dir, "Cargo.toml"))
+
+        "unknown"
+      end
+
+      def has_project_files?(dir, project_type)
+        case project_type
+        when "ruby"
+          File.exist?(File.join(dir, "Rakefile"))
+        when "dotnet"
+          Dir.glob(File.join(dir, "*.csproj")).any?
+        when "node"
+          File.exist?(File.join(dir, "package.json"))
+        when "rust"
+          File.exist?(File.join(dir, "Cargo.toml"))
+        else
+          false
+        end
+      end
+
+      def initialize_project(dir, project_type)
+        case project_type
+        when "ruby"
+          initialize_ruby_project(dir)
+        when "dotnet"
+          initialize_dotnet_project(dir)
+        when "node"
+          initialize_node_project(dir)
+        when "rust"
+          initialize_rust_project(dir)
+        end
+      end
+
+      def initialize_ruby_project(dir)
+        File.write(File.join(dir, "Rakefile"), basic_ruby_rakefile) unless File.exist?(File.join(dir, "Rakefile"))
+
+        return if Dir.exist?(File.join(dir, "test"))
+
+        FileUtils.mkdir_p(File.join(dir, "test"))
+      end
+
+      def initialize_dotnet_project(_dir)
+        # Add any .NET-specific initialization if needed
+        puts "  ✅ .NET project initialized"
+      end
+
+      def initialize_node_project(_dir)
+        # Add any Node.js-specific initialization if needed
+        puts "  ✅ Node.js project initialized"
+      end
+
+      def initialize_rust_project(_dir)
+        # Add any Rust-specific initialization if needed
+        puts "  ✅ Rust project initialized"
+      end
+
+      def basic_ruby_rakefile
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require "rake/testtask"
+
+          Rake::TestTask.new(:test) do |t|
+            t.libs << "test"
+            t.libs << "lib"
+            t.test_files = FileList["test/**/test_*.rb"]
+          end
+
+          task default: :test
+        RUBY
+      end
+    end
+
+    # Setup project dependencies and configuration
+    class SetupProjectCommand < Clamp::Command
+      self.description = <<~DESC
+        Setup project dependencies and development environment.
+
+        Examples:
+          makit project setup
+          makit project setup --skip-deps
+          makit project setup /path/to/project
+      DESC
+
+      parameter "PATH", "Path to project (default: current directory)", attribute_name: :path, default: Dir.pwd
+      option ["--skip-deps"], :flag, "Skip dependency installation"
+      option ["--verbose"], :flag, "Show verbose output"
+
+      def execute
+        project_path = File.expand_path(path)
+
+        unless Dir.exist?(project_path)
+          puts "Error: Directory does not exist: #{project_path}"
+          exit 1
+        end
+
+        project_type = detect_project_type(project_path)
+
+        if project_type == "unknown"
+          puts "Error: Could not detect project type in: #{project_path}"
+          exit 1
+        end
+
+        puts "Setting up #{project_type} project dependencies..."
+
+        Dir.chdir(project_path) do
+          setup_project(project_type)
+        end
+
+        puts "✅ Project setup completed successfully"
+      end
+
+      private
+
+      def detect_project_type(dir)
+        return "ruby" if File.exist?(File.join(dir, "Gemfile"))
+        return "dotnet" if Dir.glob(File.join(dir, "*.csproj")).any? || Dir.glob(File.join(dir, "*.sln")).any?
+        return "node" if File.exist?(File.join(dir, "package.json"))
+        return "rust" if File.exist?(File.join(dir, "Cargo.toml"))
+
+        "unknown"
+      end
+
+      def setup_project(project_type)
+        case project_type
+        when "ruby"
+          setup_ruby_project
+        when "dotnet"
+          setup_dotnet_project
+        when "node"
+          setup_node_project
+        when "rust"
+          setup_rust_project
+        end
+      end
+
+      def setup_ruby_project
+        unless skip_deps?
+          puts "  Installing Ruby dependencies..."
+          system("bundle install") || puts("Warning: bundle install failed")
+        end
+
+        puts "  ✅ Ruby project setup complete"
+      end
+
+      def setup_dotnet_project
+        unless skip_deps?
+          puts "  Restoring .NET dependencies..."
+          system("dotnet restore") || puts("Warning: dotnet restore failed")
+        end
+
+        puts "  ✅ .NET project setup complete"
+      end
+
+      def setup_node_project
+        unless skip_deps?
+          puts "  Installing Node.js dependencies..."
+          if File.exist?("package-lock.json")
+            system("npm ci") || puts("Warning: npm ci failed")
+          else
+            system("npm install") || puts("Warning: npm install failed")
+          end
+        end
+
+        puts "  ✅ Node.js project setup complete"
+      end
+
+      def setup_rust_project
+        unless skip_deps?
+          puts "  Building Rust project..."
+          system("cargo build") || puts("Warning: cargo build failed")
+        end
+
+        puts "  ✅ Rust project setup complete"
+      end
+    end
+
+    # Open project in IDE or navigate to directory
+    class WorkProjectCommand < Clamp::Command
+      self.description = <<~DESC
+        Open project in your preferred IDE or navigate to project directory.
+
+        Examples:
+          makit project work
+          makit project work /path/to/project
+          makit project work --editor code
+      DESC
+
+      parameter "PATH", "Path to project (default: current directory)", attribute_name: :path, default: Dir.pwd
+      option ["--editor"], "EDITOR", "Preferred editor (code, subl, atom, vim)", default: "auto"
+      option ["--list-editors"], :flag, "List available editors"
+
+      def execute
+        if list_editors?
+          show_available_editors
+          return
+        end
+
+        project_path = File.expand_path(path)
+
+        unless Dir.exist?(project_path)
+          puts "Error: Directory does not exist: #{project_path}"
+          exit 1
+        end
+
+        editor_cmd = determine_editor
+
+        if editor_cmd
+          puts "Opening project in #{editor_cmd}..."
+          launch_editor(editor_cmd, project_path)
+        else
+          puts "No suitable editor found. Available editors:"
+          show_available_editors
+          puts "\nNavigating to project directory: #{project_path}"
+          puts "Run: cd #{project_path}"
+        end
+      end
+
+      private
+
+      def show_available_editors
+        editors = {
+          "code" => "Visual Studio Code",
+          "subl" => "Sublime Text",
+          "atom" => "Atom",
+          "vim" => "Vim",
+          "nvim" => "Neovim",
+          "emacs" => "Emacs",
+        }
+
+        puts "Available editors:"
+        editors.each do |cmd, name|
+          available = system("which #{cmd} > /dev/null 2>&1")
+          status = available ? "✅" : "❌"
+          puts "  #{status} #{name} (#{cmd})"
+        end
+      end
+
+      def determine_editor
+        return editor if editor != "auto" && editor_available?(editor)
+
+        # Try to detect available editors in preference order
+        preferred_editors = %w[code subl atom vim nvim]
+        preferred_editors.find { |ed| editor_available?(ed) }
+      end
+
+      def editor_available?(editor_name)
+        system("which #{editor_name} > /dev/null 2>&1")
+      end
+
+      def launch_editor(editor_cmd, project_path)
+        case editor_cmd
+        when "code"
+          system("code '#{project_path}'")
+        when "subl"
+          system("subl '#{project_path}'")
+        when "atom"
+          system("atom '#{project_path}'")
+        when "vim", "nvim"
+          system("#{editor_cmd} '#{project_path}'")
+        when "emacs"
+          system("emacs '#{project_path}' &")
+        else
+          puts "Unknown editor: #{editor_cmd}"
+          exit 1
+        end
+      end
+    end
+
+    # Add subcommand declarations after all classes are defined
+    ProjectCommand.subcommand "new", "Create new project from template", NewProjectCommand
+    ProjectCommand.subcommand "init", "Initialize existing directory as project", InitProjectCommand
+    ProjectCommand.subcommand "setup", "Setup project dependencies", SetupProjectCommand
+    ProjectCommand.subcommand "work", "Open project in IDE", WorkProjectCommand
+  end
+end