codebot-ai 1.0.0

package/dist/tools/read.js

@@ -0,0 +1,75 @@
+"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.ReadFileTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ReadFileTool {
+    name = 'read_file';
+    description = 'Read the contents of a file. Returns file content with line numbers.';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file to read' },
+            offset: { type: 'number', description: 'Line number to start from (1-based). Optional.' },
+            limit: { type: 'number', description: 'Max number of lines to read. Optional.' },
+        },
+        required: ['path'],
+    };
+    async execute(args) {
+        const filePath = path.resolve(args.path);
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            throw new Error(`Path is a directory: ${filePath}. Use glob to list files.`);
+        }
+        if (stat.size > 2 * 1024 * 1024) {
+            throw new Error(`File too large (${Math.round(stat.size / 1024)}KB). Use offset/limit to read in chunks.`);
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const offset = Math.max(0, (args.offset || 1) - 1);
+        const limit = args.limit || lines.length;
+        const slice = lines.slice(offset, offset + limit);
+        return slice
+            .map((line, i) => `${String(offset + i + 1).padStart(5)}\t${line}`)
+            .join('\n');
+    }
+}
+exports.ReadFileTool = ReadFileTool;
+//# sourceMappingURL=read.js.map

package/dist/tools/think.d.ts

@@ -0,0 +1,18 @@
+import { Tool } from '../types';
+export declare class ThinkTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            thought: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+//# sourceMappingURL=think.d.ts.map

package/dist/tools/think.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThinkTool = void 0;
+class ThinkTool {
+    name = 'think';
+    description = 'A reasoning scratchpad. Use to plan your approach, analyze code, or work through complex problems before taking action. No side effects.';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            thought: { type: 'string', description: 'Your reasoning, analysis, or plan' },
+        },
+        required: ['thought'],
+    };
+    async execute(args) {
+        return 'Thought recorded.';
+    }
+}
+exports.ThinkTool = ThinkTool;
+//# sourceMappingURL=think.js.map

package/dist/tools/web-fetch.d.ts

@@ -0,0 +1,36 @@
+import { Tool } from '../types';
+export declare class WebFetchTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            url: {
+                type: string;
+                description: string;
+            };
+            method: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+            headers: {
+                type: string;
+                description: string;
+            };
+            body: {
+                type: string;
+                description: string;
+            };
+            json: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private htmlToText;
+}
+//# sourceMappingURL=web-fetch.d.ts.map

package/dist/tools/web-fetch.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebFetchTool = void 0;
+class WebFetchTool {
+    name = 'web_fetch';
+    description = 'Make HTTP requests to URLs or APIs. Fetch web pages, call REST APIs, post data. Supports GET, POST, PUT, PATCH, DELETE.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: 'URL to fetch' },
+            method: { type: 'string', description: 'HTTP method (default: GET)', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'] },
+            headers: { type: 'object', description: 'Request headers as key-value pairs' },
+            body: { type: 'string', description: 'Request body (for POST/PUT/PATCH)' },
+            json: { type: 'object', description: 'JSON body (auto-sets Content-Type)' },
+        },
+        required: ['url'],
+    };
+    async execute(args) {
+        const url = args.url;
+        const method = args.method || 'GET';
+        const headers = args.headers || {};
+        let body;
+        if (args.json) {
+            body = JSON.stringify(args.json);
+            if (!headers['Content-Type'] && !headers['content-type']) {
+                headers['Content-Type'] = 'application/json';
+            }
+        }
+        else if (args.body) {
+            body = args.body;
+        }
+        try {
+            const res = await fetch(url, {
+                method,
+                headers,
+                body,
+                signal: AbortSignal.timeout(30000),
+            });
+            const contentType = res.headers.get('content-type') || '';
+            const responseText = await res.text();
+            // Truncate very large responses
+            const maxLen = 50000;
+            const truncated = responseText.length > maxLen
+                ? responseText.substring(0, maxLen) + `\n\n... (truncated, ${responseText.length} total chars)`
+                : responseText;
+            const statusLine = `HTTP ${res.status} ${res.statusText}`;
+            // For HTML, strip tags to get readable text
+            if (contentType.includes('text/html')) {
+                const text = this.htmlToText(truncated);
+                return `${statusLine}\n\n${text}`;
+            }
+            return `${statusLine}\n\n${truncated}`;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return `Error: ${msg}`;
+        }
+    }
+    htmlToText(html) {
+        return html
+            // Remove script/style blocks
+            .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+            .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+            // Convert common block elements to newlines
+            .replace(/<\/?(div|p|br|h[1-6]|li|tr|blockquote|pre|section|article|header|footer|nav|main)[^>]*>/gi, '\n')
+            // Remove all remaining tags
+            .replace(/<[^>]+>/g, '')
+            // Decode common entities
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'")
+            .replace(/&nbsp;/g, ' ')
+            // Clean up whitespace
+            .replace(/[ \t]+/g, ' ')
+            .replace(/\n\s*\n\s*\n/g, '\n\n')
+            .trim();
+    }
+}
+exports.WebFetchTool = WebFetchTool;
+//# sourceMappingURL=web-fetch.js.map

