gibi-bot 1.0.0 → 1.1.1

package/tests/context.test.ts

@@ -0,0 +1,145 @@
+import { ContextManager } from '../src/context';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Mock fs to avoid writing to disk
+jest.mock('fs');
+
+describe('ContextManager', () => {
+  const mockStoragePath = path.join(process.cwd(), '.context.json');
+  let contextManager: ContextManager;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Setup fs mock for constructor load()
+    (fs.existsSync as jest.Mock).mockReturnValue(false);
+
+    contextManager = new ContextManager();
+  });
+
+  describe('constructor', () => {
+    it('should load existing contexts from disk', () => {
+      const mockData = {
+        'ctx-1': {
+          id: 'ctx-1',
+          createdAt: new Date('2023-01-01').toISOString(),
+          lastActiveAt: new Date('2023-01-02').toISOString(),
+          data: { role: 'admin' },
+          messages: [],
+        },
+      };
+
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+      (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(mockData));
+
+      // Re-instantiate to trigger load()
+      contextManager = new ContextManager();
+
+      const ctx = contextManager.getContext('ctx-1');
+      expect(ctx).toBeDefined();
+      expect(ctx.id).toBe('ctx-1');
+      expect(ctx.data).toEqual({ role: 'admin' });
+      expect(ctx.createdAt).toBeInstanceOf(Date);
+      expect(ctx.lastActiveAt).toBeInstanceOf(Date);
+    });
+
+    it('should handle invalid JSON gracefully', () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+      (fs.readFileSync as jest.Mock).mockReturnValue('invalid-json');
+
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+
+      contextManager = new ContextManager();
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[ContextManager] Failed to load contexts:'),
+        expect.any(Error),
+      );
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('getContext', () => {
+    it('should create a new context if it does not exist', () => {
+      const ctx = contextManager.getContext('new-ctx');
+
+      expect(ctx.id).toBe('new-ctx');
+      expect(ctx.messages).toEqual([]);
+      expect(ctx.createdAt).toBeInstanceOf(Date);
+
+      // Should save to disk when creating new context
+      expect(fs.writeFileSync).toHaveBeenCalled();
+    });
+
+    it('should retrieve an existing context', () => {
+      // First create it
+      contextManager.getContext('existing-ctx');
+
+      // Then retrieve it
+      const ctx = contextManager.getContext('existing-ctx');
+      expect(ctx.id).toBe('existing-ctx');
+    });
+
+    it('should update lastActiveAt on retrieval', () => {
+      const ctx1 = contextManager.getContext('active-ctx');
+      const firstAccess = ctx1.lastActiveAt;
+
+      // Advance time slightly (mocking Date would be cleaner but checking for change works)
+      const ctx2 = contextManager.getContext('active-ctx');
+
+      expect(ctx2.lastActiveAt.getTime()).toBeGreaterThanOrEqual(firstAccess.getTime());
+      expect(fs.writeFileSync).toHaveBeenCalled();
+    });
+  });
+
+  describe('setContextData', () => {
+    it('should update context data and save', () => {
+      contextManager.setContextData('data-ctx', { key: 'value' });
+
+      const ctx = contextManager.getContext('data-ctx');
+      expect(ctx.data).toEqual({ key: 'value' });
+
+      expect(fs.writeFileSync).toHaveBeenCalled();
+
+      // Check partial update
+      contextManager.setContextData('data-ctx', { key2: 'value2' });
+      const ctx2 = contextManager.getContext('data-ctx');
+      expect(ctx2.data).toEqual({ key: 'value', key2: 'value2' });
+    });
+  });
+
+  describe('getAllContexts', () => {
+    it('should return all contexts', () => {
+      contextManager.getContext('ctx-1');
+      contextManager.getContext('ctx-2');
+
+      const all = contextManager.getAllContexts();
+      expect(all).toHaveLength(2);
+      expect(all.map((c) => c.id)).toContain('ctx-1');
+      expect(all.map((c) => c.id)).toContain('ctx-2');
+    });
+  });
+
+  describe('clearContext', () => {
+    it('should remove context and save', () => {
+      contextManager.getContext('ctx-to-delete');
+      expect(contextManager.hasContext('ctx-to-delete')).toBe(true);
+
+      contextManager.clearContext('ctx-to-delete');
+      expect(contextManager.hasContext('ctx-to-delete')).toBe(false);
+
+      expect(fs.writeFileSync).toHaveBeenCalled();
+    });
+
+    it('should do nothing if context does not exist', () => {
+      contextManager.clearContext('non-existent');
+      // Ideally checking that save wasn't called if we tracked "dirty" state properly,
+      // but current implementation might not save.
+      // Actually implementation calls save only if delete returns true.
+      // We'll check hasContext remains false.
+      expect(contextManager.hasContext('non-existent')).toBe(false);
+    });
+  });
+});

package/tsconfig.json

@@ -10,4 +10,4 @@
     "skipLibCheck": true
   },
   "include": ["src/**/*"]
-}
+}

package/src/app.js

@@ -1,55 +0,0 @@
-"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 bolt_1 = require("@slack/bolt");
-const dotenv = __importStar(require("dotenv"));
-dotenv.config();
-const app = new bolt_1.App({
-    token: process.env.SLACK_BOT_TOKEN,
-    signingSecret: process.env.SLACK_SIGNING_SECRET,
-    socketMode: true, // Recommended for local development
-    appToken: process.env.SLACK_APP_TOKEN
-});
-// Listens to incoming messages that contain "ping"
-app.message('ping', async ({ message, say }) => {
-    // say() sends a message to the channel where the event was triggered
-    await say(`pong`);
-});
-(async () => {
-    // Start your app
-    await app.start(process.env.PORT || 3000);
-    console.log('⚡️ Bolt app is running!');
-})();
-//# sourceMappingURL=app.js.map

package/src/app.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"app.js","sourceRoot":"","sources":["app.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,sCAAkC;AAClC,+CAAiC;AAEjC,MAAM,CAAC,MAAM,EAAE,CAAC;AAEhB,MAAM,GAAG,GAAG,IAAI,UAAG,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,eAAe;IAClC,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,oBAAoB;IAC/C,UAAU,EAAE,IAAI,EAAE,oCAAoC;IACtD,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,eAAe;CACtC,CAAC,CAAC;AAEH,mDAAmD;AACnD,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE;IAC7C,qEAAqE;IACrE,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC;AACpB,CAAC,CAAC,CAAC;AAEH,CAAC,KAAK,IAAI,EAAE;IACV,iBAAiB;IACjB,MAAM,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;IAE1C,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;AACzC,CAAC,CAAC,EAAE,CAAC"}