gibi-bot 1.0.0 → 1.1.1

package/src/config.ts

@@ -7,66 +7,66 @@ 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-...):' }
+  { 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-...):' },
 ];
 
 export async function loadConfig(): Promise<void> {
-    let updated = false;
+  let updated = false;
 
-    for (const { name, message } of REQUIRED_VARS) {
-        if (process.env[name]) {
-            continue;
-        }
+  for (const { name, message } of REQUIRED_VARS) {
+    if (process.env[name]) {
+      continue;
+    }
 
-        // Try fetching from keychain
-        let storedValue: string | null = null;
-        try {
-            storedValue = await keytar.getPassword(SERVICE_NAME, name);
-        } catch (err) {
-            console.warn(`[WARN] Failed to access keychain for ${name}:`, err);
-        }
+    // Try fetching from keychain
+    let storedValue: string | null = 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;
-        }
+    if (storedValue) {
+      process.env[name] = storedValue;
+      continue;
+    }
 
-        // Prompt user
-        const response = await inquirer.prompt([
-            {
-                type: 'password',
-                name: 'value',
-                message: message,
-                mask: '*'
-            }
-        ]);
+    // Prompt user
+    const response = await inquirer.prompt([
+      {
+        type: 'password',
+        name: 'value',
+        message: message,
+        mask: '*',
+      },
+    ]);
 
-        const value = response.value as string;
-        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);
-        }
+    const value = response.value as string;
+    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.');
-    }
+  if (updated) {
+    console.log('Configuration saved to keychain for future runs.');
+  }
 }
 
 export async function clearConfig(keysToClear?: string[]): Promise<void> {
-    const varsToProcess = keysToClear
-        ? REQUIRED_VARS.filter(v => keysToClear.includes(v.name))
-        : REQUIRED_VARS;
+  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(', ')}`);
+  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/src/context.test.ts

@@ -1,75 +1,73 @@
 import { ContextManager } from './context';
 import * as fs from 'fs';
-import * as path from 'path';
 
 jest.mock('fs');
 
 describe('ContextManager', () => {
-    let contextManager: ContextManager;
-    const mockStoragePath = path.join(process.cwd(), '.context.json');
+  let contextManager: ContextManager;
 
-    beforeEach(() => {
-        jest.clearAllMocks();
-        (fs.existsSync as jest.Mock).mockReturnValue(false);
-        contextManager = new ContextManager();
-    });
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (fs.existsSync as jest.Mock).mockReturnValue(false);
+    contextManager = new ContextManager();
+  });
 
-    it('should create a new context if it does not exist', () => {
-        const contextId = 'test-id';
-        const context = contextManager.getContext(contextId);
+  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();
-    });
+    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 retrieve an existing context', () => {
+    const contextId = 'test-id';
+    contextManager.getContext(contextId); // Create it
 
-    it('should set context data', () => {
-        const contextId = 'test-id';
-        contextManager.setContextData(contextId, { key: 'value' });
+    const context = contextManager.getContext(contextId); // Retrieve it
+    expect(context.id).toBe(contextId);
+    expect(context.messages).toEqual([]);
+  });
 
-        const context = contextManager.getContext(contextId);
-        expect(context.data.key).toBe('value');
-    });
+  it('should set context data', () => {
+    const contextId = 'test-id';
+    contextManager.setContextData(contextId, { key: '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' }]
-            }
-        };
+    const context = contextManager.getContext(contextId);
+    expect(context.data.key).toBe('value');
+  });
 
-        (fs.existsSync as jest.Mock).mockReturnValue(true);
-        (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(mockData));
+  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' }],
+      },
+    };
 
-        const manager = new ContextManager();
-        const context = manager.getContext('existing-id');
+    (fs.existsSync as jest.Mock).mockReturnValue(true);
+    (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(mockData));
 
-        expect(context.id).toBe('existing-id');
-        expect(context.data.foo).toBe('bar');
-        expect(context.messages[0].content).toBe('hello');
-    });
+    const manager = new ContextManager();
+    const context = manager.getContext('existing-id');
 
-    it('should clear a context', () => {
-        const contextId = 'test-id';
-        contextManager.getContext(contextId);
-        expect(contextManager.hasContext(contextId)).toBe(true);
+    expect(context.id).toBe('existing-id');
+    expect(context.data.foo).toBe('bar');
+    expect(context.messages[0].content).toBe('hello');
+  });
 
-        contextManager.clearContext(contextId);
-        expect(contextManager.hasContext(contextId)).toBe(false);
-        expect(fs.writeFileSync).toHaveBeenCalled();
-    });
+  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/src/context.ts

@@ -1,130 +1,139 @@
 import * as fs from 'fs';
 import * as path from 'path';
 
+export interface GibiContextData {
+  model?: string;
+  agent?: string;
+  cwd?: string;
+  mode?: string;
+  [key: string]: unknown; // Keep any for flexibility but typed common fields
+}
+
 export interface GibiContext {
-    id: string;
-    createdAt: Date;
-    lastActiveAt: Date;
-    data: Record<string, any>;
-    messages: Array<{ role: 'user' | 'assistant'; content: string }>;
+  id: string;
+  createdAt: Date;
+  lastActiveAt: Date;
+  data: GibiContextData;
+  messages: Array<{ role: 'user' | 'assistant'; content: string }>;
 }
 
 export class ContextManager {
-    private contexts: Map<string, GibiContext>;
-    private readonly storagePath: string;
-
-    constructor() {
-        this.contexts = new Map();
-        this.storagePath = path.join(process.cwd(), '.context.json');
-        this.load();
-    }
-
-    private load(): void {
-        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: any) => {
-                    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);
-        }
+  private contexts: Map<string, GibiContext>;
+  private readonly storagePath: string;
+
+  constructor() {
+    this.contexts = new Map();
+    this.storagePath = path.join(process.cwd(), '.context.json');
+    this.load();
+  }
+
+  private load(): void {
+    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((c: unknown) => {
+          const ctx = c as any;
+          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);
     }
-
-    private save(): void {
-        try {
-            // Convert Map to object for JSON serialization
-            const data: Record<string, GibiContext> = {};
-            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);
-        }
+  }
+
+  private save(): void {
+    try {
+      // Convert Map to object for JSON serialization
+      const data: Record<string, GibiContext> = {};
+      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: string): boolean {
-        return this.contexts.has(id);
+  }
+
+  /**
+   * Checks if a context exists for the given ID.
+   * @param id The context ID.
+   */
+  hasContext(id: string): boolean {
+    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: string): GibiContext {
+    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}`);
     }
 
