@p4code/cli 0.1.5 → 0.1.6

package/dist/bin.mjs

@@ -233,7 +233,7 @@ const make$73 = () => {
 const layer$69 = Layer.sync(NetService, make$73);
 //#endregion
 //#region package.json
-var version = "0.1.5";
+var version = "0.1.6";
 //#endregion
 //#region src/config.ts
 /**
@@ -5634,11 +5634,22 @@ const ClaudeSettings = makeProviderSettingsSchema({
 			placeholder: "e.g. --chrome",
 			clearWhenEmpty: "omit"
 		}
+	})),
+	/**
+	* The SDK preset system prompt omits the interactive CLI's terminal-tone
+	* sections, so the model tends to open a turn with a tool call instead of
+	* saying what it is about to do. This appends that instruction back.
+	*/
+	narrateBeforeTools: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true)), Schema$1.annotateKey({
+		title: "Explain before tool calls",
+		description: "Ask Claude to write one short sentence before its first tool call in a turn.",
+		providerSettingsForm: { control: "switch" }
 	}))
 }, { order: [
 	"binaryPath",
 	"homePath",
-	"launchArgs"
+	"launchArgs",
+	"narrateBeforeTools"
 ] });
 const CursorSettings = makeProviderSettingsSchema({
 	enabled: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false)), Schema$1.annotateKey({ providerSettingsForm: { hidden: true } })),
