samarthya-bot 1.0.2

package/README.md

@@ -0,0 +1,92 @@
+<div align="center">
+  <h1>🧠 SamarthyaBot</h1>
+  <p><strong>Privacy-First Local Agentic OS & Command Center</strong></p>
+  
+  <p>
+    An intelligent, extensible, and localized AI operator built for local-first execution. Out-of-the-box support for API usage (Gemini) or completely offline execution via Ollama. It runs commands, handles background jobs, remembers you securely, and performs multi-step autonomous planning.
+  </p>
+</div>
+
+<hr/>
+
+## 🚀 The Vision: A Developer's Platform, Not Just a Chatbot
+
+Most AI tools are single-turn chat interfaces. SamarthyaBot is built as a **Platform OS**. It features a modular Plugin Engine, a Background CRON executor, and a dedicated UI Control Center. 
+
+You don't just ask SamarthyaBot questions; you *delegate tasks* to it.
+
+## 🌟 Key "Level 2" Features
+
+- 🛑 **Control Center UI**: A full dashboard monitoring the health of the agent, loaded plugins, RAM usage, and autonomous loops.
+- 🔁 **Autonomous Background Engine**: Schedule tasks (e.g. "Monitor this folder every 10 mins") and let the agent work silently in the background. Features a **Big Red Kill Switch** for emergency halts.
+- 🔌 **Dynamic Plugin Marketplace**: Drop a `.js` file into `~/SamarthyaBot_Files/plugins/`, and the agent automatically learns the new tool on start.
+- 📸 **Screen Understanding**: Native capability to capture desktop screenshots and pipe them into Vision models.
+- 🔐 **Encrypted Memory Vault**: AES-256-CBC local encryption for any API keys, tokens, or PII the agent decides it needs to remember.
+- 🇮🇳 **Indian Context**: Native prompt handling for GST due dates, UPI link generation, and Hinglish/Hindi fluency.
+
+## 🛠️ Architecture
+
+It uses a monolithic structure right now, preparing for a modular NPM package evolution:
+- **Backend**: Node.js, Express, MongoDB (Local), PM2 for Daemonizing.
+- **Frontend**: React, Vite, Lucide-Icons.
+- **Agent Loop**: A custom ReAct-inspired (`Reason`, `Act`, `Observe`) multi-step autonomous planner.
+
+## 📦 Quick Start Guide
+
+**Prerequisites:** Node.js (v20+), MongoDB running locally, Git.
+
+1. **Clone & Install:**
+```bash
+git clone https://github.com/mebishnusahu0595/SamarthyaBot.git
+cd SamarthyaBot/backend
+npm install
+cd ../frontend
+npm install
+```
+
+2. **Environment Variables:**
+Duplicate the config file in the backend.
+```bash
+cd ../backend
+cp .env.example .env
+```
+Edit `.env` and fill in your `GEMINI_API_KEY` and a random string for `MEMORY_ENCRYPTION_KEY`.
+
+3. **Build Frontend & Start:**
+```bash
+cd ../frontend
+npm run build
+cp -r dist/* ../backend/public/
+cd ../backend
+npm start   # Or use `node bin/samarthya.js start` if you have it linked globally
+```
+
+4. **Access the Control Center:**
+Open `http://localhost:5000` in your browser.
+
+## 🔌 Developing Plugins
+
+Want to give your AI a new Superpower? Just make a simple JS file in `~/SamarthyaBot_Files/plugins/my_tool.js`:
+
+```javascript
+module.exports = {
+    name: 'greet_user',
+    description: 'Greets the user nicely',
+    riskLevel: 'low',
+    category: 'tool',
+    parameters: {
+        name: { type: 'string', required: true, description: 'User name' }
+    },
+    execute: async (args, userContext) => {
+        return { success: true, result: `Hello ${args.name}!` };
+    }
+};
+```
+Restart the server, and the agent will instantly know how to greet users using your custom logic!
+
+## 🔐 Privacy Guarantee
+
+All your conversations, file reads, and parsed memories remain completely local in your MongoDB database and `~/SamarthyaBot_Files/` directory. API data is only sent to the LLM Provider you specific (Gemini or Local Ollama).
+
+## 📄 License
+MIT License

package/backend/.env.example

