@webdeb/gogi 1.0.0

package/README.md

@@ -0,0 +1,91 @@
+# 🍖 Gogi CLI
+
+Gogi is a lightweight, AI-powered terminal assistant built with Node.js. It runs locally on your machine and helps you accomplish tasks directly in your terminal by translating natural language into executable shell commands.
+
+Unlike other CLI assistants that require you to manage your own paid API keys, Gogi leverages the open-source `@mariozechner/pi-ai` library to implement **native Device-Code OAuth flows**. This means you can plug Gogi directly into your existing AI subscriptions (like ChatGPT Plus or GitHub Copilot)
+
+## ✨ Features
+
+- **Natural Language to Shell**: Tell Gogi what you want to do (e.g., `gogi how much space is left on my machine`) and it will propose the correct terminal command.
+- **Safe Execution Loop**: Gogi intercepts the AI's proposed commands and explicitly asks for your permission (`Allow? (y/N)`) before running anything. It will capture the `stdout` and `stderr` and feed it back to the LLM so it can learn from mistakes or chain commands together.
+- **Multi-Provider OAuth**: Sign in securely using your existing AI accounts. Supported providers include:
+  - `codex` (ChatGPT Plus/Pro subscription)
+  - `gemini` (Google Cloud)
+  - `github` (GitHub Copilot)
+- **Auto-Generated System Context**: On first run, Gogi automatically profiles your machine (OS, architecture, shell) and generates a `~/.gogi/system.md` file. It injects this into the LLM's system prompt so the AI always knows what operating system and shell it's working with.
+
+---
+
+## 🚀 Installation
+
+1. Clone or download the repository.
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+3. Build the TypeScript source and link it globally:
+   ```bash
+   npm run build
+   npm link
+   ```
+
+You can now use the `gogi` command from anywhere in your terminal!
+
+---
+
+## 🔑 Authentication
+
+Before using Gogi, you must authenticate it with a provider.
+
+```bash
+# Login with ChatGPT (Default)
+gogi login
+
+# Or specify a provider: 
+gogi login codex
+gogi login gemini
+gogi login github
+```
+
+This will trigger a standard OAuth flow. Gogi will open your browser, ask you to log in, and then securely store the resulting `access_token` in `~/.gogi/config.json`.
+
+Once you have logged into multiple providers, you can quickly switch the active provider being used for commands:
+
+```bash
+gogi provider gemini
+gogi provider codex
+```
+
+---
+
+## 💡 Usage
+
+Simply type `gogi` followed by your request:
+
+```bash
+gogi find all the .ts files in the current directory
+```
+
+```bash
+🤔 Gogi is thinking...
+✔ Gogi wants to run:
+  > find . -name "*.ts"
+Allow? Yes    
+
+Running...
+./src/index.ts
+./src/config.ts
+./src/agent.ts
+./src/auth.ts
+```
+
+If a command fails (e.g., a missing dependency), Gogi will read the error output and can automatically propose a follow-up command to fix the issue!
+
+---
+
+## ⚙️ Configuration
+
+Gogi stores its configuration in your home directory at `~/.gogi/`:
+
+- `~/.gogi/config.json`: Stores your active provider and OAuth access tokens securely.
+- `~/.gogi/system.md`: A markdown file containing context about your machine (OS, CPU, Shell). You can edit this file to give Gogi additional context or permanent custom instructions (e.g., "Always use fd instead of find").

