krims-code-cli 1.5.2__py3-none-any.whl

krims_pip/node_project/src/ai/google.js

@@ -0,0 +1,87 @@
+// ═══════════════════════════════════════════════════════════
+// Krims Code AI CLI — Google Gemini API Provider
+// ═══════════════════════════════════════════════════════════
+
+const BASE_URL = "https://generativelanguage.googleapis.com/v1beta/models";
+const MAX_CONTINUATIONS = 3;
+
+/**
+ * Sends a prompt to the Google Gemini API.
+ * Handles continuation if finishReason is MAX_TOKENS.
+ * @param {string} prompt - The user message
+ * @param {string} systemPrompt - System prompt for the mode
+ * @param {string} apiKey - Google API key
+ * @param {string} [model='gemini-2.5-flash'] - Model name
+ * @returns {Promise<{ text: string, provider: string, model: string }>}
+ */
+export async function callGemini(prompt, systemPrompt, apiKey, model = "gemini-2.5-flash") {
+  let fullText = "";
+  let currentPrompt = prompt;
+  let continuations = 0;
+
+  while (continuations <= MAX_CONTINUATIONS) {
+    const url = `${BASE_URL}/${model}:generateContent?key=${apiKey}`;
+
+    const body = {
+      systemInstruction: {
+        parts: [{ text: systemPrompt }],
+      },
+      contents: [
+        {
+          role: "user",
+          parts: [{ text: currentPrompt }],
+        },
+      ],
+      generationConfig: {
+        temperature: 0.7,
+        maxOutputTokens: 8192,
+      },
+    };
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      throw new Error(
+        `Gemini API error (${response.status}): ${response.statusText}. ${errorBody}`
+      );
+    }
+
+    const data = await response.json();
+
+    // Check for blocked content
+    if (data.promptFeedback?.blockReason) {
+      throw new Error(`Content blocked: ${data.promptFeedback.blockReason}`);
+    }
+
+    const candidate = data.candidates?.[0];
+    if (!candidate) {
+      throw new Error("Gemini API returned no candidates");
+    }
+
+    const chunkText = candidate.content?.parts
+      ?.map((p) => p.text)
+      .filter(Boolean)
+      .join("") || "";
+
+    fullText += chunkText;
+
+    // Check if the response was cut short
+    if (candidate.finishReason === "MAX_TOKENS" && continuations < MAX_CONTINUATIONS) {
+      continuations++;
+      currentPrompt = "Continue your previous response from exactly where you left off.";
+    } else {
+      break;
+    }
+  }
+
+  if (!fullText.trim()) {
+    throw new Error("Gemini API returned empty response");
+  }
+
+  return { text: fullText, provider: "google", model };
+}

krims_pip/node_project/src/ai/providers.js

