@vainplex/openclaw-knowledge-engine 0.1.2 → 0.1.4

package/test/hooks.test.ts

@@ -1,120 +0,0 @@
-// test/hooks.test.ts
-
-import { describe, it, beforeEach, mock, afterEach } from 'node:test';
-import * as assert from 'node:assert';
-import { HookManager } from '../src/hooks.js';
-import type { OpenClawPluginApi, KnowledgeConfig, HookEvent } from '../src/types.js';
-import { FactStore } from '../src/fact-store.js';
-import { Maintenance } from '../src/maintenance.js';
-
-type TriggerFn = (event: string, eventData: HookEvent) => Promise<void>;
-
-describe('HookManager', () => {
-  let api: OpenClawPluginApi & { _trigger: TriggerFn; handlers: Map<string, (e: HookEvent, ctx: Record<string, unknown>) => void> };
-  let config: KnowledgeConfig;
-
-  beforeEach(() => {
-    config = {
-      enabled: true,
-      workspace: '/tmp',
-      extraction: {
-        regex: { enabled: true },
-        llm: { enabled: true, model: 'm', endpoint: 'http://e.com', batchSize: 1, cooldownMs: 1 },
-      },
-      decay: { enabled: true, intervalHours: 1, rate: 0.1 },
-      embeddings: { enabled: true, syncIntervalMinutes: 1, endpoint: 'http://e.com', collectionName: 'c' },
-      storage: { maxEntities: 1, maxFacts: 1, writeDebounceMs: 0 },
-    };
-    const handlers = new Map<string, (e: HookEvent, ctx: Record<string, unknown>) => void>();
-    api = {
-      pluginConfig: {},
-      logger: { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} },
-      on: (event: string, handler: (e: HookEvent, ctx: Record<string, unknown>) => void) => { handlers.set(event, handler); },
-      handlers,
-      _trigger: async (event: string, eventData: HookEvent) => {
-        const handler = handlers.get(event);
-        if (handler) await handler(eventData, {});
-      },
-    };
-  });
-
-  afterEach(() => {
-    mock.reset();
-    mock.restoreAll();
-  });
-
-  it('should handle onSessionStart correctly', async () => {
-    const loadMock = mock.method(FactStore.prototype, 'load', async () => {});
-    const startMock = mock.method(Maintenance.prototype, 'start', () => {});
-
-    const hookManager = new HookManager(api, config);
-    hookManager.registerHooks();
-
-    await api._trigger('session_start', {});
-
-    assert.strictEqual(loadMock.mock.calls.length, 1);
-    assert.strictEqual(startMock.mock.calls.length, 1);
-  });
-
-  it('should process incoming messages', async () => {
-    mock.method(FactStore.prototype, 'load', async () => {});
-    const addFactMock = mock.method(FactStore.prototype, 'addFact', () => ({}));
-
-    const hookManager = new HookManager(api, config);
-    hookManager.registerHooks();
-
-    mock.method(hookManager as Record<string, unknown>, 'processLlmBatchWhenReady', async () => {
-      const llmEnhancer = (hookManager as Record<string, unknown>).llmEnhancer as { sendBatch: () => Promise<{ entities: unknown[]; facts: unknown[] } | null> };
-      const result = await llmEnhancer.sendBatch();
-      if (result && result.facts.length > 0) {
-        const factStore = (hookManager as Record<string, unknown>).factStore as FactStore;
-        factStore.addFact(result.facts[0] as Parameters<FactStore['addFact']>[0]);
-      }
-    });
-
-    mock.method(
-      (hookManager as Record<string, unknown>).llmEnhancer as Record<string, unknown>,
-      'sendBatch',
-      async () => ({
-        entities: [],
-        facts: [{ subject: 'test', predicate: 'is-a', object: 'fact' }],
-      })
-    );
-
-    const event: HookEvent = { content: 'This is a message.' };
-    await api._trigger('message_received', event);
-
-    assert.strictEqual(addFactMock.mock.calls.length, 1);
-    assert.strictEqual(
-      (addFactMock.mock.calls[0].arguments[0] as Record<string, unknown>).subject,
-      'test'
-    );
-  });
-
-  it('should register gateway_stop hook', () => {
-    const hookManager = new HookManager(api, config);
-    hookManager.registerHooks();
-    assert.ok(api.handlers.has('gateway_stop'), 'gateway_stop hook should be registered');
-  });
-
-  it('should call maintenance.stop() on shutdown', async () => {
-    mock.method(FactStore.prototype, 'load', async () => {});
-    const stopMock = mock.method(Maintenance.prototype, 'stop', () => {});
-    mock.method(Maintenance.prototype, 'start', () => {});
-
-    const hookManager = new HookManager(api, config);
-    hookManager.registerHooks();
-
-    await api._trigger('session_start', {});
-    await api._trigger('gateway_stop', {});
-
-    assert.strictEqual(stopMock.mock.calls.length >= 1, true);
-  });
-
-  it('should not register hooks when disabled', () => {
-    config.enabled = false;
-    const hookManager = new HookManager(api, config);
-    hookManager.registerHooks();
-    assert.strictEqual(api.handlers.size, 0);
-  });
-});

