trak_flow 0.1.3

data/lib/trak_flow/cli/main_commands.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  class CLI < Thor
+    desc "version", "Show version"
+
+    def version
+      puts "trak_flow #{VERSION}"
+    end
+
+    desc "init", "Initialize TrakFlow in the current directory"
+    option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+    option :stealth, type: :boolean, default: false, desc: "Local-only mode without git integration"
+
+    def init
+      if TrakFlow.initialized?
+        output({ success: false, error: "TrakFlow already initialized" }) do
+          puts pastel.red("Error: TrakFlow already initialized in #{TrakFlow.trak_flow_dir}")
+        end
+        return
+      end
+
+      FileUtils.mkdir_p(TrakFlow.trak_flow_dir)
+
+      db = Storage::Database.new
+      db.connect
+
+      TrakFlow.config.set("stealth", options[:stealth])
+
+      jsonl = Storage::Jsonl.new
+      jsonl.write_entities([])
+
+      setup_gitignore unless options[:stealth]
+
+      output({ success: true, path: TrakFlow.trak_flow_dir }) do
+        puts pastel.green("Initialized TrakFlow in #{TrakFlow.trak_flow_dir}")
+      end
+    end
+
+    desc "info", "Show database and configuration info"
+    option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+
+    def info
+      TrakFlow.ensure_initialized!
+
+      info_data = {
+        database_path: TrakFlow.database_path,
+        jsonl_path: TrakFlow.jsonl_path,
+        config_path: TrakFlow.config_path,
+        initialized: TrakFlow.initialized?,
+      }
+
+      output(info_data) do
+        info_data.each { |k, v| puts "#{k}: #{v}" }
+      end
+    end
+
+    desc "create TITLE", "Create a new task"
+    option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+    option :type, aliases: "-t", type: :string, default: "task", desc: "Task type (bug, feature, task, epic, chore)"
+    option :priority, aliases: "-p", type: :numeric, default: 2, desc: "Priority (0=critical, 4=backlog)"
+    option :description, aliases: "-d", type: :string, desc: "Task description"
+    option :assignee, aliases: "-a", type: :string, desc: "Assignee"
+    option :labels, aliases: "-l", type: :array, desc: "Labels to add"
+    option :parent, type: :string, desc: "Parent task ID (creates child task)"
+    option :deps, type: :array, desc: "Dependencies (format: type:id)"
+    option :body_file, type: :string, desc: "Read description from file (use - for stdin)"
+    option :plan, type: :boolean, default: false, desc: "Create as a Plan (workflow blueprint)"
+    option :ephemeral, type: :boolean, default: false, desc: "Create as ephemeral (one-shot, garbage collectible)"
+
+    def create(title)
+      validate_option!(:type, TrakFlow::TYPES, options[:type])
+      validate_option!(:priority, TrakFlow::PRIORITIES, options[:priority])
+
+      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
+
+        output(task.to_h) do
+          puts "Created: #{pastel.bold(task.id)} - #{task.title}"
+        end
+      end
+    end
+
+    desc "show ID", "Show task details"
+    option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+
+    def show(id)
+      with_database do |db|
+        task = db.find_task!(id)
+        labels = db.find_labels(id)
+        deps = db.find_dependencies(id)
+        comments = db.find_comments(id)
+
+        output({ task: task.to_h, labels: labels.map(&:name), dependencies: deps.map(&:to_h), comments: comments.map(&:to_h) }) do
+          print_task_details(task, labels, deps, comments)
+        end
+      end
+    end
+
+    desc "list", "List tasks"
+    option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+    option :status, aliases: "-s", type: :string, desc: "Filter by status"
+    option :priority, aliases: "-p", type: :numeric, desc: "Filter by priority"
+    option :type, aliases: "-t", type: :string, desc: "Filter by type"
+    option :assignee, aliases: "-a", type: :string, desc: "Filter by assignee"
+    option :label, type: :array, desc: "Filter by labels (AND)"
+    option :label_any, type: :array, desc: "Filter by labels (OR)"
+    option :title_contains, type: :string, desc: "Filter by title substring"
+    option :limit, type: :numeric, desc: "Limit results"
+
+    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]
+
+        output(tasks.map(&:to_h)) do
+          if tasks.empty?
+            puts "No tasks found"
+          else
+            print_tasks_table(tasks)
+          end
+        end
+      end
+    end
+
+    desc "update ID", "Update a task"
+    option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+    option :status, aliases: "-s", type: :string, desc: "New status"
+    option :priority, aliases: "-p", type: :numeric, desc: "New priority"
+    option :title, type: :string, desc: "New title"
+    option :description, aliases: "-d", type: :string, desc: "New description"
+    option :assignee, aliases: "-a", type: :string, desc: "New assignee"
+
+    def update(id)
+      validate_option!(:status, TrakFlow::STATUSES, options[:status])
+      validate_option!(:priority, TrakFlow::PRIORITIES, options[:priority])
+
+      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]
+
+        db.update_task(task)
+
+        output(task.to_h) do
+          puts "Updated: #{pastel.bold(task.id)} - #{task.title}"
+        end
+      end
+    end
+
+    desc "close ID", "Close a task"
+    option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+    option :reason, aliases: "-r", type: :string, desc: "Reason for closing"
+
+    def close(id)
+      with_database do |db|
+        task = db.find_task!(id)
+        task.close!(reason: options[:reason])
+        db.update_task(task)
+
+        output(task.to_h) do
+          puts "Closed: #{pastel.bold(task.id)} - #{task.title}"
+        end
+      end
+    end
+
+    desc "reopen ID", "Reopen a closed task"
+    option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+    option :reason, aliases: "-r", type: :string, desc: "Reason for reopening"
+
+    def reopen(id)
+      with_database do |db|
+        task = db.find_task!(id)
+        task.reopen!(reason: options[:reason])
+        db.update_task(task)
+
+        output(task.to_h) do
+          puts "Reopened: #{pastel.bold(task.id)} - #{task.title}"
+        end
+      end
+    end
+
+    desc "ready", "Show tasks ready for work (no blockers)"
+    option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+
+    def ready
+      with_database do |db|
+        tasks = db.ready_tasks
+
+        output(tasks.map(&:to_h)) do
+          if tasks.empty?
+            puts "No ready tasks found"
+          else
+            puts pastel.bold("Ready for work:")
+            print_tasks_table(tasks)
+          end
+        end
+      end
+    end
+
+    desc "stale", "Show stale tasks"
+    option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+    option :days, type: :numeric, default: 30, desc: "Days since last update"
+    option :status, type: :string, desc: "Filter by status"
+
+    def stale
+      with_database do |db|
+        tasks = db.stale_tasks(days: options[:days], status: options[:status])
+
+        output(tasks.map(&:to_h)) do
+          if tasks.empty?
+            puts "No stale tasks found"
+          else
+            puts pastel.bold("Stale tasks (#{options[:days]}+ days):")
+            print_tasks_table(tasks)
+          end
+        end
+      end
+    end
+
+    desc "sync", "Sync database with JSONL file"
+    option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+
+    def sync
+      with_database do |db|
+        jsonl = Storage::Jsonl.new
+
+        if jsonl.exists?
+          jsonl.import(db)
+          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}")
+        end
+
+        unless TrakFlow.config.get("stealth") || TrakFlow.config.get("no_push")
+          git_commit_and_push
+        end
+      end
+    end
+
+    # Subcommands
+    desc "dep SUBCOMMAND", "Manage dependencies"
+    subcommand "dep", DepCommands
+
+    desc "label SUBCOMMAND", "Manage labels"
+    subcommand "label", LabelCommands
+
+    desc "plan SUBCOMMAND", "Plan operations (workflow blueprints)"
+    subcommand "plan", PlanCommands
+
+    desc "workflow SUBCOMMAND", "Workflow operations (running instances)"
+    subcommand "workflow", WorkflowCommands
+
+    desc "admin SUBCOMMAND", "Administrative commands"
+    subcommand "admin", AdminCommands
+
+    desc "config SUBCOMMAND", "Configuration management"
+    subcommand "config", ConfigCommands
+
+    private
+
+    def print_task_details(task, labels, deps, comments)
+      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 "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(", ")}"
+      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
+      end
+      puts ""
+      puts "Comments: #{comments.size}"
+      comments.each do |comment|
+        puts "  [#{comment.created_at}] #{comment.author}: #{comment.body[0, 50]}..."
+      end
+    end
+
+    def setup_gitignore
+      gitignore_path = File.join(TrakFlow.trak_flow_dir, ".gitignore")
+      File.write(gitignore_path, "trak_flow.db\n")
+    end
+
+    def validate_option!(name, valid_values, value)
+      return if value.nil?
+      return if valid_values.include?(value)
+
+      valid_list = valid_values.join(", ")
+      raise ValidationError, "Invalid #{name}: '#{value}'. Valid options: #{valid_list}"
+    end
+
+    def git_commit_and_push
+      Dir.chdir(TrakFlow.root) do
+        system("git add #{TrakFlow.jsonl_path} 2>/dev/null")
+        system("git commit -m 'trak_flow: sync tasks' #{TrakFlow.jsonl_path} 2>/dev/null")
+        system("git push 2>/dev/null") unless TrakFlow.config.get("no_push")
+      end
+    end
+  end
+end

