openclacky 0.6.2 → 0.6.4

data/lib/clacky/config.rb

@@ -4,25 +4,92 @@ require "yaml"
 require "fileutils"
 
 module Clacky
+  # ClaudeCode environment variable compatibility layer
+  # Provides configuration detection from ClaudeCode's environment variables
+  module ClaudeCodeEnv
+    # Environment variable names used by ClaudeCode
+    ENV_API_KEY = "ANTHROPIC_API_KEY"
+    ENV_AUTH_TOKEN = "ANTHROPIC_AUTH_TOKEN"
+    ENV_BASE_URL = "ANTHROPIC_BASE_URL"
+
+    # Default Anthropic API endpoint
+    DEFAULT_BASE_URL = "https://api.anthropic.com"
+
+    class << self
+      # Check if any ClaudeCode authentication is configured
+      def configured?
+        !api_key.nil? && !api_key.empty?
+      end
+
+      # Get API key - prefer ANTHROPIC_API_KEY, fallback to ANTHROPIC_AUTH_TOKEN
+      def api_key
+        if ENV[ENV_API_KEY] && !ENV[ENV_API_KEY].empty?
+          ENV[ENV_API_KEY]
+        elsif ENV[ENV_AUTH_TOKEN] && !ENV[ENV_AUTH_TOKEN].empty?
+          ENV[ENV_AUTH_TOKEN]
+        end
+      end
+
+      # Get base URL from environment, or return default Anthropic API URL
+      def base_url
+        ENV[ENV_BASE_URL] && !ENV[ENV_BASE_URL].empty? ? ENV[ENV_BASE_URL] : DEFAULT_BASE_URL
+      end
+
+      # Get configuration as a hash (includes configured values)
+      # Returns api_key and base_url (always available as there's a default)
+      def to_h
+        {
+          "api_key" => api_key,
+          "base_url" => base_url
+        }.compact
+      end
+    end
+  end
+
   class Config
     CONFIG_DIR = File.join(Dir.home, ".clacky")
     CONFIG_FILE = File.join(CONFIG_DIR, "config.yml")
 
-    attr_accessor :api_key, :model, :base_url
+    # Default model for ClaudeCode environment
+    CLAUDE_DEFAULT_MODEL = "claude-sonnet-4-5"
+
+    attr_accessor :api_key, :model, :base_url, :config_source
 
     def initialize(data = {})
       @api_key = data["api_key"]
-      @model = data["model"] || "gpt-3.5-turbo"
+      @model = data["model"]
       @base_url = data["base_url"] || "https://api.openai.com"
+      @config_source = data["_config_source"] || "default"
     end
 
     def self.load(config_file = CONFIG_FILE)
+      # Load from config file first
       if File.exist?(config_file)
         data = YAML.load_file(config_file) || {}
-        new(data)
+        config_source = "file"
       else
-        new
+        data = {}
+        config_source = nil
+      end
+
+      # If api_key not found in config file, check ClaudeCode environment variables
+      if data["api_key"].nil? || data["api_key"].empty?
+        if ClaudeCodeEnv.configured?
+          data["api_key"] = ClaudeCodeEnv.api_key
+          data["base_url"] = ClaudeCodeEnv.base_url if data["base_url"].nil? || data["base_url"].empty?
+          # Use Claude default model if not specified in config file
+          data["model"] = CLAUDE_DEFAULT_MODEL if data["model"].nil? || data["model"].empty?
+          config_source = "claude_code"
+        elsif config_source.nil?
+          config_source = "default"
+        end
+      elsif config_source.nil?
+        # Config file existed but didn't have api_key
+        config_source = "default"
       end
+
+      data["_config_source"] = config_source
+      new(data)
     end
 
     def save(config_file = CONFIG_FILE)

