chiron 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1bedffbe29eddeb944137d4f3e986b45d20acfac3ddefa8d5f731efa1c7bc76
-  data.tar.gz: 1c710a2bb2eb67b01ae126f38d2853edc0527c7536832a6a691a94d896d4d79c
+  metadata.gz: ed0812e658fcd053473ebaeb84d3c0e7b5c0ca35cc9a53a66a316e72ba96d0e5
+  data.tar.gz: 45a146731a3eb6797444ae1b8d469e066da1a3e7d50d8913a414d2944c9d9a40
 SHA512:
-  metadata.gz: f1a40196a2c48302fec0be7bdba442d21386bcd8e0b2f3b88174e32f2927bec876c5673ee018e9c23cf1dd46b299ae1a628acc9b831b26c12d4da86c801913ea
-  data.tar.gz: 93668d0ac4144e80aa5b80172bad66706db730d1068f6250a2e18e3ee621479d1ca09ae118abc6b615f4b05e6b332342a53913c09fb1c392b633fa2275316344
+  metadata.gz: 0a1d06237d6c61271c7a4313a7242dc9105fdd14dc90a135f8117f18b0a5da1df02a800a5c2f731a02524bdf15a8dc1b698a5efd75f5bb9e7e634c8d6989876a
+  data.tar.gz: 90b73ca6f3b9a550ee4b78220c3f73e83587341e962c0265acdefc1276d06aa89c6f67bedd93258436760f2e6671ef47a0e4bbe0bd76643fd56e0659751ec844

data/CHANGELOG.md

@@ -5,30 +5,90 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.2.1] - 2025-07-01
 
-## [0.1.0] - 2025-01-21
+### Added
+
+#### Branch Tracking for Claude Sessions
+- **`/branch-context` Command**: Comprehensive branch information for Claude session continuity
+- **Branch Management Workflow**: Complete procedures for creating, switching, and managing Git branches
+- **Enhanced Context Commands**: Updated `/quickstart` and `/catchup` with branch awareness
+- **Development Journal Integration**: Branch tracking sections and guidelines for documentation
+- **Session Continuity**: Workflows for maintaining context across Claude sessions and branch switches
+
+#### New Workflow Templates
+- **Branch Context** (`shared/commands/context/branch-context.md`): Detailed branch information and progress tracking
+- **Branch Management** (`shared/commands/workflows/branch-management.md`): Complete branch lifecycle management
+
+#### Enhanced Documentation
+- **CLAUDE.md**: Added branch management section with naming conventions and session continuity guidelines
+- **Development Journal Template**: Enhanced with branch tracking fields and ownership documentation
+- **Context Commands**: Integrated branch awareness into existing workflow commands
+
+### Enhanced
+
+#### Session Management
+- **Context Continuity**: Improved Claude session startup with branch context
+- **Progress Tracking**: Better documentation of branch work and ownership
+- **Collaboration**: Enhanced handoff procedures and shared understanding patterns
+
+## [0.2.0] - 2025-07-01
+
+### Added
+
+#### Python Project Support
+- **Auto-detection**: Automatically detects Python projects via `requirements.txt`, `pyproject.toml`, `setup.py`, or `Pipfile`
+- **Framework Detection**: Identifies Django, FastAPI, Flask, or generic Python projects
+- **Python-specific CLAUDE.md template**: Customized for Python development with framework-specific sections
+- **CLI Options**: Added `--type=python`, `--with-django`, and `--with-fastapi` flags
+
+#### Python Workflow Templates
+- **Python Conventions** (`python/commands/conventions/python.md`): Comprehensive Python best practices including PEP 8, type hints, async patterns, and framework-specific guidelines
+- **Python Testing** (`python/commands/quality/python-testing.md`): Complete pytest patterns, fixtures, mocking, async testing, and CI/CD
+- **Python Debugging** (`python/commands/workflows/debug-python.md`): Systematic debugging with pdb, logging, and performance profiling
+- **Python Refactoring** (`python/commands/workflows/python-refactor.md`): SOLID principles, design patterns, and code organization
+- **Flask Development** (`python/commands/workflows/flask-development.md`): Complete Flask application patterns, blueprints, forms, and testing
+
+#### Enhanced Architecture
+- **ProjectConfig Class**: Language-agnostic configuration management for tools, commands, and package managers
+- **Template Organization**: Restructured templates with `rails/`, `python/`, and `shared/` directories
+- **Framework-specific Content**: Dynamic template content based on detected frameworks
+
+#### Testing & Quality
+- **Comprehensive Test Suite**: 41 tests covering both Rails and Python functionality
+- **Framework Detection Tests**: Tests for Django, FastAPI, and Flask project detection
+- **ProjectConfig Tests**: Full coverage of configuration management
+- **Backward Compatibility**: All existing Rails functionality preserved
+
+### Enhanced
+
+#### CLI Improvements
+- **Smart Project Detection**: Improved auto-detection with user prompts for unknown projects
+- **Project-specific Tips**: Displays relevant setup tips after initialization
+- **Doctor Command**: Enhanced health checks for both Rails and Python projects
+
+#### Documentation
+- **README**: Updated with Python examples and framework-specific usage
+- **Template Structure**: Clear documentation of language-specific workflow organization
+
+### Technical Details
+
+#### Supported Python Frameworks
+- **Django**: Detects `manage.py`, includes Django ORM patterns, management commands
+- **FastAPI**: Detects FastAPI in requirements, includes async patterns, API documentation
+- **Flask**: Detects Flask dependencies, includes blueprint patterns, forms, testing
+- **Generic Python**: Supports any Python project with standard tooling
+
+#### Code Quality Tools
+- **Rails**: RuboCop, RSpec, Rails conventions
+- **Python**: Black, flake8, mypy, pytest, type hints
+
+## [0.1.0] - 2025-06-30
 
 ### Added
