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

krims_pip/node_project/src/commands/commit.js

@@ -0,0 +1,157 @@
+import { getGitDiff, runGitCommit } from "../git.js";
+import { getAIConfig } from "../config.js";
+import { routePrompt } from "../ai/router.js";
+import { MODES, DEFAULT_MODE } from "../modes.js";
+import { colors, label } from "../ui/theme.js";
+import { createInterface } from "node:readline/promises";
+
+export default {
+  name: "commit",
+  description: "Generate conventional commit message from git diff and commit changes",
+  aliases: [],
+  options: [],
+  async executeCLI(args, options) {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    try {
+      const { diff, isStaged } = await getGitDiff();
+      if (!diff) {
+        console.log("\n" + label.system + " " + colors.warning("No staged or unstaged changes detected. Stage your files using 'git add' first.\n"));
+        rl.close();
+        return;
+      }
+
+      if (!isStaged) {
+        const stageAnswer = await rl.question("\n" + label.system + " " + colors.warning("No staged changes found. Do you want to stage all changes automatically? [y/N]: "));
+
+        if (stageAnswer.toLowerCase().trim() === "y" || stageAnswer.toLowerCase().trim() === "yes") {
+          const { exec } = await import("node:child_process");
+          const { promisify } = await import("node:util");
+          const execAsync = promisify(exec);
+          await execAsync("git add .");
+          console.log(label.system + " " + colors.success("Staged all changes successfully."));
+        } else {
+          console.log("\n" + label.system + " " + colors.muted("Aborted. Please stage files using 'git add' first.\n"));
+          rl.close();
+          return;
+        }
+      }
+
+      const aiConfig = await getAIConfig();
+      const mode = MODES[DEFAULT_MODE];
+
+      console.log("");
+      console.log(label.system + " " + colors.brand("Reading git diff and generating conventional commit message..."));
+      console.log("");
+
+      const systemPrompt = "You are an expert developer assistant. Generate a concise, clear, and professional conventional commit message (e.g., 'feat: add login page', 'fix: resolve buffer overflow') based on the provided git diff. Output ONLY the commit message itself on a single line, with absolutely no backticks, markdown, explanations, prefix, or introductory text.";
+      const userPrompt = `Here is the git diff:\n\n${diff}`;
+
+      let firstToken = true;
+      let commitMessage = "";
+      const onToken = (token) => {
+        if (firstToken) {
+          firstToken = false;
+          process.stdout.write(label.krims + " Suggested Commit Message: " + colors.success(token));
+        } else {
+          process.stdout.write(colors.success(token));
+        }
+        commitMessage += token;
+      };
+
+      const result = await routePrompt(userPrompt, mode.systemPrompt, aiConfig, onToken);
+      console.log("\n");
+
+      const cleanMessage = result.text.trim().replace(/^`+|`+$/g, ""); // strip quotes/backticks
+
+      const answer = await rl.question(colors.muted("Commit with this message? [Y/n]: "));
+
+      if (answer.toLowerCase().trim() === "n" || answer.toLowerCase().trim() === "no") {
+        console.log("\n" + label.system + " " + colors.muted("Commit aborted.\n"));
+        rl.close();
+        return;
+      }
+
+      console.log("\n" + label.system + " " + colors.brand("Executing git commit..."));
+      const output = await runGitCommit(cleanMessage);
+      console.log("\n" + colors.success(output) + "\n");
+
+    } catch (err) {
+      console.log("\n" + label.error + " " + colors.danger(err.message) + "\n");
+    } finally {
+      rl.close();
+    }
+  },
+  async executeChat(args, ctx) {
+    const { exec } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execAsync = promisify(exec);
+
+    try {
+      const { diff, isStaged } = await getGitDiff();
+      if (!diff) {
+        console.log("\n" + label.system + " " + colors.warning("No staged or unstaged changes detected. Stage your files using 'git add' first.\n"));
+        return;
+      }
+
+      if (!isStaged) {
+        ctx.rl.pause();
+        const stageAnswer = await new Promise((resolve) => {
+          ctx.rl.question(colors.warning("\nNo staged changes found. Do you want to stage all changes automatically? [y/N]: "), resolve);
+        });
+        ctx.rl.resume();
+
+        if (stageAnswer.toLowerCase().trim() === "y" || stageAnswer.toLowerCase().trim() === "yes") {
+          await execAsync("git add .");
+          console.log(label.system + " " + colors.success("Staged all changes successfully."));
+        } else {
+          console.log("\n" + label.system + " " + colors.muted("Aborted. Please stage files using 'git add' first.\n"));
+          return;
+        }
+      }
+
+      console.log("\n" + label.system + " " + colors.brand("Reading git diff and generating conventional commit message..."));
+      console.log("");
+
+      const systemPrompt = "You are an expert developer assistant. Generate a concise, clear, and professional conventional commit message (e.g., 'feat: add login page', 'fix: resolve buffer overflow') based on the provided git diff. Output ONLY the commit message itself on a single line, with absolutely no backticks, markdown, explanations, prefix, or introductory text.";
+      const userPrompt = `Here is the git diff:\n\n${diff}`;
+
+      let firstToken = true;
+      let commitMessage = "";
+      const onToken = (token) => {
+        if (firstToken) {
+          firstToken = false;
+          process.stdout.write(label.krims + " Suggested Commit Message: " + colors.success(token));
+        } else {
+          process.stdout.write(colors.success(token));
+        }
+        commitMessage += token;
+      };
+
+      const result = await routePrompt(userPrompt, systemPrompt, ctx.aiConfig, onToken);
+      console.log("\n");
+
+      const cleanMessage = result.text.trim().replace(/^`+|`+$/g, ""); // strip quotes/backticks
+
+      ctx.rl.pause();
+      const answer = await new Promise((resolve) => {
+        ctx.rl.question(colors.muted("Commit with this message? [Y/n]: "), resolve);
+      });
+      ctx.rl.resume();
+
+      if (answer.toLowerCase().trim() === "n" || answer.toLowerCase().trim() === "no") {
+        console.log("\n" + label.system + " " + colors.muted("Commit aborted.\n"));
+        return;
+      }
+
+      console.log("\n" + label.system + " " + colors.brand("Executing git commit..."));
+      const output = await runGitCommit(cleanMessage);
+      console.log("\n" + colors.success(output) + "\n");
+
+    } catch (err) {
+      console.log("\n" + label.error + " " + colors.danger(err.message) + "\n");
+    }
+  }
+};

