@zalom/plastic 1.0.0-alpha.35 → 1.0.0-alpha.36

package/hooks/hooks.json

@@ -93,6 +93,16 @@
             "statusMessage": "Checking auto mode..."
           }
         ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" qmd-search",
+            "statusMessage": "Searching QMD..."
+          }
+        ]
       }
     ]
   }

package/hooks/qmd-search

@@ -0,0 +1,8 @@
+#!/bin/bash
+# qmd-first search hook launcher (intent 66). No-op when there is no global store.
+GLOBAL_INDEX="$HOME/.plastic/INDEX.md"
+if [ ! -f "$GLOBAL_INDEX" ]; then
+  exit 0
+fi
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+exec ruby "$SCRIPT_DIR/../scripts/hook-qmd-search" "$HOME/.plastic"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "1.0.0-alpha.35",
+  "version": "1.0.0-alpha.36",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {

package/scripts/doctor.rb

@@ -42,6 +42,7 @@ class Doctor
     plastic-gate-check
     plastic-continue
     plastic-future-intent-check
+    plastic-qmd-search
   ].freeze
 
   CLAUDE_HOOK_EVENTS = %w[SessionStart PreCompact PostToolUse UserPromptSubmit].freeze

package/scripts/hook-qmd-search

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# qmd-first UserPromptSubmit hook (intent 66). Reads the prompt from stdin JSON,
+# delegates the decision to QmdHook.run under a hard timeout, and prints
+# hookSpecificOutput when there is something to inject/remind. Silent no-op (exit
+# 0) when qmd is absent, the prompt is trivial, or anything goes wrong. ARGV[0]
+# is the plastic_home (passed by the launcher); defaults to ~/.plastic.
+require "json"
+require "timeout"
+require_relative "lib/qmd_hook"
+
+raw = begin
+  STDIN.read
+rescue StandardError
+  ""
+end
+
+prompt = begin
+  parsed = JSON.parse(raw)
+  parsed.is_a?(Hash) ? parsed["user_prompt"].to_s : ""
+rescue StandardError
+  ""
+end
+
+plastic_home = (ARGV[0] && !ARGV[0].empty?) ? ARGV[0] : File.expand_path("~/.plastic")
+
+context = begin
+  Timeout.timeout(2) do
+    QmdHook.run(prompt: prompt, cwd: Dir.pwd, plastic_home: plastic_home)
+  end
+rescue Exception
+  nil
+end
+
+exit 0 if context.nil? || context.strip.empty?
+
+puts JSON.generate(
+  "hookSpecificOutput" => {
+    "hookEventName" => "UserPromptSubmit",
+    "additionalContext" => context,
+  }
+)

package/scripts/lib/installer_core.rb

@@ -199,6 +199,8 @@ class InstallerCore
       "scripts/hook-continue" => "scripts/hook-continue",
       "scripts/hook-future-intent-check" => "scripts/hook-future-intent-check",
       "scripts/hook-gate-check" => "scripts/hook-gate-check",
+      "scripts/hook-qmd-search" => "scripts/hook-qmd-search",
+      "scripts/lib/qmd_hook.rb" => "scripts/lib/qmd_hook.rb",
       "scripts/hook-code-gate" => "scripts/hook-code-gate",
       "scripts/hook-bash-gate" => "scripts/hook-bash-gate",
       "scripts/hook-auto-arm" => "scripts/hook-auto-arm",
@@ -543,6 +545,7 @@ class InstallerCore
           { "type" => "command", "command" => "#{hook_dir}/plastic-continue", "statusMessage" => "Checking for continue..." },
           { "type" => "command", "command" => "#{hook_dir}/plastic-future-intent-check", "statusMessage" => "Checking future intents..." },
           { "type" => "command", "command" => "#{hook_dir}/plastic-auto-arm", "statusMessage" => "Checking auto mode..." },
+          { "type" => "command", "command" => "#{hook_dir}/plastic-qmd-search", "statusMessage" => "Searching QMD..." },
         ],
       },
     }

