gsd-remix 1.0.0

package/sdk/src/query/skill-manifest.ts

@@ -0,0 +1,214 @@
+/**
+ * Skill manifest — multi-root skill discovery scan.
+ *
+ * Full port of `buildSkillManifest` / `cmdSkillManifest` from
+ * `get-shit-done/bin/lib/init.cjs` (lines 1640–1847).
+ * Uses {@link extractFrontmatterLeading} — same as CJS `frontmatter.cjs` `extractFrontmatter`
+ * (first `---` block only; skills with later `---` rules must not use TS `extractFrontmatter`'s last-block rule).
+ */
+
+import { existsSync, readdirSync, readFileSync, writeFileSync, type Dirent } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+
+import { extractFrontmatterLeading } from './frontmatter.js';
+import type { QueryHandler } from './utils.js';
+
+export interface SkillManifestSkill {
+  name: string;
+  description: string;
+  triggers: string[];
+  path: string;
+  file_path: string;
+  root: string;
+  scope: string;
+  installed: boolean;
+  deprecated: boolean;
+}
+
+export interface SkillManifestRoot {
+  root: string;
+  path: string;
+  scope: string;
+  present: boolean;
+  deprecated?: boolean;
+  skill_count?: number;
+  command_count?: number;
+}
+
+export interface SkillManifestJson {
+  skills: SkillManifestSkill[];
+  roots: SkillManifestRoot[];
+  installation: {
+    gsd_skills_installed: boolean;
+    legacy_claude_commands_installed: boolean;
+  };
+  counts: { skills: number; roots: number };
+}
+
+/**
+ * Scan canonical skill roots and build manifest JSON (same shape as gsd-tools.cjs).
+ */
+export function buildSkillManifest(cwd: string, skillsDir: string | null = null): SkillManifestJson {
+  const canonicalRoots = skillsDir
+    ? [{
+      root: resolve(skillsDir),
+      path: resolve(skillsDir),
+      scope: 'custom',
+      present: existsSync(skillsDir),
+      kind: 'skills' as const,
+    }]
+    : [
+      { root: '.claude/skills', path: join(cwd, '.claude', 'skills'), scope: 'project', kind: 'skills' as const },
+      { root: '.agents/skills', path: join(cwd, '.agents', 'skills'), scope: 'project', kind: 'skills' as const },
+      { root: '.cursor/skills', path: join(cwd, '.cursor', 'skills'), scope: 'project', kind: 'skills' as const },
+      { root: '.github/skills', path: join(cwd, '.github', 'skills'), scope: 'project', kind: 'skills' as const },
+      { root: '.codex/skills', path: join(cwd, '.codex', 'skills'), scope: 'project', kind: 'skills' as const },
+      { root: '~/.claude/skills', path: join(homedir(), '.claude', 'skills'), scope: 'global', kind: 'skills' as const },
+      { root: '~/.codex/skills', path: join(homedir(), '.codex', 'skills'), scope: 'global', kind: 'skills' as const },
+      {
+        root: '.claude/get-shit-done/skills',
+        path: join(homedir(), '.claude', 'get-shit-done', 'skills'),
+        scope: 'import-only',
+        kind: 'skills' as const,
+        deprecated: true,
+      },
+      {
+        root: '.claude/commands/gsd',
+        path: join(homedir(), '.claude', 'commands', 'gsd'),
+        scope: 'legacy-commands',
+        kind: 'commands' as const,
+        deprecated: true,
+      },
+    ];
+
+  const skills: SkillManifestSkill[] = [];
+  const roots: SkillManifestRoot[] = [];
+  let legacyClaudeCommandsInstalled = false;
+
+  for (const rootInfo of canonicalRoots) {
+    const rootPath = rootInfo.path;
+    const rootSummary: SkillManifestRoot = {
+      root: rootInfo.root,
+      path: rootPath,
+      scope: rootInfo.scope,
+      present: existsSync(rootPath),
+      deprecated: 'deprecated' in rootInfo ? !!rootInfo.deprecated : false,
+    };
+
+    if (!rootSummary.present) {
+      roots.push(rootSummary);
+      continue;
+    }
+
+    if (rootInfo.kind === 'commands') {
+      let entries: Dirent[];
+      try {
+        entries = readdirSync(rootPath, { withFileTypes: true });
+      } catch {
+        roots.push(rootSummary);
+        continue;
+      }
+      const commandFiles = entries.filter(e => e.isFile() && e.name.endsWith('.md'));
+      rootSummary.command_count = commandFiles.length;
+      if (rootSummary.command_count > 0) legacyClaudeCommandsInstalled = true;
+      roots.push(rootSummary);
+      continue;
+    }
+
+    let entries: Dirent[];
+    try {
+      entries = readdirSync(rootPath, { withFileTypes: true });
+    } catch {
+      roots.push(rootSummary);
+      continue;
+    }
+
+    let skillCount = 0;
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const entryName = entry.name.toString();
+      const skillMdPath = join(rootPath, entryName, 'SKILL.md');
+      if (!existsSync(skillMdPath)) continue;
+
+      let content: string;
+      try {
+        content = readFileSync(skillMdPath, 'utf-8');
+      } catch {
+        continue;
+      }
+
+      const frontmatter = extractFrontmatterLeading(content);
+      const name = (frontmatter.name as string) || entryName;
+      const description = (frontmatter.description as string) || '';
+
+      const triggers: string[] = [];
+      const bodyMatch = content.match(/^---[\s\S]*?---\s*\n([\s\S]*)$/);
+      if (bodyMatch) {
+        const body = bodyMatch[1];
+        const triggerLines = body.match(/^TRIGGER\s+when:\s*(.+)$/gim);
+        if (triggerLines) {
+          for (const line of triggerLines) {
+            const m = line.match(/^TRIGGER\s+when:\s*(.+)$/i);
+            if (m) triggers.push(m[1].trim());
+          }
+        }
+      }
+
+      skills.push({
+        name,
+        description,
+        triggers,
+        path: entryName,
+        file_path: `${entryName}/SKILL.md`,
+        root: rootInfo.root,
+        scope: rootInfo.scope,
+        installed: rootInfo.scope !== 'import-only',
+        deprecated: !!('deprecated' in rootInfo && rootInfo.deprecated),
+      });
+      skillCount++;
+    }
+
+    rootSummary.skill_count = skillCount;
+    roots.push(rootSummary);
+  }
+
+  skills.sort((a, b) => {
+    const rootCmp = a.root.localeCompare(b.root);
+    return rootCmp !== 0 ? rootCmp : a.name.localeCompare(b.name);
+  });
+
+  const gsdSkillsInstalled = skills.some(skill => skill.name.startsWith('gsd-'));
+
+  return {
+    skills,
+    roots,
+    installation: {
+      gsd_skills_installed: gsdSkillsInstalled,
+      legacy_claude_commands_installed: legacyClaudeCommandsInstalled,
+    },
+    counts: {
+      skills: skills.length,
+      roots: roots.length,
+    },
+  };
+}
+
+/**
+ * `skill-manifest` — same flags as gsd-tools: `--skills-dir`, `--write`.
+ */
+export const skillManifest: QueryHandler = async (args, projectDir) => {
+  const skillsDirIdx = args.indexOf('--skills-dir');
+  const skillsDir = skillsDirIdx >= 0 && args[skillsDirIdx + 1] ? args[skillsDirIdx + 1] : null;
+  const manifest = buildSkillManifest(projectDir, skillsDir);
+
+  if (args.includes('--write')) {
+    const planningDir = join(projectDir, '.planning');
+    if (existsSync(planningDir)) {
+      const manifestPath = join(planningDir, 'skill-manifest.json');
+      writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+    }
+  }
+
+  return { data: manifest };
+};

