@apmantza/greedysearch-pi 1.4.2 → 1.5.1

package/skills/greedy-search/SKILL.md

@@ -5,141 +5,70 @@ description: Multi-engine AI web search — greedy_search, deep_research, and co
 
 # GreedySearch Tools
 
-## Tool Overview
-
-| Tool | Speed | Use for |
+| Tool | Speed | Use For |
 |------|-------|---------|
-| `greedy_search` | 15-90s | Quick lookups, comparisons, debugging errors |
-| `deep_research` | 60-120s | Architecture decisions, thorough research, source-backed answers |
-| `coding_task` | 60-180s | Second opinions on code, reviews, debugging tricky issues |
-
-## When to Use Which
+| `greedy_search` | 15-90s | Quick lookups, current info |
+| `deep_research` | 60-120s | Architecture decisions, source-backed research |
+| `coding_task` | 60-180s | Debug, review, plan modes for hard problems |
 
-- **`greedy_search`** — Default. Fast enough for most things. Use when you need current info.
-- **`deep_research`** — When the answer *matters*. Gives you a structured document with confidence scores, deduplicated sources ranked by consensus, Gemini synthesis, AND actual content from top sources.
-- **`coding_task`** — When you need a "second opinion" on hard problems. Best for `debug` and `plan` modes on tricky issues.
-
----
+## greedy_search
 
-# greedy_search
+Multi-engine AI search (Perplexity, Bing, Google).
 
-Multi-engine AI web search with streaming progress.
-
-```greedy_search({ query: "what changed in React 19", engine: "all" })```
+```greedy_search({ query: "React 19 changes", engine: "all" })```
 
 | Parameter | Type | Default | Description |
 |-----------|------|---------|-------------|
-| `query` | string | required | The search question |
+| `query` | string | required | Search question |
 | `engine` | string | `"all"` | `all`, `perplexity`, `bing`, `google`, `gemini` |
-| `synthesize` | boolean | `false` | Synthesize via Gemini |
-| `fullAnswer` | boolean | `false` | Complete answer vs ~300 char summary |
-
-**When to use:** Quick lookups, error messages, comparing tools, "what's new in X".
+| `synthesize` | boolean | `false` | Gemini synthesis (+30s, higher quality) |
+| `fullAnswer` | boolean | `false` | Complete vs ~300 char summary |
 
----
+**When to use:** Current info, version changes, comparisons, debugging errors.  
+**vs web_search:** Slower but higher quality — 3 engines cross-verify.
 
-# deep_research
+**Engine Selection:**
+- `all` (default): 30-90s, highest confidence
+- `perplexity`: 15-30s, technical Q&A
+- `bing`: 15-30s, recent news
+- `google`: 15-30s, broad coverage
+- `gemini`: 15-30s, different training data
 
-Comprehensive research with source fetching and synthesis. Returns a structured document.
+## deep_research
 
-```deep_research({ query: "RAG vs fine-tuning for production" })```
+Comprehensive research with source fetching and synthesis.
 
-Returns:
-- Full answers from all 3 engines (Perplexity, Bing, Google)
-- Gemini synthesis combining all perspectives
-- Deduplicated sources ranked by consensus (3/3 > 2/3 > 1/3)
-- Fetched content from top 5 sources (no CDP — uses native fetch)
-- Confidence metadata (which engines responded, consensus score)
+```deep_research({ query: "RAG vs fine-tuning tradeoffs" })```
 
-**When to use:** Architecture decisions, "which library should I use", research for a writeup, anything where you need source-backed confidence.
+Returns: Full answers + Gemini synthesis + deduplicated sources (ranked by consensus [3/3, 2/3, 1/3]) + fetched content from top sources.
 
----
+**When to use:** Research that matters — library comparisons, architecture decisions, source-backed confidence.
 
-# coding_task
+## coding_task
 
-Browser-based coding assistant using Gemini and/or Copilot.
+Browser-based coding assistant via Gemini/Copilot.
 
-```coding_task({ task: "debug this race condition", mode: "debug", engine: "all" })```
+```coding_task({ task: "debug race condition", mode: "debug", engine: "gemini" })```
 
 | Parameter | Type | Default | Description |
 |-----------|------|---------|-------------|
-| `task` | string | required | The coding task/question |
-| `engine` | string | `"gemini"` | `gemini`, `copilot`, or `all` |
-| `mode` | string | `"code"` | See modes below |
+| `task` | string | required | Coding task/question |
+| `engine` | string | `"gemini"` | `gemini`, `copilot`, `all` |
+| `mode` | string | `"code"` | `debug`, `plan`, `review`, `test`, `code` |
 | `context` | string | — | Code snippet to include |
 
 **Modes:**
