@hasna/connectors 1.3.3 → 1.3.6

package/connectors/connect-arxiv/src/cli/index.ts

@@ -0,0 +1,229 @@
+#!/usr/bin/env bun
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { join } from 'path';
+import { Arxiv } from '../api';
+import { getDefaultCategory, setDefaultCategory, getMaxResults, setMaxResults, getOutputDir, setOutputDir, clearConfig } from '../utils/config';
+import type { OutputFormat } from '../types';
+import { success, error, info, print } from '../utils/output';
+
+const CONNECTOR_NAME = 'connect-arxiv';
+const VERSION = '0.1.0';
+
+const program = new Command();
+
+program
+  .name(CONNECTOR_NAME)
+  .description('arXiv research paper search and retrieval CLI')
+  .version(VERSION)
+  .option('-f, --format <format>', 'Output format (json, pretty)', 'pretty');
+
+function getFormat(cmd: Command): OutputFormat {
+  const parent = cmd.parent;
+  return (parent?.opts().format || cmd.opts().format || 'pretty') as OutputFormat;
+}
+
+// Config commands
+const configCmd = program.command('config').description('Manage CLI configuration');
+
+configCmd.command('set-category <category>')
+  .description('Set default arXiv category (e.g., cs.AI, cs.LG)')
+  .action((category: string) => {
+    setDefaultCategory(category);
+    success(`Default category set to: ${category}`);
+  });
+
+configCmd.command('set-max-results <n>')
+  .description('Set default max results')
+  .action((n: string) => {
+    setMaxResults(parseInt(n, 10));
+    success(`Default max results set to: ${n}`);
+  });
+
+configCmd.command('set-output-dir <dir>')
+  .description('Set default output directory for PDF downloads')
+  .action((dir: string) => {
+    setOutputDir(dir);
+    success(`Output directory set to: ${dir}`);
+  });
+
+configCmd.command('show')
+  .description('Show current configuration')
+  .action(() => {
+    const category = getDefaultCategory();
+    const maxResults = getMaxResults();
+    const outputDir = getOutputDir();
+    console.log(chalk.bold('arXiv Configuration:'));
+    info(`Default category: ${category || chalk.gray('not set')}`);
+    info(`Max results: ${maxResults}`);
+    info(`Output directory: ${outputDir}`);
+    info(`Note: arXiv API is free — no API key required.`);
+  });
+
+configCmd.command('clear')
+  .description('Clear all configuration')
+  .action(() => {
+    clearConfig();
+    success('Configuration cleared');
+  });
+
+// Search command
+program.command('search <query>')
+  .description('Search papers by query')
+  .option('-c, --category <category>', 'Filter by category (e.g., cs.AI, cs.LG)')
+  .option('-n, --max <number>', 'Maximum results')
+  .option('--start <number>', 'Start offset for pagination', '0')
+  .option('--sort <field>', 'Sort by: relevance, lastUpdatedDate, submittedDate', 'relevance')
+  .option('--order <order>', 'Sort order: ascending, descending', 'descending')
+  .action(async (query: string, opts) => {
+    try {
+      const arxiv = new Arxiv();
+      const result = await arxiv.search({
+        query,
+        category: opts.category || getDefaultCategory(),
+        maxResults: opts.max ? parseInt(opts.max) : getMaxResults(),
+        start: parseInt(opts.start),
+        sortBy: opts.sort as 'relevance' | 'lastUpdatedDate' | 'submittedDate',
+        sortOrder: opts.order as 'ascending' | 'descending',
+      });
+
+      if (getFormat(program) === 'json') {
+        print(result, 'json');
+      } else {
+        info(`Found ${result.totalResults} results (showing ${result.papers.length})`);
+        for (const paper of result.papers) {
+          console.log();
+          console.log(chalk.bold(paper.title));
+          console.log(chalk.gray(`  ${paper.id} | ${paper.primaryCategory} | ${paper.published.split('T')[0]}`));
+          console.log(chalk.cyan(`  Authors: ${paper.authors.join(', ')}`));
+          console.log(`  ${paper.abstract.substring(0, 200)}${paper.abstract.length > 200 ? '...' : ''}`);
+          console.log(chalk.blue(`  PDF: ${paper.pdfUrl}`));
+        }
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+// Get command
+program.command('get <id>')
+  .description('Get paper details by arXiv ID (e.g., 2301.12345)')
+  .action(async (id: string) => {
+    try {
+      const arxiv = new Arxiv();
+      const paper = await arxiv.get(id);
+
+      if (getFormat(program) === 'json') {
+        print(paper, 'json');
+      } else {
+        console.log(chalk.bold(paper.title));
+        console.log();
+        console.log(chalk.cyan(`ID:         ${paper.id}`));
+        console.log(chalk.cyan(`Authors:    ${paper.authors.join(', ')}`));
+        console.log(chalk.cyan(`Category:   ${paper.primaryCategory} (${paper.categories.join(', ')})`));
+        console.log(chalk.cyan(`Published:  ${paper.published.split('T')[0]}`));
+        console.log(chalk.cyan(`Updated:    ${paper.updated.split('T')[0]}`));
+        if (paper.doi) console.log(chalk.cyan(`DOI:        ${paper.doi}`));
+        if (paper.journalRef) console.log(chalk.cyan(`Journal:    ${paper.journalRef}`));
+        if (paper.comment) console.log(chalk.cyan(`Comment:    ${paper.comment}`));
+        console.log(chalk.blue(`PDF:        ${paper.pdfUrl}`));
+        console.log(chalk.blue(`Abstract:   ${paper.absUrl}`));
+        console.log();
+        console.log(chalk.bold('Abstract:'));
+        console.log(paper.abstract);
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+// List recent command
+program.command('list-recent [category]')
+  .description('List recent papers in a category (e.g., cs.AI, cs.LG, math.CO)')
+  .option('-n, --max <number>', 'Maximum results')
+  .option('--start <number>', 'Start offset for pagination', '0')
+  .action(async (category: string | undefined, opts) => {
+    try {
+      const cat = category || getDefaultCategory();
+      if (!cat) {
+        error('Category required. Pass it as argument or set with "config set-category"');
+        process.exit(1);
+      }
+
+      const arxiv = new Arxiv();
+      const result = await arxiv.listRecent(cat, {
+        maxResults: opts.max ? parseInt(opts.max) : getMaxResults(),
+        start: parseInt(opts.start),
+      });
+
+      if (getFormat(program) === 'json') {
+        print(result, 'json');
+      } else {
+        info(`Recent papers in ${chalk.bold(cat)} (${result.totalResults} total, showing ${result.papers.length})`);
+        for (const paper of result.papers) {
+          console.log();
+          console.log(chalk.bold(paper.title));
+          console.log(chalk.gray(`  ${paper.id} | ${paper.published.split('T')[0]}`));
+          console.log(chalk.cyan(`  ${paper.authors.slice(0, 5).join(', ')}${paper.authors.length > 5 ? ` +${paper.authors.length - 5} more` : ''}`));
+          console.log(`  ${paper.abstract.substring(0, 150)}${paper.abstract.length > 150 ? '...' : ''}`);
+        }
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+// Search by author
+program.command('search-authors <name>')
+  .description('Search papers by author name')
+  .option('-n, --max <number>', 'Maximum results')
+  .option('--start <number>', 'Start offset', '0')
+  .action(async (name: string, opts) => {
+    try {
+      const arxiv = new Arxiv();
+      const result = await arxiv.searchAuthors(name, {
+        maxResults: opts.max ? parseInt(opts.max) : getMaxResults(),
+        start: parseInt(opts.start),
+      });
+
+      if (getFormat(program) === 'json') {
+        print(result, 'json');
+      } else {
+        info(`Papers by "${name}" (${result.totalResults} total, showing ${result.papers.length})`);
+        for (const paper of result.papers) {
+          console.log();
+          console.log(chalk.bold(paper.title));
+          console.log(chalk.gray(`  ${paper.id} | ${paper.primaryCategory} | ${paper.published.split('T')[0]}`));
+          console.log(chalk.cyan(`  ${paper.authors.join(', ')}`));
+        }
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+// Download PDF
+program.command('download-pdf <id>')
+  .description('Download paper PDF by arXiv ID')
+  .option('-o, --output <path>', 'Output file path')
+  .action(async (id: string, opts) => {
+    try {
+      const arxiv = new Arxiv();
+      const cleanId = id.replace(/^arxiv:/i, '');
+      const filename = `${cleanId.replace(/\//g, '_')}.pdf`;
+      const outputPath = opts.output || join(getOutputDir(), filename);
+
+      info(`Downloading PDF for ${cleanId}...`);
+      const savedPath = await arxiv.downloadPdf(id, outputPath);
+      success(`PDF saved to: ${savedPath}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/connectors/connect-arxiv/src/index.ts

@@ -0,0 +1,4 @@
+// arXiv Research Paper API Connector
+export { Arxiv, ArxivClient, Connector } from './api';
+export * from './types';
+export { loadConfig, saveConfig, getDefaultCategory, setDefaultCategory, getMaxResults, setMaxResults, getOutputDir, setOutputDir, clearConfig } from './utils/config';

package/connectors/connect-arxiv/src/types/index.ts

@@ -0,0 +1,40 @@
+export type OutputFormat = 'json' | 'pretty' | 'table';
+
+export interface ArxivPaper {
+  id: string;           // e.g., "2301.12345"
+  title: string;
+  authors: string[];
+  abstract: string;
+  categories: string[];
+  primaryCategory: string;
+  published: string;    // ISO date
+  updated: string;      // ISO date
+  pdfUrl: string;
+  absUrl: string;
+  doi?: string;
+  journalRef?: string;
+  comment?: string;
+}
+
+export interface SearchOptions {
+  query: string;
+  category?: string;
+  maxResults?: number;
+  start?: number;
+  sortBy?: 'relevance' | 'lastUpdatedDate' | 'submittedDate';
+  sortOrder?: 'ascending' | 'descending';
+}
+
+export interface SearchResult {
+  papers: ArxivPaper[];
+  totalResults: number;
+  startIndex: number;
+  itemsPerPage: number;
+}
+
+export class ArxivApiError extends Error {
+  constructor(message: string, public statusCode?: number) {
+    super(message);
+    this.name = 'ArxivApiError';
+  }
+}

package/connectors/connect-arxiv/src/utils/config.ts

@@ -0,0 +1,71 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const CONFIG_DIR = join(homedir(), '.connectors', 'connect-arxiv');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+export interface CliConfig {
+  defaultCategory?: string;
+  maxResults?: number;
+  outputDir?: string;
+}
+
+function ensureConfigDir(): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function loadConfig(): CliConfig {
+  ensureConfigDir();
+  if (!existsSync(CONFIG_FILE)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+export function saveConfig(config: CliConfig): void {
+  ensureConfigDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export function getDefaultCategory(): string | undefined {
+  return process.env.ARXIV_CATEGORY || loadConfig().defaultCategory;
+}
+
+export function setDefaultCategory(category: string): void {
+  const config = loadConfig();
+  config.defaultCategory = category;
+  saveConfig(config);
+}
+
+export function getMaxResults(): number {
+  const envVal = process.env.ARXIV_MAX_RESULTS;
+  if (envVal) return parseInt(envVal, 10);
+  return loadConfig().maxResults || 10;
+}
+
+export function setMaxResults(n: number): void {
+  const config = loadConfig();
+  config.maxResults = n;
+  saveConfig(config);
+}
+
+export function getOutputDir(): string {
+  return process.env.ARXIV_OUTPUT_DIR || loadConfig().outputDir || '.';
+}
+
+export function setOutputDir(dir: string): void {
+  const config = loadConfig();
+  config.outputDir = dir;
+  saveConfig(config);
+}
+
+export function clearConfig(): void {
+  saveConfig({});
+}

package/connectors/connect-arxiv/src/utils/output.ts

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import type { OutputFormat } from '../types';
+
+export function success(message: string): void {
+  console.log(chalk.green('\u2713'), message);
+}
+
+export function error(message: string): void {
+  console.error(chalk.red('\u2717'), message);
+}
+
+export function warn(message: string): void {
+  console.log(chalk.yellow('\u26a0'), message);
+}
+
+export function info(message: string): void {
+  console.log(chalk.blue('\u2139'), message);
+}
+
+export function print(data: unknown, format: OutputFormat = 'pretty'): void {
+  if (format === 'json') {
+    console.log(JSON.stringify(data, null, 2));
+  } else if (format === 'table' && Array.isArray(data)) {
+    console.table(data);
+  } else {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}

package/connectors/connect-arxiv/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationDir": "./dist",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "bin"]
+}

package/connectors/connect-brandsight/bun.lock

@@ -0,0 +1,32 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "@hasna/connect-brandsight",
+      "dependencies": {
+        "chalk": "^5.3.0",
+        "commander": "^12.1.0",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.3.11", "", { "dependencies": { "bun-types": "1.3.11" } }, "sha512-5vPne5QvtpjGpsGYXiFyycfpDF2ECyPcTSsFBMa0fraoxiQyMJ3SmuQIGhzPg2WJuWxVBoxWJ2kClYTcw/4fAg=="],
+
+    "@types/node": ["@types/node@25.5.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-jp2P3tQMSxWugkCUKLRPVUpGaL5MVFwF8RDuSRztfwgN1wmqJeMSbKlnEtQqU8UrhTmzEmZdu2I6v2dpp7XIxw=="],
+
+    "bun-types": ["bun-types@1.3.11", "", { "dependencies": { "@types/node": "*" } }, "sha512-1KGPpoxQWl9f6wcZh57LvrPIInQMn2TQ7jsgxqpRzg+l0QPOFvJVH7HmvHo/AiPgwXy+/Thf6Ov3EdVn1vOabg=="],
+
+    "chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="],
+
+    "commander": ["commander@12.1.0", "", {}, "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
+  }
+}

package/connectors/connect-brandsight/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hasna/connect-brandsight",
   "version": "0.1.0",
-  "description": "Brandsight/GoDaddy Domain API connector CLI - A TypeScript wrapper for domain management",
+  "description": "Brandsight API connector - A TypeScript CLI for brand monitoring, domain intelligence, and threat detection",
   "type": "module",
   "bin": {
     "connect-brandsight": "./bin/index.js"
@@ -18,19 +18,17 @@
     "build": "bun build ./src/index.ts --outdir ./dist --target bun && bun build ./src/cli/index.ts --outdir ./bin --target bun",
     "dev": "bun run ./src/cli/index.ts",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "bun run build",
-    "release": "bun run ./scripts/publish.ts",
-    "release:patch": "bun run ./scripts/publish.ts patch",
-    "release:minor": "bun run ./scripts/publish.ts minor",
-    "release:major": "bun run ./scripts/publish.ts major",
-    "release:dry": "bun run ./scripts/publish.ts --dry-run"
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
   },
   "keywords": [
-    "brandsight",
-    "godaddy",
-    "domain",
     "api",
     "connector",
+    "brandsight",
+    "brand-monitoring",
+    "domain-intelligence",
+    "threat-detection",
+    "whois",
     "cli",
     "typescript",
     "bun",
@@ -53,4 +51,4 @@
     "type": "git",
     "url": "git+https://github.com/hasna/connectors.git"
   }
-}
+}