fantasy-cli 1.2.10 → 1.2.11

data/lib/gsd/api/server.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require 'webrick'
+require 'json'
+require_relative 'routes/health'
+require_relative 'routes/state'
+require_relative 'routes/phases'
+require_relative 'routes/roadmap'
+require_relative '../ai/chat'
+
+module Gsd
+  module API
+    # Custom HTTP servlet that supports PATCH and all REST methods
+    class APIServlet < WEBrick::HTTPServlet::AbstractServlet
+      def initialize(server, *options)
+        super(server)
+        @cwd = options.is_a?(Array) && options[0].is_a?(Hash) ? options[0][:cwd] : Dir.pwd
+      end
+
+      def do_GET(req, res)
+        route(req, res)
+      end
+
+      def do_POST(req, res)
+        route(req, res)
+      end
+
+      def do_PUT(req, res)
+        route(req, res)
+      end
+
+      def do_PATCH(req, res)
+        route(req, res)
+      end
+
+      def do_OPTIONS(req, res)
+        set_cors_headers(res)
+        res.status = 204
+        res.body = ''
+      end
+
+      def do_DELETE(req, res)
+        set_cors_headers(res)
+        res.status = 405
+        res.body = JSON.generate({ error: 'Method not allowed' })
+      end
+
+      private
+
+      def route(req, res)
+        set_cors_headers(res)
+
+        path = req.path_info
+        method = req.request_method
+
+        case path
+        when '/health', '/health/'
+          handle(req, res) { Routes::Health.check(cwd: @cwd) }
+
+        when '/state', '/state/'
+          route_state(method, req, res)
+
+        when '/phases', '/phases/'
+          route_phases(method, req, res)
+
+        when '/roadmap', '/roadmap/'
+          handle(req, res) do
+            if Gsd::Roadmap.exists?(cwd: @cwd)
+              Routes::Roadmap.analyze(@cwd)
+            else
+              JSON.pretty_generate({
+                success: true,
+                data: {
+                  message: 'No ROADMAP.md found in this directory',
+                  phases: [],
+                  total_phases: 0
+                }
+              })
+            end
+          end
+
+        when '/ai/chat', '/ai/chat/'
+          route_ai_chat(method, req, res)
+
+        when '/ai/models', '/ai/models/'
+          route_ai_models(method, req, res)
+
+        when '/ai/cost', '/ai/cost/'
+          route_ai_cost(method, req, res)
+
+        else
+          if path.start_with?('/state/')
+            section = path.sub('/state/', '')
+            handle(req, res) { Routes::State.get_section(section, @cwd) }
+          elsif path.start_with?('/phases/')
+            num = path.sub('/phases/', '')
+            handle(req, res) { Routes::Phases.find(num, @cwd) }
+          else
+            res.status = 404
+            res.body = JSON.generate({
+              error: 'Not found',
+              path: req.path,
+              available_endpoints: [
+                'GET    /api/health',
+                'GET    /api/state',
+                'GET    /api/state/:section',
+                'PATCH  /api/state',
+                'PUT    /api/state',
+                'GET    /api/phases',
+                'GET    /api/phases/:num',
+                'POST   /api/phases',
+                'GET    /api/roadmap',
+                'POST   /api/ai/chat',
+                'GET    /api/ai/models',
+                'GET    /api/ai/cost'
+              ]
+            })
+          end
+        end
+      end
+
+      def route_state(method, req, res)
+        case method
+        when 'GET'
+          handle(req, res) { Routes::State.json(@cwd) }
+        when 'PATCH'
+          handle(req, res) do
+            body = parse_json_body(req)
+            Routes::State.patch(body['fields'], @cwd)
+          end
+        when 'PUT'
+          handle(req, res) do
+            body = parse_json_body(req)
+            Routes::State.update(body['field'], body['value'], @cwd)
+          end
+        else
+          res.status = 405
+          res.body = JSON.generate({ error: 'Method not allowed for /api/state' })
+        end
+      end
+
+      def route_phases(method, req, res)
+        case method
+        when 'GET'
+          handle(req, res) { Routes::Phases.list(@cwd) }
+        when 'POST'
+          handle(req, res) do
+            body = parse_json_body(req)
+            Routes::Phases.add(body['description'], @cwd)
+          end
+        else
+          res.status = 405
+          res.body = JSON.generate({ error: 'Method not allowed for /api/phases' })
+        end
+      end
+
+      def route_ai_chat(method, req, res)
+        if method == 'POST'
+          handle(req, res) do
+            body = parse_json_body(req)
+            message = body['message']
+            raise ArgumentError, "message is required" unless message && !message.to_s.strip.empty?
+
+            provider = (body['provider'] || 'anthropic').to_sym
+            model = body['model']
+
+            chat = Gsd::AI::Chat.new(provider: provider, model: model, cwd: @cwd)
+            response = chat.send(message, stream: false)
+
+            JSON.pretty_generate({
+              success: true,
+              data: { response: response }
+            })
+          end
+        else
+          res.status = 405
+          res.body = JSON.generate({ error: 'Method not allowed for /api/ai/chat' })
+        end
+      end
+
+      def route_ai_models(method, req, res)
+        if method == 'GET'
+          handle(req, res) do
+            JSON.pretty_generate({
+              success: true,
+              data: {
+                providers: ['anthropic', 'openai', 'openrouter', 'ollama', 'lmstudio']
+              }
+            })
+          end
+        else
+          res.status = 405
+          res.body = JSON.generate({ error: 'Method not allowed for /api/ai/models' })
+        end
+      end
+
+      def route_ai_cost(method, req, res)
+        if method == 'GET'
+          handle(req, res) do
+            persist_dir = File.join(@cwd, '.gsd', 'ai')
+            tracker = Gsd::AI::CostTracker.new(budget: 100.0, persist_dir: persist_dir)
+            JSON.pretty_generate({
+              success: true,
+              data: tracker.stats
+            })
+          end
+        else
+          res.status = 405
+          res.body = JSON.generate({ error: 'Method not allowed for /api/ai/cost' })
+        end
+      end
+
+      def handle(req, res)
+        body = yield
+        res.status = 200
+        res.body = body
+      rescue Gsd::State::StateError, Gsd::Roadmap::RoadmapError, Gsd::Phase::PhaseError => e
+        res.status = 404
+        res.body = JSON.generate({ error: e.message })
+      rescue ArgumentError => e
+        res.status = 400
+        res.body = JSON.generate({ error: e.message })
+      rescue => e
+        res.status = 500
+        res.body = JSON.generate({ error: "Internal server error: #{e.message}" })
+      end
+
+      def set_cors_headers(res)
+        res['Content-Type'] = 'application/json'
+        res['Access-Control-Allow-Origin'] = '*'
+        res['Access-Control-Allow-Methods'] = 'GET, POST, PUT, PATCH, DELETE, OPTIONS'
+        res['Access-Control-Allow-Headers'] = 'Content-Type, Authorization, X-HTTP-Method-Override'
+        res['Access-Control-Max-Age'] = '86400'
+      end
+
+      def parse_json_body(req)
+        return {} unless req.body && !req.body.empty?
+
+        JSON.parse(req.body)
+      rescue JSON::ParserError => e
+        raise ArgumentError, "Invalid JSON body: #{e.message}"
+      end
+    end
+
+    # API Server - WEBrick HTTP server exposing CLI functionality via REST API
+    class Server
+      def initialize(cwd: nil)
+        @cwd = cwd || Dir.pwd
+      end
+
+      # Start the server with given host and port
+      #
+      # @param host [String] Host to bind to
+      # @param port [Integer] Port to listen on
+      def start(host: '127.0.0.1', port: 3000)
+        puts "🚀 Fantasy API Server starting..."
+        puts "📍 Listening on http://#{host}:#{port}"
+        puts "📂 Working directory: #{@cwd}"
+        puts "🌐 Dashboard available at: http://#{host}:#{port}/"
+        puts "🔗 Available endpoints:"
+        puts "   GET    /api/health"
+        puts "   GET    /api/state"
+        puts "   GET    /api/state/:section"
+        puts "   PATCH  /api/state"
+        puts "   PUT    /api/state"
+        puts "   GET    /api/phases"
+        puts "   GET    /api/phases/:num"
+        puts "   POST   /api/phases"
+        puts "   GET    /api/roadmap"
+        puts "   POST   /api/ai/chat"
+        puts "   GET    /api/ai/models"
+        puts "   GET    /api/ai/cost"
+        puts ""
+        puts "Press Ctrl+C to stop"
+
+        server = WEBrick::HTTPServer.new(
+          Port: port,
+          BindAddress: host,
+          AccessLog: [],
+          Logger: WEBrick::Log.new($stdout, WEBrick::Log::WARN)
+        )
+
+        # Mount public directory for static files (Web Dashboard)
+        public_dir = File.expand_path('public', __dir__)
+        server.mount('/', WEBrick::HTTPServlet::FileHandler, public_dir)
+
+        # Mount custom servlet to handle all API routes with full HTTP method support
+        server.mount('/api', APIServlet, cwd: @cwd)
+
+        # Handle graceful shutdown
+        trap('INT') do
+          puts "\n👋 Shutting down API server..."
+          server.shutdown
+        end
+
+        server.start
+      end
+    end
+  end
+end

