@ottocode/server 0.1.173

package/src/runtime/ask/service.ts

@@ -0,0 +1,369 @@
+import { eq } from 'drizzle-orm';
+import { loadConfig } from '@ottocode/sdk';
+import { getDb } from '@ottocode/database';
+import {
+	createSession,
+	getLastSession,
+	getSessionById,
+} from '../session/manager.ts';
+import {
+	selectProviderAndModel,
+	type ProviderSelection,
+} from '../provider/selection.ts';
+import { resolveAgentConfig } from '../agent/registry.ts';
+import { dispatchAssistantMessage } from '../message/service.ts';
+import {
+	validateProviderModel,
+	isProviderAuthorized,
+	ensureProviderEnv,
+	isProviderId,
+	providerEnvVar,
+	type ProviderId,
+} from '@ottocode/sdk';
+import { sessions } from '@ottocode/database/schema';
+import { time } from '../debug/index.ts';
+
+export class AskServiceError extends Error {
+	constructor(
+		message: string,
+		public status = 400,
+		public code = 'ASK_SERVICE_ERROR',
+	) {
+		super(message);
+		this.name = 'AskServiceError';
+	}
+
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			code: this.code,
+			status: this.status,
+		};
+	}
+}
+
+export type InjectableConfig = {
+	provider?: string;
+	model?: string;
+	apiKey?: string;
+	agent?: string;
+};
+
+export type InjectableCredentials = Partial<
+	Record<ProviderId, { apiKey: string }>
+>;
+
+export type AskServerRequest = {
+	projectRoot?: string;
+	prompt: string;
+	agent?: string;
+	provider?: string;
+	model?: string;
+	sessionId?: string;
+	last?: boolean;
+	jsonMode?: boolean;
+	skipFileConfig?: boolean;
+	config?: InjectableConfig;
+	credentials?: InjectableCredentials;
+	agentPrompt?: string;
+	tools?: string[];
+};
+
+export type AskServerResponse = {
+	sessionId: string;
+	header: {
+		agent?: string;
+		provider?: string;
+		model?: string;
+		sessionId: string;
+	};
+	provider: ProviderId;
+	model: string;
+	agent: string;
+	assistantMessageId: string;
+	message?: { kind: 'created' | 'last'; sessionId: string };
+};
+
+type SessionRow =
+	typeof import('@ottocode/database/schema').sessions.$inferSelect;
+
+export async function handleAskRequest(
+	request: AskServerRequest,
+): Promise<AskServerResponse> {
+	try {
+		return await processAskRequest(request);
+	} catch (err) {
+		throw normalizeAskServiceError(err);
+	}
+}
+
+async function processAskRequest(
+	request: AskServerRequest,
+): Promise<AskServerResponse> {
+	const projectRoot = request.projectRoot || process.cwd();
+	const configTimer = time('ask:loadConfig+db');
+
+	let cfg: import('@ottocode/sdk').OttoConfig;
+
+	if (request.skipFileConfig || request.config) {
+		const injectedProvider = (request.config?.provider ||
+			request.provider ||
+			'openai') as ProviderId;
+		const injectedModel =
+			request.config?.model || request.model || 'gpt-4o-mini';
+		const injectedAgent = request.config?.agent || request.agent || 'general';
+
+		cfg = {
+			projectRoot,
+			defaults: {
+				provider: injectedProvider,
+				model: injectedModel,
+				agent: injectedAgent,
+			},
+			providers: {
+				openai: { enabled: true },
+				anthropic: { enabled: true },
+				google: { enabled: true },
+				openrouter: { enabled: true },
+				opencode: { enabled: true },
+				setu: { enabled: true },
+			},
+			paths: {
+				dataDir: `${projectRoot}/.otto`,
+				dbPath: `${projectRoot}/.otto/otto.sqlite`,
+				projectConfigPath: null,
+				globalConfigPath: null,
+			},
+		};
+
+		if (request.credentials) {
+			for (const [provider, creds] of Object.entries(request.credentials)) {
+				const envKey =
+					providerEnvVar(provider as ProviderId) ??
+					`${provider.toUpperCase()}_API_KEY`;
+				process.env[envKey] = creds.apiKey;
+			}
+		} else if (request.config?.apiKey) {
+			const envKey =
+				providerEnvVar(injectedProvider) ??
+				`${injectedProvider.toUpperCase()}_API_KEY`;
+			process.env[envKey] = request.config.apiKey;
+		}
+	} else {
+		cfg = await loadConfig(projectRoot);
+	}
+
+	const db = await getDb(cfg.projectRoot);
+	configTimer.end();
+
+	let session: SessionRow | undefined;
+	let messageIndicator: AskServerResponse['message'];
+
+	if (request.sessionId) {
+		session = await getSessionById({
+			db,
+			projectPath: cfg.projectRoot,
+			sessionId: request.sessionId,
+		});
+		if (!session) {
+			throw new AskServiceError(`Session not found: ${request.sessionId}`, 404);
+		}
+	} else if (request.last) {
+		session = await getLastSession({ db, projectPath: cfg.projectRoot });
+		if (session) {
+			messageIndicator = { kind: 'last', sessionId: session.id };
+		}
+	} else {
+		session = undefined;
+	}
+
+	const agentName = (() => {
+		if (request.agent) return request.agent;
+		if (session?.agent) return session.agent;
+		return cfg.defaults.agent;
+	})();
+
+	const agentTimer = time('ask:resolveAgentConfig');
+	const agentCfg = request.agentPrompt
+		? {
+				name: agentName,
+				prompt: request.agentPrompt,
+				tools: request.tools ?? ['progress_update', 'finish'],
+				provider: isProviderId(request.provider)
+					? (request.provider as ProviderId)
+					: undefined,
+				model: request.model,
+			}
+		: await resolveAgentConfig(cfg.projectRoot, agentName);
+	agentTimer.end({ agent: agentName });
+	const agentProviderDefault = isProviderId(agentCfg.provider)
+		? agentCfg.provider
+		: cfg.defaults.provider;
+	const agentModelDefault = agentCfg.model ?? cfg.defaults.model;
+
+	const explicitProvider = isProviderId(request.provider)
+		? (request.provider as ProviderId)
+		: undefined;
+
+	let providerSelection: ProviderSelection;
+	const selectTimer = time('ask:selectProviderModel');
+	try {
+		providerSelection = await selectProviderAndModel({
+			cfg,
+			agentProviderDefault,
+			agentModelDefault,
+			explicitProvider,
+			explicitModel: request.model,
+			skipAuth: Boolean(
+				request.skipFileConfig || request.config || request.credentials,
+			),
+		});
+		selectTimer.end({ provider: providerSelection.provider });
+	} catch (err) {
+		selectTimer.end();
+		throw normalizeAskServiceError(err);
+	}
+
+	if (!session) {
+		const createTimer = time('ask:createSession');
+		const newSession = await createSession({
+			db,
+			cfg,
+			agent: agentName,
+			provider: providerSelection.provider,
+			model: providerSelection.model,
+			title: null,
+		});
+		createTimer.end();
+		session = newSession;
+		messageIndicator = { kind: 'created', sessionId: newSession.id };
+	}
+	if (!session)
+		throw new AskServiceError('Failed to resolve or create session.', 500);
+
+	const overridesProvided = Boolean(request.provider || request.model);
+
+	let providerForMessage: ProviderId;
+	let modelForMessage: string;
+
+	if (overridesProvided) {
+		providerForMessage = providerSelection.provider;
+		modelForMessage = providerSelection.model;
+	} else if (session.provider && session.model) {
+		const sessionProvider = isProviderId(session.provider)
+			? (session.provider as ProviderId)
+			: agentProviderDefault;
+		providerForMessage = sessionProvider;
+		modelForMessage = session.model;
+	} else {
+		providerForMessage = providerSelection.provider;
+		modelForMessage = providerSelection.model;
+	}
+
+	const providerAuthorized = await isProviderAuthorized(
+		cfg,
+		providerForMessage,
+	);
+	let fellBackToSelection = false;
+	if (!providerAuthorized) {
+		providerForMessage = providerSelection.provider;
+		modelForMessage = providerSelection.model;
+		fellBackToSelection = true;
+	}
+	if (
+		session &&
+		fellBackToSelection &&
+		(session.provider !== providerForMessage ||
+			session.model !== modelForMessage)
+	) {
+		await db
+			.update(sessions)
+			.set({ provider: providerForMessage, model: modelForMessage })
+			.where(eq(sessions.id, session.id));
+		session = {
+			...session,
+			provider: providerForMessage,
+			model: modelForMessage,
+		} as SessionRow;
+	}
+
+	validateProviderModel(providerForMessage, modelForMessage);
+
+	if (!request.skipFileConfig && !request.config && !request.credentials) {
+		await ensureProviderEnv(cfg, providerForMessage);
+	}
+
+	const assistantMessage = await dispatchAssistantMessage({
+		cfg,
+		db,
+		session,
+		agent: agentName,
+		provider: providerForMessage,
+		model: modelForMessage,
+		content: request.prompt,
+		oneShot: !request.sessionId && !request.last,
+	});
+
+	const headerAgent = session.agent ?? agentName;
+	const headerProvider = providerForMessage;
+	const headerModel = modelForMessage;
+
+	return {
+		sessionId: session.id,
+		header: {
+			agent: headerAgent,
+			provider: headerProvider,
+			model: headerModel,
+			sessionId: session.id,
+		},
+		provider: providerForMessage,
+		model: modelForMessage,
+		agent: agentName,
+		assistantMessageId: assistantMessage.assistantMessageId,
+		message: messageIndicator,
+	};
+}
+
+function normalizeAskServiceError(err: unknown): AskServiceError {
+	if (err instanceof AskServiceError) return err;
+	if (err instanceof Error) {
+		const status = inferStatus(err);
+		const message = err.message || 'Unknown error';
+		return new AskServiceError(message, status);
+	}
+	return new AskServiceError(String(err ?? 'Unknown error'));
+}
+
+export function inferStatus(err: Error): number {
+	const anyErr = err as { status?: unknown; code?: unknown };
+	if (typeof anyErr.status === 'number') {
+		const s = anyErr.status;
+		if (Number.isFinite(s) && s >= 400 && s < 600) return s;
+	}
+	if (typeof anyErr.code === 'number') {
+		const s = anyErr.code;
+		if (Number.isFinite(s) && s >= 400 && s < 600) return s;
+	}
+	const derived = deriveStatusFromMessage(err.message || '');
+	return derived ?? 400;
+}
+
+const STATUS_PATTERNS: Array<{ regex: RegExp; status: number }> = [
+	{ regex: /not found/i, status: 404 },
+	{ regex: /missing credentials/i, status: 401 },
+	{ regex: /unauthorized/i, status: 401 },
+	{ regex: /not configured/i, status: 401 },
+	{ regex: /authorized providers/i, status: 401 },
+	{ regex: /forbidden/i, status: 403 },
+	{ regex: /timeout/i, status: 504 },
+];
+
+export function deriveStatusFromMessage(message: string): number | undefined {
+	const trimmed = message.trim();
+	if (!trimmed) return undefined;
+	for (const { regex, status } of STATUS_PATTERNS) {
+		if (regex.test(trimmed)) return status;
+	}
+	return undefined;
+}

