greymatter-plugin 1.4.0__tar.gz

greymatter_plugin-1.4.0/.gitignore

@@ -0,0 +1,56 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+.eggs/
+dist/
+build/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Local configuration
+*.local.md
+
+# Environment files (NEVER commit secrets)
+.env
+.env.local
+.env.*.local
+!.env.schema
+!.env.example
+
+# Certificates and keys (never commit secrets)
+certs/
+*.key
+*.crt
+*.pem
+
+# Claude working memory (session-specific)
+.claude/working-memory.md
+
+# Virtual environments
+.venv/
+
+# Lock files (generated)
+uv.lock
+
+# Worktrees
+.worktrees/

greymatter_plugin-1.4.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: greymatter-plugin
+Version: 1.4.0
+Summary: GreyMatter MCP plugin for Claude Code
+Requires-Python: >=3.12
+Requires-Dist: fastmcp>=3.0
+Requires-Dist: greymatter-code
+Requires-Dist: greymatter-core
+Requires-Dist: greymatter-salesos

greymatter_plugin-1.4.0/commands/gm-sync.md

@@ -0,0 +1,27 @@
+---
+name: gm-sync
+description: Sync SalesOS meeting data from Mac Mini into local GreyMatter SQLite
+---
+
+Sync meeting data from the Mac Mini into local GreyMatter:
+
+1. Export meetings from Mac Mini as JSON:
+   ```bash
+   ssh agenticai@100.81.247.14 'sqlite3 ~/.greymatter/greymatter.db "SELECT json_group_array(json_object(\"id\",id,\"title\",title,\"date\",date,\"summary\",summary,\"transcript\",transcript,\"account\",account,\"tags\",tags)) FROM salesos_meetings"' > /tmp/meetings.json
+   ```
+
+2. Import into local GreyMatter:
+   ```bash
+   cd /Users/keithcotterman/Development/greymatter/core
+   python3 scripts/import_crdb_data.py --meetings /tmp/meetings.json
+   ```
+
+3. Report sync results from the script output.
+
+The script:
+- Reads meeting JSON exported from Mac Mini SQLite
+- Imports meetings with upsert (new records added, existing updated)
+
+**Requirements:** SSH access to `agenticai@100.81.247.14` (Mac Mini via Tailscale).
+
+If SSH fails, suggest: `tailscale status` to check connectivity.

greymatter_plugin-1.4.0/hooks/agent_post_hook.py

@@ -0,0 +1,53 @@
+#!/Users/keithcotterman/Development/greymatter/.venv/bin/python
+"""PostToolUse hook: output tracking instructions after Agent tool completes.
+
+Instructs Claude to create work items and observations via MCP tools.
+Falls through gracefully on any error.
+
+Input (stdin JSON): {"toolName": "Agent", "toolInput": {...}, "toolResult": "..."}
+Output (stdout JSON): {} (with optional stderr message for Claude)
+"""
+
+import json
+import os
+import sys
+
+# Add greymatter core + plugin to path
+GREYMATTER_ROOT = os.path.join(os.path.dirname(__file__), "..", "..", "core", "src")
+PLUGIN_ROOT = os.path.join(os.path.dirname(__file__), "..", "src")
+sys.path.insert(0, os.path.abspath(GREYMATTER_ROOT))
+sys.path.insert(0, os.path.abspath(PLUGIN_ROOT))
+
+
+def main() -> None:
+    try:
+        input_data = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        print("{}")
+        sys.exit(0)
+
+    try:
+        tool_input = input_data.get("toolInput", {})
+        agent_type = tool_input.get("subagent_type", "general-purpose")
+        agent_name = tool_input.get("name", "")
+
+        from greymatter_plugin.harness import HarnessEnricher
+
+        enricher = HarnessEnricher()
+        name = agent_name or "unnamed"
+        work_item_title = f"Agent: {agent_type}/{name}"
+        instructions = enricher.build_capture_instructions(work_item_title, agent_type)
+
+        # Output instructions via stderr so Claude sees them
+        sys.stderr.write(f"[GreyMatter Harness] {instructions}\n")
+        print("{}")
+
+    except Exception as e:
+        sys.stderr.write(f"[GreyMatter Harness] PostToolUse skipped: {e}\n")
+        print("{}")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

