openclacky 0.9.7 → 0.9.9

data/lib/clacky/cli.rb

@@ -103,8 +103,11 @@ module Clacky
       end
 
       # Create new agent if no session loaded
-      agent ||= Clacky::Agent.new(client, agent_config, working_dir: working_dir, ui: nil, profile: agent_profile,
-                                   session_id: Clacky::SessionManager.generate_id)
+      if agent.nil?
+        agent = Clacky::Agent.new(client, agent_config, working_dir: working_dir, ui: nil, profile: agent_profile,
+                                  session_id: Clacky::SessionManager.generate_id, source: :manual)
+        agent.rename("CLI Session")
+      end
 
       # Change to working directory
       original_dir = Dir.pwd
@@ -314,6 +317,18 @@ module Clacky
         end
       end
 
+      CLI_DEFAULT_SESSION_NAME = "CLI Session"
+
+      # Auto-name a CLI session from the first user message, mirroring server-side logic.
+      # Renames when the agent has no history yet (i.e. first message of the session).
+      private def auto_name_session(agent, input)
+        return unless agent.history.empty?
+
+        auto_name = input.to_s.gsub(/\s+/, " ").strip[0, 30]
+        auto_name += "…" if input.to_s.strip.length > 30
+        agent.rename(auto_name)
+      end
+
       def validate_working_directory(path)
         working_dir = path || Dir.pwd
 
@@ -348,7 +363,7 @@ module Clacky
       def list_sessions
         session_manager = Clacky::SessionManager.new
         working_dir = validate_working_directory(options[:path])
-        sessions = session_manager.list(current_dir: working_dir, limit: 5)
+        sessions = session_manager.all_sessions(current_dir: working_dir, limit: 5)
 
         if sessions.empty?
           say "No sessions found.", :yellow
@@ -379,13 +394,18 @@ module Clacky
           return nil
         end
 
+        # Prefer the agent_profile stored in the session; only fall back to the
+        # CLI --agent flag when the session predates the agent_profile field.
+        restored_profile = session_data[:agent_profile].to_s
+        resolved_profile = restored_profile.empty? ? profile : restored_profile
+
         # Don't print message here - will be shown by UI after banner
-        Clacky::Agent.from_session(client, agent_config, session_data, profile: profile)
+        Clacky::Agent.from_session(client, agent_config, session_data, profile: resolved_profile)
       end
 
       def load_session_by_number(client, agent_config, session_manager, working_dir, identifier, profile:)
         # Get a larger list to search through (for ID prefix matching)
-        sessions = session_manager.list(current_dir: working_dir, limit: 100)
+        sessions = session_manager.all_sessions(current_dir: working_dir, limit: 100)
 
         if sessions.empty?
           say "No sessions found.", :yellow
@@ -426,8 +446,13 @@ module Clacky
           end
         end
 
+        # Prefer the agent_profile stored in the session; fall back to CLI --agent flag
+        # for sessions that predate the agent_profile field.
+        restored_profile = session_data[:agent_profile].to_s
+        resolved_profile = restored_profile.empty? ? profile : restored_profile
+
         # Don't print message here - will be shown by UI after banner
-        Clacky::Agent.from_session(client, agent_config, session_data, profile: profile)
+        Clacky::Agent.from_session(client, agent_config, session_data, profile: resolved_profile)
       end
 
       # Handle agent error/interrupt with cleanup
@@ -467,6 +492,7 @@ module Clacky
         plain_ui = Clacky::PlainUIController.new
         agent.instance_variable_set(:@ui, plain_ui)
 
+        auto_name_session(agent, message)
         agent.run(message, files: files)
         session_manager&.save(agent.to_session_data(status: :success))
         exit(0)
@@ -524,13 +550,14 @@ module Clacky
               break
             when "/clear"
               agent = Clacky::Agent.new(client, agent_config, working_dir: working_dir, ui: nil, profile: profile,
-                                        session_id: Clacky::SessionManager.generate_id)
+                                        session_id: Clacky::SessionManager.generate_id, source: :manual)
               agent.instance_variable_set(:@ui, json_ui)
               json_ui.emit("info", message: "Session cleared. Starting fresh.")
               next
             end
 
             files = input["files"] || []
+            auto_name_session(agent, content)
             run_json_task(agent, json_ui, session_manager) { agent.run(content, files: files) }
           when "exit"
             break
@@ -667,7 +694,7 @@ module Clacky
             # Clear output area
             ui_controller.layout.clear_output
             # Clear session by creating a new agent
-            agent = Clacky::Agent.new(client, agent_config, working_dir: working_dir, ui: ui_controller, profile: agent.agent_profile.name, session_id: Clacky::SessionManager.generate_id)
+            agent = Clacky::Agent.new(client, agent_config, working_dir: working_dir, ui: ui_controller, profile: agent.agent_profile.name, session_id: Clacky::SessionManager.generate_id, source: :manual)
             ui_controller.show_info("Session cleared. Starting fresh.")
             # Update session bar with reset values
             ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
@@ -693,6 +720,8 @@ module Clacky
           # Cancel idle timer if running (new input means user is active)
           idle_timer.cancel
 
