openclacky 0.5.1

data/lib/clacky/tools/write.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Clacky
+  module Tools
+    class Write < Base
+      self.tool_name = "write"
+      self.tool_description = "Write content to a file. Creates new files or overwrites existing ones."
+      self.tool_category = "file_system"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "The path of the file to write (absolute or relative)"
+          },
+          content: {
+            type: "string",
+            description: "The content to write to the file"
+          }
+        },
+        required: %w[path content]
+      }
+
+      def execute(path:, content:)
+        # Validate path
+        if path.nil? || path.strip.empty?
+          return { error: "Path cannot be empty" }
+        end
+
+        begin
+          # Ensure parent directory exists
+          dir = File.dirname(path)
+          FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+
+          # Write content to file
+          File.write(path, content)
+
+          {
+            path: File.expand_path(path),
+            bytes_written: content.bytesize,
+            error: nil
+          }
+        rescue Errno::EACCES => e
+          { error: "Permission denied: #{e.message}" }
+        rescue Errno::ENOSPC => e
+          { error: "No space left on device: #{e.message}" }
+        rescue StandardError => e
+          { error: "Failed to write file: #{e.message}" }
+        end
+      end
+
+      def format_call(args)
+        path = args[:path] || args['path']
+        "Write(#{Utils::PathHelper.safe_basename(path)})"
+      end
+
+      def format_result(result)
+        return result[:error] if result[:error]
+
+        bytes = result[:bytes_written] || result['bytes_written'] || 0
+        "Written #{bytes} bytes"
+      end
+    end
+  end
+end

data/lib/clacky/trash_directory.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+
+module Clacky
+  # Manages global trash directory at ~/.clacky/trash
+  # Organizes trash by project directory using path hash
+  class TrashDirectory
+    GLOBAL_TRASH_ROOT = File.join(Dir.home, ".clacky", "trash")
+
+    attr_reader :project_root, :trash_dir, :backup_dir
+
+    def initialize(project_root = Dir.pwd)
+      @project_root = File.expand_path(project_root)
+      @project_hash = generate_project_hash(@project_root)
+      @trash_dir = File.join(GLOBAL_TRASH_ROOT, @project_hash)
+      @backup_dir = File.join(@trash_dir, "backups")
+      
+      setup_directories
+    end
+
+    # Generate a unique hash for project path
+    def generate_project_hash(path)
+      # Use MD5 hash of the absolute path, take first 16 chars for readability
+      hash = Digest::MD5.hexdigest(path)[0..15]
+      # Also include a readable suffix based on project name
+      project_name = File.basename(path).gsub(/[^a-zA-Z0-9_-]/, '_')[0..20]
+      "#{hash}_#{project_name}"
+    end
+
+    # Setup trash and backup directories with proper structure
+    def setup_directories
+      [@trash_dir, @backup_dir].each do |dir|
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+
+        # Create .gitignore file to avoid trash files being committed
+        gitignore_path = File.join(dir, '.gitignore')
+        unless File.exist?(gitignore_path)
+          File.write(gitignore_path, "*\n!.gitignore\n")
+        end
+      end
+
+      # Create project metadata file
+      create_project_metadata
+    end
+
+    # Create or update metadata about this project
+    def create_project_metadata
+      metadata_file = File.join(@trash_dir, '.project_metadata.json')
+      
+      metadata = {
+        project_root: @project_root,
+        project_name: File.basename(@project_root),
+        project_hash: @project_hash,
+        created_at: File.exist?(metadata_file) ? JSON.parse(File.read(metadata_file))['created_at'] : Time.now.iso8601,
+        last_accessed: Time.now.iso8601
+      }
+      
+      File.write(metadata_file, JSON.pretty_generate(metadata))
+    rescue StandardError => e
+      # Log warning but don't block operation
+      warn "Warning: Could not create project metadata: #{e.message}"
+    end
+
+    # Get all project directories that have trash
+    def self.all_projects
+      return [] unless Dir.exist?(GLOBAL_TRASH_ROOT)
+      
+      projects = []
+      Dir.glob(File.join(GLOBAL_TRASH_ROOT, "*", ".project_metadata.json")).each do |metadata_file|
+        begin
+          metadata = JSON.parse(File.read(metadata_file))
+          projects << {
+            project_root: metadata['project_root'],
+            project_name: metadata['project_name'],
+            project_hash: metadata['project_hash'],
+            trash_dir: File.dirname(metadata_file),
+            last_accessed: metadata['last_accessed']
+          }
+        rescue StandardError
+          # Skip corrupted metadata
+        end
+      end
+      
+      projects.sort_by { |p| p[:last_accessed] }.reverse
+    end
+
+    # Get trash directory for a specific project
+    def self.for_project(project_root)
+      new(project_root)
+    end
+
+    # Clean up trash directories for non-existent projects
+    def self.cleanup_orphaned_projects
+      return 0 unless Dir.exist?(GLOBAL_TRASH_ROOT)
+      
+      cleaned_count = 0
+      all_projects.each do |project|
+        unless Dir.exist?(project[:project_root])
+          # Project no longer exists, optionally remove trash
+          # For safety, we'll just mark it as orphaned
+          orphan_file = File.join(project[:trash_dir], '.orphaned')
+          File.write(orphan_file, "Original project path no longer exists: #{project[:project_root]}\n")
+          cleaned_count += 1
+        end
+      end
+      
+      cleaned_count
+    end
+  end
+end