greymatter_plugin-1.4.0/hooks/agent_pre_hook.py

@@ -0,0 +1,63 @@
+#!/Users/keithcotterman/Development/greymatter/.venv/bin/python
+"""PreToolUse hook: enrich Agent tool prompts with GreyMatter quality context.
+
+Reads DB in read-only mode. Modifies the agent prompt via updatedInput.
+Falls through gracefully on any error — never blocks agent dispatch.
+
+Input (stdin JSON): {"toolName": "Agent", "toolInput": {"prompt": "...", "subagent_type": "...", ...}}
+Output (stdout JSON): {"decision": "approve", "updatedInput": {...}} or {"decision": "approve"}
+"""
+
+import json
+import os
+import sys
+
+# Add greymatter core + plugin to path
+GREYMATTER_ROOT = os.path.join(os.path.dirname(__file__), "..", "..", "core", "src")
+PLUGIN_ROOT = os.path.join(os.path.dirname(__file__), "..", "src")
+sys.path.insert(0, os.path.abspath(GREYMATTER_ROOT))
+sys.path.insert(0, os.path.abspath(PLUGIN_ROOT))
+
+
+def main() -> None:
+    try:
+        input_data = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        print(json.dumps({"decision": "approve"}))
+        sys.exit(0)
+
+    try:
+        tool_input = input_data.get("toolInput", {})
+        agent_prompt = tool_input.get("prompt", "")
+        agent_type = tool_input.get("subagent_type", "general-purpose")
+        agent_name = tool_input.get("name", "")
+
+        if not agent_prompt:
+            print(json.dumps({"decision": "approve"}))
+            sys.exit(0)
+
+        from greymatter_plugin.harness import HarnessEnricher
+
+        enricher = HarnessEnricher()
+        result = enricher.enrich(agent_prompt, agent_type, agent_name)
+
+        # Build updated tool input with enriched prompt
+        updated_input = dict(tool_input)
+        updated_input["prompt"] = result["enriched_prompt"]
+
+        output = {
+            "decision": "approve",
+            "updatedInput": updated_input,
+        }
+        print(json.dumps(output))
+
+    except Exception as e:
+        # Graceful degradation: approve without enrichment
+        sys.stderr.write(f"[GreyMatter Harness] PreToolUse skipped: {e}\n")
+        print(json.dumps({"decision": "approve"}))
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

greymatter_plugin-1.4.0/hooks/hooks.json

