gibi-bot 1.0.0

package/dist/config.js

@@ -0,0 +1,102 @@
+"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.loadConfig = loadConfig;
+exports.clearConfig = clearConfig;
+const dotenv = __importStar(require("dotenv"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const keytar = __importStar(require("keytar"));
+dotenv.config();
+const SERVICE_NAME = 'gibi-slack-bot';
+const REQUIRED_VARS = [
+    { name: 'SLACK_BOT_TOKEN', message: 'Enter your Slack Bot Token (xoxb-...):' },
+    { name: 'SLACK_SIGNING_SECRET', message: 'Enter your Slack Signing Secret:' },
+    { name: 'SLACK_APP_TOKEN', message: 'Enter your Slack App Token (xapp-...):' }
+];
+async function loadConfig() {
+    let updated = false;
+    for (const { name, message } of REQUIRED_VARS) {
+        if (process.env[name]) {
+            continue;
+        }
+        // Try fetching from keychain
+        let storedValue = null;
+        try {
+            storedValue = await keytar.getPassword(SERVICE_NAME, name);
+        }
+        catch (err) {
+            console.warn(`[WARN] Failed to access keychain for ${name}:`, err);
+        }
+        if (storedValue) {
+            process.env[name] = storedValue;
+            continue;
+        }
+        // Prompt user
+        const response = await inquirer_1.default.prompt([
+            {
+                type: 'password',
+                name: 'value',
+                message: message,
+                mask: '*'
+            }
+        ]);
+        const value = response.value;
+        if (value) {
+            process.env[name] = value;
+            await keytar.setPassword(SERVICE_NAME, name, value);
+            updated = true;
+        }
+        else {
+            console.error(`Error: ${name} is required.`);
+            process.exit(1);
+        }
+    }
+    if (updated) {
+        console.log('Configuration saved to keychain for future runs.');
+    }
+}
+async function clearConfig(keysToClear) {
+    const varsToProcess = keysToClear
+        ? REQUIRED_VARS.filter(v => keysToClear.includes(v.name))
+        : REQUIRED_VARS;
+    for (const { name } of varsToProcess) {
+        await keytar.deletePassword(SERVICE_NAME, name);
+        delete process.env[name];
+    }
+    console.log(`Cleared stored configuration for: ${varsToProcess.map(v => v.name).join(', ')}`);
+}

package/dist/context.js

@@ -0,0 +1,146 @@
+"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.ContextManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ContextManager {
+    contexts;
+    storagePath;
+    constructor() {
+        this.contexts = new Map();
+        this.storagePath = path.join(process.cwd(), '.context.json');
+        this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.storagePath)) {
+                const rawData = fs.readFileSync(this.storagePath, 'utf8');
+                const parsed = JSON.parse(rawData);
+                // Convert plain objects back to GibiContext with Dates
+                Object.values(parsed).forEach((ctx) => {
+                    this.contexts.set(ctx.id, {
+                        ...ctx,
+                        createdAt: new Date(ctx.createdAt),
+                        lastActiveAt: new Date(ctx.lastActiveAt),
+                        messages: ctx.messages || [] // Ensure messages exists for old contexts
+                    });
+                });
+                console.log(`[ContextManager] Loaded ${this.contexts.size} contexts from disk`);
+            }
+        }
+        catch (error) {
+            console.error('[ContextManager] Failed to load contexts:', error);
+        }
+    }
+    save() {
+        try {
+            // Convert Map to object for JSON serialization
+            const data = {};
+            this.contexts.forEach((value, key) => {
+                data[key] = value;
+            });
+            fs.writeFileSync(this.storagePath, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            console.error('[ContextManager] Failed to save contexts:', error);
+        }
+    }
+    /**
+     * Checks if a context exists for the given ID.
+     * @param id The context ID.
+     */
+    hasContext(id) {
+        return this.contexts.has(id);
+    }
+    /**
+     * Retrieves or creates a context for the given ID.
+     * @param id The context ID (e.g., channel ID or thread timestamp).
+     */
+    getContext(id) {
+        let context = this.contexts.get(id);
+        let shouldSave = false;
+        if (!context) {
+            context = {
+                id,
+                createdAt: new Date(),
+                lastActiveAt: new Date(),
+                data: {},
+                messages: []
+            };
+            this.contexts.set(id, context);
+            console.log(`[ContextManager] Created new context: ${id}`);
+            shouldSave = true;
+        }
+        else {
+            console.log(`[ContextManager] Retrieved existing context: ${id}`);
+        }
+        // Update activity timestamp
+        context.lastActiveAt = new Date();
+        shouldSave = true; // Always save on access to update timestamp
+        if (shouldSave) {
+            this.save();
+        }
+        return context;
+    }
+    /**
+     * Sets arbitrary data on a context.
+     * @param id The context ID.
+     * @param data Key-value pairs to merge into the context data.
+     */
+    setContextData(id, data) {
+        const context = this.getContext(id);
+        context.data = { ...context.data, ...data };
+        this.contexts.set(id, context);
+        this.save();
+    }
+    /**
+     * Retrieves all stored contexts.
+     */
+    getAllContexts() {
+        return Array.from(this.contexts.values());
+    }
+    /**
+     * Clears a specific context.
+     * @param id The context ID to remove.
+     */
+    clearContext(id) {
+        if (this.contexts.delete(id)) {
+            console.log(`[ContextManager] Cleared context: ${id}`);
+            this.save();
+        }
+    }
+}
+exports.ContextManager = ContextManager;