data/lib/clacky/utils/arguments_parser.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Clacky
+  module Utils
+    class ArgumentsParser
+      # Parse and validate tool call arguments with JSON repair capability
+      def self.parse_and_validate(call, tool_registry)
+        # 1. Try standard parsing
+        begin
+          args = JSON.parse(call[:arguments], symbolize_names: true)
+          return validate_required_params(call, args, tool_registry)
+        rescue JSON::ParserError => e
+          # Continue to repair
+        end
+
+        # 2. Try simple repair
+        repaired = repair_json(call[:arguments])
+
+        begin
+          args = JSON.parse(repaired, symbolize_names: true)
+          return validate_required_params(call, args, tool_registry)
+        rescue JSON::ParserError, MissingRequiredParamsError => e
+          # 3. Repair failed or missing params, return helpful error
+          raise_helpful_error(call, tool_registry, e)
+        end
+      end
+
+      private
+
+      # Simple JSON repair: complete brackets and quotes
+      def self.repair_json(json_str)
+        result = json_str.strip
+
+        # Complete unclosed strings
+        result += '"' if result.count('"').odd?
+
+        # Complete unclosed braces
+        depth = 0
+        result.each_char { |c| depth += 1 if c == '{'; depth -= 1 if c == '}' }
+        result += '}' * depth if depth > 0
+
+        result
+      end
+
+      # Validate required parameters
+      def self.validate_required_params(call, args, tool_registry)
+        tool = tool_registry.get(call[:name])
+        required = tool.parameters&.dig(:required) || []
+
+        missing = required.reject { |param|
+          args.key?(param.to_sym) || args.key?(param.to_s)
+        }
+
+        if missing.any?
+          raise MissingRequiredParamsError.new(call[:name], missing, args.keys)
+        end
+
+        args
+      end
+
+      # Generate error message with tool definition
+      def self.raise_helpful_error(call, tool_registry, original_error)
+        tool = tool_registry.get(call[:name])
+        error_msg = build_error_message(call, tool, original_error)
+        raise StandardError, error_msg
+      end
+
+      def self.build_error_message(call, tool, original_error)
+        # Extract tool information
+        required_params = tool.parameters&.dig(:required) || []
+
+        # Try to parse provided parameters from incomplete JSON
+        provided_params = extract_provided_params(call[:arguments])
+
+        # Build clear error message
+        msg = []
+        msg << "Failed to parse arguments for tool '#{call[:name]}'."
+        msg << ""
+        msg << "Error: #{original_error.message}"
+        msg << ""
+
+        if provided_params.any?
+          msg << "Provided parameters: #{provided_params.join(', ')}"
+        else
+          msg << "No valid parameters could be extracted."
+        end
+
+        msg << "Required parameters: #{required_params.join(', ')}"
+        msg << ""
+        msg << "Tool definition:"
+        msg << format_tool_definition(tool)
+        msg << ""
+        msg << "Suggestions:"
+        msg << "- If the parameter value is too large (e.g., large file content), consider breaking it into smaller operations"
+        msg << "- Ensure all required parameters are provided"
+        msg << "- Simplify complex parameter values"
+
+        msg.join("\n")
+      end
+
+      # Extract parameter names from incomplete JSON
+      def self.extract_provided_params(json_str)
+        # Simple extraction: find all "key": patterns
+        json_str.scan(/"(\w+)"\s*:/).flatten.uniq
+      end
+
+      # Format tool definition (concise version)
+      def self.format_tool_definition(tool)
+        lines = []
+        lines << "  Name: #{tool.name}"
+        lines << "  Description: #{tool.description}"
+
+        if tool.parameters[:properties]
+          lines << "  Parameters:"
+          tool.parameters[:properties].each do |param, spec|
+            required_mark = tool.parameters[:required]&.include?(param.to_s) ? " (required)" : ""
+            lines << "    - #{param}#{required_mark}: #{spec[:description]}"
+          end
+        end
+
+        lines.join("\n")
+      end
+    end
+
+    # Custom exception for missing required parameters
+    class MissingRequiredParamsError < StandardError
+      attr_reader :tool_name, :missing_params, :provided_params
+
+      def initialize(tool_name, missing_params, provided_params)
+        @tool_name = tool_name
+        @missing_params = missing_params
+        @provided_params = provided_params
+        super("Missing required parameters: #{missing_params.join(', ')}")
+      end
+    end
+  end
+end

