scad-gltf 0.5.0 → 0.6.0

package/README.md

@@ -25,7 +25,8 @@ The C++ source code for this custom OpenSCAD version is included directly in thi
 - **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-gltf 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.
-- **Project Runner:** Bundled `scad-gltf play` CLI utility to safely unpack, build, and launch generated game projects in isolated temporary environments.
+- **Project Runner:** Bundled `scad-gltf play` CLI utility to safely unpack, build, and launch generated Markdown projects in isolated temporary environments.
+- **Project Extractor:** Bundled `scad-gltf extract` CLI utility to permanently unpack AI-generated Markdown projects to your local filesystem.
 
 ---
 
@@ -286,7 +287,7 @@ If you installed the package globally, you can configure your MCP client to use
 
 ## Automated AI Generation (`scad-gltf gen`)
 
-By default, the `scad-gltf 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-gltf 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.
+By default, the `scad-gltf 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-gltf 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.md` file to your disk.
 
 **Supported Generation Types:**
 
@@ -341,25 +342,43 @@ scad-gltf gen godot "A game using the provided player model" '{"scadFiles": ["./
 _Once the automated process completes for full game projects, you can test it instantly using the `play` command:_
 
 ```bash
-scad-gltf play generate_godot_project.js
+scad-gltf play generate_godot_project.md
 ```
 
-_Alternatively, to extract the final project permanently into your current directory, just run the script with Node:_
+_Alternatively, to permanently unpack the project to your local filesystem, use the `extract` command:_
 
 ```bash
-node generate_godot_project.js
+scad-gltf extract generate_godot_project.md
 ```
 
 ---
 
 ## Testing Generated Projects (`scad-gltf play`)
 
-The `scad-gltf play` utility is designed to quickly test the single-file Node.js scripts produced by the `gen` command. Instead of cluttering your working directory, it unpacks the project into a temporary folder, automatically installs dependencies or builds the project (Godot, Rust Bevy, or Vite), and launches it. Once you close the application, the temporary folder is automatically cleaned up.
+The `scad-gltf play` utility is designed to quickly test the single-file Markdown projects produced by the `gen` command. Instead of cluttering your working directory, it unpacks the project into a temporary folder, automatically installs dependencies or builds the project (Godot, Rust Bevy, or Vite), and launches it. Once you close the application, the temporary folder is automatically cleaned up.
 
 **Usage:**
 
 ```bash
-scad-gltf play <path_to_generated_script.js>
+scad-gltf play <path_to_generated_project.md>
+```
+
+---
+
+## Extracting Generated Projects (`scad-gltf extract`)
+
+When you are satisfied with a generated project and want to continue developing it yourself, use the `scad-gltf extract` command to permanently unpack the Markdown file to your disk.
+
+It reads the `### filepath` headers and writes the code blocks to their respective directories.
+
+**Usage:**
+
+```bash
+# Extract files into the current working directory
+scad-gltf extract <path_to_generated_project.md>
+
+# Extract files into a specific directory
+scad-gltf extract <path_to_generated_project.md> ./my_new_game
 ```
 
 ---

package/bin/extract.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import {
+  extractFilesFromMarkdown,
+  writeExtractedFiles,
+} from "../src/cli-utils.js";
+
+const args = process.argv.slice(2);
+const mdPath = args[0];
+const outDir = args[1] || process.cwd();
+
+if (!mdPath) {
+  console.error(
+    "❌ Error: Path to the generated Markdown project file is required.",
+  );
+  console.error("Usage: scad-gltf extract <project.md> [output_directory]");
+  process.exit(1);
+}
+
+const absMdPath = path.resolve(process.cwd(), mdPath);
+if (!fs.existsSync(absMdPath)) {
+  console.error(`❌ Error: File not found: ${absMdPath}`);
+  process.exit(1);
+}
+
+try {
+  console.log(
+    `📦 Extracting project files from ${path.basename(absMdPath)}...`,
+  );
+
+  const mdContent = fs.readFileSync(absMdPath, "utf-8");
+  const files = extractFilesFromMarkdown(mdContent);
+  const fileCount = Object.keys(files).length;
+
+  if (fileCount === 0) {
+    console.error("\n❌ Error: No files could be extracted.");
+    console.error(
+      "Make sure the Markdown uses '### filepath' headers followed by code blocks.",
+    );
+    process.exit(1);
+  }
+
+  const absOutDir = path.resolve(process.cwd(), outDir);
+  writeExtractedFiles(files, absOutDir);
+
+  console.log(
+    `\n✅ Successfully extracted ${fileCount} file(s) to:\n   ${absOutDir}`,
+  );
+} catch (err) {
+  console.error(`\n❌ Extraction failed: ${err.message}`);
+  process.exit(1);
+}

