clippy-test 1.0.9 → 2.0.1

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[][];
+};

package/dist/utils.js

@@ -1,10 +1,50 @@
 import * as fs from "fs";
+import * as path from "path";
+import { logd } from "./helpers/cli-helpers.js";
 //parameter to redis
 export function getContextLines(fileName, lineNumber, before = 30, after = 30) {
-    const lines = fs.readFileSync(fileName, "utf-8").split("\n");
-    const start = Math.max(0, lineNumber - before - 1);
-    const end = Math.min(lines.length, lineNumber + after);
-    return lines.slice(start, end).join("\n");
+    logd(`[getContextLines] 📥 Called with: fileName=${fileName}, lineNumber=${lineNumber}, before=${before}, after=${after}`);
+    try {
+        if (!fileName || typeof fileName !== "string") {
+            logd(`[getContextLines] ❌ ERROR: Invalid fileName: ${fileName}`);
+            return "";
+        }
+        if (typeof lineNumber !== "number" || lineNumber < 1) {
+            logd(`[getContextLines] ❌ ERROR: Invalid lineNumber: ${lineNumber}`);
+            return "";
+        }
+        const resolvedPath = path.resolve(fileName);
+        logd(`[getContextLines] 📁 Path resolution: original=${fileName}, resolved=${resolvedPath}, exists=${fs.existsSync(fileName)}`);
+        if (!fs.existsSync(fileName)) {
+            logd(`[getContextLines] ❌ ERROR: File not found: ${fileName}`);
+            logd(`[getContextLines] Attempted absolute path: ${resolvedPath}`);
+            return "";
+        }
+        const stats = fs.statSync(fileName);
+        logd(`[getContextLines] 📊 File stats: size=${stats.size}, isFile=${stats.isFile()}, isDirectory=${stats.isDirectory()}`);
+        const fileContent = fs.readFileSync(fileName, "utf-8");
+        logd(`[getContextLines] 📖 File read: contentLength=${fileContent.length}, hasContent=${fileContent.length > 0}`);
+        const lines = fileContent.split("\n");
+        const totalLines = lines.length;
+        logd(`[getContextLines] 📝 File split: totalLines=${totalLines}`);
+        const start = Math.max(0, lineNumber - before - 1);
+        const end = Math.min(totalLines, lineNumber + after);
+        logd(`[getContextLines] 🧮 Calculated indices: requestedLine=${lineNumber}, before=${before}, after=${after}, start=${start}, end=${end}, linesToExtract=${end - start}`);
+        if (lineNumber > totalLines) {
+            logd(`[getContextLines] ⚠️  WARNING: lineNumber (${lineNumber}) exceeds total lines (${totalLines})`);
+        }
+        if (lineNumber < 1) {
+            logd(`[getContextLines] ⚠️  WARNING: lineNumber (${lineNumber}) is less than 1`);
+        }
+        const extractedLines = lines.slice(start, end);
+        const result = extractedLines.join("\n");
+        logd(`[getContextLines] ✅ Extraction complete: extractedLineCount=${extractedLines.length}, resultLength=${result.length}, firstLine=${extractedLines[0]?.substring(0, 50) || "(empty)"}, lastLine=${extractedLines[extractedLines.length - 1]?.substring(0, 50) || "(empty)"}`);
+        return result;
+    }
+    catch (error) {
+        logd(`[getContextLines] ❌ EXCEPTION: error=${error instanceof Error ? error.message : String(error)}, fileName=${fileName}, lineNumber=${lineNumber}`);
+        return "";
+    }
 }
 //redis connection
 // const redisClient = createClient({
