@nomad-e/bluma-cli 0.0.113 → 0.1.1

package/dist/main.js

@@ -3071,8 +3071,9 @@ async function readArtifact(args) {
 import https from "https";
 import http from "http";
 var DEFAULT_SOURCES = ["reddit", "github", "stackoverflow"];
-var MAX_RESULTS_DEFAULT = 10;
-var REQUEST_TIMEOUT = 1e4;
+var MAX_RESULTS_DEFAULT = 5;
+var REQUEST_TIMEOUT = 15e3;
+var MAX_CONTENT_LENGTH = 4e3;
 function httpGet(url, customHeaders) {
   return new Promise((resolve, reject) => {
     const protocol = url.startsWith("https") ? https : http;
@@ -3081,7 +3082,6 @@ function httpGet(url, customHeaders) {
       "Accept": "application/json, text/html, */*",
       "Accept-Language": "en-US,en;q=0.9",
       "Accept-Encoding": "identity",
-      // Não usar gzip para simplificar
       "Cache-Control": "no-cache",
       "Connection": "keep-alive",
       ...customHeaders
@@ -3111,10 +3111,18 @@ function httpGet(url, customHeaders) {
     });
   });
 }
+function cleanContent(text, maxLength = MAX_CONTENT_LENGTH) {
+  if (!text) return "";
+  let cleaned = text.replace(/```[\s\S]*?```/g, (match) => match.substring(0, 500) + (match.length > 500 ? "\n[...code truncated...]" : "")).replace(/\n{3,}/g, "\n\n").trim();
+  if (cleaned.length > maxLength) {
+    cleaned = cleaned.substring(0, maxLength) + "\n\n[...content truncated...]";
+  }
+  return cleaned;
+}
 async function searchReddit(query, limit) {
   const results = [];
   try {
-    const subreddits = "programming+webdev+javascript+typescript+python+node+reactjs+learnprogramming";
+    const subreddits = "programming+webdev+javascript+typescript+python+node+reactjs+learnprogramming+rust+golang+devops";
     const encodedQuery = encodeURIComponent(query);
     const url = `https://www.reddit.com/r/${subreddits}/search.json?q=${encodedQuery}&sort=relevance&limit=${limit}&restrict_sr=on`;
     const response = await httpGet(url);
@@ -3122,12 +3130,46 @@ async function searchReddit(query, limit) {
     if (data.data?.children) {
       for (const child of data.data.children.slice(0, limit)) {
         const post = child.data;
+        let content = `# ${post.title}
+
+`;
+        content += `**Subreddit:** r/${post.subreddit} | **Score:** ${post.score} | **Comments:** ${post.num_comments}
+
+`;
+        if (post.selftext) {
+          content += `## Post Content:
+${cleanContent(post.selftext, 2e3)}
+
+`;
+        }
+        try {
+          const commentsUrl = `https://www.reddit.com${post.permalink}.json?limit=3&depth=1`;
+          const commentsResponse = await httpGet(commentsUrl);
+          const commentsData = JSON.parse(commentsResponse);
+          if (commentsData[1]?.data?.children) {
+            content += `## Top Comments:
+`;
+            for (const comment of commentsData[1].data.children.slice(0, 3)) {
+              if (comment.data?.body) {
+                content += `
+**[${comment.data.score || 0} pts]** ${cleanContent(comment.data.body, 500)}
+`;
+              }
+            }
+          }
+        } catch {
+        }
         results.push({
           title: post.title || "",
           url: `https://reddit.com${post.permalink}`,
           source: "reddit",
-          snippet: post.selftext?.substring(0, 200) || `r/${post.subreddit} - ${post.score} upvotes`,
-          score: post.score
+          content: cleanContent(content),
+          score: post.score,
+          metadata: {
+            author: post.author,
+            date: new Date(post.created_utc * 1e3).toISOString().split("T")[0],
+            comments_count: post.num_comments
+          }
         });
       }
     }
@@ -3145,12 +3187,35 @@ async function searchGitHub(query, limit) {
     const data = JSON.parse(response);
     if (data.items) {
       for (const item of data.items.slice(0, limit)) {
+        let content = `# ${item.title}
+
+`;
+        content += `**Repo:** ${item.repository_url?.split("/").slice(-2).join("/") || "unknown"}
+`;
+        content += `**State:** ${item.state} | **Comments:** ${item.comments} | **Reactions:** ${item.reactions?.total_count || 0}
+
+`;
+        if (item.body) {
+          content += `## Issue Description:
+${cleanContent(item.body, 2500)}
+`;
+        }
+        if (item.labels?.length > 0) {
+          content += `
+**Labels:** ${item.labels.map((l) => l.name).join(", ")}
+`;
+        }
         results.push({
           title: item.title || "",
           url: item.html_url || "",
           source: "github",
-          snippet: item.body?.substring(0, 200) || `${item.comments} comments`,
-          score: item.reactions?.total_count || 0
+          content: cleanContent(content),
+          score: item.reactions?.total_count || 0,
+          metadata: {
+            author: item.user?.login,
+            date: item.created_at?.split("T")[0],
+            comments_count: item.comments
+          }
         });
       }
     }
@@ -3163,17 +3228,56 @@ async function searchStackOverflow(query, limit) {
   const results = [];
   try {
     const encodedQuery = encodeURIComponent(query);
-    const url = `https://api.stackexchange.com/2.3/search?order=desc&sort=relevance&intitle=${encodedQuery}&site=stackoverflow&pagesize=${limit}`;
+    const url = `https://api.stackexchange.com/2.3/search/advanced?order=desc&sort=relevance&q=${encodedQuery}&site=stackoverflow&pagesize=${limit}&filter=withbody`;
     const response = await httpGet(url);
     const data = JSON.parse(response);
     if (data.items) {
       for (const item of data.items.slice(0, limit)) {
+        let content = `# ${item.title}
+
+`;
+        content += `**Score:** ${item.score} | **Answers:** ${item.answer_count} | **Views:** ${item.view_count}`;
+        content += item.is_answered ? " | \u2705 Answered" : "";
+        content += `
+
+`;
+        if (item.body) {
+          const cleanBody = item.body.replace(/<code>/g, "`").replace(/<\/code>/g, "`").replace(/<pre>/g, "```\n").replace(/<\/pre>/g, "\n```").replace(/<[^>]+>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"');
+          content += `## Question:
+${cleanContent(cleanBody, 1500)}
+
+`;
+        }
+        if (item.tags?.length > 0) {
+          content += `**Tags:** ${item.tags.join(", ")}
+
+`;
+        }
+        if (item.accepted_answer_id) {
+          try {
+            const answerUrl = `https://api.stackexchange.com/2.3/answers/${item.accepted_answer_id}?site=stackoverflow&filter=withbody`;
+            const answerResponse = await httpGet(answerUrl);
+            const answerData = JSON.parse(answerResponse);
+            if (answerData.items?.[0]?.body) {
+              const cleanAnswer = answerData.items[0].body.replace(/<code>/g, "`").replace(/<\/code>/g, "`").replace(/<pre>/g, "```\n").replace(/<\/pre>/g, "\n```").replace(/<[^>]+>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"');
+              content += `## \u2705 Accepted Answer (${answerData.items[0].score} pts):
+${cleanContent(cleanAnswer, 2e3)}
+`;
+            }
+          } catch {
+          }
+        }
         results.push({
           title: item.title || "",
           url: item.link || "",
           source: "stackoverflow",
-          snippet: `${item.score} votes, ${item.answer_count} answers${item.is_answered ? " \u2713" : ""}`,
-          score: item.score
+          content: cleanContent(content),
+          score: item.score,
+          metadata: {
+            author: item.owner?.display_name,
+            date: item.creation_date ? new Date(item.creation_date * 1e3).toISOString().split("T")[0] : void 0,
+            is_answered: item.is_answered
+          }
         });
       }
     }
@@ -3182,15 +3286,6 @@ async function searchStackOverflow(query, limit) {
   }
   return results;
 }
-function getXSearchUrl(query) {
-  const encodedQuery = encodeURIComponent(query);
-  return {
-    title: `Search X for: "${query}"`,
-    url: `https://twitter.com/search?q=${encodedQuery}&src=typed_query&f=live`,
-    source: "x",
-    snippet: "X/Twitter requires authentication. Click the link to search manually."
-  };
-}
 async function searchWeb(args) {
   try {
     const {
@@ -3224,9 +3319,6 @@ async function searchWeb(args) {
         case "stackoverflow":
           searches.push(searchStackOverflow(query, resultsPerSource));
           break;
-        case "x":
-          allResults.push(getXSearchUrl(query));
-          break;
       }
     }
     const searchResults = await Promise.all(searches);
@@ -3240,8 +3332,7 @@ async function searchWeb(args) {
       query,
       results: limitedResults,
       sources_searched: sourcesSearched,
-      total_results: limitedResults.length,
-      note: sources.includes("x") ? "X/Twitter requires manual search due to API restrictions" : void 0
+      total_results: limitedResults.length
     };
   } catch (error) {
     return {
@@ -4023,6 +4114,37 @@ var SYSTEM_PROMPT = `
 
 ---
 
+<skills_knowledge>
+## Skills vs Base Knowledge (CRITICAL)
+
+**You have TWO types of knowledge:**
+
+1. **Base Training Knowledge** - General programming knowledge from your training:
+   - Testing patterns, Git workflows, Docker, React, Python, etc.
+   - This is your GENERAL EXPERTISE
+   - This knowledge is ALWAYS available
+   - This is NOT loadable via \`load_skill\` - it's already in you
+
+2. **Pluggable Skills** - Specialized modules the user installs:
+   - Listed in the \`<available_skills>\` section (if present)
+   - These are LOADABLE via \`load_skill\` tool
+   - These override/extend your base knowledge with project-specific workflows
+   - These are files in \`.bluma/skills/\` or \`~/.bluma/skills/\`
+
+**IMPORTANT RULES:**
+
+- If you see \`<available_skills>\` section below \u2192 those are your pluggable skills
+- If you DON'T see \`<available_skills>\` section \u2192 you have NO pluggable skills installed
+- When asked "what skills do you have?":
+  - If \`<available_skills>\` exists: list ONLY what's there
+  - If \`<available_skills>\` doesn't exist: say "No pluggable skills installed. I have general knowledge about programming, testing, git, etc. but no specialized skills loaded."
+- NEVER invent skill names that aren't in \`<available_skills>\`
+- NEVER try to \`load_skill\` with a name that isn't in \`<available_skills>\`
+- Your base knowledge (testing, git, docker...) is NOT a skill - it's just knowledge you have
+</skills_knowledge>
+
+---
+
 <environment>
 ## Machine Context (Your Deep Knowledge)
 
@@ -4070,7 +4192,7 @@ You MUST adapt all commands to this environment. Use the correct package manager
 - No TODO needed for single operations
 
 ### Testing Philosophy:
-Run tests when modifying code. Use the \`testing\` skill for detailed best practices.
+Run tests when modifying code. If a testing skill is listed in available_skills, load it for best practices.
 
 **Commands:**
 - Run tests: {test_command}
@@ -4613,8 +4735,8 @@ var ToolCallNormalizer = class {
    */
   static extractFromContent(content) {
     const results = [];
-    const cleanContent = content.replace(/```(?:json)?\s*([\s\S]*?)```/g, "$1");
-    const jsonMatches = this.extractJsonObjects(cleanContent);
+    const cleanContent2 = content.replace(/```(?:json)?\s*([\s\S]*?)```/g, "$1");
+    const jsonMatches = this.extractJsonObjects(cleanContent2);
     for (const jsonStr of jsonMatches) {
       try {
         const parsed = JSON.parse(jsonStr);
@@ -4925,7 +5047,8 @@ ${editData.error.display}`;
           "count_file_lines",
           "read_file_lines",
           "todo",
-          "load_skill"
+          "load_skill",
+          "search_web"
         ];
         const toolToCall = validToolCalls[0];
         const isSafeTool = autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nomad-e/bluma-cli",
-	"version": "0.0.113",
+	"version": "0.1.1",
 	"description": "BluMa independent agent for automation and advanced software engineering.",
 	"author": "Alex Fonseca",
 	"license": "Apache-2.0",