codebot-ai 1.2.3 → 1.4.0

package/dist/tools/http-client.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientTool = void 0;
+class HttpClientTool {
+    name = 'http_client';
+    description = 'Make HTTP requests. Supports GET, POST, PUT, DELETE, PATCH with headers, auth, and body.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            method: { type: 'string', description: 'HTTP method: GET, POST, PUT, DELETE, PATCH, HEAD (default: GET)' },
+            url: { type: 'string', description: 'Full URL to request' },
+            headers: { type: 'object', description: 'Request headers as key-value pairs' },
+            body: { type: 'string', description: 'Request body (JSON string or plain text)' },
+            auth: { type: 'string', description: 'Authorization header value (e.g., "Bearer token123")' },
+            timeout: { type: 'number', description: 'Timeout in ms (default: 30000)' },
+        },
+        required: ['url'],
+    };
+    async execute(args) {
+        const url = args.url;
+        if (!url)
+            return 'Error: url is required';
+        // Validate URL
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(url);
+        }
+        catch {
+            return `Error: invalid URL: ${url}`;
+        }
+        // Block private IPs and file protocol
+        if (this.isBlocked(parsedUrl)) {
+            return 'Error: requests to private/local addresses are blocked for security.';
+        }
+        const method = (args.method || 'GET').toUpperCase();
+        const timeoutMs = args.timeout || 30_000;
+        const headers = {};
+        // Set headers
+        if (args.headers && typeof args.headers === 'object') {
+            for (const [k, v] of Object.entries(args.headers)) {
+                headers[k] = String(v);
+            }
+        }
+        if (args.auth) {
+            headers['Authorization'] = args.auth;
+        }
+        // Auto-set content type for body
+        const body = args.body;
+        if (body && !headers['Content-Type'] && !headers['content-type']) {
+            try {
+                JSON.parse(body);
+                headers['Content-Type'] = 'application/json';
+            }
+            catch { /* leave as-is */ }
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(url, {
+                method,
+                headers,
+                body: ['GET', 'HEAD'].includes(method) ? undefined : body,
+                signal: controller.signal,
+            });
+            const contentType = res.headers.get('content-type') || '';
+            let responseBody;
+            try {
+                responseBody = await res.text();
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            // Try to pretty-print JSON
+            if (contentType.includes('json') || responseBody.startsWith('{') || responseBody.startsWith('[')) {
+                try {
+                    const parsed = JSON.parse(responseBody);
+                    responseBody = JSON.stringify(parsed, null, 2);
+                }
+                catch { /* keep raw */ }
+            }
+            // Truncate huge responses
+            if (responseBody.length > 10_000) {
+                responseBody = responseBody.substring(0, 10_000) + '\n...(truncated)';
+            }
+            const headerLines = Array.from(res.headers.entries())
+                .slice(0, 10)
+                .map(([k, v]) => `  ${k}: ${v}`)
+                .join('\n');
+            return `${res.status} ${res.statusText}\n\nHeaders:\n${headerLines}\n\nBody:\n${responseBody}`;
+        }
+        catch (err) {
+            clearTimeout(timer);
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes('abort'))
+                return `Error: request timed out after ${timeoutMs}ms`;
+            return `Error: ${msg}`;
+        }
+    }
+    isBlocked(url) {
+        const host = url.hostname.toLowerCase();
+        if (url.protocol === 'file:')
+            return true;
+        if (host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '0.0.0.0')
+            return true;
+        if (host === '169.254.169.254')
+            return true; // cloud metadata
+        if (/^10\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host))
+            return true;
+        return false;
+    }
+}
+exports.HttpClientTool = HttpClientTool;
+//# sourceMappingURL=http-client.js.map

package/dist/tools/image-info.d.ts

@@ -0,0 +1,23 @@
+import { Tool } from '../types';
+export declare class ImageInfoTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            base64: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private readJpegDimensions;
+}
+//# sourceMappingURL=image-info.d.ts.map

package/dist/tools/image-info.js

