indus-swarms 0.1.0

package/extensions/teams/leader-plan-commands.ts

@@ -0,0 +1,95 @@
+import type { ExtensionCommandContext } from "indusagi-coding-agent";
+import { writeToMailbox } from "./mailbox.js";
+import { sanitizeName } from "./names.js";
+import { getTeamDir } from "./paths.js";
+import { TEAM_MAILBOX_NS } from "./protocol.js";
+import type { TeamsStyle } from "./teams-style.js";
+import { formatMemberDisplayName } from "./teams-style.js";
+
+export async function handleTeamPlanCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teamId: string;
+	leadName: string;
+	style: TeamsStyle;
+	pendingPlanApprovals: Map<string, { requestId: string; name: string; taskId?: string }>;
+}): Promise<void> {
+	const { ctx, rest, teamId, leadName, style, pendingPlanApprovals } = opts;
+
+	const [planSub, ...planRest] = rest;
+	if (!planSub || planSub === "help") {
+		ctx.ui.notify(
+			[
+				"Usage:",
+				"  /team plan approve <name>",
+				"  /team plan reject <name> [feedback...]",
+			].join("\n"),
+			"info",
+		);
+		return;
+	}
+
+	if (planSub === "approve") {
+		const nameRaw = planRest[0];
+		if (!nameRaw) {
+			ctx.ui.notify("Usage: /team plan approve <name>", "error");
+			return;
+		}
+		const name = sanitizeName(nameRaw);
+		const pending = pendingPlanApprovals.get(name);
+		if (!pending) {
+			ctx.ui.notify(`No pending plan approval for ${name}`, "error");
+			return;
+		}
+
+		const teamDir = getTeamDir(teamId);
+		const ts = new Date().toISOString();
+		await writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
+			from: leadName,
+			text: JSON.stringify({
+				type: "plan_approved",
+				requestId: pending.requestId,
+				from: leadName,
+				timestamp: ts,
+			}),
+			timestamp: ts,
+		});
+		pendingPlanApprovals.delete(name);
+		ctx.ui.notify(`Approved plan for ${formatMemberDisplayName(style, name)}`, "info");
+		return;
+	}
+
+	if (planSub === "reject") {
+		const nameRaw = planRest[0];
+		if (!nameRaw) {
+			ctx.ui.notify("Usage: /team plan reject <name> [feedback...]", "error");
+			return;
+		}
+		const name = sanitizeName(nameRaw);
+		const pending = pendingPlanApprovals.get(name);
+		if (!pending) {
+			ctx.ui.notify(`No pending plan approval for ${name}`, "error");
+			return;
+		}
+
+		const feedback = planRest.slice(1).join(" ").trim() || "Plan rejected";
+		const teamDir = getTeamDir(teamId);
+		const ts = new Date().toISOString();
+		await writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
+			from: leadName,
+			text: JSON.stringify({
+				type: "plan_rejected",
+				requestId: pending.requestId,
+				from: leadName,
+				feedback,
+				timestamp: ts,
+			}),
+			timestamp: ts,
+		});
+		pendingPlanApprovals.delete(name);
+		ctx.ui.notify(`Rejected plan for ${formatMemberDisplayName(style, name)}: ${feedback}`, "info");
+		return;
+	}
+
+	ctx.ui.notify(`Unknown plan subcommand: ${planSub}`, "error");
+}

package/extensions/teams/leader-spawn-command.ts

