@plosson/agentio 0.1.24 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plosson/agentio",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "CLI for LLM agents to interact with communication and tracking services",
   "type": "module",
   "license": "MIT",
@@ -47,6 +47,7 @@
   },
   "dependencies": {
     "commander": "^14.0.2",
-    "googleapis": "^169.0.0"
+    "googleapis": "^169.0.0",
+    "rss-parser": "^3.13.0"
   }
 }

package/src/commands/rss.ts

@@ -0,0 +1,68 @@
+import { Command } from 'commander';
+import { RssClient } from '../services/rss/client';
+import { handleError } from '../utils/errors';
+import {
+  printRssArticleList,
+  printRssArticle,
+  printRssFeedInfo,
+} from '../utils/output';
+
+export function registerRssCommands(program: Command): void {
+  const rss = program
+    .command('rss')
+    .description('RSS feed operations');
+
+  // Get articles from a feed
+  rss
+    .command('articles')
+    .description('List articles from a blog')
+    .argument('<url>', 'Blog URL (feed will be auto-discovered)')
+    .option('--limit <n>', 'Number of articles', '20')
+    .option('--since <date>', 'Only articles after this date (YYYY-MM-DD)')
+    .action(async (url, options) => {
+      try {
+        const client = new RssClient();
+        const listOptions = {
+          limit: parseInt(options.limit, 10),
+          since: options.since ? new Date(options.since) : undefined,
+        };
+
+        const info = await client.getInfo(url);
+        const articles = await client.list(url, listOptions);
+        printRssArticleList(articles, info.title);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Get a specific article
+  rss
+    .command('get')
+    .description('Get a specific article')
+    .argument('<url>', 'Blog URL (feed will be auto-discovered)')
+    .argument('<article-id>', 'Article ID or URL')
+    .action(async (url, articleId) => {
+      try {
+        const client = new RssClient();
+        const article = await client.get(url, articleId);
+        printRssArticle(article);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Get feed info
+  rss
+    .command('info')
+    .description('Get feed information')
+    .argument('<url>', 'Blog URL (feed will be auto-discovered)')
+    .action(async (url) => {
+      try {
+        const client = new RssClient();
+        const info = await client.getInfo(url);
+        printRssFeedInfo(info);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/config/config-manager.ts

@@ -115,7 +115,7 @@ export async function listProfiles(service?: ServiceName): Promise<{
   default?: string;
 }[]> {
   const config = await loadConfig();
-  const services: ServiceName[] = service ? [service] : ['gmail', 'gchat', 'jira', 'telegram'];
+  const services: ServiceName[] = service ? [service] : ['gmail', 'gchat', 'jira', 'slack', 'telegram'];
 
   return services.map((svc) => ({
     service: svc,

package/src/index.ts

@@ -5,6 +5,7 @@ import { registerTelegramCommands } from './commands/telegram';
 import { registerGChatCommands } from './commands/gchat';
 import { registerJiraCommands } from './commands/jira';
 import { registerSlackCommands } from './commands/slack';
+import { registerRssCommands } from './commands/rss';
 import { registerUpdateCommand } from './commands/update';
 import { registerConfigCommands } from './commands/config';
 import { registerClaudeCommands } from './commands/claude';
@@ -31,6 +32,7 @@ registerTelegramCommands(program);
 registerGChatCommands(program);
 registerJiraCommands(program);
 registerSlackCommands(program);
+registerRssCommands(program);
 registerUpdateCommand(program);
 registerConfigCommands(program);
 registerClaudeCommands(program);

package/src/services/rss/client.ts

@@ -0,0 +1,230 @@
+import Parser from 'rss-parser';
+import type { RssFeed, RssArticle, RssListOptions } from '../../types/rss';
+import { CliError } from '../../utils/errors';
+
+type CustomItem = {
+  contentEncoded?: string;
+  dcCreator?: string;
+};
+
+type CustomFeed = {
+  language?: string;
+  lastBuildDate?: string;
+};
+
+// Common feed paths to try if discovery fails
+const COMMON_FEED_PATHS = [
+  '/feed',
+  '/feed.xml',
+  '/rss',
+  '/rss.xml',
+  '/atom.xml',
+  '/index.xml',
+  '/feed/atom',
+  '/feed/rss',
+];
+
+export class RssClient {
+  private parser: Parser<CustomFeed, CustomItem>;
+  private feedUrl: string | null = null;
+
+  constructor() {
+    this.parser = new Parser({
+      customFields: {
+        item: [['content:encoded', 'contentEncoded'], ['dc:creator', 'dcCreator']],
+      },
+    });
+  }
+
+  /**
+   * Discover RSS feed URL from a blog URL
+   */
+  async discoverFeed(url: string): Promise<string> {
+    // Normalize URL
+    let baseUrl = url.trim();
+    if (!baseUrl.startsWith('http://') && !baseUrl.startsWith('https://')) {
+      baseUrl = 'https://' + baseUrl;
+    }
+    baseUrl = baseUrl.replace(/\/$/, '');
+
+    // First, try to parse the URL directly as a feed
+    try {
+      await this.parser.parseURL(baseUrl);
+      this.feedUrl = baseUrl;
+      return baseUrl;
+    } catch {
+      // Not a feed, continue with discovery
+    }
+
+    // Fetch the page and look for feed links in HTML
+    try {
+      const response = await fetch(baseUrl, {
+        headers: { 'User-Agent': 'agentio-rss/1.0' },
+      });
+
+      if (response.ok) {
+        const html = await response.text();
+        const feedUrl = this.extractFeedUrl(html, baseUrl);
+        if (feedUrl) {
+          // Verify it's a valid feed
+          try {
+            await this.parser.parseURL(feedUrl);
+            this.feedUrl = feedUrl;
+            return feedUrl;
+          } catch {
+            // Invalid feed, continue trying
+          }
+        }
+      }
+    } catch {
+      // Failed to fetch page, continue with common paths
+    }
+
+    // Try common feed paths
+    for (const path of COMMON_FEED_PATHS) {
+      const feedUrl = baseUrl + path;
+      try {
+        await this.parser.parseURL(feedUrl);
+        this.feedUrl = feedUrl;
+        return feedUrl;
+      } catch {
+        // Try next path
+      }
+    }
+
+    throw new CliError(
+      'NOT_FOUND',
+      `Could not find RSS feed for: ${url}`,
+      'Try providing the direct feed URL instead'
+    );
+  }
+
+  /**
+   * Extract feed URL from HTML link tags
+   */
+  private extractFeedUrl(html: string, baseUrl: string): string | null {
+    // Match <link> tags with rel="alternate" and type containing rss or atom
+    const linkRegex = /<link[^>]*rel=["']alternate["'][^>]*>/gi;
+    const matches = html.match(linkRegex) || [];
+
+    for (const link of matches) {
+      // Check if it's an RSS or Atom feed
+      if (link.includes('application/rss+xml') ||
+          link.includes('application/atom+xml') ||
+          link.includes('application/feed+json')) {
+        // Extract href
+        const hrefMatch = link.match(/href=["']([^"']+)["']/i);
+        if (hrefMatch) {
+          let href = hrefMatch[1];
+          // Handle relative URLs
+          if (href.startsWith('/')) {
+            const urlObj = new URL(baseUrl);
+            href = urlObj.origin + href;
+          } else if (!href.startsWith('http')) {
+            href = baseUrl + '/' + href;
+          }
+          return href;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Fetch and parse the RSS feed
+   */
+  async getFeed(url?: string): Promise<RssFeed> {
+    const feedUrl = url || this.feedUrl;
+    if (!feedUrl) {
+      throw new CliError('INVALID_PARAMS', 'No feed URL provided', 'Call discoverFeed() first or provide a URL');
+    }
+
+    try {
+      const feed = await this.parser.parseURL(feedUrl);
+      return this.parseFeed(feed);
+    } catch (error) {
+      if (error instanceof CliError) throw error;
+      if (error instanceof Error) {
+        if (error.message.includes('ENOTFOUND') || error.message.includes('ECONNREFUSED')) {
+          throw new CliError('NETWORK_ERROR', `Cannot reach feed: ${feedUrl}`, 'Check the URL and your internet connection');
+        }
+        if (error.message.includes('Non-whitespace before first tag') || error.message.includes('Invalid XML')) {
+          throw new CliError('INVALID_PARAMS', 'Invalid RSS feed format', 'The URL may not be an RSS feed');
+        }
+      }
+      throw new CliError('API_ERROR', `Failed to parse feed: ${error}`, 'Verify the feed URL is valid');
+    }
+  }
+
+  /**
+   * Get articles from the feed
+   */
+  async list(url: string, options?: RssListOptions): Promise<RssArticle[]> {
+    const feedUrl = await this.discoverFeed(url);
+    const feed = await this.getFeed(feedUrl);
+    let articles = feed.items;
+
+    // Filter by date if specified
+    if (options?.since) {
+      articles = articles.filter(article => {
+        if (!article.pubDate) return true;
+        return new Date(article.pubDate) >= options.since!;
+      });
+    }
+
+    // Apply limit
+    const limit = options?.limit ?? 20;
+    return articles.slice(0, limit);
+  }
+
+  /**
+   * Get a specific article by ID
+   */
+  async get(url: string, articleId: string): Promise<RssArticle> {
+    const feedUrl = await this.discoverFeed(url);
+    const feed = await this.getFeed(feedUrl);
+    const article = feed.items.find(item => item.id === articleId || item.link === articleId);
+
+    if (!article) {
+      throw new CliError('NOT_FOUND', `Article not found: ${articleId}`, 'Use "agentio rss articles" to list available articles');
+    }
+
+    return article;
+  }
+
+  /**
+   * Get feed info
+   */
+  async getInfo(url: string): Promise<RssFeed & { feedUrl: string }> {
+    const feedUrl = await this.discoverFeed(url);
+    const feed = await this.getFeed(feedUrl);
+    return { ...feed, feedUrl };
+  }
+
+  private parseFeed(raw: Parser.Output<CustomFeed & CustomItem>): RssFeed {
+    // Cast to access optional feed properties not in base type
+    const feedData = raw as Parser.Output<CustomFeed & CustomItem> & CustomFeed;
+    return {
+      title: raw.title || 'Untitled Feed',
+      description: raw.description,
+      link: raw.link,
+      language: feedData.language,
+      lastBuildDate: feedData.lastBuildDate,
+      items: (raw.items || []).map(item => this.parseArticle(item)),
+    };
+  }
+
+  private parseArticle(raw: Parser.Item & CustomItem): RssArticle {
+    return {
+      id: raw.guid || raw.link || raw.title || '',
+      title: raw.title || 'Untitled',
+      link: raw.link,
+      description: raw.contentSnippet || raw.content,
+      content: raw.contentEncoded || raw.content,
+      author: raw.creator || raw.dcCreator,
+      pubDate: raw.pubDate || raw.isoDate,
+      categories: raw.categories,
+    };
+  }
+}

package/src/types/rss.ts

@@ -0,0 +1,33 @@
+/**
+ * Parsed feed metadata
+ */
+export interface RssFeed {
+  title: string;
+  description?: string;
+  link?: string;
+  language?: string;
+  lastBuildDate?: string;
+  items: RssArticle[];
+}
+
+/**
+ * Individual article/item from feed
+ */
+export interface RssArticle {
+  id: string;
+  title: string;
+  link?: string;
+  description?: string;
+  content?: string;
+  author?: string;
+  pubDate?: string;
+  categories?: string[];
+}
+
+/**
+ * Options for listing articles
+ */
+export interface RssListOptions {
+  limit?: number;
+  since?: Date;
+}

package/src/utils/output.ts

@@ -2,6 +2,7 @@ import type { GmailMessage, GmailAttachmentInfo } from '../types/gmail';
 import type { GChatMessage } from '../types/gchat';
 import type { JiraProject, JiraIssue, JiraTransition, JiraCommentResult, JiraTransitionResult } from '../types/jira';
 import type { SlackSendResult } from '../types/slack';
+import type { RssFeed, RssArticle } from '../types/rss';
 
 function formatBytes(bytes: number): string {
   if (bytes === 0) return '0 B';
@@ -230,3 +231,50 @@ export function printSlackSendResult(result: SlackSendResult): void {
     console.log('Type: Block Kit payload');
   }
 }
+
+// RSS specific formatters
+export function printRssArticleList(articles: RssArticle[], feedName: string): void {
+  if (articles.length === 0) {
+    console.log('No articles found');
+    return;
+  }
+
+  console.log(`Articles from ${feedName} (${articles.length})\n`);
+
+  for (let i = 0; i < articles.length; i++) {
+    const article = articles[i];
+    console.log(`[${i + 1}] ${article.title}`);
+    if (article.author) console.log(`    Author: ${article.author}`);
+    if (article.pubDate) console.log(`    Date: ${article.pubDate}`);
+    if (article.link) console.log(`    Link: ${article.link}`);
+    if (article.description) {
+      const snippet = article.description.length > 150
+        ? article.description.substring(0, 150) + '...'
+        : article.description;
+      console.log(`    > ${snippet}`);
+    }
+    console.log('');
+  }
+}
+
+export function printRssArticle(article: RssArticle): void {
+  console.log(`Title: ${article.title}`);
+  if (article.author) console.log(`Author: ${article.author}`);
+  if (article.pubDate) console.log(`Date: ${article.pubDate}`);
+  if (article.link) console.log(`Link: ${article.link}`);
+  if (article.categories && article.categories.length > 0) {
+    console.log(`Categories: ${article.categories.join(', ')}`);
+  }
+  console.log('---');
+  console.log(article.content || article.description || 'No content available');
+}
+
+export function printRssFeedInfo(feed: RssFeed & { feedUrl: string }): void {
+  console.log(`Title: ${feed.title}`);
+  console.log(`Feed URL: ${feed.feedUrl}`);
+  if (feed.description) console.log(`Description: ${feed.description}`);
+  if (feed.link) console.log(`Site: ${feed.link}`);
+  if (feed.language) console.log(`Language: ${feed.language}`);
+  if (feed.lastBuildDate) console.log(`Last Updated: ${feed.lastBuildDate}`);
+  console.log(`Articles: ${feed.items.length}`);
+}