gsd-pi 2.7.1 → 2.8.1

package/node_modules/@gsd/pi-coding-agent/src/config.ts

@@ -235,6 +235,11 @@ export function getSessionsDir(): string {
 	return join(getAgentDir(), "sessions");
 }
 
+/** Get path to content-addressed blob store directory */
+export function getBlobsDir(): string {
+	return join(getAgentDir(), "blobs");
+}
+
 /** Get path to debug log file */
 export function getDebugLogPath(): string {
 	return join(getAgentDir(), `${APP_NAME}-debug.log`);

package/node_modules/@gsd/pi-coding-agent/src/core/artifact-manager.ts

@@ -0,0 +1,125 @@
+/**
+ * Session-scoped artifact storage for truncated tool outputs.
+ *
+ * Artifacts are stored in a directory alongside the session file,
+ * accessible via artifact:// URLs.
+ */
+import { mkdirSync, readdirSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Manages artifact storage for a session.
+ *
+ * Artifacts are stored with sequential IDs in the session's artifact directory.
+ * The directory is created lazily on first write.
+ */
+export class ArtifactManager {
+	#nextId = 0;
+	readonly #dir: string;
+	#dirCreated = false;
+	#initialized = false;
+
+	/**
+	 * @param sessionFile Path to the session .jsonl file
+	 */
+	constructor(sessionFile: string) {
+		// Artifact directory is session file path without .jsonl extension
+		this.#dir = sessionFile.slice(0, -6);
+	}
+
+	/**
+	 * Artifact directory path.
+	 * Directory may not exist until first artifact is saved.
+	 */
+	get dir(): string {
+		return this.#dir;
+	}
+
+	#ensureDir(): void {
+		if (!this.#dirCreated) {
+			mkdirSync(this.#dir, { recursive: true });
+			this.#dirCreated = true;
+		}
+		if (!this.#initialized) {
+			this.#scanExistingIds();
+			this.#initialized = true;
+		}
+	}
+
+	/**
+	 * Scan existing artifact files to find the next available ID.
+	 * Ensures we don't overwrite artifacts when resuming a session.
+	 */
+	#scanExistingIds(): void {
+		const files = this.listFiles();
+		let maxId = -1;
+		for (const file of files) {
+			const match = file.match(/^(\d+)\..*\.log$/);
+			if (match) {
+				const id = parseInt(match[1], 10);
+				if (id > maxId) maxId = id;
+			}
+		}
+		this.#nextId = maxId + 1;
+	}
+
+	/** Atomically allocate next artifact ID. */
+	allocateId(): number {
+		return this.#nextId++;
+	}
+
+	/**
+	 * Allocate a new artifact path and ID without writing content.
+	 * @param toolType Tool name for file extension (e.g., "bash", "fetch")
+	 */
+	allocatePath(toolType: string): { id: string; path: string } {
+		this.#ensureDir();
+		const id = String(this.allocateId());
+		const filename = `${id}.${toolType}.log`;
+		return { id, path: join(this.#dir, filename) };
+	}
+
+	/**
+	 * Save content as an artifact and return the artifact ID.
+	 * @param content Full content to save
+	 * @param toolType Tool name for file extension (e.g., "bash", "fetch")
+	 * @returns Artifact ID (numeric string)
+	 */
+	save(content: string, toolType: string): string {
+		const { id, path } = this.allocatePath(toolType);
+		writeFileSync(path, content);
+		return id;
+	}
+
+	/**
+	 * Check if an artifact exists.
+	 * @param id Artifact ID (numeric string)
+	 */
+	exists(id: string): boolean {
+		const files = this.listFiles();
+		return files.some((f) => f.startsWith(`${id}.`));
+	}
+
+	/**
+	 * List all artifact files in the directory.
+	 * Returns empty array if directory doesn't exist.
+	 */
+	listFiles(): string[] {
+		try {
+			return readdirSync(this.#dir);
+		} catch {
+			return [];
+		}
+	}
+
+	/**
+	 * Get the full path to an artifact file.
+	 * Returns null if artifact doesn't exist.
+	 * @param id Artifact ID (numeric string)
+	 */
+	getPath(id: string): string | null {
+		const files = this.listFiles();
+		const match = files.find((f) => f.startsWith(`${id}.`));
+		return match ? join(this.#dir, match) : null;
+	}
+}

package/node_modules/@gsd/pi-coding-agent/src/core/blob-store.ts

@@ -0,0 +1,106 @@
+/**
+ * Content-addressed blob store for externalizing large binary data (images) from session JSONL files.
+ *
+ * Files are stored at `<dir>/<sha256-hex>` with no extension. The SHA-256 hash is computed
+ * over the raw binary data (not base64). Content-addressing makes writes idempotent and
+ * provides automatic deduplication across sessions.
+ */
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync, existsSync, accessSync } from "node:fs";
+import { join } from "node:path";
+
+const BLOB_PREFIX = "blob:sha256:";
+const SHA256_HEX_RE = /^[a-f0-9]{64}$/;
+
+export interface BlobPutResult {
+	hash: string;
+	path: string;
+	get ref(): string;
+}
+
+export class BlobStore {
+	readonly dir: string;
+	constructor(dir: string) {
+		this.dir = dir;
+		mkdirSync(dir, { recursive: true });
+	}
+
+	/** Write binary data to the blob store. Idempotent — same content → same hash. */
+	put(data: Buffer): BlobPutResult {
+		const hash = createHash("sha256").update(data).digest("hex");
+		const blobPath = join(this.dir, hash);
+		const result: BlobPutResult = {
+			hash,
+			path: blobPath,
+			get ref() {
+				return `${BLOB_PREFIX}${hash}`;
+			},
+		};
+
+		if (!existsSync(blobPath)) {
+			writeFileSync(blobPath, data);
+		}
+		return result;
+	}
+
+	/** Read blob by hash, returns Buffer or null if not found. */
+	get(hash: string): Buffer | null {
+		if (!SHA256_HEX_RE.test(hash)) return null;
+		const blobPath = join(this.dir, hash);
+		try {
+			return readFileSync(blobPath);
+		} catch {
+			return null;
+		}
+	}
+
+	/** Check if a blob exists. */
+	has(hash: string): boolean {
+		if (!SHA256_HEX_RE.test(hash)) return false;
+		try {
+			accessSync(join(this.dir, hash));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+}
+
+/** Check if a data string is a blob reference. */
+export function isBlobRef(data: string): boolean {
+	return data.startsWith(BLOB_PREFIX);
+}
+
+/** Extract the SHA-256 hash from a blob reference string. Returns null if format is invalid. */
+export function parseBlobRef(data: string): string | null {
+	if (!data.startsWith(BLOB_PREFIX)) return null;
+	const hash = data.slice(BLOB_PREFIX.length);
+	if (!SHA256_HEX_RE.test(hash)) return null;
+	return hash;
+}
+
+/**
+ * Externalize an image's base64 data to the blob store, returning a blob reference.
+ * If the data is already a blob reference, returns it unchanged.
+ */
+export function externalizeImageData(blobStore: BlobStore, base64Data: string): string {
+	if (isBlobRef(base64Data)) return base64Data;
+	const buffer = Buffer.from(base64Data, "base64");
+	const { ref } = blobStore.put(buffer);
+	return ref;
+}
+
+/**
+ * Resolve a blob reference back to base64 data.
+ * If the data is not a blob reference, returns it unchanged.
+ * If the blob is missing, returns the ref unchanged.
+ */
+export function resolveImageData(blobStore: BlobStore, data: string): string {
+	const hash = parseBlobRef(data);
+	if (!hash) return data;
+
+	const buffer = blobStore.get(hash);
+	if (!buffer) return data; // Missing blob — return ref as-is
+
+	return buffer.toString("base64");
+}

package/node_modules/@gsd/pi-coding-agent/src/core/session-manager.ts

@@ -15,7 +15,7 @@ import {
 } from "fs";
 import { readdir, readFile, stat } from "fs/promises";
 import { join, resolve } from "path";
-import { getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
+import { getAgentDir as getDefaultAgentDir, getBlobsDir, getSessionsDir } from "../config.js";
 import {
 	type BashExecutionMessage,
 	type CustomMessage,
@@ -23,6 +23,11 @@ import {
 	createCompactionSummaryMessage,
 	createCustomMessage,
 } from "./messages.js";
+import { BlobStore, externalizeImageData, isBlobRef, resolveImageData } from "./blob-store.js";
+
+const BLOB_EXTERNALIZE_THRESHOLD = 1024; // 1KB minimum to externalize
+const MAX_PERSIST_CHARS = 500_000;
+const TRUNCATION_NOTICE = "\n\n[Session persistence truncated large content]";
 
 export const CURRENT_SESSION_VERSION = 3;
 
@@ -426,6 +431,112 @@ function getDefaultSessionDir(cwd: string): string {
 	return sessionDir;
 }
 
+function isImageBlock(value: unknown): value is { type: "image"; data: string; mimeType?: string } {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		"type" in value &&
+		(value as { type?: string }).type === "image" &&
+		"data" in value &&
+		typeof (value as { data?: string }).data === "string"
+	);
+}
+
+function truncateString(s: string, maxLength: number): string {
+	if (s.length <= maxLength) return s;
+	// Avoid splitting surrogate pairs
+	if (maxLength > 0 && s.charCodeAt(maxLength - 1) >= 0xd800 && s.charCodeAt(maxLength - 1) <= 0xdbff) {
+		return s.slice(0, maxLength - 1);
+	}
+	return s.slice(0, maxLength);
+}
+
+/**
+ * Prepare an entry for JSONL persistence: externalize large images to blob store,
+ * truncate oversized strings, strip transient fields.
+ */
+function prepareForPersistence(obj: unknown, blobStore: BlobStore, key?: string): unknown {
+	if (obj === null || obj === undefined) return obj;
+
+	if (typeof obj === "string") {
+		if (obj.length > MAX_PERSIST_CHARS) {
+			// Cryptographic signatures must be preserved exactly or cleared entirely
+			if (key === "thinkingSignature" || key === "thoughtSignature" || key === "textSignature") {
+				return "";
+			}
+			const limit = Math.max(0, MAX_PERSIST_CHARS - TRUNCATION_NOTICE.length);
+			return `${truncateString(obj, limit)}${TRUNCATION_NOTICE}`;
+		}
+		return obj;
+	}
+
+	if (Array.isArray(obj)) {
+		let changed = false;
+		const result = obj.map((item) => {
+			// Externalize oversized images to blob store
+			if (key === "content" && isImageBlock(item)) {
+				if (!isBlobRef(item.data) && item.data.length >= BLOB_EXTERNALIZE_THRESHOLD) {
+					changed = true;
+					const blobRef = externalizeImageData(blobStore, item.data);
+					return { ...item, data: blobRef };
+				}
+			}
+			const newItem = prepareForPersistence(item, blobStore, key);
+			if (newItem !== item) changed = true;
+			return newItem;
+		});
+		return changed ? result : obj;
+	}
+
+	if (typeof obj === "object") {
+		let changed = false;
+		const result: Record<string, unknown> = {};
+		for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
+			// Strip transient properties
+			if (k === "partialJson" || k === "jsonlEvents") {
+				changed = true;
+				continue;
+			}
+			const newV = prepareForPersistence(v, blobStore, k);
+			result[k] = newV;
+			if (newV !== v) changed = true;
+		}
+		// Update lineCount if content was truncated (for FileMentionFile)
+		if (changed && "lineCount" in result && "content" in result && typeof result.content === "string") {
+			result.lineCount = (result.content as string).split("\n").length;
+		}
+		return changed ? result : obj;
+	}
+
+	return obj;
+}
+
+/**
+ * Resolve blob references in loaded entries, replacing `blob:sha256:<hash>` data
+ * fields with actual base64 content. Mutates entries in place.
+ */
+function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobStore): void {
+	for (const entry of entries) {
+		if (entry.type === "session") continue;
+
+		let contentArray: unknown[] | undefined;
+		if (entry.type === "message") {
+			const content = ((entry as SessionMessageEntry).message as { content?: unknown }).content;
+			if (Array.isArray(content)) contentArray = content;
+		} else if (entry.type === "custom_message" && Array.isArray((entry as any).content)) {
+			contentArray = (entry as any).content;
+		}
+
+		if (!contentArray) continue;
+
+		for (const block of contentArray) {
+			if (isImageBlock(block) && isBlobRef(block.data)) {
+				(block as { data: string }).data = resolveImageData(blobStore, block.data);
+			}
+		}
+	}
+}
+
 /** Exported for testing */
 export function loadEntriesFromFile(filePath: string): FileEntry[] {
 	if (!existsSync(filePath)) return [];
@@ -669,6 +780,7 @@ export class SessionManager {
 	private flushed: boolean = false;
 	private fileEntries: FileEntry[] = [];
 	private byId: Map<string, SessionEntry> = new Map();
+	private blobStore: BlobStore;
 	private labelsById: Map<string, string> = new Map();
 	private leafId: string | null = null;
 
@@ -676,6 +788,7 @@ export class SessionManager {
 		this.cwd = cwd;
 		this.sessionDir = sessionDir;
 		this.persist = persist;
+		this.blobStore = new BlobStore(getBlobsDir());
 		if (persist && sessionDir && !existsSync(sessionDir)) {
 			mkdirSync(sessionDir, { recursive: true });
 		}
@@ -712,6 +825,7 @@ export class SessionManager {
 			}
 
 			this._buildIndex();
+			resolveBlobRefsInEntries(this.fileEntries, this.blobStore);
 			this.flushed = true;
 		} else {
 			const explicitPath = this.sessionFile;
@@ -800,11 +914,13 @@ export class SessionManager {
 
 		if (!this.flushed) {
 			for (const e of this.fileEntries) {
-				appendFileSync(this.sessionFile, `${JSON.stringify(e)}\n`);
+				const prepared = prepareForPersistence(e, this.blobStore) as FileEntry;
+				appendFileSync(this.sessionFile, `${JSON.stringify(prepared)}\n`);
 			}
 			this.flushed = true;
 		} else {
-			appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);
+			const prepared = prepareForPersistence(entry, this.blobStore) as FileEntry;
+			appendFileSync(this.sessionFile, `${JSON.stringify(prepared)}\n`);
 		}
 	}
 

package/node_modules/@gsd/pi-coding-agent/src/core/tools/bash.ts

@@ -8,6 +8,7 @@ import { type Static, Type } from "@sinclair/typebox";
 import { spawn } from "child_process";
 import { getShellConfig, getShellEnv, killProcessTree } from "../../utils/shell.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateTail } from "./truncate.js";
+import type { ArtifactManager } from "../artifact-manager.js";
 
 // Cached Win32 FFI handles for restoring VT input after child processes
 let _vtHandles: { GetConsoleMode: any; SetConsoleMode: any; handle: any } | null = null;
@@ -51,6 +52,7 @@ export type BashToolInput = Static<typeof bashSchema>;
 export interface BashToolDetails {
 	truncation?: TruncationResult;
 	fullOutputPath?: string;
+	artifactId?: string;
 }
 
 /**
@@ -187,12 +189,15 @@ export interface BashToolOptions {
 	commandPrefix?: string;
 	/** Hook to adjust command, cwd, or env before execution */
 	spawnHook?: BashSpawnHook;
+	/** Session-scoped artifact storage. When provided, spills to artifact files instead of temp files. */
+	artifactManager?: ArtifactManager;
 }
 
 export function createBashTool(cwd: string, options?: BashToolOptions): AgentTool<typeof bashSchema> {
 	const ops = options?.operations ?? defaultBashOperations;
 	const commandPrefix = options?.commandPrefix;
 	const spawnHook = options?.spawnHook;
+	const artifactManager = options?.artifactManager;
 
 	return {
 		name: "bash",
@@ -210,9 +215,10 @@ export function createBashTool(cwd: string, options?: BashToolOptions): AgentToo
 			const spawnContext = resolveSpawnContext(resolvedCommand, cwd, spawnHook);
 
 			return new Promise((resolve, reject) => {
-				// We'll stream to a temp file if output gets large
-				let tempFilePath: string | undefined;
-				let tempFileStream: ReturnType<typeof createWriteStream> | undefined;
+				// We'll stream to a file if output gets large
+				let spillFilePath: string | undefined;
+				let spillArtifactId: string | undefined;
+				let spillFileStream: ReturnType<typeof createWriteStream> | undefined;
 				let totalBytes = 0;
 
 				// Keep a rolling buffer of the last chunk for tail truncation
@@ -224,19 +230,25 @@ export function createBashTool(cwd: string, options?: BashToolOptions): AgentToo
 				const handleData = (data: Buffer) => {
 					totalBytes += data.length;
 
-					// Start writing to temp file once we exceed the threshold
-					if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
-						tempFilePath = getTempFilePath();
-						tempFileStream = createWriteStream(tempFilePath);
+					// Start writing to file once we exceed the threshold
+					if (totalBytes > DEFAULT_MAX_BYTES && !spillFilePath) {
+						if (artifactManager) {
+							const allocated = artifactManager.allocatePath("bash");
+							spillFilePath = allocated.path;
+							spillArtifactId = allocated.id;
+						} else {
+							spillFilePath = getTempFilePath();
+						}
+						spillFileStream = createWriteStream(spillFilePath);
 						// Write all buffered chunks to the file
 						for (const chunk of chunks) {
-							tempFileStream.write(chunk);
+							spillFileStream.write(chunk);
 						}
 					}
 
 					// Write to temp file if we have one
-					if (tempFileStream) {
-						tempFileStream.write(data);
+					if (spillFileStream) {
+						spillFileStream.write(data);
 					}
 
 					// Keep rolling buffer of recent data
@@ -258,7 +270,7 @@ export function createBashTool(cwd: string, options?: BashToolOptions): AgentToo
 							content: [{ type: "text", text: truncation.content || "" }],
 							details: {
 								truncation: truncation.truncated ? truncation : undefined,
-								fullOutputPath: tempFilePath,
+								fullOutputPath: spillFilePath,
 							},
 						});
 					}
@@ -272,8 +284,8 @@ export function createBashTool(cwd: string, options?: BashToolOptions): AgentToo
 				})
 					.then(({ exitCode }) => {
 						// Close temp file stream
-						if (tempFileStream) {
-							tempFileStream.end();
+						if (spillFileStream) {
+							spillFileStream.end();
 						}
 
 						// Combine all buffered chunks
@@ -290,21 +302,22 @@ export function createBashTool(cwd: string, options?: BashToolOptions): AgentToo
 						if (truncation.truncated) {
 							details = {
 								truncation,
-								fullOutputPath: tempFilePath,
+								fullOutputPath: spillFilePath,
+								...(spillArtifactId ? { artifactId: spillArtifactId } : {}),
 							};
 
 							// Build actionable notice
 							const startLine = truncation.totalLines - truncation.outputLines + 1;
 							const endLine = truncation.totalLines;
+							const outputRef = spillArtifactId ? `artifact://${spillArtifactId}` : spillFilePath;
 
 							if (truncation.lastLinePartial) {
-								// Edge case: last line alone > 30KB
 								const lastLineSize = formatSize(Buffer.byteLength(fullOutput.split("\n").pop() || "", "utf-8"));
-								outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${tempFilePath}]`;
+								outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${outputRef}]`;
 							} else if (truncation.truncatedBy === "lines") {
-								outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${tempFilePath}]`;
+								outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${outputRef}]`;
 							} else {
-								outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${tempFilePath}]`;
+								outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${outputRef}]`;
 							}
 						}
 
@@ -317,8 +330,8 @@ export function createBashTool(cwd: string, options?: BashToolOptions): AgentToo
 					})
 					.catch((err: Error) => {
 						// Close temp file stream
-						if (tempFileStream) {
-							tempFileStream.end();
+						if (spillFileStream) {
+							spillFileStream.end();
 						}
 
 						// Combine all buffered chunks for error output

package/node_modules/@gsd/pi-coding-agent/src/index.ts

@@ -198,6 +198,9 @@ export {
 	type SessionMessageEntry,
 	type ThinkingLevelChangeEntry,
 } from "./core/session-manager.js";
+// Blob and artifact storage
+export { BlobStore, isBlobRef, parseBlobRef, externalizeImageData, resolveImageData } from "./core/blob-store.js";
+export { ArtifactManager } from "./core/artifact-manager.js";
 export {
 	type CompactionSettings,
 	type ImageSettings,

package/node_modules/@gsd/pi-coding-agent/src/modes/interactive/interactive-mode.ts

@@ -176,7 +176,7 @@ export class InteractiveMode {
 	private pendingTools = new Map<string, ToolExecutionComponent>();
 
 	// Tool output expansion state
-	private toolOutputExpanded = false;
+	private toolOutputExpanded = true;
 
 	// Thinking block visibility state
 	private hideThinkingBlock = false;

package/node_modules/cliui/CHANGELOG.md

@@ -0,0 +1,121 @@
+# Change Log
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+### [7.0.4](https://www.github.com/yargs/cliui/compare/v7.0.3...v7.0.4) (2020-11-08)
+
+
+### Bug Fixes
+
+* **deno:** import UIOptions from definitions ([#97](https://www.github.com/yargs/cliui/issues/97)) ([f04f343](https://www.github.com/yargs/cliui/commit/f04f3439bc78114c7e90f82ff56f5acf16268ea8))
+
+### [7.0.3](https://www.github.com/yargs/cliui/compare/v7.0.2...v7.0.3) (2020-10-16)
+
+
+### Bug Fixes
+
+* **exports:** node 13.0 and 13.1 require the dotted object form _with_ a string fallback ([#93](https://www.github.com/yargs/cliui/issues/93)) ([eca16fc](https://www.github.com/yargs/cliui/commit/eca16fc05d26255df3280906c36d7f0e5b05c6e9))
+
+### [7.0.2](https://www.github.com/yargs/cliui/compare/v7.0.1...v7.0.2) (2020-10-14)
+
+
+### Bug Fixes
+
+* **exports:** node 13.0-13.6 require a string fallback ([#91](https://www.github.com/yargs/cliui/issues/91)) ([b529d7e](https://www.github.com/yargs/cliui/commit/b529d7e432901af1af7848b23ed6cf634497d961))
+
+### [7.0.1](https://www.github.com/yargs/cliui/compare/v7.0.0...v7.0.1) (2020-08-16)
+
+
+### Bug Fixes
+
+* **build:** main should be build/index.cjs ([dc29a3c](https://www.github.com/yargs/cliui/commit/dc29a3cc617a410aa850e06337b5954b04f2cb4d))
+
+## [7.0.0](https://www.github.com/yargs/cliui/compare/v6.0.0...v7.0.0) (2020-08-16)
+
+
+### ⚠ BREAKING CHANGES
+
+* tsc/ESM/Deno support (#82)
+* modernize deps and build (#80)
+
+### Build System
+
+* modernize deps and build ([#80](https://www.github.com/yargs/cliui/issues/80)) ([339d08d](https://www.github.com/yargs/cliui/commit/339d08dc71b15a3928aeab09042af94db2f43743))
+
+
+### Code Refactoring
+
+* tsc/ESM/Deno support ([#82](https://www.github.com/yargs/cliui/issues/82)) ([4b777a5](https://www.github.com/yargs/cliui/commit/4b777a5fe01c5d8958c6708695d6aab7dbe5706c))
+
+## [6.0.0](https://www.github.com/yargs/cliui/compare/v5.0.0...v6.0.0) (2019-11-10)
+
+
+### ⚠ BREAKING CHANGES
+
+* update deps, drop Node 6
+
+### Code Refactoring
+
+* update deps, drop Node 6 ([62056df](https://www.github.com/yargs/cliui/commit/62056df))
+
+## [5.0.0](https://github.com/yargs/cliui/compare/v4.1.0...v5.0.0) (2019-04-10)
+
+
+### Bug Fixes
+
+* Update wrap-ansi to fix compatibility with latest versions of chalk. ([#60](https://github.com/yargs/cliui/issues/60)) ([7bf79ae](https://github.com/yargs/cliui/commit/7bf79ae))
+
+
+### BREAKING CHANGES
+
+* Drop support for node < 6.
+
+
+
+<a name="4.1.0"></a>
+## [4.1.0](https://github.com/yargs/cliui/compare/v4.0.0...v4.1.0) (2018-04-23)
+
+
+### Features
+
+* add resetOutput method ([#57](https://github.com/yargs/cliui/issues/57)) ([7246902](https://github.com/yargs/cliui/commit/7246902))
+
+
+
+<a name="4.0.0"></a>
+## [4.0.0](https://github.com/yargs/cliui/compare/v3.2.0...v4.0.0) (2017-12-18)
+
+
+### Bug Fixes
+
+* downgrades strip-ansi to version 3.0.1 ([#54](https://github.com/yargs/cliui/issues/54)) ([5764c46](https://github.com/yargs/cliui/commit/5764c46))
+* set env variable FORCE_COLOR. ([#56](https://github.com/yargs/cliui/issues/56)) ([7350e36](https://github.com/yargs/cliui/commit/7350e36))
+
+
+### Chores
+
+* drop support for node < 4 ([#53](https://github.com/yargs/cliui/issues/53)) ([b105376](https://github.com/yargs/cliui/commit/b105376))
+
+
+### Features
+
+* add fallback for window width ([#45](https://github.com/yargs/cliui/issues/45)) ([d064922](https://github.com/yargs/cliui/commit/d064922))
+
+
+### BREAKING CHANGES
+
+* officially drop support for Node < 4
+
+
+
+<a name="3.2.0"></a>
+## [3.2.0](https://github.com/yargs/cliui/compare/v3.1.2...v3.2.0) (2016-04-11)
+
+
+### Bug Fixes
+
+* reduces tarball size ([acc6c33](https://github.com/yargs/cliui/commit/acc6c33))
+
+### Features
+
+* adds standard-version for release management ([ff84e32](https://github.com/yargs/cliui/commit/ff84e32))