@plosson/agentio 0.1.24 → 0.1.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plosson/agentio",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "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/claude.ts

@@ -10,6 +10,15 @@ import {
   removePlugin,
 } from '../services/claude-plugin/agentio-json';
 
+/**
+ * Determine if the argument is a marketplace URL or a plugin name.
+ * - URL (contains :// or github.com/) -> marketplace
+ * - Contains @ (e.g., plugin@marketplace) -> plugin
+ */
+function isMarketplaceUrl(arg: string): boolean {
+  return arg.includes('://') || arg.startsWith('github.com/');
+}
+
 /**
  * Execute a claude CLI command and return the result.
  */
@@ -90,6 +99,82 @@ async function installPluginCmd(name: string): Promise<boolean> {
   return false;
 }
 
+/**
+ * Get list of installed marketplaces with their names and sources.
+ */
+async function getMarketplaces(): Promise<Array<{ name: string; source: string }>> {
+  const result = await execClaude(['plugin', 'marketplace', 'list']);
+  if (!result.success) {
+    return [];
+  }
+
+  const marketplaces: Array<{ name: string; source: string }> = [];
+  const lines = result.stdout.split('\n');
+
+  let currentName: string | null = null;
+  for (const line of lines) {
+    // Match marketplace name: "  ❯ marketplace-name"
+    const nameMatch = line.match(/^\s*❯\s+(.+)$/);
+    if (nameMatch) {
+      currentName = nameMatch[1].trim();
+      continue;
+    }
+
+    // Match source line: "    Source: GitHub (user/repo)" or "    Source: Git (url)"
+    const sourceMatch = line.match(/^\s*Source:\s*(?:GitHub|Git)\s*\((.+)\)$/);
+    if (sourceMatch && currentName) {
+      marketplaces.push({ name: currentName, source: sourceMatch[1].trim() });
+      currentName = null;
+    }
+  }
+
+  return marketplaces;
+}
+
+/**
+ * Find marketplace name by URL.
+ */
+async function findMarketplaceName(url: string): Promise<string | null> {
+  const marketplaces = await getMarketplaces();
+
+  // Normalize the URL for comparison
+  const normalizedUrl = url
+    .replace(/^https?:\/\//, '')
+    .replace(/^github\.com\//, '')
+    .replace(/\.git$/, '')
+    .toLowerCase();
+
+  for (const mp of marketplaces) {
+    const normalizedSource = mp.source
+      .replace(/^https?:\/\//, '')
+      .replace(/^github\.com\//, '')
+      .replace(/\.git$/, '')
+      .toLowerCase();
+
+    if (normalizedSource === normalizedUrl || normalizedSource.includes(normalizedUrl) || normalizedUrl.includes(normalizedSource)) {
+      return mp.name;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Update a marketplace by name.
+ */
+async function updateMarketplace(name: string): Promise<boolean> {
+  console.error(`Updating marketplace: ${name}`);
+  const result = await execClaude(['plugin', 'marketplace', 'update', name]);
+
+  if (result.success) {
+    console.log(`  Updated: ${name}`);
+    return true;
+  }
+
+  console.error(`  Failed: ${result.stderr.trim()}`);
+  return false;
+}
+
 /**
  * Uninstall a plugin by calling claude plugin uninstall --scope project.
  */
@@ -118,79 +203,71 @@ export function registerClaudeCommands(program: Command): void {
     .command('claude')
     .description('Claude Code plugin operations');
 
-  // install command group
-  const install = claude.command('install').description('Install marketplaces and plugins');
-
-  install
-    .command('marketplace')
-    .description('Add a plugin marketplace')
-    .argument('<url>', 'Marketplace GitHub URL')
+  // install command - auto-detects marketplace vs plugin
+  claude
+    .command('install')
+    .description('Install a marketplace (URL) or plugin (name@marketplace), or all from agentio.json')
+    .argument('[target]', 'Marketplace URL or plugin name (e.g., plugin@marketplace)')
     .option('-d, --dir <path>', 'Directory with agentio.json (default: current directory)')
-    .action(async (url, options) => {
+    .action(async (target, options) => {
       try {
         const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
 
-        const success = await installMarketplace(url);
-        if (success) {
-          addMarketplace(targetDir, url);
-        }
-      } catch (error) {
-        handleError(error);
-      }
-    });
-
-  install
-    .command('plugin')
-    .description('Install a plugin')
-    .argument('<name>', 'Plugin name (e.g., plugin-name@marketplace)')
-    .option('-d, --dir <path>', 'Directory with agentio.json (default: current directory)')
-    .action(async (name, options) => {
-      try {
-        const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
+        // No argument - install all from agentio.json
+        if (!target) {
+          const config = loadAgentioJson(targetDir);
 
-        const success = await installPluginCmd(name);
-        if (success) {
-          addPlugin(targetDir, name);
-        }
-      } catch (error) {
-        handleError(error);
-      }
-    });
+          if (config.marketplaces.length === 0 && config.plugins.length === 0) {
+            console.log('No marketplaces or plugins defined in agentio.json');
+            return;
+          }
 
-  // install with no subcommand - install all from agentio.json
-  install.action(async (options) => {
-    try {
-      const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
-      const config = loadAgentioJson(targetDir);
+          console.error(`Installing from agentio.json...`);
 
-      if (config.marketplaces.length === 0 && config.plugins.length === 0) {
-        console.log('No marketplaces or plugins defined in agentio.json');
-        return;
-      }
+          // Install marketplaces first
+          if (config.marketplaces.length > 0) {
+            console.error(`\nMarketplaces (${config.marketplaces.length}):`);
+            for (const url of config.marketplaces) {
+              await installMarketplace(url);
+            }
+          }
 
-      console.error(`Installing from agentio.json...`);
+          // Then install plugins
+          if (config.plugins.length > 0) {
+            console.error(`\nPlugins (${config.plugins.length}):`);
+            for (const name of config.plugins) {
+              await installPluginCmd(name);
+            }
+          }
 
-      // Install marketplaces first
-      if (config.marketplaces.length > 0) {
-        console.error(`\nMarketplaces (${config.marketplaces.length}):`);
-        for (const url of config.marketplaces) {
-          await installMarketplace(url);
+          console.log('\nDone.');
+          return;
         }
-      }
 
-      // Then install plugins
-      if (config.plugins.length > 0) {
-        console.error(`\nPlugins (${config.plugins.length}):`);
-        for (const name of config.plugins) {
-          await installPluginCmd(name);
+        // Auto-detect type based on argument format
+        if (isMarketplaceUrl(target)) {
+          // It's a marketplace URL
+          const success = await installMarketplace(target);
+          if (success) {
+            addMarketplace(targetDir, target);
+          }
+        } else if (target.includes('@')) {
+          // It's a plugin (contains @)
+          const success = await installPluginCmd(target);
+          if (success) {
+            addPlugin(targetDir, target);
+          }
+        } else {
+          throw new CliError(
+            'INVALID_PARAMS',
+            `Cannot determine type for: ${target}`,
+            'Use a URL for marketplaces or name@marketplace for plugins'
+          );
         }
+      } catch (error) {
+        handleError(error);
       }
-
-      console.log('\nDone.');
-    } catch (error) {
-      handleError(error);
-    }
-  });
+    });
 
   // list command
   claude
@@ -228,40 +305,80 @@ export function registerClaudeCommands(program: Command): void {
       }
     });
 
-  // remove command group
-  const remove = claude.command('remove').description('Remove marketplaces and plugins');
-
-  remove
-    .command('marketplace')
-    .description('Remove a marketplace from agentio.json')
-    .argument('<url>', 'Marketplace URL to remove')
+  // update command - updates marketplaces
+  claude
+    .command('update')
+    .description('Update marketplaces (all from agentio.json or a specific URL)')
+    .argument('[url]', 'Marketplace URL to update (updates all from agentio.json if not specified)')
     .option('-d, --dir <path>', 'Directory with agentio.json (default: current directory)')
     .action(async (url, options) => {
       try {
         const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
 
-        const removed = removeMarketplace(targetDir, url);
-        if (removed) {
-          console.log(`Removed marketplace: ${url}`);
+        if (url) {
+          // Update specific marketplace by URL
+          const name = await findMarketplaceName(url);
+          if (!name) {
+            throw new CliError('NOT_FOUND', `Marketplace not found for URL: ${url}`, 'Make sure the marketplace is installed');
+          }
+          await updateMarketplace(name);
         } else {
-          throw new CliError('NOT_FOUND', `Marketplace not found: ${url}`);
+          // Update all marketplaces from agentio.json
+          const config = loadAgentioJson(targetDir);
+
+          if (config.marketplaces.length === 0) {
+            console.log('No marketplaces defined in agentio.json');
+            return;
+          }
+
+          console.error(`Updating marketplaces from agentio.json...`);
+
+          for (const marketplaceUrl of config.marketplaces) {
+            const name = await findMarketplaceName(marketplaceUrl);
+            if (name) {
+              await updateMarketplace(name);
+            } else {
+              console.error(`  Skipped (not installed): ${marketplaceUrl}`);
+            }
+          }
+
+          console.log('\nDone.');
         }
       } catch (error) {
         handleError(error);
       }
     });
 
-  remove
-    .command('plugin')
-    .description('Uninstall a plugin and remove from agentio.json')
-    .argument('<name>', 'Plugin name to remove')
+  // remove command - auto-detects marketplace vs plugin
+  claude
+    .command('remove')
+    .description('Remove a marketplace (URL) or plugin (name@marketplace)')
+    .argument('<target>', 'Marketplace URL or plugin name to remove')
     .option('-d, --dir <path>', 'Directory with agentio.json (default: current directory)')
-    .action(async (name, options) => {
+    .action(async (target, options) => {
       try {
         const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
 
-        await uninstallPluginCmd(name);
-        removePlugin(targetDir, name);
+        // Auto-detect type based on argument format
+        if (isMarketplaceUrl(target)) {
+          // It's a marketplace URL
+          const removed = removeMarketplace(targetDir, target);
+          if (removed) {
+            console.log(`Removed marketplace: ${target}`);
+          } else {
+            throw new CliError('NOT_FOUND', `Marketplace not found: ${target}`);
+          }
+        } else if (target.includes('@')) {
+          // It's a plugin (contains @)
+          await uninstallPluginCmd(target);
+          removePlugin(targetDir, target);
+        } else {
+          throw new CliError(
+            'INVALID_PARAMS',
+            `Cannot determine type for: ${target}`,
+            'Use a URL for marketplaces or name@marketplace for plugins'
+          );
+        }
       } catch (error) {
         handleError(error);
       }

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}`);
+}