chiron 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1bedffbe29eddeb944137d4f3e986b45d20acfac3ddefa8d5f731efa1c7bc76
-  data.tar.gz: 1c710a2bb2eb67b01ae126f38d2853edc0527c7536832a6a691a94d896d4d79c
+  metadata.gz: ee3cb5e4893ff687265d9e2d8d2fc75de956dd3abeca8b330e7f7c5f5d6c437a
+  data.tar.gz: 0d53f562161301fa0093939a2eee2a3fa64c5f2a5a2c9f2802ecd31be12038f9
 SHA512:
-  metadata.gz: f1a40196a2c48302fec0be7bdba442d21386bcd8e0b2f3b88174e32f2927bec876c5673ee018e9c23cf1dd46b299ae1a628acc9b831b26c12d4da86c801913ea
-  data.tar.gz: 93668d0ac4144e80aa5b80172bad66706db730d1068f6250a2e18e3ee621479d1ca09ae118abc6b615f4b05e6b332342a53913c09fb1c392b633fa2275316344
+  metadata.gz: '0183d1aa5e2fe30cd565e96ab8680b8cdb8c29066391942c641f2038c3ce0394f6ae6fd03c008ce211fc599b7e3773a429b48fb70115eaa268dd5b5942e27ae4'
+  data.tar.gz: d7a016612648121ed2c031a0180c76637684285bc448f179d81850c8f85800a98964d346363e89d49d41c232d2c4a90f1178ff4606404478b85f06e99e60dafc

data/CHANGELOG.md

@@ -5,30 +5,63 @@ 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.0] - 2025-07-01
 
-## [0.1.0] - 2025-01-21
+### 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/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/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

data/lib/chiron/project_config.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Chiron
+  class ProjectConfig
+    attr_reader :type, :test_runner, :linter, :formatter, :framework
+
+    def initialize(project_type, framework = nil)
+      @type = project_type
+      @framework = framework
+
+      case project_type
+      when :rails
+        @test_runner = 'bin/rspec'
+        @linter = 'bin/rubocop'
+        @formatter = 'bin/rubocop --autocorrect'
+      when :python
+        @test_runner = 'pytest'
+        @linter = 'flake8'
+        @formatter = 'black'
+      end
+    end
+
+    def framework_name
+      case @framework
+      when :django
+        'Django'
+      when :fastapi
+        'FastAPI'
+      when :flask
+        'Flask'
+      else
+        @type.to_s.capitalize
+      end
+    end
+
+    def test_command(file = nil)
+      case @type
+      when :rails
+        file ? "#{@test_runner} #{file}" : @test_runner
+      when :python
+        file ? "#{@test_runner} #{file}" : @test_runner
+      end
+    end
+
+    def format_command(file = nil)
+      case @type
+      when :rails
+        file ? "#{@formatter} #{file}" : @formatter
+      when :python
+        file ? "#{@formatter} #{file}" : "#{@formatter} ."
+      end
+    end
+
+    def lint_command(file = nil)
+      case @type
+      when :rails
+        file ? "#{@linter} #{file}" : @linter
+      when :python
+        file ? "#{@linter} #{file}" : @linter
+      end
+    end
+
+    def package_file
+      case @type
+      when :rails
+        'Gemfile'
+      when :python
+        if File.exist?('pyproject.toml')
+          'pyproject.toml'
+        elsif File.exist?('Pipfile')
+          'Pipfile'
+        elsif File.exist?('setup.py')
+          'setup.py'
+        else
+          'requirements.txt'
+        end
+      end
+    end
+
+    def install_command
+      case @type
+      when :rails
+        'bundle install'
+      when :python
+        if File.exist?('Pipfile')
+          'pipenv install'
+        elsif File.exist?('pyproject.toml') && File.read('pyproject.toml').include?('[tool.poetry]')
+          'poetry install'
+        else
+          'pip install -r requirements.txt'
+        end
+      end
+    end
+  end
+end

data/lib/chiron/templates/python/CLAUDE.md.erb

