openclacky 0.9.7 → 0.9.9

data/lib/clacky/default_skills/pdf-reader/SKILL.md

@@ -1,90 +0,0 @@
----
-name: pdf-reader
-description: 'Read and analyze PDF files. Use this skill when the user has attached a PDF or mentions a PDF file path and wants to understand, summarize, extract, or ask questions about its content. Trigger on: "read this PDF", "analyze the PDF", "what does this PDF say", "what is in this file", "里面有什么", "帮我看看这个PDF", "总结一下", "这份文件说了什么" — or when a message contains a PDF attachment reference even without an explicit question. Also trigger when the user asks vague questions like "what is this?", "summarize", "tell me about this" if a PDF is attached.'
-disable-model-invocation: false
-user-invocable: true
----
-
-# PDF Reading Skill
-
-## Your Goal
-Extract text content from the PDF file and answer the user's question based on that content. If the user's question is vague or absent, default to providing a clear structured summary of the document.
-
-## Step 1 — Extract text from the PDF
-
-Use `pdftotext` (preferred, fastest) or Python `pdfplumber` as fallback.
-
-### Option A: pdftotext (use this first)
-```bash
-pdftotext -layout -enc UTF-8 "/path/to/file.pdf" -
-```
-- `-enc UTF-8` ensures correct encoding for Chinese, Japanese, and other non-Latin text
-- `-layout` preserves column layout for tables
-- The `-` at the end prints to stdout (no temp file needed)
-
-**Install if missing:**
-- macOS: `brew install poppler`
-- Ubuntu/Debian: `apt install poppler-utils`
-- CentOS/Fedora: `yum install poppler-utils`
-
-### Option B: Python pdfplumber (fallback if pdftotext not available)
-```python
-import pdfplumber
-
-with pdfplumber.open("/path/to/file.pdf") as pdf:
-    for i, page in enumerate(pdf.pages, 1):
-        text = page.extract_text()
-        if text:
-            print(f"--- Page {i} ---")
-            print(text)
-```
-
-### Option C: pypdf (last resort)
-```python
-from pypdf import PdfReader
-
-reader = PdfReader("/path/to/file.pdf")
-for i, page in enumerate(reader.pages, 1):
-    print(f"--- Page {i} ---")
-    print(page.extract_text())
-```
-
-## Step 2 — Handle large files
-
-If the extracted text is truncated or very long (>200 lines):
-- For a **summary request**: read the full output file instead of relying on stdout — save to a temp file first:
-  ```bash
-  pdftotext -layout -enc UTF-8 "/path/to/file.pdf" /tmp/pdf_extracted.txt
-  cat /tmp/pdf_extracted.txt
-  ```
-- For a **specific question**: use `grep` to locate relevant sections before reading the full content:
-  ```bash
-  grep -n "keyword" /tmp/pdf_extracted.txt | head -30
-  ```
-- Extract once, answer from memory — do NOT re-read the file multiple times.
-
-## Step 3 — Answer the user's question
-
-### Output format guidelines
-
-Adapt the response format to the document type:
-
-| Document type | Recommended format |
-|---|---|
-| Business plan / Report | Structured summary with ## headers per section |
-| Contract / Legal | Key clauses in bullet points, highlight dates and parties |
-| Academic paper | Abstract → Key findings → Methodology → Conclusions |
-| Invoice / Receipt | Table: item, amount, total |
-| General / Unknown | Brief overview paragraph + key points as bullets |
-
-**General rules:**
-- Use Markdown formatting (headers, bullets, tables) for clarity
-- Match the user's language — if they asked in Chinese, answer in Chinese
-- Lead with the most important information first
-- If the user asked a specific question, answer it directly before summarizing
-
-## Rules
-- Always use the **actual file path** from the `[PDF attached: ...]` message
-- If text extraction returns empty (scanned/image PDF), inform the user and suggest: `brew install tesseract` + `tesseract file.pdf output txt`
-- Do NOT re-read the file multiple times — extract once, answer from memory
-- If the user's question is vague (e.g. "里面有什么", "what is this?"), default to a full structured summary

