opencodekit 0.15.18 → 0.15.19

package/dist/index.js

@@ -750,7 +750,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "opencodekit",
-  version: "0.15.18",
+  version: "0.15.19",
   description: "CLI tool for bootstrapping and managing OpenCodeKit projects",
   keywords: ["agents", "cli", "mcp", "opencode", "opencodekit", "template"],
   license: "MIT",
@@ -3857,18 +3857,18 @@ async function copyOpenCodeOnly(templateRoot, targetDir) {
 }
 var MODEL_PRESETS = {
   free: {
-    model: "opencode/big-pickle",
+    model: "opencode/kimi-k2.5-free",
     agents: {
-      build: "opencode/big-pickle",
-      plan: "opencode/big-pickle",
-      review: "opencode/big-pickle",
-      explore: "opencode/grok-code",
-      general: "opencode/grok-code",
-      looker: "opencode/gpt-5-nano",
-      vision: "opencode/gpt-5-nano",
-      scout: "opencode/big-pickle",
-      painter: "opencode/gpt-5-nano",
-      compaction: "opencode/big-pickle"
+      build: "opencode/kimi-k2.5-free",
+      plan: "opencode/kimi-k2.5-free",
+      review: "opencode/minimax-m2.1-free",
+      explore: "opencode/glm-4.7-free",
+      general: "opencode/kimi-k2.5-free",
+      looker: "opencode/kimi-k2.5-free",
+      vision: "opencode/kimi-k2.5-free",
+      scout: "opencode/minimax-m2.1-free",
+      painter: "opencode/kimi-k2.5-free",
+      compaction: "opencode/kimi-k2.5-free"
     }
   },
   recommend: {
@@ -3878,12 +3878,12 @@ var MODEL_PRESETS = {
       plan: "openai/gpt-5.2",
       review: "openai/gpt-5.2-codex",
       explore: "proxypal/gemini-3-flash-preview",
-      general: "github-copilot/claude-haiku-4.5",
+      general: "opencode/kimi-k2.5-free",
       looker: "proxypal/gemini-3-flash-preview",
       vision: "proxypal/gemini-3-pro-preview",
-      scout: "proxypal/gemini-3-flash-preview",
-      painter: "proxypal/gemini-3-pro-preview",
-      compaction: "proxypal/gemini-2.5-flash"
+      scout: "opencode/kimi-k2.5-free",
+      painter: "proxypal/gemini-3-pro-image-preview",
+      compaction: "opencode/kimi-k2.5-free"
     }
   }
 };

package/dist/template/.opencode/memory/observations/2026-01-30-decision-github-copilot-claude-routing-keep-disab.md

@@ -0,0 +1,32 @@
+---
+type: decision
+created: 2026-01-30T15:07:59.081Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["github-copilot", "claude", "anthropic-sdk", "reasoning", "api-routing"]
+files: [".opencode/plugins/copilot-auth.ts"]
+---
+
+# 🎯 GitHub Copilot Claude routing: Keep disabled for stability
+
+🟢 **Confidence:** high
+
+Claude routing through Anthropic SDK is currently disabled in copilot-auth.ts (commit f7aabde). This decision was made because:
+
+1. **Problem**: Enabling Claude routing to use `@ai-sdk/anthropic` with `/v1` endpoint causes "Not Found: 404" errors
+2. **Root cause**: GitHub Copilot's API likely doesn't support the native Anthropic `/v1/messages` endpoint for Claude models through this integration
+3. **Solution**: Keep all models using `@ai-sdk/github-copilot` (OpenAI-compatible `/v1/chat/completions`)
+4. **Trade-off**: All models work, but Claude models don't get native Anthropic SDK optimizations or reasoning features through the `/v1` gateway
+
+To enable reasoning in the future, would need to:
+- Research if GitHub Copilot supports a different endpoint for reasoning
+- Check if there's a separate gateway URL for reasoning models
+- Verify with GitHub Copilot API documentation
+
+Current working configuration (commit f7aabde):
+- All models use `@ai-sdk/github-copilot`
+- All models use `/v1/chat/completions` (OpenAI-compatible)
+- Claude models work but don't have reasoning enabled
+
+File: .opencode/plugins/copilot-auth.ts (lines 93-100)

package/dist/template/.opencode/plugins/copilot-auth.ts

@@ -78,11 +78,6 @@ export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 				const info = await getAuth();
 				if (!info || info.type !== "oauth") return {};
 
