@react-frameui/loki-ai 1.0.0

package/dist/context/fileContext.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFileContext = loadFileContext;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../utils/config");
+/**
+ * allowed extensions for text context.
+ */
+const ALLOWED_EXTENSIONS = [
+    '.ts', '.js', '.json', '.md', '.txt', '.html', '.css', '.py', '.java', '.c', '.cpp', '.h', '.go', '.rs', '.yml', '.yaml', '.sh'
+];
+/**
+ * Directories to ignore.
+ */
+const IGNORED_DIRS = [
+    'node_modules', '.git', 'dist', 'build', 'out', 'bin', '.idea', '.vscode', 'coverage'
+];
+/**
+ * files to ignore.
+ */
+const IGNORED_FILES = [
+    'package-lock.json', 'yarn.lock', '.DS_Store'
+];
+function isTextFile(filePath) {
+    const ext = path_1.default.extname(filePath).toLowerCase();
+    return ALLOWED_EXTENSIONS.includes(ext);
+}
+function shouldIgnore(entryName) {
+    return IGNORED_DIRS.includes(entryName) || IGNORED_FILES.includes(entryName) || entryName.startsWith('.');
+}
+/**
+ * Recursively reads files from a directory or reads a single file.
+ */
+function readPath(targetPath, gatheredContent) {
+    try {
+        const stats = fs_1.default.statSync(targetPath);
+        if (stats.isDirectory()) {
+            const entries = fs_1.default.readdirSync(targetPath);
+            for (const entry of entries) {
+                if (shouldIgnore(entry))
+                    continue;
+                readPath(path_1.default.join(targetPath, entry), gatheredContent);
+            }
+        }
+        else if (stats.isFile()) {
+            if (isTextFile(targetPath) && !shouldIgnore(path_1.default.basename(targetPath))) {
+                const content = fs_1.default.readFileSync(targetPath, 'utf-8');
+                gatheredContent.push(`\n--- FILE: ${targetPath} ---\n${content}`);
+            }
+        }
+    }
+    catch (error) {
+        // Ignore unreadable files
+    }
+}
+/**
+ * Loads context from provided file or directory paths.
+ * Truncates if it exceeds the limit.
+ */
+function loadFileContext(paths) {
+    const contentChunks = [];
+    for (const p of paths) {
+        const absPath = path_1.default.resolve(p);
+        if (fs_1.default.existsSync(absPath)) {
+            readPath(absPath, contentChunks);
+        }
+    }
+    const fullContent = contentChunks.join('\n');
+    if (fullContent.length > config_1.CONFIG.MAX_CONTEXT_CHARS) {
+        return fullContent.substring(0, config_1.CONFIG.MAX_CONTEXT_CHARS) + '\n...[Context Truncated]...';
+    }
+    return fullContent;
+}

package/dist/context/projectContext.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectContext = getProjectContext;
+exports.formatProjectContext = formatProjectContext;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const gitTool_1 = require("../tools/gitTool");
+function getDirectoryStructure(dir, depth = 0, maxDepth = 2) {
+    if (depth > maxDepth)
+        return '';
+    try {
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        const lines = [];
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'dist')
+                continue;
+            const indent = '  '.repeat(depth);
+            if (entry.isDirectory()) {
+                lines.push(`${indent}📂 ${entry.name}/`);
+                lines.push(getDirectoryStructure(path_1.default.join(dir, entry.name), depth + 1, maxDepth));
+            }
+            else {
+                // Only show key files at top level or if small
+                if (depth === 0 || ['.json', '.md', '.ts', '.js'].includes(path_1.default.extname(entry.name))) {
+                    lines.push(`${indent}📄 ${entry.name}`);
+                }
+            }
+        }
+        return lines.join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+function getProjectContext(cwd = process.cwd()) {
+    const summary = {
+        name: path_1.default.basename(cwd),
+        isGit: (0, gitTool_1.isGitRepo)(cwd),
+        gitStatus: 'N/A',
+        structure: getDirectoryStructure(cwd),
+    };
+    if (summary.isGit) {
+        summary.gitStatus = (0, gitTool_1.getGitStatus)(cwd);
+    }
+    const pkgPath = path_1.default.join(cwd, 'package.json');
+    if (fs_1.default.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+            summary.packageJson = {
+                name: pkg.name,
+                version: pkg.version,
+                scripts: pkg.scripts,
+                dependencies: pkg.dependencies ? Object.keys(pkg.dependencies) : [],
+            };
+        }
+        catch { }
+    }
+    const readmePath = path_1.default.join(cwd, 'README.md');
+    if (fs_1.default.existsSync(readmePath)) {
+        const content = fs_1.default.readFileSync(readmePath, 'utf-8');
+        summary.readmePreview = content.substring(0, 500).replace(/\n/g, ' ') + '...';
+    }
+    return summary;
+}
+function formatProjectContext(ctx) {
+    return `
+PROJECT CONTEXT:
+- Name: ${ctx.name}
+- Git: ${ctx.isGit ? 'Yes' : 'No'}
+- Git Status: ${ctx.gitStatus ? ctx.gitStatus.substring(0, 100).replace(/\n/g, ', ') : 'Clean'}
+- Structure:
+${ctx.structure}
+- Package: ${ctx.packageJson ? JSON.stringify(ctx.packageJson, null, 2) : 'N/A'}
+- Readme: ${ctx.readmePreview || 'N/A'}
+    `.trim();
+}