@@ -0,0 +1,203 @@
+// ═══════════════════════════════════════════════════════════
+// Krims Code AI CLI — Universal Provider Registry
+// Supports ANY OpenAI-compatible API + custom providers
+// ═══════════════════════════════════════════════════════════
+
+/**
+ * Registry of all supported AI providers.
+ * Each provider defines its API format, base URL, default model, and pricing tier.
+ *
+ * Providers with `format: "openai"` use the standard /v1/chat/completions endpoint.
+ * Providers with `format: "custom"` have their own handler in dedicated files.
+ */
+export const PROVIDERS = {
+  // ── Free Tier Providers ─────────────────────────────────
+  groq: {
+    name: "Groq",
+    key: "GROQ_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.groq.com/openai/v1/chat/completions",
+    defaultModel: "llama-3.3-70b-versatile",
+    models: ["llama-3.3-70b-versatile", "llama-3.1-8b-instant", "mixtral-8x7b-32768", "gemma2-9b-it"],
+    tier: "free",
+    description: "Ultra-fast inference on Llama, Mixtral, Gemma (generous free tier)",
+  },
+  together: {
+    name: "Together AI",
+    key: "TOGETHER_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.together.xyz/v1/chat/completions",
+    defaultModel: "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+    models: ["meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo", "mistralai/Mixtral-8x7B-Instruct-v0.1", "Qwen/Qwen2.5-72B-Instruct-Turbo"],
+    tier: "free",
+    description: "Open-source models with free credits on signup",
+  },
+  cerebras: {
+    name: "Cerebras",
+    key: "CEREBRAS_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.cerebras.ai/v1/chat/completions",
+    defaultModel: "llama-3.3-70b",
+    models: ["llama-3.3-70b", "llama-3.1-8b"],
+    tier: "free",
+    description: "Fastest inference engine — free tier available",
+  },
+
+  // ── OpenAI-Compatible Providers ─────────────────────────
+  openai: {
+    name: "OpenAI",
+    key: "OPENAI_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.openai.com/v1/chat/completions",
+    defaultModel: "gpt-4o",
+    models: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-3.5-turbo", "o1-mini", "o3-mini"],
+    tier: "paid",
+    description: "GPT-4o, GPT-4, o1 reasoning models",
+  },
+  mistral: {
+    name: "Mistral AI",
+    key: "MISTRAL_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.mistral.ai/v1/chat/completions",
+    defaultModel: "mistral-large-latest",
+    models: ["mistral-large-latest", "mistral-medium-latest", "mistral-small-latest", "open-mistral-nemo"],
+    tier: "paid",
+    description: "Mistral Large, Medium, and open-weight models",
+  },
+  fireworks: {
+    name: "Fireworks AI",
+    key: "FIREWORKS_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.fireworks.ai/inference/v1/chat/completions",
+    defaultModel: "accounts/fireworks/models/llama-v3p1-70b-instruct",
+    models: ["accounts/fireworks/models/llama-v3p1-70b-instruct", "accounts/fireworks/models/mixtral-8x7b-instruct"],
+    tier: "free",
+    description: "Fast open-source model hosting with free tier",
+  },
+  openrouter: {
+    name: "OpenRouter",
+    key: "OPENROUTER_API_KEY",
+    format: "openai",
+    baseUrl: "https://openrouter.ai/api/v1/chat/completions",
+    defaultModel: "meta-llama/llama-3.1-70b-instruct:free",
+    models: ["meta-llama/llama-3.1-70b-instruct:free", "google/gemini-2.5-flash-preview:free", "mistralai/mistral-7b-instruct:free", "anthropic/claude-sonnet-4", "openai/gpt-4o"],
+    tier: "free+paid",
+    description: "Gateway to 200+ models — many free options available",
+  },
+  deepseek: {
+    name: "DeepSeek",
+    key: "DEEPSEEK_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.deepseek.com/v1/chat/completions",
+    defaultModel: "deepseek-chat",
+    models: ["deepseek-chat", "deepseek-reasoner"],
+    tier: "paid",
+    description: "DeepSeek-V3 and R1 reasoning model",
+  },
+  perplexity: {
+    name: "Perplexity",
+    key: "PERPLEXITY_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.perplexity.ai/chat/completions",
+    defaultModel: "sonar",
+    models: ["sonar", "sonar-pro", "sonar-reasoning"],
+    tier: "paid",
+    description: "Search-augmented AI with real-time web access",
+  },
+
+  // ── Custom Format Providers ─────────────────────────────
+  xai: {
+    name: "xAI Grok",
+    key: "XAI_API_KEY",
+    format: "openai",
+    baseUrl: "https://api.x.ai/v1/chat/completions",
+    defaultModel: "grok-2",
+    models: ["grok-2", "grok-2-mini"],
+    tier: "paid",
+    description: "Grok-2 by xAI — witty, uncensored",
+  },
+  google: {
+    name: "Google Gemini",
+    key: "GOOGLE_API_KEY",
+    format: "custom-google",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta/models",
+    defaultModel: "gemini-2.5-flash",
+    models: ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-2.0-flash", "gemini-1.5-pro"],
+    tier: "free+paid",
+    description: "Gemini 2.5 Flash/Pro — free tier with generous limits",
+  },
+  anthropic: {
+    name: "Anthropic Claude",
+    key: "ANTHROPIC_API_KEY",
+    format: "custom-anthropic",
+    baseUrl: "https://api.anthropic.com/v1/messages",
+    defaultModel: "claude-sonnet-4-20250514",
+    models: ["claude-sonnet-4-20250514", "claude-3-5-haiku-20241022", "claude-3-5-sonnet-20241022"],
+    tier: "paid",
+    description: "Claude Sonnet 4, Haiku — premium reasoning",
+  },
+  cohere: {
+    name: "Cohere",
+    key: "COHERE_API_KEY",
+    format: "custom-cohere",
+    baseUrl: "https://api.cohere.com/v2/chat",
+    defaultModel: "command-r-plus",
+    models: ["command-r-plus", "command-r", "command-light"],
+    tier: "free+paid",
+    description: "Command R+ — free tier for developers",
+  },
+};
+
+/**
+ * Gets a flat list of all provider keys that can be configured.
+ * @returns {string[]}
+ */
+export function getAllConfigKeys() {
+  const keys = new Set();
+  for (const p of Object.values(PROVIDERS)) {
+    keys.add(p.key);
+  }
+  // Also include multi-key support for Google
+  keys.add("GOOGLE_API_KEYS");
+  return [...keys];
+}
+
+/**
+ * Gets a provider by its config key name (e.g., "OPENAI_API_KEY" → openai provider).
+ * @param {string} configKey
+ * @returns {object|null}
+ */
+export function getProviderByKey(configKey) {
+  for (const [id, p] of Object.entries(PROVIDERS)) {
+    if (p.key === configKey) return { id, ...p };
+  }
+  return null;
+}
+
+/**
+ * Gets all providers that have a valid key in the given config.
+ * @param {object} config - Config object with API keys
+ * @returns {Array<{ id: string, provider: object, apiKey: string }>}
+ */
+export function getActiveProviders(config) {
+  const active = [];
+  for (const [id, provider] of Object.entries(PROVIDERS)) {
+    const apiKey = config[provider.key];
+    if (apiKey) {
+      active.push({ id, provider, apiKey });
+    }
+  }
+  return active;
+}
+
+/**
+ * Groups providers by pricing tier for display.
+ * @returns {{ free: object[], paid: object[], mixed: object[] }}
+ */
+export function getProvidersByTier() {
+  const result = { free: [], "free+paid": [], paid: [] };
+  for (const [id, provider] of Object.entries(PROVIDERS)) {
+    result[provider.tier]?.push({ id, ...provider });
+  }
+  return result;
+}