krims_pip/node_project/src/commands/dashboard.js

@@ -0,0 +1,59 @@
+import { colors, label, separator, keyValue } from "../ui/theme.js";
+
+export default {
+  name: "dashboard",
+  description: "Launch visual telemetry dashboard HUD in browser",
+  aliases: ["telemetry"],
+  options: [
+    {
+      flags: "-p, --port <port>",
+      description: "Port to run the dashboard server on",
+      defaultValue: "5050"
+    }
+  ],
+  async executeCLI(args, options) {
+    const { startTelemetryServer, openBrowser } = await import("../telemetry-server.js");
+    const parsedPort = parseInt(options.port, 10) || 5050;
+
+    console.log("");
+    console.log(label.system + " " + colors.brand("Initializing Krims Code Visual Telemetry HUD..."));
+
+    try {
+      const { port } = await startTelemetryServer(parsedPort);
+      const url = `http://localhost:${port}`;
+      console.log("  " + colors.success(`✓ Telemetry Server active at ${colors.accent(url)}`));
+      console.log("  " + colors.muted("Press Ctrl+C to terminate dashboard server."));
+      console.log("");
+
+      openBrowser(url);
+    } catch (err) {
+      console.log("\n" + label.error + " " + colors.danger(`Failed to start telemetry server: ${err.message}\n`));
+      process.exit(1);
+    }
+  },
+  async executeChat(args, ctx) {
+    const { startDashboardServer } = await import("../dashboard.js");
+    const { exec } = await import("node:child_process");
+
+    try {
+      const { port } = await startDashboardServer();
+      console.log("\n" + label.system + " " + colors.brand("📊 Krims Code WEB TELEMETRY DASHBOARD"));
+      console.log(separator("─"));
+      console.log(keyValue("  Status", colors.success("ONLINE")));
+      console.log(keyValue("  Local URL", `http://localhost:${port}`));
+      console.log("");
+      console.log("  " + colors.muted("Launching browser companion automatically..."));
+
+      let startCmd = `start http://localhost:${port}`;
+      if (process.platform === "darwin") {
+        startCmd = `open http://localhost:${port}`;
+      } else if (process.platform === "linux") {
+        startCmd = `xdg-open http://localhost:${port}`;
+      }
+      exec(startCmd);
+      console.log("\n" + label.system + " " + colors.success("✓ Dashboard launched. Press Ctrl+C in this session to stop dashboard at exit.\n"));
+    } catch (err) {
+      console.log("\n" + label.error + " " + colors.danger("Failed to start dashboard server: " + err.message + "\n"));
+    }
+  }
+};

