fitz-graveyard 0.1.0__tar.gz

fitz_graveyard-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yan Fitzer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fitz_graveyard-0.1.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: fitz-graveyard
+Version: 0.1.0
+Summary: MCP server for local-first AI architectural planning using local LLMs
+Author-email: Yan Fitzer <yan@example.com>
+License: MIT License
+        
+        Copyright (c) 2026 Yan Fitzer
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/yafitzdev/fitz-graveyard
+Project-URL: Repository, https://github.com/yafitzdev/fitz-graveyard
+Project-URL: Issues, https://github.com/yafitzdev/fitz-graveyard/issues
+Project-URL: Documentation, https://github.com/yafitzdev/fitz-graveyard#readme
+Keywords: mcp,planning,ai,model-context-protocol,ollama,local-llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastmcp>=2.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: platformdirs>=4.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: aiosqlite>=0.20
+Requires-Dist: ollama>=0.4.0
+Requires-Dist: tenacity>=9.0.0
+Requires-Dist: psutil>=6.1.0
+Requires-Dist: typer>=0.9
+Provides-Extra: api-review
+Requires-Dist: anthropic>=0.40; extra == "api-review"
+Requires-Dist: CurrencyConverter>=0.17; extra == "api-review"
+Provides-Extra: lm-studio
+Requires-Dist: openai>=1.0.0; extra == "lm-studio"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# fitz-graveyard
+
+[![PyPI version](https://img.shields.io/pypi/v/fitz-graveyard.svg)](https://pypi.org/project/fitz-graveyard/)
+[![Python versions](https://img.shields.io/pypi/pyversions/fitz-graveyard.svg)](https://pypi.org/project/fitz-graveyard/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Tests](https://github.com/yafitzdev/fitz-graveyard/workflows/tests/badge.svg)](https://github.com/yafitzdev/fitz-graveyard/actions)
+
+MCP server for overnight AI architectural planning using local LLMs.
+
+## Features
+
+- Local-first planning with Ollama (Qwen Coder Next 80B/32B)
+- Five-stage pipeline: context, architecture, design, roadmap, risk
+- SQLite job queue with crash recovery and checkpoint resume
+- KRAG-powered codebase context via fitz-ai integration
+- Per-section confidence scoring with optional API review
+- Cross-platform: Windows, macOS, Linux
+
+## Prerequisites
+
+- Python 3.10+
+- Ollama installed and running ([https://ollama.com](https://ollama.com))
+- Qwen model pulled:
+  ```bash
+  ollama pull qwen2.5-coder:32b
+  ```
+
+## Installation
+
+```bash
+pip install fitz-graveyard
+```
+
+For API review feature:
+
+```bash
+pip install "fitz-graveyard[api-review]"
+```
+
+## Usage - MCP Server (Claude Code)
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "fitz-planner": {
+      "command": "fitz-graveyard"
+    }
+  }
+}
+```
+
+Restart Claude Desktop, then use planning tools directly in conversations.
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `create_plan` | Queue a new planning job |
+| `check_status` | Check job progress |
+| `get_plan` | Retrieve completed plan |
+| `list_plans` | List all planning jobs |
+| `retry_job` | Retry a failed job |
+| `confirm_review` | Approve API review after seeing cost |
+| `cancel_review` | Skip API review, finalize plan |
+
+## Configuration
+
+Default configuration location:
+
+- **Windows**: `%APPDATA%\fitz-graveyard\config.yaml`
+- **macOS**: `~/Library/Application Support/fitz-graveyard/config.yaml`
+- **Linux**: `~/.config/fitz-graveyard/config.yaml`
+
+Key settings (YAML):
+
+```yaml
+llm:
+  provider: ollama
+  model: qwen2.5-coder:32b
+  base_url: http://localhost:11434
+
+planning:
+  confidence_threshold: 0.75
+  max_retries: 3
+  checkpoint_interval: 60
+
+api_review:
+  provider: anthropic  # Optional: for confidence scoring
+  model: claude-opus-4
+  enabled: false
+```
+
+## Development
+
+```bash
+git clone https://github.com/yafitzdev/fitz-graveyard.git
+cd fitz-graveyard
+pip install -e ".[dev]"
+pytest
+```
+
+## Architecture
+
+```
+fitz_graveyard/
+├── server.py           # MCP server entry point
+├── engine/             # Planning orchestration
+│   ├── stages/         # Five-stage pipeline
+│   └── checkpoints/    # Crash recovery
+├── queue/              # SQLite job queue
+├── context/            # fitz-ai KRAG integration
+├── review/             # Optional API review
+└── config/             # Configuration management
+```
+
+## License
+
+[MIT](LICENSE)

fitz_graveyard-0.1.0/README.md

@@ -0,0 +1,120 @@
+# fitz-graveyard
+
+[![PyPI version](https://img.shields.io/pypi/v/fitz-graveyard.svg)](https://pypi.org/project/fitz-graveyard/)
+[![Python versions](https://img.shields.io/pypi/pyversions/fitz-graveyard.svg)](https://pypi.org/project/fitz-graveyard/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Tests](https://github.com/yafitzdev/fitz-graveyard/workflows/tests/badge.svg)](https://github.com/yafitzdev/fitz-graveyard/actions)
+
+MCP server for overnight AI architectural planning using local LLMs.
+
+## Features
+
+- Local-first planning with Ollama (Qwen Coder Next 80B/32B)
+- Five-stage pipeline: context, architecture, design, roadmap, risk
+- SQLite job queue with crash recovery and checkpoint resume
+- KRAG-powered codebase context via fitz-ai integration
+- Per-section confidence scoring with optional API review
+- Cross-platform: Windows, macOS, Linux
+
+## Prerequisites
+
+- Python 3.10+
+- Ollama installed and running ([https://ollama.com](https://ollama.com))
+- Qwen model pulled:
+  ```bash
+  ollama pull qwen2.5-coder:32b
+  ```
+
+## Installation
+
+```bash
+pip install fitz-graveyard
+```
+
+For API review feature:
+
+```bash
+pip install "fitz-graveyard[api-review]"
+```
+
+## Usage - MCP Server (Claude Code)
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "fitz-planner": {
+      "command": "fitz-graveyard"
+    }
+  }
+}
+```
+
+Restart Claude Desktop, then use planning tools directly in conversations.
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `create_plan` | Queue a new planning job |
+| `check_status` | Check job progress |
+| `get_plan` | Retrieve completed plan |
+| `list_plans` | List all planning jobs |
+| `retry_job` | Retry a failed job |
+| `confirm_review` | Approve API review after seeing cost |
+| `cancel_review` | Skip API review, finalize plan |
+
+## Configuration
+
+Default configuration location:
+
+- **Windows**: `%APPDATA%\fitz-graveyard\config.yaml`
+- **macOS**: `~/Library/Application Support/fitz-graveyard/config.yaml`
+- **Linux**: `~/.config/fitz-graveyard/config.yaml`
+
+Key settings (YAML):
+
+```yaml
+llm:
+  provider: ollama
+  model: qwen2.5-coder:32b
+  base_url: http://localhost:11434
+
+planning:
+  confidence_threshold: 0.75
+  max_retries: 3
+  checkpoint_interval: 60
+
+api_review:
+  provider: anthropic  # Optional: for confidence scoring
+  model: claude-opus-4
+  enabled: false
+```
+
+## Development
+
+```bash
+git clone https://github.com/yafitzdev/fitz-graveyard.git
+cd fitz-graveyard
+pip install -e ".[dev]"
+pytest
+```
+
+## Architecture
+
+```
+fitz_graveyard/
+├── server.py           # MCP server entry point
+├── engine/             # Planning orchestration
+│   ├── stages/         # Five-stage pipeline
+│   └── checkpoints/    # Crash recovery
+├── queue/              # SQLite job queue
+├── context/            # fitz-ai KRAG integration
+├── review/             # Optional API review
+└── config/             # Configuration management
+```
+
+## License
+
+[MIT](LICENSE)

fitz_graveyard-0.1.0/fitz_graveyard/__init__.py

@@ -0,0 +1,8 @@
+# fitz_graveyard/__init__.py
+"""
+fitz-graveyard: MCP server for local-first AI planning with fitz-ai integration.
+
+Provides tools for analyzing projects, generating plans, and managing async planning jobs.
+"""
+
+__version__ = "0.1.0"

fitz_graveyard-0.1.0/fitz_graveyard/__main__.py

@@ -0,0 +1,36 @@
+# fitz_graveyard/__main__.py
+"""
+Entry point for fitz-graveyard MCP server.
+
+CRITICAL: Server imports configure_logging() first to prevent stdout pollution.
+
+This module coordinates lifecycle initialization before starting the MCP server.
+FastMCP doesn't have built-in lifecycle hooks, so we handle it manually.
+"""
+
+import asyncio
+import logging
+
+# Import server (which configures logging before anything else)
+from fitz_graveyard.server import initialize_lifecycle, mcp
+
+logger = logging.getLogger(__name__)
+
+
+async def main() -> None:
+    """
+    Main entry point.
+
+    Initializes lifecycle (DB + worker + signals) and then runs MCP server.
+    """
+    # Initialize lifecycle first
+    await initialize_lifecycle()
+
+    # Now run the MCP server via stdio transport
+    # Note: mcp.run() is synchronous and blocks, so this must be the last call
+    logger.info("Starting MCP server on stdio transport")
+    await mcp.run_stdio_async()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

fitz_graveyard-0.1.0/fitz_graveyard/api_review/__init__.py

@@ -0,0 +1,23 @@
+# fitz_graveyard/api_review/__init__.py
+"""
+API review subsystem for optional Anthropic-based plan section review.
+
+Provides:
+- Cost estimation using Anthropic's count_tokens API
+- Async review execution with concurrent section processing
+- Token usage tracking and USD/EUR cost breakdown
+"""
+
+from .client import AnthropicReviewClient
+from .cost_calculator import CostCalculator
+from .schemas import CostBreakdown, CostEstimate, ReviewRequest, ReviewResult, build_review_prompt
+
+__all__ = [
+    "AnthropicReviewClient",
+    "CostCalculator",
+    "CostEstimate",
+    "ReviewResult",
+    "ReviewRequest",
+    "CostBreakdown",
+    "build_review_prompt",
+]

fitz_graveyard-0.1.0/fitz_graveyard/api_review/client.py

@@ -0,0 +1,142 @@
+# fitz_graveyard/api_review/client.py
+"""
+Anthropic review client for async section review.
+
+Uses AsyncAnthropic for concurrent review of multiple plan sections.
+"""
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+
+from .cost_calculator import CostCalculator
+from .schemas import ReviewRequest, ReviewResult, build_review_prompt
+
+if TYPE_CHECKING:
+    import anthropic
+
+logger = logging.getLogger(__name__)
+
+
+class AnthropicReviewClient:
+    """Async client for reviewing plan sections using Anthropic API."""
+
+    SYSTEM_PROMPT = (
+        "You are an expert technical reviewer for software project plans. "
+        "Provide actionable, substantive feedback that helps improve plan quality."
+    )
+
+    def __init__(self, api_key: str, model: str = "claude-sonnet-4-5-20250929"):
+        """
+        Initialize Anthropic review client.
+
+        Args:
+            api_key: Anthropic API key
+            model: Model to use for review (default: Claude Sonnet 4.5)
+        """
+        self._api_key = api_key
+        self._model = model
+        self._client: "anthropic.AsyncAnthropic | None" = None
+
+    @property
+    def client(self) -> "anthropic.AsyncAnthropic":
+        """Lazy-loaded Anthropic client."""
+        if self._client is None:
+            import anthropic
+
+            self._client = anthropic.AsyncAnthropic(api_key=self._api_key)
+        return self._client
+
+    async def review_sections(self, sections: list[ReviewRequest]) -> list[ReviewResult]:
+        """
+        Review multiple sections concurrently.
+
+        Args:
+            sections: Sections to review
+
+        Returns:
+            Review results (one per section, including failures)
+
+        Note:
+            Each section is reviewed independently. Failures in one section
+            do not affect others.
+        """
+        # Review all sections concurrently
+        review_tasks = [self._review_single_section(section) for section in sections]
+        results = await asyncio.gather(*review_tasks, return_exceptions=True)
+
+        # Convert exceptions to ReviewResult with error
+        processed_results = []
+        for i, result in enumerate(results):
+            if isinstance(result, Exception):
+                logger.error(
+                    f"Review failed for section '{sections[i].section_name}': {result}",
+                    exc_info=result,
+                )
+                processed_results.append(
+                    ReviewResult(
+                        section_name=sections[i].section_name,
+                        success=False,
+                        error=str(result),
+                    )
+                )
+            else:
+                processed_results.append(result)
+
+        return processed_results
+
+    async def _review_single_section(self, section: ReviewRequest) -> ReviewResult:
+        """
+        Review a single section using Anthropic API.
+
+        Args:
+            section: Section to review
+
+        Returns:
+            Review result with feedback and token usage
+
+        Raises:
+            Exception: On API errors (handled by review_sections)
+        """
+        try:
+            # Build review prompt
+            prompt = build_review_prompt(section)
+
+            # Call Anthropic API
+            response = await self.client.messages.create(
+                model=self._model,
+                max_tokens=2048,
+                system=self.SYSTEM_PROMPT,
+                messages=[{"role": "user", "content": prompt}],
+            )
+
+            # Extract feedback from response
+            feedback = response.content[0].text if response.content else ""
+
+            return ReviewResult(
+                section_name=section.section_name,
+                success=True,
+                feedback=feedback,
+                input_tokens=response.usage.input_tokens,
+                output_tokens=response.usage.output_tokens,
+            )
+
+        except Exception as e:
+            # Log and re-raise for gather() to handle
+            logger.warning(f"API call failed for section '{section.section_name}': {e}")
+            raise
+
+    def get_cost_calculator(self) -> CostCalculator:
+        """
+        Get cost calculator initialized with same client.
+
+        Returns:
+            CostCalculator instance
+        """
+        return CostCalculator(client=self.client)
+
+    async def close(self):
+        """Close the async client if initialized."""
+        if self._client is not None:
+            await self._client.close()
+            self._client = None