-- Initial release of Chiron gem (renamed from claude_rails_setup)
-- CLI command `chiron init` to initialize Claude AI workflows in Rails projects
-- PRD workflow templates for structured feature development
-- Task generation and management system
-- Development journal functionality
-- Quality assurance workflows and pre-commit checklists
-- Migration tool from `.cursor` to `.claude` directory structure
-- Comprehensive test suite with RSpec
-- GitHub Actions CI/CD pipeline
-- Support for Ruby 3.0+ and Rails projects
-
-### Features
-- **Quick Setup**: Initialize Claude workflow with one command
-- **PRD Workflow**: Structured Product Requirements Document creation
-- **Task Management**: Generate and track implementation tasks
-- **Development Journal**: Track progress and maintain project history
-- **Migration Tool**: Easy migration from `.cursor` to `.claude` structure
-- **Quality Checks**: Pre-commit checklists and TDD workflows
-- **Customizable**: Adapt workflows to your team's needs
-
-[Unreleased]: https://github.com/ebrett/chiron/compare/v0.1.0...HEAD
-[0.1.0]: https://github.com/ebrett/chiron/releases/tag/v0.1.0
+- Initial release with Rails project support
+- Claude workflow initialization
+- PRD and task management workflows
+- Development journal system
+- Migration from .cursor to .claude structure
+- Rails-specific conventions and patterns

data/CLAUDE.md

@@ -98,11 +98,40 @@ lib/
 - Test CLI commands with temporary directories
 - Follow RSpec best practices
 
+## Branch Management and Claude Sessions
+
+### Branch Naming Conventions
+- `feature/[description]` - New functionality (e.g., `feature/python-support`)
+- `bugfix/[description]` - Bug fixes (e.g., `bugfix/template-loading`)
+- `hotfix/[description]` - Urgent production fixes
+- `experiment/[description]` - Exploratory work
+
+### Claude Session Continuity
+- **Starting Sessions**: Always run `/quickstart` to get current context
+- **Branch Work**: Use `/branch-context` when working on feature branches
+- **Progress Tracking**: Update development journal for significant changes
+- **Branch Switching**: Document current state before switching branches
+
+### Development Journal Usage
+- Include branch name in all journal entries
+- Update "Active Branches & Ownership" section when creating/merging branches
+- Link journal entries to related PRD files
+- Document architectural decisions and reasoning
+
+### Branch Workflow
+1. Create branch from updated main: `git checkout -b feature/description`
+2. Document branch purpose in development journal
+3. Make initial empty commit with context
+4. Develop with frequent commits and journal updates
+5. Use `/catchup` and `/branch-context` for status updates
+6. Complete pre-commit checklist before merging
+
 ## Important Reminders
 
 - Always run tests before committing