package/dist/context.test.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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const context_1 = require("./context");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+jest.mock('fs');
+describe('ContextManager', () => {
+    let contextManager;
+    const mockStoragePath = path.join(process.cwd(), '.context.json');
+    beforeEach(() => {
+        jest.clearAllMocks();
+        fs.existsSync.mockReturnValue(false);
+        contextManager = new context_1.ContextManager();
+    });
+    it('should create a new context if it does not exist', () => {
+        const contextId = 'test-id';
+        const context = contextManager.getContext(contextId);
+        expect(context.id).toBe(contextId);
+        expect(context.messages).toEqual([]);
+        expect(context.data).toEqual({});
+        expect(fs.writeFileSync).toHaveBeenCalled();
+    });
+    it('should retrieve an existing context', () => {
+        const contextId = 'test-id';
+        contextManager.getContext(contextId); // Create it
+        const context = contextManager.getContext(contextId); // Retrieve it
+        expect(context.id).toBe(contextId);
+        expect(context.messages).toEqual([]);
+    });
+    it('should set context data', () => {
+        const contextId = 'test-id';
+        contextManager.setContextData(contextId, { key: 'value' });
+        const context = contextManager.getContext(contextId);
+        expect(context.data.key).toBe('value');
+    });
+    it('should load contexts from disk on initialization', () => {
+        const mockData = {
+            'existing-id': {
+                id: 'existing-id',
+                createdAt: new Date().toISOString(),
+                lastActiveAt: new Date().toISOString(),
+                data: { foo: 'bar' },
+                messages: [{ role: 'user', content: 'hello' }]
+            }
+        };
+        fs.existsSync.mockReturnValue(true);
+        fs.readFileSync.mockReturnValue(JSON.stringify(mockData));
+        const manager = new context_1.ContextManager();
+        const context = manager.getContext('existing-id');
+        expect(context.id).toBe('existing-id');
+        expect(context.data.foo).toBe('bar');
+        expect(context.messages[0].content).toBe('hello');
+    });
+    it('should clear a context', () => {
+        const contextId = 'test-id';
+        contextManager.getContext(contextId);
+        expect(contextManager.hasContext(contextId)).toBe(true);
+        contextManager.clearContext(contextId);
+        expect(contextManager.hasContext(contextId)).toBe(false);
+        expect(fs.writeFileSync).toHaveBeenCalled();
+    });
+});

package/dist/prompts.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLAN_MODE_PROMPT = void 0;
+exports.PLAN_MODE_PROMPT = `
+You are an expert software architect and technical lead.
+Your goal is to help the user plan and implement a software project or feature.
+
+Follow this process:
+1.  **Analyze the Request**: Understand the user's high-level goal.
+2.  **Generate a Plan**: Create a comprehensive, step-by-step markdown plan.
+    *   Break down the work into logical phases (e.g., Planning, Setup, Implementation, Verification).
+    *   Include a checklist for each phase.
+    *   Ask clarifying questions if requirements are vague.
+3.  **Refine**: Discuss the plan with the user. Answer their questions. Update the plan as needed.
+4.  **Implementation**: When the user is ready, guide them through the implementation. Provide code snippets, file structures, and commands.
+5.  **Completion**: When finished, ask if the user wants to "delete the plan" (which effectively means clearing this context or marking the task as done).
+
+**Tone**: Professional, encouraging, and structured. Use Markdown effectively (headers, lists, code blocks).
+**Important**: You are running inside a Slack bot. Keep responses concise where possible, but detailed enough for a plan.
+`;

