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

krims_pip/node_project/src/config.js

@@ -0,0 +1,400 @@
+// ═══════════════════════════════════════════════════════════
+// Krims Code AI CLI — Secure Configuration Management
+// Stores user API keys locally at ~/.krims-code/config.json
+// Supports ALL AI providers (13+ and growing)
+// ═══════════════════════════════════════════════════════════
+
+import { readFile, writeFile, mkdir, unlink, access } from "node:fs/promises";
+import {
+  existsSync,
+  readdirSync,
+  statSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync
+} from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { getAllConfigKeys } from "./ai/providers.js";
+
+const CONFIG_DIR = existsSync(join(homedir(), ".krims"))
+  ? join(homedir(), ".krims")
+  : (existsSync(join(homedir(), ".krims-code"))
+    ? join(homedir(), ".krims-code")
+    : join(homedir(), ".krims"));
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+const SENSITIVE_PATTERNS = ["KEY", "TOKEN", "SECRET"];
+
+/**
+ * Returns the full path to the config file.
+ * @returns {string}
+ */
+export function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+/**
+ * Loads the config from disk.
+ * @returns {Promise<object>} Parsed config or empty object
+ */
+export async function loadConfig() {
+  try {
+    const raw = await readFile(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Saves config to disk, creating the directory if needed.
+ * @param {object} config - The config object to write
+ */
+export async function saveConfig(config) {
+  try {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+  } catch (err) {
+    throw new Error(`Failed to save config: ${err.message}`);
+  }
+}
+
+/**
+ * Gets a single config value.
+ * @param {string} key
+ * @returns {Promise<string|undefined>}
+ */
+export async function getConfigValue(key) {
+  const config = await loadConfig();
+  return config[key];
+}
+
+/**
+ * Sets a single config value.
+ * @param {string} key
+ * @param {string} value
+ */
+export async function setConfigValue(key, value) {
+  const config = await loadConfig();
+  config[key] = value;
+  await saveConfig(config);
+}
+
+/**
+ * Deletes a single config key.
+ * @param {string} key
+ */
+export async function deleteConfigValue(key) {
+  const config = await loadConfig();
+  delete config[key];
+  await saveConfig(config);
+}
+
+/**
+ * Deletes the entire config file.
+ */
+export async function resetConfig() {
+  try {
+    await unlink(CONFIG_FILE);
+  } catch {
+    // File may not exist
+  }
+}
+
+/**
+ * Lists all config keys with sensitive values masked.
+ * @returns {Promise<object>} Config with sensitive values masked
+ */
+export async function listConfig() {
+  const config = await loadConfig();
+  const masked = {};
+
+  for (const [key, value] of Object.entries(config)) {
+    const isSensitive = SENSITIVE_PATTERNS.some((p) => key.toUpperCase().includes(p));
+    if (isSensitive && typeof value === "string" && value.length > 8) {
+      masked[key] = value.slice(0, 6) + "•••" + value.slice(-3);
+    } else {
+      masked[key] = value;
+    }
+  }
+
+  return masked;
+}
+
+/**
+ * Returns the full flat config object for the AI router.
+ * Merges the config file with environment variables (config file takes precedence).
+ * @returns {Promise<object>}
+ */
+export async function getAIConfig() {
+  const config = await loadConfig();
+  const allKeys = getAllConfigKeys();
+
+  // Merge: config file values override env vars
+  const merged = {};
+  for (const key of allKeys) {
+    merged[key] = config[key] || process.env[key] || "";
+  }
+
+  // Also pass through any custom model overrides and extra keys
+  for (const [key, value] of Object.entries(config)) {
+    if (!merged[key]) {
+      merged[key] = value;
+    }
+  }
+
+  // Check env vars for anything the config didn't have
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.endsWith("_API_KEY") && !merged[key]) {
+      merged[key] = value;
+    }
+  }
+
+  return merged;
+}
+
+/**
+ * Checks if the config file exists.
+ * @returns {Promise<boolean>}
+ */
+export async function configExists() {
+  try {
+    await access(CONFIG_FILE);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Checks if the given key is a valid/recognized config key.
+ * Accepts any *_API_KEY, *_MODEL, and known keys.
+ * @param {string} key
+ * @returns {boolean}
+ */
+export function isValidConfigKey(key) {
+  const upper = key.toUpperCase();
+  // Accept any API key or model override
+  const allowedSpecialKeys = [
+    "THEME", "CUSTOM_COMMANDS", "AUTOPILOT", 
+    "AUTO_UPDATE", "SHOW_HIGHLIGHTS", "LAST_UPDATE_CHECK", "LAST_NOTIFIED_VERSION",
+    "SHOW_TOKENS", "DIAGNOSE_CMD", "NERD_FONTS"
+  ];
+  if (upper.endsWith("_API_KEY") || upper.endsWith("_API_KEYS") || upper.endsWith("_MODEL") || allowedSpecialKeys.includes(upper)) {
+    return true;
+  }
+  // Accept known config keys
+  const knownKeys = getAllConfigKeys();
+  return knownKeys.includes(upper);
+}
+
+const HISTORY_DIR = join(CONFIG_DIR, "history");
+const LEGACY_HISTORY_FILE = join(CONFIG_DIR, "history.json");
+
+let currentSessionFile = null;
+
+/**
+ * Gets the current active session file path, initializing it if necessary.
+ * @returns {string}
+ */
+export function getSessionFile() {
+  if (currentSessionFile) {
+    return currentSessionFile;
+  }
+
+  try {
+    if (!existsSync(HISTORY_DIR)) {
+      mkdirSync(HISTORY_DIR, { recursive: true });
+    }
+
+    const files = readdirSync(HISTORY_DIR).filter(
+      (f) => f.startsWith("session_") && f.endsWith(".json")
+    );
+
+    if (files.length > 0) {
+      // Sort files descending by modification time
+      files.sort((a, b) => {
+        return statSync(join(HISTORY_DIR, b)).mtimeMs - statSync(join(HISTORY_DIR, a)).mtimeMs;
+      });
+      currentSessionFile = join(HISTORY_DIR, files[0]);
+    } else {
+      // If legacy history file exists, migrate it
+      if (existsSync(LEGACY_HISTORY_FILE)) {
+        const timestamp = statSync(LEGACY_HISTORY_FILE).mtimeMs || Date.now();
+        currentSessionFile = join(HISTORY_DIR, `session_${timestamp}.json`);
+        try {
+          const raw = readFileSync(LEGACY_HISTORY_FILE, "utf-8");
+          const legacyData = JSON.parse(raw);
+          const sessionData = {
+            mode: "titan",
+            timestamp,
+            messages: Array.isArray(legacyData) ? legacyData : (legacyData.messages || []),
+          };
+          writeFileSync(currentSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+          try {
+            unlinkSync(LEGACY_HISTORY_FILE);
+          } catch {
+            // ignore unlink error
+          }
+        } catch {
+          // ignore parsing error, start new
+          startNewSession();
+        }
+      } else {
+        startNewSession();
+      }
+    }
+  } catch {
+    startNewSession();
+  }
+
+  return currentSessionFile;
+}
+
+/**
+ * Starts a new chat session.
+ * @returns {string} Path to the new session file
+ */
+export function startNewSession() {
+  const timestamp = Date.now();
+  currentSessionFile = join(HISTORY_DIR, `session_${timestamp}.json`);
+  try {
+    if (!existsSync(HISTORY_DIR)) {
+      mkdirSync(HISTORY_DIR, { recursive: true });
+    }
+    const sessionData = {
+      mode: "titan",
+      timestamp,
+      messages: [],
+    };
+    writeFileSync(currentSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+  } catch {
+    // Fail silently
+  }
+  return currentSessionFile;
+}
+
+/**
+ * Lists all session logs.
+ * @returns {Array} List of sessions with metadata
+ */
+export function listSessions() {
+  try {
+    if (!existsSync(HISTORY_DIR)) {
+      mkdirSync(HISTORY_DIR, { recursive: true });
+    }
+    const files = readdirSync(HISTORY_DIR).filter(
+      (f) => f.startsWith("session_") && f.endsWith(".json")
+    );
+    const sessions = [];
+
+    for (const file of files) {
+      const fullPath = join(HISTORY_DIR, file);
+      try {
+        const raw = readFileSync(fullPath, "utf-8");
+        const data = JSON.parse(raw);
+        const messages = Array.isArray(data) ? data : (data.messages || []);
+        const mode = Array.isArray(data) ? "titan" : (data.mode || "titan");
+        const timestamp = Array.isArray(data)
+          ? (statSync(fullPath).mtimeMs || Date.now())
+          : (data.timestamp || statSync(fullPath).mtimeMs || Date.now());
+
+        sessions.push({
+          file: fullPath,
+          filename: file,
+          timestamp,
+          mode,
+          messages,
+        });
+      } catch {
+        // ignore corrupt files
+      }
+    }
+
+    sessions.sort((a, b) => b.timestamp - a.timestamp);
+    return sessions;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Switches the active session file.
+ * @param {string} sessionFile
+ */
+export function switchSession(sessionFile) {
+  currentSessionFile = sessionFile;
+}
+
+/**
+ * Loads chat history from disk.
+ * @returns {Promise<Array>} List of chat exchanges
+ */
+export async function loadHistory() {
+  try {
+    const file = getSessionFile();
+    const raw = readFileSync(file, "utf-8");
+    const data = JSON.parse(raw);
+    return Array.isArray(data) ? data : (data.messages || []);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Saves chat history to disk.
+ * @param {Array} history - List of chat exchanges to save
+ * @param {string} [mode] - Current mode name
+ */
+export async function saveHistory(history, mode) {
+  try {
+    const file = getSessionFile();
+    let timestamp = Date.now();
+    const match = file.match(/session_(\d+)\.json$/);
+    if (match) {
+      timestamp = parseInt(match[1], 10);
+    }
+    const trimmed = history.slice(-50);
+    
+    let finalMode = mode;
+    if (!finalMode) {
+      try {
+        const raw = readFileSync(file, "utf-8");
+        const data = JSON.parse(raw);
+        if (!Array.isArray(data)) {
+          finalMode = data.mode;
+        }
+      } catch {
+        // file might not exist yet
+      }
+    }
+    if (!finalMode) {
+      finalMode = "titan";
+    }
+
+    const sessionData = {
+      mode: finalMode,
+      timestamp,
+      messages: trimmed,
+    };
+
+    writeFileSync(file, JSON.stringify(sessionData, null, 2), "utf-8");
+  } catch {
+    // Fail silently to not block chat
+  }
+}
+
+/**
+ * Deletes the current chat history file.
+ */
+export async function clearHistory() {
+  try {
+    const file = getSessionFile();
+    unlinkSync(file);
+    currentSessionFile = null;
+  } catch {
+    // File may not exist
+  }
+}

krims_pip/node_project/src/dashboard.js

@@ -0,0 +1,112 @@
+// ═══════════════════════════════════════════════════════════
+// Krims Code AI CLI — Cyberpunk Web Telemetry Dashboard Server
+// Lightweight server using node:http to host dashboard diagnostics
+// ═══════════════════════════════════════════════════════════
+
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { getTelemetryData } from "./ai/telemetry.js";
+import { getAIConfig } from "./config.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let server = null;
+let currentPort = 4567;
+
+/**
+ * Starts the telemetry HTTP server.
+ * If the preferred port is occupied, automatically increments and tries the next port.
+ * @param {number} preferredPort
+ * @returns {Promise<{ port: number, server: http.Server }>}
+ */
+export async function startDashboardServer(preferredPort = 4567) {
+  return new Promise((resolve, reject) => {
+    let port = preferredPort;
+
+    function attemptListen() {
+      server = http.createServer(async (req, res) => {
+        const url = new URL(req.url, `http://${req.headers.host}`);
+
+        // CORS headers
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+        if (req.method === "OPTIONS") {
+          res.writeHead(200);
+          res.end();
+          return;
+        }
+
+        // Serve HTML dashboard
+        if (url.pathname === "/" || url.pathname === "/index.html") {
+          try {
+            const htmlPath = path.join(__dirname, "ui", "dashboard.html");
+            const html = fs.readFileSync(htmlPath, "utf8");
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(html);
+          } catch (err) {
+            res.writeHead(500, { "Content-Type": "text/plain" });
+            res.end("Error loading telemetry dashboard UI: " + err.message);
+          }
+          return;
+        }
+
+        // API Endpoint: /api/telemetry
+        if (url.pathname === "/api/telemetry") {
+          try {
+            const config = await getAIConfig();
+            const data = getTelemetryData(config);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(data));
+          } catch (err) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: err.message }));
+          }
+          return;
+        }
+
+        // Default 404
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+      });
+
+      server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          port++;
+          attemptListen();
+        } else {
+          reject(err);
+        }
+      });
+
+      server.listen(port, () => {
+        currentPort = port;
+        resolve({ port, server });
+      });
+    }
+
+    attemptListen();
+  });
+}
+
+/**
+ * Stops the dashboard server if active.
+ */
+export function stopDashboardServer() {
+  if (server) {
+    server.close();
+    server = null;
+  }
+}
+
+/**
+ * Gets the active port.
+ * @returns {number}
+ */
+export function getDashboardPort() {
+  return currentPort;
+}

krims_pip/node_project/src/file-parser.js

@@ -0,0 +1,164 @@
+// ═══════════════════════════════════════════════════════════
+// Krims Code AI CLI — File Parser & Context Injector
+// ═══════════════════════════════════════════════════════════
+
+import { readFile, stat } from "node:fs/promises";
+import { readdirSync, statSync } from "node:fs";
+import { resolve, extname, basename, join, relative } from "node:path";
+
+const MAX_CONTENT_LENGTH = 30000;
+
+const SUPPORTED_EXTENSIONS = new Set([
+  ".txt", ".md", ".json", ".csv", ".js", ".jsx", ".ts", ".tsx",
+  ".html", ".css", ".py", ".log", ".yaml", ".yml", ".xml",
+  ".toml", ".env", ".sh", ".bat", ".ps1", ".sql", ".rs",
+  ".go", ".java", ".c", ".cpp", ".h", ".rb", ".php",
+  ".swift", ".kt", ".dart", ".vue", ".svelte",
+]);
+
+/**
+ * Reads and parses a file for context injection.
+ * @param {string} filePath - Path to the file (absolute or relative)
+ * @returns {Promise<{ name: string, content: string, size: number, extension: string }>}
+ */
+export async function parseFile(filePath) {
+  let lineRange = null;
+  let cleanFilePath = filePath;
+
+  // Match ending with :start-end or :line (e.g. :10-50 or :100)
+  const match = filePath.match(/:(\d+)(?:-(\d+))?$/);
+  if (match) {
+    cleanFilePath = filePath.slice(0, match.index);
+    const start = parseInt(match[1], 10);
+    const end = match[2] ? parseInt(match[2], 10) : start;
+    lineRange = { start, end };
+  }
+
+  const resolved = resolve(cleanFilePath);
+  const ext = extname(resolved).toLowerCase();
+  let name = basename(resolved);
+
+  // Validate extension
+  if (!SUPPORTED_EXTENSIONS.has(ext)) {
+    const supported = [...SUPPORTED_EXTENSIONS].join(", ");
+    throw new Error(
+      `Unsupported file type: "${ext}"\nSupported types: ${supported}`
+    );
+  }
+
+  // Check file exists and get size
+  let fileStats;
+  try {
+    fileStats = await stat(resolved);
+  } catch {
+    throw new Error(`File not found: ${resolved}`);
+  }
+
+  if (!fileStats.isFile()) {
+    throw new Error(`Not a file: ${resolved}`);
+  }
+
+  // Read file content
+  let content;
+  try {
+    content = await readFile(resolved, "utf-8");
+  } catch (err) {
+    throw new Error(`Cannot read file: ${err.message}`);
+  }
+
+  let finalSize = fileStats.size;
+
+  if (lineRange) {
+    const lines = content.split(/\r?\n/);
+    const startIdx = Math.max(0, lineRange.start - 1);
+    const endIdx = Math.min(lines.length, lineRange.end);
+    content = lines.slice(startIdx, endIdx).join("\n");
+    name += `:${lineRange.start}-${lineRange.end}`;
+    finalSize = Buffer.byteLength(content, "utf-8");
+  }
+
+  // Trim if too long
+  if (content.length > MAX_CONTENT_LENGTH) {
+    content = content.slice(0, MAX_CONTENT_LENGTH) +
+      `\n\n[... truncated at ${MAX_CONTENT_LENGTH.toLocaleString()} characters]`;
+  }
+
+  return {
+    name,
+    content: content.trim(),
+    size: finalSize,
+    extension: ext,
+  };
+}
+
+/**
+ * Formats parsed file data into a context string for prompt injection.
+ * @param {{ name: string, content: string, size: number, extension: string }} fileData
+ * @returns {string}
+ */
+export function formatContext(fileData) {
+  return [
+    `[Context File: ${fileData.name} (${formatBytes(fileData.size)}, ${fileData.extension})]`,
+    "---",
+    fileData.content,
+    "---",
+    `[End of ${fileData.name}]`,
+  ].join("\n");
+}
+
+/**
+ * Formats bytes into a human-readable string.
+ * @param {number} bytes
+ * @returns {string}
+ */
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+const EXCLUDE_DIRS = new Set([
+  "node_modules", ".git", ".agents", "build", "dist", ".github",
+  "Krims Code_pip", "krims_code_agent_cli.egg-info", "krims_code_cli.egg-info"
+]);
+
+/**
+ * Recursively scans baseDir and returns a list of supported files.
+ * @param {string} baseDir - Directory to scan
+ * @returns {string[]} List of relative file paths
+ */
+export function scanWorkspaceFiles(baseDir) {
+  const files = [];
+
+  function recurse(dir) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (EXCLUDE_DIRS.has(entry)) continue;
+      const fullPath = join(dir, entry);
+      let stats;
+      try {
+        stats = statSync(fullPath);
+      } catch {
+        continue;
+      }
+
+      if (stats.isDirectory()) {
+        recurse(fullPath);
+      } else if (stats.isFile()) {
+        const ext = extname(entry).toLowerCase();
+        if (SUPPORTED_EXTENSIONS.has(ext)) {
+          files.push(relative(baseDir, fullPath));
+        }
+      }
+    }
+  }
+
+  recurse(baseDir);
+  return files.sort();
+}

