ocak 0.1.0

data/lib/ocak/commands/clean.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../config'
+require_relative '../worktree_manager'
+
+module Ocak
+  module Commands
+    class Clean < Dry::CLI::Command
+      desc 'Remove stale worktrees and prune git worktree list'
+
+      def call(**)
+        config = Config.load
+        manager = WorktreeManager.new(config: config)
+
+        puts 'Cleaning stale worktrees...'
+        removed = manager.clean_stale
+
+        if removed.empty?
+          puts 'No stale worktrees found.'
+        else
+          removed.each { |path| puts "  Removed: #{path}" }
+          puts "Cleaned #{removed.size} worktree(s)."
+        end
+      rescue Config::ConfigNotFound => e
+        warn "Error: #{e.message}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/ocak/commands/debt.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ocak
+  module Commands
+    class Debt < Dry::CLI::Command
+      desc 'Track technical debt'
+
+      def call(**)
+        skill_path = File.join(Dir.pwd, '.claude', 'skills', 'debt', 'SKILL.md')
+
+        unless File.exist?(skill_path)
+          warn 'No debt skill found. Run `ocak init` first.'
+          exit 1
+        end
+
+        puts 'Run this inside Claude Code:'
+        puts '  /debt'
+      end
+    end
+  end
+end

data/lib/ocak/commands/design.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ocak
+  module Commands
+    class Design < Dry::CLI::Command
+      desc 'Launch interactive issue design session'
+
+      argument :description, type: :string, required: false, desc: 'Rough description of what to build'
+
+      def call(description: nil, **)
+        skill_path = File.join(Dir.pwd, '.claude', 'skills', 'design', 'SKILL.md')
+
+        unless File.exist?(skill_path)
+          warn 'No design skill found. Run `ocak init` first.'
+          exit 1
+        end
+
+        puts 'Starting interactive design session...'
+        puts 'This will open Claude Code with the /design skill.'
+        puts ''
+
+        if description
+          exec('claude', '--skill', skill_path, '--', description)
+        else
+          puts 'Run this inside Claude Code:'
+          puts '  /design <description of what you want to build>'
+          puts ''
+          puts 'Or provide a description directly:'
+          puts '  ocak design "add user authentication with OAuth"'
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/init.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require_relative '../stack_detector'
+require_relative '../agent_generator'
+require_relative '../config'
+
+module Ocak
+  module Commands
+    class Init < Dry::CLI::Command
+      desc 'Initialize Ocak pipeline in the current project'
+
+      option :force, type: :boolean, default: false, desc: 'Overwrite existing configuration'
+      option :no_ai, type: :boolean, default: false, desc: 'Skip AI-powered agent customization'
+      option :config_only, type: :boolean, default: false, desc: 'Only generate config, hooks, and settings'
+      option :skip_agents, type: :boolean, default: false, desc: 'Skip agent generation'
+      option :skip_skills, type: :boolean, default: false, desc: 'Skip skill generation'
+
+      def call(**options)
+        project_dir = Dir.pwd
+
+        if File.exist?(File.join(project_dir, 'ocak.yml')) && !options[:force]
+          puts 'ocak.yml already exists. Use --force to overwrite.'
+          return
+        end
+
+        puts 'Detecting project stack...'
+        stack = StackDetector.new(project_dir).detect
+        print_stack(stack)
+
+        generator = AgentGenerator.new(
+          stack: stack, project_dir: project_dir, use_ai: !options[:no_ai], logger: init_logger
+        )
+
+        generate_files(generator, project_dir, options)
+        update_settings(project_dir, stack)
+        update_gitignore(project_dir)
+
+        puts ''
+        print_summary(project_dir, stack, options)
+      end
+
+      private
+
+      def generate_files(generator, project_dir, options)
+        generator.generate_config(File.join(project_dir, 'ocak.yml'))
+        generate_agents(generator, project_dir, options)
+        generate_skills(generator, project_dir, options)
+        generator.generate_hooks(File.join(project_dir, '.claude', 'hooks'))
+      end
+
+      def generate_agents(generator, project_dir, options)
+        return if options[:config_only] || options[:skip_agents]
+
+        agents_dir = File.join(project_dir, '.claude', 'agents')
+        if agents_exist?(agents_dir) && !options[:force]
+          puts '  Existing agents found in .claude/agents/ — skipping (use --force to overwrite)'
+        else
+          generator.generate_agents(agents_dir)
+        end
+      end
+
+      def generate_skills(generator, project_dir, options)
+        return if options[:config_only] || options[:skip_skills]
+
+        generator.generate_skills(File.join(project_dir, '.claude', 'skills'))
+      end
+
+      def agents_exist?(agents_dir)
+        Dir.exist?(agents_dir) && Dir.glob(File.join(agents_dir, '*.md')).any?
+      end
+
+      def print_stack(stack)
+        puts "  Language:  #{stack.language}"
+        puts "  Framework: #{stack.framework || 'none detected'}"
+        puts "  Tests:     #{stack.test_command || 'none detected'}"
+        puts "  Lint:      #{stack.lint_command || 'none detected'}"
+        puts "  Security:  #{stack.security_commands.empty? ? 'none detected' : stack.security_commands.join(', ')}"
+        puts "  Monorepo:  yes (#{stack.packages.size} packages)" if stack.respond_to?(:monorepo) && stack.monorepo
+        puts ''
+      end
+
+      def update_settings(project_dir, stack)
+        settings_path = File.join(project_dir, '.claude', 'settings.json')
+        existing = File.exist?(settings_path) ? JSON.parse(File.read(settings_path)) : {}
+
+        merge_permissions(existing, stack)
+        merge_hooks(existing)
+
+        FileUtils.mkdir_p(File.dirname(settings_path))
+        File.write(settings_path, JSON.pretty_generate(existing))
+        puts '  Updated .claude/settings.json'
+      end
+
+      def merge_permissions(settings, stack)
+        settings['permissions'] ||= {}
+        settings['permissions']['allow'] ||= []
+        allowed = settings['permissions']['allow']
+
+        build_permissions(stack).each do |perm|
+          allowed << perm unless allowed.include?(perm)
+        end
+      end
+
+      def merge_hooks(settings)
+        settings['hooks'] ||= {}
+        settings['hooks']['PostToolUse'] ||= []
+        settings['hooks']['TaskCompleted'] ||= []
+
+        add_hook_unless_exists(settings['hooks']['PostToolUse'], 'post-edit-lint',
+                               'matcher' => 'Edit|Write',
+                               'hooks' => [{ 'type' => 'command', 'command' => '.claude/hooks/post-edit-lint.sh' }])
+
+        add_hook_unless_exists(settings['hooks']['TaskCompleted'], 'task-completed-test',
+                               'hooks' => [{ 'type' => 'command',
+                                             'command' => '.claude/hooks/task-completed-test.sh' }])
+      end
+
+      def add_hook_unless_exists(hooks_list, hook_name, hook_entry)
+        return if hooks_list.any? { |h| h.dig('hooks', 0, 'command')&.include?(hook_name) }
+
+        hooks_list << hook_entry
+      end
+
+      def build_permissions(stack)
+        perms = language_permissions(stack)
+        # Always allow gh CLI for pipeline operations
+        perms.push('Bash(gh issue*)', 'Bash(gh pr*)', 'Bash(gh label*)')
+      end
+
+      def language_permissions(stack)
+        case stack.language
+        when 'ruby'
+          ruby_permissions(stack)
+        when 'typescript', 'javascript'
+          ['Bash(npm test*)', 'Bash(npx biome*)', 'Bash(npx eslint*)', 'Bash(npm audit*)', 'Bash(npm run typecheck*)']
+        when 'python'
+          ['Bash(pytest*)', 'Bash(python -m pytest*)', 'Bash(ruff*)', 'Bash(flake8*)']
+        when 'rust'
+          ['Bash(cargo test*)', 'Bash(cargo clippy*)', 'Bash(cargo fmt*)']
+        when 'go'
+          ['Bash(go test*)', 'Bash(golangci-lint*)']
+        else
+          []
+        end
+      end
+
+      def ruby_permissions(stack)
+        perms = ['Bash(bundle exec rubocop*)', 'Bash(bundle exec rspec*)', 'Bash(bundle exec rake test*)']
+        perms << 'Bash(bundle exec brakeman*)' if stack.security_commands.any? { |c| c.include?('brakeman') }
+        perms << 'Bash(bundle exec bundler-audit*)' if stack.security_commands.any? { |c| c.include?('bundler-audit') }
+        perms
+      end
+
+      def update_gitignore(project_dir)
+        gitignore_path = File.join(project_dir, '.gitignore')
+        additions_path = File.join(Ocak.templates_dir, 'gitignore_additions.txt')
+        additions = File.read(additions_path)
+
+        existing = File.exist?(gitignore_path) ? File.read(gitignore_path) : ''
+
+        new_lines = additions.lines.reject do |line|
+          line.strip.empty? || line.start_with?('#') || existing.include?(line.strip)
+        end
+
+        return if new_lines.empty?
+
+        File.open(gitignore_path, 'a') do |f|
+          f.puts '' unless existing.end_with?("\n\n")
+          f.puts '# Ocak / Claude Code'
+          new_lines.each { |line| f.puts line }
+        end
+        puts '  Updated .gitignore'
+      end
+
+      def print_summary(_project_dir, _stack, options)
+        puts 'Ocak initialized successfully!'
+        puts ''
+        puts 'Created:'
+        puts '  ocak.yml                          — pipeline configuration'
+        unless options[:config_only]
+          puts '  .claude/agents/                    — 8 pipeline agents' unless options[:skip_agents]
+          puts '  .claude/skills/                    — 4 interactive skills' unless options[:skip_skills]
+        end
+        puts '  .claude/hooks/                     — lint + test hooks'
+        puts '  .claude/settings.json              — permissions & hooks config'
+        puts ''
+        puts 'Next steps:'
+        puts '  1. Review ocak.yml and adjust settings'
+        puts '  2. Review .claude/agents/ and customize if needed'
+        puts '  3. Create issues with: claude then /design'
+        puts "  4. Label issues 'auto-ready'"
+        puts '  5. Run the pipeline: ocak run --once'
+        puts ''
+        puts 'Quick commands:'
+        puts '  ocak run --single 42    Run one issue'
+        puts '  ocak run --watch        Run with live output'
+        puts '  ocak status             Check pipeline state'
+        puts '  ocak audit              Run codebase audit'
+      end
+
+      def init_logger
+        @init_logger ||= Object.new.tap do |l|
+          def l.info(msg)
+            puts "  #{msg}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/resume.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative '../config'
+require_relative '../pipeline_runner'
+require_relative '../pipeline_state'
+require_relative '../claude_runner'
+require_relative '../issue_fetcher'
+require_relative '../worktree_manager'
+require_relative '../merge_manager'
+require_relative '../logger'
+
+module Ocak
+  module Commands
+    class Resume < Dry::CLI::Command
+      desc 'Resume a failed pipeline from the last successful step'
+
+      argument :issue, type: :integer, required: true, desc: 'Issue number to resume'
+      option :watch, type: :boolean, default: false, desc: 'Stream agent activity to terminal'
+
+      def call(issue:, **options)
+        config = Config.load
+        issue_number = issue.to_i
+        saved = load_state(config, issue_number)
+        chdir = resolve_worktree(config, saved)
+
+        print_resume_info(issue_number, saved, config)
+        run_resumed_pipeline(config, issue_number, saved, chdir, options)
+      rescue Config::ConfigNotFound => e
+        warn "Error: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def load_state(config, issue_number)
+        log_dir = File.join(config.project_dir, config.log_dir)
+        state = PipelineState.new(log_dir: log_dir)
+        saved = state.load(issue_number)
+        unless saved
+          warn "No saved state for issue ##{issue_number}. Nothing to resume."
+          exit 1
+        end
+        saved
+      end
+
+      def print_resume_info(issue_number, saved, config)
+        puts "Resuming issue ##{issue_number}"
+        puts "  Completed steps: #{saved[:completed_steps].size}/#{config.steps.size}"
+        puts "  Worktree: #{saved[:worktree_path]}"
+        puts "  Branch: #{saved[:branch]}"
+        puts ''
+      end
+
+      def run_resumed_pipeline(config, issue_number, saved, chdir, options)
+        log_dir = File.join(config.project_dir, config.log_dir)
+        logger = PipelineLogger.new(log_dir: log_dir, issue_number: issue_number)
+        watch_formatter = options[:watch] ? WatchFormatter.new : nil
+        claude = ClaudeRunner.new(config: config, logger: logger, watch: watch_formatter)
+        issues = IssueFetcher.new(config: config, logger: logger)
+
+        issues.transition(issue_number, from: config.label_failed, to: config.label_in_progress)
+
+        runner = PipelineRunner.new(config: config, options: { watch: options[:watch] })
+        result = runner.send(:run_pipeline, issue_number,
+                             logger: logger, claude: claude, chdir: chdir,
+                             skip_steps: saved[:completed_steps])
+
+        ctx = { config: config, issue_number: issue_number, saved: saved, chdir: chdir,
+                issues: issues, claude: claude, logger: logger, watch: watch_formatter }
+        handle_result(result, ctx)
+      end
+
+      def handle_result(result, ctx)
+        if result[:success]
+          attempt_merge(ctx)
+        else
+          ctx[:issues].transition(ctx[:issue_number], from: ctx[:config].label_in_progress,
+                                                      to: ctx[:config].label_failed)
+          ctx[:issues].comment(ctx[:issue_number],
+                               "Pipeline failed at phase: #{result[:phase]}\n\n```\n#{result[:output][0..1000]}\n```")
+          warn "Issue ##{ctx[:issue_number]} failed again at phase: #{result[:phase]}"
+        end
+      end
+
+      def attempt_merge(ctx)
+        merger = MergeManager.new(config: ctx[:config], claude: ctx[:claude],
+                                  logger: ctx[:logger], watch: ctx[:watch])
+        worktree = WorktreeManager::Worktree.new(
+          path: ctx[:chdir], branch: ctx[:saved][:branch], issue_number: ctx[:issue_number]
+        )
+
+        if merger.merge(ctx[:issue_number], worktree)
+          ctx[:issues].transition(ctx[:issue_number], from: ctx[:config].label_in_progress,
+                                                      to: ctx[:config].label_completed)
+          puts "Issue ##{ctx[:issue_number]} resumed and merged successfully!"
+        else
+          ctx[:issues].transition(ctx[:issue_number], from: ctx[:config].label_in_progress,
+                                                      to: ctx[:config].label_failed)
+          warn "Issue ##{ctx[:issue_number]} merge failed after resume"
+        end
+      end
+
+      def resolve_worktree(config, saved)
+        return saved[:worktree_path] if saved[:worktree_path] && Dir.exist?(saved[:worktree_path])
+
+        recreate_from_branch(config, saved)
+      end
+
+      def recreate_from_branch(config, saved)
+        unless saved[:branch]
+          warn 'Worktree no longer exists and no branch saved. Cannot resume.'
+          exit 1
+        end
+
+        _, _, status = Open3.capture3('git', 'rev-parse', '--verify', saved[:branch], chdir: config.project_dir)
+        unless status.success?
+          warn "Worktree no longer exists and branch '#{saved[:branch]}' not found. Cannot resume."
+          exit 1
+        end
+
+        worktrees = WorktreeManager.new(config: config)
+        wt = worktrees.create(saved[:issue_number], setup_command: config.setup_command)
+        Open3.capture3('git', 'checkout', saved[:branch], chdir: wt.path)
+        wt.path
+      end
+    end
+  end
+end