package/jest.config.js

@@ -0,0 +1,11 @@
+const { createDefaultPreset } = require("ts-jest");
+
+const tsJestTransformCfg = createDefaultPreset().transform;
+
+/** @type {import("jest").Config} **/
+module.exports = {
+  testEnvironment: "node",
+  transform: {
+    ...tsJestTransformCfg,
+  },
+};

package/nodemon.json

@@ -0,0 +1,10 @@
+{
+    "watch": [
+        "src"
+    ],
+    "ext": "ts",
+    "exec": "ts-node src/app.ts",
+    "ignore": [
+        "src/**/*.test.ts"
+    ]
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "gibi-bot",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/app.js",
+  "bin": {
+    "gibi": "dist/app.js"
+  },
+  "scripts": {
+    "start": "ts-node src/app.ts",
+    "dev": "nodemon",
+    "build": "tsc",
+    "test": "jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fa-krug/Gibi.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "bugs": {
+    "url": "https://github.com/fa-krug/Gibi/issues"
+  },
+  "homepage": "https://github.com/fa-krug/Gibi#readme",
+  "dependencies": {
+    "@slack/bolt": "^4.6.0",
+    "@types/node": "^25.0.3",
+    "dotenv": "^17.2.3",
+    "inquirer": "^8.2.7",
+    "keytar": "^7.9.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/jest": "^30.0.0",
+    "@types/keytar": "^4.4.0",
+    "jest": "^30.2.0",
+    "nodemon": "^3.1.11",
+    "ts-jest": "^29.4.6"
+  }
+}

package/src/agents.test.ts

@@ -0,0 +1,85 @@
+import { GeminiAgent } from './agents';
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+
+jest.mock('child_process');
+
+describe('GeminiAgent', () => {
+    let agent: GeminiAgent;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        agent = new GeminiAgent();
+    });
+
+    it('should run gemini with the correct arguments', async () => {
+        const mockChild = new EventEmitter() as any;
+        mockChild.stdout = new EventEmitter();
+        mockChild.stderr = new EventEmitter();
+        
+        (spawn as jest.Mock).mockReturnValue(mockChild);
+
+        const messages = [{ role: 'user', content: 'hello' }];
+        const options = { model: 'test-model' };
+
+        const promise = agent.run(messages, options);
+
+        // Simulate CLI output
+        setTimeout(() => {
+            mockChild.stdout.emit('data', Buffer.from('hi there'));
+            mockChild.emit('close', 0);
+        }, 10);
+
+        const result = await promise;
+
+        expect(result).toBe('hi there');
+        expect(spawn).toHaveBeenCalledWith('gemini', [
+            '-m', 'test-model',
+            '--approval-mode', 'yolo',
+            'User: hello\nAssistant:'
+        ]);
+    });
+
+    it('should handle errors from the CLI', async () => {
+        const mockChild = new EventEmitter() as any;
+        mockChild.stdout = new EventEmitter();
+        mockChild.stderr = new EventEmitter();
+        
+        (spawn as jest.Mock).mockReturnValue(mockChild);
+
+        const messages = [{ role: 'user', content: 'hello' }];
+        const promise = agent.run(messages);
+
+        setTimeout(() => {
+            mockChild.stderr.emit('data', Buffer.from('something went wrong'));
+            mockChild.emit('close', 1);
+        }, 10);
+
+        await expect(promise).rejects.toThrow('gemini CLI exited with code 1: something went wrong');
+    });
+
+    it('should include PLAN_MODE_PROMPT in plan mode', async () => {
+        const mockChild = new EventEmitter() as any;
+        mockChild.stdout = new EventEmitter();
+        mockChild.stderr = new EventEmitter();
+        
+        (spawn as jest.Mock).mockReturnValue(mockChild);
+
+        const messages = [{ role: 'user', content: 'plan this' }];
+        const options = { mode: 'plan' };
+
+        const promise = agent.run(messages, options);
+
+        setTimeout(() => {
+            mockChild.stdout.emit('data', Buffer.from('here is the plan'));
+            mockChild.emit('close', 0);
+        }, 10);
+
+        await promise;
+
+        const callArgs = (spawn as jest.Mock).mock.calls[0][1];
+        const lastArg = callArgs[callArgs.length - 1];
+        expect(lastArg).toContain('expert software architect');
+        expect(lastArg).toContain('User: plan this');
+    });
+});