krims_pip/node_project/src/git.js

@@ -0,0 +1,41 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(exec);
+
+/**
+ * Checks if inside a git repository and returns the staged or unstaged diff.
+ * @returns {Promise<{ diff: string, isStaged: boolean }>}
+ */
+export async function getGitDiff() {
+  try {
+    await execAsync("git rev-parse --is-inside-work-tree");
+  } catch {
+    throw new Error("Not a git repository (or git is not installed).");
+  }
+
+  // Try staged changes first
+  const { stdout: staged } = await execAsync("git diff --cached");
+  if (staged.trim()) {
+    return { diff: staged.trim(), isStaged: true };
+  }
+
+  // Fallback to unstaged changes
+  const { stdout: unstaged } = await execAsync("git diff");
+  if (unstaged.trim()) {
+    return { diff: unstaged.trim(), isStaged: false };
+  }
+
+  return { diff: "", isStaged: false };
+}
+
+/**
+ * Executes a git commit with the specified message.
+ * @param {string} message - The commit message
+ * @returns {Promise<string>} stdout output of the git commit command
+ */
+export async function runGitCommit(message) {
+  const escaped = message.replace(/"/g, '\\"');
+  const { stdout } = await execAsync(`git commit -m "${escaped}"`);
+  return stdout.trim();
+}