Update/ux

.claude/commands/code-review.md

@@ -0,0 +1 @@
+Conduct code review and make sure our standards are upheld. Simple/elegance, do simple things well. No overengineering or premature optimization.

.claude/commands/confident-in-plan.md

@@ -0,0 +1 @@
+do you think you have a confident understanding in how to implement the plan? Your confidence is derived from the plan and current state of the code?

.claude/commands/implement-plan.md

@@ -0,0 +1,3 @@
+Let's get started on the plan. Ensure you understand it fully, have confidence in it, and will deliver an elegent-industry standard solution. You will do so by delivering the parts of the plans in phases such that each phase is verified through high-quality testing. Coverage is not a number to us - we care only about quality tests that matter. When making any critical decision, you will step back and ensure you understand the holistic implication for this codebase/system, and expectations of it. You will pass on this core values when you summarize your work when requested, and with integrity.
+
+Review the plan - create a set of todos that will guide you to solid completion - remember to update the lnrwrk log along the way - make tests after phases and commit when in a valid place - do it all with elegance and smart execution.

.claude/commands/onboard-prompt.md

@@ -0,0 +1,24 @@
+# System Discovery & Understanding
+
+Your goal is to build a comprehensive understanding of this codebase so you can effectively contribute to its development.
+
+## Objective
+
+Develop a robust mental model of the system's architecture, core workflows, data flow, and key components. Your understanding should be good enough to confidently tackle diverse development tasks.
+
+## Getting Started
+
+Start with: ! `tree -a --gitignore --dirsfirst -I '.git'` to map the repository structure, then review recent documentation to understand the current state and what's next to be implemented.
+
+## What You're Building Toward
+
+Once you've explored and synthesized your understanding, provide a structured summary covering:
+
+- **System Overview**: Purpose and high-level architecture
+- **Core Workflows**: How entities flow through the system (ux/api)
+- **Key Components**: Major modules and their responsibilities
+- **Knowledge Gaps**: Areas where you need clarification or made assumptions
+
+Use whatever discovery approach feels most effective - you have full autonomy over your investigation strategy. Focus on understanding the system well enough to feel confident in beginning any new contributions.
+
+Take your time, think critically, and leverage your strengths in code analysis and pattern recognition. No coding during this phase - pure discovery and understanding.

.gitignore

@@ -4,3 +4,7 @@
 
 /.devshell
 /.env
+
+# Generated JavaScript files in TypeScript source directories
+mcp-guardian/src/**/*.js
+mcp-guardian-core/bindings/**/*.js

CLAUDE.md

