indus-swarms 0.1.0

package/extensions/teams/teams-style.ts

@@ -0,0 +1,322 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { sanitizeName, COMRADE_NAME_POOL, PIRATE_NAME_POOL } from "./names.js";
+import { getTeamsStylesDir } from "./paths.js";
+
+/**
+ * Teams UI style id.
+ *
+ * Built-in styles ship with the extension. Users can add custom styles by
+ * creating JSON files under `${getTeamsStylesDir()}`.
+ */
+export type TeamsStyle = string;
+
+export const TEAMS_STYLES = ["normal", "soviet", "pirate"] as const;
+export type BuiltinTeamsStyle = (typeof TEAMS_STYLES)[number];
+
+export type TeamsStrings = {
+	leaderTitle: string;
+	leaderControlTitle: string;
+	memberTitle: string;
+	memberPrefix: string;
+	teamNoun: string;
+	joinedVerb: string;
+	leftVerb: string;
+	killedVerb: string;
+
+	// Lifecycle copy (all shown as "<member> <verb...>")
+	shutdownRequestedVerb: string;
+	shutdownCompletedVerb: string;
+	shutdownRefusedVerb: string;
+	abortRequestedVerb: string;
+
+	// Templates (supports {members} and/or {count})
+	noMembersToShutdown: string;
+	shutdownAllPrompt: string;
+	teamEndedAllStopped: string;
+};
+
+export type TeamsAutoNameStrategy =
+	| { kind: "agent" }
+	| { kind: "pool"; pool: readonly string[]; fallbackBase: string };
+
+export type TeamsNamingRules = {
+	/** If true, `/team spawn` requires an explicit name. */
+	requireExplicitSpawnName: boolean;
+	/** Default naming strategy for auto-spawn (e.g. tool-driven). */
+	autoNameStrategy: TeamsAutoNameStrategy;
+};
+
+export type TeamsStyleDefinition = {
+	id: TeamsStyle;
+	strings: TeamsStrings;
+	naming: TeamsNamingRules;
+};
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+	return typeof v === "object" && v !== null;
+}
+
+export function formatTeamsTemplate(template: string, vars: Record<string, string>): string {
+	return template.replace(/\{([a-zA-Z0-9_]+)\}/g, (_m, key: string) => vars[key] ?? "");
+}
+
+export function normalizeTeamsStyleId(raw: unknown): TeamsStyle | null {
+	if (typeof raw !== "string") return null;
+	const trimmed = raw.trim();
+	if (!trimmed) return null;
+	const sanitized = sanitizeName(trimmed).toLowerCase();
+	return sanitized ? sanitized : null;
+}
+
+export function getTeamsStyleFromEnv(env: NodeJS.ProcessEnv = process.env): TeamsStyle {
+	return normalizeTeamsStyleId(env.PI_TEAMS_STYLE) ?? "normal";
+}
+
+function builtinStyle(id: BuiltinTeamsStyle): TeamsStyleDefinition {
+	if (id === "soviet") {
+		return {
+			id,
+			strings: {
+				leaderTitle: "Chairman",
+				leaderControlTitle: "Chairman (control)",
+				memberTitle: "Comrade",
+				memberPrefix: "Comrade ",
+				teamNoun: "Party",
+				joinedVerb: "has joined the Party",
+				leftVerb: "has left the Party",
+				killedVerb: "sent to the gulag",
+
+				shutdownRequestedVerb: "was asked to stand down",
+				shutdownCompletedVerb: "stood down",
+				shutdownRefusedVerb: "refused to comply",
+				abortRequestedVerb: "was ordered to stop",
+
+				noMembersToShutdown: "No {members} to shut down",
+				shutdownAllPrompt: "Stop all {count} {members}?",
+				teamEndedAllStopped: "Team ended: all {members} stopped (leader session remains active)",
+			},
+			naming: {
+				requireExplicitSpawnName: false,
+				autoNameStrategy: { kind: "pool", pool: COMRADE_NAME_POOL, fallbackBase: "comrade" },
+			},
+		};
+	}
+	if (id === "pirate") {
+		return {
+			id,
+			strings: {
+				leaderTitle: "Captain",
+				leaderControlTitle: "Captain (control)",
+				memberTitle: "Matey",
+				memberPrefix: "Matey ",
+				teamNoun: "crew",
+				joinedVerb: "joined the crew",
+				leftVerb: "abandoned ship",
+				killedVerb: "walked the plank",
+
+				shutdownRequestedVerb: "was ordered to strike the colors",
+				shutdownCompletedVerb: "struck their colors",
+				shutdownRefusedVerb: "defied the captain",
+				abortRequestedVerb: "was ordered to belay that",
+
+				noMembersToShutdown: "No {members} to send below decks",
+				shutdownAllPrompt: "Dismiss all {count} {members}?",
+				teamEndedAllStopped: "Crew dismissed: all {members} struck their colors (leader session remains active)",
+			},
+			naming: {
+				requireExplicitSpawnName: false,
+				autoNameStrategy: { kind: "pool", pool: PIRATE_NAME_POOL, fallbackBase: "matey" },
+			},
+		};
+	}
+
+	// normal
+	return {
+		id,
+		strings: {
+			leaderTitle: "Team leader",
+			leaderControlTitle: "Leader (control)",
+			memberTitle: "Teammate",
+			memberPrefix: "Teammate ",
+			teamNoun: "team",
+			joinedVerb: "joined the team",
+			leftVerb: "left the team",
+			killedVerb: "stopped",
+
+			shutdownRequestedVerb: "was asked to shut down",
+			shutdownCompletedVerb: "shut down",
+			shutdownRefusedVerb: "refused to shut down",
+			abortRequestedVerb: "was asked to stop",
+
+			noMembersToShutdown: "No {members} to shut down",
+			shutdownAllPrompt: "Stop all {count} {members}?",
+			teamEndedAllStopped: "Team ended: all {members} stopped (leader session remains active)",
+		},
+		naming: {
+			requireExplicitSpawnName: true,
+			autoNameStrategy: { kind: "agent" },
+		},
+	};
+}
+
+const BUILTINS: Record<BuiltinTeamsStyle, TeamsStyleDefinition> = {
+	normal: builtinStyle("normal"),
+	soviet: builtinStyle("soviet"),
+	pirate: builtinStyle("pirate"),
+};
+
+function isBuiltinStyleId(id: TeamsStyle): id is BuiltinTeamsStyle {
+	return (TEAMS_STYLES as readonly string[]).includes(id);
+}
+
+function getTeamsStyleConfigPath(styleId: TeamsStyle): string {
+	return path.join(getTeamsStylesDir(), `${styleId}.json`);
+}
+
+type CustomCacheEntry =
+	| { kind: "def"; def: TeamsStyleDefinition }
+	| { kind: "error"; error: string }
+	| { kind: "missing" };
+
+const customCache = new Map<string, CustomCacheEntry>();
+
+function coerceStringsPartial(obj: unknown): Partial<TeamsStrings> {
+	if (!isRecord(obj)) return {};
+	const out: Partial<TeamsStrings> = {};
+	const keys: Array<keyof TeamsStrings> = [
+		"leaderTitle",
+		"leaderControlTitle",
+		"memberTitle",
+		"memberPrefix",
+		"teamNoun",
+		"joinedVerb",
+		"leftVerb",
+		"killedVerb",
+		"shutdownRequestedVerb",
+		"shutdownCompletedVerb",
+		"shutdownRefusedVerb",
+		"abortRequestedVerb",
+		"noMembersToShutdown",
+		"shutdownAllPrompt",
+		"teamEndedAllStopped",
+	];
+	for (const k of keys) {
+		const v = obj[k];
+		if (typeof v === "string") out[k] = v;
+	}
+	return out;
+}
+
+function coerceAutoNameStrategy(obj: unknown): TeamsAutoNameStrategy | null {
+	if (!isRecord(obj)) return null;
+	const kind = obj.kind;
+	if (kind === "agent") return { kind: "agent" };
+	if (kind === "pool") {
+		const poolRaw = obj.pool;
+		if (!Array.isArray(poolRaw)) return null;
+		const pool = poolRaw
+			.filter((v): v is string => typeof v === "string")
+			.map((s) => sanitizeName(s.trim()).toLowerCase())
+			.filter((s) => s.length > 0);
+		const fallbackBase =
+			typeof obj.fallbackBase === "string"
+				? sanitizeName(obj.fallbackBase.trim()).toLowerCase() || "member"
+				: "member";
+		return { kind: "pool", pool, fallbackBase };
+	}
+	return null;
+}
+
+function readCustomStyleDefinition(styleId: TeamsStyle): CustomCacheEntry {
+	const file = getTeamsStyleConfigPath(styleId);
+	try {
+		if (!fs.existsSync(file)) return { kind: "missing" };
+		const raw = fs.readFileSync(file, "utf8");
+		const parsed: unknown = JSON.parse(raw);
+		if (!isRecord(parsed)) return { kind: "error", error: `Style file is not an object: ${file}` };
+
+		// Optional: base/extends
+		const extendsRaw = normalizeTeamsStyleId(parsed.extends);
+		const base: TeamsStyleDefinition =
+			extendsRaw && isBuiltinStyleId(extendsRaw) ? BUILTINS[extendsRaw] : BUILTINS.normal;
+
+		const stringsPatch = coerceStringsPartial(parsed.strings);
+		const namingObj = parsed.naming;
+		const requireExplicitSpawnName =
+			isRecord(namingObj) && typeof namingObj.requireExplicitSpawnName === "boolean"
+				? namingObj.requireExplicitSpawnName
+				: base.naming.requireExplicitSpawnName;
+		const autoNameStrategy =
+			isRecord(namingObj) && "autoNameStrategy" in namingObj
+				? coerceAutoNameStrategy((namingObj as Record<string, unknown>).autoNameStrategy) ?? base.naming.autoNameStrategy
+				: base.naming.autoNameStrategy;
+
+		const def: TeamsStyleDefinition = {
+			id: styleId,
+			strings: { ...base.strings, ...stringsPatch },
+			naming: { requireExplicitSpawnName, autoNameStrategy },
+		};
+		return { kind: "def", def };
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		return { kind: "error", error: `Failed to load style '${styleId}' from ${file}: ${msg}` };
+	}
+}
+
+export function resolveTeamsStyleDefinition(styleIdRaw: TeamsStyle, opts?: { strict?: boolean }): TeamsStyleDefinition {
+	const strict = opts?.strict === true;
+	const styleId = normalizeTeamsStyleId(styleIdRaw) ?? "normal";
+
+	if (isBuiltinStyleId(styleId)) return BUILTINS[styleId];
+
+	const cached = customCache.get(styleId);
+	const entry = cached ?? readCustomStyleDefinition(styleId);
+	if (!cached) customCache.set(styleId, entry);
+
+	if (entry.kind === "def") return entry.def;
+	if (strict) {
+		if (entry.kind === "missing") {
+			throw new Error(
+				`Unknown teams style: ${styleId}. Create ${getTeamsStyleConfigPath(styleId)} or use one of: ${TEAMS_STYLES.join(", ")}`,
+			);
+		}
+		throw new Error(entry.error);
+	}
+
+	return BUILTINS.normal;
+}
+
+export function getTeamsStrings(style: TeamsStyle): TeamsStrings {
+	return resolveTeamsStyleDefinition(style).strings;
+}
+
+export function getTeamsNamingRules(style: TeamsStyle): TeamsNamingRules {
+	return resolveTeamsStyleDefinition(style).naming;
+}
+
+export function listAvailableTeamsStyles(): { dir: string; builtins: readonly string[]; customs: string[]; all: string[] } {
+	const dir = getTeamsStylesDir();
+	let customs: string[] = [];
+	try {
+		if (fs.existsSync(dir)) {
+			customs = fs
+				.readdirSync(dir)
+				.filter((f) => f.endsWith(".json"))
+				.map((f) => f.slice(0, -".json".length))
+				.map((id) => normalizeTeamsStyleId(id))
+				.filter((id): id is string => id !== null);
+		}
+	} catch {
+		customs = [];
+	}
+
+	const builtins = TEAMS_STYLES as readonly string[];
+	const all = Array.from(new Set([...builtins, ...customs])).sort();
+	return { dir, builtins, customs, all };
+}
+
+export function formatMemberDisplayName(style: TeamsStyle, name: string): string {
+	const s = getTeamsStrings(style);
+	return s.memberPrefix ? `${s.memberPrefix}${name}` : name;
+}

