berget 1.3.0 → 1.4.0

package/dist/src/commands/chat.js

@@ -8,6 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -21,6 +28,7 @@ const api_key_service_1 = require("../services/api-key-service");
 const auth_service_1 = require("../services/auth-service");
 const error_handler_1 = require("../utils/error-handler");
 const default_api_key_1 = require("../utils/default-api-key");
+const markdown_renderer_1 = require("../utils/markdown-renderer");
 /**
  * Helper function to get user confirmation
  */
@@ -48,14 +56,16 @@ function registerChatCommands(program) {
     chat
         .command(command_structure_1.SUBCOMMANDS.CHAT.RUN)
         .description('Run a chat session with a specified model')
-        .argument('[model]', 'Model to use (default: google/gemma-3-27b-it)')
+        .argument('[model]', 'Model to use (default: openai/gpt-oss)')
+        .argument('[message]', 'Message to send directly (skips interactive mode)')
         .option('-s, --system <message>', 'System message')
         .option('-t, --temperature <temp>', 'Temperature (0-1)', parseFloat)
         .option('-m, --max-tokens <tokens>', 'Maximum tokens to generate', parseInt)
         .option('-k, --api-key <key>', 'API key to use for this chat session')
         .option('--api-key-id <id>', 'ID of the API key to use from your saved keys')
-        .option('--stream', 'Stream the response')
-        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        .option('--no-stream', 'Disable streaming (streaming is enabled by default)')
+        .action((model, message, options) => __awaiter(this, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
         try {
             const chatService = chat_service_1.ChatService.getInstance();
             // Check if we have an API key or need to get one
@@ -167,11 +177,6 @@ function registerChatCommands(program) {
                     return;
                 }
             }
-            // Set up readline interface for user input
-            const rl = readline_1.default.createInterface({
-                input: process.stdin,
-                output: process.stdout,
-            });
             // Prepare messages array
             const messages = [];
             // Add system message if provided
@@ -181,12 +186,134 @@ function registerChatCommands(program) {
                     content: options.system,
                 });
             }
+            // Check if input is being piped in
+            let inputMessage = message;
+            let stdinContent = '';
+            if (!process.stdin.isTTY) {
+                // Read from stdin (piped input)
+                const chunks = [];
+                try {
+                    for (var _d = true, _e = __asyncValues(process.stdin), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const chunk = _c;
+                        chunks.push(chunk);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                stdinContent = Buffer.concat(chunks).toString('utf8').trim();
+            }
+            // Combine stdin content with message if both exist
+            if (stdinContent && message) {
+                inputMessage = `${stdinContent}\n\n${message}`;
+            }
+            else if (stdinContent && !message) {
+                inputMessage = stdinContent;
+            }
+            // If a message is provided (either as argument, from stdin, or both), send it directly and exit
+            if (inputMessage) {
+                // Add user message
+                messages.push({
+                    role: 'user',
+                    content: inputMessage,
+                });
+                try {
+                    // Call the API
+                    const completionOptions = {
+                        model: model || 'openai/gpt-oss',
+                        messages: messages,
+                        temperature: options.temperature !== undefined ? options.temperature : 0.7,
+                        max_tokens: options.maxTokens || 4096,
+                        stream: options.stream !== false
+                    };
+                    // Only add apiKey if it actually exists
+                    if (apiKey) {
+                        completionOptions.apiKey = apiKey;
+                    }
+                    // Add streaming support (now default)
+                    if (completionOptions.stream) {
+                        let assistantResponse = '';
+                        // Stream the response in real-time
+                        completionOptions.onChunk = (chunk) => {
+                            if (chunk.choices && chunk.choices[0] && chunk.choices[0].delta && chunk.choices[0].delta.content) {
+                                const content = chunk.choices[0].delta.content;
+                                try {
+                                    process.stdout.write(content);
+                                }
+                                catch (error) {
+                                    // Handle EPIPE errors gracefully (when pipe is closed)
+                                    if (error.code === 'EPIPE') {
+                                        // Stop streaming if the pipe is closed
+                                        return;
+                                    }
+                                    throw error;
+                                }
+                                assistantResponse += content;
+                            }
+                        };
+                        try {
+                            yield chatService.createCompletion(completionOptions);
+                        }
+                        catch (streamError) {
+                            console.error(chalk_1.default.red('\nStreaming error:'), streamError);
+                            // Fallback to non-streaming if streaming fails
+                            console.log(chalk_1.default.yellow('Falling back to non-streaming mode...'));
+                            completionOptions.stream = false;
+                            delete completionOptions.onChunk;
+                            const response = yield chatService.createCompletion(completionOptions);
+                            if (response && response.choices && response.choices[0] && response.choices[0].message) {
+                                assistantResponse = response.choices[0].message.content;
+                                console.log(assistantResponse);
+                            }
+                        }
+                        console.log(); // Add newline at the end
+                        return;
+                    }
+                    const response = yield chatService.createCompletion(completionOptions);
+                    // Check if response has the expected structure
+                    if (!response ||
+                        !response.choices ||
+                        !response.choices[0] ||
+                        !response.choices[0].message) {
+                        console.error(chalk_1.default.red('Error: Unexpected response format from API'));
+                        console.error(chalk_1.default.red('Response:', JSON.stringify(response, null, 2)));
+                        throw new Error('Unexpected response format from API');
+                    }
+                    // Get assistant's response
+                    const assistantMessage = response.choices[0].message.content;
+                    // Display the response
+                    if ((0, markdown_renderer_1.containsMarkdown)(assistantMessage)) {
+                        console.log((0, markdown_renderer_1.renderMarkdown)(assistantMessage));
+                    }
+                    else {
+                        console.log(assistantMessage);
+                    }
+                    return;
+                }
+                catch (error) {
+                    console.error(chalk_1.default.red('Error: Failed to get response'));
+                    if (error instanceof Error) {
+                        console.error(chalk_1.default.red(error.message));
+                    }
+                    process.exit(1);
+                }
+            }
+            // Set up readline interface for user input (only for interactive mode)
+            const rl = readline_1.default.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
             console.log(chalk_1.default.cyan('Chat with Berget AI (type "exit" to quit)'));
             console.log(chalk_1.default.cyan('----------------------------------------'));
             // Start the conversation loop
             const askQuestion = () => {
                 rl.question(chalk_1.default.green('You: '), (input) => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
                     // Check if user wants to exit
                     if (input.toLowerCase() === 'exit') {
                         console.log(chalk_1.default.cyan('Goodbye!'));
@@ -201,28 +328,53 @@ function registerChatCommands(program) {
                     try {
                         // Call the API
                         const completionOptions = {
-                            model: ((_a = options.args) === null || _a === void 0 ? void 0 : _a[0]) || 'google/gemma-3-27b-it',
+                            model: model || 'openai/gpt-oss',
                             messages: messages,
                             temperature: options.temperature !== undefined ? options.temperature : 0.7,
                             max_tokens: options.maxTokens || 4096,
-                            stream: options.stream || false
+                            stream: options.stream !== false
                         };
                         // Only add apiKey if it actually exists
                         if (apiKey) {
                             completionOptions.apiKey = apiKey;
                         }
-                        // Add streaming support
-                        if (options.stream) {
+                        // Add streaming support (now default)
+                        if (completionOptions.stream) {
                             let assistantResponse = '';
-                            process.stdout.write(chalk_1.default.blue('Assistant: '));
+                            console.log(chalk_1.default.blue('Assistant: '));
+                            // Stream the response in real-time
                             completionOptions.onChunk = (chunk) => {
                                 if (chunk.choices && chunk.choices[0] && chunk.choices[0].delta && chunk.choices[0].delta.content) {
                                     const content = chunk.choices[0].delta.content;
-                                    process.stdout.write(content);
+                                    try {
+                                        process.stdout.write(content);
+                                    }
+                                    catch (error) {
+                                        // Handle EPIPE errors gracefully (when pipe is closed)
+                                        if (error.code === 'EPIPE') {
+                                            // Stop streaming if the pipe is closed
+                                            return;
+                                        }
+                                        throw error;
+                                    }
                                     assistantResponse += content;
                                 }
                             };
-                            yield chatService.createCompletion(completionOptions);
+                            try {
+                                yield chatService.createCompletion(completionOptions);
+                            }
+                            catch (streamError) {
+                                console.error(chalk_1.default.red('\nStreaming error:'), streamError);
+                                // Fallback to non-streaming if streaming fails
+                                console.log(chalk_1.default.yellow('Falling back to non-streaming mode...'));
+                                completionOptions.stream = false;
+                                delete completionOptions.onChunk;
+                                const response = yield chatService.createCompletion(completionOptions);
+                                if (response && response.choices && response.choices[0] && response.choices[0].message) {
+                                    assistantResponse = response.choices[0].message.content;
+                                    console.log(assistantResponse);
+                                }
+                            }
                             console.log('\n');
                             // Add assistant response to messages
                             messages.push({
@@ -256,7 +408,14 @@ function registerChatCommands(program) {
                             content: assistantMessage,
                         });
                         // Display the response
-                        console.log(chalk_1.default.blue('Assistant: ') + assistantMessage);
+                        console.log(chalk_1.default.blue('Assistant: '));
+                        // Check if the response contains markdown and render it if it does
+                        if ((0, markdown_renderer_1.containsMarkdown)(assistantMessage)) {
+                            console.log((0, markdown_renderer_1.renderMarkdown)(assistantMessage));
+                        }
+                        else {
+                            console.log(assistantMessage);
+                        }
                         console.log(); // Empty line for better readability
                         // Continue the conversation
                         askQuestion();
@@ -333,11 +492,12 @@ function registerChatCommands(program) {
             }
             console.log(chalk_1.default.bold('Available Chat Models:'));
             console.log(chalk_1.default.dim('─'.repeat(70)));
-            console.log(chalk_1.default.dim('MODEL ID'.padEnd(30)) +
-                chalk_1.default.dim('OWNER'.padEnd(25)) +
+            console.log(chalk_1.default.dim('MODEL ID'.padEnd(40)) +
                 chalk_1.default.dim('CAPABILITIES'));
             console.log(chalk_1.default.dim('─'.repeat(70)));
-            models.data.forEach((model) => {
+            // Filter to only show active models
+            const activeModels = models.data.filter((model) => model.active === true);
+            activeModels.forEach((model) => {
                 const capabilities = [];
                 if (model.capabilities.vision)
                     capabilities.push('vision');
@@ -345,8 +505,9 @@ function registerChatCommands(program) {
                     capabilities.push('function_calling');
                 if (model.capabilities.json_mode)
                     capabilities.push('json_mode');
-                console.log(model.id.padEnd(30) +
-                    model.owned_by.padEnd(25) +
+                // Format model ID in Huggingface compatible format (owner/model)
+                const modelId = `${model.owned_by.toLowerCase()}/${model.id}`.padEnd(40);
+                console.log(modelId +
                     capabilities.join(', '));
             });
         }

package/dist/src/commands/models.js

@@ -44,7 +44,7 @@ function registerModelCommands(program) {
                     throw new Error(JSON.stringify(error));
                 response = data;
                 console.log('Available Models:');
-                console.log('ID                      OWNED BY                  CAPABILITIES');
+                console.log('ID                                                 OWNED BY                 CAPABILITIES');
                 // Ensure response has the expected structure
                 const modelData = response;
                 if (modelData.data) {
@@ -56,7 +56,7 @@ function registerModelCommands(program) {
                             capabilities.push('function_calling');
                         if (model.capabilities.json_mode)
                             capabilities.push('json_mode');
-                        console.log(`${model.id.padEnd(24)} ${model.owned_by.padEnd(25)} ${capabilities.join(', ')}`);
+                        console.log(`${model.root.padEnd(50)} ${model.owned_by.padEnd(24)} ${capabilities.join(', ')}`);
                     });
                 }
             }

package/dist/src/services/chat-service.js

@@ -256,26 +256,26 @@ class ChatService {
      */
     handleStreamingResponse(options, headers) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.logger.debug('Handling streaming response');
-            // Create URL with query parameters
-            const url = new URL(`${client_1.API_BASE_URL}/v1/chat/completions`);
-            // Debug the headers and options
-            logger_1.logger.debug('Streaming headers:');
-            logger_1.logger.debug(JSON.stringify(headers, null, 2));
-            logger_1.logger.debug('Streaming options:');
-            logger_1.logger.debug(JSON.stringify(Object.assign(Object.assign({}, options), { onChunk: options.onChunk ? 'function present' : 'no function' }), null, 2));
+            // Use the same base URL as the client
+            const baseUrl = process.env.API_BASE_URL || 'https://api.berget.ai';
+            const url = new URL(`${baseUrl}/v1/chat/completions`);
             try {
+                logger_1.logger.debug(`Making streaming request to: ${url.toString()}`);
+                logger_1.logger.debug(`Headers:`, JSON.stringify(headers, null, 2));
+                logger_1.logger.debug(`Body:`, JSON.stringify(options, null, 2));
                 // Make fetch request directly to handle streaming
                 const response = yield fetch(url.toString(), {
                     method: 'POST',
                     headers: Object.assign({ 'Content-Type': 'application/json', Accept: 'text/event-stream' }, headers),
                     body: JSON.stringify(options),
                 });
+                logger_1.logger.debug(`Response status: ${response.status}`);
+                logger_1.logger.debug(`Response headers:`, JSON.stringify(Object.fromEntries(response.headers.entries()), null, 2));
                 if (!response.ok) {
                     const errorText = yield response.text();
                     logger_1.logger.error(`Stream request failed: ${response.status} ${response.statusText}`);
-                    logger_1.logger.debug(`Error response: ${errorText}`);
-                    throw new Error(`Stream request failed: ${response.status} ${response.statusText}`);
+                    logger_1.logger.error(`Error response: ${errorText}`);
+                    throw new Error(`Stream request failed: ${response.status} ${response.statusText} - ${errorText}`);
                 }
                 if (!response.body) {
                     throw new Error('No response body received');

package/dist/src/utils/markdown-renderer.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsMarkdown = exports.renderMarkdown = void 0;
+const marked_1 = require("marked");
+const marked_terminal_1 = __importDefault(require("marked-terminal"));
+const chalk_1 = __importDefault(require("chalk"));
+// Configure marked to use the terminal renderer
+marked_1.marked.setOptions({
+    renderer: new marked_terminal_1.default({
+        // Customize the rendering options
+        code: chalk_1.default.cyan,
+        blockquote: chalk_1.default.gray.italic,
+        table: chalk_1.default.white,
+        listitem: chalk_1.default.yellow,
+        strong: chalk_1.default.bold,
+        em: chalk_1.default.italic,
+        heading: chalk_1.default.bold.blueBright,
+        hr: chalk_1.default.gray,
+        link: chalk_1.default.blue.underline,
+        // Adjust the width to fit the terminal
+        width: process.stdout.columns || 80,
+        // Customize code block rendering
+        codespan: chalk_1.default.cyan
+    })
+});
+/**
+ * Render markdown text to terminal-friendly formatted text
+ * @param markdown The markdown text to render
+ * @returns Formatted text for terminal display
+ */
+function renderMarkdown(markdown) {
+    if (!markdown)
+        return '';
+    try {
+        // Convert markdown to terminal-friendly text
+        return (0, marked_1.marked)(markdown);
+    }
+    catch (error) {
+        // If rendering fails, return the original text
+        console.error(`Error rendering markdown: ${error}`);
+        return markdown;
+    }
+}
+exports.renderMarkdown = renderMarkdown;
+/**
+ * Check if a string contains markdown formatting
+ * @param text The text to check
+ * @returns True if the text contains markdown formatting
+ */
+function containsMarkdown(text) {
+    if (!text)
+        return false;
+    // Check for common markdown patterns
+    const markdownPatterns = [
+        /^#+\s+/m, // Headers
+        /\*\*.*?\*\*/, // Bold
+        /\*.*?\*/, // Italic
+        /`.*?`/, // Inline code
+        /```[\s\S]*?```/, // Code blocks
+        /\[.*?\]\(.*?\)/, // Links
+        /^\s*[-*+]\s+/m, // Lists
+        /^\s*\d+\.\s+/m, // Numbered lists
+        /^\s*>\s+/m, // Blockquotes
+        /\|.*\|.*\|/, // Tables
+        /^---+$/m, // Horizontal rules
+        /^===+$/m // Alternative headers
+    ];
+    return markdownPatterns.some(pattern => pattern.test(text));
+}
+exports.containsMarkdown = containsMarkdown;

package/dist/tests/commands/chat.test.js

@@ -0,0 +1,107 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const commander_1 = require("commander");
+const chat_1 = require("../../src/commands/chat");
+const chat_service_1 = require("../../src/services/chat-service");
+const default_api_key_1 = require("../../src/utils/default-api-key");
+// Mock dependencies
+vitest_1.vi.mock('../../src/services/chat-service');
+vitest_1.vi.mock('../../src/utils/default-api-key');
+vitest_1.vi.mock('readline', () => ({
+    createInterface: vitest_1.vi.fn(() => ({
+        question: vitest_1.vi.fn(),
+        close: vitest_1.vi.fn()
+    }))
+}));
+(0, vitest_1.describe)('Chat Commands', () => {
+    let program;
+    let mockChatService;
+    let mockDefaultApiKeyManager;
+    (0, vitest_1.beforeEach)(() => {
+        program = new commander_1.Command();
+        // Mock ChatService
+        mockChatService = {
+            createCompletion: vitest_1.vi.fn(),
+            listModels: vitest_1.vi.fn()
+        };
+        vitest_1.vi.mocked(chat_service_1.ChatService.getInstance).mockReturnValue(mockChatService);
+        // Mock DefaultApiKeyManager
+        mockDefaultApiKeyManager = {
+            getDefaultApiKeyData: vitest_1.vi.fn(),
+            promptForDefaultApiKey: vitest_1.vi.fn()
+        };
+        vitest_1.vi.mocked(default_api_key_1.DefaultApiKeyManager.getInstance).mockReturnValue(mockDefaultApiKeyManager);
+        (0, chat_1.registerChatCommands)(program);
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.describe)('chat run command', () => {
+        (0, vitest_1.it)('should use openai/gpt-oss as default model', () => {
+            const chatCommand = program.commands.find(cmd => cmd.name() === 'chat');
+            const runCommand = chatCommand === null || chatCommand === void 0 ? void 0 : chatCommand.commands.find(cmd => cmd.name() === 'run');
+            (0, vitest_1.expect)(runCommand).toBeDefined();
+            // Check the help text which contains the default model
+            const helpText = runCommand === null || runCommand === void 0 ? void 0 : runCommand.helpInformation();
+            (0, vitest_1.expect)(helpText).toContain('openai/gpt-oss');
+        });
+        (0, vitest_1.it)('should have streaming enabled by default', () => {
+            const chatCommand = program.commands.find(cmd => cmd.name() === 'chat');
+            const runCommand = chatCommand === null || chatCommand === void 0 ? void 0 : chatCommand.commands.find(cmd => cmd.name() === 'run');
+            (0, vitest_1.expect)(runCommand).toBeDefined();
+            // Check that the option is --no-stream (meaning streaming is default)
+            const streamOption = runCommand === null || runCommand === void 0 ? void 0 : runCommand.options.find(opt => opt.long === '--no-stream');
+            (0, vitest_1.expect)(streamOption).toBeDefined();
+            (0, vitest_1.expect)(streamOption === null || streamOption === void 0 ? void 0 : streamOption.description).toContain('Disable streaming');
+        });
+        (0, vitest_1.it)('should create completion with correct default options', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock API key
+            process.env.BERGET_API_KEY = 'test-key';
+            // Mock successful completion
+            mockChatService.createCompletion.mockResolvedValue({
+                choices: [{
+                        message: { content: 'Test response' }
+                    }]
+            });
+            // This would normally test the actual command execution
+            // but since it involves readline interaction, we just verify
+            // that the service would be called with correct defaults
+            (0, vitest_1.expect)(mockChatService.createCompletion).not.toHaveBeenCalled();
+            // Clean up
+            delete process.env.BERGET_API_KEY;
+        }));
+    });
+    (0, vitest_1.describe)('chat list command', () => {
+        (0, vitest_1.it)('should list available models', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockModels = {
+                data: [
+                    {
+                        id: 'gpt-oss',
+                        owned_by: 'openai',
+                        active: true,
+                        capabilities: {
+                            vision: false,
+                            function_calling: true,
+                            json_mode: true
+                        }
+                    }
+                ]
+            };
+            mockChatService.listModels.mockResolvedValue(mockModels);
+            const chatCommand = program.commands.find(cmd => cmd.name() === 'chat');
+            const listCommand = chatCommand === null || chatCommand === void 0 ? void 0 : chatCommand.commands.find(cmd => cmd.name() === 'list');
+            (0, vitest_1.expect)(listCommand).toBeDefined();
+            (0, vitest_1.expect)(listCommand === null || listCommand === void 0 ? void 0 : listCommand.description()).toBe('List available chat models');
+        }));
+    });
+});

package/dist/vitest.config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("vitest/config");
+exports.default = (0, config_1.defineConfig)({
+    test: {
+        globals: true,
+        environment: 'node',
+    },
+});

package/examples/README.md

@@ -0,0 +1,95 @@
+# Berget CLI Examples
+
+This folder contains practical examples of how you can use Berget CLI for various automation tasks.
+
+## Scripts
+
+### smart-commit.sh
+Automatic generation of conventional commit messages based on git diff.
+
+```bash
+# Make the script executable
+chmod +x examples/smart-commit.sh
+
+# Use it
+git add .
+./examples/smart-commit.sh
+```
+
+### ai-review.sh
+AI-driven code review that analyzes files for quality, bugs, and security aspects.
+
+```bash
+# Make the script executable
+chmod +x examples/ai-review.sh
+
+# Review a file
+./examples/ai-review.sh src/main.js
+```
+
+### security-check.sh
+Security review of git commits that blocks commits with critical security risks.
+
+```bash
+# Make the script executable
+chmod +x examples/security-check.sh
+
+# Run security check
+git add .
+./examples/security-check.sh
+```
+
+## Installation
+
+To use these scripts:
+
+1. Copy them to your `~/bin` folder or another location in your PATH
+2. Make them executable with `chmod +x`
+3. Make sure you have Berget CLI installed and configured
+
+```bash
+# Copy to ~/bin
+cp examples/*.sh ~/bin/
+
+# Make them executable
+chmod +x ~/bin/smart-commit.sh ~/bin/ai-review.sh ~/bin/security-check.sh
+```
+
+## Global Security Hook
+
+For maximum security, you can install a global git hook that automatically runs security checks before every push:
+
+```bash
+# Install the global security hook
+chmod +x examples/install-global-security-hook.sh
+./examples/install-global-security-hook.sh
+```
+
+This will:
+- Create a global pre-push hook that runs on all repositories
+- Automatically analyze commits for security vulnerabilities using OWASP Top 20
+- Block pushes with critical security issues
+- Warn about medium-risk issues and allow you to choose
+
+The hook will run automatically before every `git push`. To bypass it temporarily (not recommended):
+```bash
+git push --no-verify
+```
+
+## Git Aliases
+
+You can also add these as git aliases:
+
+```bash
+git config --global alias.ai-commit '!~/bin/smart-commit.sh'
+git config --global alias.ai-review '!~/bin/ai-review.sh'
+git config --global alias.security-check '!~/bin/security-check.sh'
+```
+
+Then you can use:
+
+```bash
+git ai-commit
+git ai-review src/main.js
+git security-check
+```

package/examples/ai-review.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+# AI code review using Berget AI
+# Usage: ./ai-review.sh <filename>
+set -e
+
+if [[ $# -eq 0 ]]; then
+    echo "Usage: ai-review <file>"
+    exit 1
+fi
+
+FILE="$1"
+
+if [[ ! -f "$FILE" ]]; then
+    echo "Error: File '$FILE' does not exist"
+    exit 1
+fi
+
+echo "🔍 Reviewing $FILE with AI..."
+echo "================================"
+
+cat "$FILE" | npx berget chat run openai/gpt-oss "
+Review this code and provide feedback on:
+1. Code quality and readability
+2. Potential bugs or issues
+3. Performance improvements
+4. Best practices
+5. Security aspects
+
+Provide concrete suggestions for improvements:
+"