-    /**
-     * Retrieves or creates a context for the given ID.
-     * @param id The context ID (e.g., channel ID or thread timestamp).
-     */
-    getContext(id: string): GibiContext {
-        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: string, data: Record<string, any>): void {
-        const context = this.getContext(id);
-        context.data = { ...context.data, ...data };
-        this.contexts.set(id, context);
-        this.save();
-    }
+    // Update activity timestamp
+    context.lastActiveAt = new Date();
+    shouldSave = true; // Always save on access to update timestamp
 
-    /**
-     * Retrieves all stored contexts.
-     */
-    getAllContexts(): GibiContext[] {
-        return Array.from(this.contexts.values());
+    if (shouldSave) {
+      this.save();
     }
 
-    /**
-     * Clears a specific context.
-     * @param id The context ID to remove.
-     */
-    clearContext(id: string): void {
-        if (this.contexts.delete(id)) {
-            console.log(`[ContextManager] Cleared context: ${id}`);
-            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: string, data: Partial<GibiContextData>): void {
+    const context = this.getContext(id);
+    context.data = { ...context.data, ...data };
+    this.contexts.set(id, context);
+    this.save();
+  }
+
+  /**
+   * Retrieves all stored contexts.
+   */
+  getAllContexts(): GibiContext[] {
+    return Array.from(this.contexts.values());
+  }
+
+  /**
+   * Clears a specific context.
+   * @param id The context ID to remove.
+   */
+  clearContext(id: string): void {
+    if (this.contexts.delete(id)) {
+      console.log(`[ContextManager] Cleared context: ${id}`);
+      this.save();
     }
+  }
 }

package/test_gemini.js

@@ -1,23 +1,27 @@
 const { spawn } = require('child_process');
 
-console.log("Starting gemini process...");
-const child = spawn('gemini', ['list files in current directory', '--output-format', 'stream-json', '--approval-mode', 'yolo'], {
-    stdio: ['pipe', 'pipe', 'pipe'] // We need to control pipes
-});
+console.log('Starting gemini process...');
+const child = spawn(
+  'gemini',
+  ['list files in current directory', '--output-format', 'stream-json', '--approval-mode', 'yolo'],
+  {
+    stdio: ['pipe', 'pipe', 'pipe'], // We need to control pipes
+  },
+);
 
 child.stdout.on('data', (data) => {
-    console.log(`STDOUT: ${data.toString()}`);
+  console.log(`STDOUT: ${data.toString()}`);
 });
 
 child.stderr.on('data', (data) => {
-    console.log(`STDERR: ${data.toString()}`);
+  console.log(`STDERR: ${data.toString()}`);
 });
 
 child.on('close', (code) => {
-    console.log(`Child exited with code ${code}`);
+  console.log(`Child exited with code ${code}`);
 });
 
 setTimeout(() => {
-    console.log("Timeout reached. Killing process.");
-    child.kill();
+  console.log('Timeout reached. Killing process.');
+  child.kill();
 }, 10000);

package/test_gemini_approval.js

@@ -1,24 +1,28 @@
 const { spawn } = require('child_process');
 
-console.log("Starting gemini process...");
+console.log('Starting gemini process...');
 // Attempt to force approval mode
-const child = spawn('gemini', ['list files', '--output-format', 'stream-json', '--approval-mode', 'yolo'], {
-    stdio: ['pipe', 'pipe', 'pipe']
-});
+const child = spawn(
+  'gemini',
+  ['list files', '--output-format', 'stream-json', '--approval-mode', 'yolo'],
+  {
+    stdio: ['pipe', 'pipe', 'pipe'],
+  },
+);
 
 child.stdout.on('data', (data) => {
-    console.log(`STDOUT: ${data.toString()}`);
+  console.log(`STDOUT: ${data.toString()}`);
 });
 
 child.stderr.on('data', (data) => {
-    console.log(`STDERR: ${data.toString()}`);
+  console.log(`STDERR: ${data.toString()}`);
 });
 
 child.on('close', (code) => {
-    console.log(`Child exited with code ${code}`);
+  console.log(`Child exited with code ${code}`);
 });
 
 setTimeout(() => {
-    console.log("Timeout reached. Killing process.");
-    child.kill();
+  console.log('Timeout reached. Killing process.');
+  child.kill();
 }, 10000);

package/test_gemini_write.js

@@ -1,23 +1,33 @@
 const { spawn } = require('child_process');
 
-console.log("Starting gemini process...");
-const child = spawn('gemini', ['create a file named hello_test_123.txt with content "hello"', '--output-format', 'stream-json', '--approval-mode', 'yolo'], {
-    stdio: ['pipe', 'pipe', 'pipe']
-});
+console.log('Starting gemini process...');
+const child = spawn(
+  'gemini',
+  [
+    'create a file named hello_test_123.txt with content "hello"',
+    '--output-format',
+    'stream-json',
+    '--approval-mode',
+    'yolo',
+  ],
+  {
+    stdio: ['pipe', 'pipe', 'pipe'],
+  },
+);
 
 child.stdout.on('data', (data) => {
-    console.log(`STDOUT: ${data.toString()}`);
+  console.log(`STDOUT: ${data.toString()}`);
 });
 
 child.stderr.on('data', (data) => {
-    console.log(`STDERR: ${data.toString()}`);
+  console.log(`STDERR: ${data.toString()}`);
 });
 
 child.on('close', (code) => {
-    console.log(`Child exited with code ${code}`);
+  console.log(`Child exited with code ${code}`);
 });
 
 setTimeout(() => {
-    console.log("Timeout reached. Killing process.");
-    child.kill();
+  console.log('Timeout reached. Killing process.');
+  child.kill();
 }, 15000);