@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/src/shared/display-text.ts

@@ -0,0 +1,100 @@
+function codePointWidth(codePoint: number): 1 | 2 {
+	return codePoint > 0xffff ? 2 : 1;
+}
+
+function isWhitespaceOrControl(codePoint: number): boolean {
+	if (codePoint <= 0x20 || (codePoint >= 0x7f && codePoint <= 0x9f)) return true;
+	if (codePoint >= 0xd800 && codePoint <= 0xdfff) return true;
+	return String.fromCodePoint(codePoint).trim().length === 0;
+}
+
+function consumeControlString(value: string, index: number, osc: boolean): number {
+	while (index < value.length) {
+		const codePoint = value.codePointAt(index)!;
+		const width = codePointWidth(codePoint);
+		if (osc && codePoint === 0x07) return index + width;
+		if (codePoint === 0x9c) return index + width;
+		if (codePoint === 0x1b && value.charCodeAt(index + 1) === 0x5c) return index + 2;
+		index += width;
+	}
+	return value.length;
+}
+
+function consumeCsi(value: string, index: number): number {
+	while (index < value.length) {
+		const codePoint = value.codePointAt(index)!;
+		const width = codePointWidth(codePoint);
+		if (codePoint >= 0x40 && codePoint <= 0x7e) return index + width;
+		index += width;
+	}
+	return value.length;
+}
+
+export function sanitizeDisplayText(value: string): string {
+	const output: string[] = [];
+	let pendingSpace = false;
+
+	const appendSpace = (): void => {
+		if (output.length > 0) pendingSpace = true;
+	};
+	const appendText = (text: string): void => {
+		if (pendingSpace) output.push(" ");
+		output.push(text);
+		pendingSpace = false;
+	};
+
+	for (let index = 0; index < value.length;) {
+		const codePoint = value.codePointAt(index)!;
+		const width = codePointWidth(codePoint);
+
+		if (codePoint === 0x1b) {
+			const next = value.charCodeAt(index + 1);
+			appendSpace();
+			if (next === 0x5b) {
+				index = consumeCsi(value, index + 2);
+				continue;
+			}
+			if (next === 0x5d || next === 0x50 || next === 0x58 || next === 0x5e || next === 0x5f) {
+				index = consumeControlString(value, index + 2, next === 0x5d);
+				continue;
+			}
+			index += next ? 2 : 1;
+			continue;
+		}
+
+		if (codePoint === 0x9b) {
+			appendSpace();
+			index = consumeCsi(value, index + width);
+			continue;
+		}
+		if (codePoint === 0x90 || codePoint === 0x98 || codePoint === 0x9d || codePoint === 0x9e || codePoint === 0x9f) {
+			appendSpace();
+			index = consumeControlString(value, index + width, codePoint === 0x9d);
+			continue;
+		}
+
+		if (isWhitespaceOrControl(codePoint)) appendSpace();
+		else appendText(String.fromCodePoint(codePoint));
+		index += width;
+	}
+
+	return output.join("");
+}
+
+export function truncateDisplayText(value: string, maxLength: number): string {
+	if (maxLength <= 0) return "";
+	if (value.length <= maxLength) return value;
+	let output = "";
+	for (const char of value) {
+		if (output.length + char.length > maxLength) break;
+		output += char;
+	}
+	return output;
+}
+
+export function previewDisplayText(value: string, maxLength: number): string {
+	const normalized = sanitizeDisplayText(value);
+	if (normalized.length <= maxLength) return normalized;
+	if (maxLength <= 3) return truncateDisplayText(normalized, maxLength);
+	return `${truncateDisplayText(normalized, maxLength - 3)}...`;
+}

package/dist/extensions/pi-subagents/src/shared/file-coalescer.ts

