@gringow/gringow 0.0.4 → 0.0.7

package/src/data/check-cache.ts

@@ -1,15 +0,0 @@
-import { getOrCreateCache } from '@/data/get-or-create-cache'
-import logger from '@/logger'
-
-import type { GringowCacheItem } from '@/index'
-
-export async function checkCache(cacheId: string): Promise<GringowCacheItem | undefined> {
-  const cache = await getOrCreateCache()
-
-  if (cache?.[cacheId]) {
-    logger.debug(`Cache hit, id:${cacheId}`)
-    return cache[cacheId]
-  }
-
-  return undefined
-}

package/src/data/clear-cache.ts

@@ -1,5 +0,0 @@
-import { saveCache } from '@/data/save-cache'
-
-export async function clearCache() {
-  await saveCache({})
-}

package/src/data/create-cache-dir.ts

@@ -1,7 +0,0 @@
-import { mkdirp } from 'mkdirp'
-import { awaitedConfig } from '@/config'
-
-export async function createCacheDir() {
-  const config = await awaitedConfig
-  await mkdirp(config.cache.dir)
-}

package/src/data/delete-cache-item.ts

@@ -1,20 +0,0 @@
-import { getOrCreateCache } from '@/data/get-or-create-cache'
-import { saveCache } from '@/data/save-cache'
-
-/**
- * Deletes a cache item.
- *
- * @param cacheId - The cache ID.
- * @returns The cache ID.
- */
-export async function deleteCacheItem(cacheId: string) {
-  const rawCache = await getOrCreateCache()
-  const cache = rawCache
-  if (cache[cacheId]) {
-    delete cache[cacheId]
-  }
-
-  await saveCache(cache)
-
-  return cache
-}

package/src/data/get-cache.ts

@@ -1,17 +0,0 @@
-import fs from 'node:fs/promises'
-
-import { awaitedConfig } from '@/config'
-import { createCacheDir } from '@/data/create-cache-dir'
-
-import type { GringowError } from '@/index'
-
-export async function getCache(): Promise<string> {
-  try {
-    const config = await awaitedConfig
-    await createCacheDir()
-    const rawCache = await fs.readFile(`${config.cache.dir}/${config.cache.file}`)
-    return rawCache.toString()
-  } catch (error) {
-    throw error as GringowError
-  }
-}

package/src/data/get-or-create-cache.ts

@@ -1,21 +0,0 @@
-import { getCache } from '@/data/get-cache'
-import { saveCache } from '@/data/save-cache'
-
-import type { GringowCache, GringowError } from '@/index'
-
-export async function getOrCreateCache(): Promise<GringowCache> {
-  let rawCache: string | undefined
-
-  try {
-    rawCache = await getCache()
-  } catch (error: unknown) {
-    if ((error as GringowError)?.code === 'ENOENT') {
-      await saveCache({})
-      rawCache = await getCache()
-    } else {
-      throw error as GringowError
-    }
-  }
-
-  return rawCache ? JSON.parse(rawCache?.toString()) : {}
-}

package/src/data/save-cache.ts

@@ -1,17 +0,0 @@
-import fs from 'node:fs/promises'
-import { awaitedConfig } from '@/config'
-import { createCacheDir } from '@/data/create-cache-dir'
-
-import type { GringowCache, GringowError } from '@/index'
-
-export async function saveCache(cache: GringowCache) {
-  try {
-    const config = await awaitedConfig
-    await createCacheDir()
-
-    const contents = JSON.stringify(cache, null, 2)
-    await fs.writeFile(`${config.cache.dir}/${config.cache.file}`, contents)
-  } catch (error) {
-    throw error as GringowError
-  }
-}

package/src/data/write-cache-to-disk.ts

@@ -1,20 +0,0 @@
-import { getOrCreateCache } from '@/data/get-or-create-cache'
-import { saveCache } from '@/data/save-cache'
-
-import type { GringowCacheItem } from '@/index'
-
-/**
- * Writes the cache to disk.
- *
- * @param cacheId - The cache ID.
- * @param cached - The cached function.
- * @returns The cache ID.
- */
-export async function writeCacheToDisk(cacheId: string, cached: GringowCacheItem) {
-  const cache = await getOrCreateCache()
-  cache[cacheId] = cached
-
-  await saveCache(cache)
-
-  return cache[cacheId]
-}

package/src/default-config.ts