-- Use semantic commit messages
+- Use semantic commit messages with branch context
 - Update the development journal for significant changes
 - Follow the pre-commit checklist in `.claude/commands/quality/pre-commit.md`
+- Use branch management workflows for feature development
 - Update CHANGELOG.md for notable changes
 - Test gem building and installation locally before releasing

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    chiron (0.1.0)
+    chiron (0.2.0)
       colorize (~> 1.1)
       thor (~> 1.3)
       tty-prompt (~> 0.23)

data/README.md

@@ -1,6 +1,6 @@
 # Chiron
 
-A Ruby gem that initializes Claude AI development workflows, PRD templates, and journaling system for Rails projects. Named after the wise centaur who mentored heroes, Chiron helps you quickly set up a structured development process that integrates seamlessly with Claude Code.
+A Ruby gem that initializes Claude AI development workflows, PRD templates, and journaling system for Rails and Python projects. Named after the wise centaur who mentored heroes, Chiron helps you quickly set up a structured development process that integrates seamlessly with Claude Code.
 
 ## Features
 
@@ -34,15 +34,16 @@ gem install chiron
 
 ### Initialize Claude Workflow
 
-In your Rails project root:
+In your project root (Rails or Python):
 
 ```bash
 chiron init
 ```
 
 This will:
+- Auto-detect your project type (Rails/Python)
 - Create `.claude/commands/` directory with workflow templates
-- Generate `CLAUDE.md` with project-specific configuration
+- Generate `CLAUDE.md` with language-specific configuration
 - Set up `tasks/` directory for PRDs and task lists
 - Initialize development journal in `docs/`
 - Update `.gitignore` appropriately
@@ -50,9 +51,13 @@ This will:
 ### Command Options
 
 ```bash
-# Initialize with options
+# Initialize Rails project with options
 chiron init --project-name="MyApp" --with-viewcomponents
 
+# Initialize Python project with framework-specific patterns
+chiron init --type=python --with-django
+chiron init --type=python --with-fastapi
+
 # Migrate from .cursor to .claude
 chiron migrate-cursor
 
@@ -71,15 +76,19 @@ chiron doctor
 After initialization, you'll have:
 
 ```
-your-rails-app/
+your-project/
 ├── .claude/
 │   ├── commands/
 │   │   ├── workflows/      # Development workflows
 │   │   │   ├── create-prd.md
 │   │   │   ├── generate-tasks.md
-│   │   │   └── process-tasks.md
+│   │   │   ├── process-tasks.md
+│   │   │   ├── debug-python.md    # Python debugging (Python projects)
+│   │   │   ├── python-refactor.md # Python refactoring (Python projects)
+│   │   │   └── flask-development.md # Flask patterns (Flask projects)
 │   │   ├── conventions/    # Language/framework rules
-│   │   │   └── rails.md
+│   │   │   ├── rails.md    # Rails-specific
+│   │   │   └── python.md   # Python-specific
 │   │   ├── context/        # Context commands
 │   │   │   ├── quickstart.md
 │   │   │   └── catchup.md
@@ -88,7 +97,8 @@ your-rails-app/
 │   │   │   └── template.md
 │   │   └── quality/        # Quality assurance
 │   │       ├── pre-commit.md
-│   │       └── test-driven.md
+│   │       ├── test-driven.md
+│   │       └── python-testing.md  # Python testing (Python projects)
 │   └── settings.json       # Claude permissions
 ├── CLAUDE.md              # Project-specific Claude instructions
 ├── tasks/                 # PRDs and task lists
@@ -133,6 +143,39 @@ After setup, you can tell Claude:
 - "Update the journal"
 - "Run pre-commit checks"
 
