@forgehive/hive-sdk 0.0.1

package/dist/test/index.test.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+describe('Hive SDK', () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...originalEnv };
+    });
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+    describe('HiveLogClient constructor', () => {
+        it('should create client in silent mode when HIVE_API_KEY is missing', () => {
+            delete process.env.HIVE_API_KEY;
+            process.env.HIVE_API_SECRET = 'test-secret';
+            process.env.HIVE_HOST = 'https://test.com';
+            expect(() => new index_1.HiveLogClient('test-project')).not.toThrow();
+        });
+        it('should create client in silent mode when HIVE_API_SECRET is missing', () => {
+            process.env.HIVE_API_KEY = 'test-key';
+            delete process.env.HIVE_API_SECRET;
+            process.env.HIVE_HOST = 'https://test.com';
+            expect(() => new index_1.HiveLogClient('test-project')).not.toThrow();
+        });
+        it('should create client in silent mode when HIVE_HOST is missing', () => {
+            process.env.HIVE_API_KEY = 'test-key';
+            process.env.HIVE_API_SECRET = 'test-secret';
+            delete process.env.HIVE_HOST;
+            expect(() => new index_1.HiveLogClient('test-project')).not.toThrow();
+        });
+        it('should create client in silent mode when all environment variables are missing', () => {
+            delete process.env.HIVE_API_KEY;
+            delete process.env.HIVE_API_SECRET;
+            delete process.env.HIVE_HOST;
+            expect(() => new index_1.HiveLogClient('test-project')).not.toThrow();
+        });
+        it('should create client successfully when all environment variables are present', () => {
+            process.env.HIVE_API_KEY = 'test-key';
+            process.env.HIVE_API_SECRET = 'test-secret';
+            process.env.HIVE_HOST = 'https://test.com';
+            expect(() => new index_1.HiveLogClient('test-project')).not.toThrow();
+        });
+    });
+    describe('isActive method', () => {
+        it('should return false when credentials are missing', () => {
+            delete process.env.HIVE_API_KEY;
+            delete process.env.HIVE_API_SECRET;
+            delete process.env.HIVE_HOST;
+            const client = new index_1.HiveLogClient('test-project');
+            expect(client.isActive()).toBe(false);
+        });
+        it('should return true when all credentials are present', () => {
+            process.env.HIVE_API_KEY = 'test-key';
+            process.env.HIVE_API_SECRET = 'test-secret';
+            process.env.HIVE_HOST = 'https://test.com';
+            const client = new index_1.HiveLogClient('test-project');
+            expect(client.isActive()).toBe(true);
+        });
+    });
+    describe('createHiveLogClient factory function', () => {
+        it('should create HiveLogClient instance when env vars are present', () => {
+            process.env.HIVE_API_KEY = 'test-key';
+            process.env.HIVE_API_SECRET = 'test-secret';
+            process.env.HIVE_HOST = 'https://test.com';
+            const client = (0, index_1.createHiveLogClient)('test-project');
+            expect(client).toBeInstanceOf(index_1.HiveLogClient);
+        });
+        it('should create client in silent mode when env vars are missing', () => {
+            delete process.env.HIVE_API_KEY;
+            delete process.env.HIVE_API_SECRET;
+            delete process.env.HIVE_HOST;
+            expect(() => (0, index_1.createHiveLogClient)('test-project')).not.toThrow();
+        });
+    });
+    describe('Silent mode behavior', () => {
+        let silentClient;
+        beforeEach(() => {
+            delete process.env.HIVE_API_KEY;
+            delete process.env.HIVE_API_SECRET;
+            delete process.env.HIVE_HOST;
+            silentClient = new index_1.HiveLogClient('silent-project');
+        });
+        it('should return "silent" for sendLog in silent mode', async () => {
+            const result = await silentClient.sendLog('test-task', { data: 'test' });
+            expect(result).toBe('silent');
+        });
+        it('should throw error for getLog in silent mode', async () => {
+            await expect(silentClient.getLog('test-task', 'test-uuid')).rejects.toThrow('Missing Hive API credentials or host, get them at https://forgehive.dev');
+        });
+        it('should throw error for setQuality in silent mode', async () => {
+            const quality = { score: 8, reason: 'test', suggestions: 'test' };
+            await expect(silentClient.setQuality('test-task', 'test-uuid', quality)).rejects.toThrow('Missing Hive API credentials or host, get them at https://forgehive.dev');
+        });
+    });
+});

