@sundial-ai/cli 0.0.1

package/src/commands/config.ts

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+import { getSupportedAgentsMessage, SUPPORTED_AGENTS } from '../core/agents.js';
+import { loadConfig, setDefaultAgents, getConfigPath } from '../core/config-manager.js';
+import { promptAgentSelection } from '../utils/prompts.js';
+
+/**
+ * Re-open agent selection dialog and update config.
+ */
+export async function configCommand(): Promise<void> {
+  const config = await loadConfig();
+
+  console.log(chalk.cyan('Sundial CLI Configuration'));
+  console.log(chalk.gray(`Config file: ${getConfigPath()}`));
+  console.log();
+
+  // Show current defaults
+  if (config.defaultAgents.length > 0) {
+    console.log('Current default agents:');
+    for (const agentFlag of config.defaultAgents) {
+      const agent = SUPPORTED_AGENTS.find(a => a.flag === agentFlag);
+      if (agent) {
+        console.log(`  - ${agent.name} ${chalk.gray(`(~/${agent.folderName}/ and ./${agent.folderName}/)`)}`);
+      }
+    }
+    console.log();
+  }
+
+  console.log(chalk.gray(getSupportedAgentsMessage()));
+  console.log();
+
+  // Show agent type selection dialog
+  const selectedAgents = await promptAgentSelection(config.defaultAgents);
+
+  await setDefaultAgents(selectedAgents);
+
+  console.log();
+  console.log(chalk.green('Configuration saved!'));
+
+  // Show new defaults
+  console.log('New default agents:');
+  for (const agentFlag of selectedAgents) {
+    const agent = SUPPORTED_AGENTS.find(a => a.flag === agentFlag);
+    if (agent) {
+      console.log(`  - ${agent.name} ${chalk.gray(`(~/${agent.folderName}/ and ./${agent.folderName}/)`)}`);
+    }
+  }
+}

package/src/commands/list.ts

@@ -0,0 +1,68 @@
+import chalk from 'chalk';
+import { SUPPORTED_AGENTS, getSupportedAgentsMessage } from '../core/agents.js';
+import { listSkillsForAgent } from '../core/skill-info.js';
+
+interface AgentSkills {
+  agentName: string;
+  folderName: string;
+  isGlobal: boolean;
+  skills: string[];
+}
+
+/**
+ * List all installed skills for each agent.
+ */
+export async function listCommand(): Promise<void> {
+  const allAgentSkills: AgentSkills[] = [];
+
+  // Check both local and global for each agent
+  for (const agent of SUPPORTED_AGENTS) {
+    // Local
+    const localSkills = await listSkillsForAgent(agent.folderName, false);
+    if (localSkills.length > 0) {
+      allAgentSkills.push({
+        agentName: agent.name,
+        folderName: agent.folderName,
+        isGlobal: false,
+        skills: localSkills
+      });
+    }
+
+    // Global
+    const globalSkills = await listSkillsForAgent(agent.folderName, true);
+    if (globalSkills.length > 0) {
+      allAgentSkills.push({
+        agentName: agent.name,
+        folderName: agent.folderName,
+        isGlobal: true,
+        skills: globalSkills
+      });
+    }
+  }
+
+  if (allAgentSkills.length === 0) {
+    console.log(chalk.yellow('No skills installed.'));
+    console.log();
+    console.log(chalk.gray(getSupportedAgentsMessage()));
+    console.log(chalk.gray('You can add skills with "sun add <skill>"'));
+    return;
+  }
+
+  // Print skills grouped by agent
+  for (const agentSkills of allAgentSkills) {
+    const location = agentSkills.isGlobal
+      ? `global ~/${agentSkills.folderName}/`
+      : `${agentSkills.folderName}/`;
+
+    console.log(chalk.cyan(`${agentSkills.agentName} (${location}):`));
+
+    for (const skill of agentSkills.skills) {
+      console.log(`  - ${skill}`);
+    }
+
+    console.log();
+  }
+
+  console.log(chalk.gray(getSupportedAgentsMessage()));
+  console.log(chalk.gray('You can add skills with "sun add <skill>" or remove with "sun remove <skill>"'));
+}

