Bare bones prompt

I am going to start with https://github.com/kliewerdaniel/mcbot01.git and I want to rebuild it and I want to make it more bare bones, but with the same trippy background, write a cline prompt to instruct the coding agent to do so

Here’s a sample **command-line prompt** you could give to a code-generation / coding assistant (or even yourself) — instructing it to take entity["software","mcbot01",0] (from https://github.com/kliewerdaniel/mcbot01.git) and produce a “bare-bones” version that preserves only the “trippy background” UI but strips out most functionality. You can feed this to an AI code assistant (or run interactively) to get a scaffolded simplified version. ``` You are given the repository mcbot01 (https://github.com/kliewerdaniel/mcbot01.git). Your task is to create a new, minimal version of this project (“mcbot01-lite”) with the following constraints and goals: 1. **Keep only the user interface and the “trippy background” visuals** - Retain the CSS / frontend code responsible for the background visuals / animations / “trippy background.” - Retain only the minimal frontend scaffold to render that background (e.g. index.html / main React/JSX + CSS). - Remove all backend logic, AI/ML code, database integration, data processing, graph database, LLM logic, deployments, Docker configs, etc. 2. **Strip out all functionality unrelated to UI / visuals** - Remove backend folders (Python, FastAPI, database, scripts). - Remove any dependencies on AI, Neo4j, Redis, LLM support. - Remove anything related to document upload / processing / graph construction / chat / context / MCP protocol. - Remove Docker and deployment files (Dockerfile, docker-compose files, nginx.conf). - Remove tests not related to frontend UI. 3. **Build a minimal standalone frontend project** - Use a simple stack: HTML + CSS + JS (or minimal React) — whatever preserves the background visual. - Include only what is needed to render the background. - Provide clear instructions (README) on how to run it locally (e.g. `npm install && npm start` or even a static HTML). 4. **Preserve licensing / attribution** - Maintain the original license header / MIT license (or add a new license if you rewrite significant parts). - In README, note that visuals are derived from mcbot01. 5. **Output structure for the new repo** - A root folder with minimal files: `index.html` (or `App.jsx`), `styles.css`, optionally `package.json` (if using JS/React), README, etc. - No unnecessary folders. 6. **Write a clear README** describing what the project is (just the “visual demo / background”), how to run, and what was stripped out. --- Please generate the full new project scaffold — i.e. list all files (with contents) required to run a static/web version of the trippy-background only. Also clearly mark in comments which parts (if any) were adapted from the original mcbot01 repo. ``` If you like — I can **auto–generate** a complete “lite scaffold” version for you now (just skeleton UI + background) — would you prefer it as a `.zip`-style tree (shown in text) or as a GitHub-style repo layout right here?

no try again

Cool — I’ll write a revised **command-line prompt** (for a coding agent, or AI assistant) that’s hopefully clearer/cleaner for your goal. If you like, you can feed this directly to a code-generation agent (or adapt for yourself). ``` You have cloned the repository from https://github.com/kliewerdaniel/mcbot01.git. Your goal: produce a new minimal version, “mcbot01-lite”, that preserves only the “trippy background” / UI visuals from the original, and removes *all* non-UI/visual functionality. Requirements: - Identify and extract the code (HTML, CSS, JavaScript, React, or whichever front-end) that implements the background visuals / animations / UI styling. - Create a minimal standalone project containing only what’s needed to render those visuals: e.g. index.html (or minimal React/JSX), style/CSS (or inline styles), minimal JS if needed. - Remove everything else: backend, server code, LLM/AI logic, data storage, database, API code, scripts for processing, tests, deployment configs (Docker, docker-compose, nginx, etc.). - The new project must run locally (static file or simple `npm start` for frontend) without dependencies on backend, AI, database, etc. - Maintain license / attribution (if original code uses MIT or other license) — at least credit the original repo in README or comments. - Provide a README describing: “what this is” (just UI/visual demo), “how to run it”, and note that functionality was stripped. Task: 1. Extract and copy the front-end code responsible for the background visuals. 2. Build a minimal project skeleton: root folder, minimal files (index.html / styles.css / (optional) app.js or React files), README, license or license notice. 3. Remove all other source and dependency files. 4. Ensure the resulting project only renders the background visual, no other features. Please output a **shell-style command-line prompt** (single string) that instructs a code-generation agent to perform this entire refactor. --- Example usage: ``` codex "You have cloned repository mcbot01. Transform it into a minimal static frontend project preserving only the trippy background visuals; remove all backend / AI / data / deployment code; produce project skeleton, README, and license attribution." ``` ``` ``` If you like — I can also generate a full example of the resulting minimal skeleton (file tree + content) right now, to show what “mcbot01-lite” could look like. ```

no, I want the app to still be a chatbot using all of the functionality of it, I just want it to be more simple

Good — thanks for clarifying. Now that your goal is to keep the chat-bot functionality of entity["software","mcbot01",0] *but* simplify/streamline it, here’s a refined **command-line prompt** you could give to a coding agent (or yourself) to drive that refactor. This instructs the agent to keep core chatbot functionality but clean up, simplify architecture, dependencies, and project structure. ``` You have cloned the repository at https://github.com/kliewerdaniel/mcbot01.git. Your goal: produce a simplified but functional version — call it “mcbot01-simple”. The resulting app should still work as a chatbot (backend + frontend, message exchange, etc.), but with a much cleaner, minimal, easy-to-understand codebase. Requirements: - Retain core chatbot functionality: receiving user input, generating / returning responses, maintaining context (if implemented), front-end chat UI + the “trippy background” visuals. - Remove modular complexity, unnecessary abstraction, and unneeded infrastructure. That means: * Remove complex deployment configs (Docker, docker-compose, etc.) unless absolutely essential. * Remove non-critical dependencies, heavy tooling, or libraries that are only for edge features (unless they are core for chat). * Flatten project structure: use a simple backend + frontend layout (for example: `backend/` for server code, `frontend/` for UI, or even single-directory if simple enough). * Ensure the build and run process is straightforward (e.g. `npm install && npm start` for frontend; `python app.py` or equivalent for backend), with minimal setup. - Keep the “trippy background” UI/visuals from the original (CSS / animations / background code) intact in the frontend, so the chat UI still has the same vibe. - Provide a clear README documenting: * What the app is (simplified chatbot with trippy background), * How to install and run (backend + frontend), * What was removed or simplified compared to original (big heavy dependencies, deployment configs, optional features) * Notes on license / attribution (keep original license, if any). Task: 1. Analyze the mcbot01 codebase and identify which files/modules are essential for chatbot core functionality vs which are optional or for extra features/infrastructure. 2. Extract and re-organize essential files into a clean, minimal project layout. 3. Remove or refactor away complexity as per above. 4. Ensure frontend UI (with trippy background) still works, and is connected to backend chat logic via a simple API or message-exchange mechanism. 5. Provide a new project scaffold (file-tree + minimal code) plus README to show the new simplified version. Run this as a single command to a coding-assistant agent like: ``` refactor_project --source mcbot01 --target mcbot01-simple --mode simplified-chatbot --preserve-ui-background ``` or as a natural-language prompt: ``` You have cloned mcbot01. Create mcbot01-simple: a minimal, clean chat-bot web application preserving background visuals, core chat functionality, but with simplified structure, minimal dependencies, and easy to run. Output the restructured project layout + README + instructions. ``` ``` --- If you want — I can **generate** a _draft_ of what that simplified version might look like: a minimal frontend+backend skeleton (with “trippy background” UI + simple chat backend) — as a tree + sample code + README. Do you want me to build that draft for you now?