@hasna/connectors 0.0.1

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

@@ -0,0 +1,34 @@
+// Google Gemini API Connector
+// TypeScript wrapper for the Gemini API
+
+export { Gemini } from './api';
+export * from './types';
+
+// Re-export individual API classes for advanced usage
+export {
+  GeminiClient,
+  GenerateApi,
+  ImagesApi,
+  VideoApi,
+  SpeechApi,
+  EmbeddingsApi,
+  FilesApi,
+  ModelsApi,
+} from './api';
+
+// Export config utilities
+export {
+  getApiKey,
+  setApiKey,
+  getBaseUrl,
+  setBaseUrl,
+  getCurrentProfile,
+  setCurrentProfile,
+  listProfiles,
+  createProfile,
+  deleteProfile,
+  loadProfile,
+  saveProfile,
+  clearConfig,
+  hasApiKey,
+} from './utils/config';

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

@@ -0,0 +1,324 @@
+// Google Gemini API Types
+
+// ============ Models ============
+export type GeminiModel =
+  // Text Generation Models
+  | 'gemini-3-pro-preview'
+  | 'gemini-3-flash-preview'
+  | 'gemini-2.5-pro'
+  | 'gemini-2.5-flash'
+  | 'gemini-2.5-flash-lite'
+  // Image Generation Models (Nano Banana)
+  | 'gemini-2.5-flash-preview-image-generation'
+  | 'gemini-3-pro-image-preview'
+  // TTS Models
+  | 'gemini-2.5-flash-preview-tts'
+  | 'gemini-2.5-pro-preview-tts'
+  // Embedding Model
+  | 'gemini-embedding-001'
+  // Legacy
+  | 'gemini-2.0-flash'
+  | 'gemini-2.0-flash-lite'
+  | string;
+
+export type VeoModel =
+  | 'veo-3.1-generate-preview'
+  | 'veo-3.1-fast-generate-preview'
+  | 'veo-2.0-generate-001'
+  | string;
+
+export interface ModelInfo {
+  name: string;
+  displayName: string;
+  description: string;
+  inputTokenLimit: number;
+  outputTokenLimit: number;
+  supportedGenerationMethods: string[];
+}
+
+// ============ Content Types ============
+export interface Part {
+  text?: string;
+  inlineData?: InlineData;
+  fileData?: FileData;
+}
+
+export interface InlineData {
+  mimeType: string;
+  data: string; // base64 encoded
+}
+
+export interface FileData {
+  mimeType: string;
+  fileUri: string;
+}
+
+export interface Content {
+  parts: Part[];
+  role?: 'user' | 'model';
+}
+
+// ============ Generation Config ============
+export interface GenerationConfig {
+  temperature?: number;
+  topP?: number;
+  topK?: number;
+  maxOutputTokens?: number;
+  stopSequences?: string[];
+  responseMimeType?: 'text/plain' | 'application/json';
+  responseModalities?: ('TEXT' | 'IMAGE' | 'AUDIO')[];
+  speechConfig?: SpeechConfig;
+  imageConfig?: ImageConfig;
+}
+
+export interface ImageConfig {
+  aspectRatio?: '1:1' | '2:3' | '3:2' | '3:4' | '4:3' | '4:5' | '5:4' | '9:16' | '16:9' | '21:9';
+  imageSize?: '1K' | '2K' | '4K';
+  numberOfImages?: number;
+}
+
+export interface SpeechConfig {
+  voiceConfig?: VoiceConfig;
+  multiSpeakerVoiceConfig?: MultiSpeakerVoiceConfig;
+}
+
+export interface VoiceConfig {
+  prebuiltVoiceConfig: {
+    voiceName: VoiceName;
+  };
+}
+
+export interface MultiSpeakerVoiceConfig {
+  speakerVoiceConfigs: SpeakerVoiceConfig[];
+}
+
+export interface SpeakerVoiceConfig {
+  speaker: string;
+  voiceConfig: VoiceConfig;
+}
+
+export type VoiceName =
+  | 'Kore'
+  | 'Puck'
+  | 'Charon'
+  | 'Zephyr'
+  | 'Fenrir'
+  | 'Leda'
+  | 'Enceladus'
+  | 'Aoede'
+  | 'Callirrhoe'
+  | 'Autonoe'
+  | 'Aitne'
+  | 'Elara'
+  | 'Iocaste'
+  | 'Umbriel'
+  | 'Algieba'
+  | 'Despina'
+  | 'Erinome'
+  | 'Algenib'
+  | 'Rasalgethi'
+  | 'Laomedeia'
+  | 'Achernar'
+  | 'Alnilam'
+  | 'Schedar'
+  | 'Gacrux'
+  | 'Pulcherrima'
+  | 'Achird'
+  | 'Zubenelgenubi'
+  | 'Vindemiatrix'
+  | 'Sadachbia'
+  | 'Sadaltager'
+  | string;
+
+// ============ Safety Settings ============
+export type HarmCategory =
+  | 'HARM_CATEGORY_HARASSMENT'
+  | 'HARM_CATEGORY_HATE_SPEECH'
+  | 'HARM_CATEGORY_SEXUALLY_EXPLICIT'
+  | 'HARM_CATEGORY_DANGEROUS_CONTENT';
+
+export type HarmBlockThreshold =
+  | 'BLOCK_NONE'
+  | 'BLOCK_LOW_AND_ABOVE'
+  | 'BLOCK_MEDIUM_AND_ABOVE'
+  | 'BLOCK_ONLY_HIGH';
+
+export interface SafetySetting {
+  category: HarmCategory;
+  threshold: HarmBlockThreshold;
+}
+
+// ============ Generate Content Request/Response ============
+export interface GenerateContentRequest {
+  contents: Content[];
+  generationConfig?: GenerationConfig;
+  safetySettings?: SafetySetting[];
+  systemInstruction?: Content;
+}
+
+export interface GenerateContentResponse {
+  candidates: Candidate[];
+  usageMetadata?: UsageMetadata;
+  modelVersion?: string;
+}
+
+export interface Candidate {
+  content: Content;
+  finishReason?: string;
+  safetyRatings?: SafetyRating[];
+  citationMetadata?: CitationMetadata;
+}
+
+export interface SafetyRating {
+  category: HarmCategory;
+  probability: string;
+}
+
+export interface CitationMetadata {
+  citations: Citation[];
+}
+
+export interface Citation {
+  startIndex?: number;
+  endIndex?: number;
+  uri?: string;
+  title?: string;
+}
+
+export interface UsageMetadata {
+  promptTokenCount: number;
+  candidatesTokenCount: number;
+  totalTokenCount: number;
+}
+
+// ============ Embeddings ============
+export type EmbeddingTaskType =
+  | 'SEMANTIC_SIMILARITY'
+  | 'CLASSIFICATION'
+  | 'CLUSTERING'
+  | 'RETRIEVAL_DOCUMENT'
+  | 'RETRIEVAL_QUERY'
+  | 'CODE_RETRIEVAL_QUERY'
+  | 'QUESTION_ANSWERING'
+  | 'FACT_VERIFICATION';
+
+export interface EmbedContentRequest {
+  content: Content;
+  taskType?: EmbeddingTaskType;
+  title?: string;
+  outputDimensionality?: number;
+}
+
+export interface EmbedContentResponse {
+  embedding: {
+    values: number[];
+  };
+}
+
+export interface BatchEmbedContentsRequest {
+  requests: EmbedContentRequest[];
+}
+
+export interface BatchEmbedContentsResponse {
+  embeddings: { values: number[] }[];
+}
+
+// ============ Video Generation (Veo) ============
+export interface VideoGenerationRequest {
+  instances: VideoGenerationInstance[];
+}
+
+export interface VideoGenerationInstance {
+  prompt: string;
+  negativePrompt?: string;
+  image?: {
+    bytesBase64Encoded?: string;
+    gcsUri?: string;
+  };
+  lastFrame?: {
+    bytesBase64Encoded?: string;
+    gcsUri?: string;
+  };
+  referenceImages?: {
+    referenceImage: {
+      bytesBase64Encoded?: string;
+      gcsUri?: string;
+    };
+    referenceType: 'REFERENCE_TYPE_STYLE' | 'REFERENCE_TYPE_SUBJECT';
+  }[];
+  video?: {
+    bytesBase64Encoded?: string;
+    gcsUri?: string;
+  };
+}
+
+export interface VideoGenerationParameters {
+  aspectRatio?: '16:9' | '9:16';
+  resolution?: '720p' | '1080p' | '4k';
+  durationSeconds?: 4 | 6 | 8;
+  personGeneration?: 'dont_allow' | 'allow_adult' | 'allow_all';
+  generateAudio?: boolean;
+  enhancePrompt?: boolean;
+  storageUri?: string;
+}
+
+export interface VideoGenerationOperation {
+  name: string;
+  done: boolean;
+  metadata?: {
+    '@type': string;
+  };
+  response?: {
+    generatedVideos: GeneratedVideo[];
+  };
+  error?: {
+    code: number;
+    message: string;
+  };
+}
+
+export interface GeneratedVideo {
+  video: {
+    bytesBase64Encoded?: string;
+    gcsUri?: string;
+  };
+}
+
+// ============ Files API ============
+export interface UploadedFile {
+  name: string;
+  displayName: string;
+  mimeType: string;
+  sizeBytes: string;
+  createTime: string;
+  updateTime: string;
+  expirationTime: string;
+  sha256Hash: string;
+  uri: string;
+  state: 'PROCESSING' | 'ACTIVE' | 'FAILED';
+  error?: {
+    code: number;
+    message: string;
+  };
+}
+
+export interface ListFilesResponse {
+  files: UploadedFile[];
+  nextPageToken?: string;
+}
+
+// ============ Token Counting ============
+export interface CountTokensRequest {
+  contents: Content[];
+  generationConfig?: GenerationConfig;
+}
+
+export interface CountTokensResponse {
+  totalTokens: number;
+}
+
+// ============ Config ============
+export interface GeminiConfig {
+  apiKey?: string;
+  baseUrl?: string;
+}

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

