clean hf integration

.github/workflows/ci.yml

@@ -0,0 +1,22 @@
+name: Sync to Hugging Face hub
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+
+      - name: Push to Hugging Face Space
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git push https://Yas1n:[email protected]/spaces/Yas1n/CADomatic main

.gitignore

@@ -0,0 +1,218 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+/vectorstore/
+
+# Ignore FAISS and pickle index files
+/vectorstore/index.faiss
+/vectorstore/index.pkl
+
+# Ignore the generated model
+app/generated/
+app/generated/model.FCStd
+app/generated/model.obj

.python-version

@@ -0,0 +1 @@
+3.11

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,78 @@
+# CADomatic 🛠️  
+**From prompt to CAD**
+
+CADomatic is a Python-based tool that generates editable parametric CAD scripts for FreeCAD. Instead of creating static 3D models, CADomatic produces **fully customizable Python scripts** that build CAD geometry — allowing engineers to programmatically define parts, reuse templates, and iterate fast.
+
+---
+
+## 🔍 What It Does
+
+![CADomatic Demo](demo/0.1.0_flange_generation.gif)
+
+- ✅ **Generates editable FreeCAD Python scripts** for parts like screws, nuts, fasteners, and more
+- ✅ Each script can be modified for custom parameters (length, diameter, features, etc.)
+- ✅ Outputs native `.py` scripts which use FreeCAD’s API to build geometry
+- ✅ Enables **version-controlled**, reusable, parametric CAD pipelines
+- ✅ Eliminates the need for manual modeling in the FreeCAD GUI
+
+---
+## 💡 Why Use CADomatic?
+
+- 🔁 Automate repetitive CAD tasks
+- 🧱 Build part libraries as **code**
+- 🧪 Integrate CAD into testing or CI workflows
+- 🔧 Customize geometry by changing script parameters
+- 📐 Keep models lightweight and editable at the code level
+
+---
+## 💬 Example Prompts
+
+Here are some example natural language prompts you can use to generate CAD scripts with CADomatic:
+
+- "Build a flange with a 100mm outer diameter, 10mm thickness, and 6 bolt holes evenly spaced."
+- "Make a cylindrical spacer, 20mm diameter and 30mm height, with a 5mm through hole."
+- "Produce a washer with an outer diameter of 25mm and an inner diameter of 10mm."
+- "Design a toy car with a rectangular box as the body and 4 circular wheels attached to the sides of the box."
+
+These prompts will be converted into editable Python scripts that you can modify and reuse.
+
+
+---
+⚠️ **This is the first version** of CADomatic — a flash of what's possible.  
+Future versions under development will include:
+- Improved **LLM-driven script generation**
+- A **dedicated user interface** for part selection and parameter tuning
+- More robust **template and geometry libraries**
+---
+## 🚀 How to Use CADomatic
+
+### ✅ Prerequisites
+- Python 3.11+
+- [FreeCAD](https://www.freecad.org/downloads.php) (must be installed and added to PATH)
+- [uv](https://github.com/astral-sh/uv) (install via `pip install uv`)
+
+### ⚙️ Setup
+```bash
+git clone https://github.com/yas1nsyed/CADomatic.git
+cd CADomatic
+
+# Create and activate virtual environment
+python -m venv .venv
+.venv\Scripts\activate  
+
+# Install dependencies
+uv pip install -r requirements.txt
+```
+
+- 🔐 [Set Up Gemini API Key](https://aistudio.google.com/app/apikey)
+- Create a .env file in the project root:
+
+- ▶️ Run CADomatic
+```bash
+# Run the program
+uv run main.py
+```
+- Enter your prompt (e.g., "Create a 10mm cube with 2mm hole").
+- FreeCAD will auto-launch with your generated model.
+
+---

app/app.py

@@ -0,0 +1,83 @@
+import gradio as gr
+from pathlib import Path
+from process import generate_script_and_run
+
+# === File Paths ===
+generated_dir = Path(__file__).parent / "generated"
+fcstd_file = generated_dir / "model.FCStd"
+obj_file = generated_dir / "model.obj"
+
+# Remove stale files
+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;
+    }
+
+    #fcstd-download .gr-button,
+    #obj-download .gr-button {
+        background-color: #fd7e14 !important;
+        color: white !important;
+    }
+
+    .footer-text {
+        text-align: center;
+        font-size: 0.85rem;
+        margin-top: 2em;
+        color: #888;
+    }
+
+    .footer-text a {
+        color: #fd7e14;
+        text-decoration: none;
+    }
+
+    .footer-text a:hover {
+        text-decoration: underline;
+    }
+""") as demo:
+
+    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.")
+
+    input_text = gr.Textbox(
+        label="📝 Describe your FreeCAD part",
+        lines=3,
+        placeholder="e.g., Create a 10mm thick cylinder with radius 5mm..."
+    )
+
+    generate_btn = gr.Button("Generate", elem_id="generate-btn")
+
+    model_preview = gr.Model3D(label="🔍 3D Preview", height=400)
+
+    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")
+
+    generate_btn.click(
+        fn=prepare_outputs,
+        inputs=input_text,
+        outputs=[fcstd_download, obj_download, model_preview]
+    )
+
+    gr.HTML("""
+        <div class='footer-text'>
+            <strong>Note:</strong> CADomatic is still under development and still needs to be refined. For best results, run it locally. Toggle to view all in downloaded .FCStd file to see the generated part<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

@@ -0,0 +1,10 @@
+- 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

@@ -0,0 +1,157 @@
+import sys
+import os
+import subprocess
+import platform
+from pathlib import Path
+
+# 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))
+
+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("\\", "\\\\")
+
+# Updated export logic with debug logging
+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")
+"""
+
+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()
+
+    # Build prompt
+    prompt = (
+        f"{base_instruction}\n\n"
+        f"{example_code}\n\n"
+        f"{app_prompt}\n\n"
+        f"User request: {user_input.strip()}"
+    )
+
+    # Generate LLM code
+    generated_code = prompt_llm(prompt)
+
+    # Auto-inject App.newDocument if missing
+    if "App.newDocument" not in generated_code:
+        generated_code = "App.newDocument('Unnamed')\n" + generated_code
+
+    # Clean up markdown formatting
+    # Clean up markdown formatting
+    if generated_code.startswith("```"):
+        generated_code = generated_code[generated_code.find("\n") + 1:].rsplit("```", 1)[0]
+
+    # Unwrap if __name__ == "__main__" blocks (FreeCAD won't execute them)
+    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:
+                # Remove leading indentation (usually 4 spaces)
+                unwrapped.append(line[4:] if line.startswith("    ") else line)
+            else:
+                unwrapped.append(line)
+        generated_code = "\n".join(unwrapped)
+
+    # Create output folder if needed
+    GEN_DIR.mkdir(exist_ok=True)
+
+    # Build final script with export logic
+    full_script = f"{generated_code.strip()}\n\n{EXPORT_SNIPPET}"
+
+    # Write script
+    GEN_SCRIPT.write_text(full_script, encoding="utf-8")
+
+    # Delete old outputs
+    for path in [FCSTD_PATH, OBJ_PATH, PREVIEW_PATH]:
+        if path.exists():
+            path.unlink()
+
+    # Run FreeCAD
+    freecad_cmd = get_freecad_cmd()
+    try:
+        result = subprocess.run(
+            [freecad_cmd, str(GEN_SCRIPT)],
+            cwd=APP_DIR,
+            capture_output=True,
+            text=True,
+            timeout=60
+        )
+
+        # Log output
+        (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.")
+
+    except Exception as e:
+        FCSTD_PATH.write_text(f"Error: {e}")
+        PREVIEW_PATH.write_text(f"Error: {e}")
+
+    return str(FCSTD_PATH), str(PREVIEW_PATH)

generated/result_script.py

@@ -0,0 +1,88 @@
+import FreeCAD as App
+import FreeCADGui as Gui
+from FreeCAD import Vector
+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
+    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.Radius = FLANGE_OUTER_DIAMETER / 2
+    flange.Height = FLANGE_THICKNESS
+
+    # === 2. Cut central bore from flange ===
+    bore = doc.addObject("Part::Cylinder", "Central_Bore_Cutter")
+    bore.Radius = BORE_INNER_DIAMETER / 2
+    bore.Height = FLANGE_THICKNESS
+    bore_cut = doc.addObject("Part::Cut", "Flange_with_Bore")
+    bore_cut.Base = flange
+    bore_cut.Tool = bore
+
+    # === 3. Create neck ===
+    neck_outer = doc.addObject("Part::Cylinder", "Neck_Outer")
+    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.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.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.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
+    bolt_radius = BOLT_HOLE_DIAMETER / 2
+    bolt_circle_radius = PCD / 2
+
+    for i in range(NUM_BOLT_HOLES):
+        angle_deg = 360 * i / NUM_BOLT_HOLES
+        angle_rad = math.radians(angle_deg)
+        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)
+
+        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
+
+    # === 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")
+
+    return doc
+
+if __name__ == "__main__":
+    createFlangeAssembly()
+

main.py

@@ -0,0 +1,54 @@
+from src.llm_client import prompt_llm
+from pathlib import Path
+import subprocess
+
+# File paths
+prompt_base = Path("prompts/base_instruction.txt")
+prompt_examples = Path("prompts/example_code.txt")
+GEN_SCRIPT = Path("generated/result_script.py")
+RUN_SCRIPT = Path("src/run_freecad.py")
+
+# Snippet to adjust FreeCAD GUI view
+GUI_SNIPPET = """
+import FreeCADGui
+FreeCADGui.activeDocument().activeView().viewAxometric()
+FreeCADGui.SendMsgToActiveView("ViewFit")
+"""
+
+def main():
+    # Step 1: Get user input
+    user_input = input("Describe your FreeCAD part: ")
+
+    # Step 2: Build prompt
+    base_prompt = prompt_base.read_text().strip()
+    example_prompt = prompt_examples.read_text().strip()
+    full_prompt = f"{base_prompt}\n\nExamples:\n{example_prompt}\n\nUser instruction: {user_input.strip()}"
+
+
+    # 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.strip("`\n ")
+        if generated_code.lower().startswith("python"):
+            generated_code = generated_code[len("python"):].lstrip()
+
+    # Step 5: Append GUI snippet for viewing
+    generated_code += "\n\n" + GUI_SNIPPET
+
+    # Step 6: Save to script file
+    GEN_SCRIPT.write_text(generated_code)
+    print(f"\n Code generated and written to {GEN_SCRIPT}")
+
+    # Step 7: Execute the script via FreeCAD
+    print("Running FreeCAD with the generated script...")
+    try:
+        subprocess.run(["python", str(RUN_SCRIPT)], check=True)
+    except subprocess.CalledProcessError as e:
+        print(f"❌ FreeCAD script execution failed with error code: {e.returncode}")
+    except Exception as e:
+        print(f"❌ Error running run_freecad.py: {e}")
+
+if __name__ == "__main__":
+    main()

prompts/base_instruction.txt

@@ -0,0 +1,18 @@
+You are an assistant that generates valid Python code for FreeCAD.
+
+- Use Part and Sketcher modules.
+- Do not use GUI commands unless required.
+- Make sure the code can be executed using FreeCAD.
+- make code according to FreeCAD 1.0
+- make the parts using the freecad part workbench, not partdesign workbench
+- ensure all dimensions are correct and parts dont intersect each other
+- Always use from FreeCAD import Vector instead of import FreeCAD.Vector when importing the Vector class in FreeCAD. This is the correct and preferred method.
+- Always use from FreeCAD import Placement instead of import FreeCAD.Placement when importing the Placement class in FreeCAD. This is the correct and preferred method.
+- Always use from FreeCAD import Rotation instead of import FreeCAD.Rotation when importing the Rotation class in FreeCAD. This is the correct and preferred method.
+- use the fuse() function instead of Part.Union(). Use it only where necessary. Only when it is necessary to combine parts
+- make the design tree as well for all parts. In the design tree, I must be able to change the dimension and placement of parts.
+- dont make several features and then copy and make one feature at the end.
+- Make the generated object visible 
+- try to make the design as modular as possible. for example, if i need to generate a cup, make the cup body as one feature in design tree and handle as other feature. in this way, i can edit the dimensions of both separately.
+- There is no built-in Part.makeTube function in FreeCAD. You're trying to create a hollow cylinder (tube) directly with parameters like outer_radius, inner_radius, height, but FreeCAD expects shapes, not numbers.
+- dont write comments

prompts/example_code.txt

@@ -0,0 +1,228 @@
+- Correct Usage of fuse() in FreeCAD-
+    When performing a union (boolean fuse) of multiple shapes in FreeCAD, always use the iterative .fuse() method on Part objects instead of Part.Union().
+
+    Correct Approach:
+
+    fan_final_shape = all_parts_to_fuse[0]  # Start with the first shape  
+    for shape in all_parts_to_fuse[1:]:     # Iterate over remaining shapes  
+        fan_final_shape = fan_final_shape.fuse(shape)  # Fuse one by one  
+    Avoid:
+
+    fan_final_shape = Part.Union(all_parts_to_fuse)  # Incorrect method  
+
+
+- When applying a Placement to a FreeCAD shape (like a Part.Solid or Part.Shape), do not use .Placed(placement) — this method does not exist.
+Instead, use .copy() and assign the Placement directly, like this:
+
+    shape = Part.makeBox(10, 10, 10)
+    placed_shape = shape.copy()
+    placed_shape.Placement = Placement(Vector(x, y, z), Rotation(Vector(0,0,1), angle))
+    Always use .copy() to avoid modifying the original shape directly, and set Placement as an attribute on the copied shape.
+
+
+- Whenever you are asked to make a fastner including nut bolt and screw, you need to make a similar code as the one given below. you have the rag in your context window from where you must write the necessary function of calculating dimensions from screw_maker.py. You need to then make a dummy function for the variables of the screw as asked-
+
+    from screw_maker import *
+
+    try:
+        import FreeCADGui
+        GUI_AVAILABLE = True
+    except ImportError:
+        GUI_AVAILABLE = False
+
+
+
+    def makeAllMetalFlangedLockNut(self, fa):
+        """Creates a distorted thread lock nut with a flange
+        Supported types:
+        - ISO 7044 all metal lock nuts with flange
+        - ISO 12126 all metal flanged lock nuts with fine pitch thread
+        """
+        dia = self.getDia(fa.calc_diam, True)
+        if fa.baseType in ["ISO7044", "ISO12126"]:
+            P, c, _, _, dc, _, _, h, _, m_min, _, s, _, _ = fa.dimTable
+            m_w = m_min
+        else:
+            raise NotImplementedError(f"Unknown fastener type: {fa.Type}")
+        # main hexagonal body of the nut
+        shape = self.makeHexPrism(s, h)
+        # flange of the hex
+        fm = FSFaceMaker()
+        fm.AddPoint((1.05 * dia + s) / 4, 0.0)
+        fm.AddPoint((dc + sqrt3 * c) / 2, 0.0)
+        fm.AddPoint((dc - c) / 2, 0.0)
+        fm.AddArc2(0, c / 2, 150)
+        fm.AddPoint(
+            (1.05 * dia + s) / 4,
+            sqrt3
+            / 3
+            * ((dc - c) / 2 + c / (4 - 2 * sqrt3) - (1.05 * dia + s) / 4),
+        )
+        flange = self.RevolveZ(fm.GetFace())
+        shape = shape.fuse(flange).removeSplitter()
+        # internal bore
+        fm.Reset()
+        id = self.GetInnerThreadMinDiameter(dia, P, 0.0)
+        bore_cham_ht = (dia * 1.05 - id) / 2 * tan15
+        fm.AddPoint(0.0, 0.0)
+        fm.AddPoint(dia * 1.05 / 2, 0.0)
+        fm.AddPoint(id / 2, bore_cham_ht)
+        fm.AddPoint(id / 2, h - bore_cham_ht)
+        fm.AddPoint(dia * 1.05 / 2, h)
+        fm.AddPoint(0.0, h)
+        bore_cutter = self.RevolveZ(fm.GetFace())
+        shape = shape.cut(bore_cutter)
+        # outer chamfer on the hex
+        fm.Reset()
+        fm.AddPoint((s / sqrt3 + 1.05 * dia / 2) / 2, h)
+        fm.AddPoint(s / sqrt3, h)
+        fm.AddPoint(s / sqrt3, m_w)
+        top_cham_cutter = self.RevolveZ(fm.GetFace())
+        shape = shape.cut(top_cham_cutter)
+        # add modelled threads if needed
+        if fa.Thread:
+            thread_cutter = self.CreateInnerThreadCutter(dia, P, h + P)
+            shape = shape.cut(thread_cutter)
+        return shape
+
+
+
+    if __name__ == "__main__":
+        import sys
+        sys.path.append(r"C:\Users\yasin\Desktop\Code\text2cad_trial")
+        import screw_maker as sm
+        import FreeCAD as App, Part
+
+        s = sm.Screw()
+
+        class DummyFA:
+            baseType = "ISO7044"
+            Type = "ISO7044"
+            calc_diam = "M10"
+            Diameter = "M10"
+            Thread = True
+            LeftHanded = False
+            dimTable = [1.5, 0.5, 0, 0, 17.5, 0, 0, 8.0, 0, 7.5, 0, 15, 0, 0]
+
+        fa = DummyFA()
+        shape = makeAllMetalFlangedLockNut(s, fa)
+
+        doc = App.newDocument("AutoNut")
+        obj = doc.addObject("Part::Feature", "AutoFlangedNut")
+        obj.Shape = shape
+        doc.recompute()
+
+        print("Flanged lock nut generated successfully.")
+
+    if GUI_AVAILABLE:
+        # FreeCADGui.showMainWindow()
+        FreeCADGui.activeDocument().activeView().viewAxometric()
+        FreeCADGui.SendMsgToActiveView("ViewFit")
+
+
+- when asked to "make a flange of OD 100mm, bore size as 50mm, thickness 7.5mm. the height of the middle hollow neck must be 15mm. make 6 m12 holes at PCD 75mm", make the following code:
+        import FreeCAD as App
+        import FreeCADGui as Gui
+        from FreeCAD import Vector
+        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
+            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")
+            flange.Radius = FLANGE_OUTER_DIAMETER / 2
+            flange.Height = FLANGE_THICKNESS
+
+            # === 2. Cut central bore from flange ===
+            bore = doc.addObject("Part::Cylinder", "CentralBore")
+            bore.Radius = BORE_INNER_DIAMETER / 2
+            bore.Height = FLANGE_THICKNESS
+            bore_cut = doc.addObject("Part::Cut", "FlangeWithBore")
+            bore_cut.Base = flange
+            bore_cut.Tool = bore
+
+            # === 3. Create neck ===
+            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", "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", "HollowNeck")
+            neck_hollow.Base = neck_outer
+            neck_hollow.Tool = neck_inner
+
+            # === 4. Fuse flange (with central hole) and neck ===
+            fused = doc.addObject("Part::Fuse", "FlangeAndNeck")
+            fused.Base = bore_cut
+            fused.Tool = neck_hollow
+
+            # === 5. Cut bolt holes sequentially ===
+            current_shape = fused
+            bolt_radius = BOLT_HOLE_DIAMETER / 2
+            bolt_circle_radius = PCD / 2
+
+            for i in range(NUM_BOLT_HOLES):
+                angle_deg = 360 * i / NUM_BOLT_HOLES
+                angle_rad = math.radians(angle_deg)
+                x = bolt_circle_radius * math.cos(angle_rad)
+                y = bolt_circle_radius * math.sin(angle_rad)
+
+                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 = doc.addObject("Part::Cut", f"Cut_Bolt_{i+1:02d}")
+                cut.Base = current_shape
+                cut.Tool = hole
+                current_shape = cut  # update for next iteration
+
+            # === 6. Final result ===
+        
+
+            # Recompute and fit view
+            doc.recompute()
+            Gui.activeDocument().activeView().viewAxometric()
+            Gui.SendMsgToActiveView("ViewFit")
+
+            return doc
+
+        if __name__ == "__main__":
+            createFlangeAssembly()
+
+use this template whenever asked to make a flange
+
+- Use material only when specified by user. An example of using material is-
+                
+        view_obj = final_obj.ViewObject
+        view_obj.ShapeColor = (0.8, 0.8, 0.85)      # Light grey-blue tone
+        view_obj.DiffuseColor = [(0.8, 0.8, 0.85)]  # Consistent color across faces
+        view_obj.Transparency = 0  
+
+        material_obj = doc.addObject("App::MaterialObject", "Material")
+        material_obj.Material = {
+            'Name': 'Stainless steel',
+            'Density': '8000 kg/m^3',
+            'YoungsModulus': '200000 MPa',
+            'PoissonRatio': '0.3'
+        }
+        material_obj.Label = "StainlessSteelMaterial"

pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "cadomatic"
+version = "0.1.0"
+description = "This is a code to create editable CAD files from natural language prompts"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "python-dotenv>=1.1.1",
+    "langchain>=0.3.27",
+    "beautifulsoup4>=4.13.4",
+    "langchain-google-genai>=2.1.8",
+    "langchain-community>=0.3.27",
+    "faiss-cpu>=1.11.0",
+    "huggingface-hub>=0.34.3",
+    "gradio>=5.39.0",
+]

requirements.txt

@@ -0,0 +1,313 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile pyproject.toml --output-file requirements.txt
+aiofiles==24.1.0
+    # via gradio
+aiohappyeyeballs==2.6.1
+    # via aiohttp
+aiohttp==3.12.15
+    # via langchain-community
+aiosignal==1.4.0
+    # via aiohttp
+annotated-types==0.7.0
+    # via pydantic
+anyio==4.10.0
+    # via
+    #   gradio
+    #   httpx
+    #   starlette
+attrs==25.3.0
+    # via aiohttp
+beautifulsoup4==4.13.4
+    # via cadomatic (pyproject.toml)
+brotli==1.1.0
+    # via gradio
+cachetools==5.5.2
+    # via google-auth
+certifi==2025.8.3
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.4.2
+    # via requests
+click==8.2.1
+    # via
+    #   typer
+    #   uvicorn
+colorama==0.4.6
+    # via
+    #   click
+    #   tqdm
+dataclasses-json==0.6.7
+    # via langchain-community
+faiss-cpu==1.11.0.post1
+    # via cadomatic (pyproject.toml)
+fastapi==0.116.1
+    # via gradio
+ffmpy==0.6.1
+    # via gradio
+filelock==3.18.0
+    # via huggingface-hub
+filetype==1.2.0
+    # via langchain-google-genai
+frozenlist==1.7.0
+    # via
+    #   aiohttp
+    #   aiosignal
+fsspec==2025.7.0
+    # via
+    #   gradio-client
+    #   huggingface-hub
+google-ai-generativelanguage==0.6.18
+    # via langchain-google-genai
+google-api-core==2.25.1
+    # via google-ai-generativelanguage
+google-auth==2.40.3
+    # via
+    #   google-ai-generativelanguage
+    #   google-api-core
+googleapis-common-protos==1.70.0
+    # via
+    #   google-api-core
+    #   grpcio-status
+gradio==5.41.1
+    # via cadomatic (pyproject.toml)
+gradio-client==1.11.0
+    # via gradio
+greenlet==3.2.4
+    # via sqlalchemy
+groovy==0.1.2
+    # via gradio
+grpcio==1.74.0
+    # via
+    #   google-api-core
+    #   grpcio-status
+grpcio-status==1.74.0
+    # via google-api-core
+h11==0.16.0
+    # via
+    #   httpcore
+    #   uvicorn
+httpcore==1.0.9
+    # via httpx
+httpx==0.28.1
+    # via
+    #   gradio
+    #   gradio-client
+    #   langsmith
+    #   safehttpx
+httpx-sse==0.4.1
+    # via langchain-community
+huggingface-hub==0.34.3
+    # via
+    #   cadomatic (pyproject.toml)
+    #   gradio
+    #   gradio-client
+idna==3.10
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+    #   yarl
+jinja2==3.1.6
+    # via gradio
+jsonpatch==1.33
+    # via langchain-core
+jsonpointer==3.0.0
+    # via jsonpatch
+langchain==0.3.27
+    # via
+    #   cadomatic (pyproject.toml)
+    #   langchain-community
+langchain-community==0.3.27
+    # via cadomatic (pyproject.toml)
+langchain-core==0.3.73
+    # via
+    #   langchain
+    #   langchain-community
+    #   langchain-google-genai
+    #   langchain-text-splitters
+langchain-google-genai==2.1.9
+    # via cadomatic (pyproject.toml)
+langchain-text-splitters==0.3.9
+    # via langchain
+langsmith==0.4.13
+    # via
+    #   langchain
+    #   langchain-community
+    #   langchain-core
+markdown-it-py==3.0.0
+    # via rich
+markupsafe==3.0.2
+    # via
+    #   gradio
+    #   jinja2
+marshmallow==3.26.1
+    # via dataclasses-json
+mdurl==0.1.2
+    # via markdown-it-py
+multidict==6.6.3
+    # via
+    #   aiohttp
+    #   yarl
+mypy-extensions==1.1.0
+    # via typing-inspect
+numpy==2.3.2
+    # via
+    #   faiss-cpu
+    #   gradio
+    #   langchain-community
+    #   pandas
+orjson==3.11.1
+    # via
+    #   gradio
+    #   langsmith
+packaging==25.0
+    # via
+    #   faiss-cpu
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   langchain-core
+    #   langsmith
+    #   marshmallow
+pandas==2.3.1
+    # via gradio
+pillow==11.3.0
+    # via gradio
+propcache==0.3.2
+    # via
+    #   aiohttp
+    #   yarl
+proto-plus==1.26.1
+    # via
+    #   google-ai-generativelanguage
+    #   google-api-core
+protobuf==6.31.1
+    # via
+    #   google-ai-generativelanguage
+    #   google-api-core
+    #   googleapis-common-protos
+    #   grpcio-status
+    #   proto-plus
+pyasn1==0.6.1
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.4.2
+    # via google-auth
+pydantic==2.11.7
+    # via
+    #   fastapi
+    #   gradio
+    #   langchain
+    #   langchain-core
+    #   langchain-google-genai
+    #   langsmith
+    #   pydantic-settings
+pydantic-core==2.33.2
+    # via pydantic
+pydantic-settings==2.10.1
+    # via langchain-community
+pydub==0.25.1
+    # via gradio
+pygments==2.19.2
+    # via rich
+python-dateutil==2.9.0.post0
+    # via pandas
+python-dotenv==1.1.1
+    # via
+    #   cadomatic (pyproject.toml)
+    #   pydantic-settings
+python-multipart==0.0.20
+    # via gradio
+pytz==2025.2
+    # via pandas
+pyyaml==6.0.2
+    # via
+    #   gradio
+    #   huggingface-hub
+    #   langchain
+    #   langchain-community
+    #   langchain-core
+requests==2.32.4
+    # via
+    #   google-api-core
+    #   huggingface-hub
+    #   langchain
+    #   langchain-community
+    #   langsmith
+    #   requests-toolbelt
+requests-toolbelt==1.0.0
+    # via langsmith
+rich==14.1.0
+    # via typer
+rsa==4.9.1
+    # via google-auth
+ruff==0.12.7
+    # via gradio
+safehttpx==0.1.6
+    # via gradio
+semantic-version==2.10.0
+    # via gradio
+shellingham==1.5.4
+    # via typer
+six==1.17.0
+    # via python-dateutil
+sniffio==1.3.1
+    # via anyio
+soupsieve==2.7
+    # via beautifulsoup4
+sqlalchemy==2.0.42
+    # via
+    #   langchain
+    #   langchain-community
+starlette==0.47.2
+    # via
+    #   fastapi
+    #   gradio
+tenacity==9.1.2
+    # via
+    #   langchain-community
+    #   langchain-core
+tomlkit==0.13.3
+    # via gradio
+tqdm==4.67.1
+    # via huggingface-hub
+typer==0.16.0
+    # via gradio
+typing-extensions==4.14.1
+    # via
+    #   aiosignal
+    #   anyio
+    #   beautifulsoup4
+    #   fastapi
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   langchain-core
+    #   pydantic
+    #   pydantic-core
+    #   sqlalchemy
+    #   starlette
+    #   typer
+    #   typing-inspect
+    #   typing-inspection
+typing-inspect==0.9.0
+    # via dataclasses-json
+typing-inspection==0.4.1
+    # via
+    #   pydantic
+    #   pydantic-settings
+tzdata==2025.2
+    # via pandas
+urllib3==2.5.0
+    # via requests
+uvicorn==0.35.0
+    # via gradio
+websockets==15.0.1
+    # via gradio-client
+yarl==1.20.1
+    # via aiohttp
+zstandard==0.23.0
+    # via langsmith

src/llm_client.py

@@ -0,0 +1,54 @@
+import os
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+from langchain_community.vectorstores import FAISS
+from langchain_google_genai import ChatGoogleGenerativeAI, GoogleGenerativeAIEmbeddings
+from dotenv import load_dotenv
+import google.generativeai as genai
+
+# Load API key
+load_dotenv()
+genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
+
+# Set up Hugging Face repo and files
+REPO_ID = "Yas1n/CADomatic_vectorstore"
+FILENAME_FAISS = "index.faiss"
+FILENAME_PKL = "index.pkl"
+
+# Download once (uses HF cache internally)
+faiss_path = hf_hub_download(repo_id=REPO_ID, filename=FILENAME_FAISS)
+pkl_path = hf_hub_download(repo_id=REPO_ID, filename=FILENAME_PKL)
+
+# Use same folder for both files
+download_dir = Path(faiss_path).parent
+
+# Load vectorstore
+embedding = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+vectorstore = FAISS.load_local(str(download_dir), embeddings=embedding, allow_dangerous_deserialization=True)
+retriever = vectorstore.as_retriever(search_kwargs={"k": 40})
+
+# Gemini 2.5 Flash
+llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash", temperature=1.2)
+
+def prompt_llm(user_prompt: str) -> str:
+    docs = retriever.invoke(user_prompt)
+    context = "\n\n".join(doc.page_content for doc in docs)
+
+    final_prompt = f"""
+You are a helpful assistant that writes FreeCAD Python scripts from CAD instructions.
+Use the following FreeCAD wiki documentation as context:
+
+{context}
+
+Instruction:
+{user_prompt}
+
+Respond with valid FreeCAD Python code only, no extra commentary.
+"""
+
+    try:
+        response = llm.invoke(final_prompt)
+        return response.content
+    except Exception as e:
+        print("❌ Error generating FreeCAD code:", e)
+        return ""

src/rag_builder.py

@@ -0,0 +1,110 @@
+import os
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+
+# --- Step 1: ENV setup ---
+from dotenv import load_dotenv
+import google.generativeai as genai
+
+load_dotenv()
+genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
+
+# --- Step 2: Crawler ---
+BASE_URL_WIKI = "https://wiki.freecad.org/Power_users_hub"
+BASE_URL_GITHUB = "https://github.com/shaise/FreeCAD_FastenersWB"
+
+DOMAIN_WHITELIST = [
+    "https://wiki.freecad.org",
+    "https://github.com/shaise"
+]
+
+# List of language identifiers to exclude (only for wiki)
+LANG_IDENTIFIERS = [
+    "/id", "/de", "/tr", "/es", "/fr", "/hr", "/it", "/pl",
+    "/pt", "/pt-br", "/ro", "/fi", "/sv", "/cs", "/ru", "/zh-cn",
+    "/zh-tw", "/ja", "/ko"
+]
+
+def is_excluded_url(url):
+    url_lower = url.lower()
+
+    # Apply language filters only to FreeCAD wiki URLs
+    if "wiki.freecad.org" in url_lower:
+        if any(lang in url_lower for lang in LANG_IDENTIFIERS):
+            return True
+
+    return (
+        ".jpg" in url_lower or
+        ".png" in url_lower or
+        "edit&section" in url_lower
+    )
+
+def crawl_wiki(start_url, max_pages):
+    visited = set()
+    to_visit = [start_url]
+    pages = []
+
+    while to_visit and len(visited) < max_pages:
+        url = to_visit.pop(0)
+        if url in visited or is_excluded_url(url):
+            continue
+        try:
+            print(f"Fetching: {url}")
+            res = requests.get(url)
+            res.raise_for_status()
+            soup = BeautifulSoup(res.text, "html.parser")
+            visited.add(url)
+
+            for tag in soup(["script", "style", "header", "footer", "nav", "aside"]):
+                tag.extract()
+            text = soup.get_text(separator="\n")
+            clean = "\n".join([line.strip() for line in text.splitlines() if line.strip()])
+            pages.append({"url": url, "text": clean})
+
+            # Queue internal links
+            for a in soup.find_all("a", href=True):
+                full = urljoin(url, a["href"])
+                if any(full.startswith(domain) for domain in DOMAIN_WHITELIST):
+                    if full not in visited and not is_excluded_url(full):
+                        to_visit.append(full)
+        except Exception as e:
+            print(f"Error fetching {url}: {e}")
+
+    print(f"Crawled {len(pages)} pages from {start_url}")
+    return pages
+
+# --- Step 3: RAG Build ---
+def build_vectorstore():
+    wiki_pages = crawl_wiki(BASE_URL_WIKI, max_pages=2000)  # Uncomment if you want both
+    github_pages = crawl_wiki(BASE_URL_GITHUB, max_pages=450)
+    pages = wiki_pages + github_pages
+
+    if not pages:
+        print("No pages crawled. Exiting.")
+        return
+
+    texts = [p["text"] for p in pages]
+    metadatas = [{"source": p["url"]} for p in pages]
+
+    splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
+    docs = splitter.create_documents(texts, metadatas=metadatas)
+
+    print(f"Split into {len(docs)} chunks")
+
+    embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+    vectorstore = FAISS.from_documents(docs, embeddings)
+
+    src_path = os.path.dirname(os.path.abspath(__file__))
+    root_dir_path = os.path.dirname(src_path)
+    vectorstore_path = os.path.join(root_dir_path, "vectorstore")
+
+    os.makedirs(vectorstore_path, exist_ok=True)
+    vectorstore.save_local(vectorstore_path)
+    print("Vectorstore saved to ./vectorstore")
+
+if __name__ == "__main__":
+    build_vectorstore()

src/run_freecad.py

@@ -0,0 +1,11 @@
+# run_freecad.py
+import subprocess
+from pathlib import Path
+
+freecad_exe = r"C:\Program Files\FreeCAD 1.0\bin\freecad.exe"
+script_path = Path("generated/result_script.py")
+
+if not script_path.exists():
+    raise FileNotFoundError("Generated script not found. Run main.py first.")
+
+subprocess.run([freecad_exe, str(script_path)], check=True)