package/dist/agent.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgent = runAgent;
+const pi_ai_1 = require("@mariozechner/pi-ai");
+const config_1 = require("./config");
+const prompts_1 = require("@inquirer/prompts");
+const child_process_1 = require("child_process");
+const util_1 = __importDefault(require("util"));
+const execPromise = util_1.default.promisify(child_process_1.exec);
+async function runAgent(prompt) {
+    const config = (0, config_1.getConfig)();
+    let apiKey = config.openaiApiKey;
+    let providerToUse = 'codex';
+    if (config.activeProvider && config.tokens && config.tokens[config.activeProvider]) {
+        apiKey = config.tokens[config.activeProvider];
+        providerToUse = config.activeProvider;
+    }
+    if (!apiKey) {
+        console.error('❌ No API key or token found. Please run `gogi login` first.');
+        process.exit(1);
+    }
+    let model;
+    if (providerToUse === 'codex') {
+        model = (0, pi_ai_1.getModel)('openai-codex', 'gpt-5.1-codex-mini');
+    }
+    else if (providerToUse === 'gemini') {
+        model = (0, pi_ai_1.getModel)('google-gemini-cli', 'gemini-2.5-flash');
+    }
+    else if (providerToUse === 'github') {
+        model = (0, pi_ai_1.getModel)('github-copilot', 'gpt-4o');
+    }
+    else {
+        console.warn(`Unknown provider ${providerToUse}, falling back to openai gpt-4o`);
+        model = (0, pi_ai_1.getModel)('openai', 'gpt-4o');
+    }
+    const tools = [
+        {
+            name: 'run_terminal_command',
+            description: 'Propose a terminal command for the user to execute.',
+            parameters: pi_ai_1.Type.Object({
+                command: pi_ai_1.Type.String({ description: 'The shell command to propose to the user. Do not wrap in markdown quotes.' })
+            })
+        }
+    ];
+    const systemDetails = (0, config_1.getSystemContext)();
+    const context = {
+        systemPrompt: `You are Gogi, a helpful terminal assistant running on a Mac terminal.
+You can propose shell commands to fulfill user requests using the \`run_terminal_command\` tool.
+Wait for the execution result before continuing. If a command fails, try to suggest an alternative or fix the issue.
+Keep your textual responses very concise unless asked to explain.
+
+=== SYSTEM CONTEXT ===
+${systemDetails}
+====================`,
+        messages: [
+            { role: 'user', content: prompt, timestamp: Date.now() }
+        ],
+        tools
+    };
+    console.log('🤔 Gogi is thinking...');
+    while (true) {
+        let response;
+        try {
+            response = await (0, pi_ai_1.complete)(model, context, { apiKey: config.openaiApiKey });
+        }
+        catch (err) {
+            console.error(`❌ API Error: ${err.message}`);
+            process.exit(1);
+        }
+        context.messages.push(response);
+        let hasToolCalls = false;
+        if (response.content) {
+            for (const block of response.content) {
+                if (block.type === 'text') {
+                    console.log(`\n🤖 ${block.text}`);
+                }
+                else if (block.type === 'toolCall' && block.name === 'run_terminal_command') {
+                    hasToolCalls = true;
+                    // @mariozechner/pi-ai automatically parses arguments
+                    const cmd = block.arguments.command;
+                    let answer = false;
+                    try {
+                        answer = await (0, prompts_1.confirm)({ message: `Gogi wants to run:\n  > \x1b[36m${cmd}\x1b[0m\nAllow?`, default: false });
+                    }
+                    catch (e) {
+                        if (e.name === 'ExitPromptError') {
+                            console.log('\nGoodbye!');
+                            process.exit(0);
+                        }
+                        throw e;
+                    }
+                    if (answer) {
+                        console.log('\nRunning...');
+                        try {
+                            const { stdout, stderr } = await execPromise(cmd);
+                            let toolOutput = '';
+                            if (stdout) {
+                                console.log(stdout); // Log STDOUT to the terminal directly
+                                toolOutput += `STDOUT:\n${stdout}\n`;
+                            }
+                            if (stderr) {
+                                console.error(`\x1b[31m${stderr}\x1b[0m`); // Log STDERR in red
+                                toolOutput += `STDERR:\n${stderr}\n`;
+                            }
+                            if (!toolOutput) {
+                                toolOutput = "Command executed successfully with no output.";
+                            }
+                            context.messages.push({
+                                role: 'toolResult',
+                                toolCallId: block.id,
+                                toolName: block.name,
+                                content: [{ type: 'text', text: toolOutput }],
+                                isError: false,
+                                timestamp: Date.now()
+                            });
+                        }
+                        catch (err) {
+                            console.error(`\x1b[31mExecution Error: ${err.message}\x1b[0m`);
+                            context.messages.push({
+                                role: 'toolResult',
+                                toolCallId: block.id,
+                                toolName: block.name,
+                                content: [{ type: 'text', text: `Error: ${err.message}` }],
+                                isError: true,
+                                timestamp: Date.now()
+                            });
+                        }
+                    }
+                    else {
+                        console.log('❌ Command denied.');
+                        context.messages.push({
+                            role: 'toolResult',
+                            toolCallId: block.id,
+                            toolName: block.name,
+                            content: [{ type: 'text', text: 'The user denied the execution of this command.' }],
+                            isError: true, // Mark as error so the model knows the command was rejected
+                            timestamp: Date.now()
+                        });
+                    }
+                }
+            }
+        }
+        if (!hasToolCalls) {
+            break;
+        }
+    }
+}

