@sundial-ai/cli 0.1.0

package/src/utils/fuzzy-match.ts

@@ -0,0 +1,48 @@
+import fuzzysort from 'fuzzysort';
+
+const VALID_COMMANDS = ['add', 'remove', 'list', 'show', 'config'];
+
+export interface FuzzyMatch {
+  command: string;
+  score: number;
+}
+
+/**
+ * Find the closest matching command using fuzzy search.
+ * fuzzysort scores: 0 = perfect match, negative = worse match
+ */
+export function findClosestCommand(input: string): FuzzyMatch | null {
+  const results = fuzzysort.go(input, VALID_COMMANDS, {
+    // Allow any match (we'll filter by score later)
+    threshold: -Infinity
+  });
+
+  if (results.length === 0) {
+    return null;
+  }
+
+  const best = results[0];
+  return {
+    command: best.target,
+    score: best.score
+  };
+}
+
+/**
+ * Suggest a command if the input is close enough to a valid command.
+ * Returns null if no good suggestion (avoids suggesting "add" for "xyz").
+ */
+export function suggestCommand(input: string): string | null {
+  const match = findClosestCommand(input);
+
+  // Only suggest if score is reasonable (0=perfect, -100 is still decent for typos)
+  // Examples: "ad" -> "add" (good), "addd" -> "add" (good), "xyz" -> null (no suggestion)
+  if (match && match.score > -100) {
+    return match.command;
+  }
+  return null;
+}
+
+export function getValidCommands(): string[] {
+  return [...VALID_COMMANDS];
+}

package/src/utils/prompts.ts

@@ -0,0 +1,92 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { SUPPORTED_AGENTS, getSupportedAgentsMessage } from '../core/agents.js';
+import type { AgentType, DetectedAgent } from '../types/index.js';
+
+/**
+ * Show an interactive checkbox UI for selecting default agents.
+ *
+ * @param detectedAgents - Agents found in local/global directories
+ * @param currentDefaults - Previously saved defaults (empty on first run)
+ * @returns Array of selected agent flags (e.g., ['claude', 'codex'])
+ *
+ * Behavior:
+ * - First run (currentDefaults empty): ALL detected agents are pre-selected
+ * - Subsequent runs: Only previously saved defaults are pre-selected
+ * - If no agents detected: Show all supported agents (none pre-selected)
+ */
+export async function promptAgentSelection(
+  detectedAgents: DetectedAgent[],
+  currentDefaults: AgentType[] = []
+): Promise<AgentType[]> {
+  const isFirstRun = currentDefaults.length === 0;
+
+  // Show what we detected
+  if (detectedAgents.length > 0) {
+    console.log(chalk.cyan(`\nWe detected ${detectedAgents.length} agent folders installed on your machine:`));
+    for (const detected of detectedAgents) {
+      const location = detected.isGlobal ? '~/' : './';
+      console.log(chalk.white(`  • ${detected.agent.name} ${chalk.gray(`(${location}${detected.agent.folderName})`)}`));
+    }
+    console.log();
+  }
+
+  console.log(chalk.gray(getSupportedAgentsMessage()));
+  console.log(chalk.gray('Select which agents you want to add skills to by default:\n'));
+
+  // Build choices from detected agents
+  const choices = detectedAgents.map(detected => {
+    const location = detected.isGlobal ? '(global)' : '(local)';
+    const agentFlag = detected.agent.flag as AgentType;
+
+    return {
+      name: `${detected.agent.name} ${chalk.gray(location)}`,
+      value: agentFlag,
+      // First run: select ALL detected agents
+      // Otherwise: only select if it was in previous defaults
+      checked: isFirstRun ? true : currentDefaults.includes(agentFlag)
+    };
+  });
+
+  // If no agents detected, show all supported agents as options
+  if (choices.length === 0) {
+    console.log(chalk.yellow('No agent folders detected on your machine.'));
+    console.log(chalk.gray('Showing all supported agents - select which ones you plan to use:\n'));
+    for (const agent of SUPPORTED_AGENTS) {
+      choices.push({
+        name: agent.name,
+        value: agent.flag as AgentType,
+        checked: false // None pre-selected since we don't know which they'll install
+      });
+    }
+  }
+
+  const { selectedAgents } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedAgents',
+      message: 'Select default agents:',
+      choices,
+      validate: (answer: AgentType[]) => {
+        if (answer.length === 0) {
+          return 'You must select at least one agent.';
+        }
+        return true;
+      }
+    }
+  ]);
+
+  return selectedAgents;
+}
+
+export async function confirmAction(message: string): Promise<boolean> {
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message,
+      default: true
+    }
+  ]);
+  return confirmed;
+}

