binary-collections 2.0.10 → 2.0.11

package/lib/chunk-YXSFGA2D.mjs

@@ -1,383 +0,0 @@
-import { createRequire } from 'module'; const require = createRequire(import.meta.url);
-import {
-  __require,
-  init_esm_shims
-} from "./chunk-QQ4A6DLD.mjs";
-
-// src/utils/chatgpt.js
-init_esm_shims();
-import fs from "fs-extra";
-import puppeteer from "puppeteer-extra";
-import StealthPlugin from "puppeteer-extra-plugin-stealth";
-import path from "upath";
-import { pathToFileURL } from "url";
-var COOKIE_DIR = path.join(process.cwd(), "tmp", "cookies");
-var DEFAULT_COOKIE_PATH = path.join(COOKIE_DIR, "cookies.json");
-fs.ensureDirSync(COOKIE_DIR);
-async function saveCookies(page, path2 = DEFAULT_COOKIE_PATH) {
-  const cookies = await page.cookies();
-  fs.writeFileSync(path2, JSON.stringify(cookies, null, 2));
-}
-function getCookiePathForUrl(url) {
-  try {
-    const { hostname } = new URL(url);
-    return path.join(COOKIE_DIR, `cookies_${hostname}.json`);
-  } catch {
-    return DEFAULT_COOKIE_PATH;
-  }
-}
-async function navigatePage(page, url) {
-  const cookiePath = getCookiePathForUrl(url);
-  const cookies = loadCookies(cookiePath);
-  if (cookies) {
-    await page.setCookie(...cookies);
-  }
-  await page.goto(url, { waitUntil: "networkidle0" });
-  await page.evaluate(() => {
-    window.__domStillUpdating = true;
-    if (window.__domObserver) {
-      window.__domObserver.disconnect();
-    }
-    window.__domObserver = new MutationObserver(() => {
-      window.__lastDomMutation = Date.now();
-    });
-    window.__lastDomMutation = Date.now();
-    window.__domObserver.observe(document.body, {
-      childList: true,
-      subtree: true,
-      attributes: true,
-      characterData: true
-    });
-    setTimeout(() => {
-      window.__domStillUpdating = false;
-      window.__domObserver.disconnect();
-    }, 3e4);
-  });
-  const waitForDomIdle = async (idleMs = 1e3, timeout = 1e4) => {
-    const start = Date.now();
-    while (Date.now() - start < timeout) {
-      const lastMutation = await page.evaluate(() => window.__lastDomMutation);
-      const idle = Date.now() - lastMutation;
-      if (idle >= idleMs) {
-        return true;
-      }
-      await new Promise((r) => setTimeout(r, 200));
-    }
-    throw new Error("DOM did not stabilize within timeout");
-  };
-  return { waitForDomIdle };
-}
-function loadCookies(cookieFilePath = DEFAULT_COOKIE_PATH) {
-  if (!fs.existsSync(cookieFilePath)) return null;
-  return JSON.parse(fs.readFileSync(cookieFilePath));
-}
-async function writeQuestion(page, question) {
-  const questions = question.split("\n");
-  const promptTextarea = await page.waitForSelector("#prompt-textarea", { timeout: 3e4 });
-  if (!promptTextarea) {
-    console.log(
-      "Cannot find the prompt input on the webpage. Please check whether you have access to chat.openai.com without logging in via your browser."
-    );
-  }
-  await page.evaluate(() => {
-    document.querySelector("#prompt-textarea").innerHTML = `<p></p>`;
-  });
-  if (questions.length === 1) {
-    await page.type("#prompt-textarea", questions[0], { delay: 100 });
-    return;
-  }
-  for (const q of questions) {
-    await page.type("#prompt-textarea", q, { delay: 100 });
-    if (q !== questions[questions.length - 1]) {
-      await page.keyboard.down("Shift");
-      await page.keyboard.press("Enter");
-      await page.keyboard.up("Shift");
-    }
-  }
-}
-async function clickSubmitButton(page) {
-  try {
-    const fruitjuiceSendButton = await page.evaluate(() => {
-      return document.querySelector('[data-testid="fruitjuice-send-button"]') !== null;
-    });
-    const sendButton = await page.evaluate(() => {
-      return document.querySelector('[data-testid="send-button"]') !== null;
-    });
-    if (fruitjuiceSendButton) {
-      await page.click('[data-testid="fruitjuice-send-button"]');
-    } else if (sendButton) {
-      await page.click('[data-testid="send-button"]');
-    } else {
-      console.log("Neither send button is present");
-    }
-  } catch (e) {
-    console.log(`Failed to click the send button: ${e}`);
-  }
-}
-var lastMessageId = null;
-var messageCount = 0;
-var is_streaming = false;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function waitForInitialResponse(page, timeout = 3e4) {
-  const startTime = Date.now();
-  while (Date.now() - startTime < timeout) {
-    const assistantMessages = await page.$$('[data-message-author-role="assistant"]');
-    const currentMessageCount = assistantMessages.length;
-    if (currentMessageCount > messageCount) {
-      const lastMessage = assistantMessages[assistantMessages.length - 1];
-      const isThinking = await lastMessage.$(".result-thinking");
-      if (!isThinking) {
-        lastMessageId = await page.evaluate((element) => element.getAttribute("data-message-id"), lastMessage);
-        messageCount = currentMessageCount;
-        return;
-      }
-    }
-    await sleep(100);
-  }
-  console.log("Timed out waiting for the initial response.");
-}
-async function handleStreamingResponse(page, outputFile = path.join(process.cwd(), "tmp/response.txt")) {
-  let previousText = "";
-  let completeResponse = "";
-  let newContentDetected = false;
-  while (!newContentDetected) {
-    const assistantMessages = await page.$$('[data-message-author-role="assistant"]');
-    if (assistantMessages.length > 0) {
-      const lastMessage = assistantMessages[assistantMessages.length - 1];
-      const currentMessageId = await page.evaluate((element) => element.getAttribute("data-message-id"), lastMessage);
-      if (currentMessageId === lastMessageId) {
-        const currentText = await page.evaluate((element) => element.textContent, lastMessage);
-        console.log(`Current text: ${currentText}`);
-        if (currentText !== previousText) {
-          if (is_streaming) {
-            process.stdout.write(currentText.slice(previousText.length));
-          } else {
-            completeResponse += currentText.slice(previousText.length);
-          }
-        }
-        previousText = currentText;
-        const isStreaming = await lastMessage.$(".result-streaming");
-        if (!isStreaming) {
-          newContentDetected = true;
-        }
-      } else {
-        lastMessageId = currentMessageId;
-      }
-    }
-    await sleep(100);
-  }
-  if (!is_streaming) {
-    console.log(completeResponse.trim());
-    console.log("\n\n");
-    fs.ensureDirSync(path.dirname(outputFile));
-    fs.writeFileSync(outputFile, completeResponse.trim());
-    console.log(`Response saved to ${outputFile}`);
-  }
-}
-async function isLoggedIn(page) {
-  const result = await page.evaluate(() => {
-    const loginButton = document.querySelector('[data-testid="login-button"]');
-    return !(loginButton && loginButton.offsetParent !== null);
-  });
-  return result === true;
-}
-async function createBrowser(browserOptions = {}) {
-  const defaultOptions = {
-    headless: false,
-    userDataDir: path.join(process.cwd(), "tmp/puppeteer-profile"),
-    // Windows-specific options to handle browser launch issues
-    args: [
-      "--no-sandbox",
-      "--disable-setuid-sandbox",
-      "--disable-dev-shm-usage",
-      "--disable-accelerated-2d-canvas",
-      "--no-first-run",
-      "--no-zygote",
-      "--disable-gpu",
-      "--disable-background-timer-throttling",
-      "--disable-backgrounding-occluded-windows",
-      "--disable-renderer-backgrounding"
-    ],
-    ignoreDefaultArgs: ["--disable-extensions"],
-    ...process.platform === "win32" && {
-      // Additional Windows-specific options
-      executablePath: void 0
-      // Let Puppeteer find Chrome automatically
-    }
-  };
-  try {
-    return await puppeteer.use(StealthPlugin()).launch({ ...defaultOptions, ...browserOptions });
-  } catch (_error) {
-    console.error("Failed to launch browser with default options. Trying fallback options...");
-    try {
-      return await puppeteer.use(StealthPlugin()).launch({
-        headless: browserOptions.headless || false,
-        args: ["--no-sandbox", "--disable-setuid-sandbox"],
-        ignoreDefaultArgs: false,
-        ...browserOptions
-      });
-    } catch (fallbackError) {
-      console.error("Browser launch failed completely. Common solutions:");
-      console.error("1. Install Google Chrome if not installed");
-      console.error("2. Update Node.js to the latest version");
-      console.error("3. Try running: npm install puppeteer --force");
-      console.error("4. Check if antivirus is blocking browser launch");
-      throw new Error(`Browser launch failed: ${fallbackError.message}`);
-    }
-  }
-}
-async function loginToChatGpt() {
-  const browser = await createBrowser({ headless: false });
-  const page = (await browser.pages()).length > 0 ? (await browser.pages())[0] : await browser.newPage();
-  const url = "https://chat.openai.com";
-  const navigate = await navigatePage(page, url);
-  await navigate.waitForDomIdle(2e3, 1e4);
-  const loginButtonExists = await page.evaluate(() => {
-    return document.querySelector('[data-testid="login-button"]') !== null;
-  });
-  if (loginButtonExists) {
-    console.log("Login button found, clicking to log in...");
-    await page.click('[data-testid="login-button"]');
-    await page.waitForNavigation({ waitUntil: "networkidle0" });
-    console.log("Login process completed.");
-  } else {
-    console.log("No login required - user appears to be already logged in.");
-  }
-}
-async function runChatGpt(chatgptOptions = {}) {
-  const headless = chatgptOptions.headless !== void 0 ? chatgptOptions.headless : true;
-  const questionFile = chatgptOptions.questionFile;
-  let question = chatgptOptions.question;
-  const responseFile = chatgptOptions.responseFile || path.join(process.cwd(), "tmp", "response.txt");
-  const noInputProvided = !question && !questionFile;
-  const questionIsEmpty = question && question.trim().length === 0;
-  const questionFileIsEmpty = questionFile && questionFile.trim().length === 0;
-  if (noInputProvided || questionIsEmpty || questionFileIsEmpty) {
-    throw new Error("You must provide a question or a question file.");
-  }
-  let browser;
-  try {
-    browser = await createBrowser({ headless });
-  } catch (error) {
-    console.error("Error running ChatGPT:", error);
-    console.error("\nTroubleshooting steps:");
-    console.error("1. Make sure Google Chrome is installed");
-    console.error("2. Try running: yarn add puppeteer --force");
-    console.error("3. Check if your antivirus is blocking the browser");
-    console.error("4. Close any running Chrome instances and try again");
-    throw error;
-  }
-  const page = (await browser.pages()).length > 0 ? (await browser.pages())[0] : await browser.newPage();
-  try {
-    const url = "https://chat.openai.com";
-    const navigate = await navigatePage(page, url);
-    await navigate.waitForDomIdle(2e3, 15e3);
-    try {
-      const tempChatButton = await page.$('button[aria-label="Turn on temporary chat"]');
-      if (tempChatButton) {
-        await page.evaluate((el) => el.click(), tempChatButton);
-        console.log("Successfully clicked temporary chat button");
-        await navigate.waitForDomIdle(1e3, 1e4);
-      } else {
-        console.log("Temporary chat button not found, proceeding without it.");
-      }
-    } catch (error) {
-      console.log(`Failed to click temporary chat button: ${error.message}`);
-    }
-    if (question) {
-      await writeQuestion(page, question);
-      await clickSubmitButton(page);
-      await navigate.waitForDomIdle(1e3, 3e4);
-      await waitForInitialResponse(page);
-      await handleStreamingResponse(page, responseFile);
-      await saveCookies(page, getCookiePathForUrl(url));
-    } else if (questionFile) {
-      await navigate.waitForDomIdle(2e3, 1e4);
-      const isUserLoggedIn = await isLoggedIn(page);
-      console.log(`Login status: ${isUserLoggedIn ? "Logged in" : "Not logged in"}`);
-      if (!isUserLoggedIn) {
-        console.log(
-          "Not logged in. Please log in to ChatGPT in the browser window, then close it and run the command again."
-        );
-        return loginToChatGpt();
-      }
-      const plusButtonExists = await page.evaluate(() => {
-        const button = document.querySelector('[data-testid="composer-plus-btn"]');
-        return button !== null;
-      });
-      if (plusButtonExists) {
-        await page.click('[data-testid="composer-plus-btn"]');
-        await sleep(500);
-        const menuItems = await page.$$('[role="menuitem"]');
-        let clicked = false;
-        for (const item of menuItems) {
-          const text = await page.evaluate((el) => el.innerText, item);
-          if (text && text.includes("Add photos") && text.includes("files")) {
-            await item.hover();
-            clicked = true;
-            break;
-          }
-        }
-        if (!clicked) {
-          console.log('Could not find the "Add photos & files" menu item.');
-          return;
-        }
-        try {
-          await sleep(1e3);
-          const fileInput = await page.waitForSelector('input[type="file"]', { timeout: 1e4 });
-          if (fileInput) {
-            console.log(`Uploading file: ${questionFile}`);
-            await fileInput.uploadFile(questionFile);
-            await navigate.waitForDomIdle(2e3, 15e3);
-            console.log("File uploaded successfully");
-            await clickSubmitButton(page);
-            await navigate.waitForDomIdle(1e3, 3e4);
-            await waitForInitialResponse(page);
-            await handleStreamingResponse(page, responseFile);
-          } else {
-            console.log("Could not find file input element");
-          }
-        } catch (error) {
-          console.log(`Error uploading file: ${error.message}`);
-        }
-      } else {
-        console.log('Could not find the [data-testid="composer-plus-btn"] button.');
-      }
-    }
-  } finally {
-    if (browser) {
-      await browser.close();
-    }
-  }
-}
-var isMain = false;
-try {
-  if (typeof __require !== "undefined" && typeof module !== "undefined" && __require.main === module) {
-    isMain = true;
-  }
-  const mainArg = process.argv[1] && path.resolve(process.argv[1]);
-  console.log(typeof __require, typeof module, __require.main === module, mainArg);
-} catch (_e) {
-}
-try {
-  const mainArg = process.argv[1] && path.resolve(process.argv[1]);
-  if (mainArg && import.meta.url === pathToFileURL(mainArg).href) {
-    isMain = true;
-  }
-} catch (_e) {
-}
-if (isMain) {
-  (async () => {
-    try {
-      await runChatGpt({ headless: false, questionFile: path.join(process.cwd(), "tmp/gpt-question.txt") });
-    } catch (error) {
-      console.error("Error running ChatGPT:", error);
-    }
-  })();
-}
-
-export {
-  runChatGpt
-};