package/dist/auth.js

@@ -0,0 +1,95 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginFlow = loginFlow;
+const pi_ai_1 = require("@mariozechner/pi-ai");
+const config_1 = require("./config");
+const open_1 = __importDefault(require("open"));
+const readline = __importStar(require("readline"));
+async function loginFlow(provider = 'codex') {
+    console.log(`Starting login flow for provider: ${provider}...`);
+    let credentials;
+    if (provider === 'codex') {
+        credentials = await (0, pi_ai_1.loginOpenAICodex)({
+            onAuth: (info) => {
+                console.log(`\n🌐 Opening browser for sign-in... If it doesn't open automatically, visit:\n${info.url}`);
+                if (info.instructions)
+                    console.log(info.instructions);
+                (0, open_1.default)(info.url);
+            },
+            onPrompt: async (prompt) => {
+                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                return new Promise((resolve) => rl.question(`${prompt.message} `, (answer) => { rl.close(); resolve(answer); }));
+            }
+        });
+    }
+    else if (provider === 'gemini') {
+        credentials = await (0, pi_ai_1.loginGeminiCli)((info) => {
+            console.log(`\n🌐 Opening browser for sign-in... If it doesn't open automatically, visit:\n${info.url}`);
+            if (info.instructions)
+                console.log(info.instructions);
+            (0, open_1.default)(info.url);
+        });
+    }
+    else if (provider === 'github') {
+        credentials = await (0, pi_ai_1.loginGitHubCopilot)({
+            onAuth: (url, instructions) => {
+                console.log(`\n🌐 Please authenticate GitHub Copilot.`);
+                if (instructions)
+                    console.log(instructions);
+                (0, open_1.default)(url);
+            },
+            onPrompt: async (prompt) => {
+                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                return new Promise((resolve) => rl.question(`${prompt.message} `, (answer) => { rl.close(); resolve(answer); }));
+            }
+        });
+    }
+    else {
+        console.error(`❌ Unknown provider: ${provider}. Supported providers: codex, gemini, github.`);
+        process.exit(1);
+    }
+    const currentConfig = (0, config_1.getConfig)();
+    const tokens = currentConfig.tokens || {};
+    tokens[provider] = credentials.access;
+    (0, config_1.saveConfig)({
+        activeProvider: provider,
+        tokens
+    });
+    console.log(`✅ Successfully authenticated Gogi via ${provider}!`);
+}

