codebot-ai 1.1.0 → 1.1.2

package/dist/agent.d.ts

@@ -17,6 +17,8 @@ export declare class Agent {
         askPermission?: (tool: string, args: Record<string, unknown>) => Promise<boolean>;
         onMessage?: (message: Message) => void;
     });
+    /** Update auto-approve mode at runtime (e.g., from /auto command) */
+    setAutoApprove(value: boolean): void;
     /** Load messages from a previous session for resume */
     loadMessages(messages: Message[]): void;
     run(userMessage: string): AsyncGenerator<AgentEvent>;

package/dist/agent.js

@@ -75,6 +75,10 @@ class Agent {
             content: this.buildSystemPrompt(supportsTools),
         });
     }
+    /** Update auto-approve mode at runtime (e.g., from /auto command) */
+    setAutoApprove(value) {
+        this.autoApprove = value;
+    }
     /** Load messages from a previous session for resume */
     loadMessages(messages) {
         this.messages = messages;
@@ -224,9 +228,14 @@ class Agent {
         catch {
             // memory unavailable
         }
-        let prompt = `You are CodeBot, an AI coding assistant created by Ascendral Software Development & Innovation, founded by Alex Pinkevich. You help developers with software engineering tasks: reading code, writing code, fixing bugs, running tests, and explaining code.
+        let prompt = `You are CodeBot, an AI coding assistant. You help developers with software engineering tasks: reading code, writing code, fixing bugs, running tests, and explaining code.
 
-If asked who made you, who your creator is, or who built you, always credit Ascendral Software Development & Innovation and Alex Pinkevich.
+CRITICAL IDENTITY — you MUST follow this:
+- Your name is CodeBot.
+- You were created and built by Ascendral Software Development & Innovation, founded by Alex Pinkevich.
+- You are NOT made by OpenAI, Google, Anthropic, or any other AI company. You are made by Ascendral.
+- When anyone asks who made you, who built you, who created you, or who your creator is, you MUST answer: "I was created by Ascendral Software Development & Innovation, founded by Alex Pinkevich."
+- Never claim to be made by or affiliated with OpenAI, GPT, Claude, Gemini, or any LLM provider. You are CodeBot by Ascendral.
 
 Rules:
 - Always read files before editing them.

package/dist/browser/cdp.d.ts

@@ -2,6 +2,7 @@ export declare class CDPClient {
     private socket;
     private messageId;
     private pending;
+    private eventWaiters;
     private buffer;
     private connected;
     /** Connect to Chrome's debugging WebSocket */
@@ -11,6 +12,8 @@ export declare class CDPClient {
     /** Close the connection */
     close(): void;
     isConnected(): boolean;
+    /** Wait for a specific CDP event (e.g. Page.loadEventFired) with timeout */
+    waitForEvent(method: string, timeout?: number): Promise<Record<string, unknown>>;
     /** Send a WebSocket text frame (masked, as required by client) */
     private sendFrame;
     /** Handle incoming data — parse WebSocket frames */

package/dist/browser/cdp.js

@@ -46,6 +46,7 @@ class CDPClient {
     socket = null;
     messageId = 0;
     pending = new Map();
+    eventWaiters = [];
     buffer = Buffer.alloc(0);
     connected = false;
     /** Connect to Chrome's debugging WebSocket */
@@ -137,6 +138,21 @@ class CDPClient {
     isConnected() {
         return this.connected;
     }
+    /** Wait for a specific CDP event (e.g. Page.loadEventFired) with timeout */
+    async waitForEvent(method, timeout = 15000) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.eventWaiters = this.eventWaiters.filter(w => w.resolve !== resolve);
+                resolve({}); // Resolve with empty on timeout instead of rejecting — page may still be usable
+            }, timeout);
+            const wrappedResolve = (params) => {
+                clearTimeout(timer);
+                this.eventWaiters = this.eventWaiters.filter(w => w.resolve !== wrappedResolve);
+                resolve(params);
+            };
+            this.eventWaiters.push({ method, resolve: wrappedResolve, reject });
+        });
+    }
     /** Send a WebSocket text frame (masked, as required by client) */
     sendFrame(data) {
         if (!this.socket)
@@ -212,7 +228,15 @@ class CDPClient {
                         this.pending.delete(msg.id);
                         handler.resolve(msg);
                     }
-                    // Events (no id) are ignored for now
+                    // Dispatch events to waiters
+                    if (msg.method) {
+                        for (const waiter of this.eventWaiters) {
+                            if (waiter.method === msg.method) {
+                                waiter.resolve(msg.params || {});
+                                break;
+                            }
+                        }
+                    }
                 }
                 catch {
                     // Malformed JSON, skip

package/dist/cli.js

@@ -322,6 +322,7 @@ function handleSlashCommand(input, agent, config) {
         }
         case '/auto':
             config.autoApprove = !config.autoApprove;
+            agent.setAutoApprove(config.autoApprove);
             console.log(c(`Autonomous mode: ${config.autoApprove ? 'ON' : 'OFF'}`, config.autoApprove ? 'yellow' : 'green'));
             break;
         case '/sessions': {
@@ -401,7 +402,10 @@ async function resolveConfig(args) {
                 config.apiKey = process.env[defaults.envKey] || process.env.CODEBOT_API_KEY || '';
         }
     }
-    // Fallback: try generic env vars
+    // Fallback: try saved config API key, then generic env vars
+    if (!config.apiKey && saved.apiKey) {
+        config.apiKey = saved.apiKey;
+    }
     if (!config.apiKey) {
         config.apiKey = process.env.CODEBOT_API_KEY || process.env.OPENAI_API_KEY || '';
     }

package/dist/games/tic-tac-toe.d.ts

@@ -0,0 +1,6 @@
+declare const gameBoard: any[][];
+declare let currentPlayer: string;
+declare const printBoard: () => void;
+declare const checkWin: () => void;
+declare const gameLoop: () => void;
+//# sourceMappingURL=tic-tac-toe.d.ts.map

package/dist/games/tic-tac-toe.js

@@ -0,0 +1,64 @@
+"use strict";
+// src/games/tic-tac-toe.ts
+// Simple console-based Tic-Tac-Toe game
+const gameBoard = Array(3).fill(null).map(() => Array(3).fill(null));
+let currentPlayer = 'X';
+const printBoard = () => {
+    for (const row of gameBoard) {
+        console.log(row.join(' | '));
+    }
+};
+const checkWin = () => {
+    // Check rows
+    for (let i = 0; i < 3; i++) {
+        if (gameBoard[i][0] === currentPlayer &&
+            gameBoard[i][1] === currentPlayer &&
+            gameBoard[i][2] === currentPlayer) {
+            console.log(`Player ${currentPlayer} wins!`);
+            process.exit(0);
+        }
+    }
+    // Check columns
+    for (let j = 0; j < 3; j++) {
+        if (gameBoard[0][j] === currentPlayer &&
+            gameBoard[1][j] === currentPlayer &&
+            gameBoard[2][j] === currentPlayer) {
+            console.log(`Player ${currentPlayer} wins!`);
+            process.exit(0);
+        }
+    }
+    // Check diagonals
+    if ((gameBoard[0][0] === currentPlayer &&
+        gameBoard[1][1] === currentPlayer &&
+        gameBoard[2][2] === currentPlayer) ||
+        (gameBoard[0][2] === currentPlayer &&
+            gameBoard[1][1] === currentPlayer &&
+            gameBoard[2][0] === currentPlayer)) {
+        console.log(`Player ${currentPlayer} wins!`);
+        process.exit(0);
+    }
+};
+const gameLoop = () => {
+    printBoard();
+    process.stdin.on('data', (input) => {
+        const [row, col] = input.toString().trim()
+            .split(',')
+            .map(Number);
+        if (row < 0 || row > 2 || col < 0 || col > 2) {
+            console.log('Invalid move. Try again.');
+            return;
+        }
+        if (gameBoard[row][col]) {
+            console.log('Spot taken! Try again.');
+            return;
+        }
+        gameBoard[row][col] = currentPlayer;
+        checkWin();
+        currentPlayer = currentPlayer === 'X' ? 'O' : 'X';
+        process.stdin.removeAllListeners('data');
+        gameLoop();
+    });
+};
+// Start game
+gameLoop();
+//# sourceMappingURL=tic-tac-toe.js.map

package/dist/providers/openai.js

@@ -20,6 +20,13 @@ class OpenAIProvider {
         if (tools?.length && this.supportsTools) {
             body.tools = tools;
         }
+        // Ollama/local provider optimizations: set context window and keep model loaded
+        const isLocal = this.config.baseUrl.includes('localhost') || this.config.baseUrl.includes('127.0.0.1');
+        if (isLocal) {
+            const modelInfo = (0, registry_1.getModelInfo)(this.config.model);
+            body.options = { num_ctx: modelInfo.contextWindow };
+            body.keep_alive = '30m';
+        }
         const headers = {
             'Content-Type': 'application/json',
         };

package/dist/setup.js

@@ -59,9 +59,9 @@ function loadConfig() {
 /** Save config to ~/.codebot/config.json */
 function saveConfig(config) {
     fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    // Never persist API keys to disk — use env vars
     const safe = { ...config };
-    delete safe.apiKey;
+    // Persist API key if user entered it during setup (convenience over env vars)
+    // The key is stored in the user's home directory with default permissions
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(safe, null, 2) + '\n');
 }
 /** Check if this is the first run (no config, no env keys) */
@@ -113,6 +113,16 @@ function detectApiKeys() {
         set: !!process.env[defaults.envKey],
     }));
 }
