blun-king-cli 1.0.0 → 1.1.0

package/bin/blun.js

@@ -185,6 +185,16 @@ async function handleCommand(input) {
       console.log("  /set telegram     Configure Telegram bridge");
       console.log("  /set verbose      Toggle verbose logging");
       console.log("");
+      console.log(C.yellow + "  DEV" + C.reset);
+      console.log("  /sh <cmd>         Run shell command");
+      console.log("  /git <cmd>        Git commands (status, log, diff, add, commit, push, pull, branch, checkout, clone, init)");
+      console.log("  /ssh add/del/list Connect & manage SSH hosts");
+      console.log("  /ssh <host> <cmd> Run command on remote host");
+      console.log("  /deploy <method>  Deploy: git, ssh, sync, pm2");
+      console.log("  /read <file>      Read a file");
+      console.log("  /write <file>     Write/create a file");
+      console.log("  /init             Init project (AGENT.md, .gitignore, git init)");
+      console.log("");
       console.log(C.yellow + "  SYSTEM" + C.reset);
       console.log("  /status           Runtime status");
       console.log("  /versions         Prompt versions");
@@ -272,6 +282,34 @@ async function handleCommand(input) {
       cmdFiles();
       break;
 
+    case "/sh":
+      cmdShell(args);
+      break;
+
+    case "/git":
+      cmdGit(args);
+      break;
+
+    case "/ssh":
+      cmdSsh(args);
+      break;
+
+    case "/deploy":
+      cmdDeploy(args);
+      break;
+
+    case "/read":
+      cmdRead(args);
+      break;
+
+    case "/write":
+      cmdWrite(args);
+      break;
+
+    case "/init":
+      cmdInit();
+      break;
+
     case "/exit":
     case "/quit":
     case "/q":
@@ -733,6 +771,277 @@ function cmdFiles() {
   } catch(e) { printError(e.message); }
 }
 
+// ── Shell Execution ──
+function cmdShell(command) {
+  if (!command) { printError("Usage: /sh <command>"); return; }
+  try {
+    console.log(C.dim + "$ " + command + C.reset);
+    var output = execSync(command, { cwd: config.workdir, encoding: "utf8", timeout: 30000, stdio: ["pipe", "pipe", "pipe"] });
+    console.log(output);
+  } catch(e) {
+    if (e.stdout) console.log(e.stdout);
+    if (e.stderr) console.log(C.red + e.stderr + C.reset);
+    printError("Exit code: " + (e.status || "unknown"));
+  }
+}
+
+// ── Git Commands ──
+function cmdGit(args) {
+  if (!args) {
+    // Show git status
+    cmdShell("git status --short");
+    return;
+  }
+  var sub = args.split(/\s+/)[0];
+  var rest = args.slice(sub.length).trim();
+
+  switch(sub) {
+    case "status": cmdShell("git status"); break;
+    case "log": cmdShell("git log --oneline -10"); break;
+    case "diff": cmdShell("git diff --stat"); break;
+    case "add":
+      cmdShell("git add " + (rest || "."));
+      printSuccess("Files staged.");
+      break;
+    case "commit":
+      if (!rest) { printError("Usage: /git commit <message>"); return; }
+      cmdShell('git commit -m "' + rest.replace(/"/g, '\\"') + '"');
+      break;
+    case "push":
+      var remote = rest || "origin";
+      try {
+        var branch = execSync("git branch --show-current", { cwd: config.workdir, encoding: "utf8" }).trim();
+        printInfo("Pushing " + branch + " to " + remote + "...");
+        cmdShell("git push " + remote + " " + branch);
+        printSuccess("Pushed!");
+      } catch(e) { printError("Push failed: " + e.message); }
+      break;
+    case "pull":
+      cmdShell("git pull " + (rest || ""));
+      break;
+    case "branch":
+      cmdShell("git branch " + (rest || "-a"));
+      break;
+    case "checkout":
+      if (!rest) { printError("Usage: /git checkout <branch>"); return; }
+      cmdShell("git checkout " + rest);
+      break;
+    case "clone":
+      if (!rest) { printError("Usage: /git clone <url>"); return; }
+      cmdShell("git clone " + rest);
+      break;
+    case "init":
+      cmdShell("git init");
+      break;
+    case "remote":
+      cmdShell("git remote -v");
+      break;
+    default:
+      cmdShell("git " + args);
+  }
+}
+
+// ── SSH Commands ──
+function cmdSsh(args) {
+  if (!args) {
+    // Show saved connections
+    var sshFile = path.join(CONFIG_DIR, "ssh.json");
+    if (fs.existsSync(sshFile)) {
+      var connections = JSON.parse(fs.readFileSync(sshFile, "utf8"));
+      console.log("");
+      console.log(C.bold + "SSH Connections:" + C.reset);
+      for (var name in connections) {
+        var c = connections[name];
+        console.log("  " + C.yellow + name + C.reset + " — " + c.user + "@" + c.host + (c.port !== 22 ? ":" + c.port : ""));
+      }
+      console.log("");
+      console.log(C.dim + "  /ssh <name> <command> — Run command" + C.reset);
+      console.log(C.dim + "  /ssh add <name> <user@host> — Add connection" + C.reset);
+      console.log(C.dim + "  /ssh del <name> — Remove connection" + C.reset);
+    } else {
+      printInfo("No SSH connections saved. Use /ssh add <name> <user@host>");
+    }
+    return;
+  }
+
+  var parts = args.split(/\s+/);
+  var sshFile = path.join(CONFIG_DIR, "ssh.json");
+  var connections = {};
+  if (fs.existsSync(sshFile)) {
+    try { connections = JSON.parse(fs.readFileSync(sshFile, "utf8")); } catch(e) {}
+  }
+
+  if (parts[0] === "add" && parts[1] && parts[2]) {
+    var match = parts[2].match(/^([^@]+)@([^:]+)(?::(\d+))?$/);
+    if (!match) { printError("Format: user@host or user@host:port"); return; }
+    connections[parts[1]] = { user: match[1], host: match[2], port: parseInt(match[3] || "22"), key: parts[3] || null };
+    fs.writeFileSync(sshFile, JSON.stringify(connections, null, 2));
+    printSuccess("SSH connection '" + parts[1] + "' saved.");
+    return;
+  }
+
+  if (parts[0] === "del" && parts[1]) {
+    delete connections[parts[1]];
+    fs.writeFileSync(sshFile, JSON.stringify(connections, null, 2));
+    printSuccess("SSH connection '" + parts[1] + "' removed.");
+    return;
+  }
+
+  // Execute command on saved connection
+  var connName = parts[0];
+  var remoteCmd = parts.slice(1).join(" ");
+  if (!connections[connName]) { printError("Unknown connection: " + connName + ". Use /ssh to list."); return; }
+  if (!remoteCmd) { printError("Usage: /ssh " + connName + " <command>"); return; }
+
+  var conn = connections[connName];
+  var sshCmd = "ssh";
+  if (conn.key) sshCmd += " -i " + conn.key;
+  sshCmd += " -o ConnectTimeout=10 -o StrictHostKeyChecking=no";
+  sshCmd += " -p " + conn.port;
+  sshCmd += " " + conn.user + "@" + conn.host;
+  sshCmd += ' "' + remoteCmd.replace(/"/g, '\\"') + '"';
+
+  printInfo("SSH " + connName + ": " + remoteCmd);
+  cmdShell(sshCmd);
+}
+
+// ── Deploy Command ──
+async function cmdDeploy(args) {
+  if (!args) {
+    console.log("");
+    console.log(C.bold + "Deploy Options:" + C.reset);
+    console.log("  /deploy git              — git add + commit + push");
+    console.log("  /deploy ssh <name> <cmd> — Run deploy command via SSH");
+    console.log("  /deploy sync <name>      — rsync workdir to server");
+    console.log("  /deploy pm2 <name> <app> — pm2 restart on server");
+    console.log("");
+    return;
+  }
+
+  var parts = args.split(/\s+/);
+  var action = parts[0];
+
+  if (action === "git") {
+    printInfo("Deploying via git...");
+    try {
+      var status = execSync("git status --porcelain", { cwd: config.workdir, encoding: "utf8" }).trim();
+      if (status) {
+        cmdShell("git add .");
+        var msg = parts.slice(1).join(" ") || "deploy: " + new Date().toISOString().slice(0, 16);
+        cmdShell('git commit -m "' + msg + '"');
+      }
+      var branch = execSync("git branch --show-current", { cwd: config.workdir, encoding: "utf8" }).trim();
+      cmdShell("git push origin " + branch);
+      printSuccess("Deployed via git push!");
+    } catch(e) { printError("Deploy failed: " + e.message); }
+
+  } else if (action === "ssh" && parts[1]) {
+    cmdSsh(parts.slice(1).join(" "));
+
+  } else if (action === "sync" && parts[1]) {
+    var sshFile = path.join(CONFIG_DIR, "ssh.json");
+    if (!fs.existsSync(sshFile)) { printError("No SSH connections. Use /ssh add first."); return; }
+    var connections = JSON.parse(fs.readFileSync(sshFile, "utf8"));
+    var conn = connections[parts[1]];
+    if (!conn) { printError("Unknown connection: " + parts[1]); return; }
+    var dest = parts[2] || "/root/" + path.basename(config.workdir);
+    var rsyncCmd = "rsync -avz --exclude node_modules --exclude .git";
+    if (conn.key) rsyncCmd += " -e 'ssh -i " + conn.key + " -p " + conn.port + "'";
+    rsyncCmd += " " + config.workdir + "/ " + conn.user + "@" + conn.host + ":" + dest + "/";
+    printInfo("Syncing to " + parts[1] + ":" + dest);
+    cmdShell(rsyncCmd);
+
+  } else if (action === "pm2" && parts[1] && parts[2]) {
+    cmdSsh(parts[1] + " pm2 restart " + parts[2]);
+
+  } else {
+    printError("Unknown deploy action. Use /deploy for help.");
+  }
+}
+
+// ── Read/Write Files ──
+function cmdRead(filePath) {
+  if (!filePath) { printError("Usage: /read <file>"); return; }
+  var full = path.resolve(config.workdir, filePath);
+  if (!fs.existsSync(full)) { printError("File not found: " + full); return; }
+  var content = fs.readFileSync(full, "utf8");
+  console.log("");
+  console.log(C.bold + "File: " + full + C.reset);
+  console.log(C.dim + "─".repeat(50) + C.reset);
+  var lines = content.split("\n");
+  for (var i = 0; i < lines.length; i++) {
+    console.log(C.dim + String(i + 1).padStart(4) + " │ " + C.reset + lines[i]);
+  }
+  console.log("");
+}
+
+function cmdWrite(args) {
+  if (!args) { printError("Usage: /write <file> <content> or /write <file> (then type content, end with EOF)"); return; }
+  var parts = args.split(/\s+/);
+  var filePath = parts[0];
+  var content = parts.slice(1).join(" ");
+  var full = path.resolve(config.workdir, filePath);
+
+  if (content) {
+    fs.writeFileSync(full, content);
+    printSuccess("Written: " + full + " (" + content.length + " bytes)");
+  } else {
+    printInfo("Type content (end with line 'EOF'):");
+    // This will be handled differently in interactive mode
+    printError("For multi-line write, use: /generate instead");
+  }
+}
+
+// ── Project Init ──
+function cmdInit(args) {
+  var name = args || path.basename(config.workdir);
+  var projectDir = args ? path.join(config.workdir, args) : config.workdir;
+
+  if (args && !fs.existsSync(projectDir)) {
+    fs.mkdirSync(projectDir, { recursive: true });
+  }
+
+  // Create project memory file
+  var memFile = path.join(projectDir, "AGENT.md");
+  if (!fs.existsSync(memFile)) {
+    var agentContent = "# " + name + "\n\n" +
+      "## Projekt\n" +
+      "Beschreibung: \n\n" +
+      "## Stack\n" +
+      "- \n\n" +
+      "## Regeln\n" +
+      "- \n\n" +
+      "## Status\n" +
+      "Erstellt: " + new Date().toISOString().split("T")[0] + "\n";
+    fs.writeFileSync(memFile, agentContent);
+    printSuccess("AGENT.md erstellt in " + projectDir);
+  } else {
+    printInfo("AGENT.md existiert bereits.");
+  }
+
+  // Git init if not already
+  try {
+    execSync("git rev-parse --git-dir", { cwd: projectDir, stdio: "pipe" });
+    printInfo("Git repo already initialized.");
+  } catch(e) {
+    execSync("git init", { cwd: projectDir, stdio: "pipe" });
+    printSuccess("Git repo initialized.");
+  }
+
+  // Create .gitignore if missing
+  var gitignore = path.join(projectDir, ".gitignore");
+  if (!fs.existsSync(gitignore)) {
+    fs.writeFileSync(gitignore, "node_modules/\n.env\n*.log\n.blun/\n");
+    printSuccess(".gitignore erstellt.");
+  }
+
+  if (args) {
+    config.workdir = projectDir;
+    saveConfig(config);
+    printSuccess("Workdir set to: " + projectDir);
+  }
+}
+
 // ── Main Loop ──
 async function main() {
   // Handle CLI args

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "BLUN King CLI — Premium KI Console",
   "bin": {
     "blun": "./bin/blun.js"