@nghyane/arcane 0.1.13 → 0.1.14

package/src/task/subprocess-tool-registry.ts

@@ -7,7 +7,7 @@
  * - Provide custom rendering for realtime/final display
  */
 import type { Component } from "@nghyane/arcane-tui";
-import type { Theme } from "../modes/theme/theme";
+import type { Theme } from "../theme/theme";
 
 /** Event from subprocess tool execution (parsed from JSONL) */
 export interface SubprocessToolEvent {

package/src/task/types.ts

@@ -1,58 +1,30 @@
 import type { ThinkingLevel } from "@nghyane/arcane-agent";
 import type { Usage } from "@nghyane/arcane-ai";
-import { $env } from "@nghyane/arcane-utils";
 import { type Static, Type } from "@sinclair/typebox";
 
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
 
-const parseNumber = (value: string | undefined, defaultValue: number): number => {
-	if (!value) return defaultValue;
-	const number = Number.parseInt(value, 10);
-	return Number.isNaN(number) || number <= 0 ? defaultValue : number;
-};
-
-/** Maximum output bytes per agent */
-export const MAX_OUTPUT_BYTES = parseNumber($env.ARCANE_TASK_MAX_OUTPUT_BYTES, 500_000);
-
-/** Maximum output lines per agent */
-export const MAX_OUTPUT_LINES = parseNumber($env.ARCANE_TASK_MAX_OUTPUT_LINES, 5000);
+/** Discriminant for agent capability profile */
+export type AgentKind = "local" | "remote" | "hybrid" | "reasoning";
 
 /** EventBus channel for raw subagent events */
 export const TASK_SUBAGENT_EVENT_CHANNEL = "task:subagent:event";
 
-/** EventBus channel for aggregated subagent progress */
-export const TASK_SUBAGENT_PROGRESS_CHANNEL = "task:subagent:progress";
-
-/** Single task item for execution */
-export interface TaskItem {
-	id: string;
-	description: string;
-	assignment: string;
-	skills?: string[];
-}
-
-/** Task schema — single task with optional context */
+/** Task schema — simplified prompt + description */
 export const taskSchema = Type.Object({
-	id: Type.String({
-		description: "CamelCase identifier, max 32 chars",
-		maxLength: 32,
+	prompt: Type.String({
+		description:
+			"The task for the agent to perform. Be specific about what needs to be done and include any relevant context.",
 	}),
 	description: Type.String({
-		description: "Short one-liner for UI display only \u2014 not seen by the subagent",
-	}),
-	assignment: Type.String({
-		description:
-			"Complete instructions the subagent executes. Include target files, change description, edge cases, and acceptance criteria.",
+		description: "A very short description of the task that can be displayed to the user.",
 	}),
-	context: Type.Optional(
-		Type.String({
-			description: "Optional shared background prepended to the assignment.",
-		}),
-	),
-	skills: Type.Optional(
-		Type.Array(Type.String(), {
-			description: "Skill names to preload into the subagent.",
+	complexity: Type.Optional(
+		Type.Union([Type.Literal("low"), Type.Literal("high")], {
+			description:
+				"Task complexity. 'low' for mechanical/rote changes (rename, add import, update config). 'high' for changes requiring reasoning (refactors, bug fixes, new features). Default: high.",
+			default: "high",
 		}),
 	),
 });
@@ -62,10 +34,11 @@ export type TaskParams = Static<TaskSchema>;
 
 /** Agent definition (bundled or discovered) */
 export interface AgentDefinition {
+	kind: AgentKind;
 	name: string;
 	description: string;
 	systemPrompt: string;
-	tools?: string[];
+	tools: string[];
 	model?: string[];
 	thinkingLevel?: ThinkingLevel;
 	source: AgentSource;
@@ -104,19 +77,13 @@ export interface SingleResult {
 	description?: string;
 	lastIntent?: string;
 	exitCode: number;
-	output: string;
 	stderr: string;
-	truncated: boolean;
 	durationMs: number;
 	tokens: number;
 	error?: string;
 	aborted?: boolean;
 	/** Aggregated usage from the subprocess, accumulated incrementally from message_end events. */
 	usage?: Usage;
-	/** Output path for the task result */
-	outputPath?: string;
-	/** Output metadata for agent:// URL integration */
-	outputMeta?: { lineCount: number; charCount: number };
 	/** Full history of tool calls for nested display */
 	toolHistory?: Array<{ tool: string; args: string; status: "success" | "error" }>;
 }

package/src/tools/ask.ts

@@ -18,38 +18,36 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@nghyane/arcane-tui";
 import { TERMINAL, Text } from "@nghyane/arcane-tui";
 import { type Static, Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { type Theme, theme } from "../modes/theme/theme";
-import askDescription from "../prompts/tools/ask.md" with { type: "text" };
+import { type Theme, theme } from "../theme/theme";
 import { renderStatusLine } from "../tui";
+import { formatErrorMessage } from "../ui/render-utils";
 import type { ToolSession } from ".";
-import { ToolUIKit } from "./render-utils";
 
 // =============================================================================
 // Types
 // =============================================================================
 
 const OptionItem = Type.Object({
-	label: Type.String({ description: "Display label" }),
+	label: Type.String({ description: "Display text for the option" }),
 });
 
 const QuestionItem = Type.Object({
-	id: Type.String({ description: "Question ID, e.g. 'auth', 'cache'" }),
-	question: Type.String({ description: "Question text" }),
-	options: Type.Array(OptionItem, { description: "Available options" }),
+	id: Type.String({ description: "Unique question identifier" }),
+	question: Type.String({ description: "Question text to display" }),
+	options: Type.Array(OptionItem),
 	multi: Type.Optional(Type.Boolean({ description: "Allow multiple selections" })),
-	recommended: Type.Optional(Type.Number({ description: "Index of recommended option (0-indexed)" })),
+	recommended: Type.Optional(Type.Number({ description: "Index of the recommended option" })),
 });
 
 const askSchema = Type.Object({
-	questions: Type.Array(QuestionItem, { description: "Questions to ask", minItems: 1 }),
+	questions: Type.Array(QuestionItem, { minItems: 1 }),
 });
 
-export type AskToolInput = Static<typeof askSchema>;
+type AskToolInput = Static<typeof askSchema>;
 
 /** Result for a single question */
-export interface QuestionResult {
+interface QuestionResult {
 	id: string;
 	question: string;
 	options: string[];
@@ -243,15 +241,13 @@ type AskParams = AskToolInput;
  * Allows gathering user preferences, clarifying instructions, and getting decisions
  * on implementation choices as the agent works.
  */
-export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
+export class AskTool implements AgentTool<typeof askSchema, AskToolDetails, Theme> {
 	readonly name = "ask";
 	readonly label = "Ask";
-	readonly description: string;
+	description = "Ask the user a question when genuinely blocked";
 	readonly parameters = askSchema;
 
-	constructor(private readonly session: ToolSession) {
-		this.description = renderPromptTemplate(askDescription);
-	}
+	constructor(private readonly session: ToolSession) {}
 
 	static createIf(session: ToolSession): AskTool | null {
 		return session.hasUI ? new AskTool(session) : null;
@@ -358,28 +354,9 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 
 		return { content: [{ type: "text" as const, text: responseText }], details };
 	}
-}
-
-// =============================================================================
-// TUI Renderer
-// =============================================================================
-
-interface AskRenderArgs {
-	question?: string;
-	options?: Array<{ label: string }>;
-	multi?: boolean;
-	questions?: Array<{
-		id: string;
-		question: string;
-		options: Array<{ label: string }>;
-		multi?: boolean;
-	}>;
-}
 
-export const askToolRenderer = {
 	renderCall(args: AskRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const ui = new ToolUIKit(uiTheme);
-		const label = ui.title("Ask");
+		const label = uiTheme.fg("toolTitle", uiTheme.bold("Ask"));
 
 		// Multi-part questions
 		if (args.questions && args.questions.length > 0) {
@@ -414,14 +391,14 @@ export const askToolRenderer = {
 
 		// Single question
 		if (!args.question) {
-			return new Text(ui.errorMessage("No question provided"), 0, 0);
+			return new Text(formatErrorMessage("No question provided", uiTheme), 0, 0);
 		}
 
 		let text = `${label} ${uiTheme.fg("accent", args.question)}`;
 		const meta: string[] = [];
 		if (args.multi) meta.push("multi");
 		if (args.options?.length) meta.push(`options:${args.options.length}`);
-		text += ui.meta(meta);
+		text += meta.length > 0 ? ` ${uiTheme.fg("muted", meta.join(uiTheme.sep.dot))}` : "";
 
 		if (args.options?.length) {
 			for (let i = 0; i < args.options.length; i++) {
@@ -433,7 +410,7 @@ export const askToolRenderer = {
 		}
 
 		return new Text(text, 0, 0);
-	},
+	}
 
 	renderResult(
 		result: { content: Array<{ type: string; text?: string }>; details?: AskToolDetails },
@@ -519,5 +496,17 @@ export const askToolRenderer = {
 		}
 
 		return new Text(text, 0, 0);
-	},
-};
+	}
+}
+
+interface AskRenderArgs {
+	question?: string;
+	options?: Array<{ label: string }>;
+	multi?: boolean;
+	questions?: Array<{
+		id: string;
+		question: string;
+		options: Array<{ label: string }>;
+		multi?: boolean;
+	}>;
+}

package/src/tools/bash-interactive.ts

@@ -12,10 +12,10 @@ import {
 import type { Terminal as XtermTerminalType } from "@xterm/headless";
 import xterm from "@xterm/headless";
 import { NON_INTERACTIVE_ENV } from "../exec/non-interactive-env";
-import type { Theme } from "../modes/theme/theme";
 import { OutputSink, type OutputSummary } from "../session/streaming-output";
+import type { Theme } from "../theme/theme";
 import { getStateIcon } from "../tui";
-import { replaceTabs } from "./render-utils";
+import { replaceTabs } from "../ui/render-utils";
 
 export interface BashInteractiveResult extends OutputSummary {
 	exitCode: number | undefined;

package/src/tools/bash-interceptor.ts

@@ -7,7 +7,7 @@
  */
 import type { BashInterceptorRule } from "../config/settings-schema";
 
-export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
+const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
 	{
 		pattern: "^\\s*(cat|head|tail|less|more)\\s+",
 		tool: "read",
@@ -45,7 +45,7 @@ export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
 	},
 ];
 
-export interface InterceptionResult {
+interface InterceptionResult {
 	/** If true, the bash command should be blocked */
 	block: boolean;
 	/** Error message to return instead of executing */

package/src/tools/bash-normalize.ts

@@ -6,7 +6,7 @@
  * - `| tail -n N` / `| tail -N` - extracted to tailLines
  */
 
-export interface NormalizedCommand {
+interface NormalizedCommand {
 	/** Cleaned command with patterns stripped */
 	command: string;
 	/** Extracted head line count, if any */

package/src/tools/bash-skill-urls.ts

@@ -20,7 +20,7 @@ interface InternalUrlResolver {
 	resolve(input: string): Promise<InternalResource>;
 }
 
-export interface InternalUrlExpansionOptions {
+interface InternalUrlExpansionOptions {
 	skills: readonly Skill[];
 	internalRouter?: InternalUrlResolver;
 }
@@ -29,7 +29,7 @@ export interface InternalUrlExpansionOptions {
  * Resolve a single skill:// URL to its absolute filesystem path.
  * Does NOT read file content or verify existence.
  */
-export function resolveSkillUrlToPath(url: string, skills: readonly Skill[]): string {
+function resolveSkillUrlToPath(url: string, skills: readonly Skill[]): string {
 	const parsed = /^skill:\/\/([^/?#]+)(\/[^?#]*)?(?:[?#].*)?$/.exec(url);
 	if (!parsed) {
 		throw new ToolError(`Invalid skill:// URL: ${url}`);

package/src/tools/bash.ts

@@ -6,35 +6,30 @@ import { Text } from "@nghyane/arcane-tui";
 import { $env, isEnoent } from "@nghyane/arcane-utils";
 import { getProjectDir } from "@nghyane/arcane-utils/dirs";
 import { type Static, Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import { type BashResult, executeBash } from "../exec/bash-executor";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { truncateToVisualLines } from "../modes/components/visual-truncate";
-import type { Theme } from "../modes/theme/theme";
-import bashDescription from "../prompts/tools/bash.md" with { type: "text" };
 import { DEFAULT_MAX_BYTES } from "../session/streaming-output";
+import type { Theme } from "../theme/theme";
 import { renderStatusLine } from "../tui";
-import { CachedOutputBlock } from "../tui/output-block";
+import { formatClickHint, PREVIEW_LIMITS, replaceTabs } from "../ui/render-utils";
 import type { ToolSession } from ".";
 import { type BashInteractiveResult, runInteractiveBashPty } from "./bash-interactive";
 import { checkBashInterception } from "./bash-interceptor";
 import { applyHeadTail } from "./bash-normalize";
 import { expandInternalUrls } from "./bash-skill-urls";
-import type { OutputMeta } from "./output-meta";
+import { type OutputMeta, toolResult } from "./output-meta";
 import { allocateOutputArtifact, createTailBuffer } from "./output-utils";
 import { resolveToCwd } from "./path-utils";
-import { formatBytes, replaceTabs, wrapBrackets } from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
-import { toolResult } from "./tool-result";
 
 export const BASH_DEFAULT_PREVIEW_LINES = 10;
 
 const bashSchema = Type.Object({
-	command: Type.String({ description: "Command to execute" }),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 300)" })),
-	cwd: Type.Optional(Type.String({ description: "Working directory (default: cwd)" })),
-	head: Type.Optional(Type.Number({ description: "Return only first N lines of output" })),
-	tail: Type.Optional(Type.Number({ description: "Return only last N lines of output" })),
+	command: Type.String({ description: "Shell command to execute" }),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in milliseconds" })),
+	cwd: Type.Optional(Type.String({ description: "Working directory" })),
+	head: Type.Optional(Type.Number({ description: "Return only the first N lines of output" })),
+	tail: Type.Optional(Type.Number({ description: "Return only the last N lines of output" })),
 });
 
 export type BashToolInput = Static<typeof bashSchema>;
@@ -57,16 +52,14 @@ function isInteractiveResult(result: BashResult | BashInteractiveResult): result
  *
  * Executes bash commands with optional timeout and working directory.
  */
-export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
+export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails, Theme> {
 	readonly name = "bash";
 	readonly label = "Bash";
-	readonly description: string;
+	description = "Execute a shell command";
 	readonly parameters = bashSchema;
 	readonly concurrency = "exclusive";
 
-	constructor(private readonly session: ToolSession) {
-		this.description = renderPromptTemplate(bashDescription);
-	}
+	constructor(private readonly session: ToolSession) {}
 
 	async execute(
 		_toolCallId: string,
@@ -183,11 +176,83 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 
 		return resultBuilder.done();
 	}
-}
 
-// =============================================================================
-// TUI Renderer
-// =============================================================================
+	buildRenderContext(info: {
+		args: BashToolInput;
+		result?: AgentToolResult<BashToolDetails>;
+		expanded: boolean;
+		getTextOutput: () => string;
+	}): Record<string, unknown> {
+		const context: Record<string, unknown> = {};
+		if (info.result) {
+			context.output = info.getTextOutput().trimEnd();
+			context.expanded = info.expanded;
+			context.previewLines = BASH_DEFAULT_PREVIEW_LINES;
+			if (typeof info.args.timeout === "number" && Number.isFinite(info.args.timeout)) {
+				context.timeout = Math.max(1, Math.min(3600, info.args.timeout));
+			}
+		}
+		return context;
+	}
+
+	renderCall(args: BashRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+		const cmdText = formatBashCommand(args, uiTheme);
+		const text = renderStatusLine({ icon: "pending", title: "Bash", description: cmdText }, uiTheme);
+		return new Text(text, 0, 0);
+	}
+
+	renderResult(
+		result: {
+			content: Array<{ type: string; text?: string }>;
+			details?: BashToolDetails;
+			isError?: boolean;
+		},
+		options: RenderResultOptions & { renderContext?: BashRenderContext },
+		uiTheme: Theme,
+		args?: BashRenderArgs,
+	): Component {
+		const cmdText = args ? formatBashCommand(args, uiTheme) : "…";
+		const isError = result.isError === true;
+		const { renderContext } = options;
+		const output = (renderContext?.output ?? result.content?.find(c => c.type === "text")?.text ?? "").trimEnd();
+		const outputLines = output ? output.split("\n") : [];
+		const total = outputLines.length;
+		const truncation = result.details?.meta?.truncation;
+
+		const meta: string[] = [];
+		if (isError) meta.push("failed");
+		if (total > 0) meta.push(`${total} lines`);
+
+		const header = renderStatusLine(
+			{ icon: isError ? "error" : "success", title: "Bash", description: cmdText, meta },
+			uiTheme,
+		);
+
+		const expanded = renderContext?.expanded ?? options.expanded;
+		const showAll = isError || expanded;
+		const displayLines = showAll ? outputLines : outputLines.slice(-PREVIEW_LIMITS.OUTPUT_COLLAPSED);
+		const skipped = total - displayLines.length;
+
+		const bodyLines: string[] = [];
+		if (skipped > 0) {
+			bodyLines.push(uiTheme.fg("dim", `… (${skipped} earlier lines)`));
+		}
+		const hasTruncation = Boolean(truncation);
+		for (let i = 0; i < displayLines.length; i++) {
+			bodyLines.push(uiTheme.fg("toolOutput", replaceTabs(displayLines[i])));
+		}
+
+		if (hasTruncation) {
+			bodyLines.push(uiTheme.fg("warning", "output truncated"));
+		}
+		if (!showAll && skipped > 0) {
+			bodyLines.push(formatClickHint(uiTheme));
+		}
+
+		const lines = bodyLines.length > 0 ? [header, ...bodyLines] : [header];
+		return new Text(lines.join("\n"), 0, 0);
+	}
+}
 
 interface BashRenderArgs {
 	command?: string;
@@ -231,117 +296,3 @@ function formatBashCommand(args: BashRenderArgs, _uiTheme: Theme): string {
 
 	return displayWorkdir ? `${prompt} cd ${displayWorkdir} && ${command}` : `${prompt} ${command}`;
 }
-
-// Preview line limit when not expanded (matches tool-execution behavior)
-export const BASH_PREVIEW_LINES = 10;
-
-export const bashToolRenderer = {
-	renderCall(args: BashRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const cmdText = formatBashCommand(args, uiTheme);
-		const text = renderStatusLine({ icon: "pending", title: "Bash", description: cmdText }, uiTheme);
-		return new Text(text, 0, 0);
-	},
-
-	renderResult(
-		result: {
-			content: Array<{ type: string; text?: string }>;
-			details?: BashToolDetails;
-			isError?: boolean;
-		},
-		options: RenderResultOptions & { renderContext?: BashRenderContext },
-		uiTheme: Theme,
-		args?: BashRenderArgs,
-	): Component {
-		const cmdText = args ? formatBashCommand(args, uiTheme) : undefined;
-		const isError = result.isError === true;
-		const header = renderStatusLine({ icon: isError ? "error" : "success", title: "Bash" }, uiTheme);
-		const details = result.details;
-		const truncation = details?.meta?.truncation;
-		const outputBlock = new CachedOutputBlock();
-
-		return {
-			render: (width: number): string[] => {
-				// REACTIVE: read mutable options at render time
-				const { renderContext } = options;
-				const expanded = renderContext?.expanded ?? options.expanded;
-				const previewLines = renderContext?.previewLines ?? BASH_DEFAULT_PREVIEW_LINES;
-
-				// Get output from context (preferred) or fall back to result content
-				const output = renderContext?.output ?? result.content?.find(c => c.type === "text")?.text ?? "";
-				const displayOutput = output.trimEnd();
-				const showingFullOutput = expanded && renderContext?.isFullOutput === true;
-
-				// Build truncation warning
-				const timeoutSeconds = renderContext?.timeout;
-				const timeoutLine =
-					typeof timeoutSeconds === "number"
-						? uiTheme.fg(
-								"dim",
-								`${uiTheme.format.bracketLeft}Timeout: ${timeoutSeconds}s${uiTheme.format.bracketRight}`,
-							)
-						: undefined;
-				let warningLine: string | undefined;
-				if (truncation && !showingFullOutput) {
-					const warnings: string[] = [];
-					if (truncation?.artifactId) {
-						warnings.push(`Full output: artifact://${truncation.artifactId}`);
-					}
-					if (truncation.truncatedBy === "lines") {
-						warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
-					} else {
-						warnings.push(
-							`Truncated: ${truncation.outputLines} lines shown (${formatBytes(truncation.outputBytes)} limit)`,
-						);
-					}
-					if (warnings.length > 0) {
-						warningLine = uiTheme.fg("warning", wrapBrackets(warnings.join(". "), uiTheme));
-					}
-				}
-
-				const outputLines: string[] = [];
-				const hasOutput = displayOutput.trim().length > 0;
-				if (hasOutput) {
-					if (expanded) {
-						outputLines.push(...displayOutput.split("\n").map(line => replaceTabs(line)));
-					} else {
-						const styledOutput = displayOutput
-							.split("\n")
-							.map(line => replaceTabs(line))
-							.join("\n");
-						const textContent = styledOutput;
-						const result = truncateToVisualLines(textContent, previewLines, width);
-						if (result.skippedCount > 0) {
-							outputLines.push(
-								uiTheme.fg(
-									"dim",
-									`… (${result.skippedCount} earlier lines, showing ${result.visualLines.length} of ${result.skippedCount + result.visualLines.length}) (ctrl+o to expand)`,
-								),
-							);
-						}
-						outputLines.push(...result.visualLines);
-					}
-				}
-				if (timeoutLine) outputLines.push(timeoutLine);
-				if (warningLine) outputLines.push(warningLine);
-
-				return outputBlock.render(
-					{
-						header,
-						state: isError ? "error" : "success",
-						sections: [
-							{ lines: cmdText ? [uiTheme.fg("dim", cmdText)] : [] },
-							{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines },
-						],
-						width,
-					},
-					uiTheme,
-				);
-			},
-			invalidate: () => {
-				outputBlock.invalidate();
-			},
-		};
-	},
-	mergeCallAndResult: true,
-	inline: true,
-};