@sayknow-cli/coding-agent 0.3.2 → 0.3.4

package/src/tools/cron.ts

@@ -19,34 +19,36 @@ const MAX_RECURRING_JITTER_MS = 30 * 60 * 1000;
 const MAX_ONE_SHOT_EARLY_JITTER_MS = 90 * 1000;
 const MAX_TIMEOUT_MS = 2_147_483_647;
 
-const cronCreateSchema = z.object({
-	cron_expression: z
-		.string()
-		.describe(
-			"Standard 5-field cron expression in the user's local timezone: 'minute hour day-of-month month day-of-week'. Examples: '*/5 * * * *' (every 5 min), '0 9 * * *' (9am daily), '0 9 * * 1-5' (weekdays at 9am). Day-of-week uses 0/7 for Sunday through 6 for Saturday. When both day-of-month and day-of-week are constrained, a date matches if either field matches (vixie-cron semantics).",
-		),
-	prompt: z
-		.string()
-		.describe(
-			"Prompt to inject between turns when the cron fires. May reference slash commands (e.g. '/review-pr 1234') or natural-language instructions.",
-		),
-	recurring: z
-		.boolean()
-		.default(true)
-		.describe(
-			"true to fire on every match of the cron expression (recurring, auto-expires after 7 days); false to fire once at the next match and then self-delete.",
-		),
-});
-
-export type CronCreateParams = z.infer<typeof cronCreateSchema>;
-
-const cronListSchema = z.object({});
-export type CronListParams = z.infer<typeof cronListSchema>;
-
-const cronDeleteSchema = z.object({
-	id: z.string().min(1).describe("The 8-character job ID returned by CronCreate."),
-});
-export type CronDeleteParams = z.infer<typeof cronDeleteSchema>;
+const cronSchema = z
+	.object({
+		op: z
+			.enum(["create", "list", "delete"])
+			.describe(
+				"operation: 'create' schedules a prompt on a cron expression, 'list' enumerates scheduled tasks, 'delete' cancels a task by id",
+			),
+		cron_expression: z
+			.string()
+			.optional()
+			.describe(
+				"(op=create, required) Standard 5-field cron expression in the user's local timezone: 'minute hour day-of-month month day-of-week'. Examples: '*/5 * * * *' (every 5 min), '0 9 * * *' (9am daily), '0 9 * * 1-5' (weekdays at 9am). Day-of-week uses 0/7 for Sunday through 6 for Saturday. When both day-of-month and day-of-week are constrained, a date matches if either field matches (vixie-cron semantics).",
+			),
+		prompt: z
+			.string()
+			.optional()
+			.describe(
+				"(op=create, required) Prompt to inject between turns when the cron fires. May reference slash commands (e.g. '/review-pr 1234') or natural-language instructions.",
+			),
+		recurring: z
+			.boolean()
+			.optional()
+			.describe(
+				"(op=create) true to fire on every match of the cron expression (recurring, auto-expires after 7 days); false to fire once at the next match and then self-delete.",
+			),
+		id: z.string().optional().describe("(op=delete, required) The 8-character job ID returned by op=create."),
+	})
+	.strict();
+
+export type CronParams = z.infer<typeof cronSchema>;
 
 export interface CronJobSnapshot {
 	id: string;
@@ -68,20 +70,14 @@ export interface CronListJobDetails {
 	humanSchedule: string;
 }
 
-export interface CronCreateToolDetails {
-	id: string;
-	cron_expression: string;
-	recurring: boolean;
+export interface CronToolDetails {
+	op: "create" | "list" | "delete";
+	id?: string;
+	cron_expression?: string;
+	recurring?: boolean;
 	nextFireAt?: number;
-}
-
-export interface CronListToolDetails {
-	jobs: CronListJobDetails[];
-}
-
-export interface CronDeleteToolDetails {
-	id: string;
-	deleted: boolean;
+	jobs?: CronListJobDetails[];
+	deleted?: boolean;
 }
 
 interface CronTimerHandle {
@@ -543,12 +539,12 @@ function isCronDisabled(): boolean {
 	return process.env.CLAUDE_CODE_DISABLE_CRON === "1";
 }
 
-export class CronCreateTool implements AgentTool<typeof cronCreateSchema, CronCreateToolDetails> {
-	readonly name = "CronCreate";
-	readonly label = "CronCreate";
-	readonly summary = "Schedule a prompt on a 5-field cron expression";
+export class CronTool implements AgentTool<typeof cronSchema, CronToolDetails> {
+	readonly name = "cron";
+	readonly label = "Cron";
+	readonly summary = "Schedule, list, and cancel cron-style prompts (op: create | list | delete)";
 	readonly description: string;
-	readonly parameters = cronCreateSchema;
+	readonly parameters = cronSchema;
 	readonly strict = true;
 	readonly loadMode = "discoverable";
 
@@ -556,19 +552,30 @@ export class CronCreateTool implements AgentTool<typeof cronCreateSchema, CronCr
 		this.description = prompt.render(cronDescription);
 	}
 
-	static createIf(session: ToolSession): CronCreateTool | null {
+	static createIf(session: ToolSession): CronTool | null {
 		if (!isBackgroundJobSupportEnabled(session.settings)) return null;
 		if (isCronDisabled()) return null;
-		return new CronCreateTool(session);
+		return new CronTool(session);
 	}
 
 	async execute(
 		_toolCallId: string,
-		params: CronCreateParams,
+		params: CronParams,
 		_signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<CronCreateToolDetails>,
+		_onUpdate?: AgentToolUpdateCallback<CronToolDetails>,
 		_context?: AgentToolContext,
-	): Promise<AgentToolResult<CronCreateToolDetails>> {
+	): Promise<AgentToolResult<CronToolDetails>> {
+		switch (params.op) {
+			case "create":
+				return this.#create(params);
+			case "list":
+				return this.#list();
+			case "delete":
+				return this.#delete(params);
+		}
+	}
+
+	async #create(params: CronParams): Promise<AgentToolResult<CronToolDetails>> {
 		const manager = AsyncJobManager.instance();
 		if (!manager) {
 			throw new ToolError("Async execution is disabled; cron is unavailable in this session.");
@@ -576,26 +583,30 @@ export class CronCreateTool implements AgentTool<typeof cronCreateSchema, CronCr
 		if (isCronDisabled()) {
 			throw new ToolError("Cron is disabled by CLAUDE_CODE_DISABLE_CRON=1.");
 		}
+		if (!params.cron_expression || !params.prompt) {
+			throw new ToolError("cron op=create requires both 'cron_expression' and 'prompt'.");
+		}
 		validateCronExpression(params.cron_expression);
 
 		const ownerId = this.session.getAgentId?.() ?? undefined;
 		const state = getOrCreateOwnerState(ownerId);
 		if (state.jobs.size >= MAX_CRON_TASKS_PER_OWNER) {
 			throw new ToolError(
-				`Cron task limit reached (${MAX_CRON_TASKS_PER_OWNER}). Cancel an existing task with CronDelete first.`,
+				`Cron task limit reached (${MAX_CRON_TASKS_PER_OWNER}). Cancel an existing task with cron op=delete first.`,
 			);
 		}
 		ensureOwnerCleanup(ownerId, manager, state);
 
 		const id = generateCronId(new Set(state.jobs.keys()));
 		const now = Date.now();
+		const recurring = params.recurring ?? true;
 		const snapshot: CronJobSnapshot = {
 			id,
 			cron_expression: params.cron_expression.trim(),
 			prompt: params.prompt,
-			recurring: params.recurring,
+			recurring,
 			createdAt: now,
-			expiresAt: params.recurring ? now + CRON_RECURRING_MAX_AGE_MS : undefined,
+			expiresAt: recurring ? now + CRON_RECURRING_MAX_AGE_MS : undefined,
 			humanSchedule: humanizeCronExpression(params.cron_expression.trim()),
 			ownerId,
 		};
@@ -604,7 +615,7 @@ export class CronCreateTool implements AgentTool<typeof cronCreateSchema, CronCr
 		scheduleExpiry(ownerId, record);
 		scheduleRecord(ownerId, state, record);
 
-		logger.debug("CronCreate: scheduled task", {
+		logger.debug("cron op=create: scheduled task", {
 			id,
 			ownerId,
 			cron: snapshot.cron_expression,
@@ -614,6 +625,7 @@ export class CronCreateTool implements AgentTool<typeof cronCreateSchema, CronCr
 		return {
 			content: [{ type: "text", text: `Scheduled ${id} (${snapshot.humanSchedule})` }],
 			details: {
+				op: "create",
 				id,
 				cron_expression: snapshot.cron_expression,
 				recurring: snapshot.recurring,
@@ -621,34 +633,8 @@ export class CronCreateTool implements AgentTool<typeof cronCreateSchema, CronCr
 			},
 		};
 	}
-}
-
-export class CronListTool implements AgentTool<typeof cronListSchema, CronListToolDetails> {
-	readonly name = "CronList";
-	readonly label = "CronList";
-	readonly summary = "List scheduled cron jobs";
-	readonly description: string;
-	readonly parameters = cronListSchema;
-	readonly strict = true;
-	readonly loadMode = "discoverable";
-
-	constructor(private readonly session: ToolSession) {
-		this.description = prompt.render(cronDescription);
-	}
 
-	static createIf(session: ToolSession): CronListTool | null {
-		if (!isBackgroundJobSupportEnabled(session.settings)) return null;
-		if (isCronDisabled()) return null;
-		return new CronListTool(session);
-	}
-
-	async execute(
-		_toolCallId: string,
-		_params: CronListParams,
-		_signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<CronListToolDetails>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<CronListToolDetails>> {
+	async #list(): Promise<AgentToolResult<CronToolDetails>> {
 		const ownerId = this.session.getAgentId?.() ?? undefined;
 		const state = schedulesByOwner.get(ownerKey(ownerId));
 		const records = state
@@ -658,7 +644,7 @@ export class CronListTool implements AgentTool<typeof cronListSchema, CronListTo
 		if (jobs.length === 0) {
 			return {
 				content: [{ type: "text", text: "No scheduled jobs" }],
-				details: { jobs: [] },
+				details: { op: "list", jobs: [] },
 			};
 		}
 		const lines = jobs.map(job => {
@@ -667,43 +653,20 @@ export class CronListTool implements AgentTool<typeof cronListSchema, CronListTo
 		});
 		return {
 			content: [{ type: "text", text: lines.join("\n") }],
-			details: { jobs },
+			details: { op: "list", jobs },
 		};
 	}
-}
 
-export class CronDeleteTool implements AgentTool<typeof cronDeleteSchema, CronDeleteToolDetails> {
-	readonly name = "CronDelete";
-	readonly label = "CronDelete";
-	readonly summary = "Cancel a scheduled cron job by ID";
-	readonly description: string;
-	readonly parameters = cronDeleteSchema;
-	readonly strict = true;
-	readonly loadMode = "discoverable";
-
-	constructor(private readonly session: ToolSession) {
-		this.description = prompt.render(cronDescription);
-	}
-
-	static createIf(session: ToolSession): CronDeleteTool | null {
-		if (!isBackgroundJobSupportEnabled(session.settings)) return null;
-		if (isCronDisabled()) return null;
-		return new CronDeleteTool(session);
-	}
-
-	async execute(
-		_toolCallId: string,
-		params: CronDeleteParams,
-		_signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<CronDeleteToolDetails>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<CronDeleteToolDetails>> {
+	async #delete(params: CronParams): Promise<AgentToolResult<CronToolDetails>> {
+		if (!params.id) {
+			throw new ToolError("cron op=delete requires 'id'.");
+		}
 		const ownerId = this.session.getAgentId?.() ?? undefined;
 		const deleted = deleteRecord(ownerId, params.id);
 		const text = deleted ? `Cancelled ${params.id}` : `No scheduled task '${params.id}' found; nothing to cancel.`;
 		return {
 			content: [{ type: "text", text }],
-			details: { id: params.id, deleted },
+			details: { op: "delete", id: params.id, deleted },
 		};
 	}
 }

package/src/tools/index.ts

@@ -38,12 +38,11 @@ import { BrowserTool } from "./browser";
 import { CalculatorTool } from "./calculator";
 import { type CheckpointState, CheckpointTool, RewindTool } from "./checkpoint";
 import { ComputerTool, isComputerCallable, isComputerLoadablePlatform } from "./computer";
-import { CronCreateTool, CronDeleteTool, CronListTool } from "./cron";
+import { CronTool } from "./cron";
 import { DebugTool } from "./debug";
 import { EvalTool } from "./eval";
 import { FindTool } from "./find";
 import { GithubTool } from "./gh";
-import { InspectImageTool } from "./inspect-image";
 import { IrcTool } from "./irc";
 import { JobTool } from "./job";
 import { MonitorTool } from "./monitor";
@@ -83,7 +82,6 @@ export * from "./eval";
 export * from "./find";
 export * from "./gh";
 export * from "./image-gen";
-export * from "./inspect-image";
 export * from "./irc";
 export * from "./job";
 export * from "./monitor";
@@ -389,7 +387,6 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	find: s => new FindTool(s),
 	search: s => new SearchTool(s),
 	lsp: LspTool.createIf,
-	inspect_image: s => new InspectImageTool(s),
 	browser: s => new BrowserTool(s),
 	...(isComputerLoadablePlatform() ? { computer: ComputerTool.createIf } : {}),
 	checkpoint: CheckpointTool.createIf,
@@ -398,9 +395,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	subagent: s => new SubagentTool(s),
 	job: JobTool.createIf,
 	monitor: MonitorTool.createIf,
-	CronCreate: CronCreateTool.createIf,
-	CronList: CronListTool.createIf,
-	CronDelete: CronDeleteTool.createIf,
+	cron: CronTool.createIf,
 	recipe: RecipeTool.createIf,
 	irc: IrcTool.createIf,
 	todo_write: s => new TodoWriteTool(s),
@@ -560,7 +555,6 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "ast_grep") return session.settings.get("astGrep.enabled");
 		if (name === "ast_edit") return session.settings.get("astEdit.enabled");
 		if (name === "render_mermaid") return session.settings.get("renderMermaid.enabled");
-		if (name === "inspect_image") return session.settings.get("inspect_image.enabled");
 		if (name === "web_search") return session.settings.get("web_search.enabled");
 		// search_tool_bm25 is allowed when either legacy mcp.discoveryMode or new tools.discoveryMode is active.
 		if (name === "search_tool_bm25") return discoveryActive;

package/src/tools/read.ts

@@ -670,7 +670,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 	readonly #autoResizeImages: boolean;
 	readonly #defaultLimit: number;
-	readonly #inspectImageEnabled: boolean;
 
 	constructor(private readonly session: ToolSession) {
 		const displayMode = resolveFileDisplayMode(session);
@@ -679,7 +678,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			1,
 			Math.min(session.settings.get("read.defaultLimit") ?? DEFAULT_MAX_LINES, DEFAULT_MAX_LINES),
 		);
-		this.#inspectImageEnabled = session.settings.get("inspect_image.enabled");
 		this.description = prompt.render(readDescription, {
 			DEFAULT_LIMIT: String(this.#defaultLimit),
 			DEFAULT_MAX_LINES: String(DEFAULT_MAX_LINES),
@@ -1572,62 +1570,34 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			| undefined;
 
 		if (mimeType) {
-			if (this.#inspectImageEnabled) {
-				const metadata = imageMetadata;
-				const outputMime = metadata?.mimeType ?? mimeType;
-				const outputBytes = fileSize;
-				const metadataLines = [
-					"Image metadata:",
-					`- MIME: ${outputMime}`,
-					`- Bytes: ${outputBytes} (${formatBytes(outputBytes)})`,
-					metadata?.width !== undefined && metadata.height !== undefined
-						? `- Dimensions: ${metadata.width}x${metadata.height}`
-						: "- Dimensions: unknown",
-					metadata?.channels !== undefined ? `- Channels: ${metadata.channels}` : "- Channels: unknown",
-					metadata?.hasAlpha === true
-						? "- Alpha: yes"
-						: metadata?.hasAlpha === false
-							? "- Alpha: no"
-							: "- Alpha: unknown",
-					"",
-					`If you want to analyze the image, call inspect_image with path="${formatPathRelativeToCwd(
-						absolutePath,
-						this.session.cwd,
-					)}" and a question describing what to inspect and the desired output format.`,
+			if (fileSize > MAX_IMAGE_SIZE) {
+				const sizeStr = formatBytes(fileSize);
+				const maxStr = formatBytes(MAX_IMAGE_SIZE);
+				throw new ToolError(`Image file too large: ${sizeStr} exceeds ${maxStr} limit.`);
+			}
+			try {
+				const imageInput = await loadImageInput({
+					path: readPath,
+					cwd: this.session.cwd,
+					autoResize: this.#autoResizeImages,
+					maxBytes: MAX_IMAGE_SIZE,
+					resolvedPath: absolutePath,
+					detectedMimeType: mimeType,
+				});
+				if (!imageInput) {
+					throw new ToolError(`Read image file [${mimeType}] failed: unsupported image format.`);
+				}
+				content = [
+					{ type: "text", text: imageInput.textNote },
+					{ type: "image", data: imageInput.data, mimeType: imageInput.mimeType },
 				];
-				content = [{ type: "text", text: metadataLines.join("\n") }];
 				details = {};
-				sourcePath = absolutePath;
-			} else {
-				if (fileSize > MAX_IMAGE_SIZE) {
-					const sizeStr = formatBytes(fileSize);
-					const maxStr = formatBytes(MAX_IMAGE_SIZE);
-					throw new ToolError(`Image file too large: ${sizeStr} exceeds ${maxStr} limit.`);
-				}
-				try {
-					const imageInput = await loadImageInput({
-						path: readPath,
-						cwd: this.session.cwd,
-						autoResize: this.#autoResizeImages,
-						maxBytes: MAX_IMAGE_SIZE,
-						resolvedPath: absolutePath,
-						detectedMimeType: mimeType,
-					});
-					if (!imageInput) {
-						throw new ToolError(`Read image file [${mimeType}] failed: unsupported image format.`);
-					}
-					content = [
-						{ type: "text", text: imageInput.textNote },
-						{ type: "image", data: imageInput.data, mimeType: imageInput.mimeType },
-					];
-					details = {};
-					sourcePath = imageInput.resolvedPath;
-				} catch (error) {
-					if (error instanceof ImageInputTooLargeError) {
-						throw new ToolError(error.message);
-					}
-					throw error;
+				sourcePath = imageInput.resolvedPath;
+			} catch (error) {
+				if (error instanceof ImageInputTooLargeError) {
+					throw new ToolError(error.message);
 				}
+				throw error;
 			}
 		} else if (isNotebookPath(absolutePath) && !isRawSelector(parsed)) {
 			const notebookText = await readEditableNotebookText(absolutePath, localReadPath);

package/src/tools/renderers.ts

@@ -22,7 +22,6 @@ import { debugToolRenderer } from "./debug";
 import { evalToolRenderer } from "./eval";
 import { findToolRenderer } from "./find";
 import { githubToolRenderer } from "./gh-renderer";
-import { inspectImageToolRenderer } from "./inspect-image-renderer";
 import { jobToolRenderer } from "./job";
 import { readToolRenderer } from "./read";
 import { recipeToolRenderer } from "./recipe/render";
@@ -63,7 +62,6 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	find: findToolRenderer as ToolRenderer,
 	search: searchToolRenderer as ToolRenderer,
 	lsp: lspToolRenderer as ToolRenderer,
-	inspect_image: inspectImageToolRenderer as ToolRenderer,
 	read: readToolRenderer as ToolRenderer,
 	job: jobToolRenderer as ToolRenderer,
 	resolve: resolveToolRenderer as ToolRenderer,