@ikyyofc/gemini-cli 3.0.9 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikyyofc/gemini-cli",
-  "version": "3.0.9",
+  "version": "4.0.0",
   "description": "AI Agent CLI — native function calling · GEMINI.md context · extensions",
   "type": "module",
   "bin": { "gemini": "./index.js" },

package/src/agent.js

@@ -20,8 +20,21 @@ function buildSystemPrompt(extra = "") {
     const skills      = loadSkills();
     const skillsBlock = buildSkillsPrompt(skills);
 
+    // Current datetime injected directly — no tool needed
+    const now = new Date();
+    const tz  = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const datetime = now.toLocaleString("id-ID", {
+        timeZone:  tz,
+        dateStyle: "full",
+        timeStyle: "long",
+    });
+
     return `You are an autonomous AI coding agent running in the user's terminal. You have full access to their filesystem and shell through tools.
 
+## CURRENT TIME
+${datetime} (${tz})
+Unix timestamp: ${Math.floor(now.getTime() / 1000)}
+
 ## CORE RULE — NEVER ASK, ALWAYS ACT
 
 You MUST use tools to complete tasks. You are NEVER allowed to:

package/src/tools.js

@@ -357,6 +357,89 @@ export const FUNCTION_DECLARATIONS = [
             },
             required: ["path", "permissions"]
         }
+    },
+
+    // ── REAL-TIME TOOLS ──────────────────────────────────────────
+    {
+        name: "web_search",
+        description: "Search the web for current information, news, facts, or anything up-to-date. Use this when you need real-time or recent information.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                query:  { type: "STRING", description: "Search query" },
+                region: { type: "STRING", description: "Region code e.g. id-id, us-en, my-en (default: id-id)" }
+            },
+            required: ["query"]
+        }
+    },
+    {
+        name: "get_weather",
+        description: "Get current weather and forecast for any city or location.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                location: { type: "STRING", description: "City name or location e.g. 'Jakarta', 'New York', 'Tokyo'" },
+                format:   { type: "STRING", description: "simple (1 line) | full (detailed JSON) — default: simple" }
+            },
+            required: ["location"]
+        }
+    },
+    {
+        name: "get_news",
+        description: "Get latest news headlines on any topic from around the web.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                query:    { type: "STRING", description: "Topic or keyword to search news for (e.g. 'AI', 'Indonesia', 'bitcoin')" },
+                language: { type: "STRING", description: "Language code: id, en, etc. (default: id)" },
+                limit:    { type: "NUMBER", description: "Number of results (default: 10, max: 20)" }
+            },
+            required: ["query"]
+        }
+    },
+    {
+        name: "get_exchange_rate",
+        description: "Get current currency exchange rates. Supports all major currencies.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                from: { type: "STRING", description: "Base currency code e.g. USD, IDR, EUR (default: USD)" },
+                to:   { type: "STRING", description: "Target currency or comma-separated list e.g. 'IDR,EUR,JPY'" }
+            }
+        }
+    },
+    {
+        name: "get_stock",
+        description: "Get real-time or latest stock price and info for a ticker symbol.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                symbol: { type: "STRING", description: "Stock ticker symbol e.g. AAPL, GOOGL, BBCA.JK, TLKM.JK" }
+            },
+            required: ["symbol"]
+        }
+    },
+    {
+        name: "get_crypto",
+        description: "Get current cryptocurrency prices and market data.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                coins:    { type: "STRING", description: "Coin IDs comma-separated e.g. 'bitcoin,ethereum,solana'" },
+                currency: { type: "STRING", description: "Fiat currency for prices e.g. usd, idr (default: usd)" }
+            },
+            required: ["coins"]
+        }
+    },
+    {
+        name: "get_ip_info",
+        description: "Get geolocation and network info for an IP address, or your own public IP if none given.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                ip: { type: "STRING", description: "IP address to look up (leave empty for your own IP)" }
+            }
+        }
     }
 ];
 
@@ -755,6 +838,196 @@ export async function executeTool(name, args = {}, { autoApprove = false } = {})
                 return { result: `chmod ${args.permissions} applied to ${p}` };
             }
 
+            // ── REAL-TIME TOOLS ──────────────────────────────────────
+            case "web_search": {
+                const q   = encodeURIComponent(args.query);
+                const reg = args.region ?? "id-id";
+                // DuckDuckGo Instant Answer API
+                const { stdout: ddg } = await execAsync(
+                    `curl -sL --max-time 10 "https://api.duckduckgo.com/?q=${q}&format=json&no_redirect=1&no_html=1&skip_disambig=1"`
+                ).catch(() => ({ stdout: "" }));
+
+                // Also get HTML search results via scraping (lite version)
+                const { stdout: html } = await execAsync(
+                    `curl -sL --max-time 10 -H "User-Agent: Mozilla/5.0" "https://html.duckduckgo.com/html/?q=${q}" | grep -oP '(?<=class="result__snippet">)[^<]+' | head -8`
+                ).catch(() => ({ stdout: "" }));
+
+                let out = "";
+                try {
+                    const data = JSON.parse(ddg);
+                    if (data.AbstractText) out += `📖 ${data.AbstractText}\n   Source: ${data.AbstractURL}\n\n`;
+                    if (data.Answer)       out += `💡 ${data.Answer}\n\n`;
+                    if (data.RelatedTopics?.length) {
+                        out += "Related:\n";
+                        data.RelatedTopics.slice(0, 5).forEach(t => {
+                            if (t.Text) out += `  · ${t.Text}\n`;
+                        });
+                    }
+                } catch {}
+
+                if (html.trim()) out += "\nSearch snippets:\n" + html.trim().split("\n").map(l => `  · ${l.trim()}`).join("\n");
+
+                return { result: out.trim() || "No results found. Try a different query." };
+            }
+
+            case "get_weather": {
+                const loc = encodeURIComponent(args.location);
+                if (args.format === "full") {
+                    const { stdout } = await execAsync(
+                        `curl -sL --max-time 10 "https://wttr.in/${loc}?format=j1"`
+                    );
+                    try {
+                        const data    = JSON.parse(stdout);
+                        const current = data.current_condition[0];
+                        const area    = data.nearest_area[0];
+                        const city    = area.areaName[0].value;
+                        const country = area.country[0].value;
+                        return {
+                            result: JSON.stringify({
+                                location:    `${city}, ${country}`,
+                                temp_c:      current.temp_C + "°C",
+                                feels_like:  current.FeelsLikeC + "°C",
+                                humidity:    current.humidity + "%",
+                                wind_kmph:   current.windspeedKmph + " km/h",
+                                description: current.weatherDesc[0].value,
+                                visibility:  current.visibility + " km",
+                                uv_index:    current.uvIndex,
+                            }, null, 2)
+                        };
+                    } catch {}
+                }
+                // Simple one-line format
+                const { stdout } = await execAsync(
+                    `curl -sL --max-time 10 "https://wttr.in/${loc}?format=3"`
+                );
+                return { result: stdout.trim() || "Could not fetch weather." };
+            }
+
+            case "get_news": {
+                const q    = encodeURIComponent(args.query);
+                const lang = args.language ?? "id";
+                const lim  = Math.min(args.limit ?? 10, 20);
+
+                // Use HackerNews Algolia API for tech news, BBC/Reuters RSS for general
+                const results = [];
+
+                // Try GNews RSS (free, no key)
+                const { stdout: hn } = await execAsync(
+                    `curl -sL --max-time 12 "https://hn.algolia.com/api/v1/search?query=${q}&tags=story&hitsPerPage=${lim}" 2>/dev/null`
+                ).catch(() => ({ stdout: "" }));
+
+                try {
+                    const data = JSON.parse(hn);
+                    if (data.hits?.length) {
+                        data.hits.forEach((h, i) => {
+                            results.push(`${i+1}. ${h.title}\n   🔗 ${h.url || "https://news.ycombinator.com/item?id="+h.objectID}\n   ⏱ ${h.created_at}`);
+                        });
+                    }
+                } catch {}
+
+                // Also try Google News RSS if lang is id
+                if (results.length < 5) {
+                    const { stdout: rss } = await execAsync(
+                        `curl -sL --max-time 12 "https://news.google.com/rss/search?q=${q}&hl=${lang}&gl=ID&ceid=ID:${lang}" | grep -oP '(?<=<title>)[^<]+' | grep -v "Google News" | head -${lim}`
+                    ).catch(() => ({ stdout: "" }));
+                    if (rss.trim()) {
+                        const headlines = rss.trim().split("\n").filter(Boolean);
+                        headlines.forEach((h, i) => {
+                            if (!results.find(r => r.includes(h)))
+                                results.push(`${results.length+1}. ${h}`);
+                        });
+                    }
+                }
+
+                return { result: results.slice(0, lim).join("\n\n") || "No news found." };
+            }
+
+            case "get_exchange_rate": {
+                const from = (args.from ?? "USD").toUpperCase();
+                const to   = args.to ? args.to.toUpperCase() : "";
+                const url  = to
+                    ? `https://api.frankfurter.app/latest?from=${from}&to=${to}`
+                    : `https://api.frankfurter.app/latest?from=${from}`;
+                const { stdout } = await execAsync(`curl -sL --max-time 10 "${url}"`);
+                try {
+                    const data  = JSON.parse(stdout);
+                    const rates = Object.entries(data.rates)
+                        .map(([k, v]) => `  ${k}: ${v}`)
+                        .join("\n");
+                    return { result: `1 ${from} =\n${rates}\n\nDate: ${data.date}` };
+                } catch {
+                    return { error: "Could not fetch exchange rates." };
+                }
+            }
+
+            case "get_stock": {
+                const sym = encodeURIComponent(args.symbol.toUpperCase());
+                const { stdout } = await execAsync(
+                    `curl -sL --max-time 12 "https://query1.finance.yahoo.com/v8/finance/chart/${sym}?range=1d&interval=1d"`
+                );
+                try {
+                    const data   = JSON.parse(stdout);
+                    const meta   = data.chart.result[0].meta;
+                    return {
+                        result: JSON.stringify({
+                            symbol:        meta.symbol,
+                            name:          meta.longName ?? meta.shortName ?? meta.symbol,
+                            price:         meta.regularMarketPrice,
+                            prev_close:    meta.previousClose,
+                            change:        (meta.regularMarketPrice - meta.previousClose).toFixed(2),
+                            change_pct:    (((meta.regularMarketPrice - meta.previousClose) / meta.previousClose) * 100).toFixed(2) + "%",
+                            currency:      meta.currency,
+                            exchange:      meta.exchangeName,
+                            market_state:  meta.marketState,
+                            volume:        meta.regularMarketVolume,
+                        }, null, 2)
+                    };
+                } catch {
+                    return { error: `Could not fetch stock data for ${args.symbol}.` };
+                }
+            }
+
+            case "get_crypto": {
+                const ids = encodeURIComponent(args.coins.toLowerCase().replace(/\s/g, ""));
+                const cur = (args.currency ?? "usd").toLowerCase();
+                const url = `https://api.coingecko.com/api/v3/simple/price?ids=${ids}&vs_currencies=${cur}&include_24hr_change=true&include_market_cap=true&include_24hr_vol=true`;
+                const { stdout } = await execAsync(`curl -sL --max-time 12 "${url}"`);
+                try {
+                    const data = JSON.parse(stdout);
+                    const lines = Object.entries(data).map(([coin, info]) => {
+                        const price  = info[cur];
+                        const change = info[`${cur}_24h_change`]?.toFixed(2);
+                        const mcap   = info[`${cur}_market_cap`];
+                        return `${coin.toUpperCase()}: ${cur.toUpperCase()} ${price?.toLocaleString()}  (24h: ${change}%)  mcap: ${mcap?.toLocaleString()}`;
+                    });
+                    return { result: lines.join("\n") };
+                } catch {
+                    return { error: "Could not fetch crypto prices." };
+                }
+            }
+
+            case "get_ip_info": {
+                const target = args.ip ? `https://ipapi.co/${args.ip}/json/` : "https://ipapi.co/json/";
+                const { stdout } = await execAsync(`curl -sL --max-time 10 "${target}"`);
+                try {
+                    const d = JSON.parse(stdout);
+                    return {
+                        result: JSON.stringify({
+                            ip:       d.ip,
+                            city:     d.city,
+                            region:   d.region,
+                            country:  d.country_name,
+                            timezone: d.timezone,
+                            isp:      d.org,
+                            lat:      d.latitude,
+                            lon:      d.longitude,
+                        }, null, 2)
+                    };
+                } catch {
+                    return { error: "Could not fetch IP info." };
+                }
+            }
+
             default:
                 return { error: `Unknown tool: ${name}` };
         }