@ottocode/sdk 0.1.235 → 0.1.236

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.235",
+	"version": "0.1.236",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",

package/src/config/src/manager.ts

@@ -9,6 +9,9 @@ import {
 import {
 	getGlobalConfigDir,
 	getGlobalConfigPath,
+	getGlobalDebugDir,
+	getGlobalDebugLogPath,
+	getGlobalDebugSessionsDir,
 	getLocalDataDir,
 	joinPath,
 } from './paths.ts';
@@ -20,6 +23,14 @@ import {
 
 export type Scope = 'global' | 'local';
 
+export type DebugConfig = {
+	enabled: boolean;
+	scopes: string[];
+	logPath: string;
+	sessionsDir: string;
+	debugDir: string;
+};
+
 export async function read(projectRoot?: string) {
 	const cfg = await loadConfig(projectRoot);
 	const auth = await getAllAuth(projectRoot);
@@ -111,6 +122,50 @@ export async function writeDefaults(
 	await Bun.write(globalPath, JSON.stringify(next, null, 2));
 }
 
+export async function readDebugConfig(
+	projectRoot?: string,
+): Promise<DebugConfig> {
+	const cfg = await loadConfig(projectRoot);
+	return {
+		enabled: cfg.debugEnabled === true,
+		scopes: Array.isArray(cfg.debugScopes)
+			? cfg.debugScopes.filter(
+					(scope): scope is string =>
+						typeof scope === 'string' && scope.trim().length > 0,
+				)
+			: [],
+		logPath: getGlobalDebugLogPath(),
+		sessionsDir: getGlobalDebugSessionsDir(),
+		debugDir: getGlobalDebugDir(),
+	};
+}
+
+export async function writeDebugConfig(
+	updates: Partial<{
+		enabled: boolean;
+		scopes: string[];
+	}>,
+) {
+	const globalPath = getGlobalConfigPath();
+	const existing = await readJsonFile(globalPath);
+	const next: Record<string, unknown> = { ...(existing ?? {}) };
+
+	if (updates.enabled !== undefined) {
+		next.debugEnabled = updates.enabled;
+	}
+
+	if (updates.scopes !== undefined) {
+		next.debugScopes = updates.scopes;
+	}
+
+	const base = getGlobalConfigDir();
+	try {
+		const { promises: fs } = await import('node:fs');
+		await fs.mkdir(base, { recursive: true }).catch(() => {});
+	} catch {}
+	await Bun.write(globalPath, JSON.stringify(next, null, 2));
+}
+
 async function readJsonFile(
 	filePath: string,
 ): Promise<Record<string, unknown> | undefined> {

package/src/config/src/paths.ts

@@ -79,6 +79,33 @@ export function getGlobalCommandsDir(): string {
 	return joinPath(getGlobalConfigDir(), 'commands');
 }
 
+export function getGlobalDebugDir(): string {
+	return joinPath(getGlobalConfigDir(), 'debug');
+}
+
+export function getGlobalDebugLogPath(): string {
+	return joinPath(getGlobalDebugDir(), 'latest.log');
+}
+
+export function getGlobalDebugSessionsDir(): string {
+	return joinPath(getGlobalDebugDir(), 'sessions');
+}
+
+export function getSessionDebugLogPath(sessionId: string): string {
+	return joinPath(getGlobalDebugSessionsDir(), `${sessionId}.log`);
+}
+
+export function getSessionDebugDetailsLogPath(sessionId: string): string {
+	return joinPath(getGlobalDebugSessionsDir(), `${sessionId}.details.log`);
+}
+
+export function getSessionSystemPromptPath(sessionId: string): string {
+	return joinPath(
+		getGlobalDebugSessionsDir(),
+		`${sessionId}.system-prompt.txt`,
+	);
+}
+
 export function getLocalDataDir(projectRoot: string): string {
 	return joinPath(projectRoot, '.otto');
 }

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

@@ -1,7 +1,34 @@
+import { readFileSync } from 'node:fs';
+import { getGlobalConfigPath } from '../../../config/src/paths.ts';
+
+type DebugSettings = {
+	debugEnabled?: boolean;
+	debugScopes?: unknown;
+};
+
+function readDebugSettings(): DebugSettings {
+	try {
+		const raw = readFileSync(getGlobalConfigPath(), 'utf-8');
+		const parsed = JSON.parse(raw) as DebugSettings;
+		return parsed && typeof parsed === 'object' ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+
 export function isDebugEnabled(): boolean {
-	return false;
+	return readDebugSettings().debugEnabled === true;
 }
 
 export function isTraceEnabled(): boolean {
 	return false;
 }
+
+export function getDebugScopes(): string[] {
+	const scopes = readDebugSettings().debugScopes;
+	if (!Array.isArray(scopes)) return [];
+	return scopes.filter(
+		(scope): scope is string =>
+			typeof scope === 'string' && scope.trim().length > 0,
+	);
+}

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

@@ -1,9 +1,22 @@
 import { appendFileSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { isDebugEnabled, isTraceEnabled } from './debug.ts';
+import { isDebugEnabled, isTraceEnabled, getDebugScopes } from './debug.ts';
+import {
+	getGlobalDebugLogPath,
+	getSessionDebugDetailsLogPath,
+	getSessionDebugLogPath,
+} from '../../../config/src/paths.ts';
 
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 
+const ANSI_RESET = '\x1b[0m';
+const ANSI_DIM = '\x1b[2m';
+const ANSI_CYAN = '\x1b[36m';
+const ANSI_BLUE = '\x1b[34m';
+const ANSI_GREEN = '\x1b[32m';
+const ANSI_YELLOW = '\x1b[33m';
+const ANSI_RED = '\x1b[31m';
+
 function safeHasMeta(
 	meta?: Record<string, unknown>,
 ): meta is Record<string, unknown> {
@@ -11,18 +24,90 @@ function safeHasMeta(
 }
 
 function getDebugLogFilePath(): string | undefined {
-	return undefined;
+	if (!isDebugEnabled()) return undefined;
+	return getGlobalDebugLogPath();
+}
+
+function getSessionLogFilePath(
+	meta?: Record<string, unknown>,
+): string | undefined {
+	if (!isDebugEnabled()) return undefined;
+	if (meta?.debugDetail === true) return undefined;
+	const sessionId = meta?.sessionId;
+	if (typeof sessionId !== 'string' || !sessionId.trim()) return undefined;
+	return getSessionDebugLogPath(sessionId);
+}
+
+function getSessionDetailsLogFilePath(
+	meta?: Record<string, unknown>,
+): string | undefined {
+	if (!isDebugEnabled()) return undefined;
+	const sessionId = meta?.sessionId;
+	if (typeof sessionId !== 'string' || !sessionId.trim()) return undefined;
+	return getSessionDebugDetailsLogPath(sessionId);
+}
+
+function shouldWriteDebugLog(message: string): boolean {
+	if (!isDebugEnabled()) return false;
+	const scopes = getDebugScopes();
+	if (!scopes.length) return true;
+	const match = message.match(/^\[([^\]]+)\]/);
+	if (!match?.[1]) return true;
+	return scopes.includes(match[1]);
 }
 
 function serializeLogMeta(meta?: Record<string, unknown>): string {
 	if (!safeHasMeta(meta)) return '';
 	try {
-		return ` ${JSON.stringify(meta)}`;
+		const sanitized = { ...meta };
+		delete sanitized.debugDetail;
+		return Object.keys(sanitized).length ? ` ${JSON.stringify(sanitized)}` : '';
 	} catch {
 		return ' [unserializable-meta]';
 	}
 }
 
+function colorizeLine(line: string, level: LogLevel): string {
+	const levelColor =
+		level === 'debug'
+			? ANSI_CYAN
+			: level === 'info'
+				? ANSI_BLUE
+				: level === 'warn'
+					? ANSI_YELLOW
+					: ANSI_RED;
+	const scopeMatch = line.match(
+		/\[(debug|info|warn|error|timing)\]\s+\[([^\]]+)\]/i,
+	);
+	if (!scopeMatch) {
+		return `${levelColor}${line}${ANSI_RESET}`;
+	}
+	const rest = line.slice(24);
+	return `${ANSI_DIM}${line.slice(0, 24)}${ANSI_RESET}${rest
+		.replace(scopeMatch[1], `${levelColor}${scopeMatch[1]}${ANSI_RESET}`)
+		.replace(
+			`[${scopeMatch[2]}]`,
+			`${ANSI_GREEN}[${scopeMatch[2]}]${ANSI_RESET}`,
+		)}`;
+}
+
+function printLine(
+	level: LogLevel,
+	line: string,
+	meta?: Record<string, unknown>,
+) {
+	const colored = colorizeLine(line, level);
+	if (safeHasMeta(meta)) {
+		if (level === 'warn') console.warn(colored, meta);
+		else if (level === 'error') console.error(colored, meta);
+		else console.log(colored, meta);
+		return;
+	}
+	if (level === 'warn') console.warn(colored);
+	else if (level === 'error') console.error(colored);
+	else console.log(colored);
+}
+
 function writeLogLine(line: string, meta?: Record<string, unknown>) {
 	const suffix = serializeLogMeta(meta);
 	const fullLine = `${new Date().toISOString()} ${line}${suffix}`;
@@ -37,32 +122,44 @@ function writeLogLine(line: string, meta?: Record<string, unknown>) {
 		}
 	}
 
+	const sessionLogFile = getSessionLogFilePath(meta);
+	if (sessionLogFile) {
+		try {
+			mkdirSync(dirname(sessionLogFile), { recursive: true });
+			appendFileSync(sessionLogFile, `${fullLine}\n`, 'utf-8');
+		} catch {
+			// ignore file logging errors
+		}
+	}
+
+	const sessionDetailsLogFile = getSessionDetailsLogFilePath(meta);
+	if (sessionDetailsLogFile) {
+		try {
+			mkdirSync(dirname(sessionDetailsLogFile), { recursive: true });
+			appendFileSync(sessionDetailsLogFile, `${fullLine}\n`, 'utf-8');
+		} catch {
+			// ignore file logging errors
+		}
+	}
+
 	return fullLine;
 }
 
 export function debug(message: string, meta?: Record<string, unknown>): void {
-	if (!isDebugEnabled()) return;
+	if (!shouldWriteDebugLog(message)) return;
 	try {
 		const line = writeLogLine(`[debug] ${message}`, meta);
-		if (safeHasMeta(meta)) {
-			console.log(line, meta);
-		} else {
-			console.log(line);
-		}
+		printLine('debug', line, meta);
 	} catch {
 		// ignore logging errors
 	}
 }
 
 export function info(message: string, meta?: Record<string, unknown>): void {
-	if (!isDebugEnabled() && !isTraceEnabled()) return;
+	if (!shouldWriteDebugLog(message) && !isTraceEnabled()) return;
 	try {
 		const line = writeLogLine(`[info] ${message}`, meta);
-		if (safeHasMeta(meta)) {
-			console.log(line, meta);
-		} else {
-			console.log(line);
-		}
+		printLine('info', line, meta);
 	} catch {
 		// ignore logging errors
 	}
@@ -71,11 +168,7 @@ export function info(message: string, meta?: Record<string, unknown>): void {
 export function warn(message: string, meta?: Record<string, unknown>): void {
 	try {
 		const line = writeLogLine(`[warn] ${message}`, meta);
-		if (safeHasMeta(meta)) {
-			console.warn(line, meta);
-		} else {
-			console.warn(line);
-		}
+		printLine('warn', line, meta);
 	} catch {
 		// ignore logging errors
 	}
@@ -127,10 +220,10 @@ export function error(
 
 		if (safeHasMeta(logMeta)) {
 			const line = writeLogLine(`[error] ${message}`, logMeta);
-			console.error(line, logMeta);
+			printLine('error', line, logMeta);
 		} else {
 			const line = writeLogLine(`[error] ${message}`);
-			console.error(line);
+			printLine('error', line);
 		}
 	} catch (logErr) {
 		try {
@@ -177,11 +270,7 @@ export function time(label: string): Timer {
 					`[timing] ${label} ${duration.toFixed(1)}ms`,
 					meta,
 				);
-				if (safeHasMeta(meta)) {
-					console.log(base, meta);
-				} else {
-					console.log(base);
-				}
+				printLine('info', base, meta);
 			} catch {
 				// ignore timing log errors
 			}

package/src/index.ts

@@ -177,6 +177,12 @@ export {
 	getGlobalAgentsDir,
 	getGlobalToolsDir,
 	getGlobalCommandsDir,
+	getGlobalDebugDir,
+	getGlobalDebugLogPath,
+	getGlobalDebugSessionsDir,
+	getSessionDebugLogPath,
+	getSessionDebugDetailsLogPath,
+	getSessionSystemPromptPath,
 	getSecureAuthPath,
 	getSecureBaseDir,
 	getSecureOAuthDir,
@@ -187,12 +193,14 @@ export {
 	isAuthorized,
 	ensureEnv,
 	writeDefaults as setConfig,
+	readDebugConfig,
+	writeDebugConfig,
 	writeAuth,
 	removeAuth as removeConfig,
 	getOnboardingComplete,
 	setOnboardingComplete,
 } from './config/src/manager.ts';
-export type { Scope } from './config/src/manager.ts';
+export type { Scope, DebugConfig } from './config/src/manager.ts';
 
 // =======================
 // Prompts (from internal prompts module)

package/src/prompts/src/debug.ts

@@ -3,13 +3,6 @@ export function isDebugEnabled(flag?: string): boolean {
 	return false;
 }
 
-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 {

package/src/types/src/config.ts

@@ -55,5 +55,7 @@ export type OttoConfig = {
 	defaults: DefaultConfig;
 	providers: ProviderSettings;
 	paths: PathConfig;
+	debugEnabled?: boolean;
+	debugScopes?: string[];
 	onboardingComplete?: boolean;
 };