@zalom/plastic 1.14.1 → 2.0.0-alpha.10

package/scripts/hook-capture

@@ -0,0 +1,255 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Usage: hook-capture (reads the UserPromptSubmit stdin JSON payload)
+# Intent 298. One UserPromptSubmit process replacing hook-continue,
+# hook-future-intent-check, and hook-auto-arm: it appends a pending line to
+# the session day ledger, detects "continue" and "auto" prompts, and hints at
+# matching Future intents. Every job runs in its own rescue and the hook
+# always exits 0 (spec D2).
+
+require "json"
+require "yaml"
+require "open3"
+require "fileutils"
+require_relative "lib/session_ledger"
+require_relative "lib/dashboard_banner"
+
+raw = begin
+  $stdin.read
+rescue StandardError
+  nil
+end
+exit 0 if raw.nil? || raw.strip.empty?
+
+payload = begin
+  JSON.parse(raw)
+rescue StandardError
+  nil
+end
+exit 0 unless payload.is_a?(Hash)
+
+session_id = payload["session_id"].to_s
+prompt = payload["prompt"].to_s
+prompt = payload["user_prompt"].to_s if prompt.empty?
+cwd = payload["cwd"].to_s
+cwd = Dir.pwd if cwd.empty?
+
+plastic_home = File.expand_path(ENV["PLASTIC_HOME"] || "~/.plastic")
+store = File.join(plastic_home, "store")
+templates = File.expand_path("../templates", __dir__)
+sid = SessionLedger.short_session_id(nil, session_id)
+today = SessionLedger.day_id
+
+# --- Extracted matching logic, shared by both the global and project store
+# passes of job (f) below (mirrors hook-future-intent-check verbatim). ---
+def future_intent_matches(store_root, message)
+  index_path = File.join(store_root, "INDEX.md")
+  return [] unless File.exist?(index_path)
+
+  lines = File.readlines(index_path)
+  future_dirs = []
+  section = nil
+
+  lines.each do |line|
+    section = :future if line.start_with?("## Future")
+    section = nil if line.start_with?("## ") && !line.start_with?("## Future")
+    next unless section == :future && line.strip.start_with?("- [")
+
+    future_dirs << $1 if line =~ /store\/([\w-]+)\//
+  end
+  return [] if future_dirs.empty?
+
+  matches = []
+  message_words = message.split(/\W+/).reject { |w| w.length < 4 }
+
+  future_dirs.each do |dir|
+    intent_path = File.join(store_root, "store", dir, "#{dir}.md")
+    next unless File.exist?(intent_path)
+
+    content = File.read(intent_path)
+
+    tags = []
+    tags = $1.split(",").map(&:strip).map(&:downcase) if content =~ /^tags:\s*\[([^\]]+)\]/
+
+    intent_name = ""
+    intent_name = $1.downcase if content =~ /^intent:\s*["']?(.+?)["']?\s*$/
+
+    keywords = (tags + intent_name.split(/\W+/).reject { |w| w.length < 4 }).map(&:downcase).uniq
+
+    matched_keywords = keywords.select { |kw| message.include?(kw) }
+    name_matches = message_words.select { |w| intent_name.include?(w) }
+    matched_keywords = (matched_keywords + name_matches).uniq
+
+    next if matched_keywords.empty?
+
+    index_line = lines.find { |l| l.include?(dir) }&.strip || "#{dir} - #{intent_name}"
+    matches << { "index_line" => index_line, "keywords" => matched_keywords }
+  end
+  matches
+end
+
+# The store_root that carries the current project's own store, resolved from
+# cwd through projects.yml, mirroring SessionLedger.project_slug's matching
+# but returning nil (not "global") when nothing matches, since there is then
+# no distinct second store to hint against.
+def resolve_project_store_root(cwd, plastic_home)
+  projects_path = File.join(plastic_home, "projects.yml")
+  return nil unless File.exist?(projects_path)
+
+  data = begin
+    YAML.safe_load(File.read(projects_path))
+  rescue StandardError
+    nil
+  end
+  data = {} unless data.is_a?(Hash)
+  projects = data["projects"].is_a?(Hash) ? data["projects"] : {}
+  expanded_cwd = File.expand_path(cwd)
+
+  matches = projects.filter_map do |slug, info|
+    next unless info.is_a?(Hash) && slug.is_a?(String)
+
+    path = info["path"]
+    next unless path
+
+    root = File.expand_path(path)
+    next unless expanded_cwd == root || expanded_cwd.start_with?("#{root}#{File::SEPARATOR}")
+
+    [root.length, slug]
+  end
+
+  best = matches.max_by { |(length, _slug)| length }
+  best ? File.join(plastic_home, "projects", best[1]) : nil
+end
+
+def truncate(text, max)
+  return text if text.length <= max
+
+  "#{text[0, max - 3]}..."
+end
+
+# --- (a) tmp root + heartbeat, guarded on the pointer (spec D9) ------------
+# Session start writes the `current` pointer; a capture with no pointer yet
+# means session start never ran for this session at all (a `-p` print
+# session, a resumed background job, an unregistered SessionStart hook), so
+# neither the per-session dir nor its heartbeat is created. UserPromptSubmit
+# fires before PostToolUse, so capture is the FIRST creator of every orphan
+# `.tmp/<sid>/` this guard prevents; hook-record carries the same guard for
+# its own (later) heartbeat write.
+begin
+  if File.exist?(SessionLedger.pointer_path(store, sid))
+    SessionLedger.ensure_tmp_root(store)
+    FileUtils.mkdir_p(SessionLedger.session_tmp_dir(store, sid))
+    File.write(SessionLedger.heartbeat_path(store, sid), "#{Time.now.utc.iso8601}\n")
+  end
+rescue StandardError
+  nil
+end
+
+# --- (b) read the pointer -----------------------------------------------
+skip_day_ledger = false
+begin
+  pointer = SessionLedger.pointer_path(store, sid)
+  if File.exist?(pointer)
+    current = File.read(pointer).strip
+    skip_day_ledger = !current.empty? && current != today
+  end
+rescue StandardError
+  nil
+end
+
+# --- (c) pending checklist line -------------------------------------------
+# Gated on SessionLedger.capture_worthy?(prompt) (spec D2), a pure predicate
+# over the RAW prompt so it sees the true first character and multi-line
+# shape; the line text itself is still the sanitized, truncated copy.
+unless skip_day_ledger
+  begin
+    if SessionLedger.capture_worthy?(prompt)
+      project = SessionLedger.project_slug(cwd, plastic_home: plastic_home)
+      clean = truncate(SessionLedger.sanitize_summary(prompt), 120)
+      SessionLedger.open_day(store: store, day: today, templates: templates, author: sid)
+      line = SessionLedger.checklist_line(:pending, sid, project, clean)
+      SessionLedger.append_line(SessionLedger.checklist_path(store, today), line,
+                                 header: SessionLedger.checklist_header(today))
+    end
+  rescue StandardError
+    nil
+  end
+end
+
+context_parts = []
+system_message = nil
+
+# --- (d) "continue" cockpit -------------------------------------------------
+begin
+  if prompt.match?(/\bcontinue\b/i)
+    dashboard = File.expand_path("dashboard.rb", __dir__)
+    if File.exist?(dashboard)
+      cockpit, _err, status = Open3.capture3({ "RUBYOPT" => nil }, "ruby", dashboard, "continue")
+      if status.success? && !cockpit.strip.empty?
+        context_parts << (cockpit.rstrip +
+          "\n\nFollow the plastic-intent-continuing skill workflow to resume: " \
+          "if active intents exist, read their state and resume; otherwise surface the " \
+          "most-valuable next work and any stale or triage intents from the board above.")
+
+        begin
+          data_json, _data_err, data_status = Open3.capture3({ "RUBYOPT" => nil }, "ruby", dashboard,
+                                                               "continue", "--data")
+          if data_status.success?
+            banner = DashboardBanner.render(JSON.parse(data_json))
+            system_message = banner if banner
+          end
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+rescue StandardError
+  nil
+end
+
+# --- (e) auto-trigger steering (hook-auto-arm job 1 only) ------------------
+begin
+  message_lower = prompt.downcase
+  auto_triggers = ["take it from here", "deliver this", "/plastic-auto", "auto mode"].freeze
+  triggered = auto_triggers.any? { |p| message_lower.include?(p) } || message_lower.match?(/\bauto\b/)
+  if triggered
+    context_parts << "Auto-mode request detected. Invoke the plastic-auto skill to deliver the " \
+                      "active intent autonomously - it takes the intent under a lock and a worktree " \
+                      "and points this session at it."
+  end
+rescue StandardError
+  nil
+end
+
+# --- (f) Future-intent hint, global store then the project's own store -----
+begin
+  message = prompt.to_s.downcase
+  if message.strip.length >= 10 && message.strip != "continue"
+    matches = future_intent_matches(plastic_home, message)
+    project_root = resolve_project_store_root(cwd, plastic_home)
+    matches += future_intent_matches(project_root, message) if project_root
+
+    if matches.any?
+      parts = ["PLASTIC - Future intents related to this message:\n"]
+      matches.each { |m| parts << "#{m["index_line"]} (matched: #{m["keywords"].join(", ")})" }
+      parts << "\nConsider asking the user if they want to activate any of these, or note the connection."
+      context_parts << parts.join("\n")
+    end
+  end
+rescue StandardError
+  nil
+end
+
+exit 0 if context_parts.empty?
+
+payload_out = {
+  "hookSpecificOutput" => {
+    "hookEventName" => "UserPromptSubmit",
+    "additionalContext" => context_parts.join("\n\n")
+  }
+}
+payload_out["systemMessage"] = system_message if system_message
+puts JSON.generate(payload_out)

package/scripts/hook-close

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# hook-close (intent 301): the SessionEnd hook. Reads the harness payload from
+# stdin (session_id, cwd, reason), takes the Plastic home from argv, and runs
+# SessionClose with the detached filer spawner. Always exits 0, prints nothing.
+#
+# Usage: hook-close <plastic_home>   (stdin: the hook JSON)
+
+require "json"
+require_relative "lib/session_ledger"
+require_relative "lib/session_close"
+
+plastic_home = ARGV[0]
+exit 0 if plastic_home.nil? || plastic_home.empty?
+
+payload =
+  begin
+    raw = $stdin.tty? ? "" : $stdin.read
+    raw.to_s.strip.empty? ? {} : JSON.parse(raw)
+  rescue JSON::ParserError
+    {}
+  end
+
+store = File.join(File.expand_path(plastic_home), "store")
+filer = File.expand_path("file-session-intent", __dir__)
+templates = File.expand_path("../templates", __dir__)
+begin
+  SessionClose.run(payload: payload, store: store, today: SessionLedger.day_id,
+                   spawner: SessionClose.default_spawner(filer),
+                   handoff: SessionClose.default_handoff(templates))
+rescue StandardError
+  nil
+end
+exit 0

package/scripts/hook-message-display

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# hook-message-display (intent 316a, O4): the MessageDisplay hook CLI. Reads
+# the harness's per-chunk JSON payload from stdin, hands it to MessageDisplay
+# (the pure handler class), and prints the hookSpecificOutput envelope when a
+# String comes back. Always exits 0, whatever happens — a raised exception
+# here must never surface as a non-zero exit or stray stderr on an ordinary
+# chunk of an ordinary message (matrix 31).
+#
+# This script is the one place in the O4 stack allowed to read ENV, the
+# clock, or Dir.tmpdir: MessageDisplay itself takes tmp_root/plastic_home/
+# color/now as constructor arguments and touches none of them directly.
+#
+# Claude adapter: Claude Code only; the core is harness-agnostic.
+
+# 317a (B1): the requires sit inside their own rescue - a missing or broken
+# lib file must never surface as a non-zero exit or stderr on a chunk of an
+# ordinary message (LoadError is a ScriptError, outside StandardError).
+begin
+  require "json"
+  require "time"
+  require "tmpdir"
+  require "yaml"
+  require_relative "lib/message_display"
+rescue ScriptError, StandardError
+  exit 0
+end
+
+def color_enabled?(plastic_home)
+  return false unless ENV["NO_COLOR"].to_s.empty?
+
+  cfg_path = File.join(plastic_home, "config.yml")
+  return true unless File.exist?(cfg_path)
+
+  cfg = YAML.safe_load(File.read(cfg_path))
+  display = cfg.is_a?(Hash) ? cfg["display"] : nil
+  return true unless display.is_a?(Hash)
+
+  display.fetch("ansi_screen", true) != false
+rescue StandardError
+  true
+end
+
+begin
+  raw = $stdin.tty? ? "" : $stdin.read
+  payload = raw.to_s.strip.empty? ? nil : JSON.parse(raw)
+
+  if payload.is_a?(Hash)
+    tmp_root = ENV["PLASTIC_TMP"].to_s.empty? ? Dir.tmpdir : ENV["PLASTIC_TMP"]
+    plastic_home = File.expand_path(ENV["PLASTIC_HOME"] || "~/.plastic")
+
+    handler = MessageDisplay.new(
+      tmp_root: tmp_root,
+      plastic_home: plastic_home,
+      color: color_enabled?(plastic_home),
+      now: Time.now,
+    )
+    result = handler.handle(payload)
+
+    if result.is_a?(String)
+      puts JSON.generate(
+        "hookSpecificOutput" => {
+          "hookEventName" => "MessageDisplay",
+          "displayContent" => result,
+        },
+      )
+    end
+  end
+rescue StandardError
+  nil
+end
+exit 0

package/scripts/hook-record

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Usage: hook-record (reads the PostToolUse stdin JSON payload)
+# Intent 298. Replaces hook-gate-check: never blocks, keeps the decoupled
+# intent-dir savepoint append byte for byte, refreshes the delivery-lock lease
+# for the owning session (intent 302, the lock gate's old allow-path job),
+# promotes the session's newest pending day-ledger line when a project file
+# lands, and calls the session-commit seam when that script exists. Always
+# exits 0 (spec D3).
+
+require "json"
+require "timeout"
+require "fileutils"
+require_relative "lib/savepoint"
+require_relative "lib/lock"
+require_relative "lib/session_ledger"
+
+raw = begin
+  $stdin.read
+rescue StandardError
+  nil
+end
+exit 0 if raw.nil? || raw.strip.empty?
+
+payload = begin
+  JSON.parse(raw)
+rescue StandardError
+  nil
+end
+exit 0 unless payload.is_a?(Hash)
+
+file_path = payload.dig("tool_input", "file_path") || payload.dig("tool_params", "file_path")
+exit 0 if file_path.to_s.empty?
+
+session_id = payload["session_id"].to_s
+cwd = payload["cwd"].to_s
+cwd = Dir.pwd if cwd.empty?
+
+file_path_abs = File.expand_path(file_path)
+
+# --- (a) decoupled savepoint ledger, byte for byte -------------------------
+intent_dir_abs = nil
+begin
+  intent_dir_abs = Savepoint.intent_dir_for(file_path_abs)
+  if intent_dir_abs
+    begin
+      Savepoint.append_savepoint(intent_dir_abs, file_path_abs)
+      if File.basename(file_path_abs) == "checklist.md" && Savepoint.stage_file_present?(file_path_abs)
+        Savepoint.append_exec_started(intent_dir_abs)
+      end
+    rescue StandardError
+      nil
+    end
+    # The lease heartbeat (intent 302, spec D10): the lock gate's allow path used
+    # to refresh delivery.lock on every edit; record does it now. Lock.heartbeat
+    # refuses a session that does not hold the lock, so a stranger's write never
+    # refreshes the owner's lease.
+    begin
+      Lock.heartbeat(intent_dir_abs, session: session_id) unless session_id.empty?
+    rescue StandardError
+      nil
+    end
+  end
+rescue StandardError
+  nil
+end
+
+plastic_home = File.expand_path(ENV["PLASTIC_HOME"] || "~/.plastic")
+
+# --- (b) stop the day-ledger path when inside ~/.plastic or an intent dir --
+inside_plastic = file_path_abs == plastic_home || file_path_abs.start_with?("#{plastic_home}/")
+skip_day_ledger = inside_plastic || !intent_dir_abs.nil?
+
+# --- (c) promote the newest pending line, Item savepoint, seam -------------
+unless skip_day_ledger
+  begin
+    store = File.join(plastic_home, "store")
+    sid = SessionLedger.short_session_id(nil, session_id)
+    today = SessionLedger.day_id
+
+    proceed = true
+    pointer = SessionLedger.pointer_path(store, sid)
+    if File.exist?(pointer)
+      current = File.read(pointer).strip
+      proceed = current.empty? || current == today
+    end
+
+    if proceed
+      checklist = SessionLedger.checklist_path(store, today)
+      target_summary = begin
+        SessionLedger.set_state(checklist, from: :pending, to: :open, session: sid)
+      rescue SessionLedger::LockUnavailableError
+        nil
+      end
+
+      if target_summary
+        project = SessionLedger.project_slug(cwd, plastic_home: plastic_home)
+        line = SessionLedger.savepoint_line("Item", sid, project, target_summary, now: Time.now)
+        SessionLedger.append_line(SessionLedger.savepoint_path(store, today), line, header: nil)
+
+        seam = File.expand_path("session-commit", __dir__)
+        if File.executable?(seam)
+          begin
+            # A bare Timeout.timeout around Open3.capture3 does not reliably bound a
+            # genuinely hanging child: capture3's internal wait still blocks on
+            # Process.waitpid for the child regardless of the raised Timeout::Error.
+            # Spawn directly and kill on timeout instead, so the 10s bound is real.
+            pid = Process.spawn({ "RUBYOPT" => nil }, seam, "--cwd", cwd, "--summary", target_summary,
+                                 "--session", sid, "--day", today,
+                                 [:out, :err] => File::NULL)
+            begin
+              Timeout.timeout(10) { Process.wait(pid) }
+            rescue Timeout::Error
+              begin
+                Process.kill("KILL", pid)
+              rescue StandardError
+                nil
+              end
+              begin
+                Process.wait(pid)
+              rescue StandardError
+                nil
+              end
+            end
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  rescue StandardError
+    nil
+  end
+end
+
+# --- (d) heartbeat, guarded on the pointer (spec D9) -----------------------
+# Session start writes the `current` pointer; with no pointer at all, session
+# start never ran for this session (a `-p` print session, a resumed
+# background job, an unregistered SessionStart hook), so neither the
+# per-session dir nor its heartbeat is created here -- guarding only the
+# write would still leave an empty directory that heartbeat_age's mtime
+# fallback reports as an orphan just the same.
+begin
+  store ||= File.join(plastic_home, "store")
+  sid ||= SessionLedger.short_session_id(nil, session_id)
+  if File.exist?(SessionLedger.pointer_path(store, sid))
+    SessionLedger.ensure_tmp_root(store)
+    FileUtils.mkdir_p(SessionLedger.session_tmp_dir(store, sid))
+    File.write(SessionLedger.heartbeat_path(store, sid), "#{Time.now.utc.iso8601}\n")
+  end
+rescue StandardError
+  nil
+end
+
+exit 0

package/scripts/hook-savepoint

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# hook-savepoint (intent 311): the PreCompact hook body. Reads the harness
+# payload from stdin (session_id, cwd), takes the Plastic home from argv,
+# writes this session's hand-off for the pointer's day, and prints one
+# message: the fixed text, plus the written file's path when a session
+# resolved (both harnesses relay the same launcher and the Codex pin feeds
+# both sides the same payload, so the two stay equal). Always exits 0,
+# always prints the message.
+#
+# Usage: hook-savepoint <plastic_home>   (stdin: the hook JSON)
+
+require "json"
+require_relative "lib/session_ledger"
+require_relative "lib/handoff"
+
+MESSAGE = "PLASTIC SAVEPOINT - context is being compacted. The hand-off for this " \
+          "session is written in today's day ledger " \
+          "(store/.sessions/<day>/handoff--<session>.md). " \
+          "After compaction say continue to resume from it."
+
+written = nil
+begin
+  plastic_home = ARGV[0].to_s
+  raw = $stdin.tty? ? "" : $stdin.read.to_s
+  payload = raw.strip.empty? ? {} : JSON.parse(raw)
+  payload = {} unless payload.is_a?(Hash)
+  session_id = payload["session_id"].to_s
+
+  unless plastic_home.empty? || session_id.strip.empty?
+    store = File.join(File.expand_path(plastic_home), "store")
+    session = SessionLedger.short_session_id(session_id, nil)
+    day = Handoff.day_for(store, session, today: SessionLedger.day_id)
+    written = Handoff.write(store: store, day: day, session: session, trigger: "precompact",
+                            templates: File.expand_path("../templates", __dir__))
+  end
+rescue StandardError, JSON::ParserError
+  nil
+end
+
+message = written ? "#{MESSAGE} This session's file: #{written}" : MESSAGE
+puts JSON.generate("systemMessage" => message)
+exit 0