@nghyane/arcane 0.1.13 → 0.1.14

package/src/tools/jtd-to-typescript.ts

@@ -1,198 +0,0 @@
-/**
- * Convert JSON Type Definition (JTD) to TypeScript interface notation.
- *
- * Produces human-readable TypeScript for embedding in system prompts,
- * helping models understand expected output structure.
- */
-
-type JTDPrimitive =
-	| "boolean"
-	| "string"
-	| "timestamp"
-	| "float32"
-	| "float64"
-	| "int8"
-	| "uint8"
-	| "int16"
-	| "uint16"
-	| "int32"
-	| "uint32";
-
-interface JTDType {
-	type: JTDPrimitive;
-}
-
-interface JTDEnum {
-	enum: string[];
-}
-
-interface JTDElements {
-	elements: JTDSchema;
-}
-
-interface JTDValues {
-	values: JTDSchema;
-}
-
-interface JTDProperties {
-	properties?: Record<string, JTDSchema>;
-	optionalProperties?: Record<string, JTDSchema>;
-}
-
-interface JTDDiscriminator {
-	discriminator: string;
-	mapping: Record<string, JTDProperties>;
-}
-
-interface JTDRef {
-	ref: string;
-}
-
-type JTDSchema = JTDType | JTDEnum | JTDElements | JTDValues | JTDProperties | JTDDiscriminator | JTDRef | object;
-
-const primitiveMap: Record<JTDPrimitive, string> = {
-	boolean: "boolean",
-	string: "string",
-	timestamp: "string",
-	float32: "number",
-	float64: "number",
-	int8: "number",
-	uint8: "number",
-	int16: "number",
-	uint16: "number",
-	int32: "number",
-	uint32: "number",
-};
-
-function isJTDType(schema: unknown): schema is JTDType {
-	return typeof schema === "object" && schema !== null && "type" in schema;
-}
-
-function isJTDEnum(schema: unknown): schema is JTDEnum {
-	return typeof schema === "object" && schema !== null && "enum" in schema && Array.isArray((schema as JTDEnum).enum);
-}
-
-function isJTDElements(schema: unknown): schema is JTDElements {
-	return typeof schema === "object" && schema !== null && "elements" in schema;
-}
-
-function isJTDValues(schema: unknown): schema is JTDValues {
-	return typeof schema === "object" && schema !== null && "values" in schema;
-}
-
-function isJTDProperties(schema: unknown): schema is JTDProperties {
-	return typeof schema === "object" && schema !== null && ("properties" in schema || "optionalProperties" in schema);
-}
-
-function isJTDDiscriminator(schema: unknown): schema is JTDDiscriminator {
-	return typeof schema === "object" && schema !== null && "discriminator" in schema && "mapping" in schema;
-}
-
-function isJTDRef(schema: unknown): schema is JTDRef {
-	return typeof schema === "object" && schema !== null && "ref" in schema;
-}
-
-function convertToTypeScript(schema: unknown, inline = false): string {
-	if (schema === null || schema === undefined || (typeof schema === "object" && Object.keys(schema).length === 0)) {
-		return "unknown";
-	}
-
-	if (isJTDType(schema)) {
-		const tsType = primitiveMap[schema.type as JTDPrimitive];
-		return tsType ?? "unknown";
-	}
-
-	if (isJTDEnum(schema)) {
-		return schema.enum.map(v => `"${v}"`).join(" | ");
-	}
-
-	if (isJTDElements(schema)) {
-		const itemType = convertToTypeScript(schema.elements, true);
-		if (itemType.includes("\n") || itemType.length > 40) {
-			return `Array<${itemType}>`;
-		}
-		return `${itemType}[]`;
-	}
-
-	if (isJTDValues(schema)) {
-		const valueType = convertToTypeScript(schema.values, true);
-		return `Record<string, ${valueType}>`;
-	}
-
-	if (isJTDProperties(schema)) {
-		const lines: string[] = [];
-		lines.push("{");
-
-		if (schema.properties) {
-			for (const [key, value] of Object.entries(schema.properties)) {
-				const propType = convertToTypeScript(value, true);
-				const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `"${key}"`;
-				lines.push(`  ${safeName}: ${propType};`);
-			}
-		}
-
-		if (schema.optionalProperties) {
-			for (const [key, value] of Object.entries(schema.optionalProperties)) {
-				const propType = convertToTypeScript(value, true);
-				const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `"${key}"`;
-				lines.push(`  ${safeName}?: ${propType};`);
-			}
-		}
-
-		lines.push("}");
-
-		if (inline && lines.length <= 4) {
-			// Compact single-line for small objects
-			const props = lines.slice(1, -1).map(l => l.trim());
-			if (props.join(" ").length < 60) {
-				return `{ ${props.join(" ")} }`;
-			}
-		}
-
-		return lines.join("\n");
-	}
-
-	if (isJTDDiscriminator(schema)) {
-		const variants: string[] = [];
-		for (const [tag, props] of Object.entries(schema.mapping)) {
-			const propsType = convertToTypeScript(props, true);
-			if (propsType === "{}") {
-				variants.push(`{ ${schema.discriminator}: "${tag}" }`);
-			} else {
-				// Merge discriminator into props
-				const inner = propsType.slice(1, -1).trim();
-				variants.push(`{ ${schema.discriminator}: "${tag}"; ${inner} }`);
-			}
-		}
-		return variants.join(" | ");
-	}
-
-	if (isJTDRef(schema)) {
-		return schema.ref;
-	}
-
-	return "unknown";
-}
-
-/**
- * Convert JTD schema to TypeScript interface string.
- *
- * @example
- * ```ts
- * const schema = {
- *   properties: {
- *     name: { type: "string" },
- *     count: { type: "int32" }
- *   }
- * };
- * jtdToTypeScript(schema);
- * // Returns:
- * // {
- * //   name: string;
- * //   count: number;
- * // }
- * ```
- */
-export function jtdToTypeScript(schema: unknown): string {
-	return convertToTypeScript(schema, false);
-}

