gemini-wrapper-ashes 1.0.0

package/README.md

@@ -0,0 +1,71 @@
+# gemini-wrapper-ashes
+
+A lightweight, TypeScript-first wrapper around the Google Gemini API that simplifies model configuration, system instructions, and response handling.
+
+---
+
+## Requirements
+
+- Node.js 18 or later  
+- A valid Google Gemini API key  
+
+---
+
+## Installation
+
+npm install gemini-wrapper-ashes
+
+---
+
+## User Manual
+
+### Create a Client
+
+import { GeminiClient } from "gemini-wrapper-ashes";
+
+const gemini = new GeminiClient({
+  apiKey: process.env.GEMINI_API_KEY,
+  model: "gemini-1.5-flash",
+  instruction: "You are a senior software engineer"
+});
+
+---
+
+### Ask a Question
+
+const response = await gemini.ask("Explain closures in JavaScript");
+console.log(response);
+
+---
+
+### Change System Instruction
+
+gemini.setInstruction("You are a strict technical interviewer");
+
+---
+
+### Change Model
+
+gemini.setModel("gemini-1.5-pro");
+
+Any valid Gemini model string is supported. Model validation is delegated to the Gemini API.
+
+---
+
+### Error Handling
+
+import { GeminiError } from "gemini-wrapper-ashes";
+
+try {
+  await gemini.ask("Hello");
+} catch (error) {
+  if (error instanceof GeminiError) {
+    console.error(error.message);
+    console.error(error.code);
+    console.error(error.status);
+  }
+}
+
+---
+
+

package/dist/GeminiClient.d.ts

@@ -0,0 +1,20 @@
+import { GeminiClientConfig } from "./types";
+export declare class GeminiClient {
+    private genAI;
+    private model;
+    private modelName;
+    private instruction;
+    constructor(config: GeminiClientConfig);
+    /**
+     * Update system instruction
+     */
+    setInstruction(instruction: string): void;
+    /**
+     * Update Gemini model (ANY model allowed)
+     */
+    setModel(modelName: string): void;
+    /**
+     * Ask Gemini a question
+     */
+    ask(prompt: string): Promise<string>;
+}

package/dist/GeminiClient.js

@@ -0,0 +1,51 @@
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { GeminiError } from "./errors";
+export class GeminiClient {
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new GeminiError("Gemini API key is required");
+        }
+        this.genAI = new GoogleGenerativeAI(config.apiKey);
+        this.modelName = config.model ?? "gemini-1.5-flash";
+        this.instruction = config.instruction ?? "";
+        this.model = this.genAI.getGenerativeModel({
+            model: this.modelName,
+        });
+    }
+    /**
+     * Update system instruction
+     */
+    setInstruction(instruction) {
+        this.instruction = instruction;
+    }
+    /**
+     * Update Gemini model (ANY model allowed)
+     */
+    setModel(modelName) {
+        if (!modelName || !modelName.trim()) {
+            throw new GeminiError("Model name cannot be empty");
+        }
+        this.modelName = modelName;
+        this.model = this.genAI.getGenerativeModel({
+            model: modelName,
+        });
+    }
+    /**
+     * Ask Gemini a question
+     */
+    async ask(prompt) {
+        if (!prompt || !prompt.trim()) {
+            throw new GeminiError("Prompt cannot be empty");
+        }
+        const finalPrompt = this.instruction
+            ? `SYSTEM:\n${this.instruction}\n\nUSER:\n${prompt}`
+            : prompt;
+        try {
+            const result = await this.model.generateContent(finalPrompt);
+            return result.response.text().trim();
+        }
+        catch (error) {
+            throw new GeminiError(error?.message || "Gemini request failed", error?.code, error?.status || error?.response?.status);
+        }
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class GeminiError extends Error {
+    code?: string;
+    status?: number;
+    constructor(message: string, code?: string, status?: number);
+}

package/dist/errors.js

@@ -0,0 +1,8 @@
+export class GeminiError extends Error {
+    constructor(message, code, status) {
+        super(message);
+        this.name = "GeminiError";
+        this.code = code;
+        this.status = status;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { GeminiClient } from "./GeminiClient";
+export { GeminiError } from "./errors";
+export type { GeminiClientConfig } from "./types";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { GeminiClient } from "./GeminiClient";
+export { GeminiError } from "./errors";

package/dist/types.d.ts

@@ -0,0 +1,5 @@
+export interface GeminiClientConfig {
+    apiKey: string;
+    model?: string;
+    instruction?: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "gemini-wrapper-ashes",
+  "version": "1.0.0",
+  "description": "A simple and clean wrapper around Google Gemini API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["gemini", "ai", "llm", "google", "wrapper"],
+  "author": "Ashes",
+  "license": "MIT",
+  "dependencies": {
+    "@google/generative-ai": "^0.21.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0"
+  }
+}