architext 0.2.0

data/lib/architext/cli.rb

@@ -0,0 +1,444 @@
+# frozen_string_literal: true
+
+require 'io/console'
+require 'optparse'
+require 'shellwords'
+
+require_relative 'bundle'
+require_relative 'clipboard'
+require_relative 'obsidian'
+require_relative 'picker'
+require_relative 'settings'
+require_relative 'tui'
+require_relative 'version'
+
+module Architext
+  # rubocop:disable Metrics/ClassLength
+  class CLI
+    DEFAULT_QUERY = 'tag:#project/active'
+    VAULT_SOURCE_EXPLICIT = '--vault'
+    VAULT_SOURCE_SAVED_DEFAULT = 'saved default'
+    VAULT_SOURCE_SESSION = 'session'
+    VAULT_SOURCE_OBSIDIAN_DEFAULT = 'obsidian default'
+    SearchAttempt = Data.define(:paths, :next_query)
+
+    def initialize(argv, io: {}, app_name: 'architext', dependencies: {})
+      @stdin = io.fetch(:stdin, $stdin)
+      @stdout = io.fetch(:stdout, $stdout)
+      @stderr = io.fetch(:stderr, $stderr)
+      @clipboard = dependencies.fetch(:clipboard, Clipboard.new)
+      @settings = dependencies.fetch(:settings, Settings.new)
+      @argv = argv
+      @app_name = app_name
+      @options = {
+        query: nil,
+        vault: nil,
+        set_default_vault: nil,
+        clear_default_vault: false,
+        diagnose: false,
+        stdout: false,
+        dry_run: false,
+        all: false
+      }
+      @vault_source = VAULT_SOURCE_OBSIDIAN_DEFAULT
+    end
+
+    def run
+      parse_options
+      return 0 if handled_default_vault_options?
+
+      apply_default_vault
+      return run_diagnostics if @options[:diagnose]
+
+      selected_paths = gather_selection
+      return 1 unless selected_paths
+      return no_selection if selected_paths.empty?
+
+      if @options[:dry_run]
+        print_dry_run(selected_paths, Obsidian.new(vault: @options[:vault]))
+        return 0
+      end
+
+      files = read_selected_files(Obsidian.new(vault: @options[:vault]), selected_paths)
+      bundle = Bundle.new(files).to_markdown
+      write_output(bundle)
+      0
+    rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+      ui.show_error "#{@app_name}: #{e.message}"
+      @stderr.puts "Run `bin/#{@app_name} --help` for usage."
+      2
+    rescue Obsidian::CommandNotFound => e
+      ui.show_error "#{@app_name}: #{e.message}"
+      @stderr.puts 'Install/enable Obsidian CLI, or set ARCHITEXT_OBSIDIAN to its path.'
+      127
+    rescue Obsidian::CommandFailed => e
+      ui.show_error "#{@app_name}: #{e.message}"
+      1
+    rescue Interrupt
+      @stderr.puts "\n#{@app_name}: cancelled"
+      130
+    end
+
+    private
+
+    # rubocop:disable Metrics/BlockLength
+    def parse_options
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: bin/#{@app_name} [options]"
+
+        opts.on('-q', '--query QUERY', "Obsidian search query. Default: #{DEFAULT_QUERY}") do |value|
+          @options[:query] = value
+        end
+
+        opts.on('-v', '--vault VAULT', 'Obsidian vault name or id') do |value|
+          @options[:vault] = value
+        end
+
+        opts.on('--set-default-vault VAULT', 'Set persistent default vault for future runs') do |value|
+          @options[:set_default_vault] = value
+        end
+
+        opts.on('--clear-default-vault', 'Clear persistent default vault') do
+          @options[:clear_default_vault] = true
+        end
+
+        opts.on('--diagnose', 'Print Obsidian CLI and vault diagnostics, then exit') do
+          @options[:diagnose] = true
+        end
+
+        opts.on('--stdout', 'Print stitched context instead of copying to clipboard') do
+          @options[:stdout] = true
+        end
+
+        opts.on('--dry-run', 'Show selected files and estimated bundle size') do
+          @options[:dry_run] = true
+        end
+
+        opts.on('--all', 'Include all search results without opening the picker') do
+          @options[:all] = true
+        end
+
+        opts.on('-h', '--help', 'Show this help') do
+          @stdout.puts opts
+          exit 0
+        end
+
+        opts.on('--version', 'Show version') do
+          @stdout.puts Architext::VERSION
+          exit 0
+        end
+      end
+
+      parser.parse!(@argv)
+    end
+    # rubocop:enable Metrics/BlockLength
+
+    def gather_selection
+      query = @options[:query] || prompt_for_query
+      return nil if query.nil?
+
+      vault = @options[:vault]
+      vault_source = @vault_source
+
+      loop do
+        client = Obsidian.new(vault:)
+        attempt = search_with_recovery(client, query)
+        if attempt.next_query
+          query = attempt.next_query
+          return nil if query.nil?
+
+          next
+        end
+
+        paths = attempt.paths
+        if paths.empty?
+          query = handle_no_results(query, vault, vault_source)
+          return nil if query.nil?
+
+          next
+        end
+
+        selection = select_paths(paths, query:, vault:, vault_source:)
+        if selection.new_vault
+          vault = selection.new_vault.strip
+          vault = nil if vault.empty?
+          @options[:vault] = vault
+          vault_source = vault.nil? ? VAULT_SOURCE_OBSIDIAN_DEFAULT : VAULT_SOURCE_SESSION
+          @vault_source = vault_source
+          next
+        end
+
+        if selection.reprompt_query
+          query = prompt_for_query
+
+          return nil if query.nil?
+
+          next
+        end
+
+        return selection.paths unless selection.new_query
+
+        query = selection.new_query
+      end
+    end
+
+    def search_with_recovery(client, query)
+      SearchAttempt.new(paths: client.search(query), next_query: nil)
+    rescue Obsidian::CommandFailed => e
+      if query_uses_operators?(query) && silent_exit_127?(e.message)
+        ui.show_info('Search operator query failed on this Obsidian CLI session. Retrying with plain-text fallback...')
+        fallback = operator_free_query(query)
+        retried = search_plain_fallback(client, fallback)
+        return retried if retried
+      end
+
+      next_query = handle_search_error(query, e)
+      return SearchAttempt.new(paths: [], next_query:) if interactive?
+
+      raise e
+    end
+
+    def handled_default_vault_options?
+      if @options[:set_default_vault]
+        vault = @options[:set_default_vault].to_s.strip
+        raise Obsidian::CommandFailed, 'default vault cannot be blank' if vault.empty?
+
+        @settings.default_vault = vault
+        @stdout.puts "Default vault set to: #{vault}"
+        return true
+      end
+
+      return false unless @options[:clear_default_vault]
+
+      @settings.clear_default_vault
+      @stdout.puts 'Default vault cleared.'
+      true
+    end
+
+    def apply_default_vault
+      if @options[:vault]
+        @vault_source = VAULT_SOURCE_EXPLICIT
+        return
+      end
+
+      default_vault = @settings.default_vault
+      @options[:vault] = default_vault
+      @vault_source = default_vault ? VAULT_SOURCE_SAVED_DEFAULT : VAULT_SOURCE_OBSIDIAN_DEFAULT
+    end
+
+    def prompt_for_query
+      return DEFAULT_QUERY unless interactive?
+
+      loop do
+        connection = build_connection_report
+        input = ui.prompt_query(
+          default: DEFAULT_QUERY,
+          context: {
+            vault: @options[:vault],
+            vault_source: @vault_source,
+            default_vault: @settings.default_vault,
+            default_vault_path: @settings.config_path,
+            connection_report: connection
+          }
+        )
+        return nil if input.quit
+
+        if input.open_vault_config
+          handle_prompt_vault_config
+          next
+        end
+
+        return input.query
+      end
+    end
+
+    def build_connection_report
+      report = {
+        executable: ENV.fetch('ARCHITEXT_OBSIDIAN', 'obsidian'),
+        status: 'unknown',
+        version: nil,
+        resolved_vault_summary: nil,
+        warning: nil
+      }
+      client = Obsidian.new(vault: @options[:vault], executable: report[:executable])
+      report[:version] = client.version
+      report[:resolved_vault_summary] = summarize_vault_info(client.vault_info)
+      report[:status] = 'ok'
+      report[:warning] = vault_mismatch_warning(report[:resolved_vault_summary], @options[:vault])
+      report
+    rescue Obsidian::CommandFailed => e
+      report[:status] = 'error'
+      report[:warning] = first_line(e.message)
+      report
+    rescue Obsidian::CommandNotFound => e
+      report[:status] = 'error'
+      report[:warning] = e.message
+      report
+    end
+
+    def run_diagnostics
+      report = build_connection_report
+      @stdout.puts "ARCHiTEXT diagnostics (v#{Architext::VERSION})"
+      @stdout.puts "active vault ref: #{@options[:vault] || '(none selected)'}"
+      @stdout.puts "vault source: #{@vault_source}"
+      @stdout.puts "saved default vault: #{@settings.default_vault || '(none)'}"
+      @stdout.puts "default vault config path: #{@settings.config_path}"
+      @stdout.puts "obsidian cli executable: #{report[:executable]}"
+      @stdout.puts "obsidian cli version: #{report[:version] || 'unknown'}"
+      @stdout.puts "connection check: #{report[:status]}"
+      @stdout.puts "resolved vault: #{report[:resolved_vault_summary] || '(unknown)'}"
+      @stdout.puts "diagnostic warning: #{report[:warning]}" if report[:warning]
+      report[:status] == 'ok' ? 0 : 1
+    end
+
+    def handle_no_results(query, vault, vault_source)
+      ui.show_no_results(
+        query,
+        vault:,
+        vault_source:,
+        default_vault_path: @settings.config_path,
+        obsidian_executable: ENV.fetch('ARCHITEXT_OBSIDIAN', 'obsidian')
+      )
+      interactive? ? prompt_for_query : nil
+    end
+
+    def handle_search_error(_query, error)
+      if interactive?
+        ui.show_error("#{error.message}\nReturning to search prompt.")
+        return prompt_for_query
+      end
+
+      raise error
+    end
+
+    def select_paths(paths, query:, vault:, vault_source:)
+      return TUI::Selection.new(paths:, new_query: nil, new_vault: nil, reprompt_query: false) if @options[:all]
+
+      unless interactive?
+        raise Obsidian::CommandFailed,
+              'interactive selection requires a TTY; rerun with --all or provide input from a terminal'
+      end
+
+      ui.select(paths, query:, vault:, vault_source:)
+    end
+
+    def handle_prompt_vault_config
+      loop do
+        action = ui.prompt_vault_config(
+          active_vault: @options[:vault],
+          active_vault_source: @vault_source,
+          default_vault: @settings.default_vault,
+          default_vault_path: @settings.config_path
+        )
+        return if action.back
+
+        if action.clear_default
+          @settings.clear_default_vault
+          ui.show_info('Default vault cleared.')
+          next
+        end
+
+        if action.set_default_vault
+          @settings.default_vault = action.set_default_vault
+          ui.show_info("Default vault set to: #{action.set_default_vault}")
+          next
+        end
+
+        next unless action.session_vault
+
+        vault = action.session_vault.strip
+        vault = nil if vault.empty?
+        @options[:vault] = vault
+        @vault_source = vault.nil? ? VAULT_SOURCE_OBSIDIAN_DEFAULT : VAULT_SOURCE_SESSION
+      end
+    end
+
+    def print_dry_run(selected_paths, client)
+      files = read_selected_files(client, selected_paths)
+      bytes = Bundle.new(files).to_markdown.bytesize
+      ui.show_dry_run(selected_paths, bytes)
+    end
+
+    def read_selected_files(client, selected_paths)
+      selected_paths.map do |path|
+        FileContent.new(path:, content: client.read(path))
+      end
+    end
+
+    def write_output(bundle)
+      if @options[:stdout]
+        @stdout.write bundle
+        return
+      end
+
+      @clipboard.copy(bundle)
+      ui.show_copied(bundle.bytesize)
+    rescue Clipboard::Error => e
+      raise Obsidian::CommandFailed, "#{e.message}\nTip: rerun with --stdout to print the bundle."
+    end
+
+    def query_uses_operators?(query)
+      query.to_s.match?(/(^|\s)(tag|path|file|line):/i)
+    end
+
+    def silent_exit_127?(message)
+      message.to_s.match?(/exit\s+127/i)
+    end
+
+    def operator_free_query(query)
+      query.to_s.gsub(/(^|\s)[a-z]+:[^\s]+/i, ' ').gsub('#', ' ').strip
+    end
+
+    def search_plain_fallback(client, query)
+      return nil if query.empty?
+
+      SearchAttempt.new(paths: client.search(query), next_query: nil)
+    rescue Obsidian::CommandFailed
+      nil
+    end
+
+    def summarize_vault_info(text)
+      lines = text.to_s.lines.map(&:strip).reject(&:empty?)
+      kv = lines.each_with_object({}) do |line, memo|
+        next unless line.match?(/\A[a-zA-Z0-9_]+\s+/)
+
+        key, value = line.split(/\s+/, 2)
+        memo[key.downcase] = value
+      end
+
+      name = kv['name']
+      path = kv['path']
+      return "#{name} | #{path}" if name && path
+      return name if name
+      return path if path
+
+      compact = lines.join(' | ')
+      compact[0, 180]
+    end
+
+    def vault_mismatch_warning(vault_summary, requested_vault)
+      return nil if requested_vault.to_s.strip.empty?
+      return nil if vault_summary.to_s.downcase.include?(requested_vault.to_s.downcase)
+
+      "Requested vault '#{requested_vault}' may not match resolved vault reported by Obsidian CLI."
+    end
+
+    def first_line(text)
+      text.to_s.lines.first.to_s.strip
+    end
+
+    def no_selection
+      ui.show_no_selection
+      1
+    end
+
+    def interactive?
+      @stdin.tty? && @stdout.tty?
+    end
+
+    def ui
+      @ui ||= TUI.new(stdin: @stdin, stdout: @stdout, stderr: @stderr, app_name: @app_name)
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/architext/clipboard.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'rbconfig'
+
+module Architext
+  class Clipboard
+    class Error < StandardError; end
+    class UnsupportedPlatform < Error; end
+    class CommandFailed < Error; end
+
+    def initialize(runner: Open3.method(:capture3), env: ENV, host_os: RbConfig::CONFIG['host_os'])
+      @runner = runner
+      @env = env
+      @host_os = host_os.to_s.downcase
+    end
+
+    def copy(text)
+      copied = false
+
+      candidates.each do |command|
+        _out, err, status = @runner.call(*command, stdin_data: text.to_s)
+        if status.success?
+          copied = true
+          break
+        end
+
+        details = err.to_s.strip
+        details = "exit #{status.exitstatus}" if details.empty?
+        raise CommandFailed, "Clipboard command failed: #{command.join(' ')} (#{details})"
+      rescue Errno::ENOENT
+        next
+      end
+
+      return if copied
+
+      raise UnsupportedPlatform,
+            'No supported clipboard command found. Use --stdout to print and pipe to your clipboard tool.'
+    end
+
+    private
+
+    def candidates
+      return [%w[pbcopy]] if mac?
+      return [%w[clip], %w[powershell -NoProfile -Command Set-Clipboard]] if windows?
+
+      [%w[wl-copy], %w[xclip -selection clipboard], %w[xsel --clipboard --input]]
+    end
+
+    def mac?
+      @host_os.include?('darwin')
+    end
+
+    def windows?
+      @host_os.match?(/mswin|mingw|cygwin/)
+    end
+  end
+end

