cfast-mcp 0.1.0__tar.gz

cfast_mcp-0.1.0/.github/workflows/python-publish.yml

@@ -0,0 +1,61 @@
+# This workflow will upload a Python Package to PyPI when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.x"
+
+      - name: Build release distributions
+        run: |
+          python -m pip install build
+          python -m build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v7
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    permissions:
+      id-token: write
+
+    environment:
+      name: pypi
+      url: https://pypi.org/project/cfast-mcp/
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v8
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

cfast_mcp-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,166 @@
+# This workflow runs the test suite on Linux and Windows with Python version 3.10 to version 3.14.
+# and CFAST 7.7.7.
+#
+# Strategy:
+#   - Linux: compile CFAST 7.7.7 from source with gcc
+#   - Windows: extract the pre-built binary from the official CFAST 7.7.7 installer
+#
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Test
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [ "main" ]
+    paths:
+      - 'src/**'
+      - 'tests/**'
+      - 'pyproject.toml'
+      - 'uv.lock'
+      - '.github/workflows/test.yml'
+
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - 'src/**'
+      - 'tests/**'
+      - 'pyproject.toml'
+      - 'uv.lock'
+      - '.github/workflows/test.yml'
+
+env:
+  CFAST_VERSION: "7.7.7"
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        python-version: ${{ github.event_name == 'pull_request' && fromJSON('["3.10", "3.14"]') || fromJSON('["3.10", "3.11", "3.12", "3.13", "3.14"]') }}
+        include:
+          - os: ubuntu-latest
+            cfast-tag: "CFAST-7.7.7"
+            build-dir: gnu_linux
+            build-script: make_cfast.sh
+            binary-name: cfast7_linux
+          - os: windows-latest
+            installer-url: "https://github.com/firemodels/cfast/releases/download/CFAST-7.7.7/CFAST-7.7.7_SMV-6.11.1.exe"
+
+    steps:
+    - uses: actions/checkout@v6
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v7
+      with:
+        enable-cache: true
+        cache-dependency-glob: "uv.lock"
+
+    - name: Set up Python ${{ matrix.python-version }}
+      run: uv python install ${{ matrix.python-version }}
+
+    - name: Install python dependencies
+      run: uv sync --extra dev
+
+    - name: Cache CFAST binary (Linux)
+      if: runner.os == 'Linux'
+      id: cache-cfast-linux
+      uses: actions/cache@v5
+      with:
+        path: ~/cfast-cache/cfast-${{ env.CFAST_VERSION }}-linux-gcc
+        key: cfast-${{ env.CFAST_VERSION }}-linux-gcc-${{ hashFiles('.github/workflows/test.yml') }}
+
+    - name: Install gfortran
+      if: runner.os == 'Linux' && steps.cache-cfast-linux.outputs.cache-hit != 'true'
+      uses: fortran-lang/setup-fortran@v1
+      with:
+        compiler: gcc
+
+    - name: Build CFAST from source (Linux)
+      if: runner.os == 'Linux' && steps.cache-cfast-linux.outputs.cache-hit != 'true'
+      shell: bash
+      run: |
+        git clone --depth 1 --branch ${{ matrix.cfast-tag }} https://github.com/firemodels/cfast.git cfast-src
+        cd cfast-src/Build/CFAST/${{ matrix.build-dir }}
+        chmod +x ${{ matrix.build-script }}
+        ./${{ matrix.build-script }}
+        mkdir -p ~/cfast-cache
+        cp ${{ matrix.binary-name }} ~/cfast-cache/cfast-${{ env.CFAST_VERSION }}-linux-gcc
+        chmod +x ~/cfast-cache/cfast-${{ env.CFAST_VERSION }}-linux-gcc
+
+    - name: Install CFAST to system path (Linux)
+      if: runner.os == 'Linux'
+      run: |
+        sudo cp ~/cfast-cache/cfast-${{ env.CFAST_VERSION }}-linux-gcc /usr/bin/cfast
+        sudo chmod +x /usr/bin/cfast
+
+    - name: Cache CFAST binary (Windows)
+      if: runner.os == 'Windows'
+      id: cache-cfast-windows
+      uses: actions/cache@v5
+      with:
+        path: ~/cfast-cache/cfast-${{ env.CFAST_VERSION }}-windows
+        key: cfast-installer-${{ env.CFAST_VERSION }}-windows-${{ hashFiles('.github/workflows/test.yml') }}
+
+    - name: Download and extract CFAST installer (Windows)
+      if: runner.os == 'Windows' && steps.cache-cfast-windows.outputs.cache-hit != 'true'
+      shell: pwsh
+      run: |
+        # Download the installer
+        $installerUrl = "${{ matrix.installer-url }}"
+        $installerPath = "$env:TEMP\cfast-installer.exe"
+        Write-Host "Downloading CFAST installer from $installerUrl"
+        Invoke-WebRequest -Uri $installerUrl -OutFile $installerPath
+
+        # Extract with 7-Zip (pre-installed on GitHub runners)
+        $extractDir = "$env:TEMP\cfast-extracted"
+        7z x $installerPath -o"$extractDir" -y
+
+        # Display extracted contents for debugging
+        Write-Host "--- Extracted contents ---"
+        Get-ChildItem -Recurse $extractDir | ForEach-Object { Write-Host $_.FullName }
+        Write-Host "--- End contents ---"
+
+        # Find the CFAST executable (exclude smokeview, uninstaller, cdata)
+        $cfastExe = Get-ChildItem -Recurse -Path $extractDir -Filter "cfast*.exe" |
+          Where-Object { $_.Name -notmatch "uninstall|setup|smokeview|smv|cdata" } |
+          Select-Object -First 1
+
+        if (-not $cfastExe) {
+          Write-Error "Could not find cfast executable in extracted installer"
+          exit 1
+        }
+
+        Write-Host "Found CFAST executable: $($cfastExe.FullName)"
+
+        # Copy to cache
+        $cacheDir = "$env:USERPROFILE\cfast-cache"
+        if (-not (Test-Path $cacheDir)) { New-Item -ItemType Directory -Path $cacheDir }
+        Copy-Item $cfastExe.FullName "$cacheDir\cfast-${{ env.CFAST_VERSION }}-windows"
+
+    - name: Install CFAST to system path (Windows)
+      if: runner.os == 'Windows'
+      run: |
+        copy "$env:USERPROFILE\cfast-cache\cfast-${{ env.CFAST_VERSION }}-windows" "C:\Windows\System32\cfast.exe"
+
+    - name: Verify CFAST installation
+      shell: bash
+      run: |
+        if [ "${{ runner.os }}" = "Windows" ]; then
+          where cfast
+        else
+          which cfast
+        fi
+        cfast
+
+    - name: Run tests
+      run: uv run pytest --cov=src/cfast_mcp --cov-report=xml --cov-report=term-missing
+
+    - name: Upload results to Codecov
+      uses: codecov/codecov-action@v6
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        flags: cfast-${{ env.CFAST_VERSION }}-py3.14-${{ matrix.os }}
+        fail_ci_if_error: false

