clippy-test 1.0.8 → 2.0.0

package/dist/config.js

@@ -1,12 +1,12 @@
 import dotenv from "dotenv";
 dotenv.config();
 export const config = {
-    redis_username: process.env.REDIS_USERNAME || "default",
-    redis_password: process.env.REDIS_PASSWORD || "",
-    redis_host: process.env.REDIS_HOST || "",
-    redis_port: process.env.REDIS_PORT || "25061",
-    websocket_url: process.env.WEB_SOCKET_URL || "wss://prod.revise.network/clippy/ws",
-    auth_key: process.env.AUTH_KEY || "",
-    api_base_url: process.env.API_BASE_URL || "https://prod.revise.network/clippy/api",
+    redis_username: process.env.REDIS_USERNAME,
+    redis_password: process.env.REDIS_PASSWORD,
+    redis_host: process.env.REDIS_HOST,
+    redis_port: process.env.REDIS_PORT,
+    websocket_url: process.env.WEB_SOCKET_URL || "wss://api.oncall.build/v2/ws",
+    auth_key: process.env.AUTH_KEY,
+    api_base_url: process.env.API_BASE_URL || "https://api.oncall.build/v2/api",
 };
 //# sourceMappingURL=config.js.map

package/dist/helpers/cli-helpers.d.ts

@@ -0,0 +1,25 @@
+export function printHelp(): void;
+export function printLoginHelp(): void;
+export function printInitHelp(): void;
+export function printClusterHelp(): void;
+export function ensureConfigDir(): void;
+export function buildYaml(projectId: any, description: any, name: any): string;
+export function loadProjectMetadata(cwdPath?: string): {
+    id: any;
+    description: any;
+    name: any;
+    window_id: number;
+    logs_available: any;
+    code_available: any;
+    path: string;
+    raw: string;
+};
+export function registerProjectWithCluster(metadata: any, clusterUrl?: string): Promise<any>;
+export function fetchProjectsFromCluster(metadata: any, clusterUrl?: string): Promise<any>;
+export function ensureClusterIsReady(metadata: any, registrationPromise: any): Promise<boolean>;
+export function logd(d: any): void;
+export const HOME_DIR: string;
+export const ONCALL_DIR: string;
+export const CONFIG_PATH: string;
+export const LOGS_DIR: string;
+export const CONFIG_TEMPLATE: "# OnCall Configuration File\n#\n# Place your OnCall API key here.\n# You can get a key from OnCall Web Studio.\n#\nAPI_KEY=\n\n# Project mappings (stored as JSON)\nprojects=[]\n";

package/dist/helpers/cli-helpers.js

