berget 1.3.1 → 1.4.0

package/.github/workflows/publish.yml

@@ -0,0 +1,56 @@
+name: Publish to NPM
+
+on:
+  push:
+    branches:
+      - main
+  release:
+    types: [published]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm run test:run
+
+      - name: Build project
+        run: npm run build
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main' || github.event_name == 'release'
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+          registry-url: 'https://registry.npmjs.org'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build project
+        run: npm run build
+
+      - name: Publish to NPM
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/test.yml

@@ -0,0 +1,38 @@
+name: Test
+
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [18, 20]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm run test:run
+
+      - name: Build project
+        run: npm run build
+
+      - name: Check TypeScript
+        run: npx tsc --noEmit

package/README.md

@@ -1,33 +1,193 @@
 # Berget CLI
 
-A command-line interface for interacting with the Berget AI infrastructure.
+A command-line tool for interacting with Berget AI's infrastructure and AI models.
 
 ## Installation
 
 ```bash
 npm install -g berget
+# or use directly with npx
+npx berget --help
 ```
 
 ## Authentication
 
-The CLI uses OAuth-based authentication with automatic token refresh.
+Before you can use the CLI, you need to authenticate:
 
-### Login
+```bash
+# Login with OAuth
+npx berget auth login
+
+# Create an API key
+npx berget api-keys create --name "My CLI Key"
+
+# Or use environment variable
+export BERGET_API_KEY=sk_ber_your_api_key_here
+```
+
+## Chat Command
+
+### Basic Usage
+
+```bash
+# Interactive chat session
+npx berget chat run
+
+# Use specific model
+npx berget chat run openai/gpt-oss
+
+# Send direct message
+npx berget chat run openai/gpt-oss "Explain what Docker is"
+
+# Use pipe for input
+echo "What is Kubernetes?" | npx berget chat run openai/gpt-oss
+```
+
+### Practical Use Cases
+
+#### 1. Git Commit Messages
 
 ```bash
-berget auth login
+# Generate commit message from git diff
+git diff | npx berget chat run openai/gpt-oss "Create a conventional commit message for this diff. Reply with only the message:"
+
+# Use as alias
+alias gitcommit='git diff | npx berget chat run openai/gpt-oss "Generate a conventional commit message for this diff. Reply with only the commit message, nothing else:"'
 ```
 
-This will open a browser window to authenticate with Berget. After successful authentication, your access token and refresh token will be stored securely in `~/.berget/auth.json`.
+#### 2. Code Review and Explanations
 
-### Token Refresh
+```bash
+# Explain code
+cat src/main.js | npx berget chat run openai/gpt-oss "Explain what this code does:"
 
-The CLI automatically handles token refresh when:
+# Find bugs
+cat problematic-file.py | npx berget chat run openai/gpt-oss "Analyze this code and find potential bugs:"
 
-1. The access token is about to expire (within 10 minutes of expiration)
-2. A request returns a 401 Unauthorized error
+# Improvement suggestions
+git diff | npx berget chat run openai/gpt-oss "Give suggestions for improvements to this code change:"
+```
 
-The refresh mechanism uses the stored refresh token to obtain a new access token without requiring you to log in again. If the refresh token itself is expired or invalid, you'll be prompted to log in again.
+#### 3. Documentation
+
+```bash
+# Generate README
+ls -la | npx berget chat run openai/gpt-oss "Create a README.md for this project based on the file structure:"
+
+# Comment code
+cat uncommented-code.js | npx berget chat run openai/gpt-oss "Add JSDoc comments to this code:"
+```
+
+#### 4. System Administration
+
+```bash
+# Analyze logs
+tail -n 100 /var/log/nginx/error.log | npx berget chat run openai/gpt-oss "Analyze these error logs and suggest solutions:"
+
+# Explain commands
+npx berget chat run openai/gpt-oss "Explain what this bash command does: find . -name '*.js' -exec grep -l 'TODO' {} \;"
+```
+
+## Useful Bash/Zsh Aliases
+
+Add these to your `~/.bashrc`, `~/.zshrc` or similar:
+
+```bash
+# Git-related aliases
+alias gai='git diff | npx berget chat run openai/gpt-oss "Generate a conventional commit message for this diff. Reply with only the commit message, nothing else:"'
+alias gexplain='git log --oneline -10 | npx berget chat run openai/gpt-oss "Explain what these commits do:"'
+alias gsec='~/bin/security-check'
+
+# Code-related aliases
+alias explain='npx berget chat run openai/gpt-oss "Explain this code:"'
+alias review='npx berget chat run openai/gpt-oss "Review this code and give improvement suggestions:"'
+alias debug='npx berget chat run openai/gpt-oss "Find and explain potential bugs in this code:"'
+
+# Documentation aliases
+alias docgen='npx berget chat run openai/gpt-oss "Generate documentation for this code:"'
+alias readme='ls -la | npx berget chat run openai/gpt-oss "Create a README.md for this project:"'
+
+# System aliases
+alias loganalyze='npx berget chat run openai/gpt-oss "Analyze these logs and suggest solutions:"'
+alias cmdexplain='npx berget chat run openai/gpt-oss "Explain this command:"'
+
+# Quick AI assistant
+alias ai='npx berget chat run openai/gpt-oss'
+alias ask='npx berget chat run openai/gpt-oss'
+```
+
+## Advanced Examples
+
+See the `examples/` folder for complete scripts:
+
+- **smart-commit.sh** - Automatic generation of conventional commit messages
+- **ai-review.sh** - AI-driven code review
+- **security-check.sh** - Security review of commits
+
+```bash
+# Copy example scripts
+cp examples/*.sh ~/bin/
+chmod +x ~/bin/*.sh
+
+# Use them
+~/bin/smart-commit.sh
+~/bin/ai-review.sh src/main.js
+~/bin/security-check.sh
+```
+
+## Environment Variables
+
+```bash
+# API key (recommended)
+export BERGET_API_KEY=sk_ber_your_api_key_here
+
+# Debug mode
+export LOG_LEVEL=debug
+
+# Custom API base URL (if using your own instance)
+export API_BASE_URL=https://your-custom-api.example.com
+```
+
+## Tips and Tricks
+
+1. **Use pipes**: Combine with other Unix tools for powerful workflows
+2. **Short prompts**: Be specific but concise in your prompts for best results
+3. **Streaming**: Streaming is enabled by default for faster responses
+4. **Model selection**: Experiment with different models for different tasks
+5. **Aliases**: Create aliases for common use cases to save time
+
+## Command Reference
+
+- `auth login` - Login to Berget
+- `auth logout` - Logout from Berget
+- `auth whoami` - Show current user information
+- `api-keys list` - List API keys
+- `api-keys create` - Create a new API key
+- `models list` - List available AI models
+- `chat run` - Start a chat session with an AI model
+- `chat list` - List available chat models
+
+For a complete list of commands, run:
+
+```bash
+npx berget --help
+```
+
+## Troubleshooting
+
+```bash
+# Enable debug mode
+npx berget --debug chat run openai/gpt-oss "test"
+
+# Check authentication
+npx berget auth whoami
+
+# List available models
+npx berget chat list
+
+# Check API key status
+npx berget api-keys list
+```
 
 ## Development
 