krims_pip/node_project/src/commands/github.js

@@ -0,0 +1,349 @@
+import cp from "node:child_process";
+import { getAIConfig } from "../config.js";
+import { colors, separator, keyValue, label } from "../ui/theme.js";
+
+// Helper to execute git CLI commands using child_process.exec dynamically so it's mockable in tests
+function execGit(args) {
+  return new Promise((resolve, reject) => {
+    cp.exec(`git ${args}`, (err, stdout, stderr) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
+
+// Parses GitHub owner and repo from remote git URL
+function parseGithubUrl(url) {
+  if (!url) return null;
+  const cleanUrl = url.trim();
+
+  // SSH format: git@github.com:owner/repo.git or git@github.com:owner/repo
+  const sshRegex = /git@github\.com:([^/]+)\/([^.]+)(?:\.git)?$/;
+  const sshMatch = cleanUrl.match(sshRegex);
+  if (sshMatch) {
+    return { owner: sshMatch[1], repo: sshMatch[2] };
+  }
+
+  // HTTPS format: https://github.com/owner/repo.git or https://github.com/owner/repo
+  const httpsRegex = /https?:\/\/github\.com\/([^/]+)\/([^.]+)(?:\.git)?$/;
+  const httpsMatch = cleanUrl.match(httpsRegex);
+  if (httpsMatch) {
+    return { owner: httpsMatch[1], repo: httpsMatch[2] };
+  }
+
+  // Fallback pattern if URL is slightly different but still valid github URL
+  const fallbackRegex = /github\.com[\/:][^\/]+\/[^\/]+/;
+  if (fallbackRegex.test(cleanUrl)) {
+    const parts = cleanUrl.split(/github\.com[\/:]/)[1].split('/');
+    if (parts.length >= 2) {
+      const owner = parts[0];
+      const repo = parts[1].replace(/\.git$/, '');
+      return { owner, repo };
+    }
+  }
+
+  // Simple fallback parsing for other cases (e.g. "owner/repo")
+  const parts = cleanUrl.split('/');
+  if (parts.length === 2) {
+    return { owner: parts[0], repo: parts[1] };
+  }
+
+  return null;
+}
+
+// Dynamically extracts owner/repo name from git remote configuration
+async function getGithubRepoInfo() {
+  let url = "";
+  try {
+    url = await execGit("config --get remote.origin.url");
+  } catch {
+    try {
+      const output = await execGit("remote -v");
+      const lines = output.split('\n');
+      const originLine = lines.find(l => l.includes("origin") && l.includes("github.com"));
+      if (originLine) {
+        const match = originLine.match(/origin\s+(.*?)\s+\((?:fetch|push)\)/);
+        if (match) {
+          url = match[1].trim();
+        }
+      }
+    } catch {
+      // Ignored
+    }
+  }
+
+  if (!url) {
+    throw new Error("Could not retrieve remote.origin.url. Ensure you are in a git repository with a GitHub remote configured.");
+  }
+
+  const info = parseGithubUrl(url);
+  if (!info) {
+    throw new Error(`Could not parse GitHub owner and repository from remote URL: ${url}`);
+  }
+  return info;
+}
+
+// Retrieves GITHUB token from krims-code config or env variables
+async function getGithubToken() {
+  const aiConfig = await getAIConfig();
+  const token = aiConfig.GITHUB_API_KEY || 
+                aiConfig.GITHUB_PERSONAL_ACCESS_TOKEN || 
+                process.env.GITHUB_TOKEN || 
+                process.env.GITHUB_PERSONAL_ACCESS_TOKEN;
+  return token || null;
+}
+
+// Runs standard github API fetch with appropriate auth headers
+async function githubFetch(endpoint, token) {
+  const headers = {
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "krims-code-cli"
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  const url = `https://api.github.com${endpoint}`;
+  try {
+    const res = await fetch(url, { headers });
+    if (!res.ok) {
+      if (res.status === 401 || res.status === 403) {
+        throw new Error(`GitHub API returned ${res.status} (${res.statusText}). If this is a private repository or you are hit by rate limits, please check your token.`);
+      }
+      throw new Error(`GitHub API returned ${res.status}: ${res.statusText}`);
+    }
+    return await res.json();
+  } catch (err) {
+    throw new Error(`Failed to fetch from GitHub: ${err.message}`);
+  }
+}
+
+// Formats and retrieves local git information
+async function getLocalGitStatus() {
+  try {
+    const branch = await execGit("rev-parse --abbrev-ref HEAD");
+
+    let modifiedCount = 0;
+    try {
+      const statusOutput = await execGit("status --porcelain");
+      modifiedCount = statusOutput.split('\n').map(l => l.trim()).filter(Boolean).length;
+    } catch {
+      // status porcelain might fail if not in git repo, but getGithubRepoInfo would have already thrown
+    }
+
+    let syncStatus = "No upstream branch configured";
+    let tracking = null;
+
+    try {
+      tracking = await execGit("rev-parse --abbrev-ref @{u}");
+      const countOutput = await execGit(`rev-list --left-right --count HEAD...${tracking}`);
+      const [ahead, behind] = countOutput.trim().split(/\s+/).map(Number);
+      if (ahead > 0 && behind > 0) {
+        syncStatus = `Ahead by ${ahead}, Behind by ${behind} commits`;
+      } else if (ahead > 0) {
+        syncStatus = `Ahead by ${ahead} commit${ahead > 1 ? "s" : ""}`;
+      } else if (behind > 0) {
+        syncStatus = `Behind by ${behind} commit${behind > 1 ? "s" : ""}`;
+      } else {
+        syncStatus = "Up to date with remote";
+      }
+    } catch {
+      // No upstream tracking branch
+    }
+
+    return { branch, modifiedCount, tracking, syncStatus };
+  } catch (err) {
+    throw new Error(`Git CLI error: ${err.message}`);
+  }
+}
+
+// Display help menu
+function showGithubHelp() {
+  console.log("");
+  console.log(colors.brand("  ⚡ GITHUB COMMAND USAGE"));
+  console.log(separator("─"));
+  console.log(keyValue("  Usage", "Krims Code github <subcommand> [options]"));
+  console.log(keyValue("  Chat Usage", "/github <subcommand> [options]"));
+  console.log("");
+  console.log(colors.accent("  ◈ Subcommands:"));
+  console.log(`    ${colors.success("status")} : Show remote repository metadata, local git info, and recent CI runs`);
+  console.log(`    ${colors.success("issues")} : List issues (use --state=open|closed to filter, default: open)`);
+  console.log(`    ${colors.success("prs")}    : List open pull requests`);
+  console.log("");
+  console.log(colors.accent("  ◈ Options:"));
+  console.log(`    ${colors.success("--state=<state>")} : Filter issues by state (open, closed, all)`);
+  console.log("");
+}
+
+// Main runner for github command operations
+async function runGithubCommand(subcommand, options = {}) {
+  if (!subcommand || subcommand === "help") {
+    showGithubHelp();
+    return;
+  }
+
+  // Retrieve Git repo details
+  const { owner, repo } = await getGithubRepoInfo();
+  
+  // Retrieve token
+  const token = await getGithubToken();
+  if (!token) {
+    console.log(colors.warning("  ⚠ Warning: GITHUB_TOKEN or GITHUB_API_KEY not configured. Proceeding anonymously (rate limits apply)."));
+  }
+
+  if (subcommand === "status") {
+    console.log("\n" + label.system + " " + colors.brand("Fetching remote metadata and local status..."));
+    
+    // Fetch remote metadata and runs concurrently/sequentially
+    const repoData = await githubFetch(`/repos/${owner}/${repo}`, token);
+    let runsData = { workflow_runs: [] };
+    try {
+      runsData = await githubFetch(`/repos/${owner}/${repo}/actions/runs?per_page=5`, token);
+    } catch {
+      // Actions runs might fail if actions are disabled or not accessible
+    }
+
+    const localStatus = await getLocalGitStatus();
+
+    console.log("");
+    console.log(colors.brand(`  ⚡ GITHUB WORKSPACE: ${owner}/${repo}`));
+    console.log(separator("─"));
+    console.log(keyValue("  Stars", `★ ${repoData.stargazers_count || 0}`));
+    console.log(keyValue("  Forks", `⑂ ${repoData.forks_count || 0}`));
+    console.log(keyValue("  Open Issues/PRs", `${repoData.open_issues_count || 0}`));
+    console.log("");
+
+    console.log(colors.accent("  ◈ Local Git Status:"));
+    console.log(keyValue("    Branch", localStatus.branch));
+    console.log(keyValue("    Modified Files", String(localStatus.modifiedCount)));
+    console.log(keyValue("    Sync Status", localStatus.syncStatus));
+    console.log("");
+
+    console.log(colors.accent("  ◈ Recent Workflow Runs:"));
+    const runs = runsData.workflow_runs || [];
+    if (runs.length === 0) {
+      console.log("    No recent workflow runs found.");
+    } else {
+      for (const run of runs.slice(0, 5)) {
+        let statusSymbol = colors.muted("○");
+        let statusStr = run.status;
+        if (run.status === "completed") {
+          if (run.conclusion === "success") {
+            statusSymbol = colors.success("✓");
+            statusStr = colors.success("success");
+          } else if (run.conclusion === "failure") {
+            statusSymbol = colors.danger("✗");
+            statusStr = colors.danger("failed");
+          } else {
+            statusSymbol = colors.warning("⚠");
+            statusStr = colors.warning(run.conclusion || "unknown");
+          }
+        } else {
+          statusSymbol = colors.accent("◈");
+          statusStr = colors.accent(run.status);
+        }
+        console.log(`    ${statusSymbol} ${colors.text(run.name)} (${colors.muted(run.head_branch)}) - ${statusStr} [${run.event}]`);
+      }
+    }
+    console.log("");
+
+  } else if (subcommand === "issues") {
+    const state = options.state || "open";
+    console.log("\n" + label.system + " " + colors.brand(`Fetching remote issues (state: ${state})...`));
+
+    const rawIssues = await githubFetch(`/repos/${owner}/${repo}/issues?state=${state}&per_page=15`, token);
+    const issues = rawIssues.filter(item => !item.pull_request);
+
+    console.log("");
+    console.log(colors.brand(`  ⚡ GITHUB ISSUES (State: ${state.toUpperCase()})`));
+    console.log(separator("─"));
+    if (issues.length === 0) {
+      console.log(`  No ${state} issues found.`);
+    } else {
+      for (const issue of issues.slice(0, 10)) {
+        const numberStr = colors.accent(`#${issue.number}`);
+        const titleStr = colors.text(issue.title);
+        const stateColor = issue.state === "open" ? colors.success : colors.muted;
+        console.log(`  ${numberStr}  ${titleStr}`);
+        console.log(`       ${colors.muted("State:")} ${stateColor(issue.state)} | ${colors.muted("Author:")} ${issue.user?.login || "unknown"} | ${colors.muted("Comments:")} ${issue.comments}`);
+        console.log(`       ${colors.dim(issue.html_url)}`);
+        console.log("");
+      }
+    }
+
+  } else if (subcommand === "prs") {
+    console.log("\n" + label.system + " " + colors.brand("Fetching remote open pull requests..."));
+
+    const prs = await githubFetch(`/repos/${owner}/${repo}/pulls?state=open&per_page=15`, token);
+
+    console.log("");
+    console.log(colors.brand("  ⚡ GITHUB OPEN PULL REQUESTS"));
+    console.log(separator("─"));
+    if (prs.length === 0) {
+      console.log("  No open pull requests found.");
+    } else {
+      for (const pr of prs.slice(0, 10)) {
+        const numberStr = colors.accent(`#${pr.number}`);
+        const titleStr = colors.text(pr.title);
+        console.log(`  ${numberStr}  ${titleStr}`);
+        console.log(`       ${colors.muted("Branch:")} ${colors.accent2(pr.head?.ref || "unknown")} ➔ ${colors.muted(pr.base?.ref || "unknown")} | ${colors.muted("Author:")} ${pr.user?.login || "unknown"}`);
+        console.log(`       ${colors.dim(pr.html_url)}`);
+        console.log("");
+      }
+    }
+  } else {
+    throw new Error(`Unknown subcommand: ${subcommand}. Support status, issues, prs.`);
+  }
+}
+
+// Parses slash chat command args manually
+function parseArgs(args) {
+  const parsed = {
+    subcommand: "",
+    options: { state: "open" }
+  };
+  for (const arg of args) {
+    if (arg.startsWith("--")) {
+      const parts = arg.slice(2).split("=");
+      const key = parts[0].toLowerCase();
+      parsed.options[key] = parts[1] || true;
+    } else if (arg.startsWith("-")) {
+      // Short flag support if needed
+    } else if (!parsed.subcommand) {
+      parsed.subcommand = arg.toLowerCase();
+    }
+  }
+  return parsed;
+}
+
+export default {
+  name: "github",
+  description: "Orchestrate Git & GitHub workspace status, issues, and pull requests",
+  aliases: ["gh"],
+  signature: "github [subcommand]",
+  options: [
+    {
+      flags: "--state <state>",
+      description: "State of the issues to filter (open, closed, all)",
+      defaultValue: "open"
+    }
+  ],
+  async executeCLI(args, options) {
+    try {
+      const subcommand = args[0] || "";
+      await runGithubCommand(subcommand, options);
+    } catch (err) {
+      console.log("\n" + label.error + " " + colors.danger(err.message) + "\n");
+    }
+  },
+  async executeChat(args, ctx) {
+    try {
+      const parsed = parseArgs(args);
+      await runGithubCommand(parsed.subcommand, parsed.options);
+    } catch (err) {
+      console.log("\n" + label.error + " " + colors.danger(err.message) + "\n");
+    }
+  }
+};

krims_pip/node_project/src/commands/index.js

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function loadCommands() {
+  const commands = [];
+  const files = fs.readdirSync(__dirname);
+
+  for (const file of files) {
+    if (file === 'index.js' || !file.endsWith('.js') || file.startsWith('.')) {
+      continue;
+    }
+
+    const filePath = path.join(__dirname, file);
+    const fileUrl = new URL(`file://${filePath}`).href;
+    const module = await import(fileUrl);
+    const cmd = module.default || module.command;
+
+    if (cmd && cmd.name) {
+      commands.push(cmd);
+    }
+  }
+
+  return commands;
+}
+
+class CommandRegistry {
+  constructor() {
+    this.commands = new Map();
+    this.aliases = new Map();
+    this.allList = [];
+    this.loaded = false;
+  }
+
+  async load() {
+    if (this.loaded) return;
+    this.commands.clear();
+    this.aliases.clear();
+    this.allList = [];
+
+    const loaded = await loadCommands();
+    for (const cmd of loaded) {
+      this.commands.set(cmd.name.toLowerCase(), cmd);
+      this.allList.push(cmd);
+      if (cmd.aliases && Array.isArray(cmd.aliases)) {
+        for (const alias of cmd.aliases) {
+          this.aliases.set(alias.toLowerCase(), cmd);
+        }
+      }
+    }
+    this.loaded = true;
+  }
+
+  get(nameOrAlias) {
+    const key = nameOrAlias.toLowerCase();
+    return this.commands.get(key) || this.aliases.get(key);
+  }
+
+  getAll() {
+    return this.allList;
+  }
+}
+
+export const registry = new CommandRegistry();