Convert docs to mkdocs from mintlify, set up GHA publish

Author: emdoyle

.github/workflows/docs.yml

@@ -0,0 +1,29 @@
+name: docs
+
+on:
+  push:
+    branches:
+      - main
+permissions:
+  contents: write
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Configure Git Credentials
+        run: |
+          git config user.name github-actions[bot]
+          git config user.email 41898282+github-actions[bot]@users.noreply.github.com
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3.x
+      - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV 
+      - uses: actions/cache@v4
+        with:
+          key: mkdocs-material-${{ env.cache_id }}
+          path: .cache 
+          restore-keys: |
+            mkdocs-material-
+      - run: pip install -r docs/requirements.txt
+      - run: mkdocs gh-deploy --force

Makefile

@@ -79,9 +79,16 @@ type-check: ## Run type checking
 	$(VENV_BIN)/pyright
 
 
-.PHONY: docs
-docs: ## Develop on docs locally
-	cd docs && npx mintlify dev
+.PHONY: docs docs-serve docs-build
+docs: docs-serve ## Alias for docs-serve
+
+docs-serve: ## Serve documentation locally with live reloading
+	pip install -r docs/requirements.txt
+	mkdocs serve
+
+docs-build: ## Build the documentation site
+	pip install -r docs/requirements.txt
+	mkdocs build
 
 
 .PHONY: help

docs/CNAME

@@ -0,0 +1 @@
+docs.gauge.sh

docs/README.md

@@ -1,6 +1,4 @@
----
-title: Setup Guide
----
+# Setup Guide
 
 ## 1. Automated dependency installation
 Installing all the dependencies
@@ -50,9 +48,8 @@ make deps
 
 To build and rebuild after changes to Rust files.
 
-<Note>
-Make sure you have the Rust compiler installed. This package requires Rust and Cargo to compile extensions.
-</Note>
+!!! note
+    Make sure you have the Rust compiler installed. This package requires Rust and Cargo to compile extensions.
 
 ### Install the crate as module in the current virtualenv
 
@@ -68,13 +65,22 @@ make test
 ```
 
 ## 4. Setting up the docs
-Tach internally uses `mintlify` platform to create and maintain public facing documentation
+Tach uses MkDocs with the Material theme for documentation. To work with the documentation:
 
-Note: contributors would need to install [Node](https://nodejs.org/en/download/prebuilt-installer) and [npm](https://www.npmjs.com/)
-```bash 
-make docs
+1. Install the documentation dependencies:
+```bash
+pip install -r docs/requirements.txt
+```
+
+2. Start the local development server:
+```bash
+mkdocs serve
 ```
 
