Merge pull request #11 from AnCarsenat/10-feature-using-pack_format-instead-of-version

AnCarsenat · web-flow · commit 9a96c7c776b7 · 2026-02-01T12:41:22.000+01:00
10 feature using pack format instead of version &amp; Removing tool clutter &amp; Debug environnment
diff --git a/.mcp.json b/.mcp.json
@@ -0,0 +1,9 @@
+{
+  "name": "minecode-debug",
+  "transport": "stdio",
+  "command": "${command:python.interpreterPath}",
+  "args": ["-m", "minecode.server"],
+  "cwd": ".",
+  "env": {},
+  "description": "Configuration for launching the MineCode MCP server via stdio. Use an MCP-capable client or VS Code extension to start/connect."
+}
diff --git a/.vscode/mcp.json b/.vscode/mcp.json
@@ -0,0 +1,13 @@
+{
+  "servers": [
+    {
+      "name": "minecode-debug",
+      "command": "${command:python.interpreterPath}",
+      "args": ["-m", "minecode.server"],
+      "transport": "stdio",
+      "cwd": "${workspaceFolder}",
+      "autoStart": false,
+      "description": "Start MineCode MCP server for workspace (stdio transport)."
+    }
+  ]
+}
diff --git a/minecode/config/config.json b/minecode/config/config.json
@@ -0,0 +1,6 @@
+
+{
+	"preprompt_path": "minecode/preprompts/assistant_preprompt.txt",
+	"preprompt_enabled": true,
+	"description": "Central config for MineCode MCP. Contains path to assistant pre-prompt and feature flags."
+}
diff --git a/minecode/config/prompt_config.json b/minecode/config/prompt_config.json
@@ -0,0 +1,5 @@
+{
+  "default_preprompt": "minecode/preprompts/assistant_preprompt.txt",
+  "enabled": true,
+  "description": "Path to the default assistant pre-prompt used by the MCP server."
+}
diff --git a/minecode/preprompts/assistant_preprompt.txt b/minecode/preprompts/assistant_preprompt.txt
@@ -0,0 +1,34 @@
+You are an AI agent built to help minecraft datapack/texture pack creators on java.
+When you need to search for information, use the tools provided to you if possible and target the right versions.
+
+Proceed with the following method :
+Get the pack_format of the datapack (generally in /pack.mcmeta)
+Get the versions that the pack has to support.
+    Sometimes pack have multi-version support. In those cases It will be generally harder to work with.
+Carefully examine and understand what the user reports.
+If it is an error report:
+    - Use tools to diagnose the problem (ex: get_minecraft_logs)
+    - Explain the problem to the user
+    - Try and fix
+    - Explain changes made
+If it is a feature request :
+    - Make sure you know what version you are on and what tools you can use
+    - If you know of methods and workarounds to minecraft's limitations
+        - Explain limitations and workarounds
+    - Add the feature
+When you're done TRY TO FIND PROBLEMS WHICH MIGHT ARISE
+
+Tools which are available to you :
+    scrappers contains scrappers and api wrappers for interacting with websites which are up to date and generally more accurate.
+        - misode
+        misode is a website containing UI generators : you can give the user a generator if you think he will be more able then you to add a feature.
+        - mojira
+        mojira is a bug tracking website. You generally won't have to use this.
+        - spyglass
+        spyglass is an api which has per version version information.
+        commands
+        blocks
+        etc
+        - minecraft_wiki
+        the minecraft wiki is an official wiki containing information.
+        the problem when searching this site is that it only contains the latest versions' information. (back for backporting or older versions)
diff --git a/minecode/prompts/main.txt b/minecode/prompts/main.txt
@@ -0,0 +1,26 @@
+You are an AI agent built to help minecraft datapack/texture pack creators on java.
+When you need to search for information, use the tools provided to you if possible and target the right versions.
+
+Proceed with the following method :
+Get the pack_format of the datapack (generally in /pack.mcmeta)
+Get the versions that the pack has to support.
+    Sometimes pack have multi-version support. In those cases It will be generally harder to work with.
+Carefully examine and understand what the user reports.
+If it is an error report:
+    - Use tools to diagnose the problem (ex: get_minecraft_logs)
+    - Explain the problem to the user
+    - Try and fix
+    - Explain changes made
+If it is a feature request :
+    - Make sure you know what version you are on and what tools you can use
+    - If you know of methods and workarounds to minecraft's limitations
+        - Explain limitations and workarounds
+    - Add the feature
+When you're done TRY TO FIND PROBLEMS WHICH MIGHT ARISE
+
+Tools which are available to you :
+    scrappers contains scrappers and api wrappers for interacting with websites which are up to date and generally more accurate.
+        - misode
+        misode is a website containing UI generators : you can give the user a generator if you think he will be more able then you to add a feature.
+        - mojira
+        mojira is a bug tracking website. You generally won't have to use this.
diff --git a/minecode/scrappers/minecraftwiki.py b/minecode/scrappers/minecraftwiki.py
@@ -368,7 +368,7 @@ def get_block_info(block: str) -> Optional[PageContent]:
     Args:
         block: Block name (e.g., "Stone", "Diamond Ore")
     
