@mseep/claudian 2.0.25

package/src/providers/codex/settings.ts

@@ -0,0 +1,236 @@
+import { getProviderConfig, setProviderConfig } from '../../core/providers/providerConfig';
+import { getProviderEnvironmentVariables } from '../../core/providers/providerEnvironment';
+import type { HostnameCliPaths } from '../../core/types/settings';
+import {
+  getHostnameKey,
+  getLegacyHostnameKey,
+  migrateLegacyHostnameKeyedMap,
+} from '../../utils/env';
+import { toCodexRuntimeModelId } from './modelSelection';
+import { CODEX_SPARK_MODEL } from './types/models';
+
+export type CodexSafeMode = 'workspace-write' | 'read-only';
+export type CodexReasoningSummary = 'auto' | 'concise' | 'detailed' | 'none';
+export type CodexInstallationMethod = 'native-windows' | 'wsl';
+export type HostnameInstallationMethods = Record<string, CodexInstallationMethod>;
+
+function normalizeCodexInstallationMethod(value: unknown): CodexInstallationMethod {
+  return value === 'wsl' ? 'wsl' : 'native-windows';
+}
+
+function normalizeOptionalString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+export interface CodexProviderSettings {
+  enabled: boolean;
+  safeMode: CodexSafeMode;
+  cliPath: string;
+  cliPathsByHost: HostnameCliPaths;
+  customModels: string;
+  reasoningSummary: CodexReasoningSummary;
+  environmentVariables: string;
+  environmentHash: string;
+  installationMethod: CodexInstallationMethod;
+  installationMethodsByHost: HostnameInstallationMethods;
+  wslDistroOverride: string;
+  wslDistroOverridesByHost: HostnameCliPaths;
+}
+
+export const DEFAULT_CODEX_PROVIDER_SETTINGS: Readonly<CodexProviderSettings> = Object.freeze({
+  enabled: false,
+  safeMode: 'workspace-write',
+  cliPath: '',
+  cliPathsByHost: {},
+  customModels: '',
+  reasoningSummary: 'detailed',
+  environmentVariables: '',
+  environmentHash: '',
+  installationMethod: 'native-windows',
+  installationMethodsByHost: {},
+  wslDistroOverride: '',
+  wslDistroOverridesByHost: {},
+});
+
+export function shouldDisableCodexReasoningSummary(model: string | undefined): boolean {
+  return model ? toCodexRuntimeModelId(model) === CODEX_SPARK_MODEL : false;
+}
+
+export function getEffectiveCodexReasoningSummary(
+  settings: Record<string, unknown>,
+  model: string | undefined,
+): CodexReasoningSummary {
+  if (shouldDisableCodexReasoningSummary(model)) {
+    return 'none';
+  }
+
+  return getCodexProviderSettings(settings).reasoningSummary;
+}
+
+export function applyCodexModelDefaults(
+  model: string,
+  settings: Record<string, unknown>,
+): void {
+  if (shouldDisableCodexReasoningSummary(model)) {
+    updateCodexProviderSettings(settings, { reasoningSummary: 'none' });
+  }
+}
+
+function normalizeHostnameCliPaths(value: unknown): HostnameCliPaths {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+
+  const result: HostnameCliPaths = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === 'string' && entry.trim()) {
+      result[key] = entry.trim();
+    }
+  }
+  return result;
+}
+
+function normalizeInstallationMethodsByHost(value: unknown): HostnameInstallationMethods {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+
+  const result: HostnameInstallationMethods = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof key === 'string' && key.trim()) {
+      result[key] = normalizeCodexInstallationMethod(entry);
+    }
+  }
+  return result;
+}
+
+export function getCodexProviderSettings(
+  settings: Record<string, unknown>,
+): CodexProviderSettings {
+  const config = getProviderConfig(settings, 'codex');
+  const hostnameKey = getHostnameKey();
+  const normalizedCliPathsByHost = normalizeHostnameCliPaths(config.cliPathsByHost ?? settings.codexCliPathsByHost);
+  const normalizedInstallationMethodsByHost = normalizeInstallationMethodsByHost(config.installationMethodsByHost);
+  const normalizedWslDistroOverridesByHost = normalizeHostnameCliPaths(config.wslDistroOverridesByHost);
+  const hasLegacyHostnameKeyedSettings = Object.keys(normalizedCliPathsByHost).length > 0
+    || Object.keys(normalizedInstallationMethodsByHost).length > 0
+    || Object.keys(normalizedWslDistroOverridesByHost).length > 0;
+  const legacyHostnameKey = hasLegacyHostnameKeyedSettings ? getLegacyHostnameKey() : '';
+  const cliPathsByHost = hasLegacyHostnameKeyedSettings
+    ? migrateLegacyHostnameKeyedMap(normalizedCliPathsByHost, hostnameKey, legacyHostnameKey)
+    : normalizedCliPathsByHost;
+  const installationMethodsByHost = hasLegacyHostnameKeyedSettings
+    ? migrateLegacyHostnameKeyedMap(normalizedInstallationMethodsByHost, hostnameKey, legacyHostnameKey)
+    : normalizedInstallationMethodsByHost;
+  const wslDistroOverridesByHost = hasLegacyHostnameKeyedSettings
+    ? migrateLegacyHostnameKeyedMap(normalizedWslDistroOverridesByHost, hostnameKey, legacyHostnameKey)
+    : normalizedWslDistroOverridesByHost;
+  const hasHostScopedInstallationMethods = Object.keys(installationMethodsByHost).length > 0;
+  const hasHostScopedWslDistroOverrides = Object.keys(wslDistroOverridesByHost).length > 0;
+  const legacyInstallationMethod = normalizeCodexInstallationMethod(config.installationMethod);
+  const legacyWslDistroOverride = normalizeOptionalString(config.wslDistroOverride);
+
+  return {
+    enabled: (config.enabled as boolean | undefined)
+      ?? (settings.codexEnabled as boolean | undefined)
+      ?? DEFAULT_CODEX_PROVIDER_SETTINGS.enabled,
+    safeMode: (config.safeMode as CodexSafeMode | undefined)
+      ?? (settings.codexSafeMode as CodexSafeMode | undefined)
+      ?? DEFAULT_CODEX_PROVIDER_SETTINGS.safeMode,
+    cliPath: (config.cliPath as string | undefined)
+      ?? (settings.codexCliPath as string | undefined)
+      ?? DEFAULT_CODEX_PROVIDER_SETTINGS.cliPath,
+    cliPathsByHost,
+    customModels: (config.customModels as string | undefined)
+      ?? DEFAULT_CODEX_PROVIDER_SETTINGS.customModels,
+    reasoningSummary: (config.reasoningSummary as CodexReasoningSummary | undefined)
+      ?? (settings.codexReasoningSummary as CodexReasoningSummary | undefined)
+      ?? DEFAULT_CODEX_PROVIDER_SETTINGS.reasoningSummary,
+    environmentVariables: (config.environmentVariables as string | undefined)
+      ?? getProviderEnvironmentVariables(settings, 'codex')
+      ?? DEFAULT_CODEX_PROVIDER_SETTINGS.environmentVariables,
+    environmentHash: (config.environmentHash as string | undefined)
+      ?? (settings.lastCodexEnvHash as string | undefined)
+      ?? DEFAULT_CODEX_PROVIDER_SETTINGS.environmentHash,
+    installationMethod: installationMethodsByHost[hostnameKey]
+      ?? (
+        hasHostScopedInstallationMethods
+          ? DEFAULT_CODEX_PROVIDER_SETTINGS.installationMethod
+          : legacyInstallationMethod
+      ),
+    installationMethodsByHost,
+    wslDistroOverride: wslDistroOverridesByHost[hostnameKey]
+      ?? (
+        hasHostScopedWslDistroOverrides
+          ? DEFAULT_CODEX_PROVIDER_SETTINGS.wslDistroOverride
+          : legacyWslDistroOverride
+      ),
+    wslDistroOverridesByHost,
+  };
+}
+
+export function updateCodexProviderSettings(
+  settings: Record<string, unknown>,
+  updates: Partial<CodexProviderSettings>,
+): CodexProviderSettings {
+  const current = getCodexProviderSettings(settings);
+  const hostnameKey = getHostnameKey();
+  const installationMethodsByHost = 'installationMethodsByHost' in updates
+    ? normalizeInstallationMethodsByHost(updates.installationMethodsByHost)
+    : { ...current.installationMethodsByHost };
+  const wslDistroOverridesByHost = 'wslDistroOverridesByHost' in updates
+    ? normalizeHostnameCliPaths(updates.wslDistroOverridesByHost)
+    : { ...current.wslDistroOverridesByHost };
+
+  if (
+    Object.keys(installationMethodsByHost).length === 0
+    && current.installationMethod !== DEFAULT_CODEX_PROVIDER_SETTINGS.installationMethod
+  ) {
+    installationMethodsByHost[hostnameKey] = current.installationMethod;
+  }
+
+  if (
+    Object.keys(wslDistroOverridesByHost).length === 0
+    && current.wslDistroOverride
+  ) {
+    wslDistroOverridesByHost[hostnameKey] = current.wslDistroOverride;
+  }
+
+  if ('installationMethod' in updates) {
+    installationMethodsByHost[hostnameKey] = normalizeCodexInstallationMethod(updates.installationMethod);
+  }
+
+  if ('wslDistroOverride' in updates) {
+    const normalizedDistroOverride = normalizeOptionalString(updates.wslDistroOverride);
+    if (normalizedDistroOverride) {
+      wslDistroOverridesByHost[hostnameKey] = normalizedDistroOverride;
+    } else {
+      delete wslDistroOverridesByHost[hostnameKey];
+    }
+  }
+
+  const next: CodexProviderSettings = {
+    ...current,
+    ...updates,
+    installationMethod: installationMethodsByHost[hostnameKey]
+      ?? DEFAULT_CODEX_PROVIDER_SETTINGS.installationMethod,
+    installationMethodsByHost,
+    wslDistroOverride: wslDistroOverridesByHost[hostnameKey]
+      ?? DEFAULT_CODEX_PROVIDER_SETTINGS.wslDistroOverride,
+    wslDistroOverridesByHost,
+  };
+
+  setProviderConfig(settings, 'codex', {
+    enabled: next.enabled,
+    safeMode: next.safeMode,
+    cliPath: next.cliPath,
+    cliPathsByHost: next.cliPathsByHost,
+    customModels: next.customModels,
+    reasoningSummary: next.reasoningSummary,
+    environmentVariables: next.environmentVariables,
+    environmentHash: next.environmentHash,
+    installationMethodsByHost,
+    wslDistroOverridesByHost,
+  });
+  return next;
+}