@@ -0,0 +1,192 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+<%= @project_name %> is a Python project<% if @python_framework == :django %> using Django framework<% elsif @python_framework == :fastapi %> using FastAPI framework<% elsif @python_framework == :flask %> using Flask framework<% end %>. [Add your project description here]
+
+## Development Commands
+
+**Important**: Use virtual environments for dependency isolation.
+
+```bash
+# Setup virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+<% if File.exist?('requirements-dev.txt') %>pip install -r requirements-dev.txt  # Development dependencies<% end %>
+
+<% if @python_framework == :django %>
+# Django specific
+python manage.py migrate
+python manage.py runserver
+python manage.py test
+<% elsif @python_framework == :fastapi %>
+# FastAPI specific
+uvicorn main:app --reload  # Or app:app depending on your structure
+<% elsif @python_framework == :flask %>
+# Flask specific
+flask run  # Or python app.py
+<% end %>
+
+# Testing
+pytest                               # Run all tests
+pytest tests/                        # Run specific test directory
+pytest tests/test_models.py          # Run single test file
+pytest -v                           # Verbose output
+pytest --cov=.                      # With coverage
+
+# Code quality
+black .                             # Format code
+flake8                              # Linting
+mypy .                              # Type checking (if configured)
+isort .                             # Sort imports
+```
+
+## Architecture Overview
+
+### Project Structure
+[Document your main modules and their purposes]
+
+### Core Services/Modules
+[List your service classes/modules and their purposes]
+
+<% if @python_framework == :django %>
+### Models & Database
+[Describe your Django models and relationships]
+
+### Views & URLs
+[Describe your view organization and URL patterns]
+<% elsif @python_framework == :fastapi %>
+### API Endpoints
+[Describe your API structure and main endpoints]
+
+### Schemas & Models
+[Describe your Pydantic models and database models]
+<% end %>
+
+## Technical Stack
+
+<% if @python_framework == :django %>
+- **Framework**: Django <%= options[:django_version] || "4.2+" %>
+- **Database**: PostgreSQL with Django ORM
+- **API**: Django REST Framework (if applicable)
+- **Frontend**: [Your frontend stack]
+<% elsif @python_framework == :fastapi %>
+- **Framework**: FastAPI
+- **Database**: [Your database] with SQLAlchemy/Tortoise-ORM
+- **API Documentation**: Automatic with Swagger/ReDoc
+- **Async Support**: Built-in async/await
+<% elsif @python_framework == :flask %>
+- **Framework**: Flask
+- **Database**: [Your database] with SQLAlchemy
+- **API**: Flask-RESTful (if applicable)
+<% else %>
+- **Language**: Python <%= `python --version 2>&1`.strip.split(' ')[1] rescue "3.x" %>
+- **Package Management**: pip/poetry/pipenv
+- **Testing**: pytest
+- **Code Quality**: black, flake8, mypy
+<% end %>
+- **Testing**: pytest with fixtures
+- **Type Checking**: mypy (optional but recommended)
+
+## Environment Variables
+
+Required for development:
+```
+# Add your required environment variables here
+<% if @python_framework == :django %>
+SECRET_KEY=your-secret-key
+DEBUG=True
+DATABASE_URL=postgresql://user:pass@localhost/dbname
+<% elsif @python_framework == :fastapi %>
+DATABASE_URL=postgresql://user:pass@localhost/dbname
+JWT_SECRET=your-jwt-secret
+<% end %>
+```
+
+## Python Conventions
+
+- Follow PEP 8 style guide
+- Use type hints where beneficial
+- Docstrings for all public functions/classes
+- Black for consistent formatting
+- Meaningful variable and function names
+
+## Development Patterns
+
+### Code Organization
+<% if @python_framework == :django %>
+- Follow Django's app-based architecture
+- Keep views thin, business logic in services/models
+- Use Django's built-in features (signals, middleware, etc.)
+<% elsif @python_framework == :fastapi %>
+- Organize routes by feature/domain
+- Use dependency injection
+- Leverage Pydantic for data validation
+- Keep endpoints focused and RESTful
+<% else %>
+- Organize code by feature/module
+- Use classes for complex state
+- Functions for simple transformations
+- Separate concerns clearly
+<% end %>
+
+### PRD Workflow
+- Use `.claude/commands/workflows/create-prd.md` for structured feature development
+- PRDs should be saved in `/tasks/` directory as `prd-[feature-name].md`
+- Follow the clarifying questions process before implementation
+
+### Code Quality
+- Black for consistent formatting
+- Flake8 for linting
+- pytest for testing
+- Type hints with mypy (optional)
+- Comprehensive test coverage
+
+## Testing Standards
+
+- Write tests before implementation (TDD)
+- Use pytest fixtures for test data
+- Mock external dependencies
+- Aim for high test coverage
+- Test edge cases and error conditions
+
+<% if @python_framework == :django %>
+### Django Testing
+```python
+from django.test import TestCase, Client
+from .models import MyModel
+
+class MyModelTestCase(TestCase):
+    def setUp(self):
+        self.obj = MyModel.objects.create(name="Test")
+    
+    def test_string_representation(self):
+        self.assertEqual(str(self.obj), "Test")
+```
+<% elsif @python_framework == :fastapi %>
+### FastAPI Testing
+```python
+from fastapi.testclient import TestClient
+from main import app
+
+client = TestClient(app)
+
+def test_read_main():
+    response = client.get("/")
+    assert response.status_code == 200
+```
+<% end %>
+
+## Important Reminders
+
+- Always run tests before committing
+- Use semantic commit messages
+- Update the development journal for significant changes
+- Follow the pre-commit checklist in `.claude/commands/quality/pre-commit.md`
+- Keep dependencies updated in requirements.txt
+- Document API changes

