@weavetab/mcp 2.5.0 → 2.5.1

package/dist/tools/click_and_wait.js

@@ -1,149 +0,0 @@
-// src/tools/click_and_wait.ts
-// Consolidated tool: find element + click + wait for response in one CDP round-trip
-// Eliminates the common pattern: browser_map → browser_click → browser_wait
-import { buildActionMap, findBestMatch, safeSelector, toMarkdownTable } from "../cdp/walker.js";
-import { recordAction, trackToolCall, detectStuckLoop } from "../intelligence/trail.js";
-import { waitForDOMStable } from "../sensors/guard.js";
-import { waitForNetworkIdle } from "../sensors/wait.js";
-import { ghostMove, ghostClick } from "../overlay/ghost.js";
-import { cacheActionMap, getCachedActionMap } from "../state/cache.js";
-import { storeSnapshot, computeDelta } from "../state/delta.js";
-import { sessionRegistry } from "../state/session.js";
-import { getConfigAgentId } from "../config/loader.js";
-import { operationMonitor } from "../sensors/operation_monitor.js";
-/**
- * Consolidated tool that combines element resolution, clicking, and waiting.
- * Eliminates 2-3 tool calls in the common pattern: find → click → wait
- */
-export async function weaveClickAndWait(session, args, config) {
-    const { id, label, intent, x, y, waitAfter = 500, waitForNetwork = true, includeMap = false, fast = false, tab_id } = args;
-    const { Page, DOM, Input } = session;
-    const startMs = Date.now();
-    const targetId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId ?? "default";
-    const operationId = `clickAndWait-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    operationMonitor.startOperation(operationId, 'browser_click_and_wait');
-    // Handle tab switching if tab_id is provided
-    let targetSession = session;
-    if (tab_id) {
-        const { connectToTab } = await import("../cdp/connector.js");
-        const client = await connectToTab(tab_id);
-        targetSession = client.session;
-    }
-    // Check for stuck loop before processing
-    const stuckCheck = detectStuckLoop();
-    if (stuckCheck.stuck) {
-        return {
-            success: false,
-            error_code: "STUCK_LOOP",
-            message: stuckCheck.diagnosis || "Agent is stuck in a loop",
-            suggestion: "Try a different approach or reset the loop counter",
-        };
-    }
-    // Get initial URL
-    const initialUrl = (await targetSession.Page.getFrameTree()).frameTree.frame.url;
-    // Build or get cached action map
-    let map = getCachedActionMap(targetId, initialUrl);
-    if (!map) {
-        map = await buildActionMap(targetSession, { lite: true }, targetId);
-        cacheActionMap(targetId, map);
-    }
-    await storeSnapshot(targetId, initialUrl, map.elements);
-    // Resolve element
-    let element;
-    if (id) {
-        element = map.elements.find((el) => el.id === id || el.id.endsWith(id));
-    }
-    if (!element && label) {
-        element = findBestMatch(map.elements, label);
-    }
-    if (!element && intent) {
-        element = findBestMatch(map.elements, intent);
-    }
-    if (!element && !x && !y) {
-        return {
-            success: false,
-            error_code: "ELEMENT_NOT_FOUND",
-            message: `Element not found with id="${id}", label="${label}", or intent="${intent}"`,
-            suggestion: "Try browser_map to see available elements, or use x/y coordinates",
-        };
-    }
-    const clickX = x ?? element?.x;
-    const clickY = y ?? element?.y;
-    const selector = element ? safeSelector(element) : undefined;
-    if (!clickX || !clickY) {
-        return {
-            success: false,
-            error_code: "NO_COORDINATES",
-            message: "Could not determine click coordinates",
-            suggestion: "Provide explicit x/y coordinates or ensure element has position data",
-        };
-    }
-    // Perform click with ghost move
-    await ghostMove(targetSession, clickX, clickY, config, element?.label || "target");
-    await ghostClick(targetSession, clickX, clickY, { pointerType: 'mouse' });
-    await new Promise(r => setTimeout(r, 30 + Math.random() * 40));
-    await targetSession.Input.dispatchMouseEvent({
-        type: 'mouseReleased',
-        x: clickX,
-        y: clickY,
-        button: 'left',
-        clickCount: 1,
-        pointerType: 'mouse'
-    });
-    // Wait for response
-    const waitStart = Date.now();
-    if (waitForNetwork) {
-        await Promise.all([
-            waitForDOMStable(targetSession, 50, 300),
-            waitForNetworkIdle(targetSession, waitAfter, waitAfter * 2).catch(() => { })
-        ]);
-    }
-    else {
-        await new Promise(r => setTimeout(r, waitAfter));
-    }
-    const waitedMs = Date.now() - waitStart;
-    // Check result
-    const finalUrl = (await targetSession.Page.getFrameTree()).frameTree.frame.url;
-    const urlChanged = finalUrl !== initialUrl;
-    let newMap = map;
-    let domChanged = false;
-    if (urlChanged || includeMap) {
-        newMap = await buildActionMap(targetSession, { lite: true }, targetId);
-        cacheActionMap(targetId, newMap);
-        const delta = computeDelta(targetId, initialUrl, newMap.elements);
-        domChanged = delta ? delta.added.length + delta.removed.length + delta.changed.length > 0 : urlChanged;
-    }
-    else {
-        const delta = computeDelta(targetId, initialUrl, map.elements);
-        domChanged = delta ? delta.added.length + delta.removed.length + delta.changed.length > 0 : false;
-    }
-    const executionMs = Date.now() - startMs;
-    // Track tool call
-    trackToolCall("browser_click_and_wait", element?.id || id || label || "coordinates", {
-        success: true,
-        urlChanged
-    });
-    recordAction({
-        timestamp: new Date().toISOString(),
-        tool: "browser_click_and_wait",
-        input: { ref: element?.id || id || label, waitAfter, waitForNetwork },
-        result: { success: true, urlChanged, domChanged, waitedMs },
-    });
-    operationMonitor.endOperation(operationId);
-    const result = {
-        success: true,
-        clicked: element?.label || "coordinates",
-        ref: element?.id || id || "coordinates",
-        execution_ms: executionMs,
-        tab_id: targetId,
-        url: finalUrl,
-        title: newMap?.title || "",
-        url_changed: urlChanged,
-        ...(includeMap ? { page_map: newMap ? toMarkdownTable(newMap.elements, finalUrl, newMap.title) : "" } : {}),
-        dom_changed: domChanged,
-        stuck_warning: false,
-        waited_ms: waitedMs,
-        network_idle: waitForNetwork,
-    };
-    return result;
-}

package/dist/tools/drag.d.ts

@@ -1,15 +0,0 @@
-/**
- * Weavetab — tools/drag.ts
- * browser_drag: mousedown on sourceNodeId, mousemove to targetNodeId, mouseup.
- * Weavetab by fy2ne
- */
-import CDP from "chrome-remote-interface";
-import type { Config } from "../config/loader.js";
-export interface DragOptions {
-    sourceNodeId: number;
-    targetNodeId: number;
-}
-export declare function browserDrag(session: CDP.Client, options: DragOptions, _config: Config): Promise<{
-    success: boolean;
-}>;
-//# sourceMappingURL=drag.d.ts.map

package/dist/tools/drag.js

@@ -1,29 +0,0 @@
-export async function browserDrag(session, options, _config) {
-    const { sourceNodeId, targetNodeId } = options;
-    if (!sourceNodeId || !targetNodeId) {
-        throw new Error("browser_drag requires sourceNodeId and targetNodeId");
-    }
-    const getCoords = async (nodeId) => {
-        const { model } = await session.DOM.getBoxModel({ backendNodeId: nodeId });
-        return {
-            x: (model.content[0] + model.content[2]) / 2,
-            y: (model.content[1] + model.content[5]) / 2
-        };
-    };
-    const src = await getCoords(sourceNodeId);
-    const tgt = await getCoords(targetNodeId);
-    // 1. Move to source
-    await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: src.x, y: src.y });
-    // 2. Mouse down
-    await session.Input.dispatchMouseEvent({ type: "mousePressed", x: src.x, y: src.y, button: "left", clickCount: 1 });
-    // Small delay to let UI react (e.g. drag start handlers)
-    await new Promise(r => setTimeout(r, 100));
-    // 3. Move to target with button held
-    // In a real smooth drag, we'd interpolate this, but a direct move often works.
-    await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: tgt.x, y: tgt.y, button: "left" });
-    await new Promise(r => setTimeout(r, 100));
-    // 4. Mouse up
-    await session.Input.dispatchMouseEvent({ type: "mouseReleased", x: tgt.x, y: tgt.y, button: "left", clickCount: 1 });
-    return { success: true };
-}
-//# sourceMappingURL=drag.js.map

package/dist/tools/geo.d.ts

@@ -1,19 +0,0 @@
-/**
- * Weavetab — tools/geo.ts
- * browser_geo: Override geolocation and timezone.
- * Weavetab by fy2ne
- */
-import CDP from "chrome-remote-interface";
-import type { Config } from "../config/loader.js";
-export interface GeoOptions {
-    action: "set" | "clear";
-    latitude?: number;
-    longitude?: number;
-    accuracy?: number;
-    timezoneId?: string;
-}
-export declare function browserGeo(session: CDP.Client, options: GeoOptions, _config: Config): Promise<{
-    success: boolean;
-    message: string;
-}>;
-//# sourceMappingURL=geo.d.ts.map

package/dist/tools/geo.js

@@ -1,29 +0,0 @@
-export async function browserGeo(session, options, _config) {
-    const { action, latitude, longitude, accuracy = 100, timezoneId } = options;
-    if (action === "clear") {
-        await session.Emulation.clearGeolocationOverride();
-        await session.Emulation.setTimezoneOverride({ timezoneId: "" });
-        return { success: true, message: "Cleared geolocation and timezone overrides" };
-    }
-    if (action === "set") {
-        let msg = "";
-        if (latitude !== undefined && longitude !== undefined) {
-            await session.Emulation.setGeolocationOverride({
-                latitude,
-                longitude,
-                accuracy
-            });
-            msg += `Geolocation set to ${latitude}, ${longitude}. `;
-        }
-        if (timezoneId) {
-            await session.Emulation.setTimezoneOverride({ timezoneId });
-            msg += `Timezone set to ${timezoneId}.`;
-        }
-        if (!msg) {
-            throw new Error("Must provide latitude/longitude or timezoneId to set");
-        }
-        return { success: true, message: msg.trim() };
-    }
-    throw new Error("Unknown action");
-}
-//# sourceMappingURL=geo.js.map

package/dist/tools/github/analyze.d.ts

@@ -1,4 +0,0 @@
-import CDP from "chrome-remote-interface";
-import type { Config } from "../../config/loader.js";
-import { GithubRepoCache } from "./cache.js";
-export declare function githubAnalyze(session: CDP.Client, config: Config, repoSlug?: string): Promise<import("./repoContext.js").GithubToolError | GithubRepoCache>;

package/dist/tools/github/analyze.js

@@ -1,113 +0,0 @@
-import { getRepoContext, isGithubError } from "./repoContext.js";
-import { loadRepoCache, saveRepoCache } from "./cache.js";
-import { canMakeApiCall, handleApiResponse } from "./rateLimiter.js";
-export async function githubAnalyze(session, config, repoSlug) {
-    const context = await getRepoContext(session, repoSlug);
-    if (isGithubError(context))
-        return context;
-    const { owner, repo } = context;
-    // Check cache
-    const cached = await loadRepoCache(owner, repo, config);
-    if (cached) {
-        return cached;
-    }
-    // Check rate limit before proceeding
-    const rateLimitCheck = canMakeApiCall();
-    if (isGithubError(rateLimitCheck))
-        return rateLimitCheck;
-    // 1. Fetch repo metadata
-    const repoUrl = `https://api.github.com/repos/${owner}/${repo}`;
-    const repoRes = await fetch(repoUrl, {
-        headers: {
-            "Accept": "application/vnd.github.v3+json",
-            "User-Agent": "Weavetab-MCP"
-        }
-    });
-    const handledRepoRes = handleApiResponse(repoRes);
-    if (isGithubError(handledRepoRes))
-        return handledRepoRes;
-    if (repoRes.status === 404) {
-        return {
-            error: "REPO_NOT_FOUND",
-            message: "Repository not found or not accessible. Note: Only public repositories are supported."
-        };
-    }
-    if (!repoRes.ok) {
-        return {
-            error: "API_ERROR",
-            message: `GitHub API error: ${repoRes.statusText}`
-        };
-    }
-    const repoData = await repoRes.json();
-    const default_branch = repoData.default_branch || "main";
-    const description = repoData.description || null;
-    const language = repoData.language || null;
-    // Check rate limit again just in case
-    const rateLimitCheck2 = canMakeApiCall();
-    if (isGithubError(rateLimitCheck2))
-        return rateLimitCheck2;
-    // 2. Fetch file tree
-    const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${default_branch}?recursive=1`;
-    const treeRes = await fetch(treeUrl, {
-        headers: {
-            "Accept": "application/vnd.github.v3+json",
-            "User-Agent": "Weavetab-MCP"
-        }
-    });
-    const handledTreeRes = handleApiResponse(treeRes);
-    if (isGithubError(handledTreeRes))
-        return handledTreeRes;
-    let file_tree = [];
-    if (treeRes.ok) {
-        const treeData = await treeRes.json();
-        if (treeData.tree && Array.isArray(treeData.tree)) {
-            // Pick flat structure - it's more compact and easy to grep
-            file_tree = treeData.tree.map((t) => ({
-                path: t.path,
-                mode: t.mode,
-                type: t.type,
-                sha: t.sha,
-                size: t.size,
-                url: t.url
-            }));
-        }
-    }
-    // 3. Fetch README (raw)
-    let readme_snippet = "";
-    // Check common README paths
-    const possibleReadmes = ["README.md", "README", "readme.md", "Readme.md", "README.txt"];
-    const readmeEntry = file_tree.find(f => possibleReadmes.includes(f.path));
-    if (readmeEntry) {
-        const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${default_branch}/${readmeEntry.path}`;
-        try {
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), 10000);
-            const rawRes = await fetch(rawUrl, { signal: controller.signal });
-            clearTimeout(timeout);
-            if (rawRes.ok) {
-                const fullReadme = await rawRes.text();
-                // Truncate snippet to first 100 lines
-                const lines = fullReadme.split('\n');
-                readme_snippet = lines.slice(0, 100).join('\n');
-                if (lines.length > 100) {
-                    readme_snippet += "\n\n... (truncated)";
-                }
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    const cacheData = {
-        owner,
-        repo,
-        default_branch,
-        description,
-        language,
-        file_tree,
-        readme_snippet,
-        analyzed_at: Date.now()
-    };
-    await saveRepoCache(cacheData);
-    return cacheData;
-}

