@react-frameui/loki-ai 1.0.0

package/dist/tools/fsTool.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFiles = listFiles;
+exports.readFile = readFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * File system tool for read-only access.
+ */
+// Safety blocks
+const IGNORED_DIRS = ['node_modules', '.git', 'dist', 'out', '.idea', '.vscode'];
+const BINARY_EXTS = ['.png', '.jpg', '.jpeg', '.exe', '.bin', '.dll', '.so', '.dylib', '.zip', '.tar', '.gz'];
+// Helper to determine safety
+function isSafePath(targetPath) {
+    // Resolve absolute path
+    const resolved = path_1.default.resolve(targetPath);
+    // Basic check: must ensure we don't go outside legitimate boundaries?
+    // For a local assistant, user has full access, but we should block sensitive dirs if possible.
+    // For now, we trust the local user but block binary/junk folders.
+    return true;
+}
+function listFiles(targetPath = '.') {
+    try {
+        if (!fs_1.default.existsSync(targetPath))
+            return ["Path does not exist."];
+        const stats = fs_1.default.statSync(targetPath);
+        if (!stats.isDirectory())
+            return ["Path is not a directory."];
+        const entries = fs_1.default.readdirSync(targetPath);
+        // Filter ignored
+        const filtered = entries.filter(e => !IGNORED_DIRS.includes(e));
+        // Sort: directories first, then files
+        const dirs = filtered.filter(e => fs_1.default.statSync(path_1.default.join(targetPath, e)).isDirectory());
+        const files = filtered.filter(e => !fs_1.default.statSync(path_1.default.join(targetPath, e)).isDirectory());
+        return [...dirs.map(d => `${d}/`), ...files];
+    }
+    catch (e) {
+        return [`Error listing files: ${e.message}`];
+    }
+}
+function readFile(targetPath) {
+    try {
+        if (!fs_1.default.existsSync(targetPath))
+            return "File does not exist.";
+        const stats = fs_1.default.statSync(targetPath);
+        if (stats.isDirectory())
+            return "Target is a directory, not a file.";
+        const ext = path_1.default.extname(targetPath).toLowerCase();
+        if (BINARY_EXTS.includes(ext))
+            return "Binary file detected. Cannot read text content.";
+        return fs_1.default.readFileSync(targetPath, 'utf-8');
+    }
+    catch (e) {
+        return `Error reading file: ${e.message}`;
+    }
+}

