@techwavedev/agi-agent-kit 1.1.7 → 1.2.7

package/templates/skills/knowledge/notebooklm-rag/scripts/notebook_manager.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+"""
+Notebook Library Management for NotebookLM RAG Skill
+Manages a library of NotebookLM notebooks with metadata
+Adapted from PleasePrompto/notebooklm-skill (MIT License)
+"""
+
+import json
+import argparse
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+
+
+class NotebookLibrary:
+    """Manages a collection of NotebookLM notebooks with metadata"""
+
+    def __init__(self):
+        """Initialize the notebook library"""
+        skill_dir = Path(__file__).parent.parent
+        self.data_dir = skill_dir / "data"
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+
+        self.library_file = self.data_dir / "library.json"
+        self.notebooks: Dict[str, Dict[str, Any]] = {}
+        self.active_notebook_id: Optional[str] = None
+
+        self._load_library()
+
+    def _load_library(self):
+        """Load library from disk"""
+        if self.library_file.exists():
+            try:
+                with open(self.library_file, 'r') as f:
+                    data = json.load(f)
+                    self.notebooks = data.get('notebooks', {})
+                    self.active_notebook_id = data.get('active_notebook_id')
+                    print(f"📚 Loaded library with {len(self.notebooks)} notebooks")
+            except Exception as e:
+                print(f"⚠️ Error loading library: {e}")
+                self.notebooks = {}
+                self.active_notebook_id = None
+        else:
+            self._save_library()
+
+    def _save_library(self):
+        """Save library to disk"""
+        try:
+            data = {
+                'notebooks': self.notebooks,
+                'active_notebook_id': self.active_notebook_id,
+                'updated_at': datetime.now().isoformat()
+            }
+            with open(self.library_file, 'w') as f:
+                json.dump(data, f, indent=2)
+        except Exception as e:
+            print(f"❌ Error saving library: {e}")
+
+    def add_notebook(
+        self,
+        url: str,
+        name: str,
+        description: str,
+        topics: List[str],
+        content_types: Optional[List[str]] = None,
+        use_cases: Optional[List[str]] = None,
+        tags: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """Add a new notebook to the library"""
+        notebook_id = name.lower().replace(' ', '-').replace('_', '-')
+
+        if notebook_id in self.notebooks:
+            raise ValueError(f"Notebook with ID '{notebook_id}' already exists")
+
+        notebook = {
+            'id': notebook_id,
+            'url': url,
+            'name': name,
+            'description': description,
+            'topics': topics,
+            'content_types': content_types or [],
+            'use_cases': use_cases or [],
+            'tags': tags or [],
+            'created_at': datetime.now().isoformat(),
+            'updated_at': datetime.now().isoformat(),
+            'use_count': 0,
+            'last_used': None
+        }
+
+        self.notebooks[notebook_id] = notebook
+
+        if len(self.notebooks) == 1:
+            self.active_notebook_id = notebook_id
+
+        self._save_library()
+
+        print(f"✅ Added notebook: {name} ({notebook_id})")
+        return notebook
+
+    def remove_notebook(self, notebook_id: str) -> bool:
+        """Remove a notebook from the library"""
+        if notebook_id in self.notebooks:
+            del self.notebooks[notebook_id]
+
+            if self.active_notebook_id == notebook_id:
+                self.active_notebook_id = None
+                if self.notebooks:
+                    self.active_notebook_id = list(self.notebooks.keys())[0]
+
+            self._save_library()
+            print(f"✅ Removed notebook: {notebook_id}")
+            return True
+
+        print(f"⚠️ Notebook not found: {notebook_id}")
+        return False
+
+    def update_notebook(
+        self,
+        notebook_id: str,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        topics: Optional[List[str]] = None,
+        content_types: Optional[List[str]] = None,
+        use_cases: Optional[List[str]] = None,
+        tags: Optional[List[str]] = None,
+        url: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Update notebook metadata"""
+        if notebook_id not in self.notebooks:
+            raise ValueError(f"Notebook not found: {notebook_id}")
+
+        notebook = self.notebooks[notebook_id]
+
+        if name is not None:
+            notebook['name'] = name
+        if description is not None:
+            notebook['description'] = description
+        if topics is not None:
+            notebook['topics'] = topics
+        if content_types is not None:
+            notebook['content_types'] = content_types
+        if use_cases is not None:
+            notebook['use_cases'] = use_cases
+        if tags is not None:
+            notebook['tags'] = tags
+        if url is not None:
+            notebook['url'] = url
+
+        notebook['updated_at'] = datetime.now().isoformat()
+
+        self._save_library()
+        print(f"✅ Updated notebook: {notebook['name']}")
+        return notebook
+
+    def get_notebook(self, notebook_id: str) -> Optional[Dict[str, Any]]:
+        """Get a specific notebook by ID"""
+        return self.notebooks.get(notebook_id)
+
+    def list_notebooks(self) -> List[Dict[str, Any]]:
+        """List all notebooks in the library"""
+        return list(self.notebooks.values())
+
+    def search_notebooks(self, query: str) -> List[Dict[str, Any]]:
+        """Search notebooks by query"""
+        query_lower = query.lower()
+        results = []
+
+        for notebook in self.notebooks.values():
+            searchable = [
+                notebook['name'].lower(),
+                notebook['description'].lower(),
+                ' '.join(notebook['topics']).lower(),
+                ' '.join(notebook['tags']).lower(),
+                ' '.join(notebook.get('use_cases', [])).lower()
+            ]
+
+            if any(query_lower in field for field in searchable):
+                results.append(notebook)
+
+        return results
+
+    def select_notebook(self, notebook_id: str) -> Dict[str, Any]:
+        """Set a notebook as active"""
+        if notebook_id not in self.notebooks:
+            raise ValueError(f"Notebook not found: {notebook_id}")
+
+        self.active_notebook_id = notebook_id
+        self._save_library()
+
+        notebook = self.notebooks[notebook_id]
+        print(f"✅ Activated notebook: {notebook['name']}")
+        return notebook
+
+    def get_active_notebook(self) -> Optional[Dict[str, Any]]:
+        """Get the currently active notebook"""
+        if self.active_notebook_id:
+            return self.notebooks.get(self.active_notebook_id)
+        return None
+
+    def increment_use_count(self, notebook_id: str) -> Dict[str, Any]:
+        """Increment usage counter for a notebook"""
+        if notebook_id not in self.notebooks:
+            raise ValueError(f"Notebook not found: {notebook_id}")
+
+        notebook = self.notebooks[notebook_id]
+        notebook['use_count'] += 1
+        notebook['last_used'] = datetime.now().isoformat()
+
+        self._save_library()
+        return notebook
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get library statistics"""
+        total_notebooks = len(self.notebooks)
+        total_topics = set()
+        total_use_count = 0
+
+        for notebook in self.notebooks.values():
+            total_topics.update(notebook['topics'])
+            total_use_count += notebook['use_count']
+
+        most_used = None
+        if self.notebooks:
+            most_used = max(
+                self.notebooks.values(),
+                key=lambda n: n['use_count']
+            )
+
+        return {
+            'total_notebooks': total_notebooks,
+            'total_topics': len(total_topics),
+            'total_use_count': total_use_count,
+            'active_notebook': self.get_active_notebook(),
+            'most_used_notebook': most_used,
+            'library_path': str(self.library_file)
+        }
+
+
+def main():
+    """Command-line interface for notebook management"""
+    parser = argparse.ArgumentParser(description='Manage NotebookLM library')
+
+    subparsers = parser.add_subparsers(dest='command', help='Commands')
+
+    add_parser = subparsers.add_parser('add', help='Add a notebook')
+    add_parser.add_argument('--url', required=True, help='NotebookLM URL')
+    add_parser.add_argument('--name', required=True, help='Display name')
+    add_parser.add_argument('--description', required=True, help='Description')
+    add_parser.add_argument('--topics', required=True, help='Comma-separated topics')
+    add_parser.add_argument('--use-cases', help='Comma-separated use cases')
+    add_parser.add_argument('--tags', help='Comma-separated tags')
+
+    subparsers.add_parser('list', help='List all notebooks')
+
+    search_parser = subparsers.add_parser('search', help='Search notebooks')
+    search_parser.add_argument('--query', required=True, help='Search query')
+
+    activate_parser = subparsers.add_parser('activate', help='Set active notebook')
+    activate_parser.add_argument('--id', required=True, help='Notebook ID')
+
+    remove_parser = subparsers.add_parser('remove', help='Remove a notebook')
+    remove_parser.add_argument('--id', required=True, help='Notebook ID')
+
+    subparsers.add_parser('stats', help='Show library statistics')
+
+    args = parser.parse_args()
+
+    library = NotebookLibrary()
+
+    if args.command == 'add':
+        topics = [t.strip() for t in args.topics.split(',')]
+        use_cases = [u.strip() for u in args.use_cases.split(',')] if args.use_cases else None
+        tags = [t.strip() for t in args.tags.split(',')] if args.tags else None
+
+        notebook = library.add_notebook(
+            url=args.url,
+            name=args.name,
+            description=args.description,
+            topics=topics,
+            use_cases=use_cases,
+            tags=tags
+        )
+        print(json.dumps(notebook, indent=2))
+
+    elif args.command == 'list':
+        notebooks = library.list_notebooks()
+        if notebooks:
+            print("\n📚 Notebook Library:")
+            for notebook in notebooks:
+                active = " [ACTIVE]" if notebook['id'] == library.active_notebook_id else ""
+                print(f"\n  📓 {notebook['name']}{active}")
+                print(f"     ID: {notebook['id']}")
+                print(f"     Topics: {', '.join(notebook['topics'])}")
+                print(f"     Uses: {notebook['use_count']}")
+        else:
+            print("📚 Library is empty. Add notebooks with: notebook_manager.py add")
+
+    elif args.command == 'search':
+        results = library.search_notebooks(args.query)
+        if results:
+            print(f"\n🔍 Found {len(results)} notebooks:")
+            for notebook in results:
+                print(f"\n  📓 {notebook['name']} ({notebook['id']})")
+                print(f"     {notebook['description']}")
+        else:
+            print(f"🔍 No notebooks found for: {args.query}")
+
+    elif args.command == 'activate':
+        notebook = library.select_notebook(args.id)
+        print(f"Now using: {notebook['name']}")
+
+    elif args.command == 'remove':
+        if library.remove_notebook(args.id):
+            print("Notebook removed from library")
+
+    elif args.command == 'stats':
+        stats = library.get_stats()
+        print("\n📊 Library Statistics:")
+        print(f"  Total notebooks: {stats['total_notebooks']}")
+        print(f"  Total topics: {stats['total_topics']}")
+        print(f"  Total uses: {stats['total_use_count']}")
+        if stats['active_notebook']:
+            print(f"  Active: {stats['active_notebook']['name']}")
+        if stats['most_used_notebook']:
+            print(f"  Most used: {stats['most_used_notebook']['name']} ({stats['most_used_notebook']['use_count']} uses)")
+        print(f"  Library path: {stats['library_path']}")
+
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

package/templates/skills/knowledge/notebooklm-rag/scripts/run.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+Universal runner for NotebookLM RAG skill scripts
+Ensures all scripts run with the correct virtual environment
+Adapted from PleasePrompto/notebooklm-skill (MIT License)
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+
+def get_venv_python():
+    """Get the virtual environment Python executable"""
+    skill_dir = Path(__file__).parent.parent
+    venv_dir = skill_dir / ".venv"
+
+    if os.name == 'nt':  # Windows
+        venv_python = venv_dir / "Scripts" / "python.exe"
+    else:  # Unix/Linux/Mac
+        venv_python = venv_dir / "bin" / "python"
+
+    return venv_python
+
+
+def ensure_venv():
+    """Ensure virtual environment exists"""
+    skill_dir = Path(__file__).parent.parent
+    venv_dir = skill_dir / ".venv"
+    setup_script = skill_dir / "scripts" / "setup_environment.py"
+
+    if not venv_dir.exists():
+        print("🔧 First-time setup: Creating virtual environment...")
+        print("   This may take a minute...")
+
+        result = subprocess.run([sys.executable, str(setup_script)])
+        if result.returncode != 0:
+            print("❌ Failed to set up environment")
+            sys.exit(1)
+
+        print("✅ Environment ready!")
+
+    return get_venv_python()
+
+
+def main():
+    """Main runner"""
+    if len(sys.argv) < 2:
+        print("Usage: python run.py <script_name> [args...]")
+        print("\nAvailable scripts:")
+        print("  ask_question.py     - Query NotebookLM")
+        print("  notebook_manager.py - Manage notebook library")
+        print("  auth_manager.py     - Handle authentication")
+        print("  cleanup_manager.py  - Clean up skill data")
+        sys.exit(1)
+
+    script_name = sys.argv[1]
+    script_args = sys.argv[2:]
+
+    if script_name.startswith('scripts/'):
+        script_name = script_name[8:]
+
+    if not script_name.endswith('.py'):
+        script_name += '.py'
+
+    skill_dir = Path(__file__).parent.parent
+    script_path = skill_dir / "scripts" / script_name
+
+    if not script_path.exists():
+        print(f"❌ Script not found: {script_name}")
+        print(f"   Skill directory: {skill_dir}")
+        print(f"   Looked for: {script_path}")
+        sys.exit(1)
+
+    venv_python = ensure_venv()
+
+    cmd = [str(venv_python), str(script_path)] + script_args
+
+    try:
+        result = subprocess.run(cmd)
+        sys.exit(result.returncode)
+    except KeyboardInterrupt:
+        print("\n⚠️ Interrupted by user")
+        sys.exit(130)
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/templates/skills/knowledge/notebooklm-rag/scripts/setup_environment.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""
+Environment Setup for NotebookLM RAG Skill
+Creates virtual environment and installs dependencies
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+
+def main():
+    skill_dir = Path(__file__).parent.parent
+    venv_dir = skill_dir / ".venv"
+    requirements_file = skill_dir / "requirements.txt"
+
+    print("🔧 Setting up NotebookLM RAG environment...")
+
+    # Create venv
+    print("  📦 Creating virtual environment...")
+    subprocess.run([sys.executable, "-m", "venv", str(venv_dir)], check=True)
+
+    # Get venv python
+    if os.name == 'nt':
+        venv_python = venv_dir / "Scripts" / "python.exe"
+        venv_pip = venv_dir / "Scripts" / "pip.exe"
+    else:
+        venv_python = venv_dir / "bin" / "python"
+        venv_pip = venv_dir / "bin" / "pip"
+
+    # Upgrade pip
+    print("  📦 Upgrading pip...")
+    subprocess.run([str(venv_python), "-m", "pip", "install", "--upgrade", "pip"],
+                    capture_output=True)
+
+    # Install requirements
+    if requirements_file.exists():
+        print("  📦 Installing dependencies...")
+        result = subprocess.run(
+            [str(venv_pip), "install", "-r", str(requirements_file)],
+            capture_output=True, text=True
+        )
+        if result.returncode != 0:
+            print(f"  ❌ Failed to install dependencies: {result.stderr}")
+            sys.exit(1)
+    else:
+        print("  📦 Installing patchright and python-dotenv...")
+        subprocess.run(
+            [str(venv_pip), "install", "patchright==1.55.2", "python-dotenv==1.0.0"],
+            capture_output=True
+        )
+
+    # Install Chrome for Patchright
+    print("  🌐 Installing Chrome browser...")
+    result = subprocess.run(
+        [str(venv_python), "-m", "patchright", "install", "chrome"],
+        capture_output=True, text=True
+    )
+    if result.returncode != 0:
+        print(f"  ⚠️ Chrome install issue (may already be available): {result.stderr[:200]}")
+
+    print("  ✅ Environment setup complete!")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())