package/dist/core/agentRunner.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentRunner = agentRunner;
+const providerFactory_1 = require("../llm/providerFactory");
+const index_1 = require("../agents/index");
+const memoryStore_1 = require("../memory/memoryStore");
+const fileContext_1 = require("../context/fileContext");
+const intentRouter_1 = require("./intentRouter");
+const toolRegistry_1 = require("../tools/toolRegistry");
+const semanticStore_1 = require("../memory/semanticStore");
+const projectContext_1 = require("../context/projectContext");
+/**
+ * Main orchestration layer for LOKI.
+ */
+async function agentRunner(userMessage, options = {}) {
+    // --- 0. FAST INTENT ROUTING ---
+    const intent = await (0, intentRouter_1.routeIntent)(userMessage);
+    if (intent.handled) {
+        return intent.result || "Done.";
+    }
+    if (options.signal?.aborted)
+        throw new Error('Aborted');
+    // --- 1. PREPARE CONTEXT ---
+    const projectCtx = (0, projectContext_1.getProjectContext)();
+    const projectBlock = `\n=== PROJECT CONTEXT ===\n${(0, projectContext_1.formatProjectContext)(projectCtx)}\n=======================\n`;
+    let semanticBlock = '';
+    if (options.useSemantic !== false) {
+        const memories = await (0, semanticStore_1.retrieveRelevantMemory)(userMessage);
+        if (memories.length > 0) {
+            semanticBlock = `\n=== RELEVANT MEMORIES ===\n${memories.join('\n')}\n=========================\n`;
+        }
+    }
+    let historyBlock = '';
+    if (options.useMemory !== false) {
+        const history = (0, memoryStore_1.loadMemory)();
+        if (history.length > 0) {
+            const h = history.map(getItem => `${getItem.role.toUpperCase()}: ${getItem.content}`).join('\n');
+            historyBlock = `\n=== CONVERSATION HISTORY ===\n${h}\n============================\n`;
+        }
+    }
+    let fileBlock = '';
+    if (options.fileContextPaths && options.fileContextPaths.length > 0) {
+        const fileContent = (0, fileContext_1.loadFileContext)(options.fileContextPaths);
+        if (fileContent) {
+            fileBlock = `\n=== FILE CONTEXT ===\n${fileContent}\n====================\n`;
+        }
+    }
+    // --- 2. BUILD PROMPT ---
+    const systemPrompt = (0, index_1.getSystemPrompt)(options.agent);
+    let fullPrompt;
+    if (options.isChat) {
+        // Chat mode (WhatsApp) - cleaner, conversational responses
+        const chatSystemPrompt = `You are LOKI, a friendly AI assistant chatting on WhatsApp.
+
+CRITICAL RULES:
+1. NEVER output JSON, code blocks (\`\`\`), or any programming syntax
+2. NEVER mention "tools", "commands", or technical implementation details
+3. Respond in plain, natural language only
+4. Be conversational, friendly, and concise
+5. Keep responses under 300 characters
+6. If asked about files/folders/system tasks, explain you can only help with those in the full CLI version
+7. For chat, focus on conversation, advice, information, and friendly assistance
+
+Remember: You are chatting casually. No technical output allowed.`;
+        fullPrompt = `${chatSystemPrompt}
+
+User: ${userMessage}
+Assistant:`;
+    }
+    else {
+        // Full mode (CLI) - with tools and project context
+        // System Context - Real user info
+        const os = require('os');
+        const systemContext = `
+=== SYSTEM CONTEXT ===
+User: ${os.userInfo().username}
+Home Directory: ${os.homedir()}
+Desktop Path: ${os.homedir()}/Desktop
+Current Working Directory: ${process.cwd()}
+OS: ${os.platform()}
+======================
+`;
+        const toolsBlock = `
+=== AVAILABLE TOOLS ===
+You can use tools by outputting a JSON block:
+\`\`\`json
+{ "tool": "tool_name", "args": { ... } }
+\`\`\`
+${(0, toolRegistry_1.getToolSchemas)()}
+=======================
+If you use a tool, output ONLY the JSON block first. I will give you the result.
+Then you can answer the user.
+        `;
+        fullPrompt = `
+${systemPrompt}
+
+${systemContext}
+${projectBlock}
+${semanticBlock}
+${fileBlock}
+${toolsBlock}
+${historyBlock}
+
+User: ${userMessage}
+Assistant:`;
+    }
+    // --- 3. EXECUTE ---
+    if (options.signal?.aborted)
+        throw new Error('Aborted');
+    const provider = (0, providerFactory_1.getProvider)(options.provider);
+    // Initial pass (Non-streaming to catch JSON better, or standard)
+    // We use generated promise wrapper to allow abort
+    let initialResponse = await provider.generate(fullPrompt, undefined, options.signal);
+    // Check for JSON tool call
+    const toolRegex = /```json\s*(\{.*"tool":.*\})\s*```/s;
+    const match = initialResponse.match(toolRegex);
+    if (match) {
+        try {
+            const toolCall = JSON.parse(match[1]);
+            if (options.onToken)
+                options.onToken(`[Executing ${toolCall.tool}...] `);
+            const toolResult = await (0, toolRegistry_1.executeToolCall)(toolCall.tool, toolCall.args);
+            fullPrompt += `\n${initialResponse}\n\nTool Output: ${toolResult}\n\nAssistant (Interpreting result):`;
+            // Final Response
+            if (options.stream && provider.streamGenerate && options.onToken) {
+                const final = await provider.streamGenerate(fullPrompt, options.onToken, options.signal);
+                await saveInteraction(userMessage, final, options);
+                return final.trim();
+            }
+            else {
+                const final = await provider.generate(fullPrompt, undefined, options.signal);
+                await saveInteraction(userMessage, final, options);
+                return final.trim();
+            }
+        }
+        catch (e) {
+            // failed tool parse
+        }
+    }
+    // Pass through initial response if no tool
+    if (options.stream && options.onToken) {
+        options.onToken(initialResponse);
+    }
+    await saveInteraction(userMessage, initialResponse, options);
+    return initialResponse.trim();
+}
+async function saveInteraction(user, assistant, options) {
+    if (options.useMemory !== false) {
+        const timestamp = new Date().toISOString();
+        (0, memoryStore_1.appendMemory)({ timestamp, role: 'user', content: user });
+        (0, memoryStore_1.appendMemory)({ timestamp, role: 'assistant', content: assistant });
+    }
+    if (options.useSemantic !== false) {
+        await (0, semanticStore_1.storeSemanticMemory)(user, 'chat');
+    }
+}