package/dist/tools/gitTool.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGitRepo = isGitRepo;
+exports.getGitStatus = getGitStatus;
+exports.getRecentLog = getRecentLog;
+exports.getDiff = getDiff;
+exports.getBranches = getBranches;
+const child_process_1 = require("child_process");
+function isGitRepo(cwd = process.cwd()) {
+    try {
+        (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', { cwd, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getGitStatus(cwd = process.cwd()) {
+    try {
+        return (0, child_process_1.execSync)('git status --short', { cwd, encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return 'Error getting git status';
+    }
+}
+function getRecentLog(cwd = process.cwd(), count = 5) {
+    try {
+        // oneline, graph, decorate
+        return (0, child_process_1.execSync)(`git log -n ${count} --pretty=format:"%h - %an, %ar : %s"`, { cwd, encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return 'Error getting git log';
+    }
+}
+function getDiff(cwd = process.cwd()) {
+    try {
+        // Limit diff size to prevent token explosion
+        const diff = (0, child_process_1.execSync)('git diff HEAD', { cwd, encoding: 'utf-8' });
+        if (diff.length > 2000)
+            return diff.substring(0, 2000) + '\n...[Diff Truncated]';
+        return diff || 'No changes.';
+    }
+    catch {
+        return 'Error getting diff';
+    }
+}
+function getBranches(cwd = process.cwd()) {
+    try {
+        return (0, child_process_1.execSync)('git branch', { cwd, encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return 'Error getting branches';
+    }
+}

package/dist/tools/mathTool.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Safe Math routing to evaluate simple expressions.
+ * Avoids eval().
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMathExpression = isMathExpression;
+exports.evaluateMath = evaluateMath;
+// Supported operators
+const OPERATORS = ['+', '-', '*', '/', '%', '(', ')'];
+function isMathExpression(input) {
+    // Basic heuristic: check if input contains digits and operators
+    // and DOES NOT contain letters (except for specific math keywords like 'sqrt' or 'pi' handled later)
+    // For specific keywords like sqrt, we need a robust check.
+    const trimmed = input.replace(/\s+/g, '').toLowerCase();
+    // Must have at least one digit
+    if (!/\d/.test(trimmed))
+        return false;
+    // Check against allowed chars: digits, ., operators, parenthese
+    // also "sqrt", "pow", "abs" etc?
+    // Let's stick to simple arithmetic first + math functions if strict matching allows.
+    // Simplification: valid matching for our lightweight eval
+    // 1. Digits 0-9
+    // 2. Operators + - * / % ^
+    // 3. Parentheses ( )
+    // 4. "sqrt", "sin", "cos", "tan", "log", "pi"
+    const validPattern = /^[\d\.\+\-\*\/\%\(\)\s\^]|(sqrt|sin|cos|tan|log|pi|e)+$/;
+    // If ANY character is NOT in our allowlist, it's not math.
+    // We check each char (or word structure).
+    // Actually, simpler approach:
+    // Remove known functions and constants
+    let checkStr = trimmed
+        .replace(/sqrt|sin|cos|tan|log|pi|e/g, '')
+        .replace(/[\d\.\+\-\*\/\%\(\)\^]/g, '');
+    return checkStr.length === 0;
+}
+function evaluateMath(expression) {
+    try {
+        // Sanitize
+        // we use Function constructor as a safer eval replacement FOR MATH ONLY
+        // after strict validation.
+        // Replace 'sqrt' with 'Math.sqrt', etc.
+        let sanitized = expression.toLowerCase()
+            .replace(/\^/g, '**') // Power operator
+            .replace(/sqrt/g, 'Math.sqrt')
+            .replace(/sin/g, 'Math.sin')
+            .replace(/cos/g, 'Math.cos')
+            .replace(/tan/g, 'Math.tan')
+            .replace(/log/g, 'Math.log')
+            .replace(/\bpi\b/g, 'Math.PI')
+            .replace(/\be\b/g, 'Math.E');
+        // Validation again to ensure NO malicious code slipped in
+        // e.g. "Math.sqrt(alert(1))" -> contains letters not in Math.*
+        // Our isMathExpression check should have caught generic letters.
+        // But let's be super safe:
+        // Attempt execution in a sandbox-like scope (Function)
+        // Note: Function(string) is still eval-like but restricted to global scope interaction.
+        // Given we pre-validated, it reduces risk significantly.
+        const f = new Function(`return (${sanitized})`);
+        const result = f();
+        if (typeof result === 'number' && !isNaN(result) && isFinite(result)) {
+            // Round to reasonable decimals if float
+            return parseFloat(result.toFixed(4)).toString();
+        }
+        return "Invalid math result";
+    }
+    catch (e) {
+        return "Error evaluating expression";
+    }
+}

package/dist/tools/timeTool.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Handles time and date queries with timezone support.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentTime = getCurrentTime;
+exports.getCurrentDate = getCurrentDate;
+// Mapping of common timezone aliases to IANA identifiers
+const TIMEZONE_MAP = {
+    'utc': 'UTC',
+    'gmt': 'GMT',
+    'ist': 'Asia/Kolkata',
+    'pst': 'America/Los_Angeles',
+    'est': 'America/New_York',
+    'pdt': 'America/Los_Angeles', // Daylight
+    'edt': 'America/New_York', // Daylight
+    'cet': 'Europe/Paris',
+    'bst': 'Europe/London',
+    'ny': 'America/New_York',
+    'india': 'Asia/Kolkata',
+    'london': 'Europe/London'
+};
+function resolveTimezone(tz) {
+    if (!tz)
+        return undefined;
+    const normalized = tz.toLowerCase().trim();
+    if (TIMEZONE_MAP[normalized]) {
+        return TIMEZONE_MAP[normalized];
+    }
+    // Attempt use directly if valid IANA (e.g. Asia/Tokyo)
+    try {
+        Intl.DateTimeFormat(undefined, { timeZone: tz });
+        return tz;
+    }
+    catch (e) {
+        return undefined; // Fallback to system
+    }
+}
+function getCurrentTime(timezone) {
+    const tz = resolveTimezone(timezone);
+    const now = new Date();
+    try {
+        const timeString = now.toLocaleTimeString('en-US', {
+            hour: '2-digit',
+            minute: '2-digit',
+            timeZone: tz,
+            timeZoneName: 'short'
+        });
+        return timeString;
+    }
+    catch {
+        return "Invalid timezone specified.";
+    }
+}
+function getCurrentDate(timezone) {
+    const tz = resolveTimezone(timezone);
+    const now = new Date();
+    try {
+        const dateString = now.toLocaleDateString('en-US', {
+            weekday: 'long',
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+            timeZone: tz
+        });
+        return dateString;
+    }
+    catch {
+        return "Invalid timezone specified.";
+    }
+}

package/dist/tools/toolRegistry.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOLS = void 0;
+exports.getToolSchemas = getToolSchemas;
+exports.executeToolCall = executeToolCall;
+const timeTool_1 = require("./timeTool");
+const mathTool_1 = require("./mathTool");
+const fsTool_1 = require("./fsTool");
+const gitTool_1 = require("./gitTool");
+const projectContext_1 = require("../context/projectContext");
+exports.TOOLS = {
+    get_time: {
+        name: 'get_time',
+        description: 'Get current time. Args: timezone (optional)',
+        parameters: '{ timezone?: string }',
+        execute: (args) => (0, timeTool_1.getCurrentTime)(args?.timezone)
+    },
+    get_date: {
+        name: 'get_date',
+        description: 'Get current date. Args: timezone (optional)',
+        parameters: '{ timezone?: string }',
+        execute: (args) => (0, timeTool_1.getCurrentDate)(args?.timezone)
+    },
+    calculate: {
+        name: 'calculate',
+        description: 'Evaluate math expression.',
+        parameters: '{ expression: string }',
+        execute: (args) => (0, mathTool_1.evaluateMath)(args.expression)
+    },
+    list_files: {
+        name: 'list_files',
+        description: 'List files in a directory.',
+        parameters: '{ path?: string }',
+        execute: (args) => (0, fsTool_1.listFiles)(args?.path || '.').join(', ')
+    },
+    read_file: {
+        name: 'read_file',
+        description: 'Read file content.',
+        parameters: '{ path: string }',
+        execute: (args) => (0, fsTool_1.readFile)(args.path)
+    },
+    git_status: {
+        name: 'git_status',
+        description: 'Get git status summary.',
+        parameters: '{}',
+        execute: () => (0, gitTool_1.getGitStatus)()
+    },
+    git_log: {
+        name: 'git_log',
+        description: 'Get recent git commits.',
+        parameters: '{ count?: number }',
+        execute: (args) => (0, gitTool_1.getRecentLog)(undefined, args?.count)
+    },
+    git_diff: {
+        name: 'git_diff',
+        description: 'Get git diff.',
+        parameters: '{}',
+        execute: () => (0, gitTool_1.getDiff)()
+    },
+    project_context: {
+        name: 'project_context',
+        description: 'Get full project overview.',
+        parameters: '{}',
+        execute: () => (0, projectContext_1.formatProjectContext)((0, projectContext_1.getProjectContext)())
+    }
+};
+function getToolSchemas() {
+    return Object.values(exports.TOOLS).map(t => `- Tool: ${t.name}\n  Desc: ${t.description}\n  Params: ${t.parameters}`).join('\n\n');
+}
+async function executeToolCall(toolName, args) {
+    const tool = exports.TOOLS[toolName];
+    if (!tool)
+        return `Error: Tool ${toolName} not found.`;
+    try {
+        return await tool.execute(args);
+    }
+    catch (e) {
+        return `Error executing ${toolName}: ${e.message}`;
+    }
+}

package/dist/utils/config.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+// Load environment variables
+dotenv_1.default.config();
+const HOME_DIR = os_1.default.homedir();
+const CONFIG_DIR = path_1.default.join(HOME_DIR, '.loki');
+exports.CONFIG = {
+    // App Info
+    APP_NAME: 'Loki',
+    VERSION: '1.2.0',
+    CONFIG_DIR,
+    MEMORY_FILE: path_1.default.join(CONFIG_DIR, 'memory.json'),
+    SEMANTIC_MEMORY_DIR: path_1.default.join(CONFIG_DIR, 'semantic-memory'),
+    SEMANTIC_INDEX_FILE: path_1.default.join(CONFIG_DIR, 'semantic-memory', 'index.json'),
+    // LLM Defaults
+    DEFAULT_PROVIDER: 'ollama',
+    // Ollama
+    OLLAMA_HOST: process.env.OLLAMA_HOST || 'http://localhost:11434',
+    OLLAMA_MODEL: process.env.OLLAMA_MODEL || 'mistral:7b',
+    OLLAMA_EMBED_MODEL: process.env.OLLAMA_EMBED_MODEL || 'nomic-embed-text',
+    // Groq
+    GROQ_API_KEY: process.env.GROQ_API_KEY,
+    GROQ_MODEL: 'llama-3.1-8b-instant',
+    GROQ_API_URL: 'https://api.groq.com/openai/v1/chat/completions',
+    // Limits
+    MAX_MEMORY_ITEMS: 20,
+    MAX_SEMANTIC_RESULTS: 5,
+    MAX_CONTEXT_CHARS: 6000,
+    TIMEOUT: 60000,
+    // Feature Flags (Optional Engines)
+    USE_LANGCHAIN: process.env.USE_LANGCHAIN === 'true',
+    USE_LANGGRAPH: process.env.USE_LANGGRAPH === 'true',
+    // WhatsApp
+    WHATSAPP_TOKEN: process.env.WHATSAPP_TOKEN,
+    WHATSAPP_PHONE_NUMBER_ID: process.env.WHATSAPP_PHONE_NUMBER_ID,
+    WHATSAPP_VERIFY_TOKEN: process.env.WHATSAPP_VERIFY_TOKEN || 'loki_secure_verify',
+    WHATSAPP_PORT: parseInt(process.env.WHATSAPP_PORT || '3000'),
+};

package/dist/utils/spinner.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Spinner = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+class Spinner {
+    constructor(text = '') {
+        this.text = text;
+        this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        this.interval = null;
+        this.current = 0;
+        this.isSpinning = false;
+    }
+    start() {
+        if (this.isSpinning)
+            return;
+        this.isSpinning = true;
+        process.stdout.write('\x1B[?25l'); // Hide cursor
+        this.interval = setInterval(() => {
+            // Clear line from cursor position to end (simplified: just backspace and rewrite)
+            // We assume we are appending to the current line.
+            // To properly "animate" without destroying previous text on the line (like the prefix),
+            // we essentially print the frame, then backspace.
+            const frame = chalk_1.default.gray(this.frames[this.current]);
+            process.stdout.write(frame);
+            process.stdout.write(`\b`); // Move back 1 char (assuming frame is 1 char)
+            // Note: Braille chars are usually 1 column in terminals.
+            this.current = (this.current + 1) % this.frames.length;
+        }, 80);
+    }
+    stop() {
+        if (!this.isSpinning)
+            return;
+        if (this.interval)
+            clearInterval(this.interval);
+        this.isSpinning = false;
+        // Clear the spinner character
+        process.stdout.write(' '); // overwrite with space
+        process.stdout.write('\b'); // back to position
+        process.stdout.write('\x1B[?25h'); // Show cursor
+    }
+}
+exports.Spinner = Spinner;

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@react-frameui/loki-ai",
+  "version": "1.0.0",
+  "description": "LOKI - Local Omni Knowledge Interface. A powerful CLI AI assistant with tools, memory, WhatsApp integration, and more.",
+  "keywords": [
+    "ai",
+    "assistant",
+    "cli",
+    "chatbot",
+    "ollama",
+    "langchain",
+    "whatsapp",
+    "local-ai",
+    "tui",
+    "terminal"
+  ],
+  "homepage": "https://github.com/IamNishant51/LOKI#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/IamNishant51/LOKI.git"
+  },
+  "bugs": {
+    "url": "https://github.com/IamNishant51/LOKI/issues"
+  },
+  "bin": {
+    "loki": "./dist/index.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "ts-node src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "author": "Nishant <iamnishant51@github.com>",
+  "license": "MIT",
+  "dependencies": {
+    "@langchain/community": "^1.1.9",
+    "@langchain/core": "^1.1.17",
+    "@langchain/langgraph": "^1.1.2",
+    "@types/node": "^25.1.0",
+    "@whiskeysockets/baileys": "^7.0.0-rc.9",
+    "axios": "^1.13.4",
+    "body-parser": "^2.2.2",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.2",
+    "cors": "^2.8.6",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "langchain": "^1.2.15",
+    "pino": "^10.3.0",
+    "qrcode": "^1.5.4",
+    "qrcode-terminal": "^0.12.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
+    "whatsapp-web.js": "^1.34.4",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/body-parser": "^1.19.6",
+    "@types/express": "^5.0.6",
+    "@types/qrcode-terminal": "^0.12.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}