async function loadSkillsFromDir(skillsDir: string, scope: SkillScope): Promise<LoadedSkill[]> {
  const entries = await fs.readdir(skillsDir, { withFileTypes: true }).catch(() => [])
  // ... only scans first-level subdirectories
}

import { glob } from 'glob';

async function loadSkillsFromDir(skillsDir: string, scope: SkillScope): Promise<LoadedSkill[]> {
  const skillFiles = await glob('**/SKILL.md', {
    cwd: skillsDir,
    absolute: false,
    followSymlinks: true,
  });

  const skills: LoadedSkill[] = [];
  for (const relativePath of skillFiles) {
    const skillDir = path.dirname(relativePath);
    const skillName = path.basename(skillDir);
    const group = path.dirname(skillDir) === '.' ? undefined : path.dirname(skillDir);
    const fullPath = path.join(skillsDir, relativePath);
    const resolvedPath = path.join(skillsDir, skillDir);

    const skill = await loadSkillFromPath(
      fullPath,
      resolvedPath,
      group ? `${group}:${skillName}` : skillName,
      scope,
      group
    );
    if (skill) skills.push(skill);
  }
  return skills;
}

async function loadSkillsFromDirRecursive(
  dir: string,
  basePath: string = '',
  scope: SkillScope
): Promise<LoadedSkill[]> {
  const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
  const skills: LoadedSkill[] = [];

  for (const entry of entries) {
    if (entry.name.startsWith('.')) continue;

    const fullPath = path.join(dir, entry.name);
    const relativePath = basePath ? path.join(basePath, entry.name) : entry.name;

    if (entry.isDirectory() || entry.isSymbolicLink()) {
      const resolvedPath = await resolveSymlinkAsync(fullPath);
      const skillMdPath = path.join(resolvedPath, 'SKILL.md');

      // Check if SKILL.md exists
      try {
        await fs.access(skillMdPath);
        const group = basePath;
        const skillName = entry.name;
        const skill = await loadSkillFromPath(
          skillMdPath,
          resolvedPath,
          group ? `${group}:${skillName}` : skillName,
          scope,
          group
        );
        if (skill) skills.push(skill);
      } catch {
        // If no SKILL.md, recursively scan subdirectories
        const subSkills = await loadSkillsFromDirRecursive(fullPath, relativePath, scope);
        skills.push(...subSkills);
      }
    }
  }

  return skills;
}

export interface LoadedSkill {
  name: string
  group?: string  // New field
  path?: string
  resolvedPath?: string
  definition: CommandDefinition
  scope: SkillScope
  license?: string
  compatibility?: string
  metadata?: Record<string, string>
  allowedTools?: string[]
  mcpConfig?: SkillMcpConfig
  lazyContent?: LazyContentLoader
}

function formatSkillsXml(skills: SkillInfo[]): string {
  if (skills.length === 0) return ""

  const skillsXml = skills.map(skill => {
    const lines = [
      "  <skill>",
      `    <name>${skill.name}</name>`,
      `    <description>${skill.description}</description>`,
    ]
    if (skill.group) {
      lines.push(`    <group>${skill.group}</group>`)
    }
    if (skill.compatibility) {
      lines.push(`    <compatibility>${skill.compatibility}</compatibility>`)
    }
    lines.push("  </skill>")
    return lines.join("\n")
  }).join("\n")

  return `\n\n<available_skills>\n${skillsXml}\n</available_skills>`
}