hasina-gemini-cli 1.0.0

package/src/utils/banner.js

@@ -0,0 +1,314 @@
+const chalk = require('chalk');
+const figlet = require('figlet');
+const readline = require('readline');
+
+const DEFAULT_BANNER_OPTIONS = Object.freeze({
+  title: 'GEMINI CLI',
+  subtitle: 'Real Gemini API chat assistant for your terminal.',
+  fonts: ['Big', 'ANSI Shadow', 'Standard', 'Small'],
+  center: true,
+  animationDurationMs: 960,
+  frameIntervalMs: 120,
+  shadowLayers: Object.freeze([
+    { offsetX: 3, offsetY: 1, color: '#20112f', dim: true },
+    { offsetX: 1, offsetY: 0, color: '#5f42a1', dim: false },
+  ]),
+  colors: Object.freeze({
+    foregroundStart: '#9985ff',
+    foregroundEnd: '#f0a3ff',
+    foregroundAccent: '#f7deff',
+    subtitle: '#9188a8',
+    divider: '#2d2344',
+  }),
+});
+
+function sleep(durationMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, durationMs);
+  });
+}
+
+function mergeBannerOptions(options = {}) {
+  return {
+    ...DEFAULT_BANNER_OPTIONS,
+    ...options,
+    colors: {
+      ...DEFAULT_BANNER_OPTIONS.colors,
+      ...(options.colors || {}),
+    },
+    shadowLayers: Array.isArray(options.shadowLayers)
+      ? options.shadowLayers
+      : DEFAULT_BANNER_OPTIONS.shadowLayers,
+  };
+}
+
+function hexToRgb(hex) {
+  const normalized = hex.replace('#', '');
+
+  return {
+    r: Number.parseInt(normalized.slice(0, 2), 16),
+    g: Number.parseInt(normalized.slice(2, 4), 16),
+    b: Number.parseInt(normalized.slice(4, 6), 16),
+  };
+}
+
+function rgbToHex({ r, g, b }) {
+  return `#${[r, g, b]
+    .map((value) => Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, '0'))
+    .join('')}`;
+}
+
+function blendHex(leftHex, rightHex, ratio) {
+  const left = hexToRgb(leftHex);
+  const right = hexToRgb(rightHex);
+
+  return rgbToHex({
+    r: left.r + (right.r - left.r) * ratio,
+    g: left.g + (right.g - left.g) * ratio,
+    b: left.b + (right.b - left.b) * ratio,
+  });
+}
+
+function lineWidth(value) {
+  return Array.from(value).length;
+}
+
+function getColumns() {
+  return Number.isInteger(process.stdout.columns) ? process.stdout.columns : 0;
+}
+
+function getMaxShadowOffsetX(settings) {
+  return Math.max(0, ...settings.shadowLayers.map((layer) => layer.offsetX || 0));
+}
+
+function getMaxShadowOffsetY(settings) {
+  return Math.max(0, ...settings.shadowLayers.map((layer) => layer.offsetY || 0));
+}
+
+// Render the title once per candidate font, then keep the largest font that still fits the terminal.
+function selectAsciiTitle(settings) {
+  const columns = getColumns();
+  const extraAnimatedPadding = 1;
+  const terminalLimit = columns > 0 ? columns - 2 : Number.POSITIVE_INFINITY;
+  const renderedVariants = settings.fonts.map((font) => {
+    const rendered = figlet.textSync(settings.title, {
+      font,
+      horizontalLayout: 'fitted',
+      verticalLayout: 'default',
+    });
+    const lines = rendered.split(/\r?\n/).map((line) => line.replace(/\s+$/, ''));
+
+    return {
+      font,
+      lines,
+      width: Math.max(...lines.map((line) => lineWidth(line)), 0),
+      height: lines.length,
+    };
+  });
+
+  return (
+    renderedVariants.find(
+      (variant) =>
+        variant.width + getMaxShadowOffsetX(settings) + extraAnimatedPadding <= terminalLimit
+    ) || renderedVariants[renderedVariants.length - 1]
+  );
+}
+
+function createCanvas(width, height) {
+  return Array.from({ length: height }, () => Array.from({ length: width }, () => ' '));
+}
+
+function buildFrameState(frameIndex, animated) {
+  if (!animated) {
+    return {
+      foregroundShiftX: 0,
+      foregroundShiftY: 0,
+      shadowBumpX: 0,
+      shadowBumpY: 0,
+      glitchAmount: 0,
+      highlightBoost: 0,
+      seed: 0,
+    };
+  }
+
+  const frames = [
+    { foregroundShiftX: 0, foregroundShiftY: 0, shadowBumpX: 0, shadowBumpY: 0, glitchAmount: 0.01, highlightBoost: 0.04, seed: 11 },
+    { foregroundShiftX: 1, foregroundShiftY: 0, shadowBumpX: 1, shadowBumpY: 0, glitchAmount: 0.05, highlightBoost: 0.18, seed: 29 },
+    { foregroundShiftX: 0, foregroundShiftY: 0, shadowBumpX: 0, shadowBumpY: 1, glitchAmount: 0.02, highlightBoost: 0.08, seed: 47 },
+    { foregroundShiftX: 0, foregroundShiftY: 0, shadowBumpX: 0, shadowBumpY: 0, glitchAmount: 0, highlightBoost: 0, seed: 73 },
+  ];
+
+  return frames[frameIndex % frames.length];
+}
+
+function pseudoNoise(x, y, seed) {
+  const value = Math.sin((x + 1) * 12.9898 + (y + 1) * 78.233 + seed * 19.19) * 43758.5453;
+  return value - Math.floor(value);
+}
+
+function applyLayer(canvas, asciiLines, layer, styleCharacter) {
+  asciiLines.forEach((line, y) => {
+    Array.from(line).forEach((character, x) => {
+      if (character === ' ') {
+        return;
+      }
+
+      const targetY = y + layer.offsetY;
+      const targetX = x + layer.offsetX;
+
+      if (!canvas[targetY] || typeof canvas[targetY][targetX] === 'undefined') {
+        return;
+      }
+
+      canvas[targetY][targetX] = styleCharacter(character, x, y, lineWidth(line));
+    });
+  });
+}
+
+function styleShadowCharacter(character, color, dim) {
+  const base = chalk.hex(color);
+  return dim ? base.dim(character) : base(character);
+}
+
+// The foreground uses a left-to-right neon blend and a small, deterministic glitch accent.
+function styleForegroundCharacter(character, x, y, width, settings, frameState) {
+  const positionRatio = width <= 1 ? 0 : x / (width - 1);
+  const baseColor = blendHex(
+    settings.colors.foregroundStart,
+    settings.colors.foregroundEnd,
+    positionRatio
+  );
+  const topGlow = Math.max(0, 0.18 - y * 0.03) + frameState.highlightBoost;
+  const neonColor = blendHex(baseColor, settings.colors.foregroundAccent, Math.min(topGlow, 0.35));
+  const shouldGlitch = pseudoNoise(x, y, frameState.seed) < frameState.glitchAmount;
+  const color = shouldGlitch ? settings.colors.foregroundAccent : neonColor;
+
+  return chalk.hex(color).bold(character);
+}
+
+function renderLayeredTitle(asciiTitle, settings, frameState) {
+  const width =
+    asciiTitle.width +
+    getMaxShadowOffsetX(settings) +
+    Math.max(0, frameState.foregroundShiftX || 0, frameState.shadowBumpX || 0);
+  const height =
+    asciiTitle.height +
+    getMaxShadowOffsetY(settings) +
+    Math.max(0, frameState.foregroundShiftY || 0, frameState.shadowBumpY || 0);
+  const canvas = createCanvas(width, height);
+
+  settings.shadowLayers.forEach((layer) => {
+    applyLayer(
+      canvas,
+      asciiTitle.lines,
+      {
+        offsetX: layer.offsetX + frameState.shadowBumpX,
+        offsetY: layer.offsetY + frameState.shadowBumpY,
+      },
+      (character) => styleShadowCharacter(character, layer.color, layer.dim)
+    );
+  });
+
+  applyLayer(
+    canvas,
+    asciiTitle.lines,
+    {
+      offsetX: frameState.foregroundShiftX,
+      offsetY: frameState.foregroundShiftY,
+    },
+    (character, x, y, widthForLine) =>
+      styleForegroundCharacter(character, x, y, widthForLine, settings, frameState)
+  );
+
+  return {
+    width,
+    lines: canvas.map((row) => row.join('').replace(/\s+$/, '')),
+  };
+}
+
+function createDivider(width, settings) {
+  const dividerWidth = Math.max(24, Math.min(width, 54));
+  return {
+    width: dividerWidth,
+    text: chalk.hex(settings.colors.divider)('-'.repeat(dividerWidth)),
+  };
+}
+
+function createSubtitle(settings) {
+  return {
+    width: lineWidth(settings.subtitle),
+    text: chalk.hex(settings.colors.subtitle)(settings.subtitle),
+  };
+}
+
+function centerEntries(entries, settings) {
+  const blockWidth = Math.max(...entries.map((entry) => entry.width), 0);
+  const columns = getColumns();
+  const leftPadding =
+    settings.center && columns > blockWidth ? Math.floor((columns - blockWidth) / 2) : 0;
+
+  return entries.map((entry) => {
+    const localPadding = Math.max(0, Math.floor((blockWidth - entry.width) / 2));
+    return `${' '.repeat(leftPadding + localPadding)}${entry.text}`;
+  });
+}
+
+function buildBannerEntries(settings, frameIndex = 0, animated = false) {
+  const asciiTitle = selectAsciiTitle(settings);
+  const frameState = buildFrameState(frameIndex, animated);
+  const layeredTitle = renderLayeredTitle(asciiTitle, settings, frameState);
+  const divider = createDivider(layeredTitle.width, settings);
+  const subtitle = createSubtitle(settings);
+
+  return [
+    ...layeredTitle.lines.map((line) => ({ text: line, width: layeredTitle.width })),
+    { text: '', width: 0 },
+    divider,
+    subtitle,
+  ];
+}
+
+function renderGeminiBanner(options = {}) {
+  const settings = mergeBannerOptions(options);
+  const entries = buildBannerEntries(settings);
+  return centerEntries(entries, settings).join('\n');
+}
+
+function rewindBanner(lineCount) {
+  if (!process.stdout.isTTY || lineCount <= 0) {
+    return;
+  }
+
+  readline.moveCursor(process.stdout, 0, -lineCount);
+  readline.cursorTo(process.stdout, 0);
+  readline.clearScreenDown(process.stdout);
+}
+
+async function animateGeminiBanner(options = {}) {
+  const settings = mergeBannerOptions(options);
+
+  if (!process.stdout.isTTY) {
+    process.stdout.write(`${renderGeminiBanner(settings)}\n`);
+    return;
+  }
+
+  const frameCount = Math.max(1, Math.ceil(settings.animationDurationMs / settings.frameIntervalMs));
+  let lineCount = 0;
+
+  for (let frameIndex = 0; frameIndex < frameCount; frameIndex += 1) {
+    const frame = centerEntries(buildBannerEntries(settings, frameIndex, true), settings).join('\n');
+    rewindBanner(lineCount);
+    process.stdout.write(`${frame}\n`);
+    lineCount = frame.split('\n').length;
+    await sleep(settings.frameIntervalMs);
+  }
+
+  rewindBanner(lineCount);
+  process.stdout.write(`${renderGeminiBanner(settings)}\n`);
+}
+
+module.exports = {
+  DEFAULT_BANNER_OPTIONS,
+  animateGeminiBanner,
+  renderGeminiBanner,
+};

