fantasy-cli 1.2.6

data/lib/gsd/skills/bundled/debug.md

@@ -0,0 +1,28 @@
+---
+name: debug
+description: Debug an issue or error in the code
+aliases: [/dbg, /fix]
+allowed_tools: [BashTool, FileReadTool, GrepTool, FileEditTool]
+model: claude-sonnet-4-5-20250929
+---
+
+# Debug Skill
+
+When invoked, you will:
+1. Understand the error or issue
+2. Locate the source of the problem
+3. Analyze the code
+4. Propose and implement a fix
+5. Verify the fix works
+
+## User Request
+
+{{args}}
+
+## Instructions
+
+- Start by reproducing the error if possible
+- Use logs and debugging output
+- Check for common issues (null pointers, type errors, etc.)
+- Test the fix thoroughly
+- Explain what was wrong and how you fixed it

data/lib/gsd/skills/bundled/explain.md

@@ -0,0 +1,41 @@
+---
+name: explain
+description: Explain code, files, or concepts
+aliases: [/exp, /describe]
+allowed_tools: [FileReadTool, GrepTool]
+model: claude-sonnet-4-5-20250929
+---
+
+# Explain Skill
+
+When invoked, you will:
+1. Read the specified code or files
+2. Understand the functionality
+3. Explain in clear terms
+4. Provide examples if helpful
+
+## User Request
+
+{{args}}
+
+## Output Format
+
+### Overview
+Brief description of what the code does
+
+### Detailed Explanation
+Step-by-step explanation of how it works
+
+### Key Components
+- **Component 1**: Description
+- **Component 2**: Description
+
+### Examples
+Code examples or usage if applicable
+
+## Instructions
+
+- Use simple language
+- Avoid jargon when possible
+- Include code snippets for clarity
+- Highlight important patterns or gotchas

data/lib/gsd/skills/bundled/plan.md

@@ -0,0 +1,42 @@
+---
+name: plan
+description: Create an implementation plan for a feature or task
+aliases: [/planning]
+allowed_tools: [FileReadTool, FileWriteTool, GrepTool]
+model: claude-sonnet-4-5-20250929
+---
+
+# Plan Skill
+
+When invoked, you will:
+1. Understand the requirements
+2. Research the codebase
+3. Create a detailed implementation plan
+4. Break down into actionable tasks
+5. Identify risks and dependencies
+
+## User Request
+
+{{args}}
+
+## Output Format
+
+Create a plan with:
+
+### Overview
+Brief description of what will be implemented
+
+### Tasks
+- [ ] Task 1
+- [ ] Task 2
+- [ ] Task 3
+
+### Files to Change
+- `path/to/file1.rb` - Description
+- `path/to/file2.go` - Description
+
+### Risks
+- Potential issues to watch for
+
+### Testing
+- How to verify the implementation

data/lib/gsd/skills/bundled/verify.md

@@ -0,0 +1,26 @@
+---
+name: verify
+description: Verify a code change does what it should by running the app
+aliases: [/v, /check]
+allowed_tools: [BashTool, FileReadTool, GrepTool]
+model: claude-sonnet-4-5-20250929
+---
+
+# Verify Skill
+
+When invoked, you will:
+1. Read the changed files
+2. Understand the intent
+3. Run tests/verification
+4. Report results
+
+## User Request
+
+{{args}}
+
+## Instructions
+
+- Be thorough in verification
+- Run all relevant tests
+- Check for edge cases
+- Report any issues found

