preppergpt 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Teamslop
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+# PrepperGPT
+
+PrepperGPT packages a local-first ChatGPT-like experience for Linux machines.
+It uses upstream OpenWebUI for the app shell and adds a hardware detector,
+model planner, Docker Compose runtime, local sidecars, and a practical
+PrepperGPT field-kit theme.
+
+The first release targets Linux with NVIDIA GPUs first, with CPU fallback where
+possible. It is an online installer: model and container downloads require a
+working network during setup.
+
+## Install
+
+Until the npm package is published, install from GitHub:
+
+```bash
+git clone https://github.com/teamslop/preppergpt.git
+cd preppergpt
+node bin/preppergpt.js install --profile balanced
+node bin/preppergpt.js start
+```
+
+After npm publication:
+
+```bash
+npx preppergpt install --profile balanced
+preppergpt start
+```
+
+Other profiles:
+
+```bash
+preppergpt install --profile intelligence
+preppergpt install --profile speed
+```
+
+Open the app at:
+
+```text
+http://127.0.0.1:8080
+```
+
+Default local admin credentials are written to `~/.preppergpt/.env.preppergpt`.
+Change them before exposing the machine to any network.
+
+## Commands
+
+```bash
+preppergpt detect
+preppergpt plan --profile balanced
+preppergpt install --profile balanced
+preppergpt start
+preppergpt stop
+preppergpt status
+preppergpt doctor
+preppergpt switch-profile --profile speed
+```
+
+## Profiles
+
+- `intelligence`: chooses the strongest local reasoning route that fits the
+  machine, preferring GLM 5.2 Q4 and long-context coding routes when available.
+- `speed`: chooses smaller GPU-friendly routes and makes low-latency chat the
+  default.
+- `balanced`: uses the local auto-router as the default and keeps reasoning,
+  coding, research, vision, image, and STT routes additive.
+
+The planner never removes existing OpenWebUI models. It writes additive defaults
+and route ordering into the generated compose override.
+
+## Model Assets
+
+Some routes can be pulled by the runtime, while very large routes such as GLM
+5.2 Q4 and Flux weights are marked as manual or external in
+`profiles/models.json`. `preppergpt doctor` reports which selected routes still
+need local files or endpoints.
+
+## Publishing
+
+The package is designed to be published as:
+
+```bash
+npm publish --access public
+```
+
+Publishing requires an authenticated npm account with permission to publish the
+currently unclaimed `preppergpt` package name.
+
+The source repository is expected at:
+
+```text
+https://github.com/teamslop/preppergpt
+```

package/bin/preppergpt.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { runCli } from "../installer/cli.mjs";
+
+runCli(process.argv.slice(2)).catch((error) => {
+  const message = error && error.stack ? error.stack : String(error);
+  console.error(message);
+  process.exitCode = 1;
+});

package/compose/preppergpt.yaml

