hasina-gemini-cli 1.0.0

package/src/services/command.service.js

@@ -0,0 +1,298 @@
+const { assertCommandArgument, normalizeModelName } = require('../utils/validators');
+
+const COMMAND_DEFINITIONS = [
+  { usage: '/help', description: 'Show all available commands.' },
+  { usage: '/exit', description: 'Exit the application cleanly.' },
+  { usage: '/clear', description: 'Clear in-memory history for the current session.' },
+  { usage: '/history', description: 'Show recent messages from the current session.' },
+  { usage: '/models', description: 'Open a numbered model chooser.' },
+  { usage: '/save', description: 'Persist the current session to local JSON storage.' },
+  { usage: '/new', description: 'Start a fresh conversation session.' },
+  { usage: '/model', description: 'Show the active Gemini model.' },
+  { usage: '/use-model <model_name>', description: 'Switch the active model at runtime.' },
+  { usage: '/system', description: 'Show the active system prompt.' },
+  { usage: '/set-system <text>', description: 'Override the system prompt for this session.' },
+  { usage: '/sessions', description: 'List saved local sessions.' },
+  { usage: '/load <session_id>', description: 'Load a previous session from JSON storage.' },
+];
+
+function messageResult(level, message, extra = {}) {
+  return {
+    kind: 'message',
+    level,
+    message,
+    ...extra,
+  };
+}
+
+function blockResult(title, lines) {
+  return {
+    kind: 'block',
+    title,
+    lines,
+  };
+}
+
+function modelPickerResult(title, lines, models) {
+  return {
+    kind: 'model-picker',
+    title,
+    lines,
+    models,
+  };
+}
+
+function compactText(value, maxLength = 100) {
+  const singleLine = String(value).replace(/\s+/g, ' ').trim();
+
+  if (singleLine.length <= maxLength) {
+    return singleLine;
+  }
+
+  return `${singleLine.slice(0, maxLength - 3)}...`;
+}
+
+function formatTokenCount(value) {
+  if (!Number.isFinite(value)) {
+    return '?';
+  }
+
+  if (value >= 1000000) {
+    return `${(value / 1000000).toFixed(value % 1000000 === 0 ? 0 : 1)}M`;
+  }
+
+  if (value >= 1000) {
+    return `${(value / 1000).toFixed(value % 1000 === 0 ? 0 : 1)}K`;
+  }
+
+  return String(value);
+}
+
+class CommandService {
+  constructor({ sessionService, provider }) {
+    this.sessionService = sessionService;
+    this.provider = provider;
+  }
+
+  isCommand(input) {
+    return typeof input === 'string' && input.trim().startsWith('/');
+  }
+
+  parse(input) {
+    const trimmed = input.trim();
+    const withoutSlash = trimmed.slice(1);
+    const firstSpaceIndex = withoutSlash.indexOf(' ');
+
+    if (firstSpaceIndex === -1) {
+      return {
+        name: withoutSlash.toLowerCase(),
+        rawArgs: '',
+      };
+    }
+
+    return {
+      name: withoutSlash.slice(0, firstSpaceIndex).toLowerCase(),
+      rawArgs: withoutSlash.slice(firstSpaceIndex + 1).trim(),
+    };
+  }
+
+  async execute(input, state) {
+    try {
+      const command = this.parse(input);
+
+      switch (command.name) {
+        case 'help':
+          return blockResult(
+            'Available Commands',
+            COMMAND_DEFINITIONS.map(
+              (entry) => `${entry.usage.padEnd(28)} ${entry.description}`
+            )
+          );
+
+        case 'exit':
+          return messageResult('info', 'Closing Gemini Terminal.', { exit: true });
+
+        case 'clear':
+          state.historyService.reset();
+          return messageResult('success', 'Current session history cleared from memory.');
+
+        case 'history':
+          return this.handleHistory(state);
+
+        case 'models':
+          return this.handleModels(state);
+
+        case 'save':
+          return this.handleSave(state);
+
+        case 'new':
+          return this.handleNew(state);
+
+        case 'model':
+          return messageResult('info', `Active model: ${state.model}`);
+
+        case 'use-model':
+          return this.handleUseModel(state, command.rawArgs);
+
+        case 'system':
+          return blockResult('Active System Prompt', state.systemPrompt.split(/\r?\n/));
+
+        case 'set-system':
+          return this.handleSetSystem(state, command.rawArgs);
+
+        case 'sessions':
+          return this.handleSessions();
+
+        case 'load':
+          return this.handleLoad(state, command.rawArgs);
+
+        default:
+          return messageResult(
+            'error',
+            `Unknown command "${command.name}". Use /help to see the available commands.`
+          );
+      }
+    } catch (error) {
+      return messageResult('error', error.message);
+    }
+  }
+
+  handleHistory(state) {
+    const messages = state.historyService.getRecentMessages(10);
+
+    if (messages.length === 0) {
+      return messageResult('info', 'No messages in the current session yet.');
+    }
+
+    const lines = messages.map((message, index) => {
+      const label = message.role === 'user' ? 'You' : 'Gemini';
+      return `${String(index + 1).padStart(2, '0')}. ${label}: ${compactText(message.content, 140)}`;
+    });
+
+    return blockResult('Recent Session History', lines);
+  }
+
+  async handleModels(state) {
+    if (typeof this.provider.listModels !== 'function') {
+      throw new Error('This provider does not support model listing.');
+    }
+
+    const models = await this.provider.listModels({
+      currentModel: state.model,
+    });
+
+    if (models.length === 0) {
+      return messageResult('info', 'No selectable Gemini chat models were returned by the API.');
+    }
+
+    const lines = models.map((model, index) => {
+      const tags = [];
+
+      if (model.id === state.model) {
+        tags.push('active');
+      }
+
+      if (model.isLatest) {
+        tags.push('latest');
+      }
+
+      if (model.isPreview) {
+        tags.push('preview');
+      }
+
+      const header = `${String(index + 1).padStart(2, '0')}. ${model.id}${
+        tags.length ? ` [${tags.join(', ')}]` : ''
+      }`;
+      const details = `${compactText(model.displayName, 48)} | input ${formatTokenCount(
+        model.inputTokenLimit
+      )} | output ${formatTokenCount(model.outputTokenLimit)}`;
+
+      return `${header}\n    ${details}`;
+    });
+
+    return modelPickerResult('Choose a Gemini Model', lines, models);
+  }
+
+  async handleSave(state) {
+    const savedSession = await this.sessionService.saveSession({
+      id: state.sessionId,
+      createdAt: state.sessionCreatedAt,
+      model: state.model,
+      systemPrompt: state.systemPrompt,
+      messages: state.historyService.getMessages(),
+    });
+
+    state.sessionId = savedSession.id;
+    state.sessionCreatedAt = savedSession.createdAt;
+
+    return messageResult('success', `Session "${savedSession.id}" saved to data/sessions.json.`);
+  }
+
+  async handleNew(state) {
+    state.historyService.reset();
+    state.sessionId = await this.sessionService.generateSessionId();
+    state.sessionCreatedAt = new Date().toISOString();
+
+    return messageResult(
+      'success',
+      `Started a new session "${state.sessionId}". Active model and system prompt were kept.`
+    );
+  }
+
+  async handleUseModel(state, rawArgs) {
+    const modelName = normalizeModelName(
+      assertCommandArgument(rawArgs, 'Usage: /use-model <model_name>')
+    );
+
+    await this.provider.validateModel(modelName);
+    state.model = modelName;
+
+    return messageResult('success', `Active model changed to "${modelName}".`);
+  }
+
+  handleSetSystem(state, rawArgs) {
+    const nextPrompt = assertCommandArgument(rawArgs, 'Usage: /set-system <text>');
+    state.systemPrompt = nextPrompt;
+
+    return messageResult('success', 'System prompt updated for the current session.');
+  }
+
+  async handleSessions() {
+    const sessions = await this.sessionService.listSessions();
+
+    if (sessions.length === 0) {
+      return messageResult('info', 'No saved sessions yet. Use /save to persist your current chat.');
+    }
+
+    const lines = sessions.map((session) => {
+      const updatedAt = new Date(session.updatedAt).toLocaleString();
+      return [
+        `${session.id} | ${updatedAt}`,
+        `  model=${session.model} | messages=${session.messageCount}`,
+        `  preview=${compactText(session.preview, 100)}`,
+      ].join('\n');
+    });
+
+    return blockResult('Saved Sessions', lines);
+  }
+
+  async handleLoad(state, rawArgs) {
+    const sessionId = assertCommandArgument(rawArgs, 'Usage: /load <session_id>');
+    const session = await this.sessionService.loadSession(sessionId);
+
+    state.historyService.replaceMessages(session.messages);
+    state.sessionId = session.id;
+    state.sessionCreatedAt = session.createdAt;
+    state.model = session.model;
+    state.systemPrompt = session.systemPrompt;
+
+    return messageResult(
+      'success',
+      `Loaded session "${session.id}" with ${session.messages.length} messages and model "${session.model}".`
+    );
+  }
+}
+
+module.exports = {
+  CommandService,
+};

