@ag-eco/agentplate-cli 0.13.0

package/src/logging/color.test.ts

@@ -0,0 +1,252 @@
+import { describe, expect, test } from "bun:test";
+import { dirname, join } from "node:path";
+
+// Resolve the project root from this file's location (src/logging/ -> project root)
+const projectRoot = join(dirname(import.meta.dir), "..");
+
+describe("color module", () => {
+	test("color.red is a function that wraps text", async () => {
+		const { color } = await import("./color.ts");
+		const result = color.red("hello");
+		expect(result).toContain("hello");
+		expect(typeof result).toBe("string");
+	});
+
+	test("color functions all exist", async () => {
+		const { color } = await import("./color.ts");
+		const expectedKeys = [
+			"bold",
+			"dim",
+			"red",
+			"green",
+			"yellow",
+			"blue",
+			"magenta",
+			"cyan",
+			"white",
+			"gray",
+		];
+		for (const key of expectedKeys) {
+			expect(key in color).toBe(true);
+			expect(typeof (color as Record<string, unknown>)[key]).toBe("function");
+		}
+	});
+
+	test("brand palette functions wrap text", async () => {
+		const { brand, accent, muted } = await import("./color.ts");
+		const result = brand("Agentplate");
+		expect(result).toContain("Agentplate");
+		expect(typeof accent("test")).toBe("string");
+		expect(typeof muted("test")).toBe("string");
+	});
+
+	test("noColor is an identity function", async () => {
+		const { noColor } = await import("./color.ts");
+		expect(noColor("hello")).toBe("hello");
+		expect(noColor("")).toBe("");
+	});
+
+	test("stripAnsi removes escape codes", async () => {
+		const { stripAnsi } = await import("./color.ts");
+		expect(stripAnsi("\x1b[31mhello\x1b[39m")).toBe("hello");
+		expect(stripAnsi("plain")).toBe("plain");
+		expect(stripAnsi("\x1b[1m\x1b[31mbold red\x1b[39m\x1b[22m")).toBe("bold red");
+	});
+
+	test("visibleLength excludes ANSI codes", async () => {
+		const { visibleLength } = await import("./color.ts");
+		expect(visibleLength("\x1b[31mhello\x1b[39m")).toBe(5);
+		expect(visibleLength("hello")).toBe(5);
+		expect(visibleLength("")).toBe(0);
+	});
+
+	test("setQuiet/isQuiet controls quiet mode", async () => {
+		const { isQuiet, setQuiet } = await import("./color.ts");
+		expect(isQuiet()).toBe(false);
+		setQuiet(true);
+		expect(isQuiet()).toBe(true);
+		setQuiet(false);
+		expect(isQuiet()).toBe(false);
+	});
+
+	test("NO_COLOR env causes chalk.level to be 0", async () => {
+		const proc = Bun.spawn(
+			[
+				"bun",
+				"-e",
+				'import chalk from "chalk"; console.log(JSON.stringify({ level: chalk.level }))',
+			],
+			{
+				cwd: projectRoot,
+				stdout: "pipe",
+				stderr: "pipe",
+				env: { ...process.env, NO_COLOR: "1", FORCE_COLOR: undefined },
+			},
+		);
+		await proc.exited;
+		const output = await new Response(proc.stdout).text();
+		const result = JSON.parse(output.trim());
+		expect(result.level).toBe(0);
+	});
+
+	test("FORCE_COLOR overrides NO_COLOR", async () => {
+		const proc = Bun.spawn(
+			[
+				"bun",
+				"-e",
+				'import chalk from "chalk"; console.log(JSON.stringify({ level: chalk.level }))',
+			],
+			{
+				cwd: projectRoot,
+				stdout: "pipe",
+				stderr: "pipe",
+				env: { ...process.env, NO_COLOR: "1", FORCE_COLOR: "1" },
+			},
+		);
+		await proc.exited;
+		const output = await new Response(proc.stdout).text();
+		const result = JSON.parse(output.trim());
+		expect(result.level).toBeGreaterThan(0);
+	});
+
+	test("chalk re-export is available", async () => {
+		const { chalk } = await import("./color.ts");
+		expect(typeof chalk.red).toBe("function");
+		expect(chalk.red("test")).toContain("test");
+	});
+
+	test("ColorFn type: color functions accept strings and return strings", async () => {
+		const { color } = await import("./color.ts");
+		// Each color function should accept a string and return a string
+		const result = color.bold(color.red("nested"));
+		expect(result).toContain("nested");
+		expect(typeof result).toBe("string");
+	});
+
+	test("printSuccess outputs to stdout with checkmark and message", async () => {
+		const { printSuccess, setQuiet } = await import("./color.ts");
+		setQuiet(false);
+		const logged: string[] = [];
+		const originalWrite = process.stdout.write;
+		process.stdout.write = ((chunk: string | Uint8Array) => {
+			logged.push(String(chunk));
+			return true;
+		}) as typeof process.stdout.write;
+		try {
+			printSuccess("Created issue");
+			expect(logged.length).toBe(1);
+			expect(logged[0]).toContain("\u2713");
+			expect(logged[0]).toContain("Created issue");
+		} finally {
+			process.stdout.write = originalWrite;
+		}
+	});
+
+	test("printSuccess includes accent-colored ID when provided", async () => {
+		const { printSuccess, setQuiet } = await import("./color.ts");
+		setQuiet(false);
+		const logged: string[] = [];
+		const originalWrite = process.stdout.write;
+		process.stdout.write = ((chunk: string | Uint8Array) => {
+			logged.push(String(chunk));
+			return true;
+		}) as typeof process.stdout.write;
+		try {
+			printSuccess("Created issue", "sprout-a1b2");
+			expect(logged.length).toBe(1);
+			expect(logged[0]).toContain("Created issue");
+			expect(logged[0]).toContain("sprout-a1b2");
+		} finally {
+			process.stdout.write = originalWrite;
+		}
+	});
+
+	test("printWarning outputs to stdout with ! and message and dim hint", async () => {
+		const { printWarning, setQuiet } = await import("./color.ts");
+		setQuiet(false);
+		const logged: string[] = [];
+		const originalWrite = process.stdout.write;
+		process.stdout.write = ((chunk: string | Uint8Array) => {
+			logged.push(String(chunk));
+			return true;
+		}) as typeof process.stdout.write;
+		try {
+			printWarning("3 prompts stale", "run tl emit --all");
+			expect(logged.length).toBe(1);
+			expect(logged[0]).toContain("!");
+			expect(logged[0]).toContain("3 prompts stale");
+			expect(logged[0]).toContain("run tl emit --all");
+		} finally {
+			process.stdout.write = originalWrite;
+		}
+	});
+
+	test("printError outputs to stderr with cross, message, and dim hint", async () => {
+		const { printError } = await import("./color.ts");
+		const errored: string[] = [];
+		const originalWrite = process.stderr.write;
+		process.stderr.write = ((chunk: string | Uint8Array) => {
+			errored.push(String(chunk));
+			return true;
+		}) as typeof process.stderr.write;
+		try {
+			printError("Config not found", "run sr init");
+			expect(errored.length).toBe(1);
+			expect(errored[0]).toContain("\u2717");
+			expect(errored[0]).toContain("Config not found");
+			expect(errored[0]).toContain("run sr init");
+		} finally {
+			process.stderr.write = originalWrite;
+		}
+	});
+
+	test("printHint outputs dim indented text to stdout", async () => {
+		const { printHint, setQuiet } = await import("./color.ts");
+		setQuiet(false);
+		const logged: string[] = [];
+		const originalWrite = process.stdout.write;
+		process.stdout.write = ((chunk: string | Uint8Array) => {
+			logged.push(String(chunk));
+			return true;
+		}) as typeof process.stdout.write;
+		try {
+			printHint("Run without --dry-run");
+			expect(logged.length).toBe(1);
+			expect(logged[0]).toContain("Run without --dry-run");
+		} finally {
+			process.stdout.write = originalWrite;
+		}
+	});
+
+	test("quiet mode suppresses printSuccess, printWarning, printHint but not printError", async () => {
+		const { printSuccess, printWarning, printHint, printError, setQuiet } = await import(
+			"./color.ts"
+		);
+		setQuiet(true);
+		const logged: string[] = [];
+		const errored: string[] = [];
+		const originalStdoutWrite = process.stdout.write;
+		const originalStderrWrite = process.stderr.write;
+		process.stdout.write = ((chunk: string | Uint8Array) => {
+			logged.push(String(chunk));
+			return true;
+		}) as typeof process.stdout.write;
+		process.stderr.write = ((chunk: string | Uint8Array) => {
+			errored.push(String(chunk));
+			return true;
+		}) as typeof process.stderr.write;
+		try {
+			printSuccess("suppressed success");
+			printWarning("suppressed warning");
+			printHint("suppressed hint");
+			printError("visible error");
+			expect(logged.length).toBe(0);
+			expect(errored.length).toBe(1);
+			expect(errored[0]).toContain("visible error");
+		} finally {
+			process.stdout.write = originalStdoutWrite;
+			process.stderr.write = originalStderrWrite;
+			setQuiet(false);
+		}
+	});
+});

