gibi-bot 1.0.0 → 1.1.1

package/dist/config.js

@@ -46,7 +46,7 @@ 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-...):' }
+    { name: 'SLACK_APP_TOKEN', message: 'Enter your Slack App Token (xapp-...):' },
 ];
 async function loadConfig() {
     let updated = false;
@@ -72,8 +72,8 @@ async function loadConfig() {
                 type: 'password',
                 name: 'value',
                 message: message,
-                mask: '*'
-            }
+                mask: '*',
+            },
         ]);
         const value = response.value;
         if (value) {
@@ -92,11 +92,11 @@ async function loadConfig() {
 }
 async function clearConfig(keysToClear) {
     const varsToProcess = keysToClear
-        ? REQUIRED_VARS.filter(v => keysToClear.includes(v.name))
+        ? 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(', ')}`);
+    console.log(`Cleared stored configuration for: ${varsToProcess.map((v) => v.name).join(', ')}`);
 }

package/dist/context.js

@@ -50,12 +50,13 @@ class ContextManager {
                 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) => {
+                Object.values(parsed).forEach((c) => {
+                    const ctx = c;
                     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
+                        messages: ctx.messages || [], // Ensure messages exists for old contexts
                     });
                 });
                 console.log(`[ContextManager] Loaded ${this.contexts.size} contexts from disk`);
@@ -98,7 +99,7 @@ class ContextManager {
                 createdAt: new Date(),
                 lastActiveAt: new Date(),
                 data: {},
-                messages: []
+                messages: [],
             };
             this.contexts.set(id, context);
             console.log(`[ContextManager] Created new context: ${id}`);

package/dist/context.test.js

@@ -35,11 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
 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);
@@ -73,8 +71,8 @@ describe('ContextManager', () => {
                 createdAt: new Date().toISOString(),
                 lastActiveAt: new Date().toISOString(),
                 data: { foo: 'bar' },
-                messages: [{ role: 'user', content: 'hello' }]
-            }
+                messages: [{ role: 'user', content: 'hello' }],
+            },
         };
         fs.existsSync.mockReturnValue(true);
         fs.readFileSync.mockReturnValue(JSON.stringify(mockData));

package/eslint.config.mjs

@@ -0,0 +1,17 @@
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import eslintConfigPrettier from 'eslint-config-prettier';
+import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  eslintPluginPrettierRecommended,
+  {
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
+    },
+    ignores: ['dist/', 'node_modules/', 'coverage/'],
+  },
+);

package/jest.config.js

@@ -1,11 +1,12 @@
-const { createDefaultPreset } = require("ts-jest");
+const { createDefaultPreset } = require('ts-jest');
 
 const tsJestTransformCfg = createDefaultPreset().transform;
 
 /** @type {import("jest").Config} **/
 module.exports = {
-  testEnvironment: "node",
+  testEnvironment: 'node',
   transform: {
     ...tsJestTransformCfg,
   },
-};
+  testPathIgnorePatterns: ['/node_modules/', '/dist/'],
+};

package/nodemon.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gibi-bot",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "",
   "main": "dist/app.js",
   "bin": {
@@ -10,7 +10,13 @@
     "start": "ts-node src/app.ts",
     "dev": "nodemon",
     "build": "tsc",
-    "test": "jest"
+    "test": "jest",
+    "lint": "eslint 'src/**/*.{ts,js}'",
+    "lint:fix": "eslint 'src/**/*.{ts,js}' --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "release": "semantic-release",
+    "prepare": "husky"
   },
   "repository": {
     "type": "git",
@@ -33,12 +39,36 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   },
+  "lint-staged": {
+    "src/**/*.{ts,js}": [
+      "eslint --fix",
+      "prettier --write"
+    ]
+  },
   "devDependencies": {
+    "@commitlint/cli": "^20.3.0",
+    "@commitlint/config-conventional": "^20.3.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/npm": "^13.1.3",
+    "@semantic-release/release-notes-generator": "^14.1.0",
     "@types/inquirer": "^9.0.9",
     "@types/jest": "^30.0.0",
     "@types/keytar": "^4.4.0",
+    "@typescript-eslint/eslint-plugin": "^8.52.0",
+    "@typescript-eslint/parser": "^8.52.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "husky": "^9.1.7",
     "jest": "^30.2.0",
+    "lint-staged": "^16.2.7",
     "nodemon": "^3.1.11",
-    "ts-jest": "^29.4.6"
+    "prettier": "^3.7.4",
+    "semantic-release": "^25.0.2",
+    "ts-jest": "^29.4.6",
+    "typescript-eslint": "^8.52.0"
   }
-}
+}

package/release.config.js

@@ -0,0 +1,22 @@
+module.exports = {
+  branches: ['main'],
+  plugins: [
+    '@semantic-release/commit-analyzer',
+    '@semantic-release/release-notes-generator',
+    '@semantic-release/changelog',
+    [
+      '@semantic-release/npm',
+      {
+        provenance: true,
+      },
+    ],
+    [
+      '@semantic-release/git',
+      {
+        assets: ['package.json', 'CHANGELOG.md'],
+        message: 'chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}',
+      },
+    ],
+    '@semantic-release/github',
+  ],
+};

package/src/agents.test.ts

@@ -5,81 +5,86 @@ import { EventEmitter } from 'events';
 jest.mock('child_process');
 
 describe('GeminiAgent', () => {
-    let agent: GeminiAgent;
+  let agent: GeminiAgent;
 
-    beforeEach(() => {
-        jest.clearAllMocks();
-        agent = new GeminiAgent();
+  beforeEach(() => {
+    jest.clearAllMocks();
+    agent = new GeminiAgent();
+  });
+
+  it('should run gemini with the correct arguments', async () => {
+    const mockChild = Object.assign(new EventEmitter(), {
+      stdout: new EventEmitter(),
+      stderr: new EventEmitter(),
     });
 
-    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);
+    (spawn as jest.Mock).mockReturnValue(mockChild);
+
+    const messages = [{ role: 'user', content: 'hello' }];
+    const options = { model: 'test-model' };
 
-        const messages = [{ role: 'user', content: 'hello' }];
-        const options = { model: 'test-model' };
+    const promise = agent.run(messages, options);
 
-        const promise = agent.run(messages, options);
+    // Simulate CLI output
+    setTimeout(() => {
+      mockChild.stdout.emit('data', Buffer.from('hi there'));
+      mockChild.emit('close', 0);
+    }, 10);
 
-        // Simulate CLI output
-        setTimeout(() => {
-            mockChild.stdout.emit('data', Buffer.from('hi there'));
-            mockChild.emit('close', 0);
-        }, 10);
+    const result = await promise;
 
-        const result = await promise;
+    expect(result).toBe('hi there');
+    expect(spawn).toHaveBeenCalledWith('gemini', [
+      '-m',
+      'test-model',
+      '--approval-mode',
+      'yolo',
+      'User: hello\nAssistant:',
+    ]);
+  });
 
-        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 = Object.assign(new EventEmitter(), {
+      stdout: new EventEmitter(),
+      stderr: new EventEmitter(),
     });
 
-    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);
+    (spawn as jest.Mock).mockReturnValue(mockChild);
 
-        const messages = [{ role: 'user', content: 'hello' }];
-        const promise = agent.run(messages);
+    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);
+    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');
+    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 = Object.assign(new EventEmitter(), {
+      stdout: new EventEmitter(),
+      stderr: new EventEmitter(),
     });
 
-    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);
+    (spawn as jest.Mock).mockReturnValue(mockChild);
 
-        const messages = [{ role: 'user', content: 'plan this' }];
-        const options = { mode: 'plan' };
+    const messages = [{ role: 'user', content: 'plan this' }];
+    const options = { mode: 'plan' };
 
-        const promise = agent.run(messages, options);
+    const promise = agent.run(messages, options);
 
-        setTimeout(() => {
-            mockChild.stdout.emit('data', Buffer.from('here is the plan'));
-            mockChild.emit('close', 0);
-        }, 10);
+    setTimeout(() => {
+      mockChild.stdout.emit('data', Buffer.from('here is the plan'));
+      mockChild.emit('close', 0);
+    }, 10);
 
-        await promise;
+    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');
-    });
+    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

@@ -2,111 +2,123 @@ 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>;
+  name: string;
+  run(
+    messages: Array<{ role: string; content: string }>,
+    options?: Record<string, unknown>,
+  ): Promise<string>;
 }
 
 export class GeminiAgent implements Agent {
-    name = 'gemini';
+  name = 'gemini';
 
-    async run(messages: Array<{ role: string; content: string }>, options: any = {}): Promise<string> {
-        const { model, mode } = options;
+  async run(
+    messages: Array<{ role: string; content: string }>,
+    options: Record<string, unknown> = {},
+  ): Promise<string> {
+    const { model, mode } = options as { model?: string; mode?: string };
 
-        let prompt = messages
-            .map((m: any) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`)
-            .join('\n') + '\nAssistant:';
+    let prompt =
+      messages.map((m) => `${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);
+    if (mode === 'plan') {
+      prompt = `${PLAN_MODE_PROMPT}\n\n${prompt}`;
     }
 
-    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));
-        });
+    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: Buffer) => {
+        responseText += data.toString();
+      });
+
+      child.stderr.on('data', (data: Buffer) => {
+        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: Error) => 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}`;
-        }
+  name = 'claude';
+
+  async run(
+    messages: Array<{ role: string; content: string }>,
+    options: Record<string, unknown> = {},
+  ): Promise<string> {
+    // Basic implementation for Claude - similar structure, different CLI
+    // Assuming 'claude' CLI accepts similar prompt structure or just a string
+    const { mode } = options as { mode?: string };
+
+    let prompt =
+      messages.map((m) => `${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"
+    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);
-    }
+    console.log(`[ClaudeAgent] Spawning claude with args length: ${args.length}`);
+    return this.spawnProcess('claude', args);
+  }
 }
 
 export class CursorAgent extends GeminiAgent {
-    name = 'cursor';
+  name = 'cursor';
 
-    async run(messages: Array<{ role: string; content: string }>, options: any = {}): Promise<string> {
-        const { mode } = options;
+  async run(
+    messages: Array<{ role: string; content: string }>,
+    options: Record<string, unknown> = {},
+  ): Promise<string> {
+    const { mode } = options as { mode?: string };
 
-        let prompt = messages
-            .map((m: any) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`)
-            .join('\n') + '\nAssistant:';
+    let prompt =
+      messages.map((m) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`).join('\n') +
+      '\nAssistant:';
 
-        if (mode === 'plan') {
-            prompt = `${PLAN_MODE_PROMPT}\n\n${prompt}`;
-        }
+    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
+    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);
-    }
+    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(),
+  gemini: new GeminiAgent(),
+  claude: new ClaudeAgent(),
+  cursor: new CursorAgent(),
 };

package/src/app.d.ts

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