@@ -0,0 +1,329 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import WebSocket from "ws";
+import YAML from "yaml";
+export const HOME_DIR = os.homedir();
+export const ONCALL_DIR = path.join(HOME_DIR, ".oncall");
+export const CONFIG_PATH = path.join(ONCALL_DIR, "config");
+export const LOGS_DIR = path.join(ONCALL_DIR, "logs");
+export const CONFIG_TEMPLATE = `# OnCall Configuration File
+#
+# Place your OnCall API key here.
+# You can get a key from OnCall Web Studio.
+#
+API_KEY=
+
+# Project mappings (stored as JSON)
+projects=[]
+`;
+//print help
+export function printHelp() {
+    console.log(`OnCall — AI debugging copilot for running applications
+
+Usage:
+  oncall <your command>
+
+OnCall requires a local server to be running:
+  oncall cluster
+
+Run your app with OnCall watching it:
+  oncall <your command>
+
+  Examples:
+    oncall npm run start
+    oncall node server.js
+    oncall python app.py
+
+Commands:
+  login        authenticate OnCall using an auth key
+  init         register the current project
+  cluster      start the local OnCall server
+  version      show version information
+
+Use --help with individual commands for details.
+
+Get an auth key from:
+  <https://app.oncall.build>
+`);
+}
+//printLoginHelp
+export function printLoginHelp() {
+    console.log(`Authenticate OnCall using an auth key.
+
+Usage:
+  oncall login <auth-key>
+
+Get an auth key from:
+  <https://oncall.dev/account>
+`);
+}
+//print init help
+export function printInitHelp() {
+    console.log(`Register a process with an OnCall project.
+
+An OnCall project groups multiple processes together
+so their runtime signals can be referenced in the same context.
+
+Usage:
+  oncall init --id <project-id> -m "<process description>"
+
+Options:
+  --id    Project identifier used to group related processes
+  -m      Short description of this process (used in conversations)
+
+Notes:
+  • Multiple processes can share the same project ID
+  • Each process must have its own description
+  • Processes may be started from different directories
+
+`);
+}
+//print cluster help
+export function printClusterHelp() {
+    console.log(`Start the local OnCall server for this project.
+
+The OnCall server connects all processes in the project
+so their runtime signals (logs, errors, requests) can be
+referenced together.
+
+This command must be running before you execute:
+  oncall <your command>
+
+Usage:
+  oncall cluster
+
+Notes:
+  • Keep this running in a separate terminal
+  • Run each service or process using "oncall <your command>"
+  • Press Ctrl+C to stop the server
+`);
+}
+export function ensureConfigDir() {
+    if (!fs.existsSync(ONCALL_DIR)) {
+        fs.mkdirSync(ONCALL_DIR, { recursive: true });
+        console.log(`✅ Created configuration directory: ${ONCALL_DIR}`);
+    }
+}
+export function buildYaml(projectId, description, name) {
+    const escape = (value) => value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    const lines = [
+        `id: "${escape(projectId)}"`,
+        `description: "${escape(description)}"`,
+    ];
+    if (name) {
+        lines.push(`name: "${escape(name)}"`);
+    }
+    const window_id = Date.now();
+    lines.push(`window_id: ${window_id}`);
+    lines.push(`logs_available: true`);
+    lines.push(`code_available: true`);
+    return `${lines.join("\n")}\n`;
+}
+export function loadProjectMetadata(cwdPath = process.cwd()) {
+    const yamlPath = path.join(cwdPath, "oncall.yaml");
+    if (!fs.existsSync(yamlPath)) {
+        return null;
+    }
+    try {
+        const contents = fs.readFileSync(yamlPath, "utf8");
+        const data = YAML.parse(contents);
+        if (!data?.id || !data?.description) {
+            console.warn('oncall.yaml is missing either "id" or "description". Proceeding without project metadata.');
+            return null;
+        }
+        return {
+            id: data?.id || "",
+            description: data?.description || "",
+            name: data?.name || "",
+            window_id: data?.window_id ? Number(data.window_id) : undefined,
+            logs_available: data?.logs_available || true,
+            code_available: data?.code_available || true,
+            path: cwdPath,
+            raw: contents,
+        };
+    }
+    catch (error) {
+        console.warn("Failed to read oncall.yaml. Proceeding without it.", error);
+        return null;
+    }
+}
+export function registerProjectWithCluster(metadata, clusterUrl = process.env.ONCALL_CLUSTER_URL || "ws://127.0.0.1:4466") {
+    return new Promise((resolve) => {
+        let settled = false;
+        let socket;
+        try {
+            socket = new WebSocket(clusterUrl);
+        }
+        catch (error) {
+            console.warn("Unable to connect to local cluster server. Continuing without registration.");
+            resolve(false);
+            return;
+        }
+        const cleanup = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutId);
+            try {
+                socket?.close();
+            }
+            catch {
+                // ignore
+            }
+            resolve(result);
+        };
+        const timeoutId = setTimeout(() => {
+            cleanup(false);
+        }, 2000);
+        socket.on("open", () => {
+            try {
+                const projectPayload = {
+                    id: metadata.id,
+                    description: metadata.description,
+                    name: metadata.name,
+                    path: metadata.path,
+                    window_id: typeof metadata.window_id === "number"
+                        ? metadata.window_id
+                        : Date.now(),
+                    logs_available: typeof metadata.logs_available === "boolean"
+                        ? metadata.logs_available
+                        : true,
+                    code_available: typeof metadata.code_available === "boolean"
+                        ? metadata.code_available
+                        : true,
+                };
+                socket.send(JSON.stringify({
+                    type: "register",
+                    project: projectPayload,
+                }));
+            }
+            catch (error) {
+                console.warn("Failed to send register payload to local cluster server. Continuing without registration.");
+                cleanup(false);
+            }
+        });
+        socket.on("message", (data) => {
+            try {
+                const serialized = typeof data === "string" ? data : data.toString("utf8");
+                if (!serialized) {
+                    return;
+                }
+                const parsed = JSON.parse(serialized);
+                if (parsed.type === "register_ack") {
+                    cleanup(true);
+                }
+            }
+            catch {
+                // ignore malformed ack
+            }
+        });
+        socket.on("close", () => {
+            cleanup(true);
+        });
+        socket.on("error", () => {
+            cleanup(false);
+        });
+    });
+}
+export function fetchProjectsFromCluster(metadata, clusterUrl = process.env.ONCALL_CLUSTER_URL || "ws://127.0.0.1:4466") {
+    logd(`Called fetchProjects, ${JSON.stringify(metadata)}`);
+    return new Promise((resolve) => {
+        let settled = false;
+        let socket;
+        try {
+            logd(`connecting to socket cluster to fetch`);
+            socket = new WebSocket(clusterUrl);
+        }
+        catch (error) {
+            console.warn("Unable to connect to local cluster server. Could not fetch projects.");
+            logd("Unable to connect to local cluster server. Could not fetch projects.");
+            resolve(false);
+            return;
+        }
+        const cleanup = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutId);
+            try {
+                socket?.close();
+            }
+            catch {
+                // ignore
+            }
+            resolve(result);
+        };
+        const timeoutId = setTimeout(() => {
+            logd("Fetching projects timed out");
+            cleanup(false);
+        }, 2000);
+        socket.on("open", () => {
+            try {
+                socket.send(JSON.stringify({
+                    type: "fetch_projects",
+                    id: metadata.id,
+                }));
+            }
+            catch (error) {
+                console.warn("Failed to send request to local cluster server. Continuing without fetching projects.");
+                logd("error sending fetch_projects req to cluster");
+                cleanup(false);
+            }
+        });
+        socket.on("message", (data) => {
+            try {
+                const serialized = typeof data === "string" ? data : data.toString("utf8");
+                if (!serialized) {
+                    return;
+                }
+                const parsed = JSON.parse(serialized);
+                if (parsed.type === "fetch_projects_ack") {
+                    cleanup(parsed);
+                }
+            }
+            catch {
+                // ignore malformed ack
+                logd("Malformed ack");
+            }
+        });
+        socket.on("close", () => {
+            logd("Connection closed");
+            cleanup(false);
+        });
+        socket.on("error", () => {
+            logd("Connection errored");
+            cleanup(false);
+        });
+    });
+}
+export async function ensureClusterIsReady(metadata, registrationPromise) {
+    if (!metadata) {
+        await registrationPromise?.catch(() => null);
+        return true;
+    }
+    try {
+        const result = await registrationPromise;
+        return result !== false;
+    }
+    catch {
+        return false;
+    }
+}
+export function logd(d) {
+    // try {
+    //   if (!fs.existsSync(LOGS_DIR)) {
+    //     fs.mkdirSync(LOGS_DIR, { recursive: true });
+    //   }
+    //   const now = new Date();
+    //   const day = String(now.getDate()).padStart(2, "0");
+    //   const month = String(now.getMonth() + 1).padStart(2, "0");
+    //   const year = String(now.getFullYear());
+    //   const dateStr = `${day}${month}${year}`;
+    //   const logFilePath = path.join(LOGS_DIR, `logs_${dateStr}.txt`);
+    //   fs.appendFileSync(logFilePath, `${d}\n`);
+    // } catch (error) {
+    //   console.error("Failed to log to logs file", error);
+    // }
+}
+//# sourceMappingURL=cli-helpers.js.map

