hasina-gemini-cli 1.0.0

package/src/config/env.js

@@ -0,0 +1,93 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const dotenv = require('dotenv');
+const {
+  assertNonEmptyString,
+  normalizeModelName,
+  parsePositiveInteger,
+} = require('../utils/validators');
+
+const rootDir = path.resolve(__dirname, '../..');
+const isInstalledPackage = rootDir.includes(`${path.sep}node_modules${path.sep}`);
+
+function resolveConfigDir() {
+  const customDir = process.env.GEMINI_CLI_HOME && process.env.GEMINI_CLI_HOME.trim();
+
+  if (customDir) {
+    return path.resolve(customDir);
+  }
+
+  if (process.platform === 'win32' && process.env.APPDATA) {
+    return path.join(process.env.APPDATA, 'GeminiCli');
+  }
+
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'GeminiCli');
+  }
+
+  return path.join(os.homedir(), '.gemini-cli');
+}
+
+function loadEnvFile(filePath, lockedKeys) {
+  if (!fs.existsSync(filePath)) {
+    return;
+  }
+
+  const parsed = dotenv.parse(fs.readFileSync(filePath));
+
+  Object.entries(parsed).forEach(([key, value]) => {
+    if (lockedKeys.has(key)) {
+      return;
+    }
+
+    process.env[key] = value;
+  });
+}
+
+const configDir = resolveConfigDir();
+const configEnvPath = path.join(configDir, '.env');
+const rootEnvPath = path.join(rootDir, '.env');
+const cwdEnvPath = path.join(process.cwd(), '.env');
+const lockedKeys = new Set(Object.keys(process.env));
+
+loadEnvFile(configEnvPath, lockedKeys);
+loadEnvFile(rootEnvPath, lockedKeys);
+
+if (cwdEnvPath !== rootEnvPath) {
+  loadEnvFile(cwdEnvPath, lockedKeys);
+}
+
+function loadEnvConfig() {
+  try {
+    const sessionsFilePath = process.env.GEMINI_CLI_SESSIONS_FILE
+      ? path.resolve(process.env.GEMINI_CLI_SESSIONS_FILE)
+      : isInstalledPackage
+        ? path.join(configDir, 'sessions.json')
+        : path.join(rootDir, 'data', 'sessions.json');
+
+    return Object.freeze({
+      rootDir,
+      configDir,
+      configEnvPath,
+      isInstalledPackage,
+      geminiApiKey: assertNonEmptyString(process.env.GEMINI_API_KEY, 'GEMINI_API_KEY'),
+      defaultModel: normalizeModelName(
+        assertNonEmptyString(process.env.DEFAULT_MODEL, 'DEFAULT_MODEL')
+      ),
+      maxHistoryMessages: parsePositiveInteger(
+        process.env.MAX_HISTORY_MESSAGES,
+        'MAX_HISTORY_MESSAGES'
+      ),
+      systemPrompt: assertNonEmptyString(process.env.SYSTEM_PROMPT, 'SYSTEM_PROMPT'),
+      sessionsFilePath,
+    });
+  } catch (error) {
+    throw new Error(
+      `Environment configuration error: ${error.message} Update your .env file before starting the app.`,
+      { cause: error }
+    );
+  }
+}
+
+module.exports = loadEnvConfig();

package/src/config/gemini.js