cfast_mcp-0.1.0/.github/workflows/typing.yml

@@ -0,0 +1,27 @@
+name: Typing
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          
+      - name: Set up Python
+        run: uv python install 3.14
+        
+      - name: Install dependencies
+        run: uv sync --extra dev
+
+      - name: Run mypy type check
+        run: uv run mypy src/

cfast_mcp-0.1.0/.gitignore

@@ -0,0 +1,223 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+*.lcov
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi/*
+!.pixi/config.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule*
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+.vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Claude Code local settings
+.claude/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

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

@@ -0,0 +1,8 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.15
+    hooks:
+      - id: ruff-check
+        args: [ --fix, --config=pyproject.toml ]
+      - id: ruff-format
+        args: [ --config=pyproject.toml ]

cfast_mcp-0.1.0/CLAUDE.md

@@ -0,0 +1,116 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+An MCP server built around [pycfast](https://github.com/bewygs/pycfast), a Python interface for CFAST (Consolidated Fire and Smoke Transport, NIST). It exposes tools that let an LLM build a CFAST model step by step, inspect it, run it, and read results.
+
+The pycfast source is available locally at `/home/bwygas/pycfast`. Read it directly to check signatures, defaults, and validation logic.
+
+## Commands
+
+```bash
+uv sync --extra dev         # Install package + dev dependencies (Python 3.10+)
+uv run cfast-mcp            # Run the server (console script)
+uv run main.py              # Run the server (repo-root shim)
+uv run mcp dev main.py      # MCP inspector UI
+uv run ruff check --fix .   # Lint
+uv run ruff format .        # Format
+uv run mypy src/            # Type-check
+uv run pytest               # Run all tests (CFAST-dependent ones skip if no binary)
+uv run pytest -m local      # Run only the tests requiring the CFAST binary
+uv run pytest --cov         # Coverage
+```
+
+Run a single test:
+```bash
+uv run pytest tests/test_model.py::test_create_model -v
+```
+
+Pre-commit hooks run `ruff check --fix` and `ruff format`.
+
+## Architecture
+
+```
+main.py                       # repo-root shim — re-exports server.mcp for `mcp dev`
+src/cfast_mcp/
+  server.py                   # builds FastMCP("cfast"), registers tools, main()
+  registry.py                 # ModelRegistry: model_id -> ModelEntry, in memory
+  errors.py                   # guard(): pycfast exceptions -> ToolError with hints
+  serialization.py            # bounded DataFrame summaries (never full dumps)
+  tools/                       # the 22 @mcp.tool() definitions, one module per component
+    __init__.py                # register_tools(): wires all sub-registrars
+    model.py                    # create_model, inspect_model, run_model, get_results, get_model_files
+    simulation.py               # update_simulation
+    materials.py                # add_material, update_material
+    compartments.py             # add_compartment, update_compartment
+    wall_vents.py                # add_wall_vent, update_wall_vent
+    ceiling_floor_vents.py       # add_ceiling_floor_vent, update_ceiling_floor_vent
+    mechanical_vents.py          # add_mechanical_vent, update_mechanical_vent
+    fires.py                     # add_fire, update_fire
+    devices.py                   # add_device, update_device
+    surface_connections.py       # add_surface_connection, update_surface_connection
+```
+
+### Tools
+
+| Tool | Purpose |
+|---|---|
+| `create_model` | New model + first compartment, returns `model_id` |
+| `update_simulation` | Edit the simulation environment (title, time, ambient conditions); only provided params change |
+| `add_material` | Add a `Material`; must exist before a compartment references it |
+| `update_material` | Edit an existing `Material` by id (thermophysical props); only provided params change |
+| `add_compartment` | Add a `Compartment`; must exist before vents/fires reference it |
+| `update_compartment` | Edit an existing `Compartment` by id (e.g. attach surfaces to the first one); only provided params change |
+| `add_wall_vent` | Add a `WallVent`; `comp_b` may be `"OUTSIDE"` |
+| `update_wall_vent` | Edit an existing `WallVent` by id (geometry; connection via both `comp_a`+`comp_b`); only provided params change |
+| `add_ceiling_floor_vent` | Add a `CeilingFloorVent` (vertical flow); `comp_bottom` may be `"OUTSIDE"` |
+| `update_ceiling_floor_vent` | Edit an existing `CeilingFloorVent` by id (connection via both `comp_top`+`comp_bottom`); only provided params change |
+| `add_mechanical_vent` | Add a `MechanicalVent` (fan); `comp_from`/`comp_to` may be `"OUTSIDE"` |
+| `update_mechanical_vent` | Edit an existing `MechanicalVent` by id (connection via both `comp_from`+`comp_to`); only provided params change |
+| `add_fire` | Add a `Fire`; `data_table` columns: TIME, HRR, HEIGHT, AREA, CO_YIELD, SOOT_YIELD, HCN_YIELD, HCL_YIELD, TRACE_YIELD |
+| `update_fire` | Edit an existing `Fire` by instance id (HRR curve, chemistry, location, comp_id); only provided params change |
+| `add_device` | Add a `Device` (target `PLATE`/`CYLINDER` or detector `HEAT_DETECTOR`/`SMOKE_DETECTOR`/`SPRINKLER`); pycfast validates per-type requirements |
+| `update_device` | Edit an existing `Device` by id; only provided params change |
+| `add_surface_connection` | Add a `SurfaceConnection` (`WALL`/`FLOOR` conductive heat transfer); no id |
+| `update_surface_connection` | Edit a `SurfaceConnection` by 0-based index (it has no id); only provided params change |
+| `inspect_model` | `model.summary()`, optionally the `.in` file |
+| `run_model` | Run CFAST, store results in the registry |
+| `get_results` | Bounded read of stored results (preview or per-column stats) |
+| `get_model_files` | List the model's on-disk files and their working directory |
+
+### Constraints inherited from pycfast
+
+- The registry is stateful: a `model_id` (`m1`, `m2`, ...) is returned at creation and passed to every subsequent tool. It lives for the server process lifetime only.
+- `CFASTModel` is immutable: `model.add(component)` returns a new model. Every `add_*` tool must reassign with `registry.set(model_id, ...)`.
+- A model cannot be empty: `CFASTModel.__init__` requires at least one compartment and validates immediately, so `create_model` takes the first compartment's parameters directly.
+- `add()` validates dependencies on every call. Required order: materials, then compartments, then wall vents and fires. `guard()` in `errors.py` turns the resulting `ValueError` into a message saying what to add first.
+- `view_cfast_input_file()` requires a prior `save()`. `inspect_model(show_input_file=True)` saves first and passes `pretty_print=False` to avoid ANSI codes in MCP responses.
+- Generated `.in`/output files live in a single per-process temp directory owned by the registry (`work_path`/`close`), created lazily on the first `save()`/`run()` and removed at interpreter exit. Each model's files are named `{model_id}.*`. `run_model` reports the directory and `get_model_files` lists it.
+- `run()` returns `None` on silent CFAST failure (no exception); `run_model` raises `ToolError` in that case.
+- pycfast has no component-removal methods; do not implement `remove_*` tools.
+- Component ids must be unique within their type; duplicates raise `ValueError("Duplicate id ...")`.
+- `face` for wall vents: `FRONT`, `REAR`, `LEFT`, `RIGHT` (not `BACK`).
+- CFAST names (title, material names) should be alphanumeric; `sanitize_cfast_title_and_material` exists in pycfast if needed.
+- `run()` resolves the CFAST binary via the `cfast_exe` parameter, the `CFAST` environment variable, then `cfast` on the PATH. `model.run(timeout=...)` takes seconds.
+
+### Tests
+
+- Unit tests (`test_errors.py`, `test_registry.py`, `test_serialization.py`): pure helpers, no MCP involved.
+- Integration tests (one file per component, e.g. `test_model.py`, `test_compartments.py`, `test_fires.py`, ...): tools called in process through `FastMCP.call_tool` (see `tests/conftest.py`); no CFAST binary needed.
+- End-to-end tests (`test_run.py`): real CFAST run; marked `@pytest.mark.local` and skipped automatically when the binary is unavailable.
+
+Do not retest pycfast's own validation or the mcp library — only the tool layer (argument handling, registry updates, error translation).
+
+## Standards
+
+- Ruff: line-length 88, rules E, W, F, I, B, C4, UP, D (numpy docstrings)
+- MyPy: strict options, Python 3.11 target
+- Tool docstrings are the LLM interface: numpydoc, with units and defaults written as in pycfast ("Default units: m, default value: 0 m"). Reuse pycfast's own parameter descriptions where possible.
+
+## Future scope
+
+Deliberate omissions (kept simple, can be added uniformly later): the vent open/close-criterion machinery (`open_close_criterion`/`time`/`fraction`/`set_point`/`device_id`/`pre_fraction`/`post_fraction`) on all vent types; the DIAG-only device fields (`adiabatic`, `convection_coefficients`); multi-layer compartment materials. Known pycfast limitation: `update_material_params`'s selector parameter is named `material`, which shadows the descriptive-name field, so `update_material` cannot edit the name (only thermophysical props).
+
+Still out of scope: `import_model_from_file`, `list_models`/`delete_model`, MCP Resources and Prompts.

cfast_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Benoît WYGAS.
+
+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.

cfast_mcp-0.1.0/Makefile

@@ -0,0 +1,57 @@
+.PHONY: help
+
+help:
+	@echo "Usage:"
+	@echo "  make install      Install the package with dev dependencies"
+	@echo "  make run          Run the MCP server"
+	@echo "  make test         Run all tests (CFAST-dependent ones skip if no binary)"
+	@echo "  make test-local   Run only the tests requiring the CFAST binary"
+	@echo "  make cov          Run tests with coverage report"
+	@echo "  make check        Lint the code with ruff"
+	@echo "  make format       Format the code with ruff"
+	@echo "  make type         Type check the code with mypy"
+	@echo "  make clean        Clean build artifacts and cache"
+	@echo "  make pre-commit   Run pre-commit hooks"
+	@echo "  make allci        Run all CI steps (check, format, type, test)"
+
+install:
+	uv sync --extra dev
+
+run:
+	uv run cfast-mcp
+
+test:
+	uv run pytest
+
+test-local:
+	uv run pytest -m local
+
+cov:
+	uv run pytest --cov
+
+check:
+	uv run ruff check --fix .
+
+format:
+	uv run ruff format .
+
+type:
+	uv run mypy src/
+
+clean:
+	rm -rf build/
+	rm -rf dist/
+	rm -rf *.egg-info/
+	rm -rf htmlcov/
+	rm -rf .coverage
+	rm -rf .pytest_cache/
+	rm -rf .ruff_cache/
+	rm -rf .mypy_cache/
+	find . -type d -name __pycache__ -exec rm -rf {} +
+	find . -type f -name "*.pyc" -delete
+
+pre-commit:
+	uv run pre-commit run --all-files
+
+allci: check format type cov
+	@echo "All CI steps completed!"