overarch-linux-arm64 0.8.0

package/dist/src/tools/shell.js

@@ -0,0 +1,74 @@
+import { spawn } from 'node:child_process';
+import { PermissionTier } from '../config/types.js';
+import { policyEngine } from '../security/policy.js';
+export function createShellTools() {
+    return [
+        {
+            definition: {
+                name: 'executeCommand',
+                description: 'Execute a shell command',
+                tier: PermissionTier.StateMutating,
+                parameters: [
+                    { name: 'command', type: 'string', description: 'Command to run', required: true },
+                    { name: 'cwd', type: 'string', description: 'Working directory', required: false }
+                ]
+            },
+            handler: async (params) => {
+                const cmd = String(params.command);
+                const cwd = params.cwd ? String(params.cwd) : process.cwd();
+                const isWindows = process.platform === 'win32';
+                return new Promise((resolve) => {
+                    const child = spawn(cmd, [], {
+                        shell: isWindows ? 'powershell.exe' : true,
+                        cwd,
+                        windowsVerbatimArguments: true,
+                    });
+                    if (child.pid) {
+                        policyEngine.registerProcess(child.pid);
+                        child.on('close', () => {
+                            if (child.pid)
+                                policyEngine.unregisterProcess(child.pid);
+                        });
+                    }
+                    let stdout = '';
+                    let stderr = '';
+                    child.stdout?.on('data', (data) => {
+                        if (stdout.length < 10240) {
+                            stdout += data.toString();
+                        }
+                    });
+                    child.stderr?.on('data', (data) => {
+                        if (stderr.length < 5120) {
+                            stderr += data.toString();
+                        }
+                    });
+                    let timer = setTimeout(() => {
+                        child.kill();
+                        resolve({
+                            success: false,
+                            output: stdout,
+                            error: 'Command timed out after 60s.\n' + stderr
+                        });
+                    }, 60000);
+                    child.on('close', (code) => {
+                        clearTimeout(timer);
+                        resolve({
+                            success: code === 0,
+                            output: stdout.slice(0, 10240),
+                            error: stderr.slice(0, 5120),
+                            metadata: { code }
+                        });
+                    });
+                    child.on('error', (err) => {
+                        clearTimeout(timer);
+                        resolve({
+                            success: false,
+                            output: stdout,
+                            error: err.message
+                        });
+                    });
+                });
+            }
+        }
+    ];
+}

package/dist/src/tools/symbols.d.ts

@@ -0,0 +1,30 @@
+export interface CodeSymbol {
+    name: string;
+    kind: 'function' | 'class' | 'interface' | 'type' | 'variable' | 'export';
+    line: number;
+    file: string;
+}
+export interface SymbolReference {
+    file: string;
+    line: number;
+    context: string;
+}
+export interface ChangeImpact {
+    targetFile: string;
+    symbolsChanged: string[];
+    referencingFiles: string[];
+    affectedTests: string[];
+}
+/**
+ * Lightweight regex-based AST extractor for common languages (TS, JS, Python, Go)
+ */
+export declare function extractSymbols(content: string, filePath: string): CodeSymbol[];
+/**
+ * Finds all references to a symbol across files in a directory
+ */
+export declare function findSymbolReferences(cwd: string, symbolName: string, excludes?: string[]): Promise<SymbolReference[]>;
+/**
+ * Computes change-impact analysis: given a file, discovers its symbols,
+ * referencing files, and matching tests.
+ */
+export declare function analyzeChangeImpact(cwd: string, targetFile: string): Promise<ChangeImpact>;

package/dist/src/tools/symbols.js