data/lib/chiron/templates/python/commands/conventions/python.md

@@ -0,0 +1,330 @@
+# Python Development Conventions
+
+You are an expert in Python, modern web frameworks (Django, FastAPI, Flask), and Python best practices.
+
+## Code Style and Structure
+- Write clear, idiomatic Python code following PEP 8
+- Use type hints to improve code clarity and catch errors early
+- Prefer composition over inheritance
+- Keep functions small and focused (single responsibility)
+- Use descriptive names that convey intent
+- Structure code in logical modules and packages
+
+## Naming Conventions
+- Use snake_case for functions, variables, and module names
+- Use PascalCase for class names
+- Use UPPER_SNAKE_CASE for constants
+- Prefix "private" attributes/methods with underscore (_)
+- Use descriptive names over comments when possible
+
+## Python Best Practices
+- Use Python 3.8+ features appropriately:
+  - f-strings for formatting
+  - Type hints and typing module
+  - Dataclasses for simple data structures
+  - Pattern matching (3.10+) where beneficial
+- List comprehensions for simple transformations
+- Generator expressions for memory efficiency
+- Context managers (with statements) for resource management
+- Pathlib over os.path for file operations
+
+## Type Hints
+```python
+from typing import List, Dict, Optional, Union
+
+def process_data(
+    items: List[str], 
+    config: Optional[Dict[str, Any]] = None
+) -> Dict[str, int]:
+    """Process items according to config."""
+    config = config or {}
+    return {item: len(item) for item in items}
+```
+
+## Error Handling
+- Use specific exception types
+- Avoid bare except clauses
+- Use logging instead of print for debugging
+- Fail fast with clear error messages
+- Handle exceptions at appropriate levels
+
+```python
+import logging
+
+logger = logging.getLogger(__name__)
+
+try:
+    result = risky_operation()
+except ValueError as e:
+    logger.error(f"Invalid value: {e}")
+    raise
+except Exception as e:
+    logger.exception("Unexpected error")
+    # Handle or re-raise appropriately
+```
+
+## Testing with pytest
+- Write tests before or alongside implementation
+- Use fixtures for test data and setup
+- Parametrize tests for multiple scenarios
+- Mock external dependencies
+- Aim for high coverage but focus on behavior
+
+```python
+import pytest
+from unittest.mock import Mock, patch
+
+@pytest.fixture
+def sample_data():
+    return {"key": "value"}
+
+@pytest.mark.parametrize("input,expected", [
+    ("hello", 5),
+    ("", 0),
+    ("test", 4),
+])
+def test_string_length(input, expected):
+    assert len(input) == expected
+
+def test_with_mock():
+    mock_service = Mock()
+    mock_service.get_data.return_value = {"status": "ok"}
+    assert process_with_service(mock_service)["status"] == "ok"
+```
+
+## Django Specific
+```python
+# Models
+from django.db import models
+from django.urls import reverse
+
+class Article(models.Model):
+    title = models.CharField(max_length=200)
+    slug = models.SlugField(unique=True)
+    content = models.TextField()
+    created_at = models.DateTimeField(auto_now_add=True)
+    
+    class Meta:
+        ordering = ['-created_at']
+    
+    def __str__(self):
+        return self.title
+    
+    def get_absolute_url(self):
+        return reverse('article_detail', args=[self.slug])
+
+# Views (Class-Based)
+from django.views.generic import ListView, DetailView
+from django.contrib.auth.mixins import LoginRequiredMixin
+
+class ArticleListView(ListView):
+    model = Article
+    paginate_by = 10
+    context_object_name = 'articles'
+
+# Forms
+from django import forms
+
+class ArticleForm(forms.ModelForm):
+    class Meta:
+        model = Article
+        fields = ['title', 'content']
+        widgets = {
+            'content': forms.Textarea(attrs={'rows': 10}),
+        }
+```
+
+## FastAPI Specific
+```python
+from fastapi import FastAPI, HTTPException, Depends
+from pydantic import BaseModel, Field
+from typing import List, Optional
+from datetime import datetime
+
+app = FastAPI(title="My API", version="1.0.0")
+
+# Pydantic Models
+class ItemBase(BaseModel):
+    name: str = Field(..., min_length=1, max_length=100)
+    description: Optional[str] = None
+    price: float = Field(..., gt=0)
+
+class ItemCreate(ItemBase):
+    pass
+
+class Item(ItemBase):
+    id: int
+    created_at: datetime
+    
+    class Config:
+        orm_mode = True
+
+# Dependency Injection
+async def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+# Endpoints
+@app.post("/items/", response_model=Item)
+async def create_item(
+    item: ItemCreate, 
+    db: Session = Depends(get_db)
+):
+    db_item = ItemModel(**item.dict())
+    db.add(db_item)
+    db.commit()
+    db.refresh(db_item)
+    return db_item
+
+@app.get("/items/{item_id}", response_model=Item)
+async def read_item(item_id: int, db: Session = Depends(get_db)):
+    item = db.query(ItemModel).filter(ItemModel.id == item_id).first()
+    if not item:
+        raise HTTPException(status_code=404, detail="Item not found")
+    return item
+```
+
+## Async/Await Best Practices
+```python
+import asyncio
+import aiohttp
+
+async def fetch_data(session: aiohttp.ClientSession, url: str) -> dict:
+    async with session.get(url) as response:
+        return await response.json()
+
+async def fetch_multiple(urls: List[str]) -> List[dict]:
+    async with aiohttp.ClientSession() as session:
+        tasks = [fetch_data(session, url) for url in urls]
+        return await asyncio.gather(*tasks)
+```
+
+## Data Validation with Pydantic
+```python
+from pydantic import BaseModel, validator, Field
+from typing import Optional
+from datetime import datetime
+
+class User(BaseModel):
+    username: str = Field(..., min_length=3, max_length=50)
+    email: str
+    age: Optional[int] = Field(None, ge=0, le=150)
+    created_at: datetime = Field(default_factory=datetime.now)
+    
+    @validator('email')
+    def validate_email(cls, v):
+        if '@' not in v:
+            raise ValueError('Invalid email')
+        return v.lower()
+```
+
+## Database Patterns
+```python
+# SQLAlchemy with FastAPI
+from sqlalchemy import Column, Integer, String, DateTime
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.sql import func
+
+Base = declarative_base()
+
+class UserModel(Base):
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+# Repository Pattern
+class UserRepository:
+    def __init__(self, db: Session):
+        self.db = db
+    
+    def get_by_username(self, username: str) -> Optional[UserModel]:
+        return self.db.query(UserModel).filter(
+            UserModel.username == username
+        ).first()
+    
+    def create(self, user_data: dict) -> UserModel:
+        user = UserModel(**user_data)
+        self.db.add(user)
+        self.db.commit()
+        self.db.refresh(user)
+        return user
+```
+
+## Configuration Management
+```python
+from pydantic import BaseSettings
+from functools import lru_cache
+
+class Settings(BaseSettings):
+    app_name: str = "My App"
+    debug: bool = False
+    database_url: str
+    secret_key: str
+    
+    class Config:
+        env_file = ".env"
+
+@lru_cache()
+def get_settings():
+    return Settings()
+
+# Usage
+settings = get_settings()
+```
+
+## Logging Best Practices
+```python
+import logging
+import sys
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler('app.log')
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+# Use structured logging
+logger.info(
+    "User action", 
+    extra={"user_id": 123, "action": "login", "ip": "192.168.1.1"}
+)
+```
+
+## Performance Optimization
+- Use generators for large datasets
+- Cache expensive operations with functools.lru_cache
+- Profile code with cProfile before optimizing
+- Use appropriate data structures (sets for membership, deque for queues)
+- Leverage asyncio for I/O-bound operations
+- Consider multiprocessing for CPU-bound tasks
+
+## Security Best Practices
+- Never hardcode secrets
+- Use environment variables for configuration
+- Validate all input data
+- Use parameterized queries to prevent SQL injection
+- Hash passwords with bcrypt or argon2
+- Implement proper authentication and authorization
+- Keep dependencies updated
+
+## Common Pitfalls to Avoid
+- Mutable default arguments
+- Modifying lists while iterating
+- Using `is` for value comparison (use `==`)
+- Catching too broad exceptions
+- Not closing resources properly
+- Circular imports
+- Using global variables excessively
+
+Remember: "Explicit is better than implicit" - The Zen of Python

