@buihongduc132/pi-acp-agents 0.3.1

package/src/settings/agents-command.ts

@@ -0,0 +1,138 @@
+/**
+ * agents-command.ts — Handler for /acp agents <add|remove|list|config>.
+ *
+ * Extracted from index.ts for testability. Pure logic + ctx.ui.notify calls.
+ * No pi.registerCommand dependency.
+ */
+
+import {
+	loadConfig,
+	saveConfig,
+	upsertAgentServer,
+	removeAgentServer,
+	AGENT_PRESETS,
+} from "../config/config.js";
+import type { SettingsUI } from "./agent-config-tui.js";
+
+// Re-export so index.ts can import from here
+export { openAgentConfigTUI } from "./agent-config-tui.js";
+
+// ── Types ────────────────────────────────────────────────
+
+export interface AgentsCommandCtx {
+	ui: {
+		notify(message: string, type: "info" | "warning" | "error"): void;
+	};
+}
+
+// ── Handler ──────────────────────────────────────────────
+
+/**
+ * Handle /acp agents subcommands.
+ *
+ * @param tokens - Parsed tokens after "agents" (e.g. ["add", "gemini", "--command", "gemini"])
+ * @param ctx - Context with ui.notify
+ */
+export async function handleAgentsCommand(
+	tokens: string[],
+	ctx: AgentsCommandCtx,
+): Promise<void> {
+	const [subcommand] = tokens;
+
+	if (subcommand === "config") {
+		const { openAgentConfigTUI } = await import("./agent-config-tui.js");
+		try {
+			await openAgentConfigTUI(ctx.ui as unknown as SettingsUI);
+		} catch (e) {
+			ctx.ui.notify("Failed to open agent config TUI.", "error");
+		}
+		return;
+	}
+
+	if (subcommand === "list") {
+		const cfg = loadConfig();
+		const agentLines = Object.entries(cfg.agent_servers)
+			.map(([name, a]) => {
+				const isDefault = cfg.defaultAgent === name ? " (default)" : "";
+				return `  ${name}: ${a.command} ${(a.args ?? []).join(" ")}${isDefault}`;
+			})
+			.join("\n");
+		ctx.ui.notify(
+			`Agent Servers:\n${agentLines || "  (none)"}\n\nDefault: ${cfg.defaultAgent ?? "none"}`,
+			"info",
+		);
+		return;
+	}
+
+	if (subcommand === "add") {
+		const name = tokens[1];
+		if (!name) {
+			ctx.ui.notify(
+				"Usage: /acp agents add <name> [--command <cmd>] [--args <a1,a2>] [--model <m>]",
+				"error",
+			);
+			return;
+		}
+		// Parse optional flags
+		let command = "";
+		let args: string[] = [];
+		let model = "";
+		for (let i = 2; i < tokens.length; i++) {
+			if (tokens[i] === "--command" && tokens[i + 1]) {
+				command = tokens[++i]!;
+			} else if (tokens[i] === "--args" && tokens[i + 1]) {
+				args = tokens[++i]!.split(",");
+			} else if (tokens[i] === "--model" && tokens[i + 1]) {
+				model = tokens[++i]!;
+			}
+		}
+		// If no command specified, try preset
+		if (!command) {
+			const preset = AGENT_PRESETS[name]?.();
+			if (!preset) {
+				ctx.ui.notify(
+					`No command specified and "${name}" is not a known preset. Use --command <cmd>.`,
+					"error",
+				);
+				return;
+			}
+			command = preset.command ?? "";
+			args = preset.args ?? [];
+		}
+		try {
+			const cfg = loadConfig();
+			const updated = upsertAgentServer(cfg, name, {
+				command,
+				args,
+				default_model: model || undefined,
+			});
+			saveConfig(updated);
+			ctx.ui.notify(
+				`Agent "${name}" added: ${command} ${args.join(" ")}`,
+				"info",
+			);
+		} catch (e) {
+			ctx.ui.notify(
+				`Failed to add agent: ${(e as Error).message}`,
+				"error",
+			);
+		}
+		return;
+	}
+
+	if (subcommand === "remove") {
+		const name = tokens[1];
+		if (!name) {
+			ctx.ui.notify("Usage: /acp agents remove <name>", "error");
+			return;
+		}
+		const cfg = loadConfig();
+		const updated = removeAgentServer(cfg, name);
+		saveConfig(updated);
+		ctx.ui.notify(`Agent "${name}" removed.`, "info");
+		return;
+	}
+
+	// Default: show help
+	ctx.ui.notify("/acp agents <add|remove|list|config>", "info");
+}

