scitex 2.16.1__py3-none-any.whl → 2.17.0__py3-none-any.whl

scitex/_mcp_resources/_cheatsheet.py

@@ -32,7 +32,7 @@ def main(
     CONFIG=stx.INJECTED,         # Session config with ID, paths
     plt=stx.INJECTED,            # Pre-configured matplotlib
     COLORS=stx.INJECTED,         # Color palette
-    rng=stx.INJECTED,            # Seeded random generator
+    rngg=stx.INJECTED,            # Seeded random generator
     logger=stx.INJECTED,         # Session logger
 ):
     \"\"\"This docstring becomes --help description.\"\"\"

scitex/_mcp_resources/_modules.py

@@ -223,7 +223,7 @@ def main(
     CONFIG=stx.INJECTED,         # Session config
     plt=stx.INJECTED,            # matplotlib
     COLORS=stx.INJECTED,         # Color palette
-    rng=stx.INJECTED,            # Random generator
+    rngg=stx.INJECTED,            # Random generator
     logger=stx.INJECTED,         # Logger
 ):
     \"\"\"Docstring becomes --help.\"\"\"

scitex/_mcp_tools/__init__.py

@@ -17,6 +17,7 @@ from .social import register_social_tools
 from .stats import register_stats_tools
 from .template import register_template_tools
 from .ui import register_ui_tools
+from .verify import register_verify_tools
 from .writer import register_writer_tools
 
 __all__ = ["register_all_tools"]
@@ -36,6 +37,7 @@ def register_all_tools(mcp) -> None:
     register_stats_tools(mcp)
     register_template_tools(mcp)
     register_ui_tools(mcp)
+    register_verify_tools(mcp)
     register_writer_tools(mcp)
 
 