+### Language-Specific Commands
+
+**Rails:**
+- "Run RuboCop on this file"
+- "Generate an RSpec test"
+- "Create a Rails migration"
+
+**Python:**
+- "Format this with Black"
+- "Create a pytest fixture"
+- "Generate a Django model"
+- "Debug this async function"
+- "Refactor this class using SOLID principles"
+- "Add type hints to this function"
+
+## Supported Project Types
+
+### Rails Projects
+- Full Rails conventions and best practices
+- RSpec testing patterns
+- Hotwire/Stimulus integration
+- ViewComponent support (optional)
+- RuboCop for code quality
+
+### Python Projects
+- Auto-detects Django, FastAPI, Flask, or generic Python
+- pytest testing patterns with fixtures and parametrization
+- Black/flake8/mypy for code quality and type checking
+- Framework-specific templates (Django ORM, FastAPI async, Flask blueprints)
+- Debugging workflows with pdb and logging
+- Refactoring patterns and SOLID principles
+- Virtual environment and dependency management best practices
+
 ## Customization
 
 All templates are customizable. After initialization:

data/docs/development_journal.md

@@ -1,11 +1,94 @@
 # Development Journal - Chiron Gem
 
 ## Project Overview
-Chiron is a Ruby gem that helps Rails developers set up Claude AI workflows, PRD templates, and development journaling systems.
+Chiron is a Ruby gem that helps Rails and Python developers set up Claude AI workflows, PRD templates, and development journaling systems.
+
+---
+
+## 2025-07-01 - Major Enhancement: Comprehensive Python Project Support
+**Developer(s)**: Claude Code | **Branch**: main | **Context**: User request for Python support
+
+### What was accomplished today:
+- **Major Feature Release**: Added complete Python project support to Chiron gem
+- **Framework Detection**: Implemented auto-detection for Django, FastAPI, Flask, and generic Python projects
+- **Architecture Overhaul**: Created `ProjectConfig` class for language-agnostic tool management
+- **Template Reorganization**: Restructured templates into `rails/`, `python/`, and `shared/` directories
+- **Comprehensive Testing**: Expanded test suite from 5 to 41 tests with full Python coverage
+- **Documentation Update**: Enhanced README, CHANGELOG, and CLI help with Python examples
+- **RubyGems Publication**: Successfully published version 0.2.0 to RubyGems
+
+### Technical decisions made:
+- **Multi-Language Architecture**: Designed extensible system supporting both Rails and Python
+- **Project Detection**: Auto-detects project type via `requirements.txt`, `pyproject.toml`, `setup.py`, `Pipfile`
+- **Framework Intelligence**: Identifies Django (`manage.py`), FastAPI/Flask (via requirements analysis)
+- **Template Strategy**: Shared workflows with language-specific conventions and patterns
+- **Backward Compatibility**: Maintained 100% compatibility with existing Rails functionality
+- **Configuration Management**: `ProjectConfig` class abstracts tool selection (pytest vs RSpec, black vs RuboCop)
+
+### Features added:
+- **Python CLI Options**: `--type=python`, `--with-django`, `--with-fastapi` flags
+- **Smart Project Detection**: Interactive prompts for unknown project types
+- **Python Workflow Templates**:
+  - Python Conventions (PEP 8, type hints, async patterns, framework best practices)
+  - Python Testing (pytest patterns, fixtures, mocking, async testing, CI/CD)
+  - Python Debugging (pdb workflows, logging strategies, performance profiling)
+  - Python Refactoring (SOLID principles, design patterns, code organization)
+  - Flask Development (blueprints, forms, testing, deployment patterns)
+- **Framework-Specific Content**: Dynamic CLAUDE.md templates based on detected frameworks
+- **Project-Specific Tips**: Contextual setup guidance after initialization
+
+### Code quality metrics:
+- **RSpec**: 41 examples, 0 failures (8x increase in test coverage)
+- **New Test Categories**: Framework detection, ProjectConfig functionality, Python workflows
+- **RuboCop**: 29 minor offenses (mostly method length in CLI - acceptable for feature-rich CLI)
+- **Backward Compatibility**: All existing Rails tests continue to pass
+
+### Architecture improvements:
+- **Template Structure**: 
+  ```
+  lib/chiron/templates/
+  ├── rails/           # Rails-specific templates
+  ├── python/          # Python-specific templates  
+  └── shared/          # Language-agnostic workflows
+  ```
+- **Language Detection**: Robust project type identification with fallback mechanisms
+- **Tool Configuration**: Abstracted command generation for testing, linting, formatting
+- **ERB Enhancement**: Framework-aware template rendering with conditional content
+
+### Bugs fixed:
+- **Template Fallbacks**: Graceful handling when project-specific templates don't exist
+- **CLI Robustness**: Improved error handling for unknown project types
+- **Cross-Platform**: Ensured Python detection works across different package managers
+
+### Version and release:
+- **Version Bump**: 0.1.0 → 0.2.0 (major feature enhancement)
+- **Gem Build**: Successfully built `chiron-0.2.0.gem`
+- **RubyGems**: Published to RubyGems registry
+- **Documentation**: Comprehensive CHANGELOG with technical details
+
+### Impact and usage:
+- **Multi-Language Support**: Chiron now serves both Rails and Python ecosystems
+- **Framework Coverage**: Django, FastAPI, Flask, and generic Python projects supported
+- **Developer Experience**: Auto-detection eliminates manual configuration
+- **Workflow Richness**: Language-specific best practices and patterns included
+
+### Next steps:
+- Monitor RubyGems adoption and user feedback
+- Consider additional language support (Node.js, Go, etc.)
+- Enhance framework detection with more sophisticated analysis
+- Add more Python-specific workflow templates based on community needs
+- Create video documentation showing Python project initialization
+
+### Notes:
+- This represents the largest enhancement to Chiron since its creation
+- Successfully maintained backward compatibility while adding major new functionality
+- Python support is comprehensive and production-ready
+- Architecture now supports easy addition of future languages
 
 ---
 
 ## 2025-01-21 - Initial Setup and Module Rename