package/dist/tools/github/cache.d.ts

@@ -1,21 +0,0 @@
-import type { Config } from "../../config/loader.js";
-export interface TreeEntry {
-    path: string;
-    mode: string;
-    type: string;
-    sha: string;
-    size?: number;
-    url: string;
-}
-export interface GithubRepoCache {
-    owner: string;
-    repo: string;
-    default_branch: string;
-    description: string | null;
-    language: string | null;
-    file_tree: TreeEntry[];
-    readme_snippet: string;
-    analyzed_at: number;
-}
-export declare function loadRepoCache(owner: string, repo: string, config: Config): Promise<GithubRepoCache | null>;
-export declare function saveRepoCache(data: GithubRepoCache): Promise<void>;

package/dist/tools/github/cache.js

@@ -1,28 +0,0 @@
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
-import { getConfigGithubCacheTtlMs } from "../../config/loader.js";
-const CACHE_DIR = join(homedir(), ".weavetab-system", "github_cache");
-function getCacheFile(owner, repo) {
-    const safeOwner = owner.replace(/[^a-zA-Z0-9.-]/g, "_");
-    const safeRepo = repo.replace(/[^a-zA-Z0-9.-]/g, "_");
-    return join(CACHE_DIR, `${safeOwner}_${safeRepo}.json`);
-}
-export async function loadRepoCache(owner, repo, config) {
-    try {
-        const content = await readFile(getCacheFile(owner, repo), "utf-8");
-        const data = JSON.parse(content);
-        const ttl = getConfigGithubCacheTtlMs(config) ?? (30 * 60 * 1000);
-        if (Date.now() - data.analyzed_at > ttl) {
-            return null; // Stale cache
-        }
-        return data;
-    }
-    catch {
-        return null;
-    }
-}
-export async function saveRepoCache(data) {
-    await mkdir(CACHE_DIR, { recursive: true });
-    await writeFile(getCacheFile(data.owner, data.repo), JSON.stringify(data), "utf-8");
-}

