openplanter 0.1.0

package/dist/tools.js

@@ -0,0 +1,1454 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as zlib from "node:zlib";
+import { spawn, execSync } from "node:child_process";
+import * as http from "node:http";
+import * as https from "node:https";
+import { PatchApplyError, apply_agent_patch, parse_agent_patch, } from "./patching.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const _MAX_WALK_ENTRIES = 50_000;
+const _WS_RE = /\s+/g;
+const _HASHLINE_PREFIX_RE = /^\d+:[0-9a-f]{2}\|/;
+const _HEREDOC_RE = /<<-?\s*['"]?\w+['"]?/;
+const _INTERACTIVE_RE = /(^|[;&|]\s*)(vim|nano|less|more|top|htop|man)\b/;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** 2-char hex hash, whitespace-invariant. */
+function _line_hash(line) {
+    const normalized = line.replace(_WS_RE, "");
+    const crc = zlib.crc32(Buffer.from(normalized, "utf-8"));
+    return (crc & 0xff).toString(16).padStart(2, "0");
+}
+// ---------------------------------------------------------------------------
+// ToolError
+// ---------------------------------------------------------------------------
+export class ToolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ToolError";
+    }
+}
+// ---------------------------------------------------------------------------
+// WorkspaceTools
+// ---------------------------------------------------------------------------
+export class WorkspaceTools {
+    root;
+    shell;
+    commandTimeoutSec;
+    maxShellOutputChars;
+    maxFileChars;
+    maxFilesListed;
+    maxSearchHits;
+    exaApiKey;
+    exaBaseUrl;
+    _bgJobs = new Map();
+    _bgNextId = 1;
+    // Runtime policy state
+    _filesRead = new Set();
+    _parallelWriteClaims = new Map();
+    // Scope-local state (simulated via simple fields; Node is single-threaded)
+    _scopeGroupId = null;
+    _scopeOwnerId = null;
+    // ------------------------------------------------------------------
+    // Domain tools (tools/ directory CLI scripts)
+    // ------------------------------------------------------------------
+    static _DOMAIN_TOOL_SCRIPTS = {
+        aph_holdings: "aph_holdings.py",
+        asx_parser: "asx_parser.py",
+        asx_calendar_fetcher: "asx_calendar_fetcher.py",
+        bulk_asx_announcements: "bulk_asx_announcements.py",
+        asic_officer_lookup: "asic_officer_lookup.py",
+        entity_resolver: "entity_resolver.py",
+        hotcopper_scraper: "hotcopper_scraper.py",
+        insider_graph: "insider_graph.py",
+        insider_suspicion_scorer: "insider_suspicion_scorer.py",
+        multi_forum_scraper: "multi_forum_scraper.py",
+        price_fetcher: "price_fetcher.py",
+        timeline_linker: "timeline_linker.py",
+        volume_scanner: "volume_scanner.py",
+    };
+    static _DOMAIN_ARG_MAP = {
+        asx_calendar_fetcher: {
+            tickers: "--tickers",
+            period: "--period",
+            format: "--format",
+            test: "--test",
+        },
+        bulk_asx_announcements: {
+            tickers: "--tickers",
+            types: "--types",
+            days_back: "--days-back",
+            output_dir: "--output-dir",
+            format: "--format",
+            test: "--test",
+        },
+        asic_officer_lookup: {
+            abn_or_ticker: "--abn-or-ticker",
+            max_results: "--max-results",
+            format: "--format",
+            test: "--test",
+        },
+        multi_forum_scraper: {
+            ticker: "--ticker",
+            sites: "--sites",
+            days: "--days",
+            keywords: "--keywords",
+            format: "--format",
+            test: "--test",
+        },
+        insider_suspicion_scorer: {
+            trades: "--trades",
+            anomalies: "--anomalies",
+            rumors: "--rumors",
+            holdings: "--holdings",
+            output: "--output",
+            min_score: "--min-score",
+            format: "--format",
+            test: "--test",
+        },
+        aph_holdings: {
+            member: "--member",
+            chamber: "--chamber",
+            cache_dir: "--cache-dir",
+            test: "--test",
+        },
+        asx_parser: {
+            input: "--input",
+            type: "--type",
+            test: "--test",
+        },
+        entity_resolver: {
+            mode: "--mode",
+            input: "--input",
+            reference: "--reference",
+            threshold: "--threshold",
+            test: "--test",
+        },
+        hotcopper_scraper: {
+            ticker: "--ticker",
+            days: "--days",
+            pages: "--pages",
+            format: "--format",
+            test: "--test",
+        },
+        insider_graph: {
+            input: "--input",
+            mode: "--mode",
+            find_path: "--find-path",
+            connections: "--connections",
+            depth: "--depth",
+            clusters: "--clusters",
+            suspicion: "--suspicion",
+            export_format: "--export-format",
+            stats: "--stats",
+            test: "--test",
+        },
+        price_fetcher: {
+            tickers: "--tickers",
+            period: "--period",
+            interval: "--interval",
+            format: "--format",
+            anomalies_only: "--anomalies-only",
+            summary: "--summary",
+            test: "--test",
+        },
+        timeline_linker: {
+            trades: "--trades",
+            events: "--events",
+            window: "--window",
+            min_score: "--min-score",
+            date_from: "--from",
+            date_to: "--to",
+            summary: "--summary",
+            test: "--test",
+        },
+        volume_scanner: {
+            tickers: "--tickers",
+            watchlist: "--watchlist",
+            days: "--days",
+            threshold: "--threshold",
+            format: "--format",
+            report_dates: "--report-dates",
+            test: "--test",
+        },
+    };
+    constructor(opts) {
+        const resolved = path.resolve(opts.root);
+        if (!fs.existsSync(resolved)) {
+            throw new ToolError(`Workspace does not exist: ${resolved}`);
+        }
+        const stat = fs.statSync(resolved);
+        if (!stat.isDirectory()) {
+            throw new ToolError(`Workspace is not a directory: ${resolved}`);
+        }
+        this.root = resolved;
+        this.shell = opts.shell ?? "/bin/sh";
+        this.commandTimeoutSec = opts.commandTimeoutSec ?? 45;
+        this.maxShellOutputChars = opts.maxShellOutputChars ?? 16000;
+        this.maxFileChars = opts.maxFileChars ?? 20000;
+        this.maxFilesListed = opts.maxFilesListed ?? 400;
+        this.maxSearchHits = opts.maxSearchHits ?? 200;
+        this.exaApiKey = opts.exaApiKey ?? null;
+        this.exaBaseUrl = opts.exaBaseUrl ?? "https://api.exa.ai";
+    }
+    // ------------------------------------------------------------------
+    // Private helpers
+    // ------------------------------------------------------------------
+    _clip(text, maxChars) {
+        if (text.length <= maxChars) {
+            return text;
+        }
+        const omitted = text.length - maxChars;
+        return `${text.slice(0, maxChars)}\n\n...[truncated ${omitted} chars]...`;
+    }
+    _resolvePath(rawPath) {
+        let candidate;
+        if (path.isAbsolute(rawPath)) {
+            candidate = rawPath;
+        }
+        else {
+            candidate = path.join(this.root, rawPath);
+        }
+        const resolved = path.resolve(candidate);
+        if (resolved === this.root) {
+            return resolved;
+        }
+        const relative = path.relative(this.root, resolved);
+        if (relative.startsWith("..") || path.isAbsolute(relative)) {
+            throw new ToolError(`Path escapes workspace: ${rawPath}`);
+        }
+        return resolved;
+    }
+    _checkShellPolicy(command) {
+        if (_HEREDOC_RE.test(command)) {
+            return ("BLOCKED: Heredoc syntax (<< EOF) is not allowed by runtime policy. " +
+                "Use write_file/apply_patch for multi-line content.");
+        }
+        if (_INTERACTIVE_RE.test(command)) {
+            return ("BLOCKED: Interactive terminal programs are not allowed by runtime policy " +
+                "(vim/nano/less/more/top/htop/man).");
+        }
+        return null;
+    }
+    _registerWriteTarget(resolved) {
+        const groupId = this._scopeGroupId;
+        const ownerId = this._scopeOwnerId;
+        if (!groupId || !ownerId) {
+            return;
+        }
+        let claims = this._parallelWriteClaims.get(groupId);
+        if (!claims) {
+            claims = new Map();
+            this._parallelWriteClaims.set(groupId, claims);
+        }
+        const owner = claims.get(resolved);
+        if (owner === undefined) {
+            claims.set(resolved, ownerId);
+            return;
+        }
+        if (owner !== ownerId) {
+            const rel = path.relative(this.root, resolved).split(path.sep).join("/");
+            throw new ToolError(`Parallel write conflict: '${rel}' is already claimed by sibling task ${owner}.`);
+        }
+    }
+    // ------------------------------------------------------------------
+    // Parallel write group management
+    // ------------------------------------------------------------------
+    beginParallelWriteGroup(groupId) {
+        this._parallelWriteClaims.set(groupId, new Map());
+    }
+    endParallelWriteGroup(groupId) {
+        this._parallelWriteClaims.delete(groupId);
+    }
+    executionScope(groupId, ownerId, fn) {
+        const prevGroup = this._scopeGroupId;
+        const prevOwner = this._scopeOwnerId;
+        this._scopeGroupId = groupId;
+        this._scopeOwnerId = ownerId;
+        try {
+            return fn();
+        }
+        finally {
+            this._scopeGroupId = prevGroup;
+            this._scopeOwnerId = prevOwner;
+        }
+    }
+    async executionScopeAsync(groupId, ownerId, fn) {
+        const prevGroup = this._scopeGroupId;
+        const prevOwner = this._scopeOwnerId;
+        this._scopeGroupId = groupId;
+        this._scopeOwnerId = ownerId;
+        try {
+            return await fn();
+        }
+        finally {
+            this._scopeGroupId = prevGroup;
+            this._scopeOwnerId = prevOwner;
+        }
+    }
+    // ------------------------------------------------------------------
+    // Shell execution
+    // ------------------------------------------------------------------
+    async runShell(command, timeout) {
+        const policyError = this._checkShellPolicy(command);
+        if (policyError) {
+            return policyError;
+        }
+        const effectiveTimeout = Math.max(1, Math.min(timeout ?? this.commandTimeoutSec, 600));
+        return new Promise((resolve) => {
+            let proc;
+            try {
+                proc = spawn(command, {
+                    shell: this.shell,
+                    cwd: this.root,
+                    stdio: ["ignore", "pipe", "pipe"],
+                    detached: true,
+                });
+            }
+            catch (exc) {
+                resolve(`$ ${command}\n[failed to start: ${exc}]`);
+                return;
+            }
+            let stdout = "";
+            let stderr = "";
+            let finished = false;
+            proc.stdout?.on("data", (chunk) => {
+                stdout += chunk.toString("utf-8");
+            });
+            proc.stderr?.on("data", (chunk) => {
+                stderr += chunk.toString("utf-8");
+            });
+            const timer = setTimeout(() => {
+                if (!finished) {
+                    finished = true;
+                    try {
+                        if (proc.pid !== undefined) {
+                            process.kill(-proc.pid, "SIGKILL");
+                        }
+                    }
+                    catch {
+                        try {
+                            proc.kill("SIGKILL");
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    resolve(`$ ${command}\n[timeout after ${effectiveTimeout}s — processes killed]`);
+                }
+            }, effectiveTimeout * 1000);
+            proc.on("close", (code) => {
+                if (!finished) {
+                    finished = true;
+                    clearTimeout(timer);
+                    const merged = `$ ${command}\n` +
+                        `[exit_code=${code ?? -1}]\n` +
+                        `[stdout]\n${stdout}\n` +
+                        `[stderr]\n${stderr}`;
+                    resolve(this._clip(merged, this.maxShellOutputChars));
+                }
+            });
+            proc.on("error", (err) => {
+                if (!finished) {
+                    finished = true;
+                    clearTimeout(timer);
+                    resolve(`$ ${command}\n[failed to start: ${err}]`);
+                }
+            });
+        });
+    }
+    runShellBg(command) {
+        const policyError = this._checkShellPolicy(command);
+        if (policyError) {
+            return policyError;
+        }
+        const outPath = path.join(os.tmpdir(), `.rlm_bg_${this._bgNextId}.out`);
+        const fd = fs.openSync(outPath, "w+");
+        let proc;
+        try {
+            proc = spawn(command, {
+                shell: this.shell,
+                cwd: this.root,
+                stdio: ["ignore", fd, fd],
+                detached: true,
+            });
+        }
+        catch (exc) {
+            fs.closeSync(fd);
+            try {
+                fs.unlinkSync(outPath);
+            }
+            catch {
+                // ignore
+            }
+            return `Failed to start background command: ${exc}`;
+        }
+        const jobId = this._bgNextId;
+        this._bgNextId += 1;
+        this._bgJobs.set(jobId, { proc, outPath, fd });
+        return `Background job started: job_id=${jobId}, pid=${proc.pid}`;
+    }
+    checkShellBg(jobId) {
+        const entry = this._bgJobs.get(jobId);
+        if (!entry) {
+            return `No background job with id ${jobId}`;
+        }
+        const { proc, outPath, fd } = entry;
+        const exitCode = proc.exitCode;
+        let output = "";
+        try {
+            output = fs.readFileSync(outPath, "utf-8");
+        }
+        catch {
+            // ignore
+        }
+        output = this._clip(output, this.maxShellOutputChars);
+        if (exitCode !== null) {
+            fs.closeSync(fd);
+            try {
+                fs.unlinkSync(outPath);
+            }
+            catch {
+                // ignore
+            }
+            this._bgJobs.delete(jobId);
+            return `[job ${jobId} finished, exit_code=${exitCode}]\n${output}`;
+        }
+        return `[job ${jobId} still running, pid=${proc.pid}]\n${output}`;
+    }
+    killShellBg(jobId) {
+        const entry = this._bgJobs.get(jobId);
+        if (!entry) {
+            return `No background job with id ${jobId}`;
+        }
+        const { proc, outPath, fd } = entry;
+        try {
+            if (proc.pid !== undefined) {
+                process.kill(-proc.pid, "SIGKILL");
+            }
+        }
+        catch {
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch {
+                // ignore
+            }
+        }
+        fs.closeSync(fd);
+        try {
+            fs.unlinkSync(outPath);
+        }
+        catch {
+            // ignore
+        }
+        this._bgJobs.delete(jobId);
+        return `Background job ${jobId} killed.`;
+    }
+    cleanupBgJobs() {
+        for (const [jobId, { proc, outPath, fd }] of this._bgJobs) {
+            try {
+                if (proc.pid !== undefined) {
+                    process.kill(-proc.pid, "SIGKILL");
+                }
+            }
+            catch {
+                try {
+                    proc.kill("SIGKILL");
+                }
+                catch {
+                    // ignore
+                }
+            }
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                // ignore
+            }
+            try {
+                fs.unlinkSync(outPath);
+            }
+            catch {
+                // ignore
+            }
+        }
+        this._bgJobs.clear();
+    }
+    // ------------------------------------------------------------------
+    // File listing & search
+    // ------------------------------------------------------------------
+    async listFiles(glob) {
+        let lines;
+        if (this._hasRg()) {
+            const cmd = ["rg", "--files", "--hidden", "-g", "!.git"];
+            if (glob) {
+                cmd.push("-g", glob);
+            }
+            const result = await this._spawnCapture(cmd, this.root, this.commandTimeoutSec);
+            if (result === null) {
+                return "(list_files timed out)";
+            }
+            lines = result.stdout
+                .split("\n")
+                .filter((ln) => ln.trim() !== "");
+        }
+        else {
+            const allPaths = [];
+            await this._walkDir(this.root, allPaths, _MAX_WALK_ENTRIES);
+            lines = allPaths.sort();
+        }
+        if (lines.length === 0) {
+            return "(no files)";
+        }
+        const clipped = lines.slice(0, this.maxFilesListed);
+        let suffix = "";
+        if (lines.length > clipped.length) {
+            suffix = `\n...[omitted ${lines.length - clipped.length} files]...`;
+        }
+        return clipped.join("\n") + suffix;
+    }
+    async searchFiles(query, glob) {
+        if (!query.trim()) {
+            return "query cannot be empty";
+        }
+        if (this._hasRg()) {
+            const cmd = ["rg", "-n", "--hidden", "-S", query, "."];
+            if (glob) {
+                cmd.push("-g", glob);
+            }
+            const result = await this._spawnCapture(cmd, this.root, this.commandTimeoutSec);
+            if (result === null) {
+                return "(search_files timed out)";
+            }
+            const outLines = result.stdout
+                .split("\n")
+                .filter((ln) => ln.trim() !== "");
+            if (outLines.length === 0) {
+                return "(no matches)";
+            }
+            const clipped = outLines.slice(0, this.maxSearchHits);
+            let suffix = "";
+            if (outLines.length > clipped.length) {
+                suffix = `\n...[omitted ${outLines.length - clipped.length} matches]...`;
+            }
+            return clipped.join("\n") + suffix;
+        }
+        // Fallback: manual walk + search
+        const matches = [];
+        const lowerQuery = query.toLowerCase();
+        const allPaths = [];
+        await this._walkDir(this.root, allPaths, _MAX_WALK_ENTRIES);
+        for (const rel of allPaths) {
+            const full = path.join(this.root, rel);
+            let text;
+            try {
+                text = await fsp.readFile(full, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const fileLines = text.split("\n");
+            for (let idx = 0; idx < fileLines.length; idx++) {
+                if (fileLines[idx].toLowerCase().includes(lowerQuery)) {
+                    matches.push(`${rel}:${idx + 1}:${fileLines[idx]}`);
+                    if (matches.length >= this.maxSearchHits) {
+                        return matches.join("\n") + "\n...[match limit reached]...";
+                    }
+                }
+            }
+        }
+        return matches.length > 0 ? matches.join("\n") : "(no matches)";
+    }
+    // ------------------------------------------------------------------
+    // Repo map
+    // ------------------------------------------------------------------
+    async repoMap(glob, maxFiles = 200) {
+        const clamped = Math.max(1, Math.min(Math.floor(maxFiles), 500));
+        const candidates = await this._repoFiles(glob, clamped);
+        if (candidates.length === 0) {
+            return "(no files)";
+        }
+        const languageBySuffix = {
+            ".py": "python",
+            ".js": "javascript",
+            ".jsx": "javascript",
+            ".ts": "typescript",
+            ".tsx": "typescript",
+            ".go": "go",
+            ".rs": "rust",
+            ".java": "java",
+            ".c": "c",
+            ".h": "c",
+            ".cpp": "cpp",
+            ".hpp": "cpp",
+            ".cs": "csharp",
+            ".rb": "ruby",
+            ".php": "php",
+            ".swift": "swift",
+            ".kt": "kotlin",
+            ".scala": "scala",
+            ".sh": "shell",
+        };
+        const files = [];
+        for (const rel of candidates) {
+            const suffix = path.extname(rel).toLowerCase();
+            const language = languageBySuffix[suffix];
+            if (!language)
+                continue;
+            let resolved;
+            try {
+                resolved = this._resolvePath(rel);
+            }
+            catch {
+                continue;
+            }
+            let stat;
+            try {
+                stat = await fsp.stat(resolved);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            let text;
+            try {
+                text = await fsp.readFile(resolved, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const symbols = this._genericSymbols(text);
+            files.push({
+                path: rel,
+                language,
+                lines: text.split("\n").length,
+                symbols: symbols.slice(0, 200),
+            });
+        }
+        const output = {
+            root: this.root,
+            files,
+            total: files.length,
+        };
+        return this._clip(JSON.stringify(output, null, 2), this.maxFileChars);
+    }
+    // ------------------------------------------------------------------
+    // File read/write/edit
+    // ------------------------------------------------------------------
+    async readFile(filePath, hashline = true) {
+        const resolved = this._resolvePath(filePath);
+        let stat;
+        try {
+            stat = await fsp.stat(resolved);
+        }
+        catch {
+            return `File not found: ${filePath}`;
+        }
+        if (stat.isDirectory()) {
+            return `Path is a directory, not a file: ${filePath}`;
+        }
+        let text;
+        try {
+            text = await fsp.readFile(resolved, "utf-8");
+        }
+        catch (exc) {
+            return `Failed to read file ${filePath}: ${exc}`;
+        }
+        this._filesRead.add(resolved);
+        const clipped = this._clip(text, this.maxFileChars);
+        const rel = path.relative(this.root, resolved).split(path.sep).join("/");
+        const lines = clipped.split("\n");
+        let numbered;
+        if (hashline) {
+            numbered = lines
+                .map((line, i) => `${i + 1}:${_line_hash(line)}|${line}`)
+                .join("\n");
+        }
+        else {
+            numbered = lines.map((line, i) => `${i + 1}|${line}`).join("\n");
+        }
+        return `# ${rel}\n${numbered}`;
+    }
+    async writeFile(filePath, content) {
+        const resolved = this._resolvePath(filePath);
+        let exists = false;
+        let isFile = false;
+        try {
+            const stat = await fsp.stat(resolved);
+            exists = true;
+            isFile = stat.isFile();
+        }
+        catch {
+            // does not exist
+        }
+        if (exists && isFile && !this._filesRead.has(resolved)) {
+            return (`BLOCKED: ${filePath} already exists but has not been read. ` +
+                `Use read_file('${filePath}') first, then edit via apply_patch or write_file.`);
+        }
+        try {
+            this._registerWriteTarget(resolved);
+        }
+        catch (exc) {
+            return `Blocked by policy: ${exc}`;
+        }
+        try {
+            await fsp.mkdir(path.dirname(resolved), { recursive: true });
+            await fsp.writeFile(resolved, content, "utf-8");
+        }
+        catch (exc) {
+            return `Failed to write ${filePath}: ${exc}`;
+        }
+        this._filesRead.add(resolved);
+        const rel = path.relative(this.root, resolved).split(path.sep).join("/");
+        return `Wrote ${content.length} chars to ${rel}`;
+    }
+    async editFile(filePath, oldText, newText) {
+        const resolved = this._resolvePath(filePath);
+        let stat;
+        try {
+            stat = await fsp.stat(resolved);
+        }
+        catch {
+            return `File not found: ${filePath}`;
+        }
+        if (stat.isDirectory()) {
+            return `Path is a directory, not a file: ${filePath}`;
+        }
+        let content;
+        try {
+            content = await fsp.readFile(resolved, "utf-8");
+        }
+        catch (exc) {
+            return `Failed to read file ${filePath}: ${exc}`;
+        }
+        this._filesRead.add(resolved);
+        if (!content.includes(oldText)) {
+            // Fuzzy fallback: whitespace-normalized match
+            const normOld = oldText.split(/\s+/).join(" ");
+            const oldLines = oldText.split(/\n/);
+            const contentLines = content.split(/\n/);
+            let found = false;
+            for (let i = 0; i <= contentLines.length - oldLines.length; i++) {
+                const candidate = contentLines.slice(i, i + oldLines.length).join("\n");
+                if (candidate.split(/\s+/).join(" ") === normOld) {
+                    const before = contentLines.slice(0, i).join("\n");
+                    const after = contentLines.slice(i + oldLines.length).join("\n");
+                    content =
+                        (before ? before + "\n" : "") +
+                            newText +
+                            (after ? "\n" + after : "");
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                return `edit_file failed: old_text not found in ${filePath}`;
+            }
+        }
+        else {
+            const count = content.split(oldText).length - 1;
+            if (count > 1) {
+                return `edit_file failed: old_text appears ${count} times in ${filePath}. Provide more context to make it unique.`;
+            }
+            content = content.replace(oldText, newText);
+        }
+        try {
+            this._registerWriteTarget(resolved);
+        }
+        catch (exc) {
+            return `Blocked by policy: ${exc}`;
+        }
+        try {
+            await fsp.writeFile(resolved, content, "utf-8");
+        }
+        catch (exc) {
+            return `Failed to write ${filePath}: ${exc}`;
+        }
+        this._filesRead.add(resolved);
+        const rel = path.relative(this.root, resolved).split(path.sep).join("/");
+        return `Edited ${rel}`;
+    }
+    // ------------------------------------------------------------------
+    // Hashline edit
+    // ------------------------------------------------------------------
+    _validateAnchor(anchor, lineHashes, lines) {
+        const parts = anchor.split(":");
+        if (parts.length !== 2 ||
+            !/^\d+$/.test(parts[0]) ||
+            parts[1].length !== 2) {
+            return [-1, `Invalid anchor format: '${anchor}' (expected N:HH)`];
+        }
+        const lineno = parseInt(parts[0], 10);
+        const expectedHash = parts[1];
+        if (lineno < 1 || lineno > lines.length) {
+            return [
+                -1,
+                `Line ${lineno} out of range (file has ${lines.length} lines)`,
+            ];
+        }
+        const actualHash = lineHashes.get(lineno);
+        if (actualHash !== expectedHash) {
+            const ctxStart = Math.max(1, lineno - 2);
+            const ctxEnd = Math.min(lines.length, lineno + 2);
+            const ctxLines = [];
+            for (let i = ctxStart; i <= ctxEnd; i++) {
+                ctxLines.push(`  ${i}:${lineHashes.get(i)}|${lines[i - 1]}`);
+            }
+            return [
+                -1,
+                `Hash mismatch at line ${lineno}: expected ${expectedHash}, ` +
+                    `got ${actualHash}. Current context:\n` +
+                    ctxLines.join("\n"),
+            ];
+        }
+        return [lineno, null];
+    }
+    async hashlineEdit(filePath, edits) {
+        const resolved = this._resolvePath(filePath);
+        let stat;
+        try {
+            stat = await fsp.stat(resolved);
+        }
+        catch {
+            return `File not found: ${filePath}`;
+        }
+        if (stat.isDirectory()) {
+            return `Path is a directory, not a file: ${filePath}`;
+        }
+        let content;
+        try {
+            content = await fsp.readFile(resolved, "utf-8");
+        }
+        catch (exc) {
+            return `Failed to read file ${filePath}: ${exc}`;
+        }
+        this._filesRead.add(resolved);
+        const lines = content.split("\n");
+        const lineHashes = new Map();
+        for (let i = 0; i < lines.length; i++) {
+            lineHashes.set(i + 1, _line_hash(lines[i]));
+        }
+        const parsed = [];
+        for (const edit of edits) {
+            if ("set_line" in edit) {
+                const anchor = String(edit.set_line);
+                const [lineno, err] = this._validateAnchor(anchor, lineHashes, lines);
+                if (err)
+                    return err;
+                const raw = String(edit.content ?? "");
+                const newLine = raw.replace(_HASHLINE_PREFIX_RE, "");
+                parsed.push({ op: "set", start: lineno, end: lineno, newLines: [newLine] });
+            }
+            else if ("replace_lines" in edit) {
+                const rng = edit.replace_lines;
+                const startAnchor = String(rng.start ?? "");
+                const endAnchor = String(rng.end ?? "");
+                const [start, errStart] = this._validateAnchor(startAnchor, lineHashes, lines);
+                if (errStart)
+                    return errStart;
+                const [end, errEnd] = this._validateAnchor(endAnchor, lineHashes, lines);
+                if (errEnd)
+                    return errEnd;
+                if (end < start) {
+                    return `End line ${end} is before start line ${start}`;
+                }
+                const rawContent = String(edit.content ?? "");
+                const newLines = rawContent
+                    .split("\n")
+                    .map((ln) => ln.replace(_HASHLINE_PREFIX_RE, ""));
+                parsed.push({ op: "replace", start, end, newLines });
+            }
+            else if ("insert_after" in edit) {
+                const anchor = String(edit.insert_after);
+                const [lineno, err] = this._validateAnchor(anchor, lineHashes, lines);
+                if (err)
+                    return err;
+                const rawContent = String(edit.content ?? "");
+                const newLines = rawContent
+                    .split("\n")
+                    .map((ln) => ln.replace(_HASHLINE_PREFIX_RE, ""));
+                parsed.push({ op: "insert", start: lineno, end: lineno, newLines });
+            }
+            else {
+                return `Unknown edit operation: ${JSON.stringify(edit)}. Use set_line, replace_lines, or insert_after.`;
+            }
+        }
+        // Sort by line number descending so bottom-up application doesn't shift indices
+        parsed.sort((a, b) => b.start - a.start);
+        // Apply edits
+        let changed = 0;
+        for (const { op, start, end, newLines } of parsed) {
+            if (op === "set") {
+                if (lines[start - 1] !== newLines[0]) {
+                    lines[start - 1] = newLines[0];
+                    changed += 1;
+                }
+            }
+            else if (op === "replace") {
+                const oldSlice = lines.slice(start - 1, end);
+                if (oldSlice.length !== newLines.length ||
+                    oldSlice.some((l, i) => l !== newLines[i])) {
+                    lines.splice(start - 1, end - start + 1, ...newLines);
+                    changed += 1;
+                }
+            }
+            else if (op === "insert") {
+                lines.splice(start, 0, ...newLines);
+                changed += 1;
+            }
+        }
+        if (changed === 0) {
+            return `No changes needed in ${filePath}`;
+        }
+        let newContent = lines.join("\n");
+        if (content.endsWith("\n")) {
+            newContent += "\n";
+        }
+        try {
+            this._registerWriteTarget(resolved);
+        }
+        catch (exc) {
+            return `Blocked by policy: ${exc}`;
+        }
+        try {
+            await fsp.writeFile(resolved, newContent, "utf-8");
+        }
+        catch (exc) {
+            return `Failed to write ${filePath}: ${exc}`;
+        }
+        this._filesRead.add(resolved);
+        const rel = path.relative(this.root, resolved).split(path.sep).join("/");
+        return `Edited ${rel} (${changed} edit(s) applied)`;
+    }
+    // ------------------------------------------------------------------
+    // Patch
+    // ------------------------------------------------------------------
+    async applyPatch(patchText) {
+        if (!patchText.trim()) {
+            return "apply_patch requires non-empty patch text";
+        }
+        let ops;
+        try {
+            ops = parse_agent_patch(patchText);
+        }
+        catch (exc) {
+            if (exc instanceof PatchApplyError) {
+                return `Patch failed: ${exc.message}`;
+            }
+            throw exc;
+        }
+        try {
+            for (const op of ops) {
+                if ("plus_lines" in op) {
+                    // AddFileOp
+                    this._registerWriteTarget(this._resolvePath(op.path));
+                }
+                else if ("raw_lines" in op) {
+                    // UpdateFileOp
+                    this._registerWriteTarget(this._resolvePath(op.path));
+                    if (op.move_to) {
+                        this._registerWriteTarget(this._resolvePath(op.move_to));
+                    }
+                }
+                else {
+                    // DeleteFileOp
+                    this._registerWriteTarget(this._resolvePath(op.path));
+                }
+            }
+        }
+        catch (exc) {
+            if (exc instanceof ToolError) {
+                return `Blocked by policy: ${exc.message}`;
+            }
+            return `Blocked by policy: ${String(exc)}`;
+        }
+        try {
+            const report = apply_agent_patch(patchText, (rawPath) => this._resolvePath(rawPath));
+            for (const relPath of [...report.added, ...report.updated]) {
+                try {
+                    this._filesRead.add(this._resolvePath(relPath));
+                }
+                catch {
+                    // ignore
+                }
+            }
+            return report.render();
+        }
+        catch (exc) {
+            if (exc instanceof PatchApplyError) {
+                return `Patch failed: ${exc.message}`;
+            }
+            return `Patch failed: ${String(exc)}`;
+        }
+    }
+    // ------------------------------------------------------------------
+    // Exa API: web_search and fetch_url
+    // ------------------------------------------------------------------
+    static _EXA_MAX_RETRIES = 3;
+    static _EXA_BACKOFF_BASE = 1.0;
+    _exaDiagnoseNetwork() {
+        // Synchronous quick-check diagnostics
+        const hints = [];
+        for (const envVar of [
+            "HTTPS_PROXY",
+            "https_proxy",
+            "HTTP_PROXY",
+            "http_proxy",
+        ]) {
+            const val = process.env[envVar];
+            if (val) {
+                hints.push(`proxy ${envVar}=${val} is set`);
+                break;
+            }
+        }
+        return hints.length > 0
+            ? hints.join("; ")
+            : "no obvious network issue detected";
+    }
+    async _exaRequest(endpoint, payload) {
+        if (!this.exaApiKey?.trim()) {
+            throw new ToolError("EXA_API_KEY not configured");
+        }
+        const url = new URL(endpoint, this.exaBaseUrl.replace(/\/+$/, "") + "/");
+        const data = JSON.stringify(payload);
+        const headers = {
+            "x-api-key": this.exaApiKey,
+            "Content-Type": "application/json",
+            "User-Agent": "exa-py 1.0.18",
+        };
+        let lastExc = null;
+        for (let attempt = 0; attempt < WorkspaceTools._EXA_MAX_RETRIES; attempt++) {
+            try {
+                const raw = await this._httpPost(url.href, data, headers);
+                const parsed = JSON.parse(raw);
+                if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                    throw new ToolError(`Exa API returned non-object response: ${typeof parsed}`);
+                }
+                return parsed;
+            }
+            catch (exc) {
+                if (exc instanceof ToolError) {
+                    throw exc;
+                }
+                if (exc instanceof HttpError &&
+                    exc.statusCode < 500 &&
+                    exc.statusCode !== 429) {
+                    throw new ToolError(`Exa API HTTP ${exc.statusCode}: ${exc.body}`);
+                }
+                lastExc = exc;
+                if (attempt < WorkspaceTools._EXA_MAX_RETRIES - 1) {
+                    await this._sleep(WorkspaceTools._EXA_BACKOFF_BASE * 2 ** attempt);
+                }
+            }
+        }
+        const diag = this._exaDiagnoseNetwork();
+        throw new ToolError(`Exa API error after ${WorkspaceTools._EXA_MAX_RETRIES} attempts: ${lastExc} (diagnostics: ${diag})`);
+    }
+    async webSearch(query, numResults = 10, includeText = false) {
+        const trimmed = query.trim();
+        if (!trimmed) {
+            return "web_search requires non-empty query";
+        }
+        const clampedResults = Math.max(1, Math.min(Math.floor(numResults), 20));
+        const payload = {
+            query: trimmed,
+            numResults: clampedResults,
+        };
+        if (includeText) {
+            payload.contents = { text: { maxCharacters: 4000 } };
+        }
+        let parsed;
+        try {
+            parsed = await this._exaRequest("/search", payload);
+        }
+        catch (exc) {
+            return `Web search failed: ${exc}`;
+        }
+        const outResults = [];
+        const results = Array.isArray(parsed.results) ? parsed.results : [];
+        for (const row of results) {
+            if (typeof row !== "object" || row === null)
+                continue;
+            const r = row;
+            const item = {
+                url: String(r.url ?? ""),
+                title: String(r.title ?? ""),
+                snippet: String(r.highlight ?? r.snippet ?? ""),
+            };
+            if (includeText && typeof r.text === "string") {
+                item.text = this._clip(r.text, 4000);
+            }
+            outResults.push(item);
+        }
+        const output = {
+            query: trimmed,
+            results: outResults,
+            total: outResults.length,
+        };
+        return this._clip(JSON.stringify(output, null, 2), this.maxFileChars);
+    }
+    async fetchUrl(urls) {
+        if (!Array.isArray(urls)) {
+            return "fetch_url requires a list of URL strings";
+        }
+        const normalized = [];
+        for (const raw of urls) {
+            if (typeof raw !== "string")
+                continue;
+            const text = raw.trim();
+            if (text)
+                normalized.push(text);
+        }
+        if (normalized.length === 0) {
+            return "fetch_url requires at least one valid URL";
+        }
+        const capped = normalized.slice(0, 10);
+        const payload = {
+            ids: capped,
+            text: { maxCharacters: 8000 },
+        };
+        let parsed;
+        try {
+            parsed = await this._exaRequest("/contents", payload);
+        }
+        catch (exc) {
+            return `Fetch URL failed: ${exc}`;
+        }
+        const pages = [];
+        const results = Array.isArray(parsed.results) ? parsed.results : [];
+        for (const row of results) {
+            if (typeof row !== "object" || row === null)
+                continue;
+            const r = row;
+            pages.push({
+                url: String(r.url ?? ""),
+                title: String(r.title ?? ""),
+                text: this._clip(String(r.text ?? ""), 8000),
+            });
+        }
+        const output = {
+            pages,
+            total: pages.length,
+        };
+        return this._clip(JSON.stringify(output, null, 2), this.maxFileChars);
+    }
+    // ------------------------------------------------------------------
+    // Domain tools
+    // ------------------------------------------------------------------
+    async runDomainTool(toolName, args) {
+        const script = WorkspaceTools._DOMAIN_TOOL_SCRIPTS[toolName];
+        if (!script) {
+            return `Unknown domain tool: ${toolName}`;
+        }
+        // Navigate up from this file's location to the project root, then into tools/
+        const packageDir = path.resolve(path.dirname(new URL(import.meta.url).pathname), "..");
+        const scriptPath = path.join(packageDir, "tools", script);
+        if (!fs.existsSync(scriptPath)) {
+            return `Domain tool script not found: ${scriptPath}`;
+        }
+        const argMap = WorkspaceTools._DOMAIN_ARG_MAP[toolName] ?? {};
+        const cmdParts = ["python3", scriptPath];
+        for (const [paramName, cliFlag] of Object.entries(argMap)) {
+            const value = args[paramName];
+            if (value === undefined || value === null)
+                continue;
+            if (typeof value === "boolean") {
+                if (value)
+                    cmdParts.push(cliFlag);
+            }
+            else if (Array.isArray(value)) {
+                cmdParts.push(cliFlag);
+                for (const item of value) {
+                    cmdParts.push(String(item));
+                }
+            }
+            else {
+                cmdParts.push(cliFlag, String(value));
+            }
+        }
+        const timeout = Math.max(this.commandTimeoutSec, 120);
+        return new Promise((resolve) => {
+            let proc;
+            try {
+                proc = spawn(cmdParts[0], cmdParts.slice(1), {
+                    cwd: this.root,
+                    stdio: ["ignore", "pipe", "pipe"],
+                    detached: true,
+                });
+            }
+            catch (exc) {
+                resolve(`[${toolName}] failed to start: ${exc}`);
+                return;
+            }
+            let stdout = "";
+            let stderr = "";
+            let finished = false;
+            proc.stdout?.on("data", (chunk) => {
+                stdout += chunk.toString("utf-8");
+            });
+            proc.stderr?.on("data", (chunk) => {
+                stderr += chunk.toString("utf-8");
+            });
+            const timer = setTimeout(() => {
+                if (!finished) {
+                    finished = true;
+                    try {
+                        if (proc.pid !== undefined) {
+                            process.kill(-proc.pid, "SIGKILL");
+                        }
+                    }
+                    catch {
+                        try {
+                            proc.kill("SIGKILL");
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    resolve(`[${toolName}] timeout after ${timeout}s`);
+                }
+            }, timeout * 1000);
+            proc.on("close", (code) => {
+                if (!finished) {
+                    finished = true;
+                    clearTimeout(timer);
+                    let merged = "";
+                    if (stdout.trim())
+                        merged += stdout;
+                    if (stderr.trim())
+                        merged += `\n[stderr]\n${stderr}`;
+                    if (code !== 0) {
+                        merged = `[${toolName} exited with code ${code}]\n${merged}`;
+                    }
+                    resolve(this._clip(merged.trim(), this.maxShellOutputChars));
+                }
+            });
+            proc.on("error", (err) => {
+                if (!finished) {
+                    finished = true;
+                    clearTimeout(timer);
+                    resolve(`[${toolName}] failed to start: ${err}`);
+                }
+            });
+        });
+    }
+    // ------------------------------------------------------------------
+    // Internal utilities
+    // ------------------------------------------------------------------
+    _hasRg() {
+        try {
+            const result = execSync("which rg", {
+                stdio: "pipe",
+                timeout: 5000,
+            });
+            return result.toString().trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    _spawnCapture(cmd, cwd, timeoutSec) {
+        return new Promise((resolve) => {
+            let proc;
+            try {
+                proc = spawn(cmd[0], cmd.slice(1), {
+                    cwd,
+                    stdio: ["ignore", "pipe", "pipe"],
+                    detached: true,
+                });
+            }
+            catch {
+                resolve({ stdout: "", stderr: "", code: -1 });
+                return;
+            }
+            let stdout = "";
+            let stderr = "";
+            let finished = false;
+            proc.stdout?.on("data", (chunk) => {
+                stdout += chunk.toString("utf-8");
+            });
+            proc.stderr?.on("data", (chunk) => {
+                stderr += chunk.toString("utf-8");
+            });
+            const timer = setTimeout(() => {
+                if (!finished) {
+                    finished = true;
+                    try {
+                        if (proc.pid !== undefined) {
+                            process.kill(-proc.pid, "SIGKILL");
+                        }
+                    }
+                    catch {
+                        try {
+                            proc.kill("SIGKILL");
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    resolve(null);
+                }
+            }, timeoutSec * 1000);
+            proc.on("close", (code) => {
+                if (!finished) {
+                    finished = true;
+                    clearTimeout(timer);
+                    resolve({ stdout, stderr, code: code ?? -1 });
+                }
+            });
+            proc.on("error", () => {
+                if (!finished) {
+                    finished = true;
+                    clearTimeout(timer);
+                    resolve({ stdout: "", stderr: "", code: -1 });
+                }
+            });
+        });
+    }
+    async _walkDir(dir, allPaths, maxEntries) {
+        if (allPaths.length >= maxEntries)
+            return;
+        let entries;
+        try {
+            entries = await fsp.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (allPaths.length >= maxEntries)
+                return;
+            if (entry.name === ".git")
+                continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await this._walkDir(full, allPaths, maxEntries);
+            }
+            else if (entry.isFile()) {
+                const rel = path.relative(this.root, full).split(path.sep).join("/");
+                allPaths.push(rel);
+            }
+        }
+    }
+    async _repoFiles(glob, maxFiles) {
+        let lines;
+        if (this._hasRg()) {
+            const cmd = ["rg", "--files", "--hidden", "-g", "!.git"];
+            if (glob) {
+                cmd.push("-g", glob);
+            }
+            const result = await this._spawnCapture(cmd, this.root, this.commandTimeoutSec);
+            if (!result)
+                return [];
+            lines = result.stdout.split("\n").filter((ln) => ln.trim() !== "");
+        }
+        else {
+            const allPaths = [];
+            await this._walkDir(this.root, allPaths, _MAX_WALK_ENTRIES);
+            lines = allPaths;
+            if (glob) {
+                const globRe = this._globToRegex(glob);
+                lines = lines.filter((l) => globRe.test(l));
+            }
+        }
+        return lines.slice(0, maxFiles);
+    }
+    _globToRegex(glob) {
+        // Simple glob-to-regex: * -> [^/]*, ** -> .*, ? -> .
+        let pattern = glob
+            .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+            .replace(/\*\*/g, "\0")
+            .replace(/\*/g, "[^/]*")
+            .replace(/\0/g, ".*")
+            .replace(/\?/g, ".");
+        return new RegExp(`^${pattern}$`);
+    }
+    _genericSymbols(text) {
+        const patterns = [
+            [
+                /^\s*function\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/gm,
+                "function",
+            ],
+            [/^\s*class\s+([A-Za-z_][A-Za-z0-9_]*)\b/gm, "class"],
+            [
+                /^\s*(?:const|let|var)\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\(/gm,
+                "function",
+            ],
+        ];
+        const symbols = [];
+        for (const [regex, kind] of patterns) {
+            regex.lastIndex = 0;
+            let match;
+            while ((match = regex.exec(text)) !== null) {
+                const line = text.slice(0, match.index).split("\n").length;
+                symbols.push({ kind, name: match[1], line });
+            }
+        }
+        symbols.sort((a, b) => a.line - b.line);
+        return symbols;
+    }
+    _sleep(seconds) {
+        return new Promise((resolve) => setTimeout(resolve, seconds * 1000));
+    }
+    _httpPost(url, body, headers) {
+        return new Promise((resolve, reject) => {
+            const parsed = new URL(url);
+            const isHttps = parsed.protocol === "https:";
+            const lib = isHttps ? https : http;
+            const options = {
+                method: "POST",
+                hostname: parsed.hostname,
+                port: parsed.port || (isHttps ? 443 : 80),
+                path: parsed.pathname + parsed.search,
+                headers: {
+                    ...headers,
+                    "Content-Length": Buffer.byteLength(body, "utf-8").toString(),
+                },
+                timeout: this.commandTimeoutSec * 1000,
+            };
+            const req = lib.request(options, (res) => {
+                let data = "";
+                res.setEncoding("utf-8");
+                res.on("data", (chunk) => {
+                    data += chunk;
+                });
+                res.on("end", () => {
+                    const statusCode = res.statusCode ?? 0;
+                    if (statusCode >= 200 && statusCode < 300) {
+                        resolve(data);
+                    }
+                    else {
+                        reject(new HttpError(statusCode, data));
+                    }
+                });
+            });
+            req.on("error", reject);
+            req.on("timeout", () => {
+                req.destroy(new Error("Request timeout"));
+            });
+            req.write(body);
+            req.end();
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Internal HTTP error for retry logic
+// ---------------------------------------------------------------------------
+class HttpError extends Error {
+    statusCode;
+    body;
+    constructor(statusCode, body) {
+        super(`HTTP ${statusCode}`);
+        this.name = "HttpError";
+        this.statusCode = statusCode;
+        this.body = body;
+    }
+}
+//# sourceMappingURL=tools.js.map