+**Developer(s)**: Claude Code | **Branch**: main | **Context**: Initial gem development
 
 ### What was accomplished today:
 - Set up complete gem development infrastructure

data/lib/chiron/cli.rb

@@ -13,18 +13,30 @@ module Chiron
       true
     end
 
-    desc 'init', 'Initialize Claude workflow in current Rails project'
+    desc 'init', 'Initialize Claude workflow in current project'
     option :project_name, type: :string, desc: 'Project name for CLAUDE.md'
+    option :type, type: :string, desc: 'Project type (rails, python). Auto-detected if not specified'
     option :with_oauth, type: :boolean, default: false, desc: 'Include OAuth workflow examples'
     option :with_viewcomponents, type: :boolean, default: false, desc: 'Include ViewComponent rules'
+    option :with_django, type: :boolean, default: false, desc: 'Include Django-specific patterns'
+    option :with_fastapi, type: :boolean, default: false, desc: 'Include FastAPI-specific patterns'
     option :skip_journal, type: :boolean, default: false, desc: 'Skip development journal setup'
     def init
-      say '🤖 Initializing Claude Rails Setup...'.colorize(:blue)
+      say '🤖 Initializing Claude Setup...'.colorize(:blue)
 
       @prompt = TTY::Prompt.new
+      @project_type = determine_project_type
       @project_name = options[:project_name] || prompt_for_project_name
 
-      check_rails_project
+      # Set up project configuration
+      if @project_type == :python
+        @python_framework = detect_python_framework
+        @config = ProjectConfig.new(@project_type, @python_framework)
+      else
+        @config = ProjectConfig.new(@project_type)
+      end
+
+      check_project_compatibility
       create_directories
       copy_templates
       update_gitignore
@@ -34,6 +46,20 @@ module Chiron
       say '  1. Review and customize CLAUDE.md for your project'
       say '  2. Check .claude/commands/ for available workflows'
       say "  3. Run 'claude' to start using Claude with your new setup"
