@kishlay42/moth-ai 1.0.1

package/dist/agent/orchestrator.js

@@ -0,0 +1,97 @@
+export class AgentOrchestrator {
+    config;
+    state;
+    tools;
+    constructor(config, registry) {
+        this.config = config;
+        this.tools = registry;
+        this.state = {
+            history: [],
+            maxSteps: config.maxSteps || 10
+        };
+    }
+    async *run(prompt, history = []) {
+        let currentPrompt = prompt;
+        for (let i = 0; i < this.state.maxSteps; i++) {
+            // Construct system prompt with tools
+            const systemPrompt = this.buildSystemPrompt();
+            // Full context: System -> History -> Current State
+            const messages = [
+                { role: 'user', content: systemPrompt }, // In many APIs system prompt is special, here we use user role as generic fallback or modify Client to handle system
+                ...history,
+                { role: 'user', content: currentPrompt }
+            ];
+            // This is a simplified Mock for the ReAct loop to start with
+            // In reality, we need to handle the LLM raw output, parse "Thought" and "Tool Call"
+            // For now, we will rely on a Structured Output or strict parsing if the Provider supports it.
+            // Since we are using Gemini, we can ask for JSON mode or specific formatting.
+            const responseText = await this.callLLM(messages);
+            // Parse response
+            let step;
+            try {
+                step = this.parseResponse(responseText);
+            }
+            catch (e) {
+                yield { thought: "Failed to parse LLM response. Retrying...", toolOutput: `Error: ${e}` };
+                continue;
+            }
+            this.state.history.push(step);
+            yield step;
+            if (step.finalAnswer) {
+                return step.finalAnswer;
+            }
+            if (step.toolCall) {
+                // Execute tool
+                const result = await this.executeTool(step.toolCall.name, step.toolCall.arguments);
+                step.toolOutput = result;
+                // Re-feed result to LLM
+                currentPrompt = `Tool '${step.toolCall.name}' returned: ${result}`;
+            }
+        }
+        return "Max steps reached.";
+    }
+    buildSystemPrompt() {
+        const toolDefs = this.tools.getDefinitions().map(t => `${t.name}: ${t.description} Params: ${JSON.stringify(t.parameters)}`).join('\n');
+        return `You are Moth, an intelligent CLI coding assistant.
+You have access to the following tools:
+${toolDefs}
+
+IMPORTANT GUIDELINES:
+1. For general questions, explanations, or code snippets that don't need to be saved, use "finalAnswer". 
+2. Do NOT use "write_to_file" unless the user explicitly asks to save a file or implies a persistent change.
+3. If the user asks for "Hello World code", just show it in the explanation (finalAnswer). Do NOT create a file for it.
+4. Be concise and helpful.
+
+Format your response exactly as a JSON object:
+{
+  "thought": "your reasoning",
+  "toolCall": { "name": "tool_name", "arguments": { ... } }
+}
+OR if you are done/replying:
+{
+  "thought": "reasoning",
+  "finalAnswer": "your response/code/explanation"
+}
+`;
+    }
+    async callLLM(messages) {
+        // Direct integration with LLM Client
+        // This assumes Client has a simple chat interface returning string
+        // We might need to adjust LLMClient interface to support non-streaming one-off calls
+        // Placeholder: We will need to implement a 'generate' method on LLMClient
+        // or collect the stream.
+        let fullText = "";
+        for await (const chunk of this.config.model.chatStream(messages)) {
+            fullText += chunk;
+        }
+        return fullText;
+    }
+    parseResponse(text) {
+        // Clean markdown code blocks if present
+        const jsonText = text.replace(/```json/g, '').replace(/```/g, '').trim();
+        return JSON.parse(jsonText);
+    }
+    async executeTool(name, args) {
+        return await this.tools.execute(name, args);
+    }
+}

package/dist/agent/types.js

@@ -0,0 +1 @@
+export {};

package/dist/config/configManager.js

