686f6c61_

Most cookie consent solutions only show a banner and hope for the best. They don't actually prevent scripts from running before the user makes a choice. By the time a user clicks 'Reject All', Google Analytics has already tracked their visit, Meta Pixel has already fired, and their data is already on its way to servers around the world.

This library works differently. It intercepts script loading at the DOM level using MutationObserver, converting scripts into inert data-blocked elements until explicit consent is given. This is real compliance, not just a checkbox exercise.

Why this library exists: Privacy regulations like GDPR, CCPA, and LGPD require informed consent before collecting personal data. But implementing this correctly is surprisingly hard: scripts load before your React app renders, third-party scripts inject more scripts, different laws have different rules, and Google needs specific consent signals to work correctly.

Real script blocking: Unlike CSS-based blocking that just hides content, this library uses MutationObserver to intercept script tags as they're added to the DOM. Scripts are converted to inert elements until consent is granted, then restored to their original form.

Automatic geographic detection: The library detects your user's location and automatically applies the correct privacy law. A visitor from Germany gets GDPR rules (opt-in required), a visitor from California gets CCPA rules (opt-out allowed), and a visitor from a region without privacy laws can skip the banner entirely.

274 pre-configured services: Google Analytics, Meta Pixel, TikTok Pixel, Hotjar, Mixpanel, Amplitude, Segment, Microsoft Clarity and hundreds more. Each preset includes the correct script patterns, cookie names, and consent categories. Just import and use.

Advanced features: Google Consent Mode v2 built-in with automatic consent signal updates, cookie scanner that detects undeclared cookies for compliance auditing, audit logging with cryptographic verification of every consent action, 52 privacy laws supported including regional variations, age verification for COPPA and GDPR-K with checkbox, year-of-birth, or full birthdate methods, and consent sharing across subdomains.

Accessibility and customization: Full WCAG 2.2 AA with keyboard navigation, screen reader support, and focus management. 10 languages included (English, Spanish, German, French, Portuguese, Italian, Dutch, Polish, Japanese, Chinese). 8 banner variants: bottom bar, modal, floating, corner popup, sidebar and more. CSS variables for complete customization.

GitHub sorts repositories by last updated date. This means your most important projects can get buried when you make a small fix to an old repo or create a new experimental project. It happened to me constantly: my best projects would disappear from my profile every time I touched something old.

I built GitPins to fix this. The idea is simple: automatically update the "last updated" timestamp of your chosen repos, keeping them always at the top of your profile.

How it works: You connect with GitHub, install the GitPins GitHub App, drag and drop your repos in the order you want, and activate sync. GitPins creates a config repo with a GitHub Action that periodically "bumps" your repos to maintain the order.

The technical trick: I use empty commits to update the timestamp without touching your code. With the "revert" strategy (recommended), I make an empty commit and immediately revert it, keeping the history clean. With the "branch" strategy, I create a temporary branch, make the commit and merge. You can configure the frequency: every 1, 2, 4, 6, 8, 12 or 24 hours.

Security: GitPins only requests minimal permissions. It can create empty commits and read repo metadata, but it cannot read your source code, modify existing files or delete anything. Access tokens are encrypted with AES-256-GCM. All code is open source for full transparency.

Admin panel: Includes admin dashboard with user statistics, ban management and activity charts for the last 30 days.

Self-hosting: You can deploy it on your own infrastructure. You just need Node.js 18+, PostgreSQL (Neon has a perfect free tier for this) and create a GitHub App. You can also deploy to Vercel with one click.

In HR and talent management departments, defining technical roles with clear competencies per career level is a manual, inconsistent process that consumes weeks of work. Each company reinvents the wheel creating their own definitions without a reference standard.

I developed an NPM package published at @sparring/tech-roles-library that provides 702 ready-to-use technical role definitions. These are 78 distinct roles, each with 9 complete career levels, from Trainee to VP/CTO. Each definition includes core competencies, complementary competencies, and specific level indicators.

Coverage spans 7 tech sector categories: Software Engineering with 33 roles (Frontend, Backend, Full-Stack, Mobile, DevOps, QA, architects and more), AI/ML with 16 roles specialized in artificial intelligence and machine learning, Data with 15 data engineering and analytics roles, Product with 7 product management roles, Security with 4 cybersecurity roles, Infrastructure with 2 platform roles, and Sales with technical-commercial roles.

