andur 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rivendev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# Andur 🗡️ Scout & Bridge
+
+> **The Intelligent Bridge between Production Logs and Agentic Fixing.**
+
+Andur is a developer tool designed to automate the triage and handover of production errors to autonomous agents. It acts as a **Scout**, extracting rich context and impact analysis from your logs, and a **Bridge**, initiating fix sessions directly on agentic platforms like Jules.
+
+---
+
+## 🌟 The "Scout & Bridge" Workflow
+
+1.  **Scout**: Andur fetches errors from New Relic, groups them by signature, and performs an AI-driven impact and cause analysis.
+2.  **Bridge**: If a Jules API token is configured, Andur automatically prompts you to select a target repository and branch, then creates a new fix session with a comprehensive "Handover Report".
+
+## 🚀 Key Features
+
+- **Log Ingestion**: Deep integration with New Relic (NRQL) to fetch and group transaction errors.
+- **AI Diagnosis**: Automatic analysis of stack traces using Gemini or OpenAI to identify root causes.
+- **Automated Handover**: Direct integration with the **Jules Service API** (`v1alpha`) to start fixing sessions.
+- **Impact Tracking**: Calculates how much each error group contributes to your total error volume.
+- **Fix Status**: Persistently tracks which errors have already been sent to Jules to avoid duplicate work.
+- **Usage & Cost Tracking**: Built-in monitoring of AI token consumption and estimated costs.
+
+## 📦 Installation
+
+```bash
+npm install -g andur
+```
+
+## 🛠️ Configuration
+
+Initialize your project configuration interactively:
+
+```bash
+andur init
+```
+
+### Environment Variables
+Andur requires API keys to function. Set these in your `.env` or environment:
+
+```bash
+# Log Provider (New Relic)
+ANDUR_LOGS_ACCOUNT_ID="your-id"
+ANDUR_LOGS_API_KEY="your-key"
+
+# AI Provider (Gemini/OpenAI)
+ANDUR_AI_API_KEY="your-key"
+
+# Jules Service Handover
+ANDUR_JULES_API_TOKEN="your-token"
+```
+
+### andur.config.js
+```javascript
+module.exports = {
+  logs: {
+    provider: 'new-relic',
+    since: '1 day ago',
+    limit: 100
+  },
+  ai: {
+    provider: 'gemini',
+    model: 'gemini-2.0-flash-exp'
+  },
+  repo: {
+    branch: 'develop' // Default target branch for fixes
+  }
+};
+```
+
+## ⌨️ Command Reference
+
+| Command | Description |
+| :--- | :--- |
+| `andur init` | Set up configuration interactively |
+| `andur analyze` | Scout recent logs and generate AI insights |
+| `andur fix` | Select an error and bridge it to Jules Service |
+| `andur fix --all` | Send all unhandled error groups to Jules in batch |
+| `andur usage-details` | View token usage and cost estimation |
+
+## 🛡️ License
+
+MIT © [Rivendev](https://github.com/rivendev)

package/dist/cli/index.js

@@ -0,0 +1,366 @@
+"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.setupCLI = setupCLI;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_loader_1 = require("../core/config-loader");
+const plugin_loader_1 = require("../core/plugin-loader");
+const grouping_engine_1 = require("../core/grouping-engine");
+const ai_engine_1 = require("../core/ai-engine");
+const newrelic_provider_1 = require("../plugins/logs/newrelic-provider");
+const mock_provider_1 = require("../plugins/ai/mock-provider");
+const openai_provider_1 = require("../plugins/ai/openai-provider");
+const gemini_provider_1 = require("../plugins/ai/gemini-provider");
+const local_provider_1 = require("../plugins/repo/local-provider");
+const fix_tracker_1 = require("../utils/fix-tracker");
+function setupCLI() {
+    const program = new commander_1.Command();
+    program
+        .name('andur')
+        .description('Transform production logs into code fixes')
+        .version('0.1.0');
+    program
+        .command('init')
+        .description('Initialize Andur configuration interactively')
+        .action(async () => {
+        const inquirer = require('inquirer');
+        const { LOG_PROVIDERS, AI_PROVIDERS, MODELS, REPO_PROVIDERS } = require('../types/constants');
+        console.log(chalk_1.default.blue('\n🗡️  Andur Initialization\n'));
+        const answers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'logProvider',
+                message: 'Select your log provider:',
+                choices: LOG_PROVIDERS,
+            },
+            {
+                type: 'list',
+                name: 'aiProvider',
+                message: 'Select your AI provider:',
+                choices: AI_PROVIDERS,
+            },
+            {
+                type: 'list',
+                name: 'model',
+                message: (currAnswers) => `Select model for ${currAnswers.aiProvider}:`,
+                choices: (currAnswers) => MODELS[currAnswers.aiProvider],
+            },
+            {
+                type: 'list',
+                name: 'repoProvider',
+                message: 'Select your repo provider:',
+                choices: REPO_PROVIDERS,
+            }
+        ]);
+        const configContent = config_loader_1.ConfigLoader.generateDefaultConfig(answers);
+        const configPath = path.join(process.cwd(), 'andur.config.js');
+        if (fs.existsSync(configPath)) {
+            console.error(chalk_1.default.red('andur.config.js already exists!'));
+            return;
+        }
+        fs.writeFileSync(configPath, configContent);
+        console.log(chalk_1.default.green(`\n✅ Created andur.config.js`));
+        console.log(chalk_1.default.yellow('\nNext steps:'));
+        console.log(`1. Set your environment variables:`);
+        console.log(`   - ${chalk_1.default.cyan('ANDUR_LOGS_ACCOUNT_ID')}`);
+        console.log(`   - ${chalk_1.default.cyan('ANDUR_LOGS_API_KEY')}`);
+        console.log(`   - ${chalk_1.default.cyan('ANDUR_AI_API_KEY')}`);
+        console.log(`2. Run ${chalk_1.default.cyan('andur analyze')} to start.\n`);
+    });
+    program
+        .command('analyze')
+        .description('Analyze recent logs and group errors')
+        .option('--query <nrql>', 'Custom NRQL query')
+        .action(async (options) => {
+        try {
+            console.log(chalk_1.default.blue('Loading configuration...'));
+            const config = await config_loader_1.ConfigLoader.loadConfig();
+            const plugins = new plugin_loader_1.PluginLoader();
+            plugins.registerLogProvider(new newrelic_provider_1.NewRelicProvider(config.logs.options));
+            const provider = plugins.getLogProvider(config.logs.provider);
+            const finalQuery = options.query || config_loader_1.ConfigLoader.buildQuery(config);
+            console.log(chalk_1.default.blue(`Fetching logs from ${provider.name}...`));
+            console.debug(chalk_1.default.gray(`Query: ${finalQuery}`));
+            const logs = await provider.fetchLogs({ query: finalQuery });
+            console.log(chalk_1.default.blue(`Grouping ${logs.length} errors...`));
+            const groups = grouping_engine_1.GroupingEngine.group(logs, config.grouping?.strategy);
+            console.log(chalk_1.default.green(`\nFound ${groups.length} error groups.\n`));
+            // --- NEW: AI Insights ---
+            console.log(chalk_1.default.blue('Generating AI insights...'));
+            // Setup AI Provider for insights
+            if (config.ai.provider === 'openai') {
+                plugins.registerAIProvider(new openai_provider_1.OpenAIProvider({
+                    apiKey: config.ai.options.apiKey,
+                    model: config.ai.model
+                }));
+            }
+            else if (config.ai.provider === 'gemini') {
+                plugins.registerAIProvider(new gemini_provider_1.GeminiProvider({
+                    apiKey: config.ai.options.apiKey,
+                    model: config.ai.model
+                }));
+            }
+            else {
+                plugins.registerAIProvider(new mock_provider_1.MockAIProvider());
+            }
+            const aiProvider = plugins.getAIProvider(config.ai.provider);
+            const aiEngine = new ai_engine_1.AIEngine(aiProvider);
+            const insights = await aiEngine.getInsights(groups);
+            // Record usage
+            if (insights.usage) {
+                const { UsageTracker: Tracker } = require('../utils/usage-tracker');
+                Tracker.record(config.ai.provider, config.ai.model, insights.usage.inputTokens, insights.usage.outputTokens);
+            }
+            console.log(chalk_1.default.bold('AI Summary:'));
+            console.log(chalk_1.default.white(insights.summary));
+            console.log(chalk_1.default.bold('\nCategorization:'));
+            insights.categories.forEach(cat => {
+                console.log(`- ${chalk_1.default.cyan(cat.name)}: ${cat.count} groups`);
+            });
+            console.log(chalk_1.default.bold('\nDetailed Groups:'));
+            groups.forEach(g => {
+                console.log(`${chalk_1.default.yellow(g.hash)}: ${g.representativeError.message} (${g.count} occurrences)`);
+            });
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error:'), error.message);
+        }
+    });
+    program
+        .command('jules-fix')
+        .alias('fix')
+        .description('Request Jules to generate a fix for a specific error group')
+        .argument('[hash]', 'Error group hash to fix')
+        .option('-a, --all', 'Send all detected error groups to Jules for fixing')
+        .action(async (hash, options) => {
+        try {
+            const config = await config_loader_1.ConfigLoader.loadConfig();
+            const plugins = new plugin_loader_1.PluginLoader();
+            const inquirer = require('inquirer');
+            plugins.registerLogProvider(new newrelic_provider_1.NewRelicProvider(config.logs.options));
+            // Register the correct AI provider based on config
+            if (config.ai.provider === 'openai') {
+                plugins.registerAIProvider(new openai_provider_1.OpenAIProvider({
+                    apiKey: config.ai.options.apiKey,
+                    model: config.ai.model
+                }));
+            }
+            else if (config.ai.provider === 'gemini') {
+                plugins.registerAIProvider(new gemini_provider_1.GeminiProvider({
+                    apiKey: config.ai.options.apiKey,
+                    model: config.ai.model
+                }));
+            }
+            else {
+                plugins.registerAIProvider(new mock_provider_1.MockAIProvider());
+            }
+            plugins.registerRepoProvider(new local_provider_1.LocalRepoProvider(config.repo.path));
+            const logProvider = plugins.getLogProvider(config.logs.provider);
+            const aiProvider = plugins.getAIProvider(config.ai.provider);
+            const repoProvider = plugins.getRepoProvider(config.repo.provider);
+            console.log(chalk_1.default.blue('Fetching error details...'));
+            const query = config_loader_1.ConfigLoader.buildQuery(config);
+            const logs = await logProvider.fetchLogs({ query });
+            const totalErrorCount = logs.length;
+            const groups = grouping_engine_1.GroupingEngine.group(logs, config.grouping?.strategy);
+            let targetGroups = [];
+            if (hash) {
+                const group = groups.find(g => g.hash === hash);
+                if (!group) {
+                    console.error(chalk_1.default.red(`Error group ${hash} not found.`));
+                    return;
+                }
+                targetGroups = [group];
+            }
+            else if (options?.all) {
+                targetGroups = groups.filter(g => !fix_tracker_1.FixTracker.isHandled(g.hash));
+                if (targetGroups.length === 0) {
+                    console.log(chalk_1.default.green('\n✅ All error groups have already been handled by Jules.'));
+                    return;
+                }
+                console.log(chalk_1.default.blue(`\nProcessing ${targetGroups.length} unhandled error groups...`));
+            }
+            else {
+                const { selectedHash } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'selectedHash',
+                        message: 'Select an error group for Jules to fix:',
+                        loop: false,
+                        choices: groups.map(g => {
+                            const impact = ((g.count / totalErrorCount) * 100).toFixed(1);
+                            const isHandled = fix_tracker_1.FixTracker.isHandled(g.hash);
+                            const prefix = isHandled ? chalk_1.default.green('[JULES] ') : '';
+                            return {
+                                name: `${prefix}${chalk_1.default.yellow(g.hash)}: ${g.representativeError.message} (${g.count} logs - ${impact}%)`,
+                                value: g.hash
+                            };
+                        })
+                    }
+                ]);
+                targetGroups = [groups.find(g => g.hash === selectedHash)];
+            }
+            // Prepare Jules Handover context (prompt once if multiple)
+            let selectedSource;
+            let selectedBranch;
+            if (config.jules && config.jules.token) {
+                const { JulesProvider } = require('../plugins/jules/jules-provider');
+                const julesSvc = new JulesProvider(config.jules.token);
+                console.log(chalk_1.default.blue('\nBridge: Connecting to Jules Service...'));
+                try {
+                    const sources = await julesSvc.listSources();
+                    if (sources.length === 0) {
+                        console.warn(chalk_1.default.yellow('Warning: No Jules sources found. Automated handover skipped.'));
+                    }
+                    else {
+                        const sourceAnswer = await inquirer.prompt([
+                            {
+                                type: 'list',
+                                name: 'selectedSource',
+                                message: 'Select the Jules source for this handover:',
+                                loop: false,
+                                choices: sources.map((s) => ({
+                                    name: s.id,
+                                    value: s.name
+                                }))
+                            }
+                        ]);
+                        selectedSource = sourceAnswer.selectedSource;
+                        const branchAnswer = await inquirer.prompt([
+                            {
+                                type: 'input',
+                                name: 'selectedBranch',
+                                message: 'Enter the target branch for Jules to fix:',
+                                default: config.repo.branch || 'main'
+                            }
+                        ]);
+                        selectedBranch = branchAnswer.selectedBranch;
+                    }
+                }
+                catch (e) {
+                    console.error(chalk_1.default.red('\nFailed to connect to Jules Service:'), e.message);
+                }
+            }
+            const aiEngine = new ai_engine_1.AIEngine(aiProvider);
+            const { JulesProvider } = require('../plugins/jules/jules-provider');
+            const jules = (config.jules && config.jules.token) ? new JulesProvider(config.jules.token) : null;
+            for (const group of targetGroups) {
+                const impactPercentage = ((group.count / totalErrorCount) * 100).toFixed(1);
+                console.log(chalk_1.default.magenta.bold(`\n--- Processing Group: ${group.hash} ---`));
+                console.log(chalk_1.default.blue('Scouting and analyzing...'));
+                const result = await aiEngine.analyze(group, {});
+                if (result.usage) {
+                    const { UsageTracker: Tracker } = require('../utils/usage-tracker');
+                    Tracker.record(config.ai.provider, config.ai.model, result.usage.inputTokens, result.usage.outputTokens);
+                }
+                console.log(chalk_1.default.green('\nInsights Summary: ') + result.explanation.substring(0, 150) + '...');
+                if (jules && selectedSource && selectedBranch) {
+                    const handoverPrompt = `
+JULES HANDOVER REPORT
+=====================
+Error Hash: ${group.hash}
+Impact: ${group.count} occurrences (${impactPercentage}%)
+Message: ${group.representativeError.message}
+
+Screener Insights:
+${result.explanation}
+
+Direction:
+${result.suggestedFix}
+                        `.trim();
+                    console.log(chalk_1.default.blue('Submitting to Jules...'));
+                    try {
+                        const session = await jules.createSession(selectedSource, handoverPrompt, `Fix: ${group.representativeError.message}`, selectedBranch);
+                        console.log(chalk_1.default.green(`✅ Session created: ${session.id}`));
+                        fix_tracker_1.FixTracker.markAsHandled(group.hash);
+                    }
+                    catch (e) {
+                        console.error(chalk_1.default.red(`❌ Failed to submit ${group.hash}:`), e.message);
+                    }
+                }
+                else {
+                    console.log(chalk_1.default.cyan('\nFix Direction: ') + result.suggestedFix.substring(0, 150) + '...');
+                    console.log(chalk_1.default.yellow('Note: Automated handover skipped (Service not configured or selection cancelled).'));
+                }
+            }
+            console.log(chalk_1.default.magenta.bold('\n=================================================='));
+            console.log(chalk_1.default.white('      Handover cycle complete. Jules is active.    '));
+            console.log(chalk_1.default.magenta.bold('==================================================\n'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error:'), error.message);
+        }
+    });
+    program
+        .command('usage-details')
+        .description('Show AI token usage and estimated costs')
+        .action(async () => {
+        const { UsageTracker } = require('../utils/usage-tracker');
+        const { PRICING, COST_DISCLAIMER } = require('../utils/pricing');
+        const usage = UsageTracker.load();
+        if (Object.keys(usage).length === 0) {
+            console.log(chalk_1.default.yellow('\nNo usage data found yet. Run "andur fix" to start tracking.\n'));
+            return;
+        }
+        console.log(chalk_1.default.blue('\n📊 Andur Usage & Cost Estimation\n'));
+        let totalCost = 0;
+        for (const [provider, models] of Object.entries(usage)) {
+            console.log(chalk_1.default.bold(`${provider.toUpperCase()}:`));
+            const modelEntries = Object.entries(models);
+            for (const [model, stats] of modelEntries) {
+                const pricing = PRICING[model] || { input: 0, output: 0 };
+                const inputTokens = stats.inputTokens || 0;
+                const outputTokens = stats.outputTokens || 0;
+                const inputCost = (inputTokens / 1000000) * pricing.input;
+                const outputCost = (outputTokens / 1000000) * pricing.output;
+                const modelTotal = inputCost + outputCost;
+                totalCost += modelTotal;
+                console.log(`  - ${chalk_1.default.cyan(model)}:`);
+                console.log(`    Tokens: ${inputTokens.toLocaleString()} in / ${outputTokens.toLocaleString()} out`);
+                console.log(`    Estimated Cost: ${chalk_1.default.green('$' + modelTotal.toFixed(4))}`);
+            }
+            console.log('');
+        }
+        console.log(chalk_1.default.bold(`TOTAL ESTIMATED COST: ${chalk_1.default.green('$' + totalCost.toFixed(4))}`));
+        console.log(chalk_1.default.gray(`\n${COST_DISCLAIMER}\n`));
+    });
+    program.parse(process.argv);
+}

