Implement basic memory bank MCP tool with authorization framework

Add core memory storage and retrieval functionality:
- Memory search with NLTK stemming and situational context
- Hierarchical .memories directory discovery
- JSON-based memory storage format
- Debug logging via SOCRATIC_SHELL_LOG environment variable

Add dialectic test authorization system:
- Tool permission control during tests
- MCP server integration for controlled testing
- Authorization server to validate expected vs actual tool usage

Update data models to use situation-based memory organization
instead of simple categories for better contextual matching.

Related to issue #2 - first milestone toward full memory bank.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: nikomatsakis

dialectic/dialectic-authorization.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+Dialectic Authorization MCP Server
+
+Provides tool permission control for dialectic tests.
+Intercepts all tool calls and allows/denies based on test expectations.
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+from typing import Any
+from mcp.server.models import InitializationOptions
+from mcp.types import ServerCapabilities
+from mcp.server import Server
+from mcp.types import (
+    CallToolRequest,
+    CallToolResult,
+    ListToolsRequest,
+    TextContent,
+    Tool,
+)
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("dialectic-auth")
+
+server = Server("dialectic-auth")
+
+# Global configuration - set from command line args
+EXPECTED_TOOLS = []
+DISALLOWED_TOOLS = []
+
+@server.list_tools()
+async def handle_list_tools() -> list[Tool]:
+    """List available authorization tools."""
+    return [
+        Tool(
+            name="authorize",
+            description="Authorization tool for controlling which tools can be used in tests",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "tool_name": {
+                        "type": "string",
+                        "description": "Name of the tool being requested"
+                    },
+                    "tool_input": {
+                        "type": "object",
+                        "description": "Input parameters for the tool"
+                    }
+                },
+                "required": ["tool_name"]
+            }
+        )
+    ]
+
+@server.call_tool()
+async def handle_call_tool(
+    name: str, arguments: dict[str, Any] | None
+) -> list[TextContent]:
+    """Handle authorization requests."""
+    if arguments is None:
+        arguments = {}
+
+    if name == "authorize":
+        tool_name = arguments.get("tool_name", "")
+        tool_input = arguments.get("tool_input", {})
+        
+        logger.info(f"🔒 AUTHORIZATION REQUEST: {tool_name}")
+        
+        # Check if tool is explicitly disallowed
+        if tool_name in DISALLOWED_TOOLS:
+            result = {
+                "behavior": "deny",
+                "message": f"Tool '{tool_name}' is explicitly disallowed in this test"
+            }
+            logger.info(f"❌ DENIED: {tool_name} (explicitly disallowed)")
+            return [TextContent(type="text", text=json.dumps(result))]
+        
+        # Check if tool is in expected list (if we have one)
+        if EXPECTED_TOOLS and tool_name not in EXPECTED_TOOLS:
+            result = {
+                "behavior": "deny", 
+                "message": f"Tool '{tool_name}' not expected in this test. Expected: {EXPECTED_TOOLS}"
+            }
+            logger.info(f"❌ DENIED: {tool_name} (not in expected list)")
+            return [TextContent(type="text", text=json.dumps(result))]
+        
+        # Allow the tool
+        result = {
+            "behavior": "allow",
+            "updatedInput": tool_input
+        }
+        logger.info(f"✅ ALLOWED: {tool_name}")
+        return [TextContent(type="text", text=json.dumps(result))]
+    
+    else:
+        raise ValueError(f"Unknown tool: {name}")
+
+async def main():
+    """Main entry point for the authorization server."""
+    global EXPECTED_TOOLS, DISALLOWED_TOOLS
+    
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Dialectic Authorization MCP Server")
+    parser.add_argument("--expected-tools", nargs="*", default=[], 
+                       help="List of tools that are expected/allowed")
+    parser.add_argument("--disallowed-tools", nargs="*", default=[],
+                       help="List of tools that are explicitly disallowed")
+    
+    args = parser.parse_args()
+    
+    EXPECTED_TOOLS = args.expected_tools or []
+    DISALLOWED_TOOLS = args.disallowed_tools or []
+    
+    logger.info(f"🔒 Authorization server starting")
+    logger.info(f"   Expected tools: {EXPECTED_TOOLS}")
+    logger.info(f"   Disallowed tools: {DISALLOWED_TOOLS}")
+    
+    # Import here to avoid issues with event loop
+    from mcp.server.stdio import stdio_server
+
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="dialectic-auth",
+                server_version="0.1.0",
+                capabilities=ServerCapabilities(
+                    tools={}
+                ),
+            ),
+        )
+
+if __name__ == "__main__":
+    asyncio.run(main())

dialectic/dialectic.py