package/src/utils/file.js

@@ -0,0 +1,57 @@
+const fs = require('fs/promises');
+const path = require('path');
+
+async function ensureDirectory(directoryPath) {
+  await fs.mkdir(directoryPath, { recursive: true });
+}
+
+async function writeJsonFile(filePath, data) {
+  await ensureDirectory(path.dirname(filePath));
+  await fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+
+async function ensureJsonFile(filePath, defaultValue) {
+  await ensureDirectory(path.dirname(filePath));
+
+  try {
+    await fs.access(filePath);
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error;
+    }
+
+    await writeJsonFile(filePath, defaultValue);
+  }
+}
+
+async function readJsonFile(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+
+    if (!raw.trim()) {
+      return null;
+    }
+
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return null;
+    }
+
+    if (error instanceof SyntaxError) {
+      throw new Error(
+        `The JSON file at "${filePath}" is malformed. Fix the JSON or replace the file with a valid one.`,
+        { cause: error }
+      );
+    }
+
+    throw error;
+  }
+}
+
+module.exports = {
+  ensureDirectory,
+  ensureJsonFile,
+  readJsonFile,
+  writeJsonFile,
+};

package/src/utils/printer.js

@@ -0,0 +1,147 @@
+const chalk = require('chalk');
+const { animateGeminiBanner, renderGeminiBanner } = require('./banner');
+
+const USER_PREFIX = 'You >';
+const ASSISTANT_PREFIX = 'Gemini >';
+const COMMAND_PREFIX = 'Command >';
+const INFO_PREFIX = 'Info >';
+const SUCCESS_PREFIX = 'Success >';
+const ERROR_PREFIX = 'Error >';
+const SPINNER_FRAMES = ['.', '..', '...'];
+
+function printPrefixed(prefix, colorize, message, addBlankLine = true) {
+  const lines = String(message).split(/\r?\n/);
+  const indent = ' '.repeat(prefix.length + 1);
+
+  lines.forEach((line, index) => {
+    if (index === 0) {
+      console.log(`${colorize(prefix)} ${line}`);
+      return;
+    }
+
+    console.log(`${indent}${line}`);
+  });
+
+  if (addBlankLine) {
+    console.log('');
+  }
+}
+
+async function printBanner(options = {}) {
+  if (options.animated) {
+    await animateGeminiBanner(options);
+  } else {
+    process.stdout.write(`${renderGeminiBanner(options)}\n`);
+  }
+
+  console.log('');
+}
+
+function printInfo(message) {
+  printPrefixed(INFO_PREFIX, chalk.blueBright, message);
+}
+
+function printSuccess(message) {
+  printPrefixed(SUCCESS_PREFIX, chalk.greenBright, message);
+}
+
+function printError(message) {
+  printPrefixed(ERROR_PREFIX, chalk.redBright, message);
+}
+
+function printCommandBlock(title, lines) {
+  console.log(chalk.magentaBright(`${COMMAND_PREFIX} ${title}`));
+  lines.forEach((line) => {
+    console.log(chalk.magenta(line));
+  });
+  console.log('');
+}
+
+function printAssistant(message) {
+  printPrefixed(ASSISTANT_PREFIX, chalk.cyanBright, message);
+}
+
+function printUser(message) {
+  printPrefixed(USER_PREFIX, chalk.yellowBright, message);
+}
+
+function getUserPrompt() {
+  return chalk.yellowBright(`${USER_PREFIX} `);
+}
+
+function createLoadingIndicator(label = 'Gemini is thinking') {
+  let frameIndex = 0;
+  let timer = null;
+  let active = false;
+  let wroteFallbackLine = false;
+
+  return {
+    start() {
+      if (active) {
+        return;
+      }
+
+      active = true;
+
+      if (!process.stdout.isTTY) {
+        process.stdout.write(chalk.gray(`${label}...\n`));
+        wroteFallbackLine = true;
+        return;
+      }
+
+      timer = setInterval(() => {
+        process.stdout.write(`\r${chalk.gray(`${label}${SPINNER_FRAMES[frameIndex]}`)}`);
+        frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+      }, 120);
+    },
+
+    stop() {
+      if (!active) {
+        return;
+      }
+
+      active = false;
+
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+
+      if (process.stdout.isTTY) {
+        const clearWidth = label.length + 8;
+        process.stdout.write(`\r${' '.repeat(clearWidth)}\r`);
+      } else if (!wroteFallbackLine) {
+        process.stdout.write('\n');
+      }
+    },
+  };
+}
+
+function startAssistantStream() {
+  process.stdout.write(`${chalk.cyanBright(ASSISTANT_PREFIX)} `);
+}
+
+function writeAssistantChunk(chunk) {
+  process.stdout.write(chunk);
+}
+
+function endAssistantStream() {
+  process.stdout.write('\n\n');
+}
+
+module.exports = {
+  createLoadingIndicator,
+  endAssistantStream,
+  getUserPrompt,
+  animateGeminiBanner,
+  printAssistant,
+  printBanner,
+  printCommandBlock,
+  printError,
+  printInfo,
+  renderGeminiBanner,
+  printSuccess,
+  printUser,
+  startAssistantStream,
+  writeAssistantChunk,
+};

