glitool 1.0.0 → 2.0.0

package/dist/tools/searchCodeTool.js

@@ -1,10 +1,20 @@
 import { tool } from "@langchain/core/tools";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { z } from "zod";
 export const searchCodeTool = tool(async ({ keyword }) => {
     try {
-        const result = execSync(`grep -rn "${keyword}" --include="*.ts" --include="*.js" --include="*.json" --exclude-dir=node_modules --exclude-dir=dist --exclude-dir=dist --exclude-dir=.git`, { cwd: process.cwd(), timeout: 10000, stdio: 'pipe' }).toString();
-        return result || 'No Matches found.';
+        const result = execFileSync('grep', [
+            '-rn',
+            keyword,
+            '--include=*.ts',
+            '--include=*.js',
+            '--include=*.json',
+            '--exclude-dir=node_modules',
+            '--exclude-dir=dist',
+            '--exclude-dir=.git',
+            '.'
+        ], { cwd: process.cwd(), timeout: 10000, stdio: 'pipe' }).toString();
+        return result || 'No matches found.';
     }
     catch {
         return 'No matches found.';
@@ -13,6 +23,6 @@ export const searchCodeTool = tool(async ({ keyword }) => {
     name: 'searchCode',
     description: 'Search for a keyword or function name across all project files. Returns file paths and line numbers where the keyword is found. Use this tool to quickly locate where a specific function or variable is used in the codebase.',
     schema: z.object({
-        keyword: z.string().describe('The Keyword, funtion name, or pattern to search for in the codebase')
+        keyword: z.string().describe('The keyword, function name, or pattern to search for in the codebase')
     })
 });

package/dist/tools/webFetchTool.js

@@ -0,0 +1,45 @@
+import { tool } from "@langchain/core/tools";
+import { z } from 'zod';
+import TurndownService from 'turndown';
+const turndown = new TurndownService({ headingStyle: 'atx', codeBlockStyle: 'fenced' });
+const MAX_CHARS = 20_000;
+export const webFetchTool = tool(async ({ url }) => {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return `Invalid URL: ${url}`;
+    }
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        return `BLOCKED: Only http/https URLs are allowed. Got: ${parsed.protocol}`;
+    }
+    let response;
+    try {
+        response = await fetch(url, {
+            headers: { 'User-Agent': 'glitool/1.0' },
+            signal: AbortSignal.timeout(15_000)
+        });
+    }
+    catch (err) {
+        return `Fetch failed: ${err.message}`;
+    }
+    if (!response.ok) {
+        return `HTTP ${response.status}: ${response.statusText}`;
+    }
+    const contentType = response.headers.get('content-type') ?? '';
+    if (contentType.includes('text/html')) {
+        const html = await response.text();
+        const markdown = turndown.turndown(html);
+        const trimmed = markdown.slice(0, MAX_CHARS);
+        return trimmed.length < markdown.length ? trimmed + '\n\n(content truncated at 20 00 chars)' : trimmed;
+    }
+    const text = await response.text();
+    return text.slice(0, MAX_CHARS);
+}, {
+    name: 'webFetch',
+    description: 'Fetch a public URL and return its content as readable text. HTML pages are converted to markdown. Use for reading docs, changelogs, npm package pages, GitHub READMEs, or any public web resource. Only http/https allowed — file:// and other schemes are blocked.',
+    schema: z.object({
+        url: z.string().describe('The full URL to fetch (must start with http:// or https://)')
+    })
+});

package/dist/tools/writeFileTool.js

@@ -1,20 +1,23 @@
 import { tool } from "@langchain/core/tools";
-import { confirm } from "@inquirer/prompts";
 import fs from 'fs';
 import path from 'path';
 import { z } from 'zod';
 import { requestConfirm } from "../confirmHandler.js";
+import { log } from "../logger.js";
 export const writeFileTool = tool(async ({ filePath, content }) => {
     const projectRoot = process.cwd();
     const fullPath = path.resolve(projectRoot, filePath);
     if (!fullPath.startsWith(projectRoot + path.sep) && fullPath !== projectRoot) {
         throw new Error('Access denied: cannot write outside project root');
     }
-    console.log(`\n📄 Write to: ${filePath}`);
-    console.log('_'.repeat(40));
-    console.log(content.slice(0, 500) + (content.length > 500 ? '\n...(truncated)' : ''));
-    console.log('_'.repeat(40));
-    const ok = await requestConfirm(`Write to: ${filePath}?`);
+    log('write:before-confirm', { filePath });
+    const ok = await requestConfirm({
+        type: 'write',
+        filePath,
+        content,
+        risk: 'medium',
+    });
+    log('write:after-confirm', { filePath, ok });
     if (!ok) {
         return 'USER_CANCELLED: The user explicitly rejected this file write. Do NOT retry. Inform the user the write was cancelled.';
     }

package/dist/trust/riskScorer.js

@@ -1,11 +1,30 @@
 const HIGH_RISK_PATTERNS = [
     /\.env/,
     /\.env\.\w+/,
-    /package\.json$/,
-    /tsconfig\.json$/,
     /docker-compose/,
     /\.git\//,
 ];
+const BLOCKED_SHELL_PATTERNS = [
+    /\brm\s+-rf?\s+\/(?!\w)/, // rm -rf / (not /something)
+    /\brm\s+-rf?\s+~(?!\w)/, // rm -rf ~
+    /\bsudo\b/,
+    /\|\s*(sh|bash|zsh)\b/, // piped to a shell — curl | sh etc.
+    /:\s*\(\s*\)\s*\{.*\|.*&\s*\}\s*;\s*:/, // fork bomb
+    /\bdd\s+if=/, // dd block-level copy
+    />\s*\/dev\/(sd[a-z]|hd[a-z]|nvme)/, // writing to disk devices
+    /\bmkfs\b/, // formatting disks
+    /\bchmod\s+-R\s+777\s+\//, // chmod 777 root
+];
+const CONFIRM_SHELL_PATTERNS = [
+    /\bgit\s+push\b/,
+    /\bgit\s+reset\s+--hard\b/,
+    /\bgit\s+rebase\b/,
+    /\bgit\s+(force-?push|push\s+-f)\b/,
+    /\bnpm\s+(publish|install|i|uninstall|un|rm|remove)\b/,
+    /\byarn\s+(add|remove|publish)\b/,
+    /\bpnpm\s+(add|remove|publish)\b/,
+    /\bdocker\s+(rm|rmi|kill|exec)\b/,
+];
 const LOW_RISK_TOOLS = ['listFiles', 'readFile', 'searchCode'];
 export function scoreRisk(toolName, args) {
     if (LOW_RISK_TOOLS.includes(toolName))
@@ -23,3 +42,11 @@ export function getRiskMessage(toolName, riskLevel, args) {
         return `${toolName}${filePath ? ` -> ${filePath}` : ''}`;
     return '';
 }
+export function scoreShellRisk(command) {
+    const trimmed = command.trim();
+    if (BLOCKED_SHELL_PATTERNS.some(p => p.test(trimmed)))
+        return 'block';
+    if (CONFIRM_SHELL_PATTERNS.some(p => p.test(trimmed)))
+        return 'confirm';
+    return 'allow';
+}