data/lib/clacky/utils/file_parser/docx_parser.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require "zip"
-require "rexml/document"
-require "stringio"
-
-module Clacky
-  module FileParser
-    # Parses DOCX/DOC files into Markdown, preserving headings, paragraphs, and tables.
-    module DocxParser
-      # Parse raw DOCX bytes and return a Markdown string.
-      # @param body [String] Raw file bytes
-      # @return [String] Markdown representation
-      def self.parse(body)
-        xml = read_document_xml(body)
-        return xml if xml.start_with?("(") # error string
-
-        doc = REXML::Document.new(xml)
-        numbering = read_numbering(body)
-        styles    = read_styles(body)
-
-        lines = []
-        REXML::XPath.each(doc, "//w:body/*") do |node|
-          case node.name
-          when "p"
-            line = parse_paragraph(node, styles, numbering)
-            lines << line unless line.nil?
-          when "tbl"
-            lines << parse_table(node)
-          end
-        end
-
-        result = lines.join("\n").strip
-        result.empty? ? "(Document appears to be empty)" : result
-      rescue => e
-        "(Failed to parse document: #{e.message})"
-      end
-
-      # --- private ---
-
-      def self.read_document_xml(body)
-        Zip::File.open_buffer(StringIO.new(body)) do |zip|
-          entry = zip.find_entry("word/document.xml")
-          return "(Could not extract content — possibly encrypted or invalid)" unless entry
-          entry.get_input_stream.read
-        end
-      rescue => e
-        "(Failed to open file: #{e.message})"
-      end
-
-      # Returns a hash: { abstract_num_id => { ilvl => { numFmt, start } } }
-      def self.read_numbering(body)
-        result = {}
-        Zip::File.open_buffer(StringIO.new(body)) do |zip|
-          entry = zip.find_entry("word/numbering.xml")
-          break unless entry
-          doc = REXML::Document.new(entry.get_input_stream.read)
-          REXML::XPath.each(doc, "//w:abstractNum") do |an|
-            id = an.attributes["w:abstractNumId"]
-            levels = {}
-            REXML::XPath.each(an, "w:lvl") do |lvl|
-              ilvl = lvl.attributes["w:ilvl"].to_i
-              fmt  = REXML::XPath.first(lvl, "w:numFmt")&.attributes&.[]("w:val")
-              levels[ilvl] = { fmt: fmt || "bullet" }
-            end
-            result[id] = levels
-          end
-        end
-        result
-      rescue
-        {}
-      end
-
-      # Returns a hash: { styleId => { heading_level } }
-      def self.read_styles(body)
-        result = {}
-        Zip::File.open_buffer(StringIO.new(body)) do |zip|
-          entry = zip.find_entry("word/styles.xml")
-          break unless entry
-          doc = REXML::Document.new(entry.get_input_stream.read)
-          REXML::XPath.each(doc, "//w:style") do |s|
-            sid  = s.attributes["w:styleId"]
-            name = REXML::XPath.first(s, "w:name")&.attributes&.[]("w:val").to_s
-            if name =~ /^heading (\d)/i
-              result[sid] = { heading: $1.to_i }
-            end
-          end
-        end
-        result
-      rescue
-        {}
-      end
-
-      def self.parse_paragraph(node, styles, numbering)
-        ppr    = REXML::XPath.first(node, "w:pPr")
-        style  = REXML::XPath.first(ppr, "w:pStyle")&.attributes&.[]("w:val") if ppr
-        num_pr = REXML::XPath.first(ppr, "w:numPr") if ppr
-
-        text = extract_runs(node)
-        return nil if text.strip.empty?
-
-        # Heading
-        if style && styles[style]
-          level = styles[style][:heading]
-          return "#{"#" * level} #{text}"
-        end
-
-        # List item
-        if num_pr
-          ilvl = REXML::XPath.first(num_pr, "w:ilvl")&.attributes&.[]("w:val").to_i
-          indent = "  " * ilvl
-          return "#{indent}- #{text}"
-        end
-
-        text
-      end
-
-      def self.extract_runs(para_node)
-        parts = []
-        REXML::XPath.each(para_node, "w:r") do |run|
-          rpr  = REXML::XPath.first(run, "w:rPr")
-          bold = REXML::XPath.first(rpr, "w:b") if rpr
-          text = REXML::XPath.match(run, "w:t").map(&:text).compact.join
-          next if text.empty?
-          parts << (bold ? "**#{text}**" : text)
-        end
-        parts.join
-      end
-
-      def self.parse_table(tbl_node)
-        rows = []
-        REXML::XPath.each(tbl_node, "w:tr") do |tr|
-          cells = REXML::XPath.match(tr, "w:tc").map do |tc|
-            REXML::XPath.match(tc, ".//w:t").map(&:text).compact.join(" ").strip
-          end
-          rows << cells
-        end
-        return "" if rows.empty?
-
-        # Build markdown table
-        col_count = rows.map(&:size).max
-        lines = []
-        rows.each_with_index do |row, i|
-          padded = row + [""] * [col_count - row.size, 0].max
-          lines << "| #{padded.join(" | ")} |"
-          # Header separator after first row
-          lines << "|#{" --- |" * col_count}" if i == 0
-        end
-        lines.join("\n")
-      end
-
-      private_class_method :read_document_xml, :read_numbering, :read_styles,
-                           :parse_paragraph, :extract_runs, :parse_table
-    end
-  end
-end