package/scripts/lib/qmd_hook.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative "qmd_sync"
+
+# QmdHook — decision logic for the qmd-first UserPromptSubmit hook (intent 66).
+# Pure and dependency-injected: returns the additionalContext string to emit, or
+# nil to emit nothing. The executable hook wires real deps and prints; this is
+# unit-tested with a fake runner/detector (no real qmd, no network).
+module QmdHook
+  module_function
+
+  MIN_PROMPT_LENGTH = 10
+  REMINDER = "qmd is available: query it (`qmd search` / `qmd query` over the " \
+             "`plastic-*` collections) before grep/Read when gathering intent " \
+             "context (sources/chain) or checking whether this work already " \
+             "exists as an intent."
+
+  def run(prompt:, cwd:, plastic_home:, runner: QmdSync.default_runner,
+          detector: QmdSync.method(:detect), limit: 3, min_score: 0.5)
+    return nil unless detector.call
+    p = prompt.to_s.strip
+    return nil if p.length < MIN_PROMPT_LENGTH
+    return nil if p.downcase == "continue"
+
+    collections = QmdSync.collections_for_cwd(cwd, plastic_home: plastic_home)
+    hits = QmdSync.search(p, collections: collections, limit: limit,
+                          min_score: min_score, runner: runner, detector: detector)
+
+    parts = []
+    if hits.any?
+      parts << "Related / prior Plastic intents (qmd BM25, includes completed) — " \
+               "check before treating this as new work:"
+      hits.each do |h|
+        loc = h[:file].to_s.sub(%r{\Aqmd://}, "")
+        pct = (h[:score] * 100).round
+        parts << "- [#{pct}%] #{loc} — #{h[:title]}"
+      end
+      parts << ""
+    end
+    parts << REMINDER
+    parts.join("\n")
+  end
+end

package/scripts/lib/qmd_sync.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "yaml"
+require "json"
 
 # QmdSync — the single place Plastic talks to QMD (intent 45a).
 #
@@ -111,6 +112,55 @@ module QmdSync
       missing: missing, all_registered: missing.empty? }
   end
 
+  # Read-only BM25 search over one or more collections. Returns hits sorted by
+  # score (desc), filtered by min_score, capped at limit:
+  #   [{ score: Float, file: String, line: Integer|nil, title: String, snippet: String }, ...]
+  # No-ops to [] when qmd is absent or the query is blank. Uses `qmd search --json`
+  # (BM25, no embeddings / no model downloads). Pure via the injected runner.
+  def search(query, collections:, limit: 3, min_score: 0.5, runner: default_runner, detector: method(:detect))
+    return [] unless detector.call
+    q = query.to_s.strip
+    return [] if q.empty? || Array(collections).empty?
+
+    args = ["search", q]
+    Array(collections).each { |c| args.concat(["-c", c]) }
+    args << "--json"
+
+    out, ok = runner.call(args)
+    return [] unless ok && out && !out.strip.empty?
+
+    parsed = begin
+      JSON.parse(out)
+    rescue StandardError
+      return []
+    end
+    return [] unless parsed.is_a?(Array)
+
+    parsed.filter_map do |h|
+      next unless h.is_a?(Hash)
+      score = h["score"].to_f
+      next if score < min_score
+      { score: score, file: h["file"].to_s, line: h["line"],
+        title: h["title"].to_s, snippet: h["snippet"].to_s }
+    end.sort_by { |h| -h[:score] }.first(limit)
+  end
+
+  # Which collections to search for a given working directory: the matched
+  # project's collection plus plastic-global, or just plastic-global when the
+  # CWD is not inside any registered project. Project match = CWD equals the
+  # registered path or is nested under it.
+  def collections_for_cwd(cwd, plastic_home:)
+    cwd = File.expand_path(cwd)
+    projects = load_projects(plastic_home)
+    slug, = projects.find do |_s, info|
+      path = info.is_a?(Hash) ? info["path"] : nil
+      next false unless path
+      root = File.expand_path(path)
+      cwd == root || cwd.start_with?(root + File::SEPARATOR)
+    end
+    slug ? ["plastic-#{slug}", "plastic-global"] : ["plastic-global"]
+  end
+
   # --- internals ---
 
   def skip_result