package/dist/tools/github/index.d.ts

@@ -1,19 +0,0 @@
-import CDP from "chrome-remote-interface";
-import type { Config } from "../../config/loader.js";
-import { githubAnalyze } from "./analyze.js";
-import { githubRead } from "./read.js";
-import { githubIssues } from "./issues.js";
-import { githubGetPr } from "./pr.js";
-export { githubAnalyze, githubRead, githubIssues, githubGetPr };
-export interface BrowserGithubArgs {
-    action: "analyze" | "read" | "issues" | "pr";
-    repo?: string;
-    paths?: string[];
-    line_range?: [number, number];
-    number?: number;
-    search?: string;
-    labels?: string[];
-    state?: "open" | "closed" | "all";
-    limit?: number;
-}
-export declare function browserGithub(session: CDP.Client, args: BrowserGithubArgs, cfg: Config): Promise<any>;

package/dist/tools/github/index.js

@@ -1,40 +0,0 @@
-import { githubAnalyze } from "./analyze.js";
-import { githubRead } from "./read.js";
-import { githubIssues } from "./issues.js";
-import { githubGetPr } from "./pr.js";
-export { githubAnalyze, githubRead, githubIssues, githubGetPr };
-export async function browserGithub(session, args, cfg) {
-    switch (args.action) {
-        case "analyze":
-            return await githubAnalyze(session, cfg, args.repo);
-        case "read": {
-            const paths = args.paths || [];
-            if (!paths.length) {
-                return {
-                    error: "MISSING_PATHS",
-                    message: "action 'read' requires 'paths' parameter with at least one file path."
-                };
-            }
-            return await githubRead(session, { repo: args.repo, paths, line_range: args.line_range }, cfg);
-        }
-        case "issues":
-            return await githubIssues(session, {
-                repo: args.repo,
-                search: args.search,
-                number: args.number,
-                labels: args.labels,
-                state: args.state,
-                limit: args.limit
-            });
-        case "pr":
-            return await githubGetPr(session, {
-                repo: args.repo,
-                number: args.number
-            });
-        default:
-            return {
-                error: "INVALID_ACTION",
-                message: `Unknown action: ${args.action}. Must be 'analyze', 'read', 'issues', or 'pr'.`
-            };
-    }
-}

