feat: add support for lammps problem size validator

Signed-off-by: vsoch <vsoch@users.noreply.github.com>

Author: vsoch

resource_secretary/apps/molecular_dynamics/lammps.py

@@ -1,6 +1,9 @@
+import shlex
+from typing import Annotated, Any, Dict
+
 from resource_secretary.apps.app import BaseApplication
 from resource_secretary.apps.prompts import AppPromptGenerator
-from resource_secretary.providers import get_providers
+from resource_secretary.providers.provider import dispatch_tool
 
 LAMMPS_WORKLOADS = {
     "reaxff": {
@@ -51,6 +54,125 @@ def __init__(self, **kwargs):
         self.modifiers = LAMMPS_MODIFIERS
         self.default_workload = "reaxff"
 
+    @dispatch_tool
+    def validate_lmp_problem_size(
+        command: Annotated[str, "The full LAMMPS command string generated by the agent."],
+        expected_x: Annotated[
+            int, "The required replication size or grid count in the X dimension."
+        ],
+        expected_y: Annotated[
+            int, "The required replication size or grid count in the Y dimension."
+        ],
+        expected_z: Annotated[
+            int, "The required replication size or grid count in the Z dimension."
+        ],
+    ) -> Annotated[
+        Dict[str, Any], "A dictionary containing validation results and diagnostic messages."
+    ]:
+        """
+        Parses a generated LAMMPS command string to verify that the required scientific
+        problem size variables (X, Y, Z) are present and match the expected values.
+
+        Use cases for the Agent:
+        1. Pre-Submission Check: After generating a complex command, call this tool to ensure no vital variables were dropped.
+        2. Failure Recovery: If a previous command ran too quickly or failed, use this to double-check that you are actually passing the right grid scale.
+        3. Syntax Safeguard: Ensures that the agent translates a descriptive prompt (e.g., '32x32x16 grid') into actual machine-readable command line arguments.
+
+        Returns:
+            A dictionary with:
+            - is_valid (bool): True if all variables are present and match exactly.
+            - message (str): A human-readable description of what was found or missing.
+            - parsed_dimensions (Dict[str, float]): The values of x, y, and z parsed from the command.
+            - missing_dimensions (List[str]): List of missing required variables.
+            - mismatched_dimensions (List[str]): List of variables that were present but didn't match the expectation.
+        """
+        if not command:
+            return {
+                "is_valid": False,
+                "message": "Command string is empty.",
+                "parsed_dimensions": {},
+                "missing_dimensions": ["x", "y", "z"],
+                "mismatched_dimensions": [],
+            }
+
+        try:
+            tokens = shlex.split(command)
+        except Exception as e:
+            return {
+                "is_valid": False,
+                "message": f"Failed to parse command string tokens: {str(e)}",
+                "parsed_dimensions": {},
+                "missing_dimensions": [],
+                "mismatched_dimensions": [],
+            }
+
+        parsed_vars = {}
+        i = 0
+
+        # Scan through tokens to find LAMMPS variable setting patterns
+        while i < len(tokens):
+            token = tokens[i]
+
+            # Standard LAMMPS: -v x X OR -var x Y OR --variable x 32
+            if token in ("-v", "-var", "--variable") and i + 2 < len(tokens):
+                var_name = tokens[i + 1]
+                var_val = tokens[i + 2]
+                if var_name in ("x", "y", "z"):
+                    try:
+                        parsed_vars[var_name] = float(var_val)
+                    except ValueError:
+                        pass  # Handle non-numeric edge cases gracefully
+                i += 3
+
+            # Support direct flags if asked for: -x 32, -y 32, -z 32
+            elif token in ("-x", "-y", "-z") and i + 1 < len(tokens):
+                var_name = token[1]  # Extracts 'x', 'y', or 'z'
+                var_val = tokens[i + 1]
+                try:
+                    parsed_vars[var_name] = float(var_val)
+                except ValueError:
+                    pass
+                i += 2
+
+            else:
+                i += 1
+
+        # Compare parsed against expected
+        expected = {"x": float(expected_x), "y": float(expected_y), "z": float(expected_z)}
+        missing = []
+        mismatched = []
+
+        for dim, expected_val in expected.items():
+            if dim not in parsed_vars:
+                missing.append(dim)
+            elif parsed_vars[dim] != expected_val:
+                mismatched.append(dim)
+
+        # Compile the resulting status
+        if not missing and not mismatched:
+            return {
+                "is_valid": True,
+                "message": f"Perfect match! Command correctly contains x={expected_x}, y={expected_y}, z={expected_z}.",
+                "parsed_dimensions": parsed_vars,
+                "missing_dimensions": [],
+                "mismatched_dimensions": [],
+            }
+
+        # Build failure messaging
+        error_parts = []
+        if missing:
+            error_parts.append(f"Missing variable(s): {', '.join(missing)}")
+        if mismatched:
+            error_parts.append(f"Mismatched variable(s): {', '.join(mismatched)}")
+
+        return {
+            "is_valid": False,
+            "message": f"Validation failed. " + " | ".join(error_parts),
+            "parsed_dimensions": parsed_vars,
+            "missing_dimensions": missing,
+            "mismatched_dimensions": mismatched,
+        }
+
     def get_prompt_matrix(
         self, workload="reaxff", manager="flux", flatten=False, filters=None, count=None, **params
     ):