@@ -0,0 +1,294 @@
+const { GoogleGenAI } = require('@google/genai');
+const { normalizeModelName } = require('../utils/validators');
+
+const NON_CHAT_MODEL_KEYWORDS = [
+  'embedding',
+  'image',
+  'audio',
+  'tts',
+  'native-audio',
+  'robotics',
+  'computer-use',
+];
+
+function buildGeminiChatParams({ model, systemPrompt, history }) {
+  const params = {
+    model: normalizeModelName(model),
+    history: mapHistoryToGemini(history),
+  };
+
+  if (systemPrompt && systemPrompt.trim()) {
+    params.config = {
+      systemInstruction: systemPrompt.trim(),
+    };
+  }
+
+  return params;
+}
+
+function mapHistoryToGemini(messages = []) {
+  return messages.map((message) => ({
+    role: message.role === 'assistant' ? 'model' : 'user',
+    parts: [{ text: message.content }],
+  }));
+}
+
+function extractResponseText(response) {
+  if (!response) {
+    return '';
+  }
+
+  if (typeof response.text === 'string') {
+    return response.text;
+  }
+
+  const parts = response.candidates?.[0]?.content?.parts;
+
+  if (!Array.isArray(parts)) {
+    return '';
+  }
+
+  return parts
+    .map((part) => (typeof part?.text === 'string' ? part.text : ''))
+    .join('');
+}
+
+function normalizeListedModel(model) {
+  const id = String(model?.name || '').replace(/^models\//, '').trim();
+
+  if (!id) {
+    return null;
+  }
+
+  return {
+    id,
+    displayName: model.displayName || id,
+    description: model.description || '',
+    inputTokenLimit: Number.isFinite(model.inputTokenLimit) ? model.inputTokenLimit : null,
+    outputTokenLimit: Number.isFinite(model.outputTokenLimit) ? model.outputTokenLimit : null,
+    supportedActions: Array.isArray(model.supportedActions) ? model.supportedActions : [],
+    isPreview: /preview|exp|experimental/i.test(id),
+    isLatest: /-latest$/i.test(id),
+  };
+}
+
+function isChatCapableModel(model) {
+  return (
+    model &&
+    model.id.startsWith('gemini') &&
+    model.supportedActions.includes('generateContent') &&
+    !NON_CHAT_MODEL_KEYWORDS.some((keyword) => model.id.includes(keyword))
+  );
+}
+
+function sortModels(models, currentModel) {
+  return models.slice().sort((left, right) => {
+    const leftPriority = [
+      left.id === currentModel ? 0 : 1,
+      left.isPreview ? 1 : 0,
+      left.isLatest ? 1 : 0,
+      left.id,
+    ];
+    const rightPriority = [
+      right.id === currentModel ? 0 : 1,
+      right.isPreview ? 1 : 0,
+      right.isLatest ? 1 : 0,
+      right.id,
+    ];
+
+    return leftPriority.join('|').localeCompare(rightPriority.join('|'));
+  });
+}
+
+function createFriendlyGeminiError(error, fallbackMessage) {
+  const status = typeof error?.status === 'number' ? error.status : undefined;
+  const message = typeof error?.message === 'string' ? error.message.trim() : '';
+  const lowerMessage = message.toLowerCase();
+
+  if (status === 400) {
+    if (lowerMessage.includes('model')) {
+      return new Error(
+        'Gemini rejected the selected model. Use a valid model name such as "gemini-2.5-flash".',
+        { cause: error }
+      );
+    }
+
+    return new Error(`Gemini rejected the request: ${message || 'bad request.'}`, {
+      cause: error,
+    });
+  }
+
+  if (status === 401) {
+    return new Error('Authentication failed. Check GEMINI_API_KEY in your .env file.', {
+      cause: error,
+    });
+  }
+
+  if (status === 403) {
+    if (lowerMessage.includes('quota') || lowerMessage.includes('billing')) {
+      return new Error(
+        'Gemini quota or billing limits were reached. Check your Google AI Studio quota and billing settings.',
+        { cause: error }
+      );
+    }
+
+    return new Error(
+      'Access to the Gemini API was denied. Verify that your API key has access to the selected model.',
+      { cause: error }
+    );
+  }
+
+  if (status === 404) {
+    return new Error(
+      'The requested Gemini model was not found. Check the model name and try again.',
+      { cause: error }
+    );
+  }
+
+  if (status === 429) {
+    return new Error('Gemini rate limits were reached. Wait a moment and try again.', {
+      cause: error,
+    });
+  }
+
+  if (status >= 500) {
+    return new Error('Gemini is temporarily unavailable. Try again in a few moments.', {
+      cause: error,
+    });
+  }
+
+  if (
+    lowerMessage.includes('network') ||
+    lowerMessage.includes('fetch failed') ||
+    lowerMessage.includes('timed out') ||
+    lowerMessage.includes('timeout') ||
+    lowerMessage.includes('enotfound') ||
+    lowerMessage.includes('econnreset')
+  ) {
+    return new Error('Network request to Gemini failed. Check your connection and try again.', {
+      cause: error,
+    });
+  }
+
+  return new Error(message ? `${fallbackMessage} ${message}` : fallbackMessage, {
+    cause: error,
+  });
+}
+
+function createGeminiProvider({ apiKey }) {
+  const client = new GoogleGenAI({ apiKey });
+
+  return {
+    name: 'gemini',
+
+    async validateModel(model) {
+      const normalizedModel = normalizeModelName(model);
+
+      try {
+        return await client.models.get({ model: normalizedModel });
+      } catch (error) {
+        throw createFriendlyGeminiError(
+          error,
+          `Unable to validate model "${normalizedModel}".`
+        );
+      }
+    },
+
+    async listModels({ currentModel, pageSize = 100 } = {}) {
+      try {
+        const pager = await client.models.list({
+          config: {
+            pageSize,
+          },
+        });
+        const models = [];
+
+        for await (const model of pager) {
+          const normalized = normalizeListedModel(model);
+
+          if (!isChatCapableModel(normalized)) {
+            continue;
+          }
+
+          models.push(normalized);
+        }
+
+        return sortModels(models, currentModel);
+      } catch (error) {
+        throw createFriendlyGeminiError(error, 'Unable to load the Gemini model list.');
+      }
+    },
+
+    async generateReply({ model, systemPrompt, history, message }) {
+      try {
+        const chat = client.chats.create(
+          buildGeminiChatParams({
+            model,
+            systemPrompt,
+            history,
+          })
+        );
+
+        const response = await chat.sendMessage({ message });
+
+        return {
+          model,
+          streamed: false,
+          text: extractResponseText(response),
+        };
+      } catch (error) {
+        throw createFriendlyGeminiError(error, 'Gemini request failed.');
+      }
+    },
+
+    async streamReply({ model, systemPrompt, history, message, onTextChunk }) {
+      try {
+        const chat = client.chats.create(
+          buildGeminiChatParams({
+            model,
+            systemPrompt,
+            history,
+          })
+        );
+
+        const stream = await chat.sendMessageStream({ message });
+        let fullText = '';
+
+        for await (const chunk of stream) {
+          const chunkText = extractResponseText(chunk);
+
+          if (!chunkText) {
+            continue;
+          }
+
+          const delta = chunkText.startsWith(fullText)
+            ? chunkText.slice(fullText.length)
+            : chunkText;
+
+          if (!delta) {
+            continue;
+          }
+
+          fullText += delta;
+
+          if (typeof onTextChunk === 'function') {
+            onTextChunk(delta);
+          }
+        }
+
+        return {
+          model,
+          streamed: true,
+          text: fullText,
+        };
+      } catch (error) {
+        throw createFriendlyGeminiError(error, 'Gemini streaming request failed.');
+      }
+    },
+  };
+}
+
+module.exports = {
+  createFriendlyGeminiError,
+  createGeminiProvider,
+};

package/src/index.js

@@ -0,0 +1,23 @@
+const { createGeminiProvider } = require('./config/gemini');
+const printer = require('./utils/printer');
+const { App } = require('./app');
+
+async function main() {
+  const config = require('./config/env');
+  const provider = createGeminiProvider({
+    apiKey: config.geminiApiKey,
+  });
+
+  const app = new App({
+    config,
+    provider,
+    printer,
+  });
+
+  await app.start();
+}
+
+main().catch((error) => {
+  printer.printError(error.message || 'Unexpected startup error.');
+  process.exit(1);
+});

package/src/services/chat.service.js

@@ -0,0 +1,51 @@
+const { assertNonEmptyString, normalizeModelName } = require('../utils/validators');
+
+class ChatService {
+  constructor({ provider, maxHistoryMessages }) {
+    this.provider = provider;
+    this.maxHistoryMessages = maxHistoryMessages;
+  }
+
+  getBoundedHistory(messages = []) {
+    const slice = messages.slice(-this.maxHistoryMessages);
+    return slice[0]?.role === 'assistant' ? slice.slice(1) : slice;
+  }
+
+  buildRequest({ model, systemPrompt, historyMessages, userMessage }) {
+    return {
+      model: normalizeModelName(model),
+      systemPrompt,
+      history: this.getBoundedHistory(historyMessages),
+      message: assertNonEmptyString(userMessage, 'User message'),
+    };
+  }
+
+  async sendMessage({
+    model,
+    systemPrompt,
+    historyMessages,
+    userMessage,
+    preferStreaming = true,
+    onTextChunk,
+  }) {
+    const request = this.buildRequest({
+      model,
+      systemPrompt,
+      historyMessages,
+      userMessage,
+    });
+
+    if (preferStreaming && typeof this.provider.streamReply === 'function') {
+      return this.provider.streamReply({
+        ...request,
+        onTextChunk,
+      });
+    }
+
+    return this.provider.generateReply(request);
+  }
+}
+
+module.exports = {
+  ChatService,
+};