{"owner":"mindsdb","repo":"mindshub","hasSkills":true,"hasMcp":false,"mcpConfig":null,"found":["CLAUDE.md"],"skills":{"CLAUDE.md":"# Minds Platform\n\n## Submodules\n\nThis repo has 4 submodules:\n\n| Path | Repo | Tracking |\n|---|---|---|\n| `frontend` | `mindsdb/cowork` | tag-pinned |\n| `backend/core_api` | `mindsdb/cowork-server` | tag-pinned |\n| `backend/core_agent` | `mindsdb/anton` | tag-pinned |\n| `backend/data-vault` | `mindsdb/data-vault` | `main` branch |\n\n### Clone (fresh)\n\n```bash\ngit clone --recurse-submodules https://github.com/mindsdb/minds-platform\n```\n\n### Initialize after cloning without submodules\n\n```bash\ngit submodule update --init --recursive\n```\n\n### Pull — sync to what the parent repo pins (default)\n\n```bash\ngit submodule update --recursive\n```\n\n### Pull — advance all submodules to latest `main`\n\nOnly do this if you intend to develop across all repos. You'll need to commit the updated pointers in the parent repo afterward.\n\n```bash\ngit submodule foreach 'git checkout main && git pull origin main'\n```\n\n### Make changes and push inside a submodule\n\n1. Go into the submodule and get on a real branch first (all submodules start in detached HEAD):\n\n```bash\ncd backend/data-vault   # or whichever submodule\ngit checkout main       # or: git checkout -b your-feature-branch\n```\n\n2. Make your changes, commit, and push:\n\n```bash\ngit add .\ngit commit -m \"your message\"\ngit push origin main\n```\n\n3. Back in the parent repo, stage and commit the updated submodule pointer:\n\n```bash\ncd ../..\ngit add backend/data-vault\ngit commit -m \"bump data-vault to latest\"\ngit push\n```\n\n> The parent repo stores a commit SHA pointer to each submodule, not the code itself. Always push from inside the submodule first, then update the pointer in the parent.\n\n## Working on module branches (multi-developer)\n\nThe superproject pins each submodule to a commit. To let everyone develop on\ntheir own module branches without fighting over pins or drowning in `git status`\nnoise, the workflow is:\n\n**1. `.gitmodules` sets `ignore = all` on every submodule.** Day-to-day branch\nwork in a submodule never shows up as a superproject change — `git status` in the\nparent stays clean no matter what branch each module is on. (This is the only\nsetting that silences \"new commits in `<module>`\"; `ignore = dirty` does not.)\n\n**2. Pick your branches in `dev.env`** (gitignored — copy from `dev.env.example`):\n\n```bash\ncp dev.env.example dev.env\n# REF=feat/my-thing            # all modules on one branch…\n# API_REF=feat/server-thing    # …or override per module\n```\n\n**3. `make` is the single source of truth for refs** — both run paths follow `dev.env`:\n\n| Command | What it does |\n|---|---|\n| `make refs` | print the refs the next run will use |\n| `make use` | check out those refs across all submodules |\n| `make dev` / `make dev-web` | run the **local submodule source** (`--reload`) — follows the checked-out branch |\n| `make server` | (re)install the **Electron desktop server** from `API_REF`/`AGENT_REF` |\n| `make server-local` | install Electron desktop server **from local uncommitted source** (no push needed) |\n| `make app` | run the Electron desktop app (auto-update disabled so it can't revert your branch) |\n| `make app-local` | run the Electron desktop app **against local uncommitted source** (runs `server-local` first) |\n| `make pack-local` | build macOS `.app` from local uncommitted source, iCloud-safe (no DMG, `/tmp` build) |\n| `make watch` | live reload — Electron app + Python `--reload` (alias for `make dev`) |\n| `make baseline` | snap every submodule back to the superproject's pinned commits |\n| `make pin` | record the submodules' current commits as the superproject pins (a deliberate commit) |\n\n> Two run paths, same refs: `make dev`/`dev-web` execute the local source, so they\n> follow whatever `make use` checked out. The desktop app runs a `uv`-tool-installed\n> server keyed by `COWORK_SERVER_REF`/`ANTON_REF` (see\n> `frontend/src/main/server-source.ts`); `make server`/`make app` set those from the\n> same `dev.env`. Keep both on the same ref — they share `~/.cowork/cowork.db`, so a\n> migration applied by one must exist in the other (else the app crashes on startup\n> with `Can't locate revision …`). `make flush` resets when they drift.\n\n> **Developing with uncommitted changes in the Electron app**: `make dev`/`dev-web`\n> already pick up uncommitted source changes on-the-fly. For the Electron desktop path,\n> `make app-local` installs cowork-server directly from `backend/core_api/` (no commit\n> needed) and then launches the app. `COWORK_SERVER_DISABLE_AUTOUPDATE=1` is set\n> automatically so the installer won't re-download from git. To also develop `core_agent`\n> without committing: update `[tool.uv.sources] anton-agent` in\n> `backend/core_api/pyproject.toml` to `{ path = \"../../core_agent\" }`, then re-run\n> `make app-local`. (Restore the git source before pushing.)\n\n**4. Bumping pins is deliberate.** Because submodules are ignored, the *only* way a\npin changes is `make pin` (after a submodule PR merges and you push the submodule).\nPushing from inside the submodule first still applies — `make pin` just records the\nnew SHA in the superproject as one reviewable commit.\n\n**5. Snap back to baselines** when you're *not* developing a module: `make baseline`\n(`git submodule update --init --recursive`). With `ignore = all`, `git status` won't\nremind you a teammate's pin bump left a module behind — run `make baseline` after\npulling the superproject to align.\n\n## Running locally (web browser mode)\n\nAfter initializing submodules, start the full stack with:\n\n```bash\ncd frontend\nnpm install\nnpm run dev:web\n```\n\nOpen `http://localhost:5173/`. The FastAPI backend starts automatically on `http://127.0.0.1:26866`.\n\n### Skip Keycloak auth (required for local dev)\n\nBy default the web app redirects to MindsHub SSO on first load. To bypass this locally, create `frontend/src/renderer/.env` (Vite's root is `src/renderer`, not `frontend/`):\n\n```bash\necho \"VITE_SKIP_AUTH=true\" > frontend/src/renderer/.env\n```\n\nThen restart `npm run dev:web`. The Keycloak redirect will be skipped and the app loads the onboarding screen directly where you can enter a BYOK API key.\n\n### First-time symlink fix\n\nThe `dev:web` script expects the `uv`-installed tool at `~/.local/share/uv/tools/anton/`, but it may be installed as `anton-agent`. If you see \"Anton Python interpreter not found\", run:\n\n```bash\nln -s ~/.local/share/uv/tools/anton-agent ~/.local/share/uv/tools/anton\n```\n\n## Flushing local installs (fresh start)\n\n`make flush` wipes every local install **and** all app state, returning the machine to a pre-install condition. Use it to test the from-scratch install flow or to recover from a broken/half-installed environment.\n\n```bash\nmake flush          # prompts before deleting\nmake flush FORCE=1  # skip the prompt (CI / scripts)\n```\n\nIt removes:\n\n| Removed | What it is |\n|---|---|\n| `cowork-server` uv tool (+ legacy `anton-agent`) | the runtime the **Electron app** installs via `uv tool install` |\n| `backend/core_api/.venv`, `backend/core_agent/.venv` | the venvs the **Makefile** dev flow builds via `uv sync` |\n| `~/.anton` | provider keys / `.env` |\n| `~/.cowork` | database, `hermes`, `projects` |\n\n> ⚠️ Destructive — deletes conversations and saved provider keys, no undo. After flushing, the next `make setup` (or app launch) reinstalls everything from scratch.\n\n> It deliberately leaves `uv` itself and uv-managed Python runtimes alone (shared infrastructure, not part of the anton/cowork install).\n"},"files":{"CLAUDE.md":"# Minds Platform\n\n## Submodules\n\nThis repo has 4 submodules:\n\n| Path | Repo | Tracking |\n|---|---|---|\n| `frontend` | `mindsdb/cowork` | tag-pinned |\n| `backend/core_api` | `mindsdb/cowork-server` | tag-pinned |\n| `backend/core_agent` | `mindsdb/anton` | tag-pinned |\n| `backend/data-vault` | `mindsdb/data-vault` | `main` branch |\n\n### Clone (fresh)\n\n```bash\ngit clone --recurse-submodules https://github.com/mindsdb/minds-platform\n```\n\n### Initialize after cloning without submodules\n\n```bash\ngit submodule update --init --recursive\n```\n\n### Pull — sync to what the parent repo pins (default)\n\n```bash\ngit submodule update --recursive\n```\n\n### Pull — advance all submodules to latest `main`\n\nOnly do this if you intend to develop across all repos. You'll need to commit the updated pointers in the parent repo afterward.\n\n```bash\ngit submodule foreach 'git checkout main && git pull origin main'\n```\n\n### Make changes and push inside a submodule\n\n1. Go into the submodule and get on a real branch first (all submodules start in detached HEAD):\n\n```bash\ncd backend/data-vault   # or whichever submodule\ngit checkout main       # or: git checkout -b your-feature-branch\n```\n\n2. Make your changes, commit, and push:\n\n```bash\ngit add .\ngit commit -m \"your message\"\ngit push origin main\n```\n\n3. Back in the parent repo, stage and commit the updated submodule pointer:\n\n```bash\ncd ../..\ngit add backend/data-vault\ngit commit -m \"bump data-vault to latest\"\ngit push\n```\n\n> The parent repo stores a commit SHA pointer to each submodule, not the code itself. Always push from inside the submodule first, then update the pointer in the parent.\n\n## Working on module branches (multi-developer)\n\nThe superproject pins each submodule to a commit. To let everyone develop on\ntheir own module branches without fighting over pins or drowning in `git status`\nnoise, the workflow is:\n\n**1. `.gitmodules` sets `ignore = all` on every submodule.** Day-to-day branch\nwork in a submodule never shows up as a superproject change — `git status` in the\nparent stays clean no matter what branch each module is on. (This is the only\nsetting that silences \"new commits in `<module>`\"; `ignore = dirty` does not.)\n\n**2. Pick your branches in `dev.env`** (gitignored — copy from `dev.env.example`):\n\n```bash\ncp dev.env.example dev.env\n# REF=feat/my-thing            # all modules on one branch…\n# API_REF=feat/server-thing    # …or override per module\n```\n\n**3. `make` is the single source of truth for refs** — both run paths follow `dev.env`:\n\n| Command | What it does |\n|---|---|\n| `make refs` | print the refs the next run will use |\n| `make use` | check out those refs across all submodules |\n| `make dev` / `make dev-web` | run the **local submodule source** (`--reload`) — follows the checked-out branch |\n| `make server` | (re)install the **Electron desktop server** from `API_REF`/`AGENT_REF` |\n| `make server-local` | install Electron desktop server **from local uncommitted source** (no push needed) |\n| `make app` | run the Electron desktop app (auto-update disabled so it can't revert your branch) |\n| `make app-local` | run the Electron desktop app **against local uncommitted source** (runs `server-local` first) |\n| `make pack-local` | build macOS `.app` from local uncommitted source, iCloud-safe (no DMG, `/tmp` build) |\n| `make watch` | live reload — Electron app + Python `--reload` (alias for `make dev`) |\n| `make baseline` | snap every submodule back to the superproject's pinned commits |\n| `make pin` | record the submodules' current commits as the superproject pins (a deliberate commit) |\n\n> Two run paths, same refs: `make dev`/`dev-web` execute the local source, so they\n> follow whatever `make use` checked out. The desktop app runs a `uv`-tool-installed\n> server keyed by `COWORK_SERVER_REF`/`ANTON_REF` (see\n> `frontend/src/main/server-source.ts`); `make server`/`make app` set those from the\n> same `dev.env`. Keep both on the same ref — they share `~/.cowork/cowork.db`, so a\n> migration applied by one must exist in the other (else the app crashes on startup\n> with `Can't locate revision …`). `make flush` resets when they drift.\n\n> **Developing with uncommitted changes in the Electron app**: `make dev`/`dev-web`\n> already pick up uncommitted source changes on-the-fly. For the Electron desktop path,\n> `make app-local` installs cowork-server directly from `backend/core_api/` (no commit\n> needed) and then launches the app. `COWORK_SERVER_DISABLE_AUTOUPDATE=1` is set\n> automatically so the installer won't re-download from git. To also develop `core_agent`\n> without committing: update `[tool.uv.sources] anton-agent` in\n> `backend/core_api/pyproject.toml` to `{ path = \"../../core_agent\" }`, then re-run\n> `make app-local`. (Restore the git source before pushing.)\n\n**4. Bumping pins is deliberate.** Because submodules are ignored, the *only* way a\npin changes is `make pin` (after a submodule PR merges and you push the submodule).\nPushing from inside the submodule first still applies — `make pin` just records the\nnew SHA in the superproject as one reviewable commit.\n\n**5. Snap back to baselines** when you're *not* developing a module: `make baseline`\n(`git submodule update --init --recursive`). With `ignore = all`, `git status` won't\nremind you a teammate's pin bump left a module behind — run `make baseline` after\npulling the superproject to align.\n\n## Running locally (web browser mode)\n\nAfter initializing submodules, start the full stack with:\n\n```bash\ncd frontend\nnpm install\nnpm run dev:web\n```\n\nOpen `http://localhost:5173/`. The FastAPI backend starts automatically on `http://127.0.0.1:26866`.\n\n### Skip Keycloak auth (required for local dev)\n\nBy default the web app redirects to MindsHub SSO on first load. To bypass this locally, create `frontend/src/renderer/.env` (Vite's root is `src/renderer`, not `frontend/`):\n\n```bash\necho \"VITE_SKIP_AUTH=true\" > frontend/src/renderer/.env\n```\n\nThen restart `npm run dev:web`. The Keycloak redirect will be skipped and the app loads the onboarding screen directly where you can enter a BYOK API key.\n\n### First-time symlink fix\n\nThe `dev:web` script expects the `uv`-installed tool at `~/.local/share/uv/tools/anton/`, but it may be installed as `anton-agent`. If you see \"Anton Python interpreter not found\", run:\n\n```bash\nln -s ~/.local/share/uv/tools/anton-agent ~/.local/share/uv/tools/anton\n```\n\n## Flushing local installs (fresh start)\n\n`make flush` wipes every local install **and** all app state, returning the machine to a pre-install condition. Use it to test the from-scratch install flow or to recover from a broken/half-installed environment.\n\n```bash\nmake flush          # prompts before deleting\nmake flush FORCE=1  # skip the prompt (CI / scripts)\n```\n\nIt removes:\n\n| Removed | What it is |\n|---|---|\n| `cowork-server` uv tool (+ legacy `anton-agent`) | the runtime the **Electron app** installs via `uv tool install` |\n| `backend/core_api/.venv`, `backend/core_agent/.venv` | the venvs the **Makefile** dev flow builds via `uv sync` |\n| `~/.anton` | provider keys / `.env` |\n| `~/.cowork` | database, `hermes`, `projects` |\n\n> ⚠️ Destructive — deletes conversations and saved provider keys, no undo. After flushing, the next `make setup` (or app launch) reinstalls everything from scratch.\n\n> It deliberately leaves `uv` itself and uv-managed Python runtimes alone (shared infrastructure, not part of the anton/cowork install).\n"},"items":[{"name":"CLAUDE.md","path":"CLAUDE.md","title":"CLAUDE.md","content":"# Minds Platform\n\n## Submodules\n\nThis repo has 4 submodules:\n\n| Path | Repo | Tracking |\n|---|---|---|\n| `frontend` | `mindsdb/cowork` | tag-pinned |\n| `backend/core_api` | `mindsdb/cowork-server` | tag-pinned |\n| `backend/core_agent` | `mindsdb/anton` | tag-pinned |\n| `backend/data-vault` | `mindsdb/data-vault` | `main` branch |\n\n### Clone (fresh)\n\n```bash\ngit clone --recurse-submodules https://github.com/mindsdb/minds-platform\n```\n\n### Initialize after cloning without submodules\n\n```bash\ngit submodule update --init --recursive\n```\n\n### Pull — sync to what the parent repo pins (default)\n\n```bash\ngit submodule update --recursive\n```\n\n### Pull — advance all submodules to latest `main`\n\nOnly do this if you intend to develop across all repos. You'll need to commit the updated pointers in the parent repo afterward.\n\n```bash\ngit submodule foreach 'git checkout main && git pull origin main'\n```\n\n### Make changes and push inside a submodule\n\n1. Go into the submodule and get on a real branch first (all submodules start in detached HEAD):\n\n```bash\ncd backend/data-vault   # or whichever submodule\ngit checkout main       # or: git checkout -b your-feature-branch\n```\n\n2. Make your changes, commit, and push:\n\n```bash\ngit add .\ngit commit -m \"your message\"\ngit push origin main\n```\n\n3. Back in the parent repo, stage and commit the updated submodule pointer:\n\n```bash\ncd ../..\ngit add backend/data-vault\ngit commit -m \"bump data-vault to latest\"\ngit push\n```\n\n> The parent repo stores a commit SHA pointer to each submodule, not the code itself. Always push from inside the submodule first, then update the pointer in the parent.\n\n## Working on module branches (multi-developer)\n\nThe superproject pins each submodule to a commit. To let everyone develop on\ntheir own module branches without fighting over pins or drowning in `git status`\nnoise, the workflow is:\n\n**1. `.gitmodules` sets `ignore = all` on every submodule.** Day-to-day branch\nwork in a submodule never shows up as a superproject change — `git status` in the\nparent stays clean no matter what branch each module is on. (This is the only\nsetting that silences \"new commits in `<module>`\"; `ignore = dirty` does not.)\n\n**2. Pick your branches in `dev.env`** (gitignored — copy from `dev.env.example`):\n\n```bash\ncp dev.env.example dev.env\n# REF=feat/my-thing            # all modules on one branch…\n# API_REF=feat/server-thing    # …or override per module\n```\n\n**3. `make` is the single source of truth for refs** — both run paths follow `dev.env`:\n\n| Command | What it does |\n|---|---|\n| `make refs` | print the refs the next run will use |\n| `make use` | check out those refs across all submodules |\n| `make dev` / `make dev-web` | run the **local submodule source** (`--reload`) — follows the checked-out branch |\n| `make server` | (re)install the **Electron desktop server** from `API_REF`/`AGENT_REF` |\n| `make server-local` | install Electron desktop server **from local uncommitted source** (no push needed) |\n| `make app` | run the Electron desktop app (auto-update disabled so it can't revert your branch) |\n| `make app-local` | run the Electron desktop app **against local uncommitted source** (runs `server-local` first) |\n| `make pack-local` | build macOS `.app` from local uncommitted source, iCloud-safe (no DMG, `/tmp` build) |\n| `make watch` | live reload — Electron app + Python `--reload` (alias for `make dev`) |\n| `make baseline` | snap every submodule back to the superproject's pinned commits |\n| `make pin` | record the submodules' current commits as the superproject pins (a deliberate commit) |\n\n> Two run paths, same refs: `make dev`/`dev-web` execute the local source, so they\n> follow whatever `make use` checked out. The desktop app runs a `uv`-tool-installed\n> server keyed by `COWORK_SERVER_REF`/`ANTON_REF` (see\n> `frontend/src/main/server-source.ts`); `make server`/`make app` set those from the\n> same `dev.env`. Keep both on the same ref — they share `~/.cowork/cowork.db`, so a\n> migration applied by one must exist in the other (else the app crashes on startup\n> with `Can't locate revision …`). `make flush` resets when they drift.\n\n> **Developing with uncommitted changes in the Electron app**: `make dev`/`dev-web`\n> already pick up uncommitted source changes on-the-fly. For the Electron desktop path,\n> `make app-local` installs cowork-server directly from `backend/core_api/` (no commit\n> needed) and then launches the app. `COWORK_SERVER_DISABLE_AUTOUPDATE=1` is set\n> automatically so the installer won't re-download from git. To also develop `core_agent`\n> without committing: update `[tool.uv.sources] anton-agent` in\n> `backend/core_api/pyproject.toml` to `{ path = \"../../core_agent\" }`, then re-run\n> `make app-local`. (Restore the git source before pushing.)\n\n**4. Bumping pins is deliberate.** Because submodules are ignored, the *only* way a\npin changes is `make pin` (after a submodule PR merges and you push the submodule).\nPushing from inside the submodule first still applies — `make pin` just records the\nnew SHA in the superproject as one reviewable commit.\n\n**5. Snap back to baselines** when you're *not* developing a module: `make baseline`\n(`git submodule update --init --recursive`). With `ignore = all`, `git status` won't\nremind you a teammate's pin bump left a module behind — run `make baseline` after\npulling the superproject to align.\n\n## Running locally (web browser mode)\n\nAfter initializing submodules, start the full stack with:\n\n```bash\ncd frontend\nnpm install\nnpm run dev:web\n```\n\nOpen `http://localhost:5173/`. The FastAPI backend starts automatically on `http://127.0.0.1:26866`.\n\n### Skip Keycloak auth (required for local dev)\n\nBy default the web app redirects to MindsHub SSO on first load. To bypass this locally, create `frontend/src/renderer/.env` (Vite's root is `src/renderer`, not `frontend/`):\n\n```bash\necho \"VITE_SKIP_AUTH=true\" > frontend/src/renderer/.env\n```\n\nThen restart `npm run dev:web`. The Keycloak redirect will be skipped and the app loads the onboarding screen directly where you can enter a BYOK API key.\n\n### First-time symlink fix\n\nThe `dev:web` script expects the `uv`-installed tool at `~/.local/share/uv/tools/anton/`, but it may be installed as `anton-agent`. If you see \"Anton Python interpreter not found\", run:\n\n```bash\nln -s ~/.local/share/uv/tools/anton-agent ~/.local/share/uv/tools/anton\n```\n\n## Flushing local installs (fresh start)\n\n`make flush` wipes every local install **and** all app state, returning the machine to a pre-install condition. Use it to test the from-scratch install flow or to recover from a broken/half-installed environment.\n\n```bash\nmake flush          # prompts before deleting\nmake flush FORCE=1  # skip the prompt (CI / scripts)\n```\n\nIt removes:\n\n| Removed | What it is |\n|---|---|\n| `cowork-server` uv tool (+ legacy `anton-agent`) | the runtime the **Electron app** installs via `uv tool install` |\n| `backend/core_api/.venv`, `backend/core_agent/.venv` | the venvs the **Makefile** dev flow builds via `uv sync` |\n| `~/.anton` | provider keys / `.env` |\n| `~/.cowork` | database, `hermes`, `projects` |\n\n> ⚠️ Destructive — deletes conversations and saved provider keys, no undo. After flushing, the next `make setup` (or app launch) reinstalls everything from scratch.\n\n> It deliberately leaves `uv` itself and uv-managed Python runtimes alone (shared infrastructure, not part of the anton/cowork install).\n","category":"root","tokens":1855}]}