changed gradio to make py scripts

.github/workflows/ci.yml

@@ -15,7 +15,7 @@ jobs:
           fetch-depth: 0
           lfs: true
 
-      - name: Push to Hugging Face Space
+      - name: Push to Hugggit remote listing Face Space
         env:
           HF_TOKEN: ${{ secrets.HF_TOKEN }}
         run: |

app.py

@@ -1,83 +1,145 @@
 import gradio as gr
 from pathlib import Path
-from app.process import generate_script_and_run  # Correct import from nested app directory
-
-# === File Paths ===
-generated_dir = Path("app/generated")
-fcstd_file = generated_dir / "model.FCStd"
-obj_file = generated_dir / "model.obj"
-
-# Remove stale files (optional cleanup)
-for file in ["generated_model.FCStd", "generated_model.obj"]:
-    fpath = generated_dir / file
-    if fpath.exists():
-        fpath.unlink()
-
-# === CAD Generation Callback ===
-def prepare_outputs(description):
-    generate_script_and_run(description)
-    return str(fcstd_file), str(obj_file), str(obj_file)
-
-# === UI with Custom CSS ===
-with gr.Blocks(css="""
-    #generate-btn .gr-button {
-        background-color: #28a745 !important;
-        color: white !important;
+import sys
+
+# Paths
+PROJECT_ROOT = Path(__file__).resolve().parent
+GENERATED_SCRIPT_PATH = PROJECT_ROOT / "generated" / "result_script.py"
+
+# Add root to sys.path so we can import process.py from app/
+sys.path.insert(0, str(PROJECT_ROOT / "app"))
+
+from app.process import main as generate_from_llm  # This runs generation
+
+def generate_script_and_preview(description):
+    """
+    Generates the FreeCAD script using process.py logic and returns:
+    - The script text for preview
+    - The file path for download
+    """
+    import builtins
+    original_input = builtins.input
+    builtins.input = lambda _: description
+    try:
+        generate_from_llm()
+    finally:
+        builtins.input = original_input
+
+    if GENERATED_SCRIPT_PATH.exists():
+        script_text = GENERATED_SCRIPT_PATH.read_text(encoding="utf-8")
+        return script_text, str(GENERATED_SCRIPT_PATH)
+    else:
+        return "Error: Script was not generated.", None
+
+
+css = """
+    body { background-color: #202020; color: white; margin: 0; padding: 0; }
+    .gradio-container {
+        max-width: 1400px;
+        width: 95vw;
+        margin: auto;
     }
-
-    #fcstd-download .gr-button,
-    #obj-download .gr-button {
-        background-color: #fd7e14 !important;
-        color: white !important;
+    .title { text-align: center; font-size: 2.5em; margin-bottom: 0.1em; }
+    .description { text-align: center; font-size: 1.1em; margin-bottom: 1em; color: #ccc; }
+    .preview-box { 
+        height: 400px; overflow-y: auto; 
+        background-color: #111; border: 1px solid #444; padding: 10px; 
+        font-family: monospace; white-space: pre-wrap; color: #0f0;
     }
-
-    .footer-text {
-        text-align: center;
-        font-size: 0.85rem;
-        margin-top: 2em;
+    .download-container {
+        display: flex;
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 0.5em;
+        padding-left: 15px;
+        height: 400px;
+        justify-content: flex-start;
+        width: 300px;
+    }
+    .download-button { width: 100%; }
+    .instructions {
+        font-size: 0.9em; color: #aaa;
+        max-width: 300px;
+        white-space: pre-line;
+    }
+    .footer { 
+        margin-top: 2em; 
+        text-align: center; 
+        font-size: 0.9em; 
         color: #888;
+        border-top: 1px solid #444;
+        padding-top: 1em;
     }
+    .footer a { color: #6af; text-decoration: none; }
+    .footer a:hover { text-decoration: underline; }
+"""
 
-    .footer-text a {
-        color: #fd7e14;
-        text-decoration: none;
-    }
+# Description 
+cadomatic_description_md = """ 
+<div style="text-align: center;">
 
-    .footer-text a:hover {
-        text-decoration: underline;
-    }
-""") as demo:
+Seamlessly creating python scripts for FreeCAD — from prompt to model.
 
-    gr.Markdown("<h1 style='text-align: center;'>CADomatic - FreeCAD Script Generator</h1>")
-    gr.Markdown("Generate 3D models by describing them in plain English. Powered by FreeCAD and LLMs.")
+CADomatic is a Python-powered tool that transforms prompts into **editable** parametric CAD scripts for FreeCAD. Rather than static models, it generates fully customizable Python code that programmatically builds CAD geometry — enabling engineers to define parts, reuse templates, and iterate rapidly.<br>
+CADomatic primarily aims at **reducing product development time** by making a base design which can be modified to suit the designer's main goal.<br>
+CADomatic creates native FreeCAD Python scripts for simple parts **with a complete design tree**.<br>
+"""
 
-    input_text = gr.Textbox(
-        label="📝 Describe your FreeCAD part",
+with gr.Blocks(css=css) as demo:
+    gr.Markdown("<div class='title'>CADomatic - AI powered CAD design generator</div>") # Title
+    gr.Markdown(cadomatic_description_md)
+
+    description_input = gr.Textbox(
+        label="Describe your desired CAD model below-",
         lines=3,
-        placeholder="e.g., Create a 10mm thick cylinder with radius 5mm..."
+        placeholder="e.g., Create a flange with OD 100mm, bore size 50mm and 6 m8 holes at PCD 75mm..."
     )
 
-    generate_btn = gr.Button("Generate", elem_id="generate-btn")
-
-    model_preview = gr.Model3D(label="🔍 3D Preview", height=400)
+    generate_btn = gr.Button("Generate Script", variant="primary")
 
     with gr.Row():
-        fcstd_download = gr.DownloadButton("Download .FCStd file", elem_id="fcstd-download")
-        obj_download = gr.DownloadButton("Download .obj file", elem_id="obj-download")
+        with gr.Column(scale=1):
+            preview_output = gr.Code(
+                label="Generated Script Preview",
+                language="python",
+                elem_classes="preview-box"
+            )
+            download_btn = gr.DownloadButton(
+                label="Download Python Script",
+                elem_classes="download-button"
+            )
+        with gr.Column(scale=1):
+            gr.Markdown(
+                """
+                <div class='instructions'>
+                <b>Instructions:</b><br>
+                - Enter the description for your desired CAD part.<br>
+                - Click on "Generate Script".<br>
+                - Preview the generated Python code.<br>
+                - Paste the generated code into the python console of your FreeCAD app.<br>
+                - (or)<br>
+                - Download the script.<br>
+                - In your FreeCAD python console, paste - exec(open(r"path to your python script").read())
+                </div>
+                """
+            )
+
+    # Footer
+    gr.Markdown( 
+        """
+        <div class='footer'>
+        CADomatic is still under development and may sometimes produce inaccurate results.<br>
+         <br>
+        Made with ❤️ by Yasin
+        </div>
+        """
+    )
 
     generate_btn.click(
-        fn=prepare_outputs,
-        inputs=input_text,
-        outputs=[fcstd_download, obj_download, model_preview]
+        fn=generate_script_and_preview,
+        inputs=description_input,
+        outputs=[preview_output, download_btn]
     )
 
-    gr.HTML("""
-        <div class='footer-text'>
-            <strong>Note:</strong> CADomatic is still under development and needs refinement. For best results, run locally. Toggle view in the .FCStd file for full geometry.<br>
-            Please refresh and run if there is no preview.<br>
-            View the source on <a href="https://github.com/yas1nsyed/CADomatic" target="_blank">GitHub</a>.
-        </div>
-    """)
-
 if __name__ == "__main__":
     demo.launch()

app/app_prompt.txt

@@ -1,10 +0,0 @@
-- Generate FreeCAD 1.0 Python code to create: 
-- Requirements:
-    - Must work in FreeCAD command-line mode
-    - No GUI functions (FreeCADGui)
-    - Ensure valid geometry creation
-- DO NOT wrap the logic inside any `def` functions or `if __name__ == "__main__":` blocks.
-- Always include `App.newDocument(...)` to create a document.
-- Always use top-level, immediately executable statements.
-- Use the `Part` module to construct valid geometry.
-- Recompute the document after adding objects using `doc.recompute()`.

app/process.py

@@ -1,142 +1,47 @@
-import sys
-import os
-import subprocess
-import platform
 from pathlib import Path
+import subprocess
+import sys
 
-# Define paths
-APP_DIR = Path(__file__).parent.resolve()
-PROJECT_ROOT = APP_DIR.parent
-GEN_DIR = APP_DIR / "generated"
-GEN_SCRIPT = GEN_DIR / "result_script.py"
-OBJ_PATH = GEN_DIR / "model.obj"
-FCSTD_PATH = GEN_DIR / "model.FCStd"
-PREVIEW_PATH = GEN_DIR / "preview.txt"  # Dummy preview
-
-sys.path.append(str(PROJECT_ROOT))
+# Make sure we can import from root/src
+ROOT_DIR = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT_DIR))
 
 from src.llm_client import prompt_llm
 
-def get_freecad_cmd():
-    """Get FreeCAD command path for Windows/Linux"""
-    if platform.system() == "Windows":
-        for path in [
-            r"C:\Program Files\FreeCAD 1.0\bin\freecadcmd.exe",
-            r"C:\Program Files\FreeCAD\bin\freecadcmd.exe"
-        ]:
-            if os.path.exists(path):
-                return path
-    return "freecadcmd"  # Assume it's in PATH
-
-# Escape Windows paths manually outside the f-string
-fcstd_path_str = str(FCSTD_PATH).replace("\\", "\\\\")
-obj_path_str = str(OBJ_PATH).replace("\\", "\\\\")
-preview_path_str = str(PREVIEW_PATH).replace("\\", "\\\\")
-
-EXPORT_SNIPPET = f"""
-import Mesh
-import os
-
-print(">>> Running export snippet...")
-
-try:
-    if App.ActiveDocument:
-        print(">>> Active document found")
-        doc = App.ActiveDocument
-        doc.recompute()
-        doc.saveAs(r"{fcstd_path_str}")
-        print(">>> Document saved")
-
-        objs = []
-        for obj in doc.Objects:
-            if hasattr(obj, "Shape"):
-                objs.append(obj)
-
-        print(f">>> Found {{len(objs)}} shape object(s)")
-
-        if objs:
-            Mesh.export(objs, r"{obj_path_str}")
-            print(">>> Exported OBJ file")
-
-        with open(r"{preview_path_str}", "w") as f:
-            f.write("Preview placeholder")
-
-    else:
-        print(">>> No active document!")
-
-except Exception as e:
-    App.Console.PrintError("Export failed: " + str(e) + "\\n")
+# File paths (relative to project root)
+prompt_base = ROOT_DIR / "prompts" / "base_instruction.txt"
+prompt_examples = ROOT_DIR / "prompts" / "example_code.txt"
+GEN_SCRIPT = ROOT_DIR / "generated" / "result_script.py"
+RUN_SCRIPT = ROOT_DIR / "src" / "run_freecad.py"
+
+# Snippet to adjust FreeCAD GUI view
+GUI_SNIPPET = """
+import FreeCADGui
+FreeCADGui.activeDocument().activeView().viewAxometric()
+FreeCADGui.SendMsgToActiveView("ViewFit")
 """
 
-def generate_script_and_run(user_input: str):
-    # Load modular prompt parts
-    base_prompt_path = PROJECT_ROOT / "prompts/base_instruction.txt"
-    example_prompt_path = PROJECT_ROOT / "prompts/example_code.txt"
-    app_prompt_path = APP_DIR / "app_prompt.txt"
-
-    base_instruction = base_prompt_path.read_text(encoding="utf-8").strip()
-    example_code = example_prompt_path.read_text(encoding="utf-8").strip()
-    app_prompt = app_prompt_path.read_text(encoding="utf-8").strip()
+def main():
+    # Step 1: Get user input
+    user_input = input("Describe your FreeCAD part: ")
 
-    prompt = (
-        f"{base_instruction}\n\n"
-        f"{example_code}\n\n"
-        f"{app_prompt}\n\n"
-        f"User request: {user_input.strip()}"
-    )
+    # Step 2: Build prompt
+    base_prompt = prompt_base.read_text(encoding="utf-8").strip()
+    example_prompt = prompt_examples.read_text(encoding="utf-8").strip()
+    full_prompt = f"{base_prompt}\n\nExamples:\n{example_prompt}\n\nUser instruction: {user_input.strip()}"
 
-    generated_code = prompt_llm(prompt)
-
-    if "App.newDocument" not in generated_code:
-        generated_code = "App.newDocument('Unnamed')\n" + generated_code
+    # Step 3: Get response from LLM
+    generated_code = prompt_llm(full_prompt)
 
+    # Step 4: Clean up ```python code blocks if any
     if generated_code.startswith("```"):
-        generated_code = generated_code[generated_code.find("\n") + 1:].rsplit("```", 1)[0]
-
-    if "__name__" in generated_code and "def " in generated_code:
-        lines = generated_code.splitlines()
-        in_main = False
-        unwrapped = []
-        for line in lines:
-            if line.strip().startswith("if __name__"):
-                in_main = True
-                continue
-            if in_main:
-                unwrapped.append(line[4:] if line.startswith("    ") else line)
-            else:
-                unwrapped.append(line)
-        generated_code = "\n".join(unwrapped)
-
-    GEN_DIR.mkdir(exist_ok=True)
-
-    full_script = f"{generated_code.strip()}\n\n{EXPORT_SNIPPET}"
-    GEN_SCRIPT.write_text(full_script, encoding="utf-8")
-
-    for path in [FCSTD_PATH, OBJ_PATH, PREVIEW_PATH]:
-        if path.exists():
-            path.unlink()
-
-    freecad_cmd = get_freecad_cmd()
-    try:
-        result = subprocess.run(
-            [freecad_cmd, str(GEN_SCRIPT)],
-            cwd=APP_DIR,
-            capture_output=True,
-            text=True,
-            timeout=60
-        )
-
-        (GEN_DIR / "run_stdout.txt").write_text(result.stdout or "", encoding="utf-8")
-        (GEN_DIR / "run_stderr.txt").write_text(result.stderr or "", encoding="utf-8")
-
-        if result.returncode != 0:
-            raise RuntimeError(result.stderr or result.stdout)
-
-        if not FCSTD_PATH.exists() or not OBJ_PATH.exists():
-            raise FileNotFoundError("One or more output files not created.")
+        generated_code = generated_code.strip("`\n ")
+        if generated_code.lower().startswith("python"):
+            generated_code = generated_code[len("python"):].lstrip()
 
-    except Exception as e:
-        FCSTD_PATH.write_text(f"Error: {e}")
-        PREVIEW_PATH.write_text(f"Error: {e}")
+    # Step 5: Append GUI snippet for viewing
+    generated_code += "\n\n" + GUI_SNIPPET
 
-    return str(FCSTD_PATH), str(PREVIEW_PATH)
+    # Step 6: Save to script file
+    GEN_SCRIPT.write_text(generated_code, encoding="utf-8")
+    print(f"\n Code generated and written to {GEN_SCRIPT}")

generated/result_script.py

@@ -7,53 +7,47 @@ import math
 def createFlangeAssembly():
     doc = App.newDocument("Flange")
 
-    # === Parameters ===
     FLANGE_OUTER_DIAMETER = 100.0
     FLANGE_THICKNESS = 7.5
     BORE_INNER_DIAMETER = 50.0
     NECK_HEIGHT = 15.0
-    NECK_OUTER_DIAMETER = 60.0 # Keeping this from the template as not specified in prompt
+    NECK_OUTER_DIAMETER = 60.0
     NUM_BOLT_HOLES = 6
     BOLT_HOLE_DIAMETER = 12.0
     PCD = 75.0
 
     total_height = FLANGE_THICKNESS + NECK_HEIGHT
 
-    # === 1. Create flange base ===
-    flange = doc.addObject("Part::Cylinder", "Flange_Base")
+    flange = doc.addObject("Part::Cylinder", "Flange")
     flange.Radius = FLANGE_OUTER_DIAMETER / 2
     flange.Height = FLANGE_THICKNESS
 
-    # === 2. Cut central bore from flange ===
-    bore = doc.addObject("Part::Cylinder", "Central_Bore_Cutter")
+    bore = doc.addObject("Part::Cylinder", "CentralBore")
     bore.Radius = BORE_INNER_DIAMETER / 2
     bore.Height = FLANGE_THICKNESS
-    bore_cut = doc.addObject("Part::Cut", "Flange_with_Bore")
+    bore_cut = doc.addObject("Part::Cut", "FlangeWithBore")
     bore_cut.Base = flange
     bore_cut.Tool = bore
 
-    # === 3. Create neck ===
-    neck_outer = doc.addObject("Part::Cylinder", "Neck_Outer")
+    neck_outer = doc.addObject("Part::Cylinder", "NeckOuter")
     neck_outer.Radius = NECK_OUTER_DIAMETER / 2
     neck_outer.Height = NECK_HEIGHT
     neck_outer.Placement.Base = Vector(0, 0, FLANGE_THICKNESS)
 
-    neck_inner = doc.addObject("Part::Cylinder", "Neck_Inner_Cutter")
+    neck_inner = doc.addObject("Part::Cylinder", "NeckInner")
     neck_inner.Radius = BORE_INNER_DIAMETER / 2
     neck_inner.Height = NECK_HEIGHT
     neck_inner.Placement.Base = Vector(0, 0, FLANGE_THICKNESS)
 
-    neck_hollow = doc.addObject("Part::Cut", "Hollow_Neck_Part")
+    neck_hollow = doc.addObject("Part::Cut", "HollowNeck")
     neck_hollow.Base = neck_outer
     neck_hollow.Tool = neck_inner
 
-    # === 4. Fuse flange (with central hole) and neck ===
-    fused = doc.addObject("Part::Fuse", "Flange_and_Neck_Fused")
+    fused = doc.addObject("Part::Fuse", "FlangeAndNeck")
     fused.Base = bore_cut
     fused.Tool = neck_hollow
 
-    # === 5. Cut bolt holes sequentially ===
-    current_shape_obj = fused # Reference to the last cut object in the tree
+    current_shape = fused
     bolt_radius = BOLT_HOLE_DIAMETER / 2
     bolt_circle_radius = PCD / 2
 
@@ -63,20 +57,16 @@ def createFlangeAssembly():
         x = bolt_circle_radius * math.cos(angle_rad)
         y = bolt_circle_radius * math.sin(angle_rad)
 
-        hole_cutter = doc.addObject("Part::Cylinder", f"Bolt_Hole_Cutter_{i+1:02d}")
-        hole_cutter.Radius = bolt_radius
-        hole_cutter.Height = total_height
-        hole_cutter.Placement.Base = Vector(x, y, 0)
+        hole = doc.addObject("Part::Cylinder", f"BoltHole_{i+1:02d}")
+        hole.Radius = bolt_radius
+        hole.Height = total_height
+        hole.Placement.Base = Vector(x, y, 0)
 
-        cut_obj = doc.addObject("Part::Cut", f"Flange_with_Hole_{i+1:02d}")
-        cut_obj.Base = current_shape_obj
-        cut_obj.Tool = hole_cutter
-        current_shape_obj = cut_obj  # Update for the next iteration
+        cut = doc.addObject("Part::Cut", f"Cut_Bolt_{i+1:02d}")
+        cut.Base = current_shape
+        cut.Tool = hole
+        current_shape = cut
 
-    # === 6. Final result ===
-    # The final object is current_shape_obj after all cuts
-
-    # Recompute and fit view
     doc.recompute()
     Gui.activeDocument().activeView().viewAxometric()
     Gui.SendMsgToActiveView("ViewFit")
@@ -86,3 +76,7 @@ def createFlangeAssembly():
 if __name__ == "__main__":
     createFlangeAssembly()
 
+
+import FreeCADGui
+FreeCADGui.activeDocument().activeView().viewAxometric()
+FreeCADGui.SendMsgToActiveView("ViewFit")