package/dist/core/intentRouter.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeIntent = routeIntent;
+const timeTool_1 = require("../tools/timeTool");
+const mathTool_1 = require("../tools/mathTool");
+const fsTool_1 = require("../tools/fsTool");
+/**
+ * Central routing logic.
+ * Decides if a query can be answered locally by a tool or needs the LLM.
+ */
+async function routeIntent(message) {
+    const cleanMsg = message.trim();
+    const lowerMsg = cleanMsg.toLowerCase();
+    // --- 1. TIME & DATE ---
+    if (lowerMsg.includes('time') && (lowerMsg.includes('what') || lowerMsg.includes('current') || lowerMsg.includes('now') || lowerMsg.includes('in'))) {
+        // Simple extraction of "in <location>"
+        const match = lowerMsg.match(/in\s+([a-zA-Z]+)/);
+        const timezone = match ? match[1] : undefined;
+        return { handled: true, result: `It's ${(0, timeTool_1.getCurrentTime)(timezone)}` };
+    }
+    if (lowerMsg.includes('date') && (lowerMsg.includes('what') || lowerMsg.includes('current') || lowerMsg.includes('today'))) {
+        const match = lowerMsg.match(/in\s+([a-zA-Z]+)/);
+        const timezone = match ? match[1] : undefined;
+        return { handled: true, result: `Today is ${(0, timeTool_1.getCurrentDate)(timezone)}` };
+    }
+    // --- 2. FILE SYSTEM ---
+    if (lowerMsg.startsWith('list files') || lowerMsg.startsWith('ls ') || lowerMsg.startsWith('show files')) {
+        // extract path
+        // e.g. "list files in src" -> "src"
+        // heuristic: last word or specific "in <path>"
+        let targetPath = '.';
+        if (lowerMsg.includes(' in ')) {
+            targetPath = cleanMsg.split(' in ')[1];
+        }
+        else if (lowerMsg.startsWith('ls ')) {
+            targetPath = cleanMsg.substring(3).trim();
+            if (!targetPath)
+                targetPath = '.';
+        }
+        const files = (0, fsTool_1.listFiles)(targetPath);
+        return { handled: true, result: files.join(', ') };
+    }
+    if ((lowerMsg.startsWith('read ') || lowerMsg.startsWith('cat ')) && !lowerMsg.includes('what')) {
+        let targetFile = '';
+        if (lowerMsg.startsWith('read '))
+            targetFile = cleanMsg.substring(5).trim();
+        else if (lowerMsg.startsWith('cat '))
+            targetFile = cleanMsg.substring(4).trim();
+        return { handled: true, result: (0, fsTool_1.readFile)(targetFile) };
+    }
+    // --- 3. MATH ---
+    // If it looks like a math expression and NOT natural language
+    if ((0, mathTool_1.isMathExpression)(cleanMsg)) {
+        return { handled: true, result: (0, mathTool_1.evaluateMath)(cleanMsg) };
+    }
+    // Default: Not handled by tools
+    return { handled: false };
+}