@@ -0,0 +1,149 @@
+import type { ThinkingLevel } from "indusagi/agent";
+import type { ExtensionCommandContext } from "indusagi-coding-agent";
+import { pickAgentNames, pickNamesFromPool } from "./names.js";
+import type { TeammateRpc } from "./teammate-rpc.js";
+import type { TeamsStyle } from "./teams-style.js";
+import { formatMemberDisplayName, getTeamsNamingRules, getTeamsStrings } from "./teams-style.js";
+import type { ContextMode, WorkspaceMode, SpawnTeammateFn } from "./spawn-types.js";
+
+function isThinkingLevel(v: string): v is ThinkingLevel {
+	switch (v) {
+		case "off":
+		case "minimal":
+		case "low":
+		case "medium":
+		case "high":
+		case "xhigh":
+			return true;
+		default:
+			return false;
+	}
+}
+
+export async function handleTeamSpawnCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teammates: Map<string, TeammateRpc>;
+	style: TeamsStyle;
+	spawnTeammate: SpawnTeammateFn;
+}): Promise<void> {
+	const { ctx, rest, teammates, style, spawnTeammate } = opts;
+	const strings = getTeamsStrings(style);
+
+	// Parse flags from any position
+	let nameRaw: string | undefined;
+	let mode: ContextMode = "fresh";
+	let workspaceMode: WorkspaceMode = "shared";
+	let planRequired = false;
+	let model: string | undefined;
+	let thinking: ThinkingLevel | undefined;
+
+	for (let i = 0; i < rest.length; i++) {
+		const a = rest[i];
+		if (!a) continue;
+
+		if (a === "fresh" || a === "branch") {
+			mode = a;
+			continue;
+		}
+		if (a === "shared" || a === "worktree") {
+			workspaceMode = a;
+			continue;
+		}
+		if (a === "plan") {
+			planRequired = true;
+			continue;
+		}
+
+		if (a === "--model") {
+			const next = rest[i + 1];
+			if (!next) {
+				ctx.ui.notify("Usage: /team spawn <name> [fresh|branch] [shared|worktree] [plan] [--model <provider>/<modelId>] [--thinking <level>]", "error");
+				return;
+			}
+			model = next;
+			i++;
+			continue;
+		}
+		if (a.startsWith("--model=")) {
+			model = a.slice("--model=".length);
+			continue;
+		}
+
+		if (a === "--thinking") {
+			const next = rest[i + 1];
+			if (!next) {
+				ctx.ui.notify("Usage: /team spawn <name> [fresh|branch] [shared|worktree] [plan] [--model <provider>/<modelId>] [--thinking <level>]", "error");
+				return;
+			}
+			if (!isThinkingLevel(next)) {
+				ctx.ui.notify(
+					`Invalid thinking level '${next}'. Valid values: off, minimal, low, medium, high, xhigh`,
+					"error",
+				);
+				return;
+			}
+			thinking = next;
+			i++;
+			continue;
+		}
+		if (a.startsWith("--thinking=")) {
+			const next = a.slice("--thinking=".length);
+			if (!isThinkingLevel(next)) {
+				ctx.ui.notify(
+					`Invalid thinking level '${next}'. Valid values: off, minimal, low, medium, high, xhigh`,
+					"error",
+				);
+				return;
+			}
+			thinking = next;
+			continue;
+		}
+
+		if (!nameRaw && !a.startsWith("--")) nameRaw = a;
+	}
+
+	model = model?.trim();
+	if (model === "") model = undefined;
+
+	// Auto-pick a name when the current style allows it.
+	if (!nameRaw) {
+		const naming = getTeamsNamingRules(style);
+		if (naming.requireExplicitSpawnName) {
+			ctx.ui.notify(
+				"Usage: /team spawn <name> [fresh|branch] [shared|worktree] [plan] [--model <provider>/<modelId>] [--thinking <level>]",
+				"error",
+			);
+			return;
+		}
+
+		const taken = new Set(teammates.keys());
+		const picked = (() => {
+			if (naming.autoNameStrategy.kind === "agent") return pickAgentNames(1, taken).at(0);
+			return pickNamesFromPool({
+				pool: naming.autoNameStrategy.pool,
+				count: 1,
+				taken,
+				fallbackBase: naming.autoNameStrategy.fallbackBase,
+			}).at(0);
+		})();
+		if (!picked) {
+			ctx.ui.notify(`Failed to pick a ${strings.memberTitle.toLowerCase()} name`, "error");
+			return;
+		}
+		nameRaw = picked;
+	}
+
+	const res = await spawnTeammate(ctx, { name: nameRaw, mode, workspaceMode, planRequired, model, thinking });
+	if (!res.ok) {
+		ctx.ui.notify(res.error, "error");
+		return;
+	}
+
+	for (const w of res.warnings) ctx.ui.notify(w, "warning");
+	const displayName = formatMemberDisplayName(style, res.name);
+	ctx.ui.notify(
+		`${displayName} ${strings.joinedVerb} (${res.mode}${res.note ? ", " + res.note : ""} \u00b7 ${res.workspaceMode})`,
+		"info",
+	);
+}