-				const enterpriseUrl = info.enterpriseUrl;
-				const baseURL = enterpriseUrl
-					? `https://copilot-api.${normalizeDomain(enterpriseUrl)}`
-					: undefined;
-
 				if (provider && provider.models) {
 					for (const model of Object.values(provider.models)) {
 						model.cost = {
@@ -94,22 +89,19 @@ export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 							},
 						};
 
-						// Sync with official: Handle Claude routing and SDK mapping
-						const base =
-							baseURL ?? model.api.url ?? "https://api.githubcopilot.com";
-						const isClaude = model.id.includes("claude");
-
-						let url = base;
-						if (isClaude) {
-							if (!url.endsWith("/v1")) {
-								url = url.endsWith("/") ? `${url}v1` : `${url}/v1`;
-							}
-						}
-
-						model.api.url = url;
-						model.api.npm = isClaude
-							? "@ai-sdk/anthropic"
-							: "@ai-sdk/github-copilot";
+						// TODO: re-enable once messages api has higher rate limits
+						// Claude routing is disabled to avoid "Not Found" errors and rate limits
+						// const base = baseURL ?? model.api.url ?? "https://api.githubcopilot.com";
+						// const isClaude = model.id.includes("claude");
+						// let url = base;
+						// if (isClaude) {
+						// 	if (!url.endsWith("/v1")) {
+						// 		url = url.endsWith("/") ? `${url}v1` : `${url}/v1`;
+						// 	}
+						// }
+						// model.api.url = url;
+						// model.api.npm = isClaude ? "@ai-sdk/anthropic" : "@ai-sdk/github-copilot";
+						model.api.npm = "@ai-sdk/github-copilot";
 					}
 				}
 

package/dist/template/.opencode/skills/notebooklm/SKILL.md