@@ -5827,7 +5838,8 @@ const ClaudeSettingsPatch = Schema$1.Struct({
 	binaryPath: Schema$1.optionalKey(TrimmedString),
 	homePath: Schema$1.optionalKey(TrimmedString),
 	customModels: Schema$1.optionalKey(Schema$1.Array(Schema$1.String)),
-	launchArgs: Schema$1.optionalKey(TrimmedString)
+	launchArgs: Schema$1.optionalKey(TrimmedString),
+	narrateBeforeTools: Schema$1.optionalKey(Schema$1.Boolean)
 });
 const CursorSettingsPatch = Schema$1.Struct({
 	enabled: Schema$1.optionalKey(Schema$1.Boolean),
@@ -46471,6 +46483,177 @@ function parseCliArgs(args, options) {
 	};
 }
 //#endregion
+//#region ../../packages/shared/src/toolCategory.ts
+const TOOL_CATEGORY_TITLES = {
+	file_read: "File read",
+	file_search: "File search",
+	file_change: "File change",
+	command: "Command run",
+	mcp_tool: "MCP tool call",
+	subagent: "Subagent task",
+	web_search: "Web search",
+	image_view: "Image view",
+	tool: "Tool call"
+};
+/** Exact tool names, lowercased, matched before the substring heuristics below. */
+const FILE_READ_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"read",
+	"readfile",
+	"read_file",
+	"view",
+	"viewfile",
+	"view_file",
+	"notebookread",
+	"notebook_read",
+	"openfile",
+	"open_file"
+]);
+const FILE_SEARCH_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"grep",
+	"glob",
+	"search",
+	"filesearch",
+	"file_search",
+	"codebasesearch",
+	"codebase_search",
+	"listdir",
+	"list_dir",
+	"list_directory",
+	"ls"
+]);
+const FILE_CHANGE_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"edit",
+	"write",
+	"multiedit",
+	"multi_edit",
+	"notebookedit",
+	"notebook_edit",
+	"applypatch",
+	"apply_patch",
+	"patch",
+	"createfile",
+	"create_file",
+	"strreplace",
+	"str_replace",
+	"deletefile",
+	"delete_file"
+]);
+const COMMAND_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"bash",
+	"shell",
+	"terminal",
+	"exec",
+	"execute",
+	"execcommand",
+	"exec_command",
+	"runcommand",
+	"run_command",
+	"local_shell"
+]);
+const SUBAGENT_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"task",
+	"agent",
+	"subagent",
+	"sub_agent"
+]);
+/** Shell builtins that say nothing about what the command as a whole does. */
+const NEUTRAL_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"cd",
+	"echo",
+	"printf",
+	"pwd",
+	"true",
+	"false",
+	"time"
+]);
+/** `sed`/`awk` are stream editors (`sed -i` rewrites files), so they stay commands. */
+const FILE_READ_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"cat",
+	"head",
+	"tail",
+	"less",
+	"more",
+	"bat",
+	"nl",
+	"jq",
+	"wc"
+]);
+const FILE_SEARCH_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"grep",
+	"egrep",
+	"fgrep",
+	"rg",
+	"ag",
+	"ack",
+	"find",
+	"fd",
+	"ls",
+	"tree",
+	"which"
+]);
+const SHELL_SEGMENT_SEPARATOR = /\|\||&&|;|\||\n/u;
+const LEADING_ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=\S*\s+/u;
+const REDIRECT_TARGET = /\d?>>?\s*(?<target>[^\s|;&]+)/gu;
+/** Redirect targets that discard output instead of writing a file. */
+const DISCARDED_REDIRECT_TARGETS = /* @__PURE__ */ new Set([
+	"/dev/null",
+	"&1",
+	"&2"
+]);
+function toolCategoryTitle(category) {
+	return TOOL_CATEGORY_TITLES[category];
+}
+function readCommandInput(toolInput) {
+	const raw = toolInput?.command ?? toolInput?.cmd;
+	if (typeof raw !== "string") return;
+	const trimmed = raw.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+/** `cat x > y` reads and writes; only the write matters for the row heading. */
+function redirectsToFile(segment) {
+	for (const match of segment.matchAll(REDIRECT_TARGET)) {
+		const target = match.groups?.target;
+		if (target && !DISCARDED_REDIRECT_TARGETS.has(target)) return true;
+	}
+	return false;
+}
+function classifyShellSegment(segment) {
+	if (redirectsToFile(segment)) return "command";
+	const head = segment.trim().replace(LEADING_ENV_ASSIGNMENT, "").split(/\s+/u)[0]?.replace(/^.*\//u, "").toLowerCase();
+	if (!head || NEUTRAL_SHELL_COMMANDS.has(head)) return;
+	if (FILE_READ_SHELL_COMMANDS.has(head)) return "file_read";
+	if (FILE_SEARCH_SHELL_COMMANDS.has(head)) return "file_search";
+	return "command";
+}
+/**
+* A shell call only counts as a read or a search when every non-neutral segment
+* agrees; anything unrecognized (or write-ish) keeps the whole call a command.
+* Quoted separators split segments too, which can only downgrade to "command".
+*/
+function classifyShellCommand(command) {
+	const categories = command.split(SHELL_SEGMENT_SEPARATOR).map(classifyShellSegment).filter((category) => category !== void 0);
+	if (categories.length === 0 || categories.includes("command")) return "command";
+	return categories.includes("file_search") ? "file_search" : "file_read";
+}
+function classifyToolCategory(input) {
+	const normalized = input.toolName.trim().toLowerCase();
+	if (normalized.startsWith("mcp__") || normalized.includes("mcp")) return "mcp_tool";
+	if (SUBAGENT_TOOL_NAMES.has(normalized) || normalized.includes("agent")) return "subagent";
+	if (FILE_READ_TOOL_NAMES.has(normalized)) return "file_read";
+	if (FILE_SEARCH_TOOL_NAMES.has(normalized)) return "file_search";
+	if (FILE_CHANGE_TOOL_NAMES.has(normalized)) return "file_change";
+	if (COMMAND_TOOL_NAMES.has(normalized) || normalized.includes("bash") || normalized.includes("shell") || normalized.includes("terminal") || normalized.includes("command")) {
+		const command = readCommandInput(input.toolInput);
+		return command ? classifyShellCommand(command) : "command";
+	}
+	if (normalized.includes("websearch") || normalized.includes("web_search")) return "web_search";
+	if (normalized.includes("edit") || normalized.includes("write") || normalized.includes("patch") || normalized.includes("replace") || normalized.includes("create") || normalized.includes("delete")) return "file_change";
+	if (normalized.includes("read") || normalized.includes("view")) return "file_read";
+	if (normalized.includes("grep") || normalized.includes("glob")) return "file_search";
+	if (normalized.includes("image")) return "image_view";
+	return "tool";
+}
+//#endregion
 //#region src/provider/askUserQuestionAnswers.ts
 /**
 * What separates the options of one multi-select answer.
@@ -47043,17 +47226,17 @@ function summarizeToolRequest(toolName, input) {
 	if (serialized.length <= TOOL_SUMMARY_MAX_LENGTH) return `${toolName}: ${serialized}`;
 	return `${toolName}: ${serialized.slice(0, TOOL_SUMMARY_MAX_LENGTH - 3)}...`;
 }
-function titleForTool(itemType) {
-	switch (itemType) {
-		case "command_execution": return "Command run";
-		case "file_change": return "File change";
-		case "mcp_tool_call": return "MCP tool call";
-		case "collab_agent_tool_call": return "Subagent task";
-		case "web_search": return "Web search";
-		case "image_view": return "Image view";
-		case "dynamic_tool_call": return "Tool call";
-		default: return "Item";
-	}
+/**
+* Heading for a tool row. Derived from the tool name plus its input so a `Read`
+* reads as "File read" instead of a bare "Tool call", and a `Bash` that only
+* inspects a file (`sed -n 1,20p src/x.ts`) reads as "File read" instead of
+* "Command run". Recomputed as streamed input arrives.
+*/
+function titleForTool(toolName, toolInput) {
+	return toolCategoryTitle(classifyToolCategory({
+		toolName,
+		toolInput
+	}));
 }
 const SUPPORTED_CLAUDE_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
 	"image/gif",
@@ -47061,6 +47244,12 @@ const SUPPORTED_CLAUDE_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
 	"image/png",
 	"image/webp"
 ]);