+          auto_name_session(agent, input)
+
           # Run agent in background thread
           current_task_thread = Thread.new do
             begin

data/lib/clacky/default_parsers/doc_parser.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# Clacky DOC Parser — CLI interface
+#
+# Usage:
+#   ruby doc_parser.rb <file_path>
+#
+# Output:
+#   stdout — extracted text content (UTF-8)
+#   stderr — error messages
+#   exit 0 — success
+#   exit 1 — failure
+#
+# This file lives in ~/.clacky/parsers/ and can be modified by the LLM
+# to add new capabilities (e.g. antiword, libreoffice conversion).
+#
+# VERSION: 1
+
+require "open3"
+
+MIN_CONTENT_BYTES = 20
+
+# Use macOS textutil to convert .doc → txt
+def try_textutil(path)
+  stdout, _stderr, status = Open3.capture3("textutil", "-convert", "txt", "-stdout", path)
+  return nil unless status.success?
+  text = stdout.strip
+  return nil if text.bytesize < MIN_CONTENT_BYTES
+  text
+rescue Errno::ENOENT
+  nil # textutil not available (non-macOS)
+end
+
+# Fallback: strings command — extracts printable ASCII sequences
+def try_strings(path)
+  stdout, _stderr, status = Open3.capture3("strings", path)
+  return nil unless status.success?
+  lines = stdout.lines.select { |l| l.strip.length >= 4 }
+  return nil if lines.size < 3
+  lines.join
+rescue Errno::ENOENT
+  nil # strings not available
+end
+
+# --- main ---
+
+path = ARGV[0]
+
+if path.nil? || path.empty?
+  warn "Usage: ruby doc_parser.rb <file_path>"
+  exit 1
+end
+
+unless File.exist?(path)
+  warn "File not found: #{path}"
+  exit 1
+end
+
+text = try_textutil(path) || try_strings(path)
+
+if text
+  print text
+  exit 0
+else
+  warn "Could not extract text from .doc file."
+  warn "Tip: on macOS textutil should work. On Linux try: apt install antiword"
+  exit 1
+end

data/lib/clacky/default_parsers/docx_parser.rb

@@ -0,0 +1,172 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# Clacky DOCX Parser — CLI interface
+#
+# Usage:
+#   ruby docx_parser.rb <file_path>
+#
+# Output:
+#   stdout — extracted text in Markdown (UTF-8)
+#   stderr — error messages
+#   exit 0 — success
+#   exit 1 — failure
+#
+# Dependencies: rubyzip gem (gem install rubyzip)
+#
+# This file lives in ~/.clacky/parsers/ and can be modified by the LLM.
+#
+# VERSION: 1
+
+require "zip"
+require "rexml/document"
+require "stringio"
+
+def read_document_xml(body)
+  Zip::File.open_buffer(StringIO.new(body)) do |zip|
+    entry = zip.find_entry("word/document.xml")
+    raise "Could not extract content — possibly encrypted or invalid format" unless entry
+    entry.get_input_stream.read
+  end
+end
+
+def 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
+
+def 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 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 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?
+
+  if style && styles[style]
+    level = styles[style][:heading]
+    return "#{"#" * level} #{text}"
+  end
+
+  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 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?
+
+  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
+
+# --- main ---
+
+path = ARGV[0]
+
+if path.nil? || path.empty?
+  warn "Usage: ruby docx_parser.rb <file_path>"
+  exit 1
+end
+
+unless File.exist?(path)
+  warn "File not found: #{path}"
+  exit 1
+end
+
+begin
+  body   = File.binread(path)
+  xml    = read_document_xml(body)
+  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
+  if result.empty?
+    warn "Document appears to be empty"
+    exit 1
+  end
+
+  print result
+  exit 0
+rescue => e
+  warn "Failed to parse DOCX: #{e.message}"
+  warn "Tip: ensure rubyzip is installed: gem install rubyzip"
+  exit 1
+end

data/lib/clacky/default_parsers/pdf_parser.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# Clacky PDF Parser — CLI interface
+#
+# Usage:
+#   ruby pdf_parser.rb <file_path>
+#
+# Output:
+#   stdout — extracted text content (UTF-8)
+#   stderr — error messages
+#   exit 0 — success
+#   exit 1 — failure
+#
+# This file lives in ~/.clacky/parsers/ and can be modified by the LLM
+# to add new capabilities (e.g. OCR for scanned PDFs).
+#
+# VERSION: 1
+
+require "open3"
+
+MIN_CONTENT_BYTES = 20
+
+def try_pdftotext(path)
+  stdout, _stderr, status = Open3.capture3("pdftotext", "-layout", "-enc", "UTF-8", path, "-")
+  return nil unless status.success?
+  text = stdout.strip
+  return nil if text.bytesize < MIN_CONTENT_BYTES
+  text
+rescue Errno::ENOENT
+  nil # pdftotext not installed
+end
+
+def try_pdfplumber(path)
+  script = <<~PYTHON
+    import sys, pdfplumber
+    with pdfplumber.open(sys.argv[1]) as pdf:
+        pages = []
+        for i, page in enumerate(pdf.pages, 1):
+            t = page.extract_text()
+            if t and t.strip():
+                pages.append(f"--- Page {i} ---\\n{t.strip()}")
+        print("\\n\\n".join(pages))
+  PYTHON
+
+  stdout, _stderr, status = Open3.capture3("python3", "-c", script, path)
+  return nil unless status.success?
+  text = stdout.strip
+  return nil if text.bytesize < MIN_CONTENT_BYTES
+  text
+rescue Errno::ENOENT
+  nil # python3 not available
+end
+
+# --- main ---
+
+path = ARGV[0]
+
+if path.nil? || path.empty?
+  warn "Usage: ruby pdf_parser.rb <file_path>"
+  exit 1
+end
+
+unless File.exist?(path)
+  warn "File not found: #{path}"
+  exit 1
+end
+
+text = try_pdftotext(path) || try_pdfplumber(path)
+
+if text
+  print text
+  exit 0
+else
+  warn "Could not extract text from PDF."
+  warn "Tip: install poppler for text-based PDFs: brew install poppler"
+  warn "For scanned PDFs, consider adding OCR support (e.g. tesseract)."
+  exit 1
+end