data/lib/gsd/api.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'api/server'
+require_relative 'api/client'
+
+module Gsd
+  # API module - Exposes CLI functionality via HTTP REST API
+  module API
+    class << self
+      # Returns an API client instance
+      #
+      # @param host [String] API server host (default: '127.0.0.1')
+      # @param port [Integer] API server port (default: 3000)
+      # @return [Gsd::API::Client]
+      def client(host: '127.0.0.1', port: 3000)
+        Gsd::API::Client.new(host: host, port: port)
+      end
+
+      # Starts the API server
+      #
+      # @param host [String] Host to bind to (default: '127.0.0.1')
+      # @param port [Integer] Port to listen on (default: 3000)
+      # @param cwd [String] Working directory for API operations
+      # @return [void]
+      def serve(host: '127.0.0.1', port: 3000, cwd: nil)
+        cwd ||= Dir.pwd
+        server = Gsd::API::Server.new(cwd: cwd)
+        server.start(host: host, port: port)
+      end
+    end
+  end
+end

data/lib/gsd/cli.rb

@@ -7,13 +7,29 @@ require_relative 'phase'
 require_relative 'roadmap'
 require_relative 'ai/cli'
 require_relative 'tui/app'
+require_relative 'api'
 
 module Gsd
   # CLI parser e dispatcher principal
   class CLI
     def initialize(args = [])
