pi-onedev-toolkit 0.1.0 → 0.2.0

package/src/extension.ts

@@ -1,18 +1,34 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 import {
 	formatContext,
-	probeOneDevContext,
+	OneDevContextManager,
 	type OneDevSessionContext,
 } from "./context.js";
+import { MutationApprovalManager } from "./mutation-approvals.js";
+import { OneDevSourceWatchManager } from "./source-watch.js";
 import {
 	registerOnedevTools,
 	type OnedevToolController,
 } from "./tools/index.js";
 import type { ToolDeps } from "./tools/common.js";
 
+const SETTINGS_ENTRY = "onedev-settings";
+
+interface OnedevSettings {
+	footerStatus: boolean;
+}
+
 export default function onedevExtension(pi: ExtensionAPI): void {
 	let context: OneDevSessionContext | undefined;
 	let controller: OnedevToolController | undefined;
+	let footerStatus = true;
+	const contextManager = new OneDevContextManager((command, args, options) =>
+		pi.exec(command, args, options),
+	);
+	const approvals = new MutationApprovalManager();
 
 	const deps: ToolDeps = {
 		exec: (command, args, options) => pi.exec(command, args, options),
@@ -20,6 +36,11 @@ export default function onedevExtension(pi: ExtensionAPI): void {
 			if (!context) throw new Error("OneDev extension is still initializing");
 			return context;
 		},
+		refreshContext: async (options) => {
+			context = await contextManager.refresh(options);
+			return context;
+		},
+		approvals,
 	};
 
 	const applyStatus = (ctx: {
@@ -27,28 +48,43 @@ export default function onedevExtension(pi: ExtensionAPI): void {
 		ui: { setStatus: (key: string, value: string | undefined) => void };
 	}): void => {
 		if (!ctx.hasUI) return;
-		if (context?.status === "ready" && context.project) {
+		if (footerStatus && context?.status === "ready" && context.project) {
 			ctx.ui.setStatus("onedev", `onedev: ${context.project}`);
 		} else {
 			ctx.ui.setStatus("onedev", undefined);
 		}
 	};
 
+	const restoreSettings = (ctx: ExtensionContext): void => {
+		footerStatus = true;
+		for (const entry of ctx.sessionManager.getBranch()) {
+			if (entry.type !== "custom" || entry.customType !== SETTINGS_ENTRY) continue;
+			const saved = entry.data as Partial<OnedevSettings> | undefined;
+			if (typeof saved?.footerStatus === "boolean") {
+				footerStatus = saved.footerStatus;
+			}
+		}
+	};
+
 	pi.registerCommand("od-context", {
 		description: "Show the active OneDev server, project, and user",
-		handler: async (_args, ctx) => {
+		handler: (_args, ctx) => {
 			if (!context) throw new Error("OneDev extension is still initializing");
 			ctx.ui.notify(
 				formatContext(context),
 				context.status === "ready" ? "info" : "warning",
 			);
+			return Promise.resolve();
 		},
 	});
 
 	pi.registerCommand("od-health", {
 		description: "Re-check the tod CLI configuration and OneDev server",
 		handler: async (_args, ctx) => {
-			context = await probeOneDevContext(deps.exec, ctx.cwd);
+			context = await contextManager.refresh({
+				verifyAuth: true,
+				force: true,
+			});
 			applyStatus(ctx);
 			ctx.ui.notify(
 				formatContext(context),
@@ -57,16 +93,70 @@ export default function onedevExtension(pi: ExtensionAPI): void {
 		},
 	});
 
-	controller = registerOnedevTools(pi, deps);
+	pi.registerCommand("od-settings", {
+		description: "Configure OneDev TUI settings",
+		handler: async (_args, ctx) => {
+			if (ctx.mode !== "tui") {
+				ctx.ui.notify("/od-settings requires TUI mode", "error");
+				return;
+			}
+			const selected = await ctx.ui.select(
+				`OneDev footer status (currently ${footerStatus ? "enabled" : "disabled"})`,
+				["Enabled", "Disabled"],
+			);
+			if (!selected) return;
+			const enabled = selected === "Enabled";
+			if (enabled !== footerStatus) {
+				pi.appendEntry<OnedevSettings>(SETTINGS_ENTRY, {
+					footerStatus: enabled,
+				});
+				footerStatus = enabled;
+				applyStatus(ctx);
+			}
+			ctx.ui.notify(
+				`OneDev footer status ${enabled ? "enabled" : "disabled"}`,
+				"info",
+			);
+		},
+	});
+
+	const watches = new OneDevSourceWatchManager(
+		{ exec: deps.exec, context: deps.context },
+		(emission) => {
+			pi.sendMessage(
+				{
+					customType: "onedev-watch",
+					content: emission.message,
+					display: true,
+					details: emission.details,
+				},
+				{ triggerTurn: true, deliverAs: "steer" },
+			);
+		},
+	);
+	controller = registerOnedevTools(pi, deps, watches);
 
 	pi.on("session_start", async (_event, ctx) => {
+		watches.clear();
 		controller?.reset();
-		context = await probeOneDevContext(deps.exec, ctx.cwd);
+		approvals.resetSession();
+		restoreSettings(ctx);
+		contextManager.reset(ctx.cwd);
+		context = await contextManager.refresh();
+		applyStatus(ctx);
+	});
+
+	pi.on("session_tree", (_event, ctx) => {
+		watches.clear();
+		restoreSettings(ctx);
 		applyStatus(ctx);
 	});
 
-	pi.on("session_shutdown", async (_event, ctx) => {
+	pi.on("session_shutdown", (_event, ctx) => {
 		if (ctx.hasUI) ctx.ui.setStatus("onedev", undefined);
+		approvals.resetSession();
+		watches.clear();
+		contextManager.clear();
 		context = undefined;
 	});
 }

package/src/mutation-approvals.ts

@@ -0,0 +1,130 @@
+import { join } from "node:path";
+import {
+	getAgentDir,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import type { OneDevSessionContext } from "./context.js";
+import {
+	readAllowedMutationScopes,
+	saveAllowedMutationScope,
+} from "./config-storage.js";
+
+const ALLOW_ONCE = "Allow once";
+const ALLOW_SESSION = "Allow for this session";
+const ALLOW_SAVED = "Always allow for this server and project";
+const CANCEL = "Cancel";
+
+export const MUTATION_OPERATIONS = [
+	"issue.create",
+	"issue.edit",
+	"issue.change_state",
+	"issue.add_comment",
+	"issue.link",
+	"issue.log_work",
+	"issue.create_branch",
+	"issue.checkout",
+	"pull.create",
+	"pull.edit",
+	"pull.add_comment",
+	"pull.add_code_comment",
+	"pull.reply_code_comment",
+	"pull.resolve_code_comment",
+	"pull.unresolve_code_comment",
+	"pull.approve",
+	"pull.request_changes",
+	"pull.merge",
+	"pull.discard",
+	"pull.checkout",
+	"build.run",
+	"build.check_spec",
+] as const;
+
+export type MutationOperation = (typeof MUTATION_OPERATIONS)[number];
+
+export interface MutationApprovalRequest {
+	operation: MutationOperation;
+	title: string;
+	details: string;
+	signal?: AbortSignal;
+}
+
+function scopeKey(
+	context: OneDevSessionContext,
+	operation: MutationOperation,
+): string {
+	return JSON.stringify([context.serverUrl, context.project, operation]);
+}
+
+export class MutationApprovalManager {
+	readonly #session = new Set<string>();
+
+	constructor(
+		readonly configPath = join(getAgentDir(), "onedev-toolkit.json"),
+	) {}
+
+	resetSession(): void {
+		this.#session.clear();
+	}
+
+	async confirm(
+		context: OneDevSessionContext,
+		ctx: ExtensionContext,
+		request: MutationApprovalRequest,
+	): Promise<void> {
+		if (request.signal?.aborted) {
+			throw request.signal.reason instanceof Error
+				? request.signal.reason
+				: new Error("OneDev mutation cancelled");
+		}
+		if (context.status !== "ready" || !context.serverUrl || !context.project) {
+			throw new Error("OneDev mutation requires a ready server and project context");
+		}
+
+		const scope = scopeKey(context, request.operation);
+		if (this.#session.has(scope)) return;
+		try {
+			const savedScopes = await readAllowedMutationScopes(this.configPath);
+			if (savedScopes.includes(scope)) return;
+		} catch (error) {
+			if (ctx.hasUI) {
+				ctx.ui.notify(
+					`Could not read saved OneDev approvals: ${error instanceof Error ? error.message : String(error)}`,
+					"warning",
+				);
+			}
+		}
+
+		if (!ctx.hasUI) {
+			throw new Error(
+				`${request.operation} requires interactive confirmation; run it in TUI mode or save the scoped approval there first`,
+			);
+		}
+		const prompt = [
+			request.title,
+			request.details,
+			`Server: ${context.serverUrl}`,
+			`Project: ${context.project}`,
+		].join("\n");
+		const choice = await ctx.ui.select(
+			prompt,
+			[ALLOW_ONCE, ALLOW_SESSION, ALLOW_SAVED, CANCEL],
+			{ signal: request.signal },
+		);
+		if (!choice || choice === CANCEL) {
+			throw new Error(`${request.operation} cancelled by user`);
+		}
+		if (choice === ALLOW_ONCE) return;
+
+		this.#session.add(scope);
+		if (choice === ALLOW_SAVED) {
+			try {
+				await saveAllowedMutationScope(this.configPath, scope);
+			} catch (error) {
+				ctx.ui.notify(
+					`Approval applies to this session only; it could not be saved: ${error instanceof Error ? error.message : String(error)}`,
+					"warning",
+				);
+			}
+		}
+	}
+}