data/lib/trak_flow/cli/plan_commands.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  class CLI < Thor
+    # Plan subcommands (workflow blueprints)
+    class PlanCommands < Thor
+      class_option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+
+      desc "create TITLE", "Create a new Plan (workflow blueprint)"
+      option :description, aliases: "-d", type: :string, desc: "Plan description"
+      option :type, aliases: "-t", type: :string, default: "task", desc: "Task type"
+      option :priority, aliases: "-p", type: :numeric, default: 2, desc: "Priority"
+      def create(title)
+        with_database do |db|
+          plan = Models::Task.new(
+            title: title,
+            description: options[:description] || "",
+            type: options[:type],
+            priority: options[:priority],
+            plan: true
+          )
+          db.create_task(plan)
+
+          output(plan.to_h) do
+            puts "Created Plan: #{plan.id} - #{plan.title}"
+          end
+        end
+      end
+
+      desc "list", "List Plans"
+      option :workflows, aliases: "-w", type: :boolean, default: false, desc: "Show Workflows instead of Plans"
+      def list
+        with_database do |db|
+          if options[:workflows]
+            items = db.find_workflows
+            label = "Workflows"
+          else
+            items = db.find_plans
+            label = "Plans"
+          end
+
+          output(items.map(&:to_h)) do
+            if items.empty?
+              puts "No #{label.downcase} found"
+            else
+              puts "#{label}:"
+              items.each do |item|
+                status_info = item.plan? ? "" : " (#{item.status})"
+                ephemeral_tag = item.ephemeral? ? " [ephemeral]" : ""
+                puts "  #{item.id}: #{item.title}#{status_info}#{ephemeral_tag}"
+              end
+            end
+          end
+        end
+      end
+
+      desc "show ID", "Show Plan with its Tasks"
+      def show(id)
+        with_database do |db|
+          plan = db.find_task!(id)
+          tasks = db.find_plan_tasks(id)
+
+          output({ plan: plan.to_h, tasks: tasks.map(&:to_h) }) do
+            puts "Plan: #{plan.id} - #{plan.title}"
+            puts "Description: #{plan.description.empty? ? "(none)" : plan.description}"
+            puts ""
+            puts "Tasks (#{tasks.size}):"
+            if tasks.empty?
+              puts "  (no tasks defined)"
+            else
+              tasks.each { |task| puts "  #{task.id}: #{task.title} (P#{task.priority})" }
+            end
+          end
+        end
+      end
+
+      desc "add PLAN_ID TITLE", "Add a Task to a Plan"
+      option :description, aliases: "-d", type: :string, desc: "Task description"
+      option :type, aliases: "-t", type: :string, default: "task", desc: "Task type"
+      option :priority, aliases: "-p", type: :numeric, default: 2, desc: "Priority"
+      def add(plan_id, title)
+        with_database do |db|
+          plan = db.find_task!(plan_id)
+          raise Error, "#{plan_id} is not a Plan" unless plan.plan?
+
+          task = db.create_child_task(plan_id, {
+            title: title,
+            description: options[:description] || "",
+            type: options[:type],
+            priority: options[:priority]
+          })
+
+          output(task.to_h) do
+            puts "Added Task to Plan: #{task.id} - #{task.title}"
+          end
+        end
+      end
+
+      desc "start PLAN_ID", "Create a persistent Workflow from a Plan"
+      option :var, type: :hash, default: {}, desc: "Template variables"
+      def start(plan_id)
+        instantiate_plan(plan_id, ephemeral: false)
+      end
+
+      desc "execute PLAN_ID", "Create an ephemeral Workflow from a Plan"
+      option :var, type: :hash, default: {}, desc: "Template variables"
+      def execute(plan_id)
+        instantiate_plan(plan_id, ephemeral: true)
+      end
+
+      desc "convert ID", "Convert an existing Task to a Plan"
+      def convert(id)
+        with_database do |db|
+          task = db.find_task!(id)
+          raise Error, "Task is already a Plan" if task.plan?
+          raise Error, "Cannot convert ephemeral tasks to Plans" if task.ephemeral?
+
+          db.mark_as_plan(id)
+          task = db.find_task!(id)
+
+          output(task.to_h) do
+            puts "Converted to Plan: #{task.id}"
+          end
+        end
+      end
+
+      private
+
+      def instantiate_plan(plan_id, ephemeral:)
+        with_database do |db|
+          plan = db.find_task!(plan_id)
+          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
+
+          mode = ephemeral ? "ephemeral" : "persistent"
+          output(workflow.to_h) do
+            puts "Created #{mode} Workflow: #{workflow.id}"
+          end
+        end
+      end
+
+      def interpolate_vars(text, vars)
+        return text if text.nil? || vars.empty?
+
+        result = text.dup
+        vars.each { |key, value| result.gsub!("{{#{key}}}", value.to_s) }
+        result
+      end
+
+      # Delegate helper methods to parent CLI
+      def with_database(&block) = CLI.new.with_database(&block)
+
+      def output(json_data, &human_block)
+        if options[:json]
+          puts Oj.dump(json_data, mode: :compat, indent: 2)
+        else
+          human_block.call
+        end
+      end
+    end
+  end
+end

