pmcontrols-mcp 0.1.0__tar.gz

pmcontrols_mcp-0.1.0/LICENSE

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

pmcontrols_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: pmcontrols-mcp
+Version: 0.1.0
+Summary: MCP server for pmcontrols: validated project scheduling and earned value tools for AI agents.
+Author: Atakan Arikan
+License: MIT
+Project-URL: Homepage, https://github.com/arikanatakan/pmcontrols-mcp
+Project-URL: Repository, https://github.com/arikanatakan/pmcontrols-mcp
+Project-URL: Issues, https://github.com/arikanatakan/pmcontrols-mcp/issues
+Keywords: mcp,model-context-protocol,ai-agents,project-management,critical-path,cpm,pert,earned-value,earned-schedule,project-controls
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+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 :: Scientific/Engineering
+Classifier: Topic :: Office/Business :: Scheduling
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pmcontrols>=0.1.0
+Requires-Dist: mcp>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
+
+<!-- mcp-name: io.github.arikanatakan/pmcontrols-mcp -->
+
+# pmcontrols-mcp
+
+[![CI](https://github.com/arikanatakan/pmcontrols-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/arikanatakan/pmcontrols-mcp/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/github/license/arikanatakan/pmcontrols-mcp)](LICENSE)
+
+An MCP server that exposes [pmcontrols](https://github.com/arikanatakan/pmcontrols),
+the validated project scheduling and earned value library for Python, as tools
+for AI agents.
+
+Agents asked to plan a project or report its status tend to generate the
+arithmetic themselves: a backward pass done by eye, an earned-value index
+inverted, an earned schedule mistaken for schedule variance. Generated project
+metrics fail silently. The calculation belongs in a deterministic, versioned,
+validated library that the agent calls, which leaves the agent to choose the
+analysis and explain the result.
+
+## Tools
+
+| Tool | Purpose |
+| ---- | ------- |
+| `critical_path` | CPM forward and backward pass: ES, EF, LS, LF, slack, critical path |
+| `schedule_risk` | PERT three-point analysis with a Monte Carlo completion distribution and criticality indices |
+| `crash_schedule` | minimum-cost schedule compression to a deadline, solved as a linear program |
+| `earned_value` | the full EVM indicator set with Lipke earned schedule, against a planned-value baseline |
+| `earned_schedule` | the earned schedule for a given earned value |
+
+Each tool returns the library's structured payload: named statistics, a tidy
+table, structured alerts, and provenance (library version, input hash,
+timestamp).
+
+## Installation
+
+```
+pip install pmcontrols-mcp
+```
+
+Or run it without installing, with [uv](https://docs.astral.sh/uv/):
+
+```
+uvx pmcontrols-mcp
+```
+
+## Configuration
+
+Add the server to your MCP client's configuration:
+
+```json
+{
+  "mcpServers": {
+    "pmcontrols": {
+      "command": "pmcontrols-mcp"
+    }
+  }
+}
+```
+
+The server communicates over stdio and works with any MCP-compatible client.
+
+## Example
+
+Calling `critical_path` with a list of activities returns a structured
+result the agent reads directly, instead of computing the schedule itself:
+
+```json
+{
+  "method": "cpm",
+  "stats": {"project_duration": 15.0, "n_activities": 8.0, "n_critical": 5.0},
+  "meta": {
+    "critical_activities": ["A", "C", "E", "G", "H"],
+    "version": "0.1.0",
+    "input_hash": "sha256:...",
+    "computed_at": "2026-06-15T09:14:02+00:00"
+  },
+  "table": {"activity": ["A", "B", "..."], "slack": [0.0, 1.0, "..."]}
+}
+```
+
+Every result carries provenance (library version, input hash, timestamp), so
+a figure an agent reports can be recomputed and audited later.
+
+## Design
+
+The reasoning behind routing project-control arithmetic through a validated
+tool, rather than letting a model generate it, is set out in
+[Project control is not a language task](https://arikanatakan.github.io/pmcontrols/agents/).
+
+## License
+
+MIT. Written and maintained by [Atakan Arikan](https://github.com/arikanatakan),
+MSc Student at Tsinghua University and Politecnico di Milano.

pmcontrols_mcp-0.1.0/README.md

@@ -0,0 +1,92 @@
+<!-- mcp-name: io.github.arikanatakan/pmcontrols-mcp -->
+
+# pmcontrols-mcp
+
+[![CI](https://github.com/arikanatakan/pmcontrols-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/arikanatakan/pmcontrols-mcp/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/github/license/arikanatakan/pmcontrols-mcp)](LICENSE)
+
+An MCP server that exposes [pmcontrols](https://github.com/arikanatakan/pmcontrols),
+the validated project scheduling and earned value library for Python, as tools
+for AI agents.
+
+Agents asked to plan a project or report its status tend to generate the
+arithmetic themselves: a backward pass done by eye, an earned-value index
+inverted, an earned schedule mistaken for schedule variance. Generated project
+metrics fail silently. The calculation belongs in a deterministic, versioned,
+validated library that the agent calls, which leaves the agent to choose the
+analysis and explain the result.
+
+## Tools
+
+| Tool | Purpose |
+| ---- | ------- |
+| `critical_path` | CPM forward and backward pass: ES, EF, LS, LF, slack, critical path |
+| `schedule_risk` | PERT three-point analysis with a Monte Carlo completion distribution and criticality indices |
+| `crash_schedule` | minimum-cost schedule compression to a deadline, solved as a linear program |
+| `earned_value` | the full EVM indicator set with Lipke earned schedule, against a planned-value baseline |
+| `earned_schedule` | the earned schedule for a given earned value |
+
+Each tool returns the library's structured payload: named statistics, a tidy
+table, structured alerts, and provenance (library version, input hash,
+timestamp).
+
+## Installation
+
+```
+pip install pmcontrols-mcp
+```
+
+Or run it without installing, with [uv](https://docs.astral.sh/uv/):
+
+```
+uvx pmcontrols-mcp
+```
+
+## Configuration
+
+Add the server to your MCP client's configuration:
+
+```json
+{
+  "mcpServers": {
+    "pmcontrols": {
+      "command": "pmcontrols-mcp"
+    }
+  }
+}
+```
+
+The server communicates over stdio and works with any MCP-compatible client.
+
+## Example
+
+Calling `critical_path` with a list of activities returns a structured
+result the agent reads directly, instead of computing the schedule itself:
+
+```json
+{
+  "method": "cpm",
+  "stats": {"project_duration": 15.0, "n_activities": 8.0, "n_critical": 5.0},
+  "meta": {
+    "critical_activities": ["A", "C", "E", "G", "H"],
+    "version": "0.1.0",
+    "input_hash": "sha256:...",
+    "computed_at": "2026-06-15T09:14:02+00:00"
+  },
+  "table": {"activity": ["A", "B", "..."], "slack": [0.0, 1.0, "..."]}
+}
+```
+
+Every result carries provenance (library version, input hash, timestamp), so
+a figure an agent reports can be recomputed and audited later.
+
+## Design
+
+The reasoning behind routing project-control arithmetic through a validated
+tool, rather than letting a model generate it, is set out in
+[Project control is not a language task](https://arikanatakan.github.io/pmcontrols/agents/).
+
+## License
+
+MIT. Written and maintained by [Atakan Arikan](https://github.com/arikanatakan),
+MSc Student at Tsinghua University and Politecnico di Milano.

pmcontrols_mcp-0.1.0/pmcontrols_mcp/__init__.py

@@ -0,0 +1,8 @@
+"""pmcontrols-mcp: project scheduling and earned value tools for AI agents.
+
+A Model Context Protocol server that exposes pmcontrols (critical path,
+PERT, schedule crashing, earned value, earned schedule) as validated tools,
+so an agent calls a checked function instead of doing the math in tokens.
+"""
+
+__version__ = "0.1.0"

pmcontrols_mcp-0.1.0/pmcontrols_mcp/__main__.py

@@ -0,0 +1,4 @@
+from .server import main
+
+if __name__ == "__main__":
+    main()

pmcontrols_mcp-0.1.0/pmcontrols_mcp/_tools.py

@@ -0,0 +1,118 @@
+"""Tool functions and their input schemas, kept free of the MCP SDK so they
+can be tested directly.
+
+Each activity type is a typed model, so the server advertises exactly which
+fields an agent must supply. Each tool calls pmcontrols and returns the
+analysis as a JSON-safe dict (``Result.to_dict()``) with stats, a tidy
+table, structured alerts, and provenance.
+"""
+
+from __future__ import annotations
+
+import pmcontrols as pm
+from pydantic import BaseModel, Field
+
+
+class CpmActivity(BaseModel):
+    """One activity in a deterministic schedule network."""
+
+    id: str = Field(description="Unique activity identifier.")
+    predecessors: list[str] = Field(
+        default_factory=list,
+        description="Ids of the immediate predecessor activities; empty to start.",
+    )
+    duration: float = Field(description="Activity duration in consistent time units.")
+
+
+class PertActivity(BaseModel):
+    """One activity with a three-point (optimistic/likely/pessimistic) estimate."""
+
+    id: str = Field(description="Unique activity identifier.")
+    predecessors: list[str] = Field(
+        default_factory=list,
+        description="Ids of the immediate predecessor activities; empty to start.",
+    )
+    a: float = Field(description="Optimistic duration.")
+    m: float = Field(description="Most likely duration.")
+    b: float = Field(description="Pessimistic duration.")
+
+
+class CrashActivity(BaseModel):
+    """One activity with normal and fully-crashed durations and a crash cost."""
+
+    id: str = Field(description="Unique activity identifier.")
+    predecessors: list[str] = Field(
+        default_factory=list,
+        description="Ids of the immediate predecessor activities; empty to start.",
+    )
+    duration: float = Field(description="Normal duration.")
+    crash_duration: float = Field(description="Fully-crashed (minimum) duration.")
+    crash_cost: float = Field(description="Crash cost per period of compression.")
+
+
+def _as_dicts(items: list) -> list[dict]:
+    """Accept either pydantic models (from the MCP layer) or plain dicts."""
+    return [i if isinstance(i, dict) else i.model_dump() for i in items]
+
+
+def critical_path(activities: list[CpmActivity]) -> dict:
+    """Critical path analysis (CPM) of an activity-on-node network.
+
+    Runs the forward and backward pass and returns earliest/latest start and
+    finish, total slack, and the zero-float critical path.
+    """
+    return pm.cpm(_as_dicts(activities)).to_dict()
+
+
+def schedule_risk(
+    activities: list[PertActivity],
+    n_sim: int = 20000,
+    seed: int | None = 0,
+) -> dict:
+    """PERT three-point analysis with a Monte Carlo schedule-risk simulation.
+
+    Returns the analytic expected duration and standard deviation, the
+    simulated completion distribution (p50/p80/p95), and a per-activity
+    criticality index. Pass ``seed=null`` for a fresh random draw.
+    """
+    return pm.pert(_as_dicts(activities), n_sim=n_sim, seed=seed).to_dict()
+
+
+def crash_schedule(activities: list[CrashActivity], target: float) -> dict:
+    """Minimum-cost schedule compression to a target completion time.
+
+    Returns the globally optimal crash amount per activity, the resulting
+    schedule, and the total crash cost, solved as a linear program rather
+    than by greedy marginal-cost crashing.
+    """
+    return pm.crash(_as_dicts(activities), target=target).to_dict()
+
+
+def earned_value(
+    periods: list[float],
+    pv: list[float],
+    ev: float,
+    ac: float,
+    at: float,
+    thresholds: dict[str, float] | None = None,
+) -> dict:
+    """Earned value status against a time-phased planned-value baseline.
+
+    ``periods`` and ``pv`` define the cumulative planned-value curve. Given
+    earned value ``ev``, actual cost ``ac`` and actual time ``at``, returns
+    the full indicator set (CV, SV, CPI, SPI, the EAC family, TCPI, VAC) plus
+    Lipke's earned schedule (ES, SPI(t), IEAC(t)) and any threshold alerts.
+    """
+    pmb = pm.plan(periods, pv)
+    return pm.evm(pmb, ev=ev, ac=ac, at=at, thresholds=thresholds).to_dict()
+
+
+def earned_schedule(periods: list[float], pv: list[float], ev: float) -> dict:
+    """Lipke earned schedule (ES) for a given earned value.
+
+    ``periods`` and ``pv`` define the cumulative planned-value curve. Returns
+    the time at which the plan had earned what has now been earned, by linear
+    interpolation on the curve.
+    """
+    pmb = pm.plan(periods, pv)
+    return {"es": pm.earned_schedule(pmb, ev)}

pmcontrols_mcp-0.1.0/pmcontrols_mcp/server.py

@@ -0,0 +1,43 @@
+"""The MCP server: registers the pmcontrols tools and runs over stdio.
+
+All tools are pure, read-only computations, marked with annotations so a
+client can present and auto-run them safely.
+"""
+
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+from mcp.types import ToolAnnotations
+
+from . import _tools
+
+mcp = FastMCP("pmcontrols")
+
+
+def _annotations(title: str, idempotent: bool = True) -> ToolAnnotations:
+    return ToolAnnotations(
+        title=title,
+        readOnlyHint=True,
+        idempotentHint=idempotent,
+        openWorldHint=False,
+    )
+
+
+mcp.tool(annotations=_annotations("Critical path (CPM)"))(_tools.critical_path)
+mcp.tool(
+    annotations=_annotations("Schedule risk (PERT + Monte Carlo)", idempotent=False)
+)(_tools.schedule_risk)
+mcp.tool(annotations=_annotations("Schedule crashing (minimum-cost LP)"))(
+    _tools.crash_schedule
+)
+mcp.tool(annotations=_annotations("Earned value status"))(_tools.earned_value)
+mcp.tool(annotations=_annotations("Earned schedule"))(_tools.earned_schedule)
+
+
+def main() -> None:
+    """Console-script entry point: run the server on stdio."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

pmcontrols_mcp-0.1.0/pmcontrols_mcp.egg-info/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: pmcontrols-mcp
+Version: 0.1.0
+Summary: MCP server for pmcontrols: validated project scheduling and earned value tools for AI agents.
+Author: Atakan Arikan
+License: MIT
+Project-URL: Homepage, https://github.com/arikanatakan/pmcontrols-mcp
+Project-URL: Repository, https://github.com/arikanatakan/pmcontrols-mcp
+Project-URL: Issues, https://github.com/arikanatakan/pmcontrols-mcp/issues
+Keywords: mcp,model-context-protocol,ai-agents,project-management,critical-path,cpm,pert,earned-value,earned-schedule,project-controls
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+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 :: Scientific/Engineering
+Classifier: Topic :: Office/Business :: Scheduling
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pmcontrols>=0.1.0
+Requires-Dist: mcp>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
+
+<!-- mcp-name: io.github.arikanatakan/pmcontrols-mcp -->
+
+# pmcontrols-mcp
+
+[![CI](https://github.com/arikanatakan/pmcontrols-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/arikanatakan/pmcontrols-mcp/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/github/license/arikanatakan/pmcontrols-mcp)](LICENSE)
+
+An MCP server that exposes [pmcontrols](https://github.com/arikanatakan/pmcontrols),
+the validated project scheduling and earned value library for Python, as tools
+for AI agents.
+
+Agents asked to plan a project or report its status tend to generate the
+arithmetic themselves: a backward pass done by eye, an earned-value index
+inverted, an earned schedule mistaken for schedule variance. Generated project
+metrics fail silently. The calculation belongs in a deterministic, versioned,
+validated library that the agent calls, which leaves the agent to choose the
+analysis and explain the result.
+
+## Tools
+
+| Tool | Purpose |
+| ---- | ------- |
+| `critical_path` | CPM forward and backward pass: ES, EF, LS, LF, slack, critical path |
+| `schedule_risk` | PERT three-point analysis with a Monte Carlo completion distribution and criticality indices |
+| `crash_schedule` | minimum-cost schedule compression to a deadline, solved as a linear program |
+| `earned_value` | the full EVM indicator set with Lipke earned schedule, against a planned-value baseline |
+| `earned_schedule` | the earned schedule for a given earned value |
+
+Each tool returns the library's structured payload: named statistics, a tidy
+table, structured alerts, and provenance (library version, input hash,
+timestamp).
+
+## Installation
+
+```
+pip install pmcontrols-mcp
+```
+
+Or run it without installing, with [uv](https://docs.astral.sh/uv/):
+
+```
+uvx pmcontrols-mcp
+```
+
+## Configuration
+
+Add the server to your MCP client's configuration:
+
+```json
+{
+  "mcpServers": {
+    "pmcontrols": {
+      "command": "pmcontrols-mcp"
+    }
+  }
+}
+```
+
+The server communicates over stdio and works with any MCP-compatible client.
+
+## Example
+
+Calling `critical_path` with a list of activities returns a structured
+result the agent reads directly, instead of computing the schedule itself:
+
+```json
+{
+  "method": "cpm",
+  "stats": {"project_duration": 15.0, "n_activities": 8.0, "n_critical": 5.0},
+  "meta": {
+    "critical_activities": ["A", "C", "E", "G", "H"],
+    "version": "0.1.0",
+    "input_hash": "sha256:...",
+    "computed_at": "2026-06-15T09:14:02+00:00"
+  },
+  "table": {"activity": ["A", "B", "..."], "slack": [0.0, 1.0, "..."]}
+}
+```
+
+Every result carries provenance (library version, input hash, timestamp), so
+a figure an agent reports can be recomputed and audited later.
+
+## Design
+
+The reasoning behind routing project-control arithmetic through a validated
+tool, rather than letting a model generate it, is set out in
+[Project control is not a language task](https://arikanatakan.github.io/pmcontrols/agents/).
+
+## License
+
+MIT. Written and maintained by [Atakan Arikan](https://github.com/arikanatakan),
+MSc Student at Tsinghua University and Politecnico di Milano.

pmcontrols_mcp-0.1.0/pmcontrols_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+pmcontrols_mcp/__init__.py
+pmcontrols_mcp/__main__.py
+pmcontrols_mcp/_tools.py
+pmcontrols_mcp/server.py
+pmcontrols_mcp.egg-info/PKG-INFO
+pmcontrols_mcp.egg-info/SOURCES.txt
+pmcontrols_mcp.egg-info/dependency_links.txt
+pmcontrols_mcp.egg-info/entry_points.txt
+pmcontrols_mcp.egg-info/requires.txt
+pmcontrols_mcp.egg-info/top_level.txt
+tests/test_tools.py

pmcontrols_mcp-0.1.0/pmcontrols_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pmcontrols_mcp-0.1.0/pmcontrols_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pmcontrols-mcp = pmcontrols_mcp.server:main

pmcontrols_mcp-0.1.0/pmcontrols_mcp.egg-info/requires.txt

@@ -0,0 +1,7 @@
+pmcontrols>=0.1.0
+mcp>=1.0
+
+[dev]
+pytest>=7
+ruff
+build

pmcontrols_mcp-0.1.0/pmcontrols_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+pmcontrols_mcp

pmcontrols_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pmcontrols-mcp"
+version = "0.1.0"
+description = "MCP server for pmcontrols: validated project scheduling and earned value tools for AI agents."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Atakan Arikan" }]
+requires-python = ">=3.10"
+dependencies = ["pmcontrols>=0.1.0", "mcp>=1.0"]
+keywords = [
+    "mcp", "model-context-protocol", "ai-agents", "project-management",
+    "critical-path", "cpm", "pert", "earned-value", "earned-schedule",
+    "project-controls",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Office/Business :: Scheduling",
+]
+
+[project.scripts]
+pmcontrols-mcp = "pmcontrols_mcp.server:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "ruff", "build"]
+
+[project.urls]
+Homepage = "https://github.com/arikanatakan/pmcontrols-mcp"
+Repository = "https://github.com/arikanatakan/pmcontrols-mcp"
+Issues = "https://github.com/arikanatakan/pmcontrols-mcp/issues"
+
+[tool.setuptools.packages.find]
+include = ["pmcontrols_mcp*"]
+
+[tool.ruff]
+line-length = 88
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

pmcontrols_mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pmcontrols_mcp-0.1.0/tests/test_tools.py

@@ -0,0 +1,69 @@
+"""Tests for the tool functions (no MCP client needed).
+
+The numbers are the General Foundry network and a linear PMB, the same
+reference cases pmcontrols itself validates against.
+"""
+
+import pmcontrols_mcp._tools as t
+
+FOUNDRY = [
+    {"id": "A", "predecessors": [], "duration": 2},
+    {"id": "B", "predecessors": [], "duration": 3},
+    {"id": "C", "predecessors": ["A"], "duration": 2},
+    {"id": "D", "predecessors": ["B"], "duration": 4},
+    {"id": "E", "predecessors": ["C"], "duration": 4},
+    {"id": "F", "predecessors": ["C"], "duration": 3},
+    {"id": "G", "predecessors": ["D", "E"], "duration": 5},
+    {"id": "H", "predecessors": ["F", "G"], "duration": 2},
+]
+
+CRASH = [
+    {"id": "A", "predecessors": [], "duration": 2, "crash_duration": 1, "crash_cost": 1000},
+    {"id": "B", "predecessors": [], "duration": 3, "crash_duration": 1, "crash_cost": 2000},
+    {"id": "C", "predecessors": ["A"], "duration": 2, "crash_duration": 1, "crash_cost": 1000},
+    {"id": "D", "predecessors": ["B"], "duration": 4, "crash_duration": 3, "crash_cost": 1000},
+    {"id": "E", "predecessors": ["C"], "duration": 4, "crash_duration": 2, "crash_cost": 1000},
+    {"id": "F", "predecessors": ["C"], "duration": 3, "crash_duration": 2, "crash_cost": 500},
+    {"id": "G", "predecessors": ["D", "E"], "duration": 5, "crash_duration": 2, "crash_cost": 2000},
+    {"id": "H", "predecessors": ["F", "G"], "duration": 2, "crash_duration": 1, "crash_cost": 3000},
+]
+
+PERIODS = list(range(11))
+PV = [i * 10000 for i in PERIODS]
+
+
+def test_critical_path():
+    d = t.critical_path(FOUNDRY)
+    assert d["method"] == "cpm"
+    assert d["stats"]["project_duration"] == 15.0
+    assert d["meta"]["critical_activities"] == ["A", "C", "E", "G", "H"]
+
+
+def test_schedule_risk():
+    tp = [
+        {"id": a["id"], "predecessors": a["predecessors"],
+         "a": a["duration"] * 0.8, "m": a["duration"], "b": a["duration"] * 1.3}
+        for a in FOUNDRY
+    ]
+    d = t.schedule_risk(tp, n_sim=2000, seed=1)
+    assert d["method"] == "pert"
+    assert "mc_p80" in d["stats"]
+    assert "criticality_index" in d["table"]
+
+
+def test_crash_schedule():
+    d = t.crash_schedule(CRASH, target=13)
+    assert d["method"] == "crash"
+    assert d["stats"]["total_crash_cost"] == 3000.0
+
+
+def test_earned_value():
+    d = t.earned_value(PERIODS, PV, ev=30000, ac=35000, at=4)
+    assert d["method"] == "evm"
+    assert round(d["stats"]["cpi"], 4) == 0.8571
+    assert {a["indicator"] for a in d["alerts"]} == {"cpi", "spi_t"}
+
+
+def test_earned_schedule():
+    d = t.earned_schedule(PERIODS, PV, ev=34000)
+    assert d["es"] == 3.4