@jairodri/huckleberry-cli 1.0.2 → 1.1.0

package/skills/self-improving-agent/scripts/auto_detect.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""
+Auto-Detection Integration for Agents
+Automatically detects expertise gaps and triggers research pipeline.
+Can be imported and used by any agent.
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+
+PROJECT_ROOT = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from self_improving_agent import ExpertiseGapDetector, ResearchPipeline
+
+class AutoExpertiseDetector:
+    """
+    Automatic expertise gap detection for agents.
+    Integrates with agent's natural language processing to detect
+    when the agent is about to give a generic/low-confidence answer.
+    """
+    
+    def __init__(self, agent_name: str = "clawd", auto_research: bool = True):
+        self.agent_name = agent_name
+        self.auto_research = auto_research
+        self.detector = ExpertiseGapDetector(agent_name)
+        self.pipeline = ResearchPipeline(agent_name)
+        self.detection_log = PROJECT_ROOT / "memory" / "auto-detection-log.json"
+        self._load_log()
+    
+    def _load_log(self):
+        """Load detection log."""
+        if self.detection_log.exists():
+            with open(self.detection_log) as f:
+                self.log = json.load(f)
+        else:
+            self.log = {"detections": [], "research_triggered": 0, "skipped": 0}
+    
+    def _save_log(self):
+        """Save detection log."""
+        self.detection_log.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.detection_log, 'w') as f:
+            json.dump(self.log, f, indent=2)
+    
+    def analyze_query(self, user_query: str) -> Dict[str, Any]:
+        """
+        Analyze a user query to detect potential expertise gaps.
+        Returns analysis with recommended action.
+        """
+        # Extract potential topics from query
+        topics = self._extract_topics(user_query)
+        
+        results = {
+            "query": user_query,
+            "topics_detected": topics,
+            "gaps_found": [],
+            "recommendations": []
+        }
+        
+        for topic in topics:
+            expertise = self.detector.check_expertise(topic)
+            
+            if expertise["needs_research"]:
+                gap_info = {
+                    "topic": topic,
+                    "confidence": expertise["confidence"],
+                    "reason": "No existing expertise in registry or Inkstone"
+                }
+                results["gaps_found"].append(gap_info)
+                
+                if self.auto_research:
+                    results["recommendations"].append({
+                        "action": "trigger_research",
+                        "topic": topic,
+                        "priority": "high" if expertise["confidence"] < 0.3 else "medium"
+                    })
+                else:
+                    results["recommendations"].append({
+                        "action": "flag_for_manual_research",
+                        "topic": topic,
+                        "priority": "medium"
+                    })
+        
+        # Log detection
+        self.log["detections"].append({
+            "timestamp": str(Path(__file__).stat().st_mtime),  # placeholder
+            "query": user_query,
+            "topics": topics,
+            "gaps": len(results["gaps_found"])
+        })
+        self._save_log()
+        
+        return results
+    
+    def _extract_topics(self, query: str) -> List[str]:
+        """Extract potential expertise topics from query."""
+        # This is a simplified version - in practice would use NLP
+        # For now, look for technical keywords and "how to" patterns
+        
+        topics = []
+        query_lower = query.lower()
+        
+        # Common patterns that indicate expertise need
+        patterns = [
+            ("how to", "implementation"),
+            ("best way to", "best practices"),
+            ("what is", "definition"),
+            ("explain", "explanation"),
+            ("compare", "comparison"),
+            ("vs", "comparison"),
+            ("alternative", "alternatives"),
+            ("tutorial", "tutorial"),
+            ("guide", "guide"),
+            ("setup", "setup"),
+            ("configure", "configuration"),
+            ("optimize", "optimization"),
+            ("debug", "debugging"),
+            ("troubleshoot", "troubleshooting"),
+            ("architecture", "architecture"),
+            ("design pattern", "design patterns"),
+            ("framework", "framework"),
+            ("library", "library"),
+            ("api", "API"),
+            ("integration", "integration"),
+        ]
+        
+        # Technical domains to watch for
+        domains = [
+            "machine learning", "deep learning", "neural network", "llm", "transformer",
+            "vector database", "embedding", "rag", "fine-tuning", "prompt engineering",
+            "kubernetes", "docker", "microservices", "distributed systems",
+            "rust", "golang", "typescript", "python", "javascript",
+            "react", "next.js", "vue", "svelte",
+            "postgresql", "mongodb", "redis", "elasticsearch",
+            "graphql", "rest api", "grpc", "websocket",
+            "ci/cd", "github actions", "terraform", "ansible",
+            "monitoring", "observability", "prometheus", "grafana",
+            "security", "authentication", "authorization", "oauth", "jwt",
+            "blockchain", "smart contract", "web3", "defi",
+            "quantum computing", "cryptography",
+            "computer vision", "nlp", "speech recognition",
+            "reinforcement learning", "gan", "diffusion model",
+            "agent", "multi-agent", "langchain", "autogen", "crewai",
+            "notebooklm", "gemini", "claude", "gpt", "openai",
+            "youtube", "video generation", "image generation",
+            "remotion", "ffmpeg", "video editing",
+            "google ads", "facebook ads", "seo", "sem",
+            "conversion rate optimization", "cro", "ab testing",
+            "email marketing", "copywriting", "content marketing",
+            "sales funnel", "lead generation", "crm",
+            "zoho", "hubspot", "salesforce", "pipedrive",
+        ]
+        
+        # Check for domain mentions
+        for domain in domains:
+            if domain in query_lower:
+                topics.append(domain)
+        
+        # Check for pattern + domain combinations
+        for pattern, pattern_type in patterns:
+            if pattern in query_lower:
+                # Find what comes after the pattern
+                idx = query_lower.index(pattern)
+                after = query_lower[idx + len(pattern):].strip()
+                # Extract first few words as potential topic
+                words = after.split()[:5]
+                if words:
+                    potential_topic = " ".join(words).rstrip("?.,!")
+                    if len(potential_topic) > 3:
+                        topics.append(potential_topic)
+        
+        # Deduplicate and filter
+        unique_topics = []
+        for topic in topics:
+            topic = topic.strip().lower()
+            if topic and len(topic) > 3 and topic not in unique_topics:
+                unique_topics.append(topic)
+        
+        return unique_topics[:10]  # Limit to top 10
+    
+    def auto_research_if_needed(self, user_query: str) -> Optional[Dict]:
+        """
+        Automatically trigger research if expertise gap detected.
+        Returns research result if triggered, None otherwise.
+        """
+        analysis = self.analyze_query(user_query)
+        
+        if not analysis["gaps_found"]:
+            return None
+        
+        # Trigger research for highest priority gap
+        high_priority = [r for r in analysis["recommendations"] 
+                        if r.get("priority") == "high" and r["action"] == "trigger_research"]
+        
+        if high_priority:
+            topic = high_priority[0]["topic"]
+            print(f"🔬 Auto-triggering research for: {topic}")
+            self.log["research_triggered"] += 1
+            self._save_log()
+            return self.pipeline.research_topic(topic, depth="standard")
+        
+        medium_priority = [r for r in analysis["recommendations"] 
+                          if r.get("priority") == "medium" and r["action"] == "trigger_research"]
+        
+        if medium_priority and self.auto_research:
+            topic = medium_priority[0]["topic"]
+            print(f"🔬 Auto-triggering research for: {topic}")
+            self.log["research_triggered"] += 1
+            self._save_log()
+            return self.pipeline.research_topic(topic, depth="quick")
+        
+        self.log["skipped"] += 1
+        self._save_log()
+        return None
+    
+    def get_expert_answer(self, topic: str, question: str) -> Optional[str]:
+        """
+        Get expert answer from agent's mastered knowledge.
+        Searches Inkstone for existing Q&A on topic.
+        """
+        # In real implementation, would search Inkstone
+        # For now, return None to indicate not found
+        return None
+    
+    def get_stats(self) -> Dict:
+        """Get detection statistics."""
+        return {
+            "total_detections": len(self.log.get("detections", [])),
+            "research_triggered": self.log.get("research_triggered", 0),
+            "skipped": self.log.get("skipped", 0),
+            "agent": self.agent_name
+        }
+
+
+# Convenience function for quick integration
+def check_and_research(agent_name: str, user_query: str, auto: bool = True) -> Dict:
+    """
+    Quick function to check expertise and optionally trigger research.
+    Use in agent pre-processing.
+    """
+    detector = AutoExpertiseDetector(agent_name, auto_research=auto)
+    return detector.analyze_query(user_query)
+
+
+if __name__ == "__main__":
+    # Test the auto-detector
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Test auto-detection")
+    parser.add_argument("query", help="User query to analyze")
+    parser.add_argument("--agent", default="clawd", help="Agent name")
+    parser.add_argument("--auto", action="store_true", help="Auto-trigger research")
+    
+    args = parser.parse_args()
+    
+    detector = AutoExpertiseDetector(args.agent, auto_research=args.auto)
+    result = detector.analyze_query(args.query)
+    
+    print(json.dumps(result, indent=2))
+    
+    if args.auto and result["gaps_found"]:
+        print("\n🔬 Triggering research...")
+        research_result = detector.auto_research_if_needed(args.query)
+        if research_result:
+            print("✅ Research completed")
+        else:
+            print("⏭️ Research skipped")

