chore: Remove outdated Copilot instructions and enhance documentation for debugging, fetcher, and SSO integration

- Deleted the outdated Copilot instructions file.
- Updated the debugging documentation to provide clearer guidance on using React Scan and fetch logging.
- Enhanced the fetcher documentation with improved examples and explanations for type-safe API calls.
- Revised the SSO documentation to clarify the process of creating custom SSO providers, including detailed steps and code snippets.

Author: aXenDeveloper

.cursor/rules/backend/backend.mdc

@@ -0,0 +1,8 @@
+---
+description: Rule is for generate backend code with Hono.js
+globs: 
+alwaysApply: false
+---
+- Use @hono/zod-openapi or zod 3 for schema validation
+- Use PostgreSQL with Drizzle ORM
+- Use `t.serial().primaryKey()` for all database IDs

.cursor/rules/docs.mdc

@@ -0,0 +1,13 @@
+---
+description: 
+globs: *.mdx,*.md
+alwaysApply: false
+---
+- Use Fumadocs framework
+- Write docs in `.mdx` file
+- [index.mdx](mdc:apps/docs/content/docs/dev/index.mdx) are the main docs
+- Use easy, clear and funny language for documentation to make it accessible to a wide audience (exclude title and deescription)
+- Use clear and concise examples to illustrate concepts
+- Use `// [!code ++]` to highlight code snippets and `// [!code --]` to hide code snippets
+- Don't add h1 tag in markdown
+- Don't use emoji on heading

.cursor/rules/frontend/frontend.mdc

@@ -0,0 +1,10 @@
+---
+description: Rule is for generate frontend code along with Next.js & React
+globs: 
+alwaysApply: false
+---
+- Use Next.js 15
+- Use App Router and Server Components
+- Use server actions for form handling and data mutations from Server Components
+- Leverage Next.js Image component with proper sizing for core web vitals optimization
+- Navigation api is in `vitnode/lib/navigation` file. Avoid using `next/navigation` directly

.cursor/rules/frontend/i18n.mdc

@@ -0,0 +1,9 @@
+---
+description: Use while write text on frontend
+globs: 
+alwaysApply: false
+---
+- Use `next-intl` for internationalization
+- Use `t('key')` for translation keys
+- Use `getTranslation` function for server component but `useTranslation` for client
+- Languages keys should be added in [en.json](mdc:apps/web/src/plugins/core/langs/en.json) file

.cursor/rules/global.mdc

@@ -0,0 +1,15 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+ VitNode is a comprehensive framework designed to simplify and accelerate application development with Next.js and Hono.js. Built as a monorepo solution managed by Turborepo, VitNode provides a structured environment that makes development faster and less complex. The framework includes an integrated AdminCP and plugin system to extend its core functionality.
+ 
+ - Write ESModule only
+ - Always use snake_case for file name
+ - Use pnpm as pacakge manager
+ - Use zod 3 for schema validation
+ - Use react-hook-form 7 for forms
+ - Use Shadcn UI & Tailwind CSS 4 for UI
+ - Respect Prettier [prettierrc.mjs](mdc:packages/eslint/prettierrc.mjs) and ESLint [eslint.config.mjs](mdc:packages/eslint/eslint.config.mjs)
+ - Use TypeScript 5, React 19 & Hono.js 4

.github/copilot-instructions.md

@@ -1,13 +1,13 @@
 ---
 title: Debugging
-description: ddd
+description: Master VitNode's powerful debugging features to squash those bugs faster!
 ---
 
 ## React Scan
 
