@zalom/plastic 1.0.0-alpha.1

package/scripts/hook-gate-check

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# Usage: hook-gate-check <file_path>
+# PostToolUse gate enforcement for Plastic intent lifecycle.
+# Checks if a written file triggers a stage-transition gate.
+# Exit 0 = allow (optionally with transition context)
+# Exit 2 = block (gate violation)
+
+require "json"
+require_relative "lib/bridge"
+
+file_path = ARGV[0]
+exit 0 unless file_path && !file_path.empty?
+
+# --- Find bridge file ---
+
+session = ENV["CLAUDE_SESSION_ID"]
+bridge_path = nil
+bridge_data = nil
+
+if session && !session.empty?
+  bridge_path = Bridge.path(session)
+  bridge_data = Bridge.read(session) if File.exist?(bridge_path)
+end
+
+# Fallback: scan /tmp for most recent plastic bridge file
+unless bridge_data
+  candidates = Dir.glob("/tmp/plastic-*.json").reject { |f| f.end_with?(".tmp") }
+  if candidates.any?
+    bridge_path = candidates.max_by { |f| File.mtime(f) }
+    raw = JSON.parse(File.read(bridge_path)) rescue nil
+    if raw
+      session = raw["session"]
+      bridge_data = raw
+    end
+  end
+end
+
+# No bridge = no active intent = no enforcement
+exit 0 unless bridge_data && session
+
+# --- Resolve intent directory ---
+
+intent_info = bridge_data["intent"]
+exit 0 unless intent_info
+
+store = intent_info["store"]
+dir = intent_info["dir"]
+intent_dir = "#{store}/#{dir}"
+
+# Normalize both paths for comparison
+intent_dir_abs = File.expand_path(intent_dir)
+file_path_abs = File.expand_path(file_path)
+
+# Not inside intent dir = not our business
+exit 0 unless file_path_abs.start_with?("#{intent_dir_abs}/")
+
+# --- Determine if this is a stage-transition file ---
+
+relative = file_path_abs.sub("#{intent_dir_abs}/", "")
+basename = File.basename(file_path)
+
+stage_files = %w[spec.md plan.md checklist.md outcome.md]
+is_stage_file = stage_files.include?(basename)
+is_action_file = relative.start_with?("actions/")
+
+if is_stage_file || is_action_file
+  # Run gate check
+  error = Bridge.check_gate(intent_dir_abs, file_path_abs)
+
+  if error
+    # Gate violation — block the write
+    bridge_data["build"]["gate_failures"] = (bridge_data["build"]["gate_failures"] || 0) + 1
+    Bridge.write(session, bridge_data)
+
+    payload = {
+      "decision" => "block",
+      "reason" => "PLASTIC GATE — #{error}"
+    }
+    puts JSON.generate(payload)
+    exit 2
+  end
+
+  # Gate passed — update bridge with new stage
+  old_stage = bridge_data["build"]["stage"]
+  new_stage = Bridge.derive_stage(intent_dir_abs)
+  new_missing = Bridge.missing_for_stage(new_stage) - Bridge.has_files(intent_dir_abs)
+
+  bridge_data["build"]["stage"] = new_stage
+  bridge_data["build"]["has"] = Bridge.has_files(intent_dir_abs)
+  bridge_data["build"]["missing"] = new_missing
+  bridge_data["build"]["gate_failures"] = 0
+  bridge_data["build"]["last_activity"] = Time.now.utc.iso8601
+
+  if old_stage != new_stage
+    bridge_data["observe"]["last_transition"] = "#{old_stage} → #{new_stage}"
+  end
+
+  Bridge.write(session, bridge_data)
+
+  # Build transition context
+  stage_labels = { "what" => "What", "why" => "Why", "how" => "How", "exec" => "Exec", "done" => "Done" }
+  next_hints = {
+    "why" => "write spec.md",
+    "how" => "Why complete. Invoke plastic:auto to deliver autonomously, or write plan.md manually.",
+    "exec" => "How complete. Invoke plastic:auto or plastic:executing-plan to execute, or work through the checklist manually.",
+    "done" => "Exec complete. Intent must be completed now — write outcome.md, update INDEX.md, auto-commit. Use plastic:auto or do it manually."
+  }
+
+  context_parts = ["PLASTIC"]
+  if old_stage != new_stage
+    context_parts[0] = "PLASTIC — Stage transition: #{stage_labels[old_stage] || old_stage} → #{stage_labels[new_stage] || new_stage}."
+  else
+    context_parts[0] = "PLASTIC — #{basename} written (stage: #{stage_labels[new_stage] || new_stage})."
+  end
+  context_parts << "#{basename} written."  if old_stage != new_stage
+  if new_missing.any?
+    context_parts << "Next: #{new_missing.join(", ")}"
+  elsif next_hints[new_stage]
+    context_parts << "Next: #{next_hints[new_stage]}"
+  end
+
+  payload = {
+    "hookSpecificOutput" => {
+      "hookEventName" => "PostToolUse",
+      "additionalContext" => context_parts.join(" ")
+    }
+  }
+  puts JSON.generate(payload)
+  exit 0
+else
+  # Regular file in intent dir — just update last_activity
+  bridge_data["build"]["last_activity"] = Time.now.utc.iso8601
+  Bridge.write(session, bridge_data)
+  exit 0
+end

