agentf 0.3.0

data/lib/agentf/commands/designer.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+
+module Agentf
+  module Commands
+    class Designer
+      NAME = "designer"
+
+      def self.manifest
+        {
+          "name" => NAME,
+          "description" => "Generate components from design specs and validate design systems.",
+          "commands" => [
+            { "name" => "generate_component", "type" => "function" },
+            { "name" => "validate_design_system", "type" => "function" }
+          ]
+        }
+      end
+
+      def initialize(base_path: nil)
+        @base_path = base_path || Agentf.config.base_path
+        detect_design_system
+      end
+
+      # Generate component code from design spec
+      def generate_component(name, design_spec, style_system: nil, framework: nil)
+        style = style_system || @style_system
+        fw = framework || @framework
+
+        props = parse_design_spec(design_spec)
+
+        code = if fw == "vue"
+                 generate_vue(name, props, design_spec)
+               elsif style == "tailwind" && fw == "react"
+                 generate_react_tailwind(name, props, design_spec)
+               elsif style == "css" && fw == "react"
+                 generate_react_css(name, props, design_spec)
+               else
+                 generate_react_css(name, props, design_spec)
+               end
+
+        Agentf::Tools::ComponentSpec.new(
+          name: name,
+          code: code,
+          framework: fw,
+          style: style,
+          props: props
+        )
+      end
+
+      # Check design system consistency
+      def validate_design_system
+        base = Pathname.new(@base_path)
+
+        results = {
+          "framework" => @framework,
+          "style_system" => @style_system,
+          "components_found" => [],
+          "issues" => []
+        }
+
+        %w[.tsx .jsx .vue .js].each do |ext|
+          base.glob("**/*#{ext}").first(10).each do |p|
+            results["components_found"] << p.relative_path_from(base).to_s
+          end
+        end
+
+        results
+      end
+
+      private
+
+      def detect_design_system
+        base = Pathname.new(@base_path)
+        @framework = "react"
+        @style_system = "css"
+
+        # Check package.json
+        pkg_path = base.join("package.json")
+        if pkg_path.exist?
+          pkg = JSON.parse(pkg_path.read)
+          deps = pkg.fetch("dependencies", {}).merge(pkg.fetch("devDependencies", {}))
+
+          @framework = "vue" if deps.key?("vue")
+          @style_system = "tailwind" if deps.key?("tailwindcss")
+          @style_system = "material-ui" if deps.key?("@mui/material")
+        end
+
+        # Check for Rails
+        if (base / "Gemfile").exist? && base.join("Gemfile").read.include?("rails")
+          @framework = "rails"
+          @style_system = "css"
+        end
+      end
+
+      def parse_design_spec(spec)
+        props = []
+
+        spec.scan(/(\w+):\s*(\w+)/) do |prop_name, prop_type|
+          next if %w[class style on ref].include?(prop_name)
+          props << { "name" => prop_name, "type" => prop_type, "required" => spec.downcase.include?("required").to_s }
+        end
+
+        props
+      end
+
+      def generate_react_tailwind(name, props, _spec)
+        props_interface = props.map { |p| "  #{p['name']}: #{p['type']};" }.join("\n")
+        props_destructure = props.map { |p| p['name'] }.join(", ")
+
+        <<~RUBY
+          import React from 'react';
+
+          interface #{name}Props {
+          #{props_interface.empty? ? "  // No props" : props_interface}
+          }
+
+          export function #{name}({ #{props_destructure} }: #{name}Props) {
+            return (
+              <div className="flex flex-col gap-4 p-4">
+                {/* Content here */}
+              </div>
+            );
+          }
+        RUBY
+      end
+
+      def generate_react_css(name, props, _spec)
+        props_interface = props.map { |p| "  #{p['name']}: #{p['type']};" }.join("\n")
+        props_destructure = props.map { |p| p['name'] }.join(", ")
+
+        <<~RUBY
+          import React from 'react';
+          import './#{name}.css';
+
+          interface #{name}Props {
+          #{props_interface.empty? ? "  // No props" : props_interface}
+          }
+
+          export function #{name}({ #{props_destructure} }: #{name}Props) {
+            return (
+              <div className="#{name}">
+                {/* Content here */}
+              </div>
+            );
+          }
+        RUBY
+      end
+
+      def generate_vue(name, props, _spec)
+        props_interface = props.map { |p| "  #{p['name']}: #{p['type']};" }.join("\n")
+
+        <<~RUBY
+          <template>
+            <div class="#{name}">
+              <!-- Content here -->
+            </div>
+          </template>
+
+          <script setup lang="ts">
+          interface Props {
+          #{props_interface.empty? ? "  // No props" : props_interface}
+          }
+
+          const props = defineProps<Props>();
+          </script>
+
+          <style scoped>
+          .#{name} {
+            /* styles here */
+          }
+          </style>
+        RUBY
+      end
+    end
+  end
+end