package/extensions/teams/teams-ui-shared.ts

@@ -0,0 +1,89 @@
+import type { ThemeColor } from "indusagi-coding-agent";
+import { visibleWidth } from "indusagi/tui";
+import type { TeamConfig, TeamMember } from "./team-config.js";
+import type { TeamTask } from "./task-store.js";
+import type { TeammateRpc, TeammateStatus } from "./teammate-rpc.js";
+
+// Status icon and color mapping (shared by widget + interactive panel)
+export const STATUS_ICON: Record<TeammateStatus, string> = {
+	streaming: "\u25c9",
+	idle: "\u25cf",
+	starting: "\u25cb",
+	stopped: "\u2717",
+	error: "\u2717",
+};
+
+export const STATUS_COLOR: Record<TeammateStatus, ThemeColor> = {
+	streaming: "accent",
+	idle: "success",
+	starting: "muted",
+	stopped: "dim",
+	error: "error",
+};
+
+export const TOOL_VERB: Record<string, string> = {
+	read: "reading\u2026",
+	edit: "editing\u2026",
+	write: "writing\u2026",
+	grep: "searching\u2026",
+	glob: "finding files\u2026",
+	bash: "running\u2026",
+	task: "delegating\u2026",
+	webfetch: "fetching\u2026",
+	websearch: "searching web\u2026",
+};
+
+export function toolVerb(toolName: string): string {
+	const key = toolName.toLowerCase();
+	return TOOL_VERB[key] ?? `${toolName}\u2026`;
+}
+
+export function toolActivity(toolName: string | null): string {
+	if (!toolName) return "";
+	return toolVerb(toolName);
+}
+
+export function padRight(str: string, targetWidth: number): string {
+	const w = visibleWidth(str);
+	return w >= targetWidth ? str : str + " ".repeat(targetWidth - w);
+}
+
+export function resolveStatus(rpc: TeammateRpc | undefined, cfg: TeamMember | undefined): TeammateStatus {
+	if (rpc) return rpc.status;
+	return cfg?.status === "online" ? "idle" : "stopped";
+}
+
+export function formatTokens(n: number): string {
+	if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+	if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;
+	return String(n);
+}
+
+/**
+ * Compute the set of worker names that should be visible in the UI.
+ *
+ * Rule: show any worker that is:
+ * - currently spawned/known as a teammate RPC
+ * - online in team config
+ * - owning an in-progress task (even if RPC is disconnected)
+ */
+export function getVisibleWorkerNames(opts: {
+	teammates: ReadonlyMap<string, TeammateRpc>;
+	teamConfig: TeamConfig | null;
+	tasks: readonly TeamTask[];
+}): string[] {
+	const { teammates, teamConfig, tasks } = opts;
+	const leadName = teamConfig?.leadName;
+	const cfgMembers = teamConfig?.members ?? [];
+
+	const names = new Set<string>();
+	for (const name of teammates.keys()) names.add(name);
+	for (const m of cfgMembers) {
+		if (m.role === "worker" && m.status === "online") names.add(m.name);
+	}
+	for (const t of tasks) {
+		if (t.owner && t.owner !== leadName && t.status === "in_progress") names.add(t.owner);
+	}
+
+	return Array.from(names).sort();
+}