scitex/_mcp_tools/verify.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-02-01 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/_mcp_tools/verify.py
+"""Verify module tools for FastMCP unified server."""
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+
+def _json(data: dict) -> str:
+    return json.dumps(data, indent=2, default=str)
+
+
+def register_verify_tools(mcp) -> None:
+    """Register verify tools with FastMCP server."""
+
+    @mcp.tool()
+    async def verify_list(
+        limit: int = 50,
+        status_filter: Optional[str] = None,
+    ) -> str:
+        """[verify] List all tracked runs with verification status.
+
+        Parameters
+        ----------
+        limit : int, optional
+            Maximum number of runs to return (default: 50)
+        status_filter : str, optional
+            Filter by status: 'success', 'failed', 'running', or None for all
+
+        Returns
+        -------
+        str
+            JSON with list of runs and their verification status
+        """
+        from scitex.verify import get_db, verify_run
+
+        db = get_db()
+        runs = db.list_runs(status=status_filter, limit=limit)
+
+        results = []
+        for run in runs:
+            verification = verify_run(run["session_id"])
+            results.append(
+                {
+                    "session_id": run["session_id"],
+                    "script_path": run.get("script_path"),
+                    "db_status": run.get("status"),
+                    "verification_status": verification.status.value,
+                    "is_verified": verification.is_verified,
+                    "started_at": run.get("started_at"),
+                    "finished_at": run.get("finished_at"),
+                }
+            )
+
+        return _json(
+            {
+                "count": len(results),
+                "runs": results,
+            }
+        )
+
+    @mcp.tool()
+    async def verify_run(
+        session_or_path: str,
+    ) -> str:
+        """[verify] Verify a specific session run by checking all file hashes.
+
+        Parameters
+        ----------
+        session_or_path : str
+            Session ID (e.g., '2025Y-11M-18D-09h12m03s_HmH5') or
+            path to a file to find its associated session
+
+        Returns
+        -------
+        str
+            JSON with verification results including file-level details
+        """
+        from pathlib import Path
+
+        from scitex.verify import get_db
+        from scitex.verify import verify_run as do_verify_run
+
+        db = get_db()
+
+        # Check if it's a file path
+        path = Path(session_or_path)
+        if path.exists():
+            sessions = db.find_session_by_file(str(path.resolve()), role="output")
+            if not sessions:
+                sessions = db.find_session_by_file(str(path.resolve()), role="input")
+
+            if not sessions:
+                return _json(
+                    {
+                        "error": f"No session found for file: {session_or_path}",
+                        "session_id": None,
+                    }
+                )
+            session_id = sessions[0]
+        else:
+            session_id = session_or_path
+
+        verification = do_verify_run(session_id)
+
+        return _json(
+            {
+                "session_id": verification.session_id,
+                "script_path": verification.script_path,
+                "status": verification.status.value,
+                "is_verified": verification.is_verified,
+                "combined_hash_expected": verification.combined_hash_expected,
+                "files": [
+                    {
+                        "path": f.path,
+                        "role": f.role,
+                        "status": f.status.value,
+                        "expected_hash": f.expected_hash,
+                        "current_hash": f.current_hash,
+                        "is_verified": f.is_verified,
+                    }
+                    for f in verification.files
+                ],
+                "mismatched_count": len(verification.mismatched_files),
+                "missing_count": len(verification.missing_files),
+            }
+        )
+
+    @mcp.tool()
+    async def verify_chain(
+        target_file: str,
+    ) -> str:
+        """[verify] Verify the dependency chain for a target file.
+
+        Traces back through all sessions that contributed to producing
+        the target file and verifies each one.
+
+        Parameters
+        ----------
+        target_file : str
+            Path to the target file to trace
+
+        Returns
+        -------
+        str
+            JSON with chain verification results
+        """
+        from pathlib import Path
+
+        from scitex.verify import verify_chain as do_verify_chain
+
+        path = Path(target_file)
+        if not path.exists():
+            return _json(
+                {
+                    "error": f"File not found: {target_file}",
+                    "target_file": target_file,
+                }
+            )
+
+        chain = do_verify_chain(str(path.resolve()))
+
+        return _json(
+            {
+                "target_file": chain.target_file,
+                "status": chain.status.value,
+                "is_verified": chain.is_verified,
+                "chain_length": len(chain.runs),
+                "failed_runs_count": len(chain.failed_runs),
+                "runs": [
+                    {
+                        "session_id": r.session_id,
+                        "script_path": r.script_path,
+                        "status": r.status.value,
+                        "is_verified": r.is_verified,
+                        "mismatched_files": [f.path for f in r.mismatched_files],
+                        "missing_files": [f.path for f in r.missing_files],
+                    }
+                    for r in chain.runs
+                ],
+            }
+        )
+
+    @mcp.tool()
+    async def verify_status() -> str:
+        """[verify] Show verification status summary (like git status).
+
+        Returns
+        -------
+        str
+            JSON with counts of verified, mismatched, and missing runs
+        """
+        from scitex.verify import get_status
+
+        status = get_status()
+        return _json(status)
+
+    @mcp.tool()
+    async def verify_stats() -> str:
+        """[verify] Show verification database statistics.
+
+        Returns
+        -------
+        str
+            JSON with database statistics
+        """
+        from scitex.verify import get_db
+
+        db = get_db()
+        stats = db.stats()
+        return _json(stats)
+
+    @mcp.tool()
+    async def verify_mermaid(
+        session_id: Optional[str] = None,
+        target_file: Optional[str] = None,
+    ) -> str:
+        """[verify] Generate Mermaid diagram for verification DAG.
+
+        Parameters
+        ----------
+        session_id : str, optional
+            Start from this session
+        target_file : str, optional
+            Start from session that produced this file
+
+        Returns
+        -------
+        str
+            Mermaid diagram code
+        """
+        from pathlib import Path
+
+        from scitex.verify import generate_mermaid_dag
+
+        if target_file:
+            target_file = str(Path(target_file).resolve())
+
+        mermaid_code = generate_mermaid_dag(
+            session_id=session_id,
+            target_file=target_file,
+        )
+
+        return _json(
+            {
+                "mermaid": mermaid_code,
+                "session_id": session_id,
+                "target_file": target_file,
+            }
+        )
+
+
+# EOF

scitex/cli/main.py

@@ -41,6 +41,7 @@ from . import (
     stats,
     template,
     tex,
+    verify,
     web,
     writer,
 )
@@ -97,6 +98,7 @@ cli.add_command(social.social)
 cli.add_command(stats.stats)
 cli.add_command(template.template)
 cli.add_command(tex.tex)
+cli.add_command(verify.verify)
 cli.add_command(web.web)
 cli.add_command(writer.writer)