data/lib/ocak/commands/run.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../config'
+require_relative '../pipeline_runner'
+require_relative '../claude_runner'
+require_relative '../issue_fetcher'
+require_relative '../worktree_manager'
+require_relative '../merge_manager'
+require_relative '../logger'
+
+module Ocak
+  module Commands
+    class Run < Dry::CLI::Command
+      desc 'Run the issue processing pipeline'
+
+      option :watch, type: :boolean, default: false, desc: 'Stream agent activity to terminal'
+      option :single, type: :integer, desc: 'Run a single issue without worktrees'
+      option :dry_run, type: :boolean, default: false, desc: 'Show what would happen'
+      option :once, type: :boolean, default: false, desc: 'Process current batch and exit'
+      option :max_parallel, type: :integer, desc: 'Max concurrent pipelines'
+      option :poll_interval, type: :integer, desc: 'Seconds between polls'
+
+      def call(**options)
+        config = Config.load
+
+        # CLI options override config
+        config.override(:max_parallel, options[:max_parallel]) if options[:max_parallel]
+        config.override(:poll_interval, options[:poll_interval]) if options[:poll_interval]
+
+        runner = PipelineRunner.new(
+          config: config,
+          options: {
+            watch: options[:watch],
+            single: options[:single],
+            dry_run: options[:dry_run],
+            once: options[:once]
+          }
+        )
+
+        setup_signal_handlers(runner)
+        runner.run
+      rescue Config::ConfigNotFound => e
+        warn "Error: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def setup_signal_handlers(runner)
+        %w[INT TERM].each do |signal|
+          trap(signal) do
+            warn "\nReceived #{signal}, shutting down gracefully..."
+            runner.shutdown!
+            exit 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/status.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+require_relative '../config'
+require_relative '../worktree_manager'
+
+module Ocak
+  module Commands
+    class Status < Dry::CLI::Command
+      desc 'Show pipeline status'
+
+      def call(**)
+        config = Config.load
+
+        puts 'Pipeline Status'
+        puts '=' * 40
+        puts ''
+
+        show_issues(config)
+        puts ''
+        show_worktrees(config)
+        puts ''
+        show_recent_logs(config)
+      rescue Config::ConfigNotFound => e
+        warn "Error: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def show_issues(config)
+        puts 'Issues:'
+
+        %w[ready in_progress completed failed].each do |state|
+          label = config.send(:"label_#{state}")
+          count = fetch_issue_count(label, config)
+          icon = { 'ready' => '  ', 'in_progress' => '  ', 'completed' => '  ', 'failed' => '  ' }[state]
+          puts "  #{icon} #{state.tr('_', ' ')}: #{count} (label: #{label})"
+        end
+      end
+
+      def show_worktrees(config)
+        puts 'Worktrees:'
+        manager = WorktreeManager.new(config: config)
+        worktrees = manager.list
+
+        pipeline_wts = worktrees.select { |wt| wt[:branch]&.start_with?('auto/') }
+        if pipeline_wts.empty?
+          puts '  No active pipeline worktrees'
+        else
+          pipeline_wts.each do |wt|
+            puts "  #{wt[:branch]} -> #{wt[:path]}"
+          end
+        end
+      end
+
+      def show_recent_logs(config)
+        log_dir = File.join(config.project_dir, config.log_dir)
+        return unless Dir.exist?(log_dir)
+
+        puts 'Recent logs:'
+        logs = Dir.glob(File.join(log_dir, '*.log')).last(5)
+        if logs.empty?
+          puts '  No logs yet'
+        else
+          logs.reverse_each do |log|
+            name = File.basename(log)
+            size = File.size(log)
+            puts "  #{name} (#{format_size(size)})"
+          end
+        end
+      end
+
+      def fetch_issue_count(label, config)
+        stdout, _, status = Open3.capture3(
+          'gh', 'issue', 'list',
+          '--label', label,
+          '--state', 'open',
+          '--json', 'number',
+          '--limit', '100',
+          chdir: config.project_dir
+        )
+        return 0 unless status.success?
+
+        JSON.parse(stdout).size
+      rescue JSON::ParserError, Errno::ENOENT
+        0
+      end
+
+      def format_size(bytes)
+        if bytes < 1024
+          "#{bytes}B"
+        elsif bytes < 1024 * 1024
+          "#{(bytes / 1024.0).round(1)}KB"
+        else
+          "#{(bytes / (1024.0 * 1024)).round(1)}MB"
+        end
+      end
+    end
+  end
+end