opencodekit 0.15.16 → 0.15.19

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/dist/template/.opencode/{tool → tools}/swarm-delegate.ts

@@ -47,16 +47,16 @@ Purpose:
 - Creates a consistent delegation envelope for a specific Beads task
 - Optionally appends it to .beads/artifacts/<id>/delegation.md
 
-Example:
+Example (use actual task from user request):
 swarm-delegate({
-  bead_id: "opencodekit-template-xyz",
-  title: "Add feature X",
-  expected_outcome: "Feature X works and tests pass",
-  required_tools: "read, grep, lsp, bash",
-  must_do: "LSP before edits, run project verification commands",
-  must_not_do: "no new deps, don't edit dist/",
+  bead_id: "<bead-id>",
+  title: "<phase> - <worker-id>",
+  expected_outcome: "<specific outcome for this worker's assigned files>",
+  required_tools: "read, grep, lsp, edit, bash",
+  must_do: "LSP before edits, run tests, report progress via swarm-monitor",
+  must_not_do: "no new deps, don't edit files outside assignment",
   acceptance_checks: "typecheck: <command>, lint: <command>, test: <command>",
-  context: "See .beads/artifacts/<id>/spec.md",
+  context: "Phase: <phase>, Role: <role>, Team: <team-name>, Assigned: <files>",
   write: true
 })`,
 	args: {