@musashishao/agent-kit 1.9.0 → 1.9.1

package/.agent/mcp/servers/notebooklm/src/services/library.ts

@@ -0,0 +1,217 @@
+/**
+ * Library Service
+ * 
+ * Local storage for bookmark notebooks with tags and descriptions.
+ * Enables skill-aware matching and cross-tool sharing.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+const LIBRARY_DIR = process.env.NOTEBOOKLM_LIBRARY_DIR ||
+    path.join(os.homedir(), ".agent-kit", "notebooklm", "library");
+
+const LIBRARY_FILE = path.join(LIBRARY_DIR, "notebooks.json");
+
+export interface LibraryEntry {
+    id: string;
+    notebookId: string;
+    notebookUrl: string;
+    title: string;
+    description?: string;
+    tags: string[];
+    skills?: string[]; // Linked Agent Kit skills
+    addedAt: string;
+    lastUsed?: string;
+}
+
+export interface Library {
+    entries: LibraryEntry[];
+}
+
+function ensureLibraryDir(): void {
+    if (!fs.existsSync(LIBRARY_DIR)) {
+        fs.mkdirSync(LIBRARY_DIR, { recursive: true });
+    }
+}
+
+function loadLibrary(): Library {
+    ensureLibraryDir();
+
+    if (fs.existsSync(LIBRARY_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(LIBRARY_FILE, "utf-8"));
+        } catch {
+            return { entries: [] };
+        }
+    }
+
+    return { entries: [] };
+}
+
+function saveLibrary(library: Library): void {
+    ensureLibraryDir();
+    fs.writeFileSync(LIBRARY_FILE, JSON.stringify(library, null, 2));
+}
+
+function generateId(): string {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2);
+}
+
+/**
+ * Add a notebook to the library
+ */
+export function addToLibrary(
+    notebookId: string,
+    notebookUrl: string,
+    title: string,
+    options?: {
+        description?: string;
+        tags?: string[];
+        skills?: string[];
+    }
+): LibraryEntry {
+    const library = loadLibrary();
+
+    // Check if already exists
+    const existing = library.entries.find(e => e.notebookId === notebookId);
+    if (existing) {
+        // Update existing entry
+        existing.title = title;
+        existing.description = options?.description || existing.description;
+        existing.tags = options?.tags || existing.tags;
+        existing.skills = options?.skills || existing.skills;
+        saveLibrary(library);
+        return existing;
+    }
+
+    // Create new entry
+    const entry: LibraryEntry = {
+        id: generateId(),
+        notebookId,
+        notebookUrl,
+        title,
+        description: options?.description,
+        tags: options?.tags || [],
+        skills: options?.skills,
+        addedAt: new Date().toISOString(),
+    };
+
+    library.entries.push(entry);
+    saveLibrary(library);
+
+    return entry;
+}
+
+/**
+ * Search library by tags or skills
+ */
+export function searchLibrary(options?: {
+    tags?: string[];
+    skills?: string[];
+    query?: string;
+}): LibraryEntry[] {
+    const library = loadLibrary();
+
+    if (!options) {
+        return library.entries;
+    }
+
+    return library.entries.filter(entry => {
+        // Match by tags
+        if (options.tags && options.tags.length > 0) {
+            const hasMatchingTag = options.tags.some(tag =>
+                entry.tags.some(t => t.toLowerCase().includes(tag.toLowerCase()))
+            );
+            if (!hasMatchingTag) return false;
+        }
+
+        // Match by skills
+        if (options.skills && options.skills.length > 0) {
+            const hasMatchingSkill = options.skills.some(skill =>
+                entry.skills?.some(s => s.toLowerCase().includes(skill.toLowerCase()))
+            );
+            if (!hasMatchingSkill) return false;
+        }
+
+        // Match by query (title or description)
+        if (options.query) {
+            const q = options.query.toLowerCase();
+            const matchesTitle = entry.title.toLowerCase().includes(q);
+            const matchesDesc = entry.description?.toLowerCase().includes(q);
+            if (!matchesTitle && !matchesDesc) return false;
+        }
+
+        return true;
+    });
+}
+
+/**
+ * Remove from library
+ */
+export function removeFromLibrary(entryId: string): boolean {
+    const library = loadLibrary();
+    const index = library.entries.findIndex(e => e.id === entryId);
+
+    if (index >= 0) {
+        library.entries.splice(index, 1);
+        saveLibrary(library);
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Link a notebook to an Agent Kit skill
+ */
+export function linkToSkill(entryId: string, skillName: string): LibraryEntry | null {
+    const library = loadLibrary();
+    const entry = library.entries.find(e => e.id === entryId);
+
+    if (!entry) return null;
+
+    if (!entry.skills) entry.skills = [];
+    if (!entry.skills.includes(skillName)) {
+        entry.skills.push(skillName);
+    }
+
+    saveLibrary(library);
+    return entry;
+}
+
+/**
+ * Get library entry by notebook ID
+ */
+export function getByNotebookId(notebookId: string): LibraryEntry | undefined {
+    const library = loadLibrary();
+    return library.entries.find(e => e.notebookId === notebookId);
+}
+
+/**
+ * Update last used timestamp
+ */
+export function markAsUsed(notebookId: string): void {
+    const library = loadLibrary();
+    const entry = library.entries.find(e => e.notebookId === notebookId);
+
+    if (entry) {
+        entry.lastUsed = new Date().toISOString();
+        saveLibrary(library);
+    }
+}
+
+/**
+ * Get recently used notebooks
+ */
+export function getRecentlyUsed(limit: number = 5): LibraryEntry[] {
+    const library = loadLibrary();
+
+    return library.entries
+        .filter(e => e.lastUsed)
+        .sort((a, b) => new Date(b.lastUsed!).getTime() - new Date(a.lastUsed!).getTime())
+        .slice(0, limit);
+}
+
+export { LIBRARY_DIR };

package/.agent/mcp/servers/notebooklm/src/services/notebooklm.ts

@@ -0,0 +1,380 @@
+/**
+ * NotebookLM Service
+ * 
+ * Browser automation for interacting with NotebookLM.
+ * Uses Playwright to navigate and extract data.
+ */
+
+import { Page, BrowserContext } from "playwright";
+import { getAuthenticatedContext } from "../auth/index.js";
+
+const NOTEBOOKLM_URL = "https://notebooklm.google.com";
+
+export interface Notebook {
+    id: string;
+    title: string;
+    sourceCount?: number;
+    lastModified?: string;
+    url: string;
+}
+
+export interface Source {
+    id: string;
+    title: string;
+    type: "pdf" | "url" | "text" | "gdoc" | "youtube" | "unknown";
+}
+
+export interface QueryResult {
+    answer: string;
+    citations: Array<{
+        sourceTitle: string;
+        excerpt: string;
+    }>;
+}
+
+/**
+ * Get a page ready for NotebookLM interactions
+ */
+async function getReadyPage(context: BrowserContext): Promise<Page> {
+    const pages = context.pages();
+    let page = pages.find(p => p.url().includes("notebooklm.google.com"));
+
+    if (!page) {
+        page = await context.newPage();
+        await page.goto(NOTEBOOKLM_URL, { waitUntil: "networkidle", timeout: 30000 });
+    }
+
+    return page;
+}
+
+/**
+ * List all notebooks
+ */
+export async function listNotebooks(): Promise<Notebook[]> {
+    const context = await getAuthenticatedContext();
+
+    try {
+        const page = await getReadyPage(context);
+
+        // Wait for notebooks to load
+        await page.waitForTimeout(2000);
+
+        // Try to find notebook elements
+        const notebooks: Notebook[] = [];
+
+        // NotebookLM uses different selectors, try multiple approaches
+        const notebookElements = await page.$$('[class*="notebook"], [role="listitem"], a[href*="notebook"]');
+
+        for (const el of notebookElements) {
+            try {
+                const href = await el.getAttribute("href");
+                const title = await el.innerText();
+
+                if (href && title && href.includes("notebook")) {
+                    const id = href.split("/").pop() || "";
+                    notebooks.push({
+                        id,
+                        title: title.trim().split("\n")[0], // First line only
+                        url: `${NOTEBOOKLM_URL}${href}`,
+                    });
+                }
+            } catch {
+                // Skip problematic elements
+            }
+        }
+
+        // If no notebooks found via selectors, try evaluating page content
+        if (notebooks.length === 0) {
+            const pageContent = await page.content();
+
+            // Parse notebook links from page content
+            const notebookRegex = /href="(\/notebook\/[^"]+)"[^>]*>([^<]+)/g;
+            let match;
+            while ((match = notebookRegex.exec(pageContent)) !== null) {
+                const [, href, title] = match;
+                const id = href.split("/").pop() || "";
+                notebooks.push({
+                    id,
+                    title: title.trim(),
+                    url: `${NOTEBOOKLM_URL}${href}`,
+                });
+            }
+        }
+
+        await context.close();
+        return notebooks;
+
+    } catch (error) {
+        await context.close();
+        throw error;
+    }
+}
+
+/**
+ * Query a notebook
+ */
+export async function queryNotebook(
+    notebookId: string,
+    question: string,
+    options?: { includeCitations?: boolean }
+): Promise<QueryResult> {
+    const context = await getAuthenticatedContext();
+
+    try {
+        const page = await context.newPage();
+
+        // Navigate to specific notebook
+        await page.goto(`${NOTEBOOKLM_URL}/notebook/${notebookId}`, {
+            waitUntil: "networkidle",
+            timeout: 30000,
+        });
+
+        // Wait for chat interface to load
+        await page.waitForTimeout(2000);
+
+        // Find and fill the chat input
+        const chatInput = await page.$('textarea, [contenteditable="true"], input[type="text"]');
+
+        if (!chatInput) {
+            throw new Error("Could not find chat input");
+        }
+
+        // Type the question
+        await chatInput.fill(question);
+
+        // Submit (press Enter or click send button)
+        await chatInput.press("Enter");
+
+        // Wait for response
+        await page.waitForTimeout(5000);
+
+        // Try to extract the response
+        // NotebookLM renders responses in various ways
+        const responseElements = await page.$$('[class*="response"], [class*="message"], [class*="answer"]');
+
+        let answer = "";
+        const citations: QueryResult["citations"] = [];
+
+        // Get the last response element (most recent answer)
+        if (responseElements.length > 0) {
+            const lastResponse = responseElements[responseElements.length - 1];
+            answer = await lastResponse.innerText();
+        }
+
+        // If no structured response found, try to get page content
+        if (!answer) {
+            // Wait more for response to render
+            await page.waitForTimeout(5000);
+
+            // Try again
+            const allText = await page.$$('[class*="chat"], [class*="conversation"]');
+            if (allText.length > 0) {
+                const lastEl = allText[allText.length - 1];
+                answer = await lastEl.innerText();
+            }
+        }
+
+        // Extract citations if requested
+        if (options?.includeCitations) {
+            const citationElements = await page.$$('[class*="citation"], [class*="source"]');
+
+            for (const el of citationElements) {
+                try {
+                    const text = await el.innerText();
+                    citations.push({
+                        sourceTitle: "Source",
+                        excerpt: text.trim(),
+                    });
+                } catch {
+                    // Skip
+                }
+            }
+        }
+
+        await context.close();
+
+        return {
+            answer: answer.trim() || "Could not extract response. The query was sent but response parsing failed.",
+            citations,
+        };
+
+    } catch (error) {
+        await context.close();
+        throw error;
+    }
+}
+
+/**
+ * Create a new notebook
+ */
+export async function createNotebook(title: string): Promise<Notebook> {
+    const context = await getAuthenticatedContext();
+
+    try {
+        const page = await getReadyPage(context);
+
+        // Look for "Create" or "+" button
+        const createButton = await page.$('button:has-text("Create"), button:has-text("New"), [aria-label*="Create"]');
+
+        if (!createButton) {
+            throw new Error("Could not find create notebook button");
+        }
+
+        await createButton.click();
+        await page.waitForTimeout(2000);
+
+        // Find title input and fill it
+        const titleInput = await page.$('input[type="text"], textarea, [contenteditable="true"]');
+        if (titleInput) {
+            await titleInput.fill(title);
+        }
+
+        // Look for confirm/save button
+        const saveButton = await page.$('button:has-text("Create"), button:has-text("Save"), button[type="submit"]');
+        if (saveButton) {
+            await saveButton.click();
+        }
+
+        await page.waitForTimeout(3000);
+
+        // Get the new notebook URL
+        const currentUrl = page.url();
+        const id = currentUrl.split("/notebook/")[1]?.split("?")[0] || "";
+
+        await context.close();
+
+        return {
+            id,
+            title,
+            url: currentUrl,
+        };
+
+    } catch (error) {
+        await context.close();
+        throw error;
+    }
+}
+
+/**
+ * Add a source to a notebook
+ */
+export async function addSource(
+    notebookId: string,
+    sourceType: "url" | "text",
+    content: string
+): Promise<Source> {
+    const context = await getAuthenticatedContext();
+
+    try {
+        const page = await context.newPage();
+
+        // Navigate to notebook
+        await page.goto(`${NOTEBOOKLM_URL}/notebook/${notebookId}`, {
+            waitUntil: "networkidle",
+            timeout: 30000,
+        });
+
+        await page.waitForTimeout(2000);
+
+        // Find add source button
+        const addButton = await page.$('button:has-text("Add"), button:has-text("Source"), [aria-label*="Add source"]');
+
+        if (!addButton) {
+            throw new Error("Could not find add source button");
+        }
+
+        await addButton.click();
+        await page.waitForTimeout(1000);
+
+        if (sourceType === "url") {
+            // Look for URL input option
+            const urlOption = await page.$('button:has-text("Website"), button:has-text("URL"), [aria-label*="URL"]');
+            if (urlOption) {
+                await urlOption.click();
+                await page.waitForTimeout(500);
+            }
+
+            const urlInput = await page.$('input[type="url"], input[type="text"], input[placeholder*="URL"]');
+            if (urlInput) {
+                await urlInput.fill(content);
+            }
+        } else {
+            // Text/paste option
+            const textOption = await page.$('button:has-text("Text"), button:has-text("Paste"), [aria-label*="Text"]');
+            if (textOption) {
+                await textOption.click();
+                await page.waitForTimeout(500);
+            }
+
+            const textInput = await page.$('textarea, [contenteditable="true"]');
+            if (textInput) {
+                await textInput.fill(content);
+            }
+        }
+
+        // Submit
+        const submitButton = await page.$('button:has-text("Add"), button:has-text("Submit"), button[type="submit"]');
+        if (submitButton) {
+            await submitButton.click();
+        }
+
+        await page.waitForTimeout(3000);
+
+        await context.close();
+
+        return {
+            id: Date.now().toString(),
+            title: sourceType === "url" ? content : content.slice(0, 50) + "...",
+            type: sourceType === "url" ? "url" : "text",
+        };
+
+    } catch (error) {
+        await context.close();
+        throw error;
+    }
+}
+
+/**
+ * Get sources from a notebook
+ */
+export async function getSources(notebookId: string): Promise<Source[]> {
+    const context = await getAuthenticatedContext();
+
+    try {
+        const page = await context.newPage();
+
+        await page.goto(`${NOTEBOOKLM_URL}/notebook/${notebookId}`, {
+            waitUntil: "networkidle",
+            timeout: 30000,
+        });
+
+        await page.waitForTimeout(2000);
+
+        const sources: Source[] = [];
+
+        // Find source elements
+        const sourceElements = await page.$$('[class*="source"], [role="listitem"]');
+
+        for (const el of sourceElements) {
+            try {
+                const title = await el.innerText();
+                if (title) {
+                    sources.push({
+                        id: Date.now().toString(),
+                        title: title.trim().split("\n")[0],
+                        type: "unknown",
+                    });
+                }
+            } catch {
+                // Skip
+            }
+        }
+
+        await context.close();
+        return sources;
+
+    } catch (error) {
+        await context.close();
+        throw error;
+    }
+}

package/.agent/mcp/servers/notebooklm/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}