@@ -0,0 +1,155 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+/**
+ * Lightweight regex-based AST extractor for common languages (TS, JS, Python, Go)
+ */
+export function extractSymbols(content, filePath) {
+    const symbols = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        const lineNum = i + 1;
+        // TypeScript / JavaScript
+        const fnMatch = line.match(/^(?:export\s+)?(?:async\s+)?function\s+([a-zA-Z0-9_$]+)/);
+        if (fnMatch) {
+            symbols.push({ name: fnMatch[1], kind: 'function', line: lineNum, file: filePath });
+            continue;
+        }
+        const classMatch = line.match(/^(?:export\s+)?(?:abstract\s+)?class\s+([a-zA-Z0-9_$]+)/);
+        if (classMatch) {
+            symbols.push({ name: classMatch[1], kind: 'class', line: lineNum, file: filePath });
+            continue;
+        }
+        const interfaceMatch = line.match(/^(?:export\s+)?interface\s+([a-zA-Z0-9_$]+)/);
+        if (interfaceMatch) {
+            symbols.push({ name: interfaceMatch[1], kind: 'interface', line: lineNum, file: filePath });
+            continue;
+        }
+        const typeMatch = line.match(/^(?:export\s+)?type\s+([a-zA-Z0-9_$]+)\s*=/);
+        if (typeMatch) {
+            symbols.push({ name: typeMatch[1], kind: 'type', line: lineNum, file: filePath });
+            continue;
+        }
+        const constFnMatch = line.match(/^(?:export\s+)?const\s+([a-zA-Z0-9_$]+)\s*=\s*(?:async\s*)?\(/);
+        if (constFnMatch) {
+            symbols.push({ name: constFnMatch[1], kind: 'function', line: lineNum, file: filePath });
+            continue;
+        }
+        // Python
+        const pyDef = line.match(/^def\s+([a-zA-Z0-9_]+)\s*\(/);
+        if (pyDef) {
+            symbols.push({ name: pyDef[1], kind: 'function', line: lineNum, file: filePath });
+            continue;
+        }
+        const pyClass = line.match(/^class\s+([a-zA-Z0-9_]+)/);
+        if (pyClass) {
+            symbols.push({ name: pyClass[1], kind: 'class', line: lineNum, file: filePath });
+            continue;
+        }
+        // Go
+        const goFn = line.match(/^func\s+(?:\([a-zA-Z0-9_*\s]+\)\s+)?([a-zA-Z0-9_]+)\s*\(/);
+        if (goFn) {
+            symbols.push({ name: goFn[1], kind: 'function', line: lineNum, file: filePath });
+            continue;
+        }
+    }
+    return symbols;
+}
+/**
+ * Finds all references to a symbol across files in a directory
+ */
+export async function findSymbolReferences(cwd, symbolName, excludes = ['node_modules', '.git', 'dist', 'build']) {
+    const references = [];
+    const regex = new RegExp(`\\b${symbolName}\\b`);
+    async function scan(dir) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relPath = path.relative(cwd, fullPath);
+            if (entry.isDirectory()) {
+                if (excludes.some(ex => relPath.split(path.sep).includes(ex)))
+                    continue;
+                await scan(fullPath);
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name).toLowerCase();
+                if (!['.ts', '.js', '.jsx', '.tsx', '.py', '.go', '.rs'].includes(ext))
+                    continue;
+                try {
+                    const content = await fs.readFile(fullPath, 'utf8');
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        if (regex.test(lines[i])) {
+                            references.push({
+                                file: relPath.replace(/\\/g, '/'),
+                                line: i + 1,
+                                context: lines[i].trim()
+                            });
+                        }
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    await scan(cwd);
+    return references;
+}
+/**
+ * Computes change-impact analysis: given a file, discovers its symbols,
+ * referencing files, and matching tests.
+ */
+export async function analyzeChangeImpact(cwd, targetFile) {
+    const absPath = path.isAbsolute(targetFile) ? targetFile : path.join(cwd, targetFile);
+    const relPath = path.relative(cwd, absPath).replace(/\\/g, '/');
+    let content = '';
+    try {
+        content = await fs.readFile(absPath, 'utf8');
+    }
+    catch {
+        return { targetFile: relPath, symbolsChanged: [], referencingFiles: [], affectedTests: [] };
+    }
+    const symbols = extractSymbols(content, relPath);
+    const referencingFilesSet = new Set();
+    const affectedTestsSet = new Set();
+    // Check direct test mapping
+    const baseName = path.basename(relPath, path.extname(relPath));
+    const testPatterns = [
+        `tests/${baseName}.test.ts`,
+        `tests/${baseName}.test.js`,
+        `test/${baseName}.test.ts`,
+        `tests/test_${baseName}.py`,
+        `${baseName}_test.go`
+    ];
+    for (const tp of testPatterns) {
+        try {
+            await fs.access(path.join(cwd, tp));
+            affectedTestsSet.add(tp);
+        }
+        catch { }
+    }
+    // Scan top 5 symbols for callers
+    for (const sym of symbols.slice(0, 5)) {
+        const refs = await findSymbolReferences(cwd, sym.name);
+        for (const ref of refs) {
+            if (ref.file !== relPath) {
+                referencingFilesSet.add(ref.file);
+                if (ref.file.toLowerCase().includes('test') || ref.file.toLowerCase().includes('spec')) {
+                    affectedTestsSet.add(ref.file);
+                }
+            }
+        }
+    }
+    return {
+        targetFile: relPath,
+        symbolsChanged: symbols.map(s => `${s.kind} ${s.name}`),
+        referencingFiles: Array.from(referencingFilesSet),
+        affectedTests: Array.from(affectedTestsSet)
+    };
+}

package/dist/src/tools/types.d.ts

@@ -0,0 +1,28 @@
+import { PermissionTier } from '../config/types.js';
+export interface ToolParameter {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    description: string;
+    required: boolean;
+    enum?: string[];
+    items?: {
+        type: string;
+    };
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: ToolParameter[];
+    tier: PermissionTier;
+}
+export interface ToolResult {
+    success: boolean;
+    output: string;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+export type ToolHandler = (params: Record<string, unknown>) => Promise<ToolResult>;
+export interface Tool {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+}

package/dist/src/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/tools/web_search.d.ts

@@ -0,0 +1,14 @@
+export interface WebSearchResult {
+    title: string;
+    snippet: string;
+    url: string;
+}
+export interface WebSearchResponse {
+    query: string;
+    results: WebSearchResult[];
+    totalResults: number;
+}
+/**
+ * Executes a web search using DuckDuckGo HTML endpoint without external dependencies.
+ */
+export declare function searchWeb(query: string, maxResults?: number): Promise<WebSearchResponse>;

package/dist/src/tools/web_search.js

@@ -0,0 +1,154 @@
+import * as https from 'node:https';
+import * as http from 'node:http';
+import { URL } from 'node:url';
+/**
+ * Clean HTML tags and decode HTML entities from text.
+ */
+function cleanHtml(raw) {
+    return raw
+        .replace(/<[^>]+>/g, '')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/**
+ * Standard-library HTTP GET helper with timeout.
+ */
+function fetchText(urlStr, timeoutMs = 8000) {
+    return new Promise((resolve, reject) => {
+        const parsedUrl = new URL(urlStr);
+        const client = parsedUrl.protocol === 'https:' ? https : http;
+        const req = client.get(urlStr, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                Accept: 'text/html,application/xhtml+xml,application/json,*/*',
+                'Accept-Language': 'en-US,en;q=0.9',
+            },
+        }, (res) => {
+            // Follow redirect (301, 302)
+            if (res.statusCode &&
+                res.statusCode >= 300 &&
+                res.statusCode < 400 &&
+                res.headers.location) {
+                const redirectUrl = new URL(res.headers.location, urlStr).toString();
+                return fetchText(redirectUrl, timeoutMs).then(resolve).catch(reject);
+            }
+            if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
+                return reject(new Error(`HTTP request failed with status ${res.statusCode}`));
+            }
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => resolve(data));
+        });
+        req.on('error', reject);
+        req.setTimeout(timeoutMs, () => {
+            req.destroy();
+            reject(new Error(`Search request timed out after ${timeoutMs}ms`));
+        });
+    });
+}
+/**
+ * Executes a web search using DuckDuckGo HTML endpoint without external dependencies.
+ */
+export async function searchWeb(query, maxResults = 5) {
+    const cleanQuery = query.trim();
+    if (!cleanQuery) {
+        return { query: '', results: [], totalResults: 0 };
+    }
+    const encoded = encodeURIComponent(cleanQuery);
+    const searchUrl = `https://html.duckduckgo.com/html/?q=${encoded}`;
+    try {
+        const html = await fetchText(searchUrl, 10000);
+        const results = [];
+        // Parse DuckDuckGo HTML results
+        // Matches: <a class="result__snippet" ...>...</a> and result links
+        const resultBlocks = html.split(/class="result\s+results_links/i).slice(1);
+        for (const block of resultBlocks) {
+            if (results.length >= maxResults)
+                break;
+            // Title & URL
+            const linkMatch = block.match(/<a[^>]+class="result__url"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i) ||
+                block.match(/<a[^>]+class="result__snippet"[^>]+href="([^"]+)"[^>]*>/i);
+            const titleMatch = block.match(/<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i);
+            const snippetMatch = block.match(/<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/i);
+            let url = '';
+            if (titleMatch && titleMatch[1]) {
+                url = titleMatch[1];
+            }
+            else if (linkMatch && linkMatch[1]) {
+                url = linkMatch[1];
+            }
+            // Unwrap DuckDuckGo redirect uddg= if present
+            if (url.includes('uddg=')) {
+                try {
+                    const match = url.match(/uddg=([^&]+)/);
+                    if (match)
+                        url = decodeURIComponent(match[1]);
+                }
+                catch { }
+            }
+            const title = titleMatch ? cleanHtml(titleMatch[2]) : cleanQuery;
+            const snippet = snippetMatch ? cleanHtml(snippetMatch[1]) : '';
+            if (url && (title || snippet)) {
+                results.push({
+                    title: title || cleanQuery,
+                    snippet: snippet || 'No snippet available',
+                    url,
+                });
+            }
+        }
+        // Fallback if HTML layout changes: DuckDuckGo instant API
+        if (results.length === 0) {
+            try {
+                const apiUrl = `https://api.duckduckgo.com/?q=${encoded}&format=json&no_html=1&skip_disambig=1`;
+                const jsonText = await fetchText(apiUrl, 5000);
+                const data = JSON.parse(jsonText);
+                if (data.AbstractText) {
+                    results.push({
+                        title: data.Heading || cleanQuery,
+                        snippet: data.AbstractText,
+                        url: data.AbstractURL || 'https://duckduckgo.com',
+                    });
+                }
+                if (Array.isArray(data.RelatedTopics)) {
+                    for (const topic of data.RelatedTopics) {
+                        if (results.length >= maxResults)
+                            break;
+                        if (topic.Text && topic.FirstURL) {
+                            results.push({
+                                title: topic.Text.split(' - ')[0] || cleanQuery,
+                                snippet: topic.Text,
+                                url: topic.FirstURL,
+                            });
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
+        return {
+            query: cleanQuery,
+            results,
+            totalResults: results.length,
+        };
+    }
+    catch (err) {
+        // Return empty results with error message rather than crashing
+        return {
+            query: cleanQuery,
+            results: [
+                {
+                    title: `Search error for: ${cleanQuery}`,
+                    snippet: `Unable to retrieve live search results: ${err.message}`,
+                    url: `https://duckduckgo.com/?q=${encoded}`,
+                },
+            ],
+            totalResults: 0,
+        };
+    }
+}

package/install.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env sh
+
+set -e
+
+INSTALL_DIR="${OVERARCH_INSTALL_DIR:-$HOME/.local/bin}"
+
+mkdir -p "$INSTALL_DIR"
+
+SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+
+rm -rf "$HOME/.overarch-dist"
+cp -R "$SCRIPT_DIR/dist" "$HOME/.overarch-dist"
+
+cp "$SCRIPT_DIR/overarch" "$INSTALL_DIR/overarch"
+
+chmod +x "$INSTALL_DIR/overarch"
+
+echo "✓ Overarch CLI v0.8.0 installed to:"
+echo "  $INSTALL_DIR/overarch"
+
+case ":$PATH:" in
+  *":$INSTALL_DIR:"*)
+    ;;
+  *)
+    echo
+    echo "Add this directory to your PATH:"
+    echo "  export PATH=\"\$PATH:$INSTALL_DIR\""
+    ;;
+esac

package/overarch

@@ -0,0 +1,15 @@
+#!/usr/bin/env sh
+# Overarch CLI v0.8.0
+# Linux (ARM64 / aarch64)
+
+set -e
+
+SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+
+if ! command -v node >/dev/null 2>&1; then
+  echo "Error: Node.js >= 20 is required to run Overarch."
+  echo "Install Node.js from https://nodejs.org or your package manager."
+  exit 1
+fi
+
+exec node "$SCRIPT_DIR/dist/bin/overarch.js" "$@"

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "overarch-linux-arm64",
+  "version": "0.8.0",
+  "description": "Overarch CLI platform package for Linux (ARM64 / aarch64)",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "bin": "./overarch",
+  "files": [
+    "overarch",
+    "install.sh",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "author": "Yatharth Roy (The Thursday AI Company of New Delhi)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yritb/overarch.git"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}