fantasy-cli 1.2.6

data/lib/gsd/cli.rb

@@ -0,0 +1,455 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+require_relative 'go/bridge'
+require_relative 'state'
+require_relative 'phase'
+require_relative 'roadmap'
+require_relative 'ai/cli'
+require_relative 'tui/app'
+
+module Gsd
+  # CLI parser e dispatcher principal
+  class CLI
+    def initialize(args = [])
+      @args = args
+      @command = args.first
+    end
+
+    def run
+      case @command
+      when nil, 'help', '--help', '-h'
+        print_help
+        0
+      when 'version', '--version', '-v'
+        print_version
+        0
+      when 'hello'
+        run_hello
+      when 'ai'
+        run_ai(@args[1..])
+      when 'tui'
+        run_tui(@args[1..])
+      when 'state'
+        run_state(@args[1..])
+      when 'phase'
+        run_phase(@args[1..])
+      when 'roadmap'
+        run_roadmap(@args[1..])
+      else
+        warn "Unknown command: #{@command}"
+        print_help
+        1
+      end
+    end
+
+    private
+
+    # ========================================================================
+    # Hello Command
+    # ========================================================================
+
+    def run_hello
+      result = Go::Bridge.call('hello', parse_named_args(@args[1..]))
+      output_json(result)
+      0
+    rescue => e
+      warn "Error: #{e.message}"
+      1
+    end
+
+    # ========================================================================
+    # AI Command
+    # ========================================================================
+
+    def run_ai(args)
+      ai_cli = Gsd::AI::CLI.new(args, cwd: parse_cwd(args))
+      ai_cli.run
+      0
+    rescue => e
+      warn "Error: #{e.message}"
+      1
+    end
+
+    # ========================================================================
+    # TUI Command
+    # ========================================================================
+
+    def run_tui(args)
+      theme = :fantasy
+      header_style = :pixel
+
+      args.each do |arg|
+        case arg
+        when '--theme=kilo'
+          theme = :kilo
+        when '--theme=dark'
+          theme = :dark
+        when '--theme=light'
+          theme = :light
+        when '--no-header'
+          header_style = :simple
+        end
+      end
+
+      tui_app = Gsd::TUI::App.new(theme: theme, header_style: header_style)
+      tui_app.run
+      0
+    rescue => e
+      warn "Error: #{e.message}"
+      1
+    end
+
+    # ========================================================================
+    # State Commands
+    # ========================================================================
+
+    def run_state(args)
+      args = args.compact.reject { |a| a.nil? }
+      subcommand = args.shift
+      cwd = parse_cwd(args)
+
+      case subcommand
+      when 'load'
+        cmd_state_load(cwd)
+      when 'json'
+        cmd_state_json(cwd)
+      when 'update'
+        cmd_state_update(args, cwd)
+      when 'patch'
+        cmd_state_patch(args, cwd)
+      when 'get'
+        cmd_state_get(args, cwd)
+      when nil
+        warn "Usage: gsd state <subcommand> [options]"
+        warn "Subcommands: load, json, update, patch, get"
+        1
+      else
+        warn "Unknown state subcommand: #{subcommand}"
+        warn "Available: load, json, update, patch, get"
+        1
+      end
+    end
+
+    def cmd_state_load(cwd)
+      result = Gsd::State.load(cwd: cwd)
+      output_json({ 'success' => true, 'data' => result })
+      0
+    rescue => e
+      output_error("Failed to load state: #{e.message}")
+      1
+    end
+
+    def cmd_state_json(cwd)
+      result = Gsd::State.json(cwd: cwd)
+      output_json({ 'success' => true, 'data' => result })
+      0
+    rescue => e
+      output_error("Failed to get state JSON: #{e.message}")
+      1
+    end
+
+    def cmd_state_update(args, cwd)
+      field = parse_named_arg(args, 'field')
+      value = parse_named_arg(args, 'value')
+
+      unless field && value
+        output_error("field and value are required. Usage: gsd state update --field X --value Y")
+        return 1
+      end
+
+      result = Gsd::State.update(field: field, value: value, cwd: cwd)
+      output_json({ 'success' => true, 'data' => result })
+      0
+    rescue => e
+      output_error("Failed to update state: #{e.message}")
+      1
+    end
+
+    def cmd_state_patch(args, cwd)
+      fields = parse_patch_args(args)
+
+      if fields.empty?
+        output_error("At least one field is required. Usage: gsd state patch --field1 val1 --field2 val2")
+        return 1
+      end
+
+      result = Gsd::State.patch(fields: fields, cwd: cwd)
+      output_json({ 'success' => true, 'data' => result })
+      0
+    rescue => e
+      output_error("Failed to patch state: #{e.message}")
+      1
+    end
+
+    def cmd_state_get(args, cwd)
+      section = args.first
+      result = Gsd::State.get(section: section, cwd: cwd)
+      output_json({ 'success' => true, 'data' => result })
+      0
+    rescue => e
+      output_error("Failed to get state: #{e.message}")
+      1
+    end
+
+    # ========================================================================
+    # Phase Commands
+    # ========================================================================
+
+    def run_phase(args)
+      subcommand = args.shift
+      cwd = parse_cwd(args)
+
+      case subcommand
+      when 'find'
+        cmd_phase_find(args.first, cwd)
+      when 'list'
+        cmd_phase_list(cwd)
+      when 'next-decimal'
+        cmd_phase_next_decimal(args.first, cwd)
+      when 'add'
+        cmd_phase_add(args, cwd)
+      when nil
+        warn "Usage: gsd phase <subcommand> [options]"
+        warn "Subcommands: find, list, next-decimal, add"
+        1
+      else
+        warn "Unknown phase subcommand: #{subcommand}"
+        warn "Available: find, list, next-decimal, add"
+        1
+      end
+    end
+
+    def cmd_phase_find(phase_num, cwd)
+      unless phase_num
+        output_error("phase number is required. Usage: gsd phase find <phase>")
+        return 1
+      end
+
+      result = Gsd::Phase.find(phase_num, cwd: cwd)
+      output_json({ 'success' => true, 'data' => result })
+      0
+    rescue => e
+      output_error("Failed to find phase: #{e.message}")
+      1
+    end
+
+    def cmd_phase_list(cwd)
+      result = Gsd::Phase.list(cwd: cwd)
+      output_json({ 'success' => true, 'data' => result })
+      0
+    rescue => e
+      output_error("Failed to list phases: #{e.message}")
+      1
+    end
+
+    def cmd_phase_next_decimal(phase_num, cwd)
+      unless phase_num
+        output_error("phase number is required. Usage: gsd phase next-decimal <phase>")
+        return 1
+      end
+
+      result = Gsd::Phase.next_decimal(phase_num, cwd: cwd)
+      output_json({ 'success' => true, 'data' => result })
+      0
+    rescue => e
+      output_error("Failed to calculate next decimal: #{e.message}")
+      1
+    end
+
+    def cmd_phase_add(args, cwd)
+      # Join all remaining args as description (handles multi-word descriptions)
+      description = args.join(' ').strip
+
+      unless description && !description.empty?
+        output_error("description is required. Usage: gsd phase add <description>")
+        return 1
+      end
+
+      result = Gsd::Phase.add(description, cwd: cwd)
+      output_json({ 'success' => true, 'data' => result })
+      0
+    rescue => e
+      output_error("Failed to add phase: #{e.message}")
+      1
+    end
+
+    # ========================================================================
+    # Roadmap Commands
+    # ========================================================================
+
+    def run_roadmap(args)
+      subcommand = args.shift
+      cwd = parse_cwd(args)
+
+      case subcommand
+      when 'get-phase'
+        cmd_roadmap_get_phase(args.first, cwd)
+      when 'analyze'
+        cmd_roadmap_analyze(cwd)
+      when nil
+        warn "Usage: gsd roadmap <subcommand> [options]"
+        warn "Subcommands: get-phase, analyze"
+        1
+      else
+        warn "Unknown roadmap subcommand: #{subcommand}"
+        warn "Available: get-phase, analyze"
+        1
+      end
+    end
+
+    def cmd_roadmap_get_phase(phase_num, cwd)
+      unless phase_num
+        output_error("phase number is required. Usage: gsd roadmap get-phase <phase>")
+        return 1
+      end
+
+      result = Gsd::Roadmap.get_phase(phase_num, cwd: cwd)
+      output_json({ 'success' => true, 'data' => result })
+      0
+    rescue => e
+      output_error("Failed to get phase from roadmap: #{e.message}")
+      1
+    end
+
+    def cmd_roadmap_analyze(cwd)
+      result = Gsd::Roadmap.analyze(cwd: cwd)
+      output_json({ 'success' => true, 'data' => result })
+      0
+    rescue => e
+      output_error("Failed to analyze roadmap: #{e.message}")
+      1
+    end
+
+    # ========================================================================
+    # Helpers
+    # ========================================================================
+
+    def parse_named_arg(args, name)
+      prefix = "--#{name}="
+      args.each do |arg|
+        if arg.start_with?(prefix)
+          return arg[prefix.length..]
+        end
+      end
+      nil
+    end
+
+    def parse_named_args(args)
+      result = {}
+      return result if args.nil? || args.empty?
+      
+      args.each do |arg|
+        next unless arg.is_a?(String) && arg.start_with?('--')
+        key, value = arg[2..].split('=', 2)
+        result[key] = value || true
+      end
+      result
+    end
+
+    def parse_patch_args(args)
+      fields = {}
+      i = 0
+      while i < args.length
+        if args[i].start_with?('--') && i + 1 < args.length && !args[i + 1].start_with?('--')
+          key = args[i][2..]
+          value = args[i + 1]
+          fields[key] = value
+          i += 2
+        else
+          i += 1
+        end
+      end
+      fields
+    end
+
+    def parse_cwd(args)
+      cwd = parse_named_arg(args, 'cwd')
+      cwd || Dir.pwd
+    end
+
+    def output_json(data)
+      puts JSON.pretty_generate(data)
+    end
+
+    def output_error(message)
+      puts JSON.pretty_generate({
+        'success' => false,
+        'error' => message
+      })
+    end
+
+    def print_help
+      puts <<~HELP
+        fantasy-cli v#{VERSION} - Fantasy CLI (Ruby + Go)
+
+        Usage:
+          gsd <command> [options]
+
+        Commands:
+          hello              Print greeting from Go
+          ai                 AI Chat Interface (REPL + one-shot)
+          tui                Terminal User Interface (TUI)
+          version            Print version information
+          state              State operations
+          phase              Phase operations
+          roadmap            Roadmap operations
+          help               Show this help message
+
+        AI Subcommands:
+          gsd ai                           # Inicia REPL interativo
+          gsd ai "mensagem"                # One-shot command
+          gsd ai --provider <name>         Provider: anthropic, openai, ollama
+          gsd ai --model <name>            Modelo do LLM
+          gsd ai --debug                   Habilita modo debug
+
+        TUI Options:
+          gsd tui                          # Launch TUI
+          gsd tui --theme=kilo             # Kilo theme (yellow/black)
+          gsd tui --theme=dark             # Dark theme
+          gsd tui --theme=light            # Light theme
+          gsd tui --no-header              # Without header
+
+        State Subcommands:
+          load               Load STATE.md
+          json               Output STATE.md frontmatter as JSON
+          update             Update a STATE.md field (--field, --value)
+          patch              Batch update STATE.md fields
+          get [section]      Get STATE.md content or section
+
+        Phase Subcommands:
+          find <phase>       Find phase directory
+          list               List all phases
+          next-decimal <n>   Calculate next decimal phase
+          add <description>  Add new phase
+
+        Roadmap Subcommands:
+          get-phase <phase>  Extract phase section from ROADMAP.md
+          analyze            Full roadmap analysis
+
+        Options:
+          --cwd=<path>       Working directory (default: current)
+          --field=<name>     Field name (for state update)
+          --value=<val>      Field value (for state update)
+
+        Examples:
+          gsd hello
+          gsd hello --name=World
+          gsd version
+          gsd state json --cwd /path/to/project
+          gsd state update --field current_phase --value 2
+          gsd phase find 1
+          gsd phase next-decimal 1
+          gsd roadmap get-phase 1
+          gsd roadmap analyze
+
+        For more information, see README.md
+      HELP
+    end
+
+    def print_version
+      puts "gsd v#{VERSION} (Ruby + Go)"
+      puts "gsd-core v#{Go::Bridge.core_version}"
+    end
+  end
+end