-      @args = args
-      @command = args.first
+      @args = normalize_args(args)
+      @command = @args.first
+    end
+
+    def normalize_args(args)
+      normalized = []
+      i = 0
+      while i < args.length
+        if %w[--port --host --body].include?(args[i]) && i + 1 < args.length && !args[i+1].start_with?('--')
+          normalized << "#{args[i]}=#{args[i+1]}"
+          i += 2
+        else
+          normalized << args[i]
+          i += 1
+        end
+      end
+      normalized
     end
 
     def run
@@ -36,6 +52,8 @@ module Gsd
         run_phase(@args[1..])
       when 'roadmap'
         run_roadmap(@args[1..])
+      when 'api'
+        run_api(@args[1..]) || 0
       else
         warn "Unknown command: #{@command}"
         print_help
@@ -321,6 +339,97 @@ module Gsd
       1
     end
 
+    # ========================================================================
+    # API Commands
+    # ========================================================================
+
+    def run_api(args)
+      subcommand = args.shift
+
+      case subcommand
+      when 'serve', nil
+        cmd_api_serve(args)
+      when 'status'
+        cmd_api_status(args)
+      when 'call'
+        cmd_api_call(args)
+      else
+        warn "Unknown api subcommand: #{subcommand}"
+        warn "Available: serve, status, call"
+        1
+      end
+    rescue => e
+      warn "Error: #{e.message}"
+      1
+    end
+
+    def cmd_api_serve(args)
+      host = '127.0.0.1'
+      port = 3000
+
+      args.each do |arg|
+        case arg
+        when /^--host=(.+)$/
+          host = Regexp.last_match(1)
+        when /^--port=(\d+)$/
+          port = Regexp.last_match(1).to_i
+        end
+      end
+
+      Gsd::API.serve(host: host, port: port, cwd: Dir.pwd)
+    end
+
+    def cmd_api_status(args)
+      host = parse_named_arg(args, 'host') || '127.0.0.1'
+      port = (parse_named_arg(args, 'port') || 3000).to_i
+
+      client = Gsd::API.client(host: host, port: port)
+      result = client.status
+
+      puts "✅ API Server is running on http://#{host}:#{port}"
+      if result.is_a?(Hash)
+        result.each do |k, v|
+          puts "  #{k}: #{v}" unless v.is_a?(Hash) || v.is_a?(Array)
+        end
+      end
+      0
+    rescue => e
+      puts "❌ API Server is not reachable: #{e.message}"
+      1
+    end
+
+    def cmd_api_call(args)
+      method = args.shift
+      path = args.shift
+
+      unless method && path
+        output_error("method and path are required. Usage: gsd api call <METHOD> <PATH>")
+        return 1
+      end
+
+      host = parse_named_arg(args, 'host') || '127.0.0.1'
+      port = (parse_named_arg(args, 'port') || 3000).to_i
+      body_str = parse_named_arg(args, 'body')
+
+      body = nil
+      if body_str
+        begin
+          body = JSON.parse(body_str)
+        rescue JSON::ParserError
+          body = body_str
+        end
+      end
+
+      client = Gsd::API.client(host: host, port: port)
+      result = client.call(method, path, body: body)
+
+      output_json(result)
+      0
+    rescue => e
+      output_error("API call failed: #{e.message}")
+      1
+    end
+
     # ========================================================================
     # Helpers
     # ========================================================================
