makit 0.0.99 → 0.0.111

data/lib/makit/cli/project_commands.rb

@@ -0,0 +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