@@ -1,27 +0,0 @@
-import type { z } from 'zod'
-import type { configSchema } from '@/schemas/config.shcema'
-
-export type GringowConfig = z.infer<typeof configSchema>
-
-export const defaultConfig: GringowConfig = {
-  debug: false,
-  log: {
-    level: 'debug',
-  },
-  cache: {
-    dir: './gringow',
-    file: 'gringow.json',
-    prefix: 'grw',
-    write: true,
-  },
-  keys: {},
-  sourceLanguage: 'en-US',
-  languages: ['pt-BR', 'fr-CA'],
-  llm: {
-    choice: 'huggingface',
-    model: 'Xenova/nllb-200-distilled-600M',
-    temperature: 1.0,
-    sleep: 0,
-  },
-  globby: './src/**/*.{js,jsx,ts,tsx}',
-}

package/src/flat-template-string.test.ts

@@ -1,109 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { flatTemplateString } from './flat-template-string'
-
-// Helper function to create a mock TemplateStringsArray
-function createTemplateStringsArray(strings: string[]): TemplateStringsArray {
-  return Object.assign(strings, { raw: [...strings] })
-}
-
-describe('flatTemplateString', () => {
-  it('should concatenate simple strings without values', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Hello World']), [])
-    expect(result).toBe('Hello World')
-  })
-
-  it('should interpolate simple values', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Hello ', '!']), ['World'])
-    expect(result).toBe('Hello World!')
-  })
-
-  it('should interpolate multiple values', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Hello ', ', you are ', ' years old']), ['John', 25])
-    expect(result).toBe('Hello John, you are 25 years old')
-  })
-
-  it('should handle null and undefined values', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Value: ', ', null: ', ', undefined: ']), [
-      null,
-      null,
-      undefined,
-    ])
-    expect(result).toBe('Value: null, null: null, undefined: undefined')
-  })
-
-  it('should convert numbers to string', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Number: ', '']), [42])
-    expect(result).toBe('Number: 42')
-  })
-
-  it('should convert booleans to string', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Boolean: ', ', false: ']), [true, false])
-    expect(result).toBe('Boolean: true, false: false')
-  })
-
-  it('should handle objects by converting to string', () => {
-    const obj = { name: 'John', age: 30 }
-    const result = flatTemplateString(createTemplateStringsArray(['Object: ', '']), [obj])
-    expect(result).toBe('Object: [object Object]')
-  })
-
-  it('should handle arrays by converting to string', () => {
-    const arr = [1, 2, 3]
-    const result = flatTemplateString(createTemplateStringsArray(['Array: ', '']), [arr])
-    expect(result).toBe('Array: 1,2,3')
-  })
-
-  it('should handle empty strings', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['', 'middle', '']), ['start', 'end'])
-    expect(result).toBe('startmiddleend')
-  })
-
-  it('should handle complex template string', () => {
-    const name = 'Alice'
-    const age = 28
-    const city = 'São Paulo'
-
-    const result = flatTemplateString(
-      createTemplateStringsArray(['Olá, meu nome é ', ', tenho ', ' anos e moro em ', '.']),
-      [name, age, city]
-    )
-
-    expect(result).toBe('Olá, meu nome é Alice, tenho 28 anos e moro em São Paulo.')
-  })
-
-  it('should handle values that are empty strings', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Start', 'Middle', 'End']), ['', ''])
-    expect(result).toBe('StartMiddleEnd')
-  })
-
-  it('should preserve whitespace and line breaks', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Line 1\n', 'Line 2\n', 'Line 3']), ['', ''])
-    expect(result).toBe('Line 1\nLine 2\nLine 3')
-  })
-
-  it('should handle special characters', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Special: ', '']), ['@#$%^&*()'])
-    expect(result).toBe('Special: @#$%^&*()')
-  })
-
-  it('should handle emojis', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Hello ', '!']), ['👋'])
-    expect(result).toBe('Hello 👋!')
-  })
-
-  it('should handle template string without values (strings only)', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Apenas', 'texto', 'simples']), [])
-    expect(result).toBe('Apenastextosimples')
-  })
-
-  it('should handle more values than strings', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Start', 'End']), ['Middle1', 'Middle2', 'Extra'])
-    expect(result).toBe('StartMiddle1EndMiddle2')
-  })
-
-  it('should handle fewer values than strings', () => {
-    const result = flatTemplateString(createTemplateStringsArray(['Start', 'Middle', 'End']), ['Value'])
-    expect(result).toBe('StartValueMiddleEnd')
-  })
-})

package/src/flat-template-string.ts