package/src/settings/config.ts

@@ -0,0 +1,201 @@
+/**
+ * ACP tool enable/disable settings.
+ *
+ * Pattern copied from pi-gitnexus-local/config.ts:
+ * - Global config at ~/.pi/acp-agents/settings.json
+ * - Local (project) config at <cwd>/.pi/acp-agents/settings.json
+ * - deepMerge(global, local) with local overriding global per key
+ * - DEFAULT_SETTINGS has all tools enabled
+ * - Unknown tool names are ignored gracefully
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { createNoopLogger } from "../logger.js";
+
+const log = createNoopLogger();
+
+// ── Tool names ──────────────────────────────────────────
+
+export const ACP_TOOL_NAMES = [
+	"acp_prompt",
+	"acp_status",
+	"acp_session_new",
+	"acp_session_load",
+	"acp_session_set_model",
+	"acp_session_set_mode",
+	"acp_cancel",
+	"acp_session_list",
+	"acp_session_shutdown",
+	"acp_session_kill",
+	"acp_prune",
+	"acp_delegate",
+	"acp_broadcast",
+	"acp_compare",
+	"acp_task_create",
+	"acp_task_list",
+	"acp_task_get",
+	"acp_task_assign",
+	"acp_task_set_status",
+	"acp_task_dependency_add",
+	"acp_task_dependency_remove",
+	"acp_task_clear",
+	"acp_message_send",
+	"acp_message_list",
+	"acp_plan_request",
+	"acp_plan_resolve",
+	"acp_model_policy_get",
+	"acp_model_policy_check",
+	"acp_doctor",
+	"acp_runtime_info",
+	"acp_env",
+	"acp_event_log",
+	"acp_cleanup",
+	"acp_worker_spawn",
+	"acp_worker_list",
+	"acp_worker_steer",
+	"acp_worker_shutdown",
+	"acp_worker_kill",
+	"acp_worker_prune",
+] as const;
+
+export type AcpToolName = (typeof ACP_TOOL_NAMES)[number];
+
+// ── Types ───────────────────────────────────────────────
+
+export interface AcpToolSettings {
+	tools: Record<AcpToolName, { enabled: boolean }>;
+}
+
+export type AcpToolSettingsInput = {
+	tools?: Partial<Record<string, { enabled: boolean }>>;
+};
+
+// ── Defaults ────────────────────────────────────────────
+
+function buildDefaultTools(): Record<AcpToolName, { enabled: boolean }> {
+	const tools = {} as Record<AcpToolName, { enabled: boolean }>;
+	for (const name of ACP_TOOL_NAMES) {
+		tools[name] = { enabled: true };
+	}
+	return tools;
+}
+
+export const DEFAULT_SETTINGS: AcpToolSettings = {
+	tools: buildDefaultTools(),
+};
+
+// ── Deep merge (copied from pi-gitnexus-local/config.ts) ──
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export function deepMergeSettings<T>(base: T, override: unknown): T {
+	if (!override) return structuredClone(base);
+	if (Array.isArray(base) || Array.isArray(override)) {
+		return structuredClone(override as T);
+	}
+	if (isPlainObject(base) && isPlainObject(override)) {
+		const result: Record<string, unknown> = { ...base };
+		for (const [key, value] of Object.entries(override)) {
+			const current = result[key];
+			if (isPlainObject(current) && isPlainObject(value)) {
+				result[key] = deepMergeSettings(current, value);
+			} else {
+				result[key] = structuredClone(value);
+			}
+		}
+		return result as T;
+	}
+	return structuredClone(override as T);
+}
+
+// ── Config file I/O ─────────────────────────────────────
+
+export const GLOBAL_SETTINGS_PATH = resolve(
+	homedir(),
+	".pi",
+	"acp-agents",
+	"settings.json",
+);
+
+export function getProjectSettingsPath(cwd: string): string {
+	return resolve(cwd, ".pi", "acp-agents", "settings.json");
+}
+
+function loadJsonLike(path: string): AcpToolSettingsInput | null {
+	if (!existsSync(path)) return null;
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const stripped = raw.replace(/^\s*\/\/.*$/gm, "").trim();
+		if (!stripped) return null;
+		return JSON.parse(stripped) as AcpToolSettingsInput;
+	} catch (e) {
+		// JSON parse failed for settings file — return null to use defaults
+		log.debug("settings loadJsonLike parse failed", e);
+		return null;
+	}
+}
+
+export function readGlobalSettings(): AcpToolSettingsInput | null {
+	return loadJsonLike(GLOBAL_SETTINGS_PATH);
+}
+
+export function writeGlobalSettings(config: AcpToolSettingsInput): void {
+	const dir = resolve(homedir(), ".pi", "acp-agents");
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(
+		GLOBAL_SETTINGS_PATH,
+		`${JSON.stringify(config, null, 2)}\n`,
+		"utf-8",
+	);
+}
+
+// ── Merge with validation ───────────────────────────────
+
+function validateAndStrip(settings: AcpToolSettingsInput): AcpToolSettingsInput {
+	if (!settings?.tools) return { tools: {} };
+	const valid: Record<string, { enabled: boolean }> = {};
+	for (const name of ACP_TOOL_NAMES) {
+		if (settings.tools[name] !== undefined) {
+			valid[name] = { enabled: settings.tools[name].enabled };
+		}
+	}
+	return { tools: valid };
+}
+
+export function mergeSettingsLayers(
+	globalConfig?: AcpToolSettingsInput | null,
+	projectConfig?: AcpToolSettingsInput | null,
+): AcpToolSettings {
+	const validatedGlobal = globalConfig ? validateAndStrip(globalConfig) : null;
+	const validatedLocal = projectConfig ? validateAndStrip(projectConfig) : null;
+	let merged = deepMergeSettings(DEFAULT_SETTINGS, validatedGlobal);
+	merged = deepMergeSettings(merged, validatedLocal);
+	return merged;
+}
+
+export function loadSettings(cwd: string): AcpToolSettings {
+	const projectPath = getProjectSettingsPath(cwd);
+	return mergeSettingsLayers(readGlobalSettings(), loadJsonLike(projectPath));
+}
+
+export function loadSettingsLayers(cwd: string): {
+	global: AcpToolSettingsInput | null;
+	local: AcpToolSettingsInput | null;
+	merged: AcpToolSettings;
+} {
+	const global = readGlobalSettings();
+	const local = loadJsonLike(getProjectSettingsPath(cwd));
+	return { global, local, merged: mergeSettingsLayers(global, local) };
+}
+
+// ── Helper ──────────────────────────────────────────────
+
+export function isToolEnabled(settings: AcpToolSettings, toolName: string): boolean {
+	const entry = settings.tools[toolName as AcpToolName];
+	if (!entry) return true; // unknown tools default to enabled
+	return entry.enabled;
+}

package/src/settings/configure-tui.ts

@@ -0,0 +1,135 @@
+/**
+ * TUI settings wizard for ACP tool enable/disable.
+ *
+ * Pattern copied from pi-gitnexus-local/index.ts configureExtension():
+ * Uses ctx.ui.confirm(), ctx.ui.select(), ctx.ui.input() for interactive settings.
+ * NOT ctx.ui.custom().
+ */
+
+import type { AcpToolSettings, AcpToolSettingsInput, AcpToolName } from "./config.js";
+import { ACP_TOOL_NAMES, readGlobalSettings, writeGlobalSettings, loadSettings } from "./config.js";
+
+const TOOL_GROUPS: { label: string; tools: AcpToolName[] }[] = [
+	{
+		label: "Core",
+		tools: ["acp_prompt", "acp_status"],
+	},
+	{
+		label: "Session",
+		tools: [
+			"acp_session_new", "acp_session_load", "acp_session_set_model",
+			"acp_session_set_mode", "acp_cancel",
+		],
+	},
+	{
+		label: "Lifecycle",
+		tools: ["acp_session_list", "acp_session_shutdown", "acp_session_kill", "acp_prune"],
+	},
+	{
+		label: "Coordination",
+		tools: ["acp_delegate", "acp_broadcast", "acp_compare"],
+	},
+	{
+		label: "Task",
+		tools: [
+			"acp_task_create", "acp_task_list", "acp_task_get", "acp_task_assign",
+			"acp_task_set_status", "acp_task_dependency_add", "acp_task_dependency_remove",
+			"acp_task_clear",
+		],
+	},
+	{
+		label: "Message",
+		tools: ["acp_message_send", "acp_message_list"],
+	},
+	{
+		label: "Governance",
+		tools: ["acp_plan_request", "acp_plan_resolve", "acp_model_policy_get", "acp_model_policy_check"],
+	},
+	{
+		label: "Runtime",
+		tools: ["acp_doctor", "acp_runtime_info", "acp_env", "acp_event_log", "acp_cleanup"],
+	},
+];
+
+export async function configureToolSettings(
+	ctx: {
+		hasUI: boolean;
+		ui: {
+			confirm(title: string, body: string): Promise<boolean>;
+			input(prompt: string, placeholder?: string): Promise<string | undefined>;
+			notify(message: string, type: "info" | "warning" | "error"): void;
+			select(prompt: string, items: string[]): Promise<string | undefined>;
+		};
+	},
+	cwd: string,
+): Promise<AcpToolSettings | null> {
+	if (!ctx.hasUI) {
+		ctx.ui.notify("Interactive UI required for ACP settings", "warning");
+		return null;
+	}
+
+	const current = loadSettings(cwd);
+	const base = structuredClone(readGlobalConfigForEdit());
+
+	// Ask which group to configure
+	while (true) {
+		const groupLabels = TOOL_GROUPS.map((g) => {
+			const enabled = g.tools.filter((t) => current.tools[t].enabled).length;
+			return `${g.label} (${enabled}/${g.tools.length})`;
+		});
+		groupLabels.push("Done");
+
+		const choice = await ctx.ui.select(
+			"ACP tool settings — pick a group to configure",
+			groupLabels,
+		);
+
+		if (!choice || choice === "Done") break;
+
+		const groupIndex = groupLabels.indexOf(choice);
+		const group = TOOL_GROUPS[groupIndex];
+
+		// Toggle individual tools in the group
+		for (const toolName of group.tools) {
+			const isEnabled = base.tools?.[toolName]?.enabled ?? current.tools[toolName].enabled;
+			const toggle = await ctx.ui.select(
+				`${toolName}`,
+				[
+					isEnabled ? "✓ enabled (keep)" : "○ disabled (keep)",
+					isEnabled ? "Disable" : "Enable",
+				],
+			);
+			if (toggle?.startsWith("Enable") || toggle?.startsWith("Disable")) {
+				if (!base.tools) base.tools = {};
+				base.tools[toolName] = { enabled: toggle.startsWith("Enable") };
+			}
+		}
+
+		// Refresh current view
+		for (const toolName of group.tools) {
+			if (base.tools?.[toolName] !== undefined) {
+				current.tools[toolName] = { enabled: base.tools[toolName].enabled };
+			}
+		}
+	}
+
+	// Check if anything changed
+	const hasChanges = Object.keys(base.tools ?? {}).length > 0;
+	if (!hasChanges) {
+		ctx.ui.notify("No changes made.", "info");
+		return null;
+	}
+
+	// Save
+	writeGlobalSettings(base);
+	ctx.ui.notify(
+		"ACP tool settings saved to global config.\nRestart pi for tool changes to take effect.",
+		"info",
+	);
+	return loadSettings(cwd);
+}
+
+function readGlobalConfigForEdit(): AcpToolSettingsInput {
+	const raw = readGlobalSettings();
+	return raw ? structuredClone(raw) : { tools: {} };
+}