pi-harness-runtime 0.10.0 → 0.10.2

package/packages/todo-bd-sync/src/detector.ts

@@ -0,0 +1,150 @@
+/**
+ * Detection utilities for checking if rpiv-todo is installed
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+/**
+ * Check if @juicesharp/rpiv-todo is installed globally via npm
+ */
+export function isRpivTodoInstalled(): boolean {
+	try {
+		// Check npm global packages
+		const output = execSync(
+			"npm list -g @juicesharp/rpiv-todo 2>/dev/null || echo 'NOT_FOUND'",
+			{
+				encoding: "utf8",
+				timeout: 5000,
+			},
+		);
+		return (
+			output.includes("@juicesharp/rpiv-todo") && !output.includes("NOT_FOUND")
+		);
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Check if rpiv-todo is loaded in pi extensions
+ * This checks common extension directories
+ */
+export function isRpivTodoLoaded(): boolean {
+	// Check pi-agent extensions directory
+	const extensionsDir = join(homedir(), ".pi", "agent", "extensions");
+
+	// Check for rpiv-todo related files
+	const possiblePaths = [
+		join(extensionsDir, "rpiv-todo"),
+		join(extensionsDir, "@juicesharp", "rpiv-todo"),
+		join(extensionsDir, "node_modules", "@juicesharp", "rpiv-todo"),
+	];
+
+	for (const path of possiblePaths) {
+		if (existsSync(path)) {
+			return true;
+		}
+	}
+
+	// Also check if the module can be resolved
+	try {
+		require.resolve("@juicesharp/rpiv-todo");
+		return true;
+	} catch {
+		// Not found via require
+	}
+
+	return false;
+}
+
+/**
+ * Get the version of rpiv-todo if installed
+ */
+export function getRpivTodoVersion(): string | null {
+	try {
+		const output = execSync(
+			"npm list -g @juicesharp/rpiv-todo --json 2>/dev/null | grep '\"version\"' | head -1",
+			{ encoding: "utf8", timeout: 5000 },
+		);
+		const match = output.match(/"version":\s*"([^"]+)"/);
+		return match ? match[1] : null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Check if bd CLI is installed
+ */
+export function isBdInstalled(): boolean {
+	try {
+		const output = execSync("which bd 2>/dev/null || echo 'NOT_FOUND'", {
+			encoding: "utf8",
+			timeout: 5000,
+		});
+		return output.includes("bd") && !output.includes("NOT_FOUND");
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Get the version of bd CLI if installed
+ */
+export function getBdVersion(): string | null {
+	try {
+		const output = execSync("bd --version 2>/dev/null || echo 'unknown'", {
+			encoding: "utf8",
+			timeout: 5000,
+		});
+		return output.trim().replace("bd version ", "");
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Get installation status of both dependencies
+ */
+export interface DependencyStatus {
+	rpivTodo: {
+		installed: boolean;
+		version: string | null;
+		loaded: boolean;
+	};
+	bd: {
+		installed: boolean;
+		version: string | null;
+	};
+}
+
+export function getDependencyStatus(): DependencyStatus {
+	return {
+		rpivTodo: {
+			installed: isRpivTodoInstalled(),
+			version: getRpivTodoVersion(),
+			loaded: isRpivTodoLoaded(),
+		},
+		bd: {
+			installed: isBdInstalled(),
+			version: getBdVersion(),
+		},
+	};
+}
+
+/**
+ * Log dependency status for debugging
+ */
+export function logDependencyStatus(): void {
+	const status = getDependencyStatus();
+	console.log("[DEBUG todo-bd-sync] Dependency check:");
+	console.log(
+		`  rpiv-todo: installed=${status.rpivTodo.installed}, version=${status.rpivTodo.version}, loaded=${status.rpivTodo.loaded}`,
+	);
+	console.log(
+		`  bd: installed=${status.bd.installed}, version=${status.bd.version}`,
+	);
+}

package/packages/todo-bd-sync/src/extension.ts

@@ -0,0 +1,84 @@
+/**
+ * todo-bd-sync extension entry point
+ *
+ * This is the pi-coding-agent extension that:
+ * 1. Auto-injects "todo-list" to prompt to enable rpiv-todo
+ * 2. Sets up two-way sync between rpiv-todo and bd
+ * 3. Loads existing bd issues on session start
+ *
+ * To use this extension:
+ * 1. Install dependencies:
+ *    pi install npm:@juicesharp/rpiv-todo
+ *    (bd should already be installed)
+ *
+ * 2. The extension auto-enables when rpiv-todo is detected
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+	createTodoBdSync,
+	type TodoBdSync,
+	type TodoBdSyncConfig,
+} from "./index.js";
+import { getDependencyStatus, logDependencyStatus } from "./detector.js";
+import { createCustomReminder } from "./todo-reminder.js";
+import { getOpenBdIssues } from "./sync.js";
+
+/**
+ * Register the todo-bd-sync extension
+ */
+export function registerTodoBdSync(
+	pi: ExtensionAPI,
+	config?: TodoBdSyncConfig,
+): TodoBdSync | null {
+	const deps = getDependencyStatus();
+
+	// Check if bd is installed
+	if (!deps.bd.installed) {
+		return null;
+	}
+
+	// Log dependency status for debugging (only if debug mode)
+	if (config?.debug) {
+		logDependencyStatus();
+	}
+
+	// Create and start sync
+	const sync = createTodoBdSync(pi, {
+		autoInjectPrompt: true,
+		syncDirection: "both",
+		loadOnSessionStart: true,
+		...config,
+	});
+
+	sync.start();
+
+	// Start todo reminder (DISABLED by default — Phase 1 emergency containment)
+	// Reminder spam was causing transcript growth. Enable only after proper task scoping.
+	const reminder = createCustomReminder(
+		pi,
+		() => {
+			// Get remaining todos from bd
+			const issues = getOpenBdIssues();
+			return issues
+				.filter((i) => i.status !== "closed")
+				.map((i) => ({
+					id: i.id,
+					title: i.title,
+					status: i.status,
+				}));
+		},
+		{
+			autoRemind: false, // DISABLED — fix reminder spam before re-enabling
+			minPendingTasks: 1,
+		},
+	);
+	reminder.start();
+
+	return sync;
+}
+
+// Default export for pi extension loading
+export default function todoBdSyncExtension(pi: ExtensionAPI): void {
+	registerTodoBdSync(pi, { debug: false });
+}

package/packages/todo-bd-sync/src/index.ts

@@ -0,0 +1,401 @@
+/**
+ * todo-bd-sync - Two-way sync between rpiv-todo and bd
+ *
+ * This package provides:
+ * 1. Detection of rpiv-todo installation
+ * 2. Two-way sync between rpiv-todo tasks and bd issues
+ * 3. Auto-enable functionality via prompt injection
+ *
+ * Usage:
+ *   import { createTodoBdSync } from "@moocoding/todo-bd-sync";
+ *
+ *   const sync = createTodoBdSync(pi);
+ *   sync.start();
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getDependencyStatus, logDependencyStatus } from "./detector.js";
+import {
+	syncTodoToBd,
+	isBdCommand,
+	extractBdIdFromCommand,
+	getMappingRegistry,
+	getOpenBdIssues,
+	parseBdCreateOutput,
+} from "./sync.js";
+import type { TodoTask } from "./types.js";
+
+// Configuration
+export interface TodoBdSyncConfig {
+	/** Auto-inject "todo-list" to prompt (default: true) */
+	autoInjectPrompt?: boolean;
+	/** Sync direction: both, todoOnly, bdOnly (default: both) */
+	syncDirection?: "both" | "todoOnly" | "bdOnly";
+	/** Load existing bd issues on session start (default: true) */
+	loadOnSessionStart?: boolean;
+	/** Debug logging (default: false) */
+	debug?: boolean;
+}
+
+const DEFAULT_CONFIG: Required<TodoBdSyncConfig> = {
+	autoInjectPrompt: true,
+	syncDirection: "both",
+	loadOnSessionStart: true,
+	debug: false,
+};
+
+interface ToolExecutionEvent {
+	toolName: string;
+	args?: Record<string, unknown>;
+	result?: unknown;
+	isError?: boolean;
+}
+
+/**
+ * Create a todo-bd sync instance
+ */
+export function createTodoBdSync(
+	pi: ExtensionAPI,
+	config: TodoBdSyncConfig = {},
+): TodoBdSync {
+	const finalConfig = { ...DEFAULT_CONFIG, ...config };
+	return new TodoBdSync(pi, finalConfig);
+}
+
+/**
+ * TodoBdSync class - handles two-way sync between rpiv-todo and bd
+ */
+export class TodoBdSync {
+	private pi: ExtensionAPI;
+	private config: Required<TodoBdSyncConfig>;
+	private enabled: boolean = false;
+	private sessionStartLoaded: boolean = false;
+
+	constructor(pi: ExtensionAPI, config: Required<TodoBdSyncConfig>) {
+		this.pi = pi;
+		this.config = config;
+	}
+
+	/**
+	 * Initialize and start the sync
+	 */
+	start(): void {
+		// Check dependencies
+		const deps = getDependencyStatus();
+
+		if (!deps.bd.installed) {
+			if (this.config.debug) {
+				console.log("[DEBUG todo-bd-sync] bd CLI not installed, skipping");
+			}
+			return;
+		}
+
+		if (!deps.rpivTodo.installed && !this.shouldUseFallback()) {
+			if (this.config.debug) {
+				console.log(
+					"[todo-bd-sync] rpiv-todo not installed, using fallback mode",
+				);
+			}
+			// In fallback mode, we would implement our own todo overlay
+			// For now, we'll just note that it's not available
+		}
+
+		this.enabled = true;
+
+		if (this.config.debug) {
+			logDependencyStatus();
+		}
+
+		// Register event handlers
+		this.registerHandlers();
+
+		if (this.config.debug) {
+			console.log("[DEBUG todo-bd-sync] Started with config:", this.config);
+		}
+	}
+
+	/**
+	 * Register event handlers
+	 */
+	private registerHandlers(): void {
+		// Session start - load existing bd issues
+		if (this.config.loadOnSessionStart) {
+			this.pi.on(
+				"session_start",
+				async (_event: unknown, ctx: { hasUI?: boolean }) => {
+					if (!this.enabled || this.sessionStartLoaded) return;
+					await this.handleSessionStart(ctx);
+					this.sessionStartLoaded = true;
+				},
+			);
+		}
+
+		// Tool execution end - sync changes
+		this.pi.on("tool_execution_end", async (event: ToolExecutionEvent) => {
+			if (!this.enabled) return;
+
+			if (event.toolName === "todo") {
+				// Todo tool was called - sync to bd
+				if (
+					this.config.syncDirection === "both" ||
+					this.config.syncDirection === "todoOnly"
+				) {
+					this.handleTodoExecution(event);
+				}
+			}
+
+			if (event.toolName === "bash" && event.args?.command) {
+				// Bash command executed - check if it's a bd command
+				if (
+					this.config.syncDirection === "both" ||
+					this.config.syncDirection === "bdOnly"
+				) {
+					this.handleBashExecution(event);
+				}
+			}
+		});
+
+		// Register slash command for manual sync
+		this.pi.registerCommand("bd-todo-sync", {
+			description: "Sync todo list with bd issues",
+			handler: async (_args: unknown, ctx) => {
+				if (!this.enabled) {
+					ctx.ui.notify(
+						"[todo-bd-sync] Not enabled - dependencies missing",
+						"warning",
+					);
+					return;
+				}
+
+				// Sync all todos to bd
+				const mappings = getMappingRegistry().getAll();
+				ctx.ui.notify(
+					`[todo-bd-sync] Syncing ${mappings.length} mapped tasks to bd...`,
+					"info",
+				);
+
+				// Force refresh bd issues
+				const issues = getOpenBdIssues();
+				ctx.ui.notify(
+					`[todo-bd-sync] Found ${issues.length} open bd issues`,
+					"info",
+				);
+			},
+		});
+
+		// Register slash command to check status
+		this.pi.registerCommand("bd-todo-status", {
+			description: "Show todo-bd sync status",
+			handler: async (_args: unknown, ctx) => {
+				const deps = getDependencyStatus();
+				const mappings = getMappingRegistry().getAll();
+
+				const lines = [
+					"=== todo-bd-sync Status ===",
+					`rpiv-todo: ${deps.rpivTodo.installed ? "installed" : "not installed"}`,
+					`bd: ${deps.bd.installed ? "installed (" + deps.bd.version + ")" : "not installed"}`,
+					`Mappings: ${mappings.length}`,
+					`Enabled: ${this.enabled}`,
+				];
+
+				ctx.ui.notify(lines.join("\n"), "info");
+			},
+		});
+	}
+
+	/**
+	 * Handle todo tool execution
+	 */
+	private handleTodoExecution(event: ToolExecutionEvent): void {
+		if (event.isError) return;
+
+		// Extract action and task from event
+		const action = event.args?.action as string | undefined;
+		const task = this.extractTaskFromEvent(event);
+
+		if (!action || !task) {
+			if (this.config.debug) {
+				console.log("[DEBUG todo-bd-sync] Could not extract action/task from event");
+			}
+			return;
+		}
+
+		// Sync to bd
+		const result = syncTodoToBd(action, task);
+
+		if (this.config.debug) {
+			console.log("[DEBUG todo-bd-sync] Todo sync result:", result);
+		}
+
+		// Notify if sync failed
+		if (!result.success && this.config.debug) {
+			console.error("[DEBUG todo-bd-sync] Sync failed:", result.error);
+		}
+	}
+
+	/**
+	 * Handle bash command execution
+	 */
+	private handleBashExecution(event: ToolExecutionEvent): void {
+		const command = event.args?.command as string;
+
+		if (!isBdCommand(command)) {
+			return;
+		}
+
+		if (this.config.debug) {
+			console.log("[DEBUG todo-bd-sync] Detected bd command:", command);
+		}
+
+		// Check for bd create
+		if (command.includes("bd create")) {
+			this.handleBdCreate(event);
+		}
+
+		// Check for bd update
+		if (command.includes("bd update") || command.includes("bd close")) {
+			this.handleBdUpdate(event);
+		}
+	}
+
+	/**
+	 * Handle bd create command
+	 */
+	private handleBdCreate(event: ToolExecutionEvent): void {
+		const result = event.result;
+		if (!result || typeof result !== "object") return;
+
+		// Extract created bd issue info
+		const output = JSON.stringify(result);
+		const parsed = parseBdCreateOutput(output);
+
+		if (parsed && parsed.bdId) {
+			if (this.config.debug) {
+				console.log(`[todo-bd-sync] Created bd issue: ${parsed.bdId}`);
+			}
+			// Note: At this point we don't have a todo ID yet
+			// The sync will happen when the todo tool is called next
+		}
+	}
+
+	/**
+	 * Handle bd update/close command
+	 */
+	private handleBdUpdate(event: ToolExecutionEvent): void {
+		const command = event.args?.command as string;
+		const bdId = extractBdIdFromCommand(command);
+
+		if (!bdId) return;
+
+		const mappings = getMappingRegistry();
+		const mapping = mappings.getByBdId(bdId);
+
+		if (mapping) {
+			if (this.config.debug) {
+				console.log(
+					`[todo-bd-sync] Updated bd issue ${bdId}, mapped to todo ${mapping.todoId}`,
+				);
+			}
+			mappings.updateLastSync(mapping.todoId);
+		}
+	}
+
+	/**
+	 * Handle session start
+	 */
+	private async handleSessionStart(ctx: { hasUI?: boolean }): Promise<void> {
+		if (!ctx.hasUI) return;
+
+		try {
+			// Get all open bd issues
+			const issues = getOpenBdIssues();
+
+			if (this.config.debug) {
+				console.log(
+					`[todo-bd-sync] Session start: found ${issues.length} open bd issues`,
+				);
+			}
+
+			// Notify user about sync status
+			if (issues.length > 0) {
+				ctx.hasUI && this.pi; // Just to use ctx
+			}
+		} catch (error) {
+			if (this.config.debug) {
+				console.error("[DEBUG todo-bd-sync] Session start sync failed:", error);
+			}
+		}
+	}
+
+	/**
+	 * Extract task from todo tool event
+	 */
+	private extractTaskFromEvent(event: ToolExecutionEvent): TodoTask | null {
+		// The event structure depends on how pi-coding-agent exposes tool results
+		// This is a simplified extraction
+
+		const result = event.result as Record<string, unknown> | undefined;
+		if (!result) return null;
+
+		// Try to extract task from result
+		const task = result.task as TodoTask | undefined;
+		if (task && typeof task.id === "number") {
+			return task;
+		}
+
+		// Try to extract from args
+		const args = event.args as Record<string, unknown> | undefined;
+		if (args) {
+			const id = args.id as number | undefined;
+			const subject = args.subject as string | undefined;
+			const status = args.status as TodoTask["status"] | undefined;
+			const description = args.description as string | undefined;
+
+			if (id !== undefined) {
+				return {
+					id,
+					subject: subject || "",
+					status: status || "pending",
+					description,
+					metadata: {},
+				};
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Check if we should use fallback mode (custom todo implementation)
+	 */
+	private shouldUseFallback(): boolean {
+		// Check if there's a config option for fallback
+		// For now, return false (we don't have a fallback implementation yet)
+		return false;
+	}
+
+	/**
+	 * Get the prompt injection string
+	 * This is added to the system prompt to trigger rpiv-todo
+	 */
+	static getPromptInjection(): string {
+		return "todo-list";
+	}
+
+	/**
+	 * Check if sync is enabled
+	 */
+	isEnabled(): boolean {
+		return this.enabled;
+	}
+}
+
+// Default export
+export default createTodoBdSync;
+
+export type {
+	TodoTask,
+	BdIssue,
+	SyncResult,
+	IdMappingRegistry,
+} from "./types.js";