krims_pip/node_project/src/ai/router.js

@@ -0,0 +1,146 @@
+// ═══════════════════════════════════════════════════════════
+// Krims Code AI CLI — Universal AI Router with Failover Mesh
+// Routes through ALL configured providers automatically
+// ═══════════════════════════════════════════════════════════
+
+import { detectMathExpression, solveMath, generateOfflineReply } from "./fallback.js";
+import { PROVIDERS, getActiveProviders } from "./providers.js";
+import {
+  callOpenAICompatible,
+  callGoogleGemini,
+  callAnthropic,
+  callCohere,
+} from "./universal.js";
+import { estimateTokens, recordTokenUsage } from "./tokens.js";
+import { recordLatency } from "./telemetry.js";
+
+/**
+ * Routes a prompt through the universal AI failover mesh.
+ *
+ * Priority Order:
+ * 1. Local math solver (if pure math expression)
+ * 2. All configured providers, in order of priority
+ * 3. Google key rotation (if multiple keys)
+ * 4. Krylo companion fallback (if everything else fails)
+ *
+ * @param {string} prompt - The user prompt
+ * @param {string} systemPrompt - The mode system prompt
+ * @param {object} config - Flat config object with all API keys
+ * @returns {Promise<{ text: string, provider: string, model?: string, node: number, type?: string }>}
+ */
+export async function routePrompt(prompt, systemPrompt, config, onToken, history = []) {
+  // ── Node 0: Local Math Solver ───────────────────────────
+  const mathExpr = detectMathExpression(prompt);
+  if (mathExpr) {
+    const startTime = performance.now();
+    const mathResult = solveMath(mathExpr);
+    if (mathResult) {
+      const latencyMs = performance.now() - startTime;
+      const pTokens = estimateTokens(systemPrompt + prompt);
+      const cTokens = estimateTokens(mathResult.text);
+      const usage = recordTokenUsage("local-math", pTokens, cTokens);
+      recordLatency("local", "math-solver", latencyMs, pTokens, cTokens, true);
+      return { ...mathResult, provider: "local", node: 0, usage };
+    }
+  }
+
+  // ── Gather all active providers ─────────────────────────
+  const active = getActiveProviders(config);
+
+  // Add extra Google keys for rotation
+  const googleExtraKeys = config.GOOGLE_API_KEYS;
+  if (googleExtraKeys) {
+    const extras = googleExtraKeys.split(",").map((k) => k.trim()).filter(Boolean);
+    for (const key of extras) {
+      // Avoid duplicates
+      if (!active.some((a) => a.id === "google" && a.apiKey === key)) {
+        active.push({ id: "google-extra", provider: PROVIDERS.google, apiKey: key });
+      }
+    }
+  }
+
+  // ── No providers configured → Offline ───────────────────
+  if (active.length === 0) {
+    const startTime = performance.now();
+    const offlineReply = generateOfflineReply(prompt);
+    const latencyMs = performance.now() - startTime;
+    const pTokens = estimateTokens(systemPrompt + prompt);
+    const cTokens = estimateTokens(offlineReply.text);
+    const usage = recordTokenUsage("offline-local", pTokens, cTokens);
+    recordLatency("offline-fallback", "local", latencyMs, pTokens, cTokens, true);
+    return { ...offlineReply, provider: "offline-fallback", node: 0, usage };
+  }
+
+  // ── Try each provider in order ──────────────────────────
+  const errors = [];
+  let nodeIndex = 1;
+
+  for (const { id, provider, apiKey } of active) {
+    const startTime = performance.now();
+    try {
+      const model = config[`${id.toUpperCase()}_MODEL`] || provider.defaultModel;
+      let result;
+
+      switch (provider.format) {
+        case "openai":
+          result = await callOpenAICompatible(
+            prompt, systemPrompt, apiKey,
+            provider.baseUrl, model, provider.name,
+            onToken, history
+          );
+          break;
+
+        case "custom-google":
+          result = await callGoogleGemini(prompt, systemPrompt, apiKey, model, onToken, history);
+          break;
+
+        case "custom-anthropic":
+          result = await callAnthropic(prompt, systemPrompt, apiKey, model, onToken, history);
+          break;
+
+        case "custom-cohere":
+          result = await callCohere(prompt, systemPrompt, apiKey, model, onToken, history);
+          break;
+
+        default:
+          // Treat unknown formats as OpenAI-compatible
+          result = await callOpenAICompatible(
+            prompt, systemPrompt, apiKey,
+            provider.baseUrl, model, provider.name,
+            onToken, history
+          );
+      }
+
+      const latencyMs = performance.now() - startTime;
+      const pTokens = estimateTokens(systemPrompt + prompt + history.map(h => h.content).join(""));
+      const cTokens = estimateTokens(result.text);
+      const usage = recordTokenUsage(result.model, pTokens, cTokens);
+
+      recordLatency(provider.name, result.model, latencyMs, pTokens, cTokens, true);
+
+      return { ...result, node: nodeIndex, usage };
+    } catch (err) {
+      const latencyMs = performance.now() - startTime;
+      const pTokens = estimateTokens(systemPrompt + prompt + history.map(h => h.content).join(""));
+      recordLatency(provider.name, "unknown", latencyMs, pTokens, 0, false);
+      errors.push(`[Node ${nodeIndex} ${provider.name}] ${err.message}`);
+      nodeIndex++;
+    }
+  }
+
+  // ── Final Fallback: Offline Fallback ────────────────────
+  const startTimeOffline = performance.now();
+  const offlineReply = generateOfflineReply(prompt, errors);
+  const latencyMsOffline = performance.now() - startTimeOffline;
+  const pTokens = estimateTokens(systemPrompt + prompt + history.map(h => h.content).join(""));
+  const cTokens = estimateTokens(offlineReply.text);
+  const usage = recordTokenUsage("offline-local", pTokens, cTokens);
+  recordLatency("offline-fallback", "local", latencyMsOffline, pTokens, cTokens, true);
+  return {
+    ...offlineReply,
+    provider: "offline-fallback",
+    node: 0,
+    errors,
+    usage,
+  };
+}