package/src/services/history.service.js

@@ -0,0 +1,83 @@
+const { validateHistoryMessage } = require('../utils/validators');
+
+class HistoryService {
+  constructor({ maxMessages }) {
+    this.maxMessages = maxMessages;
+    this.messages = [];
+  }
+
+  addMessage(role, content) {
+    const normalized = validateHistoryMessage(
+      {
+        role,
+        content,
+      },
+      this.messages.length
+    );
+
+    const previous = this.messages[this.messages.length - 1];
+
+    if (previous && previous.role === normalized.role) {
+      throw new Error(
+        'Conversation history is invalid. Messages must alternate between user and assistant.'
+      );
+    }
+
+    this.messages.push(normalized);
+    return this.getMessages();
+  }
+
+  replaceMessages(messages) {
+    if (!Array.isArray(messages)) {
+      throw new Error('Conversation history must be an array of messages.');
+    }
+
+    const normalized = messages.map((message, index) => validateHistoryMessage(message, index));
+
+    normalized.forEach((message, index) => {
+      if (index === 0 && message.role !== 'user') {
+        throw new Error('Conversation history must start with a user message.');
+      }
+
+      if (index > 0 && normalized[index - 1].role === message.role) {
+        throw new Error(
+          'Conversation history must alternate between user and assistant messages.'
+        );
+      }
+    });
+
+    this.messages = normalized;
+    return this.getMessages();
+  }
+
+  reset() {
+    this.messages = [];
+  }
+
+  count() {
+    return this.messages.length;
+  }
+
+  getMessages() {
+    return this.messages.map((message) => ({ ...message }));
+  }
+
+  getRecentMessages(limit = 10) {
+    return this.getMessages().slice(-limit);
+  }
+
+  getBoundedMessages(limit = this.maxMessages) {
+    const slice = this.messages.slice(-limit);
+    const bounded = slice[0]?.role === 'assistant' ? slice.slice(1) : slice;
+
+    return bounded.map((message) => ({ ...message }));
+  }
+
+  formatForProvider(limit = this.maxMessages) {
+    return this.getBoundedMessages(limit);
+  }
+}
+
+module.exports = {
+  HistoryService,
+};