package/test/http-client.test.ts

@@ -1,68 +0,0 @@
-// test/http-client.test.ts
-
-import { describe, it, afterEach } from 'node:test';
-import * as assert from 'node:assert';
-import * as http from 'node:http';
-import { httpPost } from '../src/http-client.js';
-
-describe('httpPost', () => {
-  let server: http.Server | null = null;
-
-  afterEach((_, done) => {
-    if (server) {
-      server.close(() => done());
-      server = null;
-    } else {
-      done();
-    }
-  });
-
-  it('should make a successful POST request', async () => {
-    let receivedBody = '';
-    server = http.createServer((req, res) => {
-      let body = '';
-      req.on('data', chunk => { body += chunk; });
-      req.on('end', () => {
-        receivedBody = body;
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end('{"ok":true}');
-      });
-    });
-
-    await new Promise<void>(resolve => server!.listen(0, resolve));
-    const port = (server.address() as { port: number }).port;
-
-    const result = await httpPost(`http://localhost:${port}/test`, { key: 'value' });
-    assert.strictEqual(result, '{"ok":true}');
-    assert.strictEqual(JSON.parse(receivedBody).key, 'value');
-  });
-
-  it('should reject on non-2xx status codes', async () => {
-    server = http.createServer((_req, res) => {
-      res.writeHead(500);
-      res.end('Internal Server Error');
-    });
-
-    await new Promise<void>(resolve => server!.listen(0, resolve));
-    const port = (server.address() as { port: number }).port;
-
-    await assert.rejects(
-      () => httpPost(`http://localhost:${port}/test`, {}),
-      (err: Error) => {
-        assert.ok(err.message.includes('500'));
-        return true;
-      }
-    );
-  });
-
-  it('should reject on connection error', async () => {
-    // Port that nothing is listening on
-    await assert.rejects(
-      () => httpPost('http://localhost:19999/test', {}),
-      (err: Error) => {
-        assert.ok(err.message.includes('request error'));
-        return true;
-      }
-    );
-  });
-});

package/test/llm-enhancer.test.ts

