plainfile-project-check 0.1.0__tar.gz

plainfile_project_check-0.1.0/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2026 Plainfile Tools 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.
+
+This license grants lawful personal and commercial use. It does not promise
+exclusive ownership of algorithms or AI-generated material, continuing
+maintenance, custom development, or fitness for a particular migration.

plainfile_project_check-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE README.md
+recursive-include examples *.json *.csv
+recursive-include tests *.py

plainfile_project_check-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: plainfile-project-check
+Version: 0.1.0
+Summary: Offline stable-ID reconciliation for normalized project and task exports
+Author-email: Plainfile Tools <plainfiletools@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Plainfile Tools 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.
+        
+        This license grants lawful personal and commercial use. It does not promise
+        exclusive ownership of algorithms or AI-generated material, continuing
+        maintenance, custom development, or fitness for a particular migration.
+        
+Keywords: csv,json,migration,reconciliation,data-quality
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Plainfile Project Check
+
+Plainfile Project Check is a free, open-source, dependency-free Python tool for comparing before-and-after project exports by stable ID. It runs locally, reads only the files you name, and emits a deterministic JSON report. It sends no data, performs no network requests, and includes no telemetry or runtime advertising.
+
+It checks missing and unexpected project/task IDs, duplicate IDs in either snapshot, tasks whose project is absent, task-to-project reassignments, and exact-decimal `work_minutes` changes. A clean result exits `0`, differences exit `1`, and invalid input or a refused output exits `2`.
+
+Requires Python 3.10 or newer.
+
+## Install an offline wheel
+
+From the directory containing the downloaded wheel, install the supplied file without relying on package-registry availability, contacting an index, or resolving dependencies:
+
+```console
+python -m pip install --no-index --no-deps plainfile_project_check-0.1.0-py3-none-any.whl
+```
+
+To run directly from a source checkout without installing, set `PYTHONPATH` to the `src` directory, then use the module command:
+
+```powershell
+$env:PYTHONPATH = "src"
+python -m plainfile_project_check examples/before.json examples/after-clean.json
+```
+
+## Quick start with JSON
+
+The normalized JSON format is exactly:
+
+```json
+{
+  "projects": [{"id": "P-001", "name": "Plan"}],
+  "tasks": [{"id": "T-001", "project_id": "P-001", "name": "Task", "work_minutes": "60.50"}]
+}
+```
+
+From an installed package:
+
+```console
+plainfile-project-check before.json after.json --output report.json
+```
+
+The module form is equivalent:
+
+```console
+python -m plainfile_project_check before.json after.json
+```
+
+Omit `--output` to print the report to standard output. An output path must be new. The tool refuses to overwrite an existing output or either input.
+
+## CSV adapter
+
+For each snapshot, create one directory containing these two UTF-8 CSV files with exactly these header names and order:
+
+`projects.csv`
+
+```csv
+id,name
+P-001,"Plan, phase one"
+```
+
+`tasks.csv`
+
+```csv
+id,project_id,name,work_minutes
+T-001,P-001,"Review, exact totals",60.50
+```
+
+Then run:
+
+```console
+plainfile-project-check before-dir after-dir --format csv --output report.json
+```
+
+Ready-to-run synthetic directories are included:
+
+```console
+plainfile-project-check examples/csv-before examples/csv-after-corrupted --format csv
+```
+
+CSV values remain text, so IDs such as `0007` keep their leading zeros. The adapter uses ordinary comma-delimited CSV with double-quoted fields. It rejects missing, reordered, extra, or duplicate columns, malformed rows, invalid UTF-8, and invalid decimal work values.
+
+Each input file is limited to 10 MB. IDs, names, and task project IDs must be non-empty strings. Work minutes must be finite, non-negative exact decimal text or a JSON integer, with at most 50 digits and a decimal exponent from -12 through 12. JSON duplicate object keys are rejected.
+
+## Scope and limitations
+
+This tool accepts only user-supplied normalized JSON or the documented two-file CSV shape. It has no native Project Online, Microsoft Project, OData, XML, API, authentication, or extraction support. Exporting and mapping source-system data is your responsibility.
+
+Names are validated but not compared. Tasks with duplicate IDs are reported and excluded from task reassignment and work comparison because identity is ambiguous. Duplicate project IDs are reported but do not suppress task comparisons. The report does not understand scheduling dependencies, calendars, resources, assignments, costs, custom fields, or fields omitted from the snapshots. A clean report does not certify a migration, prove data completeness, or establish legal authority to use the data. Keep source backups and review the report before changing another system.
+
+The package code, documentation, examples, and tests were produced with substantial AI assistance under owner direction. All fixtures are original synthetic data; they contain no client data and demonstrate no client results. The package does not promise automatic updates, custom maintenance, or support.
+
+The MIT license permits personal and commercial use, modification, and redistribution with its notice. It does not claim exclusive human authorship or exclusive ownership of general algorithms or AI-generated material.
+
+If you need a separate pre-import CSV cleanup utility, Plainfile Tools sells [CSV Import Check for $19](https://plainfiletools.gumroad.com/l/csv-import-check?utm_source=pypi&utm_medium=package&utm_campaign=project_check_v010). It is a distinct product, is not required for this package, and does not unlock features here.
+
+Contact: plainfiletools@gmail.com
+
+## Development
+
+```console
+python -m unittest discover -s tests -v
+python -m build --no-isolation
+```

plainfile_project_check-0.1.0/README.md

@@ -0,0 +1,102 @@
+# Plainfile Project Check
+
+Plainfile Project Check is a free, open-source, dependency-free Python tool for comparing before-and-after project exports by stable ID. It runs locally, reads only the files you name, and emits a deterministic JSON report. It sends no data, performs no network requests, and includes no telemetry or runtime advertising.
+
+It checks missing and unexpected project/task IDs, duplicate IDs in either snapshot, tasks whose project is absent, task-to-project reassignments, and exact-decimal `work_minutes` changes. A clean result exits `0`, differences exit `1`, and invalid input or a refused output exits `2`.
+
+Requires Python 3.10 or newer.
+
+## Install an offline wheel
+
+From the directory containing the downloaded wheel, install the supplied file without relying on package-registry availability, contacting an index, or resolving dependencies:
+
+```console
+python -m pip install --no-index --no-deps plainfile_project_check-0.1.0-py3-none-any.whl
+```
+
+To run directly from a source checkout without installing, set `PYTHONPATH` to the `src` directory, then use the module command:
+
+```powershell
+$env:PYTHONPATH = "src"
+python -m plainfile_project_check examples/before.json examples/after-clean.json
+```
+
+## Quick start with JSON
+
+The normalized JSON format is exactly:
+
+```json
+{
+  "projects": [{"id": "P-001", "name": "Plan"}],
+  "tasks": [{"id": "T-001", "project_id": "P-001", "name": "Task", "work_minutes": "60.50"}]
+}
+```
+
+From an installed package:
+
+```console
+plainfile-project-check before.json after.json --output report.json
+```
+
+The module form is equivalent:
+
+```console
+python -m plainfile_project_check before.json after.json
+```
+
+Omit `--output` to print the report to standard output. An output path must be new. The tool refuses to overwrite an existing output or either input.
+
+## CSV adapter
+
+For each snapshot, create one directory containing these two UTF-8 CSV files with exactly these header names and order:
+
+`projects.csv`
+
+```csv
+id,name
+P-001,"Plan, phase one"
+```
+
+`tasks.csv`
+
+```csv
+id,project_id,name,work_minutes
+T-001,P-001,"Review, exact totals",60.50
+```
+
+Then run:
+
+```console
+plainfile-project-check before-dir after-dir --format csv --output report.json
+```
+
+Ready-to-run synthetic directories are included:
+
+```console
+plainfile-project-check examples/csv-before examples/csv-after-corrupted --format csv
+```
+
+CSV values remain text, so IDs such as `0007` keep their leading zeros. The adapter uses ordinary comma-delimited CSV with double-quoted fields. It rejects missing, reordered, extra, or duplicate columns, malformed rows, invalid UTF-8, and invalid decimal work values.
+
+Each input file is limited to 10 MB. IDs, names, and task project IDs must be non-empty strings. Work minutes must be finite, non-negative exact decimal text or a JSON integer, with at most 50 digits and a decimal exponent from -12 through 12. JSON duplicate object keys are rejected.
+
+## Scope and limitations
+
+This tool accepts only user-supplied normalized JSON or the documented two-file CSV shape. It has no native Project Online, Microsoft Project, OData, XML, API, authentication, or extraction support. Exporting and mapping source-system data is your responsibility.
+
+Names are validated but not compared. Tasks with duplicate IDs are reported and excluded from task reassignment and work comparison because identity is ambiguous. Duplicate project IDs are reported but do not suppress task comparisons. The report does not understand scheduling dependencies, calendars, resources, assignments, costs, custom fields, or fields omitted from the snapshots. A clean report does not certify a migration, prove data completeness, or establish legal authority to use the data. Keep source backups and review the report before changing another system.
+
+The package code, documentation, examples, and tests were produced with substantial AI assistance under owner direction. All fixtures are original synthetic data; they contain no client data and demonstrate no client results. The package does not promise automatic updates, custom maintenance, or support.
+
+The MIT license permits personal and commercial use, modification, and redistribution with its notice. It does not claim exclusive human authorship or exclusive ownership of general algorithms or AI-generated material.
+
+If you need a separate pre-import CSV cleanup utility, Plainfile Tools sells [CSV Import Check for $19](https://plainfiletools.gumroad.com/l/csv-import-check?utm_source=pypi&utm_medium=package&utm_campaign=project_check_v010). It is a distinct product, is not required for this package, and does not unlock features here.
+
+Contact: plainfiletools@gmail.com
+
+## Development
+
+```console
+python -m unittest discover -s tests -v
+python -m build --no-isolation
+```

plainfile_project_check-0.1.0/examples/after-clean.json

@@ -0,0 +1,11 @@
+{
+  "projects": [
+    {"id": "P-100", "name": "Website rollout"},
+    {"id": "P-200", "name": "Warehouse refresh"}
+  ],
+  "tasks": [
+    {"id": "T-101", "project_id": "P-100", "name": "Discovery", "work_minutes": "480"},
+    {"id": "T-102", "project_id": "P-100", "name": "Build", "work_minutes": "1200.50"},
+    {"id": "T-201", "project_id": "P-200", "name": "Inventory", "work_minutes": "300"}
+  ]
+}

plainfile_project_check-0.1.0/examples/after-corrupted.json

@@ -0,0 +1,13 @@
+{
+  "projects": [
+    {"id": "P-100", "name": "Website rollout"},
+    {"id": "P-300", "name": "Unexpected project"},
+    {"id": "P-300", "name": "Duplicate project"}
+  ],
+  "tasks": [
+    {"id": "T-101", "project_id": "P-300", "name": "Discovery", "work_minutes": "510"},
+    {"id": "T-102", "project_id": "P-999", "name": "Build", "work_minutes": "1200.50"},
+    {"id": "T-NEW", "project_id": "P-100", "name": "Unexpected task", "work_minutes": "15"},
+    {"id": "T-NEW", "project_id": "P-100", "name": "Duplicate task", "work_minutes": "15"}
+  ]
+}

plainfile_project_check-0.1.0/examples/before.json

@@ -0,0 +1,11 @@
+{
+  "projects": [
+    {"id": "P-100", "name": "Website rollout"},
+    {"id": "P-200", "name": "Warehouse refresh"}
+  ],
+  "tasks": [
+    {"id": "T-101", "project_id": "P-100", "name": "Discovery", "work_minutes": "480"},
+    {"id": "T-102", "project_id": "P-100", "name": "Build", "work_minutes": "1200.50"},
+    {"id": "T-201", "project_id": "P-200", "name": "Inventory", "work_minutes": "300"}
+  ]
+}

plainfile_project_check-0.1.0/examples/csv-after-corrupted/projects.csv

@@ -0,0 +1,4 @@
+id,name
+P-001,"Website, phase one"
+P-003,Unexpected project
+P-003,Duplicate project

plainfile_project_check-0.1.0/examples/csv-after-corrupted/tasks.csv

@@ -0,0 +1,5 @@
+id,project_id,name,work_minutes
+000101,P-003,Discovery,510
+000102,P-999,"Build, review",1200.50
+000999,P-001,Unexpected task,15
+000999,P-001,Duplicate task,15

plainfile_project_check-0.1.0/examples/csv-before/projects.csv

@@ -0,0 +1,3 @@
+id,name
+P-001,"Website, phase one"
+P-002,Warehouse refresh

plainfile_project_check-0.1.0/examples/csv-before/tasks.csv

@@ -0,0 +1,4 @@
+id,project_id,name,work_minutes
+000101,P-001,Discovery,480
+000102,P-001,"Build, review",1200.50
+000201,P-002,Inventory,300

plainfile_project_check-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "plainfile-project-check"
+version = "0.1.0"
+description = "Offline stable-ID reconciliation for normalized project and task exports"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { file = "LICENSE" }
+authors = [{ name = "Plainfile Tools", email = "plainfiletools@gmail.com" }]
+keywords = ["csv", "json", "migration", "reconciliation", "data-quality"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Utilities",
+]
+
+[project.scripts]
+plainfile-project-check = "plainfile_project_check.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+plainfile_project_check = ["py.typed"]

plainfile_project_check-0.1.0/setup.cfg

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

plainfile_project_check-0.1.0/src/plainfile_project_check/__init__.py

@@ -0,0 +1,6 @@
+"""Plainfile Project Check public API."""
+
+from .core import InputError, load_export, reconcile
+
+__all__ = ["InputError", "load_export", "reconcile"]
+__version__ = "0.1.0"

plainfile_project_check-0.1.0/src/plainfile_project_check/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

plainfile_project_check-0.1.0/src/plainfile_project_check/cli.py

@@ -0,0 +1,64 @@
+"""Command-line interface for Plainfile Project Check."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from .core import InputError, load_export, reconcile
+from .csv_adapter import load_csv_export
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="plainfile-project-check",
+        description="Compare two normalized project/task snapshots offline by stable ID.")
+    parser.add_argument("before", type=Path, help="JSON file, or CSV directory with --format csv")
+    parser.add_argument("after", type=Path, help="JSON file, or CSV directory with --format csv")
+    parser.add_argument("--format", choices=("json", "csv"), default="json")
+    parser.add_argument("--output", type=Path, help="new report file; stdout when omitted")
+    return parser
+
+
+def _same_path(left: Path, right: Path) -> bool:
+    try:
+        return left.resolve(strict=False) == right.resolve(strict=False)
+    except OSError:
+        return left.absolute() == right.absolute()
+
+
+def _write_new(path: Path, text: str, inputs: list[Path]) -> None:
+    if any(_same_path(path, item) for item in inputs):
+        raise InputError(f"refusing to overwrite an input: {path}")
+    try:
+        with path.open("x", encoding="utf-8", newline="\n") as handle:
+            handle.write(text)
+    except FileExistsError as exc:
+        raise InputError(f"refusing to overwrite existing output: {path}") from exc
+    except OSError as exc:
+        raise InputError(f"cannot create output {path}: {exc}") from exc
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        loader = load_export if args.format == "json" else load_csv_export
+        before = loader(args.before)
+        after = loader(args.after)
+        report = reconcile(before, after)
+        # ASCII escapes keep stdout portable on Windows consoles with legacy encodings.
+        rendered = json.dumps(report, indent=2, sort_keys=True, ensure_ascii=True) + "\n"
+        if args.output:
+            input_files = ([args.before, args.after] if args.format == "json" else
+                           [args.before / "projects.csv", args.before / "tasks.csv",
+                            args.after / "projects.csv", args.after / "tasks.csv"])
+            _write_new(args.output, rendered, input_files)
+        else:
+            sys.stdout.write(rendered)
+        return 0 if report["status"] == "clean" else 1
+    except InputError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2

plainfile_project_check-0.1.0/src/plainfile_project_check/core.py

@@ -0,0 +1,173 @@
+"""Offline reconciliation for normalized project/task snapshots."""
+
+from __future__ import annotations
+
+from collections import Counter
+from decimal import Decimal, InvalidOperation, localcontext
+import json
+from pathlib import Path
+from typing import Any
+
+MAX_BYTES = 10 * 1024 * 1024
+
+
+class InputError(ValueError):
+    """An input is unreadable or does not match the documented schema."""
+
+
+def _reject_constant(value: str) -> None:
+    raise InputError(f"non-finite JSON number is not allowed: {value}")
+
+
+def _object(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in result:
+            raise InputError(f"duplicate JSON object key is not allowed: {key}")
+        result[key] = value
+    return result
+
+
+def check_input_file(path: Path) -> None:
+    try:
+        size = path.stat().st_size
+    except OSError as exc:
+        raise InputError(f"cannot access {path}: {exc}") from exc
+    if not path.is_file():
+        raise InputError(f"input is not a regular file: {path}")
+    if size > MAX_BYTES:
+        raise InputError(f"input exceeds the 10 MB limit: {path}")
+
+
+def load_export(path: Path) -> dict[str, list[dict[str, Any]]]:
+    check_input_file(path)
+    try:
+        with path.open("r", encoding="utf-8-sig") as handle:
+            value = json.load(handle, parse_float=Decimal, parse_int=Decimal,
+                              parse_constant=_reject_constant, object_pairs_hook=_object)
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise InputError(f"cannot read {path}: {exc}") from exc
+    validate_export(value, str(path))
+    return value
+
+
+def _string(record: dict[str, Any], field: str, where: str) -> str:
+    value = record.get(field)
+    if not isinstance(value, str) or not value.strip():
+        raise InputError(f"{where}.{field} must be a non-empty string")
+    return value
+
+
+def parse_work(value: Any, where: str) -> Decimal:
+    if isinstance(value, bool) or not isinstance(value, (str, int, Decimal)):
+        raise InputError(f"{where}.work_minutes must be an integer or decimal string")
+    try:
+        amount = Decimal(str(value))
+    except InvalidOperation as exc:
+        raise InputError(f"{where}.work_minutes is not a decimal") from exc
+    if not amount.is_finite() or amount < 0:
+        raise InputError(f"{where}.work_minutes must be finite and non-negative")
+    digits, exponent = len(amount.as_tuple().digits), amount.as_tuple().exponent
+    if digits > 50 or exponent < -12 or exponent > 12:
+        raise InputError(f"{where}.work_minutes exceeds 50 digits or exponent range -12..12")
+    return amount
+
+
+def validate_export(value: Any, label: str = "export") -> None:
+    if not isinstance(value, dict) or set(value) != {"projects", "tasks"}:
+        raise InputError(f"{label} must contain exactly 'projects' and 'tasks' arrays")
+    for collection in ("projects", "tasks"):
+        records = value[collection]
+        if not isinstance(records, list):
+            raise InputError(f"{label}.{collection} must be an array")
+        expected = ({"id", "name"} if collection == "projects" else
+                    {"id", "project_id", "name", "work_minutes"})
+        for index, record in enumerate(records):
+            where = f"{label}.{collection}[{index}]"
+            if not isinstance(record, dict) or set(record) != expected:
+                raise InputError(f"{where} must contain exactly {sorted(expected)}")
+            _string(record, "id", where)
+            _string(record, "name", where)
+            if collection == "tasks":
+                _string(record, "project_id", where)
+                parse_work(record["work_minutes"], where)
+
+
+def _duplicates(records: list[dict[str, Any]]) -> list[str]:
+    counts = Counter(record["id"] for record in records)
+    return sorted(key for key, count in counts.items() if count > 1)
+
+
+def _unique(records: list[dict[str, Any]]) -> dict[str, dict[str, Any]]:
+    counts = Counter(record["id"] for record in records)
+    return {record["id"]: record for record in records if counts[record["id"]] == 1}
+
+
+def _decimal_text(value: Decimal) -> str:
+    text = format(value, "f")
+    return text.rstrip("0").rstrip(".") if "." in text else text
+
+
+def reconcile(before: dict[str, Any], after: dict[str, Any]) -> dict[str, Any]:
+    validate_export(before, "before")
+    validate_export(after, "after")
+    before_tasks, after_tasks = _unique(before["tasks"]), _unique(after["tasks"])
+    before_projects = {row["id"] for row in before["projects"]}
+    after_projects = {row["id"] for row in after["projects"]}
+    before_task_ids = {row["id"] for row in before["tasks"]}
+    after_task_ids = {row["id"] for row in after["tasks"]}
+    common = sorted(set(before_tasks) & set(after_tasks))
+    deltas: list[dict[str, str]] = []
+    with localcontext() as context:
+        context.prec = 128
+        for task_id in common:
+            old = parse_work(before_tasks[task_id]["work_minutes"], "before task")
+            new = parse_work(after_tasks[task_id]["work_minutes"], "after task")
+            if old != new:
+                deltas.append({"task_id": task_id, "before": _decimal_text(old),
+                               "after": _decimal_text(new), "delta": _decimal_text(new - old)})
+    findings: dict[str, Any] = {
+        "duplicate_project_ids": {"before": _duplicates(before["projects"]),
+                                  "after": _duplicates(after["projects"])},
+        "duplicate_task_ids": {"before": _duplicates(before["tasks"]),
+                               "after": _duplicates(after["tasks"])},
+        "missing_project_ids": sorted(before_projects - after_projects),
+        "unexpected_project_ids": sorted(after_projects - before_projects),
+        "missing_task_ids": sorted(before_task_ids - after_task_ids),
+        "unexpected_task_ids": sorted(after_task_ids - before_task_ids),
+        "orphan_tasks": {
+            "before": sorted(row["id"] for row in before["tasks"]
+                             if row["project_id"] not in before_projects),
+            "after": sorted(row["id"] for row in after["tasks"]
+                            if row["project_id"] not in after_projects),
+        },
+        "task_project_reassignments": [
+            {"task_id": task_id,
+             "before_project_id": before_tasks[task_id]["project_id"],
+             "after_project_id": after_tasks[task_id]["project_id"]}
+            for task_id in common
+            if before_tasks[task_id]["project_id"] != after_tasks[task_id]["project_id"]
+        ],
+        "work_minutes_deltas": deltas,
+    }
+    count = sum(_count(value) for value in findings.values())
+    return {
+        "status": "clean" if count == 0 else "differences_found",
+        "counts": {"before_projects": len(before["projects"]),
+                   "after_projects": len(after["projects"]),
+                   "before_tasks": len(before["tasks"]),
+                   "after_tasks": len(after["tasks"]), "findings": count},
+        "findings": findings,
+        "limitations": [
+            "Compares only the supplied normalized fields and snapshots.",
+            "No native Project Online, Microsoft Project, OData, XML, API, or extraction support.",
+            "Names are validated but not compared; duplicate task IDs skip field-level comparison.",
+            "A clean result does not certify a migration or detect omitted data.",
+        ],
+    }
+
+
+def _count(value: Any) -> int:
+    if isinstance(value, dict):
+        return sum(_count(item) for item in value.values())
+    return len(value)

plainfile_project_check-0.1.0/src/plainfile_project_check/csv_adapter.py

@@ -0,0 +1,49 @@
+"""Strict CSV adapter that preserves every cell as text."""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+from typing import Any
+
+from .core import InputError, check_input_file, parse_work, validate_export
+
+HEADERS = {
+    "projects": ["id", "name"],
+    "tasks": ["id", "project_id", "name", "work_minutes"],
+}
+
+
+def _read(path: Path, kind: str) -> list[dict[str, str]]:
+    check_input_file(path)
+    try:
+        with path.open("r", encoding="utf-8-sig", newline="") as handle:
+            reader = csv.reader(handle, strict=True)
+            try:
+                header = next(reader)
+            except StopIteration as exc:
+                raise InputError(f"{path} is empty") from exc
+            if len(header) != len(set(header)):
+                raise InputError(f"{path} has duplicate column names")
+            if header != HEADERS[kind]:
+                raise InputError(f"{path} headers must be exactly {','.join(HEADERS[kind])}")
+            rows: list[dict[str, str]] = []
+            for number, values in enumerate(reader, 2):
+                if len(values) != len(header):
+                    raise InputError(f"{path} row {number} has {len(values)} fields; expected {len(header)}")
+                row = dict(zip(header, values))
+                if kind == "tasks":
+                    parse_work(row["work_minutes"], f"{path} row {number}")
+                rows.append(row)
+            return rows
+    except (OSError, UnicodeError, csv.Error) as exc:
+        raise InputError(f"cannot read {path}: {exc}") from exc
+
+
+def load_csv_export(directory: Path) -> dict[str, list[dict[str, Any]]]:
+    if not directory.is_dir():
+        raise InputError(f"CSV input must be a directory: {directory}")
+    value = {"projects": _read(directory / "projects.csv", "projects"),
+             "tasks": _read(directory / "tasks.csv", "tasks")}
+    validate_export(value, str(directory))
+    return value

plainfile_project_check-0.1.0/src/plainfile_project_check/py.typed

@@ -0,0 +1 @@
+

plainfile_project_check-0.1.0/src/plainfile_project_check.egg-info/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: plainfile-project-check
+Version: 0.1.0
+Summary: Offline stable-ID reconciliation for normalized project and task exports
+Author-email: Plainfile Tools <plainfiletools@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Plainfile Tools 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.
+        
+        This license grants lawful personal and commercial use. It does not promise
+        exclusive ownership of algorithms or AI-generated material, continuing
+        maintenance, custom development, or fitness for a particular migration.
+        
+Keywords: csv,json,migration,reconciliation,data-quality
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Plainfile Project Check
+
+Plainfile Project Check is a free, open-source, dependency-free Python tool for comparing before-and-after project exports by stable ID. It runs locally, reads only the files you name, and emits a deterministic JSON report. It sends no data, performs no network requests, and includes no telemetry or runtime advertising.
+
+It checks missing and unexpected project/task IDs, duplicate IDs in either snapshot, tasks whose project is absent, task-to-project reassignments, and exact-decimal `work_minutes` changes. A clean result exits `0`, differences exit `1`, and invalid input or a refused output exits `2`.
+
+Requires Python 3.10 or newer.
+
+## Install an offline wheel
+
+From the directory containing the downloaded wheel, install the supplied file without relying on package-registry availability, contacting an index, or resolving dependencies:
+
+```console
+python -m pip install --no-index --no-deps plainfile_project_check-0.1.0-py3-none-any.whl
+```
+
+To run directly from a source checkout without installing, set `PYTHONPATH` to the `src` directory, then use the module command:
+
+```powershell
+$env:PYTHONPATH = "src"
+python -m plainfile_project_check examples/before.json examples/after-clean.json
+```
+
+## Quick start with JSON
+
+The normalized JSON format is exactly:
+
+```json
+{
+  "projects": [{"id": "P-001", "name": "Plan"}],
+  "tasks": [{"id": "T-001", "project_id": "P-001", "name": "Task", "work_minutes": "60.50"}]
+}
+```
+
+From an installed package:
+
+```console
+plainfile-project-check before.json after.json --output report.json
+```
+
+The module form is equivalent:
+
+```console
+python -m plainfile_project_check before.json after.json
+```
+
+Omit `--output` to print the report to standard output. An output path must be new. The tool refuses to overwrite an existing output or either input.
+
+## CSV adapter
+
+For each snapshot, create one directory containing these two UTF-8 CSV files with exactly these header names and order:
+
+`projects.csv`
+
+```csv
+id,name
+P-001,"Plan, phase one"
+```
+
+`tasks.csv`
+
+```csv
+id,project_id,name,work_minutes
+T-001,P-001,"Review, exact totals",60.50
+```
+
+Then run:
+
+```console
+plainfile-project-check before-dir after-dir --format csv --output report.json
+```
+
+Ready-to-run synthetic directories are included:
+
+```console
+plainfile-project-check examples/csv-before examples/csv-after-corrupted --format csv
+```
+
+CSV values remain text, so IDs such as `0007` keep their leading zeros. The adapter uses ordinary comma-delimited CSV with double-quoted fields. It rejects missing, reordered, extra, or duplicate columns, malformed rows, invalid UTF-8, and invalid decimal work values.
+
+Each input file is limited to 10 MB. IDs, names, and task project IDs must be non-empty strings. Work minutes must be finite, non-negative exact decimal text or a JSON integer, with at most 50 digits and a decimal exponent from -12 through 12. JSON duplicate object keys are rejected.
+
+## Scope and limitations
+
+This tool accepts only user-supplied normalized JSON or the documented two-file CSV shape. It has no native Project Online, Microsoft Project, OData, XML, API, authentication, or extraction support. Exporting and mapping source-system data is your responsibility.
+
+Names are validated but not compared. Tasks with duplicate IDs are reported and excluded from task reassignment and work comparison because identity is ambiguous. Duplicate project IDs are reported but do not suppress task comparisons. The report does not understand scheduling dependencies, calendars, resources, assignments, costs, custom fields, or fields omitted from the snapshots. A clean report does not certify a migration, prove data completeness, or establish legal authority to use the data. Keep source backups and review the report before changing another system.
+
+The package code, documentation, examples, and tests were produced with substantial AI assistance under owner direction. All fixtures are original synthetic data; they contain no client data and demonstrate no client results. The package does not promise automatic updates, custom maintenance, or support.
+
+The MIT license permits personal and commercial use, modification, and redistribution with its notice. It does not claim exclusive human authorship or exclusive ownership of general algorithms or AI-generated material.
+
+If you need a separate pre-import CSV cleanup utility, Plainfile Tools sells [CSV Import Check for $19](https://plainfiletools.gumroad.com/l/csv-import-check?utm_source=pypi&utm_medium=package&utm_campaign=project_check_v010). It is a distinct product, is not required for this package, and does not unlock features here.
+
+Contact: plainfiletools@gmail.com
+
+## Development
+
+```console
+python -m unittest discover -s tests -v
+python -m build --no-isolation
+```

plainfile_project_check-0.1.0/src/plainfile_project_check.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+examples/after-clean.json
+examples/after-corrupted.json
+examples/before.json
+examples/csv-after-corrupted/projects.csv
+examples/csv-after-corrupted/tasks.csv
+examples/csv-before/projects.csv
+examples/csv-before/tasks.csv
+src/plainfile_project_check/__init__.py
+src/plainfile_project_check/__main__.py
+src/plainfile_project_check/cli.py
+src/plainfile_project_check/core.py
+src/plainfile_project_check/csv_adapter.py
+src/plainfile_project_check/py.typed
+src/plainfile_project_check.egg-info/PKG-INFO
+src/plainfile_project_check.egg-info/SOURCES.txt
+src/plainfile_project_check.egg-info/dependency_links.txt
+src/plainfile_project_check.egg-info/entry_points.txt
+src/plainfile_project_check.egg-info/top_level.txt
+tests/test_project_check.py

plainfile_project_check-0.1.0/src/plainfile_project_check.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

plainfile_project_check-0.1.0/src/plainfile_project_check.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+plainfile-project-check = plainfile_project_check.cli:main

plainfile_project_check-0.1.0/src/plainfile_project_check.egg-info/top_level.txt

@@ -0,0 +1 @@
+plainfile_project_check

plainfile_project_check-0.1.0/tests/test_project_check.py

@@ -0,0 +1,127 @@
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+from tempfile import TemporaryDirectory
+import unittest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from plainfile_project_check.cli import main
+from plainfile_project_check.core import InputError, load_export, reconcile
+from plainfile_project_check.csv_adapter import load_csv_export
+
+
+def snapshot(projects=None, tasks=None):
+    return {
+        "projects": projects if projects is not None else [{"id": "P-001", "name": "Plan"}],
+        "tasks": tasks if tasks is not None else [
+            {"id": "T-001", "project_id": "P-001", "name": "Work", "work_minutes": "60.00"}
+        ],
+    }
+
+
+class EngineTests(unittest.TestCase):
+    def test_clean_and_corrupted_synthetic_fixtures(self):
+        root = Path(__file__).resolve().parents[1] / "examples"
+        before = load_export(root / "before.json")
+        self.assertEqual("clean", reconcile(before, load_export(root / "after-clean.json"))["status"])
+        report = reconcile(before, load_export(root / "after-corrupted.json"))
+        self.assertEqual("differences_found", report["status"])
+        self.assertEqual(["P-200"], report["findings"]["missing_project_ids"])
+        self.assertEqual(["P-300"], report["findings"]["duplicate_project_ids"]["after"])
+        self.assertEqual(["T-102"], report["findings"]["orphan_tasks"]["after"])
+        self.assertEqual("30", report["findings"]["work_minutes_deltas"][0]["delta"])
+
+    def test_exact_decimal_and_reassignment(self):
+        projects = [{"id": "P-001", "name": "One"}, {"id": "P-002", "name": "Two"}]
+        before = snapshot(projects, [{"id": "T", "project_id": "P-001", "name": "x",
+                                      "work_minutes": "0.100000000001"}])
+        after = snapshot(projects, [{"id": "T", "project_id": "P-002", "name": "x",
+                                     "work_minutes": "0.100000000002"}])
+        findings = reconcile(before, after)["findings"]
+        self.assertEqual("0.000000000001", findings["work_minutes_deltas"][0]["delta"])
+        self.assertEqual("P-002", findings["task_project_reassignments"][0]["after_project_id"])
+
+
+class CsvAdapterTests(unittest.TestCase):
+    def _pair(self, root, project_header="id,name", task_header="id,project_id,name,work_minutes",
+              project_row='0007,"Quoted, project"', task_row='0009,0007,"Quoted, task",1.25'):
+        root.mkdir()
+        (root / "projects.csv").write_text(project_header + "\n" + project_row + "\n", encoding="utf-8")
+        (root / "tasks.csv").write_text(task_header + "\n" + task_row + "\n", encoding="utf-8")
+
+    def test_preserves_leading_zero_ids_and_quoted_commas(self):
+        with TemporaryDirectory() as temp:
+            directory = Path(temp) / "input"
+            self._pair(directory)
+            value = load_csv_export(directory)
+            self.assertEqual("0007", value["projects"][0]["id"])
+            self.assertEqual("Quoted, project", value["projects"][0]["name"])
+            self.assertEqual("0009", value["tasks"][0]["id"])
+
+    def test_missing_header_is_rejected(self):
+        with TemporaryDirectory() as temp:
+            directory = Path(temp) / "input"
+            self._pair(directory, project_header="id")
+            with self.assertRaises(InputError):
+                load_csv_export(directory)
+
+    def test_duplicate_columns_are_rejected(self):
+        with TemporaryDirectory() as temp:
+            directory = Path(temp) / "input"
+            self._pair(directory, task_header="id,project_id,name,name")
+            with self.assertRaisesRegex(InputError, "duplicate column"):
+                load_csv_export(directory)
+
+    def test_invalid_decimal_is_rejected(self):
+        with TemporaryDirectory() as temp:
+            directory = Path(temp) / "input"
+            self._pair(directory, task_row="0009,0007,Task,NaN")
+            with self.assertRaises(InputError):
+                load_csv_export(directory)
+
+
+class CliTests(unittest.TestCase):
+    def test_refuses_existing_output_and_input_overwrite(self):
+        root = Path(__file__).resolve().parents[1] / "examples"
+        with TemporaryDirectory() as temp:
+            output = Path(temp) / "report.json"
+            output.write_text("keep", encoding="utf-8")
+            self.assertEqual(2, main([str(root / "before.json"), str(root / "after-clean.json"),
+                                      "--output", str(output)]))
+            self.assertEqual("keep", output.read_text(encoding="utf-8"))
+            original = (root / "before.json").read_text(encoding="utf-8")
+            self.assertEqual(2, main([str(root / "before.json"), str(root / "after-clean.json"),
+                                      "--output", str(root / "before.json")]))
+            self.assertEqual(original, (root / "before.json").read_text(encoding="utf-8"))
+
+    def test_new_output_and_exit_statuses(self):
+        root = Path(__file__).resolve().parents[1] / "examples"
+        with TemporaryDirectory() as temp:
+            clean = Path(temp) / "clean.json"
+            self.assertEqual(0, main([str(root / "before.json"), str(root / "after-clean.json"),
+                                      "--output", str(clean)]))
+            self.assertEqual("clean", json.loads(clean.read_text(encoding="utf-8"))["status"])
+            self.assertEqual(1, main([str(root / "before.json"), str(root / "after-corrupted.json")]))
+
+    def test_non_ascii_output_survives_ascii_console(self):
+        with TemporaryDirectory() as temp:
+            root = Path(temp)
+            before = snapshot(projects=[{"id": "P-caf\u00e9", "name": "Plan"}], tasks=[])
+            after = snapshot(projects=[], tasks=[])
+            (root / "before.json").write_text(json.dumps(before, ensure_ascii=False), encoding="utf-8")
+            (root / "after.json").write_text(json.dumps(after, ensure_ascii=False), encoding="utf-8")
+            environment = os.environ.copy()
+            environment["PYTHONIOENCODING"] = "ascii"
+            environment["PYTHONPATH"] = str(Path(__file__).resolve().parents[1] / "src")
+            result = subprocess.run(
+                [sys.executable, "-m", "plainfile_project_check", str(root / "before.json"),
+                 str(root / "after.json")], capture_output=True, text=True, env=environment)
+            self.assertEqual(1, result.returncode, result.stderr)
+            self.assertIn("P-caf\\u00e9", result.stdout)
+
+
+if __name__ == "__main__":
+    unittest.main()