@@ -1,27 +0,0 @@
-/**
- * Flattens a template string with its values into a single flat string
- *
- * @param givenStrings - The template strings
- * @param givenValues - The values to be interpolated
- * @returns The flattened string
- *
- * @example
- * const result = flatTemplateString`Hello ${name}!`
- * // result = 'Hello John!'
- */
-export function flatTemplateString(givenStrings: TemplateStringsArray, givenValues: Array<unknown>) {
-  const strings = [...givenStrings.raw]
-  const values = [...givenValues]
-
-  const flatted = strings.reduce((acc: string, item: string, index: number) => {
-    acc += String(item ?? '')
-    if (index < values.length) {
-      const value = values[index]
-      // Preserve null and undefined as strings, but handle other falsy values
-      acc += String(value ?? '')
-    }
-    return acc
-  }, '')
-
-  return flatted
-}

package/src/gringow.ts

@@ -1,49 +0,0 @@
-import { awaitedConfig } from '@/config'
-import { checkCache } from '@/data/check-cache'
-import { createCacheId } from '@/data/create-cache-id'
-import { writeCacheToDisk } from '@/data/write-cache-to-disk'
-import { flatTemplateString } from '@/flat-template-string'
-import { askLLM } from '@/io/ask-llm'
-
-import type { GringowResponse } from '.'
-
-/**
- * Gringow is a function that translates a string or a template string into a
- * translated string.
- *
- * @param strings - The string or template string to translate.
- * @param values - The values to interpolate into the string.
- * @returns The translated string.
- */
-async function Gringow(strings: TemplateStringsArray | string, ...values: Array<unknown>): Promise<GringowResponse> {
-  const config = await awaitedConfig
-
-  // flat template string
-  let flatten: string
-  if (typeof strings === 'string') {
-    flatten = String(strings ?? '')
-  } else {
-    flatten = flatTemplateString(strings, values)
-  }
-
-  // create cache id
-  const cacheId = createCacheId(flatten)
-
-  // check cache
-  const cached = await checkCache(cacheId)
-  if (cached !== undefined && cached.original !== 'undefined') {
-    return { cacheId, translation: cached }
-  }
-
-  // ask LLM
-  const translation = await askLLM(flatten)
-
-  if (config.cache.write) {
-    // write cache to disk
-    await writeCacheToDisk(cacheId, translation)
-  }
-
-  return { cacheId, translation }
-}
-
-export { Gringow }

package/src/index.ts

@@ -1,37 +0,0 @@
-import '@/config'
-
-export type GringowTranslation = {
-  [key: string]: string
-}
-
-export type GringowCacheItem = {
-  original: string
-  translation: GringowTranslation
-}
-
-export type GringowCache = {
-  [key: string]: GringowCacheItem
-}
-
-export type GringowResponse = {
-  cacheId: string
-  translation: GringowCacheItem
-}
-
-export type GringowError = Error & {
-  code?: string
-  cause?: Error
-}
-
-export { awaitedConfig, getConfigSource, isLocalConfigFound } from '@/config'
-export { checkCache } from '@/data/check-cache'
-export { clearCache } from '@/data/clear-cache'
-export { createCacheId } from '@/data/create-cache-id'
-export { deleteCacheItem } from '@/data/delete-cache-item'
-export { getCache } from '@/data/get-cache'
-export { getOrCreateCache } from '@/data/get-or-create-cache'
-export { writeCacheToDisk } from '@/data/write-cache-to-disk'
-export { flatTemplateString } from '@/flat-template-string'
-export { Gringow as default } from '@/gringow'
-
-export type { GringowConfig } from '@/default-config'

package/src/io/anthropic/ask.ts

@@ -1,31 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk'
-import { awaitedConfig } from '@/config'
-
-export async function askAnthropic(message: string) {
-  const config = await awaitedConfig
-  if (Number(config.llm.sleep)) {
-    await new Promise((resolve) => setTimeout(resolve, config.llm.sleep ?? 1))
-  }
-
-  if (!config.keys.anthropicApiKey) {
-    throw new Error('Anthropic API key is not set in the config')
-  }
-
-  const anthropic = new Anthropic({
-    apiKey: config.keys.anthropicApiKey,
-    dangerouslyAllowBrowser: true,
-  })
-
-  const response = await anthropic.messages.create({
-    model: config.llm.model as Anthropic.Model,
-    max_tokens: 1024,
-    messages: [
-      {
-        role: 'user',
-        content: `${config.llm.prePrompt}\n\n\n${message}\n\n\n${config.llm.postPrompt}`,
-      },
-    ],
-  })
-
-  return response as Anthropic.Messages.Message
-}