package/sdk/src/query/skills.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Tests for agent skills query handler.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { agentSkills } from './skills.js';
+
+function writeSkill(rootDir: string, name: string, description = 'Skill under test') {
+  const skillDir = join(rootDir, name);
+  return mkdir(skillDir, { recursive: true }).then(() => writeFile(join(skillDir, 'SKILL.md'), [
+    '---',
+    `name: ${name}`,
+    `description: ${description}`,
+    '---',
+    '',
+    `# ${name}`,
+  ].join('\n')));
+}
+
+describe('agentSkills', () => {
+  let tmpDir: string;
+  let homeDir: string;
+
+  it('returns empty string when no agent type (matches gsd-tools)', async () => {
+    const r = await agentSkills([], tmpdir());
+    expect(r.data).toBe('');
+  });
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'gsd-skills-'));
+    homeDir = await mkdtemp(join(tmpdir(), 'gsd-skills-home-'));
+    await writeSkill(join(tmpDir, '.cursor', 'skills'), 'my-skill');
+    await writeSkill(join(tmpDir, '.codex', 'skills'), 'project-codex');
+    await mkdir(join(tmpDir, '.claude', 'skills', 'orphaned-dir'), { recursive: true });
+    await writeSkill(join(homeDir, '.claude', 'skills'), 'global-claude');
+    await writeSkill(join(homeDir, '.codex', 'skills'), 'global-codex');
+    await writeSkill(join(homeDir, '.claude', 'get-shit-done', 'skills'), 'legacy-import');
+    vi.stubEnv('HOME', homeDir);
+    // Windows `os.homedir()` reads USERPROFILE, not HOME
+    vi.stubEnv('USERPROFILE', homeDir);
+  });
+
+  afterEach(async () => {
+    vi.unstubAllEnvs();
+    await rm(tmpDir, { recursive: true, force: true });
+    await rm(homeDir, { recursive: true, force: true });
+  });
+
+  it('returns deduped skill names from project and managed global skill dirs', async () => {
+    const r = await agentSkills(['gsd-executor'], tmpDir);
+    const data = r.data as Record<string, unknown>;
+    const skills = data.skills as string[];
+
+    expect(skills).toEqual(expect.arrayContaining([
+      'my-skill',
+      'project-codex',
+      'global-claude',
+      'global-codex',
+    ]));
+    expect(skills).not.toContain('orphaned-dir');
+    expect(skills).not.toContain('legacy-import');
+    expect(data.skill_count).toBe(skills.length);
+  });
+
+  it('counts deduped skill names when the same skill exists in multiple roots', async () => {
+    await writeSkill(join(tmpDir, '.claude', 'skills'), 'shared-skill');
+    await writeSkill(join(tmpDir, '.agents', 'skills'), 'shared-skill');
+
+    const r = await agentSkills(['gsd-executor'], tmpDir);
+    const data = r.data as Record<string, unknown>;
+    const skills = data.skills as string[];
+
+    expect(skills.filter((skill) => skill === 'shared-skill')).toHaveLength(1);
+    expect(data.skill_count).toBe(skills.length);
+  });
+});

