@gajae-code/coding-agent 0.13.2 → 0.14.0

package/src/discovery/claude.ts

@@ -1,26 +1,27 @@
 /**
- * Anthropic Code project provider.
+ * Claude Code project/global skill layout adapter (import source).
  *
- * Supports project-local `.Anthropic model/` compatibility only. User-home Anthropic model
- * directories are intentionally ignored so `~/.Anthropic model` content is never injected
- * into GJC sessions.
+ * The `.claude/skills` layout is an explicit import source into the canonical
+ * `.gjc` skill locations — it is never loaded as an ordinary runtime authority.
+ * These helpers enumerate the layout for import/inspection consumers (#4291
+ * import UI, #4288 provenance diagnostics) and are deliberately NOT registered
+ * as capability providers: activating Claude's other surfaces (MCP servers,
+ * hooks, commands, tools, prompts, settings) is owned by sibling issues.
+ *
+ * User-home `~/.claude/skills` is enumerated as an explicit import candidate
+ * only; it is never loaded into sessions without an explicit import action.
  */
 import * as path from "node:path";
 import { hasFsCode, tryParseJson } from "@gajae-code/utils";
-import { registerProvider } from "../capability";
-import { type ContextFile, contextFileCapability } from "../capability/context-file";
-import { type ExtensionModule, extensionModuleCapability } from "../capability/extension-module";
+import type { ExtensionModule } from "../capability/extension-module";
 import { readFile } from "../capability/fs";
-import { type Hook, hookCapability } from "../capability/hook";
-import { type MCPServer, mcpCapability } from "../capability/mcp";
-import { type Settings, settingsCapability } from "../capability/settings";
-import { type Skill, skillCapability } from "../capability/skill";
-import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
-import { type SystemPrompt, systemPromptCapability } from "../capability/system-prompt";
-import { type CustomTool, toolCapability } from "../capability/tool";
+import type { Hook } from "../capability/hook";
+import type { MCPServer } from "../capability/mcp";
+import type { Skill } from "../capability/skill";
+import type { SlashCommand } from "../capability/slash-command";
+import type { CustomTool } from "../capability/tool";
 import type { LoadContext, LoadResult } from "../capability/types";
 import {
-	calculateDepth,
 	createSourceMeta,
 	discoverExtensionModulePaths,
 	expandEnvVarsDeep,
@@ -29,20 +30,83 @@ import {
 	scanSkillsFromDir,
 } from "./helpers";
 
-const PROVIDER_ID = "claude";
-const DISPLAY_NAME = "Claude Code";
-const PRIORITY = 80;
-const CONFIG_DIR = ".claude";
-
-function getProjectClaude(ctx: LoadContext): string {
-	return path.join(ctx.cwd, CONFIG_DIR);
-}
+export const CLAUDE_PROVIDER_ID = "claude";
+export const CLAUDE_DISPLAY_NAME = "Claude Code";
+export const CLAUDE_CONFIG_DIR = ".claude";
 
 function isMissingDirectoryError(error: unknown): boolean {
 	return hasFsCode(error, "ENOENT") || hasFsCode(error, "ENOTDIR");
 }
 
-async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
+/**
+ * Enumerate `.claude/skills` from every ancestor of `cwd` up to the repo root
+ * (closest first) — the Claude Code project convention.
+ */
+export async function scanClaudeProjectSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
+	const projectScans: Promise<LoadResult<Skill>>[] = [];
+	let current = ctx.cwd;
+	while (true) {
+		projectScans.push(
+			scanSkillsFromDir(ctx, {
+				dir: path.join(current, CLAUDE_CONFIG_DIR, "skills"),
+				providerId: CLAUDE_PROVIDER_ID,
+				level: "project",
+				requireDescription: true,
+			}),
+		);
+		if (current === (ctx.repoRoot ?? ctx.home)) break;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+
+	const results = await Promise.allSettled(projectScans);
+	const items: Skill[] = [];
+	const warnings: string[] = [];
+	for (const result of results) {
+		if (result.status === "fulfilled") {
+			items.push(...result.value.items);
+			warnings.push(...(result.value.warnings ?? []));
+		} else if (!isMissingDirectoryError(result.reason)) {
+			warnings.push(`Failed to scan Claude project skills: ${String(result.reason)}`);
+		}
+	}
+	return { items, warnings };
+}
+
+/**
+ * Enumerate the user-global `~/.claude/skills` layout. This is an explicit
+ * import candidate only; GJC never loads it without an explicit import action.
+ */
+export async function scanClaudeUserSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
+	return await scanSkillsFromDir(ctx, {
+		dir: path.join(ctx.home, CLAUDE_CONFIG_DIR, "skills"),
+		providerId: CLAUDE_PROVIDER_ID,
+		level: "user",
+		requireDescription: true,
+	});
+}
+
+export function claudeSkillSourceMeta(filePath: string, level: "user" | "project") {
+	return createSourceMeta(CLAUDE_PROVIDER_ID, filePath, level);
+}
+
+// =============================================================================
+// Provenance inspection (#4288)
+//
+// The scans below enumerate the remaining `.claude/` project surfaces (MCP
+// servers, hooks, tools, extensions, commands) for the `gjc customize doctor`
+// provenance report. They reuse the shared discovery helpers but are
+// deliberately NOT registered as capability providers: none of these surfaces
+// are part of the session load path, and inspection must not change runtime
+// behavior.
+// =============================================================================
+
+function getProjectClaude(ctx: LoadContext): string {
+	return path.join(ctx.cwd, CLAUDE_CONFIG_DIR);
+}
+
+async function inspectMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
 	const items: MCPServer[] = [];
 	const projectBase = getProjectClaude(ctx);
 	const projectPaths = [path.join(projectBase, ".mcp.json"), path.join(projectBase, "mcp.json")];
