@oh-my-pi/pi-coding-agent 6.8.5 → 6.9.69

package/src/modes/interactive/utils/ui-helpers.ts

@@ -10,6 +10,7 @@ import { BranchSummaryMessageComponent } from "../components/branch-summary-mess
 import { CompactionSummaryMessageComponent } from "../components/compaction-summary-message";
 import { CustomMessageComponent } from "../components/custom-message";
 import { DynamicBorder } from "../components/dynamic-border";
+import { PythonExecutionComponent } from "../components/python-execution";
 import { ReadToolGroupComponent } from "../components/read-tool-group";
 import { ToolExecutionComponent } from "../components/tool-execution";
 import { UserMessageComponent } from "../components/user-message";
@@ -83,6 +84,20 @@ export class UiHelpers {
 				this.ctx.chatContainer.addChild(component);
 				break;
 			}
+			case "pythonExecution": {
+				const component = new PythonExecutionComponent(message.code, this.ctx.ui, message.excludeFromContext);
+				if (message.output) {
+					component.appendOutput(message.output);
+				}
+				component.setComplete(
+					message.exitCode,
+					message.cancelled,
+					message.truncated ? ({ truncated: true } as TruncationResult) : undefined,
+					message.fullOutputPath,
+				);
+				this.ctx.chatContainer.addChild(component);
+				break;
+			}
 			case "hookMessage":
 			case "custom": {
 				if (message.display) {
@@ -461,6 +476,11 @@ export class UiHelpers {
 			this.ctx.chatContainer.addChild(component);
 		}
 		this.ctx.pendingBashComponents = [];
+		for (const component of this.ctx.pendingPythonComponents) {
+			this.ctx.pendingMessagesContainer.removeChild(component);
+			this.ctx.chatContainer.addChild(component);
+		}
+		this.ctx.pendingPythonComponents = [];
 	}
 
 	findLastAssistantMessage(): AssistantMessage | undefined {

package/src/prompts/system/system-prompt.md

@@ -200,6 +200,13 @@ Do not open a file hoping to find something. Know where to look first.
 - When summarizing: plain text, file paths. Do not echo content back.
 {{/ifAny}}
 - Be brief. Show file paths clearly.
+{{#has tools "ask"}}
+
+### Concurrent work
+Other agents or the user may be editing files concurrently.
+When file contents differ from expectations or edits fail: re-read and adapt.
+**Ask before** `git checkout/restore/reset`, bulk overwrites, or deleting code you didn't write.
+{{/has}}
 </practice>
 
 <method>
@@ -324,6 +331,7 @@ Keep going until finished.
 - Do not write code before stating assumptions.
 - Do not claim correctness you haven't verified.
 - Do not handle only the happy path.
+{{#has tools "ask"}}- If files differ from expectations, ask before discarding uncommitted work.{{/has}}
 
 
 Let edge cases surface before you handle them. Let the failure modes exist in your mind before you prevent them. Let the code be smaller than your first instinct.

package/src/prompts/tools/python.md

@@ -1,4 +1,42 @@
-Executes Python code in an IPython kernel (session or per-call) with optional timeout.
+Executes Python cells sequentially in a persistent IPython kernel.
+
+## How to use (REPL discipline)
+
+The kernel persists between calls and between cells. **Imports, variables, and functions survive.** Use this.
+
+**Work incrementally:**
+- One logical step per cell (imports, define a function, test it, use it)
+- Pass multiple small cells in one call—they execute sequentially
+- Define small functions you can reuse and debug individually
+- Put explanations in the assistant message or cell title, **not** inside code
+
+**When something fails:**
+- The error tells you which cell failed (e.g., "Cell 3 failed")
+- Earlier cells already ran—their state persists in the kernel
+- Resubmit with only the fixed cell (or the fixed cell + remaining cells)
+- Do NOT rewrite working cells or re-import modules
+
+**Anti-patterns to avoid:**
+- Putting everything in one giant cell
+- Re-importing modules you already imported
+- Rewriting working code when only one part failed
+- Large functions that are hard to debug piece by piece
+
+```python
+# BAD: One giant cell
+cells: [{
+    "title": "all-in-one",
+    "code": "import json\nfrom pathlib import Path\ndef process_all_files():\n    # 50 lines...\n    pass\nresult = process_all_files()"
+}]
+
+# GOOD: Multiple small cells
+cells: [
+    {"title": "imports", "code": "import json\nfrom pathlib import Path"},
+    {"title": "parse helper", "code": "def parse_config(path):\n    return json.loads(Path(path).read_text())"},
+    {"title": "test helper", "code": "parse_config('config.json')"},
+    {"title": "use helper", "code": "configs = [parse_config(p) for p in Path('.').glob('*.json')]"}
+]
+```
 
 ## When to use Python
 
@@ -75,7 +113,7 @@ cols(read("data.tsv"), 0, 2, sep="\t")
 
 - Code executes as IPython cells; users see the full cell output (including rendered figures, tables, etc.)
 - Kernel persists for the session by default; per-call mode uses a fresh kernel each call. Use `reset: true` to clear state when session mode is active
-- Use `workdir` parameter instead of `os.chdir()` in tool call
+- Use `cwd` parameter instead of `os.chdir()` in tool call
 - Use `plt.show()` to display figures
 - Use `display()` from IPython.display for rich output (HTML, Markdown, images, etc.)
 - Output streams in real time, truncated after 50KB

package/src/prompts/tools/task.md

@@ -49,12 +49,12 @@ Agents with "Output: structured" have a fixed schema enforced via frontmatter; y
 ## Parameters
 
 - `agent`: Agent type to use for all tasks
-- `context`: **Required context from conversation** - include ALL relevant info: requirements, schemas, decisions, constraints. Subagents cannot see chat history.
-- `model`: (optional) Model override (fuzzy matching, e.g., "sonnet", "opus")
-- `tasks`: Array of `{id, task, description}` - tasks to run in parallel (max {{MAX_PARALLEL_TASKS}}, {{MAX_CONCURRENCY}} concurrent)
+- `context`: Template with `{{placeholders}}` for multi-task. Each placeholder is filled from task vars.
+- `model`: (optional) Model override for all tasks (fuzzy matching, e.g., "sonnet", "opus")
+- `tasks`: Array of `{id, description, vars}` - tasks to run in parallel (max {{MAX_PARALLEL_TASKS}}, {{MAX_CONCURRENCY}} concurrent)
   - `id`: Short CamelCase identifier for display (max 20 chars, e.g., "SessionStore", "LspRefactor")
-  - `task`: The task prompt for the agent
   - `description`: Short human-readable description of what the task does
+  - `vars`: Object with keys matching `{{placeholders}}` in context
 - `output`: (optional) JTD schema for structured subagent output (used by the complete tool)
 
 ## Example
@@ -65,7 +65,7 @@ assistant: I'll execute the refactoring plan.
 assistant: Uses the Task tool:
 {
   "agent": "task",
-  "context": "Refactoring the auth module into separate concerns.\n\nPlan:\n1. AuthProvider - Extract React context and provider from src/auth/index.tsx\n2. AuthApi - Extract API calls to src/auth/api.ts, use existing fetchJson helper\n3. AuthTypes - Move types to src/auth/types.ts, re-export from index\n\nConstraints:\n- Preserve all existing exports from src/auth/index.tsx\n- Use project's fetchJson (src/utils/http.ts), don't use raw fetch\n- No new dependencies",
+  "context": "Refactoring the auth module into separate concerns.\n\nPlan:\n1. AuthProvider - Extract React context and provider from src/auth/index.tsx\n2. AuthApi - Extract API calls to src/auth/api.ts, use existing fetchJson helper\n3. AuthTypes - Move types to types.ts, re-export from index\n\nConstraints:\n- Preserve all existing exports from src/auth/index.tsx\n- Use project's fetchJson (src/utils/http.ts), don't use raw fetch\n- No new dependencies\n\nTask: {{step}}\n\nFiles: {{files}}",
   "output": {
     "properties": {
       "summary": { "type": "string" },
@@ -74,14 +74,9 @@ assistant: Uses the Task tool:
     }
   },
   "tasks": [
-    { "id": "AuthProvider", "task": "Execute step 1: Extract AuthProvider and AuthContext", "description": "Extract React context" },
-    { "id": "AuthApi", "task": "Execute step 2: Extract API calls to api.ts", "description": "Extract API layer" },
-    { "id": "AuthTypes", "task": "Execute step 3: Move types to types.ts", "description": "Extract types" }
+    { "id": "AuthProvider", "description": "Extract React context", "vars": { "step": "Execute step 1: Extract AuthProvider and AuthContext", "files": "src/auth/index.tsx" } },
+    { "id": "AuthApi", "description": "Extract API layer", "vars": { "step": "Execute step 2: Extract API calls to api.ts", "files": "src/auth/api.ts" } },
+    { "id": "AuthTypes", "description": "Extract types", "vars": { "step": "Execute step 3: Move types to types.ts", "files": "src/auth/types.ts" } }
   ]
 }
 </example>
-
-Key points:
-- **Plan in context**: The full plan is written once; each task references its step without repeating shared constraints
-- **Parallel execution**: 3 agents run concurrently, each owning one step - no duplicated work
-- **Structured output**: JTD schema ensures consistent reporting across all agents

package/src/core/custom-commands/bundled/wt/index.ts

@@ -1,435 +0,0 @@
-import * as path from "node:path";
-import { nanoid } from "nanoid";
-import { type CollapseStrategy, collapse } from "../../../../lib/worktree/collapse";
-import { WorktreeError, WorktreeErrorCode } from "../../../../lib/worktree/errors";
-import { getRepoRoot, git } from "../../../../lib/worktree/git";
-import * as worktree from "../../../../lib/worktree/index";
-import { createSession, updateSession } from "../../../../lib/worktree/session";
-import { formatStats, getStats } from "../../../../lib/worktree/stats";
-import type { HookCommandContext } from "../../../hooks/types";
-import { discoverAgents, getAgent } from "../../../tools/task/discovery";
-import { runSubprocess } from "../../../tools/task/executor";
-import { generateTaskName } from "../../../tools/task/name-generator";
-import type { AgentDefinition } from "../../../tools/task/types";
-import type { CustomCommand, CustomCommandAPI } from "../../types";
-
-interface FlagParseResult {
-	positionals: string[];
-	flags: Map<string, string | boolean>;
-}
-
-interface NewArgs {
-	branch: string;
-	base?: string;
-}
-
-interface MergeArgs {
-	source: string;
-	target?: string;
-	strategy?: CollapseStrategy;
-	keep?: boolean;
-}
-
-interface RmArgs {
-	name: string;
-	force?: boolean;
-}
-
-interface SpawnArgs {
-	task: string;
-	scope?: string;
-	name?: string;
-}
-
-interface ParallelTask {
-	task: string;
-	scope: string;
-}
-
-function parseFlags(args: string[]): FlagParseResult {
-	const flags = new Map<string, string | boolean>();
-	const positionals: string[] = [];
-
-	for (let i = 0; i < args.length; i++) {
-		const arg = args[i];
-		if (arg.startsWith("--")) {
-			const name = arg.slice(2);
-			const next = args[i + 1];
-			if (next && !next.startsWith("--")) {
-				flags.set(name, next);
-				i += 1;
-			} else {
-				flags.set(name, true);
-			}
-		} else {
-			positionals.push(arg);
-		}
-	}
-
-	return { positionals, flags };
-}
-
-function getFlagValue(flags: Map<string, string | boolean>, name: string): string | undefined {
-	const value = flags.get(name);
-	if (typeof value === "string") return value;
-	return undefined;
-}
-
-function getFlagBoolean(flags: Map<string, string | boolean>, name: string): boolean {
-	return flags.get(name) === true;
-}
-
-function formatUsage(): string {
-	return [
-		"Usage:",
-		"  /wt new <branch> [--base <ref>]",
-		"  /wt list",
-		"  /wt merge <src> [dst] [--strategy simple|merge-base|rebase] [--keep]",
-		"  /wt rm <name> [--force]",
-		"  /wt status",
-		'  /wt spawn "<task>" [--scope <glob>] [--name <branch>]',
-		"  /wt parallel --task <t> --scope <s> [--task <t> --scope <s>]...",
-	].join("\n");
-}
-
-function formatError(err: unknown): string {
-	if (err instanceof WorktreeError) {
-		return `${err.code}: ${err.message}`;
-	}
-	if (err instanceof Error) return err.message;
-	return String(err);
-}
-
-async function pickAgent(cwd: string): Promise<AgentDefinition> {
-	const { agents } = await discoverAgents(cwd);
-	// Use the bundled "task" agent as the general-purpose default.
-	const agent = getAgent(agents, "task") ?? agents[0];
-	if (!agent) {
-		throw new Error("No agents available");
-	}
-	return agent;
-}
-
-function parseParallelTasks(args: string[]): ParallelTask[] {
-	const tasks: ParallelTask[] = [];
-	let current: Partial<ParallelTask> = {};
-
-	for (let i = 0; i < args.length; i++) {
-		const arg = args[i];
-		if (arg === "--task") {
-			const value = args[i + 1];
-			if (!value || value.startsWith("--")) {
-				throw new Error("Missing value for --task");
-			}
-			current.task = value;
-			i += 1;
-		} else if (arg === "--scope") {
-			const value = args[i + 1];
-			if (!value || value.startsWith("--")) {
-				throw new Error("Missing value for --scope");
-			}
-			current.scope = value;
-			i += 1;
-		} else {
-			throw new Error(`Unknown argument: ${arg}`);
-		}
-
-		if (current.task && current.scope) {
-			tasks.push({ task: current.task, scope: current.scope });
-			current = {};
-		}
-	}
-
-	if (current.task || current.scope) {
-		throw new Error("Each --task must be paired with a --scope");
-	}
-
-	return tasks;
-}
-
-function validateDisjointScopes(scopes: string[]): void {
-	for (let i = 0; i < scopes.length; i++) {
-		for (let j = i + 1; j < scopes.length; j++) {
-			const a = scopes[i].replace(/\*.*$/, "");
-			const b = scopes[j].replace(/\*.*$/, "");
-			if (a.startsWith(b) || b.startsWith(a)) {
-				throw new WorktreeError(
-					`Overlapping scopes: "${scopes[i]}" and "${scopes[j]}"`,
-					WorktreeErrorCode.OVERLAPPING_SCOPES,
-				);
-			}
-		}
-	}
-}
-
-async function handleNew(args: NewArgs): Promise<string> {
-	const wt = await worktree.create(args.branch, { base: args.base });
-
-	return [`Created worktree: ${wt.path}`, `Branch: ${wt.branch ?? "detached"}`, "", `To switch: cd ${wt.path}`].join(
-		"\n",
-	);
-}
-
-async function handleList(ctx: HookCommandContext): Promise<string> {
-	const worktrees = await worktree.list();
-	const cwd = path.resolve(ctx.cwd);
-	const mainPath = await getRepoRoot();
-
-	const lines: string[] = [];
-
-	for (const wt of worktrees) {
-		const stats = await getStats(wt.path);
-		const isCurrent = cwd === wt.path || cwd.startsWith(wt.path + path.sep);
-		const isMain = wt.path === mainPath;
-
-		const marker = isCurrent ? "->" : "  ";
-		const mainTag = isMain ? " [main]" : "";
-		const branch = wt.branch ?? "detached";
-		const statsStr = formatStats(stats);
-
-		lines.push(`${marker} ${branch}${mainTag} (${statsStr})`);
-	}
-
-	return lines.join("\n") || "No worktrees found";
-}
-
-async function handleMerge(args: MergeArgs): Promise<string> {
-	const target = args.target ?? "main";
-	const strategy = args.strategy ?? "rebase";
-
-	const result = await collapse(args.source, target, {
-		strategy,
-		keepSource: args.keep,
-	});
-
-	const lines = [
-		`Collapsed ${args.source} -> ${target}`,
-		`Strategy: ${strategy}`,
-		`Changes: +${result.insertions} -${result.deletions} in ${result.filesChanged} files`,
-	];
-
-	if (!args.keep) {
-		lines.push("Source worktree removed");
-	}
-
-	return lines.join("\n");
-}
-
-async function handleRm(args: RmArgs): Promise<string> {
-	const wt = await worktree.find(args.name);
-	await worktree.remove(args.name, { force: args.force });
-
-	const mainPath = await getRepoRoot();
-	if (wt.branch) {
-		await git(["branch", "-D", wt.branch], mainPath);
-		return `Removed worktree and branch: ${wt.branch}`;
-	}
-
-	return `Removed worktree: ${wt.path}`;
-}
-
-async function handleStatus(): Promise<string> {
-	const worktrees = await worktree.list();
-	const sections: string[] = [];
-
-	for (const wt of worktrees) {
-		const branch = wt.branch ?? "detached";
-		const name = path.basename(wt.path);
-
-		const statusResult = await git(["status", "--short"], wt.path);
-		const status = statusResult.stdout.trim() || "(clean)";
-
-		sections.push(`${name} (${branch})\n${"-".repeat(40)}\n${status}`);
-	}
-
-	return sections.join("\n\n");
-}
-
-async function handleSpawn(args: SpawnArgs, ctx: HookCommandContext): Promise<string> {
-	const branch = args.name ?? `wt-agent-${nanoid(6)}`;
-	const wt = await worktree.create(branch);
-
-	const session = await createSession({
-		branch,
-		path: wt.path,
-		scope: args.scope ? [args.scope] : undefined,
-		task: args.task,
-	});
-	await updateSession(session.id, { status: "active" });
-
-	const agent = await pickAgent(ctx.cwd);
-	const context = args.scope ? `Scope: ${args.scope}` : undefined;
-
-	// Command context doesn't expose a spawn API, so run the task subprocess directly.
-	const result = await runSubprocess({
-		cwd: wt.path,
-		agent,
-		task: args.task,
-		index: 0,
-		taskId: generateTaskName(),
-		context,
-	});
-
-	await updateSession(session.id, {
-		status: result.exitCode === 0 ? "completed" : "failed",
-		completedAt: Date.now(),
-	});
-
-	if (result.exitCode !== 0) {
-		return [
-			`Agent failed in worktree: ${branch}`,
-			result.stderr.trim() ? `Error: ${result.stderr.trim()}` : "Error: agent execution failed",
-			"",
-			"Actions:",
-			`  /wt merge ${branch}     - Apply changes to main`,
-			"  /wt status              - Inspect changes",
-			`  /wt rm ${branch}        - Discard changes`,
-		].join("\n");
-	}
-
-	return [
-		`Agent completed in worktree: ${branch}`,
-		"",
-		"Actions:",
-		`  /wt merge ${branch}     - Apply changes to main`,
-		"  /wt status              - Inspect changes",
-		`  /wt rm ${branch}        - Discard changes`,
-	].join("\n");
-}
-
-async function handleParallel(args: ParallelTask[], ctx: HookCommandContext): Promise<string> {
-	validateDisjointScopes(args.map((t) => t.scope));
-
-	const sessionId = `parallel-${nanoid()}`;
-	const agent = await pickAgent(ctx.cwd);
-
-	const worktrees: Array<{ task: ParallelTask; wt: worktree.Worktree; session: worktree.WorktreeSession }> = [];
-	for (let i = 0; i < args.length; i++) {
-		const task = args[i];
-		const branch = `wt-parallel-${sessionId}-${i}`;
-		const wt = await worktree.create(branch);
-		const session = await createSession({
-			branch,
-			path: wt.path,
-			scope: [task.scope],
-			task: task.task,
-		});
-		worktrees.push({ task, wt, session });
-	}
-
-	const agentPromises = worktrees.map(async ({ task, wt, session }, index) => {
-		await updateSession(session.id, { status: "active" });
-		const result = await runSubprocess({
-			cwd: wt.path,
-			agent,
-			task: task.task,
-			index,
-			taskId: generateTaskName(),
-			context: `Scope: ${task.scope}`,
-		});
-		await updateSession(session.id, {
-			status: result.exitCode === 0 ? "completed" : "failed",
-			completedAt: Date.now(),
-		});
-		return { wt, session, result };
-	});
-
-	const results = await Promise.all(agentPromises);
-
-	const mergeResults: string[] = [];
-
-	for (const { wt, session } of results) {
-		try {
-			await updateSession(session.id, { status: "merging" });
-			const collapseResult = await collapse(wt.branch ?? wt.path, "main", {
-				strategy: "simple",
-				keepSource: false,
-			});
-			await updateSession(session.id, { status: "merged" });
-			mergeResults.push(
-				`ok ${wt.branch ?? path.basename(wt.path)}: +${collapseResult.insertions} -${collapseResult.deletions}`,
-			);
-		} catch (err) {
-			await updateSession(session.id, { status: "failed" });
-			mergeResults.push(`err ${wt.branch ?? path.basename(wt.path)}: ${formatError(err)}`);
-		}
-	}
-
-	return [`Parallel execution complete (${args.length} agents)`, "", "Results:", ...mergeResults].join("\n");
-}
-
-export class WorktreeCommand implements CustomCommand {
-	name = "wt";
-	description = "Git worktree management";
-
-	// biome-ignore lint/complexity/noUselessConstructor: interface conformance - loader passes API to all commands
-	constructor(_api: CustomCommandAPI) {}
-
-	async execute(args: string[], ctx: HookCommandContext): Promise<string | undefined> {
-		if (args.length === 0) return formatUsage();
-
-		const subcommand = args[0];
-		const rest = args.slice(1);
-
-		try {
-			switch (subcommand) {
-				case "new": {
-					const parsed = parseFlags(rest);
-					const branch = parsed.positionals[0];
-					if (!branch) return formatUsage();
-					const base = getFlagValue(parsed.flags, "base");
-					if (parsed.flags.get("base") === true) {
-						return "Missing value for --base";
-					}
-					return await handleNew({ branch, base });
-				}
-				case "list":
-					return await handleList(ctx);
-				case "merge": {
-					const parsed = parseFlags(rest);
-					const source = parsed.positionals[0];
-					const target = parsed.positionals[1];
-					if (!source) return formatUsage();
-					const strategyRaw = getFlagValue(parsed.flags, "strategy");
-					if (parsed.flags.get("strategy") === true) {
-						return "Missing value for --strategy";
-					}
-					const strategy = strategyRaw as CollapseStrategy | undefined;
-					const keep = getFlagBoolean(parsed.flags, "keep");
-					return await handleMerge({ source, target, strategy, keep });
-				}
-				case "rm": {
-					const parsed = parseFlags(rest);
-					const name = parsed.positionals[0];
-					if (!name) return formatUsage();
-					const force = getFlagBoolean(parsed.flags, "force");
-					return await handleRm({ name, force });
-				}
-				case "status":
-					return await handleStatus();
-				case "spawn": {
-					const parsed = parseFlags(rest);
-					const task = parsed.positionals[0];
-					if (!task) return formatUsage();
-					const scope = getFlagValue(parsed.flags, "scope");
-					if (parsed.flags.get("scope") === true) {
-						return "Missing value for --scope";
-					}
-					const name = getFlagValue(parsed.flags, "name");
-					return await handleSpawn({ task, scope, name }, ctx);
-				}
-				case "parallel": {
-					const tasks = parseParallelTasks(rest);
-					if (tasks.length === 0) return formatUsage();
-					return await handleParallel(tasks, ctx);
-				}
-				default:
-					return formatUsage();
-			}
-		} catch (err) {
-			return formatError(err);
-		}
-	}
-}
-
-export default WorktreeCommand;