intpot 0.1.0__tar.gz

intpot-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv sync --all-extras
+      - run: uv run ruff check src/ tests/
+      - run: uv run ruff format --check src/ tests/
+
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv sync --all-extras
+      - run: uv run pyright src/ tests/
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: uv sync --all-extras
+      - run: uv run pytest tests/ -v --cov=src/intpot --cov-report=term-missing

intpot-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,30 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

intpot-0.1.0/.gitignore

@@ -0,0 +1,31 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+*.egg
+dist/
+build/
+
+# Virtual environments
+.venv/
+venv/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Type checking / linting
+.mypy_cache/
+.ruff_cache/
+
+# OS
+.DS_Store
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~

intpot-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,15 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.9.0
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format

intpot-0.1.0/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- **Python API** — `intpot.load()` accepts file paths or live app instances (FastMCP, Typer, FastAPI) and returns an `IntpotApp` with `.to_cli()`, `.to_mcp()`, `.to_api()` methods
+- **Directory auto-discovery** — `intpot to cli ./myproject/` scans a directory for convertible apps
+- `detect_instance()` function for detecting live Python objects (not just files)
+- `discover_sources()` function for recursive directory scanning
+- `IntpotApp` wrapper class for programmatic conversions
+- New tests for Python API and discovery (13 new tests, 42 total)
+
+## [0.1.0] - 2026-03-02
+
+### Added
+
+- Core inspection engine for CLI (Typer), MCP (FastMCP), and API (FastAPI) apps
+- Code generation for all 6 conversion directions (CLI↔MCP↔API)
+- `intpot to cli` command — convert MCP/API source to a Typer CLI
+- `intpot to mcp` command — convert CLI/API source to a FastMCP server
+- `intpot to api` command — convert CLI/MCP source to a FastAPI app
+- `intpot init` command — scaffold new CLI, MCP, or API projects
+- Jinja2-based template rendering for generated code
+- Auto-detection of source framework type
+- Full test suite (29 tests)