@@ -65,7 +129,7 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 				url: serverConfig.url as string | undefined,
 				headers: serverConfig.headers as Record<string, string> | undefined,
 				transport: serverConfig.type as "stdio" | "sse" | "http" | undefined,
-				_source: createSourceMeta(PROVIDER_ID, filePath, "project"),
+				_source: createSourceMeta(CLAUDE_PROVIDER_ID, filePath, "project"),
 			};
 		});
 	};
@@ -81,91 +145,14 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 	return { items, warnings: [] };
 }
 
-async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFile>> {
-	const items: ContextFile[] = [];
-	const projectBase = getProjectClaude(ctx);
-	const projectClaudeMd = path.join(projectBase, "CLAUDE.md");
-	const projectContent = await readFile(projectClaudeMd);
-	if (projectContent !== null) {
-		const depth = calculateDepth(ctx.cwd, path.dirname(projectBase), path.sep);
-		items.push({
-			path: projectClaudeMd,
-			content: projectContent,
-			level: "project",
-			depth,
-			_source: createSourceMeta(PROVIDER_ID, projectClaudeMd, "project"),
-		});
-	}
-	return { items, warnings: [] };
-}
-
-async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
-	const projectScans: Promise<LoadResult<Skill>>[] = [];
-	let current = ctx.cwd;
-	while (true) {
-		projectScans.push(
-			scanSkillsFromDir(ctx, {
-				dir: path.join(current, CONFIG_DIR, "skills"),
-				providerId: PROVIDER_ID,
-				level: "project",
-			}),
-		);
-		if (current === (ctx.repoRoot ?? ctx.home)) break;
-		const parent = path.dirname(current);
-		if (parent === current) break;
-		current = parent;
-	}
-
-	const results = await Promise.allSettled(projectScans);
-	const items: Skill[] = [];
-	const warnings: string[] = [];
-	for (const result of results) {
-		if (result.status === "fulfilled") {
-			items.push(...result.value.items);
-			warnings.push(...(result.value.warnings ?? []));
-		} else if (!isMissingDirectoryError(result.reason)) {
-			warnings.push(`Failed to scan Claude project skills: ${String(result.reason)}`);
-		}
-	}
-	return { items, warnings };
-}
-
-async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<ExtensionModule>> {
-	const projectExtensionsDir = path.join(getProjectClaude(ctx), "extensions");
-	const paths = await discoverExtensionModulePaths(ctx, projectExtensionsDir);
-	return {
-		items: paths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "project" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "project"),
-		})),
-		warnings: [],
-	};
-}
-
-async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
-	const projectCommandsDir = path.join(getProjectClaude(ctx), "commands");
-	return await loadFilesFromDir<SlashCommand>(ctx, projectCommandsDir, PROVIDER_ID, "project", {
-		extensions: ["md"],
-		transform: (name, content, filePath, source) => ({
-			name: name.replace(/\.md$/, ""),
-			path: filePath,
-			content,
-			level: "project",
-			_source: source,
-		}),
-	});
-}
-
-async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
+async function inspectHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 	const items: Hook[] = [];
 	const warnings: string[] = [];
 	const projectHooksDir = path.join(getProjectClaude(ctx), "hooks");
 	const hookTypes = ["pre", "post"] as const;
 	const results = await Promise.all(
 		hookTypes.map(hookType =>
-			loadFilesFromDir<Hook>(ctx, path.join(projectHooksDir, hookType), PROVIDER_ID, "project", {
+			loadFilesFromDir<Hook>(ctx, path.join(projectHooksDir, hookType), CLAUDE_PROVIDER_ID, "project", {
 				transform: (name, _content, filePath, source) => ({
 					name,
 					path: filePath,
@@ -184,9 +171,9 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 	return { items, warnings };
 }
 
-async function loadTools(ctx: LoadContext): Promise<LoadResult<CustomTool>> {
+async function inspectTools(ctx: LoadContext): Promise<LoadResult<CustomTool>> {
 	const projectToolsDir = path.join(getProjectClaude(ctx), "tools");
-	return await loadFilesFromDir<CustomTool>(ctx, projectToolsDir, PROVIDER_ID, "project", {
+	return await loadFilesFromDir<CustomTool>(ctx, projectToolsDir, CLAUDE_PROVIDER_ID, "project", {
 		transform: (name, _content, filePath, source) => {
 			const toolName = name.replace(/\.(ts|js|sh|bash|py)$/, "");
 			return {
@@ -200,114 +187,60 @@ async function loadTools(ctx: LoadContext): Promise<LoadResult<CustomTool>> {
 	});
 }
 
-async function loadSystemPrompts(ctx: LoadContext): Promise<LoadResult<SystemPrompt>> {
-	const projectSystemMd = path.join(getProjectClaude(ctx), "SYSTEM.md");
-	const content = await readFile(projectSystemMd);
+async function inspectExtensionModules(ctx: LoadContext): Promise<LoadResult<ExtensionModule>> {
+	const projectExtensionsDir = path.join(getProjectClaude(ctx), "extensions");
+	const paths = await discoverExtensionModulePaths(ctx, projectExtensionsDir);
 	return {
-		items:
-			content === null
-				? []
-				: [
-						{
-							path: projectSystemMd,
-							content,
-							level: "project",
-							_source: createSourceMeta(PROVIDER_ID, projectSystemMd, "project"),
-						},
-					],
+		items: paths.map(extPath => ({
+			name: getExtensionNameFromPath(extPath),
+			path: extPath,
+			level: "project" as const,
+			_source: createSourceMeta(CLAUDE_PROVIDER_ID, extPath, "project"),
+		})),
 		warnings: [],
 	};
 }
 
-async function loadSettings(ctx: LoadContext): Promise<LoadResult<Settings>> {
-	const items: Settings[] = [];
-	const warnings: string[] = [];
-	const projectSettingsJson = path.join(getProjectClaude(ctx), "settings.json");
-	const projectContent = await readFile(projectSettingsJson);
-	if (projectContent) {
-		const data = tryParseJson<Record<string, unknown>>(projectContent);
-		if (data) {
-			items.push({
-				path: projectSettingsJson,
-				data,
-				level: "project",
-				_source: createSourceMeta(PROVIDER_ID, projectSettingsJson, "project"),
-			} as Settings);
-		} else {
-			warnings.push(`Failed to parse JSON in ${projectSettingsJson}`);
-		}
-	}
-	return { items, warnings };
+async function inspectSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
+	const projectCommandsDir = path.join(getProjectClaude(ctx), "commands");
+	return await loadFilesFromDir<SlashCommand>(ctx, projectCommandsDir, CLAUDE_PROVIDER_ID, "project", {
+		extensions: ["md"],
+		transform: (name, content, filePath, source) => ({
+			name: name.replace(/\.md$/, ""),
+			path: filePath,
+			content,
+			level: "project",
+			_source: source,
+		}),
+	});
 }
 
-registerProvider<MCPServer>(mcpCapability.id, {
-	id: PROVIDER_ID,
-	displayName: DISPLAY_NAME,
-	description: "Load MCP servers from project .claude/mcp.json",
-	priority: PRIORITY,
-	load: loadMCPServers,
-});
-
-registerProvider<ContextFile>(contextFileCapability.id, {
-	id: PROVIDER_ID,
-	displayName: DISPLAY_NAME,
-	description: "Load CLAUDE.md files from project .claude/ directories",
-	priority: PRIORITY,
-	load: loadContextFiles,
-});
-
-registerProvider<Skill>(skillCapability.id, {
-	id: PROVIDER_ID,
-	displayName: DISPLAY_NAME,
-	description: "Load skills from project .claude/skills/",
-	priority: PRIORITY,
-	load: loadSkills,
-});
-
-registerProvider<ExtensionModule>(extensionModuleCapability.id, {
-	id: PROVIDER_ID,
-	displayName: DISPLAY_NAME,
-	description: "Load extension modules from project .claude/extensions",
-	priority: PRIORITY,
-	load: loadExtensionModules,
-});
-
-registerProvider<SlashCommand>(slashCommandCapability.id, {
-	id: PROVIDER_ID,
-	displayName: DISPLAY_NAME,
-	description: "Load slash commands from project .claude/commands/*.md",
-	priority: PRIORITY,
-	load: loadSlashCommands,
-});
-
-registerProvider<Hook>(hookCapability.id, {
-	id: PROVIDER_ID,
-	displayName: DISPLAY_NAME,
-	description: "Load hooks from project .claude/hooks/pre/ and .claude/hooks/post/",
-	priority: PRIORITY,
-	load: loadHooks,
-});
-
-registerProvider<CustomTool>(toolCapability.id, {
-	id: PROVIDER_ID,
-	displayName: DISPLAY_NAME,
-	description: "Load custom tools from project .claude/tools/",
-	priority: PRIORITY,
-	load: loadTools,
-});
-
-registerProvider<Settings>(settingsCapability.id, {
-	id: PROVIDER_ID,
-	displayName: DISPLAY_NAME,
-	description: "Load settings from project .claude/settings.json",
-	priority: PRIORITY,
-	load: loadSettings,
-});
+export interface ClaudeConventionInspection {
+	mcps: LoadResult<MCPServer>;
+	skills: LoadResult<Skill>;
+	hooks: LoadResult<Hook>;
+	tools: LoadResult<CustomTool>;
+	extensions: LoadResult<ExtensionModule>;
+	commands: LoadResult<SlashCommand>;
+}
 
-registerProvider<SystemPrompt>(systemPromptCapability.id, {
-	id: PROVIDER_ID,
-	displayName: DISPLAY_NAME,
-	description: "Load system prompt from project .claude/SYSTEM.md",
-	priority: PRIORITY,
-	load: loadSystemPrompts,
-});
+/**
+ * Inspect what the Claude Code project convention (.claude/) would surface.
+ *
+ * Reuses the shared discovery scan helpers without registering any provider,
+ * so diagnostics can report the convention's files while keeping the runtime
+ * load path exactly as configured (none of these surfaces are registered for
+ * session loading; hooks are covered by the separate registered claude-hooks
+ * provider).
+ */
+export async function inspectClaudeConvention(ctx: LoadContext): Promise<ClaudeConventionInspection> {
+	const [mcps, skills, hooks, tools, extensions, commands] = await Promise.all([
+		inspectMCPServers(ctx),
+		scanClaudeProjectSkills(ctx),
+		inspectHooks(ctx),
+		inspectTools(ctx),
+		inspectExtensionModules(ctx),
+		inspectSlashCommands(ctx),
+	]);
+	return { mcps, skills, hooks, tools, extensions, commands };
+}

package/src/discovery/codex-hooks.ts

@@ -0,0 +1,38 @@
+import * as path from "node:path";
+import { registerProvider } from "../capability";
+import { type Hook, hookCapability } from "../capability/hook";
+import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import { loadFilesFromDir, SOURCE_PATHS } from "./helpers";
+
+const PROVIDER_ID = "codex";
+const DISPLAY_NAME = "OpenAI Codex";
+const PRIORITY = 70;
+
+async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
+	const projectHooksDir = path.join(ctx.cwd, SOURCE_PATHS.codex.projectDir, "hooks");
+	const transformHook = (name: string, _content: string, filePath: string, source: SourceMeta): Hook => {
+		const baseName = name.replace(/\.(ts|js)$/, "");
+		const match = baseName.match(/^(pre|post)-(.+)$/);
+		const hookType = (match?.[1] as "pre" | "post") || "pre";
+		return {
+			name,
+			path: filePath,
+			type: hookType,
+			tool: match?.[2] || baseName,
+			level: "project",
+			_source: source,
+		};
+	};
+	return await loadFilesFromDir(ctx, projectHooksDir, PROVIDER_ID, "project", {
+		extensions: ["ts", "js"],
+		transform: transformHook,
+	});
+}
+
+registerProvider<Hook>(hookCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load hooks from project .codex/hooks/",
+	priority: PRIORITY,
+	load: loadHooks,
+});