@suman_biswas/beam 0.1.0

package/dist/apps/cli/src/utils/tools.js

@@ -0,0 +1,566 @@
+import fs from "fs";
+import path from "path";
+import { exec as execCallback } from "child_process";
+import { promisify } from "util";
+const exec = promisify(execCallback);
+const COMMAND_TIMEOUT_MS = 30_000;
+const MAX_COMMAND_OUTPUT_LENGTH = 12_000;
+const MAX_GREP_RESULTS = 200;
+const MAX_WEB_RESULTS = 10;
+const MAX_FETCH_TEXT_LENGTH = 20_000;
+const BLOCKED_DELETE_PATH_PARTS = new Set([".git", "node_modules", ".vscode"]);
+function truncateOutput(value) {
+    if (value.length <= MAX_COMMAND_OUTPUT_LENGTH) {
+        return value;
+    }
+    return `${value.slice(0, MAX_COMMAND_OUTPUT_LENGTH)}\n...[truncated]`;
+}
+function toRelativeWorkspacePath(workspaceFolder, absolutePath) {
+    return path.relative(workspaceFolder, absolutePath) || ".";
+}
+function globPatternToRegExp(pattern) {
+    const normalizedPattern = pattern.replace(/\\/g, "/");
+    let regex = "^";
+    for (let i = 0; i < normalizedPattern.length; i++) {
+        const char = normalizedPattern[i];
+        if (char === "*") {
+            const next = normalizedPattern[i + 1];
+            if (next === "*") {
+                i++;
+                if (normalizedPattern[i + 1] === "/") {
+                    i++;
+                    regex += "(?:.*\\/)?";
+                }
+                else {
+                    regex += ".*";
+                }
+            }
+            else {
+                regex += "[^/]*";
+            }
+            continue;
+        }
+        if (char === "?") {
+            regex += "[^/]";
+            continue;
+        }
+        if ("\\^$.|+()[]{}".includes(char)) {
+            regex += `\\${char}`;
+            continue;
+        }
+        regex += char;
+    }
+    regex += "$";
+    return new RegExp(regex);
+}
+function isDangerousCommand(command) {
+    const normalized = command.trim().toLowerCase();
+    const blockedPatterns = [
+        /\bsudo\b/,
+        /\brm\s+-rf\b/,
+        /\bgit\s+reset\s+--hard\b/,
+        /\bgit\s+clean\s+-fd\b/,
+        /\bshutdown\b/,
+        /\breboot\b/,
+        /\bmkfs\b/,
+        /\bdd\s+if=/,
+    ];
+    return blockedPatterns.some((pattern) => pattern.test(normalized));
+}
+function matchesGitignorePattern(filePath, pattern) {
+    const cleanPattern = pattern.replace(/\/$/, "");
+    if (filePath === cleanPattern) {
+        return true;
+    }
+    if (filePath.split("/").includes(cleanPattern)) {
+        return true;
+    }
+    if (cleanPattern.includes("*")) {
+        const regex = new RegExp("^" + cleanPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$");
+        if (regex.test(filePath)) {
+            return true;
+        }
+    }
+    return false;
+}
+function decodeHtmlEntities(value) {
+    const namedEntities = {
+        amp: "&",
+        lt: "<",
+        gt: ">",
+        quot: '"',
+        apos: "'",
+        nbsp: " ",
+    };
+    return value
+        .replace(/&#(\d+);/g, (_, code) => String.fromCharCode(Number(code)))
+        .replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCharCode(Number.parseInt(code, 16)))
+        .replace(/&([a-z]+);/gi, (_, name) => namedEntities[name.toLowerCase()] ?? `&${name};`);
+}
+function stripHtmlTags(value) {
+    return decodeHtmlEntities(value
+        .replace(/<script[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style[\s\S]*?<\/style>/gi, " ")
+        .replace(/<noscript[\s\S]*?<\/noscript>/gi, " ")
+        .replace(/<\/(p|div|section|article|header|footer|main|li|tr|td|th|blockquote|pre|h[1-6])>/gi, "\n")
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<[^>]+>/g, " "))
+        .replace(/\r/g, "")
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function extractHtmlTitle(html) {
+    const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    if (!match?.[1]) {
+        return undefined;
+    }
+    return stripHtmlTags(match[1]).trim() || undefined;
+}
+function normalizeWebUrl(input) {
+    if (/^https?:\/\//i.test(input)) {
+        return input;
+    }
+    return `https://${input}`;
+}
+function extractSearchUrl(href) {
+    try {
+        const parsed = new URL(href, "https://duckduckgo.com");
+        const redirectTarget = parsed.searchParams.get("uddg");
+        if (redirectTarget) {
+            return decodeURIComponent(redirectTarget);
+        }
+        return parsed.toString();
+    }
+    catch {
+        return href;
+    }
+}
+/**
+ * Get list of all project file paths as relative paths.
+ * Returns a flat array of file paths (no directories).
+ * Respects .gitignore patterns and hardcoded ignore list.
+ */
+export function getProjectAwareness(rootDir) {
+    try {
+        const IGNORED_FOLDERS = new Set([
+            "node_modules",
+            ".git",
+            "dist",
+            "out",
+            "build",
+            ".next",
+            "coverage",
+            ".turbo",
+            "public",
+            "media",
+            "assets",
+            ".gitignore",
+            ".vscode",
+            ".DS_Store",
+            ".npmrc",
+            ".prettierignore",
+            ".eslintignore",
+            "yarn.lock",
+            "package-lock.json",
+        ]);
+        let gitignorePatterns = [];
+        try {
+            const gitignorePath = path.join(rootDir, ".gitignore");
+            const gitignoreContent = fs.readFileSync(gitignorePath, "utf8");
+            gitignorePatterns = gitignoreContent
+                .split("\n")
+                .map((line) => line.trim())
+                .filter((line) => line && !line.startsWith("#"));
+        }
+        catch {
+            // ignore missing .gitignore
+        }
+        const shouldIgnore = (name, relPath) => {
+            if (IGNORED_FOLDERS.has(name)) {
+                return true;
+            }
+            for (const pattern of gitignorePatterns) {
+                if (matchesGitignorePattern(relPath, pattern)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        const filePaths = [];
+        function walk(dir, relativePath = "") {
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            entries.forEach((entry) => {
+                const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+                if (shouldIgnore(entry.name, relPath)) {
+                    return;
+                }
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(fullPath, relPath);
+                    return;
+                }
+                if (entry.isFile()) {
+                    filePaths.push(relPath);
+                }
+            });
+        }
+        walk(rootDir);
+        return filePaths.sort();
+    }
+    catch (error) {
+        console.error("Error reading project paths:", error);
+        return [];
+    }
+}
+/**
+ * Read a file or list a directory.
+ */
+export async function readPath(targetPath, cwd) {
+    try {
+        const resolvedPath = path.resolve(cwd, targetPath);
+        const relativePath = path.relative(cwd, resolvedPath);
+        if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+            return { success: false, error: "Path must stay within the workspace folder", targetPath };
+        }
+        const stat = fs.statSync(resolvedPath);
+        if (stat.isDirectory()) {
+            try {
+                const entries = fs.readdirSync(resolvedPath);
+                const directoryEntries = entries
+                    .map((name) => ({
+                    name,
+                    type: fs.statSync(path.join(resolvedPath, name)).isDirectory() ? "directory" : "file",
+                }))
+                    .sort((a, b) => a.name.localeCompare(b.name));
+                return {
+                    success: true,
+                    path: relativePath,
+                    type: "directory",
+                    entries: directoryEntries,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return { success: false, error: errorMessage, targetPath };
+            }
+        }
+        const content = fs.readFileSync(resolvedPath, "utf8");
+        return {
+            success: true,
+            path: relativePath,
+            type: "file",
+            content,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { success: false, error: errorMessage, targetPath };
+    }
+}
+/**
+ * Write content to a file.
+ */
+export async function writePath(filePath, content, cwd) {
+    try {
+        const resolvedPath = path.resolve(cwd, filePath);
+        const relativePath = path.relative(cwd, resolvedPath);
+        if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+            return { success: false, error: "Path must stay within the workspace folder", filePath };
+        }
+        const parentDir = path.dirname(resolvedPath);
+        fs.mkdirSync(parentDir, { recursive: true });
+        fs.writeFileSync(resolvedPath, content, "utf8");
+        return {
+            success: true,
+            message: "File written successfully",
+            filePath: relativePath,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { success: false, error: errorMessage, filePath };
+    }
+}
+/**
+ * Edit a file by replacing literal text.
+ */
+export async function editPath(filePath, searchValue, replaceValue, cwd) {
+    try {
+        const resolvedPath = path.resolve(cwd, filePath);
+        const relativePath = path.relative(cwd, resolvedPath);
+        if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+            return { success: false, error: "Path must stay within the workspace folder", filePath };
+        }
+        const content = fs.readFileSync(resolvedPath, "utf8");
+        const updated = content.split(searchValue).join(replaceValue);
+        fs.writeFileSync(resolvedPath, updated, "utf8");
+        return {
+            success: true,
+            message: "File edited successfully",
+            filePath: relativePath,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { success: false, error: errorMessage, filePath };
+    }
+}
+/**
+ * Delete a file or directory.
+ */
+export async function deletePath(targetPath, cwd) {
+    try {
+        const resolvedPath = path.resolve(cwd, targetPath);
+        const relativePath = path.relative(cwd, resolvedPath);
+        if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+            return { success: false, error: "Path must stay within the workspace folder", targetPath };
+        }
+        const pathParts = relativePath.split(path.sep);
+        if (pathParts.some((part) => BLOCKED_DELETE_PATH_PARTS.has(part))) {
+            return {
+                success: false,
+                error: "Deleting files from protected paths is blocked",
+                path: relativePath,
+            };
+        }
+        const stat = fs.statSync(resolvedPath);
+        fs.rmSync(resolvedPath, { recursive: true, force: true });
+        return {
+            success: true,
+            path: relativePath,
+            type: stat.isDirectory() ? "directory" : "file",
+            message: "Path deleted",
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { success: false, error: errorMessage, targetPath };
+    }
+}
+/**
+ * Find files matching a glob pattern.
+ */
+export function glob(pattern, cwd) {
+    try {
+        const regex = globPatternToRegExp(pattern);
+        const matches = getProjectAwareness(cwd).filter((filePath) => regex.test(filePath));
+        return {
+            success: true,
+            pattern,
+            matches,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { success: false, error: errorMessage, pattern };
+    }
+}
+/**
+ * Search file contents using a regular expression.
+ */
+export function grep(pattern, flags = "gm", cwd) {
+    try {
+        let regex;
+        try {
+            regex = new RegExp(pattern, flags.includes("g") ? flags : `${flags}g`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return { success: false, error: errorMessage, pattern, flags };
+        }
+        const files = getProjectAwareness(cwd);
+        const matches = [];
+        for (const file of files) {
+            const fullPath = path.join(cwd, file);
+            let content;
+            try {
+                content = fs.readFileSync(fullPath, "utf8");
+            }
+            catch {
+                continue;
+            }
+            regex.lastIndex = 0;
+            for (const match of content.matchAll(regex)) {
+                const matchedText = match[0];
+                const matchIndex = match.index ?? 0;
+                const lineNumber = content.slice(0, matchIndex).split(/\r?\n/).length;
+                const lineText = content.split(/\r?\n/)[lineNumber - 1] ?? "";
+                matches.push({
+                    filePath: file,
+                    lineNumber,
+                    lineText,
+                    match: matchedText,
+                });
+                if (matches.length >= MAX_GREP_RESULTS) {
+                    return {
+                        success: true,
+                        pattern,
+                        flags,
+                        truncated: true,
+                        matches,
+                    };
+                }
+            }
+        }
+        return {
+            success: true,
+            pattern,
+            flags,
+            truncated: false,
+            matches,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { success: false, error: errorMessage, pattern };
+    }
+}
+/**
+ * Search the web using DuckDuckGo.
+ */
+export async function webSearch(query, limit = MAX_WEB_RESULTS) {
+    try {
+        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+        const response = await fetch(url, {
+            headers: {
+                "user-agent": "Beam/0.1",
+                accept: "text/html,application/xhtml+xml",
+            },
+        });
+        if (!response.ok) {
+            return {
+                success: false,
+                error: `Search request failed with status ${response.status}`,
+                query,
+            };
+        }
+        const html = await response.text();
+        const results = [];
+        const resultRegex = /<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?(?:<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>)?/gi;
+        let match;
+        while ((match = resultRegex.exec(html)) !== null) {
+            const urlMatch = extractSearchUrl(match[1] ?? "");
+            const title = stripHtmlTags(match[2] ?? "");
+            const snippet = match[3] ? stripHtmlTags(match[3]) : undefined;
+            if (!title || !urlMatch) {
+                continue;
+            }
+            results.push({ title, url: urlMatch, snippet });
+            if (results.length >= limit) {
+                break;
+            }
+        }
+        return {
+            success: true,
+            query,
+            source: "duckduckgo",
+            results,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { success: false, error: errorMessage, query };
+    }
+}
+/**
+ * Fetch and process a URL.
+ */
+export async function webFetch(url) {
+    try {
+        const normalizedUrl = normalizeWebUrl(url);
+        const parsedUrl = new URL(normalizedUrl);
+        if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+            return { success: false, error: "Only http and https URLs are supported", url };
+        }
+        const response = await fetch(parsedUrl.toString(), {
+            headers: {
+                "user-agent": "Beam/0.1",
+                accept: "text/html,application/json,text/plain,*/*",
+            },
+        });
+        const contentType = response.headers.get("content-type") ?? "unknown";
+        const bodyText = await response.text();
+        let extractedText = bodyText;
+        let title;
+        if (contentType.includes("application/json")) {
+            try {
+                extractedText = JSON.stringify(JSON.parse(bodyText), null, 2);
+            }
+            catch {
+                extractedText = bodyText;
+            }
+        }
+        else if (contentType.includes("text/html")) {
+            title = extractHtmlTitle(bodyText);
+            extractedText = stripHtmlTags(bodyText);
+        }
+        const truncated = extractedText.length > MAX_FETCH_TEXT_LENGTH;
+        const text = truncated ? extractedText.slice(0, MAX_FETCH_TEXT_LENGTH) : extractedText;
+        return {
+            success: true,
+            url: response.url || parsedUrl.toString(),
+            status: response.status,
+            ok: response.ok,
+            contentType,
+            title,
+            truncated,
+            text,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { success: false, error: errorMessage, url };
+    }
+}
+/**
+ * Run a shell command.
+ */
+export async function runCommand(command, cwd) {
+    if (!command.trim()) {
+        return {
+            success: false,
+            error: "Command cannot be empty",
+            command,
+        };
+    }
+    if (isDangerousCommand(command)) {
+        return {
+            success: false,
+            error: "Blocked potentially destructive command",
+            command,
+        };
+    }
+    try {
+        const { stdout, stderr } = await exec(command, {
+            cwd,
+            timeout: COMMAND_TIMEOUT_MS,
+            maxBuffer: 1024 * 1024,
+        });
+        return {
+            success: true,
+            command,
+            cwd,
+            stdout: truncateOutput(stdout),
+            stderr: truncateOutput(stderr),
+            exitCode: 0,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            command,
+            cwd,
+            stdout: truncateOutput(error?.stdout ?? ""),
+            stderr: truncateOutput(error?.stderr ?? error?.message ?? "Unknown command error"),
+            exitCode: typeof error?.code === "number" ? error.code : null,
+            timedOut: Boolean(error?.killed),
+        };
+    }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@suman_biswas/beam",
+  "version": "0.1.0",
+  "description": "A powerful CLI tool for interacting with AI models",
+  "keywords": ["ai", "cli", "beam"],
+  "homepage": "https://github.com/sumanbiswas7/beam#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sumanbiswas7/beam.git",
+    "directory": "apps/cli"
+  },
+  "author": "Suman Biswas <textsumanb@gmail.com>",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "main": "./dist/apps/cli/src/index.js",
+  "types": "./dist/apps/cli/src/index.d.ts",
+  "files": [
+    "dist/apps/cli",
+    "LICENSE"
+  ],
+  "bin": {
+    "beam": "./dist/apps/cli/src/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p ./tsconfig.json",
+    "dev:ui": "tsx watch src/index.tsx",
+    "start": "node ./dist/apps/cli/src/index.js"
+  },
+  "dependencies": {
+    "@beam/shared": "0.0.0",
+    "ink": "^7.0.0",
+    "ink-text-input": "^6.0.0",
+    "ollama": "^0.6.3",
+    "path": "^0.12.7",
+    "react": "^19.2.5"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "@types/react": "^19.2.14",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}