+3. Open your browser to http://127.0.0.1:8000/ to see the documentation.
+
+For more details, see [Working with Docs](working-with-docs.md).
+
 ## 5. Things to check before committing
 Check and sync your dependencies in the root folder
 ```bash
@@ -101,5 +107,3 @@ Find Beginner Friendly issues here:
 - [Documentation Issues](https://github.com/gauge-sh/tach/issues?q=is%3Aopen+is%3Aissue+label%3Adocumentation)
 - [Issues](https://github.com/gauge-sh/tach/issues)
 - [Documentation](https://github.com/gauge-sh/tach/tree/main/docs)
-
-For any questions, just drop a message in [Discord](https://discord.com/invite/a58vW8dnmw)

docs/contributing/setting-up-project.mdx renamed to docs/contributing/setting-up-project.md

@@ -0,0 +1,91 @@
+# Working with Documentation
+
+This guide explains how to work with Tach's documentation system, which uses MkDocs with the Material theme.
+
+## Prerequisites
+
+You need Python installed on your system and the documentation dependencies:
+
+```bash
+pip install -r docs/requirements.txt
+```
+
+## Local Development
+
+To work on the documentation locally, run:
+
+```bash
+mkdocs serve
+```
+
+This will start a local server at http://127.0.0.1:8000/ with live reloading.
+
+## Documentation Structure
+
+The documentation is organized as follows:
+
+- `docs/index.md` - Home page
+- `docs/getting-started/` - Getting started guides
+- `docs/usage/` - Usage documentation
+- `docs/contributing/` - Contributing guides
+- `docs/assets/` - Images and other assets
+
+## Adding New Pages
+
+To add a new page:
+
+1. Create a new Markdown file (`.md`) in the appropriate directory
+2. Add an entry to the `nav` section in `mkdocs.yml`
+
+Example:
+
+```yaml
+nav:
+  - Home: index.md
+  - Getting Started:
+    - Overview: getting-started/introduction.md
+    - # Add your new page here
+    - My New Page: getting-started/my-new-page.md
+```
+
+## Formatting
+
+MkDocs uses Markdown for formatting. Some useful features with Material for MkDocs include:
+
+### Code Blocks
+
+```python
+def example_function():
+    return "Hello, World!"
+```
+
+### Admonitions
+
+!!! note
+    This is a note admonition.
+
+!!! warning
+    This is a warning admonition.
+
+!!! tip
+    This is a tip admonition.
+
+### Tabs
+
+=== "Tab 1"
+    Content for tab 1
+
+=== "Tab 2"
+    Content for tab 2
+
+## Images
+
+Place images in the `docs/assets/` directory and reference them like this:
+
+```markdown
+![Alt text](../assets/image-name.png)
+```
+
+## Deployment
+
+The documentation is automatically deployed to GitHub Pages when changes are pushed to the main branch. The deployment is handled by the GitHub Actions workflow in `.github/workflows/docs.yml`. 

docs/contributing/working-with-docs.md

@@ -0,0 +1,105 @@
+# Getting Started
+
+## Installation
+
+Tach can be installed via pip:
+
+```bash
+pip install tach
+```
+
+## Quick Start
+
+### 1. Initialize Your Project
+
+```bash
+tach init
+```
+
+This will guide you through setting up your module boundaries and will create a `tach.toml` file in your project root.
+
+### 2. Define Module Boundaries
+
+Use the interactive module editor to define your module boundaries:
+
+```bash
+tach mod
+```
+
+This opens an interactive terminal UI where you can navigate and mark your module boundaries:
+
+- Use arrow keys to navigate the file tree
+- Press `Enter` to mark/unmark a module
+- Press `s` to mark a directory as a source root
+- Press `u` to mark a module as a utility module (can be used anywhere)
+- Press `Ctrl+a` to mark all siblings as modules
+- Press `Ctrl+s` to save
+- Press `Ctrl+c` to exit without saving
+
+### 3. Sync Dependencies
+
+Once your module boundaries are defined, sync your dependency rules with your actual code:
+
+```bash
+tach sync
+```
+
+This will analyze your codebase and automatically add dependency rules to your `tach.toml` file based on your actual imports.
+
+### 4. Check Boundaries
+
+Now you can check if your module boundaries are respected:
+
+```bash
+tach check
+```
+
+This command will report any violations of your module boundaries or interfaces.
+
+### 5. Visualize Dependencies
+
+To see a visualization of your module dependencies:
+
+```bash
+tach show
+```
+
+This will generate a graphical representation of your module dependencies.
+
+## Integrating with Your Development Workflow
+
+### Pre-commit Hook
+
+You can add Tach to your pre-commit hooks to automatically check your module boundaries on each commit:
+
+```bash
+tach install --pre-commit
+```
+
+Or manually add it to your `.pre-commit-config.yaml`:
+
+```yaml
+-   repo: local
+    hooks:
+    -   id: tach
+        name: tach
+        entry: tach check
+        language: system
+        pass_filenames: false
+```
+
+### CI Pipeline
+
+Add Tach to your CI pipeline to ensure your module boundaries are respected:
+
+```yaml
+- name: Check module boundaries
+  run: tach check
+```
+
+## Next Steps
+
+- Learn more about [Configuration](../usage/configuration.md)
+- Explore the [Commands](../usage/commands.md) in detail
+- Define [Public Interfaces](../usage/interfaces.md) for your modules
+- Set up [Layers](../usage/layers.md) to enforce architectural patterns