data/lib/trak_flow/cli/workflow_commands.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  class CLI < Thor
+    # Workflow subcommands (running instances of Plans)
+    class WorkflowCommands < Thor
+      class_option :json, aliases: "-j", type: :boolean, default: false, desc: "Output in JSON format"
+
+      desc "list", "List Workflows"
+      option :ephemeral, aliases: "-e", type: :boolean, default: false, desc: "Show only ephemeral Workflows"
+      option :plan, type: :string, desc: "Filter by source Plan ID"
+      def list
+        with_database do |db|
+          workflows = db.find_workflows(plan_id: options[:plan])
+          workflows = workflows.select(&:ephemeral?) if options[:ephemeral]
+
+          output(workflows.map(&:to_h)) do
+            if workflows.empty?
+              puts "No workflows found"
+            else
+              puts "Workflows:"
+              workflows.each do |wf|
+                ephemeral_tag = wf.ephemeral? ? " [ephemeral]" : ""
+                source_tag = wf.source_plan_id ? " (from: #{wf.source_plan_id})" : ""
+                puts "  #{wf.id}: #{wf.title} (#{wf.status})#{ephemeral_tag}#{source_tag}"
+              end
+            end
+          end
+        end
+      end
+
+      desc "show ID", "Show Workflow with its Tasks"
+      def show(id)
+        with_database do |db|
+          workflow = db.find_task!(id)
+          tasks = db.find_workflow_tasks(id)
+
+          output({ workflow: workflow.to_h, tasks: tasks.map(&:to_h) }) do
+            puts "Workflow: #{workflow.id} - #{workflow.title}"
+            puts "Status: #{workflow.status}"
+            puts "Ephemeral: #{workflow.ephemeral?}"
+            puts "Source Plan: #{workflow.source_plan_id || "(none)"}"
+            puts ""
+            puts "Tasks (#{tasks.size}):"
+            if tasks.empty?
+              puts "  (no tasks)"
+            else
+              tasks.each { |task| puts "  #{status_icon(task.status)} #{task.id}: #{task.title}" }
+            end
+          end
+        end
+      end
+
+      desc "discard ID", "Discard an ephemeral Workflow"
+      def discard(id)
+        with_database do |db|
+          workflow = db.find_task!(id)
+          raise Error, "Can only discard ephemeral Workflows" unless workflow.discardable?
+
+          db.child_tasks(id).each { |child| db.delete_task(child.id) }
+          db.delete_task(id)
+
+          output({ discarded: id }) do
+            puts "Discarded Workflow: #{id}"
+          end
+        end
+      end
+
+      desc "summarize ID", "Summarize and close a Workflow"
+      option :summary, aliases: "-s", type: :string, required: true, desc: "Summary text or file path"
+      def summarize(id)
+        with_database do |db|
+          workflow = db.find_task!(id)
+
+          summary_text = File.exist?(options[:summary]) ? File.read(options[:summary]) : options[:summary]
+
+          workflow.notes = "#{workflow.notes}\n\n[Summary]\n#{summary_text}".strip
+          workflow.close!(reason: "summarized")
+          db.update_task(workflow)
+
+          db.child_tasks(id).each do |child|
+            child.close!(reason: "workflow summarized")
+            db.update_task(child)
+          end
+
+          output(workflow.to_h) do
+            puts "Summarized Workflow: #{id}"
+          end
+        end
+      end
+
+      desc "gc", "Garbage collect old ephemeral Workflows"
+      option :age, type: :string, default: "24h", desc: "Maximum age (e.g., 24h, 7d)"
+      def gc
+        with_database do |db|
+          hours = parse_duration(options[:age])
+          count = db.garbage_collect_ephemeral(max_age_hours: hours)
+
+          output({ collected: count }) do
+            puts "Collected #{count} ephemeral Workflow(s)"
+          end
+        end
+      end
+
+      private
+
+      def parse_duration(str)
+        match = str.match(/^(\d+)(h|d|w)$/)
+        return 24 unless match
+
+        num = match[1].to_i
+        case match[2]
+        when "h" then num
+        when "d" then num * 24
+        when "w" then num * 24 * 7
+        else 24
+        end
+      end
+
+      # Delegate helper methods to parent CLI
+      def with_database(&block) = CLI.new.with_database(&block)
+      def status_icon(status) = CLI.new.status_icon(status)
+
+      def output(json_data, &human_block)
+        if options[:json]
+          puts Oj.dump(json_data, mode: :compat, indent: 2)
+        else
+          human_block.call
+        end
+      end
+    end
+  end
+end