package/src/io/anthropic/commit-response.ts

@@ -1,11 +0,0 @@
-import type { Anthropic } from '@anthropic-ai/sdk'
-import type { CommitResponse } from '@/types'
-
-export function commitResponseAnthropic(response: Anthropic.Messages.Message) {
-  const result = response.content.reduce((acc: string, item: Anthropic.Messages.ContentBlock) => {
-    const nextAcc = acc + (item.type === 'text' ? item.text : '')
-    return nextAcc
-  }, '')
-
-  return result as CommitResponse
-}

package/src/io/anthropic/index.ts

@@ -1,3 +0,0 @@
-export * from './ask'
-export * from './commit-response'
-export * from './parse'

package/src/io/anthropic/parse.ts

@@ -1,11 +0,0 @@
-import type { GringowCacheItem } from '@/index'
-import type { CommitResponse } from '@/types'
-
-export function parseAnthropic(unparsed: CommitResponse): GringowCacheItem {
-  if (typeof unparsed !== 'string') {
-    throw new Error('CommitResponse should be a string here.')
-  }
-
-  const parsed = JSON.parse(unparsed) as GringowCacheItem
-  return parsed
-}

package/src/io/ask-llm.ts

@@ -1,44 +0,0 @@
-import { awaitedConfig } from '@/config'
-import { askAnthropic, commitResponseAnthropic, parseAnthropic } from './anthropic'
-import { askGemini, commitResponseGemini, parseGemini } from './gemini'
-import { askHuggingface, commitResponseHuggingface, parseHuggingface } from './huggingface'
-
-import type { GringowCacheItem } from '@/index'
-import type { LLMChoice, LLMChoices, LLMOptions } from '@/types'
-
-const llmChoices: LLMChoices = {
-  anthropic: {
-    ask: askAnthropic,
-    commitResponse: commitResponseAnthropic,
-    parse: parseAnthropic,
-  },
-  gemini: {
-    ask: askGemini,
-    commitResponse: commitResponseGemini,
-    parse: parseGemini,
-  },
-  huggingface: {
-    ask: askHuggingface,
-    commitResponse: commitResponseHuggingface,
-    parse: parseHuggingface,
-  },
-}
-
-async function processChoice<T = { test: number }>(choice: LLMChoice<T>, prompt: string): Promise<GringowCacheItem> {
-  const response = await choice.ask(prompt)
-  const unparsed = choice.commitResponse(response)
-  const parsed = choice.parse(unparsed)
-  return parsed
-}
-
-export async function askLLM(prompt: string): Promise<GringowCacheItem> {
-  const config = await awaitedConfig
-  const llmChoiceName = config.llm.choice as LLMOptions
-  const llmChoice = llmChoices[llmChoiceName]
-
-  if (!llmChoice) {
-    throw new Error('LLMChoice not found')
-  }
-
-  return processChoice<Awaited<ReturnType<typeof llmChoice.ask>>>(llmChoice, prompt)
-}

package/src/io/gemini/ask.ts

@@ -1,65 +0,0 @@
-import { type GenerateContentResult, GoogleGenerativeAI } from '@google/generative-ai'
-
-import { awaitedConfig } from '@/config'
-
-async function generateResponse(message: string, temperature: number = 1.0) {
-  const config = await awaitedConfig
-  if (!config.keys.geminiApiKey) {
-    throw new Error('Gemini API key is not set in the config')
-  }
-
-  const generativeAIClient = new GoogleGenerativeAI(config.keys.geminiApiKey)
-  const model = generativeAIClient.getGenerativeModel({
-    model: config.llm.model as string,
-    generationConfig: {
-      temperature,
-    },
-  })
-
-  const prompt = String(`${config.llm.prePrompt}\n\n\n${message}\n\n\n${config.llm.postPrompt}`).trim()
-  if (config.debug) {
-    console.log('Gemini model prompt:', JSON.stringify({ prompt }))
-  }
-
-  const response = await model.generateContent([prompt])
-
-  return response
-}
-
-export async function askGemini(message: string) {
-  const config = await awaitedConfig
-  if (Number(config.llm.sleep)) {
-    await new Promise((resolve) => setTimeout(resolve, config.llm.sleep ?? 1))
-  }
-
-  if (!config.keys.geminiApiKey) {
-    throw new Error('Gemini API key is not set in the config')
-  }
-
-  if (config.debug) {
-    console.log('\nAsking Gemini model:', JSON.stringify({ model: config.llm.model, message }))
-  }
-
-  let response: GenerateContentResult | undefined
-  for (let i = 0; i < 3; i++) {
-    const maybeResponse = await generateResponse(message, config.llm.temperature)
-    if (!String(maybeResponse.response.candidates?.[0]?.content?.parts?.[0]?.text ?? '').includes('```json')) {
-      response = maybeResponse
-      break
-    }
-
-    if (config.debug) {
-      console.log('Gemini model response is not valid, contains no JSON:', JSON.stringify({ maybeResponse }))
-    }
-  }
-
-  if (config.debug) {
-    console.log('Gemini model response:', JSON.stringify({ response }))
-  }
-
-  if (!response) {
-    throw new Error('Gemini model response is not valid')
-  }
-
-  return response
-}