package/src/commands/remove.ts

@@ -0,0 +1,154 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getAgentByFlag, SUPPORTED_AGENTS } from '../core/agents.js';
+import { getDefaultAgents } from '../core/config-manager.js';
+import { detectLocalAgents } from '../core/agent-detect.js';
+import { removeSkill } from '../core/skill-install.js';
+import type { AgentType, CommandFlags } from '../types/index.js';
+
+/**
+ * Determine which agents to remove from and whether to target global installs.
+ * Uses same logic as add command (except no first-run prompt).
+ *
+ * Logic:
+ * 1. If --global flag is set, always target global
+ * 2. If agent flags (--claude, --codex, etc.) are set, use those agents
+ * 3. Otherwise use saved default agents (error if none configured)
+ *
+ * For local vs global:
+ * - If --global: always global
+ * - Otherwise: check if any configured agents have local folders
+ *   - If yes: target local
+ *   - If no local folders exist for configured agents: target global
+ */
+async function resolveTargetAgents(flags: CommandFlags): Promise<{ agents: AgentType[]; isGlobal: boolean }> {
+  const forceGlobal = flags.global ?? false;
+
+  // Check if any agent flags were explicitly set
+  const explicitAgents: AgentType[] = [];
+  for (const agent of SUPPORTED_AGENTS) {
+    if (flags[agent.flag as keyof CommandFlags]) {
+      explicitAgents.push(agent.flag as AgentType);
+    }
+  }
+
+  let targetAgents: AgentType[];
+
+  // Determine which agents to target
+  if (explicitAgents.length > 0) {
+    targetAgents = explicitAgents;
+  } else {
+    // Use saved defaults (no first-run prompt for remove)
+    const defaultAgents = await getDefaultAgents();
+    if (defaultAgents.length === 0) {
+      throw new Error('No default agents configured. Run "sun add" first or use --claude/--codex/--gemini flags.');
+    }
+    targetAgents = defaultAgents;
+  }
+
+  // Determine if we should target global or local
+  if (forceGlobal) {
+    return { agents: targetAgents, isGlobal: true };
+  }
+
+  // Check if any of the target agents have local folders in current directory
+  const localAgents = await detectLocalAgents();
+  const localAgentFlags = new Set(localAgents.map(a => a.agent.flag));
+
+  const hasLocalFolders = targetAgents.some(agentFlag => localAgentFlags.has(agentFlag));
+
+  // If no local folders exist for any configured agent, target global
+  const isGlobal = !hasLocalFolders;
+
+  return { agents: targetAgents, isGlobal };
+}
+
+export interface RemoveResult {
+  skill: string;
+  removedFrom: string[];
+  notFoundIn: string[];
+  isGlobal: boolean;
+  error?: string;
+}
+
+/**
+ * Remove skill(s) from agent configuration(s).
+ */
+export async function removeCommand(skills: string[], flags: CommandFlags): Promise<void> {
+  if (skills.length === 0) {
+    console.error(chalk.red('Error: No skills specified. Usage: sun remove <skill> [skill2] ...'));
+    process.exit(1);
+  }
+
+  // Resolve target agents
+  let agents: AgentType[];
+  let isGlobal: boolean;
+
+  try {
+    const resolved = await resolveTargetAgents(flags);
+    agents = resolved.agents;
+    isGlobal = resolved.isGlobal;
+  } catch (error) {
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+
+  const results: RemoveResult[] = [];
+
+  for (const skill of skills) {
+    const spinner = ora(`Removing ${skill}...`).start();
+
+    const result: RemoveResult = {
+      skill,
+      removedFrom: [],
+      notFoundIn: [],
+      isGlobal
+    };
+
+    try {
+      // Remove from each target agent
+      for (const agentFlag of agents) {
+        const removed = await removeSkill(skill, agentFlag, isGlobal);
+        const agentName = getAgentByFlag(agentFlag)!.name;
+
+        if (removed) {
+          result.removedFrom.push(agentName);
+        } else {
+          result.notFoundIn.push(agentName);
+        }
+      }
+
+      if (result.removedFrom.length > 0) {
+        spinner.succeed(`Removed ${skill} from ${result.removedFrom.join(' and ')}`);
+      } else {
+        const pathPrefix = isGlobal ? '~/' : './';
+        const checkedPaths = agents.map(a => `${pathPrefix}${getAgentByFlag(a)!.folderName}/`);
+        spinner.warn(`${skill} not found in configured agents (${checkedPaths.join(', ')})`);
+      }
+
+      if (result.notFoundIn.length > 0 && result.removedFrom.length > 0) {
+        console.log(chalk.gray(`  (not found in: ${result.notFoundIn.join(', ')})`));
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      result.error = message;
+      spinner.fail(`Failed to remove ${skill}: ${message}`);
+    }
+
+    results.push(result);
+  }
+
+  // Print summary if multiple skills
+  if (skills.length > 1) {
+    const totalRemoved = results.filter(r => r.removedFrom.length > 0).length;
+    const totalFailed = results.filter(r => r.error || r.removedFrom.length === 0).length;
+
+    console.log();
+    if (totalRemoved > 0) {
+      console.log(chalk.green(`Removed ${totalRemoved} skill(s)`));
+    }
+    if (totalFailed > 0) {
+      console.log(chalk.yellow(`${totalFailed} skill(s) not found or failed`));
+    }
+  }
+}

package/src/commands/show-dev.ts

@@ -0,0 +1,223 @@
+/**
+ * Dev-only show commands for debugging and exploration.
+ * These search the entire file system starting from home directory.
+ */
+
+import chalk from 'chalk';
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { SUPPORTED_AGENTS } from '../core/agents.js';
+import { readSkillMetadata } from '../core/skill-info.js';
+
+const execAsync = promisify(exec);
+
+// Timeout for find commands (60 seconds)
+const FIND_TIMEOUT = 60000;
+
+/**
+ * List skills in a directory, returning name and description.
+ */
+async function listSkillsInDir(skillsDir: string): Promise<Array<{ name: string; description: string }>> {
+  const skills: Array<{ name: string; description: string }> = [];
+
+  if (!await fs.pathExists(skillsDir)) {
+    return skills;
+  }
+
+  const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const skillPath = path.join(skillsDir, entry.name);
+      const metadata = await readSkillMetadata(skillPath);
+      if (metadata) {
+        skills.push({
+          name: metadata.name,
+          description: metadata.description
+        });
+      }
+    }
+  }
+
+  return skills;
+}
+
+/**
+ * sun show all-agent-folders
+ * Find ALL agent folders (.claude, .codex, .gemini) starting from ~ and show skills in each.
+ */
+export async function showAllAgentFolders(): Promise<void> {
+  const homeDir = os.homedir();
+
+  // Build find command: find ~ -type d \( -name ".claude" -o -name ".codex" -o -name ".gemini" \)
+  const namePatterns = SUPPORTED_AGENTS.map(a => `-name "${a.folderName}"`).join(' -o ');
+  const findCmd = `find "${homeDir}" -type d \\( ${namePatterns} \\)`;
+
+  console.log(chalk.cyan('All Agent Folders'));
+  console.log(chalk.gray('─'.repeat(40)));
+  console.log();
+
+  let stdout = '';
+  try {
+    const result = await execAsync(findCmd, { maxBuffer: 10 * 1024 * 1024, timeout: FIND_TIMEOUT });
+    stdout = result.stdout;
+  } catch (err: any) {
+    // find exits non-zero on permission errors but still produces output
+    if (err.stdout) {
+      stdout = err.stdout;
+    } else {
+      console.log(chalk.red('Failed to search for agent folders.'));
+      console.log(chalk.gray(String(err)));
+      return;
+    }
+  }
+
+  const agentPaths = stdout.trim().split('\n').filter(Boolean);
+
+  if (agentPaths.length === 0) {
+    console.log(chalk.yellow('No agent folders found.'));
+    return;
+  }
+
+  for (const agentPath of agentPaths) {
+    const folderName = path.basename(agentPath);
+    const agent = SUPPORTED_AGENTS.find(a => a.folderName === folderName);
+    if (!agent) continue;
+
+    console.log(chalk.white.bold(agent.name));
+    console.log(chalk.gray(`  ${agentPath}`));
+
+    // List skills
+    const skillsDir = path.join(agentPath, 'skills');
+    const skills = await listSkillsInDir(skillsDir);
+
+    if (skills.length === 0) {
+      console.log(chalk.gray('  No skills installed'));
+    } else {
+      console.log(`  Skills (${skills.length}):`);
+      for (const skill of skills) {
+        console.log(`    - ${skill.name} ${chalk.gray(`- ${skill.description}`)}`);
+      }
+    }
+    console.log();
+  }
+}
+
+/**
+ * sun show all-agent-skills-folders
+ * Find ALL <agent>/skills folders starting from ~ and show skills in each.
+ */
+export async function showAllAgentSkillsFolders(): Promise<void> {
+  const homeDir = os.homedir();
+
+  // Build find command for skills directories inside agent folders
+  // e.g., find ~ -type d \( -path "*/.claude/skills" -o -path "*/.codex/skills" -o -path "*/.gemini/skills" \)
+  const pathPatterns = SUPPORTED_AGENTS.map(a => `-path "*/${a.folderName}/skills"`).join(' -o ');
+  const findCmd = `find "${homeDir}" -type d \\( ${pathPatterns} \\)`;
+
+  console.log(chalk.cyan('All Agent Skills Folders'));
+  console.log(chalk.gray('─'.repeat(40)));
+  console.log();
+
+  let stdout = '';
+  try {
+    const result = await execAsync(findCmd, { maxBuffer: 10 * 1024 * 1024, timeout: FIND_TIMEOUT });
+    stdout = result.stdout;
+  } catch (err: any) {
+    if (err.stdout) {
+      stdout = err.stdout;
+    } else {
+      console.log(chalk.red('Failed to search for skills folders.'));
+      console.log(chalk.gray(String(err)));
+      return;
+    }
+  }
+
+  const skillsDirs = stdout.trim().split('\n').filter(Boolean);
+
+  if (skillsDirs.length === 0) {
+    console.log(chalk.yellow('No agent skills folders found.'));
+    return;
+  }
+
+  for (const skillsDir of skillsDirs) {
+    // Get agent name from parent folder
+    const agentFolder = path.basename(path.dirname(skillsDir));
+    const agent = SUPPORTED_AGENTS.find(a => a.folderName === agentFolder);
+
+    console.log(chalk.white.bold(agent?.name ?? agentFolder));
+    console.log(chalk.gray(`  ${skillsDir}`));
+
+    // List skills
+    const skills = await listSkillsInDir(skillsDir);
+
+    if (skills.length === 0) {
+      console.log(chalk.gray('  No skills installed'));
+    } else {
+      console.log(`  Skills (${skills.length}):`);
+      for (const skill of skills) {
+        console.log(`    - ${skill.name} ${chalk.gray(`- ${skill.description}`)}`);
+      }
+    }
+    console.log();
+  }
+}
+
+/**
+ * sun show all-skill-folders
+ * Find ALL folders containing a valid SKILL.md (with name/description frontmatter).
+ */
+export async function showAllSkillFolders(): Promise<void> {
+  const homeDir = os.homedir();
+
+  // Find all SKILL.md files
+  const findCmd = `find "${homeDir}" -name "SKILL.md" -type f`;
+
+  console.log(chalk.cyan('All Skill Folders'));
+  console.log(chalk.gray('─'.repeat(40)));
+  console.log();
+
+  let stdout = '';
+  try {
+    const result = await execAsync(findCmd, { maxBuffer: 10 * 1024 * 1024, timeout: FIND_TIMEOUT });
+    stdout = result.stdout;
+  } catch (err: any) {
+    if (err.stdout) {
+      stdout = err.stdout;
+    } else {
+      console.log(chalk.red('Failed to search for SKILL.md files.'));
+      console.log(chalk.gray(String(err)));
+      return;
+    }
+  }
+
+  const skillMdPaths = stdout.trim().split('\n').filter(Boolean);
+
+  if (skillMdPaths.length === 0) {
+    console.log(chalk.yellow('No SKILL.md files found.'));
+    return;
+  }
+
+  let validCount = 0;
+
+  for (const skillMdPath of skillMdPaths) {
+    const skillDir = path.dirname(skillMdPath);
+    const metadata = await readSkillMetadata(skillDir);
+
+    // Only show if it has valid name and description
+    if (metadata && metadata.name && metadata.description) {
+      validCount++;
+      console.log(chalk.white.bold(metadata.name));
+      console.log(chalk.gray(`  ${skillDir}`));
+      console.log(`  ${metadata.description}`);
+      console.log();
+    }
+  }
+
+  if (validCount === 0) {
+    console.log(chalk.yellow('No valid SKILL.md files found (missing name/description frontmatter).'));
+  }
+}

