scad-gltf 0.2.4 → 0.3.0

package/README.md

@@ -23,7 +23,7 @@ The C++ source code for this custom OpenSCAD version is included directly in thi
 - **MCP Server for AI Agents:** Bundled `scad-mcp` server enables MCP clients to iteratively design, compile, and **visually inspect** 3D models via multi-angle headless rendering and animation frame evaluation.
 - **AI Studio Extension:** Chrome extension to natively preview, prompt, take chat snapshots, open in Scadify, and locally save AI-generated 3D models directly inside Google AI Studio.
 - **Godot 4, Rust Bevy & Web Integration:** Native Godot 4 importer addon and Rust Bevy compile-time `build.rs` integration.
-- **Automated AI Generation:** Pass an OpenAI-compatible base URL (and optional API key) to the `scad-godot`, `scad-bevy`, or `scad-web` CLI to automatically spawn a local MCP server, query the LLM via standard endpoints, allow it to visually iterate, and output a ready-to-run project generator script.
+- **Automated AI Generation:** Pass an OpenAI-compatible base URL (and optional API key) to the `scad-gen` CLI tool to automatically spawn a local MCP server, query the LLM via standard endpoints, allow it to visually iterate, and output a ready-to-run game project or raw 3D asset script.
 
 ---
 
@@ -51,7 +51,7 @@ The built-in web editor (**Scadify**) provides a full-featured development envir
 This package is designed to be installed directly from GitHub.
 
 **Option 1: Global Installation (Recommended for CLI usage)**
-If you plan to use the `scad-convert`, `scad-serve`, or `scad-mcp` command-line tools anywhere on your system:
+If you plan to use the `scad-convert`, `scad-serve`, `scad-gen`, or `scad-mcp` command-line tools anywhere on your system:
 
 ```bash
 npm install -g scad-gltf
@@ -261,7 +261,7 @@ Instead of generating code blindly, the AI can compile its script, render the 3D
 
 - `get_scad_prompt`: Injects the custom OpenSCAD syntax rules (PBR, animations, baking) into the AI's context.
 - `render_scad_model`: Compiles the generated `.scad` code to GLB and returns base64 images from requested camera angles (front, back, left, right, top, bottom, isometric) and specific animation keyframes.
-- `compile_bevy_project` / `test_godot_project`: Tests the generated game projects for compilation and runtime errors.
+- `compile_rust_project` / `test_godot_project`: Tests the generated game projects for compilation and runtime errors.
 
 ### Setup
 
@@ -295,7 +295,14 @@ The addon allows you to drag-and-drop `.scad` files directly into your Godot pro
 
 ### Automated AI Generation (OpenAI-Compatible API)
 
-By default, `scad-godot`, `scad-bevy`, and `scad-web` copy a heavily engineered system prompt to your clipboard to paste into an LLM. However, if you provide a **Base URL** (and optional **API Key**), the CLI will fully automate this process. It will automatically spin up the `scad-mcp` server in the background, connect it to your LLM, and allow the AI to _visually evaluate and fix_ its 3D models in real-time before saving the final `generate_project.js` script to your disk.
+By default, the `scad-gen` utility copies a heavily engineered system prompt to your clipboard to paste into an LLM. However, if you provide a **Base URL** (and optional **API Key**), the CLI will fully automate this process. It will automatically spin up the `scad-mcp` server in the background, connect it to your LLM, and allow the AI to _visually evaluate and fix_ its code in real-time before saving the final `generate_project.js` script to your disk.
+
+**Supported Generation Types:**
+
+- `gen`: Generate a single raw `.scad` asset file.
+- `godot`: Generate a fully packaged Godot 4 game project containing generated assets and GDScript logic.
+- `bevy`: Generate a Rust Bevy game project.
+- `web`: Generate a Vite-based Web3D app (Three.js/Babylon).
 
 **Option 1: Using OpenAI (GPT-4o)**
 
@@ -303,7 +310,7 @@ By default, `scad-godot`, `scad-bevy`, and `scad-web` copy a heavily engineered
 export OPENAI_BASE_URL="https://api.openai.com/v1"
 export OPENAI_API_KEY="sk-..."
 export OPENAI_MODEL="gpt-4o"
-scad-bevy "A 3D spaceship shooter game"
+scad-gen bevy "A 3D spaceship shooter game"
 ```
 
 **Option 2: Using Google Gemini (via OpenAI compatibility)**
@@ -313,7 +320,7 @@ Because Gemini provides an official OpenAI-compatible endpoint, you can configur
 export OPENAI_API_KEY="AIzaSy..."
 export OPENAI_BASE_URL="https://generativelanguage.googleapis.com/v1beta/openai/"
 export OPENAI_MODEL="gemini-3.8-flash"
-scad-godot "A fast-paced 3D hovercraft racing game"
+scad-gen godot "A fast-paced 3D hovercraft racing game"
 ```
 
 **Option 3: Using Local Server**
@@ -322,17 +329,17 @@ You can use completely local, uncensored, or fine-tuned vision models by overrid
 ```bash
 export OPENAI_BASE_URL="http://127.0.0.1:8080/v1"
 export OPENAI_MODEL="llama-3" # Or whatever model name you've loaded
-scad-web "A 3D configurator app"
+scad-gen web "A 3D configurator app"
 ```
 
 **Passing Parameters via JSON**
 You can also pass credentials inline as a JSON string argument instead of modifying environment variables:
 
 ```bash
-scad-godot "A futuristic tank game" '{"openaiBaseUrl": "http://127.0.0.1:8080/v1", "openaiModel": "llama-3"}'
+scad-gen godot "A futuristic tank game" '{"openaiBaseUrl": "http://127.0.0.1:8080/v1", "openaiModel": "llama-3"}'
 ```
 
-_Once the automated process completes, simply run the generated Node.js script to assemble your complete Godot, Bevy, or Vite project structure with all assets and code!_
+_Once the automated process completes for full game projects, simply run the generated Node.js script to assemble your complete Godot, Bevy, or Vite project structure with all assets and code!_
 
 ```bash
 node generate_godot_project.js

package/bin/{scad-convert.js → convert.js}