data/lib/clacky/utils/limit_stack.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Clacky
+  module Utils
+    # Auto-rolling fixed-size array
+    # Automatically discards oldest elements when size limit is exceeded
+    class LimitStack
+      attr_reader :max_size, :items
+
+      def initialize(max_size: 5000)
+        @max_size = max_size
+        @items = []
+      end
+
+      # Add elements (supports single or multiple)
+      def push(*elements)
+        elements.each do |element|
+          @items << element
+          trim_if_needed
+        end
+        self
+      end
+      alias_method :<<, :push
+
+      # Add multi-line text (split by lines and add)
+      def push_lines(text)
+        return self if text.nil? || text.empty?
+
+        lines = text.is_a?(Array) ? text : text.lines
+        lines.each { |line| push(line) }
+        self
+      end
+
+      # Get last N elements
+      def last(n = nil)
+        n ? @items.last(n) : @items.last
+      end
+
+      # Get all elements
+      def to_a
+        @items.dup
+      end
+
+      # Convert to string (for text content)
+      def to_s
+        @items.join
+      end
+
+      # Current size
+      def size
+        @items.size
+      end
+
+      # Check if empty
+      def empty?
+        @items.empty?
+      end
+
+      # Clear all elements
+      def clear
+        @items.clear
+        self
+      end
+
+      # Iterate over elements
+      def each(&block)
+        @items.each(&block)
+      end
+
+      private
+
+      def trim_if_needed
+        if @items.size > @max_size
+          # Remove oldest elements, keep only the latest max_size items
+          @items.shift(@items.size - @max_size)
+        end
+      end
+    end
+  end
+end

data/lib/clacky/utils/path_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Clacky
+  module Utils
+    module PathHelper
+      # Safely get basename from path, return placeholder if path is nil
+      def self.safe_basename(path, placeholder: "?")
+        return placeholder if path.nil? || path.to_s.empty?
+        File.basename(path.to_s)
+      rescue StandardError
+        placeholder
+      end
+    end
+  end
+end