@@ -0,0 +1,272 @@
+---
+name: notebooklm
+description: >
+  Query Google NotebookLM notebooks directly from OpenCode for source-grounded, citation-backed answers.
+  Use when user mentions NotebookLM, shares notebook URLs, or wants to query their uploaded documents.
+  Provides document-only responses with drastically reduced hallucinations.
+version: "1.0.0"
+license: MIT
+---
+
+# NotebookLM Skill
+
+Interact with Google NotebookLM to query documentation with Gemini's source-grounded answers. Each question opens a fresh browser session, retrieves the answer exclusively from uploaded documents, and closes.
+
+## When to Use This Skill
+
+Trigger when user:
+
+- Mentions NotebookLM explicitly
+- Shares NotebookLM URL (`https://notebooklm.google.com/notebook/...`)
+- Asks to query their notebooks/documentation
+- Wants to add documentation to NotebookLM library
+- Uses phrases like "ask my NotebookLM", "check my docs", "query my notebook"
+
+## Prerequisites
+
+Before using this skill, ensure:
+
+1. **Python 3.10+** is installed
+2. **Google Chrome** browser is installed
+3. **NotebookLM account** with uploaded documents
+4. **Google authentication** (one-time setup)
+
+## Quick Start
+
+```typescript
+// Check authentication status
+await notebooklm({ operation: "auth", subOperation: "status" });
+
+// Query a notebook
+await notebooklm({
+  operation: "query",
+  question: "What are the key findings in this document?",
+  notebookUrl: "https://notebooklm.google.com/notebook/...",
+});
+```
+
+## Core Workflow
+
+### Step 1: Check Authentication
+
+```typescript
+const authStatus = await notebooklm({
+  operation: "auth",
+  subOperation: "status",
+});
+```
+
+If not authenticated, proceed to setup.
+
+### Step 2: Authenticate (One-Time Setup)
+
+```typescript
+await notebooklm({
+  operation: "auth",
+  subOperation: "setup",
+  showBrowser: true, // Browser must be visible for manual login
+});
+```
+
+**Important:**
+
+- Browser is VISIBLE for authentication
+- Browser window opens automatically
+- User must manually log in to Google
+- Tell user: "A browser window will open for Google login"
+
+### Step 3: Manage Notebook Library
+
+```typescript
+// List all notebooks
+await notebooklm({ operation: "library", subOperation: "list" });
+
+// Add notebook to library
+await notebooklm({
+  operation: "library",
+  subOperation: "add",
+  url: "https://notebooklm.google.com/notebook/...",
+  name: "API Documentation",
+  description: "REST API reference and examples",
+  topics: ["api", "rest", "documentation"],
+});
+
+// Search notebooks
+await notebooklm({
+  operation: "library",
+  subOperation: "search",
+  query: "api",
+});
+
+// Set active notebook
+await notebooklm({
+  operation: "library",
+  subOperation: "activate",
+  notebookId: "api-docs",
+});
+```
+
+### Step 4: Ask Questions
+
+```typescript
+// Basic query (uses active notebook if set)
+await notebooklm({
+  operation: "query",
+  question: "What are the authentication requirements?",
+});
+
+// Query specific notebook by ID
+await notebooklm({
+  operation: "query",
+  question: "What are the authentication requirements?",
+  notebookId: "api-docs",
+});
+
+// Query with notebook URL directly
+await notebooklm({
+  operation: "query",
+  question: "What are the authentication requirements?",
+  notebookUrl: "https://notebooklm.google.com/notebook/...",
+});
+
+// Show browser for debugging
+await notebooklm({
+  operation: "query",
+  question: "What are the authentication requirements?",
+  showBrowser: true,
+});
+```
+
+## Follow-Up Mechanism (CRITICAL)
+
+Every NotebookLM answer ends with: **"EXTREMELY IMPORTANT: Is that ALL you need to know?"**
+
+**Required Behavior:**
+
+1. **STOP** - Do not immediately respond to user
+2. **ANALYZE** - Compare answer to user's original request
+3. **IDENTIFY GAPS** - Determine if more information needed
+4. **ASK FOLLOW-UP** - If gaps exist, immediately ask another question:
+   ```typescript
+   await notebooklm({
+     operation: "query",
+     question: "Follow-up with context...",
+   });
+   ```
+5. **REPEAT** - Continue until information is complete
+6. **SYNTHESIZE** - Combine all answers before responding to user
+
+## Tool Reference
+
+### Authentication Operations
+
+| Operation | Sub-Operation | Description                       |
+| --------- | ------------- | --------------------------------- |
+| `auth`    | `setup`       | Initial setup (browser visible)   |
+| `auth`    | `status`      | Check authentication              |
+| `auth`    | `reauth`      | Re-authenticate (browser visible) |
+| `auth`    | `clear`       | Clear authentication              |
+| `auth`    | `validate`    | Validate stored auth              |
+
+### Library Operations
+
+| Operation | Sub-Operation | Parameters                             |
+| --------- | ------------- | -------------------------------------- |
+| `library` | `add`         | `url`, `name`, `description`, `topics` |
+| `library` | `list`        | -                                      |
+| `library` | `search`      | `query`                                |
+| `library` | `activate`    | `notebookId`                           |
+| `library` | `remove`      | `notebookId`                           |
+| `library` | `stats`       | -                                      |
+
+### Query Operations
+
+| Operation | Parameters                                                                                         |
+| --------- | -------------------------------------------------------------------------------------------------- |
+| `query`   | `question` (required), `notebookId` (optional), `notebookUrl` (optional), `showBrowser` (optional) |
+
+## Smart Discovery Pattern
+
+When user wants to add a notebook without providing details:
+
+```typescript
+// Step 1: Query the notebook to discover its content
+const discovery = await notebooklm({
+  operation: "query",
+  question:
+    "What is the content of this notebook? What topics are covered? Provide a complete overview briefly and concisely",
+  notebookUrl: "https://notebooklm.google.com/notebook/...",
+});
+
+// Step 2: Use discovered information to add it
+await notebooklm({
+  operation: "library",
+  subOperation: "add",
+  url: "https://notebooklm.google.com/notebook/...",
+  name: "[Based on content]",
+  description: "[Based on content]",
+  topics: ["[Based on content]"],
+});
+```
+
+## Decision Flow
+
+```
+User mentions NotebookLM
+    ↓
+Check auth → notebooklm({ operation: "auth", subOperation: "status" })
+    ↓
+If not authenticated → notebooklm({ operation: "auth", subOperation: "setup", showBrowser: true })
+    ↓
+Check/Add notebook → notebooklm({ operation: "library", subOperation: "list/add" })
+    ↓
+Activate notebook → notebooklm({ operation: "library", subOperation: "activate", notebookId: "..." })
+    ↓
+Ask question → notebooklm({ operation: "query", question: "..." })
+    ↓
+See "Is that ALL you need?" → Ask follow-ups until complete
+    ↓
+Synthesize and respond to user
+```
+
+## Troubleshooting
+
+| Problem              | Solution                                |
+| -------------------- | --------------------------------------- |
+| Not authenticated    | Run auth setup with `showBrowser: true` |
+| Authentication fails | Browser must be visible for setup       |
+| Rate limit (50/day)  | Wait or switch Google account           |
+| Notebook not found   | Check with `library` → `list` operation |
+| ModuleNotFoundError  | Tool auto-installs dependencies         |
+
+## Best Practices
+
+1. **Always check auth first** - Before any operations
+2. **Follow-up questions** - Don't stop at first answer
+3. **Browser visible for auth** - Required for manual login
+4. **Include context** - Each question is independent
+5. **Synthesize answers** - Combine multiple responses
+
+## Limitations
+
+- No session persistence (each question = new browser)
+- Rate limits on free Google accounts (50 queries/day)
+- Manual upload required (user must add docs to NotebookLM)
+- Browser overhead (few seconds per question)
+- Requires Python and Chrome installed
+
+## Data Storage
+
+All data stored in `~/.opencode/skills/notebooklm/data/`:
+
+- `library.json` - Notebook metadata
+- `auth_info.json` - Authentication status
+- `browser_state/` - Browser cookies and session
+
+**Security:** Protected by `.gitignore`, never commit to git.
+
+## Resources
+
+- **Original Skill**: https://github.com/PleasePrompto/notebooklm-skill
+- **NotebookLM**: https://notebooklm.google.com
+- **Setup Guide**: See `references/setup.md`