package/extensions/teams/teams-widget.ts

@@ -0,0 +1,212 @@
+import { truncateToWidth, visibleWidth } from "indusagi/tui";
+import type { Component, TUI } from "indusagi/tui";
+import type { Theme, ThemeColor } from "indusagi-coding-agent";
+import type { TeammateRpc, TeammateStatus } from "./teammate-rpc.js";
+import type { ActivityTracker } from "./activity-tracker.js";
+import type { TeamTask } from "./task-store.js";
+import type { TeamConfig, TeamMember } from "./team-config.js";
+import type { TeamsStyle } from "./teams-style.js";
+import { formatMemberDisplayName, getTeamsStrings } from "./teams-style.js";
+import {
+	STATUS_COLOR,
+	STATUS_ICON,
+	formatTokens,
+	getVisibleWorkerNames,
+	padRight,
+	resolveStatus,
+	toolActivity,
+} from "./teams-ui-shared.js";
+
+export interface WidgetDeps {
+	getTeammates(): Map<string, TeammateRpc>;
+	getTracker(): ActivityTracker;
+	getTasks(): TeamTask[];
+	getTeamConfig(): TeamConfig | null;
+	getStyle(): TeamsStyle;
+	isDelegateMode(): boolean;
+	getActiveTeamId(): string | null;
+	getSessionTeamId(): string | null;
+}
+
+export type WidgetFactory = (tui: TUI, theme: Theme) => Component;
+
+interface WidgetRow {
+	icon: string; // raw char (before styling)
+	iconColor: ThemeColor;
+	displayName: string;
+	statusKey: TeammateStatus;
+	pending: number;
+	completed: number;
+	tokensStr: string; // "—" for chairman
+	activityText: string;
+}
+
+function shortTeamId(teamId: string): string {
+	return teamId.length <= 12 ? teamId : `${teamId.slice(0, 8)}…`;
+}
+
+function hasQualityGateFailure(task: TeamTask): boolean {
+	return task.metadata?.["qualityGateStatus"] === "failed";
+}
+
+export function createTeamsWidget(deps: WidgetDeps): WidgetFactory {
+	return (_tui: TUI, theme: Theme): Component => {
+		return {
+			render(width: number): string[] {
+				const teammates = deps.getTeammates();
+				const tracker = deps.getTracker();
+				const tasks = deps.getTasks();
+				const teamConfig = deps.getTeamConfig();
+				const style = deps.getStyle();
+				const strings = getTeamsStrings(style);
+				const delegateMode = deps.isDelegateMode();
+
+				// Hide when no active team state.
+				// We intentionally ignore "completed-only" task lists so the widget doesn't stick around
+				// after /team shutdown.
+				const hasOnlineMembers = (teamConfig?.members ?? []).some(
+					(m) => m.role === "worker" && m.status === "online",
+				);
+				const hasActiveTasks = tasks.some((t) => t.status !== "completed");
+				if (teammates.size === 0 && !hasOnlineMembers && !hasActiveTasks) {
+					return [];
+				}
+
+				const lines: string[] = [];
+
+				// ── Header line ──
+				let header = " " + theme.bold(theme.fg("accent", "Teams"));
+				if (delegateMode) header += " " + theme.fg("warning", "[delegate]");
+				lines.push(truncateToWidth(header, width));
+
+				const activeTeamId = deps.getActiveTeamId();
+				const sessionTeamId = deps.getSessionTeamId();
+				if (activeTeamId && sessionTeamId && activeTeamId !== sessionTeamId) {
+					const attachLine = theme.fg(
+						"warning",
+						` attached: ${shortTeamId(activeTeamId)} (session ${shortTeamId(sessionTeamId)}) · /team detach`,
+					);
+					lines.push(truncateToWidth(attachLine, width));
+				}
+
+				const qgFailures = tasks.filter((task) => hasQualityGateFailure(task)).length;
+				if (qgFailures > 0) {
+					lines.push(
+						truncateToWidth(theme.fg("warning", ` quality gate failures: ${qgFailures} · /team task list`), width),
+					);
+				}
+
+				// ── Build row data ──
+				const cfgMembers = teamConfig?.members ?? [];
+				const cfgByName = new Map<string, TeamMember>();
+				for (const m of cfgMembers) cfgByName.set(m.name, m);
+
+				const rows: WidgetRow[] = [];
+
+				// Leader control row (always first when team is active)
+				const leadName = teamConfig?.leadName;
+				if (leadName) {
+					const leadTasks = tasks.filter((t) => t.owner === leadName);
+					rows.push({
+						icon: "\u25c6",
+						iconColor: "accent",
+						displayName: strings.leaderControlTitle,
+						statusKey: "idle",
+						pending: leadTasks.filter((t) => t.status === "pending").length,
+						completed: leadTasks.filter((t) => t.status === "completed").length,
+						tokensStr: "\u2014",
+						activityText: "",
+					});
+				}
+
+				const workerNames = getVisibleWorkerNames({ teammates, teamConfig, tasks });
+				if (workerNames.length === 0 && rows.length === 0) {
+					lines.push(
+						truncateToWidth(
+							" " + theme.fg("dim", `(no ${strings.memberTitle.toLowerCase()}s)  /team spawn <name>`),
+							width,
+						),
+					);
+				} else {
+					for (const name of workerNames) {
+						const rpc = teammates.get(name);
+						const cfg = cfgByName.get(name);
+						const statusKey = resolveStatus(rpc, cfg);
+						const activity = tracker.get(name);
+						const owned = tasks.filter((t) => t.owner === name);
+
+						rows.push({
+							icon: STATUS_ICON[statusKey],
+							iconColor: STATUS_COLOR[statusKey],
+							displayName: formatMemberDisplayName(style, name),
+							statusKey,
+							pending: owned.filter((t) => t.status === "pending").length,
+							completed: owned.filter((t) => t.status === "completed").length,
+							tokensStr: formatTokens(activity.totalTokens),
+							activityText: toolActivity(activity.currentToolName),
+						});
+					}
+
+					// ── Compute column widths ──
+					const totalPending = tasks.filter((t) => t.status === "pending").length;
+					const totalCompleted = tasks.filter((t) => t.status === "completed").length;
+					let totalTokensRaw = 0;
+					for (const name of workerNames) totalTokensRaw += tracker.get(name).totalTokens;
+					const totalTokensStr = formatTokens(totalTokensRaw);
+
+					const nameColWidth = Math.max(...rows.map((r) => visibleWidth(r.displayName)));
+					const pW = Math.max(...rows.map((r) => String(r.pending).length), String(totalPending).length);
+					const cW = Math.max(...rows.map((r) => String(r.completed).length), String(totalCompleted).length);
+					const tokW = Math.max(...rows.map((r) => r.tokensStr.length), totalTokensStr.length);
+
+					// ── Render rows ──
+					for (const r of rows) {
+						const icon = theme.fg(r.iconColor, r.icon);
+						const styledName = theme.bold(r.displayName);
+						const statusLabel = theme.fg(STATUS_COLOR[r.statusKey], padRight(r.statusKey, 9));
+						const pNum = String(r.pending).padStart(pW);
+						const cNum = String(r.completed).padStart(cW);
+						const tokStr = r.tokensStr.padStart(tokW);
+						const cols = theme.fg(
+							"dim",
+							` \u00b7 ${pNum} pending \u00b7 ${cNum} complete \u00b7 ${tokStr} tokens`,
+						);
+						const actLabel = r.activityText ? "  " + theme.fg("warning", r.activityText) : "";
+
+						const row = ` ${icon} ${padRight(styledName, nameColWidth)} ${statusLabel}${cols}${actLabel}`;
+						lines.push(truncateToWidth(row, width));
+					}
+
+					// ── Total row ──
+					const sepLine = " " + theme.fg("dim", "\u2500".repeat(Math.max(0, width - 2)));
+					lines.push(truncateToWidth(sepLine, width));
+
+					const totalLabel = theme.bold("Total");
+					const totalTaskCount = totalPending + totalCompleted;
+					const pct = totalTaskCount > 0 ? Math.round((totalCompleted / totalTaskCount) * 100) : 0;
+					const pctLabel = theme.fg("success", padRight(`${pct}%`, 9));
+					const tpNum = String(totalPending).padStart(pW);
+					const tcNum = String(totalCompleted).padStart(cW);
+					const ttokStr = totalTokensStr.padStart(tokW);
+					const totalSuffix = theme.fg(
+						"muted",
+						` \u00b7 ${tpNum} pending \u00b7 ${tcNum} complete \u00b7 ${ttokStr} tokens`,
+					);
+					// nameColWidth + 4 = " ◆ " + name; then " " + pctLabel fills the status column
+					const totalRow = ` ${padRight(totalLabel, nameColWidth + 3)} ${pctLabel}${totalSuffix}`;
+					lines.push(truncateToWidth(totalRow, width));
+				}
+
+				// ── Hints line ──
+				const hints = theme.fg(
+					"dim",
+					" /team widget \u00b7 /team dm <name> <msg> \u00b7 /team task list",
+				);
+				lines.push(truncateToWidth(hints, width));
+
+				return lines;
+			},
+			invalidate() {},
+		};
+	};
+}