package/extensions/teams/leader-task-commands.ts

@@ -0,0 +1,435 @@
+import * as path from "node:path";
+import type { ExtensionCommandContext } from "indusagi-coding-agent";
+import { writeToMailbox } from "./mailbox.js";
+import { sanitizeName } from "./names.js";
+import { getTeamDir } from "./paths.js";
+import { taskAssignmentPayload } from "./protocol.js";
+import {
+	addTaskDependency,
+	clearTasks,
+	createTask,
+	formatTaskLine,
+	getTask,
+	isTaskBlocked,
+	removeTaskDependency,
+	updateTask,
+	type TeamTask,
+} from "./task-store.js";
+import { ensureTeamConfig } from "./team-config.js";
+import type { TeamsStyle } from "./teams-style.js";
+import { formatMemberDisplayName } from "./teams-style.js";
+
+function parseAssigneePrefix(text: string): { assignee?: string; text: string } {
+	const m = text.match(/^([a-zA-Z0-9_-]+):\s*(.+)$/);
+	if (!m) return { text };
+	const assignee = m[1];
+	const rest = m[2];
+	if (!assignee || !rest) return { text };
+	return { assignee, text: rest };
+}
+
+export async function handleTeamTaskCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teamId: string;
+	leadName: string;
+	style: TeamsStyle;
+	getTaskListId: () => string | null;
+	setTaskListId: (id: string) => void;
+	getTasks: () => TeamTask[];
+	refreshTasks: () => Promise<void>;
+	renderWidget: () => void;
+}): Promise<void> {
+	const {
+		ctx,
+		rest,
+		teamId,
+		leadName,
+		style,
+		getTaskListId,
+		setTaskListId,
+		getTasks,
+		refreshTasks,
+		renderWidget,
+	} = opts;
+
+	const [taskSub, ...taskRest] = rest;
+	const teamDir = getTeamDir(teamId);
+	const effectiveTlId = getTaskListId() ?? teamId;
+
+	if (!taskSub || taskSub === "help") {
+		ctx.ui.notify(
+			[
+				"Usage:",
+				"  /team task add <text...>",
+				"  /team task assign <id> <agent>",
+				"  /team task unassign <id>",
+				"  /team task list",
+				"  /team task clear [completed|all] [--force]",
+				"  /team task show <id>",
+				"  /team task dep add <id> <depId>",
+				"  /team task dep rm <id> <depId>",
+				"  /team task dep ls <id>",
+				"  /team task use <taskListId>",
+				"Tip: prefix with assignee, e.g. 'alice: review the API surface'",
+			].join("\n"),
+			"info",
+		);
+		return;
+	}
+
+	switch (taskSub) {
+		case "add": {
+			const raw = taskRest.join(" ").trim();
+			if (!raw) {
+				ctx.ui.notify("Usage: /team task add <text...>", "error");
+				return;
+			}
+
+			const parsed = parseAssigneePrefix(raw);
+			const owner = parsed.assignee ? sanitizeName(parsed.assignee) : undefined;
+			const description = parsed.text.trim();
+			const firstLine = description.split("\n").at(0) ?? "";
+			const subject = firstLine.slice(0, 120);
+
+			const task = await createTask(teamDir, effectiveTlId, { subject, description, owner });
+
+			if (owner) {
+				const payload = taskAssignmentPayload(task, leadName);
+				await writeToMailbox(teamDir, effectiveTlId, owner, {
+					from: leadName,
+					text: JSON.stringify(payload),
+					timestamp: new Date().toISOString(),
+				});
+			}
+
+			ctx.ui.notify(
+				`Created task #${task.id}${owner ? ` (assigned to ${formatMemberDisplayName(style, owner)})` : ""}`,
+				"info",
+			);
+			await refreshTasks();
+			renderWidget();
+			return;
+		}
+
+		case "assign": {
+			const taskId = taskRest[0];
+			const agent = taskRest[1];
+			if (!taskId || !agent) {
+				ctx.ui.notify("Usage: /team task assign <id> <agent>", "error");
+				return;
+			}
+
+			const owner = sanitizeName(agent);
+			const updated = await updateTask(teamDir, effectiveTlId, taskId, (cur) => {
+				if (cur.status !== "completed") {
+					return { ...cur, owner, status: "pending" };
+				}
+				return { ...cur, owner };
+			});
+			if (!updated) {
+				ctx.ui.notify(`Task not found: ${taskId}`, "error");
+				return;
+			}
+
+			await writeToMailbox(teamDir, effectiveTlId, owner, {
+				from: leadName,
+				text: JSON.stringify(taskAssignmentPayload(updated, leadName)),
+				timestamp: new Date().toISOString(),
+			});
+
+			ctx.ui.notify(`Assigned task #${updated.id} to ${formatMemberDisplayName(style, owner)}`, "info");
+			await refreshTasks();
+			renderWidget();
+			return;
+		}
+
+		case "unassign": {
+			const taskId = taskRest[0];
+			if (!taskId) {
+				ctx.ui.notify("Usage: /team task unassign <id>", "error");
+				return;
+			}
+
+			const updated = await updateTask(teamDir, effectiveTlId, taskId, (cur) => {
+				if (cur.status !== "completed") {
+					return { ...cur, owner: undefined, status: "pending" };
+				}
+				return { ...cur, owner: undefined };
+			});
+			if (!updated) {
+				ctx.ui.notify(`Task not found: ${taskId}`, "error");
+				return;
+			}
+
+			ctx.ui.notify(`Unassigned task #${updated.id}`, "info");
+			await refreshTasks();
+			renderWidget();
+			return;
+		}
+
+		case "show": {
+			const taskId = taskRest[0];
+			if (!taskId) {
+				ctx.ui.notify("Usage: /team task show <id>", "error");
+				return;
+			}
+
+			const task = await getTask(teamDir, effectiveTlId, taskId);
+			if (!task) {
+				ctx.ui.notify(`Task not found: ${taskId}`, "error");
+				return;
+			}
+
+			const blocked = task.status !== "completed" && (await isTaskBlocked(teamDir, effectiveTlId, task));
+
+			const lines: string[] = [];
+			lines.push(`#${task.id} ${task.subject}`);
+			lines.push(
+				`status: ${task.status}${blocked ? " (blocked)" : ""}${task.owner ? ` • owner: ${task.owner}` : ""}`,
+			);
+			if (task.blockedBy.length) lines.push(`deps: ${task.blockedBy.join(", ")}`);
+			if (task.blocks.length) lines.push(`blocks: ${task.blocks.join(", ")}`);
+			lines.push("");
+			lines.push(task.description);
+
+			const result = typeof task.metadata?.result === "string" ? task.metadata.result : undefined;
+			if (result) {
+				lines.push("");
+				lines.push("result:");
+				lines.push(result);
+			}
+
+			const qualityGateStatusRaw = task.metadata?.["qualityGateStatus"];
+			const qualityGateStatus =
+				qualityGateStatusRaw === "failed" || qualityGateStatusRaw === "passed" ? qualityGateStatusRaw : null;
+			const qualityGateSummaryRaw = task.metadata?.["qualityGateSummary"];
+			const qualityGateSummary =
+				typeof qualityGateSummaryRaw === "string" && qualityGateSummaryRaw.trim().length > 0
+					? qualityGateSummaryRaw.trim()
+					: null;
+			if (qualityGateStatus) {
+				lines.push("");
+				lines.push(`quality gate: ${qualityGateStatus}${qualityGateSummary ? ` • ${qualityGateSummary}` : ""}`);
+			}
+
+			ctx.ui.notify(lines.join("\n"), "info");
+			return;
+		}
+
+		case "dep": {
+			const [depSub, ...depRest] = taskRest;
+			if (!depSub || depSub === "help") {
+				ctx.ui.notify(
+					[
+						"Usage:",
+						"  /team task dep add <id> <depId>",
+						"  /team task dep rm <id> <depId>",
+						"  /team task dep ls <id>",
+					].join("\n"),
+					"info",
+				);
+				return;
+			}
+
+			switch (depSub) {
+				case "add": {
+					const taskId = depRest[0];
+					const depId = depRest[1];
+					if (!taskId || !depId) {
+						ctx.ui.notify("Usage: /team task dep add <id> <depId>", "error");
+						return;
+					}
+
+					const res = await addTaskDependency(teamDir, effectiveTlId, taskId, depId);
+					if (!res.ok) {
+						ctx.ui.notify(res.error, "error");
+						return;
+					}
+
+					ctx.ui.notify(`Added dependency: #${taskId} depends on #${depId}`, "info");
+					await refreshTasks();
+					renderWidget();
+					return;
+				}
+
+				case "rm": {
+					const taskId = depRest[0];
+					const depId = depRest[1];
+					if (!taskId || !depId) {
+						ctx.ui.notify("Usage: /team task dep rm <id> <depId>", "error");
+						return;
+					}
+
+					const res = await removeTaskDependency(teamDir, effectiveTlId, taskId, depId);
+					if (!res.ok) {
+						ctx.ui.notify(res.error, "error");
+						return;
+					}
+
+					ctx.ui.notify(`Removed dependency: #${taskId} no longer depends on #${depId}`, "info");
+					await refreshTasks();
+					renderWidget();
+					return;
+				}
+
+				case "ls": {
+					const taskId = depRest[0];
+					if (!taskId) {
+						ctx.ui.notify("Usage: /team task dep ls <id>", "error");
+						return;
+					}
+
+					await refreshTasks();
+					const tasks = getTasks();
+					const task = tasks.find((t) => t.id === taskId) ?? (await getTask(teamDir, effectiveTlId, taskId));
+					if (!task) {
+						ctx.ui.notify(`Task not found: ${taskId}`, "error");
+						return;
+					}
+
+					const blocked = task.status !== "completed" && (await isTaskBlocked(teamDir, effectiveTlId, task));
+
+					const lines: string[] = [];
+					lines.push(`#${task.id} ${task.subject}`);
+					lines.push(`${blocked ? "blocked" : "unblocked"} • deps:${task.blockedBy.length} • blocks:${task.blocks.length}`);
+
+					lines.push("");
+					lines.push("blockedBy:");
+					if (!task.blockedBy.length) {
+						lines.push("  (none)");
+					} else {
+						for (const id of task.blockedBy) {
+							const dep = tasks.find((t) => t.id === id) ?? (await getTask(teamDir, effectiveTlId, id));
+							lines.push(dep ? `  - #${id} ${dep.status} ${dep.subject}` : `  - #${id} (missing)`);
+						}
+					}
+
+					lines.push("");
+					lines.push("blocks:");
+					if (!task.blocks.length) {
+						lines.push("  (none)");
+					} else {
+						for (const id of task.blocks) {
+							const child = tasks.find((t) => t.id === id) ?? (await getTask(teamDir, effectiveTlId, id));
+							lines.push(child ? `  - #${id} ${child.status} ${child.subject}` : `  - #${id} (missing)`);
+						}
+					}
+
+					ctx.ui.notify(lines.join("\n"), "info");
+					return;
+				}
+
+				default: {
+					ctx.ui.notify(`Unknown dep subcommand: ${depSub}`, "error");
+					return;
+				}
+			}
+		}
+
+		case "clear": {
+			const flags = taskRest.filter((a) => a.startsWith("--"));
+			const argsOnly = taskRest.filter((a) => !a.startsWith("--"));
+			const force = flags.includes("--force");
+
+			const unknownFlags = flags.filter((f) => f !== "--force");
+			if (unknownFlags.length) {
+				ctx.ui.notify(`Unknown flag(s): ${unknownFlags.join(", ")}`, "error");
+				return;
+			}
+
+			if (argsOnly.length > 1) {
+				ctx.ui.notify("Usage: /team task clear [completed|all] [--force]", "error");
+				return;
+			}
+
+			const modeArg = argsOnly[0];
+			if (modeArg && modeArg !== "completed" && modeArg !== "all") {
+				ctx.ui.notify("Usage: /team task clear [completed|all] [--force]", "error");
+				return;
+			}
+			const mode = modeArg === "all" ? "all" : "completed";
+
+			await refreshTasks();
+			const tasks = getTasks();
+			const toDelete = mode === "all" ? tasks.length : tasks.filter((t) => t.status === "completed").length;
+
+			if (!force) {
+				// Only prompt in interactive TTY mode. In RPC mode, confirm() would require
+				// the host to send extension_ui_response messages.
+				if (process.stdout.isTTY && process.stdin.isTTY) {
+					const title = mode === "all" ? "Clear task list" : "Clear completed tasks";
+					const body =
+						mode === "all"
+							? `Delete ALL ${toDelete} task(s) from the task list? This cannot be undone.`
+							: `Delete ${toDelete} completed task(s) from the task list? This cannot be undone.`;
+					const ok = await ctx.ui.confirm(title, body);
+					if (!ok) return;
+				} else {
+					ctx.ui.notify("Refusing to clear tasks in non-interactive mode without --force", "error");
+					return;
+				}
+			}
+
+			const res = await clearTasks(teamDir, effectiveTlId, mode);
+			const deleted = res.deletedTaskIds.length;
+
+			if (res.errors.length) {
+				ctx.ui.notify(`Cleared ${deleted} task(s) (${mode}) with ${res.errors.length} error(s)`, "warning");
+				const preview = res.errors
+					.slice(0, 8)
+					.map((e) => `- ${path.basename(e.file)}: ${e.error}`)
+					.join("\n");
+				ctx.ui.notify(
+					`Errors:\n${preview}${res.errors.length > 8 ? `\n... +${res.errors.length - 8} more` : ""}`,
+					"warning",
+				);
+			} else if (deleted === 0) {
+				ctx.ui.notify(`No task(s) cleared (${mode})`, "info");
+			} else {
+				ctx.ui.notify(`Cleared ${deleted} task(s) (${mode})`, "warning");
+			}
+
+			await refreshTasks();
+			renderWidget();
+			return;
+		}
+
+		case "list": {
+			await refreshTasks();
+			const tasks = getTasks();
+			if (!tasks.length) {
+				ctx.ui.notify("No tasks", "info");
+				return;
+			}
+
+			const slice = tasks.slice(-30);
+			const blocked = await Promise.all(
+				slice.map(async (t) => (t.status === "completed" ? false : await isTaskBlocked(teamDir, effectiveTlId, t))),
+			);
+
+			const preview = slice.map((t, i) => formatTaskLine(t, { blocked: blocked[i] })).join("\n");
+			ctx.ui.notify(preview, "info");
+			return;
+		}
+
+		case "use": {
+			const newId = taskRest[0];
+			if (!newId) {
+				ctx.ui.notify("Usage: /team task use <taskListId>", "error");
+				return;
+			}
+			setTaskListId(newId);
+			await ensureTeamConfig(teamDir, { teamId, taskListId: newId, leadName, style });
+			ctx.ui.notify(`Task list ID set to: ${newId}`, "info");
+			await refreshTasks();
+			renderWidget();
+			return;
+		}
+
+		default: {
+			ctx.ui.notify(`Unknown task subcommand: ${taskSub}`, "error");
+			return;
+		}
+	}
+}