one-code-extension 0.1.3 → 0.3.0

package/extensions/subagents/rpc-turns.ts

@@ -1,123 +0,0 @@
-/**
- * RPC child protocol state (pure) — line-wise parsing for a `pi --mode rpc`
- * child. RPC events are the same objects json mode emits (shared toJsonEvent),
- * interleaved with `response` acks and `extension_ui_request` dialogs. This
- * tracker accumulates per-turn output and cumulative stats, and tells the
- * caller when it must act (answer a UI request, settle a pending turn).
- */
-
-import { type ChildAction, recordAction } from "../auto-mode/actions.ts";
-import { addUsage, emptyUsage, type UsageTotals } from "./usage.ts";
-
-export type RpcAction =
-	| { kind: "ui_request"; id: string }
-	| { kind: "stream_start" }
-	| { kind: "turn_end" }
-	| { kind: "progress" }
-	| { kind: "message_to_main"; message: string; summary?: string };
-
-/**
- * A child's send_message {to: "main"} call needs no IPC of its own: the tool
- * returns the message in its details, and the parent already reads every
- * tool_execution_end in the child's event stream. This extracts it.
- */
-export function toMainMessage(event: unknown): { message: string; summary?: string } | undefined {
-	const e = event as {
-		type?: string;
-		toolName?: string;
-		result?: { details?: { toMain?: boolean; message?: unknown; summary?: unknown } };
-	};
-	if (e?.type !== "tool_execution_end" || e.toolName !== "send_message") return undefined;
-	const details = e.result?.details;
-	if (!details?.toMain || typeof details.message !== "string") return undefined;
-	return { message: details.message, summary: typeof details.summary === "string" ? details.summary : undefined };
-}
-
-export class RpcTurnTracker {
-	toolCalls = 0;
-	/** What the child did this turn, for auto mode's return review. */
-	actions: ChildAction[] = [];
-	readonly usage: UsageTotals = emptyUsage();
-	/** Final assistant text of the turn in progress (or the last finished one). */
-	turnText = "";
-	/**
-	 * Set when the turn's LAST assistant message ended with stopReason "error"
-	 * (provider failure: auth, billing, rate limit) — the only place such a
-	 * failure surfaces; stderr stays empty. A later successful assistant
-	 * message (pi retried) clears it.
-	 */
-	providerError: string | undefined;
-	/** Every turn's final text, for task_output on a resident agent. */
-	transcript = "";
-	/** A prompt has been sent and its agent_end not yet seen. */
-	busy = false;
-	/**
-	 * The child's agent loop is actually running (its agent_start seen). Between
-	 * a prompt being sent and this flipping true, the child is still booting —
-	 * a steer sent in that window would miss the turn.
-	 */
-	streaming = false;
-
-	beginTurn(): void {
-		this.busy = true;
-		this.turnText = "";
-		this.providerError = undefined;
-		// Per turn, not per session: the review that reads this judges the work of
-		// the turn that just finished.
-		this.actions = [];
-	}
-
-	process(line: string): RpcAction | undefined {
-		if (!line.trim()) return undefined;
-		let event: {
-			type?: string;
-			id?: string;
-			message?: { role?: string; content?: unknown; usage?: unknown; stopReason?: string; errorMessage?: string };
-		};
-		try {
-			event = JSON.parse(line);
-		} catch {
-			return undefined;
-		}
-
-		switch (event.type) {
-			case "extension_ui_request":
-				return typeof event.id === "string" ? { kind: "ui_request", id: event.id } : undefined;
-			case "agent_start":
-				this.streaming = true;
-				return { kind: "stream_start" };
-			case "tool_execution_start": {
-				this.toolCalls++;
-				const start = event as { toolName?: string; args?: unknown };
-				if (start.toolName) recordAction(this.actions, start.toolName, start.args);
-				return { kind: "progress" };
-			}
-			case "message_end": {
-				if (event.message?.role !== "assistant") return undefined;
-				addUsage(this.usage, event.message.usage);
-				this.providerError =
-					event.message.stopReason === "error" ? event.message.errorMessage || "unknown provider error" : undefined;
-				const blocks = Array.isArray(event.message.content) ? event.message.content : [];
-				const text = blocks
-					.filter((b): b is { type: string; text: string } => (b as { type?: string }).type === "text")
-					.map((b) => b.text)
-					.join("");
-				if (text.trim()) this.turnText = text;
-				return { kind: "progress" };
-			}
-			case "tool_execution_end": {
-				const toMain = toMainMessage(event);
-				return toMain ? { kind: "message_to_main", ...toMain } : undefined;
-			}
-			case "agent_end":
-				this.busy = false;
-				this.streaming = false;
-				if (this.turnText.trim()) {
-					this.transcript = this.transcript ? `${this.transcript}\n\n---\n\n${this.turnText}` : this.turnText;
-				}
-				return { kind: "turn_end" };
-			default:
-				return undefined;
-		}
-	}
-}

