clippy-test 1.0.8 → 2.0.0

package/dist/useWebSocket.js

@@ -1,13 +1,17 @@
 import { useCallback, useEffect, useRef, useState } from "react";
+import WebSocket from "ws";
 import { getContextLines } from "./utils.js";
 import { toolFunctionCall } from "./api.js";
 import fs from "fs";
 import os from "os";
 import path from "path";
-// Load Clippy config from ~/.clippy/config
+import { mapChatMessagesToStoredMessages, mapStoredMessagesToChatMessages, SystemMessage, } from "@langchain/core/messages";
+import { ripgrepSearch } from "./helpers/ripgrep-tool.js";
+import { loadProjectMetadata, logd } from "./helpers/cli-helpers.js";
+// Load OnCall config from ~/.oncall/config
 const HOME_DIR = os.homedir();
-const CLIPPY_DIR = path.join(HOME_DIR, ".clippy");
-const CONFIG_PATH = path.join(CLIPPY_DIR, "config");
+const ONCALL_DIR = path.join(HOME_DIR, ".oncall");
+const CONFIG_PATH = path.join(ONCALL_DIR, "config");
 let API_KEY = "";
 try {
     const configText = fs.readFileSync(CONFIG_PATH, "utf8");
@@ -16,34 +20,54 @@ try {
         API_KEY = match[1].trim();
     }
     else {
-        console.log("No API_KEY found in ~/.clippy/config");
+        console.log("No API_KEY found in ~/.oncall/config");
     }
 }
 catch (err) {
-    console.log("Failed to read Clippy config:", err);
+    console.log("Failed to read OnCall config:", err);
 }
