alif-digest 1.0.1

package/tests/config-manager.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { ConfigManager } from '../src/core/config-manager.js';
+import { Config } from '../src/core/config-schema.js';
+
+vi.mock('fs');
+vi.mock('os');
+
+describe('ConfigManager', () => {
+  const mockConfigDir = '/mock/home/.config/alif';
+  const mockConfigFile = path.join(mockConfigDir, 'config.json');
+  const mockConfig: Config = {
+    llm: {
+      provider: 'ollama',
+      model: 'llama3',
+      baseUrl: 'http://localhost:11434',
+    },
+    delivery: [{ type: 'slack', webhookUrl: 'https://hooks.slack.com/services/test' }],
+    preferences: {
+      signalThreshold: 60,
+      maxItemsPerCategory: 5,
+      sourceCooldownMinutes: 5,
+      customKeywords: {},
+    },
+    dbPath: path.join(mockConfigDir, 'alif.db'),
+    feedsPath: path.join(mockConfigDir, 'feeds.json'),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(os.homedir).mockReturnValue('/mock/home');
+  });
+
+  it('should return correct config paths', () => {
+    const manager = ConfigManager.getInstance();
+    expect(manager.getConfigDir()).toBe(mockConfigDir);
+    expect(manager.getConfigFile()).toBe(mockConfigFile);
+  });
+
+  it('should throw if loading non-existent config', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    const manager = ConfigManager.getInstance();
+    expect(() => manager.load()).toThrow(/Configuration file not found/);
+  });
+
+  it('should load and parse valid config', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+
+    const manager = ConfigManager.getInstance();
+    const loaded = manager.load();
+    expect(loaded).toEqual(mockConfig);
+  });
+
+  it('should save config and create directory if needed', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    const manager = ConfigManager.getInstance();
+    manager.save(mockConfig);
+
+    expect(fs.mkdirSync).toHaveBeenCalledWith(mockConfigDir, { recursive: true });
+    expect(fs.writeFileSync).toHaveBeenCalledWith(
+      mockConfigFile,
+      expect.stringContaining('"provider": "ollama"'),
+      'utf-8',
+    );
+  });
+});

package/tests/db-integration.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createDatabase } from '../src/db/connection.js';
+import { runMigrations } from '../src/db/migrate.js';
+import { ArticleStore } from '../src/db/article-store.js';
+import { SourceHealthStore } from '../src/db/source-health-store.js';
+import fs from 'fs';
+import path from 'path';
+
+describe('Database Integration', () => {
+  const testDbPath = path.join('/tmp', `alif-test-${Date.now()}.db`);
+  let db: any;
+
+  beforeEach(() => {
+    db = createDatabase(testDbPath);
+  });
+
+  afterEach(() => {
+    db.close();
+    if (fs.existsSync(testDbPath)) {
+      fs.unlinkSync(testDbPath);
+    }
+  });
+
+  it('should run migrations and create tables', () => {
+    runMigrations(db);
+
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+    const tableNames = tables.map((t: any) => t.name);
+
+    expect(tableNames).toContain('articles');
+    expect(tableNames).toContain('source_health');
+    expect(tableNames).toContain('schedules');
+    expect(tableNames).toContain('migrations');
+  });
+
+  it('should upsert articles and retrieve latest timestamp', () => {
+    runMigrations(db);
+    const store = new ArticleStore(db);
+
+    const article = {
+      id: 'test-1',
+      title: 'Test Article',
+      url: 'https://example.com',
+      source: 'test',
+      digest_date: '2024-03-05',
+      published_at: '2024-03-05T10:00:00Z',
+    };
+
+    store.upsert(article);
+    expect(store.getLatestTimestamp()).toBe('2024-03-05T10:00:00Z');
+
+    // Update
+    store.upsert({ ...article, title: 'Updated Title' });
+    const saved = db.prepare('SELECT title FROM articles WHERE id = ?').get('test-1');
+    expect(saved.title).toBe('Updated Title');
+  });
+
+  it('should record source health', () => {
+    runMigrations(db);
+    const healthStore = new SourceHealthStore(db);
+
+    healthStore.record({
+      source: 'hn',
+      status: 'ok',
+      items_found: 10,
+    });
+
+    const latest = healthStore.getLatest('hn') as any;
+    expect(latest.status).toBe('ok');
+    expect(latest.items_found).toBe(10);
+  });
+});

