pi-harness-runtime 0.9.25 → 1.1.0

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";

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

@@ -0,0 +1,322 @@
+/**
+ * Two-way sync between rpiv-todo and bd
+ *
+ * This module handles:
+ * 1. rpiv-todo → bd: When todo tool is called, sync to bd
+ * 2. bd → rpiv-todo: When bd commands are executed, sync to todo
+ * 3. Session start: Load existing bd issues into todo
+ */
+
+import { execSync } from "node:child_process";
+import type { TodoTask, BdIssue, SyncResult } from "./types.js";
+import { IdMappingRegistry, STATUS_MAP } from "./types.js";
+
+// Mapping registry singleton
+const mappingRegistry = new IdMappingRegistry();
+
+/**
+ * Execute a bd command and return the output
+ */
+export function execBdCommand(command: string): string {
+	try {
+		return execSync(command, {
+			encoding: "utf8",
+			timeout: 10000,
+			cwd: process.cwd(),
+		});
+	} catch (error: unknown) {
+		const err = error as { message?: string; stderr?: string };
+		return err.stderr || err.message || "";
+	}
+}
+
+/**
+ * Extract bd ID from command or output
+ */
+export function extractBdId(input: string): string | null {
+	// Match patterns like: bd-a1b2, bd-a1b2.1, BD-a1b2, etc.
+	const match = input.match(/bd-[a-z0-9]+(\.[0-9]+)?/i);
+	return match ? match[0].toLowerCase() : null;
+}
+
+/**
+ * Get all open bd issues
+ */
+export function getOpenBdIssues(): BdIssue[] {
+	try {
+		const output = execBdCommand("bd ready --json");
+		const issues = JSON.parse(output);
+		return issues.map((issue: Record<string, unknown>) => ({
+			id: issue.id as string,
+			title: issue.title as string,
+			status: issue.status as BdIssue["status"],
+			priority: issue.priority as number | undefined,
+			createdAt: issue.created_at as string | undefined,
+			updatedAt: issue.updated_at as string | undefined,
+		}));
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Get all bd issues (including closed)
+ */
+export function getAllBdIssues(): BdIssue[] {
+	try {
+		const output = execBdCommand("bd list --json");
+		const issues = JSON.parse(output);
+		return issues.map((issue: Record<string, unknown>) => ({
+			id: issue.id as string,
+			title: issue.title as string,
+			status: issue.status as BdIssue["status"],
+			priority: issue.priority as number | undefined,
+			createdAt: issue.created_at as string | undefined,
+			updatedAt: issue.updated_at as string | undefined,
+		}));
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Create a bd issue from a todo task
+ */
+export function createBdFromTodo(task: TodoTask): SyncResult {
+	const priority = inferPriorityFromTask(task);
+
+	try {
+		const command = `bd create "${escapeShell(task.subject)}" -p ${priority} --json`;
+		const output = execBdCommand(command);
+
+		// Try to extract bd ID from output
+		let bdId = extractBdId(output);
+
+		// If not found in output, try to get it from the created issue
+		if (!bdId) {
+			const issues = getOpenBdIssues();
+			// Match by title (not ideal but fallback)
+			const match = issues.find((i) => i.title === task.subject);
+			bdId = match?.id || null;
+		}
+
+		if (bdId) {
+			mappingRegistry.set(task.id, bdId);
+		}
+
+		return {
+			success: true,
+			direction: "todo_to_bd",
+			taskId: task.id,
+			bdId: bdId || undefined,
+			action: "create",
+		};
+	} catch (error: unknown) {
+		return {
+			success: false,
+			direction: "todo_to_bd",
+			taskId: task.id,
+			action: "create",
+			error: error instanceof Error ? error.message : String(error),
+		};
+	}
+}
+
+/**
+ * Update a bd issue from a todo task update
+ */
+export function updateBdFromTodo(task: TodoTask): SyncResult {
+	const mapping = mappingRegistry.getByTodoId(task.id);
+	if (!mapping) {
+		// No mapping exists, create new bd issue
+		return createBdFromTodo(task);
+	}
+
+	try {
+		const bdStatus = STATUS_MAP[task.status];
+		const command = `bd update ${mapping.bdId} --status ${bdStatus} --json`;
+		execBdCommand(command);
+
+		// Update last sync timestamp
+		mappingRegistry.updateLastSync(task.id);
+
+		return {
+			success: true,
+			direction: "todo_to_bd",
+			taskId: task.id,
+			bdId: mapping.bdId,
+			action: "update",
+		};
+	} catch (error: unknown) {
+		return {
+			success: false,
+			direction: "todo_to_bd",
+			taskId: task.id,
+			bdId: mapping.bdId,
+			action: "update",
+			error: error instanceof Error ? error.message : String(error),
+		};
+	}
+}
+
+/**
+ * Close/delete a bd issue when todo is deleted
+ */
+export function closeBdFromTodo(task: TodoTask): SyncResult {
+	const mapping = mappingRegistry.getByTodoId(task.id);
+	if (!mapping) {
+		return {
+			success: true, // Nothing to close
+			direction: "todo_to_bd",
+			taskId: task.id,
+			action: "delete",
+		};
+	}
+
+	try {
+		const command = `bd close ${mapping.bdId} --reason "Closed from todo" --json`;
+		execBdCommand(command);
+
+		// Remove mapping
+		mappingRegistry.delete(task.id);
+
+		return {
+			success: true,
+			direction: "todo_to_bd",
+			taskId: task.id,
+			bdId: mapping.bdId,
+			action: "delete",
+		};
+	} catch (error: unknown) {
+		return {
+			success: false,
+			direction: "todo_to_bd",
+			taskId: task.id,
+			bdId: mapping.bdId,
+			action: "delete",
+			error: error instanceof Error ? error.message : String(error),
+		};
+	}
+}
+
+/**
+ * Infer priority from task metadata
+ */
+function inferPriorityFromTask(task: TodoTask): number {
+	if (task.metadata?.priority !== undefined) {
+		return task.metadata.priority as number;
+	}
+	// Default priority 2 (medium)
+	return 2;
+}
+
+/**
+ * Parse bd create output to extract created issue
+ */
+export function parseBdCreateOutput(
+	output: string,
+): { bdId: string; title: string } | null {
+	try {
+		const json = JSON.parse(output);
+		if (json.id) {
+			return {
+				bdId: json.id,
+				title: json.title || "",
+			};
+		}
+	} catch {
+		// Not JSON, try text extraction
+	}
+
+	const bdId = extractBdId(output);
+	if (bdId) {
+		return { bdId, title: "" };
+	}
+
+	return null;
+}
+
+/**
+ * Detect if a bash command is a bd command
+ */
+export function isBdCommand(command: string): boolean {
+	const trimmed = command.trim().toLowerCase();
+	return (
+		trimmed.startsWith("bd ") ||
+		trimmed.startsWith("beads ") ||
+		trimmed.includes("bd create") ||
+		trimmed.includes("bd update") ||
+		trimmed.includes("bd close") ||
+		trimmed.includes("bd ready") ||
+		trimmed.includes("bd list")
+	);
+}
+
+/**
+ * Extract bd ID from a command
+ */
+export function extractBdIdFromCommand(command: string): string | null {
+	return extractBdId(command);
+}
+
+/**
+ * Get the mapping registry for external access
+ */
+export function getMappingRegistry(): IdMappingRegistry {
+	return mappingRegistry;
+}
+
+/**
+ * Clear all mappings (for testing or reset)
+ */
+export function clearMappings(): void {
+	mappingRegistry.clear();
+}
+
+/**
+ * Escape shell arguments
+ */
+function escapeShell(str: string): string {
+	// Escape double quotes and backslashes
+	return str.replace(/["\\]/g, "\\$&");
+}
+
+/**
+ * Sync from todo action to bd
+ * Called when todo tool is executed
+ */
+export function syncTodoToBd(action: string, task: TodoTask): SyncResult {
+	switch (action) {
+		case "create":
+			return createBdFromTodo(task);
+		case "update":
+			return updateBdFromTodo(task);
+		case "delete":
+			return closeBdFromTodo(task);
+		default:
+			return {
+				success: true,
+				direction: "todo_to_bd",
+				taskId: task.id,
+				action,
+			};
+	}
+}
+
+/**
+ * Parse todo task from tool event
+ * This is a simplified parser - actual implementation depends on event structure
+ */
+export function parseTodoTaskFromEvent(
+	event: Record<string, unknown>,
+): TodoTask | null {
+	// The event structure depends on how pi-coding-agent exposes it
+	// This is a placeholder - actual implementation needs event inspection
+
+	const task = event.task as TodoTask | undefined;
+	if (!task || typeof task.id !== "number") {
+		return null;
+	}
+
+	return task;
+}