@@ -0,0 +1,139 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import type { GeminiConfig } from '../types';
+
+const CONNECTOR_NAME = 'connect-googlegemini';
+const CONFIG_DIR = path.join(os.homedir(), '.connect', CONNECTOR_NAME);
+const PROFILES_DIR = path.join(CONFIG_DIR, 'profiles');
+const CURRENT_PROFILE_FILE = path.join(CONFIG_DIR, 'current_profile');
+
+// Ensure config directories exist
+function ensureConfigDirs(): void {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(PROFILES_DIR)) {
+    fs.mkdirSync(PROFILES_DIR, { recursive: true });
+  }
+}
+
+// Get profile file path
+function getProfilePath(name: string): string {
+  return path.join(PROFILES_DIR, `${name}.json`);
+}
+
+// Get current profile name
+export function getCurrentProfile(): string {
+  ensureConfigDirs();
+  if (fs.existsSync(CURRENT_PROFILE_FILE)) {
+    return fs.readFileSync(CURRENT_PROFILE_FILE, 'utf-8').trim() || 'default';
+  }
+  return 'default';
+}
+
+// Set current profile
+export function setCurrentProfile(name: string): void {
+  ensureConfigDirs();
+  if (!fs.existsSync(getProfilePath(name))) {
+    throw new Error(`Profile '${name}' does not exist`);
+  }
+  fs.writeFileSync(CURRENT_PROFILE_FILE, name);
+}
+
+// List all profiles
+export function listProfiles(): string[] {
+  ensureConfigDirs();
+  const files = fs.readdirSync(PROFILES_DIR);
+  return files
+    .filter((f) => f.endsWith('.json'))
+    .map((f) => f.replace('.json', ''));
+}
+
+// Create a new profile
+export function createProfile(name: string, config: GeminiConfig = {}): void {
+  ensureConfigDirs();
+  const profilePath = getProfilePath(name);
+  if (fs.existsSync(profilePath)) {
+    throw new Error(`Profile '${name}' already exists`);
+  }
+  fs.writeFileSync(profilePath, JSON.stringify(config, null, 2));
+}
+
+// Delete a profile
+export function deleteProfile(name: string): void {
+  if (name === 'default') {
+    throw new Error("Cannot delete 'default' profile");
+  }
+  const profilePath = getProfilePath(name);
+  if (!fs.existsSync(profilePath)) {
+    throw new Error(`Profile '${name}' does not exist`);
+  }
+  fs.unlinkSync(profilePath);
+
+  // If deleting current profile, switch to default
+  if (getCurrentProfile() === name) {
+    setCurrentProfile('default');
+  }
+}
+
+// Load profile config
+export function loadProfile(name?: string): GeminiConfig {
+  ensureConfigDirs();
+  const profileName = name || getCurrentProfile();
+  const profilePath = getProfilePath(profileName);
+
+  if (!fs.existsSync(profilePath)) {
+    // Create default profile if it doesn't exist
+    if (profileName === 'default') {
+      createProfile('default', {});
+      return {};
+    }
+    throw new Error(`Profile '${profileName}' does not exist`);
+  }
+
+  const content = fs.readFileSync(profilePath, 'utf-8');
+  return JSON.parse(content) as GeminiConfig;
+}
+
+// Save profile config
+export function saveProfile(name: string, config: GeminiConfig): void {
+  ensureConfigDirs();
+  const profilePath = getProfilePath(name);
+  fs.writeFileSync(profilePath, JSON.stringify(config, null, 2));
+}
+
+// Get config value with env var override
+export function getApiKey(): string | undefined {
+  return process.env.GEMINI_API_KEY || loadProfile().apiKey;
+}
+
+export function getBaseUrl(): string {
+  return process.env.GEMINI_BASE_URL || loadProfile().baseUrl || 'https://generativelanguage.googleapis.com';
+}
+
+// Set config values
+export function setApiKey(key: string, profileName?: string): void {
+  const name = profileName || getCurrentProfile();
+  const config = loadProfile(name);
+  config.apiKey = key;
+  saveProfile(name, config);
+}
+
+export function setBaseUrl(url: string, profileName?: string): void {
+  const name = profileName || getCurrentProfile();
+  const config = loadProfile(name);
+  config.baseUrl = url;
+  saveProfile(name, config);
+}
+
+// Check if we have valid API key
+export function hasApiKey(): boolean {
+  return !!getApiKey();
+}
+
+// Clear all config for a profile
+export function clearConfig(profileName?: string): void {
+  const name = profileName || getCurrentProfile();
+  saveProfile(name, {});
+}

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