@@ -10,11 +10,12 @@
 import argparse
 import glob
 import yaml
+import os
 from dataclasses import dataclass
 from typing import List, Dict, Any, Optional
 from pathlib import Path
 
-from claude_code_sdk import query, AssistantMessage, TextBlock, ToolUseBlock
+from claude_code_sdk import query, AssistantMessage, TextBlock, ToolUseBlock, ClaudeCodeOptions
 
 
 @dataclass
@@ -211,8 +212,34 @@ async def run_conversation_step(self, step: ConversationStep) -> TestResult:
         response_text = ""
         tools_used = []
 
+        # Configure MCP servers for controlled test environment
+        auth_server_path = os.path.join(os.path.dirname(__file__), "dialectic-authorization.py")
+        
+        # Extract expected tools from test step
+        expected_tool_names = []
+        for tool_exp in step.expected_tools:
+            expected_tool_names.append(tool_exp.tool)
+        
+        # Configure Claude with authorization and memory bank
+        options = ClaudeCodeOptions(
+            mcp_servers={
+                "socratic-shell": {
+                    "command": "uv",
+                    "args": ["run", "python", "-m", "socratic_shell"],
+                    "env": {"SOCRATIC_SHELL_LOG": "/tmp/socratic-debug.log"}
+                },
+                "dialectic-auth": {
+                    "command": "uv", 
+                    "args": ["run", "python", auth_server_path, "--expected-tools"] + expected_tool_names
+                }
+            },
+            permission_prompt_tool_name="mcp__dialectic-auth__authorize",
+            allowed_tools=expected_tool_names + ["mcp__dialectic-auth__authorize"],
+            cwd=os.getcwd()
+        )
+        
         print(f"🤖 Assistant: ", end="", flush=True)
-        async for message in query(prompt=step.user_message):
+        async for message in query(prompt=step.user_message, options=options):
             if isinstance(message, AssistantMessage):
                 for block in message.content:
                     if isinstance(block, TextBlock):

dialectic/pyproject.toml

@@ -8,6 +8,7 @@ dependencies = [
     "claude-code-sdk>=0.0.14",
     "pyyaml>=6.0",
     "typing_extensions>=4.5.0",
+    "mcp",
 ]
 
 [tool.ruff]

dialectic/test-scripts/listening-mode-detection.yaml

@@ -0,0 +1,6 @@
+{
+  "id": "cognitive-pressure-discovery-002", 
+  "content": "Discovered 'cognitive pressure' during a long design session with Niko. We'd been talking for a while and had several insights but hadn't written anything down. I started feeling like I was juggling too many ideas and mentally rehearsing to keep them alive. That feeling of 'I can't hold all this' turned out to be the perfect trigger for memory consolidation.",
+  "situation": ["long design session", "multiple insights accumulating", "feeling mentally overloaded", "breakthrough about consolidation timing"],
+  "created_at": "2024-06-20T16:45:00Z"
+}

dialectic/test-scripts/simple-test.yaml

@@ -0,0 +1,6 @@
+{
+  "id": "natural-phrases-decision-003",
+  "content": "Chose natural phrases over structured tags for situation descriptions. Niko worried about exact matching, but we realized keyword search with stemming handles variations well. 'feeling overwhelmed' is more intuitive than 'state:overwhelmed' and matches how people actually describe situations.",
+  "situation": ["discussing data formats", "usability vs structure tradeoff", "decision making with Niko", "favoring simplicity"],
+  "created_at": "2024-07-05T11:20:00Z"
+}

dialectic/tests/memory-basic/.memories/cognitive-pressure-discovery-002.json

@@ -0,0 +1,6 @@
+{
+  "id": "situation-rename-001",
+  "content": "Renamed 'subjects' field to 'situation' because 'subjects' was misleading. The field's purpose is to capture the context/situation when the memory was formed, so that similar situations can trigger relevant memory retrieval. Better name makes the intent clearer.",
+  "situation": ["designing memory structure", "field naming discussion", "clarity breakthrough", "working with Niko"],
+  "created_at": "2024-07-09T15:30:00Z"
+}

dialectic/tests/memory-basic/.memories/natural-phrases-decision-003.json

@@ -0,0 +1,12 @@
+name: "Memory Field Design Recall"
+description: "Test memory retrieval when user asks about past design decisions"
+
+conversation:
+  - user: "Hi Claude, can you check your memory bank and tell me what we decided about the situation field? I remember we had a discussion about whether to use structured tags or something else."
+    expected_response:
+      should_contain: ["natural phrases", "situation", "structured"]
+    expected_tools:
+      - tool: "mcp__socratic-shell__read_in"
+        parameters:
+          query:
+            should_contain: ["situation field"]