intpot-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,88 @@
+# Contributing to intpot
+
+Thanks for your interest in contributing!
+
+## Development Setup
+
+1. Fork and clone the repository:
+
+   ```bash
+   git clone https://github.com/YOUR_USERNAME/intpot.git
+   cd intpot
+   ```
+
+2. Install dependencies (requires [uv](https://docs.astral.sh/uv/)):
+
+   ```bash
+   uv sync --all-extras
+   ```
+
+3. Install pre-commit hooks:
+
+   ```bash
+   uv run pre-commit install
+   ```
+
+## Code Style
+
+- We use [Ruff](https://docs.astral.sh/ruff/) for linting and formatting.
+- Run `make format` to auto-format your code.
+- Run `make lint` to check for issues.
+- Pre-commit hooks will run automatically on each commit.
+
+## Type Checking
+
+We use [Pyright](https://github.com/microsoft/pyright) for static type analysis.
+
+- Run `make typecheck` to check types.
+- Add type annotations to all new functions and methods.
+- Use `from __future__ import annotations` for forward references.
+- Pyright is configured in `pyproject.toml` under `[tool.pyright]`.
+
+## Running Tests
+
+```bash
+make test
+```
+
+Or run the full check suite (lint + typecheck + test):
+
+```bash
+make check
+```
+
+## Project Structure
+
+```
+src/intpot/
+├── __init__.py          # Package exports (load, IntpotApp)
+├── cli.py               # Main CLI entry point
+├── converter.py         # Python API (IntpotApp, load())
+├── commands/            # CLI command handlers (to_cli, to_mcp, to_api, init)
+├── core/
+│   ├── models.py        # Shared data models (ToolInfo, ParameterInfo, SourceType)
+│   ├── detector.py      # Auto-detect source type from files or live instances
+│   ├── discovery.py     # Directory scanning for convertible apps
+│   ├── inspectors/      # Framework-specific inspectors (extract tools)
+│   └── generators/      # Framework-specific generators (render code)
+└── templates/           # Jinja2 templates for code generation
+```
+
+Key concepts:
+- **Detection** — identify framework type from a file path or live object
+- **Inspection** — extract normalized `ToolInfo` from framework-specific apps
+- **Generation** — render `ToolInfo` into target framework code via Jinja2 templates
+- **Python API** — `intpot.load(source)` returns an `IntpotApp` for programmatic use
+
+## Pull Request Process
+
+1. Create a feature branch from `main`.
+2. Make your changes and add tests if applicable.
+3. Ensure `make check` passes (lint, typecheck, and tests).
+4. Open a pull request with a clear description of your changes.
+
+## Reporting Issues
+
+- Use GitHub Issues to report bugs or request features.
+- Include steps to reproduce for bug reports.
+- Check existing issues before opening a new one.

intpot-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 intpot contributors
+
+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.

intpot-0.1.0/Makefile

@@ -0,0 +1,27 @@
+.PHONY: install test lint format typecheck check build clean
+
+install:
+	uv sync --all-extras
+
+test:
+	uv run pytest tests/ -v
+
+lint:
+	uv run ruff check src/ tests/
+	uv run ruff format --check src/ tests/
+
+format:
+	uv run ruff check --fix src/ tests/
+	uv run ruff format src/ tests/
+
+typecheck:
+	uv run pyright src/ tests/
+
+check: lint typecheck test
+
+build:
+	uv build
+
+clean:
+	rm -rf dist/ build/ *.egg-info .pytest_cache .ruff_cache .mypy_cache
+	find . -type d -name __pycache__ -exec rm -rf {} +

intpot-0.1.0/PKG-INFO

@@ -0,0 +1,355 @@
+Metadata-Version: 2.4
+Name: intpot
+Version: 0.1.0
+Summary: Universal converter between CLI (Typer), MCP (FastMCP), and API (FastAPI) interfaces
+Project-URL: Homepage, https://github.com/tugrulguner/intpot
+Project-URL: Repository, https://github.com/tugrulguner/intpot
+Project-URL: Issues, https://github.com/tugrulguner/intpot/issues
+Project-URL: Changelog, https://github.com/tugrulguner/intpot/blob/main/CHANGELOG.md
+Author: Tugrul Guner
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,code-generation,converter,fastapi,mcp,typer
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: all
+Requires-Dist: fastapi>=0.100.0; extra == 'all'
+Requires-Dist: fastmcp>=2.0.0; extra == 'all'
+Requires-Dist: uvicorn>=0.20.0; extra == 'all'
+Provides-Extra: api
+Requires-Dist: fastapi>=0.100.0; extra == 'api'
+Requires-Dist: uvicorn>=0.20.0; extra == 'api'
+Provides-Extra: dev
+Requires-Dist: fastapi>=0.100.0; extra == 'dev'
+Requires-Dist: fastmcp>=2.0.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.0.0; extra == 'dev'
+Requires-Dist: pyright>=1.1.390; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.8.0; extra == 'dev'
+Requires-Dist: uvicorn>=0.20.0; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: fastmcp>=2.0.0; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# intpot
+
+[![CI](https://github.com/tugrulguner/intpot/actions/workflows/ci.yml/badge.svg)](https://github.com/tugrulguner/intpot/actions/workflows/ci.yml)
+[![PyPI version](https://img.shields.io/pypi/v/intpot)](https://pypi.org/project/intpot/)
+[![Python versions](https://img.shields.io/pypi/pyversions/intpot)](https://pypi.org/project/intpot/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Universal converter between CLI (Typer), MCP (FastMCP), and API (FastAPI) interfaces.**
+
+intpot bridges three popular Python frameworks:
+
+- **[Typer](https://typer.tiangolo.com/)** — CLI applications
+- **[FastMCP](https://github.com/jlowin/fastmcp)** — Model Context Protocol servers
+- **[FastAPI](https://fastapi.tiangolo.com/)** — REST API applications
+
+Given a source file written in any of these frameworks, intpot detects the framework, inspects its functions/tools/endpoints, and generates equivalent code in the target framework.
+
+## Features
+
+- **6 conversion directions** — CLI to MCP, CLI to API, MCP to CLI, MCP to API, API to CLI, API to MCP
+- **Auto-detection** — automatically identifies the source framework by analyzing imports and patterns
+- **Project scaffolding** — `intpot init` creates new CLI, MCP, or API projects from templates
+- **Jinja2 templates** — clean, readable generated code with proper type hints
+- **Fully typed** — PEP 561 compatible with `py.typed` marker
+- **Zero config** — just point at a Python file and specify the target
+
+## Installation
+
+```bash
+pip install intpot            # core (CLI conversions only)
+pip install intpot[mcp]       # + FastMCP support
+pip install intpot[api]       # + FastAPI support
+pip install intpot[all]       # everything
+```
+
+## Quick Start
+
+### Scaffold a new project
+
+```bash
+intpot init my-server --type mcp
+intpot init my-app --type cli
+intpot init my-api --type api
+```
+
+### Convert between frameworks
+
+```bash
+# MCP server -> Typer CLI
+intpot to cli server.py
+
+# CLI app -> FastMCP server
+intpot to mcp app.py
+
+# CLI app -> FastAPI app
+intpot to api app.py
+
+# Write output to a file
+intpot to cli server.py --output cli_app.py
+
+# Convert all apps in a directory
+intpot to cli ./myproject/
+intpot to mcp ./myproject/ --output ./converted/
+```
+
+## Python API
+
+Use intpot programmatically from Python:
+
+```python
+import intpot
+
+# From a file
+app = intpot.load("mcp_server.py")
+cli_code = app.to_cli()
+api_code = app.to_api()
+
+# From a live instance
+from fastmcp import FastMCP
+
+mcp = FastMCP("my-server")
+
+@mcp.tool()
+def greet(name: str) -> str:
+    return f"Hello, {name}!"
+
+app = intpot.load(mcp)
+print(app.to_cli())
+```
+
+The `load()` function accepts file paths (str or Path) and live app instances (FastMCP, Typer, FastAPI). The returned `IntpotApp` object provides `.to_cli()`, `.to_mcp()`, and `.to_api()` methods that return generated code as strings.
+
+## Architecture
+
+intpot uses a four-stage pipeline:
+
+```
+                    +-----------+
+                    |  SOURCE   |
+                    | (.py file)|
+                    +-----+-----+
+                          |
+                    1. DETECT
+                    (identify framework)
+                          |
+                    +-----v-----+
+                    | SourceType|
+                    | cli/mcp/api|
+                    +-----+-----+
+                          |
+                    2. INSPECT
+                    (extract functions)
+                          |
+                    +-----v-----+
+                    | ToolDef[] |
+                    | (normalized|
+                    |  schema)  |
+                    +-----+-----+
+                          |
+                    3. GENERATE
+                    (render template)
+                          |
+                    +-----v-----+
+                    |  OUTPUT   |
+                    | (.py code)|
+                    +-----------+
+```
+
+1. **DETECT** — `core/detector.py` imports the source file and identifies whether it's a Typer app, FastMCP server, or FastAPI app
+2. **INSPECT** — Framework-specific inspectors (`core/inspectors/`) extract function signatures, parameters, types, defaults, and docstrings into a normalized `ToolDef` schema
+3. **GENERATE** — Framework-specific generators (`core/generators/`) render the normalized schema into target code using Jinja2 templates
+
+## Examples
+
+### MCP server to CLI app
+
+**Input** (`mcp_server.py`):
+```python
+from fastmcp import FastMCP
+
+mcp = FastMCP("example-server")
+
+@mcp.tool()
+def greet(name: str, greeting: str = "Hello") -> str:
+    """Greet someone by name."""
+    return f"{greeting}, {name}!"
+```
+
+**Command**: `intpot to cli mcp_server.py`
+
+**Output**:
+```python
+import typer
+
+app = typer.Typer()
+
+@app.command()
+def greet(
+    name: str = typer.Argument(..., help=""),
+    greeting: str = typer.Option('Hello', help=""),
+) -> None:
+    """Greet someone by name."""
+    # TODO: implement
+    typer.echo("greet called")
+```
+
+### CLI app to FastAPI
+
+**Input** (`cli_app.py`):
+```python
+import typer
+
+app = typer.Typer()
+
+@app.command()
+def add(
+    a: int = typer.Argument(..., help="First number"),
+    b: int = typer.Argument(..., help="Second number"),
+) -> None:
+    """Add two numbers together."""
+    typer.echo(a + b)
+```
+
+**Command**: `intpot to api cli_app.py`
+
+**Output**:
+```python
+from fastapi import FastAPI
+from pydantic import BaseModel, Field
+
+app = FastAPI()
+
+class AddRequest(BaseModel):
+    a: int = Field(..., description="First number")
+    b: int = Field(..., description="Second number")
+
+@app.post("/add")
+def add(request: AddRequest) -> dict:
+    """Add two numbers together."""
+    # TODO: implement
+    return {"result": "add called"}
+```
+
+### API app to MCP server
+
+**Input** (`api_app.py`):
+```python
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.post("/greet")
+def greet(name: str, greeting: str = "Hello") -> dict:
+    """Greet someone by name."""
+    return {"message": f"{greeting}, {name}!"}
+```
+
+**Command**: `intpot to mcp api_app.py`
+
+**Output**:
+```python
+from fastmcp import FastMCP
+
+mcp = FastMCP("generated-server")
+
+@mcp.tool()
+def greet(
+    name: str,
+    greeting: str = 'Hello',
+) -> dict:
+    """Greet someone by name."""
+    # TODO: implement
+    return "greet called"
+```
+
+See the [`examples/`](examples/) directory for all 6 conversion outputs.
+
+## CLI Reference
+
+### `intpot init`
+
+Scaffold a new project from a template.
+
+```
+intpot init <name> --type <mcp|cli|api>
+```
+
+| Argument/Option | Description |
+|----------------|-------------|
+| `name` | Project name (creates a directory) |
+| `--type`, `-t` | Project type: `mcp`, `cli`, or `api` (required) |
+
+### `intpot to cli`
+
+Convert an MCP or API source file to a Typer CLI app.
+
+```
+intpot to cli <source> [--output <path>]
+```
+
+### `intpot to mcp`
+
+Convert a CLI or API source file to a FastMCP server.
+
+```
+intpot to mcp <source> [--output <path>]
+```
+
+### `intpot to api`
+
+Convert a CLI or MCP source file to a FastAPI app.
+
+```
+intpot to api <source> [--output <path>]
+```
+
+| Argument/Option | Description |
+|----------------|-------------|
+| `source` | Path to a source Python file or directory |
+| `--output`, `-o` | Output file path (prints to stdout if omitted) |
+
+## Development
+
+Requires [uv](https://docs.astral.sh/uv/).
+
+```bash
+git clone https://github.com/tugrulguner/intpot.git
+cd intpot
+uv sync --all-extras
+uv run pre-commit install
+```
+
+Run the full check suite:
+
+```bash
+make check   # lint + typecheck + test
+```
+
+Individual targets:
+
+```bash
+make lint        # ruff check + format check
+make typecheck   # pyright
+make test        # pytest
+make format      # auto-format code
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for more details.
+
+## License
+
+MIT