data/lib/architext/obsidian.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+
+require_relative 'search_results'
+
+module Architext
+  class Obsidian
+    class CommandFailed < StandardError; end
+    class CommandNotFound < CommandFailed; end
+
+    def initialize(vault: nil, executable: ENV.fetch('ARCHITEXT_OBSIDIAN', 'obsidian'))
+      @vault = vault
+      @executable = executable
+    end
+
+    def search(query)
+      json_output = run('search', "query=#{query}", 'format=json')
+      json_paths = SearchResults.parse(json_output)
+      return json_paths unless json_paths.empty?
+
+      text_output = run('search', "query=#{query}", 'format=text')
+      SearchResults.parse(text_output)
+    end
+
+    def read(path)
+      run('read', "path=#{path}")
+    end
+
+    def version
+      run('version').to_s.strip
+    end
+
+    def vault_info
+      run('vault').to_s
+    end
+
+    private
+
+    def run(*args)
+      command = [@executable]
+      command << "vault=#{@vault}" if @vault && !@vault.empty?
+      command.concat(args)
+
+      stdout, stderr, status = Open3.capture3(*capture_command(command))
+      stdout = normalize_output(stdout)
+      stderr = normalize_output(stderr)
+      return stdout if status.success?
+
+      if status.exitstatus == 127 || stderr.match?(/not found|no such file/i)
+        raise CommandNotFound, "Obsidian CLI executable not found: #{@executable}"
+      end
+
+      rendered = command.shelljoin
+      details = stderr.strip.empty? ? "exit #{status.exitstatus}" : stderr.strip
+      raise CommandFailed, "Obsidian command failed: #{rendered}\n#{details}"
+    rescue Errno::ENOENT
+      raise CommandNotFound, "Obsidian CLI executable not found: #{@executable}"
+    end
+
+    def normalize_output(output)
+      text = output.to_s.dup
+      text.force_encoding(Encoding::UTF_8)
+      text.valid_encoding? ? text : text.scrub
+    end
+
+    def capture_command(command)
+      return command unless Gem.win_platform?
+
+      ['powershell', '-NoProfile', '-NonInteractive', '-Command', powershell_invocation(command)]
+    end
+
+    def powershell_invocation(command)
+      escaped_command = command.map { |part| powershell_quote(part) }.join(' ')
+
+      "$ErrorActionPreference = 'Stop'; & #{escaped_command}; exit $LASTEXITCODE"
+    end
+
+    def powershell_quote(value)
+      "'#{value.to_s.gsub("'", "''")}'"
+    end
+  end
+end