package/dist/core/ai-engine.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIEngine = void 0;
+class AIEngine {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async analyze(errorGroup, fileContexts) {
+        const context = this.prepareContext(fileContexts);
+        return await this.provider.analyzeError(errorGroup, context);
+    }
+    async getInsights(groups) {
+        return await this.provider.generateInsights(groups);
+    }
+    prepareContext(fileContexts) {
+        let contextStr = 'Relevant code context:\n\n';
+        for (const [path, content] of Object.entries(fileContexts)) {
+            contextStr += `--- File: ${path} ---\n${content}\n\n`;
+        }
+        return contextStr;
+    }
+}
+exports.AIEngine = AIEngine;

package/dist/core/config-loader.js

@@ -0,0 +1,116 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLoader = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const validateConfig = (config) => {
+    if (!config.logs || !config.ai || !config.repo) {
+        throw new Error('Invalid config: missing logs, ai, or repo section');
+    }
+    return config;
+};
+class ConfigLoader {
+    static async loadConfig(configPath) {
+        const searchPaths = [
+            configPath,
+            path.join(process.cwd(), 'andur.config.js'),
+            path.join(process.cwd(), 'andur.config.ts'),
+        ].filter(Boolean);
+        for (const p of searchPaths) {
+            if (fs.existsSync(p)) {
+                try {
+                    const fullPath = path.resolve(p);
+                    let module;
+                    if (p.endsWith('.js')) {
+                        module = require(fullPath);
+                    }
+                    else {
+                        module = await Promise.resolve(`${`file://${fullPath}`}`).then(s => __importStar(require(s)));
+                    }
+                    const config = module.default || module.config || module;
+                    // Inject environment variables if not present in config file
+                    if (!config.jules)
+                        config.jules = {};
+                    if (!config.jules.token)
+                        config.jules.token = process.env.ANDUR_JULES_API_TOKEN;
+                    return validateConfig(config);
+                }
+                catch (error) {
+                    console.error(`Failed to load config from ${p}:`, error);
+                }
+            }
+        }
+        throw new Error('Config file not found or invalid. Run "andur init" to create one.');
+    }
+    static buildQuery(config) {
+        const baseQuery = config.logs.query || 'SELECT * FROM TransactionError';
+        const since = config.logs.since ? ` SINCE ${config.logs.since}` : ' SINCE 1 day ago';
+        const limit = config.logs.limit ? ` LIMIT ${config.logs.limit}` : ' LIMIT 10';
+        return `${baseQuery}${since}${limit}`;
+    }
+    static generateDefaultConfig(data) {
+        return `/** @type {import('./src/types').AndurConfig} */
+module.exports = {
+  logs: {
+    provider: '${data.logProvider}',
+    query: 'SELECT * FROM TransactionError',
+    since: '1 day ago',
+    limit: 10,
+    options: {
+      accountId: process.env.ANDUR_LOGS_ACCOUNT_ID,
+      apiKey: process.env.ANDUR_LOGS_API_KEY,
+    }
+  },
+  ai: {
+    provider: '${data.aiProvider}',
+    model: '${data.model}',
+    options: {
+      apiKey: process.env.ANDUR_AI_API_KEY,
+    }
+  },
+  repo: {
+    provider: '${data.repoProvider}',
+    path: './',
+    options: {}
+  },
+  jules: {
+    token: process.env.ANDUR_JULES_API_TOKEN,
+  }
+};
+`;
+    }
+}
+exports.ConfigLoader = ConfigLoader;

package/dist/core/grouping-engine.js

@@ -0,0 +1,65 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupingEngine = void 0;
+const crypto = __importStar(require("crypto"));
+class GroupingEngine {
+    static group(errors, strategy = 'auto') {
+        const groups = new Map();
+        for (const error of errors) {
+            let hash = '';
+            if (strategy === 'message' || (strategy === 'auto' && !error.stackTrace)) {
+                hash = this.hashString(error.message);
+            }
+            else {
+                // Simple hash of first few lines of stack trace to avoid grouping variants of same error
+                const stackLines = error.stackTrace?.split('\n').slice(0, 3).join('\n') || error.message;
+                hash = this.hashString(stackLines);
+            }
+            const existing = groups.get(hash) || [];
+            groups.set(hash, [...existing, error]);
+        }
+        return Array.from(groups.entries()).map(([hash, errors]) => ({
+            hash,
+            errors,
+            representativeError: errors[0],
+            count: errors.length,
+        }));
+    }
+    static hashString(str) {
+        return crypto.createHash('md5').update(str).digest('hex').substring(0, 8);
+    }
+}
+exports.GroupingEngine = GroupingEngine;