package/src/utils/registry.ts

@@ -0,0 +1,16 @@
+/** Skill shortcuts registry - maps short names to GitHub URLs */
+export const SKILL_SHORTCUTS: Record<string, string> = {
+  tinker: 'https://github.com/sundial-org/skills/tree/main/skills/tinker'
+};
+
+export function isShortcut(skill: string): boolean {
+  return skill in SKILL_SHORTCUTS;
+}
+
+export function getShortcutUrl(skill: string): string | undefined {
+  return SKILL_SHORTCUTS[skill];
+}
+
+export function listShortcuts(): string[] {
+  return Object.keys(SKILL_SHORTCUTS);
+}

package/test/agents.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from 'vitest';
+import {
+  SUPPORTED_AGENTS,
+  getAgentByFlag,
+  getAgentByFolder,
+  getSupportedAgentsMessage,
+  isValidAgentType,
+  getAgentFlags
+} from '../src/core/agents.js';
+
+describe('agents', () => {
+  describe('SUPPORTED_AGENTS', () => {
+    it('should have claude, codex, and gemini agents', () => {
+      const flags = SUPPORTED_AGENTS.map(a => a.flag);
+      expect(flags).toContain('claude');
+      expect(flags).toContain('codex');
+      expect(flags).toContain('gemini');
+    });
+
+    it('each agent should have name, flag, and folderName', () => {
+      for (const agent of SUPPORTED_AGENTS) {
+        expect(agent.name).toBeTruthy();
+        expect(agent.flag).toBeTruthy();
+        expect(agent.folderName).toBeTruthy();
+        expect(agent.folderName.startsWith('.')).toBe(true);
+      }
+    });
+  });
+
+  describe('getAgentByFlag', () => {
+    it('returns correct agent for valid flag', () => {
+      const claude = getAgentByFlag('claude');
+      expect(claude).toBeDefined();
+      expect(claude?.name).toBe('Claude Code');
+      expect(claude?.folderName).toBe('.claude');
+    });
+
+    it('returns undefined for invalid flag', () => {
+      expect(getAgentByFlag('invalid')).toBeUndefined();
+      expect(getAgentByFlag('')).toBeUndefined();
+    });
+  });
+
+  describe('getAgentByFolder', () => {
+    it('returns correct agent for valid folder', () => {
+      const codex = getAgentByFolder('.codex');
+      expect(codex).toBeDefined();
+      expect(codex?.flag).toBe('codex');
+    });
+
+    it('returns undefined for invalid folder', () => {
+      expect(getAgentByFolder('codex')).toBeUndefined(); // missing dot
+      expect(getAgentByFolder('.invalid')).toBeUndefined();
+    });
+  });
+
+  describe('getSupportedAgentsMessage', () => {
+    it('includes all agent names', () => {
+      const message = getSupportedAgentsMessage();
+      expect(message).toContain('Claude Code');
+      expect(message).toContain('Codex');
+      expect(message).toContain('Gemini');
+      expect(message).toContain('Currently supported agents:');
+    });
+  });
+
+  describe('isValidAgentType', () => {
+    it('returns true for valid agent flags', () => {
+      expect(isValidAgentType('claude')).toBe(true);
+      expect(isValidAgentType('codex')).toBe(true);
+      expect(isValidAgentType('gemini')).toBe(true);
+    });
+
+    it('returns false for invalid flags', () => {
+      expect(isValidAgentType('invalid')).toBe(false);
+      expect(isValidAgentType('')).toBe(false);
+    });
+  });
+
+  describe('getAgentFlags', () => {
+    it('returns array of all agent flags', () => {
+      const flags = getAgentFlags();
+      expect(flags).toEqual(['claude', 'codex', 'gemini']);
+    });
+  });
+});