package/src/io/gemini/commit-response.ts

@@ -1,6 +0,0 @@
-import type { GenerateContentResult } from '@google/generative-ai'
-
-export function commitResponseGemini(response: GenerateContentResult): string {
-  const result = response.response.text()
-  return result
-}

package/src/io/gemini/index.ts

@@ -1,3 +0,0 @@
-export * from './ask'
-export * from './commit-response'
-export * from './parse'

package/src/io/gemini/parse.ts

@@ -1,12 +0,0 @@
-import type { GringowCacheItem } from '@/index'
-import type { CommitResponse } from '@/types'
-
-export function parseGemini(unparsed: CommitResponse): GringowCacheItem {
-  if (typeof unparsed !== 'string') {
-    throw new Error('CommitResponse should be a string here.')
-  }
-
-  const cleaned = unparsed.replace(/```json/g, '').replace(/```/g, '')
-  const parsed = JSON.parse(cleaned) as GringowCacheItem
-  return parsed
-}

package/src/io/huggingface/ask.ts

@@ -1,82 +0,0 @@
-import {
-  env,
-  type ProgressInfo,
-  pipeline,
-  type TranslationPipeline,
-  type TranslationSingle,
-} from '@huggingface/transformers'
-import 'node:fs'
-
-import { awaitedConfig } from '@/config'
-import { languagesMap } from './languagesMap'
-
-import type { AskHuggingfaceResponse, AskHuggingfaceResponseTranslation } from '@/io/huggingface'
-
-function getLanguageCode(language: string) {
-  return languagesMap[language as keyof typeof languagesMap]
-}
-
-function progressCallback(progress: ProgressInfo) {
-  process.stdout.clearLine(0)
-  process.stdout.cursorTo(0)
-  if (progress.status === 'download') {
-    process.stdout.write('Downloading...')
-  } else if (progress.status === 'initiate') {
-    process.stdout.write('Initializing...')
-  } else if (progress.status === 'done') {
-    process.stdout.write('Done!')
-  } else if (progress.status === 'progress' && 'progress' in progress && 'loaded' in progress && 'total' in progress) {
-    process.stdout.write(
-      `Downloading: ${Number(progress.progress).toFixed(2)}%, loaded: ${progress.loaded}/${progress.total}`
-    )
-  }
-}
-
-async function pipeLanguage(pipe: TranslationPipeline, original: string, srcLanguage: string, targetLanguage: string) {
-  const response = await pipe(original, {
-    src_lang: srcLanguage,
-    tgt_lang: targetLanguage,
-    temperature: 1.0,
-  } as Parameters<TranslationPipeline['call']>[1])
-
-  return response
-}
-
-export async function askHuggingface(original: string) {
-  const config = await awaitedConfig
-  const cacheDir = `${config.cache.dir}/.cache`
-  env.cacheDir = cacheDir
-
-  const pipe = await pipeline('translation', config.llm.model as string, {
-    progress_callback: progressCallback,
-    cache_dir: cacheDir,
-  })
-
-  const { languages } = config
-
-  let responses: AskHuggingfaceResponseTranslation[] = []
-  for await (const language of languages) {
-    const response = await pipeLanguage(
-      pipe,
-      original,
-      getLanguageCode(config.sourceLanguage),
-      getLanguageCode(language)
-    )
-
-    if (Array.isArray(response)) {
-      responses = responses.concat(
-        response.map((r) => ({
-          ...r,
-          targetLanguage: language,
-        })) as AskHuggingfaceResponseTranslation[]
-      )
-    } else {
-      responses.push({
-        ...(response as TranslationSingle),
-        targetLanguage: language,
-      } as AskHuggingfaceResponseTranslation)
-    }
-  }
-
-  return { responses, original } as AskHuggingfaceResponse
-}