mps 0.5.0 → 1.0.1

data/lib/mps/presenter.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module MPS
+  # Renders an elements hash to a string.
+  # Has no dependency on Thor; receives a colorize proc for terminal output.
+  #
+  # Usage (in CLI):
+  #   p = Presenter.new(elements, color_fn: method(:set_color), resolver: resolver)
+  #   puts p.render_tree
+  class Presenter
+    TYPE_COLORS = {
+      "task"     => :green,
+      "note"     => :cyan,
+      "reminder" => :magenta,
+      "log"      => :yellow
+    }.freeze
+
+    ANSI_CODES = {
+      green: "\e[32m", cyan: "\e[36m", magenta: "\e[35m",
+      yellow: "\e[33m", white: "\e[37m", reset: "\e[0m"
+    }.freeze
+
+    # @param elements_hash [Hash]  ref => element, as returned by Store#parse_date
+    # @param color_fn [Proc, nil]  set_color(text, color) — nil disables color
+    # @param resolver  [RefResolver, nil]
+    # @param with_refs [Boolean]   prefix each line with human ref
+    def initialize(elements_hash, color_fn: nil, resolver: nil, with_refs: false)
+      @elements  = elements_hash
+      @color_fn  = color_fn || method(:_ansi_color)
+      @resolver  = resolver
+      @with_refs = with_refs
+    end
+
+    # Renders elements as an indented tree. @mps containers shown as group headers.
+    # Returns the number of non-MPS elements printed, or just the rendered string
+    # if called for its side-effect-free return value.
+    def render_tree
+      sorted = @elements.sort_by { |k, _| k.split(".").map(&:to_i) }
+      return ["", 0] if sorted.empty?
+
+      root_segs = sorted.first.first.split(".").size
+      lines = []
+      shown = 0
+
+      sorted.each do |ref_key, el|
+        depth = ref_key.split(".").size - root_segs - 1
+        next if depth < 0
+
+        if el.is_a?(::MPS::Elements::MPS)
+          prefix = "#{ref_key}."
+          any_visible = @elements.any? { |k, v| k.start_with?(prefix) && !v.is_a?(::MPS::Elements::MPS) }
+          next unless any_visible
+          indent    = "  " * (depth + 1)
+          human     = @resolver&.to_human(ref_key) || ref_key
+          ref_col   = @with_refs ? "#{_colorize(human.ljust(12), :white)}  " : ""
+          lines << "#{indent}#{ref_col}#{_colorize("[@mps]", :white)}"
+        else
+          indent    = "  " * (depth + 1)
+          human     = @resolver&.to_human(ref_key) || ref_key
+          ref_col   = @with_refs ? "#{_colorize(human.ljust(12), :white)}  " : ""
+          lines << "#{indent}#{ref_col}#{_element_line(el)}"
+          shown += 1
+        end
+      end
+
+      [lines.join("\n"), shown]
+    end
+
+    # Renders a single element as a terminal line (no indentation).
+    def render_element(el, depth: 0)
+      indent = "  " * (depth + 1)
+      "#{indent}#{_element_line(el)}"
+    end
+
+    # Returns a tag-frequency table as a string.
+    # elements_hash should already be filtered (MPS containers excluded).
+    def render_tag_table
+      counts = Hash.new(0)
+      @elements.each_value do |el|
+        next if el.is_a?(::MPS::Elements::MPS)
+        el.tags.each { |t| counts[t] += 1 }
+      end
+      return _colorize("(no tags found)", :yellow) if counts.empty?
+      counts.sort_by { |_, v| -v }
+            .map { |tag, n| "  #{_colorize(tag, :white)} (#{n})" }
+            .join("\n")
+    end
+
+    private
+
+    def _element_line(el)
+      type_name = el.class::SIGNATURE_STAMP
+      badge     = _colorize("[#{type_name}]", TYPE_COLORS.fetch(type_name, :white))
+      extra     = _element_extra(el)
+      body_line = el.body_str.strip.lines.first&.strip
+      tags_str  = el.tags.empty? ? "" : " #{_colorize("[#{el.tags.join(', ')}]", :white)}"
+      "#{badge} #{extra}#{body_line}#{tags_str}"
+    end
+
+    def _element_extra(el)
+      case el
+      when ::MPS::Elements::Task
+        status = el.parsed_args[:status] || "open"
+        color  = status == "done" ? :green : :yellow
+        "(#{_colorize(status, color)}) "
+      when ::MPS::Elements::Log
+        dur = el.duration_str
+        dur ? "(#{_colorize(dur, :yellow)}) " : ""
+      when ::MPS::Elements::Reminder
+        at = el.parsed_args[:at]
+        at ? "(#{_colorize(at, :magenta)}) " : ""
+      else
+        ""
+      end
+    end
+
+    def _colorize(text, color)
+      @color_fn.call(text, color)
+    end
+
+    # Fallback colorizer using ANSI codes when no Thor color_fn is provided.
+    def _ansi_color(text, color)
+      code = ANSI_CODES[color]
+      return text unless code
+      "#{code}#{text}#{ANSI_CODES[:reset]}"
+    end
+  end
+end

data/lib/mps/query.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module MPS
+  # Encapsulates filter predicates derived from CLI options.
+  # Has no dependency on Thor; fully unit-testable.
+  #
+  # Usage:
+  #   q = Query.new(type: "task", status: "open", tag: "work")
+  #   filtered_hash = q.apply(elements_hash)
+  class Query
+    def initialize(opts = {})
+      @type_filter = opts[:type]&.downcase
+      @tag_filter  = opts[:tag]
+      # Collect schema-driven attribute filters from all element classes.
+      @attr_filters = _collect_attr_filters(opts)
+    end
+
+    # Returns a new hash containing only elements that pass all active filters.
+    # @mps container elements are always excluded.
+    def apply(elements_hash)
+      elements_hash.select { |_, el| !el.is_a?(::MPS::Elements::MPS) && _match?(el) }
+    end
+
+    # Applies filters while preserving the full tree structure including @mps
+    # containers. Used by the presenter's tree renderer so group headers are
+    # correctly suppressed when all their children are filtered out.
+    def apply_for_tree(elements_hash)
+      elements_hash.select do |ref_key, el|
+        if el.is_a?(::MPS::Elements::MPS)
+          prefix = "#{ref_key}."
+          elements_hash.any? { |k, v| k.start_with?(prefix) && !v.is_a?(::MPS::Elements::MPS) && _match?(v) }
+        else
+          _match?(el)
+        end
+      end
+    end
+
+    def match?(el)
+      _match?(el)
+    end
+
+    private
+
+    def _match?(el)
+      return false if el.is_a?(::MPS::Engines::Parser::Unknown)
+      return false if @type_filter && el.class::SIGNATURE_STAMP != @type_filter
+      return false if @tag_filter  && !el.tags.include?(@tag_filter)
+
+      @attr_filters.each do |name, filter_val|
+        el_val = el.parsed_args[name]
+        return false if el_val.nil? || el_val.to_s != filter_val
+      end
+      true
+    end
+
+    def _collect_attr_filters(opts)
+      filters = {}
+      ::MPS::Elements.constants
+        .map    { |k| ::MPS::Elements.const_get(k) }
+        .select { |x| x.class == Class }
+        .each do |klass|
+          klass.schema.each do |name, defn|
+            next unless defn[:flag]
+            flag_sym = defn[:flag].tr("-", "_").to_sym
+            filters[name] = opts[flag_sym].to_s if opts[flag_sym]
+          end
+        end
+      filters
+    end
+  end
+end

data/lib/mps/ref_resolver.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module MPS
+  # Translates between epoch ref-paths (e.g. "20260428.2.1") and
+  # human-readable refs (e.g. "note-1.1").
+  #
+  # Human ref format:
+  #   Top-level non-MPS:  {type}-{n}         where n counts per type across top-level
+  #   First-level nested: {parent_human}.{m}  where m is the child's sequential index
+  #   Deeper nesting:     same pattern extended (type-1.2.1, etc.)
+  #   @mps containers:    mps-{n}
+  class RefResolver
+    def initialize(elements_hash)
+      @epoch_to_human = {}
+      @human_to_epoch = {}
+      _build_maps(elements_hash)
+    end
+
+    # Returns the human ref for +epoch_ref+, or nil if not mapped.
+    def to_human(epoch_ref)
+      @epoch_to_human[epoch_ref]
+    end
+
+    # Returns the epoch ref for +human_ref+, or nil if not mapped.
+    def to_epoch(human_ref)
+      @human_to_epoch[human_ref]
+    end
+
+    # Resolves either form. Human refs are translated to epoch; epoch refs
+    # are returned as-is (validated to exist in the mapping).
+    def resolve(ref_str)
+      return @human_to_epoch[ref_str] if @human_to_epoch.key?(ref_str)
+      return ref_str if @epoch_to_human.key?(ref_str)
+      nil
+    end
+
+    # Returns all mapped epoch refs sorted by document order.
+    def all_epoch_refs
+      @epoch_to_human.keys
+    end
+
+    private
+
+    def _build_maps(elements_hash)
+      return if elements_hash.empty?
+
+      sorted = elements_hash.sort_by { |k, _| k.split(".").map(&:to_i) }
+      root_ref   = sorted.first.first
+      root_depth = root_ref.split(".").size  # always 1 (epoch only)
+
+      type_counters = Hash.new(0)
+
+      sorted.each do |epoch_ref, el|
+        depth = epoch_ref.split(".").size - root_depth  # 0=root, 1=top-level, 2+=nested
+
+        next if depth <= 0  # skip synthetic root wrapper
+
+        if depth == 1
+          next if el.is_a?(Engines::Parser::Unknown)
+          type_name = el.class::SIGNATURE_STAMP
+          type_counters[type_name] += 1
+          human = "#{type_name}-#{type_counters[type_name]}"
+        else
+          parts        = epoch_ref.split(".")
+          parent_epoch = parts[0..-2].join(".")
+          child_idx    = parts.last
+          parent_human = @epoch_to_human[parent_epoch]
+          next unless parent_human
+          human = "#{parent_human}.#{child_idx}"
+        end
+
+        @epoch_to_human[epoch_ref] = human
+        @human_to_epoch[human]     = epoch_ref
+      end
+    end
+  end
+end

data/lib/mps/store.rb

@@ -3,10 +3,13 @@
 module MPS
   class Store
     def initialize(storage_dir)
-      @storage_dir     = storage_dir
-      @element_classes = Elements.constants
+      @storage_dir        = storage_dir
+      @element_classes    = Elements.constants
         .map    { |k| Elements.const_get(k) }
         .select { |x| x.class == Class }
+      @interpolator_classes = Interpolators.constants
+        .map    { |k| Interpolators.const_get(k) }
+        .select { |x| x.class == Class }
     end
 
     # First .mps file found for +date+, or nil.
@@ -31,7 +34,14 @@ module MPS
     def parse_date(date)
       path = find_file(date)
       return {} unless path
-      Engines::Parser.parse_mps_file_to_elements_hash(path, @element_classes)
+      Engines::Parser.parse_mps_file_to_elements_hash(
+        path, @element_classes, interpolator_classes: @interpolator_classes
+      )
+    end
+
+    # Returns a RefResolver built from the parsed elements for +date+.
+    def resolver_for(date)
+      RefResolver.new(parse_date(date))
     end
 
     # Appends a new element to today's (or +date+'s) file. Returns the file path.
@@ -57,19 +67,98 @@ module MPS
     end
 
     # Full-text search across files. Returns [{element:, file:, date_str:}].
-    # +since_date+ is a Date; +type_filter+ and +tag_filter+ are strings.
     def search(query, type_filter: nil, tag_filter: nil, since_date: nil)
       files = since_date ? files_since(since_date) : all_files
       files.flat_map do |file|
         date_str = File.basename(file).slice(0, 8)
-        Engines::Parser.parse_mps_file_to_elements_hash(file, @element_classes)
+        Engines::Parser.parse_mps_file_to_elements_hash(
+          file, @element_classes, interpolator_classes: @interpolator_classes
+        )
           .values
-          .reject { |e| e.is_a?(Elements::MPS) }
+          .reject { |e| e.is_a?(Elements::MPS) || e.is_a?(Engines::Parser::Unknown) }
           .select { |e| type_filter.nil? || e.class::SIGNATURE_STAMP == type_filter }
           .select { |e| tag_filter.nil?  || e.tags.include?(tag_filter) }
           .select { |e| query.nil?       || e.body_str.downcase.include?(query.downcase) }
           .map    { |e| { element: e, file: file, date_str: date_str } }
       end
     end
+
+    # Rewrites an element's args bracket in-place and saves atomically.
+    #
+    # +ref_str+ may be an epoch ref ("20260428.1") or a human ref ("task-1").
+    # Human refs are resolved against +date+ (defaults to today).
+    # +new_attrs+ is a hash of attribute_name => new_value (symbol keys).
+    # Returns true on success, false if element not found or file unchanged.
+    def rewrite_element(ref_str, new_attrs, date: Date.today)
+      epoch_ref, path = _resolve_ref_to_path(ref_str, date)
+      return false unless epoch_ref && path
+
+      elements = Engines::Parser.parse_mps_file_to_elements_hash(path, @element_classes)
+      el = elements[epoch_ref]
+      return false unless el
+      return false if el.is_a?(Engines::Parser::Unknown)
+
+      _rewrite_element_in_file(path, el, new_attrs)
+    end
+
+    private
+
+    # Returns [epoch_ref, file_path] for the given ref_str, or [nil, nil].
+    def _resolve_ref_to_path(ref_str, date)
+      if ref_str =~ /\A\d{8}\.\d/
+        # Epoch ref — date is encoded in the prefix (YYYYMMDD)
+        date_str = ref_str[0, 8]
+        begin
+          d = Date.strptime(date_str, "%Y%m%d")
+        rescue ArgumentError
+          return [nil, nil]
+        end
+        path = find_file(d)
+        return [nil, nil] unless path
+        [ref_str, path]
+      else
+        # Human ref — resolve using the given date
+        path = find_file(date)
+        return [nil, nil] unless path
+        elements = Engines::Parser.parse_mps_file_to_elements_hash(path, @element_classes)
+        resolver = RefResolver.new(elements)
+        epoch_ref = resolver.to_epoch(ref_str)
+        return [nil, nil] unless epoch_ref
+        [epoch_ref, path]
+      end
+    end
+
+    def _rewrite_element_in_file(path, el, new_attrs)
+      content = File.read(path)
+      type    = el.class::SIGNATURE_STAMP
+      raw     = el.raw_args.to_s
+
+      # Merge new_attrs over existing parsed_args (preserve tags)
+      existing_tags   = el.tags.dup
+      merged          = el.parsed_args.reject { |k, _| k == :tags }.merge(new_attrs)
+      new_attr_parts  = merged.reject { |_, v| v.nil? }.map { |k, v| "#{k}: #{v}" }
+      new_args        = (new_attr_parts + existing_tags).join(", ")
+
+      if raw.empty?
+        old_pat  = /@#{Regexp.escape(type)}(?:\[\])?\s*\{/
+        new_open = "@#{type}[#{new_args}]{"
+      else
+        old_pat  = /@#{Regexp.escape(type)}\[#{Regexp.escape(raw)}\]\s*\{/
+        new_open = "@#{type}[#{new_args}]{"
+      end
+
+      new_content = content.sub(old_pat, new_open)
+      return false if new_content == content
+
+      tmp = "#{path}.tmp.#{Process.pid}"
+      begin
+        File.write(tmp, new_content)
+        File.rename(tmp, path)
+        true
+      rescue StandardError
+        File.delete(tmp) if File.exist?(tmp)
+        false
+      end
+    end
   end
 end

data/lib/mps/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MPS
-  VERSION = "0.5.0"
+  VERSION = "1.0.1"
 end

data/lib/mps.rb

@@ -4,18 +4,20 @@ require "yaml"
 require "logger"
 require "chronic"
 require "tty-editor"
-require "strscan"
 require_relative "mps/version"
 require_relative "mps/mps"
+require_relative "mps/constants"
+require_relative "mps/config"
+require_relative "mps/interpolators/interpolators"
+require_relative "mps/elements/elements"
+require_relative "mps/engines/engines"
+require_relative "mps/ref_resolver"
+require_relative "mps/query"
+require_relative "mps/presenter"
+require_relative "mps/store"
+require_relative "cli/mps"
+require_relative "mps/cli/commands"
 
-ir "mps/constants"
-ir "mps/config"
-ir "mps/interpolators/interpolators"
-ir "mps/elements/elements"
-ir "mps/engines/engines"
-ir "mps/store"
-ir "cli/mps"
 module MPS
   class Error < StandardError; end
-  # Your code goes here...
 end

data/mps.gemspec

@@ -8,19 +8,20 @@ Gem::Specification.new do |spec|
   spec.authors       = ["mash-97"]
   spec.email         = ["itzmashz@gmail.com"]
 
-  spec.summary       = "MPS (MonoPsyches)"
-  spec.description   = "Manage MonoPsyches."
+  spec.summary     = "Structured plain-text productivity CLI"
+  spec.description = "MPS (MonoPsyches) is a terminal-based productivity system that stores " \
+                     "tasks, notes, reminders, logs, and nested workflow structures in plain-text " \
+                     ".mps files. It provides composable typed elements with optional arguments, " \
+                     "hierarchical organization, natural-language date handling, full-text search, " \
+                     "statistics, export tools, and git integration while keeping all data " \
+                     "human-readable and portable."
   spec.homepage      = "https://github.com/mash-97/mps"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
 
-  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
-
-  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["homepage_uri"]    = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
-  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
 
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
   end
@@ -28,22 +29,12 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-  spec.add_runtime_dependency "strscan", ">= 3.0"
-  spec.add_runtime_dependency "thor", "~> 1.3"
+  spec.add_runtime_dependency "thor",       "~> 1.3"
   spec.add_runtime_dependency "tty-editor", "~> 0.7.0"
-  spec.add_runtime_dependency "chronic", "~> 0.10.2"
-  spec.add_runtime_dependency "cli-ui", "~> 2.2"
+  spec.add_runtime_dependency "chronic",    "~> 0.10.2"
+  spec.add_runtime_dependency "cli-ui",     "~> 2.2"
 
-  spec.add_development_dependency "rake", "~> 13.2"
+  spec.add_development_dependency "rake",     "~> 13.2"
   spec.add_development_dependency "minitest", "~> 5.0"
-  spec.add_development_dependency "fakefs", "~> 2.5"
-  spec.add_development_dependency "tmpdir", ">= 0.1.3"
-  spec.add_development_dependency "yard", "~> 0.9.37"
-  spec.add_development_dependency "rack", "~> 3.1"
-  spec.add_development_dependency "webrick", "~> 1.8"
-  spec.add_development_dependency "rackup", "~> 2.1"
-  # For more information and examples about making a new gem, checkout our
-  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.add_development_dependency "fakefs",   "~> 2.5"
 end

data/prompt.txt

@@ -0,0 +1,64 @@
+Re-analyze this repository from first principles.
+
+Do NOT rely only on previous memory/context. Re-read the codebase itself deeply, including:
+
+- README.md
+- GETTING_STARTED.md
+- CLAUDE.md
+- source code
+- configs
+- abstractions
+- interfaces/contracts
+- module boundaries
+- orchestration/composition systems
+- extension points
+- naming conventions
+- internal APIs
+- metaprogramming/framework-like constructs
+
+Your goal is NOT merely to explain what the code does.
+
+Your task is to reconstruct and infer:
+
+- the philosophy behind the system
+- the intended architectural direction
+- the design patterns and abstractions
+- the implementation methodology
+- the compositional/extensibility model
+- the long-term ecosystem vision emerging from the code
+- the difference between documented vision vs actual implementation
+- the difference between intentional architecture vs emergent architecture
+
+Treat this repository not just as an application, but potentially as:
+- a framework
+- DSL
+- compositional architecture system
+- ecosystem platform
+- runtime abstraction layer
+- modular engineering paradigm
+- or another evolving architectural model
+
+Analyze deeply:
+
+1. Core vision and goals
+2. Macro + micro architecture
+3. Design patterns (explicit and emergent)
+4. Dependency/layering philosophy
+5. Composition/extensibility strategy
+6. Naming and semantic modeling philosophy
+7. Current architectural maturity
+8. Strengths and architectural advantages
+9. Weaknesses, inconsistencies, and technical debt
+10. Scalability/evolution potential
+11. Architectural risks and future bottlenecks
+12. What this project is naturally evolving into
+
+Important:
+- Infer intent from implementation details.
+- Explain WHY architectural decisions appear to exist.
+- Identify unfinished abstractions and partially realized ideas.
+- Distinguish accidental complexity from intentional abstraction.
+- Be analytical and critical, not flattering.
+- Do not oversimplify the project into a generic CRUD/application architecture unless the code genuinely reflects that.
+
+Produce a comprehensive architecture understanding document that future AI agents and developers can use as the canonical mental model for evolving the system.