@agi-cli/sdk 0.1.93 → 0.1.94

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/sdk",
-	"version": "0.1.93",
+	"version": "0.1.94",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "ntishxyz",
 	"license": "MIT",

package/src/core/src/index.ts

@@ -100,3 +100,9 @@ export {
 	NotFoundError,
 	ServiceError,
 } from './errors';
+
+// =======================
+// Logging & Debug
+// =======================
+export { logger, debug, info, warn, error, time } from './utils/logger.ts';
+export { isDebugEnabled, isTraceEnabled } from './utils/debug.ts';

package/src/core/src/terminals/manager.ts

@@ -1,7 +1,8 @@
-import { spawn as spawnPty } from './bun-pty.ts';
 import { randomBytes } from 'node:crypto';
-import { Terminal } from './terminal.ts';
 import type { PtyOptions } from './bun-pty.ts';
+import { spawn as spawnPty } from './bun-pty.ts';
+import { Terminal } from './terminal.ts';
+import { logger } from '../utils/logger.ts';
 
 const MAX_TERMINALS = 10;
 const CLEANUP_DELAY_MS = 5 * 60 * 1000;
@@ -19,10 +20,7 @@ export class TerminalManager {
 	private terminals = new Map<string, Terminal>();
 	private cleanupTimers = new Map<string, NodeJS.Timeout>();
 
-	constructor() {
-		process.on('SIGTERM', () => this.killAll());
-		process.on('SIGINT', () => this.killAll());
-	}
+	constructor() {}
 
 	create(options: CreateTerminalOptions): Terminal {
 		if (this.terminals.size >= MAX_TERMINALS) {
@@ -32,7 +30,7 @@ export class TerminalManager {
 		const id = this.generateId();
 
 		try {
-			console.log('[TerminalManager] Creating terminal:', {
+			logger.debug('TerminalManager: creating terminal', {
 				id,
 				command: options.command,
 				args: options.args,
@@ -50,7 +48,9 @@ export class TerminalManager {
 
 			const pty = spawnPty(options.command, options.args || [], ptyOptions);
 
-			console.log('[TerminalManager] PTY created successfully:', pty.pid);
+			logger.debug('TerminalManager: PTY created', {
+				pid: pty.pid,
+			});
 
 			const terminal = new Terminal(id, pty, options);
 
@@ -64,11 +64,11 @@ export class TerminalManager {
 
 			this.terminals.set(id, terminal);
 
-			console.log('[TerminalManager] Terminal added to map');
+			logger.debug('TerminalManager: terminal added to map', { id });
 
 			return terminal;
 		} catch (error) {
-			console.error('[TerminalManager] Failed to create terminal:', error);
+			logger.error('TerminalManager: failed to create terminal', error);
 			throw error;
 		}
 	}

package/src/core/src/utils/debug.ts

@@ -0,0 +1,40 @@
+const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
+
+type GlobalDebugFlags = {
+	__AGI_DEBUG_ENABLED__?: boolean;
+	__AGI_TRACE_ENABLED__?: boolean;
+};
+
+function readGlobalFlag(
+	key: '__AGI_DEBUG_ENABLED__' | '__AGI_TRACE_ENABLED__',
+) {
+	const globalState = globalThis as GlobalDebugFlags;
+	return globalState[key];
+}
+
+function envEnabled(keys: string[]): boolean {
+	for (const key of keys) {
+		const raw = typeof process !== 'undefined' ? process.env?.[key] : undefined;
+		if (!raw) continue;
+		const trimmed = raw.trim().toLowerCase();
+		if (!trimmed) continue;
+		if (TRUTHY.has(trimmed) || trimmed === 'all') return true;
+	}
+	return false;
+}
+
+export function isDebugEnabled(): boolean {
+	const globalFlag = readGlobalFlag('__AGI_DEBUG_ENABLED__');
+	if (typeof globalFlag === 'boolean') {
+		return globalFlag;
+	}
+	return envEnabled(['AGI_DEBUG', 'DEBUG_AGI']);
+}
+
+export function isTraceEnabled(): boolean {
+	const globalFlag = readGlobalFlag('__AGI_TRACE_ENABLED__');
+	if (typeof globalFlag === 'boolean') {
+		return Boolean(globalFlag) && isDebugEnabled();
+	}
+	return envEnabled(['AGI_TRACE', 'TRACE_AGI']) && isDebugEnabled();
+}

package/src/core/src/utils/logger.ts

@@ -0,0 +1,150 @@
+import { isDebugEnabled, isTraceEnabled } from './debug.ts';
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+function safeHasMeta(
+	meta?: Record<string, unknown>,
+): meta is Record<string, unknown> {
+	return Boolean(meta && Object.keys(meta).length);
+}
+
+export function debug(message: string, meta?: Record<string, unknown>): void {
+	if (!isDebugEnabled()) return;
+	try {
+		if (safeHasMeta(meta)) {
+			console.log(`[debug] ${message}`, meta);
+		} else {
+			console.log(`[debug] ${message}`);
+		}
+	} catch {
+		// ignore logging errors
+	}
+}
+
+export function info(message: string, meta?: Record<string, unknown>): void {
+	if (!isDebugEnabled() && !isTraceEnabled()) return;
+	try {
+		if (safeHasMeta(meta)) {
+			console.log(`[info] ${message}`, meta);
+		} else {
+			console.log(`[info] ${message}`);
+		}
+	} catch {
+		// ignore logging errors
+	}
+}
+
+export function warn(message: string, meta?: Record<string, unknown>): void {
+	try {
+		if (safeHasMeta(meta)) {
+			console.warn(`[warn] ${message}`, meta);
+		} else {
+			console.warn(`[warn] ${message}`);
+		}
+	} catch {
+		// ignore logging errors
+	}
+}
+
+export function error(
+	message: string,
+	err?: unknown,
+	meta?: Record<string, unknown>,
+): void {
+	if (!isDebugEnabled()) return;
+
+	try {
+		const logMeta: Record<string, unknown> = meta ? { ...meta } : {};
+
+		if (err) {
+			if (err instanceof Error) {
+				logMeta.error = {
+					name: err.name,
+					message: err.message,
+				};
+				if (isTraceEnabled() && err.stack) {
+					(logMeta.error as { stack?: string }).stack = err.stack;
+				}
+			} else if (typeof err === 'string') {
+				logMeta.error = err;
+			} else if (typeof err === 'object') {
+				const errObj = err as Record<string, unknown>;
+				const details: Record<string, unknown> = {};
+				if (typeof errObj.name === 'string') details.name = errObj.name;
+				if (typeof errObj.message === 'string')
+					details.message = errObj.message;
+				if (typeof errObj.code === 'string') details.code = errObj.code;
+				if (typeof errObj.status === 'number') details.status = errObj.status;
+				if (typeof errObj.statusCode === 'number')
+					details.statusCode = errObj.statusCode;
+				if (
+					isTraceEnabled() &&
+					typeof errObj.stack === 'string' &&
+					!details.stack
+				) {
+					details.stack = errObj.stack;
+				}
+				logMeta.error = Object.keys(details).length ? details : errObj;
+			} else {
+				logMeta.error = String(err);
+			}
+		}
+
+		if (safeHasMeta(logMeta)) {
+			console.error(`[error] ${message}`, logMeta);
+		} else {
+			console.error(`[error] ${message}`);
+		}
+	} catch (logErr) {
+		try {
+			console.error(`[error] ${message} (logging failed)`, logErr);
+		} catch {
+			// ignore
+		}
+	}
+}
+
+export const logger = {
+	debug,
+	info,
+	warn,
+	error,
+};
+
+function nowMs(): number {
+	const perf = (globalThis as { performance?: { now?: () => number } })
+		.performance;
+	if (perf && typeof perf.now === 'function') return perf.now();
+	return Date.now();
+}
+
+type Timer = {
+	end(meta?: Record<string, unknown>): void;
+};
+
+export function time(label: string): Timer {
+	if (!isDebugEnabled()) {
+		return { end() {} };
+	}
+
+	const start = nowMs();
+	let finished = false;
+
+	return {
+		end(meta?: Record<string, unknown>) {
+			if (finished) return;
+			finished = true;
+			const duration = nowMs() - start;
+			try {
+				const base = `[timing] ${label} ${duration.toFixed(1)}ms`;
+				if (safeHasMeta(meta)) {
+					console.log(base, meta);
+				} else {
+					console.log(base);
+				}
+			} catch {
+				// ignore timing log errors
+			}
+		},
+	};
+}

package/src/index.ts

@@ -161,6 +161,18 @@ export {
 	ServiceError,
 } from './core/src/index.ts';
 
+// Logging & Debug
+export {
+	logger,
+	debug,
+	info,
+	warn,
+	error,
+	time,
+	isDebugEnabled,
+	isTraceEnabled,
+} from './core/src/index.ts';
+
 // Schema Validation
 export { z } from './core/src/index.ts';