package/dist/test/sendLog.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/sendLog.test.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const index_1 = require("../index");
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+describe('HiveLogClient sendLog', () => {
+    const originalEnv = process.env;
+    let client;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...originalEnv };
+        // Set up environment variables
+        process.env.HIVE_API_KEY = 'test-api-key';
+        process.env.HIVE_API_SECRET = 'test-api-secret';
+        process.env.HIVE_HOST = 'https://test-host.com';
+        // Create client instance
+        client = new index_1.HiveLogClient('test-project');
+        // Clear all mocks
+        jest.clearAllMocks();
+    });
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+    describe('successful sendLog', () => {
+        it('should send log successfully and return true', async () => {
+            // Mock successful axios response
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const logItem = { input: 'test-input', output: 'test-output' };
+            const result = await client.sendLog('test-task', logItem);
+            expect(result).toBe('success');
+            expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+            expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
+                projectName: 'test-project',
+                taskName: 'test-task',
+                logItem: JSON.stringify(logItem)
+            }, {
+                headers: {
+                    Authorization: 'Bearer test-api-key:test-api-secret',
+                    'Content-Type': 'application/json'
+                }
+            });
+        });
+        it('should handle complex log items', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const complexLogItem = {
+                input: { userId: 123, action: 'login' },
+                output: { success: true, sessionId: 'abc123' },
+                error: null,
+                boundaries: {
+                    database: [{ input: 'SELECT * FROM users', output: [{ id: 123 }], error: null }]
+                }
+            };
+            const result = await client.sendLog('complex-task', complexLogItem);
+            expect(result).toBe('success');
+            expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
+                projectName: 'test-project',
+                taskName: 'complex-task',
+                logItem: JSON.stringify(complexLogItem)
+            }, {
+                headers: {
+                    Authorization: 'Bearer test-api-key:test-api-secret',
+                    'Content-Type': 'application/json'
+                }
+            });
+        });
+    });
+    describe('failed sendLog', () => {
+        it('should return false when axios throws an error', async () => {
+            // Mock axios to throw an error
+            mockedAxios.post.mockRejectedValueOnce(new Error('Network error'));
+            const logItem = { input: 'test-input' };
+            const result = await client.sendLog('test-task', logItem);
+            expect(result).toBe('error');
+        });
+        it('should return false when server returns 500', async () => {
+            // Mock axios to throw a server error
+            const serverError = new Error('Server Error');
+            mockedAxios.post.mockRejectedValueOnce(serverError);
+            const result = await client.sendLog('test-task', { input: 'test' });
+            expect(result).toBe('error');
+        });
+    });
+    describe('sendLog parameters', () => {
+        it('should handle empty log items', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const result = await client.sendLog('empty-task', {});
+            expect(result).toBe('success');
+            expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
+                projectName: 'test-project',
+                taskName: 'empty-task',
+                logItem: JSON.stringify({})
+            }, expect.any(Object));
+        });
+        it('should handle null/undefined values in log items', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const logItem = { input: null, output: undefined, error: 'some error' };
+            const result = await client.sendLog('null-task', logItem);
+            expect(result).toBe('success');
+            expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
+                projectName: 'test-project',
+                taskName: 'null-task',
+                logItem: JSON.stringify(logItem)
+            }, expect.any(Object));
+        });
+    });
+});

