@selesai/code 0.6.3 → 0.8.0

package/dist/extensions/pi-subagents/src/slash/delegation-request.ts

@@ -1,40 +1,15 @@
 import {
-	SUBAGENT_DELEGATION_PROTOCOL_VERSION,
-	SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
 	type SubagentDelegationRequest,
-	type SubagentDelegationV2Request,
 } from "../api/delegation.ts";
-import { validateAcceptanceInput } from "../runs/shared/acceptance.ts";
 import { validateToolBudgetConfig } from "../runs/shared/tool-budget.ts";
 import { resolveTurnBudgetConfig } from "../runs/shared/turn-budget.ts";
 import { cloneJsonWithinByteLimit } from "./delegation-json.ts";
 
 export type SubagentDelegationParseResult =
-	| { ok: true; request: SubagentDelegationRequest | SubagentDelegationV2Request }
-	| { ok: false; version?: 1 | 2; requestId?: string; ownerRunId?: string; nodeId?: string; error: string };
+	| { ok: true; request: SubagentDelegationRequest }
+	| { ok: false; requestId?: string; ownerRunId?: string; nodeId?: string; error: string };
 
-const v1SupportedFields = new Set([
-	"version",
-	"requestId",
-	"agent",
-	"task",
-	"context",
-	"cwd",
-	"model",
-	"timeoutMs",
-	"turnBudget",
-	"toolBudget",
-	"skill",
-	"output",
-	"outputMode",
-	"outputSchema",
-	"agentContract",
-	"acceptance",
-	"artifacts",
-]);
-
-const v2SupportedFields = new Set([
-	"version",
+const supportedFields = new Set([
 	"requestId",
 	"ownerRunId",
 	"nodeId",
@@ -52,13 +27,13 @@ const v2SupportedFields = new Set([
 	"result",
 ]);
 
-const v2ThinkingLevels = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+const thinkingLevels = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
 const MAX_SCHEMA_BYTES = 64 * 1024;
-const MAX_V2_TASK_BYTES = 1024 * 1024;
-const MAX_V2_CWD_BYTES = 32 * 1024;
-const MAX_V2_SHORT_TEXT_BYTES = 1024;
-const MAX_V2_SKILL_ENTRIES = 256;
-const MAX_V2_SKILL_AGGREGATE_BYTES = 64 * 1024;
+const MAX_TASK_BYTES = 1024 * 1024;
+const MAX_CWD_BYTES = 32 * 1024;
+const MAX_SHORT_TEXT_BYTES = 1024;
+const MAX_SKILL_ENTRIES = 256;
+const MAX_SKILL_AGGREGATE_BYTES = 64 * 1024;
 
 function nonEmptyString(value: unknown): value is string {
 	return typeof value === "string" && value.trim().length > 0;
@@ -69,10 +44,26 @@ function validateId(value: unknown): string | undefined {
 	return value;
 }
 
-function validateSharedFields(
-	value: Record<string, unknown>,
-	identity: { requestId: string; version?: 1 | 2; ownerRunId?: string; nodeId?: string },
-): SubagentDelegationParseResult | undefined {
+export function parseSubagentDelegationRequest(data: unknown): SubagentDelegationParseResult {
+	if (!data || typeof data !== "object" || Array.isArray(data)) {
+		return { ok: false, error: "Delegation request must be an object." };
+	}
+	const value = data as Record<string, unknown>;
+	const requestId = validateId(value.requestId);
+	if (!requestId) {
+		return { ok: false, error: "Delegation requestId must be a non-empty string of at most 256 characters without newlines." };
+	}
+	const ownerRunId = validateId(value.ownerRunId);
+	if (!ownerRunId) {
+		return { ok: false, requestId, error: "Delegation ownerRunId must be a non-empty string of at most 256 characters without newlines." };
+	}
+	const nodeId = validateId(value.nodeId);
+	if (!nodeId) {
+		return { ok: false, requestId, ownerRunId, error: "Delegation nodeId must be a non-empty string of at most 256 characters without newlines." };
+	}
+	const identity = { requestId, ownerRunId, nodeId };
+	const unsupportedField = Object.keys(value).find((key) => !supportedFields.has(key));
+	if (unsupportedField) return { ok: false, ...identity, error: `Unsupported delegation field: ${unsupportedField}.` };
 	if (!nonEmptyString(value.agent)) return { ok: false, ...identity, error: "Delegation agent must be a non-empty string." };
 	if (!nonEmptyString(value.task)) return { ok: false, ...identity, error: "Delegation task must be a non-empty string." };
 	if (value.context !== "fresh" && value.context !== "fork") {
@@ -85,8 +76,9 @@ function validateSharedFields(
 	if (value.timeoutMs !== undefined && (typeof value.timeoutMs !== "number" || !Number.isInteger(value.timeoutMs) || value.timeoutMs < 1)) {
 		return { ok: false, ...identity, error: "timeoutMs must be an integer >= 1." };
 	}
-	if (identity.version === SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION && value.timeoutMs !== undefined && value.timeoutMs > 2_147_483_647) {
-		return { ok: false, ...identity, error: "timeoutMs must be <= 2147483647 for delegation v2." };
+	const timeoutMs = typeof value.timeoutMs === "number" ? value.timeoutMs : undefined;
+	if (timeoutMs !== undefined && timeoutMs > 2_147_483_647) {
+		return { ok: false, ...identity, error: "timeoutMs must be <= 2147483647." };
 	}
 	const turnBudget = resolveTurnBudgetConfig(value.turnBudget);
 	if (turnBudget.error) return { ok: false, ...identity, error: turnBudget.error };
@@ -96,11 +88,7 @@ function validateSharedFields(
 			return { ok: false, ...identity, error: `toolBudget.${unsupportedToolBudgetField} is not supported.` };
 		}
 	}
-	const toolBudget = validateToolBudgetConfig(
-		value.toolBudget,
-		"toolBudget",
-		identity.version === SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION ? { minimumHard: 0 } : undefined,
-	);
+	const toolBudget = validateToolBudgetConfig(value.toolBudget, "toolBudget", { minimumHard: 0 });
 	if (toolBudget.error) return { ok: false, ...identity, error: toolBudget.error };
 	if (value.skill !== undefined) {
 		const validSkill = typeof value.skill === "boolean"
@@ -113,46 +101,29 @@ function validateSharedFields(
 	if (value.artifacts !== undefined && typeof value.artifacts !== "boolean") {
 		return { ok: false, ...identity, error: "artifacts must be a boolean." };
 	}
-	return undefined;
-}
-
-function parseV2(value: Record<string, unknown>, requestId: string): SubagentDelegationParseResult {
-	const ownerRunId = validateId(value.ownerRunId);
-	if (!ownerRunId) {
-		return { ok: false, version: 2, requestId, error: "Delegation ownerRunId must be a non-empty string of at most 256 characters without newlines." };
-	}
-	const nodeId = validateId(value.nodeId);
-	if (!nodeId) {
-		return { ok: false, version: 2, requestId, ownerRunId, error: "Delegation nodeId must be a non-empty string of at most 256 characters without newlines." };
-	}
-	const identity = { version: 2 as const, requestId, ownerRunId, nodeId };
-	const unsupportedField = Object.keys(value).find((key) => !v2SupportedFields.has(key));
-	if (unsupportedField) return { ok: false, ...identity, error: `Unsupported delegation field: ${unsupportedField}.` };
-	const sharedError = validateSharedFields(value, identity);
-	if (sharedError) return sharedError;
-	if (Buffer.byteLength(value.task as string, "utf8") > MAX_V2_TASK_BYTES) {
+	if (Buffer.byteLength(value.task as string, "utf8") > MAX_TASK_BYTES) {
 		return { ok: false, ...identity, error: "Delegation task exceeds 1 MiB when UTF-8 encoded." };
 	}
-	if (Buffer.byteLength(value.cwd as string, "utf8") > MAX_V2_CWD_BYTES) {
+	if (Buffer.byteLength(value.cwd as string, "utf8") > MAX_CWD_BYTES) {
 		return { ok: false, ...identity, error: "Delegation cwd exceeds 32 KiB when UTF-8 encoded." };
 	}
-	if (Buffer.byteLength(value.agent as string, "utf8") > MAX_V2_SHORT_TEXT_BYTES) {
+	if (Buffer.byteLength(value.agent as string, "utf8") > MAX_SHORT_TEXT_BYTES) {
 		return { ok: false, ...identity, error: "Delegation agent exceeds 1 KiB when UTF-8 encoded." };
 	}
-	if (typeof value.model === "string" && Buffer.byteLength(value.model, "utf8") > MAX_V2_SHORT_TEXT_BYTES) {
+	if (typeof value.model === "string" && Buffer.byteLength(value.model, "utf8") > MAX_SHORT_TEXT_BYTES) {
 		return { ok: false, ...identity, error: "Delegation model exceeds 1 KiB when UTF-8 encoded." };
 	}
 	const skillEntries = typeof value.skill === "string" ? [value.skill] : Array.isArray(value.skill) ? value.skill as string[] : [];
-	if (skillEntries.length > MAX_V2_SKILL_ENTRIES) {
+	if (skillEntries.length > MAX_SKILL_ENTRIES) {
 		return { ok: false, ...identity, error: "Delegation skill supports at most 256 entries." };
 	}
-	if (skillEntries.some((entry) => Buffer.byteLength(entry, "utf8") > MAX_V2_SHORT_TEXT_BYTES)) {
+	if (skillEntries.some((entry) => Buffer.byteLength(entry, "utf8") > MAX_SHORT_TEXT_BYTES)) {
 		return { ok: false, ...identity, error: "Delegation skill entry exceeds 1 KiB when UTF-8 encoded." };
 	}
-	if (skillEntries.reduce((total, entry) => total + Buffer.byteLength(entry, "utf8"), 0) > MAX_V2_SKILL_AGGREGATE_BYTES) {
+	if (skillEntries.reduce((total, entry) => total + Buffer.byteLength(entry, "utf8"), 0) > MAX_SKILL_AGGREGATE_BYTES) {
 		return { ok: false, ...identity, error: "Delegation skill entries exceed 64 KiB in aggregate when UTF-8 encoded." };
 	}
-	if (value.thinking !== undefined && (typeof value.thinking !== "string" || !v2ThinkingLevels.has(value.thinking))) {
+	if (value.thinking !== undefined && (typeof value.thinking !== "string" || !thinkingLevels.has(value.thinking))) {
 		return { ok: false, ...identity, error: "thinking must be one of off, minimal, low, medium, high, xhigh, or max." };
 	}
 	if (!value.result || typeof value.result !== "object" || Array.isArray(value.result)) {
@@ -170,7 +141,7 @@ function parseV2(value: Record<string, unknown>, requestId: string): SubagentDel
 			return { ok: false, ...identity, error: "result.schema must be a JSON Schema object." };
 		}
 		const inspectedSchema = cloneJsonWithinByteLimit(result.schema, MAX_SCHEMA_BYTES);
-		if (!inspectedSchema.ok) {
+		if (inspectedSchema.ok === false) {
 			return {
 				ok: false,
 				...identity,
@@ -190,60 +161,6 @@ function parseV2(value: Record<string, unknown>, requestId: string): SubagentDel
 			result: structuredSchema
 				? { kind: "structured", schema: structuredSchema }
 				: { kind: "text" },
-		} as unknown as SubagentDelegationV2Request,
+		} as unknown as SubagentDelegationRequest,
 	};
 }
-
-function parseV1(value: Record<string, unknown>, requestId: string): SubagentDelegationParseResult {
-	const unsupportedField = Object.keys(value).find((key) => !v1SupportedFields.has(key));
-	if (unsupportedField) return { ok: false, requestId, error: `Unsupported delegation field: ${unsupportedField}.` };
-	const sharedError = validateSharedFields(value, { requestId });
-	if (sharedError) return sharedError;
-	if (value.output !== undefined && typeof value.output !== "boolean" && !nonEmptyString(value.output)) {
-		return { ok: false, requestId, error: "output must be a boolean or non-empty string." };
-	}
-	if (value.outputMode !== undefined && value.outputMode !== "inline" && value.outputMode !== "file-only") {
-		return { ok: false, requestId, error: "outputMode must be inline or file-only." };
-	}
-	if (value.outputMode === "file-only" && !nonEmptyString(value.output)) {
-		return { ok: false, requestId, error: 'outputMode "file-only" requires output to be a non-empty path.' };
-	}
-	if (value.outputSchema !== undefined && (!value.outputSchema || typeof value.outputSchema !== "object" || Array.isArray(value.outputSchema))) {
-		return { ok: false, requestId, error: "outputSchema must be a JSON Schema object." };
-	}
-	if (value.agentContract !== undefined) {
-		if (!value.agentContract || typeof value.agentContract !== "object" || Array.isArray(value.agentContract)) return { ok: false, requestId, error: "agentContract must be an object." };
-		const contract = value.agentContract as Record<string, unknown>;
-		if (contract.version !== 1 || Object.keys(contract).some((key) => key !== "version")) return { ok: false, requestId, error: "agentContract must be { version: 1 }." };
-	}
-	const acceptanceErrors = validateAcceptanceInput(value.acceptance);
-	if (acceptanceErrors.length > 0) return { ok: false, requestId, error: acceptanceErrors.join(" ") };
-	return { ok: true, request: value as unknown as SubagentDelegationRequest };
-}
-
-export function parseSubagentDelegationRequest(data: unknown): SubagentDelegationParseResult {
-	if (!data || typeof data !== "object" || Array.isArray(data)) {
-		return { ok: false, error: "Delegation request must be an object." };
-	}
-	const value = data as Record<string, unknown>;
-	const requestId = validateId(value.requestId);
-	if (value.version !== SUBAGENT_DELEGATION_PROTOCOL_VERSION && value.version !== SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION) {
-		return {
-			...(requestId ? { requestId } : {}),
-			ok: false,
-			error: `Unsupported delegation protocol version: ${String(value.version)}.`,
-		};
-	}
-	if (!requestId) {
-		return { ok: false, error: "Delegation requestId must be a non-empty string of at most 256 characters without newlines." };
-	}
-	if (value.version === SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION) {
-		// Preserve the v1 parser's historical diagnostic for a v1-shaped payload
-		// whose version alone was changed to 2.
-		if (!Object.hasOwn(value, "ownerRunId") && !Object.hasOwn(value, "nodeId") && !Object.hasOwn(value, "result")) {
-			return { ok: false, version: 2, requestId, error: "Unsupported delegation protocol version: 2." };
-		}
-		return parseV2(value, requestId);
-	}
-	return parseV1(value, requestId);
-}

package/dist/extensions/pi-subagents/src/slash/inline-subagents.ts

@@ -0,0 +1,136 @@
+import type { ExtensionAPI } from "@selesai/code";
+import type { AutocompleteItem, AutocompleteProvider } from "@earendil-works/pi-tui";
+import { discoverAgents, resolveAgentName, type AgentConfig } from "../agents/agents.ts";
+import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
+import type { SubagentState } from "../shared/types.ts";
+import { launchSlashSubagent } from "./slash-commands.ts";
+
+/** `#agent-name` anywhere in a message (start, middle, or end), like `$skill-name`. */
+const INLINE_AGENT_TOKEN_RE = /(^|[^a-z0-9_-])#([a-z0-9]+(?:-[a-z0-9]+)*)(?![a-z0-9_-])/i;
+
+/**
+ * Parse an inline subagent invocation from raw input.
+ * Returns the (lowercased) agent name, the task text after the mention, and
+ * whether the mention is at the start of the input (leading whitespace counts).
+ * Returns null when the text contains no `#agent-name` token.
+ */
+export function parseInlineSubagentInput(text: string): { agentName: string; task: string; atStart: boolean } | null {
+	const match = text.match(INLINE_AGENT_TOKEN_RE);
+	if (!match) return null;
+	const index = match.index ?? 0;
+	return {
+		agentName: (match[2] ?? "").toLowerCase(),
+		task: text.slice(index + match[0].length).trim(),
+		atStart: text.slice(0, index).trim() === "",
+	};
+}
+
+/** Text before the cursor: `#` optionally followed by a partial agent name (anywhere on the line). */
+function getInlineAgentToken(textBeforeCursor: string): string | undefined {
+	const match = textBeforeCursor.match(/(?:^|[^a-z0-9_-])#([a-z0-9-]*)$/i);
+	return match ? match[1] ?? "" : undefined;
+}
+
+// Agent discovery walks builtin+user+project+package agent dirs and node_modules,
+// which is far too slow to run synchronously on every `#` keystroke (it blocks the
+// event loop and the editor drops results while typing). Cache per cwd with a short
+// TTL so the picker is responsive; a failed discovery is cached as empty so a single
+// malformed agent file cannot keep blocking the editor (nor reject its shared
+// autocomplete request chain, which would permanently kill all autocomplete).
+const AGENT_DISCOVERY_CACHE_TTL_MS = 5_000;
+const agentDiscoveryCache = new Map<string, { expiry: number; agents: AgentConfig[] }>();
+
+function discoverAgentsForPicker(cwd: string): AgentConfig[] {
+	const now = Date.now();
+	const cached = agentDiscoveryCache.get(cwd);
+	if (cached && cached.expiry > now) {
+		return cached.agents;
+	}
+	let agents: AgentConfig[] = [];
+	try {
+		agents = discoverAgents(cwd, "both").agents;
+	} catch {
+		// Never let agent discovery break autocomplete; the editor's shared request
+		// chain stays poisoned forever after a single rejected getSuggestions.
+	}
+	agentDiscoveryCache.set(cwd, { expiry: now + AGENT_DISCOVERY_CACHE_TTL_MS, agents });
+	return agents;
+}
+
+export function createInlineSubagentAutocompleteProvider(
+	state: SubagentState,
+	current: AutocompleteProvider,
+): AutocompleteProvider {
+	return {
+		triggerCharacters: ["#"],
+		async getSuggestions(lines, cursorLine, cursorCol, options) {
+			// Like the $ skill picker, # works anywhere on the current line, not just
+			// at the start of the message.
+			if (!state.baseCwd) {
+				return current.getSuggestions(lines, cursorLine, cursorCol, options);
+			}
+			const token = getInlineAgentToken((lines[cursorLine] ?? "").slice(0, cursorCol));
+			if (token === undefined) {
+				return current.getSuggestions(lines, cursorLine, cursorCol, options);
+			}
+
+			const items: AutocompleteItem[] = discoverAgentsForPicker(state.baseCwd)
+				.filter((agent) => agent.name.includes(token.toLowerCase()))
+				.map((agent) => ({
+					value: `#${agent.name}`,
+					label: `#${agent.name}`,
+					description: agent.description,
+				}));
+
+			return items.length > 0
+				? { prefix: `#${token}`, items }
+				: current.getSuggestions(lines, cursorLine, cursorCol, options);
+		},
+		applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+			return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+		},
+		shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+			return current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
+		},
+	};
+}
+
+/**
+ * `#agent-name [task]` inline subagent invocation: typing `#` anywhere in a
+ * message suggests installed agents; sending a message that contains
+ * `#agent-name` runs that agent (same path as `/run agent task`) instead of
+ * sending the text to the main agent.
+ */
+export function registerInlineSubagentInvocation(pi: ExtensionAPI, state: SubagentState): void {
+	pi.on("session_start", (_event, ctx) => {
+		ctx.ui.addAutocompleteProvider((current) => createInlineSubagentAutocompleteProvider(state, current));
+	});
+
+	pi.on("input", (event, ctx) => {
+		if (event.source === "extension") return { action: "continue" };
+
+		const parsed = parseInlineSubagentInput(event.text);
+		if (!parsed) return { action: "continue" };
+		if (!state.baseCwd) return { action: "continue" };
+
+		const agents = discoverAgents(state.baseCwd, "both").agents;
+		const resolved = resolveAgentName(parsed.agentName, agents);
+		if (resolved.error || !resolved.agent) {
+			// A #mention that does not resolve only consumes the input when it is an
+			// explicit invocation at the start of the message. Mid-message mentions
+			// (e.g. "issue #42") must never swallow the user's text.
+			if (!parsed.atStart) return { action: "continue" };
+			ctx.ui.notify?.(resolved.error ?? `Unknown subagent: #${parsed.agentName}`, "warning");
+			return { action: "handled" };
+		}
+
+		const params: SubagentParamsLike = {
+			agent: resolved.agent.name,
+			task: parsed.task,
+			clarify: false,
+			agentScope: "both",
+		};
+		launchSlashSubagent(pi, ctx, params);
+		return { action: "handled" };
+	});
+}