trak_flow 0.1.3 → 0.2.0

data/lib/trak_flow/cli/main_commands.rb

@@ -13,14 +13,16 @@ module TrakFlow
     option :stealth, type: :boolean, default: false, desc: "Local-only mode without git integration"
 
     def init
+      trak_dir = TrakFlow.trak_flow_dir
+
       if TrakFlow.initialized?
         output({ success: false, error: "TrakFlow already initialized" }) do
-          puts pastel.red("Error: TrakFlow already initialized in #{TrakFlow.trak_flow_dir}")
+          puts pastel.red("Error: TrakFlow already initialized in #{trak_dir}")
         end
         return
       end
 
-      FileUtils.mkdir_p(TrakFlow.trak_flow_dir)
+      FileUtils.mkdir_p(trak_dir)
 
       db = Storage::Database.new
       db.connect
@@ -32,8 +34,8 @@ module TrakFlow
 
       setup_gitignore unless options[:stealth]
 
-      output({ success: true, path: TrakFlow.trak_flow_dir }) do
-        puts pastel.green("Initialized TrakFlow in #{TrakFlow.trak_flow_dir}")
+      output({ success: true, path: trak_dir }) do
+        puts pastel.green("Initialized TrakFlow in #{trak_dir}")
       end
     end
 
@@ -47,7 +49,7 @@ module TrakFlow
         database_path: TrakFlow.database_path,
         jsonl_path: TrakFlow.jsonl_path,
         config_path: TrakFlow.config_path,
-        initialized: TrakFlow.initialized?,
+        initialized: TrakFlow.initialized?
       }
 
       output(info_data) do
@@ -71,46 +73,12 @@ module TrakFlow
     def create(title)
       validate_option!(:type, TrakFlow::TYPES, options[:type])
       validate_option!(:priority, TrakFlow::PRIORITIES, options[:priority])
+      raise ValidationError, "Plans cannot be ephemeral" if options[:plan] && options[:ephemeral]
 
       with_database do |db|
-        description = options[:description]
-
-        if options[:body_file]
-          description = options[:body_file] == "-" ? $stdin.read : File.read(options[:body_file])
-        end
-
-        raise ValidationError, "Plans cannot be ephemeral" if options[:plan] && options[:ephemeral]
-
-        task = if options[:parent]
-            db.create_child_task(options[:parent], {
-              title: title,
-              description: description,
-              type: options[:type],
-              priority: options[:priority],
-              assignee: options[:assignee],
-              ephemeral: options[:ephemeral],
-            })
-          else
-            new_task = Models::Task.new(
-              title: title,
-              description: description,
-              type: options[:type],
-              priority: options[:priority],
-              assignee: options[:assignee],
-              plan: options[:plan],
-              ephemeral: options[:ephemeral],
-            )
-            db.create_task(new_task)
-          end
-
-        options[:labels]&.each do |label_name|
-          db.add_label(Models::Label.new(task_id: task.id, name: label_name))
-        end
-
-        options[:deps]&.each do |dep_spec|
-          type, target_id = dep_spec.split(":", 2)
-          db.add_dependency(Models::Dependency.new(source_id: task.id, target_id: target_id, type: type))
-        end
+        task = build_task(db, title, resolve_description)
+        attach_labels(db, task)
+        attach_dependencies(db, task)
 
         output(task.to_h) do
           puts "Created: #{pastel.bold(task.id)} - #{task.title}"
@@ -147,31 +115,7 @@ module TrakFlow
 
     def list
       with_database do |db|
-        filters = {
-          status: options[:status],
-          priority: options[:priority],
-          type: options[:type],
-          assignee: options[:assignee],
-          title_contains: options[:title_contains],
-        }.compact
-
-        tasks = db.list_tasks(filters)
-
-        if options[:label]
-          tasks = tasks.select do |task|
-            task_labels = db.find_labels(task.id).map(&:name)
-            options[:label].all? { |l| task_labels.include?(l) }
-          end
-        end
-
-        if options[:label_any]
-          tasks = tasks.select do |task|
-            task_labels = db.find_labels(task.id).map(&:name)
-            options[:label_any].any? { |l| task_labels.include?(l) }
-          end
-        end
-
-        tasks = tasks.take(options[:limit]) if options[:limit]
+        tasks = filtered_tasks(db)
 
         output(tasks.map(&:to_h)) do
           if tasks.empty?