krims_pip/node_project/src/ai/search.js

@@ -0,0 +1,94 @@
+import { readdirSync, statSync, readFileSync } from "node:fs";
+import { join, sep, relative } from "node:path";
+
+const IGNORE_DIRS = new Set([
+  ".git",
+  "node_modules",
+  "build",
+  "dist",
+  ".agents",
+  "krims_code_agent_cli.egg-info",
+  "krims_code_cli.egg-info",
+  "temp-test-home",
+  "temp-test-home-updater",
+  "temp-test-home-search"
+]);
+
+const BINARY_EXTS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".ico", ".webp",
+  ".zip", ".tar", ".gz", ".rar", ".7z",
+  ".pdf", ".exe", ".dll", ".so", ".dylib", ".bin",
+  ".mp3", ".mp4", ".wav", ".avi", ".mov",
+  ".woff", ".woff2", ".ttf", ".eot"
+]);
+
+/**
+ * Recursively walks a directory and yields all text files.
+ * @param {string} dir - Directory to scan
+ * @param {string} rootDir - Root directory for ignore matching
+ * @returns {string[]} List of absolute paths
+ */
+export function crawlDirectory(dir, rootDir = dir) {
+  let files = [];
+  let entries = [];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return files;
+  }
+
+  for (const entry of entries) {
+    if (IGNORE_DIRS.has(entry)) continue;
+    const fullPath = join(dir, entry);
+    try {
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        files = files.concat(crawlDirectory(fullPath, rootDir));
+      } else if (stat.isFile()) {
+        if (stat.size > 250 * 1024) continue; // Skip files larger than 250KB
+
+        const dotIdx = entry.lastIndexOf(".");
+        const ext = dotIdx !== -1 ? entry.slice(dotIdx).toLowerCase() : "";
+        if (BINARY_EXTS.has(ext)) continue;
+
+        files.push(fullPath);
+      }
+    } catch {
+      // Ignore stat failures
+    }
+  }
+  return files;
+}
+
+/**
+ * Searches all text files in the workspace for occurrences of query.
+ * @param {string} query - Query string
+ * @param {string} rootDir - The workspace root path
+ * @returns {Array<{ filePath: string, relativePath: string, lineNumber: number, lineContent: string }>}
+ */
+export function workspaceSearch(query, rootDir = process.cwd()) {
+  const files = crawlDirectory(rootDir, rootDir);
+  const results = [];
+  const lowerQuery = query.toLowerCase().trim();
+
+  for (const file of files) {
+    try {
+      const content = readFileSync(file, "utf8");
+      const lines = content.split(/\r?\n/);
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.toLowerCase().includes(lowerQuery)) {
+          results.push({
+            filePath: file,
+            relativePath: relative(rootDir, file),
+            lineNumber: i + 1,
+            lineContent: line.trim()
+          });
+        }
+      }
+    } catch {
+      // Ignore read failures
+    }
+  }
+  return results;
+}