@@ -62,7 +62,7 @@ async function run() {
 
   if (!inputPath || !outputPath) {
     console.error(
-      "Usage: scad-convert <input.scad | input_dir> <output.glb | output_dir> [options_json] [--cache]",
+      "Usage: scad-gltf convert <input.scad | input_dir> <output.glb | output_dir> [options_json] [--cache]",
     );
     process.exit(1);
   }

package/bin/gen.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+import { runCliApp } from "../src/cli-utils.js";
+import { getProjectPrompts } from "../src/project-prompts.js";
+
+const VALID_TYPES = ["scad", "bevy", "web", "godot"];
+
+async function main() {
+  const projectType = process.argv[2];
+
+  if (!projectType || !VALID_TYPES.includes(projectType)) {
+    console.error(`Error: Invalid or missing project type.`);
+    console.error(
+      `Usage: scad-gltf gen <${VALID_TYPES.join("|")}> "<description>" [options_json]`,
+    );
+    console.error(
+      `Example: scad-gltf gen godot "A 3D racing game" '{"openaiModel": "gpt-4o"}'`,
+    );
+    process.exit(1);
+  }
+
+  await runCliApp({
+    projectType,
+    ...getProjectPrompts(projectType),
+    argStartIndex: 3, // Shift arg parsing right by 1 since projectType is at index 2
+  });
+}
+
+// Execute and handle unhandled runtime errors
+main().catch((err) => {
+  console.error("An unexpected error occurred:", err);
+  process.exit(1);
+});

package/bin/{scad-mcp.js → mcp.js}

@@ -229,9 +229,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         },
       },
       {
-        name: "compile_bevy_project",
+        name: "compile_rust_project",
         description:
-          "Compiles a specified Rust Bevy project to detect syntax errors, missing dependencies, or compilation failures. Returns the cargo console output logs.",
+          "Compiles a specified Rust project to detect syntax errors, missing dependencies, or compilation failures. Returns the cargo console output logs.",
         inputSchema: {
           type: "object",
           properties: {
@@ -243,7 +243,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             nodejs_script: {
               type: "string",
               description:
-                "The complete self-contained Node.js script that generates the Bevy project. If provided, the tool will execute this script in a temporary directory to extract the project before compiling it. Use this during the generation phase to test your code before providing the final answer.",
+                "The complete self-contained Node.js script that generates the Rust project. If provided, the tool will execute this script in a temporary directory to extract the project before compiling it. Use this during the generation phase to test your code before providing the final answer.",
             },
           },
         },
@@ -946,9 +946,9 @@ func _ready():
   }
 
   // ------------------------------------------
-  // TOOL 4: compile_bevy_project
+  // TOOL 4: compile_rust_project
   // ------------------------------------------