@@ -197,13 +141,7 @@ module TrakFlow
 
       with_database do |db|
         task = db.find_task!(id)
-
-        task.status = options[:status] if options[:status]
-        task.priority = options[:priority] if options[:priority]
-        task.title = options[:title] if options[:title]
-        task.description = options[:description] if options[:description]
-        task.assignee = options[:assignee] if options[:assignee]
-
+        apply_task_updates(task)
         db.update_task(task)
 
         output(task.to_h) do
@@ -288,17 +226,18 @@ module TrakFlow
     def sync
       with_database do |db|
         jsonl = Storage::Jsonl.new
+        jsonl_path = jsonl.path
 
         if jsonl.exists?
           jsonl.import(db)
-          output({ success: true, action: "imported", path: jsonl.path }) do
-            puts pastel.green("Imported from #{jsonl.path}")
+          output({ success: true, action: "imported", path: jsonl_path }) do
+            puts pastel.green("Imported from #{jsonl_path}")
           end
         end
 
         jsonl.export(db)
-        output({ success: true, action: "exported", path: jsonl.path }) do
-          puts pastel.green("Exported to #{jsonl.path}")
+        output({ success: true, action: "exported", path: jsonl_path }) do
+          puts pastel.green("Exported to #{jsonl_path}")
         end
 
         unless TrakFlow.config.get("stealth") || TrakFlow.config.get("no_push")
@@ -328,33 +267,127 @@ module TrakFlow
 
     private
 
+    # Reads the task description from --description, --body-file, or stdin ("-").
+    def resolve_description
+      body_file = options[:body_file]
+      return $stdin.read if body_file == "-"
+      return File.read(body_file) if body_file
+
+      options[:description]
+    end
+
+    # Creates the task — as a child of --parent when given, standalone otherwise.
+    def build_task(db, title, description)
+      attrs = {
+        title: title,
+        description: description,
+        type: options[:type],
+        priority: options[:priority],
+        assignee: options[:assignee],
+        ephemeral: options[:ephemeral]
+      }
+
+      if options[:parent]
+        db.create_child_task(options[:parent], attrs)
+      else
+        db.create_task(Models::Task.new(plan: options[:plan], **attrs))
+      end
+    end
+
+    def attach_labels(db, task)
+      options[:labels]&.each do |label_name|
+        db.add_label(Models::Label.new(task_id: task.id, name: label_name))
+      end
+    end
+
+    def attach_dependencies(db, task)
+      options[:deps]&.each do |dep_spec|
+        type, target_id = dep_spec.split(":", 2)
+        db.add_dependency(Models::Dependency.new(source_id: task.id, target_id: target_id, type: type))
+      end
+    end
+
+    # Applies the list command's label/limit options on top of the db filters.
+    def filtered_tasks(db)
+      tasks = db.list_tasks(list_filters)
+      tasks = tasks.select { |task| (options[:label] - task_label_names(db, task)).empty? } if options[:label]
+      tasks = tasks.select { |task| options[:label_any].intersect?(task_label_names(db, task)) } if options[:label_any]
+      options[:limit] ? tasks.take(options[:limit]) : tasks
+    end
+
+    def list_filters
+      {
+        status: options[:status],
+        priority: options[:priority],
+        type: options[:type],
+        assignee: options[:assignee],
+        title_contains: options[:title_contains]
+      }.compact
+    end
+
+    def task_label_names(db, task)
+      db.find_labels(task.id).map(&:name)
+    end
+
+    # Copies each given update option onto the task; untouched fields keep their values.
+    def apply_task_updates(task)
+      %i[status priority title description assignee].each do |field|
+        task.send("#{field}=", options[field]) if options[field]
+      end
+    end
+
     def print_task_details(task, labels, deps, comments)
+      print_task_summary(task)
+      print_task_body(task, labels)
+      print_task_dependencies(task, deps)
+      print_task_comments(comments)
+    end
+
+    def print_task_summary(task)
       puts pastel.bold("Task: #{task.id}")