@@ -0,0 +1,209 @@
+# Important
+
+All reference for current work is located in `_context_library/`. Use this to directory to understand:
+
+- How to develop user tasks
+- Current phase of work, and implementation progress
+- Application design decisions (software, as well as UI/UX)
+
+**Note:**
+
+- All project management record keeping should be placed in `_context_library/`.
+- This directory will be empty during your onboarding process.
+
+### Onboarding Process
+
+- Focuses primarily on discovery, and note taking in `_context_library/DISCOVERY.md`.
+- As you work on tasks, you will add implementation notes and progress updates to `_context_library/PHASE{N}.md`.
+
+### Planning Process
+
+- Review `_context_library/GOALS.md` to understand critical objectives for both Tauri app and core library
+- Consult `_context_library/DEVELOPMENT_PLAN.md` for overall development strategy
+- Create detailed phase plans in `_context_library/PHASE{N}.md` files
+
+- For planning component development (React):
+- ALWAYS use `_context_library/STYLING_GUIDE.md` as your source of truth for styling guidelines
+- CRITICALLY IMPORTANT: Refer to `_context_library/PHASE1-INTERJECT.md` for component architecture
+- Use Radix UI primitives for accessible, unstyled component foundations
+- Create reusable UI components in `mcp-guardian/src/components/ui` directory
+- Component styling approach:
+  - Encapsulate component styles within the components themselves
+  - Use Tailwind CSS v4 utility classes for styling
+  - Use CSS variables from theme for consistent design
+  - Implement variant-based APIs (primary/secondary, sm/md/lg, etc.)
+- App.css should ONLY contain:
+  - Theme variables (@theme directive)
+  - Reset styles and base element styling
+  - AVOID component-specific styles in App.css - they belong in the components
+- Keep component files small and modular - use composition for reusability
+- Use strongly typed TypeScript/TSX throughout
+
+---
+
+# About this project
+
+We are working on MCP Guardian.
+
+MCP Guardian is a tool to help govern and _firewall_ MCP servers.
+
+The current implementation is:
+
+- A core lib `mcp-guardian-core/`
+- A MCP server proxy `mcp-guardian-proxy/`
+
+The current interfaces are:
+
+- A Tauri (Rust) based desktop application `mcp-guardian/`
+- A CLI `mcp-guardian-cli/`
+
+The scope of work primarily focuses on the Tauri application.
+
+The documentation for MCP Guardian is located in `docs/`.
+
+## Development Process
+
+## Testing, Linting, and Validation
+
+### Validation Scripts
+
+The following validation scripts are available in package.json:
+
+```json
+"scripts": {
+  "dev": "vite",
+  "build": "tsc && vite build",
+  "preview": "vite preview",
+  "tauri": "tauri",
+  "typecheck": "tsc --noEmit",
+  "lint:rust": "cd src-tauri && cargo clippy",
+  "check:rust": "cd src-tauri && cargo check",
+  "validate": "npm run typecheck && npm run check:rust && npm run lint:rust"
+}
+```
+
+### Frontend (TypeScript/React)
+
+- TypeCheck: `npm run typecheck` - Validate TypeScript types without emitting files
+- Build: `npm run build` - Compile TypeScript and bundle the application
+
+#### Components
+
+Always aim to keep component files small and modular. We can not afford long files.
+
+### Backend (Rust)
+
+- Check: `npm run check:rust` - Validate Rust syntax without building
+- Test: `cd src-tauri && cargo test` - Run Rust tests
+- Clippy: `npm run lint:rust` - Run Rust linter for best practices and code quality
+
+### Complete Validation
+
+- Run TypeScript & Rust Checks: `npm run validate` - Run TypeScript checks and Rust linting/checking
+- Run Full Build: `npm run build` - Verify that the application builds successfully
+
+### After Code Changes
+
+1. ALWAYS run `npm run validate` to check for type errors and code issues before committing
+2. ALWAYS run `npm run build` to ensure the application builds successfully
+3. Fix any type errors, linting warnings, or build errors before proceeding
+4. Test the application with `npm run tauri dev` before committing changes
+5. Add appropriate tests for new functionality
+
+> **IMPORTANT**: Do not commit code that fails validation or doesn't build. Both the validate script and build must pass without errors.
+
+## Code Style
+
+- Use strongly typed TypeScript/TSX throughout
+- Follow strict mode, no unused locals/parameters
+- Use React 18 with functional components only
+- Components should have explicit type definitions
+- Error handling: use try/catch with appropriate user messages
+- File naming: kebab-case for components, camelCase for utilities
+
+## Development Status
+
+- Current work is tracked in PHASE1.md (Core Infrastructure & Basic Application Flow)
+- See PHASE_DOCS_GUIDE.md for guidelines on using phase documentation
+- Update phase documents with progress notes and completed tasks
+- Mark tasks with:
+  - [ ] (not started)
+  - [/] (in progress)
+  - [x] (complete)
+  - [-] (backlogged/deferred to future phase)
+- Deprioritized features are tracked in BACKLOGGED.md
+
+### Backlogging Process
+
+- IMPORTANT: Always confirm with the user before backlogging any feature
+- Only backlog non-critical features that can be deferred to future phases
+- For each backlogged item:
+  1. Mark it with [-] in the phase document
+  2. Add detailed entry to BACKLOGGED.md with rationale
+  3. Reference the backlogged status in phase progress notes
+
+## Git Workflow
+
+- Use Git for version control and tracking changes
+- Make small, focused commits with descriptive messages
+- Create feature branches for significant additions
+- Use commits to document development progress
+- IMPORTANT: This is a local repository only - DO NOT attempt to push to remote
+- Run `git status` before commits to verify changes
+- Consider using `git diff` to review changes before committing
+
+## Playwright MCP Tool
+
+You have access to the Playwright MCP Tool. Playwright MCP will launch Chrome browser with the new profile, located at `~/Library/Caches/ms-playwright/mcp-chrome-profile` on macOS. All the logged in information will be stored in that profile, you can delete it between sessions if you'd like to clear the offline state.
+
+This MCP is setup to use: Snapshot Mode (default): Uses accessibility snapshots for better performance and reliability.
+
+With playwright you can:
+**Playwright MCP Browser Automation Tools:**
+`browser_navigate(url)` • `browser_go_back()` • `browser_go_forward()` • `browser_click(element, ref)` • `browser_hover(element, ref)` • `browser_drag(startElement, startRef, endElement, endRef)` • `browser_type(element, ref, text, submit)` • `browser_select_option(element, ref, values[])` • `browser_choose_file(paths[])` • `browser_press_key(key)` • `browser_snapshot()` • `browser_save_as_pdf()` • `browser_take_screenshot(raw)` • `browser_wait(time)` • `browser_close()`
+
+Use playwright to search the web for information, or use it to test the application (sparingly).
+
+## ProjectManagement Guidelines
+
+### ProjectManagement Files
+
+- **`CLAUDE.md`:** (ROOT LEVEL) Project-specific guidelines and commands
+- **`_context_library/GOALS.md`:** Critical objectives for both Tauri app and enterprise core library
+- **`_context_library/DEVELOPMENT_PLAN.md`:** Overall development strategy and phasing
+- **`_context_library/DISCOVERY.md`:** Technical and business analysis of the project
+- **`_context_library/PHASE{N}.md`:** Implementation notes for each development phase
+
+### ProjectManagement Coordination Process
+
+All project management record keeping should be placed in `_context_library/`.
+
+1. **When starting a new task**:
+
+   - Check PHASE{N}.md to understand task requirements and context
+   - Use CLAUDE.md for coding standards and project conventions
+
+2. **During implementation**:
+
+   - Mark tasks as in-progress [/] in `_context_library/PHASE{N}.md`
+   - Create or update `_context_library/CLAUDE_TROUBLESHOOT.md` when encountering issues
+   - Reference appropriate documentation in code comments
+
+3. **After completing a task**:
+   - Mark tasks as complete [x] in `_context_library/PHASE{N}.md`
+   - Add implementation notes with timestamps
+   - Update other documents if implementation deviates from plan
+
+### When Adding Dependencies
+
+1. Research thoroughly before adding new dependencies:
+
+   - Use Playwright to check current stable versions
+   - Verify compatibility with existing dependencies
+   - Check required feature flags and configuration
+   - Create small examples before full implementation
+
+2. When encountering significant issues:
+   - Document in `_context_library/CLAUDE_TROUBLESHOOT.md` with detailed explanations
+   - Include error messages, root causes, and resolutions
+   - Note any workarounds or simplifications needed for MVP