package/src/providers/codex/skills/CodexSkillListingService.ts

@@ -0,0 +1,173 @@
+import type ClaudianPlugin from '../../../main';
+import { CodexAppServerProcess } from '../runtime/CodexAppServerProcess';
+import {
+  initializeCodexAppServerTransport,
+  resolveCodexAppServerLaunchSpec,
+} from '../runtime/codexAppServerSupport';
+import type {
+  SkillMetadata,
+  SkillScope,
+  SkillsListResult,
+} from '../runtime/codexAppServerTypes';
+import { CodexRpcTransport } from '../runtime/CodexRpcTransport';
+import { createCodexRuntimeContext } from '../runtime/CodexRuntimeContext';
+
+export interface CodexSkillListProvider {
+  listSkills(options?: { forceReload?: boolean }): Promise<SkillMetadata[]>;
+  invalidate(): void;
+}
+
+interface CodexSkillListingServiceOptions {
+  ttlMs?: number;
+  now?: () => number;
+}
+
+const DEFAULT_SKILL_LIST_TTL_MS = 5_000;
+
+const SKILL_SCOPE_PRIORITY: Record<SkillScope, number> = {
+  repo: 0,
+  user: 1,
+  system: 2,
+  admin: 3,
+};
+
+export function compareCodexSkillPriority(
+  left: Pick<SkillMetadata, 'name' | 'path' | 'scope'>,
+  right: Pick<SkillMetadata, 'name' | 'path' | 'scope'>,
+): number {
+  const scopeDelta = SKILL_SCOPE_PRIORITY[left.scope] - SKILL_SCOPE_PRIORITY[right.scope];
+  if (scopeDelta !== 0) {
+    return scopeDelta;
+  }
+
+  const nameDelta = left.name.localeCompare(right.name);
+  if (nameDelta !== 0) {
+    return nameDelta;
+  }
+
+  return left.path.localeCompare(right.path);
+}
+
+export function extractExplicitCodexSkillNames(text: string): string[] {
+  const matches = text.matchAll(/(^|\s)\$([A-Za-z0-9_-]+)/g);
+  const names: string[] = [];
+  const seen = new Set<string>();
+
+  for (const match of matches) {
+    const name = match[2];
+    if (!name) {
+      continue;
+    }
+
+    const normalized = name.toLowerCase();
+    if (seen.has(normalized)) {
+      continue;
+    }
+
+    seen.add(normalized);
+    names.push(name);
+  }
+
+  return names;
+}
+
+export function getCodexSkillDescription(
+  skill: Pick<SkillMetadata, 'description' | 'shortDescription' | 'interface'>,
+): string | undefined {
+  return skill.interface?.shortDescription
+    ?? skill.shortDescription
+    ?? skill.description
+    ?? undefined;
+}
+
+export function findPreferredCodexSkillByName(
+  skills: SkillMetadata[],
+  name: string,
+): SkillMetadata | null {
+  const normalized = name.toLowerCase();
+  const candidates = skills
+    .filter(skill => skill.enabled && skill.name.toLowerCase() === normalized)
+    .sort(compareCodexSkillPriority);
+
+  return candidates[0] ?? null;
+}
+
+export class CodexSkillListingService implements CodexSkillListProvider {
+  private cache: SkillMetadata[] | null = null;
+  private cacheExpiresAt = 0;
+  private pending: Promise<SkillMetadata[]> | null = null;
+  private readonly ttlMs: number;
+  private readonly now: () => number;
+
+  constructor(
+    private readonly plugin: ClaudianPlugin,
+    options: CodexSkillListingServiceOptions = {},
+  ) {
+    this.ttlMs = options.ttlMs ?? DEFAULT_SKILL_LIST_TTL_MS;
+    this.now = options.now ?? (() => Date.now());
+  }
+
+  async listSkills(options?: { forceReload?: boolean }): Promise<SkillMetadata[]> {
+    if (options?.forceReload) {
+      const skills = await this.fetchSkills(true);
+      this.storeCache(skills);
+      return skills;
+    }
+
+    if (this.cache && this.now() < this.cacheExpiresAt) {
+      return this.cache;
+    }
+
+    if (this.pending) {
+      return this.pending;
+    }
+
+    this.pending = this.fetchSkills(false)
+      .then((skills) => {
+        this.storeCache(skills);
+        return skills;
+      })
+      .finally(() => {
+        this.pending = null;
+      });
+
+    return this.pending;
+  }
+
+  invalidate(): void {
+    this.cache = null;
+    this.cacheExpiresAt = 0;
+  }
+
+  private async fetchSkills(forceReload: boolean): Promise<SkillMetadata[]> {
+    const launchSpec = resolveCodexAppServerLaunchSpec(this.plugin, 'codex');
+    const process = new CodexAppServerProcess(launchSpec);
+    process.start();
+
+    const transport = new CodexRpcTransport(process);
+    transport.start();
+
+    try {
+      const initializeResult = await initializeCodexAppServerTransport(transport);
+      createCodexRuntimeContext(launchSpec, initializeResult);
+      const result = await transport.request<SkillsListResult>('skills/list', {
+        cwds: [launchSpec.targetCwd],
+        ...(forceReload ? { forceReload: true } : {}),
+      });
+
+      const entry = result.data.find(candidate => candidate.cwd === launchSpec.targetCwd) ?? result.data[0];
+      return (entry?.skills ?? []).map(skill => ({
+        ...skill,
+        path: launchSpec.pathMapper.toHostPath(skill.path) ?? skill.path,
+      }));
+    } finally {
+      transport.dispose();
+      await process.shutdown();
+    }
+  }
+
+  private storeCache(skills: SkillMetadata[]): void {
+    this.cache = skills;
+    this.cacheExpiresAt = this.now() + this.ttlMs;
+  }
+}

