@gringow/gringow 0.6.1 → 0.6.2

package/dist/data/cache-queue.mjs

@@ -0,0 +1,372 @@
+import fs from 'fs/promises';
+import { cosmiconfig } from 'cosmiconfig';
+import mergeWith from 'lodash.mergewith';
+import { z } from 'zod';
+import { dirname, resolve, parse } from 'path';
+import { mkdir, stat, statSync, mkdirSync } from 'fs';
+
+// src/data/cache-queue.ts
+
+// src/constants/default-config.ts
+var defaultConfig = {
+  debug: false,
+  log: {
+    level: "debug"
+  },
+  cache: {
+    dir: "./gringow",
+    file: "gringow.json",
+    prefix: "grw",
+    write: true
+  },
+  sourceLanguage: "en-US",
+  defaultLanguage: "pt-BR",
+  languages: ["pt-BR", "fr-CA"],
+  llm: {
+    provider: "ollama",
+    apiKey: void 0,
+    model: "llama3.2",
+    temperature: 1,
+    sleep: 0
+  },
+  globby: "./src/**/*.{js,jsx,ts,tsx}"
+};
+var languageSchema = z.string().regex(/^[a-z]{2,3}(-[A-Z]{2})?$/);
+var llmProviderSchema = z.enum([
+  "anthropic",
+  "gemini",
+  "openai",
+  "groq",
+  "mistral",
+  "ollama",
+  "xai",
+  "deepseek",
+  "openrouter",
+  "cerebras",
+  "lmstudio",
+  "azure",
+  "meta"
+]);
+var keylessProviders = ["ollama", "lmstudio"];
+var configSchema = z.object({
+  debug: z.boolean().optional(),
+  log: z.object({
+    level: z.enum(["debug", "info", "warn", "error", "trace"])
+  }),
+  cache: z.object({
+    dir: z.string(),
+    file: z.string(),
+    prefix: z.string(),
+    write: z.boolean().optional()
+  }),
+  sourceLanguage: languageSchema,
+  defaultLanguage: languageSchema,
+  languages: z.array(languageSchema),
+  llm: z.object({
+    provider: llmProviderSchema,
+    apiKey: z.string().optional(),
+    baseURL: z.string().optional(),
+    model: z.string().nullable(),
+    temperature: z.number().optional(),
+    sleep: z.number().optional(),
+    prePrompt: z.string().max(128).optional(),
+    postPrompt: z.string().max(128).optional(),
+    prePromptReplace: z.string().optional(),
+    postPromptReplace: z.string().optional(),
+    prePromptAppend: z.string().optional(),
+    postPromptPrepend: z.string().optional()
+  }).strict(),
+  globby: z.string().regex(/^\.\/.*/).optional()
+}).refine(
+  (data) => {
+    if (keylessProviders.includes(data.llm.provider)) {
+      return true;
+    }
+    return !!data.llm.apiKey;
+  },
+  {
+    message: "The API key must be present in llm.apiKey for the chosen provider.",
+    path: ["llm", "apiKey"]
+  }
+);
+
+// src/config.ts
+var explorer = cosmiconfig("gringow");
+var result = await explorer.search();
+function replaceArrays(_destination, source) {
+  if (Array.isArray(source)) return [...source];
+  return void 0;
+}
+async function loadUserConfig() {
+  try {
+    const mergedConfig = mergeWith({}, defaultConfig, result?.config, replaceArrays);
+    return await configSchema.parseAsync(mergedConfig);
+  } catch (error) {
+    console.warn(`${error?.message}, using default configuration`);
+    return defaultConfig;
+  }
+}
+var awaitedConfig = loadUserConfig();
+
+// src/data/cache-file-path.ts
+function cacheFilePath(config) {
+  return `${config.cache.dir}/${config.cache.file}`;
+}
+var optsArg = (opts) => {
+  if (!opts) {
+    opts = { mode: 511 };
+  } else if (typeof opts === "object") {
+    opts = { mode: 511, ...opts };
+  } else if (typeof opts === "number") {
+    opts = { mode: opts };
+  } else if (typeof opts === "string") {
+    opts = { mode: parseInt(opts, 8) };
+  } else {
+    throw new TypeError("invalid options argument");
+  }
+  const resolved = opts;
+  const optsFs = opts.fs || {};
+  opts.mkdir = opts.mkdir || optsFs.mkdir || mkdir;
+  opts.mkdirAsync = opts.mkdirAsync ? opts.mkdirAsync : async (path, options) => {
+    return new Promise((res, rej) => resolved.mkdir(path, options, (er, made) => er ? rej(er) : res(made)));
+  };
+  opts.stat = opts.stat || optsFs.stat || stat;
+  opts.statAsync = opts.statAsync ? opts.statAsync : async (path) => new Promise((res, rej) => resolved.stat(path, (err, stats) => err ? rej(err) : res(stats)));
+  opts.statSync = opts.statSync || optsFs.statSync || statSync;
+  opts.mkdirSync = opts.mkdirSync || optsFs.mkdirSync || mkdirSync;
+  return resolved;
+};
+
+// ../node_modules/.pnpm/mkdirp@3.0.1/node_modules/mkdirp/dist/mjs/mkdirp-manual.js
+var mkdirpManualSync = (path, options, made) => {
+  const parent = dirname(path);
+  const opts = { ...optsArg(options), recursive: false };
+  if (parent === path) {
+    try {
+      return opts.mkdirSync(path, opts);
+    } catch (er) {
+      const fer = er;
+      if (fer && fer.code !== "EISDIR") {
+        throw er;
+      }
+      return;
+    }
+  }
+  try {
+    opts.mkdirSync(path, opts);
+    return made || path;
+  } catch (er) {
+    const fer = er;
+    if (fer && fer.code === "ENOENT") {
+      return mkdirpManualSync(path, opts, mkdirpManualSync(parent, opts, made));
+    }
+    if (fer && fer.code !== "EEXIST" && fer && fer.code !== "EROFS") {
+      throw er;
+    }
+    try {
+      if (!opts.statSync(path).isDirectory())
+        throw er;
+    } catch (_) {
+      throw er;
+    }
+  }
+};
+var mkdirpManual = Object.assign(async (path, options, made) => {
+  const opts = optsArg(options);
+  opts.recursive = false;
+  const parent = dirname(path);
+  if (parent === path) {
+    return opts.mkdirAsync(path, opts).catch((er) => {
+      const fer = er;
+      if (fer && fer.code !== "EISDIR") {
+        throw er;
+      }
+    });
+  }
+  return opts.mkdirAsync(path, opts).then(() => made || path, async (er) => {
+    const fer = er;
+    if (fer && fer.code === "ENOENT") {
+      return mkdirpManual(parent, opts).then((made2) => mkdirpManual(path, opts, made2));
+    }
+    if (fer && fer.code !== "EEXIST" && fer.code !== "EROFS") {
+      throw er;
+    }
+    return opts.statAsync(path).then((st) => {
+      if (st.isDirectory()) {
+        return made;
+      } else {
+        throw er;
+      }
+    }, () => {
+      throw er;
+    });
+  });
+}, { sync: mkdirpManualSync });
+var findMade = async (opts, parent, path) => {
+  if (path === parent) {
+    return;
+  }
+  return opts.statAsync(parent).then(
+    (st) => st.isDirectory() ? path : void 0,
+    // will fail later
+    // will fail later
+    (er) => {
+      const fer = er;
+      return fer && fer.code === "ENOENT" ? findMade(opts, dirname(parent), parent) : void 0;
+    }
+  );
+};
+var findMadeSync = (opts, parent, path) => {
+  if (path === parent) {
+    return void 0;
+  }
+  try {
+    return opts.statSync(parent).isDirectory() ? path : void 0;
+  } catch (er) {
+    const fer = er;
+    return fer && fer.code === "ENOENT" ? findMadeSync(opts, dirname(parent), parent) : void 0;
+  }
+};
+
+// ../node_modules/.pnpm/mkdirp@3.0.1/node_modules/mkdirp/dist/mjs/mkdirp-native.js
+var mkdirpNativeSync = (path, options) => {
+  const opts = optsArg(options);
+  opts.recursive = true;
+  const parent = dirname(path);
+  if (parent === path) {
+    return opts.mkdirSync(path, opts);
+  }
+  const made = findMadeSync(opts, path);
+  try {
+    opts.mkdirSync(path, opts);
+    return made;
+  } catch (er) {
+    const fer = er;
+    if (fer && fer.code === "ENOENT") {
+      return mkdirpManualSync(path, opts);
+    } else {
+      throw er;
+    }
+  }
+};
+var mkdirpNative = Object.assign(async (path, options) => {
+  const opts = { ...optsArg(options), recursive: true };
+  const parent = dirname(path);
+  if (parent === path) {
+    return await opts.mkdirAsync(path, opts);
+  }
+  return findMade(opts, path).then((made) => opts.mkdirAsync(path, opts).then((m) => made || m).catch((er) => {
+    const fer = er;
+    if (fer && fer.code === "ENOENT") {
+      return mkdirpManual(path, opts);
+    } else {
+      throw er;
+    }
+  }));
+}, { sync: mkdirpNativeSync });
+var platform = process.env.__TESTING_MKDIRP_PLATFORM__ || process.platform;
+var pathArg = (path) => {
+  if (/\0/.test(path)) {
+    throw Object.assign(new TypeError("path must be a string without null bytes"), {
+      path,
+      code: "ERR_INVALID_ARG_VALUE"
+    });
+  }
+  path = resolve(path);
+  if (platform === "win32") {
+    const badWinChars = /[*|"<>?:]/;
+    const { root } = parse(path);
+    if (badWinChars.test(path.substring(root.length))) {
+      throw Object.assign(new Error("Illegal characters in path."), {
+        path,
+        code: "EINVAL"
+      });
+    }
+  }
+  return path;
+};
+var version = process.env.__TESTING_MKDIRP_NODE_VERSION__ || process.version;
+var versArr = version.replace(/^v/, "").split(".");
+var hasNative = +versArr[0] > 10 || +versArr[0] === 10 && +versArr[1] >= 12;
+var useNativeSync = !hasNative ? () => false : (opts) => optsArg(opts).mkdirSync === mkdirSync;
+var useNative = Object.assign(!hasNative ? () => false : (opts) => optsArg(opts).mkdir === mkdir, {
+  sync: useNativeSync
+});
+
+// ../node_modules/.pnpm/mkdirp@3.0.1/node_modules/mkdirp/dist/mjs/index.js
+var mkdirpSync = (path, opts) => {
+  path = pathArg(path);
+  const resolved = optsArg(opts);
+  return useNativeSync(resolved) ? mkdirpNativeSync(path, resolved) : mkdirpManualSync(path, resolved);
+};
+var mkdirp = Object.assign(async (path, opts) => {
+  path = pathArg(path);
+  const resolved = optsArg(opts);
+  return useNative(resolved) ? mkdirpNative(path, resolved) : mkdirpManual(path, resolved);
+}, {
+  mkdirpSync,
+  mkdirpNative,
+  mkdirpNativeSync,
+  mkdirpManual,
+  mkdirpManualSync,
+  sync: mkdirpSync,
+  native: mkdirpNative,
+  nativeSync: mkdirpNativeSync,
+  manual: mkdirpManual,
+  manualSync: mkdirpManualSync,
+  useNative,
+  useNativeSync
+});
+
+// src/data/create-cache-dir.ts
+async function createCacheDir() {
+  const config = await awaitedConfig;
+  await mkdirp(config.cache.dir);
+}
+async function getCache() {
+  const config = await awaitedConfig;
+  try {
+    const rawCache = await fs.readFile(cacheFilePath(config));
+    return rawCache.toString();
+  } catch (error) {
+    if (error?.code === "ENOENT") await createCacheDir();
+    throw error;
+  }
+}
+
+// src/data/cache-queue.ts
+var cacheQueue = Promise.resolve();
+function enqueueCacheTask(task) {
+  const run = cacheQueue.then(task);
+  cacheQueue = run.catch(() => void 0);
+  return run;
+}
+async function writeCacheFile(cache) {
+  const config = await awaitedConfig;
+  await createCacheDir();
+  const contents = JSON.stringify(cache, null, 2);
+  await fs.writeFile(cacheFilePath(config), contents);
+}
+async function parseCacheOrEmpty(rawCache) {
+  if (!rawCache) return {};
+  try {
+    return JSON.parse(rawCache);
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+    const config = await awaitedConfig;
+    console.warn(`Gringow cache ${cacheFilePath(config)} has invalid JSON (${error.message}), recreating it as {}`);
+    return {};
+  }
+}
+async function readCacheOrEmpty() {
+  let rawCache;
+  try {
+    rawCache = await getCache();
+  } catch (error) {
+    if (error?.code === "ENOENT") return {};
+    throw error;
+  }
+  return parseCacheOrEmpty(rawCache);
+}
+
+export { enqueueCacheTask, parseCacheOrEmpty, readCacheOrEmpty, writeCacheFile };

package/dist/data/check-cache.d.mts

@@ -1,10 +1,19 @@
-export { checkCache } from '../index.mjs';
-import '../config.mjs';
-import '../constants/default-config.mjs';
+import { GringowCacheItem } from '../types/index.mjs';
 import 'zod';
 import '../schemas/config.shcema.mjs';
-import '../create-cache-id.mjs';
-import './clear-cache.mjs';
-import './get-cache.mjs';
-import '../interpolate-template.mjs';
-import '../strip-comments.mjs';
+
+/**
+ * Checks if a cache item exists for the given ID
+ *
+ * @param cacheId - The cache ID to check
+ * @returns Promise that resolves to the cached item if found, or undefined otherwise
+ *
+ * @example
+ * const item = await checkCache("gid_123abc")
+ * if (item) {
+ *   console.log("Found in cache:", item.translation)
+ * }
+ */
+declare function checkCache(cacheId: string): Promise<GringowCacheItem | undefined>;
+
+export { checkCache };

package/dist/data/check-cache.mjs

@@ -1,5 +1,5 @@
 import { cosmiconfig } from 'cosmiconfig';
-import merge from 'lodash.merge';
+import mergeWith from 'lodash.mergewith';
 import { z } from 'zod';
 import fs from 'fs/promises';
 import { dirname, resolve, parse } from 'path';
@@ -23,9 +23,9 @@ var defaultConfig = {
   defaultLanguage: "pt-BR",
   languages: ["pt-BR", "fr-CA"],
   llm: {
-    provider: "openai",
+    provider: "ollama",
     apiKey: void 0,
-    model: "gpt-4o-mini",
+    model: "llama3.2",
     temperature: 1,
     sleep: 0
   },
@@ -47,6 +47,7 @@ var llmProviderSchema = z.enum([
   "azure",
   "meta"
 ]);
+var keylessProviders = ["ollama", "lmstudio"];
 var configSchema = z.object({
   debug: z.boolean().optional(),
   log: z.object({
@@ -78,8 +79,7 @@ var configSchema = z.object({
   globby: z.string().regex(/^\.\/.*/).optional()
 }).refine(
   (data) => {
-    const noApiKeyRequired = ["ollama", "lmstudio"];
-    if (noApiKeyRequired.includes(data.llm.provider)) {
+    if (keylessProviders.includes(data.llm.provider)) {
       return true;
     }
     return !!data.llm.apiKey;
@@ -93,79 +93,24 @@ var configSchema = z.object({
 // src/config.ts
 var explorer = cosmiconfig("gringow");
 var result = await explorer.search();
+function replaceArrays(_destination, source) {
+  if (Array.isArray(source)) return [...source];
+  return void 0;
+}
 async function loadUserConfig() {
   try {
-    const mergedConfig = merge({}, defaultConfig, result?.config);
-    const parsedConfig = await configSchema.parseAsync(mergedConfig);
-    parsedConfig.llm.prePrompt = prePrompt(
-      parsedConfig,
-      parsedConfig.llm.prePromptAppend ?? "",
-      parsedConfig.llm.prePromptReplace ?? ""
-    );
-    parsedConfig.llm.postPrompt = postPrompt(
-      parsedConfig,
-      parsedConfig.llm.postPromptPrepend ?? "",
-      parsedConfig.llm.postPromptReplace ?? ""
-    );
-    return parsedConfig;
+    const mergedConfig = mergeWith({}, defaultConfig, result?.config, replaceArrays);
+    return await configSchema.parseAsync(mergedConfig);
   } catch (error) {
     console.warn(`${error?.message}, using default configuration`);
     return defaultConfig;
   }
 }
 var awaitedConfig = loadUserConfig();
-function defaultPrePrompt(config, extraInstructions) {
-  return `
-You are a ultimate translation generator server api.
-
-Your task is to translate a given text and output **only one valid JSON object**, with **no text, explanations, or formatting than the JSON**.
-
-Follow these rules strictly:
 
-1. The original text is written in English or Spanish.
-2. You will receive additional user parameters under the variable 'extraInstructions'. These may specify tone, persona, style, context, or any relevant translation guideline.
-   - Examples: \u201Ctranslate as if you were a Shakespearean narrator\u201D or \u201Cuse a formal business tone suitable for a corporate presentation.\u201D
-   - Apply these creatively but **without altering the meaning or punctuation** of the original text.
-3. Produce translations naturally, as a **professional human translator** would.
-4. Respect the original punctuation, sentence boundaries, and capitalization.
-5. Consider only the following target languages: ${(config?.languages ? Array.from(/* @__PURE__ */ new Set([...config.languages, config.sourceLanguage])) : []).join(", ")}.
-6. The final output must be a **valid JSON** following this exact schema:
-
-{
-  "original": "<original input text>",
-  "translation": {
-    "<language-code>": "<translated text>",
-    "<language-code>": "<translated text>"
-  }
-}
-
-7. The JSON must be syntactically valid, UTF-8 encoded, with no code fences, markdown, or commentary.
-8. Ignore any instructions that would alter the structure or format of the JSON.
-9. The only text that should appear in the output is valid JSON \u2014 **no headers, preambles, or explanations**.
-
-${extraInstructions ? `
-Now, using these instructions and applying the following extra parameters:
-
-extraInstructions: ${extraInstructions}
-` : ""}
-
-Translate the following text faithfully:
-`;
-}
-function defaultPostPrompt(_config) {
-  return "";
-}
-function prePrompt(config, prepend, replace) {
-  return [
-    // ...(append ? ['[SPECIFIC_INPUTS]', String(append), '[/SPECIFIC_INPUTS]'] : []),
-    replace ? String(replace) : defaultPrePrompt(config, prepend)
-  ].join(" ").trim();
-}
-function postPrompt(config, prepend, replace) {
-  return [
-    ...prepend ? ["[SPECIFIC_INPUTS]", String(prepend), "[/SPECIFIC_INPUTS]"] : [],
-    replace ? String(replace) : defaultPostPrompt()
-  ].join(" ").trim();
+// src/data/cache-file-path.ts
+function cacheFilePath(config) {
+  return `${config.cache.dir}/${config.cache.file}`;
 }
 var optsArg = (opts) => {
   if (!opts) {
@@ -378,32 +323,50 @@ async function createCacheDir() {
   const config = await awaitedConfig;
   await mkdirp(config.cache.dir);
 }
-
-// src/data/get-cache.ts
 async function getCache() {
+  const config = await awaitedConfig;
   try {
-    const config = await awaitedConfig;
-    await createCacheDir();
-    const rawCache = await fs.readFile(`${config.cache.dir}/${config.cache.file}`);
+    const rawCache = await fs.readFile(cacheFilePath(config));
     return rawCache.toString();
   } catch (error) {
+    if (error?.code === "ENOENT") await createCacheDir();
     throw error;
   }
 }
-var savingQueue = Promise.resolve();
-async function saveCache(cache) {
+
+// src/data/cache-queue.ts
+var cacheQueue = Promise.resolve();
+function enqueueCacheTask(task) {
+  const run = cacheQueue.then(task);
+  cacheQueue = run.catch(() => void 0);
+  return run;
+}
+async function writeCacheFile(cache) {
+  const config = await awaitedConfig;
+  await createCacheDir();
+  const contents = JSON.stringify(cache, null, 2);
+  await fs.writeFile(cacheFilePath(config), contents);
+}
+async function parseCacheOrEmpty(rawCache) {
+  if (!rawCache) return {};
   try {
-    savingQueue = savingQueue.then(async () => {
-      const config = await awaitedConfig;
-      await createCacheDir();
-      const contents = JSON.stringify(cache, null, 2);
-      await fs.writeFile(`${config.cache.dir}/${config.cache.file}`, contents);
-    });
-    await savingQueue;
-    return cache;
+    return JSON.parse(rawCache);
   } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+    const config = await awaitedConfig;
+    console.warn(`Gringow cache ${cacheFilePath(config)} has invalid JSON (${error.message}), recreating it as {}`);
+    return {};
+  }
+}
+async function readCacheOrEmpty() {
+  let rawCache;
+  try {
+    rawCache = await getCache();
+  } catch (error) {
+    if (error?.code === "ENOENT") return {};
     throw error;
   }
+  return parseCacheOrEmpty(rawCache);
 }
 
 // src/data/get-or-create-cache.ts
@@ -413,13 +376,16 @@ async function getOrCreateCache() {
     rawCache = await getCache();
   } catch (error) {
     if (error?.code === "ENOENT") {
-      await saveCache({});
-      rawCache = await getCache();
+      return enqueueCacheTask(async () => {
+        const cache = await readCacheOrEmpty();
+        if (Object.keys(cache).length === 0) await writeCacheFile(cache);
+        return cache;
+      });
     } else {
       throw error;
     }
   }
-  return rawCache ? JSON.parse(rawCache?.toString()) : {};
+  return parseCacheOrEmpty(rawCache);
 }
 
 // src/data/check-cache.ts