chainlesschain 0.37.9 → 0.37.11

package/src/lib/bm25-search.js

@@ -0,0 +1,322 @@
+/**
+ * BM25 search engine for CLI
+ *
+ * Implements Okapi BM25 ranking algorithm for keyword-based search.
+ * Lightweight port of desktop-app-vue/src/main/rag/bm25-search.js
+ * No external dependencies — uses simple tokenization.
+ */
+
+/**
+ * Simple tokenizer for text
+ * Handles both Chinese and English text
+ */
+function tokenize(text, language = "auto") {
+  if (!text || typeof text !== "string") return [];
+
+  const normalized = text.toLowerCase().trim();
+
+  // Detect language
+  const hasChinese = /[\u4e00-\u9fff]/.test(normalized);
+  const lang = language === "auto" ? (hasChinese ? "zh" : "en") : language;
+
+  if (lang === "zh") {
+    // Chinese: character-level + word-level bigrams
+    const chars = normalized.match(/[\u4e00-\u9fff]/g) || [];
+    const words = normalized.match(/[a-z0-9]+/g) || [];
+    const bigrams = [];
+    for (let i = 0; i < chars.length - 1; i++) {
+      bigrams.push(chars[i] + chars[i + 1]);
+    }
+    return [...chars, ...bigrams, ...words];
+  }
+
+  // English: word tokenization with stop word removal
+  const STOP_WORDS = new Set([
+    "a",
+    "an",
+    "the",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "shall",
+    "can",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "between",
+    "but",
+    "and",
+    "or",
+    "not",
+    "no",
+    "nor",
+    "so",
+    "if",
+    "then",
+    "than",
+    "too",
+    "very",
+    "just",
+    "about",
+    "up",
+    "out",
+    "it",
+    "its",
+    "this",
+    "that",
+    "these",
+    "those",
+    "i",
+    "me",
+    "my",
+    "we",
+    "our",
+    "you",
+    "your",
+    "he",
+    "him",
+    "his",
+    "she",
+    "her",
+    "they",
+    "them",
+    "their",
+    "what",
+    "which",
+  ]);
+
+  return normalized
+    .split(/[^a-z0-9\u4e00-\u9fff]+/)
+    .filter((w) => w.length > 1 && !STOP_WORDS.has(w));
+}
+
+/**
+ * BM25 Search Engine
+ */
+export class BM25Search {
+  /**
+   * @param {object} options
+   * @param {number} [options.k1=1.5] - Term frequency saturation parameter
+   * @param {number} [options.b=0.75] - Length normalization parameter
+   * @param {string} [options.language="auto"] - Language for tokenization
+   */
+  constructor(options = {}) {
+    this.k1 = options.k1 || 1.5;
+    this.b = options.b || 0.75;
+    this.language = options.language || "auto";
+
+    // Index state
+    this.documents = []; // Array of { id, tokens, originalDoc }
+    this.df = new Map(); // document frequency per term
+    this.avgDl = 0; // average document length
+    this.totalDocs = 0;
+  }
+
+  /**
+   * Index a batch of documents
+   * @param {Array<{id: string, title?: string, content?: string}>} documents
+   */
+  indexDocuments(documents) {
+    this.documents = [];
+    this.df = new Map();
+
+    for (const doc of documents) {
+      const text = [doc.title || "", doc.content || ""].join(" ");
+      const tokens = tokenize(text, this.language);
+
+      this.documents.push({
+        id: doc.id,
+        tokens,
+        originalDoc: doc,
+      });
+
+      // Count document frequency
+      const seen = new Set();
+      for (const token of tokens) {
+        if (!seen.has(token)) {
+          seen.add(token);
+          this.df.set(token, (this.df.get(token) || 0) + 1);
+        }
+      }
+    }
+
+    this.totalDocs = this.documents.length;
+    this.avgDl =
+      this.totalDocs > 0
+        ? this.documents.reduce((sum, d) => sum + d.tokens.length, 0) /
+          this.totalDocs
+        : 0;
+  }
+
+  /**
+   * Add a single document to the index
+   */
+  addDocument(doc) {
+    const text = [doc.title || "", doc.content || ""].join(" ");
+    const tokens = tokenize(text, this.language);
+
+    this.documents.push({
+      id: doc.id,
+      tokens,
+      originalDoc: doc,
+    });
+
+    const seen = new Set();
+    for (const token of tokens) {
+      if (!seen.has(token)) {
+        seen.add(token);
+        this.df.set(token, (this.df.get(token) || 0) + 1);
+      }
+    }
+
+    this.totalDocs = this.documents.length;
+    this.avgDl =
+      this.documents.reduce((sum, d) => sum + d.tokens.length, 0) /
+      this.totalDocs;
+  }
+
+  /**
+   * Remove a document from the index
+   */
+  removeDocument(docId) {
+    const idx = this.documents.findIndex((d) => d.id === docId);
+    if (idx === -1) return false;
+
+    const doc = this.documents[idx];
+    const seen = new Set();
+    for (const token of doc.tokens) {
+      if (!seen.has(token)) {
+        seen.add(token);
+        const count = this.df.get(token) || 0;
+        if (count <= 1) {
+          this.df.delete(token);
+        } else {
+          this.df.set(token, count - 1);
+        }
+      }
+    }
+
+    this.documents.splice(idx, 1);
+    this.totalDocs = this.documents.length;
+    this.avgDl =
+      this.totalDocs > 0
+        ? this.documents.reduce((sum, d) => sum + d.tokens.length, 0) /
+          this.totalDocs
+        : 0;
+
+    return true;
+  }
+
+  /**
+   * Search for documents matching a query
+   * @param {string} query
+   * @param {object} [options]
+   * @param {number} [options.topK=10]
+   * @param {number} [options.threshold=0]
+   * @returns {Array<{id: string, score: number, doc: object}>}
+   */
+  search(query, options = {}) {
+    const topK = options.topK || 10;
+    const threshold = options.threshold || 0;
+
+    if (this.totalDocs === 0) return [];
+
+    const queryTokens = tokenize(query, this.language);
+    if (queryTokens.length === 0) return [];
+
+    const scores = [];
+
+    for (let i = 0; i < this.documents.length; i++) {
+      const score = this._calculateBM25(queryTokens, i);
+      if (score > threshold) {
+        scores.push({
+          id: this.documents[i].id,
+          score,
+          doc: this.documents[i].originalDoc,
+        });
+      }
+    }
+
+    scores.sort((a, b) => b.score - a.score);
+    return scores.slice(0, topK);
+  }
+
+  /**
+   * Calculate BM25 score for a document
+   */
+  _calculateBM25(queryTokens, docIdx) {
+    const doc = this.documents[docIdx];
+    const dl = doc.tokens.length;
+    let score = 0;
+
+    // Build term frequency map for this document
+    const tf = new Map();
+    for (const token of doc.tokens) {
+      tf.set(token, (tf.get(token) || 0) + 1);
+    }
+
+    for (const term of queryTokens) {
+      const termFreq = tf.get(term) || 0;
+      if (termFreq === 0) continue;
+
+      const docFreq = this.df.get(term) || 0;
+      if (docFreq === 0) continue;
+
+      // IDF component
+      const idf = Math.log(
+        (this.totalDocs - docFreq + 0.5) / (docFreq + 0.5) + 1,
+      );
+
+      // TF component with length normalization
+      const avgDl = this.avgDl || 1;
+      const tfNorm =
+        (termFreq * (this.k1 + 1)) /
+        (termFreq + this.k1 * (1 - this.b + this.b * (dl / avgDl)));
+
+      score += idf * tfNorm;
+    }
+
+    return score;
+  }
+
+  /**
+   * Get index statistics
+   */
+  getStats() {
+    return {
+      totalDocuments: this.totalDocs,
+      uniqueTerms: this.df.size,
+      avgDocumentLength: Math.round(this.avgDl),
+    };
+  }
+}

