@gajae-code/coding-agent 0.1.2 → 0.2.0

package/src/skill-state/active-state.ts

@@ -7,6 +7,23 @@ export const SKILL_ACTIVE_STALE_MS = 24 * 60 * 60 * 1000;
 export const CANONICAL_GJC_WORKFLOW_SKILLS = ["deep-interview", "ralplan", "ultragoal", "team"] as const;
 
 export type CanonicalGjcWorkflowSkill = (typeof CANONICAL_GJC_WORKFLOW_SKILLS)[number];
+export type WorkflowHudSeverity = "info" | "warning" | "blocked" | "error" | "success";
+
+export interface WorkflowHudChip {
+	label: string;
+	value?: string;
+	priority?: number;
+	severity?: WorkflowHudSeverity;
+}
+
+export interface WorkflowHudSummary {
+	version: 1;
+	summary?: string;
+	chips?: WorkflowHudChip[];
+	details?: WorkflowHudChip[];
+	severity?: WorkflowHudSeverity;
+	updated_at?: string;
+}
 
 export interface SkillActiveEntry {
 	skill: string;
@@ -17,6 +34,8 @@ export interface SkillActiveEntry {
 	session_id?: string;
 	thread_id?: string;
 	turn_id?: string;
+	hud?: WorkflowHudSummary;
+	stale?: boolean;
 }
 
 export interface SkillActiveState {
@@ -50,12 +69,79 @@ export interface SyncSkillActiveStateOptions {
 	turnId?: string;
 	nowIso?: string;
 	source?: string;
+	hud?: WorkflowHudSummary;
 }
 
+const HUD_TEXT_LIMIT = 80;
+const HUD_CHIP_LIMIT = 6;
+const HUD_DETAIL_LIMIT = 12;
+const ANSI_PATTERN = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+const HUD_SEVERITIES = new Set<WorkflowHudSeverity>(["info", "warning", "blocked", "error", "success"]);
+
 function safeString(value: unknown): string {
 	return typeof value === "string" ? value : "";
 }
 
+function sanitizeHudString(value: unknown, limit = HUD_TEXT_LIMIT): string | undefined {
+	const normalized = safeString(value)
+		.replace(ANSI_PATTERN, "")
+		.replace(/[\r\n\t]+/g, " ")
+		.trim();
+	if (!normalized) return undefined;
+	return normalized.length > limit ? normalized.slice(0, limit) : normalized;
+}
+
+function normalizeSeverity(value: unknown): WorkflowHudSeverity | undefined {
+	return typeof value === "string" && HUD_SEVERITIES.has(value as WorkflowHudSeverity)
+		? (value as WorkflowHudSeverity)
+		: undefined;
+}
+
+function normalizeHudChip(raw: unknown): WorkflowHudChip | null {
+	if (!raw || typeof raw !== "object") return null;
+	const record = raw as Record<string, unknown>;
+	const label = sanitizeHudString(record.label, 32);
+	if (!label) return null;
+	const value = sanitizeHudString(record.value, HUD_TEXT_LIMIT);
+	const priority =
+		typeof record.priority === "number" && Number.isFinite(record.priority) ? record.priority : undefined;
+	const severity = normalizeSeverity(record.severity);
+	return {
+		label,
+		...(value ? { value } : {}),
+		...(priority !== undefined ? { priority } : {}),
+		...(severity ? { severity } : {}),
+	};
+}
+
+function normalizeHudChips(raw: unknown, limit: number): WorkflowHudChip[] | undefined {
+	if (!Array.isArray(raw)) return undefined;
+	const chips = raw
+		.map(normalizeHudChip)
+		.filter((chip): chip is WorkflowHudChip => chip !== null)
+		.slice(0, limit);
+	return chips.length > 0 ? chips : undefined;
+}
+
+export function normalizeWorkflowHudSummary(raw: unknown): WorkflowHudSummary | undefined {
+	if (!raw || typeof raw !== "object") return undefined;
+	const record = raw as Record<string, unknown>;
+	if (record.version !== 1) return undefined;
+	const summary = sanitizeHudString(record.summary);
+	const chips = normalizeHudChips(record.chips, HUD_CHIP_LIMIT);
+	const details = normalizeHudChips(record.details, HUD_DETAIL_LIMIT);
+	const severity = normalizeSeverity(record.severity);
+	const updatedAt = sanitizeHudString(record.updated_at, 40);
+	return {
+		version: 1,
+		...(summary ? { summary } : {}),
+		...(chips ? { chips } : {}),
+		...(details ? { details } : {}),
+		...(severity ? { severity } : {}),
+		...(updatedAt ? { updated_at: updatedAt } : {}),
+	};
+}
+
 function encodePathSegment(value: string): string {
 	return encodeURIComponent(value).replaceAll(".", "%2E");
 }
@@ -70,16 +156,25 @@ function timestampMs(value: string | undefined): number | null {
 	return Number.isFinite(ms) ? ms : null;
 }
 
+function entryTimestampMs(entry: SkillActiveEntry): number | null {
+	return timestampMs(entry.hud?.updated_at) ?? timestampMs(entry.updated_at) ?? timestampMs(entry.activated_at);
+}
+
 function isFreshEntry(entry: SkillActiveEntry, nowMs = Date.now()): boolean {
-	const ms = timestampMs(entry.updated_at) ?? timestampMs(entry.activated_at);
+	const ms = entryTimestampMs(entry);
 	return ms === null || nowMs - ms <= SKILL_ACTIVE_STALE_MS;
 }
 
+function withDerivedStale(entry: SkillActiveEntry, nowMs = Date.now()): SkillActiveEntry {
+	return { ...entry, stale: !isFreshEntry(entry, nowMs) };
+}
+
 function normalizeEntry(raw: unknown): SkillActiveEntry | null {
 	if (!raw || typeof raw !== "object") return null;
 	const record = raw as Record<string, unknown>;
 	const skill = safeString(record.skill).trim();
 	if (!skill) return null;
+	const hud = normalizeWorkflowHudSummary(record.hud);
 	return {
 		...record,
 		skill,
@@ -90,6 +185,8 @@ function normalizeEntry(raw: unknown): SkillActiveEntry | null {
 		session_id: safeString(record.session_id).trim() || undefined,
 		thread_id: safeString(record.thread_id).trim() || undefined,
 		turn_id: safeString(record.turn_id).trim() || undefined,
+		...(hud ? { hud } : {}),
+		stale: undefined,
 	};
 }
 
@@ -185,11 +282,12 @@ function mergeVisibleEntries(
 	rootState: SkillActiveState | null,
 	sessionId?: string,
 ): SkillActiveEntry[] {
-	const rootEntries = filterRootEntriesForSession(listActiveSkills(rootState), sessionId).filter(entry =>
-		isFreshEntry(entry),
+	const nowMs = Date.now();
+	const rootEntries = filterRootEntriesForSession(listActiveSkills(rootState), sessionId).map(entry =>
+		withDerivedStale(entry, nowMs),
 	);
 	const merged = new Map(rootEntries.map(entry => [entryKey(entry), entry]));
-	for (const entry of listActiveSkills(sessionState).filter(entry => isFreshEntry(entry))) {
+	for (const entry of listActiveSkills(sessionState).map(candidate => withDerivedStale(candidate, nowMs))) {
 		merged.set(entryKey(entry), entry);
 	}
 	return [...merged.values()];
@@ -229,6 +327,7 @@ function upsertEntry(entries: SkillActiveEntry[], entry: SkillActiveEntry, activ
 
 export async function syncSkillActiveState(options: SyncSkillActiveStateOptions): Promise<void> {
 	const nowIso = options.nowIso ?? new Date().toISOString();
+	const hud = normalizeWorkflowHudSummary(options.hud);
 	const entry: SkillActiveEntry = {
 		skill: options.skill,
 		phase: options.phase,
@@ -238,6 +337,7 @@ export async function syncSkillActiveState(options: SyncSkillActiveStateOptions)
 		session_id: options.sessionId,
 		thread_id: options.threadId,
 		turn_id: options.turnId,
+		...(hud ? { hud } : {}),
 	};
 	const { rootPath, sessionPath } = getSkillActiveStatePaths(options.cwd, options.sessionId);
 	const rootState = (await readStateFile(rootPath)) ?? { version: 1, active_skills: [] };

package/src/skill-state/workflow-hud.ts

@@ -0,0 +1,160 @@
+import type { WorkflowHudChip, WorkflowHudSummary } from "./active-state";
+
+interface DeepInterviewHudState {
+	phase?: string;
+	ambiguity?: number;
+	threshold?: number;
+	roundCount?: number;
+	targetComponent?: string;
+	weakestDimension?: string;
+	specStatus?: string;
+	updatedAt?: string;
+}
+
+interface RalplanHudState {
+	stage?: string;
+	waiting?: string;
+	iteration?: number;
+	verdict?: string;
+	latestSummary?: string;
+	pendingApproval?: boolean;
+	updatedAt?: string;
+}
+
+interface UltragoalLikeGoal {
+	id: string;
+	title: string;
+	status: string;
+}
+
+interface UltragoalHudState {
+	status: string;
+	currentGoal?: UltragoalLikeGoal;
+	counts: Record<string, number>;
+	goals: UltragoalLikeGoal[];
+	latestLedgerEvent?: { event?: string; goalId?: string; timestamp?: string };
+	updatedAt?: string;
+}
+
+interface TeamHudWorker {
+	id: string;
+	status?: string;
+}
+
+interface TeamHudState {
+	phase: string;
+	task_total: number;
+	task_counts: Record<string, number>;
+	workers: TeamHudWorker[];
+	updated_at?: string;
+	latestEvent?: { type?: string; worker?: string; message?: string };
+	latestMessage?: { from_worker?: string; body?: string };
+}
+
+function percent(value: number | undefined): string | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+	return `${Math.round(value * 100)}%`;
+}
+
+function chip(
+	label: string,
+	value: string | undefined,
+	priority: number,
+	severity?: WorkflowHudChip["severity"],
+): WorkflowHudChip | null {
+	if (!value) return null;
+	return { label, value, priority, ...(severity ? { severity } : {}) };
+}
+
+function compactChips(chips: Array<WorkflowHudChip | null>): WorkflowHudChip[] {
+	return chips.filter((item): item is WorkflowHudChip => item !== null);
+}
+
+export function buildDeepInterviewHudSummary(state: DeepInterviewHudState): WorkflowHudSummary {
+	return {
+		version: 1,
+		chips: compactChips([
+			chip("phase", state.phase, 10),
+			chip("ambiguity", [percent(state.ambiguity), percent(state.threshold)].filter(Boolean).join("/"), 20),
+			chip("round", state.roundCount === undefined ? undefined : String(state.roundCount), 30),
+			chip("target", state.targetComponent, 40),
+			chip("weakest", state.weakestDimension, 50),
+			chip("spec", state.specStatus, 60),
+		]),
+		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
+	};
+}
+
+export function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSummary {
+	const verdict = state.verdict?.toUpperCase();
+	const verdictSeverity =
+		verdict === "BLOCK"
+			? "blocked"
+			: verdict === "ITERATE" || verdict === "WATCH"
+				? "warning"
+				: verdict === "APPROVE" || verdict === "CLEAR"
+					? "success"
+					: undefined;
+	return {
+		version: 1,
+		summary: state.latestSummary,
+		chips: compactChips([
+			state.pendingApproval ? { label: "pending", value: "approval", priority: 5, severity: "warning" } : null,
+			chip("stage", state.stage, 10),
+			chip("waiting", state.waiting, 20),
+			chip("iter", state.iteration === undefined ? undefined : String(state.iteration), 30),
+			chip("verdict", verdict, 40, verdictSeverity),
+		]),
+		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
+	};
+}
+
+export function buildUltragoalHudSummary(state: UltragoalHudState): WorkflowHudSummary {
+	const total = state.goals.length;
+	const complete = state.counts.complete ?? 0;
+	const blockers = (state.counts.blocked ?? 0) + (state.counts.review_blocked ?? 0) + (state.counts.failed ?? 0);
+	return {
+		version: 1,
+		chips: compactChips([
+			blockers > 0 ? { label: "blocked", value: String(blockers), priority: 5, severity: "blocked" } : null,
+			chip("goals", `${complete}/${total}`, 10),
+			chip("current", state.currentGoal ? `${state.currentGoal.id}:${state.currentGoal.title}` : state.status, 20),
+			chip("status", state.status, 30, state.status === "complete" ? "success" : undefined),
+		]),
+		details: state.latestLedgerEvent
+			? compactChips([
+					chip(
+						"ledger",
+						[state.latestLedgerEvent.event, state.latestLedgerEvent.goalId].filter(Boolean).join(":"),
+						100,
+					),
+				])
+			: undefined,
+		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
+	};
+}
+
+export function buildTeamHudSummary(state: TeamHudState): WorkflowHudSummary {
+	const failedWorkers = state.workers.filter(
+		worker => worker.status === "failed" || worker.status === "blocked",
+	).length;
+	const stoppedWorkers = state.workers.filter(worker => worker.status === "stopped").length;
+	const completed = state.task_counts.completed ?? 0;
+	const failedTasks = (state.task_counts.failed ?? 0) + (state.task_counts.blocked ?? 0);
+	const latest = state.latestEvent?.message ?? state.latestEvent?.type ?? state.latestMessage?.body;
+	return {
+		version: 1,
+		chips: compactChips([
+			failedWorkers > 0 || failedTasks > 0
+				? { label: "blocked", value: String(failedWorkers + failedTasks), priority: 5, severity: "blocked" }
+				: stoppedWorkers > 0
+					? { label: "stopped", value: String(stoppedWorkers), priority: 5, severity: "warning" }
+					: null,
+			chip("phase", state.phase, 10),
+			chip("workers", `${state.workers.length - failedWorkers}/${state.workers.length}`, 20),
+			chip("tasks", `${completed}/${state.task_total}`, 30),
+			chip("latest", latest, 50),
+		]),
+		...(state.updated_at ? { updated_at: state.updated_at } : {}),
+	};
+}

package/src/tools/image-gen.ts

@@ -44,6 +44,7 @@ interface ImageApiKey {
 	apiKey: string;
 	projectId?: string;
 	model?: Model;
+	authCredentialType?: "api_key" | "oauth";
 }
 
 const responseModalitySchema = z.enum(["IMAGE", "TEXT"] as const);
@@ -441,6 +442,7 @@ async function findOpenAIHostedImageCredentials(
 		provider: getOpenAIHostedImageProvider(activeModel),
 		apiKey,
 		model: activeModel,
+		authCredentialType: modelRegistry.getSessionCredentialType?.(activeModel.provider, sessionId),
 	};
 }
 
@@ -700,16 +702,21 @@ function getOpenAIResponseErrorMessage(rawText: string): string {
 	}
 }
 
-function getOpenAIBaseUrl(model: Model): string {
-	const fallback =
-		model.api === "openai-codex-responses" || model.provider === "openai-codex"
-			? CODEX_BASE_URL
-			: DEFAULT_OPENAI_BASE_URL;
-	return (model.baseUrl || fallback).replace(/\/+$/, "");
+function getOpenAIBaseUrl(model: Model, authCredentialType?: "api_key" | "oauth"): string {
+	if (model.api === "openai-codex-responses" || model.provider === "openai-codex") {
+		return (model.baseUrl || CODEX_BASE_URL).replace(/\/+$/, "");
+	}
+	if (authCredentialType === "oauth") return DEFAULT_OPENAI_BASE_URL;
+	const envBaseUrl = $env.OPENAI_BASE_URL?.trim();
+	const configuredBaseUrl = model.baseUrl?.trim();
+	if (envBaseUrl && (!configuredBaseUrl || configuredBaseUrl.toLowerCase().includes("api.openai.com"))) {
+		return envBaseUrl.replace(/\/+$/, "");
+	}
+	return (configuredBaseUrl || envBaseUrl || DEFAULT_OPENAI_BASE_URL).replace(/\/+$/, "");
 }
 
-function getOpenAIResponsesUrl(model: Model): string {
-	const baseUrl = getOpenAIBaseUrl(model);
+function getOpenAIResponsesUrl(model: Model, authCredentialType?: "api_key" | "oauth"): string {
+	const baseUrl = getOpenAIBaseUrl(model, authCredentialType);
 	if (model.api !== "openai-codex-responses" && model.provider !== "openai-codex") {
 		return `${baseUrl}/responses`;
 	}
@@ -782,11 +789,12 @@ async function generateOpenAIHostedImage(
 	inputImages: InlineImageData[],
 	signal: AbortSignal | undefined,
 	sessionId: string | undefined,
+	options?: { authCredentialType?: "api_key" | "oauth" },
 ): Promise<OpenAIHostedImageResult> {
 	const promptText = assemblePrompt(params);
 	const stream = model.api === "openai-codex-responses" || model.provider === "openai-codex";
 	const requestBody = buildOpenAIHostedImageRequest(model, promptText, params, inputImages, stream);
-	const response = await fetch(getOpenAIResponsesUrl(model), {
+	const response = await fetch(getOpenAIResponsesUrl(model, options?.authCredentialType), {
 		method: "POST",
 		headers: buildOpenAIImageHeaders(model, apiKey, sessionId),
 		body: JSON.stringify(requestBody),
@@ -946,6 +954,7 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 					resolvedImages,
 					requestSignal,
 					sessionId,
+					{ authCredentialType: apiKey.authCredentialType },
 				);
 
 				if (parsed.images.length === 0) {
@@ -1075,7 +1084,7 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 					headers: {
 						"Content-Type": "application/json",
 						Authorization: `Bearer ${apiKey.apiKey}`,
-						"HTTP-Referer": "https://gajae-code.dev/",
+						"HTTP-Referer": "https://gaebal-gajae.dev/",
 						"X-OpenRouter-Title": "Gajae Code",
 						"X-OpenRouter-Categories": "cli-agent",
 					},