package/tests/filters.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from 'vitest';
+import { KeywordScorer } from '../src/core/filters/keywords.js';
+import { Deduplicator } from '../src/core/filters/deduplicator.js';
+
+describe('Filters', () => {
+  describe('KeywordScorer', () => {
+    it('should calculate score based on keywords', () => {
+      const scorer = new KeywordScorer({ 'gpt-4': 50, ai: 10 });
+      const article = {
+        id: '1',
+        title: 'New GPT-4 details',
+        content: 'AI is changing the world',
+        source: 'test',
+        url: 'http://example.com',
+      };
+      expect(scorer.score(article)).toBe(60);
+    });
+
+    it('should prioritize overridden keywords and include new ones', () => {
+      // Simulate merging mechanics from pipeline
+      const BASE = { 'gpt-4': 50, ai: 10 };
+      const CUSTOM = { 'gpt-4': 100, custom_tool: 30, ai: 0 };
+      const merged = { ...BASE, ...CUSTOM };
+
+      const scorer = new KeywordScorer(merged);
+      const article = {
+        id: '1',
+        title: 'New GPT-4 details using custom_tool',
+        content: 'AI is changing the world',
+        source: 'test',
+        url: 'http://example.com',
+      };
+
+      // GPT-4 (100) + custom_tool (30) + AI (0) = 130
+      expect(scorer.score(article)).toBe(130);
+    });
+  });
+
+  describe('Deduplicator', () => {
+    it('should remove duplicate URLs', () => {
+      const deduplicator = new Deduplicator();
+      const articles = [
+        { id: '1', title: 'A', url: 'http://example.com/', source: 's1' },
+        { id: '2', title: 'A proxy', url: 'http://example.com', source: 's2' },
+        { id: '3', title: 'B', url: 'http://other.com', source: 's1' },
+      ];
+      const result = deduplicator.process(articles);
+      expect(result).toHaveLength(2);
+      expect(result[0].id).toBe('1');
+      expect(result[1].id).toBe('3');
+    });
+  });
+});

package/tests/llm-provider.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import axios from 'axios';
+import { OllamaProvider } from '../src/providers/llm/ollama.js';
+
+vi.mock('axios');
+
+describe('OllamaProvider', () => {
+  const options = { baseUrl: 'http://localhost:11434', model: 'test-model' };
+  const provider = new OllamaProvider(options);
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return empty array if no articles provided', async () => {
+    const result = await provider.analyze([]);
+    expect(result).toEqual([]);
+  });
+
+  it('should parse valid JSON response from Ollama', async () => {
+    const mockResponse = {
+      data: {
+        response: JSON.stringify([
+          { summary: 'AI reaches breakthrough.', category: 'Research' },
+          { summary: 'New model released.', category: 'Model Release' },
+        ]),
+      },
+    };
+    vi.mocked(axios.post).mockResolvedValue(mockResponse);
+
+    const articles = [{ title: 'Article 1' }, { title: 'Article 2' }];
+    const result = await provider.analyze(articles);
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({ summary: 'AI reaches breakthrough.', category: 'Research' });
+    expect(result[1]).toEqual({ summary: 'New model released.', category: 'Model Release' });
+  });
+
+  it('should handle single object response by wrapping in array', async () => {
+    const mockResponse = {
+      data: {
+        response: JSON.stringify({ summary: 'Single breakthrough.', category: 'Research' }),
+      },
+    };
+    vi.mocked(axios.post).mockResolvedValue(mockResponse);
+
+    const result = await provider.analyze([{ title: 'Article 1' }]);
+    expect(result).toHaveLength(1);
+    expect(result[0].summary).toBe('Single breakthrough.');
+  });
+
+  it('should return default objects on parse error', async () => {
+    const mockResponse = {
+      data: {
+        response: 'Invalid JSON',
+      },
+    };
+    vi.mocked(axios.post).mockResolvedValue(mockResponse);
+
+    const articles = [{ title: 'Article 1' }];
+    const result = await provider.analyze(articles);
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({ summary: null, category: 'Uncategorized' });
+  });
+
+  it('should handle empty response from Ollama', async () => {
+    const mockResponse = {
+      data: {
+        response: '',
+      },
+    };
+    vi.mocked(axios.post).mockResolvedValue(mockResponse);
+
+    const result = await provider.analyze([{ title: 'Article 1' }]);
+    expect(result[0]).toEqual({ summary: null, category: 'Uncategorized' });
+  });
+  it('should handle markdown-wrapped JSON response', async () => {
+    const mockResponse = {
+      data: {
+        response:
+          'Here is the analysis:\n```json\n[{"summary": "Markdown works.", "category": "Test"}]\n```',
+      },
+    };
+    vi.mocked(axios.post).mockResolvedValue(mockResponse);
+
+    const result = await provider.analyze([{ title: 'Article 1' }]);
+    expect(result[0].summary).toBe('Markdown works.');
+  });
+
+  it('should handle text-wrapped JSON response', async () => {
+    const mockResponse = {
+      data: {
+        response:
+          'The result is: [{"summary": "Text wrapped.", "category": "Test"}] end of message.',
+      },
+    };
+    vi.mocked(axios.post).mockResolvedValue(mockResponse);
+
+    const result = await provider.analyze([{ title: 'Article 1' }]);
+    expect(result[0].summary).toBe('Text wrapped.');
+  });
+  it('should fallback to thinking field if response is empty', async () => {
+    const mockResponse = {
+      data: {
+        response: '',
+        thinking: JSON.stringify([{ summary: 'Thoughtful insight.', category: 'Research' }]),
+      },
+    };
+    vi.mocked(axios.post).mockResolvedValue(mockResponse);
+
+    const result = await provider.analyze([{ title: 'Article 1' }]);
+    expect(result[0].summary).toBe('Thoughtful insight.');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests", "**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+    },
+  },
+});