Master Tool Standard Ver

Use this checklist on every MTSV run:

When using a comparator, align the standard and master tool along the same measurement axis. Misalignment introduces cosine error. master tool standard ver

The old paper-based "master tool standard ver" logbook is dying. Industry 4.0 introduces new approaches. Use this checklist on every MTSV run:

import hashlib
import json
import os
from pathlib import Path
from typing import Dict, List, Optional
from dataclasses import dataclass, asdict
from datetime import datetime
@dataclass
class ToolAsset:
name: str
version: str
sha256: str
dependencies: List[str]  # list of "name@version"
registered_at: str When using a comparator, align the standard and
class MasterToolStandard:
"""
Master Tool Standard v1 — Version-aware asset registry.
"""
MANIFEST_PATH = Path.home() / ".mts" / "manifest.json"
def __init__(self):
    self.manifest: Dict[str, ToolAsset] = {}
    self._load_manifest()
def _load_manifest(self):
    if self.MANIFEST_PATH.exists():
        with open(self.MANIFEST_PATH, "r") as f:
            data = json.load(f)
            for k, v in data.items():
                self.manifest[k] = ToolAsset(**v)
def _save_manifest(self):
    self.MANIFEST_PATH.parent.mkdir(parents=True, exist_ok=True)
    with open(self.MANIFEST_PATH, "w") as f:
        json.dump(k: asdict(v) for k, v in self.manifest.items(), f, indent=2)
@staticmethod
def compute_sha256(file_path: Path) -> str:
    sha = hashlib.sha256()
    with open(file_path, "rb") as f:
        for chunk in iter(lambda: f.read(65536), b""):
            sha.update(chunk)
    return sha.hexdigest()
def register(self, file_path: Path, name: str, version: str, dependencies: List[str] = None):
    """Register a tool asset into the master standard."""
    if not file_path.exists():
        raise FileNotFoundError(f"file_path not found")
    sha = self.compute_sha256(file_path)
    asset = ToolAsset(
        name=name,
        version=version,
        sha256=sha,
        dependencies=dependencies or [],
        registered_at=datetime.utcnow().isoformat()
    )
    self.manifest[f"name@version"] = asset
    self._save_manifest()
    print(f"✅ Registered name vversion (hash: sha[:8]...)")
def validate_environment(self, working_dir: Path) -> List[str]:
    """
    Check all registered tools in a directory against the master standard.
    Returns list of violations.
    """
    issues = []
    for key, asset in self.manifest.items():
        candidate = working_dir / asset.name
        if not candidate.exists():
            issues.append(f"Missing: asset.name")
            continue
        actual_hash = self.compute_sha256(candidate)
        if actual_hash != asset.sha256:
            issues.append(
                f"Integrity failure: asset.name vasset.version "
                f"(expected asset.sha256[:8], got actual_hash[:8])"
            )
    return issues
def resolve_dependency_chain(self, tool_name: str, tool_version: str) -> List[str]:
    """Return ordered list of dependencies for a given tool."""
    key = f"tool_name@tool_version"
    if key not in self.manifest:
        raise KeyError(f"Tool key not registered")
    visited = set()
    order = []
def dfs(dep_key):
        if dep_key in visited:
            return
        visited.add(dep_key)
        if dep_key not in self.manifest:
            raise KeyError(f"Missing dependency dep_key")
        for dep in self.manifest[dep_key].dependencies:
            dfs(dep)
        order.append(dep_key)
dfs(key)
    return order