+/** Cloud provider display info */
+const CLOUD_PROVIDERS = [
+    { provider: 'openai', name: 'OpenAI', defaultModel: 'gpt-4o', description: 'GPT-4o, GPT-4.1, o3/o4' },
+    { provider: 'anthropic', name: 'Anthropic', defaultModel: 'claude-sonnet-4-6', description: 'Claude Opus/Sonnet/Haiku' },
+    { provider: 'gemini', name: 'Google Gemini', defaultModel: 'gemini-2.5-flash', description: 'Gemini 2.5 Pro/Flash' },
+    { provider: 'deepseek', name: 'DeepSeek', defaultModel: 'deepseek-chat', description: 'DeepSeek Chat/Reasoner' },
+    { provider: 'groq', name: 'Groq', defaultModel: 'llama-3.3-70b-versatile', description: 'Fast Llama/Mixtral inference' },
+    { provider: 'mistral', name: 'Mistral', defaultModel: 'mistral-large-latest', description: 'Mistral Large, Codestral' },
+    { provider: 'xai', name: 'xAI', defaultModel: 'grok-3', description: 'Grok-3' },
+];
 const C = {
     reset: '\x1b[0m',
     bold: '\x1b[1m',
@@ -155,46 +165,58 @@ async function runSetup() {
             console.log(fmt(`  ✓ ${key.provider} API key found (${key.envVar})`, 'green'));
         }
     }