@@ -1,132 +0,0 @@
-// test/llm-enhancer.test.ts
-
-import { describe, it, beforeEach, afterEach, mock } from 'node:test';
-import * as assert from 'node:assert';
-import { LlmEnhancer } from '../src/llm-enhancer.js';
-import type { KnowledgeConfig, Logger } from '../src/types.js';
-
-const createMockLogger = (): Logger & { logs: { level: string; msg: string }[] } => {
-  return {
-    logs: [],
-    info: function(msg) { this.logs.push({ level: 'info', msg }); },
-    warn: function(msg) { this.logs.push({ level: 'warn', msg }); },
-    error: function(msg) { this.logs.push({ level: 'error', msg }); },
-    debug: function(msg) { this.logs.push({ level: 'debug', msg }); },
-  };
-};
-
-const mockConfig: KnowledgeConfig['extraction']['llm'] = {
-  enabled: true,
-  model: 'test-model',
-  endpoint: 'http://localhost:12345/api/test',
-  batchSize: 3,
-  cooldownMs: 100,
-};
-
-describe('LlmEnhancer', () => {
-  let logger: ReturnType<typeof createMockLogger>;
-  let enhancer: LlmEnhancer;
-
-  beforeEach(() => {
-    logger = createMockLogger();
-    enhancer = new LlmEnhancer(mockConfig, logger);
-  });
-
-  afterEach(() => {
-    enhancer.clearTimers();
-    mock.reset();
-    mock.restoreAll();
-  });
-
-  const mockHttpRequest = (response: string): void => {
-    // Mock the private makeHttpRequest method on the instance prototype
-    mock.method(
-      enhancer as unknown as Record<string, unknown>,
-      'makeHttpRequest',
-      async () => response
-    );
-  };
-
-  it('should add items to the batch and respect batchSize', () => {
-    const llmPayload = { entities: [], facts: [] };
-    const llmResponse = { response: JSON.stringify(llmPayload) };
-    mockHttpRequest(JSON.stringify(llmResponse));
-
-    enhancer.addToBatch({ id: 'msg1', text: 'Hello' });
-    enhancer.addToBatch({ id: 'msg2', text: 'World' });
-    assert.strictEqual(logger.logs.filter(l => l.msg.includes('Sending immediately')).length, 0);
-
-    enhancer.addToBatch({ id: 'msg3', text: 'Test' });
-    assert.strictEqual(logger.logs.filter(l => l.msg.includes('Sending immediately')).length, 1);
-  });
-
-  it('should correctly parse a valid LLM response', async () => {
-    const llmPayload = {
-      entities: [{ type: 'person', value: 'Claude', importance: 0.9 }],
-      facts: [{ subject: 'Claude', predicate: 'is-a', object: 'Person' }],
-    };
-    const llmResponse = { response: JSON.stringify(llmPayload) };
-    mockHttpRequest(JSON.stringify(llmResponse));
-
-    enhancer.addToBatch({ id: 'm1', text: 'The person is Claude.' });
-    const result = await enhancer.sendBatch();
-
-    assert.ok(result);
-    assert.strictEqual(result.entities.length, 1);
-    assert.strictEqual(result.entities[0].value, 'Claude');
-    assert.strictEqual(result.facts.length, 1);
-    assert.strictEqual(result.facts[0].subject, 'Claude');
-  });
-
-  it('should return null when the batch is empty', async () => {
-    const result = await enhancer.sendBatch();
-    assert.strictEqual(result, null);
-  });
-
-  it('should handle HTTP errors gracefully', async () => {
-    mock.method(
-      enhancer as unknown as Record<string, unknown>,
-      'makeHttpRequest',
-      async () => { throw new Error('HTTP request failed with status 500'); }
-    );
-
-    enhancer.addToBatch({ id: 'm1', text: 'Test' });
-    const result = await enhancer.sendBatch();
-
-    assert.strictEqual(result, null);
-    assert.ok(logger.logs.some(l => l.level === 'error'));
-  });
-
-  it('should handle invalid JSON from LLM', async () => {
-    mockHttpRequest('not json');
-
-    enhancer.addToBatch({ id: 'm1', text: 'Test' });
-    const result = await enhancer.sendBatch();
-
-    assert.strictEqual(result, null);
-    assert.ok(logger.logs.some(l => l.level === 'error'));
-  });
-
-  it('should clear the batch after sending', async () => {
-    const llmPayload = { entities: [], facts: [] };
-    mockHttpRequest(JSON.stringify({ response: JSON.stringify(llmPayload) }));
-
-    enhancer.addToBatch({ id: 'm1', text: 'Test' });
-    await enhancer.sendBatch();
-
-    // Second send should return null (empty batch)
-    const result = await enhancer.sendBatch();
-    assert.strictEqual(result, null);
-  });
-
-  it('should handle LLM response with missing entities/facts gracefully', async () => {
-    mockHttpRequest(JSON.stringify({ response: '{}' }));
-
-    enhancer.addToBatch({ id: 'm1', text: 'Test' });
-    const result = await enhancer.sendBatch();
-
-    assert.ok(result);
-    assert.strictEqual(result.entities.length, 0);
-    assert.strictEqual(result.facts.length, 0);
-  });
-});