package/test/fuzzy-match.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import {
+  findClosestCommand,
+  suggestCommand,
+  getValidCommands
+} from '../src/utils/fuzzy-match.js';
+
+describe('fuzzy-match', () => {
+  describe('findClosestCommand', () => {
+    it('finds exact matches', () => {
+      const match = findClosestCommand('add');
+      expect(match).not.toBeNull();
+      expect(match?.command).toBe('add');
+      // fuzzysort returns positive scores for matches
+      expect(match?.score).toBeGreaterThanOrEqual(0);
+    });
+
+    it('finds partial matches', () => {
+      const match = findClosestCommand('rem');
+      expect(match).not.toBeNull();
+      expect(match?.command).toBe('remove');
+    });
+
+    it('finds matches for single character typos', () => {
+      const match = findClosestCommand('lst');
+      expect(match).not.toBeNull();
+      expect(match?.command).toBe('list');
+    });
+  });
+
+  describe('suggestCommand', () => {
+    it('suggests for close matches', () => {
+      expect(suggestCommand('ad')).toBe('add');
+      expect(suggestCommand('remov')).toBe('remove');
+      expect(suggestCommand('lis')).toBe('list');
+    });
+
+    it('returns null for completely different input', () => {
+      expect(suggestCommand('xyz')).toBeNull();
+      expect(suggestCommand('foobar')).toBeNull();
+    });
+
+    it('returns exact match', () => {
+      expect(suggestCommand('config')).toBe('config');
+    });
+  });
+
+  describe('getValidCommands', () => {
+    it('returns all valid commands', () => {
+      const commands = getValidCommands();
+      expect(commands).toContain('add');
+      expect(commands).toContain('remove');
+      expect(commands).toContain('list');
+      expect(commands).toContain('show');
+      expect(commands).toContain('config');
+    });
+  });
+});

package/test/registry.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import {
+  SKILL_SHORTCUTS,
+  isShortcut,
+  getShortcutUrl,
+  listShortcuts
+} from '../src/utils/registry.js';
+
+describe('registry', () => {
+  describe('SKILL_SHORTCUTS', () => {
+    it('should have tinker shortcut', () => {
+      expect(SKILL_SHORTCUTS.tinker).toBeDefined();
+      expect(SKILL_SHORTCUTS.tinker).toContain('github.com');
+    });
+  });
+
+  describe('isShortcut', () => {
+    it('returns true for registered shortcuts', () => {
+      expect(isShortcut('tinker')).toBe(true);
+    });
+
+    it('returns false for non-shortcuts', () => {
+      expect(isShortcut('not-a-shortcut')).toBe(false);
+      expect(isShortcut('github.com/user/repo')).toBe(false);
+      expect(isShortcut('./local-path')).toBe(false);
+    });
+  });
+
+  describe('getShortcutUrl', () => {
+    it('returns URL for valid shortcut', () => {
+      const url = getShortcutUrl('tinker');
+      expect(url).toBeDefined();
+      expect(url).toContain('sundial-org/skills');
+    });
+
+    it('returns undefined for invalid shortcut', () => {
+      expect(getShortcutUrl('invalid')).toBeUndefined();
+    });
+  });
+
+  describe('listShortcuts', () => {
+    it('returns list of all shortcuts', () => {
+      const shortcuts = listShortcuts();
+      expect(shortcuts).toContain('tinker');
+      expect(Array.isArray(shortcuts)).toBe(true);
+    });
+  });
+});