package/dist/helpers/config-helpers.js

@@ -0,0 +1,189 @@
+import readline from "readline";
+import yaml from "js-yaml";
+import fs from "fs";
+
+let onCallYAML = {};
+if (fs.existsSync("oncall.yaml")) {
+  const readYAMLFile = fs.readFileSync("oncall.yaml", "utf8");
+  onCallYAML = yaml.load(readYAMLFile) ?? {};
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function upsertConfigValue(contents, key, value) {
+  const keyRegex = new RegExp(`^${escapeRegExp(key)}\\s*=.*$`, "m");
+  const nextLine = `${key}=${value}`;
+  if (keyRegex.test(contents)) {
+    return contents.replace(keyRegex, nextLine);
+  }
+  const trimmed = contents.trimEnd();
+  const prefix = trimmed.length > 0 ? `${trimmed}\n` : "";
+  return `${prefix}${nextLine}\n`;
+}
+
+export function readProjects(contents) {
+  const match = contents.match(/^projects\s*=\s*(\[.*\]|\{.*\})$/m);
+  if (!match) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(match[1]);
+    if (Array.isArray(parsed)) {
+      return parsed;
+    }
+    return Object.entries(parsed).map(([id, list]) => ({
+      id,
+      projects: Array.isArray(list) ? list : [],
+    }));
+  } catch (err) {
+    console.warn(
+      "⚠️  Failed to parse projects JSON; resetting to empty array."
+    );
+    return [];
+  }
+}
+
+export function writeProjects(contents, projectsArr) {
+  const serialized = JSON.stringify(projectsArr);
+  return upsertConfigValue(contents, "projects", serialized);
+}
+
+export function parseConfigFlags(argsList) {
+  let projectId = onCallYAML.id;
+  let message = onCallYAML.description;
+
+  for (let i = 1; i < argsList.length; i += 1) {
+    const token = argsList[i];
+
+    if (token === "-id") {
+      if (projectId !== undefined) {
+        console.error("❌ Duplicate -id flag detected.");
+        process.exit(1);
+      }
+      const next = argsList[i + 1];
+      if (!next) {
+        console.error(`Missing project ID.
+
+Usage:
+  oncall init --id <project-id> [-m "<description>"]`);
+        process.exit(1);
+      }
+      projectId = next.trim();
+      i += 1;
+    } else if (token === "-m") {
+      if (message !== undefined) {
+        console.error("❌ Duplicate -m flag detected.");
+        process.exit(1);
+      }
+      const next = argsList[i + 1];
+      if (!next) {
+        console.error(`Missing process description.
+
+Each process needs a short description so it can
+be referenced later in conversations.
+
+Usage:
+  oncall init -id <project-id> -m "<process description>"
+`);
+        process.exit(1);
+      }
+      message = next.trim();
+      i += 1;
+    }
+  }
+  if (!message) {
+    console.error(`Missing process description.
+
+Each process needs a short description so it can
+be referenced later in conversations.
+
+Usage:
+  oncall init -id <project-id> -m "<process description>"
+`);
+    process.exit(1);
+  }
+  return { projectId, message };
+}
+
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function promptForNewProjectId(projectsList) {
+  while (true) {
+    const input = await prompt("Enter new project id: ");
+    if (!input) {
+      console.log("Project id cannot be empty.");
+      continue;
+    }
+    const exists = projectsList.some((entry) => entry.id === input);
+    if (exists) {
+      console.log("Project id already exists. Please choose a different id.");
+      continue;
+    }
+    return input;
+  }
+}
+
+async function promptForExistingProject(projectsList) {
+  console.log("\nAvailable projects:");
+  projectsList.forEach((entry, index) => {
+    console.log(`  ${index + 1}. ${entry.id}`);
+  });
+  while (true) {
+    const input = await prompt("Select a project by number: ");
+    const choice = Number.parseInt(input, 10);
+    if (Number.isNaN(choice) || choice < 1 || choice > projectsList.length) {
+      console.log("Please enter a valid number from the list.");
+      continue;
+    }
+    return projectsList[choice - 1].id;
+  }
+}
+
+export async function resolveProjectId(initialId, projectsList) {
+  if (initialId) {
+    return initialId;
+  }
+
+  console.log("\nChoose an option:");
+  console.log("  1. Create new project");
+  console.log("  2. Use existing project");
+
+  while (true) {
+    const choice = await prompt("Enter choice (1 or 2): ");
+    if (choice === "1") {
+      return promptForNewProjectId(projectsList);
+    }
+    if (choice === "2") {
+      if (projectsList.length === 0) {
+        console.log("No existing projects found. Please create a new project.");
+        return promptForNewProjectId(projectsList);
+      }
+      return promptForExistingProject(projectsList);
+    }
+    console.log("Invalid choice. Please enter 1 or 2.");
+  }
+}
+
+export async function promptForInput(message) {
+  while (true) {
+    const input = await prompt(`${message} `);
+    if (!input) {
+      console.log("Project id cannot be empty.");
+      continue;
+    }
+    return input;
+  }
+}

package/dist/helpers/ripgrep-tool.d.ts

@@ -0,0 +1,15 @@
+export interface RipgrepResult {
+    filePath: string;
+    line?: number | null;
+    preview?: string;
+    score?: number;
+}
+export interface RipgrepOptions {
+    maxResults?: number;
+    caseSensitive?: boolean;
+    fileTypes?: string[];
+    excludePatterns?: string[];
+    workingDirectory?: string;
+}
+export declare function ripgrepSearch(query: string, options?: RipgrepOptions): Promise<RipgrepResult[]>;
+export declare function ripgrepSearchMultiple(queries: string[], options?: RipgrepOptions): Promise<RipgrepResult[]>;