data/lib/agentf/commands/explorer.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "open3"
+require "pathname"
+
+module Agentf
+  module Commands
+    class Explorer
+      NAME = "explorer"
+
+      def self.manifest
+        {
+          "name" => NAME,
+          "description" => "Find files, search code, and explore project structure.",
+          "commands" => [
+            { "name" => "glob", "type" => "function" },
+            { "name" => "grep", "type" => "function" },
+            { "name" => "get_file_tree", "type" => "function" },
+            { "name" => "find_related_files", "type" => "function" }
+          ]
+        }
+      end
+
+      def initialize(base_path: nil)
+        @base_path = base_path || Agentf.config.base_path
+      end
+
+      # Find files matching a glob pattern
+      def glob(pattern, file_types: nil)
+        base = Pathname.new(@base_path)
+        matches = []
+
+        base.glob(pattern).each do |match|
+          next unless match.file?
+
+          if file_types
+            matches << match.relative_path_from(base).to_s if file_types.include?(match.extname.delete("."))
+          else
+            matches << match.relative_path_from(base).to_s
+          end
+        end
+
+        matches.sort
+      rescue StandardError => e
+        [{ "error" => e.message }]
+      end
+
+      # Search for pattern in files
+      def grep(pattern, file_pattern: nil, context_lines: 2)
+        cmd = ["grep", "-rn"]
+        cmd << "--include=#{file_pattern || '*'}" if file_pattern
+        cmd << pattern
+        cmd << @base_path
+
+        stdout, _stderr, _status = Open3.capture3(*cmd)
+
+        matches = []
+        stdout.lines.each do |line|
+          parts = line.split(":", 3)
+          next unless parts.length >= 3
+
+          begin
+            line_num = Integer(parts[1])
+            matches << Agentf::Tools::FileMatch.new(
+              path: parts[0],
+              line_number: line_num,
+              content: parts[2].strip,
+              match_type: "pattern"
+            )
+          rescue ArgumentError
+            # Skip invalid line numbers
+          end
+        end
+
+        matches
+      rescue StandardError => e
+        [{ "error" => e.message }]
+      end
+
+      # Get directory tree structure
+      def get_file_tree(max_depth: 3, exclude_dirs: nil)
+        exclude_dirs ||= %w[node_modules .git __pycache__ .venv venv dist build]
+        base = Pathname.new(@base_path)
+
+        build_tree(base, 0, max_depth, exclude_dirs)
+      end
+
+      # Find related files based on imports/exports
+      def find_related_files(target_file)
+        base = Pathname.new(@base_path)
+        target = base + target_file
+
+        return { "error" => "File not found" } unless target.exist?
+
+        content = target.read
+        result = { "imports" => [], "imported_by" => [], "tests" => [], "similar" => [] }
+
+        # Ruby imports
+        if target.extname == ".rb"
+          content.scan(/^(?:require|require_relative)\s+['"]([^'"]+)['"]/) do |match|
+            result["imports"] << match[0]
+          end
+        end
+
+        # Python imports
+        if target.extname == ".py"
+          content.scan(/^(?:from|import)\s+([\w.]+)/) do |match|
+            result["imports"] << match[0]
+          end
+        end
+
+        # JS/TS imports
+        if %w[.js .ts .jsx .tsx].include?(target.extname)
+          content.scan(/(?:import|require)\s+['"]([^'"]+)['"]/) do |match|
+            result["imports"] << match[0]
+          end
+        end
+
+        # Discover files that reference the target file by basename or relative path fragment
+        target_stem = target.basename.sub_ext("").to_s
+        search_tokens = [target_stem, target_file.gsub(target.extname, "")].uniq
+        base.glob("**/*#{target.extname}").each do |file|
+          next if file == target
+          next unless file.file?
+
+          file_content = safe_read(file)
+          next if file_content.empty?
+
+          if search_tokens.any? { |token| file_content.include?(token) }
+            result["imported_by"] << file.relative_path_from(base).to_s
+          end
+        end
+
+        # Test companions by naming convention
+        target_dir = target.dirname.relative_path_from(base).to_s
+        target_name = target.basename.sub_ext("").to_s
+        test_patterns = [
+          "spec/**/*#{target_name}*_spec.rb",
+          "test/**/*#{target_name}*_test.rb",
+          "**/*#{target_name}.test.js",
+          "**/*#{target_name}.test.ts",
+          "**/*#{target_name}.spec.js",
+          "**/*#{target_name}.spec.ts"
+        ]
+
+        test_patterns.each do |pattern|
+          base.glob(pattern).each do |match|
+            rel = match.relative_path_from(base).to_s
+            result["tests"] << rel if rel.include?(target_name) || rel.include?(target_dir)
+          end
+        end
+
+        # Similar files in same directory by prefix
+        sibling_prefix = target_name.split("_").first
+        target.dirname.children.each do |child|
+          next unless child.file?
+          next if child == target
+
+          name = child.basename.sub_ext("").to_s
+          result["similar"] << child.relative_path_from(base).to_s if name.start_with?(sibling_prefix)
+        end
+
+        result["imports"].uniq!
+        result["imported_by"].uniq!
+        result["tests"].uniq!
+        result["similar"].uniq!
+
+        result
+      rescue StandardError => e
+        { "error" => e.message }
+      end
+
+      private
+
+      def build_tree(path, depth, max_depth, exclude_dirs)
+        return {} if depth > max_depth
+
+        tree = { "type" => "directory", "name" => path.basename.to_s, "children" => [] }
+
+        begin
+          path.children.sort.each do |item|
+            next if exclude_dirs.include?(item.basename.to_s)
+
+            if item.directory?
+              tree["children"] << build_tree(item, depth + 1, max_depth, exclude_dirs)
+            else
+              tree["children"] << {
+                "type" => "file",
+                "name" => item.basename.to_s,
+                "ext" => item.extname
+              }
+            end
+          end
+        rescue Errno::EACCES
+          # Permission denied, skip
+        end
+
+        tree
+      end
+
+      def safe_read(path)
+        path.read
+      rescue StandardError
+        ""
+      end
+    end
+  end
+end