package/dist/test/setQuality.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/setQuality.test.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const index_1 = require("../index");
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+describe('HiveLogClient setQuality', () => {
+    const originalEnv = process.env;
+    let client;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...originalEnv };
+        // Set up environment variables
+        process.env.HIVE_API_KEY = 'test-api-key';
+        process.env.HIVE_API_SECRET = 'test-api-secret';
+        process.env.HIVE_HOST = 'https://test-host.com';
+        // Create client instance
+        client = new index_1.HiveLogClient('test-project');
+        // Clear all mocks
+        jest.clearAllMocks();
+    });
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+    describe('successful setQuality', () => {
+        it('should set quality successfully and return true', async () => {
+            // Mock successful axios response
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const quality = {
+                score: 8.5,
+                reason: 'Good performance with minor improvements needed',
+                suggestions: 'Consider optimizing the database query for better performance'
+            };
+            const result = await client.setQuality('test-task', 'test-uuid-123', quality);
+            expect(result).toBe(true);
+            expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+            expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/test-task/logs/test-uuid-123/set-quality', {
+                quality
+            }, {
+                headers: {
+                    Authorization: 'Bearer test-api-key:test-api-secret',
+                    'Content-Type': 'application/json'
+                }
+            });
+        });
+        it('should handle perfect score quality', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const perfectQuality = {
+                score: 10,
+                reason: 'Excellent implementation with no issues found',
+                suggestions: 'No improvements needed, great work!'
+            };
+            const result = await client.setQuality('perfect-task', 'perfect-uuid', perfectQuality);
+            expect(result).toBe(true);
+            expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/perfect-task/logs/perfect-uuid/set-quality', {
+                quality: perfectQuality
+            }, expect.any(Object));
+        });
+        it('should handle poor score quality with detailed suggestions', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const poorQuality = {
+                score: 2.0,
+                reason: 'Multiple issues found including performance problems and code quality issues',
+                suggestions: 'Refactor the main function, add error handling, optimize database queries, and improve variable naming conventions'
+            };
+            const result = await client.setQuality('poor-task', 'poor-uuid', poorQuality);
+            expect(result).toBe(true);
+            expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/poor-task/logs/poor-uuid/set-quality', {
+                quality: poorQuality
+            }, expect.any(Object));
+        });
+        it('should handle edge case scores', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const edgeCaseQuality = {
+                score: 0,
+                reason: 'Critical failure in implementation',
+                suggestions: 'Complete rewrite required'
+            };
+            const result = await client.setQuality('edge-task', 'edge-uuid', edgeCaseQuality);
+            expect(result).toBe(true);
+        });
+    });
+    describe('failed setQuality', () => {
+        it('should return false when axios throws an error', async () => {
+            // Mock axios to throw an error
+            mockedAxios.post.mockRejectedValueOnce(new Error('Network error'));
+            const quality = {
+                score: 7.0,
+                reason: 'Test quality',
+                suggestions: 'Test suggestions'
+            };
+            const result = await client.setQuality('test-task', 'test-uuid', quality);
+            expect(result).toBe(false);
+        });
+        it('should return false when server returns 404', async () => {
+            // Mock axios to throw a 404 error
+            const notFoundError = new Error('Request failed with status code 404');
+            mockedAxios.post.mockRejectedValueOnce(notFoundError);
+            const quality = {
+                score: 5.0,
+                reason: 'Not found test',
+                suggestions: 'Test suggestions for not found'
+            };
+            const result = await client.setQuality('non-existent-task', 'non-existent-uuid', quality);
+            expect(result).toBe(false);
+        });
+        it('should return false when server returns 500', async () => {
+            // Mock axios to throw a server error
+            const serverError = new Error('Internal Server Error');
+            mockedAxios.post.mockRejectedValueOnce(serverError);
+            const quality = {
+                score: 6.0,
+                reason: 'Server error test',
+                suggestions: 'Test suggestions for server error'
+            };
+            const result = await client.setQuality('test-task', 'test-uuid', quality);
+            expect(result).toBe(false);
+        });
+        it('should return false when unauthorized', async () => {
+            // Mock axios to throw an unauthorized error
+            const unauthorizedError = new Error('Request failed with status code 401');
+            mockedAxios.post.mockRejectedValueOnce(unauthorizedError);
+            const quality = {
+                score: 3.0,
+                reason: 'Unauthorized test',
+                suggestions: 'Check API credentials'
+            };
+            const result = await client.setQuality('test-task', 'test-uuid', quality);
+            expect(result).toBe(false);
+        });
+    });
+    describe('setQuality parameters', () => {
+        it('should handle special characters in taskName and uuid', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const quality = {
+                score: 4.5,
+                reason: 'Special characters test',
+                suggestions: 'Handle special characters properly'
+            };
+            const result = await client.setQuality('task-with-special-chars-!@#', 'uuid-with-special-chars-!@#', quality);
+            expect(result).toBe(true);
+            expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/task-with-special-chars-!@#/logs/uuid-with-special-chars-!@#/set-quality', { quality }, expect.any(Object));
+        });
+        it('should handle decimal scores correctly', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const quality = {
+                score: 7.123456789,
+                reason: 'Decimal precision test',
+                suggestions: 'Maintain precision in quality scores'
+            };
+            const result = await client.setQuality('decimal-task', 'decimal-uuid', quality);
+            expect(result).toBe(true);
+            expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/decimal-task/logs/decimal-uuid/set-quality', { quality }, expect.any(Object));
+        });
+        it('should handle long reason and suggestions', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const longReason = 'This is a very long reason that explains in detail what went wrong with the implementation and why the score is what it is. '.repeat(5);
+            const longSuggestions = 'Here are detailed suggestions for improvement: 1. Refactor the main function, 2. Add comprehensive error handling, 3. Optimize database queries, 4. Improve code documentation, 5. Add unit tests. '.repeat(3);
+            const quality = {
+                score: 3.5,
+                reason: longReason,
+                suggestions: longSuggestions
+            };
+            const result = await client.setQuality('long-text-task', 'long-text-uuid', quality);
+            expect(result).toBe(true);
+            expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/long-text-task/logs/long-text-uuid/set-quality', { quality }, expect.any(Object));
+        });
+    });
+    describe('silent mode behavior', () => {
+        it('should throw error when credentials are missing', async () => {
+            // Create client without credentials
+            process.env.HIVE_API_KEY = '';
+            process.env.HIVE_API_SECRET = '';
+            process.env.HIVE_HOST = '';
+            const silentClient = new index_1.HiveLogClient('silent-project');
+            const quality = {
+                score: 8.0,
+                reason: 'Test quality for silent mode',
+                suggestions: 'This should not be processed'
+            };
+            await expect(silentClient.setQuality('test-task', 'test-uuid', quality))
+                .rejects
+                .toThrow('Missing Hive API credentials or host, get them at https://forgehive.dev');
+            // Verify axios was never called
+            expect(mockedAxios.post).not.toHaveBeenCalled();
+        });
+    });
+});