data/lib/clacky/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Clacky
+  VERSION = "0.5.1"
+end

data/lib/clacky.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "clacky/version"
+require_relative "clacky/config"
+require_relative "clacky/client"
+require_relative "clacky/conversation"
+
+# Agent system
+require_relative "clacky/agent_config"
+require_relative "clacky/hook_manager"
+require_relative "clacky/tool_registry"
+require_relative "clacky/thinking_verbs"
+require_relative "clacky/progress_indicator"
+require_relative "clacky/session_manager"
+require_relative "clacky/utils/limit_stack"
+require_relative "clacky/utils/path_helper"
+require_relative "clacky/tools/base"
+
+require_relative "clacky/tools/shell"
+require_relative "clacky/tools/file_reader"
+require_relative "clacky/tools/write"
+require_relative "clacky/tools/edit"
+require_relative "clacky/tools/glob"
+require_relative "clacky/tools/grep"
+require_relative "clacky/tools/web_search"
+require_relative "clacky/tools/web_fetch"
+require_relative "clacky/tools/todo_manager"
+require_relative "clacky/tools/run_project"
+require_relative "clacky/tools/safe_shell"
+require_relative "clacky/tools/trash_manager"
+require_relative "clacky/agent"
+
+require_relative "clacky/cli"
+
+module Clacky
+  class Error < StandardError; end
+  class AgentInterrupted < StandardError; end
+end

data/sig/clacky.rbs

@@ -0,0 +1,4 @@
+module Clacky
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: openclacky
+version: !ruby/object:Gem::Version
+  version: 0.5.1
+platform: ruby
+authors:
+- windy
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: diffy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: OpenClacky is a Ruby CLI tool for interacting with AI models via OpenAI-compatible
+  APIs. It provides chat functionality and autonomous AI agent capabilities with tool
+  use.
+email:
+- yafei@dao42.com
+executables:
+- clacky
+- openclacky
+extensions: []
+extra_rdoc_files: []
+files:
+- ".clackyrules"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/clacky
+- bin/openclacky
+- clacky-legacy/clacky.gemspec
+- clacky-legacy/clarky.gemspec
+- lib/clacky.rb
+- lib/clacky/agent.rb
+- lib/clacky/agent_config.rb
+- lib/clacky/cli.rb
+- lib/clacky/client.rb
+- lib/clacky/config.rb
+- lib/clacky/conversation.rb
+- lib/clacky/hook_manager.rb
+- lib/clacky/progress_indicator.rb
+- lib/clacky/session_manager.rb
+- lib/clacky/thinking_verbs.rb
+- lib/clacky/tool_registry.rb
+- lib/clacky/tools/base.rb
+- lib/clacky/tools/edit.rb
+- lib/clacky/tools/file_reader.rb
+- lib/clacky/tools/glob.rb
+- lib/clacky/tools/grep.rb
+- lib/clacky/tools/run_project.rb
+- lib/clacky/tools/safe_shell.rb
+- lib/clacky/tools/shell.rb
+- lib/clacky/tools/todo_manager.rb
+- lib/clacky/tools/trash_manager.rb
+- lib/clacky/tools/web_fetch.rb
+- lib/clacky/tools/web_search.rb
+- lib/clacky/tools/write.rb
+- lib/clacky/trash_directory.rb
+- lib/clacky/utils/arguments_parser.rb
+- lib/clacky/utils/limit_stack.rb
+- lib/clacky/utils/path_helper.rb
+- lib/clacky/version.rb
+- sig/clacky.rbs
+homepage: https://github.com/yafeilee/clacky
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/yafeilee/clacky
+  source_code_uri: https://github.com/yafeilee/clacky
+  changelog_uri: https://github.com/yafeilee/clacky/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A command-line interface for AI models (Claude, OpenAI, etc.)
+test_files: []