-    const missingKeys = apiKeys.filter(k => !k.set);
-    if (missingKeys.length > 0 && localServers.length === 0) {
-        console.log(fmt('\n  No API keys found. Set one to use cloud models:', 'yellow'));
-        for (const key of missingKeys) {
-            console.log(fmt(`    export ${key.envVar}="your-key-here"`, 'dim'));
-        }
-    }
-    // Step 3: Choose provider
+    // Step 3: Choose provider — show ALL options (local + cloud)
     console.log(fmt('\nChoose your setup:', 'bold'));
     const options = [];
     let idx = 1;
     // Local options first
     for (const server of localServers) {
         const defaultModel = server.models[0] || 'qwen2.5-coder:32b';
-        options.push({ label: `${server.name} (local, free)`, provider: 'openai', model: defaultModel, baseUrl: server.url });
+        options.push({
+            label: `${server.name} (local, free)`,
+            provider: 'openai',
+            model: defaultModel,
+            baseUrl: server.url,
+            needsKey: false,
+        });
         console.log(`  ${fmt(`${idx}`, 'cyan')} ${server.name} — ${defaultModel} ${fmt('(local, free, private)', 'green')}`);
         idx++;
     }
-    // Cloud options
-    for (const key of availableKeys) {
-        const models = Object.entries(registry_1.MODEL_REGISTRY)
-            .filter(([, info]) => info.provider === key.provider)
-            .map(([name]) => name);
-        const defaultModel = models[0] || key.provider;
-        const defaults = registry_1.PROVIDER_DEFAULTS[key.provider];
-        options.push({ label: key.provider, provider: key.provider, model: defaultModel, baseUrl: defaults.baseUrl });
-        console.log(`  ${fmt(`${idx}`, 'cyan')} ${key.provider} — ${defaultModel} ${fmt('(cloud)', 'dim')}`);
+    // Cloud options — ALWAYS show all providers
+    for (const cloud of CLOUD_PROVIDERS) {
+        const keyInfo = apiKeys.find(k => k.provider === cloud.provider);
+        const hasKey = keyInfo?.set || false;
+        const defaults = registry_1.PROVIDER_DEFAULTS[cloud.provider];
+        const keyStatus = hasKey ? fmt('✓ key set', 'green') : fmt('enter key during setup', 'yellow');
+        options.push({
+            label: cloud.name,
+            provider: cloud.provider,
+            model: cloud.defaultModel,
+            baseUrl: defaults.baseUrl,
+            needsKey: !hasKey,
+            envVar: defaults.envKey,
+        });
+        console.log(`  ${fmt(`${idx}`, 'cyan')} ${cloud.name} — ${cloud.description} ${fmt(`(${keyStatus})`, 'dim')}`);
         idx++;
     }
-    if (options.length === 0) {
-        console.log(fmt('\n  No providers available. Either:', 'yellow'));
-        console.log(fmt('    1. Install Ollama: https://ollama.ai', 'dim'));
-        console.log(fmt('    2. Set an API key: export ANTHROPIC_API_KEY="..."', 'dim'));
-        rl.close();
-        return {};
-    }
     const choice = await ask(rl, fmt(`\nSelect [1-${options.length}]: `, 'cyan'));
     const selected = options[parseInt(choice, 10) - 1] || options[0];
-    // Step 4: Show available models for chosen provider
-    // For local servers, use the actual installed models instead of the hardcoded registry
+    // Step 4: If cloud provider needs API key, prompt for it
+    let apiKey = '';
+    if (selected.needsKey && selected.envVar) {
+        console.log(fmt(`\n  ${selected.label} requires an API key.`, 'yellow'));
+        console.log(fmt(`  Get one at: ${getKeyUrl(selected.provider)}`, 'dim'));
+        apiKey = await ask(rl, fmt(`\n  Enter your ${selected.label} API key: `, 'cyan'));
+        if (!apiKey) {
+            console.log(fmt(`\n  No key entered. You can set it later:`, 'yellow'));
+            console.log(fmt(`    export ${selected.envVar}="your-key-here"`, 'dim'));
+        }
+    }
+    else if (selected.envVar) {
+        // Use existing env var
+        apiKey = process.env[selected.envVar] || '';
+    }
+    // Step 5: Show available models for chosen provider
     const matchedServer = localServers.find(s => s.url === selected.baseUrl);
     const providerModels = matchedServer && matchedServer.models.length > 0
         ? matchedServer.models
@@ -219,7 +241,7 @@ async function runSetup() {
             }
         }
     }