-    Returns:
+    Returns:    
         PageContent object with block information
     """
     return get_page_content(block)
diff --git a/minecode/scrappers/spyglass.py b/minecode/scrappers/spyglass.py
@@ -69,51 +69,6 @@ def get_versions() -> List[Dict[str, Any]]:
     return _make_request("/mcje/versions")
 
 
-def get_latest_release() -> Optional[Dict[str, Any]]:
-    """
-    Get the latest stable release version.
-    
-    Returns:
-        Version object for the latest release, or None if not found
-    """
-    versions = get_versions()
-    for version in versions:
-        if version.get("type") == "release" and version.get("stable"):
-            return version
-    return None
-
-
-def get_latest_snapshot() -> Optional[Dict[str, Any]]:
-    """
-    Get the latest snapshot version.
-    
-    Returns:
-        Version object for the latest snapshot, or None if not found
-    """
-    versions = get_versions()
-    for version in versions:
-        if version.get("type") == "snapshot":
-            return version
-    return None
-
-
-def get_version_info(version_id: str) -> Optional[Dict[str, Any]]:
-    """
-    Get information about a specific version.
-    
-    Args:
-        version_id: Version ID (e.g., "1.21", "24w14a")
-        
-    Returns:
-        Version object or None if not found
-    """
-    versions = get_versions()
-    for version in versions:
-        if version.get("id") == version_id:
-            return version
-    return None
-
-
 # ============================================================================
 # Block States Endpoint
 # ============================================================================
diff --git a/minecode/server.py b/minecode/server.py
@@ -6,6 +6,7 @@
 
 import asyncio
 import json
+import logging
 
 from mcp.server import Server
 from mcp.server.stdio import stdio_server
@@ -21,6 +22,74 @@
 # Initialize MCP Server
 server = Server("minecode-server")
 
+# logging
+logging.basicConfig(level=logging.INFO, format="[%(levelname)s] %(message)s")
+logger = logging.getLogger("minecode.server")
+
+# Load central configuration and assistant preprompt (if enabled)
+from pathlib import Path
+
+_pkg_dir = Path(__file__).resolve().parent
+_config_file = _pkg_dir / "config" / "config.json"
+
+# attach default_preprompt to server so other modules can access it
+server.default_preprompt = None
+
+def _load_preprompt_from_config():
+    try:
+        if _config_file.exists():
+            cfg = json.loads(_config_file.read_text(encoding="utf-8"))
+            preprompt_enabled = cfg.get("preprompt_enabled", False)
+            preprompt_path = cfg.get("preprompt_path")
+            if preprompt_enabled and preprompt_path:
+                # Try multiple candidate locations for the preprompt path:
+                candidates = []
+                p = Path(preprompt_path)
+                # Absolute path as-given
+                if p.is_absolute():
+                    candidates.append(p)
+
+                # Package-relative (e.g. "preprompts/assistant_preprompt.txt")
+                candidates.append((_pkg_dir / preprompt_path))
+
+                # Workspace/root-relative if the config used "minecode/..." or similar
+                repo_root = _pkg_dir.parent
+                candidates.append(repo_root / preprompt_path)
+
+                # If path contains a nested "minecode/", try the suffix relative to package
+                if "minecode/" in preprompt_path:
+                    suffix = preprompt_path.split("minecode/", 1)[1]
+                    candidates.append(_pkg_dir / suffix)
+
+                found = None
+                for c in candidates:
+                    try:
+                        cc = c.resolve()
+                    except Exception:
+                        cc = c
+                    logger.debug(f"Checking preprompt candidate: {cc}")
+                    if cc.exists():
+                        found = cc
+                        break
+
+                if found:
+                    server.default_preprompt = found.read_text(encoding="utf-8")
+                    logger.info(f"Loaded assistant preprompt from {found}")
+                else:
+                    logger.info(f"Assistant preprompt not found; tried {len(candidates)} locations")
+    except Exception as e:
+        logger.exception("Failed loading preprompt from config")
+
+
+_load_preprompt_from_config()
+
+def get_preprompt_messages():
+    if server.default_preprompt:
+        return [{"role": "system", "content": server.default_preprompt}]
+    return []
+
+server.get_preprompt_messages = get_preprompt_messages
+
 
 # Tool definitions
 TOOLS = [
@@ -47,9 +116,13 @@
                 "version": {
                     "type": "string",
                     "description": "Minecraft version (e.g., 1.20.1, latest)"
+                },
+                "datapack_path": {
+                    "type": "string",
+                    "description": "Path to a datapack folder containing pack.mcmeta to infer version"
                 }
             },
-            "required": ["version"]
+            "required": []
         }
     ),
     Tool(
@@ -482,30 +555,62 @@ def handle_hello_world(name: str = None) -> str:
     return "Hello, World! Welcome to MineCode - Your Minecraft Datapack Development Assistant"
 
 
-def handle_get_minecraft_version(version: str) -> dict:
-    """Handle get_minecraft_version tool"""
-    # Simulated version info
-    versions = {
-        "1.20.1": {
-            "release_date": "2023-12-07",
-            "snapshot": False,
-            "features": ["Decorated pots", "Armor trims", "Smithing templates"]
-        },
-        "1.20": {
-            "release_date": "2023-06-07",
-            "snapshot": False,
-            "features": ["Cherry logs", "Painting variants", "Camel mob"]
-        },
-        "latest": {
-            "release_date": "2024-01-18",
-            "snapshot": False,
-            "version": "1.20.4"
-        }
-    }
-    
-    if version in versions:
-        return {"success": True, "data": versions[version]}
-    return {"success": False, "error": f"Version {version} not found in database"}
+def handle_get_minecraft_version(version: str = None, datapack_path: str = None) -> dict:
+    """Handle get_minecraft_version tool.
+
+    If `datapack_path` is provided, attempt to read `pack.mcmeta` and infer
+    the pack_format, then use `misode` metadata to find matching Minecraft
+    versions. If `version` is provided, return the version info from `misode`.
+    """
+    # If a datapack path is provided, try to read pack.mcmeta and infer versions
+    if datapack_path:
+        from pathlib import Path
+        try:
+            p = Path(datapack_path)
+            # allow passing either the folder or the direct path to pack.mcmeta
+            pp = p / "pack.mcmeta" if p.is_dir() else p
+            if not pp.exists():
+                return {"success": False, "error": f"pack.mcmeta not found at {pp}"}
+
+            import json as _json
+            content = _json.loads(pp.read_text(encoding="utf-8"))
+            pack = content.get("pack") or {}
+            pack_format = pack.get("pack_format")
+            if pack_format is None:
+                return {"success": False, "error": "pack_format not found in pack.mcmeta"}
+
+            # Find versions in misode that match this data_pack_version
+            try:
+                candidates = []
+                for vid in misode.list_versions():
+                    info = misode.get_version_info(vid) or {}
+                    dpv = info.get("data_pack_version") or info.get("dataPackVersion") or info.get("pack_format")
+                    if dpv is None:
+                        continue
+                    # compare as ints/strings
+                    try:
+                        if int(dpv) == int(pack_format):
+                            candidates.append({"version": vid, "data_pack_version": dpv})
+                    except Exception:
+                        if str(dpv) == str(pack_format):
+                            candidates.append({"version": vid, "data_pack_version": dpv})
+
+                if candidates:
+                    return {"success": True, "pack_format": pack_format, "matches": candidates}
+                return {"success": False, "pack_format": pack_format, "matches": [], "note": "No matching versions found in misode metadata"}
+            except Exception as e:
+                return {"success": False, "error": f"Error querying misode metadata: {e}"}
+        except Exception as e:
+            return {"success": False, "error": f"Failed reading pack.mcmeta: {e}"}
+
+    # Fallback: if a version string is provided, try to get info from misode
+    if version:
+        info = misode.get_version_info(version)
+        if info:
+            return {"success": True, "version": version, "info": info}
+        return {"success": False, "error": f"Version {version} not found in misode database"}
+
+    return {"success": False, "error": "Either `version` or `datapack_path` must be provided"}
 
 
 def handle_validate_datapack(datapack_path: str, mc_version: str) -> dict:
@@ -965,7 +1070,7 @@ async def call_tool(name: str, arguments: dict) -> list[TextContent]:
         if name == "hello_world":
             result = handle_hello_world(arguments.get("name"))
         elif name == "get_minecraft_version":
-            result = handle_get_minecraft_version(arguments["version"])
+            result = handle_get_minecraft_version(arguments.get("version"), arguments.get("datapack_path"))
         elif name == "validate_datapack":
             result = handle_validate_datapack(arguments["datapack_path"], arguments["mc_version"])
         elif name == "search_wiki":
@@ -1085,15 +1190,22 @@ async def list_tools():
 async def _run():
     """Run the MCP server"""
     async with stdio_server() as (read_stream, write_stream):
-        await server.run(
-            read_stream,
-            write_stream,
-            server.create_initialization_options()
-        )
+        logger.info("MineCode MCP server starting (stdio mode)")
+        logger.info(f"Registering {len(TOOLS)} tools")
+        try:
+            await server.run(
+                read_stream,
+                write_stream,
+                server.create_initialization_options()
+            )
+        finally:
+            logger.info("MineCode MCP server stopped")
 
 
 def main():
     """Entry point for the MCP server"""
+    logger.info("Starting MineCode MCP server (main entry)")
+    logger.info(f"Config file: {_config_file}")
     asyncio.run(_run())
 
 