package/src/providers/codex/storage/CodexSkillStorage.ts

@@ -0,0 +1,250 @@
+import * as path from 'path';
+
+import type { VaultFileAdapter } from '../../../core/storage/VaultFileAdapter';
+import { parseSlashCommandContent, serializeSlashCommandMarkdown } from '../../../utils/slashCommand';
+
+export const CODEX_VAULT_SKILLS_PATH = '.codex/skills';
+export const AGENTS_VAULT_SKILLS_PATH = '.agents/skills';
+
+export type CodexSkillRootId = 'vault-codex' | 'vault-agents';
+
+export const CODEX_SKILL_ROOT_OPTIONS = [
+  { id: 'vault-codex' as const, label: CODEX_VAULT_SKILLS_PATH },
+  { id: 'vault-agents' as const, label: AGENTS_VAULT_SKILLS_PATH },
+];
+
+const ROOT_PATH_BY_ID: Record<CodexSkillRootId, string> = {
+  'vault-codex': CODEX_VAULT_SKILLS_PATH,
+  'vault-agents': AGENTS_VAULT_SKILLS_PATH,
+};
+
+const ROOT_ID_BY_PATH = new Map<string, CodexSkillRootId>(
+  Object.entries(ROOT_PATH_BY_ID).map(([rootId, rootPath]) => [rootPath, rootId as CodexSkillRootId]),
+);
+
+const ALL_SCAN_ROOTS: CodexSkillRootId[] = ['vault-codex', 'vault-agents'];
+const SKILL_PERSISTENCE_PREFIX = 'codex-skill';
+
+export type CodexSkillStorageAdapter = Pick<
+  VaultFileAdapter,
+  'read' | 'write' | 'delete' | 'deleteFolder' | 'listFolders' | 'ensureFolder'
+>;
+
+export interface CodexSkillEntry {
+  name: string;
+  description?: string;
+  content: string;
+  provenance: 'vault' | 'home';
+  rootId: CodexSkillRootId;
+}
+
+export interface CodexSkillLocation {
+  name: string;
+  rootId: CodexSkillRootId;
+}
+
+export interface CodexSkillSaveInput {
+  name: string;
+  description?: string;
+  content: string;
+  rootId?: CodexSkillRootId;
+  previousLocation?: CodexSkillLocation;
+}
+
+export interface CodexSkillPersistenceState {
+  rootId: CodexSkillRootId;
+  currentName?: string;
+}
+
+export function createCodexSkillPersistenceKey(
+  state: CodexSkillPersistenceState,
+): string {
+  const parts = [SKILL_PERSISTENCE_PREFIX, state.rootId];
+  if (state.currentName) {
+    parts.push(encodeURIComponent(state.currentName));
+  }
+  return parts.join(':');
+}
+
+export function parseCodexSkillPersistenceKey(
+  persistenceKey?: string,
+): CodexSkillPersistenceState | null {
+  if (!persistenceKey) {
+    return null;
+  }
+
+  const legacyRootId = ROOT_ID_BY_PATH.get(persistenceKey);
+  if (legacyRootId) {
+    return { rootId: legacyRootId };
+  }
+
+  const [prefix, rootId, encodedName] = persistenceKey.split(':');
+  if (prefix !== SKILL_PERSISTENCE_PREFIX) {
+    return null;
+  }
+  if (rootId !== 'vault-codex' && rootId !== 'vault-agents') {
+    return null;
+  }
+
+  return {
+    rootId,
+    ...(encodedName ? { currentName: decodeURIComponent(encodedName) } : {}),
+  };
+}
+
+export function resolveCodexSkillLocationFromPath(
+  skillPath: string,
+  vaultPath: string,
+): CodexSkillLocation | null {
+  const usesWindowsPathSemantics = (
+    /^[A-Za-z]:[\\/]/.test(skillPath)
+    || /^[A-Za-z]:[\\/]/.test(vaultPath)
+    || skillPath.startsWith('\\\\')
+    || vaultPath.startsWith('\\\\')
+  );
+  const pathApi = usesWindowsPathSemantics ? path.win32 : path.posix;
+  const normalizedSkillPath = pathApi.normalize(skillPath);
+  const normalizedVaultPath = pathApi.normalize(vaultPath);
+
+  for (const [rootId, rootPath] of Object.entries(ROOT_PATH_BY_ID) as Array<[CodexSkillRootId, string]>) {
+    const rootDir = pathApi.normalize(pathApi.join(normalizedVaultPath, rootPath));
+    const relative = pathApi.relative(rootDir, normalizedSkillPath);
+
+    if (
+      !relative
+      || relative.startsWith(`..${pathApi.sep}`)
+      || relative === '..'
+    ) {
+      continue;
+    }
+
+    const parts = relative.split(pathApi.sep);
+    if (parts.length !== 2 || parts[1] !== 'SKILL.md' || !parts[0]) {
+      continue;
+    }
+
+    return {
+      name: parts[0],
+      rootId,
+    };
+  }
+
+  return null;
+}
+
+export class CodexSkillStorage {
+  constructor(
+    private vaultAdapter: CodexSkillStorageAdapter,
+    private homeAdapter?: CodexSkillStorageAdapter,
+  ) {}
+
+  async scanAll(): Promise<CodexSkillEntry[]> {
+    const vaultSkills = await this.scanRoots(this.vaultAdapter, ALL_SCAN_ROOTS, 'vault');
+    const homeSkills = this.homeAdapter
+      ? await this.scanRoots(this.homeAdapter, ALL_SCAN_ROOTS, 'home')
+      : [];
+
+    // Deduplicate: vault takes priority over home
+    const seen = new Set(vaultSkills.map(s => s.name.toLowerCase()));
+    const deduped = homeSkills.filter(s => !seen.has(s.name.toLowerCase()));
+
+    return [...vaultSkills, ...deduped];
+  }
+
+  async scanVault(): Promise<CodexSkillEntry[]> {
+    return this.scanRoots(this.vaultAdapter, ALL_SCAN_ROOTS, 'vault');
+  }
+
+  async save(input: CodexSkillSaveInput): Promise<void> {
+    const targetRootId = input.rootId ?? 'vault-codex';
+    const targetLocation = { rootId: targetRootId, name: input.name };
+    const { dirPath, filePath } = this.buildLocationPaths(targetLocation);
+    const previousLocation = input.previousLocation;
+
+    await this.vaultAdapter.ensureFolder(dirPath);
+    const markdown = serializeSlashCommandMarkdown(
+      { name: input.name, description: input.description },
+      input.content,
+    );
+    await this.vaultAdapter.write(filePath, markdown);
+
+    if (
+      previousLocation
+      && (previousLocation.rootId !== targetRootId || previousLocation.name !== input.name)
+    ) {
+      await this.delete(previousLocation);
+    }
+  }
+
+  async delete(location: CodexSkillLocation): Promise<void> {
+    const { dirPath, filePath } = this.buildLocationPaths(location);
+    await this.vaultAdapter.delete(filePath);
+    await this.vaultAdapter.deleteFolder(dirPath);
+  }
+
+  async load(location: CodexSkillLocation): Promise<CodexSkillEntry | null> {
+    const { filePath } = this.buildLocationPaths(location);
+
+    try {
+      const content = await this.vaultAdapter.read(filePath);
+      const parsed = parseSlashCommandContent(content);
+
+      return {
+        name: location.name,
+        description: parsed.description,
+        content: parsed.promptContent,
+        provenance: 'vault',
+        rootId: location.rootId,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  private async scanRoots(
+    adapter: CodexSkillStorageAdapter,
+    roots: CodexSkillRootId[],
+    provenance: 'vault' | 'home',
+  ): Promise<CodexSkillEntry[]> {
+    const results: CodexSkillEntry[] = [];
+
+    for (const rootId of roots) {
+      const rootPath = ROOT_PATH_BY_ID[rootId];
+      try {
+        const folders = await adapter.listFolders(rootPath);
+        for (const folder of folders) {
+          const skillName = folder.split('/').pop()!;
+          const skillPath = `${rootPath}/${skillName}/SKILL.md`;
+
+          try {
+            const content = await adapter.read(skillPath);
+            const parsed = parseSlashCommandContent(content);
+
+            results.push({
+              name: skillName,
+              description: parsed.description,
+              content: parsed.promptContent,
+              provenance,
+              rootId,
+            });
+          } catch {
+            // Skip malformed files
+          }
+        }
+      } catch {
+        // Root doesn't exist or can't be read
+      }
+    }
+
+    return results;
+  }
+
+  private buildLocationPaths(location: CodexSkillLocation): { dirPath: string; filePath: string } {
+    const rootPath = ROOT_PATH_BY_ID[location.rootId];
+    const dirPath = `${rootPath}/${location.name}`;
+    return {
+      dirPath,
+      filePath: `${dirPath}/SKILL.md`,
+    };
+  }
+}