cf-mcp 0.9.2

data/lib/cf/mcp/models/doc_item.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module CF
+  module MCP
+    module Models
+      class DocItem
+        GITHUB_REPO = "https://github.com/RandyGaul/cute_framework"
+        GITHUB_RAW_BASE = "https://raw.githubusercontent.com/RandyGaul/cute_framework/refs/heads/master"
+
+        attr_accessor :name, :type, :category, :brief, :remarks, :example,
+          :example_brief, :related, :source_file, :source_line
+
+        def initialize(
+          name: nil,
+          type: nil,
+          category: nil,
+          brief: nil,
+          remarks: nil,
+          example: nil,
+          example_brief: nil,
+          related: [],
+          source_file: nil,
+          source_line: nil
+        )
+          @name = name
+          @type = type
+          @category = category
+          @brief = brief
+          @remarks = remarks
+          @example = example
+          @example_brief = example_brief
+          @related = related || []
+          @source_file = source_file
+          @source_line = source_line
+        end
+
+        def matches?(query)
+          return true if query.nil? || query.empty?
+
+          pattern = Regexp.new(Regexp.escape(query), Regexp::IGNORECASE)
+          [name, brief, remarks, category].any? { |field| field&.match?(pattern) }
+        end
+
+        # Returns a relevance score for ranking search results.
+        # Higher scores indicate better matches.
+        def relevance_score(query)
+          return 0 if query.nil? || query.empty?
+
+          score = 0
+          query_downcase = query.downcase
+          name_downcase = name&.downcase || ""
+
+          # Exact name match (highest priority)
+          if name_downcase == query_downcase
+            score += 1000
+          # Name starts with query (prefix match)
+          elsif name_downcase.start_with?(query_downcase)
+            score += 500
+          # Name ends with query (suffix match, e.g., "make_app" matches "cf_make_app")
+          elsif name_downcase.end_with?(query_downcase)
+            score += 400
+          # Name contains query
+          elsif name_downcase.include?(query_downcase)
+            score += 100
+          end
+
+          # Brief contains query
+          score += 50 if brief&.downcase&.include?(query_downcase)
+
+          # Category contains query
+          score += 30 if category&.downcase&.include?(query_downcase)
+
+          # Remarks contains query
+          score += 10 if remarks&.downcase&.include?(query_downcase)
+
+          score
+        end
+
+        def source_urls
+          return nil unless source_file
+          # Header file URLs (include/cute_xxx.h)
+          header_path = "include/#{source_file}"
+          raw = "#{GITHUB_RAW_BASE}/#{header_path}"
+          blob = "#{GITHUB_REPO}/blob/master/#{header_path}"
+          blob += "#L#{source_line}" if source_line
+
+          # Implementation file URL (src/cute_xxx.cpp)
+          impl_file = source_file.sub(/\.h$/, ".cpp")
+          impl_raw = "#{GITHUB_RAW_BASE}/src/#{impl_file}"
+
+          {raw: raw, blob: blob, impl_raw: impl_raw}
+        end
+
+        def to_h
+          {
+            name: name,
+            type: type,
+            category: category,
+            brief: brief,
+            remarks: remarks,
+            example: example,
+            example_brief: example_brief,
+            related: related,
+            source_file: source_file,
+            source_line: source_line
+          }.compact
+        end
+
+        def to_summary
+          "- **#{name}** `(#{type}, #{category})` — #{brief}"
+        end
+
+        def to_text(detailed: false, index: nil)
+          lines = []
+          lines << "# #{name}"
+          lines << ""
+          lines << "- **Type:** #{type}"
+          lines << "- **Category:** #{category}" if category
+          if source_file
+            urls = source_urls
+            lines << "- **Source:** [include/#{source_file}](#{urls[:blob]})"
+            lines << "- **Raw:** #{urls[:raw]}"
+            lines << "- **Implementation:** #{urls[:impl_raw]}"
+          end
+          lines << ""
+          lines << "## Description"
+          lines << brief if brief
+          lines << ""
+
+          if detailed
+            if remarks && !remarks.empty?
+              lines << "## Remarks"
+              lines << remarks
+              lines << ""
+            end
+
+            if example && !example.empty?
+              lines << "## Example"
+              lines << example_brief if example_brief
+              lines << "```c"
+              lines << example
+              lines << "```"
+              lines << ""
+            end
+
+            if related && !related.empty?
+              lines << "## Related"
+              lines << format_related_items(index)
+              lines << ""
+            end
+          end
+
+          lines.join("\n")
+        end
+
+        def format_related_items(index)
+          return related.join(", ") unless index
+
+          related.map do |rel_name|
+            info = index.brief_for(rel_name)
+            if info
+              "- `#{info[:name]}` (#{info[:type]}) — #{info[:brief]}"
+            else
+              "- `#{rel_name}`"
+            end
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/cf/mcp/models/enum_doc.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "doc_item"
+
+module CF
+  module MCP
+    module Models
+      class EnumDoc < DocItem
+        attr_accessor :entries
+
+        Entry = Data.define(:name, :value, :description)
+
+        def initialize(
+          entries: [],
+          **kwargs
+        )
+          super(type: :enum, **kwargs)
+          @entries = entries || []
+        end
+
+        def to_h
+          super.merge(
+            entries: entries.map { |e| {name: e.name, value: e.value, description: e.description} }
+          ).compact
+        end
+
+        def to_text(detailed: false, index: nil)
+          lines = []
+          lines << "# #{name}"
+          lines << ""
+          lines << "- **Type:** enum"
+          lines << "- **Category:** #{category}" if category
+          if source_file
+            urls = source_urls
+            lines << "- **Source:** [include/#{source_file}](#{urls[:blob]})"
+            lines << "- **Raw:** #{urls[:raw]}"
+            lines << "- **Implementation:** #{urls[:impl_raw]}"
+          end
+          lines << ""
+          lines << "## Description"
+          lines << brief if brief
+          lines << ""
+
+          if detailed
+            if entries && !entries.empty?
+              lines << "## Values"
+              lines << ""
+              lines << "| Name | Value | Description |"
+              lines << "| --- | --- | --- |"
+              entries.each do |entry|
+                lines << "| `#{entry.name}` | #{entry.value} | #{entry.description} |"
+              end
+              lines << ""
+            end
+
+            if remarks && !remarks.empty?
+              lines << "## Remarks"
+              lines << remarks
+              lines << ""
+            end
+
+            if example && !example.empty?
+              lines << "## Example"
+              lines << example_brief if example_brief
+              lines << "```c"
+              lines << example
+              lines << "```"
+              lines << ""
+            end
+
+            if related && !related.empty?
+              lines << "## Related"
+              lines << format_related_items(index)
+              lines << ""
+            end
+          end
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/cf/mcp/models/function_doc.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "doc_item"
+
+module CF
+  module MCP
+    module Models
+      class FunctionDoc < DocItem
+        attr_accessor :signature, :parameters, :return_value
+
+        Parameter = Data.define(:name, :description)
+
+        def initialize(
+          signature: nil,
+          parameters: [],
+          return_value: nil,
+          **kwargs
+        )
+          super(type: :function, **kwargs)
+          @signature = signature
+          @parameters = parameters || []
+          @return_value = return_value
+        end
+
+        def to_h
+          super.merge(
+            signature: signature,
+            parameters: parameters.map { |p| {name: p.name, description: p.description} },
+            return_value: return_value
+          ).compact
+        end
+
+        def to_summary
+          lines = ["- **#{name}** `(#{type}, #{category})` — #{brief}"]
+          lines << "  `#{signature}`" if signature
+          lines.join("\n")
+        end
+
+        def to_text(detailed: false, index: nil)
+          lines = []
+          lines << "# #{name}"
+          lines << ""
+          lines << "- **Type:** function"
+          lines << "- **Category:** #{category}" if category
+          if source_file
+            urls = source_urls
+            lines << "- **Source:** [include/#{source_file}](#{urls[:blob]})"
+            lines << "- **Raw:** #{urls[:raw]}"
+            lines << "- **Implementation:** #{urls[:impl_raw]}"
+          end
+          lines << ""
+
+          if signature
+            lines << "## Signature"
+            lines << "```c"
+            lines << signature
+            lines << "```"
+            lines << ""
+          end
+
+          lines << "## Description"
+          lines << brief if brief
+          lines << ""
+
+          if detailed
+            if parameters && !parameters.empty?
+              lines << "## Parameters"
+              lines << ""
+              lines << "| Parameter | Description |"
+              lines << "| --- | --- |"
+              parameters.each do |param|
+                lines << "| `#{param.name}` | #{param.description} |"
+              end
+              lines << ""
+            end
+
+            if return_value && !return_value.empty?
+              lines << "## Return Value"
+              lines << return_value
+              lines << ""
+            end
+
+            if remarks && !remarks.empty?
+              lines << "## Remarks"
+              lines << remarks
+              lines << ""
+            end
+
+            if example && !example.empty?
+              lines << "## Example"
+              lines << example_brief if example_brief
+              lines << "```c"
+              lines << example
+              lines << "```"
+              lines << ""
+            end
+
+            if related && !related.empty?
+              lines << "## Related"
+              lines << format_related_items(index)
+              lines << ""
+            end
+          end
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/cf/mcp/models/struct_doc.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "doc_item"
+
+module CF
+  module MCP
+    module Models
+      class StructDoc < DocItem
+        attr_accessor :members
+
+        Member = Data.define(:declaration, :description)
+
+        def initialize(
+          members: [],
+          **kwargs
+        )
+          super(type: :struct, **kwargs)
+          @members = members || []
+        end
+
+        def to_h
+          super.merge(
+            members: members.map { |m| {declaration: m.declaration, description: m.description} }
+          ).compact
+        end
+
+        def to_text(detailed: false, index: nil)
+          lines = []
+          lines << "# #{name}"
+          lines << ""
+          lines << "- **Type:** struct"
+          lines << "- **Category:** #{category}" if category
+          if source_file
+            urls = source_urls
+            lines << "- **Source:** [include/#{source_file}](#{urls[:blob]})"
+            lines << "- **Raw:** #{urls[:raw]}"
+            lines << "- **Implementation:** #{urls[:impl_raw]}"
+          end
+          lines << ""
+          lines << "## Description"
+          lines << brief if brief
+          lines << ""
+
+          if detailed
+            if members && !members.empty?
+              lines << "## Members"
+              lines << ""
+              lines << "| Member | Description |"
+              lines << "| --- | --- |"
+              members.each do |member|
+                lines << "| `#{member.declaration}` | #{member.description} |"
+              end
+              lines << ""
+            end
+
+            if remarks && !remarks.empty?
+              lines << "## Remarks"
+              lines << remarks
+              lines << ""
+            end
+
+            if example && !example.empty?
+              lines << "## Example"
+              lines << example_brief if example_brief
+              lines << "```c"
+              lines << example
+              lines << "```"
+              lines << ""
+            end
+
+            if related && !related.empty?
+              lines << "## Related"
+              lines << format_related_items(index)
+              lines << ""
+            end
+          end
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/cf/mcp/models/topic_doc.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module CF
+  module MCP
+    module Models
+      class TopicDoc < DocItem
+        attr_accessor :content, :sections, :function_references, :struct_references,
+          :enum_references, :topic_references, :reading_order
+
+        Section = Data.define(:title, :content)
+
+        def initialize(
+          content: nil,
+          sections: [],
+          function_references: [],
+          struct_references: [],
+          enum_references: [],
+          topic_references: [],
+          reading_order: nil,
+          **kwargs
+        )
+          super(type: :topic, **kwargs)
+          @content = content
+          @sections = sections || []
+          @function_references = function_references || []
+          @struct_references = struct_references || []
+          @enum_references = enum_references || []
+          @topic_references = topic_references || []
+          @reading_order = reading_order
+        end
+
+        def all_api_references
+          function_references + struct_references + enum_references
+        end
+
+        def to_h
+          super.merge(
+            content: content,
+            sections: sections.map { |s| {title: s.title, content: s.content} },
+            function_references: function_references,
+            struct_references: struct_references,
+            enum_references: enum_references,
+            topic_references: topic_references,
+            reading_order: reading_order
+          ).compact
+        end
+
+        def to_summary
+          "- **#{name}** `(topic)` — #{brief}"
+        end
+
+        def to_text(detailed: false, index: nil)
+          lines = []
+          lines << "# #{name}"
+          lines << ""
+          lines << "**Type:** topic"
+          lines << "**Category:** #{category}" if category
+          lines << "**Source:** #{source_file}" if source_file
+          lines << ""
+          lines << "## Overview"
+          lines << brief if brief
+          lines << ""
+
+          if detailed
+            lines << "## Content"
+            lines << ""
+            lines << content if content
+            lines << ""
+
+            if function_references.any?
+              lines << "## Referenced Functions"
+              lines << format_api_references(function_references, index)
+              lines << ""
+            end
+
+            if struct_references.any?
+              lines << "## Referenced Structs"
+              lines << format_api_references(struct_references, index)
+              lines << ""
+            end
+
+            if enum_references.any?
+              lines << "## Referenced Enums"
+              lines << format_api_references(enum_references, index)
+              lines << ""
+            end
+
+            if topic_references.any?
+              lines << "## Related Topics"
+              lines << topic_references.map { |t| "- #{t}" }.join("\n")
+              lines << ""
+            end
+          end
+
+          lines.join("\n")
+        end
+
+        private
+
+        def format_api_references(refs, index)
+          refs.map do |ref_name|
+            if index
+              info = index.brief_for(ref_name)
+              info ? "- `#{info[:name]}` — #{info[:brief]}" : "- `#{ref_name}`"
+            else
+              "- `#{ref_name}`"
+            end
+          end.join("\n")
+        end
+      end
+    end
+  end
+end