@@ -19,4 +59,85 @@ export function getContextLines(fileName, lineNumber, before = 30, after = 30) {
 // });
 // redisClient.connect();
 // export default redisClient;
+export function extractMessageContent(messages) {
+    return messages.reduce((prev, message) => {
+        return prev + message.content;
+    }, "");
+}
+/**
+ * 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 function getMessageKey(message) {
+    // Priority 1: Check message.id if it's a string (unique ID)
+    if (message.id && typeof message.id === "string") {
+        return message.id;
+    }
+    // Priority 2: Check response_metadata.id (some messages store ID here)
+    const msgAny = message;
+    if (msgAny.response_metadata?.id && typeof msgAny.response_metadata.id === "string") {
+        return msgAny.response_metadata.id;
+    }
+    // Priority 3: Check lc_kwargs.id (LangChain might preserve original kwargs)
+    if (msgAny.lc_kwargs?.id && typeof msgAny.lc_kwargs.id === "string") {
+        return msgAny.lc_kwargs.id;
+    }
+    // Priority 4: For ToolMessage, use tool_call_id as unique identifier
+    const toolCallId = msgAny.tool_call_id;
+    if (toolCallId && typeof toolCallId === "string") {
+        return `tool_${toolCallId}`;
+    }
+    // Fallback: create a key from content + type + tool_call_id (if available)
+    // This handles messages without IDs by creating a content-based key
+    // NOTE: This could cause false duplicates if two different messages have same content
+    const type = message.constructor.name || "Unknown";
+    let content = "";
+    if (typeof message.content === "string") {
+        content = message.content.substring(0, 50);
+    }
+    else if (message.content !== undefined && message.content !== null) {
+        const stringified = JSON.stringify(message.content);
+        content = stringified ? stringified.substring(0, 50) : "";
+    }
+    // Include a hash of full content to reduce collisions
+    const contentHash = typeof message.content === "string"
+        ? message.content.length.toString()
+        : "0";
+    return `${type}_${contentHash}_${content}_${toolCallId || ""}`;
+}
+/**
+ * Deduplicate messages array by message ID, keeping the last occurrence
+ * Preserves message order
+ */
+export function deduplicateMessages(messages) {
+    const messageMap = new Map();
+    const order = [];
+    messages.forEach((msg) => {
+        const key = getMessageKey(msg);
+        if (!messageMap.has(key)) {
+            order.push(key);
+        }
+        // Keep the last occurrence of messages with the same ID
+        messageMap.set(key, msg);
+    });
+    // Return messages in original order, but deduplicated
+    return order.map((key) => messageMap.get(key)).filter(Boolean);
+}
+export function groupMessageChunks(messages) {
+    return messages.reduce((prev, message) => {
+        if (!prev)
+            prev = { lastId: "", messages: [] };
+        const messageKey = getMessageKey(message);
+        if (messageKey !== prev.lastId) {
+            prev.messages.push([message]);
+            prev.lastId = messageKey;
+            return prev;
+        }
+        else {
+        }
+        const lastMessageIndex = prev.messages.length - 1;
+        prev.messages[lastMessageIndex].push(message);
+        return prev;
+    }, { lastId: "", messages: [] });
+}
 //# sourceMappingURL=utils.js.map

package/dist/websocket-server.d.ts

@@ -0,0 +1,24 @@
+import { AddressInfo } from "net";
+type Logger = Pick<Console, "log" | "info" | "warn" | "error">;
+export interface OnCallWebSocketServerOptions {
+    port?: number;
+    host?: string;
+    logger?: Logger;
+}
+export declare class OnCallWebSocketServer {
+    private wss;
+    private readonly allProjects;
+    private readonly options;
+    constructor(options?: OnCallWebSocketServerOptions);
+    get address(): AddressInfo | null;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleServerClose;
+    private handleConnection;
+    private handleMessage;
+    private send;
+    private normalizeProjectPayload;
+    private upsertProjectRegistration;
+}
+export declare function startOnCallWebSocketServer(options?: OnCallWebSocketServerOptions): Promise<OnCallWebSocketServer>;
+export {};

package/dist/websocket-server.js

@@ -0,0 +1,235 @@
+import { once } from "events";
+import { WebSocketServer, WebSocket } from "ws";
+import { logd } from "./helpers/cli-helpers.js";
+const DEFAULT_PORT = Number.parseInt(process.env.ONCALL_WS_PORT ?? "", 10) || 6111;
+const DEFAULT_HOST = process.env.ONCALL_WS_HOST || "127.0.0.1";
+export class OnCallWebSocketServer {
+    constructor(options = {}) {
+        this.wss = null;
+        this.allProjects = [];
+        this.options = {
+            port: options.port ?? DEFAULT_PORT,
+            host: options.host ?? DEFAULT_HOST,
+            logger: options.logger ?? console,
+        };
+    }
+    get address() {
+        if (!this.wss)
+            return null;
+        const addr = this.wss.address();
+        return typeof addr === "string" || addr === null ? null : addr;
+    }
+    async start() {
+        if (this.wss) {
+            // this.options.logger.warn("Attempted to start an already running server.");
+            return;
+        }
+        this.wss = new WebSocketServer({
+            host: this.options.host,
+            port: this.options.port,
+        });
+        this.wss.on("connection", (socket, request) => this.handleConnection(socket, request.headers));
+        this.wss.on("close", () => this.handleServerClose());
+        try {
+            await Promise.race([
+                once(this.wss, "listening"),
+                once(this.wss, "error").then(([error]) => {
+                    throw error;
+                }),
+            ]);
+        }
+        catch (error) {
+            // this.options.logger.error(
+            //   `Failed to start WebSocket server on ws://${this.options.host}:${this.options.port}`,
+            //   error
+            // );
+            await this.stop();
+            if (error.code === "EADDRINUSE" ||
+                error.message.includes("address already in use")) {
+                throw `Failed to start the OnCall server.
+
+      Port 4466 is already in use.
+      Stop the other process or free the port and try again.
+      `;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async stop() {
+        if (!this.wss) {
+            return;
+        }
+        const server = this.wss;
+        this.wss = null;
+        await new Promise((resolve, reject) => {
+            server.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        // this.options.logger.info("Server stopped.");
+    }
+    handleServerClose() {
+        // noop for now
+    }
+    handleConnection(socket, headers) {
+        // this.options.logger.info(
+        //   `Client connected from ${headers["x-forwarded-for"] || "local"}`
+        // );
+        socket.on("message", (data) => this.handleMessage(socket, data));
+        socket.on("close", (code, reason) => {
+            // this.options.logger.info(
+            //   `Client disconnected`
+            // );
+        });
+        socket.on("error", (error) => {
+            // this.options.logger.warn("Client error:", error);
+            socket.close(1011, "internal_error");
+        });
+    }
+    handleMessage(socket, raw) {
+        let payload;
+        try {
+            const serialized = typeof raw === "string" ? raw : raw.toString("utf8").trim();
+            if (!serialized)
+                return;
+            payload = JSON.parse(serialized);
+        }
+        catch (error) {
+            this.send(socket, {
+                type: "error",
+                message: "Invalid JSON payload",
+            });
+            // this.options.logger.warn("Invalid payload received:", error);
+            return;
+        }
+        switch (payload.type) {
+            case "register": {
+                const projectPayload = "project" in payload
+                    ? payload.project
+                    : undefined;
+                const project = this.normalizeProjectPayload(projectPayload);
+                if (!project) {
+                    this.send(socket, {
+                        type: "error",
+                        message: "Invalid project payload for register channel",
+                    });
+                    return;
+                }
+                const projectRecord = this.upsertProjectRegistration(project);
+                this.send(socket, {
+                    type: "register_ack",
+                    projectId: project.id,
+                    totalRegisteredProjects: projectRecord.projects.length,
+                });
+                break;
+            }
+            case "fetch_projects": {
+                logd("Received the fetch_projects_req");
+                let projectRecord = this.allProjects.find((entry) => entry.id === payload.id);
+                logd("Found the following: " + JSON.stringify(projectRecord.projects));
+                this.send(socket, {
+                    type: "fetch_projects_ack",
+                    projects: projectRecord.projects,
+                });
+                logd("Sent the response for fetch_projects");
+                break;
+            }
+            default: {
+                this.send(socket, {
+                    type: "ack",
+                    message: `Unhandled message type "${payload.type}"`,
+                });
+            }
+        }
+    }
+    send(socket, message) {
+        if (socket.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        try {
+            socket.send(JSON.stringify(message));
+        }
+        catch (error) {
+            // this.options.logger.warn("Failed to send message to client:", error);
+        }
+    }
+    normalizeProjectPayload(payload) {
+        if (!payload ||
+            typeof payload.id !== "string" ||
+            typeof payload.description !== "string" ||
+            typeof payload.path !== "string") {
+            return null;
+        }
+        const id = payload.id.trim();
+        const description = payload.description.trim();
+        const projectPath = payload.path.trim();
+        const name = typeof payload.name === "string" && payload.name.trim()
+            ? payload.name.trim()
+            : undefined;
+        const window_id = typeof payload.window_id === "number" ? payload.window_id : Date.now();
+        const logs_available = typeof payload.logs_available === "boolean"
+            ? payload.logs_available
+            : true;
+        const code_available = typeof payload.code_available === "boolean"
+            ? payload.code_available
+            : true;
+        if (!id || !description || !projectPath) {
+            return null;
+        }
+        return {
+            id,
+            description,
+            path: projectPath,
+            name,
+            window_id,
+            logs_available,
+            code_available,
+        };
+    }
+    upsertProjectRegistration(project) {
+        let projectRecord = this.allProjects.find((entry) => entry.id === project.id);
+        if (!projectRecord) {
+            projectRecord = { id: project.id, projects: [] };
+            this.allProjects.push(projectRecord);
+        }
+        const existingProject = projectRecord.projects.find((item) => item.path === project.path);
+        if (existingProject) {
+            existingProject.description = project.description;
+            if (project.name) {
+                existingProject.name = project.name;
+            }
+            existingProject.window_id = project.window_id;
+            existingProject.logs_available = project.logs_available;
+            existingProject.code_available = project.code_available;
+        }
+        else {
+            projectRecord.projects.push({
+                path: project.path,
+                description: project.description,
+                name: project.name,
+                window_id: project.window_id,
+                logs_available: project.logs_available,
+                code_available: project.code_available,
+            });
+        }
+        // this.options.logger.info(
+        //   `Registered project "${project.id}" -> ${project.path} (total directories: ${projectRecord.projects.length})`
+        // );
+        // const snapshot = JSON.stringify(this.allProjects, null, 2);
+        // this.options.logger.info(`Current projects: ${snapshot}`);
+        return projectRecord;
+    }
+}
+export async function startOnCallWebSocketServer(options) {
+    const server = new OnCallWebSocketServer(options);
+    await server.start();
+    return server;
+}
+//# sourceMappingURL=websocket-server.js.map

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "clippy-test",
-  "version": "1.0.9",
+  "version": "2.0.1",
   "type": "module",
   "bin": {
-    "clippy": "bin/clippy.js"
+    "oncall": "bin/oncall.js"
   },
   "files": [
     "bin/",
@@ -15,24 +15,37 @@
     "start": "tsx index.tsx",
     "dev": "tsx index.tsx",
     "code-hierarchy": "tsx code_hierarchy.ts",
-    "build": "tsc",
+    "postinstall": "node dist/postinstall.js",
+    "build": "patch-package && tsc && npm run copy-js && npm run clean-maps",
+    "copy-js": "mkdir -p dist/helpers && cp helpers/config-helpers.js dist/helpers/config-helpers.js && cp postinstall.js dist/postinstall.js",
+    "clean-maps": "find dist -name '*.map' -type f -delete 2>/dev/null || true",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@langchain/anthropic": "^1.3.3",
+    "@langchain/core": "^1.1.0",
+    "@langchain/openai": "^1.2.0",
+    "@types/ws": "^8.18.1",
     "axios": "^1.12.2",
     "dotenv": "^17.2.3",
     "ignore": "^5.3.2",
     "ink": "^6.3.1",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
+    "js-yaml": "^4.1.1",
+    "langchain": "^1.1.1",
     "marked": "^15.0.0",
     "marked-terminal": "^7.3.0",
-    "node-pty": "^1.0.0",
-    "react": "^19.2.0"
+    "node-pty": "0.10.1",
+    "react": "^19.2.0",
+    "ripgrep-node": "^1.0.0",
+    "ws": "^8.18.3",
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@types/node": "^24.9.1",
     "@types/react": "^19.1.13",
+    "patch-package": "^8.0.1",
     "tsx": "^4.19.2",
     "typescript": "^5.9.3"
   }