Cargo.toml

@@ -4,6 +4,7 @@ members = [
     "mcp-guardian-core",
     "mcp-guardian-cli",
     "mcp-guardian-proxy",
+    "mcp-guardian-schema",
 ]
 resolver = "2"
 
@@ -43,6 +44,7 @@ dirs = "5"
 env_logger = "0.11"
 humantime = "2"
 log = "0.4"
+schemars = { version = "0.8", features = ["derive"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 strum = { version = "0.26", features = ["derive"] }

README.md

@@ -18,6 +18,16 @@ MCP Guardian manages your LLM assistant's access to MCP servers, handing you rea
 
 MCP Guardian also makes it a breeze to manage multiple MCP server configurations. Quickly switch between server collections without having to manually manage configuration files for your MCP host applications.
 
+## Project Components
+
+MCP Guardian consists of the following components:
+
+- `mcp-guardian-core` - Core library with data models and business logic
+- `mcp-guardian-proxy` - MCP server proxy for intercepting and managing messages
+- `mcp-guardian-cli` - Command-line interface for managing MCP Guardian
+- `mcp-guardian-schema` - JSON Schema generation from core data models
+- `mcp-guardian` - Desktop application (Tauri/React)
+
 ## Development
 
 This project uses [nix](https://nixos.org/) to manage a development environment that can be used on Linux and macOS.