+/**
+* Appended to the preset system prompt when `narrateBeforeTools` is on. The SDK
+* preset drops the interactive CLI's terminal-tone sections, so without this the
+* model opens a turn with a tool call rather than a line saying what it is doing.
+*/
+const NARRATE_BEFORE_TOOLS_PROMPT = "Before your first tool call in a turn, write one short sentence saying what you are about to do. Keep it to a single line and skip it when you are answering without tools.";
 const CLAUDE_SETTING_SOURCES = [
 	"user",
 	"project",
@@ -47786,6 +47975,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		});
 		const updatedAt = yield* nowIso;
 		context.turnState = void 0;
+		context.steeredMessages.clear();
 		context.session = {
 			...context.session,
 			status: "ready",
@@ -47832,6 +48022,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		const updatedAt = yield* nowIso;
 		context.turnState = turnState;
 		context.interruptRequested = false;
+		context.steeredMessages.clear();
 		context.session = {
 			...context.session,
 			status: "running",
@@ -47853,24 +48044,49 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 	/**
 	* Start the queued sendTurn, if the session has gone idle.
 	*
-	* Runs after every turn completion. Messages sent during a running turn wait
-	* here for the agent loop to end; pressing Stop ends the loop early, and the
-	* same drain is what makes Stop mean "and run my messages now". Everything
-	* queued during that turn is already merged into one request by `sendTurn`,
-	* so it starts as a single turn.
+	* Runs after every turn completion. What waits here are the steers Stop took
+	* back from the CLI before they ran (see `reclaimSteeredMessages`); they are
+	* already merged into one request, so they start as a single turn the moment
+	* the interrupted loop ends.
 	*/
 	const drainPendingTurns = Effect.fn("drainPendingTurns")(function* (context) {
 		if (context.stopped || context.turnState !== void 0) return;
 		const pending = context.pendingTurnRequest;
 		if (pending === void 0) return;
 		context.pendingTurnRequest = void 0;
-		yield* applyTurnSessionOptions(context, pending.modelSelection, pending.interactionMode).pipe(Effect.catchCause((cause) => Effect.logWarning("claude pending turn session options failed", { cause })));
-		yield* beginTurn(context, pending.turnId, pending.modelSelection?.model);
+		yield* beginTurn(context, pending.turnId, context.session.model);
 		yield* Queue.offer(context.promptQueue, {
 			type: "message",
 			message: pending.message
 		}).pipe(Effect.ignore);
 	});
+	/**
+	* Take back the steers the CLI has not started yet, so Stop still runs them.
+	*
+	* A steer sits in the CLI's async-message queue until the agent loop reaches
+	* its next boundary. `cancelAsyncMessage` answers true only while it is still
+	* waiting there: those never reached the model and become the next turn
+	* together, while an already-dequeued one is part of the turn being stopped
+	* and must not run a second time.
+	*/
+	const reclaimSteeredMessages = Effect.fn("reclaimSteeredMessages")(function* (context) {
+		const steered = Array.from(context.steeredMessages);
+		context.steeredMessages.clear();
+		const cancelAsyncMessage = context.query.cancelAsyncMessage;
+		if (steered.length === 0 || cancelAsyncMessage === void 0) return;
+		const reclaimed = [];
+		for (const [messageUuid, message] of steered) if (yield* Effect.tryPromise({
+			try: () => cancelAsyncMessage(messageUuid),
+			catch: (cause) => toRequestError$1(context.session.threadId, "turn/cancelAsyncMessage", cause)
+		}).pipe(Effect.catchCause((cause) => Effect.logWarning("claude steer cancel failed", { cause }).pipe(Effect.as(false))))) reclaimed.push(message);
+		if (reclaimed.length === 0) return;
+		const merged = reclaimed.reduce((left, right) => mergeUserMessages(left, right));
+		const pending = context.pendingTurnRequest;
+		context.pendingTurnRequest = {
+			turnId: pending?.turnId ?? TurnId.make(yield* randomUUIDv4),
+			message: pending ? mergeUserMessages(pending.message, merged) : merged
+		};
+	});
 	const handleStreamEvent = Effect.fn("handleStreamEvent")(function* (context, message) {
 		if (message.type !== "stream_event") return;
 		const { event } = message;
@@ -47921,11 +48137,13 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 				const partialInputJson = tool.partialInputJson + event.delta.partial_json;
 				const parsedInput = tryParseJsonRecord(partialInputJson);
 				const detail = parsedInput ? summarizeToolRequest(tool.toolName, parsedInput) : tool.detail;
+				const title = parsedInput ? titleForTool(tool.toolName, parsedInput) : tool.title;
 				let nextTool = {
 					...tool,
 					partialInputJson,
 					...parsedInput ? { input: parsedInput } : {},
-					...detail ? { detail } : {}
+					...detail ? { detail } : {},
+					title
 				};
 				const nextFingerprint = parsedInput && Object.keys(parsedInput).length > 0 ? toolInputFingerprint(parsedInput) : void 0;
 				context.inFlightTools.set(event.index, nextTool);
@@ -47998,7 +48216,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 				itemId,
 				itemType,
 				toolName,
-				title: titleForTool(itemType),
+				title: titleForTool(toolName, toolInput),
 				detail,
 				input: toolInput,
 				partialInputJson: "",
@@ -48864,7 +49082,8 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			pathToClaudeCodeExecutable: claudeBinaryPath,
 			systemPrompt: {
 				type: "preset",
-				preset: "claude_code"
+				preset: "claude_code",
+				...claudeSettings.narrateBeforeTools ? { append: NARRATE_BEFORE_TOOLS_PROMPT } : {}
 			},
 			settingSources: [...CLAUDE_SETTING_SOURCES],
 			...effectiveEffort ? { effort: effectiveEffort } : {},
@@ -48906,6 +49125,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			"claude.query.include_partial_messages": true,
 			"claude.query.additional_directories": input.cwd ? [input.cwd] : [],
 			"claude.query.setting_sources": [...CLAUDE_SETTING_SOURCES],
+			"claude.query.narrate_before_tools": claudeSettings.narrateBeforeTools,
 			"claude.query.settings_json": encodeJsonStringForDiagnostics$2(settings) ?? "",
 			"claude.query.extra_args_json": encodeJsonStringForDiagnostics$2(extraArgs) ?? "",
 			"claude.query.path_to_executable": claudeBinaryPath
@@ -48956,6 +49176,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			claudeTasks,
 			turnState: void 0,
 			pendingTurnRequest: void 0,
+			steeredMessages: /* @__PURE__ */ new Map(),
 			lastKnownContextWindow: initialContextWindow,
 			lastKnownTokenUsage: void 0,
 			lastKnownTotalProcessedTokens: void 0,
@@ -49024,17 +49245,19 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			boundInstanceId
 		});
 		if (context.turnState) {
-			const pending = context.pendingTurnRequest;
-			const turnId = pending?.turnId ?? TurnId.make(yield* randomUUIDv4);
-			context.pendingTurnRequest = {
-				turnId,
-				message: pending ? mergeUserMessages(pending.message, message) : message,
-				modelSelection,
-				interactionMode: input.interactionMode
+			const steerUuid = yield* randomUUIDv4;
+			const steered = {
+				...message,
+				uuid: steerUuid
 			};
+			context.steeredMessages.set(steerUuid, steered);
+			yield* Queue.offer(context.promptQueue, {
+				type: "message",
+				message: steered
+			}).pipe(Effect.mapError((cause) => toRequestError$1(input.threadId, "turn/start", cause)));
 			return {
 				threadId: context.session.threadId,
-				turnId,
+				turnId: context.turnState.turnId,
 				...context.session.resumeCursor !== void 0 ? { resumeCursor: context.session.resumeCursor } : {}
 			};
 		}
@@ -49054,6 +49277,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 	const interruptTurn = Effect.fn("interruptTurn")(function* (threadId, _turnId) {
 		const context = yield* requireSession(threadId);
 		context.interruptRequested = true;
+		yield* reclaimSteeredMessages(context);
 		yield* Effect.tryPromise({
 			try: () => context.query.interrupt(),
 			catch: (cause) => toRequestError$1(threadId, "turn/interrupt", cause)