@xagent/x-cli 1.1.66 → 1.1.68

package/README.md

@@ -1,4 +1,6 @@
-## 1.1.66 – Logo Assets & NPM Publication Complete
+<!-- Test comment for PR creation -->
+
+## 1.1.68 – Logo Assets & NPM Publication Complete
 
 ✅ **Live on NPM**: [@xagent/x-cli](https://www.npmjs.com/package/@xagent/x-cli) - Fully published and ready for global installation
 
@@ -1078,7 +1080,7 @@ To add yourself as a contributor:
 
 - **[@unblock-everything](https://github.com/unblock-everything)** — [x.ai](https://x.ai) — Cold-ass honkey 😎
 - **[@Bucko89](https://github.com/Bucko89)** — [GMA](https://getmyagencies.com) — Grinding daily
-- **[@base-buzz](https://github.com/base-buzz)** — [Meta](team.meta.com)
+- **[@base-buzz](https://github.com/base-buzz)** — [BaseBUzz](team.basebuzz.com)
 
 _Want to see your name here? Check out our [Contributing Guide](CONTRIBUTING.md) and submit a pull request!_
 
@@ -1102,3 +1104,5 @@ _Want to see your name here? Check out our [Contributing Guide](CONTRIBUTING.md)
 - 💡 **Feature requests** - Suggest new functionality
 
 Join our growing community of AI-powered terminal enthusiasts!
+
+# Test: Branch Protection Rules Test

package/dist/index.js

@@ -14655,7 +14655,7 @@ ${guardrail.createdFrom ? `- Created from incident: ${guardrail.createdFrom}` :
 var package_default = {
   type: "module",
   name: "@xagent/x-cli",
-  version: "1.1.66",
+  version: "1.1.68",
   description: "An open-source AI agent that brings the power of Grok directly into your terminal.",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -15183,6 +15183,7 @@ Self-Healing & Optimization:
 
 Git Commands:
   /commit-and-push - AI-generated commit + push to remote
+  /smart-push      - Intelligent staging, commit message generation, and push
 
 Enhanced Input Features:
   \u2191/\u2193 Arrow   - Navigate command history
@@ -16357,6 +16358,267 @@ Operations will now ${newLevel === "off" ? "show no explanations" : newLevel ===
       clearInput();
       return true;
     }
+    if (trimmedInput === "/smart-push") {
+      const userEntry = {
+        type: "user",
+        content: trimmedInput,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      setChatHistory((prev) => [...prev, userEntry]);
+      setIsProcessing(true);
+      try {
+        const statusResult = await agent.executeBashCommand("git status --porcelain");
+        if (!statusResult.success) {
+          const errorEntry = {
+            type: "assistant",
+            content: "\u274C **Git Error**\n\nUnable to check git status. Are you in a git repository?",
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          setChatHistory((prev) => [...prev, errorEntry]);
+          setIsProcessing(false);
+          clearInput();
+          return true;
+        }
+        if (!statusResult.output || statusResult.output.trim() === "") {
+          const noChangesEntry = {
+            type: "assistant",
+            content: "\u{1F4CB} **No Changes to Push**\n\nWorking directory is clean. No commits to push.",
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          setChatHistory((prev) => [...prev, noChangesEntry]);
+          setIsProcessing(false);
+          clearInput();
+          return true;
+        }
+        const addResult = await agent.executeBashCommand("git add .");
+        if (!addResult.success) {
+          const errorEntry = {
+            type: "assistant",
+            content: `\u274C **Failed to stage changes**
+
+${addResult.error || "Unknown error"}`,
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          setChatHistory((prev) => [...prev, errorEntry]);
+          setIsProcessing(false);
+          clearInput();
+          return true;
+        }
+        const addEntry = {
+          type: "tool_result",
+          content: "\u2705 Changes staged successfully",
+          timestamp: /* @__PURE__ */ new Date(),
+          toolCall: {
+            id: `git_add_${Date.now()}`,
+            type: "function",
+            function: {
+              name: "bash",
+              arguments: JSON.stringify({ command: "git add ." })
+            }
+          },
+          toolResult: addResult
+        };
+        setChatHistory((prev) => [...prev, addEntry]);
+        const diffResult = await agent.executeBashCommand("git diff --cached");
+        const commitPrompt = `Generate a concise, professional git commit message for these changes:
+
+Git Status:
+${statusResult.output}
+
+Git Diff (staged changes):
+${diffResult.output || "No staged changes shown"}
+
+Follow conventional commit format (feat:, fix:, docs:, etc.) and keep it under 72 characters.
+Respond with ONLY the commit message, no additional text.`;
+        let commitMessage = "";
+        let streamingEntry = null;
+        let accumulatedCommitContent = "";
+        let lastCommitUpdateTime = Date.now();
+        for await (const chunk of agent.processUserMessageStream(commitPrompt)) {
+          if (chunk.type === "content" && chunk.content) {
+            accumulatedCommitContent += chunk.content;
+            const now = Date.now();
+            if (now - lastCommitUpdateTime >= 150) {
+              commitMessage += accumulatedCommitContent;
+              if (!streamingEntry) {
+                const newEntry = {
+                  type: "assistant",
+                  content: `\u{1F916} Generating commit message...
+
+${commitMessage}`,
+                  timestamp: /* @__PURE__ */ new Date(),
+                  isStreaming: true
+                };
+                setChatHistory((prev) => [...prev, newEntry]);
+                streamingEntry = newEntry;
+              } else {
+                setChatHistory(
+                  (prev) => prev.map(
+                    (entry, idx) => idx === prev.length - 1 && entry.isStreaming ? {
+                      ...entry,
+                      content: `\u{1F916} Generating commit message...
+
+${commitMessage}`
+                    } : entry
+                  )
+                );
+              }
+              accumulatedCommitContent = "";
+              lastCommitUpdateTime = now;
+            }
+          } else if (chunk.type === "done") {
+            if (streamingEntry) {
+              setChatHistory(
+                (prev) => prev.map(
+                  (entry) => entry.isStreaming ? {
+                    ...entry,
+                    content: `\u2705 Generated commit message: "${commitMessage.trim()}"`,
+                    isStreaming: false
+                  } : entry
+                )
+              );
+            }
+            break;
+          }
+        }
+        const cleanCommitMessage = commitMessage.trim().replace(/^["']|["']$/g, "");
+        const commitCommand = `git commit -m "${cleanCommitMessage}"`;
+        const commitResult = await agent.executeBashCommand(commitCommand);
+        const commitEntry = {
+          type: "tool_result",
+          content: commitResult.success ? `\u2705 **Commit Created**: ${commitResult.output?.split("\n")[0] || "Commit successful"}` : `\u274C **Commit Failed**: ${commitResult.error || "Unknown error"}`,
+          timestamp: /* @__PURE__ */ new Date(),
+          toolCall: {
+            id: `git_commit_${Date.now()}`,
+            type: "function",
+            function: {
+              name: "bash",
+              arguments: JSON.stringify({ command: commitCommand })
+            }
+          },
+          toolResult: commitResult
+        };
+        setChatHistory((prev) => [...prev, commitEntry]);
+        if (commitResult.success) {
+          const pushResult = await agent.executeBashCommand("git push");
+          if (pushResult.success) {
+            const pushEntry = {
+              type: "tool_result",
+              content: `\u{1F680} **Push Successful**: ${pushResult.output?.split("\n")[0] || "Changes pushed to remote"}`,
+              timestamp: /* @__PURE__ */ new Date(),
+              toolCall: {
+                id: `git_push_${Date.now()}`,
+                type: "function",
+                function: {
+                  name: "bash",
+                  arguments: JSON.stringify({ command: "git push" })
+                }
+              },
+              toolResult: pushResult
+            };
+            setChatHistory((prev) => [...prev, pushEntry]);
+          } else {
+            const pushError = pushResult.error || pushResult.output || "";
+            if (pushError.includes("protected branch") || pushError.includes("Changes must be made through a pull request") || pushError.includes("GH006")) {
+              const branchProtectionEntry = {
+                type: "assistant",
+                content: "\u{1F6E1}\uFE0F **Branch Protection Detected**: Direct pushes to this branch are blocked.\n\n\u{1F504} **Creating PR workflow...**",
+                timestamp: /* @__PURE__ */ new Date()
+              };
+              setChatHistory((prev) => [...prev, branchProtectionEntry]);
+              const featureBranch = `feature/${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[:-]/g, "").replace("T", "-")}-smart-push`;
+              const createBranchResult = await agent.executeBashCommand(`git checkout -b ${featureBranch}`);
+              if (createBranchResult.success) {
+                const pushBranchResult = await agent.executeBashCommand(`git push -u origin ${featureBranch}`);
+                if (pushBranchResult.success) {
+                  const branchSuccessEntry = {
+                    type: "tool_result",
+                    content: `\u2705 **Feature Branch Created**: \`${featureBranch}\`
+
+\u{1F4CB} **Attempting to create Pull Request...**`,
+                    timestamp: /* @__PURE__ */ new Date()
+                  };
+                  setChatHistory((prev) => [...prev, branchSuccessEntry]);
+                  const prResult = await agent.executeBashCommand(`gh pr create --title "${cleanCommitMessage}" --body "Auto-generated PR from smart-push" --head ${featureBranch} --base main`);
+                  if (prResult.success) {
+                    const prUrl = prResult.output?.match(/https:\/\/github\.com\/[^\s]+/)?.[0];
+                    const prSuccessEntry = {
+                      type: "tool_result",
+                      content: `\u2705 **Pull Request Created Successfully!**
+
+\u{1F517} **PR URL**: ${prUrl || "Check GitHub for the link"}
+
+\u{1F3AF} **Next Steps**:
+\u2022 Review the PR on GitHub
+\u2022 Wait for CI checks to pass
+\u2022 Request approval and merge`,
+                      timestamp: /* @__PURE__ */ new Date()
+                    };
+                    setChatHistory((prev) => [...prev, prSuccessEntry]);
+                  } else {
+                    const prManualEntry = {
+                      type: "assistant",
+                      content: `\u26A0\uFE0F **PR Creation Failed**: GitHub CLI may not be available.
+
+\u{1F4A1} **Create PR Manually**:
+\u2022 Go to GitHub repository
+\u2022 Create PR from \`${featureBranch}\` \u2192 \`main\`
+\u2022 Title: \`${cleanCommitMessage}\``,
+                      timestamp: /* @__PURE__ */ new Date()
+                    };
+                    setChatHistory((prev) => [...prev, prManualEntry]);
+                  }
+                } else {
+                  const pushFailEntry = {
+                    type: "tool_result",
+                    content: `\u274C **Failed to push feature branch**: ${pushBranchResult.error}`,
+                    timestamp: /* @__PURE__ */ new Date()
+                  };
+                  setChatHistory((prev) => [...prev, pushFailEntry]);
+                }
+              } else {
+                const branchFailEntry = {
+                  type: "tool_result",
+                  content: `\u274C **Failed to create feature branch**: ${createBranchResult.error}`,
+                  timestamp: /* @__PURE__ */ new Date()
+                };
+                setChatHistory((prev) => [...prev, branchFailEntry]);
+              }
+            } else {
+              const pushFailEntry = {
+                type: "tool_result",
+                content: `\u274C **Push Failed**: ${pushResult.error || "Unknown error"}
+
+Try running \`git push\` manually.`,
+                timestamp: /* @__PURE__ */ new Date(),
+                toolCall: {
+                  id: `git_push_${Date.now()}`,
+                  type: "function",
+                  function: {
+                    name: "bash",
+                    arguments: JSON.stringify({ command: "git push" })
+                  }
+                },
+                toolResult: pushResult
+              };
+              setChatHistory((prev) => [...prev, pushFailEntry]);
+            }
+          }
+        }
+      } catch (error) {
+        const errorEntry = {
+          type: "assistant",
+          content: `\u274C **Smart Push Failed**
+
+${error instanceof Error ? error.message : String(error)}`,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        setChatHistory((prev) => [...prev, errorEntry]);
+      }
+      setIsProcessing(false);
+      clearInput();
+      return true;
+    }
     const directBashCommands = [
       "ls",
       "pwd",