package/dist/index.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chat_1 = require("./cli/chat");
+const doctor_1 = require("./cli/doctor");
+const refactorEngine_1 = require("./refactor/refactorEngine");
+const indexer_1 = require("./rag/indexer");
+const config_1 = require("./utils/config");
+const chalk_1 = __importDefault(require("chalk"));
+const program = new commander_1.Command();
+const ASCII_ART = `
+██╗      ██████╗ ██╗  ██╗██╗
+██║     ██╔═══██╗██║ ██╔╝██║
+██║     ██║   ██║█████╔╝ ██║
+██║     ██║   ██║██╔═██╗ ██║
+███████╗╚██████╔╝██║  ██╗██║
+╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚═╝
+`;
+program
+    .name('loki')
+    .description(`${chalk_1.default.green.bold(ASCII_ART)}\nLocal-first AI developer platform.`)
+    .version(config_1.CONFIG.VERSION);
+program
+    .command('chat [message]')
+    .description('Chat with LOKI.')
+    .option('-p, --provider <name>', 'model provider: ollama or groq', 'ollama')
+    .option('-a, --agent <name>', 'agent persona: dev, explain, refactor', 'dev')
+    .option('--no-memory', 'disable persistent memory')
+    .option('--no-stream', 'disable streaming output')
+    .option('-f, --file <path>', 'add a single file to context')
+    .option('-d, --dir <path>', 'add a directory files to context')
+    .action(async (message, options) => {
+    await (0, chat_1.chatCommand)(message, options);
+});
+program
+    .command('doctor')
+    .description('System health check.')
+    .action(async () => {
+    await (0, doctor_1.doctorCommand)();
+});
+program
+    .command('workflow <instruction>')
+    .description('Run a multi-agent workflow (e.g. refactor).')
+    .action(async (instruction) => {
+    await (0, refactorEngine_1.engineCommand)(instruction);
+});
+program
+    .command('index')
+    .description('Index current repository for RAG.')
+    .action(async () => {
+    await (0, indexer_1.indexRepository)();
+});
+program
+    .command('server')
+    .description('Start the WhatsApp webhook server.')
+    .action(async () => {
+    // Lazy load to avoid require cost if not used
+    const { startWhatsAppClient } = require('./interfaces/whatsapp/client');
+    await startWhatsAppClient();
+});
+// Check if any command was provided
+if (process.argv.length <= 2) {
+    // No args passed. Launch TUI.
+    // Need to import dynamically or at top. 
+    // We can just rely on the import we will add.
+    const { startLoop } = require('./cli/tui');
+    startLoop();
+}
+else {
+    program.parse(process.argv);
+}