package/test/skill-hash.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { computeContentHash } from '../src/core/skill-hash.js';
+
+describe('skill-hash', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = path.join(os.tmpdir(), `sun-test-hash-${Date.now()}`);
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  describe('computeContentHash', () => {
+    it('returns consistent hash for same content', async () => {
+      await fs.writeFile(path.join(tempDir, 'file.txt'), 'hello world');
+
+      const hash1 = await computeContentHash(tempDir);
+      const hash2 = await computeContentHash(tempDir);
+
+      expect(hash1).toBe(hash2);
+    });
+
+    it('returns different hash for different content', async () => {
+      const dir1 = path.join(tempDir, 'dir1');
+      const dir2 = path.join(tempDir, 'dir2');
+      await fs.ensureDir(dir1);
+      await fs.ensureDir(dir2);
+
+      await fs.writeFile(path.join(dir1, 'file.txt'), 'content 1');
+      await fs.writeFile(path.join(dir2, 'file.txt'), 'content 2');
+
+      const hash1 = await computeContentHash(dir1);
+      const hash2 = await computeContentHash(dir2);
+
+      expect(hash1).not.toBe(hash2);
+    });
+
+    it('returns hash for empty folder', async () => {
+      const hash = await computeContentHash(tempDir);
+      expect(hash).toBeTruthy();
+      expect(hash.length).toBe(12); // Truncated to 12 chars
+    });
+
+    it('includes subdirectory content in hash', async () => {
+      const subDir = path.join(tempDir, 'subdir');
+      await fs.ensureDir(subDir);
+      await fs.writeFile(path.join(subDir, 'nested.txt'), 'nested content');
+
+      const hashBefore = await computeContentHash(tempDir);
+
+      await fs.writeFile(path.join(subDir, 'nested.txt'), 'modified content');
+
+      const hashAfter = await computeContentHash(tempDir);
+
+      expect(hashBefore).not.toBe(hashAfter);
+    });
+
+    it('hash changes when file is renamed', async () => {
+      await fs.writeFile(path.join(tempDir, 'original.txt'), 'content');
+      const hash1 = await computeContentHash(tempDir);
+
+      await fs.rename(
+        path.join(tempDir, 'original.txt'),
+        path.join(tempDir, 'renamed.txt')
+      );
+      const hash2 = await computeContentHash(tempDir);
+
+      expect(hash1).not.toBe(hash2);
+    });
+  });
+});