-  if (name === "compile_bevy_project") {
+  if (name === "compile_rust_project") {
     let cleanupDir = null;
     try {
       let projectDir = null;
@@ -956,7 +956,7 @@ func _ready():
       if (args.nodejs_script) {
         // Create a unique temporary directory
         const tempBase = fs.mkdtempSync(
-          path.join(os.tmpdir(), "scad-bevy-compile-"),
+          path.join(os.tmpdir(), "scad-rust-compile-"),
         );
         cleanupDir = tempBase;
 
@@ -1001,7 +1001,7 @@ func _ready():
             content: [
               {
                 type: "text",
-                text: `Error: The Node.js script finished running, but NO Bevy project was found. A valid Rust Bevy project requires a 'Cargo.toml' file. Ensure your script creates a root project directory and places 'Cargo.toml' inside it.`,
+                text: `Error: The Node.js script finished running, but NO Rust project was found. A valid Rust project requires a 'Cargo.toml' file. Ensure your script creates a root project directory and places 'Cargo.toml' inside it.`,
               },
             ],
             isError: true,
@@ -1026,7 +1026,7 @@ func _ready():
           content: [
             {
               type: "text",
-              text: `Error: The specified directory is not a valid Rust Bevy project. 'Cargo.toml' was not found in: ${projectDir}`,
+              text: `Error: The specified directory is not a valid Rust project. 'Cargo.toml' was not found in: ${projectDir}`,
             },
           ],
           isError: true,
@@ -1055,7 +1055,7 @@ func _ready():
             resolve({ code, output });
           });
 
-          // 2-minute timeout for Bevy compilation (can be slow as dependencies download)
+          // 2-minute timeout for Rust compilation (can be slow as dependencies download)
           setTimeout(() => {
             try {
               child.kill();
@@ -1115,7 +1115,7 @@ func _ready():
         content: [
           {
             type: "text",
-            text: `Error compiling Bevy project: ${error.message}`,
+            text: `Error compiling Rust project: ${error.message}`,
           },
         ],
         isError: true,
@@ -1138,7 +1138,7 @@ func _ready():
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("🚀 SCAD MCP Server running on stdio");
+  console.error("🚀 scad-gltf mcp server running on stdio");
 }
 
 main().catch((error) => {

package/bin/{scad-play.js → play.js}

@@ -13,9 +13,7 @@ function main() {
     console.error(
       "❌ Error: Path to the packed Node.js generator script is required.",
     );
-    console.error(
-      "Usage: node bin/scad-play.js <path_to_generated_project.js>",
-    );
+    console.error("Usage: scad-gltf play <path_to_generated_project.js>");
     process.exit(1);
   }
 
@@ -64,7 +62,7 @@ function main() {
 
     // 3. Find the resulting project folder and determine its type
     let projectDir = null;
-    let projectType = null; // 'godot' | 'web'
+    let projectType = null; // 'godot' | 'web' | 'bevy'
     let latestTime = 0;
 
     const items = fs.readdirSync(tempDir);

package/bin/scad-gltf.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+const command = process.argv[2];
+
+const commands = {
+  convert: "./convert.js",
+  serve: "./serve.js",
+  mcp: "./mcp.js",
+  gen: "./gen.js",
+  play: "./play.js",
+};
+
+if (!command || !commands[command]) {
+  console.error("Usage: scad-gltf <command> [options]");
+  console.error("\nAvailable commands:");
+  console.error("  convert   Convert .scad files to .glb binaries");
+  console.error("  serve     Start local API server and Web Editor");
+  console.error("  mcp       Start the Model Context Protocol (MCP) server");
+  console.error(
+    "  gen       Automated AI generation of 3D models and game projects",
+  );
+  console.error("  play      Test and launch generated Node.js scripts");
+  process.exit(1);
+}
+
+// Remove the subcommand from argv so the delegated scripts parse indices exactly as they did before
+process.argv.splice(2, 1);
+
+// Dynamically import the requested command script
+import(commands[command]).catch((err) => {
+  console.error(`Failed to execute command '${command}':`, err);
+  process.exit(1);
+});

package/bin/{scad-serve.js → serve.js}

@@ -217,7 +217,7 @@ if (fs.existsSync(editorDistDir)) {
 
 // Start Server
 app.listen(port, () => {
-  console.log(`🚀 scad-serve listening on http://localhost:${port}`);
+  console.log(`🚀 scad-gltf serve listening on http://localhost:${port}`);
   if (fs.existsSync(editorDistDir)) {
     console.log(`🌐 Editor available at: http://localhost:${port}/`);
   }

package/godot/README.md

@@ -10,7 +10,7 @@ By leveraging the `scad-gltf` compiler under the hood, this addon allows you to
 - **Advanced Materials**: Supports standard OpenSCAD plus custom extensions for roughness, metalness, transmission, emission, and more.
 - **Hierarchical Node Animations**: Automatically parses `armature()` and `bone()` modules into Godot `Node3D` transform hierarchies animated via `AnimationPlayer` (rigid-body hierarchy animation, ideal for mechanical and articulated models).
 - **Dependency Tracking**: Smart resolution of local `include` and `use` OpenSCAD dependencies.
-- **Auto-Fallback Engine**: Attempts to use the high-performance CLI compiler (`scad-convert`) and seamlessly falls back to the HTTP backend (`scad-serve`) if running in a restricted environment.
+- **Auto-Fallback Engine**: Attempts to use the high-performance CLI compiler (`scad-gltf convert`) and seamlessly falls back to the HTTP backend (`scad-gltf serve`) if running in a restricted environment.
 
 ---
 
@@ -42,7 +42,7 @@ When you import or reimport a `.scad` file, the plugin will attempt to compile i
 
 ### 1. CLI Mode (Default)
 
-The plugin will try to execute the `scad-convert` CLI command natively through your operating system. This requires the `scad-gltf` package to be installed globally (as shown in Prerequisites). This is the fastest and recommended method for Windows, macOS, and Linux desktops.
+The plugin will try to execute the `scad-gltf convert` CLI command natively through your operating system. This requires the `scad-gltf` package to be installed globally (as shown in Prerequisites). This is the fastest and recommended method for Windows, macOS, and Linux desktops.
 
 ### 2. Server Fallback Mode (Termux / Android / Portable)
 
@@ -53,7 +53,7 @@ It will look for a local backend server running on `127.0.0.1:3000`. To use this
 1. Open your terminal in your project directory.
 2. Run the server using `npx`:
    ```bash
-   npx -p scad-gltf scad-serve
+   npx scad-gltf serve
    ```
 3. Leave the server running in the background. Godot will now send your `.scad` code to this local server, compile it in memory, and import the resulting 3D mesh.
 

package/godot/addons/scad_importer/scad_importer.gd

@@ -16,27 +16,28 @@ func _import_scene(path: String, flags: int, options: Dictionary) -> Object:
 	var temp_glb_path = ProjectSettings.globalize_path("user://scad_cache_" + unique_id + ".glb")
 
 	var args = PackedStringArray()
+	args.append("convert")
 	args.append(global_source)
 	args.append(temp_glb_path)
 
 	var output = []
-	print("Importing %s via scad-convert..." % path.get_file())
+	print("Importing %s via scad-gltf..." % path.get_file())
 
 	var exit_code = -1
 	if OS.get_name() == "Windows":
-		var win_args = PackedStringArray(["/c", "scad-convert"])
+		var win_args = PackedStringArray(["/c", "scad-gltf"])
 		win_args.append_array(args)
 		exit_code = OS.execute("cmd.exe", win_args, output, true)
 	else:
-		exit_code = OS.execute("scad-convert", args, output, true)
+		exit_code = OS.execute("scad-gltf", args, output, true)
 
 	if exit_code != 0:
-		print("scad-convert conversion failed for %s. Attempting fallback to local scad-serve..." % path.get_file())
+		print("scad-gltf convert failed for %s. Attempting fallback to local scad-gltf serve..." % path.get_file())
 		var fallback_success = _try_scad_serve_fallback(global_source, temp_glb_path)
 
 		if not fallback_success:
-			push_error("Failed to compile SCAD file: %s. Ensure Node.js is installed or scad-serve is running." % path.get_file())
-			push_error("scad-convert output: ", "\n".join(output))
+			push_error("Failed to compile SCAD file: %s. Ensure Node.js is installed or scad-gltf serve is running." % path.get_file())
+			push_error("scad-gltf convert output: ", "\n".join(output))
 			return null
 
 	var gltf_doc = GLTFDocument.new()
@@ -194,7 +195,7 @@ func _try_scad_serve_fallback(source_path: String, out_glb_path: String) -> bool
 		out_file.store_buffer(rb)
 		out_file.close()
 
-		print("Successfully compiled %s using scad-serve fallback." % source_path.get_file())
+		print("Successfully compiled %s using scad-gltf serve fallback." % source_path.get_file())
 		return true
 
 	return false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scad-gltf",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "WASM build of a custom OpenSCAD fork that compiles .scad scripts directly to glTF/GLB with PBR and animation support",
   "type": "module",
   "main": "./src/ext/openscad.js",
@@ -32,14 +32,7 @@
     "editor/dist"
   ],
   "bin": {
-    "scad-convert": "./bin/scad-convert.js",
-    "scad-serve": "./bin/scad-serve.js",
-    "scad-mcp": "./bin/scad-mcp.js",
-    "scad-godot": "./bin/scad-godot.js",
-    "scad-web": "./bin/scad-web.js",
-    "scad-bevy": "./bin/scad-bevy.js",
-    "scad-gen": "./bin/scad-gen.js",
-    "scad-play": "./bin/scad-play.js"
+    "scad-gltf": "./bin/scad-gltf.js"
   },
   "exports": {
     ".": "./src/ext/openscad.js",
@@ -51,10 +44,8 @@
   },
   "scripts": {
     "format": "prettier --write .",
-    "mcp": "npx @modelcontextprotocol/inspector node ./bin/scad-mcp.js",
-    "prepublishOnly": "npm install --prefix editor && npm run build --prefix editor",
-    "build:godot": "node scripts/build-godot-web.js",
-    "deploy:godot": "gh-pages -d .godot-dist --repo git@github.com:iliagrigorevdev/scad-godot.git -b gh-pages"
+    "mcp": "npx @modelcontextprotocol/inspector node ./bin/mcp.js",
+    "prepublishOnly": "npm install --prefix editor && npm run build --prefix editor"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
@@ -63,7 +54,6 @@
     "puppeteer": "^25.9.0"
   },
   "devDependencies": {
-    "gh-pages": "^6.3.0",
     "prettier": "3.9.6"
   }
 }

package/src/cli-utils.js

@@ -19,7 +19,7 @@ export function hasStdinData() {
   }
 }
 
-export function parseTaskAndOptions() {
+export function parseTaskAndOptions(startIndex = 2) {
   let task = "";
   let optionsStr = "{}";
 
@@ -29,10 +29,10 @@ export function parseTaskAndOptions() {
     } catch (e) {
       console.error("Error reading from STDIN:", e);
     }
-    if (process.argv[2]) optionsStr = process.argv[2];
+    if (process.argv[startIndex]) optionsStr = process.argv[startIndex];
   } else {
-    if (process.argv[2]) task = process.argv[2];
-    if (process.argv[3]) optionsStr = process.argv[3];
+    if (process.argv[startIndex]) task = process.argv[startIndex];
+    if (process.argv[startIndex + 1]) optionsStr = process.argv[startIndex + 1];
   }
   return { task, optionsStr };
 }
@@ -145,7 +145,7 @@ export async function runAutomatedAIFlow(
   }
 
   const outputFilename = `generate_${projectType}_project.js`;
-  const isRawScad = projectType === "gen";
+  const isRawScad = projectType === "scad";
   const modelTag = modelName ? ` (${modelName})` : "";
 
   console.log(`\n🚀 Starting automated AI generation${modelTag}...`);
@@ -163,7 +163,7 @@ export async function runAutomatedAIFlow(
     console.log("🔌 Starting local SCAD MCP server...");
     mcpTransport = new mcpClientStdio.StdioClientTransport({
       command: process.execPath,
-      args: [path.resolve(__dirname, "../bin/scad-mcp.js")],
+      args: [path.resolve(__dirname, "../bin/mcp.js")],
     });
 
     mcpClient = new mcpClientIndex.Client(
@@ -460,7 +460,7 @@ export async function runAutomatedAIFlow(
             `\n🌐 Starting local viewer to preview ${extractedFilename}...`,
           );
 
-          const scadServePath = path.resolve(__dirname, "../bin/scad-serve.js");
+          const scadServePath = path.resolve(__dirname, "../bin/serve.js");
           runProc = spawn(process.execPath, [scadServePath], {
             cwd: tempDir,
             stdio: "inherit",
@@ -645,43 +645,32 @@ export async function runCliApp({
   buildSystemPrompt,
   buildInputRequest,
   allowedTools = ["render_scad_model"],
+  argStartIndex = 2,
 }) {
   if (!projectType) {
     throw new Error("projectType is required.");
   }
 
-  const appName = `scad-${projectType}`;
-  const isRawScad = projectType === "gen";
-
-  const { task, optionsStr } = parseTaskAndOptions();
+  const isRawScad = projectType === "scad";
+  const { task, optionsStr } = parseTaskAndOptions(argStartIndex);
 
   if (!task) {
     console.error("Error: Task parameter is required.");
+    console.error(
+      `Usage: scad-gltf gen ${projectType} "<description>" [options_json]`,
+    );
+    console.error(
+      `   or: echo "<description>" | scad-gltf gen ${projectType} [options_json]`,
+    );
+    console.error("");
+    console.error("Examples with JSON options (Automated AI flow):");
     if (isRawScad) {
       console.error(
-        `Usage: ${appName} "<description of the 3D model to generate>" [options_json]`,
-      );
-      console.error(`   or: echo "<description>" | ${appName} [options_json]`);
-      console.error("");
-      console.error("Examples with JSON options (Automated AI flow):");
-      console.error(
-        `  ${appName} "A modular sci-fi corridor piece" '{"openaiApiKey": "sk-...", "openaiModel": "gpt-4o"}'`,
-      );
-      console.error(
-        `  ${appName} "A medieval longsword" '{"openaiBaseUrl": "http://127.0.0.1:8080/v1", "openaiModel": "llama-3"}'`,
+        `  scad-gltf gen ${projectType} "A modular sci-fi corridor piece" '{"openaiApiKey": "sk-...", "openaiModel": "gpt-4o"}'`,
       );
     } else {
       console.error(
-        `Usage: ${appName} "<description of the game to generate>" [options_json]`,
-      );
-      console.error(`   or: echo "<description>" | ${appName} [options_json]`);
-      console.error("");
-      console.error("Examples with JSON options (Automated AI flow):");
-      console.error(
-        `  ${appName} "A simple 3D game" '{"openaiApiKey": "sk-...", "openaiModel": "gpt-4o"}'`,
-      );
-      console.error(
-        `  ${appName} "A simple 3D game" '{"openaiBaseUrl": "http://127.0.0.1:8080/v1", "openaiModel": "llama-3"}'`,
+        `  scad-gltf gen ${projectType} "A simple 3D game" '{"openaiApiKey": "sk-...", "openaiModel": "gpt-4o"}'`,
       );
     }
     process.exit(1);

package/src/project-prompts.js

@@ -0,0 +1,256 @@
+import fs from "node:fs";
+import path from "node:path";
+import url from "node:url";
+
+const __filename = url.fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const DIR = path.resolve(__dirname, "..");
+
+export function getProjectPrompts(projectType) {
+  if (projectType === "scad") {
+    return {
+      buildSystemPrompt: () =>
+        `You are an expert procedural 3D technical artist and OpenSCAD developer.
+Your goal is to generate a single OpenSCAD (.scad) file based on the user's request.
+
+CRITICAL WORKFLOW:
+1. Write the OpenSCAD code using the custom syntax rules provided in the request.
+2. Call the \`render_scad_model\` tool with your code to visually verify your design.
+3. If the model looks incorrect, adjust your code and re-render. Iterate until perfect.
+4. Provide your final OpenSCAD code in a standard markdown block (\`\`\`openscad).`,
+      allowedTools: ["render_scad_model"],
+    };
+  }
+
+  if (projectType === "bevy") {
+    return {
+      buildSystemPrompt: (
+        promptRules,
+      ) => `You are an expert Rust Bevy engine game developer and procedural 3D technical artist.
+
+NAMING CONVENTION REQUIREMENT:
+- All generated files, directories, models, scripts, and root folders MUST strictly use snake_case (lowercase with underscores, e.g. \`player_character.rs\`, \`enemy_walker.scad\`).
+- NEVER use hyphens/minus signs (\`-\`) or spaces in any file or folder names.
+
+What to generate:
+1. 3D Game Assets (.scad):
+   - Generate procedural 3D models for the game using OpenSCAD.
+   - CRITICAL: The SCAD to glTF converter automatically converts OpenSCAD's Z-up coordinate system to the standard glTF Y-up coordinate system. Design your models naturally in OpenSCAD.
+   - CRITICAL: You must use the custom OpenSCAD glTF extensions for PBR materials (e.g., \`roughness\`, \`metalness\`, \`emissive\`) and Hierarchical Node Animations (\`armature()\`, \`bone()\`). The rules and syntax for these features are provided below:
+
+=== OPENSCAD SYNTAX RULES ===
+${promptRules}
+=============================
+
+2. Rust Bevy Project Files:
+   - Create the necessary files for a modern Rust Bevy engine application (e.g., \`Cargo.toml\`, \`build.rs\`, \`src/main.rs\`).
+   - In \`Cargo.toml\`, include \`bevy\` as a dependency.
+   - You MUST include this EXACT \`build.rs\` script at the root of the project to automatically compile the \`.scad\` files into \`.glb\` format inside the \`assets/models\` folder before running the game via Cargo:
+     \`\`\`rust
+     use std::process::Command;
+
+     fn main() {
+         // Tell Cargo to re-run this script only if the 'scad' directory changes
+         println!("cargo::rerun-if-changed=scad");
+
+         // Ensure cross-platform compatibility for npm global binaries
+         let cmd = if cfg!(target_os = "windows") {
+             "scad-gltf.cmd"
+         } else {
+             "scad-gltf"
+         };
+
+         let status = Command::new(cmd)
+             .args(["convert", "./scad", "./assets/models", "--cache"])
+             .status()
+             .expect("Failed to execute scad-gltf. Is scad-gltf installed globally?");
+
+         if !status.success() {
+             panic!("scad-gltf convert failed with status: {}", status);
+         }
+     }
+     \`\`\`
+   - Write the core application logic in \`src/main.rs\` to load and display the converted \`.glb\` files interactively. Provide standard Bevy game systems (camera, lights, movement, etc.).
+
+3. Delivery Format (Single Node.js Script):
+   - Output exactly ONE self-contained Node.js script. Do not output manual setup instructions.
+   - CRITICAL: The generated Node.js script MUST first create a root project folder (named using a slugified version of the project name) and output all files and folders inside this newly created project folder.
+   - When executed, this script must programmatically create the entire project directory structure and write all the files to disk using the \`fs\` module.
+   - The script must embed and write:
+     - Your generated \`.scad\` 3D assets.
+     - Your generated Rust Bevy project files (\`Cargo.toml\`, \`build.rs\`, \`src/main.rs\`).
+   - Ensure all string file contents inside the Node.js script are properly escaped.`,
+      buildInputRequest: (task) =>
+        `Design and implement a Rust Bevy engine game for the following concept: "${task}"`,
+      allowedTools: ["render_scad_model", "compile_bevy_project"],
+    };
+  }
+
+  if (projectType === "web") {
+    return {
+      buildSystemPrompt: (
+        promptRules,
+      ) => `You are an expert Web 3D developer and procedural 3D technical artist.
+
+What to generate:
+1. 3D Web Assets (.scad):
+   - Generate procedural 3D models for the game using OpenSCAD.
+   - CRITICAL: The SCAD to glTF converter automatically converts OpenSCAD's Z-up coordinate system to the standard glTF Y-up coordinate system. Design your models naturally in OpenSCAD.
+   - CRITICAL: You must use the custom OpenSCAD glTF extensions for PBR materials (e.g., \`roughness\`, \`metalness\`, \`emissive\`) and Hierarchical Node Animations (\`armature()\`, \`bone()\`). The rules and syntax for these features are provided below:
+
+=== OPENSCAD SYNTAX RULES ===
+${promptRules}
+=============================
+
+2. Vite Web Project Files (npm based):
+   - Create the necessary files for a modern web application (e.g., \`package.json\`, \`index.html\`, \`main.js\`).
+   - You can use ANY web 3D library with glTF support (e.g., Three.js, Babylon.js, @google/model-viewer, PlayCanvas, A-Frame, etc.) that fits the game's requirements.
+   - In \`package.json\`, you MUST include the scad to gltf converter tool as a dev dependency:
+     \`"scad-gltf": "^0.3.0"\`
+   - In \`package.json\`, add npm scripts to automatically compile the \`.scad\` files into \`.glb\` format inside the \`public/\` folder before Vite runs its dev or build steps.
+     For example:
+     \`"predev": "scad-gltf convert ./scad ./public/models --cache"\`
+     \`"prebuild": "scad-gltf convert ./scad ./public/models --cache"\`
+   - Write the core game logic to load and display the converted \`.glb\` files interactively.
+
+3. Delivery Format (Single Node.js Script):
+   - Output exactly ONE self-contained Node.js script. Do not output manual setup instructions.
+   - CRITICAL: The generated Node.js script MUST first create a root project folder (named using a slugified version of the project name) and output all files and folders inside this newly created project folder.
+   - When executed, this script must programmatically create the entire project directory structure and write all the files to disk using the \`fs\` module.
+   - The script must embed and write:
+     - Your generated \`.scad\` 3D assets.
+     - Your generated Vite web project files.
+   - Ensure all string file contents inside the Node.js script are properly escaped.`,
+      buildInputRequest: (task) =>
+        `Design and implement a web-based 3D glTF game using Vite for the following concept: "${task}"`,
+      allowedTools: ["render_scad_model"],
+    };
+  }
+
+  if (projectType === "godot") {
+    return {
+      buildSystemPrompt: (promptRules, options = {}) => {
+        const hasUserScadFiles =
+          Array.isArray(options.scadFiles) && options.scadFiles.length > 0;
+
+        const systemPrompt = `You are an expert Godot 4 game developer and procedural 3D technical artist.
+
+NAMING CONVENTION REQUIREMENT:
+- All generated files, directories, models, scripts, scenes, and root folders MUST strictly use snake_case (lowercase with underscores, e.g. \`player_character.gd\`, \`main_scene.tscn\`, \`enemy_walker.scad\`).
+- NEVER use hyphens/minus signs (\`-\`) or spaces in any file or folder names.
+
+What to generate:
+1. 3D Game Assets (.scad):
+   - Generate procedural 3D models for the game using OpenSCAD.
+   - Scale & Units: 1 OpenSCAD unit = 1 Godot meter. Design your models using realistic meter-based scales (e.g., a character should be ~1.8 units tall). DO NOT use millimeter-based scaling.
+   - Coordinate System & Forward Convention: Write standard OpenSCAD Z-up code (+Z is UP, XY plane is ground). Build objects standing upright and facing Front (Positive Y-axis).
+   - Left/Right Convention: Always name and position "left" and "right" components (e.g., LeftArm, RightEye) based on the object's anatomical point of view (facing Forward towards +Y), NOT the camera/viewer's screen perspective. Because the object faces +Y, the object's Left side is along the -X axis, and the object's Right side is along the +X axis.
+   - CRITICAL Coordinate Mapping: The SCAD to glTF converter used by the Godot importer automatically converts OpenSCAD's Z-up coordinate system to Godot's Y-up coordinate system. Design your models naturally in OpenSCAD using this exact mapping:
+     * OpenSCAD +X (Right)   -> Godot +X (Right)
+     * OpenSCAD -X (Left)    -> Godot -X (Left)
+     * OpenSCAD +Y (Forward) -> Godot -Z (Forward)
+     * OpenSCAD -Y (Back)    -> Godot +Z (Back)
+     * OpenSCAD +Z (Up)      -> Godot +Y (Up)
+     DO NOT manually apply root rotations (e.g., \`rotate([90, 0, 0])\`) to compensate for Godot.
+   - CRITICAL: You must use the custom OpenSCAD glTF extensions for PBR materials (e.g., \`roughness\`, \`metalness\`, \`emissive\`) and Hierarchical Node Animations (\`armature()\`, \`bone()\`). The rules and syntax for these features are provided below:
+
+=== OPENSCAD SYNTAX RULES ===
+${promptRules}
+=============================
+
+2. Godot 4 Project Files:
+   - Create the necessary GDScript (\`.gd\`) and scene (\`.tscn\`) files to implement the game logic, responsive player input controls, and a core gameplay loop.
+   - The scenes should directly instance the generated \`.scad\` files (the provided addon will handle importing them as 3D scenes).
+   - GDScript Coordinate, Forward, and Left/Right Conventions:
+     * Forward is -Z: In Godot, \`Vector3.FORWARD\` is \`Vector3(0, 0, -1)\`. A 3D node's local forward direction is \`-transform.basis.z\` (or \`-global_transform.basis.z\`). In character movement, forward input (e.g., W or ui_up) must translate along \`-transform.basis.z\`. Never treat +Z as forward.
+     * Backward is +Z: \`Vector3.BACK\` is \`Vector3(0, 0, 1)\` (\`transform.basis.z\`).
+     * Right is +X: \`Vector3.RIGHT\` is \`Vector3(1, 0, 0)\` (\`transform.basis.x\`).
+     * Left is -X: \`Vector3.LEFT\` is \`Vector3(-1, 0, 0)\` (\`-transform.basis.x\`).
+     * Left/Right Convention in Godot Script: Maintain anatomical consistency in scripts—character Right is along +X (\`transform.basis.x\`) and character Left is along -X (\`-transform.basis.x\`).
+     * Natural Model Alignment: Because OpenSCAD models face +Y (Forward), they automatically import facing Godot's Forward direction (-Z). Built-in Godot methods like \`look_at()\` orient the node's -Z axis toward the target, which perfectly aligns with the model's front. Do NOT apply compensation rotations (e.g., \`rotate_y(PI)\`) in GDScript to compensate for model orientation.
+   - Generate a \`project.godot\` file. It must configure the project and automatically enable the \`scad_importer\` plugin.
+   - Generate a \`.gitignore\` file that ignores the \`.godot/\` folder.
+   - Generate a \`README.md\` file that documents the project, gameplay mechanics, and controls.
+
+3. Delivery Format (Single Node.js Script):
+   - Output exactly ONE self-contained Node.js script. Do not output manual setup instructions.
+   - CRITICAL: The generated Node.js script MUST first create a root project folder (named using snake_case with underscores, e.g., \`my_game_project\`) and output all files and folders inside this newly created project folder.
+   - When executed, this script must programmatically create the entire project directory structure and write all the files to disk using the \`fs\` module.
+   - The script must embed and write:
+     - Your generated \`.scad\` game assets.
+     - Your generated Godot project files.
+     - The exact source code of the provided \`addons/scad_importer/*\` files, placed in their correct respective paths.${
+       hasUserScadFiles
+         ? "\n     - The exact source code of the provided user `.scad` files, placed in the appropriate project folders."
+         : ""
+     }
+   - Ensure all string file contents inside the Node.js script are properly escaped.
+   - TESTING CAPABILITY: You have access to the \`test_godot_project\` tool. If you want to verify your code before outputting your final response, you can pass your complete generated Node.js script as the \`nodejs_script\` parameter. The server will execute it in a temporary folder and run the Godot tests automatically.`;
+
+        // Gather Addon Files content
+        const addonDir = path.join(DIR, "godot", "addons", "scad_importer");
+        let addonFiles = [];
+        try {
+          if (fs.existsSync(addonDir)) {
+            const files = fs.readdirSync(addonDir);
+            for (const file of files) {
+              const fullPath = path.join(addonDir, file);
+              if (
+                fs.statSync(fullPath).isFile() &&
+                (file.endsWith(".gd") || file.endsWith(".cfg"))
+              ) {
+                addonFiles.push(fullPath);
+              }
+            }
+          }
+        } catch (e) {
+          console.error("Warning: Could not read addon directory.", e);
+        }
+
+        let systemClipboardOutput = `${systemPrompt}\n\n`;
+
+        for (const file of addonFiles) {
+          try {
+            const content = fs
+              .readFileSync(file, "utf-8")
+              .replace(/\r\n/g, "\n");
+            const relativePath = path.relative(DIR, file).replace(/\\/g, "/");
+            const lang = file.endsWith(".gd") ? "gdscript" : "text";
+            systemClipboardOutput += `### ${relativePath}\n---\n\`\`\`${lang}\n${content}\n\`\`\`\n\n`;
+          } catch (e) {
+            console.error(
+              `Warning: Skipping '${file}'. It is not a readable file.`,
+            );
+          }
+        }
+
+        if (hasUserScadFiles) {
+          systemClipboardOutput += `=== USER PROVIDED OPENSCAD FILES ===\n`;
+          systemClipboardOutput += `The following .scad files are provided as reference or base assets. You MUST embed and write them into the generated project, modifying them if necessary to fit the game logic.\n\n`;
+          for (const file of options.scadFiles) {
+            try {
+              const content = fs
+                .readFileSync(file, "utf-8")
+                .replace(/\r\n/g, "\n");
+              const relativePath = path.isAbsolute(file)
+                ? path.relative(process.cwd(), file).replace(/\\/g, "/")
+                : file.replace(/\\/g, "/");
+              systemClipboardOutput += `### ${relativePath}\n---\n\`\`\`openscad\n${content}\n\`\`\`\n\n`;
+            } catch (e) {
+              console.error(
+                `Warning: Skipping user SCAD file '${file}'. It is not a readable file.`,
+              );
+            }
+          }
+        }
+
+        return systemClipboardOutput.trimEnd() + "\n";
+      },
+      buildInputRequest: (task) =>
+        `Design and implement a Godot 4 project for the following game concept: "${task}"`,
+      allowedTools: ["render_scad_model", "test_godot_project"],
+    };
+  }
+
+  throw new Error(`Unknown project type: ${projectType}`);
+}

package/bin/scad-bevy.js

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-
-import { runCliApp } from "../src/cli-utils.js";
-
-async function main() {
-  await runCliApp({
-    projectType: "bevy",
-    buildSystemPrompt: (
-      promptRules,
-    ) => `You are an expert Rust Bevy engine game developer and procedural 3D technical artist.
-
-NAMING CONVENTION REQUIREMENT:
-- All generated files, directories, models, scripts, and root folders MUST strictly use snake_case (lowercase with underscores, e.g. \`player_character.rs\`, \`enemy_walker.scad\`).
-- NEVER use hyphens/minus signs (\`-\`) or spaces in any file or folder names.
-
-What to generate:
-1. 3D Game Assets (.scad):
-   - Generate procedural 3D models for the game using OpenSCAD.
-   - CRITICAL: The SCAD to glTF converter automatically converts OpenSCAD's Z-up coordinate system to the standard glTF Y-up coordinate system. Design your models naturally in OpenSCAD.
-   - CRITICAL: You must use the custom OpenSCAD glTF extensions for PBR materials (e.g., \`roughness\`, \`metalness\`, \`emissive\`) and Hierarchical Node Animations (\`armature()\`, \`bone()\`). The rules and syntax for these features are provided below:
-
-=== OPENSCAD SYNTAX RULES ===
-${promptRules}
-=============================
-
-2. Rust Bevy Project Files:
-   - Create the necessary files for a modern Rust Bevy engine application (e.g., \`Cargo.toml\`, \`build.rs\`, \`src/main.rs\`).
-   - In \`Cargo.toml\`, include \`bevy\` as a dependency.
-   - You MUST include this EXACT \`build.rs\` script at the root of the project to automatically compile the \`.scad\` files into \`.glb\` format inside the \`assets/models\` folder before running the game via Cargo:
-     \`\`\`rust
-     use std::process::Command;
-
-     fn main() {
-         // Tell Cargo to re-run this script only if the 'scad' directory changes
-         println!("cargo::rerun-if-changed=scad");
-
-         // Ensure cross-platform compatibility for npm global binaries
-         let cmd = if cfg!(target_os = "windows") {
-             "scad-convert.cmd"
-         } else {
-             "scad-convert"
-         };
-
-         let status = Command::new(cmd)
-             .args(["./scad", "./assets/models", "--cache"])
-             .status()
-             .expect("Failed to execute scad-convert. Is scad-gltf installed globally?");
-
-         if !status.success() {
-             panic!("scad-convert failed with status: {}", status);
-         }
-     }
-     \`\`\`
-   - Write the core application logic in \`src/main.rs\` to load and display the converted \`.glb\` files interactively. Provide standard Bevy game systems (camera, lights, movement, etc.).
-
-3. Delivery Format (Single Node.js Script):
-   - Output exactly ONE self-contained Node.js script. Do not output manual setup instructions.
-   - CRITICAL: The generated Node.js script MUST first create a root project folder (named using a slugified version of the project name) and output all files and folders inside this newly created project folder.
-   - When executed, this script must programmatically create the entire project directory structure and write all the files to disk using the \`fs\` module.
-   - The script must embed and write:
-     - Your generated \`.scad\` 3D assets.
-     - Your generated Rust Bevy project files (\`Cargo.toml\`, \`build.rs\`, \`src/main.rs\`).
-   - Ensure all string file contents inside the Node.js script are properly escaped.`,
-    buildInputRequest: (task) =>
-      `Design and implement a Rust Bevy engine game for the following concept: "${task}"`,
-    allowedTools: ["render_scad_model", "compile_bevy_project"],
-  });
-}
-
-// Execute and handle unhandled runtime errors
-main().catch((err) => {
-  console.error("An unexpected error occurred:", err);
-  process.exit(1);
-});

package/bin/scad-gen.js

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-
-import { runCliApp } from "../src/cli-utils.js";
-
-async function main() {
-  await runCliApp({
-    projectType: "gen",
-    buildSystemPrompt: () =>
-      `You are an expert procedural 3D technical artist and OpenSCAD developer.
-Your goal is to generate a single OpenSCAD (.scad) file based on the user's request.
-
-CRITICAL WORKFLOW:
-1. Write the OpenSCAD code using the custom syntax rules provided in the request.
-2. Call the \`render_scad_model\` tool with your code to visually verify your design.
-3. If the model looks incorrect, adjust your code and re-render. Iterate until perfect.
-4. Provide your final OpenSCAD code in a standard markdown block (\`\`\`openscad).`,
-    allowedTools: ["render_scad_model"],
-  });
-}
-
-// Execute and handle unhandled runtime errors
-main().catch((err) => {
-  console.error("An unexpected error occurred:", err);
-  process.exit(1);
-});

package/bin/scad-godot.js

@@ -1,140 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import path from "node:path";
-import url from "node:url";
-import { runCliApp } from "../src/cli-utils.js";
-
-const __filename = url.fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const DIR = path.resolve(__dirname, "..");
-
-async function main() {
-  await runCliApp({
-    projectType: "godot",
-    buildSystemPrompt: (promptRules, options) => {
-      const hasUserScadFiles =
-        Array.isArray(options.scadFiles) && options.scadFiles.length > 0;
-
-      const systemPrompt = `You are an expert Godot 4 game developer and procedural 3D technical artist.
-
-NAMING CONVENTION REQUIREMENT:
-- All generated files, directories, models, scripts, scenes, and root folders MUST strictly use snake_case (lowercase with underscores, e.g. \`player_character.gd\`, \`main_scene.tscn\`, \`enemy_walker.scad\`).
-- NEVER use hyphens/minus signs (\`-\`) or spaces in any file or folder names.
-
-What to generate:
-1. 3D Game Assets (.scad):
-   - Generate procedural 3D models for the game using OpenSCAD.
-   - Scale & Units: 1 OpenSCAD unit = 1 Godot meter. Design your models using realistic meter-based scales (e.g., a character should be ~1.8 units tall). DO NOT use millimeter-based scaling.
-   - Coordinate System & Forward Convention: Write standard OpenSCAD Z-up code (+Z is UP, XY plane is ground). Build objects standing upright and facing Front (Positive Y-axis).
-   - Left/Right Convention: Always name and position "left" and "right" components (e.g., LeftArm, RightEye) based on the object's anatomical point of view (facing Forward towards +Y), NOT the camera/viewer's screen perspective. Because the object faces +Y, the object's Left side is along the -X axis, and the object's Right side is along the +X axis.
-   - CRITICAL Coordinate Mapping: The SCAD to glTF converter used by the Godot importer automatically converts OpenSCAD's Z-up coordinate system to Godot's Y-up coordinate system. Design your models naturally in OpenSCAD using this exact mapping:
-     * OpenSCAD +X (Right)   -> Godot +X (Right)
-     * OpenSCAD -X (Left)    -> Godot -X (Left)
-     * OpenSCAD +Y (Forward) -> Godot -Z (Forward)
-     * OpenSCAD -Y (Back)    -> Godot +Z (Back)
-     * OpenSCAD +Z (Up)      -> Godot +Y (Up)
-     DO NOT manually apply root rotations (e.g., \`rotate([90, 0, 0])\`) to compensate for Godot.
-   - CRITICAL: You must use the custom OpenSCAD glTF extensions for PBR materials (e.g., \`roughness\`, \`metalness\`, \`emissive\`) and Hierarchical Node Animations (\`armature()\`, \`bone()\`). The rules and syntax for these features are provided below:
-
-=== OPENSCAD SYNTAX RULES ===
-${promptRules}
-=============================
-
-2. Godot 4 Project Files:
-   - Create the necessary GDScript (\`.gd\`) and scene (\`.tscn\`) files to implement the game logic, responsive player input controls, and a core gameplay loop.
-   - The scenes should directly instance the generated \`.scad\` files (the provided addon will handle importing them as 3D scenes).
-   - GDScript Coordinate, Forward, and Left/Right Conventions:
-     * Forward is -Z: In Godot, \`Vector3.FORWARD\` is \`Vector3(0, 0, -1)\`. A 3D node's local forward direction is \`-transform.basis.z\` (or \`-global_transform.basis.z\`). In character movement, forward input (e.g., W or ui_up) must translate along \`-transform.basis.z\`. Never treat +Z as forward.
-     * Backward is +Z: \`Vector3.BACK\` is \`Vector3(0, 0, 1)\` (\`transform.basis.z\`).
-     * Right is +X: \`Vector3.RIGHT\` is \`Vector3(1, 0, 0)\` (\`transform.basis.x\`).
-     * Left is -X: \`Vector3.LEFT\` is \`Vector3(-1, 0, 0)\` (\`-transform.basis.x\`).
-     * Left/Right Convention in Godot Script: Maintain anatomical consistency in scripts—character Right is along +X (\`transform.basis.x\`) and character Left is along -X (\`-transform.basis.x\`).
-     * Natural Model Alignment: Because OpenSCAD models face +Y (Forward), they automatically import facing Godot's Forward direction (-Z). Built-in Godot methods like \`look_at()\` orient the node's -Z axis toward the target, which perfectly aligns with the model's front. Do NOT apply compensation rotations (e.g., \`rotate_y(PI)\`) in GDScript to compensate for model orientation.
-   - Generate a \`project.godot\` file. It must configure the project and automatically enable the \`scad_importer\` plugin.
-   - Generate a \`.gitignore\` file that ignores the \`.godot/\` folder.
-   - Generate a \`README.md\` file that documents the project, gameplay mechanics, and controls.
-
-3. Delivery Format (Single Node.js Script):
-   - Output exactly ONE self-contained Node.js script. Do not output manual setup instructions.
-   - CRITICAL: The generated Node.js script MUST first create a root project folder (named using snake_case with underscores, e.g., \`my_game_project\`) and output all files and folders inside this newly created project folder.
-   - When executed, this script must programmatically create the entire project directory structure and write all the files to disk using the \`fs\` module.
-   - The script must embed and write:
-     - Your generated \`.scad\` game assets.
-     - Your generated Godot project files.
-     - The exact source code of the provided \`addons/scad_importer/*\` files, placed in their correct respective paths.${
-       hasUserScadFiles
-         ? "\n     - The exact source code of the provided user `.scad` files, placed in the appropriate project folders."
-         : ""
-     }
-   - Ensure all string file contents inside the Node.js script are properly escaped.
-   - TESTING CAPABILITY: You have access to the \`test_godot_project\` tool. If you want to verify your code before outputting your final response, you can pass your complete generated Node.js script as the \`nodejs_script\` parameter. The server will execute it in a temporary folder and run the Godot tests automatically.`;
-
-      // Gather Addon Files content
-      const addonDir = path.join(DIR, "godot", "addons", "scad_importer");
-      let addonFiles = [];
-      try {
-        if (fs.existsSync(addonDir)) {
-          const files = fs.readdirSync(addonDir);
-          for (const file of files) {
-            const fullPath = path.join(addonDir, file);
-            if (
-              fs.statSync(fullPath).isFile() &&
-              (file.endsWith(".gd") || file.endsWith(".cfg"))
-            ) {
-              addonFiles.push(fullPath);
-            }
-          }
-        }
-      } catch (e) {
-        console.error("Warning: Could not read addon directory.", e);
-      }
-
-      let systemClipboardOutput = `${systemPrompt}\n\n`;
-
-      for (const file of addonFiles) {
-        try {
-          const content = fs.readFileSync(file, "utf-8").replace(/\r\n/g, "\n");
-          const relativePath = path.relative(DIR, file).replace(/\\/g, "/");
-          const lang = file.endsWith(".gd") ? "gdscript" : "text";
-          systemClipboardOutput += `### ${relativePath}\n---\n\`\`\`${lang}\n${content}\n\`\`\`\n\n`;
-        } catch (e) {
-          console.error(
-            `Warning: Skipping '${file}'. It is not a readable file.`,
-          );
-        }
-      }
-
-      if (hasUserScadFiles) {
-        systemClipboardOutput += `=== USER PROVIDED OPENSCAD FILES ===\n`;
-        systemClipboardOutput += `The following .scad files are provided as reference or base assets. You MUST embed and write them into the generated project, modifying them if necessary to fit the game logic.\n\n`;
-        for (const file of options.scadFiles) {
-          try {
-            const content = fs
-              .readFileSync(file, "utf-8")
-              .replace(/\r\n/g, "\n");
-            const relativePath = path.isAbsolute(file)
-              ? path.relative(process.cwd(), file).replace(/\\/g, "/")
-              : file.replace(/\\/g, "/");
-            systemClipboardOutput += `### ${relativePath}\n---\n\`\`\`openscad\n${content}\n\`\`\`\n\n`;
-          } catch (e) {
-            console.error(
-              `Warning: Skipping user SCAD file '${file}'. It is not a readable file.`,
-            );
-          }
-        }
-      }
-
-      return systemClipboardOutput.trimEnd() + "\n";
-    },
-    buildInputRequest: (task) =>
-      `Design and implement a Godot 4 project for the following game concept: "${task}"`,
-    allowedTools: ["render_scad_model", "test_godot_project"],
-  });
-}
-
-// Execute and handle unhandled runtime errors
-main().catch((err) => {
-  console.error("An unexpected error occurred:", err);
-  process.exit(1);
-});

package/bin/scad-web.js

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-
-import { runCliApp } from "../src/cli-utils.js";
-
-async function main() {
-  await runCliApp({
-    projectType: "web",
-    buildSystemPrompt: (
-      promptRules,
-    ) => `You are an expert Web 3D developer and procedural 3D technical artist.
-
-What to generate:
-1. 3D Web Assets (.scad):
-   - Generate procedural 3D models for the game using OpenSCAD.
-   - CRITICAL: The SCAD to glTF converter automatically converts OpenSCAD's Z-up coordinate system to the standard glTF Y-up coordinate system. Design your models naturally in OpenSCAD.
-   - CRITICAL: You must use the custom OpenSCAD glTF extensions for PBR materials (e.g., \`roughness\`, \`metalness\`, \`emissive\`) and Hierarchical Node Animations (\`armature()\`, \`bone()\`). The rules and syntax for these features are provided below:
-
-=== OPENSCAD SYNTAX RULES ===
-${promptRules}
-=============================
-
-2. Vite Web Project Files (npm based):
-   - Create the necessary files for a modern web application (e.g., \`package.json\`, \`index.html\`, \`main.js\`).
-   - You can use ANY web 3D library with glTF support (e.g., Three.js, Babylon.js, @google/model-viewer, PlayCanvas, A-Frame, etc.) that fits the game's requirements.
-   - In \`package.json\`, you MUST include the scad to gltf converter tool as a dev dependency:
-     \`"scad-gltf": "^0.1.0"\`
-   - In \`package.json\`, add npm scripts to automatically compile the \`.scad\` files into \`.glb\` format inside the \`public/\` folder before Vite runs its dev or build steps.
-     For example:
-     \`"predev": "scad-convert ./scad ./public/models --cache"\`
-     \`"prebuild": "scad-convert ./scad ./public/models --cache"\`
-   - Write the core game logic to load and display the converted \`.glb\` files interactively.
-
-3. Delivery Format (Single Node.js Script):
-   - Output exactly ONE self-contained Node.js script. Do not output manual setup instructions.
-   - CRITICAL: The generated Node.js script MUST first create a root project folder (named using a slugified version of the project name) and output all files and folders inside this newly created project folder.
-   - When executed, this script must programmatically create the entire project directory structure and write all the files to disk using the \`fs\` module.
-   - The script must embed and write:
-     - Your generated \`.scad\` 3D assets.
-     - Your generated Vite web project files.
-   - Ensure all string file contents inside the Node.js script are properly escaped.`,
-    buildInputRequest: (task) =>
-      `Design and implement a web-based 3D glTF game using Vite for the following concept: "${task}"`,
-    allowedTools: ["render_scad_model"],
-  });
-}
-
-// Execute and handle unhandled runtime errors
-main().catch((err) => {
-  console.error("An unexpected error occurred:", err);
-  process.exit(1);
-});