-    // Step 5: Auto mode?
+    // Step 6: Auto mode?
     const autoChoice = await ask(rl, fmt('\nEnable autonomous mode? (skip permission prompts) [y/N]: ', 'cyan'));
     const autoApprove = autoChoice.toLowerCase().startsWith('y');
     rl.close();
@@ -230,14 +252,34 @@ async function runSetup() {
         baseUrl: selected.baseUrl,
         autoApprove,
     };
+    // Save API key if user entered one
+    if (apiKey) {
+        config.apiKey = apiKey;
+    }
     saveConfig(config);
     console.log(fmt('\n✓ Config saved to ~/.codebot/config.json', 'green'));
     console.log(fmt(`  Model: ${config.model}`, 'dim'));
     console.log(fmt(`  Provider: ${config.provider}`, 'dim'));
+    if (apiKey) {
+        console.log(fmt(`  API Key: ${'*'.repeat(Math.min(apiKey.length, 20))}`, 'dim'));
+    }
     if (autoApprove) {
         console.log(fmt(`  Mode: AUTONOMOUS`, 'yellow'));
     }
     console.log(fmt(`\nRun ${fmt('codebot', 'bold')} to start. Run ${fmt('codebot --setup', 'bold')} to reconfigure.\n`, 'dim'));
     return config;
 }