@@ -0,0 +1,169 @@
+import chalk from 'chalk';
+
+export type OutputFormat = 'json' | 'pretty';
+
+let outputFormat: OutputFormat = 'pretty';
+
+export function setOutputFormat(format: OutputFormat): void {
+  outputFormat = format;
+}
+
+export function getOutputFormat(): OutputFormat {
+  return outputFormat;
+}
+
+export function output(data: unknown, options?: { title?: string }): void {
+  if (outputFormat === 'json') {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    if (options?.title) {
+      console.log(chalk.bold.blue(`\n${options.title}`));
+      console.log(chalk.gray('─'.repeat(50)));
+    }
+    prettyPrint(data);
+  }
+}
+
+export function prettyPrint(data: unknown, indent = 0): void {
+  const prefix = '  '.repeat(indent);
+
+  if (data === null || data === undefined) {
+    console.log(`${prefix}${chalk.gray('null')}`);
+    return;
+  }
+
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      console.log(`${prefix}${chalk.gray('[]')}`);
+      return;
+    }
+    data.forEach((item, index) => {
+      if (typeof item === 'object' && item !== null) {
+        console.log(`${prefix}${chalk.yellow(`[${index}]`)}`);
+        prettyPrint(item, indent + 1);
+      } else {
+        console.log(`${prefix}${chalk.yellow(`[${index}]`)} ${formatValue(item)}`);
+      }
+    });
+    return;
+  }
+
+  if (typeof data === 'object') {
+    const obj = data as Record<string, unknown>;
+    const entries = Object.entries(obj);
+    if (entries.length === 0) {
+      console.log(`${prefix}${chalk.gray('{}')}`);
+      return;
+    }
+    for (const [key, value] of entries) {
+      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        console.log(`${prefix}${chalk.cyan(key)}:`);
+        prettyPrint(value, indent + 1);
+      } else if (Array.isArray(value)) {
+        console.log(`${prefix}${chalk.cyan(key)}: ${chalk.gray(`[${value.length} items]`)}`);
+        if (value.length > 0 && value.length <= 5) {
+          prettyPrint(value, indent + 1);
+        }
+      } else {
+        console.log(`${prefix}${chalk.cyan(key)}: ${formatValue(value)}`);
+      }
+    }
+    return;
+  }
+
+  console.log(`${prefix}${formatValue(data)}`);
+}
+
+function formatValue(value: unknown): string {
+  if (value === null || value === undefined) {
+    return chalk.gray('null');
+  }
+  if (typeof value === 'boolean') {
+    return value ? chalk.green('true') : chalk.red('false');
+  }
+  if (typeof value === 'number') {
+    return chalk.yellow(value.toString());
+  }
+  if (typeof value === 'string') {
+    // Truncate long strings (like base64 data)
+    if (value.length > 100) {
+      return chalk.white(value.slice(0, 100) + '...');
+    }
+    // Check if it's a date string
+    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
+      return chalk.magenta(value);
+    }
+    // Check if it's a status
+    if (['ACTIVE', 'PROCESSING'].includes(value)) {
+      return chalk.green(value);
+    }
+    if (['FAILED'].includes(value)) {
+      return chalk.red(value);
+    }
+    return chalk.white(value);
+  }
+  return chalk.white(String(value));
+}
+
+export function success(message: string): void {
+  console.log(chalk.green('✓'), message);
+}
+
+export function error(message: string): void {
+  console.error(chalk.red('✗'), message);
+}
+
+export function warn(message: string): void {
+  console.log(chalk.yellow('⚠'), message);
+}
+
+export function info(message: string): void {
+  console.log(chalk.blue('ℹ'), message);
+}
+
+export function table(
+  headers: string[],
+  rows: (string | number | boolean | null | undefined)[][]
+): void {
+  if (outputFormat === 'json') {
+    const data = rows.map((row) => {
+      const obj: Record<string, unknown> = {};
+      headers.forEach((header, i) => {
+        obj[header] = row[i];
+      });
+      return obj;
+    });
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  // Calculate column widths
+  const widths = headers.map((h, i) => {
+    const values = [h, ...rows.map((r) => String(r[i] ?? ''))];
+    return Math.min(Math.max(...values.map((v) => v.length)), 50);
+  });
+
+  // Print header
+  const headerRow = headers.map((h, i) => h.padEnd(widths[i])).join('  ');
+  console.log(chalk.bold(headerRow));
+  console.log(chalk.gray('─'.repeat(headerRow.length)));
+
+  // Print rows
+  for (const row of rows) {
+    const formattedRow = row
+      .map((cell, i) => {
+        const str = String(cell ?? '');
+        const truncated = str.length > widths[i] ? str.slice(0, widths[i] - 3) + '...' : str;
+        return truncated.padEnd(widths[i]);
+      })
+      .join('  ');
+    console.log(formattedRow);
+  }
+}
+
+export function progressBar(current: number, total: number, width = 30): string {
+  const percentage = Math.round((current / total) * 100);
+  const filled = Math.round((current / total) * width);
+  const empty = width - filled;
+  return `[${'█'.repeat(filled)}${'░'.repeat(empty)}] ${percentage}%`;
+}

package/connectors/connect-googlegemini/tsconfig.json

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

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

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