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

krims_pip/node_project/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@krishivpb60/krims-code-cli",
+  "version": "1.5.2",
+  "description": "Krims Code AI — A cyberpunk command-line AI assistant with multi-mode reasoning, 12-node failover mesh, file context injection, and offline fallbacks.",
+  "main": "src/cli.js",
+  "bin": {
+    "krims-code": "bin/krims-code.js"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "node bin/krims-code.js",
+    "test": "node --test"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "gemini",
+    "grok",
+    "xai",
+    "chatbot",
+    "Krims Code",
+    "cyberpunk",
+    "terminal",
+    "assistant"
+  ],
+  "author": "Krishiv PB <krylobloxyt@gmail.com> (https://github.com/Krylo-60)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Krylo-60/krims-code-cli.git"
+  },
+  "homepage": "https://github.com/Krylo-60/krims-code-cli#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "marked": "^14.0.0",
+    "marked-terminal": "^7.2.0",
+    "ora": "^8.1.0"
+  }
+}

krims_pip/node_project/src/agent.js

@@ -0,0 +1,415 @@
+// ═══════════════════════════════════════════════════════════
+// Krims Code AI CLI — Agent Autopilot Engine
+// Safe Command Execution, File Sandbox, DuckDuckGo Search
+// ═══════════════════════════════════════════════════════════
+
+import { resolve, relative, isAbsolute, dirname } from "node:path";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import chalk from "chalk";
+
+const execAsync = promisify(exec);
+
+export const AGENT_INSTRUCTIONS = `
+SYSTEM AGENT CAPABILITIES:
+You can interact with the user's terminal and files by outputting special command blocks in your responses. You can output multiple command blocks in one turn. The CLI will execute them, show you the result, and let you continue.
+Supported commands:
+1. To read a file: [READ_FILE: path/to/file.ext]
+2. To write/create a file:
+[WRITE_FILE: path/to/file.ext]
+<content>
+[END_WRITE]
+3. To run a terminal command: [RUN_COMMAND: your command here]
+4. To search the web: [SEARCH_WEB: search query here]
+
+Rules:
+- Before running modifying commands or reading private files, check the user's permission level.
+- Always output clean, direct commands.
+- Do not explain these command blocks; just output them when you need to perform the action.
+- Never output or format responses using local output prefixes like '🤖 [LOCAL MATH SOLVER]' or offline fallback banners. Respond naturally as the assistant.
+`;
+
+export function isSafeCommand(cmd) {
+  const safePatterns = [
+    /^git\s+(status|diff|log|branch|show)/i,
+    /^(ls|dir|pwd)(\s+|$)/i,
+    /^(cat|type|head|tail)(\s+|$)/i,
+    /^(npm|yarn|pnpm)\s+test(\s+|$)/i,
+    /^(node|npm|git|yarn|pnpm|python\d*|py|pip)\s+(--version|-v)(\s+|$)/i,
+    /^py\s+-[0-9a-zA-Z]+(\s+|$)/i, // matches 'py -0p', 'py -0'
+    /^py\s+-\d+(\.\d+)*\s+(--version|-v)(\s+|$)/i, // matches 'py -3.12 --version'
+  ];
+  return safePatterns.some((pattern) => pattern.test(cmd.trim()));
+}
+
+/**
+ * Checks if a target path is inside the current working directory.
+ * @param {string} path
+ * @returns {boolean}
+ */
+export function isInsideWorkspace(path) {
+  const ws = resolve(process.cwd());
+  const target = resolve(path);
+  const rel = relative(ws, target);
+  return !rel.startsWith("..") && !isAbsolute(rel);
+}
+
+/**
+ * Free web search via DuckDuckGo HTML scraping.
+ * @param {string} query
+ * @returns {Promise<Array>} List of search results
+ */
+export async function searchDuckDuckGo(query) {
+  try {
+    const response = await fetch(
+      `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`,
+      {
+        headers: {
+          "User-Agent":
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        },
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`DuckDuckGo returned status ${response.status}`);
+    }
+    const html = await response.text();
+
+    const results = [];
+    const matches = [...html.matchAll(/<a class="result__a"[^>]* href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g)];
+    const snippets = [...html.matchAll(/<a class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g)];
+
+    for (let i = 0; i < Math.min(5, matches.length); i++) {
+      let url = matches[i][1];
+      const title = matches[i][2].replace(/<[^>]*>/g, "").trim();
+      const snippet = snippets[i]
+        ? snippets[i][1].replace(/<[^>]*>/g, "").trim()
+        : "";
+
+      if (url.includes("uddg=")) {
+        const urlMatch = url.match(/uddg=([^&]+)/);
+        if (urlMatch) {
+          url = decodeURIComponent(urlMatch[1]);
+        }
+      }
+      if (url.startsWith("//")) {
+        url = "https:" + url;
+      }
+
+      results.push({ title, url, snippet });
+    }
+    return results;
+  } catch (err) {
+    throw new Error(`DuckDuckGo search failed: ${err.message}`);
+  }
+}
+
+/**
+ * Sequentially parses and executes all agent tool blocks in the text.
+ * @param {string} text - AI response
+ * @param {object} aiConfig - Flat config object
+ * @param {object} rl - Readline interface
+ * @returns {Promise<Array>} List of execution results
+ */
+export async function processAgentBlocks(text, aiConfig, rl) {
+  let index = 0;
+  const results = [];
+
+  while (true) {
+    const runMatch = text.indexOf("[RUN_COMMAND:", index);
+    const readMatch = text.indexOf("[READ_FILE:", index);
+    const searchMatch = text.indexOf("[SEARCH_WEB:", index);
+    const writeMatch = text.indexOf("[WRITE_FILE:", index);
+
+    const matches = [
+      { type: "RUN_COMMAND", pos: runMatch },
+      { type: "READ_FILE", pos: readMatch },
+      { type: "SEARCH_WEB", pos: searchMatch },
+      { type: "WRITE_FILE", pos: writeMatch },
+    ].filter((m) => m.pos !== -1);
+
+    if (matches.length === 0) break;
+
+    // Process the earliest tag in the text
+    matches.sort((a, b) => a.pos - b.pos);
+    const nextTool = matches[0];
+
+    if (nextTool.type === "WRITE_FILE") {
+      const startTag = "[WRITE_FILE:";
+      const startIdx = nextTool.pos;
+      const endTagIdx = text.indexOf("]", startIdx);
+      if (endTagIdx === -1) {
+        index = startIdx + startTag.length;
+        continue;
+      }
+      const filePath = text.substring(startIdx + startTag.length, endTagIdx).trim();
+      const endWriteIdx = text.indexOf("[END_WRITE]", endTagIdx);
+      if (endWriteIdx === -1) {
+        index = endTagIdx + 1;
+        continue;
+      }
+      const content = text.substring(endTagIdx + 1, endWriteIdx);
+
+      const result = await executeTool("WRITE_FILE", filePath, content, aiConfig, rl);
+      results.push(result);
+      index = endWriteIdx + "[END_WRITE]".length;
+    } else {
+      const tag = `[${nextTool.type}:`;
+      const startIdx = nextTool.pos;
+      const endIdx = text.indexOf("]", startIdx);
+      if (endIdx === -1) {
+        index = startIdx + tag.length;
+        continue;
+      }
+      const arg = text.substring(startIdx + tag.length, endIdx).trim();
+
+      const result = await executeTool(nextTool.type, arg, "", aiConfig, rl);
+      results.push(result);
+      index = endIdx + 1;
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Executes a single tool based on autopilot config settings.
+ * @param {string} type - Tool type
+ * @param {string} arg - Tool argument
+ * @param {string} content - Write file content (if applicable)
+ * @param {object} aiConfig - Flat config object
+ * @param {object} rl - Readline interface
+ */
+export async function executeTool(type, arg, content, aiConfig, rl) {
+  const autopilot = (aiConfig.AUTOPILOT || "off").toLowerCase();
+
+  if (type === "READ_FILE") {
+    const filePath = arg;
+    const inside = isInsideWorkspace(filePath);
+
+    let allowed = false;
+    if (
+      autopilot === "machine" ||
+      autopilot === "workspace" ||
+      (autopilot === "safe" && inside)
+    ) {
+      allowed = true;
+    } else {
+      rl.pause();
+      const answer = await new Promise((resolve) => {
+        rl.question(
+          chalk.yellow(
+            `\n⚠️  AI wants to read file: "${filePath}". Allow? [y/N]: `
+          ),
+          resolve
+        );
+      });
+      rl.resume();
+      allowed =
+        answer.toLowerCase().trim() === "y" ||
+        answer.toLowerCase().trim() === "yes";
+    }
+
+    if (!allowed) {
+      return {
+        tool: "READ_FILE",
+        arg,
+        success: false,
+        error: "Access denied by user.",
+      };
+    }
+
+    try {
+      const fileContent = readFileSync(resolve(filePath), "utf-8");
+      return {
+        tool: "READ_FILE",
+        arg,
+        success: true,
+        content: fileContent,
+      };
+    } catch (err) {
+      return {
+        tool: "READ_FILE",
+        arg,
+        success: false,
+        error: err.message,
+      };
+    }
+  }
+
+  if (type === "WRITE_FILE") {
+    const filePath = arg;
+    const inside = isInsideWorkspace(filePath);
+
+    let allowed = false;
+    if (autopilot === "machine" || (autopilot === "workspace" && inside)) {
+      allowed = true;
+    } else {
+      rl.pause();
+      const answer = await new Promise((resolve) => {
+        rl.question(
+          chalk.yellow(
+            `\n⚠️  AI wants to write file: "${filePath}". Allow? [y/N]: `
+          ),
+          resolve
+        );
+      });
+      rl.resume();
+      allowed =
+        answer.toLowerCase().trim() === "y" ||
+        answer.toLowerCase().trim() === "yes";
+    }
+
+    if (!allowed) {
+      return {
+        tool: "WRITE_FILE",
+        arg,
+        success: false,
+        error: "Access denied by user.",
+      };
+    }
+
+    try {
+      const fullPath = resolve(filePath);
+      mkdirSync(dirname(fullPath), { recursive: true });
+      writeFileSync(fullPath, content, "utf-8");
+      return {
+        tool: "WRITE_FILE",
+        arg,
+        success: true,
+        message: "File written successfully.",
+      };
+    } catch (err) {
+      return {
+        tool: "WRITE_FILE",
+        arg,
+        success: false,
+        error: err.message,
+      };
+    }
+  }
+
+  if (type === "RUN_COMMAND") {
+    const command = arg;
+    const safe = isSafeCommand(command);
+
+    let allowed = false;
+    if (
+      autopilot === "machine" ||
+      (autopilot === "safe" && safe) ||
+      (autopilot === "workspace" && safe)
+    ) {
+      allowed = true;
+    } else {
+      rl.pause();
+      const answer = await new Promise((resolve) => {
+        rl.question(
+          chalk.yellow(
+            `\n⚠️  AI wants to run terminal command: "${command}". Allow? [y/N/always]: `
+          ),
+          resolve
+        );
+      });
+      rl.resume();
+
+      const cleanAnswer = answer.toLowerCase().trim();
+      if (cleanAnswer === "always") {
+        const { setConfigValue } = await import("./config.js");
+        await setConfigValue("AUTOPILOT", "safe");
+        aiConfig.AUTOPILOT = "safe";
+        console.log(chalk.green(`\n✓ Autopilot enabled (Safe mode).`));
+        allowed = true;
+      } else {
+        allowed = cleanAnswer === "y" || cleanAnswer === "yes";
+      }
+    }
+
+    if (!allowed) {
+      return {
+        tool: "RUN_COMMAND",
+        arg,
+        success: false,
+        error: "Execution denied by user.",
+      };
+    }
+
+    console.log(chalk.cyan(`\n⚡ Running command: ${command}`));
+    try {
+      const { stdout, stderr } = await execAsync(command);
+      return {
+        tool: "RUN_COMMAND",
+        arg,
+        success: true,
+        stdout,
+        stderr,
+      };
+    } catch (err) {
+      return {
+        tool: "RUN_COMMAND",
+        arg,
+        success: false,
+        error: err.message,
+        stdout: err.stdout,
+        stderr: err.stderr,
+      };
+    }
+  }
+
+  if (type === "SEARCH_WEB") {
+    const query = arg;
+
+    let allowed = false;
+    if (autopilot !== "off") {
+      allowed = true;
+    } else {
+      rl.pause();
+      const answer = await new Promise((resolve) => {
+        rl.question(
+          chalk.yellow(
+            `\n⚠️  AI wants to search the web for: "${query}". Allow? [y/N]: `
+          ),
+          resolve
+        );
+      });
+      rl.resume();
+      allowed =
+        answer.toLowerCase().trim() === "y" ||
+        answer.toLowerCase().trim() === "yes";
+    }
+
+    if (!allowed) {
+      return {
+        tool: "SEARCH_WEB",
+        arg,
+        success: false,
+        error: "Search denied by user.",
+      };
+    }
+
+    console.log(chalk.cyan(`\n🔍 Searching web: "${query}"`));
+    try {
+      const results = await searchDuckDuckGo(query);
+      return {
+        tool: "SEARCH_WEB",
+        arg,
+        success: true,
+        results,
+      };
+    } catch (err) {
+      return {
+        tool: "SEARCH_WEB",
+        arg,
+        success: false,
+        error: err.message,
+      };
+    }
+  }
+
+  return {
+    tool: type,
+    arg,
+    success: false,
+    error: "Unknown tool type.",
+  };
+}

krims_pip/node_project/src/ai/fallback.js

@@ -0,0 +1,239 @@
+// ═══════════════════════════════════════════════════════════
+// Krims Code AI CLI — Local Fallback Engine
+// Math Solver & Offline Fallback
+// ═══════════════════════════════════════════════════════════
+
+/**
+ * Detects if a prompt is a pure mathematical expression.
+ * Supports basic operators, parentheses, standard math functions, and constants.
+ * @param {string} prompt - The user prompt
+ * @returns {string|null} The cleaned expression or null
+ */
+export function detectMathExpression(prompt) {
+  const clean = prompt.replace(/\s+/g, "").toLowerCase();
+  
+  // Check if it's a word-based status query
+  if (clean === "status" || clean === "hud") return null;
+
+  // Strip allowed function and constant words
+  const structure = clean.replace(/sin|cos|tan|log|ln|sqrt|pi|e|abs/g, "");
+  
+  // Must be composed of valid math characters, AND contain either a math operator or an active function call
+  if (/^[0-9+\-*/().%^]+$/.test(structure)) {
+    const hasOperator = /[+\-*/%^]/.test(structure);
+    const hasFunction = /(sin|cos|tan|log|ln|sqrt|abs)\(/.test(clean);
+    if (hasOperator || hasFunction) {
+      return clean;
+    }
+  }
+  return null;
+}
+
+/**
+ * Safely evaluates a mathematical expression locally.
+ * Supports trig, square root, natural/base-10 logs, absolute values, pi, and e.
+ * @param {string} expression - A sanitized math expression
+ * @returns {{ text: string, type: string }|null}
+ */
+export function solveMath(expression) {
+  if (!expression) return null;
+  try {
+    const clean = expression.replace(/\s+/g, "").toLowerCase();
+    
+    // Validate character structure
+    const structure = clean.replace(/sin|cos|tan|log|ln|sqrt|pi|e|abs/g, "");
+    if (!/^[0-9+\-*/().%^]+$/.test(structure)) return null;
+
+    // Convert terms to JavaScript Math equivalents
+    let jsExpr = clean
+      .replace(/\^/g, "**")
+      .replace(/sin\(/g, "Math.sin(")
+      .replace(/cos\(/g, "Math.cos(")
+      .replace(/tan\(/g, "Math.tan(")
+      .replace(/log\(/g, "Math.log10(")
+      .replace(/ln\(/g, "Math.log(")
+      .replace(/sqrt\(/g, "Math.sqrt(")
+      .replace(/abs\(/g, "Math.abs(")
+      .replace(/\bpi\b/g, "Math.PI")
+      .replace(/\be\b/g, "Math.E");
+
+    const result = Function(`"use strict"; return (${jsExpr})`)();
+    if (typeof result === "number" && !isNaN(result) && isFinite(result)) {
+      return {
+        text: [
+          "🤖 [LOCAL MATH SOLVER]",
+          `   Expression: ${expression}`,
+          `   Result: ${Number(result.toFixed(6))}`,
+        ].join("\n"),
+        type: "local-math",
+      };
+    }
+  } catch {
+    // Not a valid expression
+  }
+  return null;
+}
+
+/**
+ * Starts a mainframe security bypass mini-game.
+ * @returns {{ text: string, type: string }}
+ */
+export function runMainframeHack() {
+  return {
+    text: [
+      "⚡ [LOCAL TERMINAL SECURITY BYPASS GAME]",
+      "   MAINFRAME HACK PROTOCOL LOADED.",
+      "   ────────────────────────────────────────",
+      "   Objective: Bypass security by guessing the 4-digit PIN (digits 0-9).",
+      "   For each guess, you will get feedback:",
+      "     • 'Hit'   - correct digit in correct position.",
+      "     • 'Close' - correct digit but in wrong position.",
+      "   You have 6 attempts before security lock-out.",
+      "   ",
+      "   Type `/guess <number>` to input breach code (e.g. /guess 2941)",
+      "   To abort, type `/abort`.",
+      "   ────────────────────────────────────────",
+    ].join("\n"),
+    type: "mainframe-game",
+  };
+}
+
+/**
+ * Generates a local offline/error reply when no AI keys are configured or fail.
+ * Implements the Krylo companion bot fallback speaking clean English.
+ * @param {string} prompt - The user prompt
+ * @param {string[]} [errors] - Optional error messages from failed provider nodes
+ * @returns {{ text: string, type: string }}
+ */
+export function generateOfflineReply(prompt, errors = []) {
+  const clean = (prompt || "").trim().toLowerCase();
+  let header = "🤖 [KRYLO COMPANION - OFFLINE MODE]";
+
+  // Default Error/Quota Fallback
+  if (errors && errors.length > 0) {
+    const isRateLimited = errors.some((e) => {
+      const lower = e.toLowerCase();
+      return (
+        lower.includes("quota") ||
+        lower.includes("rate limit") ||
+        lower.includes("rate-limit") ||
+        lower.includes("429") ||
+        lower.includes("resource_exhausted") ||
+        lower.includes("limit exceeded")
+      );
+    });
+
+    const lines = [
+      header,
+      "⚠️ All configured AI provider nodes failed to respond.",
+      ""
+    ];
+    if (isRateLimited) {
+      lines.push("💡 [Rate Limit / Quota Exceeded]: One or more provider nodes hit their API usage limits.");
+    }
+    lines.push(
+      "Errors encountered:",
+      ...errors.map((e) => `• ${e}`),
+      "",
+      "Please check your API keys, network connection, or rate limits."
+    );
+
+    return {
+      text: lines.join("\n"),
+      type: "offline-error"
+    };
+  }
+
+  let warning = "\n💡 Note: Running locally to conserve your API quota.";
+
+  // Greetings
+  if (/^(hello|hi|hey|greetings|yo|sup)\b/.test(clean)) {
+    return {
+      text: [
+        header,
+        warning,
+        "",
+        "Hello! I am Krylo, your offline companion for Krims Code CLI.",
+        "I can help you with local math calculations (e.g. 2 + 2), status checks, or run simple hacking games.",
+        "To converse with an advanced LLM, please configure an API key using:",
+        "  krims-code config set GOOGLE_API_KEY <your_key_here>"
+      ].join("\n"),
+      type: "krylo-local"
+    };
+  }
+
+  // Help / Commands
+  if (clean.includes("help") || clean.includes("command") || clean.includes("shortcut")) {
+    return {
+      text: [
+        header,
+        warning,
+        "",
+        "💡 [Krims Code CLI QUICK CHEAT SHEET]",
+        "   • /mode <name>      - Switch reasoning modes (synthesis, research, architect, titan)",
+        "   • /attach <file>    - Attach a file for context (supports autocomplete)",
+        "   • /git              - Launch interactive Git TUI & file stager checkbox menu",
+        "   • /dashboard        - Launch local web telemetry dashboard HUD",
+        "   • /autopilot debug  - Run autonomous debug loop to fix test failures",
+        "   • /copy             - Copy the last response to clipboard",
+        "   • /export           - Export conversation history to Markdown"
+      ].join("\n"),
+      type: "krylo-local"
+    };
+  }
+
+  // Diagnostics / Status
+  if (clean.includes("status") || clean.includes("hud") || clean.includes("cpu") || clean.includes("ping") || clean.includes("diagnostics")) {
+    return {
+      text: [
+        header,
+        warning,
+        "",
+        "📊 [SYSTEM DIAGNOSTIC READOUT]",
+        "   • CPU Core Load: Nominal / Optimized",
+        "   • Memory Usage: Active & stable",
+        "   • Network Link: Standby / Offline local mesh active",
+        "   • Failover Mesh: Ready to route prompts"
+      ].join("\n"),
+      type: "krylo-local"
+    };
+  }
+
+  // Code / Programming
+  if (clean.includes("code") || clean.includes("write") || clean.includes("program") || clean.includes("javascript") || clean.includes("python")) {
+    return {
+      text: [
+        header,
+        warning,
+        "",
+        "💻 [LOCAL CODE REFERENCE]",
+        "Since I am running offline, I cannot write complex code for you. Here is a basic template:",
+        "",
+        "```javascript",
+        "// Node.js entry template",
+        "import fs from 'node:fs/promises';",
+        "",
+        "async function main() {",
+        "  console.log('Krims Code offline node initialized.');",
+        "}",
+        "main();",
+        "```",
+        "",
+        "Configure an API key to have Krims Code write, refactor, or debug code on your behalf!"
+      ].join("\n"),
+      type: "krylo-local"
+    };
+  }
+
+  return {
+    text: [
+      header,
+      warning,
+      "",
+      "No active API keys configured. Please set GOOGLE_API_KEY, GROQ_API_KEY, or OPENAI_API_KEY in your config to start chatting.",
+      "Example: krims-code config set GOOGLE_API_KEY <your-key>"
+    ].join("\n"),
+    type: "offline-error"
+  };
+}
+