package/extensions/todo/index.ts

@@ -1,133 +0,0 @@
-/**
- * todo extension — Claude Code's TodoWrite: stateless whole-list replacement.
- *
- * Schema matches Claude Code (content / status / activeForm per item). State
- * lives in tool-result details, so branching and resuming a session restores
- * the list that was current at that point in history (pattern from pi's
- * official todo example). A widget under the editor shows live progress.
- */
-
-import { StringEnum } from "@earendil-works/pi-ai";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import { restoreLatestDetails } from "../lib/branch-restore.ts";
-import { REMINDER_CHANNEL } from "../lib/reminders.ts";
-import { ccToolRenderers } from "../lib/tui-render.ts";
-
-interface TodoItem {
-	content: string;
-	status: "pending" | "in_progress" | "completed";
-	activeForm: string;
-}
-
-interface TodoDetails {
-	todos: TodoItem[];
-}
-
-const TodoWriteParams = Type.Object({
-	todos: Type.Array(
-		Type.Object({
-			content: Type.String({ description: "The task, in imperative form (e.g. 'Fix the login bug')" }),
-			status: StringEnum(["pending", "in_progress", "completed"] as const),
-			activeForm: Type.String({ description: "Present-continuous form shown while in progress (e.g. 'Fixing the login bug')" }),
-		}),
-		{ description: "The complete todo list; this REPLACES the previous list entirely" },
-	),
-});
-
-function formatTodos(todos: TodoItem[]): string {
-	if (todos.length === 0) return "Todo list cleared.";
-	const mark = (t: TodoItem) => (t.status === "completed" ? "x" : t.status === "in_progress" ? "▸" : " ");
-	return todos.map((t) => `[${mark(t)}] ${t.content}`).join("\n");
-}
-
-/**
- * Claude Code nudges the model when the task tools have gone unused for a while.
- * A todo tool nobody remembers to call is decoration, so we do the same — quietly
- * and rarely, based on session state.
- */
-const NUDGE_AFTER_TURNS = 8;
-const TODO_TOOLS = new Set(["todo_write"]);
-
-export default function todoExtension(pi: ExtensionAPI) {
-	let todos: TodoItem[] = [];
-	let turnsSinceTodoUse = 0;
-
-	const updateWidget = (ctx: ExtensionContext) => {
-		if (!ctx.hasUI) return;
-		if (todos.length === 0) {
-			ctx.ui.setWidget("cc-todos", undefined);
-			return;
-		}
-		const done = todos.filter((t) => t.status === "completed").length;
-		const active = todos.find((t) => t.status === "in_progress");
-		const line = ` todos ${done}/${todos.length}${active ? ` · ${active.activeForm}` : ""}`;
-		ctx.ui.setWidget("cc-todos", [line]);
-	};
-
-	const reconstructState = (ctx: ExtensionContext) => {
-		const details = restoreLatestDetails<TodoDetails>(ctx.sessionManager.getBranch(), TODO_TOOLS, (d) => Boolean(d?.todos));
-		todos = details?.todos ?? [];
-		updateWidget(ctx);
-	};
-
-	pi.on("session_start", (_event, ctx) => reconstructState(ctx));
-	pi.on("session_tree", (_event, ctx) => reconstructState(ctx));
-
-	pi.on("turn_end", () => {
-		turnsSinceTodoUse++;
-		if (turnsSinceTodoUse < NUDGE_AFTER_TURNS) return;
-		turnsSinceTodoUse = 0;
-
-		if (todos.length === 0) {
-			pi.events.emit(REMINDER_CHANNEL, {
-				text: "The todo tool has not been used recently. If the current work has several steps, track it with todo_write so progress is visible; skip this if the task is simple.",
-			});
-			return;
-		}
-
-		const active = todos.filter((t) => t.status === "in_progress");
-		const done = todos.filter((t) => t.status === "completed").length;
-		if (active.length === 0 && done < todos.length) {
-			pi.events.emit(REMINDER_CHANNEL, {
-				text: `The todo list has ${todos.length - done} unfinished item(s) and none marked in_progress. Update it with todo_write to reflect what you are actually doing, or clear it if it is stale.`,
-			});
-		} else if (active.length > 1) {
-			pi.events.emit(REMINDER_CHANNEL, {
-				text: `${active.length} todo items are marked in_progress. Exactly one should be in progress at a time — update the list with todo_write.`,
-			});
-		}
-	});
-
-	pi.registerTool({
-		name: "todo_write",
-		label: "Todos",
-		...ccToolRenderers<{ todos?: unknown[] }>("Todos", {
-			title: (a) => (a?.todos ? `${a.todos.length} items` : undefined),
-			maxCollapsedLines: 12,
-		}),
-		description:
-			"Create and manage a structured task list for the current session. Each call REPLACES the entire list. Use for multi-step tasks (3+ steps): mark exactly one item in_progress before starting it, mark it completed immediately when done, and keep the list current rather than batching updates.",
-		promptSnippet: "Track multi-step task progress with a todo list",
-		promptGuidelines: [
-			"For tasks with 3+ steps, track progress with todo_write; keep exactly one item in_progress",
-		],
-		parameters: TodoWriteParams,
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-			todos = params.todos as TodoItem[];
-			turnsSinceTodoUse = 0;
-			updateWidget(ctx);
-			return {
-				content: [{ type: "text", text: formatTodos(todos) }],
-				details: { todos: [...todos] } satisfies TodoDetails,
-			};
-		},
-	});
-
-	pi.registerCommand("todos", {
-		description: "Show the agent's current todo list",
-		handler: async (_args, ctx) => {
-			ctx.ui.notify(todos.length ? formatTodos(todos) : "No todos.", "info");
-		},
-	});
-}