@@ -0,0 +1,170 @@
+"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.ImageInfoTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ImageInfoTool {
+    name = 'image_info';
+    description = 'Get image file information — dimensions, format, file size. Supports PNG, JPEG, GIF, BMP, SVG.';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to image file' },
+            base64: { type: 'boolean', description: 'Also return base64-encoded content (default: false)' },
+        },
+        required: ['path'],
+    };
+    async execute(args) {
+        const filePath = args.path;
+        if (!filePath)
+            return 'Error: path is required';
+        if (!fs.existsSync(filePath))
+            return `Error: file not found: ${filePath}`;
+        const stat = fs.statSync(filePath);
+        const ext = path.extname(filePath).toLowerCase();
+        const sizeKB = (stat.size / 1024).toFixed(1);
+        let width = 0, height = 0, format = 'unknown';
+        try {
+            const buf = Buffer.alloc(Math.min(stat.size, 32));
+            const fd = fs.openSync(filePath, 'r');
+            fs.readSync(fd, buf, 0, buf.length, 0);
+            fs.closeSync(fd);
+            // PNG: bytes 16-23 contain width (4 bytes) and height (4 bytes)
+            if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4E && buf[3] === 0x47) {
+                format = 'PNG';
+                width = buf.readUInt32BE(16);
+                height = buf.readUInt32BE(20);
+            }
+            // JPEG: SOI marker
+            else if (buf[0] === 0xFF && buf[1] === 0xD8) {
+                format = 'JPEG';
+                const dims = this.readJpegDimensions(filePath);
+                width = dims.width;
+                height = dims.height;
+            }
+            // GIF: GIF87a or GIF89a
+            else if (buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46) {
+                format = 'GIF';
+                width = buf.readUInt16LE(6);
+                height = buf.readUInt16LE(8);
+            }
+            // BMP
+            else if (buf[0] === 0x42 && buf[1] === 0x4D) {
+                format = 'BMP';
+                const fullBuf = Buffer.alloc(26);
+                const fd2 = fs.openSync(filePath, 'r');
+                fs.readSync(fd2, fullBuf, 0, 26, 0);
+                fs.closeSync(fd2);
+                width = fullBuf.readInt32LE(18);
+                height = Math.abs(fullBuf.readInt32LE(22));
+            }
+            // SVG
+            else if (ext === '.svg') {
+                format = 'SVG';
+                const content = fs.readFileSync(filePath, 'utf-8').substring(0, 1000);
+                const wMatch = content.match(/width=["'](\d+)/);
+                const hMatch = content.match(/height=["'](\d+)/);
+                const vbMatch = content.match(/viewBox=["']\s*\d+\s+\d+\s+(\d+)\s+(\d+)/);
+                if (wMatch)
+                    width = parseInt(wMatch[1]);
+                if (hMatch)
+                    height = parseInt(hMatch[1]);
+                if (!width && vbMatch) {
+                    width = parseInt(vbMatch[1]);
+                    height = parseInt(vbMatch[2]);
+                }
+            }
+        }
+        catch {
+            // Could not read dimensions
+        }
+        let result = `File: ${path.basename(filePath)}\nFormat: ${format}\nSize: ${sizeKB} KB`;
+        if (width > 0 && height > 0) {
+            result += `\nDimensions: ${width} x ${height}`;
+        }
+        result += `\nModified: ${stat.mtime.toISOString()}`;
+        if (args.base64) {
+            try {
+                const content = fs.readFileSync(filePath);
+                const b64 = content.toString('base64');
+                if (b64.length > 50_000) {
+                    result += '\n\nBase64: (too large — over 50KB encoded)';
+                }
+                else {
+                    result += `\n\nBase64:\n${b64}`;
+                }
+            }
+            catch {
+                result += '\n\nBase64: Error reading file';
+            }
+        }
+        return result;
+    }
+    readJpegDimensions(filePath) {
+        try {
+            const buf = fs.readFileSync(filePath);
+            let offset = 2; // Skip SOI
+            while (offset < buf.length - 1) {
+                if (buf[offset] !== 0xFF)
+                    break;
+                const marker = buf[offset + 1];
+                // SOF markers (C0-C3, C5-C7, C9-CB, CD-CF)
+                if ((marker >= 0xC0 && marker <= 0xC3) || (marker >= 0xC5 && marker <= 0xC7) ||
+                    (marker >= 0xC9 && marker <= 0xCB) || (marker >= 0xCD && marker <= 0xCF)) {
+                    const height = buf.readUInt16BE(offset + 5);
+                    const width = buf.readUInt16BE(offset + 7);
+                    return { width, height };
+                }
+                // Skip non-SOF markers
+                if (marker === 0xD8 || marker === 0xD9) {
+                    offset += 2;
+                    continue;
+                }
+                if (marker >= 0xD0 && marker <= 0xD7) {
+                    offset += 2;
+                    continue;
+                }
+                const len = buf.readUInt16BE(offset + 2);
+                offset += 2 + len;
+            }
+        }
+        catch { /* fallback */ }
+        return { width: 0, height: 0 };
+    }
+}
+exports.ImageInfoTool = ImageInfoTool;
+//# sourceMappingURL=image-info.js.map

package/dist/tools/index.js

@@ -14,11 +14,28 @@ const web_search_1 = require("./web-search");
 const browser_1 = require("./browser");
 const batch_edit_1 = require("./batch-edit");
 const routine_1 = require("./routine");
+// v1.4.0 — 15 new tools
+const git_1 = require("./git");
+const code_analysis_1 = require("./code-analysis");
+const multi_search_1 = require("./multi-search");
+const task_planner_1 = require("./task-planner");
+const diff_viewer_1 = require("./diff-viewer");
+const docker_1 = require("./docker");
+const database_1 = require("./database");
+const test_runner_1 = require("./test-runner");
+const http_client_1 = require("./http-client");
+const image_info_1 = require("./image-info");
+const ssh_remote_1 = require("./ssh-remote");
+const notification_1 = require("./notification");
+const pdf_extract_1 = require("./pdf-extract");
+const package_manager_1 = require("./package-manager");
+const code_review_1 = require("./code-review");
 var edit_2 = require("./edit");
 Object.defineProperty(exports, "EditFileTool", { enumerable: true, get: function () { return edit_2.EditFileTool; } });
 class ToolRegistry {
     tools = new Map();
     constructor(projectRoot) {
+        // Core file tools
         this.register(new read_1.ReadFileTool());
         this.register(new write_1.WriteFileTool());
         this.register(new edit_1.EditFileTool());
@@ -28,10 +45,27 @@ class ToolRegistry {
         this.register(new grep_1.GrepTool());
         this.register(new think_1.ThinkTool());
         this.register(new memory_1.MemoryTool(projectRoot));
+        // Web & browser
         this.register(new web_fetch_1.WebFetchTool());
         this.register(new web_search_1.WebSearchTool());
         this.register(new browser_1.BrowserTool());
         this.register(new routine_1.RoutineTool());
+        // v1.4.0 — intelligence & dev tools
+        this.register(new git_1.GitTool());
+        this.register(new code_analysis_1.CodeAnalysisTool());
+        this.register(new multi_search_1.MultiSearchTool());
+        this.register(new task_planner_1.TaskPlannerTool());
+        this.register(new diff_viewer_1.DiffViewerTool());
+        this.register(new docker_1.DockerTool());
+        this.register(new database_1.DatabaseTool());
+        this.register(new test_runner_1.TestRunnerTool());
+        this.register(new http_client_1.HttpClientTool());
+        this.register(new image_info_1.ImageInfoTool());
+        this.register(new ssh_remote_1.SshRemoteTool());
+        this.register(new notification_1.NotificationTool());
+        this.register(new pdf_extract_1.PdfExtractTool());
+        this.register(new package_manager_1.PackageManagerTool());
+        this.register(new code_review_1.CodeReviewTool());
     }
     register(tool) {
         this.tools.set(tool.name, tool);

package/dist/tools/multi-search.d.ts

@@ -0,0 +1,28 @@
+import { Tool } from '../types';
+export declare class MultiSearchTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+            max_results: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private searchDir;
+    private fuzzyScore;
+}
+//# sourceMappingURL=multi-search.d.ts.map

package/dist/tools/multi-search.js

@@ -0,0 +1,153 @@
+"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.MultiSearchTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class MultiSearchTool {
+    name = 'multi_search';
+    description = 'Fuzzy search across filenames, file contents, and code symbols. Returns ranked results by relevance.';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query (fuzzy matched against filenames, content, and symbols)' },
+            path: { type: 'string', description: 'Directory to search (defaults to current)' },
+            max_results: { type: 'number', description: 'Max results to return (default: 20)' },
+        },
+        required: ['query'],
+    };
+    async execute(args) {
+        const query = args.query;
+        if (!query)
+            return 'Error: query is required';
+        const searchPath = args.path || process.cwd();
+        const maxResults = args.max_results || 20;
+        if (!fs.existsSync(searchPath))
+            return `Error: path not found: ${searchPath}`;
+        const results = [];
+        const queryLower = query.toLowerCase();
+        const queryParts = queryLower.split(/\s+/);
+        this.searchDir(searchPath, queryLower, queryParts, results);
+        // Sort by score descending
+        results.sort((a, b) => b.score - a.score);
+        const top = results.slice(0, maxResults);
+        if (top.length === 0)
+            return `No results for "${query}".`;
+        const lines = top.map(r => {
+            const tag = r.type === 'filename' ? '[file]' : r.type === 'symbol' ? '[symbol]' : '[content]';
+            const loc = r.line ? `:${r.line}` : '';
+            const preview = r.text ? ` — ${r.text.substring(0, 80)}` : '';
+            return `  ${tag} ${r.file}${loc}${preview}`;
+        });
+        return `Search results for "${query}" (${top.length} matches):\n${lines.join('\n')}`;
+    }
+    searchDir(dir, query, parts, results) {
+        const skip = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '__pycache__', '.next']);
+        const codeExts = new Set(['.ts', '.js', '.tsx', '.jsx', '.py', '.go', '.rs', '.java', '.rb', '.c', '.cpp', '.h', '.css', '.html', '.json', '.md', '.yaml', '.yml', '.toml']);
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || skip.has(entry.name))
+                continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Score directory name
+                const dirScore = this.fuzzyScore(entry.name.toLowerCase(), query, parts);
+                if (dirScore > 0) {
+                    results.push({ file: full + '/', score: dirScore * 0.5, type: 'filename' });
+                }
+                this.searchDir(full, query, parts, results);
+            }
+            else {
+                // Filename match
+                const nameScore = this.fuzzyScore(entry.name.toLowerCase(), query, parts);
+                if (nameScore > 0) {
+                    results.push({ file: full, score: nameScore, type: 'filename' });
+                }
+                // Content + symbol search for code files
+                const ext = path.extname(entry.name).toLowerCase();
+                if (!codeExts.has(ext))
+                    continue;
+                try {
+                    const content = fs.readFileSync(full, 'utf-8');
+                    if (content.length > 500_000 || content.includes('\0'))
+                        continue; // skip huge/binary
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        const lineLower = line.toLowerCase();
+                        // Content match
+                        if (lineLower.includes(query)) {
+                            results.push({ file: full, line: i + 1, text: line.trimEnd(), score: 3, type: 'content' });
+                        }
+                        // Symbol match (class, function, method definitions)
+                        const symbolMatch = line.match(/(?:class|function|interface|type|const|let|var|def|fn|func)\s+(\w+)/);
+                        if (symbolMatch) {
+                            const symScore = this.fuzzyScore(symbolMatch[1].toLowerCase(), query, parts);
+                            if (symScore > 0) {
+                                results.push({ file: full, line: i + 1, text: line.trimEnd(), score: symScore * 1.5, type: 'symbol' });
+                            }
+                        }
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    fuzzyScore(target, query, parts) {
+        // Exact match
+        if (target === query)
+            return 10;
+        // Contains full query
+        if (target.includes(query))
+            return 7;
+        // All parts present
+        if (parts.every(p => target.includes(p)))
+            return 5;
+        // Some parts present
+        const matched = parts.filter(p => target.includes(p)).length;
+        if (matched > 0)
+            return matched * 2;
+        return 0;
+    }
+}
+exports.MultiSearchTool = MultiSearchTool;
+//# sourceMappingURL=multi-search.js.map

package/dist/tools/notification.d.ts

@@ -0,0 +1,38 @@
+import { Tool } from '../types';
+export declare class NotificationTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            url: {
+                type: string;
+                description: string;
+            };
+            message: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            severity: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private sendSlack;
+    private sendDiscord;
+    private sendGeneric;
+    private post;
+}
+//# sourceMappingURL=notification.d.ts.map

package/dist/tools/notification.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationTool = void 0;
+class NotificationTool {
+    name = 'notification';
+    description = 'Send notifications via webhook (Slack, Discord, or generic). Actions: slack, discord, webhook.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: slack, discord, webhook' },
+            url: { type: 'string', description: 'Webhook URL' },
+            message: { type: 'string', description: 'Message text' },
+            title: { type: 'string', description: 'Optional title/subject' },
+            severity: { type: 'string', description: 'Severity: info, warning, error, success (affects color)' },
+        },
+        required: ['action', 'url', 'message'],
+    };
+    async execute(args) {
+        const action = args.action;
+        const url = args.url;
+        const message = args.message;
+        if (!action)
+            return 'Error: action is required';
+        if (!url)
+            return 'Error: url is required';
+        if (!message)
+            return 'Error: message is required';
+        // Validate URL
+        try {
+            new URL(url);
+        }
+        catch {
+            return `Error: invalid URL: ${url}`;
+        }
+        const title = args.title || '';
+        const severity = args.severity || 'info';
+        switch (action) {
+            case 'slack': return this.sendSlack(url, message, title, severity);
+            case 'discord': return this.sendDiscord(url, message, title, severity);
+            case 'webhook': return this.sendGeneric(url, message, title, severity);
+            default: return `Error: unknown action "${action}". Use: slack, discord, webhook`;
+        }
+    }
+    async sendSlack(url, message, title, severity) {
+        const colors = { info: '#2196F3', warning: '#FF9800', error: '#F44336', success: '#4CAF50' };
+        const payload = {
+            attachments: [{
+                    color: colors[severity] || colors.info,
+                    title: title || undefined,
+                    text: message,
+                    ts: Math.floor(Date.now() / 1000),
+                }],
+        };
+        return this.post(url, payload);
+    }
+    async sendDiscord(url, message, title, severity) {
+        const colors = { info: 0x2196F3, warning: 0xFF9800, error: 0xF44336, success: 0x4CAF50 };
+        const payload = {
+            embeds: [{
+                    title: title || undefined,
+                    description: message,
+                    color: colors[severity] || colors.info,
+                    timestamp: new Date().toISOString(),
+                }],
+        };
+        return this.post(url, payload);
+    }
+    async sendGeneric(url, message, title, severity) {
+        const payload = { title, message, severity, timestamp: new Date().toISOString() };
+        return this.post(url, payload);
+    }
+    async post(url, payload) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 15_000);
+        try {
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            clearTimeout(timer);
+            if (res.ok)
+                return `Notification sent (${res.status}).`;
+            const body = await res.text().catch(() => '');
+            return `Error: webhook returned ${res.status} ${res.statusText}${body ? `: ${body.substring(0, 200)}` : ''}`;
+        }
+        catch (err) {
+            clearTimeout(timer);
+            return `Error: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+}
+exports.NotificationTool = NotificationTool;
+//# sourceMappingURL=notification.js.map