package/dist/tools/github/issues.d.ts

@@ -1,9 +0,0 @@
-import CDP from "chrome-remote-interface";
-export declare function githubIssues(session: CDP.Client, args: {
-    repo?: string;
-    search?: string;
-    number?: number;
-    labels?: string[];
-    state?: 'open' | 'closed' | 'all';
-    limit?: number;
-}): Promise<any>;

package/dist/tools/github/issues.js

@@ -1,88 +0,0 @@
-import { getRepoContext, isGithubError } from "./repoContext.js";
-import { canMakeApiCall, handleApiResponse } from "./rateLimiter.js";
-export async function githubIssues(session, args) {
-    const context = await getRepoContext(session, args.repo);
-    if (isGithubError(context))
-        return context;
-    const { owner, repo } = context;
-    const rateLimitCheck = canMakeApiCall();
-    if (isGithubError(rateLimitCheck))
-        return rateLimitCheck;
-    const headers = {
-        "Accept": "application/vnd.github.v3+json",
-        "User-Agent": "Weavetab-MCP"
-    };
-    // If number is provided, fetch specific issue + comments
-    if (args.number) {
-        const issueUrl = `https://api.github.com/repos/${owner}/${repo}/issues/${args.number}`;
-        const issueRes = await fetch(issueUrl, { headers });
-        const handledIssueRes = handleApiResponse(issueRes);
-        if (isGithubError(handledIssueRes))
-            return handledIssueRes;
-        if (!issueRes.ok) {
-            return { error: "FETCH_FAILED", status: issueRes.status, message: `Failed to fetch issue #${args.number}` };
-        }
-        const issueData = await issueRes.json();
-        let comments = [];
-        if (issueData.comments > 0) {
-            const rateLimitCheck2 = canMakeApiCall();
-            if (!isGithubError(rateLimitCheck2)) {
-                const commentsUrl = `https://api.github.com/repos/${owner}/${repo}/issues/${args.number}/comments`;
-                const commentsRes = await fetch(commentsUrl, { headers });
-                const handledCommentsRes = handleApiResponse(commentsRes);
-                if (!isGithubError(handledCommentsRes) && commentsRes.ok) {
-                    const commentsData = await commentsRes.json();
-                    comments = commentsData.map((c) => ({
-                        id: c.id,
-                        user: c.user?.login,
-                        body: c.body,
-                        created_at: c.created_at
-                    }));
-                }
-            }
-        }
-        return {
-            number: issueData.number,
-            title: issueData.title,
-            state: issueData.state,
-            user: issueData.user?.login,
-            body: issueData.body,
-            created_at: issueData.created_at,
-            labels: issueData.labels?.map((l) => l.name),
-            comments
-        };
-    }
-    // Else list issues
-    let urlStr = `https://api.github.com/repos/${owner}/${repo}/issues?per_page=${args.limit || 5}`;
-    if (args.state)
-        urlStr += `&state=${args.state}`;
-    if (args.labels && args.labels.length > 0)
-        urlStr += `&labels=${args.labels.join(',')}`;
-    // GitHub Search API is different from Issues API. If search is provided, we should use search API.
-    if (args.search) {
-        let q = `repo:${owner}/${repo} is:issue ${args.search}`;
-        if (args.state && args.state !== 'all')
-            q += ` is:${args.state}`;
-        if (args.labels)
-            args.labels.forEach(l => q += ` label:"${l}"`);
-        urlStr = `https://api.github.com/search/issues?q=${encodeURIComponent(q)}&per_page=${args.limit || 5}`;
-    }
-    const listRes = await fetch(urlStr, { headers });
-    const handledListRes = handleApiResponse(listRes);
-    if (isGithubError(handledListRes))
-        return handledListRes;
-    if (!listRes.ok) {
-        return { error: "FETCH_FAILED", status: listRes.status, message: "Failed to list/search issues" };
-    }
-    const listData = await listRes.json();
-    const items = args.search ? listData.items : listData;
-    return items.map((i) => ({
-        number: i.number,
-        title: i.title,
-        state: i.state,
-        user: i.user?.login,
-        labels: i.labels?.map((l) => l.name),
-        created_at: i.created_at,
-        comments_count: i.comments
-    }));
-}