data/lib/clacky/utils/file_parser/pptx_parser.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require "zip"
-require "rexml/document"
-require "stringio"
-
-module Clacky
-  module FileParser
-    # Parses PPTX files into Markdown, one section per slide.
-    # Extracts slide titles, body text, and table content.
-    module PptxParser
-      # Parse raw PPTX bytes and return a Markdown string.
-      # @param body [String] Raw file bytes
-      # @return [String] Markdown representation
-      def self.parse(body)
-        slides = {}
-
-        Zip::File.open_buffer(StringIO.new(body)) do |zip|
-          zip.each do |entry|
-            if entry.name =~ %r{ppt/slides/slide(\d+)\.xml}
-              slides[$1.to_i] = entry.get_input_stream.read
-            end
-          end
-        end
-
-        return "(Presentation appears to be empty)" if slides.empty?
-
-        sections = slides.keys.sort.map do |num|
-          doc = REXML::Document.new(slides[num])
-          parse_slide(doc, num)
-        end.compact
-
-        sections.empty? ? "(Presentation appears to be empty)" : sections.join("\n\n---\n\n")
-      rescue => e
-        "(Failed to parse presentation: #{e.message})"
-      end
-
-      # --- private ---
-
-      def self.parse_slide(doc, slide_num)
-        lines = []
-
-        # Title: look for ph type="title" or ph type="ctrTitle"
-        title_text = nil
-        REXML::XPath.each(doc, "//p:sp") do |sp|
-          ph = REXML::XPath.first(sp, ".//p:ph")
-          next unless ph
-          ph_type = ph.attributes["type"]
-          if ph_type == "title" || ph_type == "ctrTitle"
-            title_text = extract_text(sp).strip
-            break
-          end
-        end
-
-        lines << "## Slide #{slide_num}#{title_text && !title_text.empty? ? ": #{title_text}" : ""}"
-
-        # Body: all other text shapes
-        REXML::XPath.each(doc, "//p:sp") do |sp|
-          ph = REXML::XPath.first(sp, ".//p:ph")
-          # Skip title shapes (already handled) and slide number/date placeholders
-          if ph
-            ph_type = ph.attributes["type"]
-            next if %w[title ctrTitle sldNum dt ftr].include?(ph_type)
-          end
-
-          text = extract_text(sp).strip
-          next if text.empty?
-          next if text == title_text  # deduplicate
-
-          # Indent body bullets
-          text.each_line do |line|
-            lines << "- #{line.rstrip}" unless line.strip.empty?
-          end
-        end
-
-        # Tables
-        REXML::XPath.each(doc, "//a:tbl") do |tbl|
-          lines << parse_table(tbl)
-        end
-
-        lines.join("\n")
-      end
-
-      def self.extract_text(shape_node)
-        paras = []
-        REXML::XPath.each(shape_node, ".//a:p") do |para|
-          text = REXML::XPath.match(para, ".//a:t").map(&:text).compact.join
-          paras << text unless text.strip.empty?
-        end
-        paras.join("\n")
-      end
-
-      def self.parse_table(tbl_node)
-        rows = []
-        REXML::XPath.each(tbl_node, ".//a:tr") do |tr|
-          cells = REXML::XPath.match(tr, ".//a:tc").map do |tc|
-            REXML::XPath.match(tc, ".//a:t").map(&:text).compact.join(" ").strip
-          end
-          rows << cells
-        end
-        return "" if rows.empty?
-
-        col_count = rows.map(&:size).max
-        lines = []
-        rows.each_with_index do |row, i|
-          padded = row + [""] * [col_count - row.size, 0].max
-          lines << "| #{padded.join(" | ")} |"
-          lines << "|#{" --- |" * col_count}" if i == 0
-        end
-        lines.join("\n")
-      end
-
-      private_class_method :parse_slide, :extract_text, :parse_table
-    end
-  end
-end