package/bin/mcp.js

@@ -15,7 +15,11 @@ import { convertScadToGltf } from "../src/convert.js";
 import { generatePrompt } from "../src/prompt.js";
 import { getProjectPrompts } from "../src/project-prompts.js";
 import { runGodotAsync } from "../src/godot-utils.js";
-import { generateScadPreviewUrl } from "../src/cli-utils.js";
+import {
+  generateScadPreviewUrl,
+  extractFilesFromMarkdown,
+  writeExtractedFiles,
+} from "../src/cli-utils.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -43,7 +47,7 @@ global.fetch = async (url, options) => {
 const server = new Server(
   {
     name: "scad-mcp-server",
-    version: "1.3.0",
+    version: "1.4.0",
   },
   {
     capabilities: {
@@ -216,19 +220,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       {
         name: "test_godot_project",
         description:
-          "Runs a specified Godot project for a short duration to detect script errors, missing resources, or runtime crashes. Returns the console output logs and a visual screenshot of the running project.",
+          "Extracts a Godot project from a Markdown format and runs it for a short duration to detect script errors, missing resources, or runtime crashes. Returns the console output logs and a visual screenshot.",
         inputSchema: {
           type: "object",
           properties: {
-            project_dir: {
-              type: "string",
-              description:
-                "The relative or absolute path to the directory containing project.godot. Use this if the project is already extracted on disk.",
-            },
-            nodejs_script: {
+            project_markdown: {
               type: "string",
               description:
-                "The complete self-contained Node.js script that generates the Godot project. If provided, the tool will execute this script in a temporary directory to extract the project before testing it. Use this during the generation phase to test your code before providing the final answer.",
+                "The complete markdown string containing all project files formatted with '### filepath' headers and code blocks.",
             },
             run_time: {
               type: "number",
@@ -238,29 +237,26 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             return_images: {
               type: "boolean",
               description:
-                "Capture a screenshot of the project. Set to false for text-only logs (faster). Default is true.",
+                "Capture a screenshot of the project. Set to false for text-only logs. Default is true.",
             },
           },
+          required: ["project_markdown"],
         },
       },
       {
         name: "compile_rust_project",
         description:
-          "Compiles a specified Rust project to detect syntax errors, missing dependencies, or compilation failures. Returns the cargo console output logs.",
+          "Extracts a Rust project from a Markdown format and compiles it to detect syntax errors, missing dependencies, or compilation failures. Returns the cargo console output logs.",
         inputSchema: {
           type: "object",
           properties: {
-            project_dir: {
+            project_markdown: {
               type: "string",
               description:
-                "The relative or absolute path to the directory containing Cargo.toml. Use this if the project is already extracted on disk.",
-            },
-            nodejs_script: {
-              type: "string",
-              description:
-                "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.",
+                "The complete markdown string containing all project files formatted with '### filepath' headers and code blocks.",
             },
           },
+          required: ["project_markdown"],
         },
       },
     ],
@@ -786,81 +782,60 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
       let projectDir = null;
       const runTime = args.run_time || 5.0;
+      const markdown = args.project_markdown;
 
-      if (args.nodejs_script) {
-        // Create a unique temporary directory
-        const tempBase = fs.mkdtempSync(
-          path.join(os.tmpdir(), "scad-godot-test-"),
-        );
-        cleanupDir = tempBase;
-
-        const scriptPath = path.join(tempBase, "generate.js");
-        fs.writeFileSync(scriptPath, args.nodejs_script, "utf-8");
-
-        try {
-          execSync(`node generate.js`, {
-            cwd: tempBase,
-            stdio: "pipe",
-            timeout: 15000, // Time out after 15 seconds if it hangs
-          });
-        } catch (err) {
-          const stderr = err.stderr ? err.stderr.toString() : "";
-          const stdout = err.stdout ? err.stdout.toString() : "";
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: The Node.js script failed to execute properly.\n\nSTDERR:\n${stderr}\n\nSTDOUT:\n${stdout}\n\nException: ${err.message}`,
-              },
-            ],
-            isError: true,
-          };
-        }
+      if (!markdown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: 'project_markdown' is required.`,
+            },
+          ],
+          isError: true,
+        };
+      }
 
-        // Find the generated folder containing project.godot
-        const items = fs.readdirSync(tempBase);
-        for (const item of items) {
-          const itemPath = path.join(tempBase, item);
-          if (
-            fs.statSync(itemPath).isDirectory() &&
-            fs.existsSync(path.join(itemPath, "project.godot"))
-          ) {
-            projectDir = itemPath;
-            break;
-          }
-        }
+      // Create a unique temporary directory
+      const tempBase = fs.mkdtempSync(
+        path.join(os.tmpdir(), "scad-godot-test-"),
+      );
+      cleanupDir = tempBase;
 
-        if (!projectDir) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: The Node.js script finished running, but NO Godot project was found. A valid Godot project requires a 'project.godot' file. Ensure your script creates a root project directory and places 'project.godot' inside it.`,
-              },
-            ],
-            isError: true,
-          };
-        }
-      } else if (args.project_dir) {
-        projectDir = path.resolve(process.cwd(), args.project_dir);
-      } else {
+      const files = extractFilesFromMarkdown(markdown);
+      if (Object.keys(files).length === 0) {
         return {
           content: [
             {
               type: "text",
-              text: `Error: Invalid arguments. You must provide either 'project_dir' or 'nodejs_script'.`,
+              text: `Error: No files could be extracted from the Markdown text. Make sure you use '### filepath' headers followed by code blocks.`,
             },
           ],
           isError: true,
         };
       }
 
-      if (!fs.existsSync(path.join(projectDir, "project.godot"))) {
+      writeExtractedFiles(files, tempBase);
+
+      // Find the generated folder containing project.godot
+      const items = fs.readdirSync(tempBase);
+      for (const item of items) {
+        const itemPath = path.join(tempBase, item);
+        if (
+          fs.statSync(itemPath).isDirectory() &&
+          fs.existsSync(path.join(itemPath, "project.godot"))
+        ) {
+          projectDir = itemPath;
+          break;
+        }
+      }
+
+      if (!projectDir) {
         return {
           content: [
             {
               type: "text",
-              text: `Error: The specified directory is not a valid Godot project. 'project.godot' was not found in: ${projectDir}`,
+              text: `Error: The extracted Markdown output did not contain a valid Godot project. A valid Godot project requires a 'project.godot' file placed inside a root directory block.`,
             },
           ],
           isError: true,
@@ -1081,81 +1056,60 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     let cleanupDir = null;
     try {
       let projectDir = null;
+      const markdown = args.project_markdown;
 
-      if (args.nodejs_script) {
-        // Create a unique temporary directory
-        const tempBase = fs.mkdtempSync(
-          path.join(os.tmpdir(), "scad-rust-compile-"),
-        );
-        cleanupDir = tempBase;
-
-        const scriptPath = path.join(tempBase, "generate.js");
-        fs.writeFileSync(scriptPath, args.nodejs_script, "utf-8");
-
-        try {
-          execSync(`node generate.js`, {
-            cwd: tempBase,
-            stdio: "pipe",
-            timeout: 15000, // Time out after 15 seconds if it hangs
-          });
-        } catch (err) {
-          const stderr = err.stderr ? err.stderr.toString() : "";
-          const stdout = err.stdout ? err.stdout.toString() : "";
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: The Node.js script failed to execute properly.\n\nSTDERR:\n${stderr}\n\nSTDOUT:\n${stdout}\n\nException: ${err.message}`,
-              },
-            ],
-            isError: true,
-          };
-        }
+      if (!markdown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: 'project_markdown' is required.`,
+            },
+          ],
+          isError: true,
+        };
+      }
 
-        // Find the generated folder containing Cargo.toml
-        const items = fs.readdirSync(tempBase);
-        for (const item of items) {
-          const itemPath = path.join(tempBase, item);
-          if (
-            fs.statSync(itemPath).isDirectory() &&
-            fs.existsSync(path.join(itemPath, "Cargo.toml"))
-          ) {
-            projectDir = itemPath;
-            break;
-          }
-        }
+      // Create a unique temporary directory
+      const tempBase = fs.mkdtempSync(
+        path.join(os.tmpdir(), "scad-rust-compile-"),
+      );
+      cleanupDir = tempBase;
 
-        if (!projectDir) {
-          return {
-            content: [
-              {
-                type: "text",
-                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,
-          };
-        }
-      } else if (args.project_dir) {
-        projectDir = path.resolve(process.cwd(), args.project_dir);
-      } else {
+      const files = extractFilesFromMarkdown(markdown);
+      if (Object.keys(files).length === 0) {
         return {
           content: [
             {
               type: "text",
-              text: `Error: Invalid arguments. You must provide either 'project_dir' or 'nodejs_script'.`,
+              text: `Error: No files could be extracted from the Markdown text. Make sure you use '### filepath' headers followed by code blocks.`,
             },
           ],
           isError: true,
         };
       }
 
-      if (!fs.existsSync(path.join(projectDir, "Cargo.toml"))) {
+      writeExtractedFiles(files, tempBase);
+
+      // Find the generated folder containing Cargo.toml
+      const items = fs.readdirSync(tempBase);
+      for (const item of items) {
+        const itemPath = path.join(tempBase, item);
+        if (
+          fs.statSync(itemPath).isDirectory() &&
+          fs.existsSync(path.join(itemPath, "Cargo.toml"))
+        ) {
+          projectDir = itemPath;
+          break;
+        }
+      }
+
+      if (!projectDir) {
         return {
           content: [
             {
               type: "text",
-              text: `Error: The specified directory is not a valid Rust project. 'Cargo.toml' was not found in: ${projectDir}`,
+              text: `Error: The extracted Markdown output did not contain a valid Rust project. A valid Rust project requires a 'Cargo.toml' file placed inside a root directory block.`,
             },
           ],
           isError: true,

package/bin/play.js

@@ -5,15 +5,19 @@ import path from "node:path";
 import os from "node:os";
 import { execSync, spawn } from "node:child_process";
 import { getGodotBin } from "../src/godot-utils.js";
+import {
+  extractFilesFromMarkdown,
+  writeExtractedFiles,
+} from "../src/cli-utils.js";
 
 function main() {
   const packedScriptPath = process.argv[2];
 
   if (!packedScriptPath) {
     console.error(
-      "❌ Error: Path to the packed Node.js generator script is required.",
+      "❌ Error: Path to the generated Markdown project file is required.",
     );
-    console.error("Usage: scad-gltf play <path_to_generated_project.js>");
+    console.error("Usage: scad-gltf play <path_to_generated_project.md>");
     process.exit(1);
   }
 
@@ -25,7 +29,7 @@ function main() {
 
   // 1. Create a unique temporary directory
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "scad-play-"));
-  console.log(`📦 Unpacking script to temporary directory...\n   ${tempDir}`);
+  console.log(`📦 Unpacking project to temporary directory...\n   ${tempDir}`);
 
   let appProcess = null;
 
@@ -54,11 +58,38 @@ function main() {
   });
 
   try {
-    // 2. Execute the packed Node.js script inside the temp directory
-    console.log(
-      `\n⚙️  Running generator script: ${path.basename(absScriptPath)}`,
-    );
-    execSync(`node "${absScriptPath}"`, { cwd: tempDir, stdio: "inherit" });
+    const ext = path.extname(absScriptPath).toLowerCase();
+
+    // 2. Extract files based on extension
+    if (ext === ".js") {
+      // Legacy support for older node.js script generations
+      console.log(
+        `\n⚙️  Running legacy generator script: ${path.basename(absScriptPath)}`,
+      );
+      execSync(`node "${absScriptPath}"`, { cwd: tempDir, stdio: "inherit" });
+    } else if (ext === ".md") {
+      console.log(
+        `\n⚙️  Extracting Markdown project: ${path.basename(absScriptPath)}`,
+      );
+      const mdContent = fs.readFileSync(absScriptPath, "utf-8");
+      const files = extractFilesFromMarkdown(mdContent);
+
+      if (Object.keys(files).length === 0) {
+        console.error(
+          "\n❌ Error: No files could be extracted from the Markdown. Make sure it uses '### filepath' headers followed by code blocks.",
+        );
+        cleanup();
+        process.exit(1);
+      }
+
+      writeExtractedFiles(files, tempDir);
+    } else {
+      console.error(
+        "\n❌ Error: Unsupported file type. Please provide a .md or .js generated project file.",
+      );
+      cleanup();
+      process.exit(1);
+    }
 
     // 3. Find the resulting project folder and determine its type
     let projectDir = null;
@@ -87,14 +118,14 @@ function main() {
     if (!projectDir || !projectType) {
       console.error("\n❌ Error: Could not find a valid generated project.");
       console.error(
-        "The script did not produce a folder containing 'project.godot', 'package.json', or 'Cargo.toml'.",
+        "The project did not contain a root folder holding 'project.godot', 'package.json', or 'Cargo.toml'.",
       );
       cleanup();
       process.exit(1);
     }
 
     console.log(
-      `\n✔️  Found generated ${projectType.toUpperCase()} project: ${path.basename(projectDir)}`,
+      `\n✔️  Found extracted ${projectType.toUpperCase()} project: ${path.basename(projectDir)}`,
     );
 
     // 4. Boot the corresponding environment

package/bin/scad-gltf.js

@@ -8,6 +8,7 @@ const commands = {
   mcp: "./mcp.js",
   gen: "./gen.js",
   play: "./play.js",
+  extract: "./extract.js",
 };
 
 if (!command || !commands[command]) {
@@ -19,7 +20,12 @@ if (!command || !commands[command]) {
   console.error(
     "  gen       Automated AI generation of 3D models, simulations, and interactive projects",
   );
-  console.error("  play      Test and launch generated Node.js scripts");
+  console.error(
+    "  play      Test and launch generated projects in a temporary folder",
+  );
+  console.error(
+    "  extract   Extract a generated Markdown project to your local filesystem",
+  );
   process.exit(1);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scad-gltf",
-  "version": "0.5.0",
+  "version": "0.6.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",
@@ -29,6 +29,7 @@
     "bin",
     "src",
     "godot",
+    "rust",
     "editor/dist"
   ],
   "bin": {
@@ -43,9 +44,10 @@
     "./openscad.wasm": "./src/ext/openscad.wasm"
   },
   "scripts": {
+    "test": "node --test 'test/**/*.test.js'",
     "format": "prettier --write .",
     "mcp": "npx @modelcontextprotocol/inspector node ./bin/mcp.js",
-    "prepublishOnly": "npm install --prefix editor && npm run build --prefix editor"
+    "prepublishOnly": "npm test && npm install --prefix editor && npm run build --prefix editor"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.31.0",

package/rust/build.rs

@@ -0,0 +1,22 @@
+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);
+    }
+}

package/src/cli-utils.js

@@ -157,6 +157,59 @@ export function generateScadPreviewUrl(
   }
 }
 
+export function extractFilesFromMarkdown(mdContent) {
+  const files = {};
+  const lines = mdContent.split("\n");
+  let currentFile = null;
+  let inCodeBlock = false;
+  let currentContent = [];
+
+  // \S+ ensures the header is a single continuous path without spaces,
+  // preventing regular English markdown headers from being parsed as files.
+  const headerMatchRegex = /^###\s+(\S+)\s*$/;
+
+  for (const line of lines) {
+    const headerMatch = line.match(headerMatchRegex);
+    if (headerMatch) {
+      currentFile = headerMatch[1];
+      inCodeBlock = false;
+      currentContent = [];
+      continue;
+    }
+
+    if (currentFile) {
+      if (line.startsWith("```")) {
+        if (inCodeBlock) {
+          // Close block and save
+          files[currentFile] = currentContent.join("\n");
+          currentFile = null;
+          inCodeBlock = false;
+        } else {
+          // Open block
+          inCodeBlock = true;
+          currentContent = [];
+        }
+      } else if (inCodeBlock) {
+        currentContent.push(line);
+      }
+    }
+  }
+
+  return files;
+}
+
+export function writeExtractedFiles(files, targetDir) {
+  for (const [filepath, content] of Object.entries(files)) {
+    // Prevent directory traversal attacks
+    const safePath = path.normalize(filepath).replace(/^(\.\.(\/|\\|$))+/, "");
+    const absPath = path.resolve(targetDir, safePath);
+    if (!absPath.startsWith(path.resolve(targetDir))) continue;
+
+    fs.mkdirSync(path.dirname(absPath), { recursive: true });
+    fs.writeFileSync(absPath, content, "utf-8");
+  }
+}
+
 export async function runAutomatedAIFlow(
   apiKey,
   baseUrl,
@@ -177,8 +230,10 @@ export async function runAutomatedAIFlow(
     process.argv.includes("-v") ||
     process.env.VERBOSE,
   );
-  const outputFilename = `generate_${projectType}_project.js`;
+
+  // Output a Markdown file for non-raw scad projects instead of a JS script
   const isRawScad = projectType === "scad";
+  const outputFilename = `generate_${projectType}_project.${isRawScad ? "scad" : "md"}`;
   const modelTag = modelName ? ` (${modelName})` : "";
 
   console.log(`\n🚀 Starting automated AI generation${modelTag}...`);
@@ -241,10 +296,12 @@ export async function runAutomatedAIFlow(
     );
   }
 