@@ -36,12 +196,12 @@ The refresh mechanism uses the stored refresh token to obtain a new access token
 Clone the repository and install dependencies:
 
 ```bash
-git clone https://github.com/berget/cli.git
+git clone https://github.com/berget-ai/cli.git
 cd cli
 npm install
 ```
 
-### Testing Locally
+### Test Locally
 
 Use the `start` script to test the CLI locally with the `--local` flag:
 
@@ -62,31 +222,10 @@ npm start -- auth whoami
 npm start -- auth whoami --debug
 ```
 
-The `--debug` flag provides detailed information about token refresh attempts and API responses.
-
-### Testing Token Refresh
-
-To test the token refresh mechanism:
+## Contributing
 
-1. Log in with `npm start -- auth login`
-2. Make a request that requires authentication, like `npm start -- auth whoami`
-3. To force a token refresh, you can:
-   - Wait until the token is close to expiration
-   - Manually edit `~/.berget/auth.json` and set `expires_at` to a past timestamp
-   - Use the `--debug` flag to see the token refresh process in action
+Berget CLI is open source. Contributions are welcome!
 
-## Commands
-
-- `auth login` - Log in to Berget
-- `auth logout` - Log out from Berget
-- `auth whoami` - Show current user information
-- `api-keys list` - List API keys
-- `api-keys create` - Create a new API key
-- `models list` - List available AI models
-- `chat run` - Start a chat session with an AI model
-
-For a complete list of commands, run:
-
-```bash
-berget --help
-```
+- GitHub: [berget-ai/cli](https://github.com/berget-ai/cli)
+- Issues: [Report bugs](https://github.com/berget-ai/cli/issues)
+- Documentation: [docs.berget.ai](https://docs.berget.ai)

package/dist/package.json

@@ -1,17 +1,22 @@
 {
     "name": "berget",
-    "version": "1.3.1",
+    "version": "1.4.0",
     "main": "dist/index.js",
     "bin": {
         "berget": "dist/index.js"
     },
     "private": false,
+    "publishConfig": {
+        "access": "public"
+    },
     "scripts": {
         "start": "node --import tsx ./index.ts --local",
         "login": "node --import tsx ./index.ts --local auth login",
         "logout": "node --import tsx ./index.ts --local auth logout",
         "whoami": "node --import tsx ./index.ts --local auth whoami",
         "build": "tsc",
+        "test": "vitest",
+        "test:run": "vitest run",
         "prepublishOnly": "npm run build",
         "generate-types": "openapi-typescript https://api.berget.ai/openapi.json -o src/types/api.d.ts"
     },
@@ -23,7 +28,8 @@
         "@types/marked-terminal": "^6.1.1",
         "@types/node": "^20.11.20",
         "tsx": "^4.19.3",
-        "typescript": "^5.3.3"
+        "typescript": "^5.3.3",
+        "vitest": "^1.0.0"
     },
     "dependencies": {
         "chalk": "^4.1.2",

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 };
 };
@@ -49,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
@@ -168,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
@@ -182,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!'));
@@ -202,30 +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 = '';
                             console.log(chalk_1.default.blue('Assistant: '));
-                            // For streaming, we'll collect the response and render it at the end
-                            // since markdown needs the complete text to render properly
+                            // 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({

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');