package/src/logging/color.ts

@@ -0,0 +1,105 @@
+/**
+ * Central color and output control using Chalk.
+ *
+ * Chalk natively handles NO_COLOR, FORCE_COLOR, and TERM=dumb.
+ * See https://github.com/chalk/chalk#supportscolor for detection logic.
+ */
+
+import chalk from "chalk";
+
+// --- Brand palette (ag-eco brand colors) ---
+
+/** Forest green — Agentplate primary brand color. */
+export const brand = chalk.rgb(46, 125, 50);
+
+/** Amber — highlights, warnings. */
+export const accent = chalk.rgb(255, 183, 77);
+
+/** Stone gray — secondary text, muted content. */
+export const muted = chalk.rgb(120, 120, 110);
+
+// --- Standard color functions ---
+
+/**
+ * Color functions that wrap text with ANSI codes.
+ * Each value is a function: color.red("text") returns "\x1b[31mtext\x1b[39m".
+ * Chalk auto-resets when wrapping, so color.reset is not needed.
+ */
+export const color = {
+	bold: chalk.bold,
+	dim: chalk.dim,
+	red: chalk.red,
+	green: chalk.green,
+	yellow: chalk.yellow,
+	blue: chalk.blue,
+	magenta: chalk.magenta,
+	cyan: chalk.cyan,
+	white: chalk.white,
+	gray: chalk.gray,
+} as const;
+
+// Re-export chalk for direct use (chaining, custom RGB, etc.)
+export { chalk };
+
+/** Type for color function values (for consumers that store colors in variables). */
+export type ColorFn = (text: string) => string;
+
+/** Identity function for "no color" cases (replaces old color.white as default). */
+export const noColor: ColorFn = (text: string) => text;
+
+// --- ANSI strip utilities (for visible-width calculations in dashboard) ---
+
+// biome-ignore lint/suspicious/noControlCharactersInRegex: ESC (0x1B) is required to match ANSI escape sequences
+const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
+
+/** Strip ANSI escape codes from a string. */
+export function stripAnsi(str: string): string {
+	return str.replace(ANSI_REGEX, "");
+}
+
+/** Visible string length (excluding ANSI escape codes). */
+export function visibleLength(str: string): number {
+	return stripAnsi(str).length;
+}
+
+// --- Quiet mode ---
+
+let quietMode = false;
+
+/** Enable quiet mode (suppress non-error output). */
+export function setQuiet(enabled: boolean): void {
+	quietMode = enabled;
+}
+
+/** Check if quiet mode is active. */
+export function isQuiet(): boolean {
+	return quietMode;
+}
+
+// --- Standardized message formatters (visual-spec.md Message Formats) ---
+
+/** Success: brand checkmark + brand message. Optional accent-colored ID. */
+export function printSuccess(msg: string, id?: string): void {
+	if (isQuiet()) return;
+	const idPart = id ? ` ${accent(id)}` : "";
+	process.stdout.write(`${brand.bold("\u2713")} ${brand(msg)}${idPart}\n`);
+}
+
+/** Warning: yellow ! + yellow message. Optional dim hint. */
+export function printWarning(msg: string, hint?: string): void {
+	if (isQuiet()) return;
+	const hintPart = hint ? ` ${chalk.dim(`\u2014 ${hint}`)}` : "";
+	process.stdout.write(`${chalk.yellow.bold("!")} ${chalk.yellow(msg)}${hintPart}\n`);
+}
+
+/** Error: red cross + red message. Optional dim hint. Always to stderr. */
+export function printError(msg: string, hint?: string): void {
+	const hintPart = hint ? ` ${chalk.dim(`\u2014 ${hint}`)}` : "";
+	process.stderr.write(`${chalk.red.bold("\u2717")} ${chalk.red(msg)}${hintPart}\n`);
+}
+
+/** Hint/info: dim indented text. */
+export function printHint(msg: string): void {
+	if (isQuiet()) return;
+	process.stdout.write(`${chalk.dim(`  ${msg}`)}\n`);
+}

