@leing2021/super-pi 0.21.0 → 0.22.1

package/extensions/subagent/chain-serializer.ts

@@ -0,0 +1,127 @@
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
+import type { ChainConfig, ChainStepConfig } from "./agents.ts";
+import { parseFrontmatter } from "./frontmatter.ts";
+
+function parseStepBody(agent: string, sectionBody: string): ChainStepConfig {
+	const lines = sectionBody.split("\n");
+	const blankIndex = lines.findIndex((line) => line.trim() === "");
+	const configLines = blankIndex === -1 ? lines : lines.slice(0, blankIndex);
+	const task = (blankIndex === -1 ? "" : lines.slice(blankIndex + 1).join("\n")).trim();
+
+	const step: ChainStepConfig = { agent, task };
+	for (const line of configLines) {
+		const match = line.match(/^([\w-]+):\s*(.*)$/);
+		if (!match) continue;
+		const key = match[1].trim().toLowerCase();
+		const rawValue = match[2].trim();
+
+		if (key === "output") {
+			if (rawValue === "false") step.output = false;
+			else if (rawValue) step.output = rawValue;
+			continue;
+		}
+		if (key === "reads") {
+			if (rawValue === "false") {
+				step.reads = false;
+			} else {
+				const reads = rawValue
+					.split(",")
+					.map((v) => v.trim())
+					.filter(Boolean);
+				step.reads = reads.length > 0 ? reads : false;
+			}
+			continue;
+		}
+		if (key === "model") {
+			if (rawValue) step.model = rawValue;
+			continue;
+		}
+		if (key === "skills") {
+			if (rawValue === "false") {
+				step.skills = false;
+			} else {
+				const skills = rawValue
+					.split(",")
+					.map((v) => v.trim())
+					.filter(Boolean);
+				step.skills = skills.length > 0 ? skills : false;
+			}
+			continue;
+		}
+		if (key === "progress") {
+			if (rawValue === "true") step.progress = true;
+			else if (rawValue === "false") step.progress = false;
+		}
+	}
+
+	return step;
+}
+
+export function parseChain(content: string, source: "user" | "project", filePath: string): ChainConfig {
+	const { frontmatter, body } = parseFrontmatter(content);
+	if (!frontmatter.name || !frontmatter.description) {
+		throw new Error("Chain frontmatter must include name and description");
+	}
+
+	const matches = [...body.matchAll(/^##\s+(.+)[^\S\n]*$/gm)];
+	const steps: ChainStepConfig[] = [];
+
+	for (let i = 0; i < matches.length; i++) {
+		const match = matches[i]!;
+		const agent = match[1]!.trim();
+		const lineEndOffset = body[match.index! + match[0].length] === "\n" ? 1 : 0;
+		const sectionStart = match.index! + match[0].length + lineEndOffset;
+		const sectionEnd = i + 1 < matches.length ? matches[i + 1]!.index! : body.length;
+		const sectionBody = body.slice(sectionStart, sectionEnd).trimEnd();
+		steps.push(parseStepBody(agent, sectionBody));
+	}
+
+	const extraFields: Record<string, string> = {};
+	for (const [key, value] of Object.entries(frontmatter)) {
+		if (key === "name" || key === "description") continue;
+		extraFields[key] = value;
+	}
+
+	return {
+		name: frontmatter.name,
+		description: frontmatter.description,
+		source,
+		filePath,
+		steps,
+		extraFields: Object.keys(extraFields).length > 0 ? extraFields : undefined,
+	};
+}
+
+export function serializeChain(config: ChainConfig): string {
+	const lines: string[] = [];
+	lines.push("---");
+	lines.push(`name: ${config.name}`);
+	lines.push(`description: ${config.description}`);
+	if (config.extraFields) {
+		for (const [key, value] of Object.entries(config.extraFields)) {
+			lines.push(`${key}: ${value}`);
+		}
+	}
+	lines.push("---");
+	lines.push("");
+
+	for (let i = 0; i < config.steps.length; i++) {
+		const step = config.steps[i]!;
+		lines.push(`## ${step.agent}`);
+		if (step.output === false) lines.push("output: false");
+		else if (step.output) lines.push(`output: ${step.output}`);
+		if (step.reads === false) lines.push("reads: false");
+		else if (Array.isArray(step.reads) && step.reads.length > 0) lines.push(`reads: ${step.reads.join(", ")}`);
+		if (step.model) lines.push(`model: ${step.model}`);
+		if (step.skills === false) lines.push("skills: false");
+		else if (Array.isArray(step.skills) && step.skills.length > 0) lines.push(`skills: ${step.skills.join(", ")}`);
+		if (step.progress !== undefined) lines.push(`progress: ${step.progress ? "true" : "false"}`);
+		lines.push("");
+		lines.push(step.task ?? "");
+		if (i < config.steps.length - 1) lines.push("");
+	}
+
+	return `${lines.join("\n")}\n`;
+}

package/extensions/subagent/completion-dedupe.ts

@@ -0,0 +1,66 @@
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
+interface CompletionDataLike {
+	id?: unknown;
+	agent?: unknown;
+	timestamp?: unknown;
+	sessionId?: unknown;
+	taskIndex?: unknown;
+	totalTasks?: unknown;
+	success?: unknown;
+}
+
+function asNonEmptyString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function asFiniteNumber(value: unknown): number | undefined {
+	if (typeof value !== "number") return undefined;
+	return Number.isFinite(value) ? value : undefined;
+}
+
+export function buildCompletionKey(data: CompletionDataLike, fallback: string): string {
+	const id = asNonEmptyString(data.id);
+	if (id) return `id:${id}`;
+	const sessionId = asNonEmptyString(data.sessionId) ?? "no-session";
+	const agent = asNonEmptyString(data.agent) ?? "unknown";
+	const timestamp = asFiniteNumber(data.timestamp);
+	const taskIndex = asFiniteNumber(data.taskIndex);
+	const totalTasks = asFiniteNumber(data.totalTasks);
+	const success = typeof data.success === "boolean" ? (data.success ? "1" : "0") : "?";
+	return [
+		"meta",
+		sessionId,
+		agent,
+		timestamp !== undefined ? String(timestamp) : "no-ts",
+		taskIndex !== undefined ? String(taskIndex) : "-",
+		totalTasks !== undefined ? String(totalTasks) : "-",
+		success,
+		fallback,
+	].join(":");
+}
+
+export function pruneSeenMap(seen: Map<string, number>, now: number, ttlMs: number): void {
+	for (const [key, ts] of seen.entries()) {
+		if (now - ts > ttlMs) seen.delete(key);
+	}
+}
+
+export function markSeenWithTtl(seen: Map<string, number>, key: string, now: number, ttlMs: number): boolean {
+	pruneSeenMap(seen, now, ttlMs);
+	if (seen.has(key)) return true;
+	seen.set(key, now);
+	return false;
+}
+
+export function getGlobalSeenMap(storeKey: string): Map<string, number> {
+	const globalStore = globalThis as Record<string, unknown>;
+	const existing = globalStore[storeKey];
+	if (existing instanceof Map) return existing as Map<string, number>;
+	const map = new Map<string, number>();
+	globalStore[storeKey] = map;
+	return map;
+}

package/extensions/subagent/doctor.ts

@@ -0,0 +1,201 @@
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { discoverAgentsAll, type AgentSource } from "./agents.ts";
+import { isAsyncAvailable } from "./async-execution.ts";
+import { diagnoseIntercomBridge, type IntercomBridgeDiagnostic } from "./intercom-bridge.ts";
+import { discoverAvailableSkills, type SkillSource } from "./skills.ts";
+import {
+	ASYNC_DIR,
+	CHAIN_RUNS_DIR,
+	RESULTS_DIR,
+	TEMP_ROOT_DIR,
+	type ExtensionConfig,
+	type SubagentState,
+} from "./types.ts";
+
+interface DoctorPaths {
+	tempRootDir: string;
+	asyncDir: string;
+	resultsDir: string;
+	chainRunsDir: string;
+}
+
+interface DoctorDeps {
+	isAsyncAvailable: () => boolean;
+	discoverAgentsAll: typeof discoverAgentsAll;
+	discoverAvailableSkills: typeof discoverAvailableSkills;
+	diagnoseIntercomBridge: typeof diagnoseIntercomBridge;
+}
+
+export interface DoctorReportInput {
+	cwd: string;
+	config: ExtensionConfig;
+	state: SubagentState;
+	context?: "fresh" | "fork";
+	requestedSessionDir?: string;
+	currentSessionFile?: string | null;
+	currentSessionId?: string | null;
+	orchestratorTarget?: string;
+	sessionError?: string;
+	expandTilde?: (value: string) => string;
+	paths?: DoctorPaths;
+	deps?: Partial<DoctorDeps>;
+}
+
+const DEFAULT_PATHS: DoctorPaths = {
+	tempRootDir: TEMP_ROOT_DIR,
+	asyncDir: ASYNC_DIR,
+	resultsDir: RESULTS_DIR,
+	chainRunsDir: CHAIN_RUNS_DIR,
+};
+
+const DEFAULT_DEPS: DoctorDeps = {
+	isAsyncAvailable,
+	discoverAgentsAll,
+	discoverAvailableSkills,
+	diagnoseIntercomBridge,
+};
+
+function errorText(error: unknown): string {
+	return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+}
+
+function lineFromCheck(label: string, check: () => string): string {
+	try {
+		return check();
+	} catch (error) {
+		return `- ${label}: failed — ${errorText(error)}`;
+	}
+}
+
+function formatExistingDirectory(label: string, dirPath: string): string {
+	try {
+		if (!fs.existsSync(dirPath)) return `- ${label}: missing (${dirPath})`;
+		const stats = fs.statSync(dirPath);
+		if (!stats.isDirectory()) throw new Error(`not a directory: ${dirPath}`);
+		fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
+		return `- ${label}: ok (${dirPath})`;
+	} catch (error) {
+		return `- ${label}: failed (${dirPath}) — ${errorText(error)}`;
+	}
+}
+
+function formatSourceCounts(counts: Record<AgentSource, number>): string {
+	return `builtin ${counts.builtin}, user ${counts.user}, project ${counts.project}`;
+}
+
+function formatSkillSourceCounts(skills: Array<{ source: SkillSource }>): string {
+	const counts = new Map<SkillSource, number>();
+	for (const skill of skills) counts.set(skill.source, (counts.get(skill.source) ?? 0) + 1);
+	const ordered: SkillSource[] = [
+		"project",
+		"project-settings",
+		"project-package",
+		"user",
+		"user-settings",
+		"user-package",
+		"extension",
+		"builtin",
+		"unknown",
+	];
+	const parts = ordered
+		.map((source) => `${source} ${counts.get(source) ?? 0}`)
+		.filter((part) => !part.endsWith(" 0"));
+	return parts.length > 0 ? parts.join(", ") : "none";
+}
+
+function formatConfiguredSessionDir(input: DoctorReportInput): string {
+	if (input.requestedSessionDir) {
+		return path.resolve(input.expandTilde?.(input.requestedSessionDir) ?? input.requestedSessionDir);
+	}
+	if (input.config.defaultSessionDir) {
+		return path.resolve(input.expandTilde?.(input.config.defaultSessionDir) ?? input.config.defaultSessionDir);
+	}
+	return "not configured";
+}
+
+function formatSessionLines(input: DoctorReportInput): string[] {
+	const sessionFile = input.currentSessionFile ?? null;
+	const lines = [
+		lineFromCheck("configured session dir", () => `- configured session dir: ${formatConfiguredSessionDir(input)}`),
+		`- current session file: ${sessionFile ?? "not available"}`,
+		`- current session dir: ${sessionFile ? path.dirname(sessionFile) : "not available"}`,
+		`- current session id: ${input.currentSessionId ?? input.state.currentSessionId ?? "not available"}`,
+	];
+	if (input.sessionError) lines.push(`- session manager: failed — ${input.sessionError}`);
+	return lines;
+}
+
+function formatDiscovery(input: DoctorReportInput, deps: DoctorDeps): string[] {
+	return [
+		lineFromCheck("agents/chains", () => {
+			const discovered = deps.discoverAgentsAll(input.cwd);
+			const agentCounts = {
+				builtin: discovered.builtin.length,
+				user: discovered.user.length,
+				project: discovered.project.length,
+			};
+			const chainCounts = discovered.chains.reduce<Record<AgentSource, number>>((counts, chain) => {
+				counts[chain.source] += 1;
+				return counts;
+			}, { builtin: 0, user: 0, project: 0 });
+			return [
+				`- agents: total ${agentCounts.builtin + agentCounts.user + agentCounts.project} (${formatSourceCounts(agentCounts)})`,
+				`- chains: total ${discovered.chains.length} (${formatSourceCounts(chainCounts)})`,
+			].join("\n");
+		}),
+		lineFromCheck("skills", () => {
+			const skills = deps.discoverAvailableSkills(input.cwd);
+			return `- skills: total ${skills.length} (${formatSkillSourceCounts(skills)})`;
+		}),
+	];
+}
+
+function formatIntercomDiagnostic(diagnostic: IntercomBridgeDiagnostic, context: "fresh" | "fork" | undefined): string[] {
+	const lines = [
+		`- bridge: ${diagnostic.active ? "active" : "inactive"}${diagnostic.reason ? ` (${diagnostic.reason})` : ""}`,
+		`- mode: ${diagnostic.mode}; context: ${context ?? "unspecified"}`,
+		`- orchestrator target: ${diagnostic.orchestratorTarget ?? "not available"}`,
+		`- pi-intercom: ${diagnostic.piIntercomAvailable ? "available" : "unavailable"} at ${diagnostic.extensionDir}`,
+	];
+	if (diagnostic.configPath && diagnostic.intercomConfigEnabled !== undefined) {
+		lines.push(`- intercom config: ${diagnostic.intercomConfigEnabled === false ? "disabled" : "enabled or absent"} (${diagnostic.configPath})`);
+	}
+	if (diagnostic.intercomConfigError) {
+		lines.push(`- intercom config warning: ${diagnostic.intercomConfigError}; runtime assumes enabled`);
+	}
+	return lines;
+}
+
+export function buildDoctorReport(input: DoctorReportInput): string {
+	const paths = input.paths ?? DEFAULT_PATHS;
+	const deps = { ...DEFAULT_DEPS, ...input.deps };
+	const lines = [
+		"Subagents doctor report",
+		"",
+		"Runtime",
+		`- cwd: ${input.cwd}`,
+		lineFromCheck("async support", () => `- async support: ${deps.isAsyncAvailable() ? "available" : "unavailable"}`),
+		...formatSessionLines(input),
+		"",
+		"Filesystem",
+		formatExistingDirectory("temp root", paths.tempRootDir),
+		formatExistingDirectory("async runs", paths.asyncDir),
+		formatExistingDirectory("results", paths.resultsDir),
+		formatExistingDirectory("chain runs", paths.chainRunsDir),
+		"",
+		"Discovery",
+		...formatDiscovery(input, deps),
+		"",
+		"Intercom bridge",
+		...lineFromCheck("intercom bridge", () => formatIntercomDiagnostic(deps.diagnoseIntercomBridge({
+			config: input.config.intercomBridge,
+			context: input.context,
+			orchestratorTarget: input.orchestratorTarget,
+		}), input.context).join("\n")).split("\n"),
+	];
+	return lines.join("\n");
+}