@zalom/plastic 2.0.0-alpha.9 → 2.0.1

package/scripts/lib/store_sync.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tempfile"
+require_relative "search_index"
+require_relative "reference_archive"
+require_relative "work_graph"
+
+module Plastic
+  module StoreSync
+    INTENT_PATH = %r{\A(?:(?:projects|stores)/([^/]+)/)?store/([^/]+?)--}
+    ROW_HASH = "lower(hex(sha3(sqlar_uncompress(data, sz), 256)))"
+
+    def self.action(state)
+      file, row, recorded = state.values_at("file", "row", "hash")
+      return "write" if file.nil?
+      return if file == row
+      return "read" if row == recorded
+      return "write" if file == recorded
+
+      "conflict"
+    end
+
+    def self.plan(home)
+      known = states(home)
+      fresh = SearchIndex.files(home) - known.map { |state| state["path"] }
+      plan = known.map { |state| [action(state), state["path"]] } + fresh.map { |file| ["read", file] }
+      plan.select(&:first).sort_by(&:last)
+    end
+
+    def self.states(home)
+      Sqlite.call(SearchIndex.path(home), <<~SQL, readonly: true)
+        SELECT path, lower(hex(sha3(readfile(#{Sqlite.quote(home)} || '/' || path), 256))) AS file, #{ROW_HASH} AS row, hash
+        FROM doc;
+      SQL
+    end
+
+    def self.apply(home, plan)
+      statements = plan.map { |action, path| send(action, home, path) }
+      statements << "INSERT INTO ft(ft) VALUES('rebuild');" if plan.any? { |action, _path| action == "read" }
+      Sqlite.call(SearchIndex.path(home), ["BEGIN;", *statements, "COMMIT;"].join("\n"))
+    end
+
+    def self.read(home, path)
+      "DELETE FROM doc WHERE path = #{Sqlite.quote(path)};\n#{SearchIndex.insert(home, path)}"
+    end
+
+    def self.write(home, path)
+      where = "WHERE path = #{Sqlite.quote(path)}"
+      "#{restore(home, "doc", "path")} #{where};\nUPDATE doc SET hash = #{ROW_HASH} #{where};"
+    end
+
+    def self.restore(home, table, column)
+      "SELECT writefile(#{Sqlite.quote(home)} || '/' || #{column}, sqlar_uncompress(data, sz)) FROM #{table}"
+    end
+
+    def self.diff(home, path)
+      body = Sqlite.call(SearchIndex.path(home), <<~SQL, readonly: true).first["body"]
+        SELECT CAST(sqlar_uncompress(data, sz) AS TEXT) AS body FROM doc WHERE path = #{Sqlite.quote(path)};
+      SQL
+      Tempfile.create("plastic-row") do |row|
+        row.write(body)
+        row.flush
+        Open3.capture2("diff", "-u", "-L", "row", "-L", "file", row.path, File.join(home, path)).first
+      end
+    end
+
+    def self.orphans(home)
+      paths = Sqlite.call(SearchIndex.path(home), "SELECT path FROM doc;", readonly: true) +
+        Sqlite.call(ReferenceArchive.path(home), "SELECT name AS path FROM sqlar;", readonly: true)
+      keys = paths.filter_map { |row| row["path"].match(INTENT_PATH) }.map { |found| "#{found[1] || "global"}:#{found[2]}" }
+      (keys.uniq - WorkGraph.known(home)).sort
+    end
+
+    def self.checkout(home)
+      {SearchIndex.path(home) => %w[doc path], ReferenceArchive.path(home) => %w[sqlar name]}.flat_map do |database, (table, column)|
+        missing = Sqlite.call(database, "SELECT #{column} AS path FROM #{table};", readonly: true)
+          .map { |row| row["path"] }.reject { |path| File.exist?(File.join(home, path)) }
+        names = missing.map { |path| Sqlite.quote(path) }.join(", ")
+        Sqlite.call(database, "#{restore(home, table, column)} WHERE #{column} IN (#{names});", readonly: true)
+        missing
+      end
+    end
+  end
+end

package/scripts/lib/stores_move.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "store_layout"
+require_relative "sqlite"
+require_relative "lock"
+
+module Plastic
+  class StoresMove
+    Refused = Class.new(StandardError)
+
+    GLOBAL_ENTRIES = %w[store INDEX.md roadmaps].freeze
+    PATH_COLUMNS = {"knowledge_graph.db" => %w[doc path], "references.db" => %w[sqlar name]}.freeze
+    LOCKS = "{store,projects/*/store}/*/delivery.lock"
+
+    def initialize(home, qmd_index:, dry_run: false)
+      @home = home
+      @qmd_index = qmd_index
+      @dry_run = dry_run
+    end
+
+    def call
+      refuse
+      plan = [["copy", copy]] + moves.map { |from, to| ["move", "#{from} -> #{to}"] } + rewrites.map { |file| ["rewrite", file] }
+      run unless @dry_run
+      plan
+    end
+
+    def copy
+      "#{@home}-before-stores-move"
+    end
+
+    private
+
+    def refuse
+      raise Refused, "#{File.join(@home, "stores")}/ exists, so this home has moved already" if StoreLayout.moved?(@home)
+      raise Refused, "a delivery lock is held: #{held.join(", ")}" unless held.empty?
+      raise Refused, "#{copy} exists; remove it or move it away first" if File.exist?(copy)
+    end
+
+    def held
+      Dir.glob(LOCKS, base: @home).select { |lock| Time.now - File.mtime(File.join(@home, lock)) < Lock::TTL_SECONDS }
+    end
+
+    def moves
+      @moves ||= GLOBAL_ENTRIES.select { |name| File.exist?(File.join(@home, name)) }.map { |name| [name, "stores/global/#{name}"] } +
+        project_entries.map { |entry| ["projects/#{entry}", "stores/#{entry}"] }
+    end
+
+    def project_entries
+      Dir.exist?(projects) ? Dir.children(projects).sort : []
+    end
+
+    def projects
+      File.join(@home, "projects")
+    end
+
+    def rewrites
+      [File.join(@home, "config.yml"), @qmd_index, *PATH_COLUMNS.keys.map { |name| File.join(@home, name) }].select { |file| File.file?(file) }
+    end
+
+    def run
+      files = rewrites
+      FileUtils.cp_r(@home, copy, preserve: true)
+      moves.each { |from, to| move(from, to) }
+      FileUtils.rmdir(projects) if Dir.exist?(projects)
+      files.each { |file| PATH_COLUMNS.key?(File.basename(file)) ? rewrite_rows(file) : rewrite_text(file) }
+    end
+
+    def move(from, to)
+      FileUtils.mkdir_p(File.dirname(File.join(@home, to)))
+      FileUtils.mv(File.join(@home, from), File.join(@home, to))
+    end
+
+    def rewrite_text(file)
+      FileUtils.cp(file, "#{file}.before-stores-move", preserve: true)
+      File.write(file, [@home, "~/.plastic"].inject(File.read(file)) { |text, base| relocate(text, base) })
+    end
+
+    def relocate(text, base)
+      text.gsub(%r{#{Regexp.escape(base)}/(store|roadmaps|INDEX\.md)\b}) { "#{base}/stores/global/#{Regexp.last_match(1)}" }
+        .gsub(%r{#{Regexp.escape(base)}/projects\b}) { "#{base}/stores" }
+    end
+
+    def rewrite_rows(file)
+      table, column = PATH_COLUMNS.fetch(File.basename(file))
+      Sqlite.call(file, <<~SQL)
+        UPDATE #{table} SET #{column} = 'stores/' || substr(#{column}, 10) WHERE #{column} LIKE 'projects/%';
+        UPDATE #{table} SET #{column} = 'stores/global/' || #{column} WHERE #{column} LIKE 'store/%';
+      SQL
+    end
+  end
+end

package/scripts/lib/verify_intent.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require_relative "worktree"
 require_relative "scaffold_intent"
 
@@ -9,7 +10,7 @@ require_relative "scaffold_intent"
 # (`Doctor#run_intent_check`), a net-new added-line em-dash diff guard (the first standing
 # implementation of this check; the only prior automated em-dash check,
 # `test/skill_command_lint_test.rb`, asserts against two FIXED file sets and cannot scan a
-# diff), a diffstat, and an optional caller-supplied `--suite` command folded into the same
+# diff), a diffstat, and an optional caller-supplied `--suite` command merged into the same
 # verdict.
 #
 # Repo resolution and base-branch detection are NOT re-implemented here: `resolve_repo_dir`,
@@ -70,6 +71,10 @@ module VerifyIntent
     lines.concat(diffstat_lines)
     checks[:diffstat] = diffstat_check
 
+    report_lines_out, report_check = run_report_lines_check(intent_dir: intent_dir)
+    lines.concat(report_lines_out)
+    checks[:report] = report_check
+
     if Worktree.blank?(suite)
       checks[:suite] = { status: "skipped" }
     else
@@ -92,13 +97,7 @@ module VerifyIntent
   # shapes are told apart by whether store's grandparent is literally named "projects" (the
   # StoreDiscovery convention), never by hardcoding ".plastic" as a name.
   def resolve_plastic_home_and_scope(store)
-    parent = File.dirname(store)
-    grandparent = File.dirname(parent)
-    if File.basename(grandparent) == "projects"
-      [File.dirname(grandparent), "project:#{File.basename(parent)}"]
-    else
-      [parent, "global"]
-    end
+    Plastic::StoreLayout.home_and_scope(store)
   end
 
   # --- check 1: doctor, scoped to the intent --------------------------------------
@@ -235,6 +234,35 @@ module VerifyIntent
     end
   end
 
+  # --- check: the Report savepoint lines (intent 331f, F17) ------------------------
+
+  REPORT_LINE_RE = /\A(\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ)\s{2,}(\S+)\s{2,}(.+?)\s*\z/.freeze
+
+  # Every `Report`-kind savepoint line for this intent, oldest first: [timestamp, text].
+  # Never fails or gates anything (D3: the diffstat check already prints a summary block,
+  # this merges into the same verdict so verify-intent surfaces them too) - a delivery with
+  # no Report line is visible to `doctor`'s intent_reports_printed_check instead.
+  def report_lines(intent_dir)
+    path = File.join(intent_dir, "savepoint.md")
+    return [] unless File.exist?(path)
+
+    File.readlines(path).filter_map do |line|
+      m = line.strip.match(REPORT_LINE_RE)
+      next nil unless m && m[2] == "Report"
+      [m[1], m[3]]
+    end
+  end
+
+  def run_report_lines_check(intent_dir:)
+    entries = report_lines(intent_dir)
+    if entries.empty?
+      [["report lines: none recorded"], { status: "pass", lines: [] }]
+    else
+      lines = ["report lines:"] + entries.map { |ts, text| "#{ts}  Report  #{text}" }
+      [lines, { status: "pass", lines: entries }]
+    end
+  end
+
   # --- check 4: the optional suite --------------------------------------------------
 
   # The supplied command is very likely a ruby command, so it is spawned with RUBYOPT

package/scripts/lib/version_number.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# VersionNumber - dotted version comparison without RubyGems (intent 363).
+#
+# The launcher starts as `ruby --disable-gems`, which saves about 26 of the 40
+# milliseconds a plain Ruby process costs, so no file a command loads may reach
+# for Gem::Version. Parses the leading run of dotted integers, ignoring a
+# leading "v" and anything after the digits, and compares two of them segment by
+# segment with the shorter one zero-padded. A string with no leading integer
+# parses to nil, so a caller answers "not found" instead of raising.
+#
+# It deliberately does not order pre-release suffixes: 2.0.0-alpha.27 and 2.0.0
+# compare equal here. A caller that needs RubyGems' pre-release order, such as
+# the release-tag reader in scripts/report-screen, keeps Gem::Version.
+class VersionNumber
+  include Comparable
+
+  LEADING_DIGITS = /\A(\d+(?:\.\d+)*)/
+
+  attr_reader :segments
+
+  def self.parse(value)
+    match = LEADING_DIGITS.match(value.to_s.strip.sub(/\Av/, ""))
+    match && new(match[1].split(".").map(&:to_i))
+  end
+
+  def initialize(segments)
+    @segments = segments
+  end
+
+  def <=>(other)
+    return nil unless other.is_a?(VersionNumber)
+
+    width = [segments.length, other.segments.length].max
+    padded(width) <=> other.padded(width)
+  end
+
+  def to_s
+    segments.join(".")
+  end
+
+  protected
+
+  def padded(width)
+    segments + Array.new(width - segments.length, 0)
+  end
+end

package/scripts/lib/work_graph.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "sqlite"
+require_relative "index_entry"
+require_relative "store_discovery"
+
+module Plastic
+  module WorkGraph
+    NAME = "work_graph.db"
+    SCHEMA = <<~SQL
+      CREATE TABLE intent(id TEXT, store TEXT, slug TEXT, status TEXT, title TEXT);
+      CREATE TABLE ledger(intent_id TEXT, store TEXT, at TEXT, stage TEXT, text TEXT);
+    SQL
+    STATUSES = %w[active future completed abandoned].freeze
+    LEDGER_LINE = /\A(\S+)\s{2,}(\S+)\s{2,}(.+)\z/
+
+    def self.path(home)
+      File.join(home, NAME)
+    end
+
+    def self.build(home)
+      draft = "#{path(home)}.tmp"
+      FileUtils.rm_f(draft)
+      rows = StoreDiscovery.discover(home)[:stores].flat_map { |store| intents(store) + ledger(store) }
+      Sqlite.call(draft, [SCHEMA, "BEGIN;", *rows, "COMMIT;"].join("\n"))
+      File.rename(draft, path(home))
+    end
+
+    def self.intents(store)
+      return [] unless File.exist?(store[:index])
+
+      status = nil
+      File.readlines(store[:index], chomp: true, encoding: "UTF-8").filter_map do |line|
+        status = line.delete_prefix("## ").downcase if line.start_with?("## ")
+        entry = STATUSES.include?(status) && IndexEntry.match(line)
+        entry && insert("intent", entry[1], store[:slug], File.basename(File.dirname(entry[3])).split("--", 2).last, status, entry[2])
+      end
+    end
+
+    def self.ledger(store)
+      Dir.glob("*/savepoint.md", base: store[:store]).sort.flat_map do |file|
+        id = file.split("--").first
+        File.readlines(File.join(store[:store], file), chomp: true, encoding: "UTF-8").filter_map do |line|
+          entry = line.match(LEDGER_LINE)
+          entry && insert("ledger", id, store[:slug], entry[1], entry[2], entry[3])
+        end
+      end
+    end
+
+    def self.insert(table, *values)
+      "INSERT INTO #{table} VALUES(#{values.map { |value| Sqlite.quote(value.to_s) }.join(", ")});"
+    end
+
+    def self.known(home)
+      Sqlite.call(path(home), "SELECT store, id FROM intent;", readonly: true).map { |row| "#{row["store"]}:#{row["id"]}" }
+    end
+  end
+end

package/scripts/lib/work_graph_validator.rb

@@ -0,0 +1,201 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative "graph_file"
+require_relative "graph_edges"
+require_relative "node_file"
+require_relative "action_graph_shim"
+
+# WorkGraphValidator (intent 334, n4): the in-batch reader over one intent's
+# graph.md and nodes/ - 327's rule for budget, files, and the decision and
+# research kinds (review A17). {ok:, missing:, errors:}, the same Result shape
+# ProjectValidator returns (review B7). Named apart from
+# IntentValidator#validate_graph, which already exists for the KNOWLEDGE
+# graph and stays unrelated to this one under D40 (review B9).
+#
+# Built over GraphFile, GraphEdges, and NodeFile only - never IntentValidator,
+# never ReportScreen. Every check accumulates into `errors` rather than
+# short-circuiting on the first one (see: "the owner fixes one thing per
+# run").
+module WorkGraphValidator
+  module_function
+
+  def validate(intent_dir)
+    missing = []
+    errors = []
+
+    graph_path = File.join(intent_dir, "graph.md")
+    parsed = GraphFile.parse(graph_path)
+    errors.concat(parsed[:errors])
+
+    graph = parsed[:graph]
+    if graph.nil?
+      # G9 (intent 342, D6/D7/D12): a legacy intent that never got a
+      # graph.md still reads as a valid work graph, structurally, through
+      # the backward shim - but only when graph.md is genuinely absent.
+      # A graph.md that exists but is malformed (no "## Graph" section)
+      # must never fall through to the synthetic chain and hide its own
+      # error (D12's whole point). The fresh error list here is
+      # deliberate: `errors` above already holds the not-found error from
+      # `parsed[:errors]`, and reusing it would return ok: false for every
+      # legacy intent in the store.
+      if !File.exist?(graph_path) && ActionGraphShim.shape(intent_dir) == :actions
+        return validate_actions_shape(intent_dir)
+      end
+
+      missing << "graph.md ## Graph section"
+      return { ok: false, missing: missing, errors: errors }
+    end
+
+    nodes = graph[:nodes]
+    edges = graph[:edges]
+    declared_ids = edges.keys
+
+    # Intent-scope dangling check: every node must be declared with its own
+    # needs-line here (unlike a roadmap, which may have undeclared roots -
+    # that reconciliation is G4's, not this validator's).
+    (nodes - declared_ids).each { |id| errors << "needs target #{id.inspect} names no declared node" }
+
+    cyc = GraphEdges.cycle(edges)
+    errors << "cyclic graph, cannot validate: #{cyc.join(' > ')}" if cyc
+
+    node_paths = Dir.glob(File.join(intent_dir, "nodes", "*.md")).sort
+    parsed_nodes = {}
+    paths_by_id = Hash.new { |h, k| h[k] = [] }
+
+    node_paths.each do |path|
+      nf = NodeFile.parse(path)
+      nf[:errors].each { |e| errors << "#{File.basename(path)}: #{e}" }
+      id = nf[:node]
+      next unless id
+
+      paths_by_id[id] << path
+      parsed_nodes[id] ||= nf
+    end
+
+    paths_by_id.each do |id, paths|
+      next unless paths.length > 1
+
+      errors << "node id #{id.inspect} claimed by more than one file: #{paths.map { |p| File.basename(p) }.join(', ')}"
+    end
+
+    declared_ids.each do |id|
+      missing << "nodes/ file for #{id}" unless parsed_nodes.key?(id)
+      errors << "declared node #{id.inspect} has no node file under nodes/" unless parsed_nodes.key?(id)
+    end
+    parsed_nodes.each_key do |id|
+      errors << "node file for #{id.inspect} exists but ## Graph declares no such node" unless declared_ids.include?(id)
+    end
+
+    work_nodes = []
+    verify_nodes = []
+
+    declared_ids.each do |id|
+      nf = parsed_nodes[id]
+      next unless nf
+
+      case nf[:kind]
+      when "verify"
+        verify_nodes << id
+        errors << "verify node #{id.inspect} has no ## Criteria" unless has_section?(nf[:body], "## Criteria")
+      when "decision"
+        errors << "decision node #{id.inspect} has no ## Question with a question" unless has_nonblank_section?(nf[:body], "## Question")
+      when "research"
+        errors << "research node #{id.inspect} has no ## Deposit" unless has_section?(nf[:body], "## Deposit")
+      when "work"
+        work_nodes << id
+        errors << "work node #{id.inspect} has no ## Steps" unless has_section?(nf[:body], "## Steps")
+        errors << "work node #{id.inspect} has no ## Proven by" unless has_section?(nf[:body], "## Proven by")
+      end
+    end
+
+    above_trivial_bar = work_nodes.length >= 2
+    if above_trivial_bar
+      verify_directive = parsed[:verify]
+      directive_ok = verify_directive && !verify_directive[:reason].to_s.empty?
+
+      unless directive_ok
+        attached = verify_nodes.select { |vid| node_touches_graph?(vid, edges) }
+        if attached.empty?
+          errors << "two or more work nodes require a verify node attached to the graph, or a verify: none reason=<text> directive"
+        end
+      end
+
+      work_nodes.each do |id|
+        nf = parsed_nodes[id]
+        next unless nf
+
+        errors << "work node #{id.inspect} has no failure-mode matrix under a heading carrying its id" unless has_valid_matrix?(id, nf[:body])
+      end
+    end
+
+    verify_nodes.each do |id|
+      next if node_touches_graph?(id, edges)
+
+      errors << "verify node #{id.inspect} exists but no edge reaches it (attach it or drop it)"
+    end
+
+    { ok: errors.empty?, missing: missing, errors: errors }
+  end
+
+  # A node "touches" the graph when some edge involves it on either side:
+  # it targets something, or something targets it. A verify node declared
+  # with "needs nothing" and targeted by nothing is fully isolated (review
+  # A13).
+  def node_touches_graph?(id, edges)
+    (edges[id] || []).any? || edges.values.any? { |targets| targets.include?(id) }
+  end
+
+  def has_section?(body, heading_text)
+    NodeFile.split_by_headings(body.to_s).any? { |heading, _| heading.strip == heading_text }
+  end
+
+  def has_nonblank_section?(body, heading_text)
+    NodeFile.split_by_headings(body.to_s).any? { |heading, section| heading.strip == heading_text && !section.strip.empty? }
+  end
+
+  def heading_tokens(heading)
+    heading.to_s.sub(/\A#+\s*/, "").split(/[^A-Za-z0-9]+/)
+  end
+
+  # The matrix table must sit under a heading whose tokens include the
+  # node's own id, and that heading must own at least one data row (review
+  # A1 - the same table-owning rule report_screen's resolver uses, so a
+  # node's own Proven-by cell is never "not recorded" the moment it ships).
+  def has_valid_matrix?(id, body)
+    NodeFile.split_by_headings(body.to_s).any? do |heading, section|
+      heading_tokens(heading).include?(id) && NodeFile.table_rows(section).any?
+    end
+  end
+
+  # The structural check the synthetic (actions/-only) shape gets, and
+  # nothing more (D6): at least one node, unique ids, every needs target
+  # names a declared node, acyclic. Never the kind-section rules, the
+  # failure-mode matrix bar, or the verify-attachment bar - a legacy action
+  # file labels its headings "S1", or nothing at all, and was never asked
+  # to meet a bar written for a graph authored under 327.
+  def validate_actions_shape(intent_dir)
+    errors = []
+    graph = ActionGraphShim.view(intent_dir)[:graph] || { nodes: [], edges: {}, errors: [] }
+    nodes = graph[:nodes]
+    edges = graph[:edges]
+
+    errors << "actions/ yields no nodes" if nodes.empty?
+    # D16: uniqueness is checked over the node array, not edges.keys - a
+    # Hash key set is unique by construction, so checking edges.keys can
+    # never fire.
+    errors << "duplicate node ids in synthetic chain" if nodes.uniq.length != nodes.length
+
+    # D16: every needs target is checked against the declared node list,
+    # not the node list against its own key set (nodes - edges.keys, which
+    # can never differ since the builder mints edges.keys from nodes).
+    (edges.values.flatten.uniq - nodes).each do |id|
+      errors << "needs target #{id.inspect} names no declared node"
+    end
+
+    cyc = GraphEdges.cycle(edges)
+    errors << "cyclic graph, cannot validate: #{cyc.join(' > ')}" if cyc
+
+    { ok: errors.empty?, missing: [], errors: errors }
+  end
+end