alif-digest 1.0.1

package/src/db/schedule-store.ts

@@ -0,0 +1,41 @@
+import { Database } from 'better-sqlite3';
+
+export interface Schedule {
+  id: string;
+  name: string;
+  cron: string;
+  scheduled_time?: string | null; // HH:mm
+  active: number;
+  last_run?: string | null;
+}
+
+export class ScheduleStore {
+  constructor(private db: Database) { }
+
+  add(schedule: Schedule) {
+    const stmt = this.db.prepare(`
+      INSERT INTO schedules (id, name, cron, scheduled_time, active, last_run)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      schedule.id,
+      schedule.name,
+      schedule.cron,
+      schedule.scheduled_time || null,
+      schedule.active,
+      schedule.last_run || null,
+    );
+  }
+
+  getAll(): Schedule[] {
+    return this.db.prepare('SELECT * FROM schedules').all() as Schedule[];
+  }
+
+  delete(id: string) {
+    this.db.prepare('DELETE FROM schedules WHERE id = ?').run(id);
+  }
+
+  updateLastRun(id: string, timestamp: string) {
+    this.db.prepare('UPDATE schedules SET last_run = ? WHERE id = ?').run(timestamp, id);
+  }
+}

package/src/db/source-health-store.ts

@@ -0,0 +1,42 @@
+import { Database } from 'better-sqlite3';
+
+export interface SourceHealth {
+  source: string;
+  status: 'ok' | 'error';
+  items_found: number;
+  error_message?: string | null;
+}
+
+export class SourceHealthStore {
+  constructor(private db: Database) {}
+
+  record(health: SourceHealth) {
+    const stmt = this.db.prepare(`
+      INSERT INTO source_health (source, status, items_found, error_message)
+      VALUES (?, ?, ?, ?)
+    `);
+    stmt.run(health.source, health.status, health.items_found, health.error_message || null);
+  }
+
+  getLatest(source: string) {
+    return this.db
+      .prepare(
+        `
+      SELECT * FROM source_health WHERE source = ? ORDER BY last_check DESC LIMIT 1
+    `,
+      )
+      .get(source) as { last_check: string } | undefined;
+  }
+
+  isThrottled(source: string, minutes: number): boolean {
+    const latest = this.getLatest(source);
+    if (!latest) return false;
+
+    // SQLite CURRENT_TIMESTAMP is UTC
+    const lastCheck = new Date(latest.last_check + 'Z').getTime();
+    const now = Date.now();
+    const diffMinutes = (now - lastCheck) / (1000 * 60);
+
+    return diffMinutes < minutes;
+  }
+}

package/src/providers/delivery/index.ts

@@ -0,0 +1,19 @@
+export interface Digest {
+  items: {
+    title: string;
+    url: string;
+    summary: string | null;
+    category: string;
+    source: string;
+    score: number;
+  }[];
+  metadata: {
+    total_new_items: number;
+    total_selected: number;
+    date: string;
+  };
+}
+
+export interface DeliveryProvider {
+  send(digest: Digest): Promise<void>;
+}

package/src/providers/delivery/slack.ts

@@ -0,0 +1,55 @@
+import axios from 'axios';
+import { DeliveryProvider, Digest } from './index.js';
+
+export class SlackDelivery implements DeliveryProvider {
+  constructor(private webhookUrl: string) {}
+
+  async send(digest: Digest): Promise<void> {
+    const blocks = [
+      {
+        type: 'header',
+        text: {
+          type: 'plain_text',
+          text: `🚀 Alif AI Signal Digest - ${digest.metadata.date}`,
+          emoji: true,
+        },
+      },
+      {
+        type: 'section',
+        text: {
+          type: 'mrkdwn',
+          text: `Found *${digest.metadata.total_selected}* high-signal items out of *${digest.metadata.total_new_items}* new articles analyzed today.`,
+        },
+      },
+      { type: 'divider' },
+    ];
+
+    for (const item of digest.items) {
+      blocks.push({
+        type: 'section',
+        text: {
+          type: 'mrkdwn',
+          text: `*<${item.url}|${item.title}>*\n_${item.category}_ • ${item.source} • Score: ${item.score}\n${item.summary || 'No summary available.'}`,
+        },
+      } as any);
+    }
+
+    blocks.push({
+      type: 'context',
+      elements: [
+        {
+          type: 'mrkdwn',
+          text: 'Generated by *Alif CLI* — Built by qarib.',
+        },
+      ],
+    } as any);
+
+    try {
+      await axios.post(this.webhookUrl, { blocks });
+    } catch (error) {
+      console.error(
+        `[Slack Delivery] Error: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}

package/src/providers/delivery/webhook.ts

@@ -0,0 +1,16 @@
+import axios from 'axios';
+import { DeliveryProvider, Digest } from './index.js';
+
+export class WebhookDelivery implements DeliveryProvider {
+  constructor(private webhookUrl: string) {}
+
+  async send(digest: Digest): Promise<void> {
+    try {
+      await axios.post(this.webhookUrl, digest);
+    } catch (error) {
+      console.error(
+        `[Webhook Delivery] Error: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}

package/src/providers/factory.ts

@@ -0,0 +1,37 @@
+import { Config } from '../core/config-schema.js';
+import { LLMProvider } from './llm/index.js';
+import { OllamaProvider } from './llm/ollama.js';
+import { AnthropicProvider } from './llm/anthropic.js';
+import { OpenRouterProvider } from './llm/openrouter.js';
+import { DeliveryProvider } from './delivery/index.js';
+import { SlackDelivery } from './delivery/slack.js';
+import { WebhookDelivery } from './delivery/webhook.js';
+
+export class ProviderFactory {
+  static createLLM(config: Config): LLMProvider {
+    const { provider, apiKey, model, baseUrl } = config.llm;
+    switch (provider) {
+      case 'ollama':
+        return new OllamaProvider({ baseUrl: baseUrl || 'http://localhost:11434', model });
+      case 'anthropic':
+        return new AnthropicProvider({ apiKey: apiKey || '', model });
+      case 'openrouter':
+        return new OpenRouterProvider({ apiKey: apiKey || '', model });
+      default:
+        throw new Error(`Unsupported LLM provider: ${provider}`);
+    }
+  }
+
+  static createDelivery(config: Config): DeliveryProvider[] {
+    return config.delivery.map((d) => {
+      switch (d.type) {
+        case 'slack':
+          return new SlackDelivery(d.webhookUrl);
+        case 'webhook':
+          return new WebhookDelivery(d.webhookUrl);
+        default:
+          throw new Error(`Unsupported delivery type: ${d.type}`);
+      }
+    });
+  }
+}

package/src/providers/llm/anthropic.ts

@@ -0,0 +1,48 @@
+import axios from 'axios';
+import { LLMProvider, AnalysisResult } from './index.js';
+import { parseLLMJson } from './utils.js';
+
+export class AnthropicProvider implements LLMProvider {
+  constructor(private options: { apiKey: string; model: string }) { }
+
+  async analyze(articles: { title: string; content?: string }[]): Promise<AnalysisResult[]> {
+    if (articles.length === 0) return [];
+
+    const prompt = `
+Analyze the following AI-related news items. For each item, provide:
+1. A concise, one-sentence summary (max 30 words).
+2. A category (e.g., "Model Release", "Research", "Tool/SDK", "Policy", "Industry News", "Tutorial").
+
+Return ONLY a JSON array of objects with keys "summary" and "category". Match the order of the input items.
+
+Items:
+${articles.map((a, idx) => `${idx + 1}. TITLE: ${a.title}\nCONTENT: ${a.content || 'None'}`).join('\n\n')}
+`;
+
+    try {
+      const response = await axios.post(
+        'https://api.anthropic.com/v1/messages',
+        {
+          model: this.options.model,
+          max_tokens: 4096,
+          messages: [{ role: 'user', content: prompt }],
+          system:
+            'You are an AI signal analyst. Be precise and objective. You respond ONLY with valid JSON array.',
+        },
+        {
+          headers: {
+            'x-api-key': this.options.apiKey,
+            'anthropic-version': '2023-06-01',
+            'content-type': 'application/json',
+          },
+        },
+      );
+
+      const content = response.data.content[0].text;
+      return parseLLMJson(content);
+    } catch (error) {
+      console.error(`[Anthropic] Error: ${error instanceof Error ? error.message : String(error)}`);
+      return articles.map(() => ({ summary: null, category: 'Uncategorized' }));
+    }
+  }
+}

package/src/providers/llm/index.ts

@@ -0,0 +1,8 @@
+export interface AnalysisResult {
+  summary: string | null;
+  category: string;
+}
+
+export interface LLMProvider {
+  analyze(articles: { title: string; content?: string }[]): Promise<AnalysisResult[]>;
+}

package/src/providers/llm/ollama.ts

@@ -0,0 +1,44 @@
+import axios from 'axios';
+import { LLMProvider, AnalysisResult } from './index.js';
+import { parseLLMJson } from './utils.js';
+
+export class OllamaProvider implements LLMProvider {
+  constructor(private options: { baseUrl: string; model: string }) {}
+
+  async analyze(articles: { title: string; content?: string }[]): Promise<AnalysisResult[]> {
+    if (articles.length === 0) return [];
+
+    const prompt = `
+Analyze the following AI-related news items. For each item, provide:
+1. A concise, one-sentence summary (max 30 words).
+2. A category (e.g., "Model Release", "Research", "Tool/SDK", "Policy", "Industry News", "Tutorial").
+
+Return ONLY a JSON array of objects with keys "summary" and "category". Match the order of the input items.
+
+Items:
+${articles.map((a, idx) => `${idx + 1}. TITLE: ${a.title}\nCONTENT: ${a.content || 'None'}`).join('\n\n')}
+`;
+
+    try {
+      const response = await axios.post(`${this.options.baseUrl}/api/generate`, {
+        model: this.options.model,
+        system:
+          'You are an AI signal analyst. Provide direct, objective summaries and categories. Do NOT include any reasoning, thinking process, or <think> tags. Always return a JSON array of objects.',
+        prompt: prompt,
+        stream: false,
+        format: 'json',
+        options: {
+          stop: ['<think>', '</think>', 'Reasoning:'],
+        },
+      });
+
+      const ollamaData = response.data;
+      const finalResponse = ollamaData.response || ollamaData.thinking || '';
+
+      return parseLLMJson(finalResponse);
+    } catch (error) {
+      console.error(`[Ollama] Error: ${error instanceof Error ? error.message : String(error)}`);
+      return articles.map(() => ({ summary: null, category: 'Uncategorized' }));
+    }
+  }
+}

package/src/providers/llm/openrouter.ts

@@ -0,0 +1,56 @@
+import OpenAI from 'openai';
+import { LLMProvider, AnalysisResult } from './index.js';
+import { parseLLMJson } from './utils.js';
+
+export class OpenRouterProvider implements LLMProvider {
+  private client: OpenAI;
+
+  constructor(private options: { apiKey: string; model: string }) {
+    this.client = new OpenAI({
+      baseURL: 'https://openrouter.ai/api/v1',
+      apiKey: this.options.apiKey,
+      defaultHeaders: {
+        'HTTP-Referer': 'https://github.com/qarib/alif',
+        'X-Title': 'Alif CLI',
+      },
+    });
+  }
+
+  async analyze(articles: { title: string; content?: string }[]): Promise<AnalysisResult[]> {
+    if (articles.length === 0) return [];
+
+    const prompt = `
+Analyze the following AI-related news items. For each item, provide:
+1. A concise, one-sentence summary (max 30 words).
+2. A category (e.g., "Model Release", "Research", "Tool/SDK", "Policy", "Industry News", "Tutorial").
+
+Return ONLY a JSON array of objects with keys "summary" and "category". Match the order of the input items.
+
+Items:
+${articles.map((a, idx) => `${idx + 1}. TITLE: ${a.title}\nCONTENT: ${a.content || 'None'}`).join('\n\n')}
+`;
+
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.options.model,
+        messages: [
+          {
+            role: 'system',
+            content:
+              'You are an AI signal analyst. Provide direct, objective summaries and categories. Do NOT include any reasoning, thinking process, or <think> tags. Return valid JSON only.',
+          },
+          { role: 'user', content: prompt },
+        ],
+        response_format: { type: 'json_object' },
+      });
+
+      const content = response.choices[0].message.content;
+      if (!content) throw new Error('Empty response from OpenRouter');
+
+      return parseLLMJson(content);
+    } catch (error) {
+      console.error(`[OpenRouter] Error: ${error instanceof Error ? error.message : String(error)}`);
+      return articles.map(() => ({ summary: null, category: 'Uncategorized' }));
+    }
+  }
+}

package/src/providers/llm/utils.ts

@@ -0,0 +1,54 @@
+import { AnalysisResult } from './index.js';
+
+/**
+ * Robustly parses a JSON string from LLM output.
+ * Handles markdown code blocks and attempts to find the first array/object if surrounded by text.
+ */
+export function parseLLMJson(text: string): AnalysisResult[] {
+    if (!text || text.trim() === '') {
+        throw new Error('Empty response from LLM');
+    }
+
+    // Clean up markdown blocks if present
+    let cleanText = text.trim();
+    if (cleanText.includes('```')) {
+        const match = cleanText.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+        if (match && match[1]) {
+            cleanText = match[1].trim();
+        }
+    }
+
+    // Find the first instance of [ or {
+    const firstArray = cleanText.indexOf('[');
+    const firstObject = cleanText.indexOf('{');
+
+    let startIndex = -1;
+    if (firstArray !== -1 && (firstObject === -1 || firstArray < firstObject)) {
+        startIndex = firstArray;
+    } else if (firstObject !== -1) {
+        startIndex = firstObject;
+    }
+
+    if (startIndex === -1) {
+        throw new Error('No JSON structure found in LLM response');
+    }
+
+    // Truncate to the last ] or }
+    const lastArray = cleanText.lastIndexOf(']');
+    const lastObject = cleanText.lastIndexOf('}');
+    const endIndex = Math.max(lastArray, lastObject);
+
+    if (endIndex === -1 || endIndex < startIndex) {
+        throw new Error('Incomplete JSON structure in LLM response');
+    }
+
+    const jsonStr = cleanText.substring(startIndex, endIndex + 1);
+    const parsed = JSON.parse(jsonStr);
+
+    const results = Array.isArray(parsed) ? parsed : [parsed];
+
+    return results.map((item: any) => ({
+        summary: item.summary || null,
+        category: item.category || 'Uncategorized',
+    }));
+}