The 9 career levels follow an industry-standard progression: Trainee for profiles without experience, Junior I and Junior II for the first career years, Mid-level I and Mid-level II for profiles with consolidated experience, Senior I and Senior II for technical experts, Staff/Principal for reference technical leaders, and VP/CTO for executive technology leadership roles.

The API enables multiple operations: Get the complete career view of an employee showing mastered levels, current level, and growth path. Calculate accumulated competencies from career start to any level. Identify specific requirements for promotion to the next level. Determine the appropriate level based on years of experience. Search roles by name or category with relevance scoring.

The translation system is complete: 156 validated translation files, 78 in English and 78 in Spanish, with lazy loading to optimize performance. Spanish uses neutral terminology without regionalisms, valid for any Spanish-speaking market. Pre-publication validation guarantees 0% translation errors and 0% cross-language contamination.

Production quality: 99 tests with 100% pass rate including JSON integrity validation, bidirectional translation verification, structure consistency, and year ranges. Zero external runtime dependencies. Exports both CommonJS and ESM, with full TypeScript support and tree-shaking.

The React ecosystem has several options for persisting state to browser storage, but each comes with limitations that make form persistence more difficult than it should be.

The problem with existing solutions: react-hook-form-persist is tightly coupled to react-hook-form exclusively, if you use Formik, a custom form solution, or plain React state, you cannot use it. The package was last updated in 2021 and has known issues with default values overriding restored data. use-local-storage-state provides a solid useState replacement with localStorage sync, but it lacks form-specific features: no field exclusion for sensitive data, no debouncing to prevent excessive writes during typing, no expiration handling, no undo/redo, and no cross-tab synchronization. redux-persist and zustand persist require you to adopt a global state management library, for a simple contact form or checkout page adding Redux or Zustand just to persist form fields is unnecessary complexity, and they add significant bundle size (Redux ecosystem ~10KB).

What this library provides: Framework agnostic, works with any form approach: react-hook-form, Formik, plain controlled inputs, or any other solution. The API mirrors useState, so integration requires changing one import. Zero dependencies, the core bundle is under 2KB gzipped with no runtime dependencies beyond React. Form-aware features out of the box: debounced saves prevent excessive writes during typing, field exclusion keeps passwords and credit card numbers out of storage, data expiration automatically cleans up stale form data, schema versioning with migrations handles evolving form structures.

Built-in undo and redo: Users can navigate through their edit history, a feature that typically requires significant custom code. Cross-tab synchronization: when users have the same form open in multiple tabs, changes sync automatically using BroadcastChannel with a fallback to storage events for older browsers.

Production ready: Full TypeScript support with exported types. SSR compatible with Next.js, Remix, and other frameworks without hydration errors. Memory fallback when localStorage is unavailable. Testing utilities included. GDPR compliant by design: the enabled option lets you disable persistence until the user consents, the clearGroup utility implements right to erasure.

For a technology company specialising in the banking sector, the challenge was to develop an intelligent orchestrator capable of managing the massive volume of errors their client processes daily.

The implemented solution consists of a multi-agent architecture composed of:
• 6 specialised agents coordinated by 1 main orchestrator
• 4 analysis agents specialised in specific error types and Java/Cobol console files
• 1 validation agent that verifies data consistency, code lines, paths and structures
• 1 reporting agent that generates structured reports in multiple formats

Scalability and performance:
• Processing of 1400 files with 10 levels of nested depth
• Generation of actionable report in less than 5 minutes
• Time reduction: from up to a day's work per error to less than 5 minutes total

Technical requirements implemented:
• Integration with Google partnership using Gemini 2.5 Pro
• SaaS architecture for immediate deployment
• Authentication system with user management and access limits
• Parallel processing of multiple error files from ZIP

# AI AGENT ORCHESTRATOR FOR EUROPEAN REGULATIONS AND BOE

## WHAT IT IS
An intelligent platform that automates the extraction, validation and organization of legal references from study materials for competitive exams. The system processes documents, identifies all legislative references, validates them against official sources and generates structured documents ready for study.

## THE PROBLEM IT SOLVES
Competitive exam students spend 2-3 hours per topic manually searching for each legal article mentioned in their materials. This process includes:
• Identifying laws and articles in the text
• Searching each reference in BOE or EUR-Lex
• Finding the specific article
• Copying the full text
• Organizing everything in a study document

Additionally, there's risk of errors: laws with similar names, misidentified articles, ambiguous references or fragmented sources between national and European legislation.