package/src/services/session.service.js

@@ -0,0 +1,165 @@
+const {
+  assertNonEmptyString,
+  normalizeModelName,
+  validateHistoryMessage,
+} = require('../utils/validators');
+const { ensureJsonFile, readJsonFile, writeJsonFile } = require('../utils/file');
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function normalizeMessages(messages) {
+  if (!Array.isArray(messages)) {
+    throw new Error('Session messages must be an array.');
+  }
+
+  const normalized = messages.map((message, index) => validateHistoryMessage(message, index));
+
+  normalized.forEach((message, index) => {
+    if (index === 0 && message.role !== 'user') {
+      throw new Error('Saved session history must start with a user message.');
+    }
+
+    if (index > 0 && normalized[index - 1].role === message.role) {
+      throw new Error('Saved session history must alternate between user and assistant messages.');
+    }
+  });
+
+  return normalized;
+}
+
+function normalizeStoredSession(session, index) {
+  if (!session || typeof session !== 'object') {
+    throw new Error(`Session at index ${index} must be an object.`);
+  }
+
+  return {
+    id: assertNonEmptyString(session.id, `Session id at index ${index}`),
+    createdAt: assertNonEmptyString(session.createdAt, `Session createdAt at index ${index}`),
+    updatedAt: assertNonEmptyString(session.updatedAt, `Session updatedAt at index ${index}`),
+    model: normalizeModelName(session.model),
+    systemPrompt: assertNonEmptyString(
+      session.systemPrompt,
+      `Session systemPrompt at index ${index}`
+    ),
+    messages: normalizeMessages(session.messages || []),
+  };
+}
+
+function normalizeSessionForSave(session) {
+  if (!session || typeof session !== 'object') {
+    throw new Error('Session data must be an object.');
+  }
+
+  return {
+    id: assertNonEmptyString(session.id, 'Session id'),
+    createdAt: session.createdAt ? assertNonEmptyString(session.createdAt, 'Session createdAt') : '',
+    model: normalizeModelName(session.model),
+    systemPrompt: assertNonEmptyString(session.systemPrompt, 'Session systemPrompt'),
+    messages: normalizeMessages(session.messages || []),
+  };
+}
+
+class SessionService {
+  constructor({ storagePath }) {
+    this.storagePath = storagePath;
+  }
+
+  async ensureStorage() {
+    await ensureJsonFile(this.storagePath, { sessions: [] });
+  }
+
+  async readStore() {
+    await this.ensureStorage();
+
+    const data = await readJsonFile(this.storagePath);
+
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+      throw new Error('Session storage is invalid. Expected an object with a "sessions" array.');
+    }
+
+    if (!Array.isArray(data.sessions)) {
+      throw new Error('Session storage is invalid. Expected "sessions" to be an array.');
+    }
+
+    return {
+      sessions: data.sessions.map((session, index) => normalizeStoredSession(session, index)),
+    };
+  }
+
+  async listSessions() {
+    const store = await this.readStore();
+
+    return store.sessions
+      .slice()
+      .sort((left, right) => new Date(right.updatedAt) - new Date(left.updatedAt))
+      .map((session) => ({
+        id: session.id,
+        model: session.model,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        messageCount: session.messages.length,
+        preview:
+          session.messages.find((message) => message.role === 'user')?.content || 'No messages yet.',
+      }));
+  }
+
+  async loadSession(sessionId) {
+    const normalizedId = assertNonEmptyString(sessionId, 'Session ID');
+    const store = await this.readStore();
+    const session = store.sessions.find((item) => item.id === normalizedId);
+
+    if (!session) {
+      throw new Error(`Session "${normalizedId}" was not found. Use /sessions to list available IDs.`);
+    }
+
+    return clone(session);
+  }
+
+  async saveSession(session) {
+    const normalizedSession = normalizeSessionForSave(session);
+    const store = await this.readStore();
+    const existingIndex = store.sessions.findIndex((item) => item.id === normalizedSession.id);
+    const now = new Date().toISOString();
+    const existing = existingIndex >= 0 ? store.sessions[existingIndex] : null;
+
+    const record = {
+      id: normalizedSession.id,
+      createdAt: existing?.createdAt || normalizedSession.createdAt || now,
+      updatedAt: now,
+      model: normalizedSession.model,
+      systemPrompt: normalizedSession.systemPrompt,
+      messages: normalizedSession.messages,
+    };
+
+    if (existingIndex >= 0) {
+      store.sessions[existingIndex] = record;
+    } else {
+      store.sessions.push(record);
+    }
+
+    await writeJsonFile(this.storagePath, store);
+    return clone(record);
+  }
+
+  async generateSessionId() {
+    const store = await this.readStore();
+    const existingIds = new Set(store.sessions.map((session) => session.id));
+    let counter = store.sessions.length + 1;
+
+    while (true) {
+      const candidate = `session_${String(counter).padStart(3, '0')}`;
+
+      if (!existingIds.has(candidate)) {
+        return candidate;
+      }
+
+      counter += 1;
+    }
+  }
+}
+
+module.exports = {
+  SessionService,
+};