@@ -338,7 +447,7 @@ module Gsd
     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)
@@ -390,6 +499,7 @@ module Gsd
           hello              Print greeting from Go
           ai                 AI Chat Interface (REPL + one-shot)
           tui                Terminal User Interface (TUI)
+          api                API Server (HTTP REST interface)
           version            Print version information
           state              State operations
           phase              Phase operations
@@ -427,6 +537,13 @@ module Gsd
           get-phase <phase>  Extract phase section from ROADMAP.md
           analyze            Full roadmap analysis
 
+        API Subcommands:
+          serve              Start API HTTP server
+          serve --port 3000  Custom port (default: 3000)
+          serve --host 0.0.0.0  Bind address (default: 127.0.0.1)
+          status             Check API server status
+          call <METH> <PATH> Call API endpoint (e.g., call GET /api/state)
+
         Options:
           --cwd=<path>       Working directory (default: current)
           --field=<name>     Field name (for state update)
@@ -442,6 +559,10 @@ module Gsd
           gsd phase next-decimal 1
           gsd roadmap get-phase 1
           gsd roadmap analyze
+          gsd api serve
+          gsd api serve --port 8080
+          gsd api status
+          gsd api call GET /api/state
 
         For more information, see README.md
       HELP

data/lib/gsd/tui/app.rb

@@ -33,6 +33,9 @@ module Gsd
         @output = []
         @frame_count = 0
         @render_count = 0
+
+        # Initialize status bar with current agent mode
+        update_status_mode
       end
 
       def run
@@ -349,6 +352,27 @@ module Gsd
           end
         else
           @selected_agent = (@selected_agent + 1) % @agents.length
+          update_status_mode
+        end
+      end
+
+      # Map selected agent to mode and update status bar
+      def update_status_mode
+        mode = agent_to_mode(@agents[@selected_agent])
+        @status_bar.update_mode(mode)
+      end
+
+      # Map agent name to mode
+      def agent_to_mode(agent)
+        case agent
+        when 'Code'
+          'CODE'
+        when 'Kilo Auto Free'
+          'PLAN'
+        when 'Kilo Gateway'
+          'DEBUG'
+        else
+          'NORMAL'
         end
       end
 

data/lib/gsd/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gsd
-  VERSION = '1.2.10'
+  VERSION = '1.2.11'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fantasy-cli
 version: !ruby/object:Gem::Version
-  version: 1.2.10
+  version: 1.2.11
 platform: ruby
 authors:
 - Fantasy Team
@@ -37,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -129,6 +143,17 @@ files:
 - lib/gsd/ai/repl.rb
 - lib/gsd/ai/streaming.rb
 - lib/gsd/ai/ui.rb
+- lib/gsd/api.rb
+- lib/gsd/api/client.rb
+- lib/gsd/api/middleware/cors.rb
+- lib/gsd/api/public/app.js
+- lib/gsd/api/public/index.html
+- lib/gsd/api/public/style.css
+- lib/gsd/api/routes/health.rb
+- lib/gsd/api/routes/phases.rb
+- lib/gsd/api/routes/roadmap.rb
+- lib/gsd/api/routes/state.rb
+- lib/gsd/api/server.rb
 - lib/gsd/buddy.rb
 - lib/gsd/buddy/cli.rb
 - lib/gsd/buddy/gacha.rb