package/src/logging/format.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, test } from "bun:test";
+import type { StoredEvent } from "../types.ts";
+import { stripAnsi } from "./color.ts";
+import { formatEventLine, numericPriorityColor } from "./format.ts";
+
+// Minimal StoredEvent fixture for testing formatEventLine
+const BASE_EVENT: StoredEvent = {
+	id: 1,
+	runId: "run-001",
+	agentName: "agent1",
+	sessionId: null,
+	eventType: "tool_start",
+	level: "info",
+	toolName: "bash",
+	toolArgs: null,
+	toolDurationMs: null,
+	data: null,
+	createdAt: "2024-01-15T10:30:45.000Z",
+};
+
+describe("numericPriorityColor", () => {
+	test("returns a function for priority 1", () => {
+		const fn = numericPriorityColor(1);
+		expect(typeof fn).toBe("function");
+		// Function must accept a string and return a string
+		expect(typeof fn("x")).toBe("string");
+	});
+
+	test("returns a function for priority 2", () => {
+		const fn = numericPriorityColor(2);
+		expect(typeof fn).toBe("function");
+		expect(typeof fn("x")).toBe("string");
+	});
+
+	test("priority 3 is identity (returns input unchanged)", () => {
+		const fn = numericPriorityColor(3);
+		// Priority 3 = normal = (text) => text, always identity regardless of chalk level
+		expect(fn("x")).toBe("x");
+		expect(fn("hello world")).toBe("hello world");
+	});
+
+	test("returns a function for priority 4", () => {
+		const fn = numericPriorityColor(4);
+		expect(typeof fn).toBe("function");
+		expect(typeof fn("x")).toBe("string");
+	});
+
+	test("unknown priority returns identity function", () => {
+		const fn = numericPriorityColor(99);
+		expect(typeof fn).toBe("function");
+		expect(fn("x")).toBe("x");
+	});
+
+	test("all priority functions preserve input text (visible content after strip)", () => {
+		for (const p of [1, 2, 3, 4]) {
+			const fn = numericPriorityColor(p);
+			expect(stripAnsi(fn("hello"))).toBe("hello");
+		}
+	});
+});
+
+describe("formatEventLine", () => {
+	test("returns a non-empty string", () => {
+		const colorMap = new Map<string, (t: string) => string>();
+		const result = formatEventLine(BASE_EVENT, colorMap);
+		expect(result.length).toBeGreaterThan(0);
+	});
+
+	test("includes agent name in the result", () => {
+		const colorMap = new Map<string, (t: string) => string>();
+		const result = formatEventLine(BASE_EVENT, colorMap);
+		// Strip ANSI so we can do plain text comparison
+		expect(stripAnsi(result)).toContain("agent1");
+	});
+
+	test("includes time portion (10:30:45) in the result", () => {
+		const colorMap = new Map<string, (t: string) => string>();
+		const result = formatEventLine(BASE_EVENT, colorMap);
+		expect(stripAnsi(result)).toContain("10:30:45");
+	});
+
+	test("result does NOT end with a newline", () => {
+		const colorMap = new Map<string, (t: string) => string>();
+		const result = formatEventLine(BASE_EVENT, colorMap);
+		expect(result.endsWith("\n")).toBe(false);
+	});
+
+	test("error level result is a non-empty string", () => {
+		const colorMap = new Map<string, (t: string) => string>();
+		const errorEvent: StoredEvent = { ...BASE_EVENT, level: "error" };
+		const result = formatEventLine(errorEvent, colorMap);
+		expect(result.length).toBeGreaterThan(0);
+		expect(result.endsWith("\n")).toBe(false);
+	});
+
+	test("uses color from colorMap when agent is registered", () => {
+		const blueColor = (t: string) => `\x1b[34m${t}\x1b[39m`;
+		const colorMap = new Map<string, (t: string) => string>([["agent1", blueColor]]);
+		const result = formatEventLine(BASE_EVENT, colorMap);
+		// The colored agent name should appear in the output
+		expect(result).toContain("\x1b[34m");
+	});
+
+	test("falls back to gray when agent is not in colorMap", () => {
+		const colorMap = new Map<string, (t: string) => string>();
+		// Should not throw — gray fallback is used
+		const result = formatEventLine(BASE_EVENT, colorMap);
+		expect(result.length).toBeGreaterThan(0);
+	});
+});