data/lib/architext/picker.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'selection_parser'
+
+module Architext
+  class Picker
+    def initialize(stdin:, stdout:)
+      @stdin = stdin
+      @stdout = stdout
+    end
+
+    def select(paths)
+      tty_prompt_select(paths) || fallback_select(paths)
+    end
+
+    private
+
+    def tty_prompt_select(paths)
+      require 'tty-prompt'
+
+      prompt = TTY::Prompt.new(input: @stdin, output: @stdout)
+      prompt.multi_select('Select notes to include:', paths, per_page: 20)
+    rescue LoadError
+      nil
+    end
+
+    def fallback_select(paths)
+      @stdout.puts 'Select notes to include:'
+      paths.each_with_index do |path, index|
+        @stdout.puts "#{index + 1}. #{path}"
+      end
+
+      @stdout.puts
+      @stdout.print 'Enter numbers, ranges, or all (example: 1,3-5): '
+      input = @stdin.gets&.strip.to_s
+      SelectionParser.new(paths).parse(input)
+    end
+  end
+end

data/lib/architext/search_results.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Architext
+  class SearchResults
+    def self.parse(output)
+      new(output).parse
+    end
+
+    def initialize(output)
+      @output = normalize_output(output)
+    end
+
+    def parse
+      parsed = JSON.parse(@output)
+      paths_from_json(parsed).uniq
+    rescue JSON::ParserError
+      paths_from_text(@output).uniq
+    end
+
+    private
+
+    def paths_from_json(value)
+      paths = case value
+              when Array
+                value.flat_map { |entry| paths_from_json(entry) }
+              when Hash
+                [hash_path(value), *paths_from_nested_hash(value)]
+              when String
+                [clean_path(value)]
+              else
+                []
+              end
+
+      paths.compact
+    end
+
+    def paths_from_nested_hash(hash)
+      %w[results matches files items].flat_map do |key|
+        paths_from_json(hash[key] || hash[key.to_sym])
+      end
+    end
+
+    def hash_path(hash)
+      path = hash['path'] || hash[:path] || hash['file'] || hash[:file]
+      clean_path(path) if path
+    end
+
+    def paths_from_text(text)
+      text.lines.filter_map { |line| clean_path(line) }
+    end
+
+    def clean_path(value)
+      path = value.to_s.strip
+      return nil if path.empty?
+
+      path
+    end
+
+    def normalize_output(output)
+      text = output.to_s.dup
+      text.force_encoding(Encoding::UTF_8)
+      text.valid_encoding? ? text : text.scrub
+    end
+  end
+end