package/test/maintenance.test.ts

@@ -1,117 +0,0 @@
-// test/maintenance.test.ts
-
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import * as assert from 'node:assert';
-import { Maintenance } from '../src/maintenance.js';
-import { Embeddings } from '../src/embeddings.js';
-import type { KnowledgeConfig, Logger, Fact } from '../src/types.js';
-import * as timers from 'node:timers/promises';
-
-class MockFactStore {
-  decayRate = 0;
-  decayedCount = 0;
-  unembeddedFacts: Fact[] = [];
-  markedAsEmbeddedIds: string[] = [];
-
-  decayFacts(rate: number) {
-    this.decayRate = rate;
-    this.decayedCount++;
-    return { decayedCount: 1 };
-  }
-  getUnembeddedFacts() { return this.unembeddedFacts; }
-  markFactsAsEmbedded(ids: string[]) {
-    this.markedAsEmbeddedIds.push(...ids);
-    // Clear unembedded facts after marking (mimics real behavior)
-    this.unembeddedFacts = this.unembeddedFacts.filter(f => !ids.includes(f.id));
-  }
-}
-
-class MockEmbeddings {
-  isEnabledState = true;
-  syncedFacts: Fact[] = [];
-  isEnabled() { return this.isEnabledState; }
-  sync(facts: Fact[]) {
-    this.syncedFacts.push(...facts);
-    return Promise.resolve(facts.length);
-  }
-}
-
-const createMockLogger = (): Logger => ({
-  info: () => {}, warn: () => {}, error: () => {}, debug: () => {},
-});
-
-const mockConfig: KnowledgeConfig = {
-  enabled: true,
-  workspace: '/tmp',
-  decay: { enabled: true, intervalHours: 0.0001, rate: 0.1 },
-  embeddings: {
-    enabled: true,
-    syncIntervalMinutes: 0.0001,
-    endpoint: 'http://test.com',
-    collectionName: 'test',
-  },
-  storage: { maxEntities: 100, maxFacts: 100, writeDebounceMs: 0 },
-  extraction: {
-    regex: { enabled: true },
-    llm: { enabled: false, model: '', endpoint: '', batchSize: 1, cooldownMs: 0 },
-  },
-};
-
-describe('Maintenance', () => {
-  let logger: Logger;
-  let mockFactStore: MockFactStore;
-  let mockEmbeddings: MockEmbeddings;
-  let maintenance: Maintenance;
-
-  beforeEach(() => {
-    logger = createMockLogger();
-    mockFactStore = new MockFactStore();
-    mockEmbeddings = new MockEmbeddings();
-    // @ts-ignore - Using mock class
-    maintenance = new Maintenance(mockConfig, logger, mockFactStore, mockEmbeddings);
-  });
-
-  afterEach(() => {
-    maintenance.stop();
-  });
-
-  it('should schedule and run decay task', async () => {
-    maintenance.start();
-    await timers.setTimeout(mockConfig.decay.intervalHours * 60 * 60 * 1000 + 10);
-    assert.strictEqual(mockFactStore.decayedCount > 0, true);
-    assert.strictEqual(mockFactStore.decayRate, mockConfig.decay.rate);
-  });
-
-  it('should schedule and run embeddings sync task', async () => {
-    const testFact: Fact = {
-      id: 'fact1', subject: 's', predicate: 'p', object: 'o',
-      relevance: 1, createdAt: 't', lastAccessed: 't', source: 'ingested',
-    };
-    mockFactStore.unembeddedFacts = [testFact];
-    maintenance.start();
-    await timers.setTimeout(mockConfig.embeddings.syncIntervalMinutes * 60 * 1000 + 10);
-    assert.strictEqual(mockEmbeddings.syncedFacts.length > 0, true);
-    assert.deepStrictEqual(mockEmbeddings.syncedFacts[0], testFact);
-    assert.deepStrictEqual(mockFactStore.markedAsEmbeddedIds, [testFact.id]);
-  });
-
-  it('should not schedule embeddings if disabled', async () => {
-    mockEmbeddings.isEnabledState = false;
-    maintenance.start();
-    await timers.setTimeout(5);
-    assert.strictEqual(mockEmbeddings.syncedFacts.length, 0);
-  });
-
-  it('should stop all timers cleanly', () => {
-    maintenance.start();
-    maintenance.stop();
-    // No error means timers were cleared successfully
-    assert.ok(true);
-  });
-
-  it('should run decay manually', () => {
-    maintenance.runDecay();
-    assert.strictEqual(mockFactStore.decayedCount, 1);
-    assert.strictEqual(mockFactStore.decayRate, mockConfig.decay.rate);
-  });
-});

