huhaa-myskills 0.2.13 → 0.3.4

package/packages/scanner/src/index.mjs

@@ -9,90 +9,115 @@ import fs from 'node:fs';
 import YAML from 'yaml';
 import { configFile } from '../../../bin/lib/paths.mjs';
 import { scanMarkdownSkills } from './adapters/markdown-skill.mjs';
+import { scanDirectorySkills } from './adapters/directory-skill.mjs';
 import { scanFileDocs } from './adapters/file-docs.mjs';
 import { scanMcpConfigs } from './adapters/mcp-config.mjs';
 import { scanHermesPlugins } from './adapters/hermes-plugin.mjs';
 import { expandRoots, expandTilde } from './utils.mjs';
 
 const ADAPTERS = {
-  hermes: async (cfg, limits) => scanMarkdownSkills({
-    source: 'hermes',
-    roots: cfg.roots || [],
-    fileGlob: '**/SKILL.md',
-    limits,
-  }),
-  'claude-code': async (cfg, limits) => scanMarkdownSkills({
-    source: 'claude-code',
-    roots: cfg.roots || [],
-    fileGlob: '**/SKILL.md',
-    limits,
-  }),
-  codex: async (cfg, limits) => scanFileDocs({
-    source: 'codex',
-    editor: 'Codex',
-    kind: 'instruction',
-    files: cfg.files || [],
-    roots: cfg.roots || [],
-    globs: normalizeGlobs(cfg, ['AGENTS.md']),
-    limits,
-  }),
-  cursor: async (cfg, limits) => scanFileDocs({
-    source: 'cursor',
-    editor: 'Cursor',
-    kind: 'instruction',
-    files: cfg.files || [],
-    roots: cfg.roots || [],
-    globs: normalizeGlobs(cfg, ['.cursorrules', '.cursor/rules/**/*.{md,mdc}']),
-    limits,
-  }),
-  'mcp-config': async (cfg, limits) => scanMcpConfigs({
-    source: 'mcp-config',
-    editor: 'MCP',
-    files: cfg.files || [],
-    limits,
-  }),
-  'hermes-plugin': async (cfg, limits) => scanHermesPlugins({
-    source: 'hermes-plugin',
-    editor: 'Hermes Agent',
-    roots: cfg.roots || [],
-    limits,
-  }),
-  'project-runbook': async (cfg, limits) => scanFileDocs({
-    source: 'project-runbook',
-    editor: 'Project Docs',
-    kind: 'runbook',
-    files: cfg.files || [],
-    roots: cfg.roots || [],
-    globs: normalizeGlobs(cfg, ['docs/RUNBOOK-*.md', 'AGENTS.md', 'CLAUDE.md', '.cursorrules', '.cursor/rules/**/*.{md,mdc}']),
-    limits,
-  }),
-  'skills': async (cfg, limits) => scanFileDocs({
-    source: 'skills',
-    editor: 'Skills Hub',
-    kind: 'skill',
-    files: cfg.files || [],
-    roots: cfg.roots || [],
-    globs: normalizeGlobs(cfg, ['*.md', '*/SKILL.md', '**/SKILL.md']),
-    limits,
-  }),
-  'mcp': async (cfg, limits) => scanFileDocs({
-    source: 'mcp',
-    editor: 'MCP Hub',
-    kind: 'mcp-tool',
-    files: cfg.files || [],
-    roots: cfg.roots || [],
-    globs: normalizeGlobs(cfg, ['*.md', '*.json', '*.yaml', '*.yml', '**/manifest.*']),
-    limits,
-  }),
-  'skill': async (cfg, limits) => scanFileDocs({
-    source: 'skill',
-    editor: 'Skill Hub',
-    kind: 'skill',
-    files: cfg.files || [],
-    roots: cfg.roots || [],
-    globs: normalizeGlobs(cfg, ['*.md', '*/SKILL.md', '**/SKILL.md']),
+  // Tier 1: Tool adapters (return items with tier='tool', brand set)
+  hermes: async (cfg, limits) => {
+    const result = await scanMarkdownSkills({
+      source: 'hermes',
+      roots: cfg.roots || [],
+      fileGlob: '**/SKILL.md',
+      limits,
+    });
+    result.items.forEach(it => {
+      it.tier = 'tool';
+      it.brand = 'hermes';
+    });
+    return result;
+  },
+  
+  'claude-code': async (cfg, limits) => {
+    const result = await scanMarkdownSkills({
+      source: 'claude-code',
+      roots: cfg.roots || [],
+      fileGlob: '**/SKILL.md',
+      limits,
+    });
+    result.items.forEach(it => {
+      it.tier = 'tool';
+      it.brand = 'claude';
+    });
+    return result;
+  },
+  
+  codex: async (cfg, limits) => {
+    const result = await scanFileDocs({
+      source: 'codex',
+      editor: 'Codex',
+      kind: 'instruction',
+      files: cfg.files || [],
+      roots: cfg.roots || [],
+      globs: normalizeGlobs(cfg, ['AGENTS.md']),
+      limits,
+    });
+    result.items.forEach(it => {
+      it.tier = 'tool';
+      it.brand = 'codex';
+    });
+    return result;
+  },
+  
+  cursor: async (cfg, limits) => {
+    const result = await scanFileDocs({
+      source: 'cursor',
+      editor: 'Cursor',
+      kind: 'instruction',
+      files: cfg.files || [],
+      roots: cfg.roots || [],
+      globs: normalizeGlobs(cfg, ['.cursorrules', '.cursor/rules/**/*.{md,mdc}']),
+      limits,
+    });
+    result.items.forEach(it => {
+      it.tier = 'tool';
+      it.brand = 'cursor';
+    });
+    return result;
+  },
+
+  'hermes-plugin': async (cfg, limits) => {
+    const result = await scanHermesPlugins({
+      source: 'hermes-plugin',
+      editor: 'Hermes Agent',
+      roots: cfg.roots || [],
+      limits,
+    });
+    result.items.forEach(it => {
+      it.tier = 'tool';
+      it.brand = 'hermes';
+    });
+    return result;
+  },
+
+  // Tier 2: Directory-based skills (already returns tier='directory', dirName)
+  'directory-skill': async (cfg, limits) => scanDirectorySkills({
+    paths: cfg.paths || [],
+    globs: normalizeGlobs(cfg, ['**/SKILL.md']),
     limits,
   }),
+
+  // Tier 3: Other sources (assign tier='other')
+  'project-runbook': async (cfg, limits) => {
+    const result = await scanFileDocs({
+      source: 'project-runbook',
+      editor: 'Project Docs',
+      kind: 'runbook',
+      files: cfg.files || [],
+      roots: cfg.roots || [],
+      globs: normalizeGlobs(cfg, ['docs/RUNBOOK-*.md', 'AGENTS.md', 'CLAUDE.md', '.cursorrules', '.cursor/rules/**/*.{md,mdc}']),
+      limits,
+    });
+    result.items.forEach(it => {
+      it.tier = 'other';
+    });
+    return result;
+  },
+
+  // Removed: 'mcp-config', 'mcp', 'skills', 'skill' — no longer scanned
   // Future: obsidian
 };
 
@@ -159,7 +184,11 @@ export async function getWatchTargets() {
     if (!src?.enabled) continue;
     for (const f of src.files || []) targets.add(expandTilde(f));
 
-    const roots = await expandRoots(src.roots || []);
+    // directory-skill uses 'paths' instead of 'roots'
+    const roots = name === 'directory-skill'
+      ? await expandRoots(src.paths || [])
+      : await expandRoots(src.roots || []);
+
     const globs = normalizeGlobs(src, defaultWatchGlobs(name));
     for (const root of roots) {
       for (const g of globs) targets.add(`${root}/${g}`);
@@ -173,12 +202,8 @@ function defaultWatchGlobs(name) {
   switch (name) {
     case 'hermes':
     case 'claude-code':
+    case 'directory-skill':
       return ['**/SKILL.md'];
-    case 'skills':
-    case 'skill':
-      return ['*.md', '*/SKILL.md', '**/SKILL.md'];
-    case 'mcp':
-      return ['*.md', '*.json', '*.yaml', '*.yml', '**/manifest.*'];
     case 'hermes-plugin':
       return ['**/{plugin.yaml,plugin.yml,plugin.json,manifest.json,package.json,README.md,readme.md}'];
     case 'project-runbook':

package/packages/scanner/src/types.d.ts

@@ -30,6 +30,7 @@ export interface SkillItem {
     | 'project'
     | 'project-runbook'
     | 'hermes-plugin'
+    | 'directory'
     | 'mcp-config';
 
   /** machine name (frontmatter.name or file basename) */
@@ -85,4 +86,21 @@ export interface SkillItem {
 
   /** present when frontmatter / format parse failed; UI shows red badge */
   parseError?: string;
+
+  // NEW FIELDS for Skills Tab Redesign v0.3.3
+  /** Tier 1/2/3 categorization — controls display logic and icon in UI */
+  tier?: 'tool' | 'directory' | 'other';
+
+  /** Parent directory name (Tier 2 only) — used for display label */
+  dirName?: string;
+
+  /** i18n translation metadata (if present) */
+  i18n?: {
+    zh?: {
+      title?: string;
+      description?: string;
+    };
+    translatedAt?: string;
+    translationModel?: string;
+  };
 }

package/packages/scanner/test/icon.test.mjs

@@ -0,0 +1,61 @@
+// Tests for the R6 real-icon logic (brand-map + icon-extractor).
+// Focus on the pure/sync resolution chain — spawn-based extraction is exercised
+// lightly since it depends on which apps are installed on the host.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { resolveBrandSpec, emojiForBrand, BRAND_APP_MAP } from '../src/icon/brand-map.mjs';
+import { resolveIconRef, getIconForBrand } from '../src/icon/icon-extractor.mjs';
+
+test('resolveBrandSpec resolves known brands and raw bundle ids', () => {
+  assert.ok(resolveBrandSpec('cursor'), 'cursor is a known brand');
+  assert.equal(resolveBrandSpec('Cursor')?.appNames.includes('Cursor'), true, 'case-insensitive');
+  // A dotted string is treated as an explicit bundle id
+  const spec = resolveBrandSpec('com.example.MyApp');
+  assert.deepEqual(spec?.bundleIds, ['com.example.MyApp']);
+  // Unknown, non-dotted value → null
+  assert.equal(resolveBrandSpec('totally-unknown-brand'), null);
+  assert.equal(resolveBrandSpec(''), null);
+});
+
+test('emojiForBrand returns the mapped emoji', () => {
+  assert.equal(emojiForBrand('hermes'), BRAND_APP_MAP.hermes.emoji);
+  assert.equal(emojiForBrand('CLAUDE-CODE'), BRAND_APP_MAP['claude-code'].emoji);
+  assert.equal(emojiForBrand('nope'), undefined);
+});
+
+test('resolveIconRef honors explicit frontmatter icon overrides', () => {
+  assert.deepEqual(resolveIconRef({ icon: 'emoji:🎯' }), { iconFallback: '🎯' });
+  assert.deepEqual(resolveIconRef({ icon: 'url:https://x/icon.png' }), {
+    iconUrl: 'https://x/icon.png',
+  });
+  assert.deepEqual(resolveIconRef({ icon: 'app:com.microsoft.VSCode' }), {
+    iconUrl: '/api/icons/com.microsoft.VSCode?size=64',
+  });
+  // Bare glyph → fallback emoji
+  assert.deepEqual(resolveIconRef({ icon: '🔥' }), { iconFallback: '🔥' });
+});
+
+test('resolveIconRef maps brand/source to a real-icon URL with emoji fallback', () => {
+  const ref = resolveIconRef({ brand: 'cursor' }, 64);
+  assert.equal(ref.iconUrl, '/api/icons/cursor?size=64');
+  assert.equal(ref.iconFallback, BRAND_APP_MAP.cursor.emoji);
+
+  // Falls through to source when brand is absent/unmapped
+  const bySource = resolveIconRef({ source: 'vs-code' }, 32);
+  assert.equal(bySource.iconUrl, '/api/icons/vs-code?size=32');
+
+  // Unknown brand → empty (frontend emoji map handles it)
+  assert.deepEqual(resolveIconRef({ brand: 'made-up' }), {});
+  assert.deepEqual(resolveIconRef({}), {});
+});
+
+test('resolveIconRef clamps invalid sizes to 64', () => {
+  const ref = resolveIconRef({ brand: 'cursor' }, 999);
+  assert.equal(ref.iconUrl, '/api/icons/cursor?size=64');
+});
+
+test('getIconForBrand returns null for an unmapped brand', async () => {
+  const result = await getIconForBrand('definitely-not-an-app-xyz', 64);
+  assert.equal(result, null);
+});

package/packages/scanner/test/scanner.test.mjs

@@ -27,7 +27,7 @@ function groupBy(items, fn) {
   }, {});
 }
 
-test('scan aggregates enabled sources, strips duplicate semantic skill exports, and redacts MCP secrets', async (t) => {
+test('scan aggregates enabled sources and strips duplicate semantic skill exports', async (t) => {
   const { root, home } = makeTempHome();
   t.after(() => fs.rmSync(root, { recursive: true, force: true }));
 
@@ -35,7 +35,7 @@ test('scan aggregates enabled sources, strips duplicate semantic skill exports,
   const hermesRoot = path.join(root, 'hermes-skills');
   const codexRoot = path.join(root, 'project-a');
   const cursorRoot = path.join(root, 'project-b');
-  const mcpFile = path.join(root, 'mcp.json');
+  const directorySkillsRoot = path.join(root, 'custom-skills');
 
   write(path.join(hermesRoot, 'devops', 'deploy-helper', 'SKILL.md'), `---
 name: deploy-helper
@@ -52,21 +52,14 @@ description: Duplicate hidden export
 ---
 # Duplicate hidden export
 `);
-  write(path.join(codexRoot, 'AGENTS.md'), '# Codex Instructions\n\nUse Node 20 and run tests.');
+  write(path.join(codexRoot, 'AGENTS.md'), '# Codex Instructions\\n\\nUse Node 20 and run tests.');
   write(path.join(cursorRoot, '.cursorrules'), 'Always keep UI concise.');
-  write(mcpFile, JSON.stringify({
-    mcpServers: {
-      dangerous: {
-        command: 'node',
-        args: ['server.js'],
-        env: {
-          API_TOKEN: 'fake-token-value-for-redaction-test',
-          normal: 'visible',
-        },
-        url: 'https://example.com/mcp?token=secret-value',
-      },
-    },
-  }, null, 2));
+  write(path.join(directorySkillsRoot, 'auth-flow', 'SKILL.md'), `---
+name: auth-flow
+description: Custom auth flow implementation
+---
+# Auth Flow
+`);
 
   write(sources, `sources:
   hermes:
@@ -81,10 +74,10 @@ description: Duplicate hidden export
     enabled: true
     roots:
       - ${JSON.stringify(cursorRoot)}
-  mcp-config:
+  directory-skill:
     enabled: true
-    files:
-      - ${JSON.stringify(mcpFile)}
+    paths:
+      - ${JSON.stringify(directorySkillsRoot)}
 limits:
   maxFiles: 100
   maxFileBytes: 1048576
@@ -96,22 +89,24 @@ limits:
   assert.equal(bySource.hermes?.length, 1, 'semantic duplicate hermes skill should collapse to one item');
   assert.equal(bySource.codex?.length, 1);
   assert.equal(bySource.cursor?.length, 1);
-  assert.equal(bySource['mcp-config']?.length, 1);
-
-  const skill = bySource.hermes[0];
-  assert.equal(skill.name, 'deploy-helper');
-  assert.equal(skill.editor, 'Hermes Agent');
-  assert.equal(skill.category, 'devops');
-  assert.deepEqual(skill.triggers, ['deploy service']);
-  assert.ok(!skill.paths.abs.includes('/.hidden-export/'), 'visible export should outrank hidden duplicate');
-
-  const mcp = bySource['mcp-config'][0];
-  assert.equal(mcp.kind, 'mcp');
-  assert.equal(mcp.name, 'dangerous');
-  assert.match(mcp.raw, /\[REDACTED\]/);
-  assert.doesNotMatch(mcp.raw, /fake-token-value-for-redaction-test/);
-  assert.doesNotMatch(mcp.raw, /secret-value/);
-  assert.match(mcp.raw, /visible/);
+  assert.equal(bySource.directory?.length, 1, 'directory-skill should return one item');
+
+  // Verify Tier 1 tool skills have tier='tool' and brand
+  const hermesSkill = bySource.hermes[0];
+  assert.equal(hermesSkill.tier, 'tool', 'hermes skill should have tier="tool"');
+  assert.equal(hermesSkill.brand, 'hermes', 'hermes skill should have brand="hermes"');
+  assert.equal(hermesSkill.name, 'deploy-helper');
+  assert.equal(hermesSkill.editor, 'Hermes Agent');
+  assert.equal(hermesSkill.category, 'devops');
+  assert.deepEqual(hermesSkill.triggers, ['deploy service']);
+  assert.ok(!hermesSkill.paths.abs.includes('/.hidden-export/'), 'visible export should outrank hidden duplicate');
+
+  // Verify Tier 2 directory skills have tier='directory' and dirName
+  const dirSkill = bySource.directory[0];
+  assert.equal(dirSkill.tier, 'directory', 'directory-skill should have tier="directory"');
+  assert.equal(dirSkill.dirName, 'auth-flow', 'directory-skill should have dirName="auth-flow"');
+  assert.equal(dirSkill.source, 'directory', 'directory-skill should have source="directory"');
+  assert.equal(dirSkill.name, 'auth-flow');
 });
 
 test('getWatchTargets includes config file plus configured source files and globs', async (t) => {
@@ -119,22 +114,23 @@ test('getWatchTargets includes config file plus configured source files and glob
   t.after(() => fs.rmSync(root, { recursive: true, force: true }));
 
   const hermesRoot = path.join(root, 'skills');
-  const mcpFile = path.join(root, 'mcp.json');
+  const directorySkillsRoot = path.join(root, 'custom-skills');
   fs.mkdirSync(hermesRoot, { recursive: true });
-  write(mcpFile, '{}');
+  fs.mkdirSync(directorySkillsRoot, { recursive: true });
+
   write(path.join(home, 'sources.yaml'), `sources:
   hermes:
     enabled: true
     roots:
       - ${JSON.stringify(hermesRoot)}
-  mcp-config:
+  directory-skill:
     enabled: true
-    files:
-      - ${JSON.stringify(mcpFile)}
+    paths:
+      - ${JSON.stringify(directorySkillsRoot)}
 `);
 
   const targets = await getWatchTargets();
   assert.ok(targets.includes(path.join(home, 'sources.yaml')));
-  assert.ok(targets.includes(mcpFile));
   assert.ok(targets.some(t => t.endsWith('/skills/**/SKILL.md')));
+  assert.ok(targets.some(t => t.endsWith('/custom-skills/**/SKILL.md')));
 });

package/packages/scanner/test/skill-adapter.test.mjs

@@ -0,0 +1,70 @@
+// Tests for scanSkills R7 behavior: two-stage (mini/full) + stable ordering.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import os from 'node:os';
+import fs from 'node:fs';
+import path from 'node:path';
+import { scanSkills } from '../src/adapters/skill-adapter.mjs';
+
+function makeFixture() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'huhaa-skills-'));
+  const write = (rel, content) => {
+    const abs = path.join(dir, rel);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, content);
+  };
+  write('zebra/SKILL.md', '---\nname: zebra\ndescription: last alphabetically\ntags: [z1, z2]\n---\n# Zebra body');
+  write('alpha/SKILL.md', '---\nname: alpha\ndescription: first alphabetically\ntags: [a1]\nicon: "emoji:🅰️"\n---\n# Alpha body');
+  write('mid/SKILL.md', '---\nname: mid\ndescription: middle\n---\n# Mid body');
+  return dir;
+}
+
+test('scanSkills full stage returns rich fields', async () => {
+  const dir = makeFixture();
+  const { items, stats } = await scanSkills({ roots: [dir], stage: 'full' });
+  assert.equal(items.length, 3);
+  assert.equal(stats.stage, 'full');
+  const alpha = items.find(i => i.name === 'alpha');
+  assert.deepEqual(alpha.tags, ['a1']);
+  assert.ok(alpha.raw.includes('Alpha body'), 'full stage includes raw');
+  assert.ok(alpha.preview.length > 0, 'full stage includes preview');
+  assert.equal(alpha.icon, 'emoji:🅰️', 'frontmatter icon passed through');
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test('scanSkills mini stage omits heavy fields but keeps display data', async () => {
+  const dir = makeFixture();
+  const { items, stats } = await scanSkills({ roots: [dir], stage: 'mini' });
+  assert.equal(items.length, 3);
+  assert.equal(stats.stage, 'mini');
+  const alpha = items.find(i => i.name === 'alpha');
+  assert.equal(alpha.description, 'first alphabetically');
+  assert.equal(alpha.icon, 'emoji:🅰️');
+  assert.equal(alpha.tags, undefined, 'mini omits tags');
+  assert.equal(alpha.raw, undefined, 'mini omits raw');
+  assert.equal(alpha.preview, undefined, 'mini omits preview');
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test('scanSkills returns a stable path-sorted order regardless of concurrency', async () => {
+  const dir = makeFixture();
+  const a = await scanSkills({ roots: [dir], concurrency: 1 });
+  const b = await scanSkills({ roots: [dir], concurrency: 8 });
+  const names = x => x.items.map(i => i.name);
+  assert.deepEqual(names(a), names(b), 'order independent of concurrency');
+  // Sorted by absolute path → alpha, mid, zebra
+  assert.deepEqual(names(a), ['alpha', 'mid', 'zebra']);
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test('scanSkills reports duration and handles empty roots', async () => {
+  const empty = await scanSkills({ roots: ['/nonexistent-path-xyz'] });
+  assert.equal(empty.items.length, 0);
+  assert.equal(empty.stats.available, false);
+
+  const dir = makeFixture();
+  const { stats } = await scanSkills({ roots: [dir] });
+  assert.equal(typeof stats.duration, 'number');
+  fs.rmSync(dir, { recursive: true, force: true });
+});

package/packages/scanner/tests/directory-skill.test.mjs

@@ -0,0 +1,93 @@
+// directory-skill.test.mjs — unit tests for directory-skill adapter
+//
+// Tests cover:
+// 1. Successfully scanning a directory with SKILL.md files
+// 2. Proper tier assignment (tier='directory')
+// 3. dirName field population
+// 4. Empty directory handling
+// 5. File glob filtering
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { scanDirectorySkills } from '../src/adapters/directory-skill.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const FIXTURES_DIR = path.join(__dirname, 'fixtures/directory-skill');
+
+test('scanDirectorySkills: basic scanning', async () => {
+  const result = await scanDirectorySkills({
+    paths: [FIXTURES_DIR],
+    globs: ['**/SKILL.md'],
+    limits: { maxFiles: 100, maxFileBytes: 1024 * 1024 },
+  });
+
+  assert.ok(result.items, 'items array should exist');
+  assert(Array.isArray(result.items), 'items should be an array');
+  assert(result.stats, 'stats should exist');
+  assert.equal(result.stats.source, 'directory', 'source should be "directory"');
+});
+
+test('scanDirectorySkills: tier assignment', async () => {
+  const result = await scanDirectorySkills({
+    paths: [FIXTURES_DIR],
+    globs: ['**/SKILL.md'],
+    limits: { maxFiles: 100, maxFileBytes: 1024 * 1024 },
+  });
+
+  for (const item of result.items) {
+    assert.equal(item.tier, 'directory', `tier should be "directory" for item ${item.name}`);
+    assert.ok(item.dirName, `dirName should be set for item ${item.name}`);
+    assert.equal(item.source, 'directory', `source should be "directory" for item ${item.name}`);
+  }
+});
+
+test('scanDirectorySkills: empty directory', async () => {
+  const result = await scanDirectorySkills({
+    paths: ['/nonexistent/path'],
+    globs: ['**/SKILL.md'],
+    limits: { maxFiles: 100, maxFileBytes: 1024 * 1024 },
+  });
+
+  assert.equal(result.items.length, 0, 'should return empty list for non-existent path');
+  assert.equal(result.stats.available, false, 'stats.available should be false');
+});
+
+test('scanDirectorySkills: no paths provided', async () => {
+  const result = await scanDirectorySkills({
+    paths: [],
+    globs: ['**/SKILL.md'],
+    limits: { maxFiles: 100, maxFileBytes: 1024 * 1024 },
+  });
+
+  assert.equal(result.items.length, 0, 'should return empty list when paths is empty');
+  assert.equal(result.stats.available, false, 'stats.available should be false');
+});
+
+test('scanDirectorySkills: dirName extraction', async () => {
+  const result = await scanDirectorySkills({
+    paths: [FIXTURES_DIR],
+    globs: ['**/SKILL.md'],
+    limits: { maxFiles: 100, maxFileBytes: 1024 * 1024 },
+  });
+
+  for (const item of result.items) {
+    // dirName should be the parent directory of SKILL.md
+    assert.ok(item.dirName, `dirName should exist for ${item.name}`);
+    assert(item.dirName.length > 0, `dirName should not be empty for ${item.name}`);
+    // dirName should match the dir part of the path
+    const expectedDirName = path.basename(path.dirname(item.paths.abs));
+    assert.equal(item.dirName, expectedDirName, `dirName should match directory name for ${item.name}`);
+  }
+});
+
+test('scanDirectorySkills: file limits respected', async () => {
+  const result = await scanDirectorySkills({
+    paths: [FIXTURES_DIR],
+    globs: ['**/SKILL.md'],
+    limits: { maxFiles: 1, maxFileBytes: 1024 * 1024 },
+  });
+
+  assert(result.items.length <= 1, 'should respect maxFiles limit');
+});