-      puts "Title: #{task.title}"
-      puts "Status: #{colorize_status(task.status)}"
-      puts "Priority: #{colorize_priority(task.priority)}"
-      puts "Type: #{task.type}"
-      puts "Assignee: #{task.assignee || "unassigned"}"
+      puts <<~SUMMARY
+        Title: #{task.title}
+        Status: #{colorize_status(task.status)}
+        Priority: #{colorize_priority(task.priority)}
+        Type: #{task.type}
+        Assignee: #{task.assignee || "unassigned"}
+      SUMMARY
       puts "Parent: #{task.parent_id}" if task.parent_id
       puts "Created: #{task.created_at}"
       puts "Updated: #{task.updated_at}"
       puts "Closed: #{task.closed_at}" if task.closed_at
-      puts ""
-      puts "Description:"
-      puts task.description.empty? ? "(none)" : task.description
-      puts ""
-      puts "Labels: #{labels.empty? ? "(none)" : labels.map(&:name).join(", ")}"
+    end
+
+    def print_task_body(task, labels)
+      puts <<~BODY
+
+        Description:
+        #{task.description.empty? ? "(none)" : task.description}
+
+        Labels: #{labels.empty? ? "(none)" : labels.map(&:name).join(", ")}
+      BODY
+    end
+
+    def print_task_dependencies(task, deps)
       puts ""
       puts "Dependencies:"
       if deps.empty?
         puts "  (none)"
       else
-        deps.each do |dep|
-          direction = dep.source_id == task.id ? "->" : "<-"
-          other_id = dep.source_id == task.id ? dep.target_id : dep.source_id
-          puts "  #{direction} #{other_id} (#{dep.type})"
-        end
+        deps.each { |dep| puts "  #{format_dependency(task, dep)}" }
       end
+    end
+
+    # Renders one dependency relative to the task being shown:
+    # "-> other (type)" when the task is the source, "<- other (type)" otherwise.
+    def format_dependency(task, dep)
+      outgoing = dep.source_id == task.id
+      direction = outgoing ? "->" : "<-"
+      other_id = outgoing ? dep.target_id : dep.source_id
+      "#{direction} #{other_id} (#{dep.type})"
+    end
+
+    def print_task_comments(comments)
       puts ""
       puts "Comments: #{comments.size}"
       comments.each do |comment|

data/lib/trak_flow/cli/plan_commands.rb

@@ -132,28 +132,8 @@ module TrakFlow
           raise Error, "#{plan_id} is not a Plan" unless plan.plan?
 
           vars = options[:var] || {}
-
-          workflow = Models::Task.new(
-            title: interpolate_vars(plan.title, vars),
-            description: interpolate_vars(plan.description, vars),
-            type: plan.type,
-            priority: plan.priority,
-            source_plan_id: plan.id,
-            ephemeral: ephemeral
-          )
-          db.create_task(workflow)
-          workflow.append_trace("INSTANTIATED", "from Plan #{plan.id}")
-          db.update_task(workflow)
-
-          db.find_plan_tasks(plan_id).each do |step|
-            db.create_child_task(workflow.id, {
-              title: interpolate_vars(step.title, vars),
-              description: interpolate_vars(step.description, vars),
-              type: step.type,
-              priority: step.priority,
-              ephemeral: ephemeral
-            })
-          end
+          workflow = create_workflow_from_plan(db, plan, vars, ephemeral)
+          instantiate_plan_steps(db, plan_id, workflow.id, vars, ephemeral)
 
           mode = ephemeral ? "ephemeral" : "persistent"
           output(workflow.to_h) do
@@ -162,6 +142,33 @@ module TrakFlow
         end
       end
 
