trak_flow 0.1.3

data/lib/trak_flow/graph/dependency_graph.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  module Graph
+    # Dependency graph operations for visualizing and analyzing task relationships
+    class DependencyGraph
+      # Graph visualization colors (dark theme compatible)
+      COLORS = {
+        status: {
+          closed: "#4a5568",
+          tombstone: "#4a5568",
+          in_progress: "#3182ce",
+          blocked: "#e53e3e",
+          deferred: "#d69e2e",
+          pinned: "#805ad5"
+        },
+        priority: {
+          critical: "#e53e3e",
+          high: "#ed8936",
+          medium: "#48bb78",
+          low: "#4299e1",
+          backlog: "#a0aec0"
+        },
+        edge: {
+          blocks: "#e53e3e",
+          parent_child: "#3182ce",
+          related: "#a0aec0",
+          discovered_from: "#805ad5"
+        }
+      }.freeze
+
+      def initialize(db)
+        @db = db
+      end
+
+      # Build a tree representation of dependencies for a task
+      def dependency_tree(task_id, direction: :blocking, max_depth: 10)
+        task = @db.find_task!(task_id)
+        build_tree_node(task, direction, max_depth, Set.new)
+      end
+
+      # Find all tasks that block the given task (directly or transitively)
+      def all_blockers(task_id)
+        collect_related_tasks(task_id, :incoming, Models::Dependency::BLOCKING_TYPES)
+      end
+
+      # Find all tasks blocked by the given task (directly or transitively)
+      def all_blocked(task_id)
+        collect_related_tasks(task_id, :outgoing, Models::Dependency::BLOCKING_TYPES)
+      end
+
+      # Find the critical path - longest chain of blocking dependencies
+      def critical_path(root_task_id)
+        visited = {}
+        find_longest_path(root_task_id, visited)
+      end
+
+      # Get all leaf tasks (tasks with no children/blocked tasks)
+      def leaf_tasks
+        all_targets = Set.new
+
+        @db.all_task_ids.each do |id|
+          @db.find_dependencies(id, direction: :outgoing).each do |dep|
+            all_targets << dep.target_id if dep.blocking?
+          end
+        end
+
+        @db.list_tasks.reject { |task| all_targets.include?(task.id) }
+      end
+
+      # Get all root tasks (tasks with no parents/blockers)
+      def root_tasks
+        all_sources = Set.new
+
+        @db.all_task_ids.each do |id|
+          @db.find_dependencies(id, direction: :incoming).each do |dep|
+            all_sources << dep.source_id if dep.blocking?
+          end
+        end
+
+        @db.list_tasks.reject { |task| all_sources.include?(task.id) }
+      end
+
+      # Generate a DOT representation for Graphviz
+      def to_dot(task_ids: nil, include_closed: false)
+        task_ids ||= @db.all_task_ids
+        tasks = task_ids.map { |id| @db.find_task(id) }.compact
+        tasks = tasks.reject(&:closed?) unless include_closed
+
+        lines = ["digraph dependencies {"]
+        lines << '  rankdir=TB;'
+        lines << '  node [shape=box, style=filled];'
+        lines << ""
+
+        tasks.each do |task|
+          color = node_color(task)
+          label = "#{task.id}\\n#{truncate(task.title, 30)}"
+          lines << "  \"#{task.id}\" [label=\"#{label}\", fillcolor=\"#{color}\"];"
+        end
+
+        lines << ""
+
+        task_set = Set.new(tasks.map(&:id))
+
+        tasks.each do |task|
+          @db.find_dependencies(task.id, direction: :outgoing).each do |dep|
+            next unless task_set.include?(dep.target_id)
+
+            style = edge_style(dep)
+            lines << "  \"#{dep.source_id}\" -> \"#{dep.target_id}\" [#{style}];"
+          end
+        end
+
+        lines << "}"
+        lines.join("\n")
+      end
+
+      # Generate SVG using Graphviz (if available)
+      def to_svg(task_ids: nil, include_closed: false)
+        dot = to_dot(task_ids: task_ids, include_closed: include_closed)
+
+        require "open3"
+        stdout, stderr, status = Open3.capture3("dot", "-Tsvg", stdin_data: dot)
+
+        unless status.success?
+          raise Error, "Graphviz error: #{stderr}"
+        end
+
+        # Make background transparent for dark theme compatibility
+        stdout.gsub(/fill="white"/, 'fill="none"')
+      end
+
+      # Analyze the graph for potential problems
+      def analyze
+        {
+          total_tasks: @db.all_task_ids.size,
+          open_tasks: @db.list_tasks(status: "open").size,
+          ready_tasks: @db.ready_tasks.size,
+          blocked_tasks: @db.blocked_tasks.size,
+          orphan_tasks: find_orphans.size,
+          potential_cycles: find_potential_bottlenecks
+        }
+      end
+
+      private
+
+      def build_tree_node(task, direction, remaining_depth, visited)
+        return nil if remaining_depth <= 0 || visited.include?(task.id)
+
+        visited << task.id
+
+        node = {
+          id: task.id,
+          title: task.title,
+          status: task.status,
+          priority: task.priority,
+          children: []
+        }
+
+        dep_direction = direction == :blocking ? :incoming : :outgoing
+        deps = @db.find_dependencies(task.id, direction: dep_direction)
+        deps = deps.select(&:blocking?) if direction == :blocking
+
+        deps.each do |dep|
+          related_id = direction == :blocking ? dep.source_id : dep.target_id
+          related_task = @db.find_task(related_id)
+          next unless related_task
+
+          child_node = build_tree_node(related_task, direction, remaining_depth - 1, visited.dup)
+          node[:children] << child_node if child_node
+        end
+
+        node
+      end
+
+      def collect_related_tasks(start_id, direction, types)
+        visited = Set.new
+        queue = [start_id]
+        result = []
+
+        while queue.any?
+          current_id = queue.shift
+          next if visited.include?(current_id)
+
+          visited << current_id
+
+          deps = @db.find_dependencies(current_id, direction: direction)
+          deps = deps.select { |d| types.include?(d.type) }
+
+          deps.each do |dep|
+            related_id = direction == :incoming ? dep.source_id : dep.target_id
+            next if visited.include?(related_id)
+
+            task = @db.find_task(related_id)
+            if task
+              result << task
+              queue << related_id
+            end
+          end
+        end
+
+        result
+      end
+
+      def find_longest_path(task_id, memo)
+        return memo[task_id] if memo.key?(task_id)
+
+        task = @db.find_task(task_id)
+        return [] unless task
+
+        deps = @db.find_dependencies(task_id, direction: :outgoing)
+        blocking_deps = deps.select(&:blocking?)
+
+        if blocking_deps.empty?
+          memo[task_id] = [task]
+          return [task]
+        end
+
+        longest_child_path = blocking_deps.map do |dep|
+          find_longest_path(dep.target_id, memo)
+        end.max_by(&:size) || []
+
+        memo[task_id] = [task] + longest_child_path
+        memo[task_id]
+      end
+
+      def find_orphans
+        @db.list_tasks.select do |task|
+          task.parent_id && !@db.find_task(task.parent_id)
+        end
+      end
+
+      def find_potential_bottlenecks
+        bottlenecks = []
+
+        @db.list_tasks(status: "open").each do |task|
+          incoming = @db.find_dependencies(task.id, direction: :incoming).count
+          outgoing = @db.find_dependencies(task.id, direction: :outgoing).count
+
+          if incoming >= 3 || outgoing >= 3
+            bottlenecks << {
+              id: task.id,
+              title: task.title,
+              incoming_deps: incoming,
+              outgoing_deps: outgoing
+            }
+          end
+        end
+
+        bottlenecks.sort_by { |b| -(b[:incoming_deps] + b[:outgoing_deps]) }
+      end
+
+      def node_color(task)
+        status_color = COLORS[:status][task.status.to_sym]
+        return status_color if status_color
+
+        priority_colors = {
+          0 => COLORS[:priority][:critical],
+          1 => COLORS[:priority][:high],
+          2 => COLORS[:priority][:medium],
+          3 => COLORS[:priority][:low]
+        }
+        priority_colors[task.priority] || COLORS[:priority][:backlog]
+      end
+
+      def edge_style(dep)
+        type_key = dep.type.tr("-", "_").to_sym
+        color = COLORS[:edge][type_key]
+        return "" unless color
+
+        style = case dep.type
+                when "blocks" then "bold"
+                when "parent-child", "related", "discovered-from" then "dashed"
+                else "solid"
+                end
+        style = "dotted" if %w[related discovered-from].include?(dep.type)
+
+        %(color="#{color}", style=#{style})
+      end
+
+      def truncate(str, length)
+        return str if str.length <= length
+
+        "#{str[0, length - 3]}..."
+      end
+    end
+  end
+end

data/lib/trak_flow/id_generator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  # Generates hash-based IDs to prevent merge conflicts when multiple
+  # agents or branches work simultaneously. The ID format is "tf-XXXX"
+  # where XXXX is a truncated hash derived from a UUID.
+  class IdGenerator
+    DEFAULT_PREFIX = "tf"
+    MIN_HASH_LENGTH = 4
+    MAX_HASH_LENGTH = 8
+
+    class << self
+      def generate(prefix: DEFAULT_PREFIX, existing_ids: [], min_length: MIN_HASH_LENGTH)
+        loop do
+          uuid = SecureRandom.uuid
+          hash = Digest::SHA256.hexdigest(uuid)[0, max_length_needed(existing_ids, min_length)]
+          id = "#{prefix}-#{hash}"
+
+          return id unless existing_ids.include?(id)
+        end
+      end
+
+      def generate_child_id(parent_id, child_index)
+        "#{parent_id}.#{child_index}"
+      end
+
+      def parent_id(child_id)
+        return nil unless child_id.include?(".")
+
+        child_id.split(".")[0..-2].join(".")
+      end
+
+      def valid?(id)
+        return false if id.nil? || id.empty?
+
+        id.match?(/^[a-z]+-[a-f0-9]{#{MIN_HASH_LENGTH},#{MAX_HASH_LENGTH}}(\.\d+)*$/i)
+      end
+
+      def content_hash(data)
+        Digest::SHA256.hexdigest(Oj.dump(data, mode: :compat))[0, 16]
+      end
+
+      private
+
+      def max_length_needed(existing_ids, min_length)
+        return min_length if existing_ids.empty?
+
+        [min_length, MAX_HASH_LENGTH].max
+      end
+    end
+  end
+end

data/lib/trak_flow/mcp/resources/base_resource.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  module Mcp
+    module Resources
+      class BaseResource < FastMcp::Resource
+        class << self
+          def with_database
+            TrakFlow.ensure_initialized!
+
+            db = Storage::Database.new
+            db.connect
+
+            jsonl = Storage::Jsonl.new
+            jsonl.import(db) if jsonl.exists?
+
+            yield db
+          ensure
+            db&.close
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trak_flow/mcp/resources/dependency_graph.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  module Mcp
+    module Resources
+      class DependencyGraph < BaseResource
+        uri "trak_flow://graph/dependencies"
+        resource_name "Dependency Graph"
+        description "Full dependency graph of all tasks"
+        mime_type "application/json"
+
+        def content
+          self.class.with_database do |db|
+            tasks = db.list_tasks
+            nodes = tasks.map { |t| { id: t.id, title: t.title, status: t.status } }
+
+            edges = []
+            tasks.each do |task|
+              db.find_dependencies(task.id, direction: :outgoing).each do |dep|
+                edges << { source: dep.source_id, target: dep.target_id, type: dep.type }
+              end
+            end
+
+            result = { nodes: nodes, edges: edges }
+            Oj.dump(result, mode: :compat, indent: 2)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trak_flow/mcp/resources/label_list.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  module Mcp
+    module Resources
+      class LabelList < BaseResource
+        uri "trak_flow://labels"
+        resource_name "Label List"
+        description "List of all unique labels in the system"
+        mime_type "application/json"
+
+        def content
+          self.class.with_database do |db|
+            labels = db.all_labels
+            Oj.dump(labels, mode: :compat, indent: 2)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trak_flow/mcp/resources/plan_by_id.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  module Mcp
+    module Resources
+      class PlanById < BaseResource
+        uri "trak_flow://plans/{id}"
+        resource_name "Plan by ID"
+        description "Get a Plan with its steps (child tasks)"
+        mime_type "application/json"
+
+        def content
+          self.class.with_database do |db|
+            plan = db.find_task!(params[:id])
+            steps = db.find_plan_tasks(plan.id)
+
+            result = {
+              plan: plan.to_h,
+              steps: steps.map(&:to_h)
+            }
+            Oj.dump(result, mode: :compat, indent: 2)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trak_flow/mcp/resources/plan_list.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  module Mcp
+    module Resources
+      class PlanList < BaseResource
+        uri "trak_flow://plans"
+        resource_name "Plan List"
+        description "List of all Plans (workflow blueprints)"
+        mime_type "application/json"
+
+        def content
+          self.class.with_database do |db|
+            plans = db.find_plans
+            Oj.dump(plans.map(&:to_h), mode: :compat, indent: 2)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trak_flow/mcp/resources/task_by_id.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  module Mcp
+    module Resources
+      class TaskById < BaseResource
+        uri "trak_flow://tasks/{id}"
+        resource_name "Task by ID"
+        description "Get a specific task by its ID, including labels, dependencies, and comments"
+        mime_type "application/json"
+
+        def content
+          self.class.with_database do |db|
+            task = db.find_task!(params[:id])
+            labels = db.find_labels(task.id)
+            deps = db.find_dependencies(task.id)
+            comments = db.find_comments(task.id)
+
+            result = {
+              task: task.to_h,
+              labels: labels.map(&:name),
+              dependencies: deps.map(&:to_h),
+              comments: comments.map(&:to_h)
+            }
+            Oj.dump(result, mode: :compat, indent: 2)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trak_flow/mcp/resources/task_list.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  module Mcp
+    module Resources
+      class TaskList < BaseResource
+        uri "trak_flow://tasks"
+        resource_name "Task List"
+        description "List of all tasks with their status and priority"
+        mime_type "application/json"
+
+        def content
+          self.class.with_database do |db|
+            tasks = db.list_tasks({})
+            Oj.dump(tasks.map(&:to_h), mode: :compat, indent: 2)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trak_flow/mcp/resources/task_next.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  module Mcp
+    module Resources
+      class TaskNext < BaseResource
+        uri "trak_flow://tasks/next"
+        resource_name "Next Actionable Task"
+        description "Get the next actionable task (highest priority with no blockers)"
+        mime_type "application/json"
+
+        def content
+          self.class.with_database do |db|
+            tasks = db.ready_tasks
+            next_task = tasks.first
+
+            if next_task
+              labels = db.find_labels(next_task.id)
+              result = { task: next_task.to_h, labels: labels.map(&:name) }
+            else
+              result = { task: nil, message: "No ready tasks found" }
+            end
+
+            Oj.dump(result, mode: :compat, indent: 2)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trak_flow/mcp/resources/workflow_by_id.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  module Mcp
+    module Resources
+      class WorkflowById < BaseResource
+        uri "trak_flow://workflows/{id}"
+        resource_name "Workflow by ID"
+        description "Get a Workflow with its tasks"
+        mime_type "application/json"
+
+        def content
+          self.class.with_database do |db|
+            workflow = db.find_task!(params[:id])
+            tasks = db.find_workflow_tasks(workflow.id)
+
+            result = {
+              workflow: workflow.to_h,
+              tasks: tasks.map(&:to_h)
+            }
+            Oj.dump(result, mode: :compat, indent: 2)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trak_flow/mcp/resources/workflow_list.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TrakFlow
+  module Mcp
+    module Resources
+      class WorkflowList < BaseResource
+        uri "trak_flow://workflows"
+        resource_name "Workflow List"
+        description "List of all Workflows (running instances of Plans)"
+        mime_type "application/json"
+
+        def content
+          self.class.with_database do |db|
+            workflows = db.find_workflows
+            Oj.dump(workflows.map(&:to_h), mode: :compat, indent: 2)
+          end
+        end
+      end
+    end
+  end
+end