package/src/utils/validators.js

@@ -0,0 +1,67 @@
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function assertNonEmptyString(value, label) {
+  if (!isNonEmptyString(value)) {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+
+  return value.trim();
+}
+
+function parsePositiveInteger(value, label) {
+  const parsed = Number.parseInt(String(value), 10);
+
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`${label} must be a positive integer.`);
+  }
+
+  return parsed;
+}
+
+function normalizeModelName(modelName) {
+  const normalized = assertNonEmptyString(modelName, 'Model name');
+
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(normalized)) {
+    throw new Error(
+      'Model name contains invalid characters. Use letters, numbers, dots, dashes, or underscores only.'
+    );
+  }
+
+  return normalized;
+}
+
+function validateHistoryMessage(message, index) {
+  if (!message || typeof message !== 'object') {
+    throw new Error(`History message at index ${index} must be an object.`);
+  }
+
+  if (message.role !== 'user' && message.role !== 'assistant') {
+    throw new Error(
+      `History message at index ${index} has an invalid role. Use "user" or "assistant".`
+    );
+  }
+
+  return {
+    role: message.role,
+    content: assertNonEmptyString(message.content, `History message content at index ${index}`),
+  };
+}
+
+function assertCommandArgument(rawArgs, usageMessage) {
+  if (!isNonEmptyString(rawArgs)) {
+    throw new Error(usageMessage);
+  }
+
+  return rawArgs.trim();
+}
+
+module.exports = {
+  assertCommandArgument,
+  assertNonEmptyString,
+  isNonEmptyString,
+  normalizeModelName,
+  parsePositiveInteger,
+  validateHistoryMessage,
+};