@gajae-code/coding-agent 0.6.4 → 0.7.0

package/src/main.ts

@@ -47,6 +47,7 @@ import {
 import type { AgentSession } from "./session/agent-session";
 import type { AuthStorage } from "./session/auth-storage";
 import { resolveResumableSession, type SessionInfo, SessionManager } from "./session/session-manager";
+import { runStartupCredentialAutoImportIfNeeded } from "./setup/credential-auto-import";
 import { formatModelOnboardingGuidance } from "./setup/model-onboarding-guidance";
 import { executeBuiltinSlashCommand } from "./slash-commands/builtin-registry";
 import { resolvePromptInput } from "./system-prompt";
@@ -856,6 +857,14 @@ export async function runRootCommand(
 		settingsInstance.get("theme.light"),
 	);
 
+	const credentialAutoImportNotice = isInteractive
+		? await logger.time("credentialAutoImport", runStartupCredentialAutoImportIfNeeded, {
+				authStorage,
+				modelRegistry,
+				agentDir: settingsInstance.getAgentDir(),
+			})
+		: undefined;
+
 	let scopedModels: ScopedModel[] = [];
 	const modelPatterns = parsedArgs.models ?? settingsInstance.get("enabledModels");
 	const modelMatchPreferences = {
@@ -895,6 +904,24 @@ export async function runRootCommand(
 		sessionManager = await SessionManager.open(selectedPath);
 	}
 
+	// Restore the resumed session's working directory so the HUD branch, the
+	// project path, and the agent's tools all match where the session was
+	// created. A `--worktree` session lives in a linked worktree whose path
+	// differs from where `--continue`/`--resume` is invoked, which would
+	// otherwise leave the HUD pinned to the main checkout's branch.
+	if (sessionManager && !parsedArgs.cwd) {
+		const sessionCwd = sessionManager.getCwd();
+		if (sessionCwd && normalizePathForComparison(sessionCwd) !== normalizePathForComparison(getProjectDir())) {
+			try {
+				if ((await fs.stat(sessionCwd)).isDirectory()) {
+					setProjectDir(sessionCwd);
+				}
+			} catch {
+				// Session cwd no longer exists (e.g. worktree removed); keep current dir.
+			}
+		}
+	}
+
 	const { options: sessionOptions } = await logger.time(
 		"buildSessionOptions",
 		buildSessionOptions,
@@ -976,6 +1003,9 @@ export async function runRootCommand(
 		if (modelRegistryError) {
 			notifs.push({ kind: "error", message: modelRegistryError.message });
 		}
+		if (credentialAutoImportNotice) {
+			notifs.push({ kind: "info", message: credentialAutoImportNotice });
+		}
 
 		if (isInteractive && !session.model && !modelFallbackMessage) {
 			notifs.push({

package/src/migrate/action-planner.ts

@@ -0,0 +1,318 @@
+/**
+ * Central migration action planner.
+ *
+ * Reads destination state ONCE and produces an immutable list of actions that
+ * both dry-run and live execution consume unchanged. This is the single place
+ * that decides add/update/skip/fail, destinations, and warnings, guaranteeing
+ * dry-run/live parity.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isEnoent, parseFrontmatter } from "@gajae-code/utils";
+import { readMCPConfigFile, validateServerName } from "../runtime-mcp/config-writer";
+import { mapMcpEntry } from "./mcp-mapper";
+import { slugify } from "./skill-normalizer";
+import type { AdapterResult, MigrateAction, MigrateDestinations, MigrateWarning } from "./types";
+
+export interface PlanInput {
+	results: AdapterResult[];
+	destinations: MigrateDestinations;
+	force: boolean;
+}
+
+export interface PlanOutput {
+	actions: MigrateAction[];
+	warnings: MigrateWarning[];
+}
+
+interface DestSkillIndex {
+	/** slug -> kind of existing destination entry. */
+	slugs: Map<string, "dir-with-skill" | "stale-dir" | "occupied">;
+	/** effective loaded name -> owning slug. */
+	effectiveNames: Map<string, string>;
+	/** The skills root exists but is unsafe to write through. */
+	rootUnsafe?: boolean;
+}
+
+async function indexDestinationSkills(skillsDir: string): Promise<DestSkillIndex> {
+	const index: DestSkillIndex = { slugs: new Map(), effectiveNames: new Map() };
+	let rootStat: Awaited<ReturnType<typeof fs.lstat>>;
+	try {
+		rootStat = await fs.lstat(skillsDir);
+	} catch (error) {
+		if (isEnoent(error)) return index;
+		throw error;
+	}
+	if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) return { ...index, rootUnsafe: true };
+	const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+	for (const entry of entries) {
+		const name = String(entry.name);
+		if (!entry.isDirectory() || entry.isSymbolicLink()) {
+			index.slugs.set(name, "occupied");
+			continue;
+		}
+		const slug = name;
+		const skillFile = path.join(skillsDir, slug, "SKILL.md");
+		let content: string | undefined;
+		try {
+			const skillFileStat = await fs.lstat(skillFile);
+			if (!skillFileStat.isFile() || skillFileStat.isSymbolicLink()) {
+				index.slugs.set(slug, "occupied");
+				continue;
+			}
+			content = await fs.readFile(skillFile, "utf-8");
+		} catch (error) {
+			if (isEnoent(error)) {
+				index.slugs.set(slug, "stale-dir");
+				continue;
+			}
+			throw error;
+		}
+		index.slugs.set(slug, "dir-with-skill");
+		const { frontmatter } = parseFrontmatter(content, { level: "off" });
+		const effective =
+			typeof frontmatter.name === "string" && frontmatter.name.trim() ? slugify(frontmatter.name) : slug;
+		index.effectiveNames.set(effective, slug);
+	}
+	return index;
+}
+
+export async function planMigration(input: PlanInput): Promise<PlanOutput> {
+	const actions: MigrateAction[] = [];
+	const warnings: MigrateWarning[] = [];
+
+	// 1. Source-level diagnostics become `source`-typed actions.
+	for (const result of input.results) {
+		for (const diag of result.diagnostics) {
+			actions.push({
+				source: diag.source,
+				type: "source",
+				operation: diag.status.startsWith("failed") ? "fail" : "skip",
+				status: diag.status,
+				reason: diag.message,
+			});
+		}
+	}
+
+	// 2. MCP actions — read the destination config once.
+	const existingConfig = await readMCPConfigFile(input.destinations.mcpConfigPath).catch(() => null);
+	const mcpInvalid = existingConfig === null;
+	const existingServers = new Set(Object.keys(existingConfig?.mcpServers ?? {}));
+	const disabledServers = new Set(existingConfig?.disabledServers ?? []);
+
+	for (const result of input.results) {
+		for (const candidate of result.mcpCandidates) {
+			const nameError = validateServerName(candidate.name);
+			if (nameError) {
+				actions.push({
+					source: candidate.source,
+					type: "mcp",
+					name: candidate.name,
+					operation: "fail",
+					status: "failed_invalid_source",
+					reason: nameError,
+				});
+				continue;
+			}
+			const mapped = mapMcpEntry(candidate.source, candidate.name, candidate.raw);
+			if (!mapped.ok) {
+				actions.push({
+					source: candidate.source,
+					type: "mcp",
+					name: candidate.name,
+					operation: mapped.status.startsWith("failed") ? "fail" : "skip",
+					status: mapped.status,
+					reason: mapped.reason,
+				});
+				continue;
+			}
+			for (const w of mapped.warnings)
+				warnings.push({ source: candidate.source, type: "mcp", name: candidate.name, message: w });
+
+			if (mcpInvalid) {
+				actions.push({
+					source: candidate.source,
+					type: "mcp",
+					name: candidate.name,
+					destination: input.destinations.mcpConfigPath,
+					operation: "fail",
+					status: "failed_invalid_destination",
+					reason: "destination mcp.json is malformed",
+				});
+				continue;
+			}
+
+			const exists = existingServers.has(candidate.name);
+			if (exists && !input.force) {
+				actions.push({
+					source: candidate.source,
+					type: "mcp",
+					name: candidate.name,
+					destination: input.destinations.mcpConfigPath,
+					operation: "skip",
+					status: "skipped_exists",
+				});
+				continue;
+			}
+			const actionWarnings = [...mapped.warnings];
+			if (exists && disabledServers.has(candidate.name)) {
+				const msg = `disabled MCP state preserved for "${candidate.name}"`;
+				actionWarnings.push(msg);
+				warnings.push({ source: candidate.source, type: "mcp", name: candidate.name, message: msg });
+			}
+			actions.push({
+				source: candidate.source,
+				type: "mcp",
+				name: candidate.name,
+				destination: input.destinations.mcpConfigPath,
+				operation: exists ? "update" : "create",
+				status: exists ? "updated" : "imported",
+				warnings: actionWarnings.length > 0 ? actionWarnings : undefined,
+				mcp: { config: mapped.config, force: input.force },
+			});
+			// Track so an intra-run duplicate of the same name doesn't double-write.
+			existingServers.add(candidate.name);
+		}
+	}
+
+	// 3. Skill actions — index the destination skills tree once.
+	const destIndex = await indexDestinationSkills(input.destinations.skillsDir);
+	const plannedSlugs = new Map<string, string>(); // slug -> source (intra-run)
+	const plannedEffective = new Map<string, string>(); // effective -> slug (intra-run)
+
+	for (const result of input.results) {
+		for (const candidate of result.skillCandidates) {
+			for (const w of candidate.warnings) {
+				warnings.push({ source: candidate.source, type: "skill", name: candidate.slug, message: w });
+			}
+			const slug = candidate.slug;
+			const destination = path.join(input.destinations.skillsDir, slug, "SKILL.md");
+			const base = {
+				source: candidate.source,
+				type: "skill" as const,
+				name: slug,
+				effectiveName: slug,
+				destination,
+			};
+
+			// Intra-run duplicate slug / effective name. Since effective name == slug, a
+			// duplicate always targets the same destination: skip by default; with --force
+			// the later (canonical-order) source overwrites the same destination.
+			if (plannedSlugs.has(slug) || plannedEffective.has(slug)) {
+				if (input.force) {
+					actions.push({
+						...base,
+						operation: "update",
+						status: "updated",
+						reason: "duplicate within this run (overwritten under --force)",
+						skill: { content: candidate.content },
+					});
+				} else {
+					actions.push({
+						...base,
+						operation: "skip",
+						status: "skipped_exists",
+						reason: "duplicate within this run",
+					});
+				}
+				continue;
+			}
+
+			const existingKind = destIndex.slugs.get(slug);
+			const effectiveOwner = destIndex.effectiveNames.get(slug);
+
+			if (destIndex.rootUnsafe) {
+				if (!input.force) {
+					actions.push({
+						...base,
+						operation: "skip",
+						status: "skipped_exists",
+						reason: "skills destination root is not a real directory",
+					});
+				} else {
+					actions.push({
+						...base,
+						operation: "fail",
+						status: "failed_invalid_destination",
+						reason: "skills destination root is not a real directory; refusing to write",
+					});
+				}
+				continue;
+			}
+
+			// Effective-name collision with a different existing destination skill.
+			if (effectiveOwner && effectiveOwner !== slug) {
+				if (!input.force) {
+					actions.push({
+						...base,
+						operation: "skip",
+						status: "skipped_exists",
+						reason: `effective name collides with "${effectiveOwner}"`,
+					});
+				} else {
+					actions.push({
+						...base,
+						operation: "fail",
+						status: "failed_invalid_destination",
+						reason: `effective name collides with "${effectiveOwner}"`,
+					});
+				}
+				continue;
+			}
+
+			if (existingKind === "occupied") {
+				if (!input.force) {
+					actions.push({
+						...base,
+						operation: "skip",
+						status: "skipped_exists",
+						reason: "a non-directory or unsafe file occupies the destination path",
+					});
+				} else {
+					actions.push({
+						...base,
+						operation: "fail",
+						status: "failed_invalid_destination",
+						reason: "a non-directory or unsafe file occupies the destination path; refusing to delete",
+					});
+				}
+				continue;
+			}
+
+			if (existingKind === "dir-with-skill") {
+				if (!input.force) {
+					actions.push({ ...base, operation: "skip", status: "skipped_exists" });
+				} else {
+					actions.push({ ...base, operation: "update", status: "updated", skill: { content: candidate.content } });
+				}
+				plannedSlugs.set(slug, candidate.source);
+				plannedEffective.set(slug, slug);
+				continue;
+			}
+
+			if (existingKind === "stale-dir") {
+				if (!input.force) {
+					actions.push({ ...base, operation: "skip", status: "skipped_exists", reason: "stale skill directory" });
+				} else {
+					actions.push({
+						...base,
+						operation: "update",
+						status: "updated",
+						reason: "stale skill directory reused",
+						skill: { content: candidate.content },
+					});
+				}
+				plannedSlugs.set(slug, candidate.source);
+				plannedEffective.set(slug, slug);
+				continue;
+			}
+
+			// Fresh import.
+			actions.push({ ...base, operation: "create", status: "imported", skill: { content: candidate.content } });
+			plannedSlugs.set(slug, candidate.source);
+			plannedEffective.set(slug, slug);
+		}
+	}
+
+	return { actions, warnings };
+}

package/src/migrate/adapters/claude-code.ts

@@ -0,0 +1,39 @@
+/**
+ * Claude Code adapter: reads `~/.claude.json` (mcpServers) and `~/.claude/skills`.
+ */
+import * as path from "node:path";
+import type { AdapterResult, McpCandidate } from "../types";
+import { type Adapter, type AdapterOptions, collectSkillDir, parseSourceJson, readSourceText } from "./index";
+
+const SOURCE = "claude-code" as const;
+
+export const claudeCodeAdapter: Adapter = {
+	source: SOURCE,
+	async collect({ homeDir }: AdapterOptions): Promise<AdapterResult> {
+		const result: AdapterResult = { mcpCandidates: [], skillCandidates: [], diagnostics: [] };
+
+		const configPath = path.join(homeDir, ".claude.json");
+		const read = await readSourceText(configPath, SOURCE, "mcp");
+		if ("diagnostic" in read) {
+			result.diagnostics.push(read.diagnostic);
+		} else {
+			const parsed = parseSourceJson(read.text, configPath, SOURCE, "mcp");
+			if ("diagnostic" in parsed) {
+				result.diagnostics.push(parsed.diagnostic);
+			} else {
+				const servers = parsed.data.mcpServers;
+				if (servers && typeof servers === "object" && !Array.isArray(servers)) {
+					for (const [name, raw] of Object.entries(servers as Record<string, unknown>)) {
+						result.mcpCandidates.push({ source: SOURCE, name, raw } satisfies McpCandidate);
+					}
+				}
+			}
+		}
+
+		const skills = await collectSkillDir(path.join(homeDir, ".claude", "skills"), SOURCE);
+		result.skillCandidates.push(...skills.candidates);
+		result.diagnostics.push(...skills.diagnostics);
+
+		return result;
+	},
+};

package/src/migrate/adapters/codex.ts

@@ -0,0 +1,70 @@
+/**
+ * Codex adapter: reads `~/.codex/config.toml` ([mcp_servers]) and `~/.codex/prompts`.
+ */
+
+import * as path from "node:path";
+import { TOML } from "bun";
+import type { AdapterResult, McpCandidate, SourceDiagnostic } from "../types";
+import { type Adapter, type AdapterOptions, collectMarkdownPrompts, readSourceText } from "./index";
+
+const SOURCE = "codex" as const;
+
+function parseToml(
+	text: string,
+	filePath: string,
+): { data: Record<string, unknown> } | { diagnostic: SourceDiagnostic } {
+	try {
+		const data = TOML.parse(text) as unknown;
+		if (typeof data !== "object" || data === null) {
+			return {
+				diagnostic: {
+					source: SOURCE,
+					type: "mcp",
+					status: "failed_invalid_source",
+					message: `${filePath} is not a TOML table`,
+				},
+			};
+		}
+		return { data: data as Record<string, unknown> };
+	} catch (error) {
+		return {
+			diagnostic: {
+				source: SOURCE,
+				type: "mcp",
+				status: "failed_invalid_source",
+				message: `invalid TOML in ${filePath}: ${(error as Error).message}`,
+			},
+		};
+	}
+}
+
+export const codexAdapter: Adapter = {
+	source: SOURCE,
+	async collect({ homeDir }: AdapterOptions): Promise<AdapterResult> {
+		const result: AdapterResult = { mcpCandidates: [], skillCandidates: [], diagnostics: [] };
+
+		const configPath = path.join(homeDir, ".codex", "config.toml");
+		const read = await readSourceText(configPath, SOURCE, "mcp");
+		if ("diagnostic" in read) {
+			result.diagnostics.push(read.diagnostic);
+		} else {
+			const parsed = parseToml(read.text, configPath);
+			if ("diagnostic" in parsed) {
+				result.diagnostics.push(parsed.diagnostic);
+			} else {
+				const servers = parsed.data.mcp_servers;
+				if (servers && typeof servers === "object" && !Array.isArray(servers)) {
+					for (const [name, raw] of Object.entries(servers as Record<string, unknown>)) {
+						result.mcpCandidates.push({ source: SOURCE, name, raw } satisfies McpCandidate);
+					}
+				}
+			}
+		}
+
+		const prompts = await collectMarkdownPrompts(path.join(homeDir, ".codex", "prompts"), SOURCE);
+		result.skillCandidates.push(...prompts.candidates);
+		result.diagnostics.push(...prompts.diagnostics);
+
+		return result;
+	},
+};