data/lib/clacky/default_parsers/pptx_parser.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# Clacky PPTX Parser — CLI interface
+#
+# Usage:
+#   ruby pptx_parser.rb <file_path>
+#
+# Output:
+#   stdout — extracted content in Markdown (UTF-8)
+#   stderr — error messages
+#   exit 0 — success
+#   exit 1 — failure
+#
+# Dependencies: rubyzip gem (gem install rubyzip)
+#
+# This file lives in ~/.clacky/parsers/ and can be modified by the LLM.
+#
+# VERSION: 1
+
+require "zip"
+require "rexml/document"
+require "stringio"
+
+def 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 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
+
+def parse_slide(doc, slide_num)
+  lines = []
+
+  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}" : ""}"
+
+  REXML::XPath.each(doc, "//p:sp") do |sp|
+    ph = REXML::XPath.first(sp, ".//p:ph")
+    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
+
+    text.each_line do |line|
+      lines << "- #{line.rstrip}" unless line.strip.empty?
+    end
+  end
+
+  REXML::XPath.each(doc, "//a:tbl") do |tbl|
+    lines << parse_table(tbl)
+  end
+
+  lines.join("\n")
+end
+
+# --- main ---
+
+path = ARGV[0]
+
+if path.nil? || path.empty?
+  warn "Usage: ruby pptx_parser.rb <file_path>"
+  exit 1
+end
+
+unless File.exist?(path)
+  warn "File not found: #{path}"
+  exit 1
+end
+
+begin
+  body   = File.binread(path)
+  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
+
+  if slides.empty?
+    warn "Presentation appears to be empty"
+    exit 1
+  end
+
+  sections = slides.keys.sort.map do |num|
+    doc = REXML::Document.new(slides[num])
+    parse_slide(doc, num)
+  end.compact
+
+  if sections.empty?
+    warn "Presentation appears to be empty"
+    exit 1
+  end
+
+  print sections.join("\n\n---\n\n")
+  exit 0
+rescue => e
+  warn "Failed to parse PPTX: #{e.message}"
+  warn "Tip: ensure rubyzip is installed: gem install rubyzip"
+  exit 1
+end

data/lib/clacky/default_parsers/xlsx_parser.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# Clacky XLSX Parser — CLI interface
+#
+# Usage:
+#   ruby xlsx_parser.rb <file_path>
+#
+# Output:
+#   stdout — extracted content in Markdown tables (UTF-8)
+#   stderr — error messages
+#   exit 0 — success
+#   exit 1 — failure
+#
+# Dependencies: rubyzip gem (gem install rubyzip)
+#
+# This file lives in ~/.clacky/parsers/ and can be modified by the LLM.
+#
+# VERSION: 1
+
+require "zip"
+require "rexml/document"
+require "stringio"
+
+def 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 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
+
+# --- main ---
+
+path = ARGV[0]
+
+if path.nil? || path.empty?
+  warn "Usage: ruby xlsx_parser.rb <file_path>"
+  exit 1
+end
+
+unless File.exist?(path)
+  warn "File not found: #{path}"
+  exit 1
+end
+
+begin
+  body = File.binread(path)
+  shared_strings = []
+  sheet_names    = {}
+  sheet_xmls     = {}
+
+  Zip::File.open_buffer(StringIO.new(body)) do |zip|
+    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
+
+    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
+
+    zip.each do |entry|
+      if entry.name =~ %r{xl/worksheets/sheet(\d+)\.xml}
+        sheet_xmls[$1] = entry.get_input_stream.read
+      end
+    end
+  end
+
+  if sheet_xmls.empty?
+    warn "Spreadsheet appears to be empty"
+    exit 1
+  end
+
+  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
+
+  if sections.empty?
+    warn "Spreadsheet appears to be empty"
+    exit 1
+  end
+
+  print sections.join("\n\n")
+  exit 0
+rescue => e
+  warn "Failed to parse XLSX: #{e.message}"
+  warn "Tip: ensure rubyzip is installed: gem install rubyzip"
+  exit 1
+end