@@ -5,6 +5,7 @@ interface TimerApi {
 
 interface FileCoalescer {
 	schedule(file: string, delayMs?: number): boolean;
+	flush(file: string): boolean;
 	clear(): void;
 }
 
@@ -30,6 +31,14 @@ export function createFileCoalescer(
 			pending.set(file, timer);
 			return true;
 		},
+		flush(file: string): boolean {
+			const timer = pending.get(file);
+			if (timer === undefined) return false;
+			timerApi.clearTimeout(timer);
+			pending.delete(file);
+			handler(file);
+			return true;
+		},
 		clear(): void {
 			for (const timer of pending.values()) {
 				timerApi.clearTimeout(timer);

package/dist/extensions/pi-subagents/src/shared/fork-context.ts

@@ -9,6 +9,7 @@ type SubagentExecutionContext = "fresh" | "fork";
 interface BranchSessionEntry {
 	type: string;
 	id?: string;
+	cwd?: string;
 	parentId?: string | null;
 	timestamp?: string;
 	message?: {
@@ -128,6 +129,18 @@ function readSessionEntries(sessionFile: string): BranchSessionEntry[] {
 	});
 }
 
+/** Keep Pi from restoring a forked session into the parent's cwd instead of the child launch cwd. */
+export function alignForkedSessionCwd(sessionFile: string, cwd: string): void {
+	const entries = readSessionEntries(sessionFile);
+	const header = entries[0];
+	if (header?.type !== "session") throw new Error(`Forked session ${sessionFile} does not start with a session header.`);
+	const resolvedCwd = path.resolve(cwd);
+	const effectiveCwd = fs.realpathSync.native(resolvedCwd);
+	if (header.cwd === effectiveCwd) return;
+	header.cwd = effectiveCwd;
+	fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
+}
+
 export function createForkContextResolver(
 	sessionManager: ForkableSessionManager,
 	requestedContext: unknown,

package/dist/extensions/pi-subagents/src/shared/formatters.ts

@@ -7,6 +7,7 @@ import * as path from "node:path";
 import type { Usage, SingleResult } from "./types.ts";
 import type { ChainStep } from "./settings.ts";
 import { isDynamicParallelStep, isParallelStep } from "./settings.ts";
+import { previewDisplayText, sanitizeDisplayText } from "./display-text.ts";
 import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.ts";
 
 /**
@@ -100,8 +101,7 @@ export function formatToolCall(name: string, args: Record<string, unknown>, expa
 	switch (name) {
 		case "bash": {
 			const command = typeof args.command === "string" ? args.command : "";
-			const maxLength = expanded ? 240 : 60;
-			return `$ ${command.slice(0, maxLength)}${command.length > maxLength ? "..." : ""}`;
+			return `$ ${previewDisplayText(command, expanded ? 240 : 60)}`;
 		}
 		case "read":
 		case "write":
@@ -111,12 +111,10 @@ export function formatToolCall(name: string, args: Record<string, unknown>, expa
 				: typeof args.file_path === "string"
 					? args.file_path
 					: "";
-			return `${name} ${shortenPath(target)}`;
+			return `${name} ${sanitizeDisplayText(shortenPath(target))}`;
 		}
 		default: {
-			const s = JSON.stringify(args);
-			const maxLength = expanded ? 160 : 40;
-			return `${name} ${s.slice(0, maxLength)}${s.length > maxLength ? "..." : ""}`;
+			return `${name} ${previewDisplayText(JSON.stringify(args), expanded ? 160 : 40)}`;
 		}
 	}
 }

package/dist/extensions/pi-subagents/src/shared/prompt-resources.ts

@@ -0,0 +1,51 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseFrontmatter } from "../agents/frontmatter.ts";
+import { getAgentDir, getProjectConfigDir } from "./utils.ts";
+
+const PROMPT_REF_PATTERN = /^(package|user|project):([A-Za-z0-9][A-Za-z0-9._-]{0,127})$/;
+const PROMPT_VARIABLE_PATTERN = /\{\{(\w+)\}\}/g;
+
+type PromptVariable = string | number | boolean;
+
+export function getPromptDirectories(cwd: string) {
+	return {
+		package: path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "prompts"),
+		user: path.join(getAgentDir(), "prompts"),
+		project: path.join(getProjectConfigDir(cwd), "prompts"),
+	};
+}
+
+function promptVariables(vars: unknown): Record<string, PromptVariable> {
+	if (vars === undefined) return {};
+	if (!vars || typeof vars !== "object" || Array.isArray(vars)) throw new Error("prompts.render vars must be a plain object.");
+	const prototype = Object.getPrototypeOf(vars);
+	if (prototype !== null && prototype !== Object.prototype) throw new Error("prompts.render vars must be a plain object.");
+	for (const [name, value] of Object.entries(vars)) {
+		if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+			throw new Error(`prompts.render variable '${name}' must be a string, number, or boolean.`);
+		}
+	}
+	return vars as Record<string, PromptVariable>;
+}
+
+export function renderWorkflowPrompt(ref: string, vars: unknown, cwd: string): string {
+	const match = ref.match(PROMPT_REF_PATTERN);
+	if (!match) throw new Error("prompts.render ref must use package:<name>, user:<name>, or project:<name>.");
+	const scope = match[1] as keyof ReturnType<typeof getPromptDirectories>;
+	const name = match[2]!;
+	const filePath = path.join(getPromptDirectories(cwd)[scope], `${name}.md`);
+	let content: string;
+	try {
+		if (!fs.lstatSync(filePath).isFile()) throw new Error("not a regular file");
+		content = fs.readFileSync(filePath, "utf-8");
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		throw new Error(`Could not read prompt fragment '${ref}': ${detail}`);
+	}
+	const variables = promptVariables(vars);
+	return parseFrontmatter(content).body.trim().replace(PROMPT_VARIABLE_PATTERN, (placeholder, variable: string) => {
+		return Object.hasOwn(variables, variable) ? String(variables[variable]) : placeholder;
+	});
+}

package/dist/extensions/pi-subagents/src/shared/settings.ts

@@ -3,6 +3,7 @@
  */
 
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentConfig } from "../agents/agents.ts";
 import { normalizeSkillInput } from "../agents/skills.ts";
@@ -23,8 +24,10 @@ export interface ResolvedStepBehavior {
 	model?: string;
 }
 
+export type OutputOverrideInput = string | boolean;
+
 export interface StepOverrides {
-	output?: string | false;
+	output?: OutputOverrideInput;
 	outputMode?: OutputMode;
 	reads?: string[] | false;
 	progress?: boolean;
@@ -32,8 +35,10 @@ export interface StepOverrides {
 	model?: string;
 }
 
-function normalizeOutputOverride(output: string | false | undefined): string | false | undefined {
-	return output === "false" ? false : output;
+function normalizeOutputOverride(output: unknown): string | false | undefined {
+	if (output === false || output === "false") return false;
+	if (output === true || output === "true") return undefined;
+	return typeof output === "string" && output.length > 0 ? output : undefined;
 }
 
 // =============================================================================
@@ -49,7 +54,7 @@ export interface SequentialStep {
 	as?: string;
 	outputSchema?: JsonSchemaObject;
 	cwd?: string;
-	output?: string | false;
+	output?: OutputOverrideInput;
 	outputMode?: OutputMode;
 	reads?: string[] | false;
 	progress?: boolean;
@@ -71,7 +76,7 @@ export interface ParallelTaskItem {
 	outputSchema?: JsonSchemaObject;
 	cwd?: string;
 	count?: number;
-	output?: string | false;
+	output?: OutputOverrideInput;
 	outputMode?: OutputMode;
 	reads?: string[] | false;
 	progress?: boolean;
@@ -123,7 +128,7 @@ export interface CheckpointStep {
 	agent?: string;
 	task?: string;
 	as?: string;
-	output?: string | false;
+	output?: OutputOverrideInput;
 	outputMode?: OutputMode;
 	reads?: string[] | false;
 	progress?: boolean;
@@ -330,10 +335,34 @@ export function suppressProgressForReadOnlyTask(behavior: ResolvedStepBehavior,
 // =============================================================================
 
 /**
- * Resolve a file path: absolute paths pass through, relative paths get chainDir prepended.
+ * Expand a leading `~`/`~/` to the user's home directory. Other forms (relative,
+ * absolute, `~user/`) pass through unchanged.
+ */
+export function expandHomePath(filePath: string): string {
+	if (filePath === "~") return os.homedir();
+	if (filePath.startsWith("~/")) return path.join(os.homedir(), filePath.slice(2));
+	return filePath;
+}
+
+/**
+ * Resolve a file path: `~`/`~/` expand to home first, then absolute paths pass
+ * through and relative paths get chainDir prepended.
  */
-function resolveChainPath(filePath: string, chainDir: string): string {
-	return path.isAbsolute(filePath) ? filePath : path.join(chainDir, filePath);
+export function resolveChainPath(filePath: string, chainDir: string): string {
+	const expanded = expandHomePath(filePath);
+	return path.isAbsolute(expanded) ? expanded : path.join(chainDir, expanded);
+}
+
+export function resolveExistingReadInstructionPaths(reads: readonly string[], instructionCwd: string, existenceCwd = instructionCwd): string[] {
+	return reads.flatMap((filePath) => {
+		const instructionPath = resolveChainPath(filePath, instructionCwd);
+		const existencePath = resolveChainPath(filePath, existenceCwd);
+		return fs.existsSync(existencePath) ? [instructionPath] : [];
+	});
+}
+
+export function resolveExistingReadPaths(reads: readonly string[], cwd: string): string[] {
+	return resolveExistingReadInstructionPaths(reads, cwd);
 }
 
 /**
@@ -350,14 +379,15 @@ export function buildChainInstructions(
 	chainDir: string,
 	isFirstProgressAgent: boolean,
 	previousSummary?: string,
+	readExistenceDir = chainDir,
 ): { prefix: string; suffix: string } {
 	const prefixParts: string[] = [];
 	const suffixParts: string[] = [];
 
 	// READS - prepend to override any hardcoded filenames in task text
 	if (behavior.reads && behavior.reads.length > 0) {
-		const files = behavior.reads.map((f) => resolveChainPath(f, chainDir));
-		prefixParts.push(`[Read from: ${files.join(", ")}]`);
+		const files = resolveExistingReadInstructionPaths(behavior.reads, chainDir, readExistenceDir);
+		if (files.length > 0) prefixParts.push(`[Read from: ${files.join(", ")}]`);
 	}
 
 	// OUTPUT - prepend so agent knows where to write