package/dist/tools/github/pr.d.ts

@@ -1,5 +0,0 @@
-import CDP from "chrome-remote-interface";
-export declare function githubGetPr(session: CDP.Client, args: {
-    repo?: string;
-    number?: number;
-}): Promise<any>;

package/dist/tools/github/pr.js

@@ -1,88 +0,0 @@
-import { getRepoContext, isGithubError } from "./repoContext.js";
-import { canMakeApiCall, handleApiResponse } from "./rateLimiter.js";
-export async function githubGetPr(session, args) {
-    const context = await getRepoContext(session, args.repo);
-    if (isGithubError(context))
-        return context;
-    const { owner, repo } = context;
-    const rateLimitCheck = canMakeApiCall();
-    if (isGithubError(rateLimitCheck))
-        return rateLimitCheck;
-    const headers = {
-        "Accept": "application/vnd.github.v3+json",
-        "User-Agent": "Weavetab-MCP"
-    };
-    if (args.number) {
-        const prUrl = `https://api.github.com/repos/${owner}/${repo}/pulls/${args.number}`;
-        const prRes = await fetch(prUrl, { headers });
-        const handledPrRes = handleApiResponse(prRes);
-        if (isGithubError(handledPrRes))
-            return handledPrRes;
-        if (!prRes.ok) {
-            return { error: "FETCH_FAILED", status: prRes.status, message: `Failed to fetch PR #${args.number}` };
-        }
-        const prData = await prRes.json();
-        let files_changed = [];
-        const rateLimitCheck2 = canMakeApiCall();
-        if (!isGithubError(rateLimitCheck2)) {
-            const filesUrl = `https://api.github.com/repos/${owner}/${repo}/pulls/${args.number}/files`;
-            const filesRes = await fetch(filesUrl, { headers });
-            const handledFilesRes = handleApiResponse(filesRes);
-            if (!isGithubError(handledFilesRes) && filesRes.ok) {
-                const filesData = await filesRes.json();
-                files_changed = filesData.map((f) => f.filename);
-            }
-        }
-        let comments = [];
-        if (prData.comments > 0) {
-            const rateLimitCheck3 = canMakeApiCall();
-            if (!isGithubError(rateLimitCheck3)) {
-                const commentsUrl = `https://api.github.com/repos/${owner}/${repo}/issues/${args.number}/comments`;
-                const commentsRes = await fetch(commentsUrl, { headers });
-                const handledCommentsRes = handleApiResponse(commentsRes);
-                if (!isGithubError(handledCommentsRes) && commentsRes.ok) {
-                    const commentsData = await commentsRes.json();
-                    comments = commentsData.map((c) => ({
-                        id: c.id,
-                        user: c.user?.login,
-                        body: c.body,
-                        created_at: c.created_at
-                    }));
-                }
-            }
-        }
-        return {
-            number: prData.number,
-            title: prData.title,
-            state: prData.state,
-            user: prData.user?.login,
-            body: prData.body,
-            created_at: prData.created_at,
-            merged: prData.merged,
-            mergeable: prData.mergeable,
-            additions: prData.additions,
-            deletions: prData.deletions,
-            changed_files: prData.changed_files,
-            files: files_changed,
-            comments
-        };
-    }
-    // Else list recent PRs
-    const listUrl = `https://api.github.com/repos/${owner}/${repo}/pulls?state=all&per_page=10`;
-    const listRes = await fetch(listUrl, { headers });
-    const handledListRes = handleApiResponse(listRes);
-    if (isGithubError(handledListRes))
-        return handledListRes;
-    if (!listRes.ok) {
-        return { error: "FETCH_FAILED", status: listRes.status, message: "Failed to list PRs" };
-    }
-    const listData = await listRes.json();
-    return listData.map((pr) => ({
-        number: pr.number,
-        title: pr.title,
-        state: pr.state,
-        user: pr.user?.login,
-        created_at: pr.created_at,
-        updated_at: pr.updated_at
-    }));
-}