data/lib/clacky/default_skills/skill-add/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: skill-add
+description: Guide for creating new SKILL.md files
+disable-model-invocation: false
+user-invocable: true
+---
+
+# Skill Creation Guide
+
+## SKILL.md Structure
+
+### 1. Front Matter (Required)
+```yaml
+---
+name: skill-name
+description: Brief one-line description
+disable-model-invocation: false
+user-invocable: true
+---
+```
+
+### 2. Main Content
+```markdown
+# Skill Title
+
+## Usage
+How to invoke: "command description" or `/skill-name`
+
+## Process Steps
+
+### 1. First Step
+What to do
+
+### 2. Next Step
+Continue the task
+
+## Commands Used
+```bash
+# Key commands
+```
+
+## Notes
+- Important points
+```
+
+## File Location
+`.clacky/skills/{skill-name}/SKILL.md`
+
+## Minimal Example
+```markdown
+---
+name: hello
+description: Simple greeting
+disable-model-invocation: false
+user-invocable: true
+---
+
+# Hello Skill
+
+## Usage
+Say "hello" or `/hello`
+
+## Process Steps
+### 1. Greet user
+### 2. Offer help
+```

data/lib/clacky/skill.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module Clacky
+  # Represents a skill with its metadata and content.
+  # A skill is defined by a SKILL.md file with optional YAML frontmatter.
+  class Skill
+    # Frontmatter fields that are recognized
+    FRONTMATTER_FIELDS = %w[
+      name
+      description
+      disable-model-invocation
+      user-invocable
+      allowed-tools
+      context
+      agent
+      argument-hint
+      hooks
+    ].freeze
+
+    attr_reader :directory, :frontmatter, :source_path
+    attr_reader :name, :description, :content
+    attr_reader :disable_model_invocation, :user_invocable
+    attr_reader :allowed_tools, :context, :agent_type, :argument_hint, :hooks
+
+    # @param directory [Pathname, String] Path to the skill directory
+    # @param source_path [Pathname, String, nil] Optional source path for priority resolution
+    def initialize(directory, source_path: nil)
+      @directory = Pathname.new(directory)
+      @source_path = source_path ? Pathname.new(source_path) : @directory
+
+      load_skill
+    end
+
+    # Get the skill identifier (uses name from frontmatter or directory name)
+    # @return [String]
+    def identifier
+      @name || @directory.basename.to_s
+    end
+
+    # Check if skill can be invoked by user via slash command
+    # @return [Boolean]
+    def user_invocable?
+      @user_invocable.nil? || @user_invocable
+    end
+
+    # Check if skill can be automatically invoked by the model
+    # @return [Boolean]
+    def model_invocation_allowed?
+      !@disable_model_invocation
+    end
+
+    # Check if skill runs in a forked subagent context
+    # @return [Boolean]
+    def forked_context?
+      @context == "fork"
+    end
+
+    # Get the slash command for this skill
+    # @return [String] e.g., "/explain-code"
+    def slash_command
+      "/#{identifier}"
+    end
+
+    # Get the description for context loading
+    # Returns the description from frontmatter, or first paragraph of content
+    # @return [String]
+    def context_description
+      @description || extract_first_paragraph
+    end
+
+    # Get all supporting files in the skill directory (excluding SKILL.md)
+    # @return [Array<Pathname>]
+    def supporting_files
+      return [] unless @directory.exist?
+
+      @directory.children.reject { |p| p.basename.to_s == "SKILL.md" }
+    end
+
+    # Check if this skill has supporting files
+    # @return [Boolean]
+    def has_supporting_files?
+      supporting_files.any?
+    end
+
+    # Process the skill content with argument substitution
+    # @param arguments [String] Arguments passed to the skill
+    # @param shell_output [Hash] Shell command outputs for !command` syntax (optional)
+    # @return [String] Processed content
+    def process_content(arguments = "", shell_output: {})
+      processed_content = @content.dup
+
+      # Replace argument placeholders
+      processed_content = substitute_arguments(processed_content, arguments)
+
+      # Replace shell command outputs
+      shell_output.each do |command, output|
+        placeholder = "!`#{command}`"
+        processed_content.gsub!(placeholder, output.to_s)
+      end
+
+      processed_content
+    end
+
+    # Convert to a hash representation
+    # @return [Hash]
+    def to_h
+      {
+        name: identifier,
+        description: context_description,
+        directory: @directory.to_s,
+        source_path: @source_path.to_s,
+        user_invocable: user_invocable?,
+        model_invocation_allowed: model_invocation_allowed?,
+        forked_context: forked_context?,
+        allowed_tools: @allowed_tools,
+        argument_hint: @argument_hint,
+        content_length: @content.length
+      }
+    end
+
+    # Load content of a supporting file
+    # @param filename [String] Relative path from skill directory
+    # @return [String, nil] File contents or nil if not found
+    def read_supporting_file(filename)
+      file_path = @directory.join(filename)
+      file_path.exist? ? file_path.read : nil
+    end
+
+    private
+
+    def load_skill
+      skill_file = @directory.join("SKILL.md")
+
+      unless skill_file.exist?
+        raise Clacky::AgentError, "SKILL.md not found in skill directory: #{@directory}"
+      end
+
+      content = skill_file.read
+
+      # Parse frontmatter if present
+      if content.start_with?("---")
+        parse_frontmatter(content)
+      else
+        @frontmatter = {}
+        @content = content
+      end
+
+      # Set defaults
+      @user_invocable = true if @user_invocable.nil?
+      @disable_model_invocation = false if @disable_model_invocation.nil?
+
+      validate_frontmatter
+    end
+
+    def parse_frontmatter(content)
+      # Extract frontmatter between first and second "---"
+      frontmatter_match = content.match(/^---\n(.*?)\n---/m)
+
+      unless frontmatter_match
+        raise Clacky::AgentError, "Invalid frontmatter format in SKILL.md: missing closing ---"
+      end
+
+      yaml_content = frontmatter_match[1]
+      @frontmatter = YAML.safe_load(yaml_content) || {}
+
+      # Extract content after frontmatter
+      @content = content[frontmatter_match.end(0)..-1].to_s.strip
+
+      # Extract fields from frontmatter
+      @name = @frontmatter["name"]
+      @description = @frontmatter["description"]
+      @disable_model_invocation = @frontmatter["disable-model-invocation"]
+      @user_invocable = @frontmatter["user-invocable"]
+      @allowed_tools = @frontmatter["allowed-tools"]
+      @context = @frontmatter["context"]
+      @agent_type = @frontmatter["agent"]
+      @argument_hint = @frontmatter["argument-hint"]
+      @hooks = @frontmatter["hooks"]
+    end
+
+    def validate_frontmatter
+      # Validate name if provided
+      if @name
+        unless @name.match?(/^[a-z0-9][a-z0-9-]*$/)
+          raise Clacky::AgentError,
+            "Invalid skill name '#{@name}'. Use lowercase letters, numbers, and hyphens only (max 64 chars)."
+        end
+        if @name.length > 64
+          raise Clacky::AgentError, "Skill name '#{@name}' exceeds 64 characters."
+        end
+      end
+
+      # Validate context
+      if @context && @context != "fork"
+        raise Clacky::AgentError, "Invalid context '#{@context}'. Only 'fork' is supported."
+      end
+
+      # Validate allowed-tools format
+      if @allowed_tools && !@allowed_tools.is_a?(Array)
+        raise Clacky::AgentError, "allowed-tools must be an array of tool names"
+      end
+    end
+
+    def extract_first_paragraph
+      @content.split(/\n\n/).first.to_s
+    end
+
+    def substitute_arguments(content, arguments)
+      # Parse arguments as shell words for indexed access
+      args_array = arguments.shellsplit
+
+      # Replace $ARGUMENTS with all arguments
+      result = content.gsub("$ARGUMENTS", arguments.to_s)
+
+      # Replace $ARGUMENTS[N] with specific argument
+      result.gsub!(/\$ARGUMENTS\[(\d+)\]/) do
+        index = $1.to_i
+        args_array[index] || ""
+      end
+
+      # Replace $N shorthand ($0, $1, etc.)
+      result.gsub!(/\$([0-9]+)/) do
+        index = $1.to_i
+        args_array[index] || ""
+      end
+
+      # Replace ${CLAUDE_SESSION_ID} with empty string (session not available in current context)
+      result.gsub!(/\${CLAUDE_SESSION_ID}/, "")
+
+      result
+    end
+  end
+end