+
+      # Project-specific suggestions
+      case @project_type
+      when :python
+        say "\nPython project tips:".colorize(:yellow)
+        say '  - Install dev dependencies: pip install pytest black flake8'
+        say '  - Set up pre-commit hooks for code quality'
+        say '  - Configure your IDE to use black formatting'
+      when :rails
+        say "\nRails project tips:".colorize(:yellow)
+        say '  - Ensure binstubs are set up: bundle binstubs bundler --force'
+        say "  - Run 'bin/rubocop' to check code style"
+        say "  - Use 'bin/rspec' for running tests"
+      end
     end
 
     desc 'migrate-cursor', 'Migrate from .cursor to .claude structure'
@@ -90,8 +116,9 @@ module Chiron
     def doctor
       say '🏥 Running Claude setup diagnostics...'.colorize(:blue)
 
+      project_type = detect_project_type
       checks = {
-        'Rails project' => Dir.exist?('app') && File.exist?('Gemfile'),
+        "#{project_type.to_s.capitalize} project" => project_type != :unknown,
         'CLAUDE.md exists' => File.exist?('CLAUDE.md'),
         '.claude directory' => Dir.exist?('.claude'),
         '.claude/commands' => Dir.exist?('.claude/commands'),
@@ -104,6 +131,15 @@ module Chiron
         end
       }
 
+      # Add project-specific checks
+      case project_type
+      when :rails
+        checks['Gemfile exists'] = File.exist?('Gemfile')
+        checks['Rails app structure'] = Dir.exist?('app')
+      when :python
+        checks['Python package file'] = python_package_exists?
+      end
+
       checks.each do |check, result|
         status = result ? '✅'.colorize(:green) : '❌'.colorize(:red)
         say "#{status} #{check}"
@@ -112,7 +148,7 @@ module Chiron
       if checks.values.all?
         say "\n✨ All checks passed!".colorize(:green)
       else
-        say "\n⚠️  Some checks failed. Run 'claude-rails init' to fix.".colorize(:yellow)
+        say "\n⚠️  Some checks failed. Run 'chiron init' to fix.".colorize(:yellow)
       end
     end
 
@@ -130,11 +166,58 @@ module Chiron
       end
     end
 
-    def check_rails_project
-      return if File.exist?('Gemfile') && File.read('Gemfile').include?('rails')
+    def determine_project_type
+      return options[:type].to_sym if options[:type]
+
+      detected_type = detect_project_type
+      if detected_type == :unknown
+        @prompt.select('What type of project is this?') do |menu|
+          menu.choice 'Rails', :rails
+          menu.choice 'Python', :python
+        end
+      else
+        say "Detected #{detected_type} project".colorize(:green)
+        detected_type
+      end
+    end
 
-      error "This doesn't appear to be a Rails project!"
-      exit 1
+    def detect_project_type
+      if File.exist?('Gemfile') && File.read('Gemfile').include?('rails')
+        :rails
+      elsif python_package_exists?
+        :python
+      else
+        :unknown
+      end
+    end
+
+    def detect_python_framework
+      if File.exist?('manage.py')
+        :django
+      elsif File.exist?('app.py') || File.exist?('main.py')
+        if File.exist?('requirements.txt')
+          content = File.read('requirements.txt')
+          return :fastapi if content.include?('fastapi')
+          return :flask if content.include?('flask')
+        end
+        :generic
+      else
+        :generic
+      end
+    end
+
+    def check_project_compatibility
+      case @project_type
+      when :rails
+        unless File.exist?('Gemfile')
+          error "This doesn't appear to be a Rails project!"
+          exit 1
+        end
+      when :python
+        if !python_package_exists? && @prompt.yes?('No Python package file found. Create requirements.txt?')
+          File.write('requirements.txt', "# Python dependencies\n")
+        end
+      end
     end
 
     def create_directories
@@ -157,8 +240,12 @@ module Chiron
     def copy_templates(update: false)
       # Copy CLAUDE.md template
       unless update
-        template_path = File.join(templates_path, 'CLAUDE.md.erb')
+        template_path = File.join(templates_path, @project_type.to_s, 'CLAUDE.md.erb')
+        # Fall back to shared template if project-specific doesn't exist
+        template_path = File.join(templates_path, 'CLAUDE.md.erb') unless File.exist?(template_path)
+
         if File.exist?(template_path)