package/scripts/hook-session-start

@@ -0,0 +1,224 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# Usage: hook-session-start <index_path> <store_root> <mode> [plugin_root]
+# Outputs hook JSON for the session-start hook. Exits silently if nothing to show.
+
+require "json"
+require "date"
+require "yaml"
+require_relative "lib/bridge"
+
+index_path, store_root, mode, plugin_root = ARGV
+exit 0 unless index_path && store_root && mode
+
+# --- Parse INDEX.md ---
+
+lines = File.readlines(index_path)
+active = []
+future = []
+section = nil
+
+lines.each do |line|
+  if line.start_with?("## Active")
+    section = :active
+    next
+  elsif line.start_with?("## Future")
+    section = :future
+    next
+  elsif line.start_with?("## ")
+    section = nil
+    next
+  end
+
+  next unless section && line.strip.start_with?("- [")
+
+  if section == :active
+    active << line.strip
+  elsif section == :future
+    future << line.strip
+  end
+end
+
+# --- Derive bridge for active intent ---
+
+bridge_data = nil
+if active.length == 1 && active.first =~ /store\/([\w-]+)\//
+  dir_name = $1
+  intent_dir = "#{store_root}/store/#{dir_name}"
+  session = ENV["CLAUDE_SESSION_ID"] || Process.pid.to_s
+  intent_id = dir_name.split("--").first
+  intent_name = active.first[/\[([^\]]+)\]/, 1] || "unknown"
+  bridge_data = Bridge.derive(session, intent_id: intent_id, intent_dir: intent_dir, store: store_root, name: intent_name)
+end
+
+# --- Detect stale future intents ---
+
+stale = []
+read_config = if plugin_root && !plugin_root.empty?
+  "#{plugin_root}/scripts/read-config"
+else
+  File.expand_path("~/.plastic/scripts/read-config")
+end
+stale_days = `"#{read_config}" stale_threshold_days`.strip.to_i
+stale_days = 3 if stale_days == 0
+
+future.each do |f|
+  if f =~ /store\/([\w-]+)\//
+    dir_name = $1
+    intent_file = "#{store_root}/store/#{dir_name}/#{dir_name}.md"
+    next unless File.exist?(intent_file)
+
+    content = File.read(intent_file)
+    if content =~ /^created:\s*['"]?(\d{4}-\d{2}-\d{2})/
+      age = (Date.today - Date.parse($1)).to_i
+      if age >= stale_days
+        name = f[/\[([^\]]+)\]/, 1] || "unknown"
+        stale << { name: name, age: age, entry: f }
+      end
+    end
+  end
+end
+
+# --- Detect current project ---
+
+current_project = nil
+project_active = []
+project_future = []
+
+projects_path = "#{store_root}/projects.yml"
+if File.exist?(projects_path)
+  projects = YAML.safe_load(File.read(projects_path)) rescue {}
+  cwd = Dir.pwd
+  (projects["projects"] || {}).each do |slug, info|
+    project_path = File.expand_path(info["path"])
+    if cwd.start_with?(project_path)
+      current_project = { "slug" => slug, "parent" => info["parent"], "path" => project_path }
+      project_index = "#{store_root}/projects/#{slug}/INDEX.md"
+      if File.exist?(project_index)
+        p_section = nil
+        File.readlines(project_index).each do |pline|
+          if pline.start_with?("## Active")
+            p_section = :active
+            next
+          elsif pline.start_with?("## Future")
+            p_section = :future
+            next
+          elsif pline.start_with?("## ")
+            p_section = nil
+            next
+          end
+          next unless p_section && pline.strip.start_with?("- [")
+          project_active << pline.strip if p_section == :active
+          project_future << pline.strip if p_section == :future
+        end
+      end
+      break
+    end
+  end
+end
+
+# --- Load deprecations ---
+
+deprecations = []
+if plugin_root && !plugin_root.empty?
+  dep_file = "#{plugin_root}/deprecations.yml"
+  if File.exist?(dep_file)
+    dep_data = YAML.safe_load(File.read(dep_file)) rescue {}
+    deprecations = dep_data["deprecations"] || []
+  end
+end
+
+dismissed_json = `"#{read_config}" deprecations_dismissed`.strip
+dismissed = begin
+  JSON.parse(dismissed_json)
+rescue
+  []
+end
+
+current_version = nil
+if plugin_root && !plugin_root.empty?
+  plugin_json_path = "#{plugin_root}/.claude-plugin/plugin.json"
+  if File.exist?(plugin_json_path)
+    pj = JSON.parse(File.read(plugin_json_path)) rescue {}
+    current_version = pj["version"]
+  end
+end
+
+active_deprecations = deprecations.select do |dep|
+  next true if dep["severity"] == "critical"
+  next true if current_version && dep["removal"] == current_version
+  !dismissed.include?(dep["id"])
+end
+
+# --- Early exit if nothing to show ---
+
+all_active = active + project_active
+all_future = future + project_future
+exit 0 if all_active.empty? && stale.empty? && all_future.empty? && active_deprecations.empty?
+
+# --- Build context ---
+
+parts = []
+
+if current_project
+  parts << "PLASTIC — Global store | Project: #{current_project["slug"]} (#{current_project["path"]})\n"
+else
+  parts << "PLASTIC — Global store loaded from ~/.plastic/\n"
+end
+
+if all_active.any?
+  parts << "Active intents:\n"
+  all_active.each { |a| parts << a }
+  if bridge_data
+    stage = bridge_data["build"]["stage"]
+    missing = bridge_data["build"]["missing"]
+    missing_str = missing.empty? ? "none" : missing.join(", ")
+    parts << "Stage: #{stage} | Next: #{missing_str}"
+  end
+  parts << ""
+else
+  parts << "No active intents. #{future.length} future intents available.\n"
+end
+
+if stale.any?
+  parts << "\nStale future intents (untouched for days):\n"
+  stale.each do |s|
+    parts << "- #{s[:name]} (#{s[:age]} days) — consider: activate, abandon, or defer to agent"
+  end
+  parts << "\nWhen appropriate, ask the user what to do with stale intents."
+end
+
+if active_deprecations.any?
+  parts << ""
+  active_deprecations.each do |dep|
+    severity = dep["severity"] || "info"
+    summary = dep["summary"] || dep["id"]
+    removal = dep["removal"]
+    link = dep["link"]
+    steps = dep["migration_steps"] || []
+
+    if severity == "info"
+      line = "i Deprecation: #{summary}. Removed in: #{removal}."
+      line += " See: #{link}" if link
+      parts << line
+    else
+      marker = severity == "critical" ? "!! DEPRECATION (critical)" : "! DEPRECATION (warning)"
+      parts << "#{marker}: #{summary}"
+      if steps.any?
+        parts << "  Migration steps:"
+        steps.each_with_index { |s, i| parts << "  #{i + 1}. #{s}" }
+      end
+      trail = "  Removed in: #{removal}"
+      trail += " | Details: #{link}" if link
+      parts << trail
+    end
+  end
+end
+
+payload = {
+  "hookSpecificOutput" => {
+    "hookEventName" => "SessionStart",
+    "additionalContext" => parts.join("\n")
+  }
+}
+puts JSON.generate(payload)