jerob 1.0.0

package/tui/spinup.ts

@@ -0,0 +1,67 @@
+import { select, isCancel } from "@clack/prompts";
+import chalk from "chalk";
+import figlet from "figlet";
+import { runCLIMode } from "../CLI/cli";
+import { runTelegramMode } from "../Telegram";
+
+const HF = "ANSI Shadow";
+const SHADOW = chalk.hex("#5941de");
+const FACE = chalk.hex("#eeeffff").bold;
+
+function printBannerWithShadow(ascii: string) {
+  const bannerLines = ascii.replace(/\s+$/, "").split("\n");
+  const maxLen = Math.max(...bannerLines.map((l) => l.length), 0);
+  const rowWidth = maxLen + 2;
+
+  for (const line of bannerLines) {
+    console.log(SHADOW(("  " + line).padEnd(rowWidth)));
+  }
+  process.stdout.write(`\x1b[${bannerLines.length}A`);
+  for (const line of bannerLines) {
+    console.log(FACE(line.padEnd(rowWidth)));
+  }
+  console.log();
+}
+
+export const startArena = async () => {
+  let ascii: string;
+
+  try {
+    ascii = figlet.textSync("Jerob", { font: HF });
+  } catch (e) {
+    ascii = figlet.textSync("Jerob", { font: "Standard" });
+  }
+
+  printBannerWithShadow(ascii);
+
+  while (true) {
+    const option = await select({
+      message: chalk.green("choose way to communicate"),
+      options: [
+        { value: "CLI", label: "CLI" },
+        { value: "Telegram", label: "Telegram" },
+        { value: "Exit", label: "Exit" },
+      ],
+    });
+
+    if (isCancel(option) || option == "Exit") {
+      console.log(chalk.green.bold("Goodbye !!!"));
+      return "END";
+    }
+    if (option == "CLI") {
+      try {
+        await runCLIMode();
+      } catch (err) {
+        console.log(chalk.red(`\n✖ CLI error: ${err instanceof Error ? err.message : String(err)}\n`));
+      }
+      continue;
+    } else if (option == "Telegram") {
+      try {
+        await runTelegramMode();
+      } catch (err) {
+        console.log(chalk.red(`\n✖ Telegram error: ${err instanceof Error ? err.message : String(err)}\n`));
+      }
+      continue;
+    }
+  }
+};

package/tui/terminal-render.ts

@@ -0,0 +1,16 @@
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+
+let ready=false;
+
+function ensureMarked():void{
+    if(ready) return;
+    const w=Math.max(40,Math.min(process.stdout.columns || 80,120));
+    // @ts-ignore
+    marked.use(markedTerminal({width:w,reflowText: true},{}));
+    ready=true;
+}
+export const renderHTMLMarkdown=(content:string): string=>{
+    ensureMarked()
+    return marked.parse(content.trimEnd(),{async:false}) as string
+}

package/utils/llm-error.ts

