@dungle-scrubs/tallow 0.8.7 → 0.8.8

package/extensions/read-tool-enhanced/index.ts

@@ -3,6 +3,7 @@
  * - Live truncated content during execution (first N lines)
  * - Compact summary when done (✓ file.md (22 lines, 0.8KB))
  * - Special rendering for SKILL.md files
+ * - Structured parsing for PDFs and Jupyter notebooks
  * - Full content always sent to LLM via context restoration
  *
  * Uses raw render functions for renderResult so that
@@ -40,6 +41,7 @@ import {
 } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { getIcon } from "../_icons/index.js";
+import { getTallowSettingsPath } from "../_shared/tallow-paths.js";
 import {
 	appendSection,
 	dimProcessOutputLine,
@@ -50,6 +52,14 @@ import {
 	renderLines,
 	truncateForDisplay,
 } from "../tool-display/index.js";
+import {
+	formatNotebookOutput,
+	isNotebook,
+	NOTEBOOK_MARKER,
+	NotebookParseError,
+	parseNotebook,
+	summarizeNotebookCounts,
+} from "./notebook.js";
 import {
 	formatPdfOutput,
 	isPdf,
@@ -81,10 +91,7 @@ function resolveHome(p: string): string {
  * @returns Array of resolved skill directory paths from packages
  */
 export function getPackageSkillPaths(): string[] {
-	const settingsPath = join(
-		process.env.TALLOW_CODING_AGENT_DIR ?? join(homedir(), ".tallow"),
-		"settings.json"
-	);
+	const settingsPath = getTallowSettingsPath();
 	if (!fs.existsSync(settingsPath)) return [];
 
 	try {
@@ -362,6 +369,73 @@ async function executePdf(
 	}
 }
 
+/**
+ * Execute notebook reading: parse notebook JSON, format cell content, and summarize.
+ *
+ * @param absolutePath - Absolute path to the notebook file
+ * @param displayPath - Original user-facing path string
+ * @param onUpdate - Streaming update callback for live preview
+ * @returns Tool result with notebook content and summary metadata
+ */
+function executeNotebook(
+	absolutePath: string,
+	displayPath: string,
+	onUpdate?: (partialResult: {
+		content: Array<{ type: "text"; text: string }>;
+		details: Record<string, unknown>;
+	}) => void
+): {
+	content: Array<{ type: "text"; text: string }>;
+	details: Record<string, unknown>;
+	isError?: boolean;
+} {
+	const notebookContent = fs.readFileSync(absolutePath, "utf-8");
+
+	try {
+		const notebook = parseNotebook(notebookContent);
+		const formatted = formatNotebookOutput(notebook);
+		const counts = summarizeNotebookCounts(notebook);
+
+		// Stream a preview during execution
+		const previewLines = formatted.split("\n").slice(0, 10).join("\n");
+		onUpdate?.({
+			content: [{ type: "text" as const, text: previewLines }],
+			details: { _preview: true },
+		});
+
+		const sizeKb = (Buffer.byteLength(formatted, "utf-8") / 1024).toFixed(1);
+		const summary =
+			`${displayPath} (${notebook.cells.length} cells, ` +
+			`${counts.codeCells} code, ${counts.markdownCells} markdown, ` +
+			`${counts.outputCount} outputs, ${sizeKb}KB extracted)`;
+
+		return {
+			content: [{ type: "text" as const, text: summary }],
+			details: {
+				[NOTEBOOK_MARKER]: true,
+				_fullText: formatted,
+				_path: displayPath,
+				_filename: displayPath,
+				_cellCount: notebook.cells.length,
+				_codeCellCount: counts.codeCells,
+				_markdownCellCount: counts.markdownCells,
+				_outputCount: counts.outputCount,
+				_rawCellCount: counts.rawCells,
+				_language: notebook.language,
+			},
+		};
+	} catch (err: unknown) {
+		if (err instanceof NotebookParseError) {
+			return {
+				content: [{ type: "text" as const, text: err.message }],
+				details: {},
+				isError: true,
+			};
+		}
+		throw err;
+	}
+}
+
 /**
  * Linkify the file-path prefix in a summary string.
  *
@@ -462,6 +536,11 @@ export default function readSummary(pi: ExtensionAPI): void {
 				return executePdf(absolutePath, path, params.pages as string | undefined, onUpdate);
 			}
 
+			// ── Notebook handling (.ipynb) ──────────────────────
+			if (isNotebook(absolutePath)) {
+				return executeNotebook(absolutePath, path, onUpdate);
+			}
+
 			// ── Image detection from bytes ──────────────────────
 			// Read first 12 bytes to detect image format by magic numbers.
 			// The base tool handles actual image reading via file-type; we
@@ -591,13 +670,20 @@ export default function readSummary(pi: ExtensionAPI): void {
 						_filename?: string;
 						_fullText?: string;
 						_isSkill?: boolean;
-						_isPdf?: boolean;
-						_totalPages?: number;
+						_cellCount?: number;
+						_codeCellCount?: number;
 						_emptyText?: boolean;
 						_imageMetadata?: ImageMetadata;
-						[SUMMARY_MARKER]?: boolean;
-						[PDF_MARKER]?: boolean;
+						_isPdf?: boolean;
+						_language?: string;
+						_markdownCellCount?: number;
+						_outputCount?: number;
+						_rawCellCount?: number;
+						_totalPages?: number;
 						[IMAGE_MARKER]?: boolean;
+						[NOTEBOOK_MARKER]?: boolean;
+						[PDF_MARKER]?: boolean;
+						[SUMMARY_MARKER]?: boolean;
 				  }
 				| undefined;
 
@@ -657,6 +743,21 @@ export default function readSummary(pi: ExtensionAPI): void {
 				return renderLines([footer]);
 			}
 
+			// Notebook file: compact summary collapsed, full text expanded
+			if (details?.[NOTEBOOK_MARKER]) {
+				const summary = textContent?.text ?? "Notebook";
+				const footer = buildFooter(summary);
+
+				if (expanded && details?._fullText) {
+					const lines: string[] = [];
+					appendSection(lines, [formatSectionDivider(theme, "Output")]);
+					appendSection(lines, details._fullText.split("\n").map(styleProcessLine));
+					appendSection(lines, [footer], { blankBefore: true });
+					return renderLines(lines, { wrap: true });
+				}
+				return renderLines([footer]);
+			}
+
 			// If not summarized, show raw content
 			if (!details?.[SUMMARY_MARKER]) {
 				const raw = textContent?.text ?? "";
@@ -694,10 +795,11 @@ export default function readSummary(pi: ExtensionAPI): void {
 			if (msg.role !== "toolResult") continue;
 
 			const details = msg.details as Record<string, unknown> | undefined;
-			// Restore full text for both summarized text files and PDF results
+			// Restore full text for summarized text files, PDFs, and notebook results.
 			const isSummarized = details?.[SUMMARY_MARKER] && details._fullText;
 			const isPdfResult = details?.[PDF_MARKER] && details._fullText;
-			if (!(isSummarized || isPdfResult)) continue;
+			const isNotebookResult = details?.[NOTEBOOK_MARKER] && details._fullText;
+			if (!(isSummarized || isPdfResult || isNotebookResult)) continue;
 
 			const textContent = msg.content.find(
 				(c): c is { type: "text"; text: string } => c.type === "text"

package/extensions/read-tool-enhanced/notebook.ts

@@ -0,0 +1,526 @@
+import { extname } from "node:path";
+
+const DEFAULT_NOTEBOOK_LANGUAGE = "python";
+const MAX_OUTPUT_CHARACTERS = 8_000;
+const IMAGE_MIME_TYPES = [
+	"image/gif",
+	"image/jpeg",
+	"image/jpg",
+	"image/png",
+	"image/webp",
+] as const;
+
+/** Marker for notebook results in details, used by renderResult/context restoration. */
+export const NOTEBOOK_MARKER = "__notebook_read__";
+
+/** Parsed notebook output cell. */
+export interface NotebookOutput {
+	readonly data?: Record<string, unknown>;
+	readonly ename?: string;
+	readonly evalue?: string;
+	readonly metadata?: Record<string, unknown>;
+	readonly name?: string;
+	readonly output_type: string;
+	readonly text?: string | readonly string[];
+	readonly traceback?: readonly string[];
+}
+
+/** Parsed notebook cell. */
+export interface NotebookCell {
+	readonly cell_type: "code" | "markdown" | "raw";
+	readonly execution_count?: number;
+	readonly outputs?: readonly NotebookOutput[];
+	readonly source: string | readonly string[];
+}
+
+/** Parsed notebook structure used by the read tool. */
+export interface ParsedNotebook {
+	readonly cells: readonly NotebookCell[];
+	readonly language: string;
+	readonly metadata: Record<string, unknown>;
+}
+
+/** Count summary for notebook cell/output types. */
+export interface NotebookCellCounts {
+	readonly codeCells: number;
+	readonly markdownCells: number;
+	readonly outputCount: number;
+	readonly rawCells: number;
+}
+
+/** Thrown when a notebook cannot be parsed into a supported shape. */
+export class NotebookParseError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "NotebookParseError";
+	}
+}
+
+/**
+ * Detect whether a file path looks like a Jupyter notebook.
+ *
+ * @param absolutePath - Absolute path to inspect
+ * @returns True when extension is `.ipynb` (case-insensitive)
+ */
+export function isNotebook(absolutePath: string): boolean {
+	return extname(absolutePath).toLowerCase() === ".ipynb";
+}
+
+/**
+ * Parse notebook JSON into a normalized representation used by formatters.
+ *
+ * @param content - Raw `.ipynb` JSON content
+ * @returns Parsed notebook structure with normalized cells and metadata
+ * @throws {NotebookParseError} When JSON is invalid or notebook shape is unsupported
+ */
+export function parseNotebook(content: string): ParsedNotebook {
+	const root = parseNotebookJson(content);
+	const cellsValue = root.cells;
+	if (!Array.isArray(cellsValue)) {
+		throw new NotebookParseError("Cannot read notebook: missing cells array");
+	}
+
+	const metadata = toRecord(root.metadata) ?? {};
+	const language = detectNotebookLanguage(metadata);
+	const cells = cellsValue.map((cell) => normalizeCell(cell));
+
+	return {
+		cells,
+		language,
+		metadata,
+	};
+}
+
+/**
+ * Format parsed notebook cells into LLM-friendly plain text.
+ *
+ * @param notebook - Parsed notebook from `parseNotebook`
+ * @returns Human-readable notebook text with cell separators and structured outputs
+ */
+export function formatNotebookOutput(notebook: ParsedNotebook): string {
+	const counts = summarizeNotebookCounts(notebook);
+	const lines: string[] = [
+		`[Notebook: ${notebook.language} | ${notebook.cells.length} cells (${counts.codeCells} code, ${counts.markdownCells} markdown, ${counts.rawCells} raw, ${counts.outputCount} outputs)]`,
+		"",
+	];
+
+	notebook.cells.forEach((cell, index) => {
+		if (index > 0) {
+			lines.push("---", "");
+		}
+		lines.push(...formatCell(cell, index + 1, notebook.language));
+	});
+
+	return lines.join("\n").trimEnd();
+}
+
+/**
+ * Count notebook cell and output totals for summary display.
+ *
+ * @param notebook - Parsed notebook from `parseNotebook`
+ * @returns Aggregated counts used in collapsed summaries
+ */
+export function summarizeNotebookCounts(notebook: ParsedNotebook): NotebookCellCounts {
+	let codeCells = 0;
+	let markdownCells = 0;
+	let rawCells = 0;
+	let outputCount = 0;
+
+	for (const cell of notebook.cells) {
+		if (cell.cell_type === "code") codeCells += 1;
+		if (cell.cell_type === "markdown") markdownCells += 1;
+		if (cell.cell_type === "raw") rawCells += 1;
+		outputCount += cell.outputs?.length ?? 0;
+	}
+
+	return {
+		codeCells,
+		markdownCells,
+		outputCount,
+		rawCells,
+	};
+}
+
+/**
+ * Parse a JSON string and validate the top-level notebook object shape.
+ *
+ * @param content - Raw JSON string
+ * @returns Parsed top-level notebook object
+ * @throws {NotebookParseError} When JSON is invalid or top-level is not an object
+ */
+function parseNotebookJson(content: string): Record<string, unknown> {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(content) as unknown;
+	} catch {
+		throw new NotebookParseError("Cannot read notebook: invalid JSON");
+	}
+
+	if (!isRecord(parsed)) {
+		throw new NotebookParseError("Cannot read notebook: expected top-level object");
+	}
+
+	return parsed;
+}
+
+/**
+ * Normalize a raw notebook cell object.
+ *
+ * @param value - Raw cell value from parsed JSON
+ * @returns Normalized notebook cell
+ */
+function normalizeCell(value: unknown): NotebookCell {
+	if (!isRecord(value)) {
+		return {
+			cell_type: "raw",
+			source: "[Unsupported cell structure]",
+		};
+	}
+
+	const cellType = normalizeCellType(value.cell_type);
+	const source = normalizeSource(value.source);
+	const executionCount =
+		typeof value.execution_count === "number" ? value.execution_count : undefined;
+	const outputs = Array.isArray(value.outputs)
+		? value.outputs
+				.map((output) => normalizeOutput(output))
+				.filter((output): output is NotebookOutput => output !== null)
+		: undefined;
+
+	return {
+		cell_type: cellType,
+		execution_count: executionCount,
+		outputs,
+		source,
+	};
+}
+
+/**
+ * Normalize a raw notebook output object.
+ *
+ * @param value - Raw output value from parsed JSON
+ * @returns Normalized output, or null when value is not an object
+ */
+function normalizeOutput(value: unknown): NotebookOutput | null {
+	if (!isRecord(value)) return null;
+
+	const traceback = Array.isArray(value.traceback)
+		? value.traceback.filter((line): line is string => typeof line === "string")
+		: undefined;
+	const text = normalizeOptionalSource(value.text);
+
+	return {
+		data: toRecord(value.data),
+		ename: typeof value.ename === "string" ? value.ename : undefined,
+		evalue: typeof value.evalue === "string" ? value.evalue : undefined,
+		metadata: toRecord(value.metadata),
+		name: typeof value.name === "string" ? value.name : undefined,
+		output_type: typeof value.output_type === "string" ? value.output_type : "stream",
+		text,
+		traceback,
+	};
+}
+
+/**
+ * Normalize an optional source/text field.
+ *
+ * @param value - Raw source value
+ * @returns Normalized source value, or undefined when missing/unsupported
+ */
+function normalizeOptionalSource(value: unknown): string | readonly string[] | undefined {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) {
+		return value.filter((item): item is string => typeof item === "string");
+	}
+	return undefined;
+}
+
+/**
+ * Normalize a required source field.
+ *
+ * @param value - Raw source value
+ * @returns Normalized source string or string-array
+ */
+function normalizeSource(value: unknown): string | readonly string[] {
+	return normalizeOptionalSource(value) ?? "";
+}
+
+/**
+ * Normalize notebook cell type to supported values.
+ *
+ * @param value - Raw `cell_type` value
+ * @returns One of `markdown`, `code`, or `raw`
+ */
+function normalizeCellType(value: unknown): "code" | "markdown" | "raw" {
+	if (value === "code" || value === "markdown" || value === "raw") return value;
+	return "raw";
+}
+
+/**
+ * Detect notebook language from metadata.
+ *
+ * @param metadata - Top-level notebook metadata
+ * @returns Kernel language name, falling back to python
+ */
+function detectNotebookLanguage(metadata: Record<string, unknown>): string {
+	const kernelspec = toRecord(metadata.kernelspec);
+	const kernelLanguage = typeof kernelspec?.language === "string" ? kernelspec.language.trim() : "";
+	if (kernelLanguage.length > 0) return kernelLanguage;
+
+	const languageInfo = toRecord(metadata.language_info);
+	const languageName = typeof languageInfo?.name === "string" ? languageInfo.name.trim() : "";
+	if (languageName.length > 0) return languageName;
+
+	return DEFAULT_NOTEBOOK_LANGUAGE;
+}
+
+/**
+ * Format a single notebook cell and its outputs.
+ *
+ * @param cell - Notebook cell to format
+ * @param cellNumber - 1-indexed cell number
+ * @param language - Notebook language used for code fences
+ * @returns Formatted cell lines
+ */
+function formatCell(cell: NotebookCell, cellNumber: number, language: string): string[] {
+	if (cell.cell_type === "markdown") {
+		const markdown = joinSource(cell.source).trimEnd();
+		return [`Cell ${cellNumber} [markdown]`, markdown || "[Empty markdown cell]"];
+	}
+
+	if (cell.cell_type === "raw") {
+		const raw = joinSource(cell.source).trimEnd();
+		return [
+			`Cell ${cellNumber} [raw]`,
+			"```text",
+			raw.length > 0 ? raw : "[Empty raw cell]",
+			"```",
+		];
+	}
+
+	const lines: string[] = [`Cell ${cellNumber} [code]`];
+	if (typeof cell.execution_count === "number") {
+		lines.push(`# [${cell.execution_count}]`);
+	}
+
+	const code = joinSource(cell.source).trimEnd();
+	lines.push(`\`\`\`${language}`, code.length > 0 ? code : "", "```");
+	lines.push(...formatCellOutputs(cell.outputs));
+	return lines;
+}
+
+/**
+ * Format all outputs for a code cell.
+ *
+ * @param outputs - Optional code cell outputs
+ * @returns Formatted output lines
+ */
+function formatCellOutputs(outputs: readonly NotebookOutput[] | undefined): string[] {
+	if (!outputs || outputs.length === 0) return [];
+
+	const lines: string[] = ["Outputs:"];
+	outputs.forEach((output, index) => {
+		if (index > 0) lines.push("");
+		lines.push(...formatOutput(output, index + 1));
+	});
+	return lines;
+}
+
+/**
+ * Format one notebook output entry.
+ *
+ * @param output - Output entry to format
+ * @param outputNumber - 1-indexed output number within a cell
+ * @returns Formatted output lines
+ */
+function formatOutput(output: NotebookOutput, outputNumber: number): string[] {
+	if (output.output_type === "error") {
+		return formatErrorOutput(output, outputNumber);
+	}
+
+	if (output.output_type === "stream") {
+		return formatStreamOutput(output, outputNumber);
+	}
+
+	if (output.output_type === "execute_result" || output.output_type === "display_data") {
+		return formatRichOutput(output, outputNumber);
+	}
+
+	return formatUnknownOutput(output, outputNumber);
+}
+
+/**
+ * Format stream output text.
+ *
+ * @param output - Stream output entry
+ * @param outputNumber - 1-indexed output number
+ * @returns Formatted output lines
+ */
+function formatStreamOutput(output: NotebookOutput, outputNumber: number): string[] {
+	const text = truncateForDisplay(joinSource(output.text).trimEnd());
+	if (text.length === 0) {
+		return [`[Output ${outputNumber}: stream]`, "[No text output]"];
+	}
+	return [`[Output ${outputNumber}: stream]`, "```text", text, "```"];
+}
+
+/**
+ * Format rich display output (`execute_result` / `display_data`).
+ *
+ * @param output - Rich output entry
+ * @param outputNumber - 1-indexed output number
+ * @returns Formatted output lines
+ */
+function formatRichOutput(output: NotebookOutput, outputNumber: number): string[] {
+	const lines: string[] = [`[Output ${outputNumber}: ${output.output_type}]`];
+	const data = output.data ?? {};
+
+	const plainText = extractPlainText(data);
+	if (plainText.length > 0) {
+		lines.push("```text", truncateForDisplay(plainText.trimEnd()), "```");
+	}
+
+	const imageLines = IMAGE_MIME_TYPES.flatMap((mimeType) => {
+		if (!(mimeType in data)) return [];
+		const dimensions = getImageDimensionsFromMetadata(output.metadata, mimeType);
+		const format = mimeType.split("/")[1]?.toUpperCase() ?? "IMAGE";
+		return dimensions
+			? [`[Image output: ${format} ${dimensions.width}x${dimensions.height}]`]
+			: [`[Image output: ${format}]`];
+	});
+	lines.push(...imageLines);
+
+	const hasHtml = typeof data["text/html"] === "string" || Array.isArray(data["text/html"]);
+	if (hasHtml) {
+		lines.push("[HTML output]");
+	}
+
+	if (plainText.length === 0 && imageLines.length === 0 && !hasHtml) {
+		const fallbackText = truncateForDisplay(joinSource(output.text).trimEnd());
+		if (fallbackText.length > 0) {
+			lines.push("```text", fallbackText, "```");
+		} else {
+			lines.push("[Unsupported rich output]");
+		}
+	}
+
+	return lines;
+}
+
+/**
+ * Format error output with traceback.
+ *
+ * @param output - Error output entry
+ * @param outputNumber - 1-indexed output number
+ * @returns Formatted output lines
+ */
+function formatErrorOutput(output: NotebookOutput, outputNumber: number): string[] {
+	const header = [output.ename, output.evalue].filter(Boolean).join(": ") || "Execution error";
+	const traceback = output.traceback?.join("\n");
+	const body = traceback ? `${header}\n${traceback}` : header;
+	return [`[Output ${outputNumber}: error]`, "```text", truncateForDisplay(body), "```"];
+}
+
+/**
+ * Format unsupported output types using best-effort text extraction.
+ *
+ * @param output - Unknown output entry
+ * @param outputNumber - 1-indexed output number
+ * @returns Formatted output lines
+ */
+function formatUnknownOutput(output: NotebookOutput, outputNumber: number): string[] {
+	const text = truncateForDisplay(joinSource(output.text).trimEnd());
+	if (text.length === 0) {
+		return [`[Output ${outputNumber}: ${output.output_type}]`, "[Unsupported output]"];
+	}
+	return [`[Output ${outputNumber}: ${output.output_type}]`, "```text", text, "```"];
+}
+
+/**
+ * Extract plain text from rich output data payloads.
+ *
+ * @param data - Rich output `data` map
+ * @returns Joined plain-text content, or empty string when absent
+ */
+function extractPlainText(data: Record<string, unknown>): string {
+	const plain = data["text/plain"];
+	if (typeof plain === "string") return plain;
+	if (Array.isArray(plain)) {
+		return plain.filter((part): part is string => typeof part === "string").join("");
+	}
+	return "";
+}
+
+/**
+ * Join notebook source/text fields into a single string.
+ *
+ * @param source - String or line-array field
+ * @returns Combined text string
+ */
+function joinSource(source: string | readonly string[] | undefined): string {
+	if (typeof source === "string") return source;
+	if (Array.isArray(source)) return source.join("");
+	return "";
+}
+
+/**
+ * Truncate very large output segments while preserving context.
+ *
+ * @param value - Text to truncate
+ * @returns Original text if short, otherwise truncated text with notice
+ */
+function truncateForDisplay(value: string): string {
+	if (value.length <= MAX_OUTPUT_CHARACTERS) return value;
+	return `${value.slice(0, MAX_OUTPUT_CHARACTERS)}\n[Output truncated at ${MAX_OUTPUT_CHARACTERS} chars]`;
+}
+
+/**
+ * Read image dimensions from notebook output metadata.
+ *
+ * @param metadata - Output metadata payload
+ * @param mimeType - Image MIME type key
+ * @returns Width/height pair when available, otherwise null
+ */
+function getImageDimensionsFromMetadata(
+	metadata: Record<string, unknown> | undefined,
+	mimeType: string
+): { height: number; width: number } | null {
+	if (!metadata) return null;
+	const nested = readDimensionCandidate(metadata[mimeType]);
+	if (nested) return nested;
+	return readDimensionCandidate(metadata);
+}
+
+/**
+ * Parse a metadata object and extract numeric width/height.
+ *
+ * @param value - Metadata candidate object
+ * @returns Dimensions when both values are valid positive numbers
+ */
+function readDimensionCandidate(value: unknown): { height: number; width: number } | null {
+	if (!isRecord(value)) return null;
+	const width = typeof value.width === "number" ? value.width : null;
+	const height = typeof value.height === "number" ? value.height : null;
+	if (width === null || height === null || width <= 0 || height <= 0) return null;
+	return { height, width };
+}
+
+/**
+ * Narrow an unknown value to a plain object record.
+ *
+ * @param value - Value to narrow
+ * @returns Record value or undefined when value is not a plain object
+ */
+function toRecord(value: unknown): Record<string, unknown> | undefined {
+	return isRecord(value) ? value : undefined;
+}
+
+/**
+ * Check whether a value is a non-null object (excluding arrays).
+ *
+ * @param value - Value to check
+ * @returns True for plain object-like records
+ */
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}