@@ -0,0 +1,232 @@
+name: preppergpt
+
+services:
+  open-webui:
+    image: ghcr.io/open-webui/open-webui:main
+    container_name: preppergpt-open-webui
+    pull_policy: always
+    restart: unless-stopped
+    network_mode: host
+    ulimits:
+      nofile:
+        soft: 1048576
+        hard: 1048576
+    volumes:
+      - ${PREPPERGPT_DATA_DIR:?set PREPPERGPT_DATA_DIR}/openwebui:/app/backend/data
+      - ../services/comfyui:/app/backend/data/parity-comfyui:ro
+      - ../themes/preppergpt/static/favicon.svg:/app/backend/open_webui/static/favicon.svg:ro
+      - ../themes/preppergpt/static/logo.svg:/app/backend/open_webui/static/logo.svg:ro
+    environment:
+      WEBUI_NAME: "PrepperGPT"
+      WEBUI_AUTH: "True"
+      WEBUI_ADMIN_EMAIL: "${WEBUI_ADMIN_EMAIL:?set WEBUI_ADMIN_EMAIL}"
+      WEBUI_ADMIN_PASSWORD: "${WEBUI_ADMIN_PASSWORD:?set WEBUI_ADMIN_PASSWORD}"
+      WEBUI_ADMIN_NAME: "${WEBUI_ADMIN_NAME:-PrepperGPT Admin}"
+      WEBUI_SECRET_KEY: "${WEBUI_SECRET_KEY:?set WEBUI_SECRET_KEY}"
+      ENABLE_OLLAMA_API: "True"
+      OLLAMA_BASE_URLS: "${OLLAMA_BASE_URL:-http://127.0.0.1:11434}"
+      ENABLE_OPENAI_API: "True"
+      OPENAI_API_BASE_URLS: "${SLOCODE_BASE_URL:-http://127.0.0.1:11438/v1};${GLM52_BASE_URL:-http://127.0.0.1:11441/v1};http://127.0.0.1:18041/v1;http://127.0.0.1:18043/v1;http://127.0.0.1:18044/v1"
+      OPENAI_API_KEYS: "slopcode;glm52;deep-research;local-agent;local-vision"
+      ENABLE_DIRECT_CONNECTIONS: "True"
+      DEFAULT_MODELS: "${PREPPERGPT_DEFAULT_MODEL:-local-chatgpt-auto}"
+      MODEL_ORDER_LIST: "${PREPPERGPT_MODEL_ORDER_LIST:-[\"local-chatgpt-auto\"]}"
+      TASK_MODEL: "${PREPPERGPT_DEFAULT_MODEL:-local-chatgpt-auto}"
+      ENABLE_CHANNELS: "True"
+      ENABLE_TITLE_GENERATION: "False"
+      ENABLE_TAGS_GENERATION: "False"
+      ENABLE_FOLLOW_UP_GENERATION: "False"
+      ENABLE_SEARCH_QUERY_GENERATION: "True"
+      ENABLE_RETRIEVAL_QUERY_GENERATION: "True"
+      DEFAULT_PROMPT_SUGGESTIONS: >-
+        [
+          {"title":["Field repair","diagnose a broken water pump"],"content":"Help me troubleshoot a broken water pump with only hand tools. Ask clarifying questions first."},
+          {"title":["Food storage","build a rotation plan"],"content":"Create a practical food storage rotation plan for a household of four using shelf-stable staples."},
+          {"title":["Medical reference","triage a minor injury"],"content":"Give general first-aid information for a minor injury and clearly flag when professional care is needed."},
+          {"title":["Radio log","summarize messages"],"content":"Turn this radio message log into a concise situation report with unresolved questions."}
+        ]
+      CONTENT_EXTRACTION_ENGINE: "tika"
+      TIKA_SERVER_URL: "http://127.0.0.1:9998"
+      ENABLE_RAG_HYBRID_SEARCH: "True"
+      RAG_EMBEDDING_MODEL: "BAAI/bge-m3"
+      RAG_RERANKING_MODEL: "BAAI/bge-reranker-v2-m3"
+      RAG_TOP_K: "8"
+      RAG_TOP_K_RERANKER: "4"
+      CHUNK_SIZE: "1000"
+      CHUNK_OVERLAP: "150"
+      ENABLE_WEB_SEARCH: "True"
+      WEB_SEARCH_ENGINE: "searxng"
+      SEARXNG_QUERY_URL: "http://127.0.0.1:18080/search?q=<query>&format=json"
+      WEB_SEARCH_RESULT_COUNT: "5"
+      WEB_SEARCH_CONCURRENT_REQUESTS: "3"
+      ENABLE_CODE_EXECUTION: "True"
+      CODE_EXECUTION_ENGINE: "jupyter"
+      CODE_EXECUTION_JUPYTER_URL: "http://127.0.0.1:8888"
+      CODE_EXECUTION_JUPYTER_AUTH: "token"
+      CODE_EXECUTION_JUPYTER_AUTH_TOKEN: "${JUPYTER_TOKEN:?set JUPYTER_TOKEN}"
+      ENABLE_CODE_INTERPRETER: "True"
+      CODE_INTERPRETER_ENGINE: "jupyter"
+      CODE_INTERPRETER_JUPYTER_URL: "http://127.0.0.1:8888"
+      CODE_INTERPRETER_JUPYTER_AUTH: "token"
+      CODE_INTERPRETER_JUPYTER_AUTH_TOKEN: "${JUPYTER_TOKEN:?set JUPYTER_TOKEN}"
+      WHISPER_MODEL: "large-v3"
+      WHISPER_COMPUTE_TYPE: "int8"
+      WHISPER_MODEL_AUTO_UPDATE: "True"
+      WHISPER_VAD_FILTER: "True"
+      WHISPER_MULTILINGUAL: "True"
+      ENABLE_IMAGE_GENERATION: "True"
+      IMAGE_GENERATION_ENGINE: "comfyui"
+      COMFYUI_BASE_URL: "http://127.0.0.1:8188"
+      IMAGE_GENERATION_MODEL: "flux-2-klein-9b-fp8.safetensors"
+      IMAGE_SIZE: "1024x1024"
+      IMAGE_STEPS: "20"
+      SCARF_NO_ANALYTICS: "True"
+      DO_NOT_TRACK: "True"
+      ANONYMIZED_TELEMETRY: "False"
+      PORT: "${PREPPERGPT_PORT:-8080}"
+
+  ollama:
+    image: ollama/ollama:latest
+    container_name: preppergpt-ollama
+    restart: unless-stopped
+    network_mode: host
+    volumes:
+      - ${PREPPERGPT_DATA_DIR:?set PREPPERGPT_DATA_DIR}/ollama:/root/.ollama
+    environment:
+      OLLAMA_HOST: "127.0.0.1:11434"
+      OLLAMA_MODELS: "/root/.ollama/models"
+
+  searxng:
+    image: searxng/searxng:latest
+    container_name: preppergpt-searxng
+    restart: unless-stopped
+    network_mode: host
+    volumes:
+      - ../services/searxng/settings.yml:/etc/searxng/settings.yml:ro
+    environment:
+      SEARXNG_BASE_URL: "http://127.0.0.1:18080/"
+      SEARXNG_SECRET_KEY: "${SEARXNG_SECRET_KEY:?set SEARXNG_SECRET_KEY}"
+
+  tika:
+    image: apache/tika:latest-full
+    container_name: preppergpt-tika
+    restart: unless-stopped
+    network_mode: host
+
+  jupyter:
+    image: quay.io/jupyter/minimal-notebook:latest
+    container_name: preppergpt-jupyter
+    restart: unless-stopped
+    network_mode: host
+    user: root
+    volumes:
+      - ${PREPPERGPT_DATA_DIR:?set PREPPERGPT_DATA_DIR}/jupyter:/home/jovyan/work
+    environment:
+      JUPYTER_ENABLE_LAB: "yes"
+      JUPYTER_TOKEN: "${JUPYTER_TOKEN:?set JUPYTER_TOKEN}"
+      CHOWN_HOME: "yes"
+      CHOWN_HOME_OPTS: "-R"
+    command:
+      - start-notebook.py
+      - "--ServerApp.ip=0.0.0.0"
+      - "--ServerApp.port=8888"
+      - "--ServerApp.token=${JUPYTER_TOKEN:?set JUPYTER_TOKEN}"
+      - "--ServerApp.password="
+      - "--ServerApp.allow_origin=*"
+
+  deep-research:
+    build:
+      context: ../services/deep-research
+    container_name: preppergpt-deep-research
+    restart: unless-stopped
+    network_mode: host
+    volumes:
+      - ${PREPPERGPT_DATA_DIR:?set PREPPERGPT_DATA_DIR}/deep-research:/data
+    environment:
+      DEEP_RESEARCH_HOST: "127.0.0.1"
+      DEEP_RESEARCH_PORT: "18041"
+      DEEP_RESEARCH_PUBLIC_BASE_URL: "http://127.0.0.1:18041"
+      DEEP_RESEARCH_MODEL_ID: "deep-research-glm52"
+      DEEP_RESEARCH_MODEL: "${DEEP_RESEARCH_MODEL:-glm52-q4-local}"
+      DEEP_RESEARCH_GLM_BASE_URL: "${GLM52_BASE_URL:-http://127.0.0.1:11441/v1}"
+      DEEP_RESEARCH_SEARXNG_URL: "http://127.0.0.1:18080/search"
+      DEEP_RESEARCH_TIKA_URL: "http://127.0.0.1:9998/tika"
+      DEEP_RESEARCH_LOCAL_APP_CONNECTOR_URL: "http://127.0.0.1:18042"
+
+  local-scheduler:
+    build:
+      context: ../services/local-scheduler
+    container_name: preppergpt-local-scheduler
+    restart: unless-stopped
+    network_mode: host
+    volumes:
+      - ${PREPPERGPT_DATA_DIR:?set PREPPERGPT_DATA_DIR}/local-scheduler:/data
+      - ../docs:/app/parity-docs:ro
+    environment:
+      LOCAL_SCHEDULER_HOST: "127.0.0.1"
+      LOCAL_SCHEDULER_PORT: "18042"
+      LOCAL_SCHEDULER_PUBLIC_BASE_URL: "http://127.0.0.1:18042"
+      LOCAL_SCHEDULER_DEFAULT_BASE_URL: "http://127.0.0.1:18041/v1"
+      LOCAL_SCHEDULER_DEFAULT_MODEL: "deep-research-glm52"
+      LOCAL_PARITY_DOCS_DIR: "/app/parity-docs"
+
+  playwright-agent:
+    image: mcr.microsoft.com/playwright:v1.58.0-noble
+    container_name: preppergpt-playwright-agent
+    restart: unless-stopped
+    network_mode: host
+    command: npx -y playwright@1.58.0 run-server --port 18045 --host 127.0.0.1
+
+  local-agent:
+    build:
+      context: ../services/local-agent
+    container_name: preppergpt-local-agent
+    restart: unless-stopped
+    network_mode: host
+    volumes:
+      - ${PREPPERGPT_DATA_DIR:?set PREPPERGPT_DATA_DIR}/local-agent:/data
+      - /tmp/.X11-unix:/tmp/.X11-unix:rw
+      - ${XDG_RUNTIME_DIR:-/run/user/1000}:${XDG_RUNTIME_DIR:-/run/user/1000}:rw
+      - ${XAUTHORITY:-/tmp/.preppergpt-missing-xauthority}:/tmp/.Xauthority:ro
+    environment:
+      LOCAL_AGENT_HOST: "127.0.0.1"
+      LOCAL_AGENT_PORT: "18043"
+      LOCAL_AGENT_PUBLIC_BASE_URL: "http://127.0.0.1:18043"
+      LOCAL_AGENT_MODEL_ID: "local-agent-glm52"
+      LOCAL_AGENT_GLM_MODEL: "glm52-q4-local"
+      LOCAL_AGENT_GLM_BASE_URL: "${GLM52_BASE_URL:-http://127.0.0.1:11441/v1}"
+      LOCAL_AGENT_AUTO_ROUTER_MODEL_ID: "local-auto-router"
+      LOCAL_AGENT_AUTO_ROUTER_FAST_MODEL: "gemma4:12b-256k-gpu"
+      LOCAL_AGENT_AUTO_ROUTER_FAST_BASE_URL: "http://127.0.0.1:11434/v1"
+      LOCAL_AGENT_AUTO_ROUTER_CODE_MODEL: "qwen3.6-35b-a3b:slopcode-cpu-64k"
+      LOCAL_AGENT_AUTO_ROUTER_CODE_BASE_URL: "${SLOCODE_BASE_URL:-http://127.0.0.1:11438/v1}"
+      LOCAL_AGENT_AUTO_ROUTER_RESEARCH_MODEL: "deep-research-glm52"
+      LOCAL_AGENT_AUTO_ROUTER_RESEARCH_BASE_URL: "http://127.0.0.1:18041/v1"
+      LOCAL_AGENT_AUTO_ROUTER_AGENT_MODEL: "local-agent-glm52"
+      LOCAL_AGENT_AUTO_ROUTER_AGENT_BASE_URL: "http://127.0.0.1:18043/v1"
+      LOCAL_AGENT_SEARXNG_URL: "http://127.0.0.1:18080/search"
+      LOCAL_AGENT_TIKA_URL: "http://127.0.0.1:9998/tika"
+      LOCAL_AGENT_SCHEDULER_URL: "http://127.0.0.1:18042"
+      LOCAL_AGENT_PLAYWRIGHT_WS_URL: "ws://127.0.0.1:18045"
+      LOCAL_AGENT_DESKTOP_ENABLED: "${LOCAL_AGENT_DESKTOP_ENABLED:-1}"
+      DISPLAY: "${DISPLAY:-}"
+      WAYLAND_DISPLAY: "${WAYLAND_DISPLAY:-}"
+      XDG_RUNTIME_DIR: "${XDG_RUNTIME_DIR:-/run/user/1000}"
+      XAUTHORITY: "/tmp/.Xauthority"
+
+  local-vision:
+    build:
+      context: ../services/local-vision
+    container_name: preppergpt-local-vision
+    restart: unless-stopped
+    network_mode: host
+    volumes:
+      - ${PREPPERGPT_DATA_DIR:?set PREPPERGPT_DATA_DIR}/local-vision:/data
+    environment:
+      LOCAL_VISION_HOST: "127.0.0.1"
+      LOCAL_VISION_PORT: "18044"
+      LOCAL_VISION_DEVICE: "${LOCAL_VISION_DEVICE:-cpu}"
+      LOCAL_VISION_OLLAMA_ENABLED: "1"
+      LOCAL_VISION_OLLAMA_MODEL_ID: "local-vision-gemma4-12b"
+      LOCAL_VISION_OLLAMA_MODEL: "gemma4:12b"
+      LOCAL_VISION_OLLAMA_URL: "http://127.0.0.1:11434"