package/dist/interfaces/whatsapp/client.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWhatsAppClient = startWhatsAppClient;
+const baileys_1 = __importStar(require("@whiskeysockets/baileys"));
+const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
+const config_1 = require("../../utils/config");
+const agentRunner_1 = require("../../core/agentRunner");
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const pino_1 = __importDefault(require("pino"));
+const authDir = path_1.default.join(config_1.CONFIG.CONFIG_DIR, 'whatsapp_baileys_auth');
+async function startWhatsAppClient() {
+    console.log(chalk_1.default.blue.bold('📱 LOKI WhatsApp Client'));
+    console.log(chalk_1.default.gray('Connecting...\n'));
+    // Ensure auth directory exists
+    if (!fs_1.default.existsSync(authDir)) {
+        fs_1.default.mkdirSync(authDir, { recursive: true });
+    }
+    const { state, saveCreds } = await (0, baileys_1.useMultiFileAuthState)(authDir);
+    // Silent logger to reduce noise
+    const logger = (0, pino_1.default)({ level: 'silent' });
+    const sock = (0, baileys_1.default)({
+        auth: state,
+        browser: ['LOKI', 'Desktop', '1.0.0'],
+        logger: logger
+    });
+    // Save credentials on update
+    sock.ev.on('creds.update', saveCreds);
+    // Connection updates
+    sock.ev.on('connection.update', (update) => {
+        const { connection, lastDisconnect, qr } = update;
+        // Display QR code manually
+        if (qr) {
+            console.log(chalk_1.default.yellow('\n📷 Scan this QR code with WhatsApp:\n'));
+            qrcode_terminal_1.default.generate(qr, { small: true });
+        }
+        if (connection === 'close') {
+            const statusCode = lastDisconnect?.error?.output?.statusCode;
+            const shouldReconnect = statusCode !== baileys_1.DisconnectReason.loggedOut;
+            console.log(chalk_1.default.red('Connection closed.'));
+            if (shouldReconnect) {
+                console.log(chalk_1.default.yellow('Reconnecting...'));
+                startWhatsAppClient();
+            }
+            else {
+                console.log(chalk_1.default.red('Logged out. Delete ~/.loki/whatsapp_baileys_auth to re-link.'));
+            }
+        }
+        else if (connection === 'open') {
+            console.log(chalk_1.default.green.bold('\n✅ LOKI WhatsApp Client Connected!'));
+            console.log(chalk_1.default.cyan('Listening for messages. Send /ping to test.\n'));
+        }
+    });
+    // Message handler
+    sock.ev.on('messages.upsert', async (m) => {
+        const msg = m.messages[0];
+        if (!msg)
+            return;
+        // Skip if no message content
+        if (!msg.message)
+            return;
+        // Skip status broadcasts
+        if (msg.key.remoteJid === 'status@broadcast')
+            return;
+        // Get message text
+        const text = msg.message.conversation ||
+            msg.message.extendedTextMessage?.text ||
+            '';
+        if (!text.trim())
+            return;
+        const fromMe = msg.key.fromMe || false;
+        const sender = msg.key.remoteJid || '';
+        // Check if this is a self-chat (messaging yourself)
+        const isSelfChat = sender.includes('@lid') || sender === msg.key.participant;
+        console.log(chalk_1.default.magenta(`[MSG] ${sender}: "${text}" (fromMe: ${fromMe}, selfChat: ${isSelfChat})`));
+        // CRITICAL: Only respond to incoming messages OR self-chat
+        if (fromMe && !isSelfChat) {
+            console.log(chalk_1.default.gray('  [Skipped - outgoing message to someone else]'));
+            return;
+        }
+        // Skip LOKI's own responses (double safety)
+        if (text.startsWith('🧠') || text.startsWith('🏓') || text.startsWith('⚠️')) {
+            return;
+        }
+        const cmd = text.trim().toLowerCase();
+        // Command: /ping
+        if (cmd === '/ping') {
+            console.log(chalk_1.default.yellow('→ Processing /ping'));
+            await sock.sendMessage(sender, { text: '🏓 Pong! LOKI is online.' });
+            console.log(chalk_1.default.green('✓ Sent pong'));
+            return;
+        }
+        // Command: /help
+        if (cmd === '/help') {
+            await sock.sendMessage(sender, {
+                text: `🧠 *LOKI Help*\n• Ask anything in natural language\n• /ping - Check if online\n• /help - Show this help`
+            });
+            console.log(chalk_1.default.green('✓ Sent help'));
+            return;
+        }
+        // AI Processing for ALL messages (including self for testing)
+        console.log(chalk_1.default.yellow('→ Processing with LOKI AI...'));
+        // Show "typing..." indicator to user
+        try {
+            await sock.presenceSubscribe(sender);
+            await sock.sendPresenceUpdate('composing', sender);
+            console.log(chalk_1.default.gray('  [typing indicator sent]'));
+        }
+        catch (e) {
+            console.log(chalk_1.default.gray('  [typing indicator failed]'));
+        }
+        try {
+            // Use FULL agent mode with tools enabled
+            const rawResponse = await (0, agentRunner_1.agentRunner)(text, {
+                useMemory: true,
+                stream: false,
+                isChat: false // Enable tools!
+            });
+            // Clean up response - remove code blocks and JSON artifacts
+            let cleanResponse = rawResponse
+                .replace(/```json[\s\S]*?```/g, '') // Remove JSON blocks
+                .replace(/```[\s\S]*?```/g, '') // Remove any code blocks
+                .replace(/\{[^{}]*"tool"[^{}]*\}/g, '') // Remove inline tool JSON
+                .replace(/\n{3,}/g, '\n\n') // Collapse multiple newlines
+                .trim();
+            // If response is empty after cleanup, provide fallback
+            if (!cleanResponse) {
+                cleanResponse = "I've processed your request. Is there anything else you'd like to know?";
+            }
+            // Stop typing indicator
+            try {
+                await sock.sendPresenceUpdate('paused', sender);
+            }
+            catch (e) { }
+            await sock.sendMessage(sender, { text: `🧠 ${cleanResponse}` });
+            console.log(chalk_1.default.green('✓ Sent AI response'));
+        }
+        catch (e) {
+            // Stop typing indicator on error too
+            try {
+                await sock.sendPresenceUpdate('paused', sender);
+            }
+            catch (err) { }
+            console.error(chalk_1.default.red('AI Error:'), e.message);
+            await sock.sendMessage(sender, { text: `⚠️ Error: ${e.message}` });
+        }
+    });
+}