+      def create_workflow_from_plan(db, plan, vars, ephemeral)
+        workflow = Models::Task.new(
+          title: interpolate_vars(plan.title, vars),
+          description: interpolate_vars(plan.description, vars),
+          type: plan.type,
+          priority: plan.priority,
+          source_plan_id: plan.id,
+          ephemeral: ephemeral
+        )
+        db.create_task(workflow)
+        workflow.append_trace("INSTANTIATED", "from Plan #{plan.id}")
+        db.update_task(workflow)
+        workflow
+      end
+
+      def instantiate_plan_steps(db, plan_id, workflow_id, vars, ephemeral)
+        db.find_plan_tasks(plan_id).each do |step|
+          db.create_child_task(workflow_id, {
+            title: interpolate_vars(step.title, vars),
+            description: interpolate_vars(step.description, vars),
+            type: step.type,
+            priority: step.priority,
+            ephemeral: ephemeral
+          })
+        end
+      end
+
       def interpolate_vars(text, vars)
         return text if text.nil? || vars.empty?
 
@@ -171,13 +178,13 @@ module TrakFlow
       end
 
       # Delegate helper methods to parent CLI
-      def with_database(&block) = CLI.new.with_database(&block)
+      def with_database(&) = CLI.new.with_database(&)
 
-      def output(json_data, &human_block)
+      def output(json_data)
         if options[:json]
           puts Oj.dump(json_data, mode: :compat, indent: 2)
         else
-          human_block.call
+          yield
         end
       end
     end

data/lib/trak_flow/cli/workflow_commands.rb

@@ -72,7 +72,8 @@ module TrakFlow
         with_database do |db|
           workflow = db.find_task!(id)
 
-          summary_text = File.exist?(options[:summary]) ? File.read(options[:summary]) : options[:summary]
+          summary = options[:summary]
+          summary_text = File.exist?(summary) ? File.read(summary) : summary
 
           workflow.notes = "#{workflow.notes}\n\n[Summary]\n#{summary_text}".strip
           workflow.close!(reason: "summarized")
@@ -118,14 +119,14 @@ module TrakFlow
       end
 
       # Delegate helper methods to parent CLI
-      def with_database(&block) = CLI.new.with_database(&block)
+      def with_database(&) = CLI.new.with_database(&)
       def status_icon(status) = CLI.new.status_icon(status)
 
-      def output(json_data, &human_block)
+      def output(json_data)
         if options[:json]
           puts Oj.dump(json_data, mode: :compat, indent: 2)
         else
-          human_block.call
+          yield
         end
       end
     end

data/lib/trak_flow/cli.rb

@@ -18,11 +18,11 @@ module TrakFlow
         puts Oj.dump(data, mode: :compat, indent: 2)
       end
 
-      def output(json_data, &human_block)
+      def output(json_data)
         if json?
           output_json(json_data)
         else
-          human_block.call
+          yield
         end
       end
 

data/lib/trak_flow/config/defaults.yml

@@ -102,10 +102,14 @@ defaults:
 
   # ---------------------------------------------------------------------------
   # MCP Server Configuration
-  # Access: TrakFlow.config.mcp.port
+  # Access: TrakFlow.config.mcp.port, TrakFlow.config.mcp.handler
   # ---------------------------------------------------------------------------
   mcp:
     port: 3333
+    # Rack server for the HTTP transport, by Rackup handler name (e.g.
+    # "puma", "falcon", "webrick"). Null lets Rackup pick whatever server
+    # the bundle already carries. The server must support rack.hijack.
+    handler: ~
 
   # ---------------------------------------------------------------------------
   # Actor Configuration

data/lib/trak_flow/config/section.rb

@@ -16,14 +16,12 @@ module TrakFlow
       end
     end
 
-    def method_missing(method, *args, &block)
+    def method_missing(method, *args, &)
       key = method.to_s
       if key.end_with?('=')
         @data[key.chomp('=').to_sym] = args.first
       elsif @data.key?(method)
         @data[method]
-      else
-        nil
       end
     end
 
@@ -55,8 +53,8 @@ module TrakFlow
       @data.keys
     end
 
-    def each(&block)
-      @data.each(&block)
+    def each(&)
+      @data.each(&)
     end
 
     private

data/lib/trak_flow/config.rb

@@ -53,11 +53,13 @@ module TrakFlow
       SCHEMA = raw_yaml[:defaults] || {}
     rescue StandardError => e
       raise TrakFlow::ConfigurationError,