package/dist/config.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = getConfig;
+exports.saveConfig = saveConfig;
+exports.hasValidConfig = hasValidConfig;
+exports.getSystemContext = getSystemContext;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const GOGI_DIR = path_1.default.join(os_1.default.homedir(), '.gogi');
+const CONFIG_FILE = path_1.default.join(GOGI_DIR, 'config.json');
+const SYSTEM_FILE = path_1.default.join(GOGI_DIR, 'system.md');
+function getConfig() {
+    if (!fs_1.default.existsSync(CONFIG_FILE)) {
+        return { tokens: {} };
+    }
+    try {
+        const data = fs_1.default.readFileSync(CONFIG_FILE, 'utf-8');
+        const parsed = JSON.parse(data);
+        if (!parsed.tokens)
+            parsed.tokens = {};
+        return parsed;
+    }
+    catch {
+        return { tokens: {} };
+    }
+}
+function saveConfig(config) {
+    if (!fs_1.default.existsSync(GOGI_DIR)) {
+        fs_1.default.mkdirSync(GOGI_DIR, { recursive: true });
+    }
+    const currentConfig = getConfig();
+    const newConfig = { ...currentConfig, ...config };
+    fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(newConfig, null, 2));
+}
+function hasValidConfig() {
+    const config = getConfig();
+    if (config.openaiApiKey)
+        return true; // legacy
+    return !!(config.activeProvider && config.tokens && config.tokens[config.activeProvider]);
+}
+function getSystemContext() {
+    if (!fs_1.default.existsSync(SYSTEM_FILE)) {
+        const defaultContent = `You are running on a ${os_1.default.type()} (${os_1.default.release()}) machine.
+Architecture: ${os_1.default.arch()}
+CPU: ${os_1.default.cpus()[0]?.model}
+Home directory: ${os_1.default.homedir()}
+Default shell: ${process.env.SHELL || 'unknown'}
+
+Please tailor your commands and suggestions to this specific environment.`;
+        if (!fs_1.default.existsSync(GOGI_DIR)) {
+            fs_1.default.mkdirSync(GOGI_DIR, { recursive: true });
+        }
+        fs_1.default.writeFileSync(SYSTEM_FILE, defaultContent, 'utf-8');
+        return defaultContent;
+    }
+    return fs_1.default.readFileSync(SYSTEM_FILE, 'utf-8');
+}

package/dist/index.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const auth_1 = require("./auth");
+const agent_1 = require("./agent");
+const config_1 = require("./config");
+const program = new commander_1.Command();
+program
+    .name('gogi')
+    .description('Gogi CLI: An AI-powered terminal assistant')
+    .version('1.0.0');
+program
+    .command('login [provider]')
+    .description('Authenticate Gogi with a provider (codex, gemini, github)')
+    .action(async (provider) => {
+    await (0, auth_1.loginFlow)(provider || 'codex');
+});
+program
+    .command('provider <provider>')
+    .description('Switch the active provider (codex, gemini, github)')
+    .action((provider) => {
+    const config = (0, config_1.getConfig)();
+    const tokens = config.tokens || {};
+    if (!tokens[provider] && !(provider === 'codex' && config.openaiApiKey)) {
+        console.error(`❌ No token found for provider '${provider}'. Please run \`gogi login ${provider}\` first.`);
+        process.exit(1);
+    }
+    (0, config_1.saveConfig)({ activeProvider: provider });
+    console.log(`✅ Active provider switched to ${provider}`);
+});
+program
+    .argument('[prompt...]', 'The task you want gogi to perform')
+    .action(async (promptArr) => {
+    const prompt = promptArr.join(' ').trim();
+    if (!prompt) {
+        // If no prompt, just output help
+        program.help();
+        return;
+    }
+    if (!(0, config_1.hasValidConfig)()) {
+        console.log('You need to log in first. Running `gogi login`...');
+        await (0, auth_1.loginFlow)();
+    }
+    await (0, agent_1.runAgent)(prompt);
+});
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@webdeb/gogi",
+  "version": "1.0.0",
+  "description": "Gogi CLI: An AI-powered terminal assistant with native device-code OAuth.",
+  "main": "dist/index.js",
+  "bin": {
+    "gogi": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node ./dist/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "openai",
+    "gemini",
+    "github",
+    "copilot",
+    "terminal",
+    "assistant"
+  ],
+  "author": "Boris Kotov <bk@webdeb.de> (http://www.webdeb.de/)",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/webdeb/gogi.git"
+  },
+  "type": "commonjs",
+  "dependencies": {
+    "@inquirer/prompts": "^8.3.0",
+    "@mariozechner/pi-ai": "^0.54.2",
+    "@types/node": "^25.3.0",
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1",
+    "open": "^11.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}