-In VitNode we implemented the [React Scan](https://react-scan.com/) feature that will show you re-rendering components in real-time. This feature will help you to optimize your React application.
+Ever wondered which components are secretly re-rendering and slowing down your app? Say hello to [React Scan](https://react-scan.com/)! This awesome feature shows you component re-renders in real-time, helping you catch performance bottlenecks before they catch you.
 
-To enable **React Scan**, you need to pass `debug` props in `RootLayout` component:
+Want to become a performance detective? Here's how to enable **React Scan**:
 
 ```tsx title="src/app/[locale]/layout.tsx"
 export default function LocaleLayout({
@@ -30,9 +30,11 @@ export default function LocaleLayout({
 }
 ```
 
-## Fetching logs
+Just add that magical `debug` prop, and you're ready to hunt down those unnecessary re-renders! 🎯
 
-[Next.js has a build-in fetch cache](https://nextjs.org/docs/app/building-your-application/data-fetching/fetching) that will cache the fetch requests. You can enable the fetch logs by passing the `logging` object in the `next.config.ts` file:
+## Fetch Detective
+
+Want to know exactly what's happening with your API calls? Next.js has your back with its built-in fetch cache system. Let's make it spill all the secrets by enabling fetch logging:
 
 ```ts title="next.config.ts"
 import type { NextConfig } from 'next';
@@ -54,4 +56,6 @@ const nextConfig: NextConfig = {
 export default vitNodeNextConfig(nextConfig);
 ```
 
-You can read more about it in the [official documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/logging#fetching).
+With `fullUrl: true`, you'll see every fetch request in its full glory! 🎉
+
+Want to dive deeper into the fetch logging rabbit hole? Check out the [official Next.js logging docs](https://nextjs.org/docs/app/api-reference/config/next-config-js/logging#fetching) for more cool tricks!

apps/docs/content/docs/dev/debugging.mdx

@@ -1,83 +1,81 @@
 ---
 title: Fetcher
-description: Fetch data with type-safe API
+description: Type-safe API data fetching with RPC-style interface
 ---
 
-Our fetcher has RPC (Remote Procedure Call) style API. It allows you to call any API endpoint with type-safe API.
+The VitNode fetcher provides a type-safe RPC (Remote Procedure Call) style interface for making API requests. It simplifies data fetching by providing strong typing and a consistent API across your application.
 
 <Callout type="warn" emoji="⚠️" title="Server-side only">
-  The `fetcher()` function is only server-side. You cannot use it on the
-  client-side.
+  The `fetcher()` function can only be used on the server-side. Client-side
+  usage is not supported.
 </Callout>
 
-## Usage
+## Getting Started
 
-To use the `fetcher()` function, you need to import it from the `vitnode/lib/fetcher` module. You also need to import the module you want to use.
-
-More about modules can be found in the [Modules](/docs/dev/modules) section.
+First, import the required dependencies:
 
 ```ts
 import { fetcher } from 'vitnode/lib/fetcher';
 import { usersModule } from 'vitnode/api/modules/users/users.module';
 ```
 
+Make your first API call:
+
 ```ts
-const res = await fetcher(usersModule, {
+const response = await fetcher(usersModule, {
   path: '/session',
   method: 'get',
   module: 'users',
 });
-```
 
-The response from `fetcher()` is compatible with the standard `fetch` Response API. Here are common way to work with the response:
-
-```ts
-// Basic response handling
-if (res.ok) {
-  const data = await res.json();
-  console.log(data);
+// Handle the response
+if (response.ok) {
+  const data = await response.json();
+  console.log('Session data:', data);
 }
 ```
 
-### Options
+The fetcher returns a standard Response object, just like the native `fetch` API. This makes it familiar and easy to work with.
+
+## Advanced Features
 
-You can pass the `options` object to modify the `fetch` function. For example we can pass `cache` option to enable the cache from `next`:
+### Caching Responses
+
+You can leverage Next.js caching by passing cache options:
 
 ```ts
-const res = await fetcher(usersModule, {
+const response = await fetcher(usersModule, {
   path: '/session',
   method: 'get',
   module: 'users',
-  // [!code ++]
   options: {
     // [!code ++]
-    cache: 'force-cache',
-    // [!code ++]
+    cache: 'force-cache', // Uses Next.js cache
   },
 });
 ```
 
-### Handle set-cookies
+### Cookie Management
 
-React Server Components cannot handle `set-cookies` headers from the server. To handle
-this, you need to pass the `allowSaveCookies` param to the `fetcher()` function. This will allow the cookies to be saved in the response.
+When working with authentication or sessions, you might need to handle cookies. React Server Components have special considerations for cookie handling:
 
-<Callout type="warn" emoji="⚠️" title="Server-side only">
-  The `allowSaveCookies` param works only when your request has method different
-  from `get` and response status has 2xx.
+<Callout type="info" title="Cookie Handling">
+  Cookie saving is only supported for requests that return a 2xx status code.
 </Callout>
 
+Here's how to enable cookie handling for a sign-in request:
+
 ```ts
-const res = await fetcher(usersModule, {
+const response = await fetcher(usersModule, {
   path: '/sign_in',
   method: 'post',
   module: 'users',
   // [!code ++]
   allowSaveCookies: true,
   args: {
     body: {
-      email: '',
-      password: '',
+      email: 'user@example.com',
+      password: '********',
     },
   },
 });