package/jest.config.js

@@ -0,0 +1,11 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/src/test/**/*.ts', '**/?(*.)+(spec|test).ts'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest'
+  },
+  moduleFileExtensions: ['ts', 'js', 'json', 'node']
+} 

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@forgehive/hive-sdk",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^24.0.3",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.8.4",
+    "debug": "^4.4.1"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  }
+}

package/src/index.ts

@@ -0,0 +1,168 @@
+import axios from 'axios'
+import debug from 'debug'
+
+const log = debug('hive-sdk')
+
+// API Response Types
+export interface LogApiResponse {
+  uuid: string
+  taskName: string
+  projectName: string
+  logItem: {
+    input: unknown
+    output?: unknown
+    error?: unknown
+    boundaries?: Record<string, Array<{ input: unknown; output: unknown, error: unknown }>>
+  }
+  replayFrom?: string
+  createdAt: string
+}
+
+export interface ApiError {
+  error: string
+}
+
+export interface LogApiSuccess extends LogApiResponse {}
+
+export type LogApiResult = LogApiSuccess | ApiError
+
+// Quality interface for setQuality method
+export interface Quality {
+  score: number
+  reason: string
+  suggestions: string
+}
+
+// Type guard to check if response is an error
+export function isApiError(response: unknown): response is ApiError {
+  return response !== null && typeof response === 'object' && 'error' in response
+}
+
+export class HiveLogClient {
+  private apiKey: string | null
+  private apiSecret: string | null
+  private host: string | null
+  private projectName: string
+  private isInitialized: boolean
+
+  constructor(projectName: string) {
+    const apiKey = process.env.HIVE_API_KEY
+    const apiSecret = process.env.HIVE_API_SECRET
+    const host = process.env.HIVE_HOST
+
+    this.projectName = projectName
+
+    if (!apiKey || !apiSecret || !host) {
+      this.apiKey = null
+      this.apiSecret = null
+      this.host = null
+      this.isInitialized = false
+      log('HiveLogClient in silent mode for project "%s" - missing credentials (get them at https://forgehive.dev)', projectName)
+    } else {
+      this.apiKey = apiKey
+      this.apiSecret = apiSecret
+      this.host = host
+      this.isInitialized = true
+      log('HiveLogClient initialized for project "%s" with host "%s"', projectName, host)
+    }
+  }
+
+  isActive(): boolean {
+    return this.isInitialized
+  }
+
+  async sendLog(taskName: string, logItem: unknown): Promise<'success' | 'error' | 'silent'> {
+    if (!this.isInitialized) {
+      log('Silent mode: Skipping sendLog for task "%s" - client not initialized', taskName)
+      return 'silent'
+    }
+
+    try {
+      const logsUrl = `${this.host}/api/tasks/log-ingest`
+      log('Sending log for task "%s" to %s', taskName, logsUrl)
+
+      const authToken = `${this.apiKey}:${this.apiSecret}`
+
+      await axios.post(logsUrl, {
+        projectName: this.projectName,
+        taskName,
+        logItem: JSON.stringify(logItem)
+      }, {
+        headers: {
+          Authorization: `Bearer ${authToken}`,
+          'Content-Type': 'application/json'
+        }
+      })
+
+      log('Success: Sent log for task "%s"', taskName)
+      return 'success'
+    } catch (e) {
+      const error = e as Error
+      log('Error: Failed to send log for task "%s": %s', taskName, error.message)
+      return 'error'
+    }
+  }
+
+  async getLog(taskName: string, uuid: string): Promise<LogApiResult | null> {
+    if (!this.isInitialized) {
+      log('Error: getLog for task "%s" with uuid "%s" - missing credentials', taskName, uuid)
+      throw new Error('Missing Hive API credentials or host, get them at https://forgehive.dev')
+    }
+
+    try {
+      const logUrl = `${this.host}/api/tasks/${taskName}/logs/${uuid}`
+      log('Fetching log for task "%s" with uuid "%s" from %s', taskName, uuid, logUrl)
+
+      const authToken = `${this.apiKey}:${this.apiSecret}`
+
+      const response = await axios.get(logUrl, {
+        headers: {
+          Authorization: `Bearer ${authToken}`,
+          'Content-Type': 'application/json'
+        }
+      })
+
+      log('Success: Fetched log for task "%s" with uuid "%s"', taskName, uuid)
+      return response.data as LogApiResult
+    } catch (e) {
+      const error = e as Error
+      log('Error: Failed to fetch log for task "%s" with uuid "%s": %s', taskName, uuid, error.message)
+      return null
+    }
+  }
+
+  async setQuality(taskName: string, uuid: string, quality: Quality): Promise<boolean> {
+    if (!this.isInitialized) {
+      log('Error: setQuality for task "%s" with uuid "%s" - missing credentials', taskName, uuid)
+      throw new Error('Missing Hive API credentials or host, get them at https://forgehive.dev')
+    }
+
+    try {
+      const qualityUrl = `${this.host}/api/tasks/${taskName}/logs/${uuid}/set-quality`
+      log('Setting quality for task "%s" with uuid "%s" (score: %d) to %s', taskName, uuid, quality.score, qualityUrl)
+
+      const authToken = `${this.apiKey}:${this.apiSecret}`
+
+      await axios.post(qualityUrl, {
+        quality
+      }, {
+        headers: {
+          Authorization: `Bearer ${authToken}`,
+          'Content-Type': 'application/json'
+        }
+      })
+
+      log('Success: Set quality for task "%s" with uuid "%s" (score: %d)', taskName, uuid, quality.score)
+      return true
+    } catch (e) {
+      const error = e as Error
+      log('Error: Failed to set quality for task "%s" with uuid "%s": %s', taskName, uuid, error.message)
+      return false
+    }
+  }
+}
+
+export const createHiveLogClient = (projectName: string): HiveLogClient => {
+  log('Creating HiveLogClient for project "%s"', projectName)
+  return new HiveLogClient(projectName)
+}