data/lib/clacky/utils/file_parser/xlsx_parser.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require "zip"
-require "rexml/document"
-require "stringio"
-
-module Clacky
-  module FileParser
-    # Parses XLSX/XLS files into Markdown tables, one section per sheet.
-    module XlsxParser
-      # Parse raw XLSX bytes and return a Markdown string.
-      # @param body [String] Raw file bytes
-      # @return [String] Markdown representation with one table per sheet
-      def self.parse(body)
-        shared_strings = []
-        sheet_names    = {}
-        sheet_xmls     = {}
-
-        Zip::File.open_buffer(StringIO.new(body)) do |zip|
-          # Shared strings table
-          ss_entry = zip.find_entry("xl/sharedStrings.xml")
-          if ss_entry
-            doc = REXML::Document.new(ss_entry.get_input_stream.read)
-            REXML::XPath.each(doc, "//si") do |si|
-              shared_strings << REXML::XPath.match(si, ".//t").map(&:text).compact.join
-            end
-          end
-
-          # Sheet name mapping from workbook.xml
-          wb_entry = zip.find_entry("xl/workbook.xml")
-          if wb_entry
-            doc = REXML::Document.new(wb_entry.get_input_stream.read)
-            REXML::XPath.each(doc, "//sheet") do |s|
-              idx  = s.attributes["sheetId"]
-              name = s.attributes["name"]
-              sheet_names[idx] = name if idx && name
-            end
-          end
-
-          # Sheet XMLs
-          zip.each do |entry|
-            if entry.name =~ %r{xl/worksheets/sheet(\d+)\.xml}
-              sheet_xmls[$1] = entry.get_input_stream.read
-            end
-          end
-        end
-
-        return "(Spreadsheet appears to be empty)" if sheet_xmls.empty?
-
-        sections = []
-        sheet_xmls.keys.sort_by(&:to_i).each do |idx|
-          name = sheet_names[idx] || "Sheet#{idx}"
-          doc  = REXML::Document.new(sheet_xmls[idx])
-
-          rows = []
-          REXML::XPath.each(doc, "//row") do |row|
-            cells = parse_row(row, shared_strings)
-            rows << cells unless cells.all?(&:empty?)
-          end
-
-          next if rows.empty?
-
-          sections << "### #{name}\n\n#{build_markdown_table(rows)}"
-        end
-
-        sections.empty? ? "(Spreadsheet appears to be empty)" : sections.join("\n\n")
-      rescue => e
-        "(Failed to parse spreadsheet: #{e.message})"
-      end
-
-      # --- private ---
-
-      def self.parse_row(row_node, shared_strings)
-        REXML::XPath.match(row_node, ".//c").map do |c|
-          v = REXML::XPath.first(c, "v")&.text
-          next "" unless v
-          c.attributes["t"] == "s" ? (shared_strings[v.to_i] || "") : v
-        end
-      end
-
-      def self.build_markdown_table(rows)
-        col_count = rows.map(&:size).max
-        lines = []
-        rows.each_with_index do |row, i|
-          padded = row + [""] * [col_count - row.size, 0].max
-          lines << "| #{padded.join(" | ")} |"
-          lines << "|#{" --- |" * col_count}" if i == 0
-        end
-        lines.join("\n")
-      end
-
-      private_class_method :parse_row, :build_markdown_table
-    end
-  end
-end