package/sdk/src/query/skills.ts

@@ -0,0 +1,62 @@
+/**
+ * Agent skills query handler — scan installed skill directories.
+ *
+ * Reads from project `.claude/skills/`, `.agents/skills/`, `.cursor/skills/`,
+ * `.github/skills/`, `.codex/skills/`, plus managed global `~/.claude/skills/`
+ * and `~/.codex/skills/` roots.
+ *
+ * @example
+ * ```typescript
+ * import { agentSkills } from './skills.js';
+ *
+ * await agentSkills(['gsd-executor'], '/project');
+ * // { data: { agent_type: 'gsd-executor', skills: ['plan', 'verify'], skill_count: 2 } }
+ * await agentSkills([], '/project');
+ * // { data: '' } — matches gsd-tools when no agent type is passed
+ * ```
+ */
+
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+import type { QueryHandler } from './utils.js';
+
+export const agentSkills: QueryHandler = async (args, projectDir) => {
+  const agentType = (args[0] || '').trim();
+  // Match gsd-tools `cmdAgentSkills`: no agent type → empty string (JSON `""`), not a structured object.
+  if (!agentType) {
+    return { data: '' };
+  }
+  const skillDirs = [
+    join(projectDir, '.claude', 'skills'),
+    join(projectDir, '.agents', 'skills'),
+    join(projectDir, '.cursor', 'skills'),
+    join(projectDir, '.github', 'skills'),
+    join(projectDir, '.codex', 'skills'),
+    join(homedir(), '.claude', 'skills'),
+    join(homedir(), '.codex', 'skills'),
+  ];
+
+  const skills: string[] = [];
+  for (const dir of skillDirs) {
+    if (!existsSync(dir)) continue;
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (!existsSync(join(dir, entry.name, 'SKILL.md'))) continue;
+        skills.push(entry.name);
+      }
+    } catch { /* skip */ }
+  }
+
+  const dedupedSkills = [...new Set(skills)];
+  return {
+    data: {
+      agent_type: agentType,
+      skills: dedupedSkills,
+      skill_count: dedupedSkills.length,
+    },
+  };
+};