@@ -0,0 +1,62 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import yaml from 'js-yaml';
+import { CONFIG_DIR, ensureConfigDir } from '../utils/paths.js';
+const CONFIG_FILE = path.join(CONFIG_DIR, 'profiles.yaml');
+const DEFAULT_CONFIG = {
+    profiles: [],
+};
+export function loadConfig() {
+    ensureConfigDir();
+    if (!fs.existsSync(CONFIG_FILE)) {
+        saveConfig(DEFAULT_CONFIG);
+        return DEFAULT_CONFIG;
+    }
+    try {
+        const content = fs.readFileSync(CONFIG_FILE, 'utf8');
+        const parsed = yaml.load(content);
+        // ensure structure matches
+        return {
+            profiles: parsed?.profiles || [],
+            activeProfile: parsed?.activeProfile,
+            username: parsed?.username
+        };
+    }
+    catch (e) {
+        // console.error('Failed to load config, using default', e); 
+        // ^ Silence for now or use UI error in future
+        return DEFAULT_CONFIG;
+    }
+}
+export function saveConfig(config) {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, yaml.dump(config), 'utf8');
+}
+export function addProfile(config, profile) {
+    const existingIndex = config.profiles.findIndex(p => p.name === profile.name);
+    if (existingIndex >= 0) {
+        config.profiles[existingIndex] = profile;
+    }
+    else {
+        config.profiles.push(profile);
+    }
+    return config;
+}
+export function removeProfile(config, name) {
+    config.profiles = config.profiles.filter(p => p.name !== name);
+    if (config.activeProfile === name) {
+        config.activeProfile = undefined;
+    }
+    return config;
+}
+export function setActiveProfile(config, name) {
+    const exists = config.profiles.some(p => p.name === name);
+    if (exists) {
+        config.activeProfile = name;
+    }
+    return config;
+}
+export function setUsername(config, username) {
+    config.username = username;
+    return config;
+}

package/dist/config/keychain.js

@@ -0,0 +1,20 @@
+import keytar from 'keytar';
+const SERVICE_NAME = 'moth-cli';
+const LEGACY_SERVICE_NAME = 'saute-cli';
+export async function setApiKey(profileName, key) {
+    await keytar.setPassword(SERVICE_NAME, profileName, key);
+}
+export async function getApiKey(profileName) {
+    let key = await keytar.getPassword(SERVICE_NAME, profileName);
+    if (!key) {
+        // Try legacy service and migrate if found
+        key = await keytar.getPassword(LEGACY_SERVICE_NAME, profileName);
+        if (key) {
+            await keytar.setPassword(SERVICE_NAME, profileName, key);
+        }
+    }
+    return key;
+}
+export async function deleteApiKey(profileName) {
+    return keytar.deletePassword(SERVICE_NAME, profileName);
+}

package/dist/context/ignore.js

@@ -0,0 +1,27 @@
+import ignore from 'ignore';
+import * as fs from 'fs';
+import * as path from 'path';
+export class IgnoreManager {
+    ig = ignore();
+    constructor(root) {
+        this.loadIgnoreFile(root);
+        // Always ignore .git and node_modules
+        this.ig.add(['.git', 'node_modules', '.moth', 'dist', 'coverage']);
+    }
+    loadIgnoreFile(root) {
+        const ignorePath = path.join(root, '.gitignore');
+        if (fs.existsSync(ignorePath)) {
+            try {
+                const content = fs.readFileSync(ignorePath, 'utf8');
+                this.ig.add(content);
+            }
+            catch (error) {
+                console.warn('Failed to load .gitignore:', error);
+            }
+        }
+    }
+    shouldIgnore(filePath) {
+        // ignore package expects relative paths
+        return this.ig.ignores(filePath);
+    }
+}

package/dist/context/manager.js