package/docs/hardware.md

@@ -0,0 +1,15 @@
+# Hardware Guide
+
+PrepperGPT works best on Linux with an NVIDIA GPU and enough NVMe space for
+model weights.
+
+Recommended starting points:
+
+- Speed profile: 16 GB RAM, 8-12 GB VRAM, 40 GB free disk.
+- Balanced profile: 32-64 GB RAM, 12-24 GB VRAM, 120 GB free disk.
+- Intelligence profile: 96 GB RAM or more, fast NVMe, and hundreds of GB free
+  for GLM 5.2 Q4 or similar large weights.
+
+The installer reserves about 15-20% VRAM headroom when deciding whether a model
+fits. If a large manual model is selected, `preppergpt doctor` explains the
+endpoint or file path that must be provided.

package/docs/model-sources.md

@@ -0,0 +1,12 @@
+# Model Sources
+
+PrepperGPT separates routing from model licensing and distribution.
+
+- Ollama models are pulled by the local Ollama runtime when available.
+- OpenWebUI STT models are downloaded by OpenWebUI/faster-whisper.
+- Hugging Face vision models are downloaded by the local vision sidecar.
+- Very large GLM, Slopcode, and Flux assets are marked as manual or external
+  until a license-compatible public download source is configured.
+
+Manual routes are still added to OpenWebUI. They become live when their local
+endpoint or files are present.