data/lib/chiron/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Chiron
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/chiron.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'chiron/version'
+require_relative 'chiron/project_config'
 require_relative 'chiron/cli'
 
 module Chiron

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chiron
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Brett McHargue
@@ -108,7 +108,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.21'
 description: A Ruby gem that sets up Claude AI development workflows, PRD templates,
-  and journaling system for Rails projects
+  and journaling system for Rails and Python projects
 email:
 - ebrett@users.noreply.github.com
 executables:
@@ -130,21 +130,24 @@ files:
 - exe/chiron
 - lib/chiron.rb
 - lib/chiron/cli.rb
-- lib/chiron/templates/CLAUDE.md.erb
-- lib/chiron/templates/claude/settings.json
-- lib/chiron/templates/commands/context/catchup.md
-- lib/chiron/templates/commands/context/prime.md
-- lib/chiron/templates/commands/context/quickstart.md
-- lib/chiron/templates/commands/conventions/rails.md
-- lib/chiron/templates/commands/journal/instructions.md
-- lib/chiron/templates/commands/journal/template.md
-- lib/chiron/templates/commands/quality/pre-commit.md
-- lib/chiron/templates/commands/quality/test-driven.md
-- lib/chiron/templates/commands/workflows/create-prd.md
-- lib/chiron/templates/commands/workflows/feature-complete.md
-- lib/chiron/templates/commands/workflows/generate-tasks.md
-- lib/chiron/templates/commands/workflows/process-tasks.md
-- lib/chiron/templates/development_journal.md.erb
+- lib/chiron/project_config.rb
+- lib/chiron/templates/python/CLAUDE.md.erb
+- lib/chiron/templates/python/commands/conventions/python.md
+- lib/chiron/templates/rails/CLAUDE.md.erb
+- lib/chiron/templates/rails/commands/conventions/rails.md
+- lib/chiron/templates/shared/claude/settings.json
+- lib/chiron/templates/shared/commands/context/catchup.md
+- lib/chiron/templates/shared/commands/context/prime.md
+- lib/chiron/templates/shared/commands/context/quickstart.md
+- lib/chiron/templates/shared/commands/journal/instructions.md
+- lib/chiron/templates/shared/commands/journal/template.md
+- lib/chiron/templates/shared/commands/quality/pre-commit.md
+- lib/chiron/templates/shared/commands/quality/test-driven.md
+- lib/chiron/templates/shared/commands/workflows/create-prd.md
+- lib/chiron/templates/shared/commands/workflows/feature-complete.md
+- lib/chiron/templates/shared/commands/workflows/generate-tasks.md
+- lib/chiron/templates/shared/commands/workflows/process-tasks.md
+- lib/chiron/templates/shared/development_journal.md.erb
 - lib/chiron/version.rb
 homepage: https://github.com/ebrett/chiron
 licenses:
@@ -170,5 +173,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.2
 specification_version: 4
-summary: Initialize Claude AI workflow for Rails projects
+summary: Initialize Claude AI workflow for Rails and Python projects
 test_files: []