krims_pip/node_project/src/ai/telemetry.js

@@ -0,0 +1,125 @@
+// ═══════════════════════════════════════════════════════════
+// Krims Code AI CLI — Telemetry & Latency Logger
+// Logs request latencies, prompt speeds, and meshes provider logs.
+// ═══════════════════════════════════════════════════════════
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { getSessionTokenStats, getBreakdownByModel } from "./tokens.js";
+import { getActiveProviders, PROVIDERS } from "./providers.js";
+import { listSessions } from "../config.js";
+
+const CONFIG_DIR = join(homedir(), ".krims-code");
+const TELEMETRY_FILE = join(CONFIG_DIR, "telemetry.json");
+
+/**
+ * Loads telemetry logs from disk.
+ * @returns {Array}
+ */
+function loadTelemetryFromDisk() {
+  try {
+    if (existsSync(TELEMETRY_FILE)) {
+      const raw = readFileSync(TELEMETRY_FILE, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+    // ignore
+  }
+  return [];
+}
+
+/**
+ * Saves telemetry logs to disk.
+ * @param {Array} logs
+ */
+function saveTelemetryToDisk(logs) {
+  try {
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(TELEMETRY_FILE, JSON.stringify(logs, null, 2), "utf-8");
+  } catch {
+    // ignore
+  }
+}
+
+const latencyLogs = loadTelemetryFromDisk();
+
+/**
+ * Records telemetry metrics for an AI call.
+ * @param {string} provider - The provider name
+ * @param {string} model - The model name
+ * @param {number} latencyMs - The request latency in ms
+ * @param {number} promptTokens - Prompt token count
+ * @param {number} completionTokens - Completion token count
+ * @param {boolean} success - Whether the call succeeded
+ */
+export function recordLatency(provider, model, latencyMs, promptTokens, completionTokens, success) {
+  latencyLogs.push({
+    timestamp: new Date().toISOString(),
+    provider: provider || "unknown",
+    model: model || "unknown",
+    latencyMs: Math.round(latencyMs),
+    promptTokens: promptTokens || 0,
+    completionTokens: completionTokens || 0,
+    success: !!success,
+  });
+
+  // Limit to last 100 entries for historical visualization
+  if (latencyLogs.length > 100) {
+    latencyLogs.shift();
+  }
+
+  saveTelemetryToDisk(latencyLogs);
+}
+
+/**
+ * Returns raw latency records.
+ * @returns {Array}
+ */
+export function getLatencyLogs() {
+  return latencyLogs;
+}
+
+/**
+ * Clears all telemetry logs.
+ */
+export function clearTelemetryLogs() {
+  latencyLogs.length = 0;
+  try {
+    if (existsSync(TELEMETRY_FILE)) {
+      unlinkSync(TELEMETRY_FILE);
+    }
+  } catch {
+    // ignore
+  }
+}
+
+/**
+ * Gathers all metrics needed for the web dashboard visualization.
+ * @param {object} config - krims-code configuration object
+ * @returns {object}
+ */
+export function getTelemetryData(config = {}) {
+  // Map active status for all providers in our registry
+  const mesh = Object.entries(PROVIDERS).map(([id, provider]) => {
+    const isConfigured = !!config[provider.key];
+    return {
+      id,
+      name: provider.name,
+      configured: isConfigured,
+      defaultModel: provider.defaultModel,
+      tier: provider.tier,
+      description: provider.description,
+    };
+  });
+
+  return {
+    tokenStats: getSessionTokenStats(),
+    modelBreakdown: getBreakdownByModel(),
+    latencyLogs: [...latencyLogs],
+    meshStructure: mesh,
+    sessions: listSessions(),
+  };
+}