package/docs/preppergpt-local-parity-map.md

@@ -0,0 +1,16 @@
+# PrepperGPT Local Parity Map
+
+PrepperGPT packages the local ChatGPT-like stack around OpenWebUI:
+
+- OpenWebUI UI at `http://127.0.0.1:8080`
+- Ollama fast local models at `http://127.0.0.1:11434`
+- Optional GLM 5.2 route at `http://127.0.0.1:11441/v1`
+- Optional Slopcode/Qwen route at `http://127.0.0.1:11438/v1`
+- Deep research sidecar at `http://127.0.0.1:18041/v1`
+- Local scheduler connector at `http://127.0.0.1:18042`
+- Local agent and auto-router at `http://127.0.0.1:18043/v1`
+- Local vision sidecar at `http://127.0.0.1:18044/v1`
+- SearXNG, Tika, Jupyter, and ComfyUI support services
+
+The local goal is functional local parity for common ChatGPT workflows, not
+hosted frontier-model quality or cloud account continuity.

package/docs/publishing.md

@@ -0,0 +1,24 @@
+# Publishing
+
+GitHub source is published at:
+
+```text
+https://github.com/teamslop/preppergpt
+```
+
+To publish npm manually:
+
+```bash
+npm login
+npm whoami
+npm run check
+npm publish --access public
+```
+
+To publish from GitHub Actions:
+
+1. Create an npm automation token.
+2. Add it as the repository secret `NPM_TOKEN`.
+3. Push a SemVer tag such as `v0.1.0`.
+
+The release workflow runs tests and publishes `preppergpt` with npm provenance.