package/src/runtime/context/environment.ts

@@ -0,0 +1,202 @@
+import { getHomeDir } from '@ottocode/sdk';
+
+async function detectProjectTooling(
+	projectRoot: string,
+): Promise<{ packageManager?: string; runtime?: string; language?: string }> {
+	const { existsSync } = await import('node:fs');
+	const { join } = await import('node:path');
+	const result: {
+		packageManager?: string;
+		runtime?: string;
+		language?: string;
+	} = {};
+
+	try {
+		const pkgPath = join(projectRoot, 'package.json');
+		if (existsSync(pkgPath)) {
+			const pkg = await Bun.file(pkgPath).json();
+			if (pkg.packageManager) {
+				const match = String(pkg.packageManager).match(/^(bun|npm|yarn|pnpm)/);
+				if (match) result.packageManager = match[1];
+			}
+		}
+	} catch {}
+
+	if (!result.packageManager) {
+		if (
+			existsSync(join(projectRoot, 'bun.lockb')) ||
+			existsSync(join(projectRoot, 'bun.lock'))
+		) {
+			result.packageManager = 'bun';
+		} else if (existsSync(join(projectRoot, 'yarn.lock'))) {
+			result.packageManager = 'yarn';
+		} else if (existsSync(join(projectRoot, 'pnpm-lock.yaml'))) {
+			result.packageManager = 'pnpm';
+		} else if (existsSync(join(projectRoot, 'package-lock.json'))) {
+			result.packageManager = 'npm';
+		}
+	}
+
+	if (existsSync(join(projectRoot, 'package.json'))) {
+		result.runtime = result.packageManager === 'bun' ? 'bun' : 'node';
+	} else if (existsSync(join(projectRoot, 'Cargo.toml'))) {
+		result.language = 'rust';
+	} else if (existsSync(join(projectRoot, 'go.mod'))) {
+		result.language = 'go';
+	} else if (
+		existsSync(join(projectRoot, 'pyproject.toml')) ||
+		existsSync(join(projectRoot, 'requirements.txt'))
+	) {
+		result.language = 'python';
+	} else if (existsSync(join(projectRoot, 'Gemfile'))) {
+		result.language = 'ruby';
+	}
+
+	return result;
+}
+
+export async function getEnvironmentContext(
+	projectRoot: string,
+): Promise<string> {
+	const parts: string[] = [];
+
+	parts.push(
+		'Here is some useful information about the environment you are running in:',
+	);
+	parts.push('<env>');
+	parts.push(`  Working directory: ${projectRoot}`);
+
+	try {
+		const { existsSync } = await import('node:fs');
+		const isGitRepo = existsSync(`${projectRoot}/.git`);
+		parts.push(`  Is directory a git repo: ${isGitRepo ? 'yes' : 'no'}`);
+	} catch {
+		parts.push('  Is directory a git repo: unknown');
+	}
+
+	parts.push(`  Platform: ${process.platform}`);
+	parts.push(`  Today's date: ${new Date().toDateString()}`);
+
+	try {
+		const tooling = await detectProjectTooling(projectRoot);
+		if (tooling.packageManager) {
+			parts.push(
+				`  Package manager: ${tooling.packageManager} (ALWAYS use this for install/run/build commands)`,
+			);
+		}
+		if (tooling.runtime) {
+			parts.push(`  Runtime: ${tooling.runtime}`);
+		}
+		if (tooling.language) {
+			parts.push(`  Primary language: ${tooling.language}`);
+		}
+	} catch {}
+
+	parts.push('</env>');
+
+	return parts.join('\n');
+}
+
+export async function getProjectTree(projectRoot: string): Promise<string> {
+	try {
+		const { promisify } = await import('node:util');
+		const { exec } = await import('node:child_process');
+		const execAsync = promisify(exec);
+
+		const { stdout } = await execAsync(
+			'git ls-files 2>/dev/null || find . -type f -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/dist/*" 2>/dev/null | head -100',
+			{ cwd: projectRoot, maxBuffer: 1024 * 1024 },
+		);
+
+		if (!stdout.trim()) return '';
+
+		const files = stdout.trim().split('\n').slice(0, 100);
+		return `<project>\n${files.join('\n')}\n</project>`;
+	} catch {
+		return '';
+	}
+}
+
+export async function findInstructionFiles(
+	projectRoot: string,
+): Promise<string[]> {
+	const { existsSync } = await import('node:fs');
+	const { join } = await import('node:path');
+	const foundPaths: string[] = [];
+
+	const localFiles = ['AGENTS.md', 'CLAUDE.md', 'CONTEXT.md'];
+	for (const filename of localFiles) {
+		let currentDir = projectRoot;
+		for (let i = 0; i < 5; i++) {
+			const filePath = join(currentDir, filename);
+			if (existsSync(filePath)) {
+				foundPaths.push(filePath);
+				break;
+			}
+			const parentDir = join(currentDir, '..');
+			if (parentDir === currentDir) break;
+			currentDir = parentDir;
+		}
+	}
+
+	const homeDir = getHomeDir();
+	const globalFiles = [
+		join(homeDir, '.config', 'otto', 'AGENTS.md'),
+		join(homeDir, '.claude', 'CLAUDE.md'),
+	];
+
+	for (const filePath of globalFiles) {
+		if (existsSync(filePath) && !foundPaths.includes(filePath)) {
+			foundPaths.push(filePath);
+		}
+	}
+
+	return foundPaths;
+}
+
+export async function loadInstructionFiles(
+	projectRoot: string,
+): Promise<string> {
+	const paths = await findInstructionFiles(projectRoot);
+	if (paths.length === 0) return '';
+
+	const contents: string[] = [];
+
+	for (const path of paths) {
+		try {
+			const file = Bun.file(path);
+			const content = await file.text();
+			if (content.trim()) {
+				contents.push(
+					`\n--- Custom Instructions from ${path} ---\n${content.trim()}`,
+				);
+			}
+		} catch {}
+	}
+
+	return contents.join('\n');
+}
+
+export async function composeEnvironmentAndInstructions(
+	projectRoot: string,
+	options?: { includeProjectTree?: boolean },
+): Promise<string> {
+	const parts: string[] = [];
+
+	const envContext = await getEnvironmentContext(projectRoot);
+	parts.push(envContext);
+
+	if (options?.includeProjectTree !== false) {
+		const projectTree = await getProjectTree(projectRoot);
+		if (projectTree) {
+			parts.push(projectTree);
+		}
+	}
+
+	const customInstructions = await loadInstructionFiles(projectRoot);
+	if (customInstructions) {
+		parts.push(customInstructions);
+	}
+
+	return parts.filter(Boolean).join('\n\n');
+}