## THE SOLUTION
The system reduces this process from hours to less than 1 minute through multi-agent artificial intelligence. The student simply drags their document and gets a complete report with all references extracted, validated and organized.

## HOW IT WORKS
### 4-LAYER ARCHITECTURE
1. WEB INTERFACE (REACT)
The student uploads their document via drag and drop, sees real-time progress, consults results in an interactive table and downloads generated documents in their preferred format.

2. REST API (FASTAPI)
Asynchronous backend that manages background processing. The system can handle multiple documents simultaneously without blocking the interface.

3. MULTI-AGENT SYSTEM (8 AI AGENTS)
The system core orchestrates 8 specialised agents working in 4 phases:

Phase 1 - Extraction: Three agents with different strategies analyze the document in parallel. One is conservative (only finds clear references), another is aggressive (searches for subtle mentions) and the third acts as a hound (implicit references).

Phase 2 - Resolution: Two specialised agents resolve ambiguities (context and titles), a normalizer standardizes the format, and two validators verify against BOE and EUR-Lex using cache to optimize speed.

Phase 3 - Convergence: The system iterates until no new references are found, ensuring maximum coverage. An auditor scores result quality and suggests improvements.

Phase 4 - Export: Generates three output formats (Markdown, TXT and Word) with clickable direct links to BOE and EUR-Lex.

4. EXTERNAL INTEGRATIONS
• BOE API: Validates Spanish legislation through the official State Gazette API
• EUR-Lex: Obtains European legislation using CELEX identifiers (Regulations, Directives, EU Decisions)
• Google Gemini 2.5 Pro: AI engine for intelligent reference extraction with approximate consumption of 65,000 tokens per document

### KEY OPTIMIZATIONS
• Parallel agent execution (2-3x superior speed)
• Cache system with 70% hit rate (fewer calls to external APIs)
• Early convergence (stops iterations when no new references)

## TECHNOLOGIES
Frontend: React 18 + Vite + modern CSS
Backend: Python + FastAPI + Uvicorn
AI: Google Gemini 2.5 Pro with configurable temperatures (0.1 to 0.4)
Extraction: BeautifulSoup4 for scraping
Validation: Official BOE API + EUR-Lex web scraping
Cache: Persistent LRU on disk

## RESULTS
Time reduction: From 2-3 hours to less than 1 minute (95% savings)
Precision: 85-95% correct extraction validated in real tests
Coverage: Supports Spanish (BOE) and European (EUR-Lex) legislation
Output: Documents with direct links to official legal texts

## REAL USE CASE
A competitive exam student has Topic 31 of their syllabus. The topic mentions dozens of laws, regulations and articles. Instead of spending the whole afternoon searching for each reference:

1. Drags the document to the platform
2. The system processes the document in 30-60 seconds
3. Receives a table with all found references
4. Downloads a Word document with full texts of each article
5. Each reference includes a direct link to BOE or EUR-Lex

Result: The student has their complete and validated study material in minutes, not hours.

In technical hiring processes, evaluating whether a candidate's code style fits the company's is subjective and time-consuming. Interviewers review repositories by eye without clear metrics, generating inconsistency and decisions based on superficial impressions.

I built a Python CLI that compares GitHub repositories through static analysis. You input the company repo and the candidate's repo, and it generates an empathy score based on 11 categories: descriptive names, documentation, modularity, cyclomatic complexity, error handling, tests, security, style consistency, design patterns, performance, and comments.