package/lib/git/gitattributes.d.ts

@@ -1,33 +0,0 @@
-/**
- * Parse existing .gitattributes file into structured rules
- * @param {string} gitattributesPath - Path to .gitattributes file
- * @returns {Array} Array of parsed rules
- */
-export function parseGitAttributes(gitattributesPath: string): any[];
-/**
- * Check if two patterns conflict (same or overlapping file patterns)
- * @param {string} pattern1 - First pattern
- * @param {string} pattern2 - Second pattern
- * @returns {boolean} True if patterns conflict
- */
-export function patternsConflict(pattern1: string, pattern2: string): boolean;
-/**
- * Merge existing rules with desired rules, detecting conflicts
- * @param {Array} existingRules - Parsed existing rules
- * @param {Array} desiredRules - Desired rules to add
- * @returns {Object} Result with mergedRules, conflicts, and changes
- */
-export function mergeGitAttributeRules(existingRules: any[], desiredRules: any[]): any;
-/**
- * Format merged rules back into .gitattributes content
- * @param {Array} rules - Merged rules array
- * @returns {string} Formatted .gitattributes content
- */
-export function formatGitAttributes(rules: any[]): string;
-/**
- * Update .gitattributes file with new rules, handling conflicts intelligently
- * @param {string} gitattributesPath - Path to .gitattributes file
- * @param {Array} desiredRules - Array of desired rules to add/merge
- * @returns {Object} Result with success status, conflicts, and changes
- */
-export function updateGitAttributes(gitattributesPath: string, desiredRules: any[]): any;