package/test/patterns.test.ts

@@ -1,123 +0,0 @@
-// test/patterns.test.ts
-
-import { describe, it } from 'node:test';
-import * as assert from 'node:assert';
-import { REGEX_PATTERNS } from '../src/patterns.js';
-
-type TestCase = [string, string | null | string[]];
-
-const runTestCases = (regex: RegExp, testCases: TestCase[]) => {
-  for (const [input, expected] of testCases) {
-    // Reset regex state for each test case
-    regex.lastIndex = 0;
-    const matches = input.match(regex);
-    if (expected === null) {
-      assert.strictEqual(matches, null, `Expected no match for: "${input}"`);
-    } else if (Array.isArray(expected)) {
-      assert.deepStrictEqual(matches, expected, `Mismatch for: "${input}"`);
-    } else {
-      assert.deepStrictEqual(matches, [expected], `Mismatch for: "${input}"`);
-    }
-  }
-};
-
-describe('REGEX_PATTERNS', () => {
-
-  it('should match valid email addresses', () => {
-    const testCases: TestCase[] = [
-      ['contact support at support@example.com', 'support@example.com'],
-      ['my email is john.doe123@sub.domain.co.uk.', 'john.doe123@sub.domain.co.uk'],
-      ['invalid-email@', null],
-      ['user@localhost', null],
-      ['test@.com', null],
-      ['multiple emails: a@b.com and c@d.org', ['a@b.com', 'c@d.org']],
-    ];
-    runTestCases(REGEX_PATTERNS.email, testCases);
-  });
-
-  it('should match valid URLs', () => {
-    const testCases: TestCase[] = [
-      ['visit https://www.example.com for more info', 'https://www.example.com'],
-      ['check http://sub.domain.org/path?query=1', 'http://sub.domain.org/path?query=1'],
-      ['ftp://invalid.com', null],
-      ['www.example.com', null],
-      ['a link: https://a.co and another http://b.com/end.', ['https://a.co', 'http://b.com/end']],
-    ];
-    runTestCases(REGEX_PATTERNS.url, testCases);
-  });
-
-  it('should match ISO 8601 dates', () => {
-    const testCases: TestCase[] = [
-      ['The date is 2026-02-17.', '2026-02-17'],
-      ['Timestamp: 2026-02-17T15:30:00Z', '2026-02-17T15:30:00Z'],
-      ['With milliseconds: 2026-02-17T15:30:00.123Z', '2026-02-17T15:30:00.123Z'],
-      ['Not a date: 2026-02-17T', null],
-      ['Invalid format 2026/02/17', null],
-    ];
-    runTestCases(REGEX_PATTERNS.iso_date, testCases);
-  });
-
-  it('should match common date formats (US & EU)', () => {
-    const testCases: TestCase[] = [
-        ['US date: 02/17/2026.', '02/17/2026'],
-        ['EU date: 17.02.2026,', '17.02.2026'],
-        ['Short year: 1.1.99', '1.1.99'],
-        ['Two dates: 12/25/2024 and 24.12.2024', ['12/25/2024', '24.12.2024']],
-    ];
-    runTestCases(REGEX_PATTERNS.common_date, testCases);
-  });
-
-  it('should match German date formats', () => {
-    const testCases: TestCase[] = [
-      ['Datum: 17. Februar 2026', '17. Februar 2026'],
-      ['Am 1. Januar 2025 war es kalt.', '1. Januar 2025'],
-      ['No match: 17 Februar 2026', null],
-    ];
-    runTestCases(REGEX_PATTERNS.german_date, testCases);
-  });
-
-  it('should match English date formats', () => {
-    const testCases: TestCase[] = [
-      ['Date: February 17, 2026', 'February 17, 2026'],
-      ['On March 1st, 2025, we launched.', 'March 1st, 2025'],
-      ['Also August 2nd, 2024 and May 3rd, 2023.', ['August 2nd, 2024', 'May 3rd, 2023']],
-      ['No match: February 17 2026', null],
-    ];
-    runTestCases(REGEX_PATTERNS.english_date, testCases);
-  });
-
-  it('should match proper nouns (names, places)', () => {
-    const testCases: TestCase[] = [
-      ['Hello, my name is Claude Keller.', ['Claude Keller']],
-      ['This is Jean-Luc Picard of the USS Enterprise.', ['Jean-Luc Picard', 'USS Enterprise']],
-      ['Talk to O\'Malley about it.', ['O\'Malley']],
-      ['OpenClaw is a project.', ['OpenClaw']],
-      ['Not a name: lower case', null],
-      ['Multiple: Forge and Atlas are agents.', ['Forge', 'Atlas']],
-    ];
-    runTestCases(REGEX_PATTERNS.proper_noun, testCases);
-  });
-
-  it('should match product-like names', () => {
-    const testCases: TestCase[] = [
-        ['I have an iPhone 15.', 'iPhone 15'],
-        ['We are using Windows 11.', 'Windows 11'],
-        ['The latest model is GPT-4.', 'GPT-4'],
-        ['Also look at ProductX.', 'ProductX'],
-        ['The Roman Empire used IV.', 'Roman Empire used IV'], // Imperfect but acceptable
-    ];
-    runTestCases(REGEX_PATTERNS.product_name, testCases);
-  });
-  
-  it('should match organization names with suffixes', () => {
-    const testCases: TestCase[] = [
-        ['He works at Acme GmbH.', 'Acme GmbH'],
-        ['The owner of Stark Industries, LLC is Tony Stark.', 'Stark Industries, LLC'],
-        ['Globex Corp. is another example.', 'Globex Corp.'],
-        ['This also catches Acme Inc. and Cyberdyne Systems Ltd.', ['Acme Inc.', 'Cyberdyne Systems Ltd.']],
-        ['No match for Acme alone', null],
-    ];
-    runTestCases(REGEX_PATTERNS.organization_suffix, testCases);
-  });
-
-});