package/dist/tools/write.d.ts

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

package/dist/tools/write.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.WriteFileTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class WriteFileTool {
+    name = 'write_file';
+    description = 'Create a new file or overwrite an existing file with the given content.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file to write' },
+            content: { type: 'string', description: 'Content to write to the file' },
+        },
+        required: ['path', 'content'],
+    };
+    async execute(args) {
+        const filePath = path.resolve(args.path);
+        const content = args.content;
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const existed = fs.existsSync(filePath);
+        fs.writeFileSync(filePath, content, 'utf-8');
+        const lines = content.split('\n').length;
+        return `${existed ? 'Overwrote' : 'Created'} ${filePath} (${lines} lines, ${content.length} bytes)`;
+    }
+}
+exports.WriteFileTool = WriteFileTool;
+//# sourceMappingURL=write.js.map

package/dist/types.d.ts

@@ -0,0 +1,82 @@
+export interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    name?: string;
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ToolResult {
+    tool_call_id: string;
+    content: string;
+    is_error?: boolean;
+}
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    permission: 'auto' | 'prompt' | 'always-ask';
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+export interface ProviderConfig {
+    baseUrl: string;
+    apiKey?: string;
+    model: string;
+}
+export interface LLMProvider {
+    name: string;
+    chat(messages: Message[], tools?: ToolSchema[]): AsyncGenerator<StreamEvent>;
+    listModels?(): Promise<string[]>;
+}
+export interface ToolSchema {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export interface StreamEvent {
+    type: 'text' | 'thinking' | 'tool_call_start' | 'tool_call_delta' | 'tool_call_end' | 'usage' | 'done' | 'error';
+    text?: string;
+    toolCall?: Partial<ToolCall>;
+    error?: string;
+    usage?: UsageStats;
+}
+export interface UsageStats {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+export interface AgentEvent {
+    type: 'thinking' | 'text' | 'tool_call' | 'tool_result' | 'done' | 'error' | 'compaction' | 'usage';
+    text?: string;
+    toolCall?: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+    toolResult?: {
+        name: string;
+        result: string;
+        is_error?: boolean;
+    };
+    error?: string;
+    usage?: UsageStats;
+}
+export interface Config {
+    provider: string;
+    model: string;
+    baseUrl: string;
+    apiKey?: string;
+    maxIterations: number;
+    autoApprove: boolean;
+    contextBudget?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "codebot-ai",
+  "version": "1.0.0",
+  "description": "Local-first AI coding assistant. Zero dependencies. Works with Ollama, LM Studio, vLLM, Claude, GPT, Gemini, and more.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "codebot": "./bin/codebot"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/cli.js",
+    "test": "node --test dist/*.test.js dist/**/*.test.js",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "coding-assistant",
+    "ollama",
+    "local-llm",
+    "agent",
+    "cli",
+    "code-generation",
+    "claude",
+    "gpt",
+    "gemini",
+    "autonomous",
+    "agentic"
+  ],
+  "author": "Ascendral Software Development & Innovation",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AscendralSoftware/codebot-ai.git"
+  },
+  "homepage": "https://github.com/AscendralSoftware/codebot-ai#readme",
+  "bugs": {
+    "url": "https://github.com/AscendralSoftware/codebot-ai/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "!dist/**/*.test.*",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "@types/node": "^20.0.0"
+  }
+}