package/src/commands/show.ts

@@ -0,0 +1,203 @@
+import chalk from 'chalk';
+import path from 'path';
+import { findSkillInstallations, readSkillMetadata } from '../core/skill-info.js';
+import { getAgentByFlag } from '../core/agents.js';
+import { detectAllAgents, detectLocalAgents } from '../core/agent-detect.js';
+import { getDefaultAgents } from '../core/config-manager.js';
+import { showAllAgentFolders, showAllAgentSkillsFolders, showAllSkillFolders } from './show-dev.js';
+import fs from 'fs-extra';
+
+/**
+ * List all skills in a given skills directory path.
+ */
+async function listSkillsInPath(skillsDir: string): Promise<Array<{ name: string; description: string }>> {
+  const skills: Array<{ name: string; description: string }> = [];
+
+  if (!await fs.pathExists(skillsDir)) {
+    return skills;
+  }
+
+  const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const skillPath = path.join(skillsDir, entry.name);
+      const metadata = await readSkillMetadata(skillPath);
+      if (metadata) {
+        skills.push({
+          name: metadata.name,
+          description: metadata.description
+        });
+      }
+    }
+  }
+
+  return skills;
+}
+
+/**
+ * Show all agent folders and their installed skills.
+ */
+async function showAllAgents(): Promise<void> {
+  const allAgents = await detectAllAgents();
+  const defaultAgents = await getDefaultAgents();
+  const defaultSet = new Set(defaultAgents);
+  const localAgents = await detectLocalAgents();
+  const localAgentFlags = new Set(localAgents.map(a => a.agent.flag));
+
+  if (allAgents.length === 0) {
+    console.log(chalk.yellow('No agent folders found.'));
+    console.log(chalk.gray('Agent folders are directories like .claude/, .codex/, .gemini/'));
+    return;
+  }
+
+  console.log(chalk.cyan('Agent Folders & Installed Skills'));
+  console.log(chalk.gray('─'.repeat(40)));
+  console.log();
+
+  for (const detected of allAgents) {
+    const { agent, path: agentPath, isGlobal } = detected;
+    const locationLabel = isGlobal ? chalk.gray('(global)') : chalk.gray('(local)');
+    const isDefault = defaultSet.has(agent.flag as any);
+    const hasLocalFolder = localAgentFlags.has(agent.flag);
+
+    // Show checkmark if this folder would be affected by sun add/remove:
+    // - Local folder: affected if agent is selected
+    // - Global folder: affected if agent is selected AND no local folder exists
+    const wouldBeAffected = isDefault && (isGlobal ? !hasLocalFolder : true);
+    const marker = wouldBeAffected ? chalk.green('✓') : chalk.gray('○');
+
+    console.log(`${marker} ${chalk.white.bold(agent.name)} ${locationLabel}`);
+    console.log(chalk.gray(`  ${agentPath}`));
+
+    // List skills in this agent folder
+    const skillsDir = path.join(agentPath, 'skills');
+    const skills = await listSkillsInPath(skillsDir);
+
+    if (skills.length === 0) {
+      console.log(chalk.gray('  No skills installed'));
+    } else {
+      console.log(`  Skills (${skills.length}):`);
+      for (const skill of skills) {
+        console.log(`    - ${skill.name} ${chalk.gray(`- ${skill.description}`)}`);
+      }
+    }
+    console.log();
+  }
+
+  console.log(`${chalk.green('✓')} = affected by sun add/remove in this directory`);
+  console.log('Run "sun config" to change selected agents.');
+}
+
+/**
+ * Show skill details and installation locations.
+ * If no skill specified, shows all agent folders and their packages.
+ *
+ * Secret commands (not in README, documented in DEV.md):
+ * - all-agent-folders: Find all agent folders on the system
+ * - all-agent-skills-folders: Find all <agent>/skills folders
+ * - all-skill-folders: Find all folders with valid SKILL.md
+ */
+export async function showCommand(skillName?: string): Promise<void> {
+  // Handle secret dev commands
+  if (skillName === 'all-agent-folders') {
+    await showAllAgentFolders();
+    return;
+  }
+
+  if (skillName === 'all-agent-skills-folders') {
+    await showAllAgentSkillsFolders();
+    return;
+  }
+
+  if (skillName === 'all-skill-folders') {
+    await showAllSkillFolders();
+    return;
+  }
+
+  // If no skill specified, show all agents and their packages
+  if (!skillName) {
+    await showAllAgents();
+    return;
+  }
+
+  const installations = await findSkillInstallations(skillName);
+
+  if (installations.length === 0) {
+    console.error(chalk.yellow(`Skill "${skillName}" is not installed.`));
+    process.exit(1);
+  }
+
+  // Check if there are multiple versions (different content hashes)
+  const uniqueHashes = new Set(installations.map(i => i.contentHash));
+  const hasMultipleVersions = uniqueHashes.size > 1;
+
+  if (hasMultipleVersions) {
+    // Multiple versions detected
+    console.log(chalk.cyan(`Skill: ${skillName}`));
+    console.log(chalk.yellow('Warning: Multiple versions detected'));
+    console.log();
+
+    // Group by content hash
+    const byHash = new Map<string, typeof installations>();
+    for (const inst of installations) {
+      const existing = byHash.get(inst.contentHash) || [];
+      existing.push(inst);
+      byHash.set(inst.contentHash, existing);
+    }
+
+    let versionNum = 1;
+    for (const [hash, insts] of byHash) {
+      const firstInst = insts[0];
+      const locations = insts.map(i => {
+        const agent = getAgentByFlag(i.agent)!;
+        return i.isGlobal ? `~/${agent.folderName}/` : `${agent.folderName}/`;
+      });
+
+      console.log(chalk.white(`Version ${versionNum} (${locations.join(', ')}):`));
+      console.log(`  Description: ${firstInst.metadata.description}`);
+
+      if (firstInst.metadata.metadata?.author) {
+        console.log(`  Author: ${firstInst.metadata.metadata.author}`);
+      }
+      if (firstInst.metadata.metadata?.version) {
+        console.log(`  Version: ${firstInst.metadata.metadata.version}`);
+      }
+      if (firstInst.metadata.license) {
+        console.log(`  License: ${firstInst.metadata.license}`);
+      }
+
+      console.log(`  Content hash: ${hash}`);
+      console.log();
+
+      versionNum++;
+    }
+  } else {
+    // Single version across all installations
+    const firstInst = installations[0];
+
+    console.log(chalk.cyan(`Skill: ${skillName}`));
+    console.log(`Description: ${firstInst.metadata.description}`);
+
+    if (firstInst.metadata.metadata?.author) {
+      console.log(`Author: ${firstInst.metadata.metadata.author}`);
+    }
+    if (firstInst.metadata.metadata?.version) {
+      console.log(`Version: ${firstInst.metadata.metadata.version}`);
+    }
+    if (firstInst.metadata.license) {
+      console.log(`License: ${firstInst.metadata.license}`);
+    }
+    if (firstInst.metadata.compatibility) {
+      console.log(`Compatibility: ${firstInst.metadata.compatibility}`);
+    }
+
+    console.log();
+    console.log('Installed in:');
+    for (const inst of installations) {
+      const agent = getAgentByFlag(inst.agent)!;
+      const location = inst.isGlobal ? '(global)' : '(local)';
+      console.log(`  - ${agent.folderName}/ ${chalk.gray(location)}`);
+    }
+  }
+}