data/lib/gsd/commands.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'date'
+
+module Gsd
+  # Commands atômicos do GSD
+  module Commands
+    class << self
+      # Git commit wrapper
+      #
+      # @param message [String] Commit message
+      # @param files [Array<String>] Files to commit
+      # @param cwd [String] Working directory
+      # @param no_verify [Boolean] Skip pre-commit hooks
+      # @return [Hash] Result with success status and message/error
+      def commit(message, files: [], cwd: nil, no_verify: false)
+        cwd ||= Dir.pwd
+        cmd = ['git', 'commit', '-m', message]
+        cmd << '--no-verify' if no_verify
+        cmd << '--'
+        cmd += files unless files.empty?
+
+        stdout, stderr, status = Open3.capture3(*cmd, chdir: cwd)
+
+        if status.success?
+          { success: true, message: stdout.strip }
+        else
+          { success: false, error: stderr.strip }
+        end
+      end
+
+      # Generate URL-safe slug from text
+      #
+      # @param text [String] Text to convert to slug
+      # @return [String] URL-safe slug
+      def generate_slug(text)
+        text
+          .downcase
+          .gsub(/[^\w\s-]/, '')
+          .gsub(/\s+/, '-')
+          .gsub(/-+/, '-')
+          .strip('-')
+      end
+
+      # Get current timestamp in various formats
+      #
+      # @param format [String] Format type: 'full', 'date', 'filename'
+      # @return [String] Timestamp string
+      def current_timestamp(format = 'full')
+        case format
+        when 'date'
+          Date.today.to_s
+        when 'filename'
+          Time.now.strftime('%Y%m%d%H%M%S')
+        else
+          Time.now.iso8601
+        end
+      end
+
+      # Verify if a path exists
+      #
+      # @param path [String] Path to verify
+      # @return [Hash] Result with exists status and path
+      def verify_path_exists(path)
+        if File.exist?(path)
+          { exists: true, path: path }
+        else
+          { exists: false, path: path, error: "Path not found: #{path}" }
+        end
+      end
+
+      # List pending todos
+      #
+      # @param area [String] Optional area filter
+      # @param cwd [String] Working directory
+      # @return [Hash] Result with count and todo list
+      def list_todos(area = nil, cwd: nil)
+        cwd ||= Dir.pwd
+        todos_dir = File.join(cwd, '.planning', 'todos')
+        return { count: 0, todos: [] } unless File.directory?(todos_dir)
+
+        pending_dir = File.join(todos_dir, 'pending')
+        return { count: 0, todos: [] } unless File.directory?(pending_dir)
+
+        files = Dir.glob('*.md', base: pending_dir)
+        files = files.select { |f| f.start_with?(area) } if area
+
+        {
+          count: files.length,
+          todos: files.map { |f| f.gsub('.md', '') }
+        }
+      end
+
+      # Complete a todo (move from pending to completed)
+      #
+      # @param filename [String] Todo filename (without .md)
+      # @param cwd [String] Working directory
+      # @return [Hash] Result with success status
+      def todo_complete(filename, cwd: nil)
+        cwd ||= Dir.pwd
+        todos_dir = File.join(cwd, '.planning', 'todos')
+        pending_dir = File.join(todos_dir, 'pending')
+        completed_dir = File.join(todos_dir, 'completed')
+
+        pending_file = File.join(pending_dir, "#{filename}.md")
+        completed_file = File.join(completed_dir, "#{filename}.md")
+
+        unless File.exist?(pending_file)
+          return { success: false, error: "Todo not found: #{filename}" }
+        end
+
+        FileUtils.mkdir_p(completed_dir) unless File.directory?(completed_dir)
+        FileUtils.mv(pending_file, completed_file)
+
+        { success: true, message: "Todo completed: #{filename}" }
+      end
+
+      # Generate a unique slug with timestamp
+      #
+      # @param text [String] Base text for slug
+      # @return [String] Unique slug with timestamp
+      def generate_unique_slug(text)
+        base_slug = generate_slug(text)
+        timestamp = Time.now.strftime('%Y%m%d%H%M%S')
+        "#{base_slug}-#{timestamp}"
+      end
+
+      # Verify if a file has valid frontmatter
+      #
+      # @param path [String] File path to check
+      # @return [Hash] Result with valid status and frontmatter if present
+      def has_frontmatter?(path)
+        return { valid: false, error: 'File not found' } unless File.exist?(path)
+
+        content = File.read(path)
+        return { valid: false, error: 'Empty file' } if content.empty?
+
+        unless content.start_with?('---')
+          return { valid: false, frontmatter: nil }
+        end
+
+        lines = content.split("\n")
+        end_index = lines[1..-1]&.index { |line| line.strip == '---' }
+
+        if end_index
+          frontmatter_lines = lines[1..end_index]
+          frontmatter = {}
+          frontmatter_lines.each do |line|
+            key, value = line.split(':', 2)
+            if key && value
+              frontmatter[key.strip] = value.strip.gsub(/["']/, '')
+            end
+          end
+          { valid: true, frontmatter: frontmatter }
+        else
+          { valid: false, error: 'Unclosed frontmatter' }
+        end
+      end
+
+      # Extract text from markdown file (skip frontmatter)
+      #
+      # @param path [String] File path
+      # @return [Hash] Result with content or error
+      def extract_markdown_content(path)
+        return { error: 'File not found' } unless File.exist?(path)
+
+        content = File.read(path)
+
+        # Skip frontmatter if present
+        if content.start_with?('---')
+          lines = content.split("\n")
+          end_index = lines[1..-1]&.index { |line| line.strip == '---' }
+          if end_index
+            content = lines[end_index + 2..-1]&.join("\n") || ''
+          end
+        end
+
+        { content: content.strip }
+      end
+
+      # Count lines in file
+      #
+      # @param path [String] File path
+      # @return [Hash] Result with line count
+      def count_lines(path)
+        return { error: 'File not found' } unless File.exist?(path)
+
+        lines = File.readlines(path)
+        {
+          total: lines.length,
+          non_empty: lines.count { |l| !l.strip.empty? },
+          code: lines.count { |l| !l.strip.empty? && !l.strip.start_with?('#') }
+        }
+      end
+    end
+  end
+end