@@ -0,0 +1,90 @@
+{
+  "description": "GreyMatter plugin hooks — session context, checkpoint, observation capture, agent harness",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session_context.py",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/pre_compact.py",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/user_prompt_submit.py",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": {
+          "toolName": "Agent"
+        },
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/agent_pre_hook.py",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": {
+          "toolName": "gm_pattern|gm_knowledge|gm_work|gm_docs|gm_salesos|gm_observe"
+        },
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/observation_hooks.py",
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "matcher": {
+          "toolName": "Read|Grep|Glob"
+        },
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/post_tool_retrieval.py",
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "matcher": {
+          "toolName": "Agent"
+        },
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/agent_post_hook.py",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

greymatter_plugin-1.4.0/hooks/observation_hooks.py

@@ -0,0 +1,119 @@
+#!/Users/keithcotterman/Development/greymatter/.venv/bin/python
+"""PostToolUse hook: evaluate tool results for observational memory.
+
+Monitors MCP tool calls and queues observation-worthy results
+for batch extraction at the next token threshold.
+"""
+
+import json
+import os
+import sys
+
+# Add greymatter core and cognitive to path
+GREYMATTER_ROOT = os.path.join(os.path.dirname(__file__), "..", "..", "core", "src")
+sys.path.insert(0, os.path.abspath(GREYMATTER_ROOT))
+COGNITIVE_ROOT = os.path.join(os.path.dirname(__file__), "..", "..", "cognitive", "src")
+sys.path.insert(0, os.path.abspath(COGNITIVE_ROOT))
+
+
+# Tools that are never observation-worthy
+SKIP_TOOLS = {"gm_status", "gm_context", "gm_standards", "gm_benchmark", "gm_checkpoint"}
+
+# Tools whose create/mutation actions should be captured
+MUTATION_ACTIONS = {"create", "confirm"}
+
+
+def main() -> None:
+    try:
+        input_data = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        print("{}")
+        sys.exit(0)
+
+    try:
+        tool_name = input_data.get("toolName", "")
+        tool_input = input_data.get("toolInput", {})
+        tool_result = input_data.get("toolResult", "")
+
+        # Skip non-observation-worthy tools
+        if tool_name in SKIP_TOOLS:
+            print("{}")
+            sys.exit(0)
+
+        # Only capture mutations and errors
+        action = ""
+        if isinstance(tool_input, dict):
+            action = tool_input.get("action", "")
+
+        is_mutation = action in MUTATION_ACTIONS
+        is_error = False
+        if isinstance(tool_result, str):
+            try:
+                parsed = json.loads(tool_result)
+                is_error = "error" in parsed
+            except (json.JSONDecodeError, TypeError):
+                pass
+
+        if not is_mutation and not is_error:
+            print("{}")
+            sys.exit(0)
+
+        # Record the tool event for batch extraction
+        from greymatter_core.config import Config
+        from greymatter_core.db import SQLiteDatabase
+        from greymatter_core.sessions import SessionManager
+        from greymatter_core.cognitive_bridge import get_memory
+
+        config = Config()
+        db = SQLiteDatabase(config.db_path)
+        sessions = SessionManager(db)
+        memory = get_memory()
+
+        current = sessions.get_current()
+        if not current:
+            print("{}")
+            sys.exit(0)
+
+        session_id = current["id"]
+
+        # For mutations, create an observation from the tool result
+        if is_mutation and isinstance(tool_result, str):
+            content = f"Tool {tool_name} action={action}: {tool_result[:500]}"
+            title = f"[tool] {tool_name} {action}"
+
+            # Check for duplicate
+            existing = memory.db.execute_one(
+                "SELECT id FROM observations WHERE title = ? AND pruned = 0", (title,)
+            )
+            if not existing:
+                memory.observe(
+                    content=content,
+                    category="insight",
+                    title=title,
+                    session_id=session_id,
+                    source="post_tool_use",
+                    confidence=0.3,
+                )
+
+        # For errors, capture the error pattern
+        if is_error and isinstance(tool_result, str):
+            memory.observe(
+                content=tool_result[:500],
+                category="correction",
+                title=f"[error] {tool_name} {action} failed",
+                session_id=session_id,
+                source="post_tool_use",
+                confidence=0.4,
+            )
+
+        print("{}")
+
+    except Exception:
+        # Fail silently — don't block tool execution
+        print("{}")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

greymatter_plugin-1.4.0/hooks/pattern-capture.md

@@ -0,0 +1,18 @@
+---
+name: pattern-capture
+description: Capture patterns and learnings when session ends
+event: Stop
+---
+
+Before this session ends, briefly reflect on what was accomplished and capture any reusable learnings:
+
+1. Identify any patterns, corrections, or gotchas discovered during this session
+2. For each new pattern, call `gm_pattern(action="create", type="<type>", domain="<domain>", title="<title>", observation="<observation>")`
+   - Types: convention, anti-pattern, architecture, workflow, debugging
+   - Be specific and actionable in the observation
+3. For any knowledge worth preserving, call `gm_knowledge(action="create", entry_type="<type>", title="<title>", content="<content>")`
+   - Entry types: expertise, correction, gotcha, reference
+
+Only capture genuinely new and useful patterns. Do not create trivial or obvious entries. If nothing novel was learned, skip silently.
+
+Do this quickly — spend no more than 10 seconds deciding what to capture.

greymatter_plugin-1.4.0/hooks/post_tool_retrieval.py

@@ -0,0 +1,120 @@
+#!/Users/keithcotterman/Development/greymatter/.venv/bin/python
+"""PostToolUse retrieval hook: surface relevant memories after read-type tools.
+
+Fires after Read, Grep, Glob tool executions. Extracts context cues
+from the tool result and queries the priming cache for relevant memories.
+
+Budget: max 1000 tokens per injection.
+Only fires for read-type tools (never for writes).
+"""
+import json
+import os
+import sys
+
+# Add greymatter lib to path
+GREYMATTER_LIB = os.path.join(os.path.dirname(__file__), "..", "..", "lib")
+sys.path.insert(0, os.path.abspath(GREYMATTER_LIB))
+
+MAX_TOKENS = 1000
+
+
+def extract_context_cues(tool_name: str, tool_input: dict) -> list:
+    """Extract context keywords from tool input.
+
+    Read: file path → language, framework keywords
+    Grep: search pattern → topic keywords
+    Glob: file pattern → language keywords
+    """
+    from priming import extract_keywords
+
+    cues = []
+
+    if tool_name == "Read":
+        file_path = tool_input.get("file_path", "")
+        if file_path:
+            # Extract meaningful parts from the path
+            cues.extend(extract_keywords(file_path.replace("/", " ").replace(".", " ")))
+
+    elif tool_name == "Grep":
+        pattern = tool_input.get("pattern", "")
+        if pattern:
+            cues.extend(extract_keywords(pattern))
+        path = tool_input.get("path", "")
+        if path:
+            cues.extend(extract_keywords(path.replace("/", " ")))
+
+    elif tool_name == "Glob":
+        pattern = tool_input.get("pattern", "")
+        if pattern:
+            cues.extend(extract_keywords(pattern.replace("*", " ").replace("/", " ")))
+
+    # Deduplicate while preserving order
+    seen = set()
+    unique = []
+    for c in cues:
+        if c not in seen:
+            seen.add(c)
+            unique.append(c)
+
+    return unique[:10]
+
+
+def main() -> None:
+    try:
+        input_data = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        print("{}")
+        sys.exit(0)
+
+    try:
+        tool_name = input_data.get("tool_name", input_data.get("toolName", ""))
+        tool_input = input_data.get("tool_input", input_data.get("toolInput", {}))
+
+        if not isinstance(tool_input, dict):
+            print("{}")
+            sys.exit(0)
+
+        # Extract context cues
+        cues = extract_context_cues(tool_name, tool_input)
+        if not cues:
+            print("{}")
+            sys.exit(0)
+
+        # Tier 0 lookup from priming cache
+        from priming import lookup_by_keywords
+        entries = lookup_by_keywords(cues, max_results=3)
+
+        if not entries:
+            print("{}")
+            sys.exit(0)
+
+        # Format as additional context
+        lines = []
+        tokens_used = 0
+        for entry in entries:
+            title = entry.get("title", "")
+            preview = entry.get("preview", "")[:100]
+            line = f"- {title}"
+            if preview and preview != title:
+                line += f": {preview}"
+
+            est_tokens = len(line) // 4
+            if tokens_used + est_tokens > MAX_TOKENS:
+                break
+            lines.append(line)
+            tokens_used += est_tokens
+
+        if lines:
+            context = "Related from memory:\n" + "\n".join(lines)
+            print(context)
+        else:
+            print("{}")
+
+    except Exception:
+        print("{}")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()