package/extensions/workflow/permission-gate.ts

@@ -1,71 +0,0 @@
-/**
- * Permission gate for workflow subagents (pure).
- *
- * Workflow subagent sessions are built with `noExtensions: true`, so One Code's
- * own permissions extension never loads inside them — without this gate every
- * subagent bash/edit/write would run unchecked. `DefaultResourceLoader` always
- * loads explicitly passed `extensionFactories` (even under noExtensions),
- * which is where this inline factory attaches.
- *
- * Policy: deny rules always win; explicit allow rules allow; edits are
- * auto-allowed (Claude Code runs workflow subagents in acceptEdits); anything
- * that would normally *ask* is denied — there is no interactive prompt inside
- * an agent() call, and fail-closed beats silently trusting the model.
- */
-
-import type { InlineExtension } from "@earendil-works/pi-coding-agent";
-import { findGitRoot } from "../lib/git.ts";
-import { memoryDir } from "../lib/memory.ts";
-import { sessionScratchpadDir } from "../lib/scratchpad.ts";
-import { decide, extractSubject, normalizeToolName, parseRules } from "../permissions/matcher.ts";
-import { loadPermissionSettings } from "../permissions/settings.ts";
-
-/** Tools the workflow runtime itself injects into subagents; never gate them. */
-const WORKFLOW_INTERNAL_TOOLS = new Set(["structured_output"]);
-
-export function permissionGateFactory(cwd: string, home: string): InlineExtension {
-	const settings = loadPermissionSettings(cwd, home);
-	const deny = parseRules(settings.deny);
-	const allow = parseRules(settings.allow);
-	const mode = settings.defaultMode === "bypassPermissions" ? "bypassPermissions" : "acceptEdits";
-	// Memory writes work inside agent() calls too — otherwise the protected
-	// `.claude` check turns them into "needs interactive approval" and the
-	// harness blocks its own feature (same rationale as in decide()).
-	const memoryDirPath = memoryDir(home, findGitRoot(cwd) ?? cwd);
-
-	return {
-		name: "workflow-permission-gate",
-		hidden: true,
-		factory: (pi) => {
-			// The scratchpad embeds the *child's* session id, which does not exist
-			// until the session runs — derived on first tool call, then pinned.
-			let scratchpadDirPath: string | undefined;
-			pi.on("tool_call", (event, ctx) => {
-				if (WORKFLOW_INTERNAL_TOOLS.has(event.toolName)) return undefined;
-				const sessionId = ctx?.sessionManager?.getSessionId?.();
-				if (!scratchpadDirPath && sessionId) scratchpadDirPath = sessionScratchpadDir(cwd, sessionId);
-				const subject = extractSubject(normalizeToolName(event.toolName), event.input as Record<string, unknown>);
-				const result = decide({
-					toolName: event.toolName,
-					subject,
-					cwd,
-					mode,
-					deny,
-					ask: [],
-					allow,
-					memoryDirPath,
-					scratchpadDirPath,
-				});
-				if (result.decision === "allow") return undefined;
-				const ruleNote = result.rule ? ` (rule: ${result.rule.raw})` : "";
-				return {
-					block: true,
-					reason:
-						result.decision === "deny"
-							? `Denied by permission rules${ruleNote}.`
-							: "This action needs interactive approval, which is not available inside a workflow agent. Ask for it to be added to the allow rules, or work around it.",
-				};
-			});
-		},
-	};
-}