@@ -0,0 +1,185 @@
+import chalk from "chalk";
+
+export interface LLMError {
+  type: "rate_limit" | "quota" | "auth" | "network" | "refusal" | "timeout" | "unknown";
+  message: string;
+  retryable: boolean;
+  retryAfterMs?: number;
+}
+
+/**
+ * Parse any LLM/API error into a structured, user-friendly form.
+ */
+export function parseLLMError(err: unknown): LLMError {
+  const raw = err instanceof Error ? err.message : String(err);
+  // Log the raw provider error so we can see exactly what the API returned
+  console.error(chalk.dim(`[LLM raw error] ${raw}`));
+  const lower = raw.toLowerCase();
+
+  // Rate limit / quota
+  if (
+    lower.includes("rate limit") ||
+    lower.includes("ratelimit") ||
+    lower.includes("rate_limit") ||
+    lower.includes("429") ||
+    lower.includes("too many requests")
+  ) {
+    // Try to extract retry-after seconds from message
+    const retryMatch = raw.match(/retry after (\d+)/i) || raw.match(/(\d+)\s*second/i);
+    const retryAfterMs = retryMatch ? parseInt(retryMatch[1]!) * 1000 : 10_000;
+    return {
+      type: "rate_limit",
+      message: "Rate limit reached. The model is temporarily throttled.",
+      retryable: true,
+      retryAfterMs,
+    };
+  }
+
+  // Quota exceeded
+  if (
+    lower.includes("quota") ||
+    lower.includes("insufficient_quota") ||
+    lower.includes("billing") ||
+    lower.includes("credits") ||
+    lower.includes("402")
+  ) {
+    return {
+      type: "quota",
+      message: "API quota or credits exhausted. Check your billing at openrouter.ai or groq.com.",
+      retryable: false,
+    };
+  }
+
+  // Auth
+  if (
+    lower.includes("401") ||
+    lower.includes("403") ||
+    lower.includes("unauthorized") ||
+    lower.includes("invalid api key") ||
+    lower.includes("invalid_api_key") ||
+    lower.includes("authentication")
+  ) {
+    return {
+      type: "auth",
+      message: "Invalid or missing API key. Run `jimmy set-key` to update it.",
+      retryable: false,
+    };
+  }
+
+  // Timeout / network
+  if (
+    lower.includes("timeout") ||
+    lower.includes("timed out") ||
+    lower.includes("econnrefused") ||
+    lower.includes("enotfound") ||
+    lower.includes("network") ||
+    lower.includes("fetch failed") ||
+    lower.includes("504") ||
+    lower.includes("503") ||
+    lower.includes("502")
+  ) {
+    return {
+      type: "timeout",
+      message: "Network or server timeout. Check your internet connection and try again.",
+      retryable: true,
+      retryAfterMs: 3_000,
+    };
+  }
+
+  // Model refusal / content policy
+  if (
+    lower.includes("content policy") ||
+    lower.includes("safety") ||
+    lower.includes("i'm sorry") ||
+    lower.includes("i cannot") ||
+    lower.includes("i can't help") ||
+    lower.includes("cannot assist")
+  ) {
+    return {
+      type: "refusal",
+      message: "The model refused this request due to content policy. Try rephrasing your prompt.",
+      retryable: false,
+    };
+  }
+
+  return {
+    type: "unknown",
+    message: raw.slice(0, 300),
+    retryable: false,
+  };
+}
+
+/**
+ * Print a formatted, user-friendly LLM error to the console.
+ */
+export function printLLMError(err: unknown, context?: string): void {
+  const parsed = parseLLMError(err);
+
+  const prefix = context ? chalk.dim(`[${context}] `) : "";
+
+  switch (parsed.type) {
+    case "rate_limit":
+      console.log(chalk.yellow(`\n${prefix}⏱  Rate limited — ${parsed.message}`));
+      if (parsed.retryAfterMs) {
+        console.log(chalk.dim(`   Retry in ~${Math.ceil(parsed.retryAfterMs / 1000)}s`));
+      }
+      break;
+    case "quota":
+      console.log(chalk.red(`\n${prefix}💳 Quota exceeded — ${parsed.message}`));
+      break;
+    case "auth":
+      console.log(chalk.red(`\n${prefix}🔑 Auth error — ${parsed.message}`));
+      break;
+    case "timeout":
+      console.log(chalk.yellow(`\n${prefix}🌐 Network error — ${parsed.message}`));
+      break;
+    case "refusal":
+      console.log(chalk.yellow(`\n${prefix}🚫 Model refusal — ${parsed.message}`));
+      break;
+    default:
+      console.log(chalk.red(`\n${prefix}❌ LLM error — ${parsed.message}`));
+  }
+}
+
+/**
+ * Retry an LLM operation with exponential backoff.
+ * Stops immediately on non-retryable errors (auth, quota, refusal).
+ */
+export async function withLLMRetry<T>(
+  operation: () => Promise<T>,
+  options: {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    context?: string;
+  } = {}
+): Promise<T> {
+  const { maxRetries = 3, baseDelayMs = 1_500, context } = options;
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await operation();
+    } catch (err) {
+      lastError = err;
+      const parsed = parseLLMError(err);
+
+      if (!parsed.retryable) {
+        printLLMError(err, context);
+        throw err;
+      }
+
+      if (attempt === maxRetries) break;
+
+      const delay = parsed.retryAfterMs ?? baseDelayMs * Math.pow(2, attempt);
+      console.log(
+        chalk.dim(
+          `  ${context ? `[${context}] ` : ""}Retrying in ${Math.ceil(delay / 1000)}s (attempt ${attempt + 1}/${maxRetries})…`
+        )
+      );
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+
+  printLLMError(lastError, context);
+  throw lastError;
+}

package/utils/model-validator.ts