+          @python_framework = detect_python_framework if @project_type == :python
           content = ERB.new(File.read(template_path)).result(binding)
           File.write('CLAUDE.md', content)
           say '📄 Created CLAUDE.md'.colorize(:light_blue)
@@ -169,7 +256,10 @@ module Chiron
       copy_commands
 
       # Copy settings.json
-      settings_path = File.join(templates_path, 'claude/settings.json')
+      settings_path = File.join(templates_path, 'shared', 'claude', 'settings.json')
+      # Fall back to root claude dir if shared doesn't exist
+      settings_path = File.join(templates_path, 'claude', 'settings.json') unless File.exist?(settings_path)
+
       if File.exist?(settings_path) && !File.exist?('.claude/settings.json')
         FileUtils.cp(settings_path, '.claude/settings.json')
         say '⚙️  Created .claude/settings.json'.colorize(:light_blue)
@@ -182,21 +272,50 @@ module Chiron
     end
 
     def copy_commands
-      commands_dir = File.join(templates_path, 'commands')
-      return unless Dir.exist?(commands_dir)
+      # Copy shared commands first
+      shared_commands_dir = File.join(templates_path, 'shared', 'commands')
+      if Dir.exist?(shared_commands_dir)
+        Dir.glob(File.join(shared_commands_dir, '**/*.md')).each do |file|
+          relative_path = file.sub("#{shared_commands_dir}/", '')
+          target_path = File.join('.claude/commands', relative_path)
+
+          FileUtils.mkdir_p(File.dirname(target_path))
+          FileUtils.cp(file, target_path)
+          say "📋 Copied shared: #{relative_path}".colorize(:light_blue)
+        end
+      end
+
+      # Copy project-specific commands
+      project_commands_dir = File.join(templates_path, @project_type.to_s, 'commands')
+      if Dir.exist?(project_commands_dir)
+        Dir.glob(File.join(project_commands_dir, '**/*.md')).each do |file|
+          relative_path = file.sub("#{project_commands_dir}/", '')
+          target_path = File.join('.claude/commands', relative_path)
+
+          FileUtils.mkdir_p(File.dirname(target_path))
+          FileUtils.cp(file, target_path)
+          say "📋 Copied #{@project_type}: #{relative_path}".colorize(:light_blue)
+        end
+      end
 
-      Dir.glob(File.join(commands_dir, '**/*.md')).each do |file|
-        relative_path = file.sub("#{commands_dir}/", '')
-        target_path = File.join('.claude/commands', relative_path)
+      # Fall back to legacy commands if new structure doesn't exist
+      legacy_commands_dir = File.join(templates_path, 'commands')
+      if !Dir.exist?(shared_commands_dir) && !Dir.exist?(project_commands_dir) && Dir.exist?(legacy_commands_dir)
+        Dir.glob(File.join(legacy_commands_dir, '**/*.md')).each do |file|
+          relative_path = file.sub("#{legacy_commands_dir}/", '')
+          target_path = File.join('.claude/commands', relative_path)
 
-        FileUtils.mkdir_p(File.dirname(target_path))
-        FileUtils.cp(file, target_path)
-        say "📋 Copied #{relative_path}".colorize(:light_blue)
+          FileUtils.mkdir_p(File.dirname(target_path))
+          FileUtils.cp(file, target_path)
+          say "📋 Copied #{relative_path}".colorize(:light_blue)
+        end
       end
     end
 
     def create_development_journal
-      journal_template = File.join(templates_path, 'development_journal.md.erb')
+      journal_template = File.join(templates_path, 'shared', 'development_journal.md.erb')
+      # Fall back to root if shared doesn't exist
+      journal_template = File.join(templates_path, 'development_journal.md.erb') unless File.exist?(journal_template)
       return unless File.exist?(journal_template)
 
       content = ERB.new(File.read(journal_template)).result(binding)
@@ -252,6 +371,11 @@ module Chiron
       Chiron.templates_path
     end
 
+    def python_package_exists?
+      File.exist?('requirements.txt') || File.exist?('pyproject.toml') ||
+        File.exist?('setup.py') || File.exist?('Pipfile')
+    end
+
     def error(message)
       say "❌ #{message}".colorize(:red)
     end