Implement unified Socratic Shell installation and MCP server

[nikomatsakis]

Unified Socratic Shell Installation Experience

Status: Planning

Current Understanding

Create a comprehensive setup script and unified MCP server that transforms socratic shell from a collection of patterns into a complete collaborative AI environment that "just works out of the box."

Architecture Vision

Single Binary - Multiple Modes:

• MCP Server Mode: socratic-shell serve - provides unified MCP interface to all socratic shell capabilities (memory via hippo, dialectic, project setup tools, etc.)
• Hook Mode: socratic-shell hook conversation-start / socratic-shell hook per-prompt - lightweight event handlers for AI tool lifecycle events

Setup Script Components:

1. VSCode Extension - for dialectic integration and broader socratic shell features
2. Context Injection - install socratic shell prompts into user's AI tool context
3. Socratic Shell MCP Server - unified front-end for dialectic, hippo, and future tools
4. Event Hooks - conversation start and per-prompt triggers
5. Canned Prompts - MCP tools for common operations (project setup, github tracking patterns, etc.)

Intelligence:

• Auto-detect Claude Code vs Q CLI (extensible for future AI tools)
• Adapt installation and configuration accordingly
• Per-project setup capabilities

Next Steps

• Design MCP server tool interface and internal architecture
• Prototype hook system integration with Claude Code/Q CLI
• Plan setup script structure and auto-detection logic
• Define canned prompt/tool catalog

Open Questions

• What specific tools should the MCP server expose initially?
• How should hooks integrate with different AI tool configurations?
• What's the right balance between setup automation vs user control?
• Should we support partial installations (e.g., just MCP server without hooks)?

Context

This transforms socratic shell from documentation and separate tools into a cohesive collaborative AI environment. Users would run one setup script and get the full socratic shell experience integrated into their preferred AI tool.

[nikomatsakis]

Session summary:

• Created comprehensive RFC structure with 4 detailed documents
• Explored VSCode extension integration patterns and determined dialectic can be incorporated as JavaScript library
• Designed git subtree strategy for coordinating multi-language components (Python hippo, TypeScript dialectic, future Rust components)
• Established automated GitHub Actions syncing with conflict detection and issue filing

Impact on approach:

• VSCode extension becomes thin orchestration layer that primarily delegates to dialectic
• Git subtrees provide language-agnostic coordination while preserving component independence
• Multi-binary bundling strategy confirmed for cross-platform distribution
• Automated syncing reduces manual coordination overhead

Progress: Completed architectural design phase. Next: begin prototyping MCP server routing logic and VSCode extension integration.

RFCs created:

• Main RFC - Overall vision and architecture
• MCP Server - Rust orchestrator implementation
• Hooks - AI tool lifecycle integration
• Repository Coordination - Multi-language component management

[nikomatsakis]

Architecture Update

Major changes since initial planning:

• All MCP servers now implemented in Rust using the rmcp crate (sources in ~/dev/rust-sdk)
• Plan: Single socratic-shell MCP server that repackages existing Rust MCP servers
• VSCode extension will wrap the dialectic extension and possibly others
• Extension manages downloading Rust binaries and local models

Updated Architecture Sketch:

• Socratic Shell MCP Server (Rust): Unified server repackaging existing Rust MCP implementations
• Socratic Shell VSCode Extension: Wraps dialectic extension, manages binary/model downloads
• Distribution: Extension handles downloading and lifecycle of Rust binaries + local models

Next Steps:

• Elaborate on repackaging approach for existing Rust MCP servers
• Define extension architecture for wrapping dialectic + others
• Design download/update mechanism for binaries and models
• Plan integration points between extension and MCP server