-        "Could not load schema from #{DEFAULTS_PATH}: #{e.message}"
+            "Could not load schema from #{DEFAULTS_PATH}: #{e.message}"
     end
 
     # Nested section attributes (defined as hashes, converted to ConfigSection)
-    attr_config :output, :daemon, :sync, :create, :validation, :id, :import, :export, :storage, :database, :mcp
+    SECTION_KEYS = %i[output daemon sync create validation id import export storage database mcp].freeze
+
+    attr_config(*SECTION_KEYS)
 
     # Top-level scalar attributes
     attr_config :actor
@@ -68,7 +70,7 @@ module TrakFlow
 
     def self.config_section_with_defaults(section_key)
       defaults = SCHEMA[section_key] || {}
-      ->(v) {
+      lambda { |v|
         return v if v.is_a?(ConfigSection)
         incoming = v || {}
         merged = deep_merge_hashes(defaults.dup, incoming)
@@ -86,19 +88,7 @@ module TrakFlow
       end
     end
 
-    coerce_types(
-      output: config_section_with_defaults(:output),
-      daemon: config_section_with_defaults(:daemon),
-      sync: config_section_with_defaults(:sync),
-      create: config_section_with_defaults(:create),
-      validation: config_section_with_defaults(:validation),
-      id: config_section_with_defaults(:id),
-      import: config_section_with_defaults(:import),
-      export: config_section_with_defaults(:export),
-      storage: config_section_with_defaults(:storage),
-      database: config_section_with_defaults(:database),
-      mcp: config_section_with_defaults(:mcp)
-    )
+    coerce_types(SECTION_KEYS.to_h { |key| [key, config_section_with_defaults(key)] })
 
     on_load :setup_defaults
 
@@ -229,13 +219,12 @@ module TrakFlow
       mapping = LEGACY_KEY_MAP[key.to_s]
       return unless mapping
 
-      if mapping.is_a?(Array)
-        if mapping.length == 1
-          send("#{mapping[0]}=", value)
-        else
-          section = send(mapping[0])
-          section.send("#{mapping[1]}=", value)
-        end
+      return unless mapping.is_a?(Array)
+      if mapping.length == 1
+        send("#{mapping[0]}=", value)
+      else
+        section = send(mapping[0])
+        section.send("#{mapping[1]}=", value)
       end
     end
 
@@ -244,19 +233,16 @@ module TrakFlow
     def setup_defaults
       # Ensure all sections are initialized with defaults even when no config files exist
       # Manually apply coercion since it only fires when values come from config sources
-      self.output = self.class.config_section_with_defaults(:output).call(output) unless output.is_a?(ConfigSection)
-      self.daemon = self.class.config_section_with_defaults(:daemon).call(daemon) unless daemon.is_a?(ConfigSection)
-      self.sync = self.class.config_section_with_defaults(:sync).call(sync) unless sync.is_a?(ConfigSection)
-      self.create = self.class.config_section_with_defaults(:create).call(create) unless create.is_a?(ConfigSection)
-      self.validation = self.class.config_section_with_defaults(:validation).call(validation) unless validation.is_a?(ConfigSection)
-      self.id = self.class.config_section_with_defaults(:id).call(self.id) unless self.id.is_a?(ConfigSection)
-      self.import = self.class.config_section_with_defaults(:import).call(self.import) unless self.import.is_a?(ConfigSection)
-      self.export = self.class.config_section_with_defaults(:export).call(self.export) unless self.export.is_a?(ConfigSection)
-      self.storage = self.class.config_section_with_defaults(:storage).call(self.storage) unless self.storage.is_a?(ConfigSection)
-      self.database = self.class.config_section_with_defaults(:database).call(self.database) unless self.database.is_a?(ConfigSection)
-      self.mcp = self.class.config_section_with_defaults(:mcp).call(self.mcp) unless self.mcp.is_a?(ConfigSection)
+      SECTION_KEYS.each { |key| ensure_section!(key) }
       self.actor ||= ENV.fetch('USER', 'unknown')
     end
+
+    def ensure_section!(key)
+      current = send(key)
+      return if current.is_a?(ConfigSection)
+
+      send("#{key}=", self.class.config_section_with_defaults(key).call(current))
+    end
   end
 
   class << self