data/lib/clacky/utils/file_parser/zip_parser.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "zip"
-require "stringio"
-
-module Clacky
-  module FileParser
-    # Lists the contents of a ZIP archive as a Markdown file tree.
-    module ZipParser
-      MAX_ENTRIES = 200
-
-      # Parse raw ZIP bytes and return a Markdown directory listing.
-      # @param body [String] Raw file bytes
-      # @return [String] Markdown representation of archive contents
-      def self.parse(body)
-        entries = []
-
-        Zip::File.open_buffer(StringIO.new(body)) do |zip|
-          zip.each do |entry|
-            entries << {
-              name: entry.name,
-              size: entry.file? ? entry.size : nil,
-              dir:  entry.directory?
-            }
-            break if entries.size >= MAX_ENTRIES
-          end
-        end
-
-        return "(ZIP archive appears to be empty)" if entries.empty?
-
-        truncated = entries.size >= MAX_ENTRIES
-        lines = ["**Archive contents** (#{entries.size}#{truncated ? "+" : ""} entries):\n"]
-
-        entries.sort_by { |e| [e[:dir] ? 0 : 1, e[:name]] }.each do |e|
-          if e[:dir]
-            lines << "- 📁 #{e[:name]}"
-          else
-            size_str = e[:size] ? " *(#{format_size(e[:size])})*" : ""
-            lines << "- #{e[:name]}#{size_str}"
-          end
-        end
-
-        lines << "\n*(listing truncated at #{MAX_ENTRIES} entries)*" if truncated
-        lines.join("\n")
-      rescue => e
-        "(Failed to read ZIP: #{e.message})"
-      end
-
-      # --- private ---
-
-      def self.format_size(bytes)
-        return "#{bytes} B"       if bytes < 1024
-        return "#{bytes / 1024} KB" if bytes < 1024 * 1024
-        "#{(bytes / 1024.0 / 1024).round(1)} MB"
-      end
-
-      private_class_method :format_size
-    end
-  end
-end

data/scripts/install_agent_browser.sh

@@ -1,67 +0,0 @@
-#!/bin/bash
-# Install or upgrade agent-browser (browser automation tool)
-# Can be sourced by install.sh or run standalone (e.g. from Ruby via shell)
-#
-# Exit codes:
-#   0 — success (installed/upgraded)
-#   1 — failure (npm not found or install failed)
-
-set -e
-
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m'
-
-print_info()    { echo -e "${BLUE}ℹ${NC} $1"; }
-print_success() { echo -e "${GREEN}✓${NC} $1"; }
-print_warning() { echo -e "${YELLOW}⚠${NC} $1"; }
-print_error()   { echo -e "${RED}✗${NC} $1"; }
-print_step()    { echo -e "\n${BLUE}==>${NC} $1"; }
-
-command_exists() { command -v "$1" >/dev/null 2>&1; }
-
-print_step "Installing agent-browser..."
-
-# Try to find npm; if missing, attempt to install Node.js via mise
-if ! command_exists npm; then
-    mise_bin=""
-    if command_exists mise; then
-        mise_bin="mise"
-    elif [ -x "$HOME/.local/bin/mise" ]; then
-        mise_bin="$HOME/.local/bin/mise"
-    fi
-
-    if [ -n "$mise_bin" ]; then
-        print_info "Installing Node.js via mise..."
-        "$mise_bin" install node@22 > /dev/null 2>&1 || true
-        "$mise_bin" use -g node@22 > /dev/null 2>&1 || true
-        eval "$("$mise_bin" activate bash 2>/dev/null)" 2>/dev/null || true
-    fi
-fi
-
-if ! command_exists npm; then
-    print_error "agent-browser installation failed: Node.js/npm not found."
-    print_info "Please run: mise install node@22 && mise use -g node@22 && npm install -g agent-browser"
-    exit 1
-fi
-
-print_info "Running: npm install -g agent-browser"
-if npm install -g agent-browser > /dev/null 2>&1; then
-    version=$(agent-browser --version 2>/dev/null | awk '{print $NF}')
-    print_success "agent-browser ${version} installed/updated"
-else
-    print_error "agent-browser installation failed."
-    print_info "To install manually: npm install -g agent-browser"
-    exit 1
-fi
-
-print_info "Installing Playwright Chromium..."
-if npx playwright install chromium > /dev/null 2>&1; then
-    print_success "Playwright Chromium installed"
-else
-    print_error "Playwright Chromium installation failed."
-    print_info "To install manually: npx playwright install chromium"
-    exit 1
-fi