@hasna/connectors 0.0.1

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

@@ -0,0 +1,204 @@
+// Reducto API Types
+
+export type OutputFormat = 'json' | 'pretty';
+
+// Configuration
+export interface ProfileConfig {
+  apiKey?: string;
+}
+
+export interface ReductoConfig {
+  currentProfile: string;
+  profiles: Record<string, ProfileConfig>;
+}
+
+// Common types
+export interface BoundingBox {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+}
+
+export interface BoundingBoxOrigin {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+  page: number;
+}
+
+// Parse API types
+export type ChunkingStrategy = 'page' | 'section' | 'paragraph' | 'none';
+export type OutputMode = 'text' | 'markdown' | 'html';
+
+export interface ParseOptions {
+  chunkingStrategy?: ChunkingStrategy;
+  outputMode?: OutputMode;
+  extractTables?: boolean;
+  extractImages?: boolean;
+  ocrLanguages?: string[];
+  pageRange?: string;
+  webhook?: string;
+  priority?: 'standard' | 'high';
+}
+
+export interface TableCell {
+  content: string;
+  rowSpan?: number;
+  colSpan?: number;
+  bbox?: BoundingBox;
+}
+
+export interface Table {
+  headers: string[];
+  rows: TableCell[][];
+  bbox?: BoundingBoxOrigin;
+  confidence?: number;
+}
+
+export interface Image {
+  url: string;
+  caption?: string;
+  bbox?: BoundingBoxOrigin;
+}
+
+export interface Chunk {
+  content: string;
+  pageNumber: number;
+  chunkIndex: number;
+  bbox?: BoundingBoxOrigin;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ParseResult {
+  jobId: string;
+  status: 'completed' | 'processing' | 'failed';
+  documentId?: string;
+  chunks?: Chunk[];
+  tables?: Table[];
+  images?: Image[];
+  pageCount?: number;
+  processingTime?: number;
+  error?: string;
+}
+
+// Extract API types
+export interface FieldDefinition {
+  name: string;
+  description: string;
+  type: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'date';
+  required?: boolean;
+  arrayOf?: FieldDefinition;
+  properties?: FieldDefinition[];
+}
+
+export interface Schema {
+  fields: FieldDefinition[];
+}
+
+export interface ExtractOptions {
+  schema: Schema;
+  examples?: Record<string, unknown>[];
+  webhook?: string;
+  priority?: 'standard' | 'high';
+}
+
+export interface ExtractResult {
+  jobId: string;
+  status: 'completed' | 'processing' | 'failed';
+  documentId?: string;
+  data?: Record<string, unknown>;
+  confidence?: Record<string, number>;
+  processingTime?: number;
+  error?: string;
+}
+
+// Split API types
+export interface SplitOptions {
+  splitBy?: 'page' | 'section' | 'custom';
+  customDelimiter?: string;
+  maxChunkSize?: number;
+  overlap?: number;
+  webhook?: string;
+}
+
+export interface SplitSegment {
+  content: string;
+  startPage: number;
+  endPage: number;
+  segmentIndex: number;
+  metadata?: Record<string, unknown>;
+}
+
+export interface SplitResult {
+  jobId: string;
+  status: 'completed' | 'processing' | 'failed';
+  documentId?: string;
+  segments?: SplitSegment[];
+  segmentCount?: number;
+  processingTime?: number;
+  error?: string;
+}
+
+// Edit API types
+export type EditOperation = 'fill' | 'replace' | 'redact' | 'insert';
+
+export interface FieldEdit {
+  fieldName: string;
+  value: string | number | boolean;
+  operation?: EditOperation;
+}
+
+export interface EditOptions {
+  edits: FieldEdit[];
+  outputFormat?: 'pdf' | 'docx';
+  flatten?: boolean;
+  webhook?: string;
+}
+
+export interface EditResult {
+  jobId: string;
+  status: 'completed' | 'processing' | 'failed';
+  documentId?: string;
+  outputUrl?: string;
+  processingTime?: number;
+  error?: string;
+}
+
+// Job status
+export interface JobStatus {
+  jobId: string;
+  status: 'pending' | 'processing' | 'completed' | 'failed';
+  progress?: number;
+  result?: ParseResult | ExtractResult | SplitResult | EditResult;
+  createdAt: string;
+  updatedAt: string;
+  error?: string;
+}
+
+// Document types
+export interface Document {
+  documentId: string;
+  filename: string;
+  mimeType: string;
+  size: number;
+  pageCount?: number;
+  createdAt: string;
+  metadata?: Record<string, unknown>;
+}
+
+// Error types
+export interface ReductoError extends Error {
+  name: 'ReductoError';
+  message: string;
+  statusCode?: number;
+  details?: unknown;
+}
+
+export class AuthenticationError extends Error {
+  constructor(message: string = 'Not authenticated. Run "connect-reducto auth setup" first.') {
+    super(message);
+    this.name = 'AuthenticationError';
+  }
+}

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

@@ -0,0 +1,144 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import type { ProfileConfig } from '../types';
+
+const APP_NAME = 'connect-reducto';
+
+// Profile override for CLI -p flag
+let profileOverride: string | undefined;
+
+export function setProfileOverride(profile: string): void {
+  profileOverride = profile;
+}
+
+export function getBaseConfigDir(): string {
+  return join(homedir(), '.connect', APP_NAME);
+}
+
+export function getConfigDir(): string {
+  const profile = getCurrentProfile();
+  return join(getBaseConfigDir(), 'profiles', profile);
+}
+
+export function ensureConfigDir(): void {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function getCurrentProfile(): string {
+  if (profileOverride) {
+    return profileOverride;
+  }
+
+  const profileFile = join(getBaseConfigDir(), 'current_profile');
+  if (existsSync(profileFile)) {
+    return readFileSync(profileFile, 'utf-8').trim() || 'default';
+  }
+  return 'default';
+}
+
+export function setCurrentProfile(name: string): void {
+  const profileDir = join(getBaseConfigDir(), 'profiles', name);
+  if (!existsSync(profileDir)) {
+    throw new Error(`Profile "${name}" does not exist`);
+  }
+
+  const baseDir = getBaseConfigDir();
+  if (!existsSync(baseDir)) {
+    mkdirSync(baseDir, { recursive: true });
+  }
+
+  writeFileSync(join(baseDir, 'current_profile'), name);
+}
+
+export function listProfiles(): string[] {
+  const profilesDir = join(getBaseConfigDir(), 'profiles');
+  if (!existsSync(profilesDir)) {
+    return [];
+  }
+
+  return readdirSync(profilesDir, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => dirent.name);
+}
+
+export function createProfile(name: string): boolean {
+  const profileDir = join(getBaseConfigDir(), 'profiles', name);
+  if (existsSync(profileDir)) {
+    return false;
+  }
+
+  mkdirSync(profileDir, { recursive: true });
+  writeFileSync(join(profileDir, 'config.json'), JSON.stringify({}, null, 2));
+  return true;
+}
+
+export function deleteProfile(name: string): boolean {
+  if (name === 'default') {
+    return false;
+  }
+
+  const profileDir = join(getBaseConfigDir(), 'profiles', name);
+  if (!existsSync(profileDir)) {
+    return false;
+  }
+
+  rmSync(profileDir, { recursive: true });
+
+  // Switch to default if deleting current profile
+  if (getCurrentProfile() === name) {
+    setCurrentProfile('default');
+  }
+
+  return true;
+}
+
+export function loadProfile(): ProfileConfig {
+  ensureConfigDir();
+  const configFile = join(getConfigDir(), 'config.json');
+
+  if (existsSync(configFile)) {
+    const content = readFileSync(configFile, 'utf-8');
+    return JSON.parse(content) as ProfileConfig;
+  }
+
+  return {};
+}
+
+export function saveProfile(config: ProfileConfig): void {
+  ensureConfigDir();
+  const configFile = join(getConfigDir(), 'config.json');
+  writeFileSync(configFile, JSON.stringify(config, null, 2));
+}
+
+export function getApiKey(): string | undefined {
+  // Check environment variable first
+  const envKey = process.env.REDUCTO_API_KEY;
+  if (envKey) {
+    return envKey;
+  }
+
+  // Fall back to profile config
+  const config = loadProfile();
+  return config.apiKey;
+}
+
+export function setApiKey(apiKey: string): void {
+  const config = loadProfile();
+  config.apiKey = apiKey;
+  saveProfile(config);
+}
+
+export function clearApiKey(): void {
+  const config = loadProfile();
+  delete config.apiKey;
+  saveProfile(config);
+}
+
+export function clearConfig(): void {
+  ensureConfigDir();
+  saveProfile({});
+}

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

@@ -0,0 +1,256 @@
+import chalk from 'chalk';
+import type { OutputFormat, ParseResult, ExtractResult, SplitResult, EditResult, JobStatus, Document } from '../types';
+
+export function print(data: unknown, format: OutputFormat = 'pretty'): void {
+  if (format === 'json') {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(data);
+  }
+}
+
+export function success(message: string): void {
+  console.log(chalk.green('✓'), message);
+}
+
+export function error(message: string): void {
+  console.error(chalk.red('✗'), message);
+}
+
+export function info(message: string): void {
+  console.log(chalk.blue('ℹ'), message);
+}
+
+export function warn(message: string): void {
+  console.log(chalk.yellow('⚠'), message);
+}
+
+export function formatDate(dateString: string): string {
+  const date = new Date(dateString);
+  return date.toLocaleString();
+}
+
+export function formatSize(bytes: number): string {
+  const units = ['B', 'KB', 'MB', 'GB'];
+  let size = bytes;
+  let unitIndex = 0;
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+
+  return `${size.toFixed(1)} ${units[unitIndex]}`;
+}
+
+function getStatusColor(status: string): string {
+  switch (status) {
+    case 'completed':
+      return chalk.green(status);
+    case 'processing':
+    case 'pending':
+      return chalk.yellow(status);
+    case 'failed':
+      return chalk.red(status);
+    default:
+      return status;
+  }
+}
+
+export function printParseResult(result: ParseResult, format: OutputFormat): void {
+  if (format === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  success(`Parse Job: ${result.jobId}`);
+  console.log(`  Status: ${getStatusColor(result.status)}`);
+
+  if (result.documentId) {
+    console.log(`  Document ID: ${chalk.gray(result.documentId)}`);
+  }
+
+  if (result.pageCount !== undefined) {
+    console.log(`  Pages: ${result.pageCount}`);
+  }
+
+  if (result.chunks) {
+    console.log(`  Chunks: ${result.chunks.length}`);
+    for (const chunk of result.chunks.slice(0, 3)) {
+      const preview = chunk.content.substring(0, 100).replace(/\n/g, ' ');
+      console.log(`    [${chunk.pageNumber}:${chunk.chunkIndex}] ${chalk.gray(preview)}...`);
+    }
+    if (result.chunks.length > 3) {
+      console.log(`    ... and ${result.chunks.length - 3} more chunks`);
+    }
+  }
+
+  if (result.tables && result.tables.length > 0) {
+    console.log(`  Tables: ${result.tables.length}`);
+  }
+
+  if (result.images && result.images.length > 0) {
+    console.log(`  Images: ${result.images.length}`);
+  }
+
+  if (result.processingTime) {
+    console.log(`  Processing Time: ${chalk.gray(`${result.processingTime}ms`)}`);
+  }
+
+  if (result.error) {
+    console.log(`  Error: ${chalk.red(result.error)}`);
+  }
+}
+
+export function printExtractResult(result: ExtractResult, format: OutputFormat): void {
+  if (format === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  success(`Extract Job: ${result.jobId}`);
+  console.log(`  Status: ${getStatusColor(result.status)}`);
+
+  if (result.documentId) {
+    console.log(`  Document ID: ${chalk.gray(result.documentId)}`);
+  }
+
+  if (result.data) {
+    console.log(`  Extracted Fields:`);
+    for (const [key, value] of Object.entries(result.data)) {
+      const confidence = result.confidence?.[key];
+      const confidenceStr = confidence ? chalk.gray(` (${(confidence * 100).toFixed(1)}%)`) : '';
+      const valueStr = typeof value === 'object' ? JSON.stringify(value) : String(value);
+      console.log(`    ${chalk.cyan(key)}: ${valueStr}${confidenceStr}`);
+    }
+  }
+
+  if (result.processingTime) {
+    console.log(`  Processing Time: ${chalk.gray(`${result.processingTime}ms`)}`);
+  }
+
+  if (result.error) {
+    console.log(`  Error: ${chalk.red(result.error)}`);
+  }
+}
+
+export function printSplitResult(result: SplitResult, format: OutputFormat): void {
+  if (format === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  success(`Split Job: ${result.jobId}`);
+  console.log(`  Status: ${getStatusColor(result.status)}`);
+
+  if (result.documentId) {
+    console.log(`  Document ID: ${chalk.gray(result.documentId)}`);
+  }
+
+  if (result.segmentCount !== undefined) {
+    console.log(`  Segments: ${result.segmentCount}`);
+  }
+
+  if (result.segments) {
+    for (const segment of result.segments.slice(0, 5)) {
+      const preview = segment.content.substring(0, 80).replace(/\n/g, ' ');
+      console.log(`    [${segment.segmentIndex}] Pages ${segment.startPage}-${segment.endPage}: ${chalk.gray(preview)}...`);
+    }
+    if (result.segments.length > 5) {
+      console.log(`    ... and ${result.segments.length - 5} more segments`);
+    }
+  }
+
+  if (result.processingTime) {
+    console.log(`  Processing Time: ${chalk.gray(`${result.processingTime}ms`)}`);
+  }
+
+  if (result.error) {
+    console.log(`  Error: ${chalk.red(result.error)}`);
+  }
+}
+
+export function printEditResult(result: EditResult, format: OutputFormat): void {
+  if (format === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  success(`Edit Job: ${result.jobId}`);
+  console.log(`  Status: ${getStatusColor(result.status)}`);
+
+  if (result.documentId) {
+    console.log(`  Document ID: ${chalk.gray(result.documentId)}`);
+  }
+
+  if (result.outputUrl) {
+    console.log(`  Output URL: ${chalk.cyan(result.outputUrl)}`);
+  }
+
+  if (result.processingTime) {
+    console.log(`  Processing Time: ${chalk.gray(`${result.processingTime}ms`)}`);
+  }
+
+  if (result.error) {
+    console.log(`  Error: ${chalk.red(result.error)}`);
+  }
+}
+
+export function printJobStatus(job: JobStatus, format: OutputFormat): void {
+  if (format === 'json') {
+    console.log(JSON.stringify(job, null, 2));
+    return;
+  }
+
+  success(`Job: ${job.jobId}`);
+  console.log(`  Status: ${getStatusColor(job.status)}`);
+
+  if (job.progress !== undefined) {
+    console.log(`  Progress: ${job.progress}%`);
+  }
+
+  console.log(`  Created: ${chalk.gray(formatDate(job.createdAt))}`);
+  console.log(`  Updated: ${chalk.gray(formatDate(job.updatedAt))}`);
+
+  if (job.error) {
+    console.log(`  Error: ${chalk.red(job.error)}`);
+  }
+}
+
+export function printDocument(doc: Document, format: OutputFormat): void {
+  if (format === 'json') {
+    console.log(JSON.stringify(doc, null, 2));
+    return;
+  }
+
+  success(`Document: ${doc.filename}`);
+  console.log(`  ID: ${chalk.gray(doc.documentId)}`);
+  console.log(`  Type: ${doc.mimeType}`);
+  console.log(`  Size: ${formatSize(doc.size)}`);
+
+  if (doc.pageCount) {
+    console.log(`  Pages: ${doc.pageCount}`);
+  }
+
+  console.log(`  Created: ${chalk.gray(formatDate(doc.createdAt))}`);
+}
+
+export function printDocuments(docs: Document[], format: OutputFormat): void {
+  if (format === 'json') {
+    console.log(JSON.stringify(docs, null, 2));
+    return;
+  }
+
+  if (docs.length === 0) {
+    info('No documents found');
+    return;
+  }
+
+  success(`Documents (${docs.length}):`);
+  for (const doc of docs) {
+    console.log(`  ${chalk.bold(doc.filename)}`);
+    console.log(`    ID: ${chalk.gray(doc.documentId)}`);
+    console.log(`    Size: ${formatSize(doc.size)} | Type: ${doc.mimeType}`);
+    console.log();
+  }
+}

package/connectors/connect-reducto/tsconfig.json

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

package/connectors/connect-resend/.npmrc.example

@@ -0,0 +1,2 @@
+@hasna:registry=https://registry.npmjs.org/
+//registry.npmjs.org/:_authToken=${NPM_TOKEN}

package/connectors/connect-resend/AGENTS.md

@@ -0,0 +1,76 @@
+# AGENTS.md
+
+This file provides guidance to AI coding agents when working with this repository.
+
+## Project Overview
+
+Resend Email API connector CLI - Send emails, manage templates, domains, API keys, audiences, contacts, webhooks, and broadcasts
+
+## Build & Run Commands
+
+```bash
+# Install dependencies
+bun install
+
+# Run CLI in development
+bun run dev
+
+# Build for distribution
+bun run build
+
+# Type check
+bun run typecheck
+```
+
+## Code Style
+
+- TypeScript with strict mode
+- ESM modules (`type: module`)
+- Async/await for all async operations
+- Minimal dependencies: commander, chalk
+- Type annotations required everywhere
+
+## Project Structure
+
+```
+src/
+├── api/           # API client modules
+│   ├── client.ts  # HTTP client with authentication
+│   └── index.ts   # Main connector class
+├── cli/
+│   └── index.ts   # CLI commands
+├── types/
+│   └── index.ts   # TypeScript types
+├── utils/
+│   ├── config.ts  # Multi-profile configuration
+│   └── output.ts  # CLI output formatting
+└── index.ts       # Library exports
+```
+
+## Authentication
+
+API Key authentication. Credentials can be set via:
+- Environment variable (see below)
+- Profile configuration: `connect-resend config set-key <key>`
+
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `RESEND_API_KEY` | API key |
+
+## Data Storage
+
+```
+~/.connect/connect-resend/
+├── current_profile   # Active profile name
+└── profiles/
+    ├── default.json  # Default profile
+    └── {name}.json   # Named profiles
+```
+
+## Dependencies
+
+- commander: CLI framework
+- chalk: Terminal styling