package/dist/template/.opencode/skills/notebooklm/references/setup.md

@@ -0,0 +1,353 @@
+# NotebookLM Skill Setup Guide
+
+Complete setup instructions for the NotebookLM skill integration.
+
+## Prerequisites
+
+### 1. Python 3.10+
+
+Check if Python is installed:
+
+```bash
+python --version
+# or
+python3 --version
+```
+
+**Install if missing:**
+
+**macOS (using Homebrew):**
+
+```bash
+brew install python@3.11
+```
+
+**Ubuntu/Debian:**
+
+```bash
+sudo apt update
+sudo apt install python3 python3-pip python3-venv
+```
+
+**Windows:**
+Download from [python.org](https://python.org) and install with "Add to PATH" checked.
+
+### 2. Google Chrome
+
+Check if Chrome is installed:
+
+**macOS:**
+
+```bash
+ls /Applications/Google\ Chrome.app
+```
+
+**Linux:**
+
+```bash
+which google-chrome
+```
+
+**Windows:**
+Check Start Menu for Google Chrome.
+
+**Install if missing:**
+Download from [google.com/chrome](https://google.com/chrome)
+
+### 3. NotebookLM Account
+
+1. Visit [notebooklm.google.com](https://notebooklm.google.com)
+2. Sign in with Google account
+3. Upload documents to create notebooks
+
+## First-Time Setup
+
+### Step 1: Verify Tool Installation
+
+The tool auto-installs the Python skill on first use. Verify it's working:
+
+```typescript
+const setup = await notebooklm({ operation: "setup" });
+console.log(setup.output);
+```
+
+Expected output:
+
+```
+📦 NotebookLM skill not found. Installing...
+   Cloning from https://github.com/PleasePrompto/notebooklm-skill...
+   ✓ Skill installed successfully
+   📍 Location: ~/.opencode/skills/notebooklm
+```
+
+### Step 2: Authenticate with Google
+
+**CRITICAL:** Browser must be visible for manual login.
+
+```typescript
+await notebooklm({
+  operation: "auth",
+  subOperation: "setup",
+  showBrowser: true,
+});
+```
+
+**What happens:**
+
+1. Browser window opens automatically
+2. Navigate to notebooklm.google.com
+3. **You must manually log in** to your Google account
+4. Authentication state is saved for future use
+
+**Authentication lasts:** ~7 days (then requires re-auth)
+
+### Step 3: Verify Authentication
+
+```typescript
+const status = await notebooklm({
+  operation: "auth",
+  subOperation: "status",
+});
+
+console.log(status.output);
+```
+
+Expected output:
+
+```
+🔐 Authentication Status:
+  Authenticated: Yes
+  State age: 0.5 hours
+  Last auth: 2025-01-30 14:32:15
+```
+
+## Adding Notebooks
+
+### Method 1: Smart Discovery (Recommended)
+
+If you don't know the notebook content:
+
+```typescript
+// Step 1: Query to discover content
+const discovery = await notebooklm({
+  operation: "query",
+  question:
+    "What is the content of this notebook? What topics are covered? Provide a complete overview briefly and concisely",
+  notebookUrl: "https://notebooklm.google.com/notebook/abc123...",
+});
+
+// Step 2: Add with discovered info
+await notebooklm({
+  operation: "library",
+  subOperation: "add",
+  url: "https://notebooklm.google.com/notebook/abc123...",
+  name: "API Documentation",
+  description: "REST API reference with authentication examples",
+  topics: ["api", "rest", "authentication"],
+});
+```
+
+### Method 2: Manual Entry
+
+If you already know the details:
+
+```typescript
+await notebooklm({
+  operation: "library",
+  subOperation: "add",
+  url: "https://notebooklm.google.com/notebook/abc123...",
+  name: "Project Documentation",
+  description: "Architecture and design decisions",
+  topics: ["architecture", "design", "documentation"],
+});
+```
+
+## Usage Examples
+
+### Query Active Notebook
+
+```typescript
+// Set active notebook first
+await notebooklm({
+  operation: "library",
+  subOperation: "activate",
+  notebookId: "api-docs",
+});
+
+// Query without specifying notebook
+const answer = await notebooklm({
+  operation: "query",
+  question: "What are the rate limits?",
+});
+
+console.log(answer.output);
+```
+
+### Query Specific Notebook
+
+```typescript
+const answer = await notebooklm({
+  operation: "query",
+  question: "What are the rate limits?",
+  notebookId: "api-docs",
+});
+```
+
+### Query by URL
+
+```typescript
+const answer = await notebooklm({
+  operation: "query",
+  question: "What are the rate limits?",
+  notebookUrl: "https://notebooklm.google.com/notebook/abc123...",
+});
+```
+
+### List All Notebooks
+
+```typescript
+const library = await notebooklm({
+  operation: "library",
+  subOperation: "list",
+});
+
+console.log(library.output);
+```
+
+### Search Notebooks
+
+```typescript
+const results = await notebooklm({
+  operation: "library",
+  subOperation: "search",
+  query: "authentication",
+});
+
+console.log(results.output);
+```
+
+## Troubleshooting
+
+### "Not authenticated" Error
+
+**Cause:** Authentication expired or never completed.
+
+**Fix:**
+
+```typescript
+await notebooklm({
+  operation: "auth",
+  subOperation: "setup",
+  showBrowser: true,
+});
+```
+
+### "ModuleNotFoundError" Error
+
+**Cause:** Python dependencies not installed.
+
+**Fix:** The tool auto-installs on first use. If it fails:
+
+```bash
+cd ~/.opencode/skills/notebooklm
+python -m venv .venv
+source .venv/bin/activate  # Linux/Mac
+# or .venv\Scripts\activate  # Windows
+pip install -r requirements.txt
+python -m patchright install chromium
+```
+
+### "Notebook not found" Error
+
+**Cause:** Notebook ID doesn't exist in library.
+
+**Fix:**
+
+```typescript
+// List available notebooks
+await notebooklm({ operation: "library", subOperation: "list" });
+
+// Or add the notebook first
+await notebooklm({
+  operation: "library",
+  subOperation: "add",
+  url: "...",
+  name: "...",
+  description: "...",
+  topics: ["..."],
+});
+```
+
+### Rate Limit (50 queries/day)
+
+**Cause:** Free Google account limit reached.
+
+**Fix:**
+
+- Wait 24 hours
+- Use a different Google account
+- Upgrade to Google One AI Premium (if available)
+
+### Browser Not Opening
+
+**Cause:** Chrome not found or headless mode enabled.
+
+**Fix:**
+
+```typescript
+// Always use showBrowser: true for auth
+await notebooklm({
+  operation: "auth",
+  subOperation: "setup",
+  showBrowser: true, // Required!
+});
+```
+
+## Data Locations
+
+All data stored in `~/.opencode/skills/notebooklm/`:
+
+```
+~/.opencode/skills/notebooklm/
+├── data/
+│   ├── library.json          # Your notebook library
+│   ├── auth_info.json        # Authentication metadata
+│   └── browser_state/        # Browser cookies/session
+│       ├── state.json
+│       └── browser_profile/
+├── scripts/                  # Python automation scripts
+│   ├── run.py               # Virtual environment wrapper
+│   ├── ask_question.py      # Query interface
+│   ├── notebook_manager.py  # Library management
+│   ├── auth_manager.py      # Authentication
+│   ├── browser_utils.py     # Browser utilities
+│   └── config.py            # Configuration
+├── .venv/                    # Python virtual environment
+├── requirements.txt          # Python dependencies
+└── .gitignore               # Protects sensitive data
+```
+
+**Security Note:** The `data/` directory contains authentication cookies. Never commit this to git.
+
+## Updating the Skill
+
+To update to the latest version:
+
+```bash
+cd ~/.opencode/skills/notebooklm
+git pull origin master
+```
+
+## Uninstalling
+
+To completely remove the skill:
+
+```bash
+rm -rf ~/.opencode/skills/notebooklm
+```
+
+## Getting Help
+
+- **Original Repository:** https://github.com/PleasePrompto/notebooklm-skill
+- **NotebookLM Help:** https://support.google.com/notebooklm
+- **OpenCodeKit Issues:** File an issue in the opencodekit-template repository

package/dist/template/.opencode/tools/notebooklm.ts

@@ -0,0 +1,488 @@
+/**
+ * NotebookLM Tool for OpenCodeKit
+ *
+ * Wraps the Python NotebookLM skill for querying Google NotebookLM notebooks.
+ * Auto-clones the skill repository and manages the Python virtual environment.
+ *
+ * @module notebooklm
+ */
+
+import { homedir } from "os";
+import { join } from "path";
+import { $ } from "bun";
+
+/**
+ * Logger interface for OpenCode client app logging
+ * Falls back to console if client logger not available
+ */
+interface Logger {
+	debug: (message: string, extra?: Record<string, unknown>) => void;
+	info: (message: string, extra?: Record<string, unknown>) => void;
+	warn: (message: string, extra?: Record<string, unknown>) => void;
+	error: (message: string, extra?: Record<string, unknown>) => void;
+}
+
+/**
+ * Create a logger that uses OpenCode client.app.log() when available,
+ * otherwise falls back to console
+ */
+function createLogger(client?: {
+	app: {
+		log: (log: {
+			service: string;
+			level: "debug" | "info" | "warn" | "error";
+			message: string;
+			extra?: Record<string, unknown>;
+		}) => Promise<void>;
+	};
+}): Logger {
+	const service = "notebooklm";
+
+	if (client?.app?.log) {
+		// Use OpenCode client logging
+		return {
+			debug: (message: string, extra?: Record<string, unknown>) => {
+				client.app
+					.log({ service, level: "debug", message, extra })
+					.catch(() => {});
+			},
+			info: (message: string, extra?: Record<string, unknown>) => {
+				client.app
+					.log({ service, level: "info", message, extra })
+					.catch(() => {});
+			},
+			warn: (message: string, extra?: Record<string, unknown>) => {
+				client.app
+					.log({ service, level: "warn", message, extra })
+					.catch(() => {});
+			},
+			error: (message: string, extra?: Record<string, unknown>) => {
+				client.app
+					.log({ service, level: "error", message, extra })
+					.catch(() => {});
+			},
+		};
+	}
+
+	// Fallback to console
+	return {
+		debug: (message: string, extra?: Record<string, unknown>) => {
+			console.log(`[DEBUG] ${message}`, extra ? JSON.stringify(extra) : "");
+		},
+		info: (message: string, extra?: Record<string, unknown>) => {
+			console.log(`[INFO] ${message}`, extra ? JSON.stringify(extra) : "");
+		},
+		warn: (message: string, extra?: Record<string, unknown>) => {
+			console.warn(`[WARN] ${message}`, extra ? JSON.stringify(extra) : "");
+		},
+		error: (message: string, extra?: Record<string, unknown>) => {
+			console.error(`[ERROR] ${message}`, extra ? JSON.stringify(extra) : "");
+		},
+	};
+}
+
+// Global logger instance (will be initialized with client if available)
+let globalLogger: Logger = createLogger();
+
+/**
+ * Set the logger instance (called by plugin initialization)
+ */
+export function setNotebookLMLogger(client?: {
+	app: {
+		log: (log: {
+			service: string;
+			level: "debug" | "info" | "warn" | "error";
+			message: string;
+			extra?: Record<string, unknown>;
+		}) => Promise<void>;
+	};
+}): void {
+	globalLogger = createLogger(client);
+}
+
+// Detect Python command (python or python3)
+async function getPythonCommand(): Promise<string> {
+	try {
+		await $`python --version`.quiet();
+		return "python";
+	} catch {
+		try {
+			await $`python3 --version`.quiet();
+			return "python3";
+		} catch {
+			throw new Error("Python not found. Please install Python 3.10+");
+		}
+	}
+}
+
+// Skill repository URL
+const SKILL_REPO = "https://github.com/PleasePrompto/notebooklm-skill";
+
+// Skill installation directory
+const SKILL_DIR = join(homedir(), ".opencode", "skills", "notebooklm");
+
+// Scripts directory
+const SCRIPTS_DIR = join(SKILL_DIR, "scripts");
+
+/**
+ * Input parameters for notebooklm tool
+ */
+export interface NotebookLMInput {
+	/** Operation to perform */
+	operation: "auth" | "query" | "library" | "setup";
+
+	/** Sub-operation for auth and library operations */
+	subOperation?:
+		| "setup"
+		| "status"
+		| "reauth"
+		| "clear"
+		| "validate"
+		| "add"
+		| "list"
+		| "search"
+		| "activate"
+		| "remove"
+		| "stats";
+
+	/** Question to ask (for query operation) */
+	question?: string;
+
+	/** Notebook URL (for add or query operations) */
+	notebookUrl?: string;
+
+	/** Notebook ID from library (for query or activate operations) */
+	notebookId?: string;
+
+	/** Notebook name (for add operation) */
+	name?: string;
+
+	/** Notebook description (for add operation) */
+	description?: string;
+
+	/** Topics/tags (for add operation) - array or comma-separated string */
+	topics?: string[] | string;
+
+	/** Search query (for library search) */
+	query?: string;
+
+	/** Show browser window (for auth setup or debugging) */
+	showBrowser?: boolean;
+
+	/** Timeout in minutes for authentication */
+	timeout?: number;
+}
+
+/**
+ * Result from notebooklm operation
+ */
+export interface NotebookLMResult {
+	/** Whether the operation succeeded */
+	success: boolean;
+
+	/** Output from the operation */
+	output: string;
+
+	/** Error message if failed */
+	error?: string;
+
+	/** Parsed data (for library operations) */
+	data?: unknown;
+}
+
+/**
+ * Ensure Python virtual environment is set up with dependencies
+ */
+async function ensureVirtualEnv(): Promise<void> {
+	const venvPath = join(SKILL_DIR, ".venv");
+	const venvPython = join(venvPath, "bin", "python");
+	const venvPip = join(venvPath, "bin", "pip");
+
+	// Check if venv exists with pip
+	const venvExists = await Bun.file(venvPython).exists();
+	const pipExists = await Bun.file(venvPip).exists();
+
+	if (venvExists && pipExists) {
+		// Check if patchright is installed
+		const checkResult =
+			await $`cd ${SKILL_DIR} && .venv/bin/python -c "import patchright" 2>&1`.nothrow();
+		if (checkResult.exitCode === 0) {
+			return;
+		}
+	}
+
+	globalLogger.info("Setting up Python virtual environment...");
+
+	const pythonCmd = await getPythonCommand();
+
+	// Remove broken venv if exists
+	if (venvExists && !pipExists) {
+		globalLogger.warn("Removing incomplete virtual environment...");
+		await $`cd ${SKILL_DIR} && rm -rf .venv`;
+	}
+
+	// Create virtual environment with pip
+	globalLogger.info("Creating virtual environment...");
+	const venvResult =
+		await $`cd ${SKILL_DIR} && ${pythonCmd} -m venv .venv --without-pip`.nothrow();
+	if (venvResult.exitCode !== 0) {
+		throw new Error(
+			`Failed to create virtual environment: ${venvResult.stderr}`,
+		);
+	}
+
+	// Install pip manually
+	globalLogger.info("Installing pip...");
+	const pipInstallResult =
+		await $`cd ${SKILL_DIR} && .venv/bin/python -m ensurepip --upgrade`.nothrow();
+	if (pipInstallResult.exitCode !== 0) {
+		// Try alternative method
+		await $`cd ${SKILL_DIR} && curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py && .venv/bin/python get-pip.py && rm get-pip.py`.nothrow();
+	}
+
+	// Install dependencies
+	globalLogger.info("Installing dependencies (this may take a minute)...");
+	const pipResult =
+		await $`cd ${SKILL_DIR} && .venv/bin/python -m pip install -r requirements.txt`.nothrow();
+	if (pipResult.exitCode !== 0) {
+		throw new Error(`Failed to install dependencies: ${pipResult.stderr}`);
+	}
+
+	// Install patchright browser
+	globalLogger.info("Installing browser automation...");
+	const browserResult =
+		await $`cd ${SKILL_DIR} && .venv/bin/python -m patchright install chromium`.nothrow();
+	if (browserResult.exitCode !== 0) {
+		globalLogger.warn("Browser install may have issues, but continuing...");
+	}
+
+	globalLogger.info("Virtual environment ready");
+}
+
+/**
+ * Ensure the NotebookLM skill is installed
+ */
+async function ensureSkillInstalled(): Promise<void> {
+	const runPyPath = join(SCRIPTS_DIR, "run.py");
+
+	// Check if skill is already installed
+	const exists = await Bun.file(runPyPath).exists();
+	if (exists) {
+		return;
+	}
+
+	globalLogger.info("NotebookLM skill not found. Installing...");
+
+	// Create parent directory
+	const parentDir = join(homedir(), ".opencode", "skills");
+	await $`mkdir -p ${parentDir}`;
+
+	// Clone the repository
+	globalLogger.info(`Cloning from ${SKILL_REPO}...`);
+	const result =
+		await $`cd ${parentDir} && git clone ${SKILL_REPO} notebooklm`.quiet();
+
+	if (result.exitCode !== 0) {
+		throw new Error(`Failed to clone NotebookLM skill: ${result.stderr}`);
+	}
+
+	globalLogger.info("Skill installed successfully", { location: SKILL_DIR });
+
+	// Set up virtual environment
+	await ensureVirtualEnv();
+}
+
+/**
+ * Build command arguments for run.py wrapper
+ */
+function buildCommandArgs(input: NotebookLMInput): string[] {
+	const args: string[] = [];
+
+	switch (input.operation) {
+		case "auth":
+			args.push(input.subOperation || "status");
+
+			if (input.subOperation === "setup" || input.subOperation === "reauth") {
+				if (!input.showBrowser) {
+					args.push("--headless");
+				}
+				if (input.timeout) {
+					args.push("--timeout", String(input.timeout));
+				}
+			}
+			break;
+
+		case "library":
+			args.push(input.subOperation || "list");
+
+			if (input.subOperation === "add") {
+				if (input.notebookUrl) args.push("--url", input.notebookUrl);
+				if (input.name) args.push("--name", input.name);
+				if (input.description) args.push("--description", input.description);
+				if (input.topics) {
+					const topicsStr = Array.isArray(input.topics)
+						? input.topics.join(",")
+						: input.topics;
+					args.push("--topics", topicsStr);
+				}
+			} else if (input.subOperation === "search") {
+				if (input.query) args.push("--query", input.query);
+			} else if (
+				input.subOperation === "activate" ||
+				input.subOperation === "remove"
+			) {
+				if (input.notebookId) args.push("--id", input.notebookId);
+			}
+			break;
+
+		case "query":
+			// ask_question.py is passed as script parameter
+
+			if (input.question) {
+				args.push("--question", input.question);
+			}
+
+			if (input.notebookUrl) {
+				args.push("--notebook-url", input.notebookUrl);
+			} else if (input.notebookId) {
+				args.push("--notebook-id", input.notebookId);
+			}
+
+			if (input.showBrowser) {
+				args.push("--show-browser");
+			}
+			break;
+
+		case "setup":
+			// Setup is handled by ensureSkillInstalled
+			return [];
+	}
+
+	return args;
+}
+
+/**
+ * Execute a NotebookLM operation
+ */
+async function executeOperation(
+	script: string,
+	args: string[],
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+	const runPyPath = join(SCRIPTS_DIR, "run.py");
+	const venvPython = join(SKILL_DIR, ".venv", "bin", "python");
+
+	// Use venv python if available, otherwise fall back to system
+	const pythonCmd = (await Bun.file(venvPython).exists())
+		? venvPython
+		: await getPythonCommand();
+
+	// Build full command
+	const cmd = [pythonCmd, runPyPath, script, ...args];
+
+	globalLogger.debug(`Executing: ${cmd.join(" ")}`);
+
+	// Execute with Bun
+	const result = await $`cd ${SKILL_DIR} && ${cmd}`.nothrow();
+
+	return {
+		stdout: result.stdout.toString(),
+		stderr: result.stderr.toString(),
+		exitCode: result.exitCode,
+	};
+}
+
+/**
+ * Main notebooklm tool function
+ *
+ * @param input - Operation parameters
+ * @returns Result of the operation
+ *
+ * @example
+ * // Check authentication status
+ * const status = await notebooklm({ operation: "auth", subOperation: "status" });
+ *
+ * @example
+ * // Query a notebook
+ * const answer = await notebooklm({
+ *   operation: "query",
+ *   question: "What are the key findings?",
+ *   notebookId: "my-notebook"
+ * });
+ */
+export default async function notebooklm(
+	input: NotebookLMInput,
+): Promise<NotebookLMResult> {
+	try {
+		// Ensure skill is installed
+		await ensureSkillInstalled();
+
+		// Ensure virtual environment is set up (for non-setup operations)
+		if (input.operation !== "setup") {
+			await ensureVirtualEnv();
+		}
+
+		// Handle setup operation (just verify installation)
+		if (input.operation === "setup") {
+			return {
+				success: true,
+				output: `NotebookLM skill installed at: ${SKILL_DIR}\n\nPrerequisites:\n- Python 3.10+ must be installed\n- Google Chrome must be installed\n- Run auth setup before querying`,
+				data: { skillDir: SKILL_DIR },
+			};
+		}
+
+		// Build command arguments
+		const args = buildCommandArgs(input);
+
+		// Determine which script to run
+		let script: string;
+		switch (input.operation) {
+			case "auth":
+				script = "auth_manager.py";
+				break;
+			case "library":
+				script = "notebook_manager.py";
+				break;
+			case "query":
+				script = "ask_question.py";
+				break;
+			default:
+				throw new Error(`Unknown operation: ${input.operation}`);
+		}
+
+		// Execute the operation
+		globalLogger.info(
+			`NotebookLM: ${input.operation}${input.subOperation ? `/${input.subOperation}` : ""}`,
+		);
+		const result = await executeOperation(script, args);
+
+		// Parse result
+		const success = result.exitCode === 0;
+
+		// Try to parse JSON data from output (for library operations)
+		let data: unknown = undefined;
+		try {
+			// Look for JSON in the output
+			const jsonMatch = result.stdout.match(/\{[\s\S]*\}/);
+			if (jsonMatch) {
+				data = JSON.parse(jsonMatch[0]);
+			}
+		} catch {
+			// Not JSON, that's fine
+		}
+
+		return {
+			success,
+			output: result.stdout || result.stderr,
+			error: success ? undefined : result.stderr,
+			data,
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+
+		return {
+			success: false,
+			output: "",
+			error: errorMessage,
+		};
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencodekit",
-	"version": "0.15.18",
+	"version": "0.15.19",
 	"description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
 	"keywords": ["agents", "cli", "mcp", "opencode", "opencodekit", "template"],
 	"license": "MIT",