+- `debug`: Stuck on tricky bug — fresh eyes catch different failure modes
+- `plan`: Big refactor coming — Gemini plays devil's advocate
+- `review`: High-stakes code review before merge
+- `test`: Edge cases the author missed
+- `code`: Simple generation (but you're probably faster)
 
-| Mode | Use when |
-|------|----------|
-| `debug` | Stuck on a tricky bug. Fresh eyes catch different failure modes. |
-| `plan` | About to refactor something big. Gemini plays devil's advocate. |
-| `review` | Code review before merge. High-stakes code benefits from second opinion. |
-| `test` | Need edge cases the author missed. |
-| `code` | Just need the code written (but you can probably do this yourself faster). |
-
-**When to use:** Debugging tricky issues, planning major refactors, security-critical reviews. **Skip for** simple code generation — you're faster.
-
-## Greedy Search vs Built-in Web Search
-
-| | `web_search` | `greedy_search` |
-|---|---|---|
-| Speed | Instant (~2s) | 15-60s (one engine) / 30-90s (all engines) |
-| Quality | Good for simple lookups | Higher — 3 AI engines cross-verify |
-| Synthesis | Single engine answer | Optional Gemini synthesis (cleanest answer) |
-| Use for | Quick facts, simple questions | Research, decisions, complex topics |
-
-**Rule of thumb:** Use `web_search` for quick facts. Use `greedy_search` when the answer matters — architecture decisions, comparing libraries, understanding new releases, debugging tricky errors.
-
-## When to Use
-
-- **Version-specific changes** — "What changed in React 19?" / "Breaking changes in FastAPI 0.100"
-- **Choosing between tools** — "Prisma vs Drizzle in 2026" / "Best auth library for Next.js 15"
-- **Debugging** — User pastes an error message or stack trace
-- **Research tasks** — When you need to synthesize information from multiple sources
-- **Best practices** — "How to structure a monorepo" / "Auth patterns for SaaS"
-- **Anything where training data might be stale** — 2025+, 2026+, "latest", "current", "still maintained"
-
-## Engine Selection
-
-```greedy_search({ query: "what changed in React 19", engine: "all" })```
-
-| Engine | Latency | Best for |
-|---|---|---|
-| `all` (default) | 30-90s | Highest confidence — all 3 engines in parallel |
-| `perplexity` | 15-30s | Technical Q&A, code explanations, documentation |
-| `bing` | 15-30s | Recent news, Microsoft ecosystem |
-| `google` | 15-30s | Broad coverage, multiple perspectives |
-| `gemini` | 15-30s | Google's perspective, different training data |
-
-Use a single engine when speed matters and the question isn't contentious.
-
-## Synthesis Mode
-
-For complex research questions, use `synthesize: true` with `engine: "all"`:
-
-```greedy_search({ query: "best auth patterns for SaaS in 2026", engine: "all", synthesize: true })```
-
-This deduplicates sources across engines and feeds them to Gemini for one clean, synthesized answer. Adds ~30s but produces the highest quality output — ideal for research tasks where you'd otherwise need to parse 3 separate answers.
-
-Use synthesis when:
-- You need one definitive answer, not multiple perspectives
-- You're researching a topic to write about or make a decision
-- The question has a lot of noise and you want the signal
-
-Skip synthesis when:
-- You want to see where engines disagree (useful for controversial topics)
-- Speed matters
-
-## Full vs Short Answers
-
-Default mode returns ~300 char summaries to save tokens. Use `fullAnswer: true` when you need the complete response:
-
-```greedy_search({ query: "explain the React compiler", engine: "perplexity", fullAnswer: true })```
+**When to use:** Second opinions on hard problems. Skip for simple code.
 
 ## Interpreting Results
 
 - **All 3 agree** → High confidence, present as fact
-- **2 agree, 1 differs** → Likely correct but note the dissent
-- **All differ** → Present the different perspectives to the user
-- **Sources with `[3/3]` or `[2/3]`** → Cited by multiple engines, higher confidence
+- **2 agree, 1 differs** → Likely correct, note the dissent
+- **All differ** → Present different perspectives
+- **Sources [3/3] or [2/3]** → Cited by multiple engines, higher confidence

package/newfeaturesideas.md

@@ -1,105 +0,0 @@
-# New Feature Ideas
-
-Ideas for future features — thinking from the perspective of an AI assistant using these tools.
-
----
-
-## 1. Source Verification
-
-**Problem:** I get sources but can't verify if they're live, updated, or actually support the claimed content.
-
-```
-verify_sources({ urls: ["https://...", "https://..."] })
-→ [{ url, status: 200, title, snippet, lastModified, claim: "supports X" }]
-```
-
-**Use cases:**
-- Before citing a source, verify it's not 404
-- Check if a page actually contains the claimed information
-- Get last-modified dates to assess freshness
-
----
-
-## 2. Incremental / Continuation Research
-
-**Problem:** After deep_research on "RAG vs fine-tuning", going deeper on just RAG means re-running everything with a new query and losing original context.
-
-```
-deep_research({ query: "RAG vs fine-tuning", ... })  // initial
-continue_research({ previousId: "...", query: "production RAG architectures" })  // goes deeper on RAG
-```
-
-**Use cases:**
-- Drill into a specific aspect after initial broad research
-- Build on previous results without re-fetching everything
-- Progressive disclosure of complex topics
-
----
-
-## 3. Multi-Query Synthesis
-
-**Problem:** One query isn't enough for complex research. I chain multiple greedy_search calls manually.
-
-```
-multi_research({
-  queries: ["auth best practices", "NextAuth vs Clerk vs Lucia", "Next.js auth security"],
-  synthesize: true
-})
-```
-
-**Use cases:**
-- "Best auth for Next.js" needs multiple angles
-- Research with different facets (comparison, security, performance)
-- Casting a wider net when single query returns narrow results
-
----
-
-## 4. Structured Extraction
-
-**Problem:** When researching "which libraries are maintained", I want tables (name, stars, last commit, license), not prose.
-
-```
-extract_structured({
-  query: "Python HTTP client libraries 2026",
-  schema: { name: "string", stars: "number", lastUpdated: "date", async: "boolean" }
-})
-```
-
-**Use cases:**
-- Library comparisons as structured data
-- Dependency audits
-- Feature matrices for tools/frameworks
-
----
-
-## 5. Confidence Scoring on Specific Claims
-
-**Problem:** I say "high confidence" but it's hand-wavy. What if I could ask: "how confident are we that library X is actively maintained?"
-
-```
-verify_claim({
-  claim: "Prisma is actively maintained",
-  evidence: ["last commit: 2 weeks ago", "open issues: 45", "npm downloads: 2M/week"]
-})
-→ { confidence: 0.95, reasoning: "..." }
-```
-
----
-
-## 6. Research Cache / History
-
-**Problem:** I do expensive deep_research, then the user asks a follow-up. I have to re-run everything.
-
-```
-get_research(id: "...")  // retrieve previous results
-list_research({ query: "RAG" })  // find related previous research
-```
-
----
-
-## Priority
-
-1. **Source verification** — high value, relatively simple, fixes trust gap
-2. **Multi-query synthesis** — high value, complex but powerful
-3. **Incremental research** — medium value, nice UX improvement
-4. **Structured extraction** — medium value, specialized use cases

package/test.sh

@@ -1,298 +0,0 @@
-#!/usr/bin/env bash
-# test.sh — GreedySearch test suite
-#
-# Usage:
-#   ./test.sh           # run all tests
-#   ./test.sh parallel  # run only parallel test
-#   ./test.sh quick     # skip slow tests (parallel + stress)
-#
-# Tests verify:
-#   - No crashes/errors from extractors
-#   - All engines complete in "all" mode
-#   - Correct queries in results (not mixed up)
-#   - Parallel searches don't race on shared tabs
-
-set -e
-
-cd "$(dirname "$0")"
-RESULTS_DIR="results/test_$(date +%Y%m%d_%H%M%S)"
-mkdir -p "$RESULTS_DIR"
-
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m'
-
-PASS=0
-FAIL=0
-FAILURES=()  # Array to store failure details for report
-
-pass() { PASS=$((PASS+1)); echo -e "  ${GREEN}✓${NC} $1"; }
-fail() { 
-  FAIL=$((FAIL+1)); 
-  echo -e "  ${RED}✗${NC} $1"
-  FAILURES+=("$1")
-}
-
-check_no_errors() {
-  local file="$1"
-  local errors=$(node -e "
-    const d = JSON.parse(require('fs').readFileSync('$file','utf8'));
-    const errs = [];
-    if (d.perplexity?.error) errs.push('perplexity: ' + d.perplexity.error);
-    if (d.bing?.error) errs.push('bing: ' + d.bing.error);
-    if (d.google?.error) errs.push('google: ' + d.google.error);
-    console.log(errs.join('; ') || '');
-  " 2>/dev/null)
-  echo "$errors"
-}
-
-check_correct_queries() {
-  local file="$1"
-  local expected="$2"
-  local result=$(node -e "
-    const d = JSON.parse(require('fs').readFileSync('$file','utf8'));
-    const queries = [d.perplexity?.query, d.bing?.query, d.google?.query].filter(Boolean);
-    const allMatch = queries.every(q => q === '$expected');
-    console.log(allMatch ? 'ok' : 'queries: ' + queries.join(', '));
-  " 2>/dev/null)
-  echo "$result"
-}
-
-check_all_engines_completed() {
-  local file="$1"
-  local result=$(node -e "
-    const d = JSON.parse(require('fs').readFileSync('$file','utf8'));
-    const hasAnswer = (e) => d[e]?.answer && d[e].answer.length > 10;
-    const engines = ['perplexity', 'bing', 'google'];
-    const ok = engines.every(hasAnswer);
-    console.log(ok ? 'ok' : 'missing: ' + engines.filter(e => !hasAnswer(e)).join(', '));
-  " 2>/dev/null)
-  echo "$result"
-}
-
-# ─────────────────────────────────────────────────────────
-echo -e "\n${YELLOW}═══ GreedySearch Test Suite ═══${NC}\n"
-
-# ── Test 1: Single engine mode ──────────────────────────
-if [[ "$1" != "parallel" ]]; then
-  echo "Test 1: Single engine mode"
-  
-  for engine in perplexity bing google gemini; do
-    outfile="$RESULTS_DIR/single_${engine}.json"
-    node search.mjs "$engine" "explain $engine attention mechanism" --out "$outfile" 2>/dev/null
-    if [[ $? -eq 0 && -f "$outfile" ]]; then
-      errors=$(check_no_errors "$outfile")
-      if [[ -z "$errors" ]]; then
-        pass "$engine completed without errors"
-      else
-        fail "$engine errors: $errors"
-      fi
-    else
-      fail "$engine failed to run"
-    fi
-  done
-fi
-
-# ── Test 2: Sequential "all" mode ───────────────────────
-if [[ "$1" != "parallel" ]]; then
-  echo -e "\nTest 2: Sequential 'all' mode (3 runs)"
-  
-  for i in 1 2 3; do
-    outfile="$RESULTS_DIR/seq_${i}.json"
-    query="LLM inference optimization techniques $i"
-    node search.mjs all "$query" --out "$outfile" 2>/dev/null
-    
-    if [[ $? -eq 0 && -f "$outfile" ]]; then
-      errors=$(check_no_errors "$outfile")
-      if [[ -z "$errors" ]]; then
-        pass "Run $i: no errors"
-      else
-        fail "Run $i errors: $errors"
-      fi
-      
-      correct=$(check_correct_queries "$outfile" "$query")
-      if [[ "$correct" == "ok" ]]; then
-        pass "Run $i: correct queries"
-      else
-        fail "Run $i: $correct"
-      fi
-    else
-      fail "Run $i: failed to run"
-    fi
-  done
-fi
-
-# ── Test 3: Parallel "all" mode (race condition test) ───
-if [[ "$1" != "quick" && "$1" != "sequential" ]]; then
-  echo -e "\nTest 3: Parallel 'all' mode (5 concurrent searches)"
-  
-  PARALLEL_QUERIES=(
-    "what are transformer architectures in LLMs"
-    "explain RLHF fine-tuning process"
-    "difference between GPT and BERT models"
-    "how does chain of thought prompting work"
-    "what is retrieval augmented generation"
-  )
-  
-  PIDS=()
-  for i in "${!PARALLEL_QUERIES[@]}"; do
-    outfile="$RESULTS_DIR/parallel_${i}.json"
-    query="${PARALLEL_QUERIES[$i]}"
-    node search.mjs all "$query" --out "$outfile" 2>/dev/null &
-    PIDS+=($!)
-  done
-  
-  # Wait for all to complete
-  FAILED=0
-  for i in "${!PIDS[@]}"; do
-    if ! wait "${PIDS[$i]}"; then
-      fail "Parallel $i: process exited with error"
-      ((FAILED++))
-    fi
-  done
-  
-  if [[ $FAILED -eq 0 ]]; then
-    # Check results
-    for i in "${!PARALLEL_QUERIES[@]}"; do
-      outfile="$RESULTS_DIR/parallel_${i}.json"
-      query="${PARALLEL_QUERIES[$i]}"
-      
-      if [[ -f "$outfile" ]]; then
-        errors=$(check_no_errors "$outfile")
-        if [[ -z "$errors" ]]; then
-          pass "Parallel $i: no errors"
-        else
-          fail "Parallel $i: $errors"
-        fi
-        
-        correct=$(check_correct_queries "$outfile" "$query")
-        if [[ "$correct" == "ok" ]]; then
-          pass "Parallel $i: correct query"
-        else
-          fail "Parallel $i: $correct (TAB RACE DETECTED)"
-        fi
-        
-        all_done=$(check_all_engines_completed "$outfile")
-        if [[ "$all_done" == "ok" ]]; then
-          pass "Parallel $i: all engines answered"
-        else
-          fail "Parallel $i: $all_done"
-        fi
-      else
-        fail "Parallel $i: no result file"
-      fi
-    done
-  fi
-fi
-
-# ── Test 4: Synthesis mode ──────────────────────────────
-if [[ "$1" != "parallel" && "$1" != "quick" ]]; then
-  echo -e "\nTest 4: Synthesis mode"
-  
-  outfile="$RESULTS_DIR/synthesis.json"
-  node search.mjs all "what is Mixture of Experts in neural networks" --synthesize --out "$outfile" 2>/dev/null
-  
-  if [[ $? -eq 0 && -f "$outfile" ]]; then
-    has_synthesis=$(node -e "
-      const d = JSON.parse(require('fs').readFileSync('$outfile','utf8'));
-      console.log(d._synthesis?.answer ? 'ok' : 'missing');
-    " 2>/dev/null)
-    
-    if [[ "$has_synthesis" == "ok" ]]; then
-      pass "Synthesis completed"
-    else
-      fail "Synthesis missing"
-    fi
-    
-    errors=$(check_no_errors "$outfile")
-    if [[ -z "$errors" ]]; then
-      pass "Synthesis: no engine errors"
-    else
-      fail "Synthesis: $errors"
-    fi
-  else
-    fail "Synthesis failed to run"
-  fi
-fi
-
-# ─────────────────────────────────────────────────────────
-# Generate test report
-REPORT_FILE="$RESULTS_DIR/REPORT.md"
-
-cat > "$REPORT_FILE" << EOF
-# GreedySearch Test Report
-
-**Date:** $(date)
-**Test run:** $RESULTS_DIR
-
-## Summary
-
-| Result | Count |
-|--------|-------|
-| ✅ Passed | $PASS |
-| ❌ Failed | $FAIL |
-| Total | $((PASS + FAIL)) |
-
-## Failures
-
-EOF
-
-if [[ ${#FAILURES[@]} -eq 0 ]]; then
-  echo "No failures — all tests passed! 🎉" >> "$REPORT_FILE"
-else
-  for i in "${!FAILURES[@]}"; do
-    echo "$((i+1)). ${FAILURES[$i]}" >> "$REPORT_FILE"
-  done
-  
-  cat >> "$REPORT_FILE" << 'EOF'
-
-## Common Issues
-
-### Bing Copilot "copy button did not appear"
-This usually means:
-- **Verification challenge appeared** — Cloudflare Turnstile or Microsoft auth
-- **Page didn't load** — network issue or Copilot slow to respond
-- **UI changed** — selector no longer matches Copilot's DOM
-
-To debug: check the result JSON file for the full error message.
-
-### Google "verification required"
-Google sometimes shows CAPTCHAs that can't be auto-solved.
-Manual intervention required in the Chrome window.
-
-### Perplexity "Clipboard interceptor returned empty text"
-Perplexity's UI may have changed. Check if the copy button selector still works.
-
-EOF
-fi
-
-cat >> "$REPORT_FILE" << EOF
-
-## Result Files
-
-\`\`\`
-$(ls -la "$RESULTS_DIR"/*.json 2>/dev/null | awk '{print $NF}' | xargs -I{} basename {})
-\`\`\`
-
----
-*Generated by test.sh*
-EOF
-
-echo -e "\n${YELLOW}═══ Results ═══${NC}"
-echo -e "  ${GREEN}Passed: $PASS${NC}"
-[[ $FAIL -gt 0 ]] && echo -e "  ${RED}Failed: $FAIL${NC}" || echo "  Failed: 0"
-echo "  Results in: $RESULTS_DIR"
-echo "  Report: $REPORT_FILE"
-echo ""
-
-# Print failure details to console too
-if [[ ${#FAILURES[@]} -gt 0 ]]; then
-  echo -e "${RED}Failures:${NC}"
-  for f in "${FAILURES[@]}"; do
-    echo -e "  ${RED}•${NC} $f"
-  done
-  echo ""
-fi
-
-[[ $FAIL -eq 0 ]] && exit 0 || exit 1