package/src/agents.ts

@@ -0,0 +1,112 @@
+import { spawn } from 'child_process';
+import { PLAN_MODE_PROMPT } from './prompts';
+
+export interface Agent {
+    name: string;
+    run(messages: Array<{ role: string; content: string }>, options?: any): Promise<string>;
+}
+
+export class GeminiAgent implements Agent {
+    name = 'gemini';
+
+    async run(messages: Array<{ role: string; content: string }>, options: any = {}): Promise<string> {
+        const { model, mode } = options;
+
+        let prompt = messages
+            .map((m: any) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`)
+            .join('\n') + '\nAssistant:';
+
+        if (mode === 'plan') {
+            prompt = `${PLAN_MODE_PROMPT}\n\n${prompt}`;
+        }
+
+        const args = [];
+        if (model) {
+            args.push('-m', model);
+        }
+        args.push('--approval-mode', 'yolo');
+        args.push(prompt);
+
+        console.log(`[GeminiAgent] Spawning gemini with args: ${JSON.stringify(args)}`);
+        return this.spawnProcess('gemini', args);
+    }
+
+    protected spawnProcess(command: string, args: string[]): Promise<string> {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args);
+            let responseText = '';
+            let errorText = '';
+
+            child.stdout.on('data', (data: any) => {
+                responseText += data.toString();
+            });
+
+            child.stderr.on('data', (data: any) => {
+                errorText += data.toString();
+            });
+
+            child.on('close', (code: number) => {
+                if (code !== 0) {
+                    reject(new Error(`${command} CLI exited with code ${code}: ${errorText}`));
+                } else {
+                    resolve(responseText.trim());
+                }
+            });
+
+            child.on('error', (err: any) => reject(err));
+        });
+    }
+}
+
+export class ClaudeAgent extends GeminiAgent {
+    name = 'claude';
+
+    async run(messages: Array<{ role: string; content: string }>, options: any = {}): Promise<string> {
+        // Basic implementation for Claude - similar structure, different CLI
+        // Assuming 'claude' CLI accepts similar prompt structure or just a string
+        const { mode } = options;
+
+        let prompt = messages
+            .map((m: any) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`)
+            .join('\n') + '\nAssistant:';
+
+        if (mode === 'plan') {
+            prompt = `${PLAN_MODE_PROMPT}\n\n${prompt}`;
+        }
+
+        const args = [prompt];
+        // Add specific arguments if Claude CLI requires them, e.g. -p or similar. 
+        // logic here assumes usage: claude "prompt"
+
+        console.log(`[ClaudeAgent] Spawning claude with args length: ${args.length}`);
+        return this.spawnProcess('claude', args);
+    }
+}
+
+export class CursorAgent extends GeminiAgent {
+    name = 'cursor';
+
+    async run(messages: Array<{ role: string; content: string }>, options: any = {}): Promise<string> {
+        const { mode } = options;
+
+        let prompt = messages
+            .map((m: any) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`)
+            .join('\n') + '\nAssistant:';
+
+        if (mode === 'plan') {
+            prompt = `${PLAN_MODE_PROMPT}\n\n${prompt}`;
+        }
+
+        const args = [prompt];
+        // Logic assumes usage: cursor "prompt" - this is hypothetical as 'cursor' CLI might differ
+
+        console.log(`[CursorAgent] Spawning cursor with args length: ${args.length}`);
+        return this.spawnProcess('cursor', args);
+    }
+}
+
+export const agentRegistry: Record<string, Agent> = {
+    gemini: new GeminiAgent(),
+    claude: new ClaudeAgent(),
+    cursor: new CursorAgent(),
+};

package/src/app.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=app.d.ts.map

package/src/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["app.ts"],"names":[],"mappings":""}