data/lib/agentf/commands/memory_reviewer.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module Agentf
+  module Commands
+    # Tool for reviewing Redis-stored memories and learnings
+    class MemoryReviewer
+      NAME = "memory"
+
+      def self.manifest
+        {
+          "name" => NAME,
+          "description" => "Review and query Redis-stored memories, pitfalls, and learnings.",
+          "commands" => [
+            { "name" => "get_recent_memories", "type" => "function" },
+            { "name" => "get_pitfalls", "type" => "function" },
+            { "name" => "get_lessons", "type" => "function" },
+            { "name" => "get_successes", "type" => "function" },
+            { "name" => "get_all_tags", "type" => "function" },
+            { "name" => "get_by_tag", "type" => "function" },
+            { "name" => "get_by_type", "type" => "function" },
+            { "name" => "get_by_agent", "type" => "function" },
+            { "name" => "search", "type" => "function" },
+            { "name" => "get_summary", "type" => "function" }
+          ]
+        }
+      end
+
+      def initialize(project: nil)
+        @project = project || Agentf.config.project_name
+        @memory = Agentf::Memory::RedisMemory.new(project: @project)
+      end
+
+      # Get recent memories
+      def get_recent_memories(limit: 10)
+        memories = @memory.get_recent_memories(limit: limit)
+        format_memories(memories)
+      rescue => e
+        { "error" => e.message }
+      end
+
+      # Get all pitfalls (things that went wrong)
+      def get_pitfalls(limit: 10)
+        pitfalls = @memory.get_pitfalls(limit: limit)
+        format_memories(pitfalls)
+      rescue => e
+        { "error" => e.message }
+      end
+
+      # Get all lessons learned
+      def get_lessons(limit: 10)
+        lessons = @memory.get_memories_by_type(type: "lesson", limit: limit)
+        format_memories(lessons)
+      rescue => e
+        { "error" => e.message }
+      end
+
+      # Get all successes
+      def get_successes(limit: 10)
+        successes = @memory.get_memories_by_type(type: "success", limit: limit)
+        format_memories(successes)
+      rescue => e
+        { "error" => e.message }
+      end
+
+      def get_business_intents(limit: 10)
+        intents = @memory.get_intents(kind: "business", limit: limit)
+        format_memories(intents)
+      rescue => e
+        { "error" => e.message }
+      end
+
+      def get_feature_intents(limit: 10)
+        intents = @memory.get_intents(kind: "feature", limit: limit)
+        format_memories(intents)
+      rescue => e
+        { "error" => e.message }
+      end
+
+      # Get all unique tags from memories
+      def get_all_tags
+        tags = @memory.get_all_tags
+        { "tags" => tags.sort, "count" => tags.length }
+      rescue => e
+        { "error" => e.message }
+      end
+
+      # Get memories by tag
+      def get_by_tag(tag, limit: 10)
+        memories = @memory.get_recent_memories(limit: 100)
+        filtered = memories.select { |m| m["tags"]&.include?(tag) }
+        format_memories(filtered.first(limit))
+      rescue => e
+        { "error" => e.message }
+      end
+
+      # Get memories by type (pitfall, lesson, success)
+      def get_by_type(type, limit: 10)
+        memories = @memory.get_recent_memories(limit: 100)
+        filtered = memories.select { |m| m["type"] == type }
+        format_memories(filtered.first(limit))
+      rescue => e
+        { "error" => e.message }
+      end
+
+      # Get memories by agent
+      def get_by_agent(agent, limit: 10)
+        memories = @memory.get_recent_memories(limit: 100)
+        filtered = memories.select { |m| m["agent"] == agent }
+        format_memories(filtered.first(limit))
+      rescue => e
+        { "error" => e.message }
+      end
+
+      # Search memories by keyword in title or description
+      def search(query, limit: 10)
+        memories = @memory.get_recent_memories(limit: 100)
+        q = query.downcase
+        filtered = memories.select do |m|
+          m["title"]&.downcase&.include?(q) ||
+            m["description"]&.downcase&.include?(q) ||
+            m["context"]&.downcase&.include?(q)
+        end
+        format_memories(filtered.first(limit))
+      rescue => e
+        { "error" => e.message }
+      end
+
+      # Get summary statistics
+      def get_summary
+        memories = @memory.get_recent_memories(limit: 100)
+        tags = @memory.get_all_tags
+
+        {
+          "total_memories" => memories.length,
+          "by_type" => {
+            "pitfall" => memories.count { |m| m["type"] == "pitfall" },
+            "lesson" => memories.count { |m| m["type"] == "lesson" },
+            "success" => memories.count { |m| m["type"] == "success" },
+            "business_intent" => memories.count { |m| m["type"] == "business_intent" },
+            "feature_intent" => memories.count { |m| m["type"] == "feature_intent" }
+          },
+          "by_agent" => memories.each_with_object(Hash.new(0)) { |m, h| h[m["agent"]] += 1 },
+          "unique_tags" => tags.length,
+          "project" => @project
+        }
+      rescue => e
+        { "error" => e.message }
+      end
+
+      private
+
+      def format_memories(memories)
+        return { "memories" => [], "count" => 0 } if memories.empty?
+
+        formatted = memories.map { |m| format_single_memory(m) }
+        { "memories" => formatted, "count" => formatted.length }
+      end
+
+      def format_single_memory(m)
+        {
+          "id" => m["id"],
+          "type" => m["type"],
+          "title" => m["title"],
+          "description" => m["description"],
+          "context" => m["context"],
+          "code_snippet" => m["code_snippet"],
+          "tags" => m["tags"],
+          "agent" => m["agent"],
+          "created_at" => format_time(m["created_at"]),
+          "created_at_unix" => m["created_at"]
+        }
+      end
+
+      def format_time(unix_time)
+        return nil unless unix_time
+
+        Time.at(unix_time).strftime("%Y-%m-%d %H:%M:%S")
+      rescue
+        nil
+      end
+    end
+  end
+end