package/skills/self-improving-agent/scripts/init_expertise_registry.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+Initialize Agent Expertise Registry
+Creates the registry file with proper structure.
+"""
+
+import json
+from pathlib import Path
+from datetime import datetime
+
+PROJECT_ROOT = Path(__file__).parent.parent.parent.parent
+REGISTRY_PATH = PROJECT_ROOT / "memory" / "agent-expertise-registry.json"
+
+# Default registry structure
+DEFAULT_REGISTRY = {
+    "version": "1.0",
+    "created": datetime.now().isoformat(),
+    "last_updated": datetime.now().isoformat(),
+    "agents": {
+        "clawd": {},
+        "harper": {},
+        "plan": {},
+        "build": {},
+        "skye": {},
+        "rai": {},
+        "paco": {},
+        "thinker": {},
+        "hr": {},
+        "leads": {}
+    },
+    "global_index": {}  # topic_slug -> {best_agent, confidence, all_agents}
+}
+
+def init_registry():
+    """Initialize or verify registry exists."""
+    REGISTRY_PATH.parent.mkdir(parents=True, exist_ok=True)
+    
+    if REGISTRY_PATH.exists():
+        print(f"✅ Registry already exists at {REGISTRY_PATH}")
+        with open(REGISTRY_PATH) as f:
+            registry = json.load(f)
+        print(f"   Version: {registry.get('version', 'unknown')}")
+        print(f"   Agents: {len(registry.get('agents', {}))}")
+        total_topics = sum(len(topics) for topics in registry.get('agents', {}).values())
+        print(f"   Total mastered topics: {total_topics}")
+        return registry
+    
+    # Create new registry
+    with open(REGISTRY_PATH, 'w') as f:
+        json.dump(DEFAULT_REGISTRY, f, indent=2)
+    
+    print(f"✅ Created new expertise registry at {REGISTRY_PATH}")
+    return DEFAULT_REGISTRY
+
+def rebuild_global_index(registry: dict) -> dict:
+    """Rebuild global topic index from agent data."""
+    global_index = {}
+    
+    for agent_name, topics in registry.get("agents", {}).items():
+        for slug, topic_data in topics.items():
+            topic_name = topic_data.get("topic", slug)
+            confidence = topic_data.get("confidence", 0.0)
+            
+            if slug not in global_index:
+                global_index[slug] = {
+                    "topic": topic_name,
+                    "best_agent": agent_name,
+                    "best_confidence": confidence,
+                    "all_agents": {agent_name: confidence}
+                }
+            else:
+                global_index[slug]["all_agents"][agent_name] = confidence
+                if confidence > global_index[slug]["best_confidence"]:
+                    global_index[slug]["best_agent"] = agent_name
+                    global_index[slug]["best_confidence"] = confidence
+    
+    registry["global_index"] = global_index
+    registry["last_updated"] = datetime.now().isoformat()
+    
+    with open(REGISTRY_PATH, 'w') as f:
+        json.dump(registry, f, indent=2)
+    
+    print(f"✅ Rebuilt global index: {len(global_index)} topics indexed")
+    return registry
+
+if __name__ == "__main__":
+    registry = init_registry()
+    registry = rebuild_global_index(registry)
+    print("\n📊 Registry initialized and ready for use!")

package/skills/self-improving-agent/scripts/nlm_curation.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""
+NLM Source Curation
+Deep research finds web pages + documents, but pulls irrelevant stuff.
+This module curates: cited-only import + relevance scoring + deletion of
+below-threshold sources.
+
+CLI:
+  python3 nlm_curation.py curate --topic "..." --notebook <id> [--execute]
+  python3 nlm_curation.py research --topic "..." --notebook <id> [--mode fast|deep] [--execute]
+"""
+
+import json
+import re
+import subprocess
+import sys
+import argparse
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+from urllib.parse import urlparse
+
+# Domain reputation: positive = authoritative, negative = aggregator/spam-prone
+DOMAIN_SCORES = {
+    # Strongly authoritative
+    "arxiv.org": 1.0, "github.com": 0.9, "docs.python.org": 0.9,
+    "developer.mozilla.org": 0.9, "stackoverflow.com": 0.7,
+    "nature.com": 1.0, "sciencedirect.com": 0.9, "ieee.org": 0.9,
+    "acm.org": 0.9, "springer.com": 0.8, "mit.edu": 0.9, "stanford.edu": 0.9,
+    "google.com": 0.6, "openai.com": 0.8, "anthropic.com": 0.8,
+    "deepmind.google": 0.8, "huggingface.co": 0.8, "aws.amazon.com": 0.8,
+    "learn.microsoft.com": 0.8, "cloud.google.com": 0.8,
+    "rust-lang.org": 0.9, "golang.org": 0.9, "python.org": 0.9,
+    "postgrespro.com": 0.7, "postgresql.org": 0.9, "redis.io": 0.8,
+    "kubernetes.io": 0.9, "docker.com": 0.8,
+    # Neutral / content platforms
+    "medium.com": 0.2, "substack.com": 0.3, "dev.to": 0.3,
+    "freecodecamp.org": 0.4, "geeksforgeeks.org": 0.2,
+    "towardsdatascience.com": 0.3, "realpython.com": 0.6,
+    # Aggregators / low signal for deep expertise
+    "pinterest.com": -0.8, "quora.com": -0.4, "reddit.com": 0.1,
+    "linkedin.com": 0.0, "facebook.com": -0.6, "twitter.com": 0.0,
+    "x.com": 0.0, "youtube.com": 0.2, "tiktok.com": -0.6,
+    "wikipedia.org": 0.4,
+}
+
+# Title tokens that signal listicle/SEO-spam rather than expertise
+SPAM_TITLE_PATTERNS = [
+    r"\btop \d+\b", r"\bbest \d+\b", r"\b\d+ (tips|tricks|hacks|tools)\b",
+    r"\byou won'?t believe\b", r"\bultimate guide\b", r"\bcomplete guide\b",
+    r"\bcourse\b.*\b(only|free|discount)\b", r"\bcoupon\b", r"\bdeal\b",
+    r"\bdownload (now|free)\b", r"\blogin\b", r"\bsign ?up\b",
+]
+
+STOPWORDS = {
+    "the", "a", "an", "of", "for", "and", "or", "to", "in", "on", "with",
+    "how", "what", "why", "is", "are", "do", "does", "best", "way", "vs",
+    "using", "use", "get", "your", "my",
+}
+
+
+def tokenize(text: str) -> set:
+    words = re.findall(r"[a-z0-9+#.]+", text.lower())
+    return {w for w in words if len(w) > 2 and w not in STOPWORDS}
+
+
+class SourceCurator:
+    """Scores NLM sources for relevance and prunes the irrelevant ones."""
+
+    def __init__(self, topic: str, threshold: float = 0.35, min_sources: int = 5):
+        self.topic = topic
+        self.threshold = threshold
+        self.min_sources = min_sources  # never prune below this many sources
+        self.topic_tokens = tokenize(topic)
+        self.report: List[Dict] = []
+
+    def score_source(self, title: str, url: str) -> Dict:
+        reasons = []
+        score = 0.0
+
+        # 1. Domain reputation
+        domain = urlparse(url).netloc.lower().removeprefix("www.") if url else ""
+        domain_score = 0.0
+        for dom, s in DOMAIN_SCORES.items():
+            if domain == dom or domain.endswith("." + dom):
+                domain_score = s
+                break
+        score += domain_score
+        if domain_score > 0:
+            reasons.append(f"domain:{domain}(+{domain_score})")
+        elif domain_score < 0:
+            reasons.append(f"domain:{domain}({domain_score})")
+
+        # 2. Topic-token overlap with title
+        title_tokens = tokenize(title)
+        if self.topic_tokens:
+            overlap = len(title_tokens & self.topic_tokens) / len(self.topic_tokens)
+            score += overlap * 1.2
+            if overlap > 0:
+                reasons.append(f"topic-overlap:{overlap:.2f}")
+
+        # 3. Spam/listicle penalty
+        title_lower = title.lower()
+        for pat in SPAM_TITLE_PATTERNS:
+            if re.search(pat, title_lower):
+                score -= 0.5
+                reasons.append(f"spam-pattern:{pat}")
+                break
+
+        return {"score": round(score, 2), "reasons": reasons, "domain": domain}
+
+    def curate(self, notebook_id: str, execute: bool = False) -> Dict:
+        """Score all sources in notebook; optionally delete below threshold."""
+        sources = self._list_sources(notebook_id)
+        if not sources:
+            return {"error": "no sources found", "notebook_id": notebook_id}
+
+        keep, prune = [], []
+        for src in sources:
+            title = src.get("title", "") or ""
+            url = src.get("url", "") or ""
+            scored = self.score_source(title, url)
+            entry = {
+                "id": src.get("id"),
+                "title": title[:80],
+                "url": url,
+                **scored,
+            }
+            if scored["score"] >= self.threshold:
+                keep.append(entry)
+            else:
+                prune.append(entry)
+
+        # Protect floor: if pruning would drop below min_sources, keep the best
+        if len(keep) < self.min_sources and prune:
+            prune.sort(key=lambda e: e["score"], reverse=True)
+            rescue = self.min_sources - len(keep)
+            keep.extend(prune[:rescue])
+            prune = prune[rescue:]
+
+        deleted = []
+        if execute and prune:
+            for entry in prune:
+                ok = self._delete_source(notebook_id, entry["id"])
+                if ok:
+                    deleted.append(entry["id"])
+
+        result = {
+            "notebook_id": notebook_id,
+            "topic": self.topic,
+            "threshold": self.threshold,
+            "total_sources": len(sources),
+            "kept": len(keep),
+            "pruned": len(prune),
+            "deleted": deleted if execute else [],
+            "executed": execute,
+            "keep": keep,
+            "prune": prune,
+            "timestamp": datetime.now().isoformat(),
+        }
+        self._save_report(result)
+        return result
+
+    def deep_research(self, notebook_id: str, mode: str = "fast",
+                      timeout: int = 1800) -> Dict:
+        """
+        Run NLM deep research with cited-only import (first curation filter),
+        then post-import relevance curation.
+        """
+        steps = {}
+
+        # Step 1: start research (non-blocking)
+        r = subprocess.run(
+            ["notebooklm", "source", "add-research", self.topic,
+             "--mode", mode, "--no-wait", "--json", "-n", notebook_id],
+            capture_output=True, text=True, timeout=120,
+        )
+        if r.returncode != 0:
+            return {"error": f"add-research failed: {r.stderr[:500]}", **steps}
+        steps["research_started"] = True
+
+        # Step 2: wait + import cited-only (import-time curation)
+        r = subprocess.run(
+            ["notebooklm", "research", "wait", "-n", notebook_id,
+             "--import-all", "--cited-only", "--timeout", str(timeout), "--json"],
+            capture_output=True, text=True, timeout=timeout + 120,
+        )
+        steps["research_wait_rc"] = r.returncode
+        try:
+            steps["research_output"] = json.loads(r.stdout) if r.stdout.strip() else {}
+        except json.JSONDecodeError:
+            steps["research_output"] = {"raw": r.stdout[:500]}
+
+        return steps
+
+    def _list_sources(self, notebook_id: str) -> List[Dict]:
+        r = subprocess.run(
+            ["notebooklm", "source", "list", "-n", notebook_id, "--json"],
+            capture_output=True, text=True, timeout=60,
+        )
+        if r.returncode != 0:
+            return []
+        try:
+            return json.loads(r.stdout).get("sources", [])
+        except json.JSONDecodeError:
+            return []
+
+    def _delete_source(self, notebook_id: str, source_id: str) -> bool:
+        r = subprocess.run(
+            ["notebooklm", "source", "delete", source_id,
+             "-n", notebook_id, "--yes", "--json"],
+            capture_output=True, text=True, timeout=60,
+        )
+        return r.returncode == 0
+
+    def _save_report(self, result: Dict):
+        report_dir = Path.home() / "clawd" / "memory" / "curation-reports"
+        report_dir.mkdir(parents=True, exist_ok=True)
+        slug = re.sub(r"[^a-z0-9]+", "-", self.topic.lower())[:40].strip("-")
+        path = report_dir / f"{datetime.now().date()}-{slug}.json"
+        with open(path, "w") as f:
+            json.dump(result, f, indent=2)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="NLM source curation")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_cur = sub.add_parser("curate", help="Score + prune existing sources")
+    p_cur.add_argument("--topic", required=True)
+    p_cur.add_argument("--notebook", required=True)
+    p_cur.add_argument("--execute", action="store_true",
+                       help="Actually delete below-threshold sources (default: report only)")
+    p_cur.add_argument("--threshold", type=float, default=0.35)
+
+    p_res = sub.add_parser("research", help="Deep research + cited-only import + curate")
+    p_res.add_argument("--topic", required=True)
+    p_res.add_argument("--notebook", required=True)
+    p_res.add_argument("--mode", choices=["fast", "deep"], default="deep")
+    p_res.add_argument("--execute", action="store_true")
+    p_res.add_argument("--timeout", type=int, default=1800)
+
+    args = parser.parse_args()
+    curator = SourceCurator(args.topic, threshold=args.threshold)
+
+    if args.command == "curate":
+        result = curator.curate(args.notebook, execute=args.execute)
+    else:
+        result = curator.deep_research(args.notebook, mode=args.mode,
+                                       timeout=args.timeout)
+        curation = curator.curate(args.notebook, execute=args.execute)
+        result["curation"] = {k: curation[k] for k in
+                              ("total_sources", "kept", "pruned", "executed")}
+
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()