package/src/lib/browser-automation.js

@@ -0,0 +1,216 @@
+/**
+ * Headless browser automation — fetch, scrape, and extract content from web pages.
+ * Uses built-in fetch for basic operations, optional playwright for screenshots.
+ */
+
+/**
+ * Fetch a URL and return the raw HTML.
+ */
+export async function fetchPage(url, options = {}) {
+  const timeout = options.timeout || 30000;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const headers = {
+      "User-Agent": "ChainlessChain-CLI/0.37.9",
+      Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      ...(options.headers || {}),
+    };
+
+    const response = await fetch(url, {
+      headers,
+      signal: controller.signal,
+      redirect: "follow",
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} ${response.statusText}`);
+    }
+
+    const contentType = response.headers.get("content-type") || "";
+    const html = await response.text();
+
+    return {
+      url: response.url,
+      status: response.status,
+      contentType,
+      html,
+      size: html.length,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Extract text content from HTML, stripping tags.
+ */
+export function extractText(html) {
+  return html
+    .replace(/<script[\s\S]*?<\/script>/gi, "")
+    .replace(/<style[\s\S]*?<\/style>/gi, "")
+    .replace(/<nav[\s\S]*?<\/nav>/gi, "")
+    .replace(/<footer[\s\S]*?<\/footer>/gi, "")
+    .replace(/<!--[\s\S]*?-->/g, "")
+    .replace(/<br\s*\/?>/gi, "\n")
+    .replace(/<\/p>/gi, "\n\n")
+    .replace(/<\/div>/gi, "\n")
+    .replace(/<\/h[1-6]>/gi, "\n\n")
+    .replace(/<\/li>/gi, "\n")
+    .replace(/<[^>]+>/g, "")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(parseInt(n)))
+    .replace(/\n{3,}/g, "\n\n")
+    .replace(/[ \t]+/g, " ")
+    .split("\n")
+    .map((l) => l.trim())
+    .join("\n")
+    .trim();
+}
+
+/**
+ * Extract page title from HTML.
+ */
+export function extractTitle(html) {
+  const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  return match ? match[1].trim().replace(/\s+/g, " ") : "";
+}
+
+/**
+ * Extract meta description from HTML.
+ */
+export function extractMeta(html) {
+  const descMatch =
+    html.match(
+      /<meta\s+name=["']description["']\s+content=["']([^"']*?)["']/i,
+    ) ||
+    html.match(/<meta\s+content=["']([^"']*?)["']\s+name=["']description["']/i);
+  return descMatch ? descMatch[1] : "";
+}
+
+/**
+ * Extract elements matching a simple CSS selector.
+ * Supports: tag, .class, #id, tag.class, tag#id
+ */
+export function querySelectorAll(html, selector) {
+  const results = [];
+
+  // Parse selector
+  const tagMatch = selector.match(/^(\w+)/);
+  const classMatch = selector.match(/\.([a-zA-Z0-9_-]+)/);
+  const idMatch = selector.match(/#([a-zA-Z0-9_-]+)/);
+
+  const tag = tagMatch ? tagMatch[1] : null;
+  const className = classMatch ? classMatch[1] : null;
+  const id = idMatch ? idMatch[1] : null;
+
+  // Build regex pattern
+  let pattern;
+  if (tag) {
+    pattern = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, "gi");
+  } else if (className || id) {
+    pattern = new RegExp(`<\\w+[^>]*>([\\s\\S]*?)<\\/\\w+>`, "gi");
+  } else {
+    return results;
+  }
+
+  let match;
+  while ((match = pattern.exec(html)) !== null) {
+    const fullTag = match[0];
+
+    // Check class filter
+    if (className) {
+      const classAttr = fullTag.match(/class=["']([^"']*?)["']/i);
+      if (!classAttr || !classAttr[1].split(/\s+/).includes(className))
+        continue;
+    }
+
+    // Check id filter
+    if (id) {
+      const idAttr = fullTag.match(/id=["']([^"']*?)["']/i);
+      if (!idAttr || idAttr[1] !== id) continue;
+    }
+
+    results.push({
+      html: fullTag,
+      text: extractText(fullTag),
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Extract all links from HTML.
+ */
+export function extractLinks(html, baseUrl) {
+  const links = [];
+  const linkRegex = /<a\s+[^>]*href=["']([^"'#]+)["'][^>]*>([\s\S]*?)<\/a>/gi;
+  let match;
+
+  while ((match = linkRegex.exec(html)) !== null) {
+    let href = match[1];
+    const text = extractText(match[2]).trim();
+
+    // Resolve relative URLs
+    if (baseUrl && !href.startsWith("http")) {
+      try {
+        href = new URL(href, baseUrl).href;
+      } catch {
+        continue;
+      }
+    }
+
+    if (text && href.startsWith("http")) {
+      links.push({ href, text });
+    }
+  }
+
+  return links;
+}
+
+/**
+ * Take a screenshot using playwright (optional dependency).
+ * Returns null if playwright is not installed.
+ */
+export async function takeScreenshot(url, outputPath, options = {}) {
+  try {
+    const { chromium } = await import("playwright");
+    const browser = await chromium.launch({ headless: true });
+    const page = await browser.newPage({
+      viewport: {
+        width: options.width || 1280,
+        height: options.height || 720,
+      },
+    });
+
+    await page.goto(url, {
+      waitUntil: options.waitUntil || "networkidle",
+      timeout: options.timeout || 30000,
+    });
+
+    await page.screenshot({
+      path: outputPath,
+      fullPage: options.fullPage || false,
+    });
+
+    await browser.close();
+    return { success: true, path: outputPath };
+  } catch (err) {
+    if (
+      err.code === "ERR_MODULE_NOT_FOUND" ||
+      err.message?.includes("Cannot find")
+    ) {
+      return {
+        success: false,
+        error: "playwright not installed. Run: npm install -g playwright",
+      };
+    }
+    throw err;
+  }
+}

package/src/lib/cowork/ab-comparator-cli.js

@@ -0,0 +1,180 @@
+/**
+ * A/B Comparator for CLI
+ *
+ * Generates N solution variants for a prompt using different agent configurations,
+ * then scores and ranks them against specified criteria.
+ */
+
+import { createChatFn } from "../cowork-adapter.js";
+
+const DEFAULT_CRITERIA = ["quality", "performance", "readability"];
+
+const VARIANT_PROFILES = [
+  {
+    name: "conservative",
+    system:
+      "You are a conservative software engineer who favors proven patterns, stability, and minimal dependencies. Prefer simple, well-tested approaches over cutting-edge solutions.",
+  },
+  {
+    name: "innovative",
+    system:
+      "You are an innovative software engineer who favors modern patterns, new APIs, and elegant abstractions. Prioritize developer experience and future-proofing.",
+  },
+  {
+    name: "pragmatic",
+    system:
+      "You are a pragmatic software engineer who balances simplicity with capability. Choose the approach that ships fastest while maintaining acceptable quality.",
+  },
+  {
+    name: "performance-focused",
+    system:
+      "You are a performance-oriented engineer. Optimize for speed, memory efficiency, and minimal overhead. Accept complexity if it yields measurable performance gains.",
+  },
+];
+
+/**
+ * Generate and compare N solution variants
+ *
+ * @param {object} params
+ * @param {string} params.prompt - The task/problem description
+ * @param {number} [params.variants=3] - Number of variants to generate
+ * @param {string[]} [params.criteria] - Scoring criteria
+ * @param {object} [params.llmOptions] - LLM provider options
+ * @returns {Promise<object>} Comparison result with ranked variants
+ */
+export async function compare({
+  prompt,
+  variants = 3,
+  criteria = DEFAULT_CRITERIA,
+  llmOptions = {},
+}) {
+  const chat = createChatFn(llmOptions);
+  const numVariants = Math.min(variants, VARIANT_PROFILES.length);
+  const profiles = VARIANT_PROFILES.slice(0, numVariants);
+  const generatedVariants = [];
+
+  // Phase 1: Generate variants
+  for (const profile of profiles) {
+    const messages = [
+      { role: "system", content: profile.system },
+      {
+        role: "user",
+        content: `Provide a solution for the following task. Include code if applicable.\n\nTask: ${prompt}\n\nProvide your solution with:\n1. Approach summary (1-2 sentences)\n2. Implementation (code or detailed steps)\n3. Trade-offs (pros and cons of this approach)`,
+      },
+    ];
+
+    try {
+      const response = await chat(messages, { maxTokens: 2000 });
+      generatedVariants.push({
+        name: profile.name,
+        profile: profile.system,
+        solution: response,
+      });
+    } catch (err) {
+      generatedVariants.push({
+        name: profile.name,
+        profile: profile.system,
+        solution: `Error generating variant: ${err.message}`,
+      });
+    }
+  }
+
+  // Phase 2: Score each variant against criteria
+  const scoringPrompt = `You are an impartial judge evaluating ${numVariants} solution variants against these criteria: ${criteria.join(", ")}.
+
+For each variant, assign a score from 1-10 for each criterion. Then provide an overall ranking.
+
+${generatedVariants
+  .map((v, i) => `### Variant ${i + 1}: ${v.name}\n${v.solution}`)
+  .join("\n\n---\n\n")}
+
+Respond in this exact format for each variant:
+SCORES:
+${generatedVariants.map((v, i) => `Variant ${i + 1} (${v.name}): ${criteria.map((c) => `${c}=X`).join(", ")}`).join("\n")}
+
+RANKING: (best to worst, comma-separated variant names)
+WINNER: (name of the best variant)
+REASON: (1-2 sentence justification)`;
+
+  let scores = [];
+  let ranking = [];
+  let winner = "";
+  let reason = "";
+
+  try {
+    const judgement = await chat(
+      [
+        {
+          role: "system",
+          content:
+            "You are an impartial technical evaluator. Score solutions objectively based on the given criteria.",
+        },
+        { role: "user", content: scoringPrompt },
+      ],
+      { maxTokens: 1500 },
+    );
+
+    // Parse scores
+    scores = parseScores(judgement, generatedVariants, criteria);
+    ranking = parseRanking(judgement, generatedVariants);
+    winner = parseWinner(judgement) || generatedVariants[0]?.name || "unknown";
+    reason = parseReason(judgement) || "See detailed scores above.";
+  } catch (err) {
+    reason = `Scoring error: ${err.message}`;
+  }
+
+  return {
+    prompt,
+    criteria,
+    variants: generatedVariants.map((v, i) => ({
+      ...v,
+      scores: scores[i] || {},
+      totalScore: scores[i]
+        ? Object.values(scores[i]).reduce((a, b) => a + b, 0)
+        : 0,
+    })),
+    ranking,
+    winner,
+    reason,
+  };
+}
+
+function parseScores(text, variants, criteria) {
+  const scores = [];
+  for (let i = 0; i < variants.length; i++) {
+    const variantScores = {};
+    for (const c of criteria) {
+      const pattern = new RegExp(
+        `variant\\s*${i + 1}[^\\n]*${c}\\s*=\\s*(\\d+)`,
+        "i",
+      );
+      const match = text.match(pattern);
+      variantScores[c] = match ? parseInt(match[1], 10) : 5;
+    }
+    scores.push(variantScores);
+  }
+  return scores;
+}
+
+function parseRanking(text, variants) {
+  const match = text.match(/RANKING:\s*(.+)/i);
+  if (match) {
+    return match[1]
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean);
+  }
+  return variants.map((v) => v.name);
+}
+
+function parseWinner(text) {
+  const match = text.match(/WINNER:\s*(.+)/i);
+  return match ? match[1].trim() : null;
+}
+
+function parseReason(text) {
+  const match = text.match(/REASON:\s*(.+)/i);
+  return match ? match[1].trim() : null;
+}
+
+export { DEFAULT_CRITERIA, VARIANT_PROFILES };