package/test/skill-info.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import {
+  isValidSkillDirectory,
+  findSkillDirectories,
+  readSkillMetadata,
+  getSkillName
+} from '../src/core/skill-info.js';
+
+describe('skill-info', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = path.join(os.tmpdir(), `sun-test-info-${Date.now()}`);
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  const createSkillMd = (name: string, description: string, extras = '') => `---
+name: ${name}
+description: ${description}
+${extras}
+---
+
+# ${name}
+
+This is the skill documentation.
+`;
+
+  describe('isValidSkillDirectory', () => {
+    it('returns true for directory with valid SKILL.md', async () => {
+      await fs.writeFile(
+        path.join(tempDir, 'SKILL.md'),
+        createSkillMd('test-skill', 'A test skill')
+      );
+
+      expect(await isValidSkillDirectory(tempDir)).toBe(true);
+    });
+
+    it('returns false for directory without SKILL.md', async () => {
+      expect(await isValidSkillDirectory(tempDir)).toBe(false);
+    });
+
+    it('returns false for SKILL.md without name', async () => {
+      await fs.writeFile(
+        path.join(tempDir, 'SKILL.md'),
+        `---
+description: A skill without name
+---
+`
+      );
+
+      expect(await isValidSkillDirectory(tempDir)).toBe(false);
+    });
+
+    it('returns false for SKILL.md without description', async () => {
+      await fs.writeFile(
+        path.join(tempDir, 'SKILL.md'),
+        `---
+name: nameless
+---
+`
+      );
+
+      expect(await isValidSkillDirectory(tempDir)).toBe(false);
+    });
+  });
+
+  describe('findSkillDirectories', () => {
+    it('returns empty array for directory with no skills', async () => {
+      const skills = await findSkillDirectories(tempDir);
+      expect(skills).toEqual([]);
+    });
+
+    it('finds skill if path itself is a skill', async () => {
+      await fs.writeFile(
+        path.join(tempDir, 'SKILL.md'),
+        createSkillMd('test-skill', 'A test skill')
+      );
+
+      const skills = await findSkillDirectories(tempDir);
+      expect(skills).toHaveLength(1);
+      expect(skills[0]).toBe(tempDir);
+    });
+
+    it('finds skills in direct children', async () => {
+      const skill1 = path.join(tempDir, 'skill-one');
+      const skill2 = path.join(tempDir, 'skill-two');
+      await fs.ensureDir(skill1);
+      await fs.ensureDir(skill2);
+
+      await fs.writeFile(
+        path.join(skill1, 'SKILL.md'),
+        createSkillMd('skill-one', 'First skill')
+      );
+      await fs.writeFile(
+        path.join(skill2, 'SKILL.md'),
+        createSkillMd('skill-two', 'Second skill')
+      );
+
+      const skills = await findSkillDirectories(tempDir);
+      expect(skills).toHaveLength(2);
+      expect(skills).toContain(skill1);
+      expect(skills).toContain(skill2);
+    });
+
+    it('does not search deeper than direct children', async () => {
+      const nested = path.join(tempDir, 'level1', 'level2');
+      await fs.ensureDir(nested);
+      await fs.writeFile(
+        path.join(nested, 'SKILL.md'),
+        createSkillMd('nested-skill', 'A nested skill')
+      );
+
+      const skills = await findSkillDirectories(tempDir);
+      expect(skills).toHaveLength(0);
+    });
+  });
+
+  describe('readSkillMetadata', () => {
+    it('reads name and description from frontmatter', async () => {
+      await fs.writeFile(
+        path.join(tempDir, 'SKILL.md'),
+        createSkillMd('my-skill', 'My skill description')
+      );
+
+      const metadata = await readSkillMetadata(tempDir);
+      expect(metadata).not.toBeNull();
+      expect(metadata?.name).toBe('my-skill');
+      expect(metadata?.description).toBe('My skill description');
+    });
+
+    it('reads optional fields', async () => {
+      await fs.writeFile(
+        path.join(tempDir, 'SKILL.md'),
+        createSkillMd('my-skill', 'Description', `license: MIT
+compatibility: Node.js 18+`)
+      );
+
+      const metadata = await readSkillMetadata(tempDir);
+      expect(metadata?.license).toBe('MIT');
+      expect(metadata?.compatibility).toBe('Node.js 18+');
+    });
+
+    it('reads metadata block', async () => {
+      await fs.writeFile(
+        path.join(tempDir, 'SKILL.md'),
+        `---
+name: my-skill
+description: A skill
+metadata:
+  author: Test Author
+  version: 1.0.0
+---
+`
+      );
+
+      const metadata = await readSkillMetadata(tempDir);
+      expect(metadata?.metadata?.author).toBe('Test Author');
+      expect(metadata?.metadata?.version).toBe('1.0.0');
+    });
+
+    it('returns null for invalid SKILL.md', async () => {
+      await fs.writeFile(
+        path.join(tempDir, 'SKILL.md'),
+        'No frontmatter here'
+      );
+
+      const metadata = await readSkillMetadata(tempDir);
+      expect(metadata).toBeNull();
+    });
+  });
+
+  describe('getSkillName', () => {
+    it('returns name from frontmatter', async () => {
+      await fs.writeFile(
+        path.join(tempDir, 'SKILL.md'),
+        createSkillMd('canonical-name', 'Description')
+      );
+
+      const name = await getSkillName(tempDir);
+      expect(name).toBe('canonical-name');
+    });
+
+    it('returns null for invalid skill', async () => {
+      const name = await getSkillName(tempDir);
+      expect(name).toBeNull();
+    });
+  });
+});