@@ -0,0 +1,23 @@
+GEMINI_API_KEY=your_gemini_api_key_here
+MONGO_URI=mongodb://localhost:27017/samarthya
+PORT=5000
+
+# Security (Required for Encrypted Vault)
+MEMORY_ENCRYPTION_KEY=generate_a_random_32_character_string_here
+
+# Optional Email Integration
+# SMTP_EMAIL=your_email@gmail.com
+# SMTP_PASSWORD=your_16_char_app_password
+
+# Optional Desktop Application Features
+USE_OLLAMA=false
+OLLAMA_URL=http://localhost:11434
+OLLAMA_MODEL=llama3.2
+ACTIVE_PROVIDER=gemini
+ACTIVE_MODEL=gemini-2.5-flash-lite
+
+# Optional Telegram Remote Control
+# TELEGRAM_BOT_TOKEN=your_telegram_bot_token
+
+# Node Environment
+NODE_ENV=production

package/backend/bin/samarthya.js

@@ -0,0 +1,384 @@
+#!/usr/bin/env node
+const { execSync, spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const readline = require('readline');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+const backendDir = path.join(__dirname, '..');
+
+// Helper to check if server is already running on port 5000
+const isServerRunning = () => {
+    try {
+        execSync('fuser 5000/tcp 2>/dev/null');
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+if (!command) {
+    console.log(`
+🤖 SamarthyaBot Local AI Agent
+Usage:
+  samarthya onboard      - Setup your local environment
+  samarthya model        - Change your active AI provider/model
+  samarthya gateway      - Start the local server
+  samarthya status       - Check if the agent is running
+  samarthya tunnel       - Expose to internet & setup webhooks 
+  samarthya stop         - Stop the running gateway
+  samarthya restart      - Restart the gateway
+`);
+    process.exit(0);
+}
+
+switch (command) {
+    case 'onboard':
+        console.log('🚀 Running SamarthyaBot Setup Wizard...');
+
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        const question = (query) => new Promise(resolve => rl.question(query, resolve));
+
+        (async () => {
+            console.log("\n🌐 Select your primary AI Provider:");
+            console.log("  1) Google Gemini (Default)");
+            console.log("  2) Anthropic Claude");
+            console.log("  3) Groq (Fastest)");
+            console.log("  4) OpenAI");
+            console.log("  5) Local Ollama (Offline)");
+            console.log("  6) Mistral AI\n");
+
+            let providerRaw = await question("Enter choice (1-6, default 1): ");
+            let activeProvider = 'gemini';
+            let useOllama = 'false';
+
+            switch (providerRaw.trim()) {
+                case '2': activeProvider = 'anthropic'; break;
+                case '3': activeProvider = 'groq'; break;
+                case '4': activeProvider = 'openai'; break;
+                case '5':
+                    activeProvider = 'ollama';
+                    useOllama = 'true';
+                    break;
+                case '6': activeProvider = 'mistral'; break;
+                case '1':
+                default:
+                    activeProvider = 'gemini';
+                    break;
+            }
+
+            console.log(`\n👉 Selected Provider: ${activeProvider.toUpperCase()}\n`);
+
+            const geminiKey = await question('🔑 Enter Google Gemini API Key (or press Enter to skip if already set): ');
+            const anthropicKey = await question('🔑 Enter Anthropic (Claude) API Key (or press Enter to skip): ');
+            const groqKey = await question('🔑 Enter Groq API Key (or press Enter to skip): ');
+            const openAiKey = await question('🔑 Enter OpenAI API Key (or press Enter to skip): ');
+
+            const envPath = path.join(backendDir, '.env');
+            let envVars = {};
+
+            // Read existing if present to keep other configs
+            if (fs.existsSync(envPath)) {
+                const currentEnv = fs.readFileSync(envPath, 'utf8');
+                currentEnv.split('\n').forEach(line => {
+                    const [k, v] = line.split('=');
+                    if (k && v) envVars[k.trim()] = v.trim();
+                });
+            } else {
+                envVars = {
+                    PORT: '5000',
+                    MONGODB_URI: 'mongodb://localhost:27017/samarthya',
+                    JWT_SECRET: 'samarthya_secret_key_change_in_production',
+                    NODE_ENV: 'production',
+                    CORS_ORIGIN: 'http://localhost:5000',
+                    USE_OLLAMA: useOllama,
+                    ACTIVE_PROVIDER: activeProvider,
+                    ACTIVE_MODEL: activeProvider === 'gemini' ? 'gemini-2.5-flash' : '',
+                    OLLAMA_URL: 'http://localhost:11434',
+                    OLLAMA_MODEL: 'dolphin3:8b-llama3.1-q4_K_M'
+                };
+            }
+
+            envVars['USE_OLLAMA'] = useOllama;
+            envVars['ACTIVE_PROVIDER'] = activeProvider;
+
+            // Assign keys if provided
+            if (geminiKey.trim()) envVars['GEMINI_API_KEY'] = geminiKey.trim();
+            if (anthropicKey.trim()) envVars['ANTHROPIC_API_KEY'] = anthropicKey.trim();
+            if (groqKey.trim()) envVars['GROQ_API_KEY'] = groqKey.trim();
+            if (openAiKey.trim()) envVars['OPENAI_API_KEY'] = openAiKey.trim();
+
+            if (!envVars['GEMINI_API_KEY']) envVars['GEMINI_API_KEY'] = 'dummy';
+
+            // Write back to .env
+            const newEnvContent = Object.keys(envVars).map(k => `${k}=${envVars[k]}`).join('\n');
+            fs.writeFileSync(envPath, newEnvContent);
+            console.log('\n✅ Keys saved to .env file securely.');
+
+            console.log('📦 Installing backend dependencies (this might take a few seconds)...');
+            try {
+                execSync('npm install --production', { cwd: backendDir, stdio: 'ignore' });
+            } catch (e) { /* ignore */ }
+
+            console.log('\n✨ Onboarding complete! Run "samarthya gateway" to start your AI Operator.');
+            rl.close();
+            process.exit(0);
+        })();
+        break;
+
+    case 'model':
+        console.log('🔄 Changing SamarthyaBot Active AI Model...');
+        const rlModel = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const qModel = (query) => new Promise(res => rlModel.question(query, res));
+
+        (async () => {
+            console.log("\n🌐 Select your primary AI Provider:");
+            console.log("  1) Google Gemini (Default)");
+            console.log("  2) Anthropic Claude");
+            console.log("  3) Groq (Fastest)");
+            console.log("  4) OpenAI");
+            console.log("  5) Local Ollama (Offline)");
+            console.log("  6) Mistral AI\n");
+
+            let pRaw = await qModel("Enter choice (1-6, default 1): ");
+            let aProv = 'gemini';
+            let uOll = 'false';
+
+            switch (pRaw.trim()) {
+                case '2': aProv = 'anthropic'; break;
+                case '3': aProv = 'groq'; break;
+                case '4': aProv = 'openai'; break;
+                case '5': aProv = 'ollama'; uOll = 'true'; break;
+                case '6': aProv = 'mistral'; break;
+                default: aProv = 'gemini'; break;
+            }
+
+            let aMod = '';
+            console.log(`\n📌 Sub-Models for ${aProv.toUpperCase()}:`);
+            if (aProv === 'gemini') {
+                console.log(" 1) gemini-2.5-flash        (Fastest reasoning, great pricing)");
+                console.log(" 2) gemini-2.5-pro          (Advanced complex multi-step reasoning)");
+                console.log(" 3) gemini-2.5-flash-lite   (Fastest, budget friendly)");
+                console.log(" 4) gemini-2.0-flash        (Older 1M context version)");
+                const mSel = await qModel("Enter model choice (or type custom model ID directly): ");
+                if (mSel.trim() === '1' || mSel.trim() === '') aMod = 'gemini-2.5-flash';
+                else if (mSel.trim() === '2') aMod = 'gemini-2.5-pro';
+                else if (mSel.trim() === '3') aMod = 'gemini-2.5-flash-lite';
+                else if (mSel.trim() === '4') aMod = 'gemini-2.0-flash';
+                else aMod = mSel.trim();
+            } else if (aProv === 'openai') {
+                console.log(" 1) gpt-5.2      (Best for coding & agentic tasks)");
+                console.log(" 2) gpt-5-mini   (Faster, cost-efficient GPT-5)");
+                console.log(" 3) gpt-4o       (Fast, intelligent, flexible)");
+                console.log(" 4) o3-mini      (Small reasoning alternative)");
+                const mSel = await qModel("Enter model choice (or type custom ID): ");
+                if (mSel.trim() === '1') aMod = 'gpt-5.2';
+                else if (mSel.trim() === '2') aMod = 'gpt-5-mini';
+                else if (mSel.trim() === '3') aMod = 'gpt-4o';
+                else if (mSel.trim() === '4') aMod = 'o3-mini';
+                else aMod = mSel.trim();
+            } else if (aProv === 'groq') {
+                console.log(" 1) llama-3.3-70b-versatile  (Best overall Llama)");
+                console.log(" 2) llama-3.1-8b-instant     (Extreme Fast Llama)");
+                console.log(" 3) qwen/qwen3-32b           (Powerful 32b reasoning)");
+                const mSel = await qModel("Enter model choice (or type custom ID): ");
+                if (mSel.trim() === '1' || mSel.trim() === '') aMod = 'llama-3.3-70b-versatile';
+                else if (mSel.trim() === '2') aMod = 'llama-3.1-8b-instant';
+                else if (mSel.trim() === '3') aMod = 'qwen/qwen3-32b';
+                else aMod = mSel.trim();
+            } else if (aProv === 'mistral') {
+                console.log(" 1) mistral-large-3          (General-purpose multimodal)");
+                console.log(" 2) ministral-3-8b           (Powerful & efficient)");
+                console.log(" 3) mistral-small-3.2        (Small latest model)");
+                console.log(" 4) devstral-2               (Best for code & agents)");
+                const mSel = await qModel("Enter model choice (or type custom ID): ");
+                if (mSel.trim() === '1' || mSel.trim() === '') aMod = 'mistral-large-3';
+                else if (mSel.trim() === '2') aMod = 'ministral-3-8b';
+                else if (mSel.trim() === '3') aMod = 'mistral-small-3.2';
+                else if (mSel.trim() === '4') aMod = 'devstral-2';
+                else aMod = mSel.trim();
+            } else if (aProv === 'anthropic') {
+                console.log(" 1) claude-3-5-sonnet-latest");
+                console.log(" 2) claude-3-opus-latest");
+                const mSel = await qModel("Enter model choice (or type custom ID): ");
+                if (mSel.trim() === '1' || mSel.trim() === '') aMod = 'claude-3-5-sonnet-latest';
+                else if (mSel.trim() === '2') aMod = 'claude-3-opus-latest';
+                else aMod = mSel.trim();
+            } else if (aProv === 'ollama') {
+                console.log(" Your models list usually includes:");
+                console.log(" 1) dolphin3:8b-llama3.1-q4_K_M   (Default)");
+                console.log(" 2) llama3:8b");
+                console.log(" 3) mistral");
+                const mSel = await qModel("Enter model choice (or type custom Ollama tag): ");
+                if (mSel.trim() === '1' || mSel.trim() === '') aMod = 'dolphin3:8b-llama3.1-q4_K_M';
+                else if (mSel.trim() === '2') aMod = 'llama3:8b';
+                else if (mSel.trim() === '3') aMod = 'mistral';
+                else aMod = mSel.trim();
+            }
+
+            const ePath = path.join(backendDir, '.env');
+            if (fs.existsSync(ePath)) {
+                let currentEnv = fs.readFileSync(ePath, 'utf8');
+                let lines = currentEnv.split('\n');
+                let updated = false;
+                let mUpdated = false;
+
+                lines = lines.map(line => {
+                    if (line.startsWith('ACTIVE_PROVIDER=')) { updated = true; return `ACTIVE_PROVIDER=${aProv}`; }
+                    if (line.startsWith('ACTIVE_MODEL=')) { mUpdated = true; return `ACTIVE_MODEL=${aMod}`; }
+                    if (line.startsWith('USE_OLLAMA=')) { uUpdated = true; return `USE_OLLAMA=${uOll}`; }
+                    if (aProv === 'ollama' && line.startsWith('OLLAMA_MODEL=')) { return `OLLAMA_MODEL=${aMod}`; }
+                    return line;
+                });
+
+                if (!updated) lines.push(`ACTIVE_PROVIDER=${aProv}`);
+                if (!mUpdated) lines.push(`ACTIVE_MODEL=${aMod}`);
+                if (!uUpdated) lines.push(`USE_OLLAMA=${uOll}`);
+
+                fs.writeFileSync(ePath, lines.join('\n'));
+                console.log(`\n✅ Model successfully switched to: ${aProv.toUpperCase()}!`);
+                console.log('🔄 Please restart the gateway if it is currently running.');
+            } else {
+                console.log('❌ Error: .env file not found. Please run "samarthya onboard" first.');
+            }
+
+            rlModel.close();
+        })();
+        break;
+
+    case 'gateway':
+        if (isServerRunning()) {
+            console.log('⚠️  Gateway is already running on port 5000!');
+            console.log('🌐 Access the dashboard at http://localhost:5000');
+            process.exit(0);
+        }
+
+        try { require('dotenv').config({ path: path.join(backendDir, '.env') }); } catch (e) { /* ignore if not installed */ }
+
+        const activeProvider = process.env.ACTIVE_PROVIDER ? process.env.ACTIVE_PROVIDER.toUpperCase() : 'GEMINI';
+        const activeModel = process.env.ACTIVE_MODEL || 'gemini-2.5-flash';
+
+        console.log('🚀 Starting SamarthyaBot Gateway in the background...');
+        console.log(`🧠 Local Config: Using ${activeProvider} (${activeModel})`);
+        console.log('💡 Tip: Run "samarthya model" to change your AI provider/model at any time.');
+        console.log('🌐 You can access your agent dashboard at http://localhost:5000\n');
+
+        // We use spawn to run the server
+        const child = spawn('node', ['server.js'], {
+            cwd: backendDir,
+            stdio: 'inherit'
+        });
+
+        child.on('close', (code) => {
+            console.log(`Gateway exited with code ${code}`);
+        });
+        break;
+
+    case 'status':
+        if (isServerRunning()) {
+            console.log('🟢 SamarthyaBot Gateway is actively running on port 5000.');
+            console.log('🌐 Dashboard: http://localhost:5000');
+        } else {
+            console.log('🔴 SamarthyaBot Gateway is offline. Run "samarthya gateway" to start.');
+        }
+        break;
+
+    case 'tunnel':
+        console.log('🚇 Starting LocalTunnel to expose port 5000 to the internet...');
+        if (!isServerRunning()) {
+            console.log('⚠️  Warning: SamarthyaBot Gateway is not running! Run "samarthya gateway" in another terminal first.');
+        }
+
+        try { require('dotenv').config({ path: path.join(backendDir, '.env') }); } catch (e) { }
+
+        const tunnelProcess = spawn('npx', ['localtunnel', '--port', '5000'], { stdio: 'pipe' });
+
+        tunnelProcess.stdout.on('data', async (data) => {
+            const output = data.toString();
+            console.log(output.trim());
+            const match = output.match(/your url is: (https:\/\/.+)/);
+            if (match && match[1]) {
+                const publicUrl = match[1];
+                console.log(`\n✅ Public Gateway URL: ${publicUrl}`);
+
+                // Set Telegram Webhook Automatically
+                if (process.env.TELEGRAM_BOT_TOKEN) {
+                    console.log('🔗 Setting Telegram Webhook...');
+                    try {
+                        const tgUrl = `https://api.telegram.org/bot${process.env.TELEGRAM_BOT_TOKEN}/setWebhook?url=${publicUrl}/api/telegram/webhook`;
+                        const res = await fetch(tgUrl);
+                        const result = await res.json();
+                        if (result.ok) {
+                            console.log('🟢 Telegram Webhook Set Successfully!');
+                        } else {
+                            console.log('🔴 Failed to set Telegram Webhook:', result.description);
+                        }
+                    } catch (err) {
+                        console.log('🔴 Error setting Telegram Webhook:', err.message);
+                    }
+                } else {
+                    console.log('ℹ️  TELEGRAM_BOT_TOKEN not found in .env. Skipping Telegram Webhook setup.');
+                }
+
+                console.log('\n📱 Put this URL in your Meta WhatsApp App Dashboard:');
+                console.log(`   ${publicUrl}/api/whatsapp/webhook`);
+                console.log('\n(Leave this terminal running to keep the tunnel open natively)');
+            }
+        });
+
+        tunnelProcess.stderr.on('data', (data) => {
+            console.error('Tunnel Error:', data.toString());
+        });
+
+        tunnelProcess.on('close', (code) => {
+            console.log(`Tunnel closed with code ${code}`);
+        });
+
+        break;
+
+    case 'stop':
+        if (isServerRunning()) {
+            console.log('🛑 Stopping SamarthyaBot Gateway...');
+            try {
+                execSync('fuser -k 5000/tcp 2>/dev/null');
+                console.log('✅ Gateway stopped successfully.');
+            } catch (e) {
+                console.log('❌ Failed to stop gateway gracefully. Process might already be dead.');
+            }
+        } else {
+            console.log('⚠️  Gateway is not currently running.');
+        }
+        break;
+
+    case 'restart':
+        console.log('🔄 Restarting SamarthyaBot Gateway...');
+        if (isServerRunning()) {
+            try {
+                execSync('fuser -k 5000/tcp 2>/dev/null');
+            } catch (e) { /* ignore */ }
+        }
+        // Give it a moment to free the port
+        setTimeout(() => {
+            const restartChild = spawn('node', ['server.js'], {
+                cwd: backendDir,
+                stdio: 'inherit'
+            });
+            restartChild.on('close', (code) => {
+                console.log(`Gateway exited with code ${code}`);
+            });
+            console.log('✅ Gateway restarted successfully!');
+            console.log('🌐 Dashboard: http://localhost:5000\n');
+        }, 1000);
+        break;
+
+    default:
+        console.log(`❌ Unknown command: ${command}`);
+        console.log('Try "samarthya onboard" or "samarthya gateway"');
+        process.exit(1);
+}

package/backend/config/constants.js

@@ -0,0 +1,71 @@
+module.exports = {
+    SUPPORTED_LANGUAGES: ['hindi', 'hinglish', 'english'],
+
+    TOOL_PACKS: {
+        student: {
+            name: '🎓 Student Pack',
+            nameHi: '🎓 स्टूडेंट पैक',
+            tools: ['web_search', 'summarize_text', 'note_take', 'calculate', 'reminder_set', 'file_read', 'file_write', 'file_list', 'weather_info', 'run_command', 'capture_desktop_screenshot', 'schedule_background_task', 'simulate_task'],
+            description: 'Assignment summary, notes, exam reminders, calculations'
+        },
+        business: {
+            name: '🏢 Small Business Pack',
+            nameHi: '🏢 बिज़नेस पैक',
+            tools: ['web_search', 'send_email', 'calendar_schedule', 'gst_reminder', 'calculate', 'file_read', 'file_write', 'file_list', 'upi_generate', 'note_take', 'reminder_set', 'weather_info', 'system_info', 'run_command', 'capture_desktop_screenshot', 'schedule_background_task', 'simulate_task'],
+            description: 'GST reminders, email, UPI links, file management'
+        },
+        developer: {
+            name: '👨‍💻 Developer Pack',
+            nameHi: '👨‍💻 डेवलपर पैक',
+            tools: ['web_search', 'file_read', 'file_write', 'file_list', 'calculate', 'send_email', 'run_command', 'system_info', 'open_url', 'note_take', 'reminder_set', 'capture_desktop_screenshot', 'schedule_background_task', 'simulate_task'],
+            description: 'Shell commands, file ops, system info, browser control'
+        },
+        personal: {
+            name: '🏠 Personal Pack',
+            nameHi: '🏠 पर्सनल पैक',
+            tools: ['web_search', 'reminder_set', 'note_take', 'calculate', 'weather_info', 'file_read', 'file_write', 'file_list', 'calendar_schedule', 'upi_generate', 'send_email', 'system_info', 'open_url', 'run_command', 'capture_desktop_screenshot', 'schedule_background_task', 'simulate_task'],
+            description: 'Weather, notes, reminders, UPI, email, files'
+        }
+    },
+
+    PERMISSION_LEVELS: {
+        ALLOW_ONCE: 'allow_once',
+        ALLOW_ALWAYS: 'allow_always',
+        NEVER: 'never',
+        ASK: 'ask'
+    },
+
+    SENSITIVE_PATTERNS: {
+        PAN: /[A-Z]{5}[0-9]{4}[A-Z]/g,
+        AADHAAR: /\b\d{4}\s?\d{4}\s?\d{4}\b/g,
+        PHONE: /(\+91|0)?[6-9]\d{9}/g,
+        EMAIL: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+        BANK_ACCOUNT: /\d{9,18}/g,
+        IFSC: /[A-Z]{4}0[A-Z0-9]{6}/g
+    },
+
+    INDIAN_HOLIDAYS_2025: [
+        { date: '2025-01-14', name: 'Makar Sankranti', nameHi: 'मकर संक्रांति' },
+        { date: '2025-01-26', name: 'Republic Day', nameHi: 'गणतंत्र दिवस' },
+        { date: '2025-03-14', name: 'Holi', nameHi: 'होली' },
+        { date: '2025-03-31', name: 'Eid ul-Fitr', nameHi: 'ईद उल-फ़ित्र' },
+        { date: '2025-04-06', name: 'Ram Navami', nameHi: 'राम नवमी' },
+        { date: '2025-04-14', name: 'Ambedkar Jayanti', nameHi: 'अंबेडकर जयंती' },
+        { date: '2025-04-18', name: 'Good Friday', nameHi: 'गुड फ्राइडे' },
+        { date: '2025-05-01', name: 'May Day', nameHi: 'मज़दूर दिवस' },
+        { date: '2025-08-15', name: 'Independence Day', nameHi: 'स्वतंत्रता दिवस' },
+        { date: '2025-08-27', name: 'Janmashtami', nameHi: 'जन्माष्टमी' },
+        { date: '2025-10-02', name: 'Gandhi Jayanti', nameHi: 'गांधी जयंती' },
+        { date: '2025-10-20', name: 'Dussehra', nameHi: 'दशहरा' },
+        { date: '2025-11-01', name: 'Diwali', nameHi: 'दीपावली' },
+        { date: '2025-11-05', name: 'Guru Nanak Jayanti', nameHi: 'गुरु नानक जयंती' },
+        { date: '2025-12-25', name: 'Christmas', nameHi: 'क्रिसमस' }
+    ],
+
+    RISK_LEVELS: {
+        LOW: 'low',
+        MEDIUM: 'medium',
+        HIGH: 'high',
+        CRITICAL: 'critical'
+    }
+};

package/backend/config/db.js

@@ -0,0 +1,13 @@
+const mongoose = require('mongoose');
+
+const connectDB = async () => {
+    try {
+        const conn = await mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/samarthya');
+        console.log(`✅ MongoDB Connected: ${conn.connection.host}`);
+    } catch (error) {
+        console.error(`❌ MongoDB Error: ${error.message}`);
+        process.exit(1);
+    }
+};
+
+module.exports = connectDB;

package/backend/controllers/auditController.js

@@ -0,0 +1,86 @@
+const AuditLog = require('../models/AuditLog');
+
+// Get audit logs with pagination
+exports.getAuditLogs = async (req, res) => {
+    try {
+        const { page = 1, limit = 50, category, status } = req.query;
+        const query = {};
+
+        if (category) query.category = category;
+        if (status) query.status = status;
+
+        const logs = await AuditLog.find(query)
+            .sort({ createdAt: -1 })
+            .skip((page - 1) * limit)
+            .limit(parseInt(limit));
+
+        const total = await AuditLog.countDocuments(query);
+
+        res.json({
+            success: true,
+            logs,
+            pagination: {
+                page: parseInt(page),
+                limit: parseInt(limit),
+                total,
+                pages: Math.ceil(total / limit)
+            }
+        });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+// Get audit stats
+exports.getAuditStats = async (req, res) => {
+    try {
+        const userId = req.user.id;
+
+        const [totalActions, byCategory, byStatus, recentRisks] = await Promise.all([
+            AuditLog.countDocuments({}),
+            AuditLog.aggregate([
+                { $group: { _id: '$category', count: { $sum: 1 } } }
+            ]),
+            AuditLog.aggregate([
+                { $group: { _id: '$status', count: { $sum: 1 } } }
+            ]),
+            AuditLog.find({
+                'details.riskLevel': { $in: ['high', 'critical'] }
+            }).sort({ createdAt: -1 }).limit(10)
+        ]);
+
+        res.json({
+            success: true,
+            stats: {
+                totalActions,
+                byCategory: Object.fromEntries(byCategory.map(c => [c._id, c.count])),
+                byStatus: Object.fromEntries(byStatus.map(s => [s._id, s.count])),
+                recentHighRisks: recentRisks
+            }
+        });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+// Rollback an action
+exports.rollbackAction = async (req, res) => {
+    try {
+        const log = await AuditLog.findOne({
+            _id: req.params.id,
+            canRollback: true
+        });
+
+        if (!log) {
+            return res.status(404).json({ success: false, message: 'Action not found or cannot be rolled back' });
+        }
+
+        // Mark as rolled back
+        log.status = 'rolled_back';
+        await log.save();
+
+        res.json({ success: true, message: 'Action rolled back successfully' });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};