package/installer/cli.mjs

@@ -0,0 +1,225 @@
+import fs from "node:fs";
+import http from "node:http";
+import { detectMachine } from "./lib/detect.mjs";
+import { buildPlan, normalizeProfile } from "./lib/planner.mjs";
+import { packageRoot, runtimePaths } from "./lib/paths.mjs";
+import { renderInstall } from "./lib/render.mjs";
+import { commandResult, parseArgs, readJson, shellQuote } from "./lib/util.mjs";
+
+const VERSION = "0.1.0";
+
+function usage() {
+  return `PrepperGPT ${VERSION}
+
+Usage:
+  preppergpt detect [--json]
+  preppergpt plan --profile balanced|intelligence|speed [--json]
+  preppergpt install --profile balanced|intelligence|speed [--dry-run] [--home PATH]
+  preppergpt start [--home PATH]
+  preppergpt stop [--home PATH]
+  preppergpt status [--home PATH] [--json]
+  preppergpt doctor [--profile balanced|intelligence|speed] [--home PATH]
+  preppergpt switch-profile --profile balanced|intelligence|speed [--home PATH]
+  preppergpt version
+`;
+}
+
+function printJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+function profileFrom(flags) {
+  return normalizeProfile(flags.profile || flags.mode || "balanced");
+}
+
+function composeArgs(paths) {
+  return ["compose", "--env-file", paths.envFile, "-f", `${packageRoot}/compose/preppergpt.yaml`, "-f", paths.generatedCompose];
+}
+
+function runCompose(paths, args) {
+  const result = commandResult("docker", [...composeArgs(paths), ...args], {
+    timeoutMs: 120000,
+    stdio: ["ignore", "inherit", "inherit"]
+  });
+  if (!result.ok) {
+    throw new Error(`docker compose ${args.join(" ")} failed`);
+  }
+}
+
+async function fetchStatus(url) {
+  return new Promise((resolve) => {
+    const req = http.get(url, { timeout: 4000 }, (res) => {
+      res.resume();
+      res.on("end", () => resolve({ url, ok: res.statusCode >= 200 && res.statusCode < 500, status: res.statusCode }));
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      resolve({ url, ok: false, status: "timeout" });
+    });
+    req.on("error", () => resolve({ url, ok: false, status: "down" }));
+  });
+}
+
+function printPlan(plan) {
+  console.log(`Profile: ${plan.profileLabel}`);
+  console.log(`Default model: ${plan.defaultModel}`);
+  console.log(`Routes: ${plan.routeIds.join(", ")}`);
+  console.log(`Context: default ${plan.estimates.defaultContextTokens}, max ${plan.estimates.maxContextTokens}`);
+  console.log(`TPS estimate: default ${plan.estimates.defaultTpsEstimate}; best ${plan.estimates.bestTpsEstimate}`);
+  if (plan.manualAssets.length) {
+    console.log("\nManual or external assets:");
+    for (const asset of plan.manualAssets) {
+      console.log(`  ${asset.id}: ${asset.reason}`);
+    }
+  }
+  if (plan.warnings.length) {
+    console.log("\nWarnings:");
+    for (const warning of plan.warnings) {
+      console.log(`  ${warning}`);
+    }
+  }
+}
+
+async function commandDetect(flags) {
+  const detection = await detectMachine();
+  if (flags.json) {
+    printJson(detection);
+    return;
+  }
+  console.log(`Host: ${detection.hostname} (${detection.platform}/${detection.arch})`);
+  console.log(`CPU: ${detection.cpu.cores} cores, ${detection.cpu.model}`);
+  console.log(`RAM: ${detection.memory.totalGb} GB total, ${detection.memory.freeGb} GB free`);
+  const bestDisk = detection.disks[0];
+  console.log(`Disk: ${bestDisk ? `${bestDisk.freeGb.toFixed(1)} GB free at ${bestDisk.mount}` : "not detected"}`);
+  if (detection.gpus.length) {
+    for (const gpu of detection.gpus) {
+      console.log(`GPU ${gpu.index}: ${gpu.name}, ${gpu.totalVramGb} GB VRAM, ${gpu.freeVramGb} GB free`);
+    }
+  } else {
+    console.log("GPU: no NVIDIA GPU detected");
+  }
+  const missing = Object.entries(detection.tools).filter(([, present]) => !present).map(([tool]) => tool);
+  console.log(`Tools: ${missing.length ? `missing ${missing.join(", ")}` : "all required tools present"}`);
+}
+
+async function commandPlan(flags) {
+  const detection = await detectMachine({ skipPorts: Boolean(flags.no_ports) });
+  const plan = buildPlan(detection, profileFrom(flags));
+  if (flags.json) {
+    printJson(plan);
+    return;
+  }
+  printPlan(plan);
+}
+
+async function commandInstall(flags) {
+  const home = flags.home;
+  const detection = await detectMachine();
+  const plan = buildPlan(detection, profileFrom(flags));
+  if (flags.dry_run) {
+    printPlan(plan);
+    console.log("\nDry run only. No files written.");
+    return;
+  }
+  const paths = renderInstall(plan, detection, { home });
+  console.log(`Wrote ${paths.envFile}`);
+  console.log(`Wrote ${paths.generatedCompose}`);
+  console.log(`Wrote ${paths.modelPlan}`);
+  console.log("\nNext:");
+  console.log(`  preppergpt start --home ${shellQuote(paths.root)}`);
+  console.log("  Open http://127.0.0.1:8080");
+}
+
+async function commandSwitchProfile(flags) {
+  const paths = runtimePaths(flags.home);
+  const detection = await detectMachine();
+  const plan = buildPlan(detection, profileFrom(flags));
+  renderInstall(plan, detection, { home: paths.root });
+  console.log(`Switched PrepperGPT to ${plan.profile}.`);
+}
+
+async function commandStart(flags) {
+  const paths = runtimePaths(flags.home);
+  if (!fs.existsSync(paths.envFile) || !fs.existsSync(paths.generatedCompose)) {
+    throw new Error(`PrepperGPT is not installed at ${paths.root}. Run preppergpt install first.`);
+  }
+  runCompose(paths, ["up", "-d"]);
+  console.log("PrepperGPT start requested.");
+  console.log("Open http://127.0.0.1:8080");
+}
+
+async function commandStop(flags) {
+  const paths = runtimePaths(flags.home);
+  runCompose(paths, ["stop"]);
+}
+
+async function commandStatus(flags) {
+  const paths = runtimePaths(flags.home);
+  const checks = await Promise.all([
+    fetchStatus("http://127.0.0.1:8080/health"),
+    fetchStatus("http://127.0.0.1:11434/api/tags"),
+    fetchStatus("http://127.0.0.1:18041/health"),
+    fetchStatus("http://127.0.0.1:18042/health"),
+    fetchStatus("http://127.0.0.1:18043/health"),
+    fetchStatus("http://127.0.0.1:18044/health"),
+    fetchStatus("http://127.0.0.1:18080/search?q=test&format=json")
+  ]);
+  let plan = null;
+  if (fs.existsSync(paths.modelPlan)) {
+    plan = readJson(paths.modelPlan);
+  }
+  const status = { home: paths.root, url: "http://127.0.0.1:8080", plan, checks };
+  if (flags.json) {
+    printJson(status);
+    return;
+  }
+  console.log(`PrepperGPT home: ${paths.root}`);
+  console.log(`OpenWebUI URL: ${status.url}`);
+  if (plan) {
+    console.log(`Profile: ${plan.profile}`);
+    console.log(`Default model: ${plan.defaultModel}`);
+    console.log(`Context limit estimate: ${plan.estimates.maxContextTokens}`);
+    console.log(`TPS estimate: ${plan.estimates.bestTpsEstimate}`);
+  }
+  for (const check of checks) {
+    console.log(`${check.ok ? "up  " : "down"} ${check.url} (${check.status})`);
+  }
+}
+
+async function commandDoctor(flags) {
+  const detection = await detectMachine();
+  const plan = buildPlan(detection, profileFrom(flags));
+  printPlan(plan);
+  console.log("\nDoctor:");
+  const requiredTools = ["docker", "dockerCompose", "curl", "python3"];
+  for (const tool of requiredTools) {
+    console.log(`  ${tool}: ${detection.tools[tool] ? "ok" : "missing"}`);
+  }
+  for (const [port, entry] of Object.entries(detection.ports)) {
+    if (!entry.free) {
+      console.log(`  port ${port}: occupied`);
+    }
+  }
+}
+
+export async function runCli(argv) {
+  const { flags, positional } = parseArgs(argv);
+  const command = positional[0] || (flags.help ? "help" : "");
+  if (!command || command === "help" || flags.help) {
+    console.log(usage());
+    return;
+  }
+  if (command === "version" || command === "--version") {
+    console.log(VERSION);
+    return;
+  }
+  if (command === "detect") return commandDetect(flags);
+  if (command === "plan") return commandPlan(flags);
+  if (command === "install") return commandInstall(flags);
+  if (command === "start") return commandStart(flags);
+  if (command === "stop") return commandStop(flags);
+  if (command === "status") return commandStatus(flags);
+  if (command === "doctor") return commandDoctor(flags);
+  if (command === "switch-profile") return commandSwitchProfile(flags);
+  throw new Error(`Unknown command: ${command}\n\n${usage()}`);
+}

package/installer/install.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if ! command -v node >/dev/null 2>&1; then
+  printf 'PrepperGPT requires Node.js 20 or newer.\n' >&2
+  exit 1
+fi
+
+if [[ -x "$(dirname "${BASH_SOURCE[0]}")/../bin/preppergpt.js" ]]; then
+  exec node "$(dirname "${BASH_SOURCE[0]}")/../bin/preppergpt.js" install "$@"
+fi
+
+if ! command -v npx >/dev/null 2>&1; then
+  printf 'PrepperGPT requires npx or a cloned preppergpt checkout.\n' >&2
+  exit 1
+fi
+
+exec npx preppergpt install "$@"