@@ -0,0 +1,62 @@
+import { ProjectScanner } from './scanner.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class ContextManager {
+    scanner;
+    root;
+    constructor(root) {
+        this.root = root;
+        this.scanner = new ProjectScanner(root);
+    }
+    async gather(request) {
+        const filePaths = await this.scanner.scan();
+        const files = [];
+        // Simple Scoring: 
+        // 1. Exact filename match (1.0)
+        // 2. Query terms in path (0.5)
+        // 3. Default (0.1)
+        // Normalize query terms
+        const terms = request.query.toLowerCase().split(/\s+/);
+        for (const filePath of filePaths) {
+            let score = 0.1;
+            const lowerPath = filePath.toLowerCase();
+            const basename = path.basename(lowerPath);
+            if (terms.some(t => basename === t)) {
+                score = 1.0;
+            }
+            else if (terms.some(t => lowerPath.includes(t))) {
+                score = 0.5;
+            }
+            // Basic Tiering Logic (Placeholder)
+            // If score > 0.8 => Full
+            // If score > 0.4 => Summary (but we don't have summarizer yet, so Path)
+            // Else => Path
+            let tier = 'path';
+            let content;
+            if (score >= 0.8) {
+                tier = 'full';
+                try {
+                    // Limit file read size for safety
+                    content = await fs.readFile(path.join(this.root, filePath), 'utf8');
+                    // Truncate if too huge? (TODO)
+                }
+                catch (e) {
+                    console.warn(`Failed to read ${filePath}`, e);
+                    tier = 'path';
+                }
+            }
+            files.push({
+                path: filePath,
+                relevance: score,
+                tier,
+                content
+            });
+        }
+        // Sort by relevance
+        files.sort((a, b) => b.relevance - a.relevance);
+        return {
+            files,
+            totalTokens: 0 // Placeholder
+        };
+    }
+}

package/dist/context/scanner.js

@@ -0,0 +1,41 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { IgnoreManager } from './ignore.js';
+export class ProjectScanner {
+    root;
+    ignoreManager;
+    constructor(root) {
+        this.root = root;
+        this.ignoreManager = new IgnoreManager(root);
+    }
+    async scan() {
+        const files = [];
+        await this.scanDir('', files);
+        return files;
+    }
+    async scanDir(relativeDir, fileList) {
+        const fullDir = path.join(this.root, relativeDir);
+        // Check if directory itself is ignored
+        if (relativeDir && this.ignoreManager.shouldIgnore(relativeDir)) {
+            return;
+        }
+        try {
+            const entries = await fs.readdir(fullDir, { withFileTypes: true });
+            for (const entry of entries) {
+                const relativePath = path.join(relativeDir, entry.name);
+                if (this.ignoreManager.shouldIgnore(relativePath)) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    await this.scanDir(relativePath, fileList);
+                }
+                else if (entry.isFile()) {
+                    fileList.push(relativePath);
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to scan directory ${fullDir}:`, error);
+        }
+    }
+}

package/dist/context/types.js

@@ -0,0 +1 @@
+export {};

package/dist/editing/patcher.js

@@ -0,0 +1,37 @@
+import * as Diff from 'diff';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class Patcher {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    async applyPatch(filePath, patchContent) {
+        const fullPath = path.join(this.root, filePath);
+        try {
+            const originalContent = await fs.readFile(fullPath, 'utf8');
+            // Safety: Create backup
+            await this.createBackup(filePath, originalContent);
+            // Apply patch
+            const patchedContent = Diff.applyPatch(originalContent, patchContent);
+            if (patchedContent === false) {
+                console.error(`Failed to apply patch to ${filePath}. Context mismatch.`);
+                return false;
+            }
+            await fs.writeFile(fullPath, patchedContent, 'utf8');
+            return true;
+        }
+        catch (error) {
+            console.error(`Error patching ${filePath}:`, error);
+            return false;
+        }
+    }
+    async createBackup(filePath, content) {
+        const backupDir = path.join(this.root, '.moth', 'backups');
+        await fs.mkdir(backupDir, { recursive: true });
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const safeName = filePath.replace(/[\\/]/g, '_');
+        const backupPath = path.join(backupDir, `${safeName}_${timestamp}.bak`);
+        await fs.writeFile(backupPath, content, 'utf8');
+    }
+}