@@ -0,0 +1,247 @@
+/**
+ * Model ID validation for all supported providers.
+ *
+ * Strategy:
+ * - Each provider has a curated list of known-valid models.
+ * - If the input matches a known model → valid.
+ * - If the input passes the provider's format rules → warn but allow (future models).
+ * - If neither → error with suggestions.
+ *
+ * No live API calls are made — this is intentional to keep setup fast and offline-capable.
+ */
+
+export type Provider = "openrouter" | "gemini" | "claude" | "openai" | "groq";
+
+// ── Known valid models per provider ──────────────────────────────────────────
+
+export const KNOWN_MODELS: Record<Provider, string[]> = {
+  openrouter: [
+    // Anthropic via OpenRouter
+    "anthropic/claude-3.5-sonnet",
+    "anthropic/claude-3.5-haiku",
+    "anthropic/claude-3-opus",
+    "anthropic/claude-3-haiku",
+    // OpenAI via OpenRouter
+    "openai/gpt-4o",
+    "openai/gpt-4o-mini",
+    "openai/gpt-4-turbo",
+    "openai/o1-preview",
+    "openai/o1-mini",
+    // Google via OpenRouter
+    "google/gemini-pro-1.5",
+    "google/gemini-flash-1.5",
+    "google/gemini-2.0-flash-exp:free",
+    // Meta via OpenRouter
+    "meta-llama/llama-3.1-8b-instruct:free",
+    "meta-llama/llama-3.1-70b-instruct",
+    "meta-llama/llama-3.3-70b-instruct",
+    // Mistral via OpenRouter
+    "mistralai/mistral-7b-instruct:free",
+    "mistralai/mistral-large",
+    "mistralai/mixtral-8x7b-instruct",
+    // Qwen
+    "qwen/qwen-2.5-72b-instruct",
+    "qwen/qwen-2.5-7b-instruct:free",
+    // Free routing
+    "openrouter/free",
+  ],
+
+  gemini: [
+    "gemini-2.0-flash",
+    "gemini-2.0-flash-exp",
+    "gemini-1.5-pro",
+    "gemini-1.5-flash",
+    "gemini-1.5-flash-8b",
+    "gemini-1.0-pro",
+    "gemini-pro",
+    "gemini-3.1-flash-lite-preview",
+    "gemini-2.0-flash-thinking-exp",
+  ],
+
+  claude: [
+    "claude-3-5-sonnet-20241022",
+    "claude-3-5-haiku-20241022",
+    "claude-3-opus-20240229",
+    "claude-3-sonnet-20240229",
+    "claude-3-haiku-20240307",
+    "claude-2.1",
+    "claude-instant-1.2",
+  ],
+
+  openai: [
+    "gpt-4o",
+    "gpt-4o-mini",
+    "gpt-4-turbo",
+    "gpt-4-turbo-preview",
+    "gpt-4",
+    "gpt-3.5-turbo",
+    "gpt-3.5-turbo-16k",
+    "o1-preview",
+    "o1-mini",
+    "o3-mini",
+  ],
+
+  groq: [
+    "llama-3.3-70b-versatile",
+    "llama-3.1-8b-instant",
+    "llama-3.1-70b-versatile",
+    "llama3-8b-8192",
+    "llama3-70b-8192",
+    "mixtral-8x7b-32768",
+    "gemma2-9b-it",
+    "gemma-7b-it",
+    "whisper-large-v3",
+  ],
+};
+
+// ── Format rules per provider ─────────────────────────────────────────────────
+
+const FORMAT_RULES: Record<Provider, { pattern: RegExp; hint: string }> = {
+  openrouter: {
+    pattern: /^[a-z0-9_-]+\/[a-z0-9._:-]+$/i,
+    hint:    "Must be in format provider/model-name (e.g. openai/gpt-4o, meta-llama/llama-3.1-8b-instruct:free)",
+  },
+  gemini: {
+    pattern: /^gemini[-\w.]+$/i,
+    hint:    "Must start with 'gemini' (e.g. gemini-2.0-flash, gemini-1.5-pro)",
+  },
+  claude: {
+    pattern: /^claude[-\w.]+$/i,
+    hint:    "Must start with 'claude' (e.g. claude-3-5-sonnet-20241022)",
+  },
+  openai: {
+    pattern: /^(gpt|o[0-9])[-\w.]+$/i,
+    hint:    "Must start with 'gpt-' or 'o1/'o3' (e.g. gpt-4o, o1-mini)",
+  },
+  groq: {
+    pattern: /^[a-z0-9][-\w.]+$/i,
+    hint:    "e.g. llama-3.3-70b-versatile, mixtral-8x7b-32768",
+  },
+};
+
+// ── Public validator ──────────────────────────────────────────────────────────
+
+export interface ValidationResult {
+  valid: boolean;
+  error?: string;     // hard error — don't allow
+  warning?: string;   // soft warning — allow but inform
+  suggestions?: string[]; // closest known models
+}
+
+/**
+ * Validates a model ID for a given provider.
+ * Returns { valid: true } if known, { valid: true, warning } if format-valid but unknown,
+ * { valid: false, error } if format is wrong.
+ */
+export function validateModel(provider: Provider, modelId: string): ValidationResult {
+  const s = modelId.trim();
+
+  if (!s) {
+    return { valid: false, error: "Model ID cannot be empty" };
+  }
+
+  if (s.length > 150) {
+    return { valid: false, error: "Model ID is too long (max 150 characters)" };
+  }
+
+  // Check known list first
+  const known = KNOWN_MODELS[provider];
+  if (known.includes(s)) {
+    return { valid: true };
+  }
+
+  // Check format
+  const rule = FORMAT_RULES[provider];
+  if (!rule.pattern.test(s)) {
+    const suggestions = closestMatches(s, known);
+    return {
+      valid: false,
+      error: `Invalid format for ${provider}. ${rule.hint}`,
+      suggestions,
+    };
+  }
+
+  // Format valid but not in known list — allow with warning
+  const suggestions = closestMatches(s, known);
+  return {
+    valid: true,
+    warning: `"${s}" is not in the known model list for ${provider}. It may work if it's a new model.`,
+    suggestions,
+  };
+}
+
+/** Find up to 3 closest known models by string similarity */
+function closestMatches(input: string, known: string[]): string[] {
+  const lower = input.toLowerCase();
+  return known
+    .map((k) => ({ k, score: similarity(lower, k.toLowerCase()) }))
+    .sort((a, b) => b.score - a.score)
+    .slice(0, 3)
+    .filter((x) => x.score > 0.2)
+    .map((x) => x.k);
+}
+
+/** Simple bigram similarity (Sørensen–Dice coefficient) */
+function similarity(a: string, b: string): number {
+  if (a === b) return 1;
+  if (a.length < 2 || b.length < 2) return 0;
+
+  const bigrams = (s: string) => {
+    const set = new Map<string, number>();
+    for (let i = 0; i < s.length - 1; i++) {
+      const bg = s.slice(i, i + 2);
+      set.set(bg, (set.get(bg) ?? 0) + 1);
+    }
+    return set;
+  };
+
+  const aGrams = bigrams(a);
+  const bGrams = bigrams(b);
+  let intersection = 0;
+
+  for (const [bg, count] of aGrams) {
+    const bCount = bGrams.get(bg) ?? 0;
+    intersection += Math.min(count, bCount);
+  }
+
+  return (2 * intersection) / (a.length - 1 + (b.length - 1));
+}
+
+/**
+ * Returns a validate function compatible with @clack/prompts `text.validate`.
+ * Shows hard errors, shows warnings inline, allows the user to proceed.
+ */
+export function clackModelValidator(
+  provider: Provider
+): (value: string | undefined) => string | undefined {
+  return (value) => {
+    const v = value?.trim() ?? "";
+    if (!v) return "Model ID required";
+    const result = validateModel(provider, v);
+    if (!result.valid) {
+      const base = result.error!;
+      const hint = result.suggestions?.length
+        ? `\n  Did you mean: ${result.suggestions.join(", ")}?`
+        : "";
+      return base + hint;
+    }
+    // warnings are shown after the prompt, not as validation errors
+    return undefined;
+  };
+}
+
+/**
+ * Print a validation warning to the console (called after text() resolves).
+ */
+export function printModelWarning(provider: Provider, modelId: string): void {
+  const result = validateModel(provider, modelId.trim());
+  if (result.warning) {
+    console.log(chalk.yellow(`  ⚠  ${result.warning}`));
+    if (result.suggestions?.length) {
+      console.log(chalk.dim(`     Known models: ${result.suggestions.join(", ")}`));
+    }
+  }
+}
+
+// chalk is used only in printModelWarning — import it here to avoid circular deps
+import chalk from "chalk";