package/src/tools/renderers.ts

@@ -1,60 +0,0 @@
-/**
- * TUI renderers for built-in tools.
- *
- * These provide rich visualization for tool calls and results in the TUI.
- */
-import type { Component } from "@nghyane/arcane-tui";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { lspToolRenderer } from "../lsp/render";
-import type { Theme } from "../modes/theme/theme";
-import { editToolRenderer } from "../patch";
-import { taskToolRenderer } from "../task/render";
-import { webSearchToolRenderer } from "../web/search/render";
-import { askToolRenderer } from "./ask";
-import { bashToolRenderer } from "./bash";
-import { calculatorToolRenderer } from "./calculator";
-import { fetchToolRenderer } from "./fetch";
-import { findToolRenderer } from "./find";
-import { grepToolRenderer } from "./grep";
-import { notebookToolRenderer } from "./notebook";
-import { pythonToolRenderer } from "./python";
-import { readToolRenderer } from "./read";
-import { sshToolRenderer } from "./ssh";
-import { todoWriteToolRenderer } from "./todo-write";
-import { undoEditToolRenderer } from "./undo-edit";
-import { writeToolRenderer } from "./write";
-
-type ToolRenderer = {
-	renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
-	renderResult: (
-		result: { content: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean },
-		options: RenderResultOptions & { renderContext?: Record<string, unknown> },
-		theme: Theme,
-		args?: unknown,
-	) => Component;
-	mergeCallAndResult?: boolean;
-	/** Render without background box, inline in the response flow */
-	inline?: boolean;
-};
-
-export const toolRenderers: Record<string, ToolRenderer> = {
-	ask: askToolRenderer as ToolRenderer,
-	bash: bashToolRenderer as ToolRenderer,
-	python: pythonToolRenderer as ToolRenderer,
-	calc: calculatorToolRenderer as ToolRenderer,
-	edit: editToolRenderer as ToolRenderer,
-	find: findToolRenderer as ToolRenderer,
-	grep: grepToolRenderer as ToolRenderer,
-	lsp: lspToolRenderer as ToolRenderer,
-	notebook: notebookToolRenderer as ToolRenderer,
-	read: readToolRenderer as ToolRenderer,
-	ssh: sshToolRenderer as ToolRenderer,
-	task: taskToolRenderer as ToolRenderer,
-	explore: taskToolRenderer as ToolRenderer,
-	review: taskToolRenderer as ToolRenderer,
-	todo_write: todoWriteToolRenderer as ToolRenderer,
-	undo_edit: undoEditToolRenderer as ToolRenderer,
-	fetch: fetchToolRenderer as ToolRenderer,
-	web_search: webSearchToolRenderer as ToolRenderer,
-	write: writeToolRenderer as ToolRenderer,
-};

package/src/tools/tool-result.ts

@@ -1,86 +0,0 @@
-import type { AgentToolResult } from "@nghyane/arcane-agent";
-import type { ImageContent, TextContent } from "@nghyane/arcane-ai";
-import type { OutputSummary, TruncationResult } from "../session/streaming-output";
-import type { OutputMeta, TruncationOptions, TruncationSummaryOptions, TruncationTextOptions } from "./output-meta";
-import { outputMeta } from "./output-meta";
-
-type ToolContent = Array<TextContent | ImageContent>;
-
-type DetailsWithMeta = { meta?: OutputMeta };
-
-export class ToolResultBuilder<TDetails extends DetailsWithMeta> {
-	#details: TDetails;
-	#meta = outputMeta();
-	#content: ToolContent = [];
-
-	constructor(details?: TDetails) {
-		this.#details = details ?? ({} as TDetails);
-	}
-
-	text(text: string): this {
-		this.#content = [{ type: "text", text }];
-		return this;
-	}
-
-	content(content: ToolContent): this {
-		this.#content = content;
-		return this;
-	}
-
-	truncation(result: TruncationResult, options: TruncationOptions): this {
-		this.#meta.truncation(result, options);
-		return this;
-	}
-
-	truncationFromSummary(summary: OutputSummary, options: TruncationSummaryOptions): this {
-		this.#meta.truncationFromSummary(summary, options);
-		return this;
-	}
-
-	truncationFromText(text: string, options: TruncationTextOptions): this {
-		this.#meta.truncationFromText(text, options);
-		return this;
-	}
-
-	limits(limits: { matchLimit?: number; resultLimit?: number; headLimit?: number; columnMax?: number }): this {
-		this.#meta.limits(limits);
-		return this;
-	}
-
-	sourceUrl(value: string): this {
-		this.#meta.sourceUrl(value);
-		return this;
-	}
-
-	sourcePath(value: string): this {
-		this.#meta.sourcePath(value);
-		return this;
-	}
-
-	sourceInternal(value: string): this {
-		this.#meta.sourceInternal(value);
-		return this;
-	}
-
-	diagnostics(summary: string, messages: string[]): this {
-		this.#meta.diagnostics(summary, messages);
-		return this;
-	}
-
-	done(): AgentToolResult<TDetails> {
-		const meta = this.#meta.get();
-		if (meta) {
-			this.#details.meta = meta;
-		}
-		const hasDetails = Object.entries(this.#details).some(([, value]) => value !== undefined);
-
-		return {
-			content: this.#content,
-			details: hasDetails ? this.#details : undefined,
-		};
-	}
-}
-
-export function toolResult<TDetails extends DetailsWithMeta>(details?: TDetails): ToolResultBuilder<TDetails> {
-	return new ToolResultBuilder(details);
-}