-  let messages = [
-    { role: "system", content: systemPrompt },
-    { role: "user", content: inputRequest },
-  ];
+  let messages = isRawScad
+    ? [{ role: "user", content: systemPrompt }]
+    : [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: inputRequest },
+      ];
 
   let iterations = 0;
   const maxIterations = 30;
@@ -462,10 +519,9 @@ export async function runAutomatedAIFlow(
         const finalText = message.content || "";
         console.log("\n✅ AI proposed a final code version.");
 
-        let finalCode = "";
+        let finalCode = finalText.trim();
         let extractedFilename = outputFilename;
 
-        // Extract the code payload based on the project type target
         if (isRawScad) {
           const match = finalText.match(
             /```(?:openscad|scad)?\n([\s\S]*?)```/i,
@@ -484,11 +540,6 @@ export async function runAutomatedAIFlow(
             if (!safeName.endsWith(".scad")) safeName += ".scad";
             extractedFilename = safeName;
           }
-        } else {
-          const match = finalText.match(
-            /```(?:javascript|js|node)?\n([\s\S]*?)```/i,
-          );
-          finalCode = match ? match[1].trim() : finalText.trim();
         }
 
         const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "scad-preview-"));
@@ -509,14 +560,16 @@ export async function runAutomatedAIFlow(
             }
           } else {
             console.log(
-              `   Generating project files to preview in a temporary folder...`,
+              `   Extracting Markdown project files to temporary folder...`,
             );
-            console.log(`   Temp script: ${tempFilePath}`);
+            const files = extractFilesFromMarkdown(finalCode);
 
-            execSync(`node "${tempFilePath}"`, {
-              cwd: tempDir,
-              stdio: "pipe",
-            });
+            if (Object.keys(files).length === 0) {
+              throw new Error(
+                "No files could be extracted from the AI's Markdown output. Ensure it uses the '### filepath' format.",
+              );
+            }
+            writeExtractedFiles(files, tempDir);
 
             let projectDir = null;
             let latestTime = 0;
@@ -558,7 +611,7 @@ export async function runAutomatedAIFlow(
                     : "package.json";
               messages.push({
                 role: "user",
-                content: `Your script successfully executed, but no valid project directory was found. Make sure your script creates a root folder and generates the correct required files (like ${expectedFile}) inside it.`,
+                content: `Your generated output successfully parsed, but no valid project directory was found. Make sure you place the required files (like ${expectedFile}) inside a root project folder block.`,
               });
               continue;
             }
@@ -632,7 +685,7 @@ export async function runAutomatedAIFlow(
 
             if (!isRawScad) {
               console.log(
-                `▶️  Run it again later to unpack the final project with: node ${extractedFilename}`,
+                `▶️  Run it again later to unpack and play the final project with: scad-gltf play ${extractedFilename}`,
               );
             }
 
@@ -641,7 +694,7 @@ export async function runAutomatedAIFlow(
             console.log("\n🔄 Sending your feedback back to the LLM...");
             messages.push({
               role: "user",
-              content: `I reviewed the current version. Here is my feedback to improve it:\n\n${feedback}\n\nPlease implement these fixes and output an updated ${isRawScad ? "OpenSCAD block" : "Node.js script"}.`,
+              content: `I reviewed the current version. Here is my feedback to improve it:\n\n${feedback}\n\nPlease implement these fixes and output an updated ${isRawScad ? "OpenSCAD block" : "Markdown project file"}.`,
             });
           }
         } catch (err) {
@@ -651,7 +704,7 @@ export async function runAutomatedAIFlow(
           );
           messages.push({
             role: "user",
-            content: `Your generated code threw an error when I tried to run/preview it locally:\n${stderr}\n\nPlease fix the ${isRawScad ? "OpenSCAD code" : "Node.js script"}.`,
+            content: `Your generated code threw an error when I tried to run/preview it locally:\n${stderr}\n\nPlease fix the ${isRawScad ? "OpenSCAD code" : "Markdown output format"}.`,
           });
         } finally {
           if (runProc) {

package/src/godot-utils.js

@@ -1,8 +1,8 @@
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { execSync, spawn } from "child_process";
-import { fileURLToPath } from "url";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import cp from "node:child_process";
+import { fileURLToPath } from "node:url";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -37,7 +37,7 @@ export function ensureExportTemplates() {
     fs.mkdirSync(BIN_DIR, { recursive: true });
 
     const tpzPath = path.join(BIN_DIR, "templates.tpz");
-    execSync(
+    cp.execSync(
       `curl -fL "https://github.com/godotengine/godot/releases/download/${GODOT_VERSION}/Godot_v${GODOT_VERSION}_export_templates.tpz" -o "${tpzPath}"`,
       { stdio: "inherit" },
     );
@@ -46,9 +46,11 @@ export function ensureExportTemplates() {
     fs.mkdirSync(extractTemp, { recursive: true });
 
     if (os.platform() === "win32") {
-      execSync(`tar -xf "${tpzPath}" -C "${extractTemp}"`, { stdio: "ignore" });
+      cp.execSync(`tar -xf "${tpzPath}" -C "${extractTemp}"`, {
+        stdio: "ignore",
+      });
     } else {
-      execSync(`unzip -q -o "${tpzPath}" -d "${extractTemp}"`, {
+      cp.execSync(`unzip -q -o "${tpzPath}" -d "${extractTemp}"`, {
         stdio: "ignore",
       });
     }
@@ -67,7 +69,7 @@ export function ensureExportTemplates() {
 
 export function getGodotBin(withTemplates = false) {
   try {
-    execSync("godot --version", { stdio: "ignore" });
+    cp.execSync("godot --version", { stdio: "ignore" });
     if (withTemplates) ensureExportTemplates();
     return "godot";
   } catch {
@@ -101,12 +103,14 @@ export function getGodotBin(withTemplates = false) {
       }
 
       const zipPath = path.join(BIN_DIR, "godot.zip");
-      execSync(`curl -fL "${zipUrl}" -o "${zipPath}"`, { stdio: "ignore" });
+      cp.execSync(`curl -fL "${zipUrl}" -o "${zipPath}"`, { stdio: "ignore" });
 
       if (isWin) {
-        execSync(`tar -xf "${zipPath}" -C "${BIN_DIR}"`, { stdio: "ignore" });
+        cp.execSync(`tar -xf "${zipPath}" -C "${BIN_DIR}"`, {
+          stdio: "ignore",
+        });
       } else {
-        execSync(`unzip -q -o "${zipPath}" -d "${BIN_DIR}"`, {
+        cp.execSync(`unzip -q -o "${zipPath}" -d "${BIN_DIR}"`, {
           stdio: "ignore",
         });
       }
@@ -153,7 +157,7 @@ export function runGodotAsync(args, cwd, timeoutMs) {
       spawnBin = "xvfb-run";
     }
 
-    const godotProcess = spawn(spawnBin, spawnArgs, { cwd, env });
+    const godotProcess = cp.spawn(spawnBin, spawnArgs, { cwd, env });
 
     godotProcess.stdout.on("data", (data) => {
       output += data.toString();

package/src/project-prompts.js

@@ -16,7 +16,7 @@ function readFile(filePath) {
 }
 
 function formatMarkdownFile(displayPath, lang, content) {
-  return `### ${displayPath}\n---\n\`\`\`${lang}\n${content}\n\`\`\`\n\n`;
+  return `### ${displayPath}\n\`\`\`${lang}\n${content}\n\`\`\`\n\n`;
 }
 
 function appendUserScadFiles(options = {}, isRawScad = false) {
@@ -46,6 +46,90 @@ function appendUserScadFiles(options = {}, isRawScad = false) {
   return output;
 }
 
+function getScadAssetsInstructions(promptRules, projectType) {
+  let specificRules = "";
+  if (projectType === "godot") {
+    specificRules = `   - 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.`;
+  } else {
+    specificRules = `   - 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.`;
+  }
+
+  return `1. 3D Assets (.scad):
+   - Generate procedural 3D models for the project using OpenSCAD.
+${specificRules}
+   - 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}
+=============================`;
+}
+
+function getDeliveryFormat(projectType, frameworkName, hasUserScadFiles) {
+  let exampleCode = "";
+  let includes = "";
+
+  if (projectType === "bevy" || projectType === "wgpu") {
+    exampleCode = `     ### my_project/Cargo.toml
+     \`\`\`toml
+     [package]
+     name = "my_project"
+     ...
+     \`\`\`
+     ### my_project/src/main.rs
+     \`\`\`rust
+     fn main() {}
+     \`\`\``;
+    includes = `     - Your generated Rust ${frameworkName} project files (\`Cargo.toml\`, \`src/main.rs\`).
+     - The exact source code of the provided \`build.rs\` file, placed in the project root.`;
+  } else if (projectType === "web") {
+    exampleCode = `     ### my_project/package.json
+     \`\`\`json
+     {
+       "name": "my_project"
+     }
+     \`\`\`
+     ### my_project/main.js
+     \`\`\`javascript
+     console.log("Started");
+     \`\`\``;
+    includes = `     - Your generated Vite web project files.`;
+  } else if (projectType === "godot") {
+    exampleCode = `     ### my_project/project.godot
+     \`\`\`ini
+     config_version=5
+     \`\`\`
+     ### my_project/main.gd
+     \`\`\`gdscript
+     extends Node
+     \`\`\``;
+    includes = `     - Your generated Godot project files.
+     - The exact source code of the provided \`addons/scad_importer/*\` files, placed in their correct respective paths.`;
+  }
+
+  return `3. Delivery Format (Single Markdown File):
+   - Output exactly ONE Markdown response containing all project files.
+   - Format EACH file with a Markdown header specifying the relative file path (using snake_case directories), followed immediately by a code block containing the file's contents.
+   - Example Format:
+${exampleCode}
+   - The project files must be placed inside a root project folder (e.g., \`my_project/\`).
+   - You must include and write:
+     - Your generated \`.scad\` 3D assets.
+${includes}${
+    hasUserScadFiles
+      ? "\n     - The provided user `.scad` files (modified if necessary), placed in the appropriate project folders."
+      : ""
+  }`;
+}
+
 export function getProjectPrompts(projectType) {
   if (projectType === "scad") {
     return {
@@ -78,14 +162,7 @@ NAMING CONVENTION REQUIREMENT:
 - NEVER use hyphens/minus signs (\`-\`) or spaces in any file or folder names.
 
 What to generate:
-1. 3D Assets (.scad):
-   - Generate procedural 3D models for the project 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}
-=============================
+${getScadAssetsInstructions(promptRules, projectType)}
 
 2. Rust ${frameworkName} Project Files:
    - Create the necessary files for a modern Rust ${frameworkName} application (e.g., \`Cargo.toml\`, \`build.rs\`, \`src/main.rs\`).
@@ -97,20 +174,7 @@ ${promptRules}
        : ""
    }
 
-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.
-   - CRITICAL: You MUST use \`process.cwd()\` (and NOT \`__dirname\`) when defining the target directory path (e.g. \`const rootDir = path.join(process.cwd(), "my_project");\`). This ensures the script extracts correctly into whatever temporary folder it is executed from.
-   - 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 ${frameworkName} project files (\`Cargo.toml\`, \`src/main.rs\`).
-     - The exact source code of the provided \`build.rs\` file, placed in the project root.${
-       hasUserScadFiles
-         ? "\n     - The provided user `.scad` files (modified if necessary), placed in the appropriate project folders."
-         : ""
-     }
-   - Ensure all string file contents inside the Node.js script are properly escaped.`;
+${getDeliveryFormat(projectType, frameworkName, hasUserScadFiles)}`;
 
         let systemClipboardOutput = `${systemPrompt}\n\n`;
 
@@ -144,14 +208,7 @@ ${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 project 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}
-=============================
+${getScadAssetsInstructions(promptRules, projectType)}
 
 2. Vite Web Project Files (npm based):
    - Create the necessary files for a modern web application (e.g., \`package.json\`, \`index.html\`, \`main.js\`).
@@ -164,19 +221,7 @@ ${promptRules}
      \`"prebuild": "scad-gltf convert ./scad ./public/models --cache"\`
    - Write the core application 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.
-   - CRITICAL: You MUST use \`process.cwd()\` (and NOT \`__dirname\`) when defining the target directory path (e.g. \`const rootDir = path.join(process.cwd(), "my_project");\`). This ensures the script extracts correctly into whatever temporary folder it is executed from.
-   - 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.${
-       hasUserScadFiles
-         ? "\n     - The provided user `.scad` files (modified if necessary), placed in the appropriate project folders."
-         : ""
-     }
-   - Ensure all string file contents inside the Node.js script are properly escaped.` +
+${getDeliveryFormat(projectType, null, hasUserScadFiles)}` +
           appendUserScadFiles(options)
         );
       },
@@ -199,23 +244,7 @@ NAMING CONVENTION REQUIREMENT:
 - NEVER use hyphens/minus signs (\`-\`) or spaces in any file or folder names.
 
 What to generate:
-1. 3D Assets (.scad):
-   - Generate procedural 3D models for the project 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}
-=============================
+${getScadAssetsInstructions(promptRules, projectType)}
 
 2. Godot 4 Project Files:
    - Create the necessary GDScript (\`.gd\`) and scene (\`.tscn\`) files to implement the project logic, responsive user input controls, and a core interaction loop.
@@ -229,20 +258,7 @@ ${promptRules}
      * 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.
 
-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_project\`) and output all files and folders inside this newly created project folder.
-   - CRITICAL: You MUST use \`process.cwd()\` (and NOT \`__dirname\`) when defining the target directory path (e.g. \`const rootDir = path.join(process.cwd(), "my_project");\`). This ensures the script extracts correctly into whatever temporary folder it is executed from.
-   - 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\` 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 provided user `.scad` files (modified if necessary), placed in the appropriate project folders."
-         : ""
-     }
-   - Ensure all string file contents inside the Node.js script are properly escaped.`;
+${getDeliveryFormat(projectType, null, hasUserScadFiles)}`;
 
         let systemClipboardOutput = `${systemPrompt}\n\n`;