The system supports 12 languages: Python is analyzed with AST for maximum precision, the rest (JavaScript, TypeScript, Java, Go, C#, C++, PHP, Ruby, Swift, HTML, CSS) use optimized regex. It detects design patterns (Singleton, Factory, Observer) and anti-patterns (God Class, Spaghetti Code).

Usage modes: Interactive mode guides step by step with options menu and repo selection from a REPO.txt file. CLI mode allows CI/CD pipeline integration. Team mode compares multiple candidates against the company's master repo in a single run.

Result export: Generates reports in TXT, JSON, static HTML and interactive dashboard with Bootstrap 5. Also exports 5 PNG graphics: comparative radar, category bars, evolution lines, dual pie charts and intensity heatmap.

Real use cases: Automated candidate pre-screening before interviews, identification of training areas during onboarding, consistency audits in existing teams, and external consultant evaluation before assigning them to projects.

For developers working with multiple simultaneous services, the 'Address already in use' error is a constant workflow interruption. The traditional solution requires remembering complex terminal commands (lsof, netstat, kill) and performing multiple manual steps.

The implemented solution consists of a native desktop application with three complementary interfaces: a GTK4 graphical interface with libadwaita for complete visual management, a system tray indicator for quick access without opening the application, and a complete CLI for script integration and automation.

Main features: The system automatically detects development ports in ranges 3000-3999, 5000-5999, and 8000-8999. It humanizes processes by converting cryptic paths like /proc/self/exe into easy-to-understand descriptive names. It protects critical services such as PostgreSQL, MySQL, and Nginx by requiring mandatory confirmation before terminating them. It automatically updates every 5 seconds showing current port status, and allows both individual and bulk termination of development processes.

Modular architecture: The detection engine implemented in port_manager.py uses psutil for network connection reading. The GTK4 interface in main_window.py offers a reactive list with integrated confirmation dialogs. The system tray runs as an independent GTK3 process (tray_standalone.py) to avoid conflicts with GTK4. The CLI module (cli.py) provides list, kill, and info commands for integration with npm scripts and Makefiles.

Real use cases: Developers can add predev scripts in npm to automatically clean ports before starting the server. In projects with Makefiles, automatic targets can be created to free ports in multi-service projects. Through shell aliases, ultra-short commands like kp 3000 or kpd can be achieved for frequent use. The info PORT command allows identifying exactly which process occupies a specific port, facilitating conflict debugging.

At a company I faced the challenge of notifying employees every month if their corporate email accounts had been exposed in data breaches. People weren't following security policies and we needed to verify 800+ emails monthly. The manual process took days: entering Have I Been Pwned, typing each email, copying results to Excel and sending individual notifications.

I built a Python CLI that automates the entire process. It reads a CSV with emails, queries the Have I Been Pwned API, and generates an Excel report with risk analysis classified by criticality levels based on exposed data types (passwords, cards, banking data). The system sends two types of notifications: an executive summary to the system administrator and individual emails to each affected employee with their breach details.

For enterprise environments I added local cache that stores results for 24 hours to avoid querying the same email multiple times. Rate limiting adapts to the HIBP subscription tier (from 10 requests/minute on basic to 1000 on enterprise) with automatic retries if limits are reached. Excel reports include risk distribution charts and a table with all breaches: affected domain, incident date, number of compromised accounts and exposed data types.

I use it in several scenarios: a client has a cron job that runs on the 1st of each month at 3 AM verifying all corporate emails and sending the report to the CISO, going from 8 hours of manual work to zero intervention. Startups integrate it into onboarding to verify the candidate's personal email before the offer. When a major breach like Equifax happens it runs manually to identify affected people in minutes. The JSON output can be ingested into SIEM or ServiceNow to create automatic tickets.

The need to maintain an organized backup of all documents received by email is a common challenge in professional environments. Invoices, quotes, contracts and other important files arrive daily in email, but keeping them manually organized in Drive consumes valuable time and is prone to human errors. This project emerged to completely automate that process, freeing the user from the repetitive task of downloading and organizing files.

The system works completely autonomously through scheduled Google Apps Script triggers. Every hour, day or at the configured frequency, the script runs automatically without user intervention. It searches for emails in Gmail that have not yet been processed, extracts the sender's domain to determine origin, validates attachments according to configurable file type rules, and finally saves them in Google Drive following an intelligent hierarchical structure. Processed emails are marked with a specific label to avoid duplicates in future runs.

File organization implements a multi-layer folder strategy that greatly facilitates subsequent searches. First, a main folder is created in Drive called 'Attach GMAIL'. Within it, the system generates subfolders with the sender's domain name, for example 'company.com' or 'client.com'. For generic domains like Gmail or Outlook, the system can be configured to use the full username instead of the domain, avoiding mixing files from multiple personal contacts under the same generic folder. Within each domain folder, specific subfolders are created for each processed email combining the reception date with a summarized version of the subject, for example '2025-11-17 - Invoice November services'. This structure allows locating any file in seconds by navigating through sender, date and context.

The system implements advanced filtering through inclusion and exclusion lists for both domains and file types. You can specify exactly which senders you want to process and which file formats interest you, automatically ignoring everything else. For example, you can configure to only process PDF, Word and Excel from your specific suppliers, automatically discarding images, videos or emails from non-relevant senders. The system even supports wildcard patterns for domains, allowing rules like '*.company.com' that match all subdomains.

The code architecture implements separation of concerns in four main modules: Code.gs manages configuration and entry points, Utils.gs provides validation and sanitization utilities, Services.gs encapsulates all interactions with Gmail and Drive APIs implementing cache and automatic retries, and Core.gs contains the main processing logic. This modularity facilitates maintenance, extensibility and code understanding. The system includes robust error handling with exhaustive try-catch, retries with exponential backoff for API operations that may fail temporarily, complete validation of all user inputs, and a structured logging system with INFO, WARN and ERROR levels that maintains a history of the last 50 errors for auditing.

The web interface implements Material Design with a professional monochrome palette in black and white, fully responsive design that works on mobile and computers, and Material components like cards, interactive chips for file type selection, text fields, elevated buttons and switches. The application allows configuring all parameters without touching the code: sync frequency, domain and file filters, subject patterns for thematic organization, and email notifications with detailed periodic summaries. The system can send daily, weekly or monthly notifications with complete statistics of completed syncs, including breakdown by domain, processed file types and errors found.

This script arose from the need to keep an inbox organized with hundreds of emails from different companies and services. Instead of manually creating labels for each sender, the system automatically analyzes the domain of each email and generates labels with the company name. For example, emails from support@github.com and hello@github.com are grouped under a single 'github' label.

One of the most useful features is its ability to ignore common subdomains like 'e.', 'info.' or 'noreply.', allowing emails from info@atlassian.com and jira@atlassian.com to be classified under the same 'atlassian' label. The script also automatically groups emails from generic providers like Gmail, Outlook or Yahoo under a 'generic' label, keeping your label list clean.

Version 0.4 represents a complete code refactoring, applying modular architecture principles with separation of concerns. It implements a caching system to reduce redundant calls to the Gmail API, batch processing for better performance, and execution time control to avoid timeouts on accounts with lots of email. Additionally, it includes a control panel integrated directly into Gmail where you can configure automatic processing, define which subdomains to ignore, set the maximum emails to process, and view detailed statistics with graphs of the most frequent domains.

The structured logging system with DEBUG, INFO, WARN, ERROR and CRITICAL levels facilitates troubleshooting, while robust validation at multiple layers ensures data integrity. The export functionality allows you to save statistics in CSV format for external analysis, and the script maintains full compatibility with the previous version, automatically migrating existing configuration without data loss.

The 2048 game is addictive, but opening a new tab every time you want to play a quick game breaks your workflow. This extension converts it into a popup accessible with one click from the toolbar, perfect for 2-3 minute breaks without losing context of what you were doing.

The implementation goes beyond the basic game. It includes four difficulty levels that adjust tile spawn probability: Easy (95% of 2s), Normal (90%), Hard (80%) and Extreme (70% of 2s). This allows both beginners to enjoy the game and advanced players to seek extreme challenges where 4 tiles appear more frequently.

Smart undo functionality:
The undo system maintains a history of up to 10 previous moves, saving both board state and exact score at each step. This allows experimenting with strategies without fear of ruining a promising game. If you make a move and see you blocked an important combination, simply undo and try another direction. The history is maintained even if you close the popup and reopen it during the same game.

Statistics persistence across sessions:
The system records three key metrics using browser localStorage: total games played, best score achieved and highest tile reached. Statistics persist across browser sessions, allowing you to compete against your own records over time. Statistics cards update automatically at the end of each game, showing your historical progress.

Dark mode with preference persistence:
The dark mode toggle is not just aesthetic. The implementation includes carefully optimized color contrasts for each tile value (2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048) ensuring perfect readability in both themes. The preference is automatically saved and restored each time you open the popup. The toggle button includes a smooth animation providing immediate visual feedback of the theme change.

Full accessibility with ARIA:
All interactive elements include appropriate ARIA labels allowing screen reader users to navigate and play effectively. The board uses semantic structure with grid and gridcell roles. Buttons provide descriptive labels. Visible focus indicators facilitate keyboard navigation. Modal dialogs include aria-live regions to announce state changes. Color contrast meets WCAG standards in both light and dark modes.

Polished interface with animations:
The score includes animated transitions highlighting point increments when combining tiles. The difficulty selector uses pill-style buttons with clear visual indicators for active selection. Modal dialogs replace standard browser alerts with custom windows matching the extension's design language. The victory modal includes an animated confetti effect with 100 particles celebrating the achievement of reaching 2048.

Modular architecture without dependencies:
The project follows Chrome Manifest V3 with clear separation of concerns: index.html (108 lines) defines semantic structure, styles.css (470 lines) implements visual design with CSS Grid and CSS variables for theming, script.js (381 lines) contains game logic in vanilla JavaScript ES6+. Zero external dependencies. Code uses const/let, arrow functions, modern array methods and JSDoc comments documenting parameters and returns.

Configurable constants:
GRID_SIZE = 4 defines board dimensions (4x4), WIN_TILE = 2048 sets target value, CONFETTI_COUNT = 100 controls victory animation particles, ANIMATION_DURATION = 3000 sets animation duration. CSS variables (--bg-primary, --bg-grid, --tile-empty, --text-primary, --button-bg) allow easy theme customization through overrides.

Main functions:
init() initializes new game state, render() updates DOM with current board state, move(direction) processes tile movement in specified direction, slide(row) combines and shifts tiles within a row, hasMoves() verifies remaining valid moves, undo() restores previous game state. Each function includes input validation and error handling.

Structured local storage:
The statistics object includes gamesPlayed (total completed games), bestScore (highest score achieved), bestTile (highest tile value reached). Dark mode preference is saved as boolean string. All information is stored locally without transmission to external servers. Clearing browser data resets all stored information.

Planned future development:
The roadmap includes Chrome Web Store publication for wider distribution, support for alternative grid sizes (5x5, 6x6), achievement system with unlock conditions, optional sound effects with user toggle, additional color themes and customization, internationalization support for multiple languages, and animated tile movements during transitions.

You're searching for something on Google, find partial information, and want to see what DuckDuckGo or Perplexity AI says about the same thing. The normal flow is to copy the search terms, open a new tab, paste, search. You repeat this several times a day comparing results between engines. It's tedious and breaks the workflow.

Search Engine Converter eliminates that friction. The extension automatically detects the current search by extracting the terms from the URL, and a popup shows buttons for over 34 different engines. One click and you're viewing the same terms in the engine you chose. If the original search was for images, the conversion maintains that context in engines that support it.

Main use cases:
The first case is research where you need to triangulate information from multiple sources. You're investigating a Python library, search on Google and find the official documentation. You want to see real user discussions, so you convert to Reddit. You need example code, you convert to GitHub. You want a direct answer with context, you convert to Perplexity AI. All without rewriting the query.

The second case is privacy. You start searching on Google because it indexes more content, but for sensitive searches you prefer DuckDuckGo or Brave Search that don't track. The extension allows that instant switch without copy-pasting terms.

The third case is specialization. YouTube for videos, Stack Overflow for technical questions, Amazon for products, Wikipedia for definitions, WolframAlpha for calculations. Each engine has its strength. The extension converts between 34 engines organized into categories: general purpose (Google, Bing, Brave, DuckDuckGo), AI-powered engines (Perplexity, Kagi, You.com, SearX), social networks (Twitter, Reddit, LinkedIn, TikTok), multimedia (YouTube, Spotify, Vimeo), e-commerce (Amazon, eBay, Etsy), development (GitHub, GitLab, Stack Overflow), and academic (Wikipedia, Google Scholar, Archive.org).

Quick search: dual mode that inverts the flow:
The core functionality is conversion: you're on a results page, open the popup, choose destination engine, it opens a new tab with the converted search. But v2.0 adds a dual mode that allows you to perform new searches directly from the popup without being on any results page. You activate the 'Search' toggle at the top of the popup, type the terms in the input field, select the engine from the dropdown, and press Enter. The tab opens directly with the results. The dropdown in search mode only shows the engines you marked as visible in the configuration. The Ctrl+K shortcut activates search mode and puts focus on the input field automatically.

Complete keyboard shortcut system:
Alt+1 through Alt+9 convert the current search to the corresponding engine according to its position in the grid. If in the configuration you ordered the buttons so Google is first, DuckDuckGo is second, and GitHub is third, then Alt+1 converts to Google, Alt+2 to DuckDuckGo, Alt+3 to GitHub. The order is what you define through drag-and-drop in settings. The advantage of being able to customize the order is that you assign the first numbers to the engines you use most.

Copy URL without opening tab:
Each engine button has a copy icon in the upper right corner that appears on hover. You click that icon and the converted URL is copied to the clipboard without opening any tab. This is useful when you want to share a specific search. You're on Google searching for 'error ECONNREFUSED docker', find relevant information, and want to send a colleague the same search but on Stack Overflow because it indexes technical discussions better. You hover over the Stack Overflow button, click the copy icon, and paste the URL in Slack.

Advanced configuration:
The configuration panel has four main sections. The first is regional domains for Amazon (Spain .es, USA .com, United Kingdom .co.uk, Germany .de, France .fr, Italy .it) and YouTube (Global and Spain). The second section is engine visibility with checkboxes where you mark which engines you want to see in the button grid. The third section is button ordering through drag-and-drop. The fourth section is default engine for the context menu.

Image context detection:
When you perform an image search on Google (URL contains tbm=isch), and convert to another engine, the extension maintains that context in engines that support image search. The nine engines that detect and preserve the type are: Google, Bing, Brave, DuckDuckGo, Startpage, Ecosia, Qwant, Yandex and Baidu.

Technical architecture:
The extension uses Manifest V3 with Service Workers for better performance and security. The Service Worker has 175 lines and handles dynamic creation of context menus plus tab opening. The main popup is vanilla JavaScript with 993 lines without dependencies on React, Vue, Angular or any framework. The only external library is Sortable.js (22KB minified) for drag-and-drop. The total size is 111KB compared to 150KB of v1.2. The 26% reduction comes from removing four modules related to the AI functionality that v1.2 had.

Comparison v1.2 vs v2.0:
Version 1.2 had complete integration with OpenAI GPT-4 Vision: selective screen area capture through injected content scripts, image analysis with the Vision API, AES-GCM encryption of user API keys, rate limiting system to avoid excessive costs, and HTML sanitization. This functionality required four additional modules, added 600 lines of code, and needed two extra permissions. 90% of users never configured an OpenAI API key, so the functionality was there but unused. Version 2.0 completely removed everything related to AI, reducing the code to 993 lines in 3 files. In return, three new functionalities were added: quick search with dual mode, copy URL to clipboard system, and complete keyboard shortcuts. Four specialized AI engines were added (Perplexity, Kagi, You.com, SearX) that work without needing API keys because they are normal web searches.

When searching for an available domain, the typical flow is frustrating: you open a registrar's site, type an idea, it says it's taken, you try variations, search again. You repeat this dozens of times until finding something available. Registrars bombard you with upsells of premium domains at inflated prices and the experience is slow because each search reloads the entire page.

Domain Checker eliminates that friction. You type a keyword and the system automatically searches the Domainr API suggesting related domains. Availability verification is instant showing real-time status: green for available, red for taken. If you want to explore more options, the expanded search button automatically generates variations with 11 common TLDs (com, net, org, io, co, app, dev, tech, ai, shop, store) without manually typing each combination.

Export and registration search:
Once you identify available domains, you can export results in two formats. TXT generates a plain text file with one domain per line, perfect for post-processing or sharing with clients. CSV includes three columns (Domain, Status, Type) allowing analysis in Excel or import to databases. Each available domain shows icons to search directly on Google, Bing, DuckDuckGo or Brave Search, making it easy to investigate similar trademarks or verify reputation before registering.

Two-layer architecture:
The frontend is a React application managing the interface, local cache and API calls. It implements an LRU (Least Recently Used) cache system that stores results for 5 minutes, reducing redundant calls to the external API and improving response time for repeated searches. The centralized API service uses Axios with interceptors for uniform HTTP error handling, 10-second timeouts and automatic response transformation.

The backend is a hardened Express server with multiple security layers. Helmet.js configures 11 HTTP security headers preventing XSS, clickjacking and other common attacks. Rate limiting allows maximum 100 requests every 15 minutes per IP, preventing abuse and controlling external API costs. CORS uses a whitelist of allowed domains validating the origin of each request. All user input goes through sanitization removing dangerous characters and validation with regex for domains. 10-second timeouts on external requests prevent a slow API from blocking the server.

Logging and monitoring:
Winston implements structured logging at three levels. INFO records normal operations like successful searches. WARN captures suspicious events like exceeded rate limits or CORS attempts from non-allowed origins. ERROR saves critical failures with complete stack traces. The /health endpoint returns server status, timestamp, uptime and environment, allowing monitoring with tools like UptimeRobot or integration in Grafana dashboards.

Chrome extension:
The extension allows verifying domains without opening the complete web application. It activates with one click on the toolbar showing a compact popup. The first time it requests your RapidAPI key storing it locally securely. Searches work exactly the same as on the web but from any tab without interrupting your browsing. Results display in the same popup with the same color indicators and search options.

Deployment on Render:
Deployment is done on two separate services. The backend as Node.js Web Service with environment variables (RAPIDAPI_KEY required, CLIENT_URL for CORS, optional rate limiting and timeout configuration). The frontend as Static Site that builds the React app and serves static files. Communication between services uses HTTPS with automatic certificates. Render's health check pings /health every 5 minutes marking the service as unhealthy if it fails three consecutive times.

You arrive home after work, open the fridge and see chicken, tomatoes, onion and some pasta. You could search for recipes on Google typing each ingredient, filtering thousands of results, discarding those requiring ingredients you don't have. Or simply take a photo of the fridge and in 30 seconds have three complete recipes adapted exactly to what you have available.

AI Photo Kitchen Assistant solves the daily problem of deciding what to cook using what you already have. The application combines two types of AI models: vision models that analyze the image identifying each visible ingredient, and language models that generate professional recipes with detailed instructions, cooking times, culinary techniques and chef tips. The complete flow takes between 15 and 30 seconds depending on the AI provider.

Multi-provider architecture:
The system supports two AI providers with flexible configuration. OpenRouter works as unified gateway giving access to over 50 different models: Google Gemini Pro 1.5 for fast and economical visual analysis, Anthropic Claude 3.5 Sonnet for creative and detailed recipes, OpenAI GPT-4o for balanced performance, Meta Llama 3.1 70B as economical open source option. The alternative is connecting directly with OpenAI using GPT-4o for vision and text generation. Provider choice is made through environment variables without code changes.

Visual analysis uses the OpenAI SDK client configured with OpenRouter or OpenAI base URL according to configuration. The image is encoded in base64 and sent along with a specific prompt instructing the model to list only identifiable ingredients, ignoring packaging, brands and non-edible elements. The vision model returns a structured list of ingredients that gets validated and cleaned before passing to recipe generation. Temperature is configured at 0.3 for consistent and predictable analysis.

Professional recipe generation:
With the validated ingredient list, the system builds a detailed prompt for the language model. The prompt includes the system role defining the model as professional chef with 20 years of experience, the list of available ingredients, dietary restrictions if any (allergies, intolerances, vegan preferences), preferred cuisine type (Italian, Mexican, Mediterranean, Asian), and the exact expected format in the response. Temperature is increased to 0.8 to generate more creative and varied recipes.

Each generated recipe includes complete professional structure: attractive and descriptive name, ingredient list with exact quantities in grams and milliliters, breakdown of preparation and cooking times, technical difficulty level, numbered step-by-step instructions with specific culinary techniques, professional chef tips to improve results, approximate nutritional information per serving, and automatic shopping list with missing ingredients that need to be purchased. HTML format is generated with specific CSS classes for consistent frontend rendering.

Robust error handling:
The system implements automatic retries with exponential backoff for API calls. If a request fails due to timeout, rate limit or transient provider error, the system waits 1 second and retries. On second failure it waits 2 seconds, on third 4 seconds, up to maximum 3 retries. Permanent errors like invalid API key or unavailable model fail immediately without retries. Logging records each attempt with timestamp, model used, response time and error code if applicable.

Security and validation:
Flask-Limiter implements configurable rate limiting per IP: 10 requests per minute and 50 per hour by default, adjustable via environment variables. All uploaded files are validated against whitelist of allowed extensions (jpg, jpeg, png, webp) and maximum size of 16MB. Filenames are sanitized with secure_filename() preventing path traversal. Files are saved in temporary folder and automatically deleted after processing regardless of success or error. User inputs for allergies and cuisine type are escaped preventing injection in prompts.

Intuitive web interface:
The frontend uses Bootstrap 5 with fully responsive design. The main page shows drag-and-drop zone to upload fridge photos, optional fields to specify allergies using interactive tags, cuisine type selector with preconfigured options, slider to choose number of recipes to generate (1-5), and generation button showing animated spinner during processing. Results are rendered as cards with recipes in professional format, buttons to copy individual recipes to clipboard, and button to copy complete shopping list. Errors are shown with non-intrusive toast notifications.

Deployment and configuration:
The .env.example file documents all available configuration variables. For local development only an API key (OpenRouter or OpenAI) is required and the rest uses sensible defaults. The run.sh script automates virtual environment activation and Flask server start. For production it includes Gunicorn configuration with 4 workers, file logging with automatic rotation, and secure SECRET_KEY generation if not configured. Structured logging uses INFO level for normal operations, WARN for exceeded rate limits or suspicious inputs, and ERROR for API failures with complete stack traces.