-export function useWebSocket(url) {
+export function useWebSocket(url, rawLogData) {
     //refs
     const socketRef = useRef(null);
     const [socketId, setSocketId] = useState(null);
     const [chatResponseMessages, setChatResponseMessages] = useState([]);
     const [trimmedChats, setTrimmedChats] = useState([]);
-    const [visibleChats, setVisibleChats] = useState([]);
+    const initialAssistantMessage = new SystemMessage("I’m watching your app run locally. You can ask me about errors, logs, performance,or anything else related to this run.");
+    const [visibleChats, setVisibleChats] = useState([
+        initialAssistantMessage,
+    ]);
     const [isConnected, setIsConnected] = useState(false);
     const [connectionError, setConnectionError] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
-    const [isControlRPressed, setIsControlRPressed] = useState(false);
     const [showControlR, setShowControlR] = useState(false);
+    const [customMessage, setCustomMessage] = useState(null);
+    const [graphState, setGraphState] = useState(null);
     const authKey = API_KEY;
+    const initialProjectMetadata = loadProjectMetadata();
+    const getProjectMetadata = () => loadProjectMetadata() || initialProjectMetadata;
+    const getServiceId = () => getProjectMetadata()?.window_id;
+    const hasLogsAccess = () => {
+        const value = getProjectMetadata()?.logs_available;
+        return value === undefined ? true : value;
+    };
+    const hasCodeAccess = () => {
+        const value = getProjectMetadata()?.code_available;
+        return value === undefined ? true : value;
+    };
     useEffect(() => {
         if (API_KEY === "") {
-            setConnectionError("No API_KEY found in ~/.clippy/config");
-            console.log("No API_KEY found in ~/.clippy/config");
+            setConnectionError("No API_KEY found in ~/.oncall/config");
+            console.log("No API_KEY found in ~/.oncall/config");
             process.exit();
         }
     }, [API_KEY]);
     //web socket connection
     const connectWebSocket = useCallback(() => {
+        // const d = fs.readFileSync('logs')
+        // fs.writeFileSync('logs', `${d} inside connectWS \n message: ${url} ${authKey} ${serviceId}`)
+        // if (!url || !authKey || serviceId.trim() === "") {
+        //   return;
+        // }
         if (socketRef.current) {
             socketRef.current.close();
         }
@@ -53,14 +77,24 @@ export function useWebSocket(url) {
         setIsConnected(false);
         socket.onopen = () => {
             try {
-                socket.send(JSON.stringify({ type: "recurring_connection", authKey }));
+                const md = getProjectMetadata();
+                if (!md?.window_id) {
+                    setConnectionError("Missing serviceId (window_id) in oncall.yaml");
+                    console.log("Missing serviceId (window_id) in oncall.yaml");
+                    return;
+                }
+                socket.send(JSON.stringify({
+                    type: "recurring_connection",
+                    authKey,
+                    serviceId: md.window_id,
+                }));
             }
             catch (error) {
                 setConnectionError("error");
             }
         };
         socket.onmessage = async (event) => {
-            setShowControlR(false);
+            // setShowControlR(false);
             try {
                 const raw = event.data;
                 let text = "";
@@ -84,7 +118,8 @@ export function useWebSocket(url) {
                     return; // ignore non-JSON frames
                 }
                 const data = JSON.parse(text);
-                if (data.type === "user_assigned" && data.socketId) {
+                // if (data.type === "user_assigned" && data.socketId) {
+                if (data.type === "user_assigned") {
                     setIsConnected(true);
                     setSocketId(data.socketId);
                 }
@@ -100,46 +135,126 @@ export function useWebSocket(url) {
                     return;
                 }
                 if (data.type === "tool_function_call") {
-                    if (data.function_name === "get_context_lines") {
+                    if (data.function_name === "read_file") {
+                        logd(`[read_file] 📥 Tool call received: tool_call_id=${data.tool_call_id}, args=${JSON.stringify(data.args)}`);
+                        if (!hasCodeAccess()) {
+                            logd(`[read_file] ⚠️  No code access, denying tool`);
+                            await denyToolAccess("read_file", data);
+                            return;
+                        }
                         const argsData = {
-                            fileName: data.args.fileName,
+                            filePath: data.args.filePath,
                             lineNumber: data.args.lineNumber,
-                            before: data.args.before,
-                            after: data.args.after,
+                            before: data.args.before || 30,
+                            after: data.args.after || 30,
                         };
-                        const result = getContextLines(argsData.fileName, argsData.lineNumber, argsData.before, argsData.after);
-                        try {
-                            await toolFunctionCall(data?.tool_call_id, result, data?.args, "tool_function_call");
+                        logd(`[read_file] 📋 Extracted args: filePath=${argsData.filePath}, lineNumber=${argsData.lineNumber}, before=${argsData.before}, after=${argsData.after}`);
+                        logd(`[read_file] 🔍 Calling getContextLines...`);
+                        const result = getContextLines(argsData.filePath, argsData.lineNumber, argsData.before, argsData.after);
+                        logd(`[read_file] ✅ File content extracted: resultLength=${result.length}, resultLines=${result.split("\n").length}, isEmpty=${result.trim().length === 0}`);
+                        logd(`[read_file] 📄 Result preview (first 300 chars): ${result.substring(0, 300)}${result.length > 300 ? "..." : ""}`);
+                        await postToolCallResult(data, result, setChatResponseMessages);
+                        logd(`[read_file] 📤 Result sent to backend successfully`);
+                        // await redisClient.set(data.tool_call_id, result, { EX: 120 });
+                        return;
+                    }
+                    if (data.function_name === "grep_search") {
+                        if (!hasCodeAccess()) {
+                            await denyToolAccess("grep_search", data);
+                            return;
                         }
-                        catch (error) {
-                            setChatResponseMessages((prev) => [
-                                ...prev,
-                                error?.response?.message || "Error, please try again",
-                            ]);
+                        await grepSearch(data.args.searchTerm, data);
+                        return;
+                    }
+                    if (data.function_name === "read_logs") {
+                        if (!hasLogsAccess()) {
+                            await denyToolAccess("read_logs", data);
+                            return;
                         }
-                        // await redisClient.set(data.tool_call_id, result, { EX: 120 });
+                        await readLogs(data.args.pageNumber, data);
+                        return;
+                    }
+                    if (data.function_name === "tail_logs") {
+                        if (!hasLogsAccess()) {
+                            await denyToolAccess("tail_logs", data);
+                            return;
+                        }
+                        await tailLogs(data.args.n, data);
+                        return;
+                    }
+                    if (data.function_name === "grep_logs") {
+                        if (!hasLogsAccess()) {
+                            await denyToolAccess("grep_logs", data);
+                            return;
+                        }
+                        await grepLogs(data.args.pattern, data.args.before, data.args.after, data);
+                        return;
+                    }
+                    if (data.function_name === "get_recent_errors") {
+                        if (!hasLogsAccess()) {
+                            await denyToolAccess("get_recent_errors", data);
+                            return;
+                        }
+                        await getRecentErrors(data.args.n, data);
+                        return;
                     }
-                    return;
                 }
-                setChatResponseMessages((prev) => [...prev, data]);
-                setVisibleChats((prev) => [...prev, data]);
+                // trimmed - imp msgs
+                // visible - shown
+                // chatresponses - all
                 // add non-progress responses to trimmedChats
-                if (data.type !== "progress") {
-                    setTrimmedChats((prevTrimmed) => {
-                        const updated = [...prevTrimmed, data];
-                        // update visible chats with all trimmed messages
-                        setVisibleChats(updated);
-                        return updated;
-                    });
+                // @todo this is where the messages get trimmed
+                // if (data.type !== "progress") {
+                //   setTrimmedChats((prevTrimmed) => {
+                //     const updated = [...prevTrimmed, data];
+                //     // update visible chats with all trimmed messages
+                //     setVisibleChats(updated);
+                //     return updated;
+                //   });
+                // }
+                if (data.type === "response") {
+                    let messages = data.data.messages ? data.data.messages : [];
+                    messages = mapStoredMessagesToChatMessages(messages);
+                    switch (data.data.type) {
+                        case "messages":
+                            if (data.data.sender !== "toolNode") {
+                                setVisibleChats(old => [...old, ...messages]);
+                            }
+                            // logd(`LOGGING RESPONSE SENDER: ${data.data.sender}`);
+                            break;
+                        case "values":
+                            if (data.data.state) {
+                                setGraphState(data.data.state);
+                            }
+                            break;
+                        case "updates":
+                            if (data.data.sender !== "toolNode" && data.data.sender !== "routerNode") {
+                                setChatResponseMessages(old => [...old, ...messages]);
+                            }
+                            if (data.data.sender === "answerNode") {
+                                setTrimmedChats(prev => {
+                                    setVisibleChats([...prev, ...messages]);
+                                    return [...prev, ...messages];
+                                });
+                                setIsLoading(false);
+                            }
+                            if (data.data.sender === "userNode") {
+                                setIsLoading(false);
+                            }
+                            break;
+                        default:
+                            break;
+                    }
                 }
-                if (data.type === "response" ||
-                    data.type === "error" ||
+                if (data.type === "error" ||
                     data.type === "ask_user") {
                     setIsLoading(false);
+                    setCustomMessage(null);
                 }
             }
             catch (error) {
-                console.warn("WebSocket message handling warning:", error);
+                setIsLoading(false);
+                // console.warn("WebSocket message handling warning:", error);
                 return;
             }
         };
@@ -160,34 +275,160 @@ export function useWebSocket(url) {
         //   };
         // }
     }, [url, authKey]);
-    const sendQuery = useCallback((query, logs, state) => {
+    const sendQuery = useCallback((messages, architecture, logs, planningDoc) => {
         const socket = socketRef.current;
         if (socket && socket.readyState === WebSocket.OPEN) {
             setIsLoading(true);
-            const payload = state
-                ? { type: "query", socketId, logs, query, state }
-                : { type: "query", socketId, logs, query };
+            setCustomMessage("🤔 Thinking...");
+            const md = getProjectMetadata();
+            const payload = {
+                type: "query",
+                authKey,
+                serviceId: md?.window_id,
+                userQuery: {
+                    messages: graphState
+                        ? mapChatMessagesToStoredMessages([messages[messages.length - 1]])
+                        : mapChatMessagesToStoredMessages(messages),
+                    architecture: architecture,
+                    logs,
+                    planningDoc: "",
+                },
+                planningDoc,
+                graphState: graphState || undefined,
+            };
             socket.send(JSON.stringify(payload));
         }
         else {
             setConnectionError("WebSocket not connected");
             throw new Error("Cannot send the message: Web socket not connected");
         }
-    }, [socketId]);
+    }, [socketId, graphState]);
     // Clean up on unmount
     useEffect(() => {
         return () => {
             if (socketRef.current) {
-                socketRef.current.close();
+                // socketRef.current.close();
             }
         };
     }, []);
+    async function grepSearch(searchTerm, data) {
+        logd(`[grepSearch] 🔍 Grep search invoked: searchTerm=${searchTerm}, tool_call_id=${data.tool_call_id}, args=${JSON.stringify(data.args)}`);
+        const projectMetadata = getProjectMetadata();
+        const workingDirectory = projectMetadata?.path || process.cwd();
+        logd(`[grepSearch] 📁 Working directory: workingDirectory=${workingDirectory}, projectPath=${projectMetadata?.path || 'N/A'}, processCwd=${process.cwd()}`);
+        const maxResults = data.args?.max_results || 20;
+        const caseSensitive = data.args?.case_sensitive || false;
+        const fileTypes = data.args?.file_types || [];
+        logd(`[grepSearch] ⚙️  Search options: maxResults=${maxResults}, caseSensitive=${caseSensitive}, fileTypes=${JSON.stringify(fileTypes)}`);
+        try {
+            const results = await ripgrepSearch(searchTerm, {
+                maxResults,
+                caseSensitive,
+                fileTypes,
+                workingDirectory,
+            });
+            logd(`[grepSearch] ✅ Search completed: resultCount=${results.length}, results=${JSON.stringify(results.map((r) => ({
+                filePath: r.filePath,
+                line: r.line,
+                previewLength: r.preview?.length || 0,
+            })))}`);
+            await postToolCallResult(data, results, setChatResponseMessages);
+        }
+        catch (error) {
+            logd(`[grepSearch] ❌ Error during grep search: ${error instanceof Error ? error.message : String(error)}, stack=${error instanceof Error ? error.stack : "N/A"}`);
+            await postToolCallResult(data, [], setChatResponseMessages);
+        }
+    }
+    async function readLogs(pageNumber, data) {
+        logd(`Triggered readLogs: ${pageNumber}`);
+        pageNumber = parseInt(pageNumber.toString());
+        const lines = rawLogData
+            .getLogs()
+            .split("\n")
+            .slice(-50 * pageNumber)
+            .join("\n");
+        logd(`Triggered readLogs - Posting result: ${lines.length}`);
+        await postToolCallResult(data, lines, setChatResponseMessages);
+        logd(`Triggered readLogs - done Posting result`);
+    }
+    async function tailLogs(n, data) {
+        try {
+            logd(`Triggered tailLogs: ${n}`);
+            n = parseInt(n.toString());
+            if (Number.isNaN(n) || n <= 0) {
+                await postToolCallResult(data, "Invalid value for n. Please provide a positive number of log lines to fetch.", setChatResponseMessages);
+                return;
+            }
+            const tail = rawLogData.getTailLogs(n);
+            logd(`Triggered tailLogs - Posting result: ${tail.length}`);
+            await postToolCallResult(data, tail, setChatResponseMessages);
+            logd(`Triggered tailLogs - done Posting result`);
+        }
+        catch (error) {
+            logd(`Triggered tailLogs - error: ${JSON.stringify(error)}`);
+            await postToolCallResult(data, "Failed to fetch tail logs from CLI.", setChatResponseMessages);
+        }
+    }
+    async function grepLogs(pattern, before, after, data) {
+        try {
+            logd(`Triggered grepLogs: pattern=${pattern}, before=${before}, after=${after}`);
+            if (!pattern || !pattern.trim()) {
+                await postToolCallResult(data, "Invalid pattern for grep_logs. Please provide a non-empty pattern.", setChatResponseMessages);
+                return;
+            }
+            const beforeCount = before !== undefined ? parseInt(before.toString()) : 5;
+            const afterCount = after !== undefined ? parseInt(after.toString()) : 5;
+            const result = rawLogData.getGrepLogs(pattern, beforeCount, afterCount);
+            await postToolCallResult(data, result, setChatResponseMessages);
+            logd(`Triggered grepLogs - done Posting result of length ${result.length}`);
+        }
+        catch (error) {
+            logd(`Triggered grepLogs - error: ${JSON.stringify(error)}`);
+            await postToolCallResult(data, "Failed to search logs with grep_logs.", setChatResponseMessages);
+        }
+    }
+    async function getRecentErrors(n, data) {
+        try {
+            logd(`Triggered getRecentErrors: n=${n}`);
+            n = parseInt(n.toString());
+            if (Number.isNaN(n) || n <= 0) {
+                await postToolCallResult(data, "Invalid value for n. Number Provided :" + n.toString(), setChatResponseMessages);
+                return;
+            }
+            const result = rawLogData.getRecentErrors(n);
+            await postToolCallResult(data, result, setChatResponseMessages);
+            logd(`Triggered getRecentErrors - done Posting result of length ${result.length}`);
+        }
+        catch (error) {
+            logd(`Triggered getRecentErrors - error: ${JSON.stringify(error)}`);
+            await postToolCallResult(data, "Failed to fetch recent error logs.", setChatResponseMessages);
+        }
+    }
+    async function postToolCallResult(data, result, setChatResponseMessages) {
+        try {
+            await toolFunctionCall(data?.tool_call_id, result, data?.args, "tool_function_call");
+        }
+        catch (error) {
+            logd(`Triggered readLogs - failer podting: ${JSON.stringify(error)}`);
+            // setChatResponseMessages((prev) => [
+            //   ...prev,
+            //   error?.response?.message || "Error, please try again",
+            // ]);
+        }
+    }
+    async function denyToolAccess(functionName, data) {
+        const serviceId = getServiceId();
+        const message = `No Access to execute ${functionName}. with the serviceId of ${serviceId ?? "unknown"}.`;
+        await postToolCallResult(data, message, setChatResponseMessages);
+    }
     return {
         connectWebSocket,
         socketId,
         sendQuery,
-        chatResponseMessages: visibleChats,
-        setChatResponseMessages: setVisibleChats,
+        chatResponseMessages: chatResponseMessages, // Full history including ToolMessage (needed for backend)
+        visibleChats: visibleChats, // Filtered for UI display (excludes ToolMessage except reflections)
+        setVisibleChats: setVisibleChats,
+        setChatResponseMessages,
         setTrimmedChats,
         isConnected,
         connectionError,
@@ -197,10 +438,12 @@ export function useWebSocket(url) {
         setIsConnected,
         socket: socketRef.current,
         setIsLoading,
-        setIsControlRPressed,
         setShowControlR,
         showControlR,
         setCompleteChatHistory: setChatResponseMessages,
+        customMessage,
+        graphState,
+        setGraphState,
     };
 }
 //# sourceMappingURL=useWebSocket.js.map

package/dist/utils/version-check.d.ts

@@ -0,0 +1,2 @@
+export function checkVersionCompatibility(forceCheck?: boolean): Promise<boolean>;
+export function checkVersionAndExit(): Promise<void>;

package/dist/utils/version-check.js

@@ -0,0 +1,124 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { fileURLToPath } from "url";
+import axios from "axios";
+const ONCALL_DIR = path.join(os.homedir(), ".oncall");
+const VERSION_CACHE_FILE = path.join(ONCALL_DIR, "version-cache.json");
+const API_BASE_URL = "http://api.oncall.build/v2/api";
+const CACHE_DURATION_MS = 24 * 60 * 60 * 1000;
+function compareVersions(v1, v2) {
+    const parts1 = v1.split(".").map(Number);
+    const parts2 = v2.split(".").map(Number);
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+        const part1 = parts1[i] || 0;
+        const part2 = parts2[i] || 0;
+        if (part1 < part2)
+            return -1;
+        if (part1 > part2)
+            return 1;
+    }
+    return 0;
+}
+function isVersionDeprecated(currentVersion, minimumVersion) {
+    return compareVersions(currentVersion, minimumVersion) < 0;
+}
+function readVersionCache() {
+    if (fs.existsSync(VERSION_CACHE_FILE)) {
+        const content = fs.readFileSync(VERSION_CACHE_FILE, "utf8");
+        return JSON.parse(content);
+    }
+    return null;
+}
+function ensureOnCallDir() {
+    if (!fs.existsSync(ONCALL_DIR)) {
+        fs.mkdirSync(ONCALL_DIR, { recursive: true });
+    }
+}
+function writeVersionCache(cache) {
+    ensureOnCallDir();
+    fs.writeFileSync(VERSION_CACHE_FILE, JSON.stringify(cache, null, 2));
+}
+function shouldCheckVersion() {
+    const cache = readVersionCache();
+    if (!cache || !cache.lastCheck) {
+        return true;
+    }
+    const now = Date.now();
+    const timeSinceLastCheck = now - cache.lastCheck;
+    return timeSinceLastCheck >= CACHE_DURATION_MS;
+}
+async function fetchMinimumVersion() {
+    try {
+        const response = await axios.get(`${API_BASE_URL}/health/minimum-cli-version`);
+        if (response.data?.success && response.data?.minimumCliVersion) {
+            return response.data.minimumCliVersion;
+        }
+    }
+    catch (error) {
+        console.warn("Failed to check CLI version:", error instanceof Error ? error.message : "Unknown error");
+    }
+    return null;
+}
+function getCurrentVersion() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const possiblePaths = [
+            path.resolve(__dirname, "../package.json"),
+            path.resolve(__dirname, "../../package.json"),
+        ];
+        for (const pkgPath of possiblePaths) {
+            if (fs.existsSync(pkgPath)) {
+                const pkgJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+                return pkgJson.version || "0.0.0";
+            }
+        }
+        return "0.0.0";
+    }
+    catch (error) {
+        return "0.0.0";
+    }
+}
+function formatDeprecationError(currentVersion, minimumVersion) {
+    return `
+⚠️  CLI VERSION DEPRECATED
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Your current version: ${currentVersion}
+Minimum required version: ${minimumVersion}
+
+Please update to the latest version to continue using OnCall CLI.
+
+To update, run:
+  npm install -g oncall-cli@latest
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+}
+export async function checkVersionCompatibility(forceCheck = false) {
+    const currentVersion = getCurrentVersion();
+    const cache = readVersionCache();
+    if (!forceCheck && cache?.lastCheck && !shouldCheckVersion()) {
+        return true;
+    }
+    const minimumVersion = await fetchMinimumVersion();
+    if (!minimumVersion) {
+        return true;
+    }
+    writeVersionCache({
+        lastCheck: Date.now(),
+    });
+    if (isVersionDeprecated(currentVersion, minimumVersion)) {
+        console.error(formatDeprecationError(currentVersion, minimumVersion));
+        return false;
+    }
+    return true;
+}
+export async function checkVersionAndExit() {
+    const isCompatible = await checkVersionCompatibility(true);
+    if (!isCompatible) {
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=version-check.js.map

package/dist/utils.d.ts

@@ -1 +1,17 @@
+import { BaseMessage } from "langchain";
 export declare function getContextLines(fileName: string, lineNumber: number, before?: number, after?: number): string;
+export declare function extractMessageContent(messages: BaseMessage[]): string;
+/**
+ * Get a unique key for a message for deduplication purposes
+ * Uses message.id if available (string), otherwise checks other locations, then creates a fallback key
+ */
+export declare function getMessageKey(message: BaseMessage): string;
+/**
+ * Deduplicate messages array by message ID, keeping the last occurrence
+ * Preserves message order
+ */
+export declare function deduplicateMessages(messages: BaseMessage[]): BaseMessage[];
+export declare function groupMessageChunks(messages: BaseMessage[]): {
+    lastId: string;
+    messages: BaseMessage[][];
+};