package/test/storage.test.ts

@@ -1,86 +0,0 @@
-// test/storage.test.ts
-
-import { describe, it, before, after, beforeEach } from 'node:test';
-import * as assert from 'node:assert';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { AtomicStorage } from '../src/storage.js';
-import type { Logger } from '../src/types.js';
-
-const createMockLogger = (): Logger & { logs: { level: string; msg: string }[] } => {
-  const logs: { level: string; msg: string }[] = [];
-  return { logs, info: (msg) => logs.push({ level: 'info', msg }), warn: (msg) => logs.push({ level: 'warn', msg }), error: (msg) => logs.push({ level: 'error', msg }), debug: (msg) => logs.push({ level: 'debug', msg }) };
-};
-
-describe('AtomicStorage', () => {
-  const testDir = path.join('/tmp', `atomic-storage-test-${Date.now()}`);
-  let logger: ReturnType<typeof createMockLogger>;
-  let storage: AtomicStorage;
-
-  before(async () => await fs.mkdir(testDir, { recursive: true }));
-  after(async () => await fs.rm(testDir, { recursive: true, force: true }));
-  beforeEach(() => { logger = createMockLogger(); storage = new AtomicStorage(testDir, logger); });
-
-  it('should initialize and create the storage directory', async () => {
-    const newDir = path.join(testDir, 'new-dir');
-    const newStorage = new AtomicStorage(newDir, logger);
-    await newStorage.init();
-    const stats = await fs.stat(newDir);
-    assert.ok(stats.isDirectory(), 'Directory should be created');
-  });
-
-  describe('writeJson', () => {
-    it('should write a JSON object to a file', async () => {
-      const fileName = 'test.json';
-      const data = { key: 'value', number: 123 };
-      await storage.writeJson(fileName, data);
-      const content = await fs.readFile(path.join(testDir, fileName), 'utf-8');
-      assert.deepStrictEqual(JSON.parse(content), data);
-    });
-  });
-
-  describe('readJson', () => {
-    it('should read and parse a valid JSON file', async () => {
-      const fileName = 'read.json';
-      const data = { a: 1, b: [2, 3] };
-      await fs.writeFile(path.join(testDir, fileName), JSON.stringify(data));
-      const result = await storage.readJson<typeof data>(fileName);
-      assert.deepStrictEqual(result, data);
-    });
-
-    it('should return null if the file does not exist', async () => {
-      const result = await storage.readJson('nonexistent.json');
-      assert.strictEqual(result, null);
-    });
-  });
-
-  describe('debounce', () => {
-    it('should only call the async function once after the delay', async () => {
-      let callCount = 0;
-      const asyncFn = async () => { callCount++; return callCount; };
-      const debouncedFn = AtomicStorage.debounce(asyncFn, 50);
-
-      const p1 = debouncedFn();
-      const p2 = debouncedFn();
-      const p3 = debouncedFn();
-
-      const results = await Promise.all([p1, p2, p3]);
-      assert.strictEqual(callCount, 1);
-      assert.deepStrictEqual(results, [1, 1, 1]);
-    });
-
-    it('should pass the arguments of the last call to the async function', async () => {
-      let finalArgs: any[] = [];
-      const asyncFn = async (...args: any[]) => { finalArgs = args; return finalArgs; };
-      const debouncedFn = AtomicStorage.debounce(asyncFn, 50);
-
-      debouncedFn(1);
-      debouncedFn(2, 3);
-      const finalPromise = debouncedFn(4, 5, 6);
-      
-      const result = await finalPromise;
-      assert.deepStrictEqual(finalArgs, [4, 5, 6]);
-      assert.deepStrictEqual(result, [4, 5, 6]);
-    });
-  });
-});

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "lib": ["ES2022"],
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "strict": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "strictFunctionTypes": true,
-    "strictBindCallApply": true,
-    "strictPropertyInitialization": true,
-    "noImplicitThis": true,
-    "alwaysStrict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "skipLibCheck": true,
-    "outDir": "./dist",
-    "declaration": true
-  },
-  "include": ["src/**/*.ts", "index.ts"],
-  "exclude": ["node_modules", "dist", "test"]
-}