@react-frameui/loki-ai 1.0.0

package/dist/langchain/rag/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalRAG = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// @ts-ignore
+const ollama_1 = require("@langchain/community/embeddings/ollama");
+// @ts-ignore
+const memory_1 = require("langchain/vectorstores/memory");
+// @ts-ignore
+const text_splitter_1 = require("langchain/text_splitter");
+const config_1 = require("../../utils/config");
+class LocalRAG {
+    constructor() {
+        this.vectorStore = null;
+        // @ts-ignore
+        this.embeddings = new ollama_1.OllamaEmbeddings({
+            model: config_1.CONFIG.OLLAMA_EMBED_MODEL,
+            baseUrl: config_1.CONFIG.OLLAMA_HOST,
+        });
+    }
+    async indexRepo(cwd) {
+        console.log(`[LangChain RAG] Indexing ${cwd}...`);
+        const docs = this.loadDocuments(cwd);
+        // @ts-ignore
+        const splitter = new text_splitter_1.RecursiveCharacterTextSplitter({
+            chunkSize: 1000,
+            chunkOverlap: 200,
+        });
+        const chunks = await splitter.createDocuments(docs.map((d) => d.pageContent), docs.map((d) => d.metadata));
+        // @ts-ignore
+        this.vectorStore = await memory_1.MemoryVectorStore.fromDocuments(chunks, this.embeddings);
+        console.log(`[LangChain RAG] Indexed ${chunks.length} chunks.`);
+    }
+    async query(question, k = 4) {
+        if (!this.vectorStore)
+            return "RAG not initialized. Run index first.";
+        const results = await this.vectorStore.similaritySearch(question, k);
+        return results.map((r) => `[${r.metadata.source}]: ${r.pageContent}`).join('\n\n');
+    }
+    loadDocuments(dir, fileList = []) {
+        try {
+            const files = fs_1.default.readdirSync(dir, { withFileTypes: true });
+            const docs = [];
+            for (const file of files) {
+                if (file.isDirectory()) {
+                    if (['node_modules', '.git', 'dist', 'out'].includes(file.name))
+                        continue;
+                    docs.push(...this.loadDocuments(path_1.default.join(dir, file.name)));
+                }
+                else {
+                    if (['.ts', '.js', '.md', '.json'].includes(path_1.default.extname(file.name))) {
+                        const content = fs_1.default.readFileSync(path_1.default.join(dir, file.name), 'utf-8');
+                        docs.push({
+                            pageContent: content,
+                            metadata: { source: path_1.default.relative(process.cwd(), path_1.default.join(dir, file.name)) }
+                        });
+                    }
+                }
+            }
+            return docs;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.LocalRAG = LocalRAG;

package/dist/langchain/tools.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lokiTools = exports.gitStatusTool = exports.fsReadTool = exports.fsListTool = exports.mathTool = exports.dateTool = exports.timeTool = void 0;
+const tools_1 = require("@langchain/core/tools");
+const zod_1 = require("zod");
+const toolRegistry_1 = require("../tools/toolRegistry");
+// Helper to wrap LOKI tools
+// We verify parameters manually for now since LOKI tools behave predictably
+exports.timeTool = new tools_1.DynamicStructuredTool({
+    name: "get_time",
+    description: toolRegistry_1.TOOLS.get_time.description,
+    schema: zod_1.z.object({
+        timezone: zod_1.z.string().optional()
+    }),
+    func: async ({ timezone }) => {
+        return await toolRegistry_1.TOOLS.get_time.execute({ timezone });
+    }
+});
+exports.dateTool = new tools_1.DynamicStructuredTool({
+    name: "get_date",
+    description: toolRegistry_1.TOOLS.get_date.description,
+    schema: zod_1.z.object({
+        timezone: zod_1.z.string().optional()
+    }),
+    func: async ({ timezone }) => {
+        return await toolRegistry_1.TOOLS.get_date.execute({ timezone });
+    }
+});
+exports.mathTool = new tools_1.DynamicStructuredTool({
+    name: "calculate",
+    description: toolRegistry_1.TOOLS.calculate.description,
+    schema: zod_1.z.object({
+        expression: zod_1.z.string().describe("The math expression to evaluate")
+    }),
+    func: async ({ expression }) => {
+        return await toolRegistry_1.TOOLS.calculate.execute({ expression });
+    }
+});
+exports.fsListTool = new tools_1.DynamicStructuredTool({
+    name: "list_files",
+    description: toolRegistry_1.TOOLS.list_files.description,
+    schema: zod_1.z.object({
+        path: zod_1.z.string().optional().describe("Directory path to list")
+    }),
+    func: async ({ path }) => {
+        return await toolRegistry_1.TOOLS.list_files.execute({ path });
+    }
+});
+exports.fsReadTool = new tools_1.DynamicStructuredTool({
+    name: "read_file",
+    description: toolRegistry_1.TOOLS.read_file.description,
+    schema: zod_1.z.object({
+        path: zod_1.z.string().describe("File path to read")
+    }),
+    func: async ({ path }) => {
+        return await toolRegistry_1.TOOLS.read_file.execute({ path });
+    }
+});
+exports.gitStatusTool = new tools_1.DynamicStructuredTool({
+    name: "git_status",
+    description: toolRegistry_1.TOOLS.git_status.description,
+    schema: zod_1.z.object({}),
+    func: async () => {
+        return await toolRegistry_1.TOOLS.git_status.execute({});
+    }
+});
+exports.lokiTools = [
+    exports.timeTool,
+    exports.dateTool,
+    exports.mathTool,
+    exports.fsListTool,
+    exports.fsReadTool,
+    exports.gitStatusTool
+];

package/dist/langgraph/refactorGraph.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refactorGraph = void 0;
+const langgraph_1 = require("@langchain/langgraph");
+const messages_1 = require("@langchain/core/messages");
+const llmAdapter_1 = require("../langchain/llmAdapter");
+// Agents execution 
+async function plannerNode(state, config) {
+    const model = new llmAdapter_1.LokiChatModel();
+    const result = await model.invoke([
+        ...state.messages,
+        new messages_1.HumanMessage("Create a plan for this request.")
+    ]);
+    return { plan: result.content, messages: [result] };
+}
+async function analyzerNode(state) {
+    const model = new llmAdapter_1.LokiChatModel();
+    const result = await model.invoke([
+        new messages_1.HumanMessage(`Analyze the plan: ${state.plan}`)
+    ]);
+    return { analysis: result.content };
+}
+async function refactorNode(state) {
+    const model = new llmAdapter_1.LokiChatModel();
+    const result = await model.invoke([
+        new messages_1.HumanMessage(`Generate code for plan: ${state.plan}. Analysis: ${state.analysis}`)
+    ]);
+    return { code: result.content };
+}
+// Build Graph
+const builder = new langgraph_1.StateGraph({
+    channels: {
+        messages: { reducer: (a, b) => a.concat(b) },
+        plan: null,
+        analysis: null,
+        code: null,
+        approved: null
+    }
+});
+// Register nodes
+builder.addNode("planner", plannerNode);
+builder.addNode("analyzer", analyzerNode);
+builder.addNode("refactor", refactorNode);
+// Define edges with strict casts to bypass TS checking "Start" node logic
+builder.addEdge("planner", "analyzer");
+builder.addEdge("analyzer", "refactor");
+builder.addEdge("refactor", langgraph_1.END);
+builder.setEntryPoint("planner");
+exports.refactorGraph = builder.compile();

package/dist/llm/groq.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroqProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../utils/config");
+class GroqProvider {
+    async generate(prompt) {
+        if (!config_1.CONFIG.GROQ_API_KEY) {
+            throw new Error('GROQ_API_KEY is not set. Please set it in your environment to use Groq.');
+        }
+        try {
+            const response = await axios_1.default.post(config_1.CONFIG.GROQ_API_URL, {
+                model: config_1.CONFIG.GROQ_MODEL,
+                messages: [
+                    { role: 'user', content: prompt } // Groq expects chat format
+                ]
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${config_1.CONFIG.GROQ_API_KEY}`,
+                    'Content-Type': 'application/json'
+                },
+                timeout: config_1.CONFIG.TIMEOUT
+            });
+            return response.data.choices[0].message.content;
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                throw new Error(`Groq API error: ${error.response?.data?.error?.message || error.message}`);
+            }
+            throw error;
+        }
+    }
+    async checkHealth() {
+        if (!config_1.CONFIG.GROQ_API_KEY)
+            return false;
+        // We can't easily ping without cost or auth, so we assume strictly key presence + superficial check
+        return true;
+    }
+    getName() {
+        return `Groq Cloud (${config_1.CONFIG.GROQ_MODEL})`;
+    }
+}
+exports.GroqProvider = GroqProvider;

package/dist/llm/ollama.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../utils/config");
+class OllamaProvider {
+    async generate(prompt, context, signal) {
+        const url = `${config_1.CONFIG.OLLAMA_HOST}/api/generate`;
+        try {
+            const response = await axios_1.default.post(url, {
+                model: config_1.CONFIG.OLLAMA_MODEL,
+                prompt: prompt,
+                stream: false,
+            }, {
+                timeout: config_1.CONFIG.TIMEOUT,
+                signal: signal
+            });
+            if (response.data && response.data.response) {
+                return response.data.response;
+            }
+            throw new Error('Invalid response format from Ollama');
+        }
+        catch (error) {
+            this.handleError(error);
+            return '';
+        }
+    }
+    async streamGenerate(prompt, onToken, signal) {
+        const url = `${config_1.CONFIG.OLLAMA_HOST}/api/generate`;
+        try {
+            const response = await axios_1.default.post(url, {
+                model: config_1.CONFIG.OLLAMA_MODEL,
+                prompt: prompt,
+                stream: true
+            }, {
+                responseType: 'stream',
+                timeout: config_1.CONFIG.TIMEOUT,
+                signal: signal
+            });
+            return new Promise((resolve, reject) => {
+                let fullText = '';
+                const stream = response.data;
+                stream.on('data', (chunk) => {
+                    const lines = chunk.toString().split('\n').filter(Boolean);
+                    for (const line of lines) {
+                        try {
+                            const json = JSON.parse(line);
+                            if (json.response) {
+                                onToken(json.response);
+                                fullText += json.response;
+                            }
+                            if (json.done) {
+                                resolve(fullText);
+                            }
+                        }
+                        catch (e) {
+                            // ignore
+                        }
+                    }
+                });
+                stream.on('end', () => {
+                    resolve(fullText);
+                });
+                stream.on('error', (err) => {
+                    // If aborted, axios destroys stream with error
+                    if (signal?.aborted) {
+                        reject(new Error('Aborted'));
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            });
+        }
+        catch (error) {
+            // Axios throws CanceledError if aborted
+            if (axios_1.default.isCancel(error)) {
+                throw new Error('Request cancelled by user');
+            }
+            this.handleError(error);
+            return '';
+        }
+    }
+    async checkHealth() {
+        try {
+            await axios_1.default.get(config_1.CONFIG.OLLAMA_HOST, { timeout: 2000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getName() {
+        return `Ollama (${config_1.CONFIG.OLLAMA_MODEL})`;
+    }
+    handleError(error) {
+        if (axios_1.default.isCancel(error)) {
+            throw error;
+        }
+        if (axios_1.default.isAxiosError(error)) {
+            if (error.code === 'ECONNREFUSED') {
+                throw new Error(`Could not connect to Ollama at ${config_1.CONFIG.OLLAMA_HOST}. Is it running?`);
+            }
+            throw new Error(`Ollama API error: ${error.message}`);
+        }
+        throw error;
+    }
+}
+exports.OllamaProvider = OllamaProvider;

package/dist/llm/providerFactory.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProvider = getProvider;
+const ollama_1 = require("./ollama");
+const groq_1 = require("./groq");
+const config_1 = require("../utils/config");
+function getProvider(requestedProvider) {
+    const providerKey = (requestedProvider || config_1.CONFIG.DEFAULT_PROVIDER).toLowerCase();
+    if (providerKey === 'groq') {
+        return new groq_1.GroqProvider();
+    }
+    // Default to Ollama
+    return new ollama_1.OllamaProvider();
+}

package/dist/llm/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/memory/memoryStore.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMemory = loadMemory;
+exports.saveMemory = saveMemory;
+exports.appendMemory = appendMemory;
+const fs_1 = __importDefault(require("fs"));
+const config_1 = require("../utils/config");
+/**
+ * Ensures the configuration directory exists.
+ */
+function ensureConfigDir() {
+    if (!fs_1.default.existsSync(config_1.CONFIG.CONFIG_DIR)) {
+        fs_1.default.mkdirSync(config_1.CONFIG.CONFIG_DIR, { recursive: true });
+    }
+}
+/**
+ * Loads the last N memory items from local storage.
+ */
+function loadMemory() {
+    try {
+        ensureConfigDir();
+        if (!fs_1.default.existsSync(config_1.CONFIG.MEMORY_FILE)) {
+            return [];
+        }
+        const data = fs_1.default.readFileSync(config_1.CONFIG.MEMORY_FILE, 'utf-8');
+        const items = JSON.parse(data);
+        // Return only the last MAX_MEMORY_ITEMS
+        return items.slice(-config_1.CONFIG.MAX_MEMORY_ITEMS);
+    }
+    catch (error) {
+        // If memory is corrupt or unreadable, return empty to prevent crash
+        return [];
+    }
+}
+/**
+ * Saves the full list of memory items to local storage.
+ */
+function saveMemory(memory) {
+    try {
+        ensureConfigDir();
+        fs_1.default.writeFileSync(config_1.CONFIG.MEMORY_FILE, JSON.stringify(memory, null, 2), 'utf-8');
+    }
+    catch (error) {
+        console.error('Failed to save memory:', error);
+    }
+}
+/**
+ * Appends a single item to the persistent memory store.
+ */
+function appendMemory(item) {
+    const currentMemory = loadMemory();
+    currentMemory.push(item);
+    saveMemory(currentMemory);
+}

package/dist/memory/semanticStore.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeSemanticMemory = storeSemanticMemory;
+exports.retrieveRelevantMemory = retrieveRelevantMemory;
+const fs_1 = __importDefault(require("fs"));
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../utils/config");
+// Simple cosine similarity
+function cosineSimilarity(vecA, vecB) {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < vecA.length; i++) {
+        dotProduct += vecA[i] * vecB[i];
+        normA += vecA[i] * vecA[i];
+        normB += vecB[i] * vecB[i];
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+async function getEmbedding(text) {
+    try {
+        const response = await axios_1.default.post(`${config_1.CONFIG.OLLAMA_HOST}/api/embeddings`, {
+            model: config_1.CONFIG.OLLAMA_EMBED_MODEL,
+            prompt: text,
+        });
+        return response.data.embedding;
+    }
+    catch (e) {
+        // console.error("Error getting embedding:", e);
+        return [];
+    }
+}
+function ensureDir() {
+    if (!fs_1.default.existsSync(config_1.CONFIG.SEMANTIC_MEMORY_DIR)) {
+        fs_1.default.mkdirSync(config_1.CONFIG.SEMANTIC_MEMORY_DIR, { recursive: true });
+    }
+}
+function loadIndex() {
+    try {
+        ensureDir();
+        if (!fs_1.default.existsSync(config_1.CONFIG.SEMANTIC_INDEX_FILE))
+            return [];
+        return JSON.parse(fs_1.default.readFileSync(config_1.CONFIG.SEMANTIC_INDEX_FILE, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}
+function saveIndex(index) {
+    ensureDir();
+    fs_1.default.writeFileSync(config_1.CONFIG.SEMANTIC_INDEX_FILE, JSON.stringify(index, null, 2));
+}
+async function storeSemanticMemory(content, source = 'chat') {
+    if (!content || content.length < 10)
+        return; // Ignore noise
+    // Check if Ollama is embedding-capable
+    const embedding = await getEmbedding(content);
+    if (!embedding || embedding.length === 0)
+        return;
+    const index = loadIndex();
+    const entry = {
+        id: Math.random().toString(36).substring(7),
+        content,
+        embedding,
+        metadata: {
+            source,
+            timestamp: new Date().toISOString()
+        }
+    };
+    index.push(entry);
+    saveIndex(index);
+}
+async function retrieveRelevantMemory(query, topK = 5) {
+    const queryEmbedding = await getEmbedding(query);
+    if (!queryEmbedding || queryEmbedding.length === 0)
+        return [];
+    const index = loadIndex();
+    const scored = index.map(entry => ({
+        entry,
+        score: cosineSimilarity(queryEmbedding, entry.embedding)
+    }));
+    // Filter and sort
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, topK).map(s => `[Memory: ${s.entry.metadata.timestamp}] ${s.entry.content}`);
+}

package/dist/rag/indexer.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexRepository = indexRepository;
+exports.retrieveContext = retrieveContext;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const config_1 = require("../utils/config");
+const semanticStore_1 = require("../memory/semanticStore");
+// Local RAG Store Path
+const RAG_DIR = path_1.default.join(config_1.CONFIG.CONFIG_DIR, 'rag');
+function getRepoHash(cwd) {
+    return crypto_1.default.createHash('md5').update(cwd).digest('hex');
+}
+function getRepoIndexDir(cwd) {
+    return path_1.default.join(RAG_DIR, getRepoHash(cwd));
+}
+// Simple heuristic to find source files
+function findSourceFiles(dir, fileList = []) {
+    const files = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    for (const file of files) {
+        if (file.isDirectory()) {
+            if (['node_modules', '.git', 'dist', 'out', 'build'].includes(file.name))
+                continue;
+            findSourceFiles(path_1.default.join(dir, file.name), fileList);
+        }
+        else {
+            if (['.ts', '.js', '.md', '.json'].includes(path_1.default.extname(file.name))) {
+                fileList.push(path_1.default.join(dir, file.name));
+            }
+        }
+    }
+    return fileList;
+}
+async function indexRepository(cwd = process.cwd()) {
+    const indexDir = getRepoIndexDir(cwd);
+    // Check if already indexed (simple existence check for now)
+    // Real implementation would check timestamps
+    if (fs_1.default.existsSync(indexDir)) {
+        console.log(`[RAG] Repository already indexed: ${indexDir}`);
+        return;
+    }
+    console.log(`[RAG] Indexing repository...`);
+    const files = findSourceFiles(cwd);
+    // We reuse semantic memory store logic but tag it with "RAG"
+    // Ideally we'd use a separate collection, but for this MVP, shared store with metadata is fine
+    // Or we use storeSemanticMemory but force source="rag"
+    // Actually, 'semanticStore' uses a single file index.json.
+    // For per-repo RAG, we need to namespace it.
+    // Complexity warning: The current simple store is single-file.
+    // Upgrading it for per-repo is needed.
+    // Strategy: We will just index into the SAME store but with metadata: { repo: hash }
+    let count = 0;
+    for (const f of files) {
+        try {
+            const content = fs_1.default.readFileSync(f, 'utf-8');
+            // Chunking would go here. For now, we take whole file if small, or truncate.
+            // Limit to ~2k chars for embedding
+            const chunk = content.substring(0, 2000);
+            // Artificial metadata injection for retrieval filtering
+            // Note: Our current retrieveRelevantMemory doesn't support metadata filtering yet.
+            // We accepted this limitation for the MVP.
+            // We just store it.
+            await (0, semanticStore_1.storeSemanticMemory)(chunk, `file:${path_1.default.relative(cwd, f)}`);
+            if (count++ > 50)
+                break; // Safety limit
+            process.stdout.write('.');
+        }
+        catch { }
+    }
+    console.log(`\n[RAG] Indexed ${count} files.`);
+    // Mark as indexed
+    fs_1.default.mkdirSync(indexDir, { recursive: true });
+}
+async function retrieveContext(query, cwd = process.cwd()) {
+    // Just leverage the global semantic store for now.
+    // It will return chat memories AND file memories.
+    const results = await (0, semanticStore_1.retrieveRelevantMemory)(query, 3);
+    return results.join('\n');
+}

package/dist/refactor/refactorEngine.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.engineCommand = engineCommand;
+const orchestrator_1 = require("../agents/orchestrator");
+const child_process_1 = require("child_process");
+async function engineCommand(instruction) {
+    if (!instruction) {
+        console.log("Please provide a refactor instruction e.g. 'convert to typescript'");
+        return;
+    }
+    try {
+        // Enforce safety: Check git status first
+        try {
+            const status = (0, child_process_1.execSync)('git status --porcelain').toString();
+            if (status.trim().length > 0) {
+                console.log("⚠️  Standard Safety Check: You have uncommitted changes.");
+                console.log("   LOKI recommends a clean state before refactoring.");
+                // In a real CLI we would ask prompt yes/no.
+                // For now, proceed with warning.
+            }
+        }
+        catch {
+            console.log("⚠️  Not a git repository. Safety features limited.");
+        }
+        console.log(`🧠 LOKI Engine: Initializing Refactor Workflow...`);
+        const result = await (0, orchestrator_1.runRefactorWorkflow)(instruction);
+        console.log(result.details);
+        console.log("\n---------------------------------------------------");
+        console.log("To apply changes, this scaffold would prompt for 'Yes'.");
+        console.log("Currently, changes are proposed ONLY. No files modified.");
+    }
+    catch (e) {
+        console.error("Engine Error:", e.message);
+    }
+}