package/lib/git/gitattributes.js

@@ -1,223 +0,0 @@
-const fs = require("fs");
-/**
- * Parse existing .gitattributes file into structured rules
- * @param {string} gitattributesPath - Path to .gitattributes file
- * @returns {Array} Array of parsed rules
- */
-function parseGitAttributes(gitattributesPath) {
-    const rules = [];
-    if (!fs.existsSync(gitattributesPath)) {
-        return rules;
-    }
-    const content = fs.readFileSync(gitattributesPath, "utf8");
-    const lines = content.split("\n");
-    lines.forEach((line, index) => {
-        const trimmedLine = line.trim();
-        // Skip empty lines and comments
-        if (!trimmedLine || trimmedLine.startsWith("#")) {
-            rules.push({
-                type: trimmedLine.startsWith("#") ? "comment" : "empty",
-                content: line,
-                lineNumber: index + 1
-            });
-            return;
-        }
-        // Parse rule line
-        const parts = trimmedLine.split(/\s+/);
-        if (parts.length >= 2) {
-            const pattern = parts[0];
-            const attributes = parts.slice(1).join(" ");
-            rules.push({
-                type: "rule",
-                pattern,
-                attributes,
-                content: line,
-                lineNumber: index + 1
-            });
-        }
-        else {
-            // Invalid line, keep as-is
-            rules.push({
-                type: "invalid",
-                content: line,
-                lineNumber: index + 1
-            });
-        }
-    });
-    return rules;
-}
-/**
- * Check if two patterns conflict (same or overlapping file patterns)
- * @param {string} pattern1 - First pattern
- * @param {string} pattern2 - Second pattern
- * @returns {boolean} True if patterns conflict
- */
-function patternsConflict(pattern1, pattern2) {
-    // Exact match
-    if (pattern1 === pattern2) {
-        return true;
-    }
-    // Universal pattern conflicts with everything
-    if (pattern1 === "*" || pattern2 === "*") {
-        return pattern1 !== pattern2;
-    }
-    // Simple glob overlap detection
-    const normalize = (p) => p.replace(/\{[^}]+\}/g, "*").replace(/\*+/g, "*");
-    const norm1 = normalize(pattern1);
-    const norm2 = normalize(pattern2);
-    return norm1 === norm2;
-}
-/**
- * Merge existing rules with desired rules, detecting conflicts
- * @param {Array} existingRules - Parsed existing rules
- * @param {Array} desiredRules - Desired rules to add
- * @returns {Object} Result with mergedRules, conflicts, and changes
- */
-function mergeGitAttributeRules(existingRules, desiredRules) {
-    let mergedRules;
-    if (existingRules.length === 0) {
-        // If no existing rules, just add all desired rules in order
-        mergedRules = desiredRules.map((desired, idx) => ({
-            type: "rule",
-            pattern: desired.pattern,
-            attributes: desired.attributes,
-            content: `${desired.pattern} ${desired.attributes}`,
-            lineNumber: idx + 1,
-            added: true
-        }));
-        return {
-            mergedRules,
-            conflicts: [],
-            changes: desiredRules.map((rule) => ({ action: "added", pattern: rule.pattern, attributes: rule.attributes }))
-        };
-    }
-    else {
-        mergedRules = [...existingRules];
-    }
-    const conflicts = [];
-    const changes = [];
-    desiredRules.forEach((desired) => {
-        // Look for an exact pattern match in existing rules
-        const existingIdx = mergedRules.findIndex((r) => r.type === "rule" && r.pattern === desired.pattern);
-        if (existingIdx !== -1) {
-            const existing = mergedRules[existingIdx];
-            if (existing.attributes === desired.attributes) {
-                // Already present, do nothing
-                conflicts.push({
-                    pattern: desired.pattern,
-                    existing: existing.attributes,
-                    proposed: desired.attributes,
-                    action: "kept existing (identical)"
-                });
-            }
-            else if (desired.priority > (existing.priority || 0)) {
-                // Replace with higher priority rule
-                mergedRules[existingIdx] = {
-                    type: "rule",
-                    pattern: desired.pattern,
-                    attributes: desired.attributes,
-                    content: `${desired.pattern} ${desired.attributes}`,
-                    lineNumber: existing.lineNumber,
-                    replaced: true
-                };
-                conflicts.push({
-                    pattern: desired.pattern,
-                    existing: existing.attributes,
-                    proposed: desired.attributes,
-                    action: "replaced (higher priority)"
-                });
-                changes.push({
-                    action: "replaced",
-                    pattern: desired.pattern,
-                    attributes: desired.attributes,
-                    oldAttributes: existing.attributes
-                });
-            }
-            else {
-                // Keep existing rule
-                conflicts.push({
-                    pattern: desired.pattern,
-                    existing: existing.attributes,
-                    proposed: desired.attributes,
-                    action: "kept existing (lower priority)"
-                });
-            }
-        }
-        else {
-            // No exact pattern match, add new rule
-            mergedRules.push({
-                type: "rule",
-                pattern: desired.pattern,
-                attributes: desired.attributes,
-                content: `${desired.pattern} ${desired.attributes}`,
-                lineNumber: mergedRules.length + 1,
-                added: true
-            });
-            changes.push({
-                action: "added",
-                pattern: desired.pattern,
-                attributes: desired.attributes
-            });
-        }
-    });
-    return { mergedRules, conflicts, changes };
-}
-/**
- * Format merged rules back into .gitattributes content
- * @param {Array} rules - Merged rules array
- * @returns {string} Formatted .gitattributes content
- */
-function formatGitAttributes(rules) {
-    return (rules
-        .map((rule) => {
-        if (rule.type === "rule") {
-            return `${rule.pattern} ${rule.attributes}`;
-        }
-        return rule.content;
-    })
-        .join("\n") + "\n");
-}
-/**
- * Update .gitattributes file with new rules, handling conflicts intelligently
- * @param {string} gitattributesPath - Path to .gitattributes file
- * @param {Array} desiredRules - Array of desired rules to add/merge
- * @returns {Object} Result with success status, conflicts, and changes
- */
-function updateGitAttributes(gitattributesPath, desiredRules) {
-    try {
-        // Parse existing .gitattributes
-        const existingRules = parseGitAttributes(gitattributesPath);
-        // Merge rules and detect conflicts
-        const { mergedRules, conflicts, changes } = mergeGitAttributeRules(existingRules, desiredRules);
-        // Write updated .gitattributes if changes were made
-        let success = false;
-        if (changes.length > 0) {
-            const newContent = formatGitAttributes(mergedRules);
-            fs.writeFileSync(gitattributesPath, newContent);
-            success = true;
-        }
-        return {
-            success,
-            conflicts,
-            changes,
-            message: success
-                ? `Updated .gitattributes with ${changes.length} changes`
-                : "No changes needed - all rules already present"
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: error.message,
-            conflicts: [],
-            changes: []
-        };
-    }
-}
-module.exports = {
-    parseGitAttributes,
-    patternsConflict,
-    mergeGitAttributeRules,
-    formatGitAttributes,
-    updateGitAttributes
-};