data/lib/gsd/skills/loader.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Gsd
+  module Skills
+    # Skills Loader - Carrega skills bundled e do usuário
+    #
+    # Responsável por:
+    # - Carregar skills bundled
+    # - Carregar skills do usuário
+    # - Parsear formato de skill markdown
+    # - Executar skills
+    class Loader
+      attr_reader :bundled_skills, :user_skills
+
+      # Inicializa o loader
+      #
+      # @param cwd [String] Diretório de trabalho
+      def initialize(cwd: Dir.pwd)
+        @cwd = cwd
+        @bundled_skills = {}
+        @user_skills = {}
+
+        load_bundled_skills
+        load_user_skills
+      end
+
+      # Retorna todas as skills (bundled + user)
+      #
+      # @return [Hash] Todas as skills
+      def all
+        @bundled_skills.merge(@user_skills)
+      end
+
+      # Busca uma skill por nome
+      #
+      # @param name [String] Nome da skill
+      # @return [Hash,nil] Skill ou nil
+      def find(name)
+        @user_skills[name] || @bundled_skills[name]
+      end
+
+      # Lista todas as skills disponíveis
+      #
+      # @return [Array<String>] Lista de nomes
+      def list
+        all.keys.sort
+      end
+
+      # Executa uma skill
+      #
+      # @param name [String] Nome da skill
+      # @param args [String] Argumentos da skill
+      # @return [String] Resultado da execução
+      def execute(name, args = '')
+        skill = find(name)
+        raise "Skill not found: #{name}" unless skill
+
+        # Skill é um hash com :prompt e :metadata
+        prompt = skill[:prompt]
+        prompt = prompt.gsub('{{args}}', args) if args && !args.empty?
+
+        prompt
+      end
+
+      # Recarrega as skills
+      #
+      # @return [void]
+      def reload
+        @bundled_skills = {}
+        @user_skills = {}
+        load_bundled_skills
+        load_user_skills
+      end
+
+      private
+
+      # Carrega skills bundled
+      #
+      # @return [void]
+      def load_bundled_skills
+        bundled_dir = File.join(__dir__, 'bundled')
+        return unless File.directory?(bundled_dir)
+
+        Dir.glob(File.join(bundled_dir, '*.md')).each do |file|
+          skill = parse_skill_file(file)
+          @bundled_skills[skill[:name]] = skill if skill
+        end
+      end
+
+      # Carrega skills do usuário
+      #
+      # @return [void]
+      def load_user_skills
+        user_dir = File.join(@cwd, '.gsd', 'skills')
+        return unless File.directory?(user_dir)
+
+        Dir.glob(File.join(user_dir, '*.md')).each do |file|
+          skill = parse_skill_file(file)
+          @user_skills[skill[:name]] = skill if skill
+        end
+      end
+
+      # Parseia um arquivo de skill
+      #
+      # @param file [String] Caminho do arquivo
+      # @return [Hash,nil] Skill parseada ou nil
+      def parse_skill_file(file)
+        content = File.read(file)
+
+        # Extrai frontmatter YAML
+        frontmatter = extract_frontmatter(content)
+        body = extract_body(content)
+
+        return nil unless frontmatter
+
+        {
+          name: frontmatter['name'] || File.basename(file, '.md'),
+          description: frontmatter['description'] || '',
+          aliases: frontmatter['aliases'] || [],
+          allowed_tools: frontmatter['allowed_tools'] || [],
+          model: frontmatter['model'],
+          prompt: body,
+          metadata: frontmatter,
+          source: file
+        }
+      end
+
+      # Extrai frontmatter YAML do conteúdo
+      #
+      # @param content [String] Conteúdo do arquivo
+      # @return [Hash,nil] Frontmatter parseado ou nil
+      def extract_frontmatter(content)
+        # Frontmatter está entre --- no início do arquivo
+        return nil unless content.start_with?("---\n")
+
+        parts = content.split(/^---$/, 3)
+        return nil if parts.length < 2
+
+        yaml_content = parts[1]
+        parse_yaml_simple(yaml_content)
+      end
+
+      # Extrai corpo do conteúdo (após frontmatter)
+      #
+      # @param content [String] Conteúdo do arquivo
+      # @return [String] Corpo do arquivo
+      def extract_body(content)
+        parts = content.split(/^---$/, 3)
+        return content if parts.length < 3
+
+        parts[2].strip
+      end
+
+      # Parse YAML simples (sem dependências externas)
+      #
+      # @param yaml [String] YAML string
+      # @return [Hash] Hash parseado
+      def parse_yaml_simple(yaml)
+        result = {}
+
+        yaml.each_line do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?('#')
+
+          if line.include?(':')
+            key, value = line.split(':', 2)
+            key = key.strip
+            value = value.strip
+
+            # Remove aspas
+            value = value[1..-2] if value.start_with?('"') && value.end_with?('"')
+            value = value[1..-2] if value.start_with?("'") && value.end_with?("'")
+
+            # Parseia array simples
+            if value.start_with?('[') && value.end_with?(']')
+              value = value[1..-2].split(',').map(&:strip)
+            end
+
+            result[key] = value
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/gsd/state.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative 'go/bridge'
+
+module Gsd
+  # State - Wrapper Ruby para operações de STATE.md via Go
+  class State
+    class << self
+      # Carrega STATE.md e retorna dados completos
+      def load(cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.state_load(cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise StateError, result['error']
+        end
+      end
+
+      # Retorna frontmatter do STATE.md como JSON
+      def json(cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.state_json(cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise StateError, result['error']
+        end
+      end
+
+      # Atualiza um campo específico no STATE.md
+      def update(field:, value:, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.state_update(field: field, value: value, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise StateError, result['error']
+        end
+      end
+
+      # Atualiza múltiplos campos no STATE.md
+      def patch(fields:, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.state_patch(fields: fields, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise StateError, result['error']
+        end
+      end
+
+      # Obtém conteúdo do STATE.md ou uma seção específica
+      def get(section: nil, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.state_get(section: section, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise StateError, result['error']
+        end
+      end
+
+      # Helper: verifica se STATE.md existe
+      def exists?(cwd: nil)
+        cwd ||= Dir.pwd
+        state_path = File.join(cwd, '.planning', 'STATE.md')
+        File.exist?(state_path)
+      end
+
+      # Helper: obtém valor de um campo específico
+      def fetch(field, cwd: nil)
+        data = json(cwd: cwd)
+        data[field]
+      end
+
+      # Helper: atualiza progresso automaticamente
+      def update_progress(plans_of:, plans_total:, cwd: nil)
+        progress = calculate_progress(plans_of, plans_total)
+        update(field: 'plans_of', value: plans_of.to_s, cwd: cwd)
+        update(field: 'plans_total', value: plans_total.to_s, cwd: cwd)
+        update(field: 'progress', value: progress, cwd: cwd)
+      end
+
+      private
+
+      def calculate_progress(of, total)
+        return '0%' if total.nil? || total.to_i == 0
+        
+        percentage = (of.to_f / total.to_i * 100).round
+        "#{percentage}%"
+      end
+    end
+
+    class StateError < StandardError; end
+  end
+end

data/lib/gsd/template.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative 'go/bridge'
+
+module Gsd
+  # Template - Wrapper Ruby para operações de template filling via Go
+  module Template
+    class << self
+      # Preenche template de SUMMARY.md
+      #
+      # @param phase [String] Número da phase
+      # @param plan [String] Número do plan
+      # @param name [String] Nome do summary
+      # @param fields [Hash] Campos adicionais
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado do preenchimento
+      def fill_summary(phase:, plan:, name:, fields: {}, cwd: nil)
+        cwd ||= Dir.pwd
+        args = build_template_args('summary', phase, plan, name, fields)
+        result = Go::Bridge.call('template', args, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise TemplateError, result['error']
+        end
+      end
+
+      # Preenche template de PLAN.md
+      #
+      # @param phase [String] Número da phase
+      # @param plan [String] Número do plan
+      # @param type [String] Tipo do plan (execute, tdd)
+      # @param wave [String] Número da wave
+      # @param fields [Hash] Campos adicionais
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado do preenchimento
+      def fill_plan(phase:, plan:, type: 'execute', wave: '1', fields: {}, cwd: nil)
+        cwd ||= Dir.pwd
+        args = build_template_args('plan', phase, plan, nil, fields)
+        args['type'] = type
+        args['wave'] = wave
+        result = Go::Bridge.call('template', args, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise TemplateError, result['error']
+        end
+      end
+
+      # Preenche template de VERIFICATION.md
+      #
+      # @param phase [String] Número da phase
+      # @param fields [Hash] Campos adicionais
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado do preenchimento
+      def fill_verification(phase:, fields: {}, cwd: nil)
+        cwd ||= Dir.pwd
+        args = { 'fill' => 'verification', 'phase' => phase }
+        fields.each { |k, v| args[k.to_s] = v.to_s }
+        result = Go::Bridge.call('template', args, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise TemplateError, result['error']
+        end
+      end
+
+      # Preenche template de CONTEXT.md
+      #
+      # @param phase [String] Número da phase
+      # @param fields [Hash] Campos adicionais
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado do preenchimento
+      def fill_context(phase:, fields: {}, cwd: nil)
+        cwd ||= Dir.pwd
+        args = { 'fill' => 'context', 'phase' => phase }
+        fields.each { |k, v| args[k.to_s] = v.to_s }
+        result = Go::Bridge.call('template', args, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise TemplateError, result['error']
+        end
+      end
+
+      private
+
+      def build_template_args(template_type, phase, plan, name, fields)
+        args = {
+          'fill' => template_type,
+          'phase' => phase,
+          'plan' => plan
+        }
+        args['name'] = name if name
+        fields.each { |k, v| args[k.to_s] = v.to_s }
+        args
+      end
+    end
+
+    class TemplateError < StandardError; end
+  end
+end