package/src/runtime/debug/index.ts

@@ -0,0 +1,117 @@
+/**
+ * Legacy debug utilities - now integrated with new logger
+ *
+ * This file maintains backward compatibility while using the new
+ * centralized debug-state and logger modules.
+ */
+
+import { isDebugEnabled as isDebugEnabledNew } from './state.ts';
+import { time as timeNew, debug as debugNew } from '@ottocode/sdk';
+
+const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
+
+const SYNONYMS: Record<string, string> = {
+	debug: 'log',
+	logs: 'log',
+	logging: 'log',
+	trace: 'log',
+	verbose: 'log',
+	log: 'log',
+	time: 'timing',
+	timing: 'timing',
+	timings: 'timing',
+	perf: 'timing',
+};
+
+type DebugConfig = { flags: Set<string> };
+
+let cachedConfig: DebugConfig | null = null;
+
+function isTruthy(raw: string | undefined): boolean {
+	if (!raw) return false;
+	const trimmed = raw.trim().toLowerCase();
+	if (!trimmed) return false;
+	return TRUTHY.has(trimmed) || trimmed === 'all';
+}
+
+function normalizeToken(token: string): string {
+	const trimmed = token.trim().toLowerCase();
+	if (!trimmed) return '';
+	if (TRUTHY.has(trimmed) || trimmed === 'all') return 'all';
+	return SYNONYMS[trimmed] ?? trimmed;
+}
+
+function parseDebugConfig(): DebugConfig {
+	const flags = new Set<string>();
+	const sources = [process.env.OTTO_DEBUG, process.env.DEBUG_OTTO];
+	let sawValue = false;
+	for (const raw of sources) {
+		if (typeof raw !== 'string') continue;
+		const trimmed = raw.trim();
+		if (!trimmed) continue;
+		sawValue = true;
+		const tokens = trimmed.split(/[\s,]+/);
+		let matched = false;
+		for (const token of tokens) {
+			const normalized = normalizeToken(token);
+			if (!normalized) continue;
+			matched = true;
+			flags.add(normalized);
+		}
+		if (!matched && isTruthy(trimmed)) flags.add('all');
+	}
+	if (isTruthy(process.env.OTTO_DEBUG_TIMING)) flags.add('timing');
+	if (!flags.size && sawValue) flags.add('all');
+	return { flags };
+}
+
+function getDebugConfig(): DebugConfig {
+	if (!cachedConfig) cachedConfig = parseDebugConfig();
+	return cachedConfig;
+}
+
+/**
+ * Check if debug mode is enabled for a specific flag
+ * Now uses the centralized debug state
+ *
+ * @deprecated Use isDebugEnabled from debug-state.ts instead
+ */
+export function isDebugEnabled(flag?: string): boolean {
+	// Use new centralized debug state for general debug
+	if (!flag || flag === 'log') {
+		return isDebugEnabledNew();
+	}
+
+	// For specific flags like 'timing', check both new state and legacy env vars
+	if (flag === 'timing') {
+		// If new debug state is enabled OR timing flag is set
+		if (isDebugEnabledNew()) return true;
+	}
+
+	// Legacy flag checking
+	const config = getDebugConfig();
+	if (config.flags.has('all')) return true;
+	if (flag) return config.flags.has(flag);
+	return config.flags.has('log');
+}
+
+/**
+ * Log debug message
+ * Now uses the centralized logger
+ *
+ * @deprecated Use logger.debug from logger.ts instead
+ */
+export function debugLog(...args: unknown[]) {
+	if (!isDebugEnabled('log')) return;
+	debugNew(args.map((arg) => String(arg)).join(' '));
+}
+
+/**
+ * Create a timer for performance measurement
+ * Integrated with centralized logger
+ */
+export function time(label: string): {
+	end(meta?: Record<string, unknown>): void;
+} {
+	return timeNew(label);
+}