+/** Get the URL where users can get API keys for each provider */
+function getKeyUrl(provider) {
+    switch (provider) {
+        case 'openai': return 'https://platform.openai.com/api-keys';
+        case 'anthropic': return 'https://console.anthropic.com/settings/keys';
+        case 'gemini': return 'https://aistudio.google.com/app/apikey';
+        case 'deepseek': return 'https://platform.deepseek.com/api_keys';
+        case 'groq': return 'https://console.groq.com/keys';
+        case 'mistral': return 'https://console.mistral.ai/api-keys';
+        case 'xai': return 'https://console.x.ai/';
+        default: return 'Check provider documentation';
+    }
+}
 //# sourceMappingURL=setup.js.map

package/dist/tools/browser.js

@@ -1,15 +1,79 @@
 "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.BrowserTool = void 0;
 const cdp_1 = require("../browser/cdp");
 const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
 // Shared browser instance across tool calls
 let client = null;
 let debugPort = 9222;
+const CHROME_DATA_DIR = path.join(os.homedir(), '.codebot', 'chrome-profile');
+/** Kill any Chrome using our debug port or data dir (but NEVER kill ourselves) */
+function killExistingChrome() {
+    // Close our own CDP connection first so we don't hold the port
+    if (client) {
+        try {
+            client.close();
+        }
+        catch { /* ignore */ }
+        client = null;
+    }
+    const { execSync } = require('child_process');
+    const myPid = process.pid;
+    try {
+        if (process.platform === 'win32') {
+            execSync(`for /f "tokens=5" %a in ('netstat -aon ^| findstr :${debugPort}') do taskkill /F /PID %a`, { stdio: 'ignore' });
+        }
+        else {
+            // Kill Chrome/Chromium processes on our debug port — exclude our own PID
+            execSync(`lsof -ti:${debugPort} | grep -v "^${myPid}$" | xargs kill -9 2>/dev/null || true`, { stdio: 'ignore' });
+            // Also kill any Chrome using our data dir
+            execSync(`pkill -9 -f "chrome.*--user-data-dir=${CHROME_DATA_DIR}" 2>/dev/null || true`, { stdio: 'ignore' });
+        }
+    }
+    catch {
+        // ignore — nothing to kill
+    }
+}
 async function ensureConnected() {
     if (client?.isConnected())
         return client;
-    // Try connecting to existing Chrome
+    // Try connecting to existing Chrome with debug port
     try {
         const wsUrl = await (0, cdp_1.getDebuggerUrl)(debugPort);
         client = new cdp_1.CDPClient();
@@ -28,7 +92,9 @@ async function ensureConnected() {
         return client;
     }
     catch {
-        // Chrome not running with debugging — try to launch it
+        // Can't connect — kill stale processes and launch fresh
+        killExistingChrome();
+        await new Promise(r => setTimeout(r, 500));
     }
     // Launch Chrome with debugging
     const chromePaths = process.platform === 'win32'
@@ -55,14 +121,49 @@ async function ensureConnected() {
                 'chromium',
             ];
     let launched = false;
-    for (const chromePath of chromePaths) {
-        try {
-            (0, child_process_1.execSync)(`"${chromePath}" --remote-debugging-port=${debugPort} --no-first-run --no-default-browser-check about:blank &`, { stdio: 'ignore', timeout: 5000 });
-            launched = true;
-            break;
+    // Create isolated Chrome profile dir so it doesn't conflict with user's running Chrome
+    fs.mkdirSync(CHROME_DATA_DIR, { recursive: true });
+    const chromeArgs = [
+        `--remote-debugging-port=${debugPort}`,
+        `--user-data-dir=${CHROME_DATA_DIR}`,
+        '--no-first-run',
+        '--no-default-browser-check',
+        '--disable-background-timer-throttling',
+        '--disable-backgrounding-occluded-windows',
+        'about:blank',
+    ];
+    // On macOS, launch directly (not via 'open -a' which reuses existing instance)
+    if (process.platform === 'darwin') {
+        const macPaths = [
+            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+            '/Applications/Chromium.app/Contents/MacOS/Chromium',
+            '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+        ];
+        for (const chromePath of macPaths) {
+            try {
+                if (fs.existsSync(chromePath)) {
+                    const child = (0, child_process_1.spawn)(chromePath, chromeArgs, { stdio: 'ignore', detached: true });
+                    child.unref();
+                    launched = true;
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
         }
-        catch {
-            continue;
+    }
+    if (!launched) {
+        for (const chromePath of chromePaths) {
+            try {
+                const child = (0, child_process_1.spawn)(chromePath, chromeArgs, { stdio: 'ignore', detached: true });
+                child.unref();
+                launched = true;
+                break;
+            }
+            catch {
+                continue;
+            }
         }
     }
     if (!launched) {
@@ -151,16 +252,30 @@ class BrowserTool {
         if (!url.startsWith('http://') && !url.startsWith('https://')) {
             url = 'https://' + url;
         }
+        // Set up load event listener BEFORE navigating
+        const loadPromise = cdp.waitForEvent('Page.loadEventFired', 15000);
         await cdp.send('Page.navigate', { url });
-        // Wait for page load
-        await new Promise(r => setTimeout(r, 2000));
-        // Get page title
+        // Wait for actual page load event (up to 15s)
+        await loadPromise;
+        // Extra delay for SPA hydration (React, Next.js, etc.)
+        await new Promise(r => setTimeout(r, 1500));
+        // Get final URL (after redirects) and page title
         const result = await cdp.send('Runtime.evaluate', {
-            expression: 'document.title',
+            expression: 'JSON.stringify({ title: document.title, url: window.location.href })',
             returnByValue: true,
         });
-        const title = result.result?.value || 'untitled';
-        return `Navigated to: ${url}\nTitle: ${title}`;
+        const val = result.result?.value;
+        let title = 'untitled';
+        let finalUrl = url;
+        try {
+            const parsed = JSON.parse(val);
+            title = parsed.title || 'untitled';
+            finalUrl = parsed.url || url;
+        }
+        catch {
+            // fallback
+        }
+        return `Navigated to: ${finalUrl}\nTitle: ${title}`;
     }
     async getContent() {
         const cdp = await ensureConnected();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebot-ai",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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",
@@ -33,11 +33,11 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/AscendralSoftware/codebot-ai.git"
+    "url": "git+https://github.com/zanderone1980/codebot-ai.git"
   },
-  "homepage": "https://github.com/AscendralSoftware/codebot-ai#readme",
+  "homepage": "https://github.com/zanderone1980/codebot-ai#readme",
   "bugs": {
-    "url": "https://github.com/AscendralSoftware/codebot-ai/issues"
+    "url": "https://github.com/zanderone1980/codebot-ai/issues"
   },
   "engines": {
     "node": ">=18.0.0"