I maintain DreamWeaver_AI, a Python repository on my GitHub. Its README presents it as a full-stack creative toolkit for generating stories, images, and playable mini-games from prompts, with a web UI and FastAPI backend. The README documents capabilities and setup, but does not report measured generation quality, latency, or other performance results.
My DreamWeaver_AI repository is Python, 2 stars, started 2025-07, and last updated 2025-07.
DreamWeaver_AI documents Story generation from a user prompt; text-to-speech conversion of generated stories.
DreamWeaver_AI documents playable mini-games generated from a prompt in a selected language, with Python and JavaScript examples.
I use Replicate's API for image generation from text prompts.
My DreamWeaver_AI frontend stack is HTML, TailwindCSS, JavaScript, with a responsive UI powered by vanilla JavaScript.
My DreamWeaver_AI backend stack is Python, FastAPI, async tools, Replicate API, TTS, environment variable support.
My DreamWeaver_AI README says Dockerfiles provided for backend.
The DreamWeaver_AI Game tab returns mini-game source code with 1-click copy.
I license DreamWeaver_AI under MIT.
git clone https://github.com/avi2614/DreamWeaver_AI.git
cd DreamWeaver_AI
cd backend
docker build -t dreamweaver-backend .
docker run -p 8000:8000 --env-file .env dreamweaver-backend
cd backend
pip install -r requirements.txt
uvicorn app.main:app --host <redacted> --port 8000
My documented frontend setup is to open frontend/index.html in a browser and ensure the backend is accessible at http://localhost:8000.
REPLICATE_API_TOKEN=your_replicate_token
# Optionally, set REPLICATE_MODEL and REPLICATE_VERSION
- My documented file structure assigns
backend/app/main.pyas the FastAPI entrypoint,backend/app/agents.pyto AI agent prompt handling,backend/app/tools/to image generation and TTS tools,backend/Dockerfileto backend container setup,frontend/index.htmlas the main UI,frontend/scripts/main.jsto UI logic and backend API calls, andfrontend/styles.cssto styling.
The DreamWeaver_AI README credits Replicate for the image generation API, FastAPI for the backend, and TailwindCSS for frontend styling.
The README has an Author heading but supplies no author details. It does not identify the TTS service, default Replicate model or version, or the redacted Uvicorn host; it gives Python and JavaScript as examples of game languages without specifying the full supported set.
My portfolio presents me as a DevOps Engineer and Full Stack Developer. I describe my work as building scalable systems, automating infrastructure, and creating full-stack applications, bridging development and operations.
My portfolio lists my email as avisharma2614@gmail.com and my location as Jaipur, Rajasthan; the phone number is shown as <redacted>.
I am pursuing a B.Tech at Poornima College of Engineering; my portfolio lists the period as Poornima College of Engineering, 2022 - 2026.
My portfolio lists my completed 12th Grade education as Gyan Ashram, 2021 - 2022, in Jaipur, in the Science stream with Mathematics and Computer Science.
My portfolio lists my completed 10th Grade education as St. Xavier's School, 2019 - 2020, in Jaipur, with a foundation in Science and Mathematics.
My portfolio describes my LinuxWorld Informatics Pvt. Ltd. DevOps internship as Ongoing (2025), remote, involving DevOps practices, cloud infrastructure automation, and CI/CD pipeline optimization.
My LinuxWorld internship achievements are listed as Implemented automated deployment pipelines; Optimized cloud infrastructure costs; Enhanced monitoring and logging systems.
I completed a Full Stack Developer internship at Cynbit Technologies in July - Aug 2024 in Jaipur, developing web applications and contributing to client projects.
My Cynbit internship achievement included improving application performance by 30%.
I completed a Software Development internship at Devyut Technology Pvt. Ltd. in June - July 2023 in Jaipur, working on development projects and learning about the software development lifecycle.
My Devyut internship included Collaborated in agile development environment.
My portfolio presents four projects: Smart Code Explainer, Multi Utility App, DevOps Project, and File Manager. It describes Smart Code Explainer as an AI-based code analysis and explanation tool; Multi Utility App as a productivity and development utility application; DevOps Project as an ongoing demonstration of CI/CD, containerization, and cloud deployment; and File Manager as a system for organizing and managing files.
My listed technology areas include JavaScript, Python, Java, React, HTML5, CSS3, Tailwind CSS, Framer Motion, Node.js, Express.js, MongoDB, Docker, Jenkins, Git, GitHub, GitHub Actions, Linux, and AWS.
The technology category counts displayed in my portfolio are 3+ Languages; 5+ Frontend Tools; 3+ Backend Tools; 5+ DevOps Tools; 2+ Infrastructure.
My portfolio terminal displays the prompt avi@portfolio:~ and lists these quick commands: help; sudo hire avi; avi --journey; avi --projects; joke; matrix.
My portfolio invites people to contact me about opportunities, projects, or technology and development. It includes email and location details, while the phone number is redacted. The portfolio presents these profile details and work claims but does not independently verify them.
I started my Smart-Code-Explainer repository in 2025-06.
My Portfolio repository’s README contains only the title “Portfolio.”
I have a Python repository on GitHub called ai_text_summarizer-DevOps-Project-. Its README presents it as an educational demonstration of an AI-powered summarizer packaged as a Flask app, containerized with Docker, and automated with Jenkins CI/CD. The README documents setup and pipeline behavior, but reports no test, build, deployment, or summarization-quality results.
I built the summarizer with Python and Hugging Face Transformers to turn large blocks of text into concise summaries.
git clone https://github.com/avi2614/ai_text_summarizer-DevOps-Project-.git
cd ai_text_summarizer-DevOps-Project-
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
My summarizer uses the Hugging Face Transformers model sshleifer/distilbart-cnn-12-6 to turn large blocks of text into concise summaries.
I package the summarizer as a Flask web app with a simple form where users paste text and receive an instant summary.
My project includes Pytest-based tests for model functionality; the README does not report test results.
My Jenkins pipeline is described as cloning the repository, building a Docker image, running Pytest, pushing the image to Docker Hub on the main branch, and deploying the container.
To configure the documented Jenkins pipeline, I need to set up Docker Hub credentials and update the DOCKERHUB_USER environment variable.
The README lists Docker, Python 3.9+, and optionally Jenkins for CI/CD as prerequisites.
docker build -t flask-summarizer .
docker run -d --name summarizer -p 5000:5000 flask-summarizer
The README says I can open the Dockerized app at http://localhost:5000.
- The README maps the project files this way:
app.pyis the main Flask application;templates/index.htmlis the web UI template;Dockerfilecontains Docker build instructions;Jenkinsfiledefines the CI/CD pipeline; andtests/contains unit tests.
My README characterizes the project as being for educational and demonstration purposes, without naming a specific license.
MenuBase’s README says the repository started in 2025-08.
The README’s direct local-opening method is to double-click index.html.
The README’s Netlify drag-and-drop method is to upload the entire folder.
For Netlify Git integration, the README says to connect the GitHub repository to Netlify.
The README describes model training as providing real-time progress visualization.
MenuBase is my HTML repository on GitHub, presented in its README as “Multiple Things On Single Platform.” The README describes a broad browser-based demonstration app for automation, AI, cloud management, and development. It emphasizes that the project is built with vanilla web technologies for compatibility and easy deployment; some integrations are simulations rather than real backend operations.
MenuBase’s README describes it as “A comprehensive, fully functional web application that provides tools for automation, AI, cloud management, and development tasks.”
The README says MenuBase is “Built with vanilla HTML/CSS/JavaScript for maximum compatibility and easy deployment.”
The repository’s README lists the MIT License.
The README credits Hardik Gothwal as MenuBase’s builder.
MenuBase’s README documents a load time of “< 1 second (single HTML file).”
The README claims the total bundle size is “< 500KB total.”
MenuBase’s local-server instructions use port 8000 and direct the reader to http://localhost:8000.
python -m http.server 8000
npx serve .
php -S localhost:8000
The README recommends Netlify and says that “Every push to main branch triggers deployment.”
- The README’s dashboard features include interactive feature cards, quick-access navigation chips, responsive design, and a dark/light mode toggle with persistent storage.
- The README documents Python-development demonstrations for simulated WhatsApp message sending, an email composition and sending interface, Python code generation from descriptions, and toast feedback.
- The README lists browser tools for real camera capture and photo download, GPS coordinates with Google Maps integration, text-to-speech with multiple voice options, a calculator, and file downloads.
- The README describes machine-learning demonstrations for CSV upload and preview, simulated model training with progress bars, JSON-input predictions, and canvas-based scatter, line, and bar charts.
- MenuBase’s prompt-engineering tools offer GPT-4, GPT-3.5, Claude, and Gemini selection, a creativity-temperature slider, prompt templates, simulated responses, and prompt optimization.
- The README lists Linux-management demonstrations for a simulated SSH connection, an interactive terminal with command history, speech-recognition commands, system monitoring, and arrow-key navigation through command history.
- The Docker interface documents container creation, running, and stopping; a running-container table; Docker Compose deployment; image listing; and port mapping.
- The AWS interface documents EC2 launch and termination, RDS, DynamoDB, and Aurora database creation, instance-type selection, cost estimates, and generated database connection strings.
- The Kubernetes interface documents cluster creation and deletion, application deployment with replicas, node and pod monitoring, scaling, and support for EKS, GKE, AKS, and Minikube.
- The README describes agentic-AI tools for creating specialized agents, assigning and managing tasks, monitoring agent performance, and choosing agent types such as Data Analyst, Code Reviewer, and Content Writer.
- The file-management interface documents drag-and-drop upload with progress, search and type filters, a file table with download and delete actions, storage analytics, and support for images, documents, videos, and archives.
- The Windows-management interface documents system-information scanning, an interactive PowerShell terminal, service management, performance monitoring, and security scanning.
- The README lists Material Design Icons, CSS Grid and Flexbox, Local Storage, MediaDevices, Geolocation, SpeechSynthesis, File, and Canvas APIs among MenuBase’s frontend technologies and browser APIs.
- The README lists a Netlify-configured Content Security Policy, input validation, safe calculator evaluation, and file-type restrictions for uploads as security features.
- The README lists GitHub Pages, Vercel, Firebase Hosting, and any web server as alternatives to its recommended Netlify deployment.
- The README lists Chrome, Firefox, Safari, and Edge as fully supported, and says the responsive design works on mobile browsers.
- The README says I can customize MenuBase by adding pages to
pageContent, editing CSS in the<style>section, extending JavaScript functions, and changing themes and styling. - The README notes that camera access requires HTTPS or localhost, location services require user permission, speech recognition works only in modern browsers, and uploads are subject to browser storage limits.
- The README claims minimal memory usage and says network requests are limited to external fonts and icons.
- The README’s contribution workflow is to fork the repository, create a feature branch, make changes, test thoroughly, and submit a pull request.
The README distinguishes browser-functional demonstrations from integrations that need real services. It says operations such as SSH connections and AWS API calls are simulated, and that production use would require backend services and APIs. It does not identify every feature’s integration status or provide a performance-test methodology for its load-time, memory, or bundle-size claims.
I organize GitHub Repo Explorer as a client/server monorepo. These notes describe its project structure and planned improvements; they do not establish that the planned work has been completed.
My root-level server.ts is described as the fullstack development runtime layer on Port 3000.
My Express backend package is organized under server/.
My React client single-page application is organized under client/.
My RepoList.tsx component is described as a grid containing repository entries and loaders.
I plan to upgrade the in-memory Map layer to a distributed Redis store to persist cached user metrics across multiple scaling cluster configurations.
I plan to introduce OAuth2.0 GitHub authorizations to automatically scale rate-limit sizes dynamically per-user.
I plan to add Playwright workflows validating client expansion transitions, dark theme loading, and search histories.
I plan to build Progressive Web App (PWA) manifests and service-worker cache adapters for offline support.
Assistant AI systems helped me scaffold code skeletons and structural folder boundaries quickly.
I wrote professional refactoring, custom backend server-side cache intercepts, and complete python integrations by hand to verify runtime execution boundaries and formatting criteria.
The profile sample request is GET http://localhost:4000/api/users/torvalds.
The torvalds profile sample's avatar URL is https://avatars.githubusercontent.com/u/1024222?v=4.
The torvalds profile sample bio is “The creator of Linux kernel and Git.”
The torvalds profile sample lists https://linuxfoundation.org as the blog URL.
The torvalds profile sample's GitHub URL is https://github.com/torvalds.
The torvalds profile sample account creation time is 2011-09-03T15:26:59Z.
The repository-list sample request is GET http://localhost:4000/api/users/torvalds/repos?page=1&per_page=30&sort=stars.
The torvalds/subsurface-tracker sample describes the repository as “Subsurface divelog tracker written in Qt/C++”.
The torvalds/subsurface-tracker sample lists its update time as 2026-05-20T18:40:02Z.
The torvalds/subsurface-tracker sample's GitHub URL is https://github.com/torvalds/subsurface-tracker.
The torvalds/subsurface-tracker sample lists the topics divelog, qt, and c-plus-plus.
The torvalds/subsurface-tracker sample lists its license as GPL-2.0.
The torvalds/subsurface-tracker sample lists https://subsurface-divelog.org as its homepage.
The profile route behavior is: GET /api/users/:username returns a filtered GitHub user profile, has no query parameters, and includes an x-cache response header indicating HIT or MISS.
The repository-list route behavior is: GET /api/users/:username/repos fetches user public repositories, paginated and sorted server-side; page defaults to 1, per_page to 30, and sort defaults to stars with stars, name, and updated choices.
The repository-list response fields are repos, page, per_page, and hasMore.
The extended-statistics route behavior is: GET /api/repos/:owner/:repo fetches full extended statistics for lazy-expand cards.
The text-analysis route method is: POST /api/analyze-text executes a local python tokenizer analyzer on user text content and takes a text field in the request body.
The health route purpose is: GET /api/health echoes backend status and cache metrics.
The profile sample shows that torvalds is Linus Torvalds, with 198000 followers, 0 following, and 6 public repositories.
The profile sample not-found response is {"error": "User or repository not found on GitHub."}.
The repository sample shows that torvalds/subsurface-tracker has 4831 stars, 1259 forks, and 52 open issues.
The repository sample pagination is page 1, per_page 30, and hasMore false.
The extended-statistics example requests GET http://localhost:4000/api/repos/torvalds/subsurface-tracker.
The text-analysis sample result is mode text_snippet, 30 characters, 5 words, 2 lines, and 8 estimated tokens.
The health sample response is status ok, uptime 23.51, and cacheSize 4.
The documented API has five routes, all under /api, with examples using http://localhost:4000. The documentation does not provide a response example or detailed schema for the extended-statistics route, does not specify error behavior for the repository-list, extended-statistics, text-analysis, or health routes, and does not explain how repository sorting or hasMore is computed beyond saying pagination and sorting are server-side.
I have a repository called befikrr on my GitHub. Its README presents it as a fashion app, but it documents the project rather than confirming which capabilities are implemented or live.
My befikrr repository is TypeScript, 2 stars; started 2025-07, last updated 2025-07.
The README positions the app as “बेfikrr - Wear Your Vibe” and describes it as: “A modern fashion app with AI-powered styling, virtual try-ons, and custom designs that define your unique style.”
- The README describes these product features: - AI-Powered Styling: Get personalized style recommendations; - Virtual Try-On: See how clothes look on you with AR technology; - Design Studio: Create custom designs with our 3D preview tool; - Voice Shopping: Shop hands-free with voice commands; - Responsive Design: Optimized for both desktop and mobile devices; - Modern UI/UX: Beautiful, intuitive interface with smooth animations.
- The README’s documented stack is: Frontend: React 18 + TypeScript; Styling: Tailwind CSS; Icons: Lucide React; Routing: React Router DOM; Build Tool: Vite; Deployment: Netlify.
The README lists responsive breakpoints as Mobile devices (320px+), Tablets (768px+), Desktop (1024px+), and Large screens (1280px+): 320px+, 768px+, 1024px+, 1280px+.
The documented prerequisites are Node.js 18.0.0 or higher and npm 8.0.0 or higher: Node.js 18.0.0 or higher; npm 8.0.0 or higher.
The README’s local setup instructions include npm run dev and say to open http://localhost:3000. The documented local development URL is http://localhost:3000.
My README’s clone command uses the placeholder git clone <repository-url>.
- The README lists these available scripts:
npm run dev- Start development server;npm run build- Build for production;npm run preview- Preview production build;npm run lint- Run ESLint;npm run type-check- Run TypeScript type checking;npm run format- Format code with Prettier. The script names are npm run dev; npm run build; npm run preview; npm run lint; npm run type-check; npm run format.
The documented Netlify settings are Build command: npm run build; Publish directory: dist; Node version: 18. The settings are Build command: npm run build; publish directory: dist; Node version: 18.
The README says: “Add any required environment variables in Netlify dashboard.” It does not name specific variables; the documented note is Add any required environment variables in Netlify dashboard.
The documented Netlify workflow says: “Netlify will automatically detect the build settings.” For manual deployment, the README says to upload the dist folder to a hosting provider. The workflows are: Netlify will automatically detect the build settings; Upload the dist folder to your hosting provider.
My README’s Netlify deployment instructions say to push the code to GitHub or GitLab and connect the repository to Netlify.
My README says to configure a custom domain in Netlify settings.
The documented source layout includes Header.tsx, Footer.tsx, NewsletterPopup.tsx, the pages Home.tsx, Shop.tsx, TryOn.tsx, Design.tsx, Account.tsx, and Track.tsx, plus App.tsx, main.tsx, and index.css. The layout is Layout Header.tsx and Footer.tsx; NewsletterPopup.tsx; pages Home.tsx, Shop.tsx, TryOn.tsx, Design.tsx, Account.tsx, Track.tsx; App.tsx, main.tsx, index.css.
The README documents the design colors #1c5681 (blue) and #f5f0e6 (light cream), gray shades, Poppins for headings, and Inter for body text. The two specified colors are #1c5681 and #f5f0e6.
The README describes the UI components as Primary and secondary button styles, consistent card design with hover effects, and styled input fields with focus states: Primary and secondary button styles; cards with hover effects; styled inputs with focus states.
The README lists vite.config.ts, tailwind.config.js, netlify.toml, and tsconfig.json as configuration files: vite.config.ts; tailwind.config.js; netlify.toml; tsconfig.json.
The README claims automatic chunk splitting, optimized images, preloaded Google Fonts, cache headers for static assets, and bundle analysis with npm run analyze: Automatic chunk splitting; optimized images; preloaded Google Fonts; cache headers for static assets; npm run analyze for bundle analysis.
The README’s security claims are Content Security Policy configured in Netlify headers; XSS protection enabled in response headers; HTTPS enforced on Netlify deployment.
The project is licensed under the MIT License.
The README lists support as hello@befikrr.com or an issue in the repository: hello@befikrr.com or create an issue in the repository.
My befikrr README’s closing tagline is “Where fashion meets technology. Wear Your Vibe!”
The documented contribution workflow is: Fork the repository; Create a feature branch; Make your changes; Run tests and linting; Submit a pull request.
My GitHub profile is for @avi2614. I use it to showcase projects aligned with my interest in problem-solving, scalable systems, infrastructure automation, and full-stack applications.
My GitHub profile lists my location as Jaipur,Rajasthan.
I have been on GitHub since 2021.
My profile describes me this way: “I'm a problem-solving enthusiast who builds scalable systems, automates infrastructure, and creates powerful full-stack apps.”
My GitHub-Repo-Explorer repository is TypeScript; 2 stars; last updated 2026-06; web application for searching, browsing, and analyzing GitHub repositories and details, contributors, stars, forks, and project insights.
I built GitHub Repo Explorer to simplify repository discovery and provide an organized interface for exploring open-source projects efficiently.
My README says Vite provides instant asset bundling and lightning-fast development reloading.
My frontend uses Tailwind CSS v4, described as embedding utility-first styles that compile directly to native stylesheets.
I use Axios to communicate request bodies directly to the official GitHub API.
My backend uses Helmet, which the README says disables header sniff vectors and secures browser transactions.
My backend uses Morgan for development request logging.
I started GitHub Repo Explorer in 2026-06.
My GitHub Repo Explorer README describes it as a responsive full-stack monorepo for searching GitHub developer usernames and exploring profile details, repository breakdowns, and primary programming language splits.
I built the frontend with React 19, TypeScript, Vite, Tailwind CSS v4, React Query (@tanstack/react-query), Recharts, and Motion/React.
My backend stack is Node.js, Express, TypeScript, Axios, Helmet, Morgan, an in-memory Map cache with TTL, and an inline Python token-limit engine.
I use an Express server-side proxy to keep secret access keys and internal stack-trace logs out of client browsers.
My in-memory cache stores endpoints and lazily evicts entries after 60 seconds to minimize direct GitHub API hits.
I use React Query for asynchronous server fetches, auto-caching, retry buffers, and visual loader skeleton states.
My README describes loading skeletons, reactive page-state appends, debounced incremental lookups, and a Python analysis pipeline for system-resource context-fit tokenization as part of the application's performance and API-rate-limit approach.
My inline Python token-limit engine analyzes code structures, calculates file sizes, and maps LLM fit thresholds for Gemini and GPT models.
My documented local-development prerequisites are Node.js 20+ and Python 3.
git clone https://github.com/avisharma2614/github-repo-explorer.git
cd github-repo-explorer
npm install
cp server/.env.example server/.env
PORT=4000
GITHUB_TOKEN=your_github_personal_access_token_here
NODE_ENV=development
npm run dev:local
npm run build
npm run start
My README says the frontend and Express server run locally at localhost:5173 and localhost:4000, respectively, and that Vite coordinates request proxy overrides during local development.
I use Recharts to build customizable SVG donut layouts displaying language counts, and Motion/React for page-slide entry effects and collapsible card drawers.
My README presents the Vercel frontend at https://github-repo-explorer-client.vercel.app and the Render backend at https://github-repo-explorer-server.onrender.com, and labels both links as placeholders.
My README says a GitHub Personal Access Token is optional and can help avoid public rate-limiting.
My MenuBase repository is HTML; 2 stars; last updated 2025-08.
My befikrr7 repository is TypeScript; 2 stars; last updated 2025-07.
My DreamWeaver_AI repository is Python; 2 stars; last updated 2025-07.
My ai_text_summarizer-DevOps-Project- repository is Python; 2 stars; last updated 2025-07.
My Portfolio repository is TypeScript; 2 stars; last updated 2025-07.
My MultiUtilityApp repository is HTML; 2 stars; last updated 2025-06.
My README lists HTML, JavaScript, and CSS as the technologies used to build MultiUtilityApp.
I describe the app’s glassmorphic interface as inspired by cold, digital glaciers.
My README names Orbitron and Comfortaa as the app’s fonts.
My README lists ipinfo.io for IP and geolocation lookup and Google Maps for local search.
I instruct users to open the app, grant camera or location permissions if needed, and then use its utilities.
My README says users can open MultiUtilityApp directly in a browser.
I document the SMS and calling workflow as entering a phone number, with backend endpoints required.
My README says users can ask anything in the AI chat box and get instant replies.
My TODO list includes a Node/Express example for the Twilio backend endpoints.
My README’s closing tagline is “Stay Cool. Stay Productive. — Cold Breeze”.
My MultiUtilityApp README presents it as “Neo Utility Web App – Cold Breeze,” an all-in-one PWA utility app for everyday needs.
I describe the app as combining camera and photo capture, Gmail email, WhatsApp messaging, Twilio SMS and calls, IP lookup and geolocation, nearby grocery search, video recording, Gemini chat, theme switching, and social sharing.
My README describes the app’s interface as glassmorphic, with neon-blue glows and soft gradients, and says it is responsive on mobile and desktop.
I document Twilio SMS and calling as requiring backend endpoints, specifically /api/send-sms and /api/make-call.
My README describes the Gemini API chat assistant as “demo mode” and lists real Gemini API integration as a TODO.
I document the photo-email workflow as downloading the photo and then attaching it in Gmail.
My README says a manifest is included for installability, a service worker provides offline support, and push notifications are ready.
I credit Avi Sharma for UI/UX and development of MultiUtilityApp.
My README lists the MIT License and says the app is free for personal and commercial use.
My file_manager repository is Python; 2 stars; last updated 2025-06.
My Smart-Code-Explainer repository is Python; 2 stars; last updated 2025-06.
My devkripahealthcare-website repository is TypeScript; last updated 2026-10; website for Devkripa Healthcare — dental, skin & hair clinic in Jhotwara, Jaipur.
The language totals listed for my repositories are TypeScript (5), Python (4), HTML (2).