package/dist/langchain/llmAdapter.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LokiChatModel = void 0;
+const chat_models_1 = require("@langchain/core/language_models/chat_models");
+const providerFactory_1 = require("../llm/providerFactory");
+const config_1 = require("../utils/config");
+class LokiChatModel extends chat_models_1.SimpleChatModel {
+    constructor(fields) {
+        super({});
+        this.providerName = fields?.providerName || config_1.CONFIG.DEFAULT_PROVIDER;
+        this.provider = (0, providerFactory_1.getProvider)(this.providerName);
+    }
+    _llmType() {
+        return 'loki_chat_model';
+    }
+    async _call(messages, options, runManager) {
+        const prompt = this.messagesToPrompt(messages);
+        if (this.provider.streamGenerate) {
+            // If provider supports streaming, we should probably prefer _stream 
+            // but SimpleChatModel logic separates them.
+            // However, if we are just calling generates, we can assume non-stream here 
+            // or we can consume the stream and concatenate.
+            // Let's just use generate for _call.
+        }
+        // We pass an abort signal if runManager has one? 
+        // runManager doesn't expose signal directly usually, but it's in options usually.
+        // For MVP, simple call.
+        return await this.provider.generate(prompt);
+    }
+    // Helper to convert LangChain messages to a single string prompt
+    // Since our providers currently expect a string string (Mistral style usually).
+    messagesToPrompt(messages) {
+        return messages.map(m => {
+            if (m._getType() === 'system')
+                return `System: ${m.content}\n`;
+            if (m._getType() === 'human')
+                return `User: ${m.content}\n`;
+            if (m._getType() === 'ai')
+                return `Assistant: ${m.content}\n`;
+            return `${m.content}\n`;
+        }).join('\n') + "\nAssistant:";
+    }
+}
+exports.LokiChatModel = LokiChatModel;