@orderful/droid 0.2.0

package/src/commands/skills.ts

@@ -0,0 +1,159 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { join } from 'path';
+import {
+  getBundledSkills,
+  getBundledSkillsDir,
+  isSkillInstalled,
+  getInstalledSkill,
+  getSkillStatusDisplay,
+  installSkill,
+  uninstallSkill,
+  loadSkillManifest,
+} from '../lib/skills.js';
+import { promptForSkillConfig } from '../lib/skill-config.js';
+import { SkillStatus, type SkillManifest } from '../lib/types.js';
+
+function formatSkillChoice(skill: SkillManifest): string {
+  const installed = isSkillInstalled(skill.name);
+  const installedInfo = getInstalledSkill(skill.name);
+  const statusDisplay = getSkillStatusDisplay(skill.status);
+
+  let line = `${skill.name}`;
+
+  if (installed && installedInfo) {
+    line += chalk.green(` [installed] v${installedInfo.version}`);
+  } else {
+    line += chalk.gray(` v${skill.version}`);
+  }
+
+  if (statusDisplay) {
+    const color =
+      skill.status === SkillStatus.Alpha
+        ? chalk.red
+        : skill.status === SkillStatus.Beta
+          ? chalk.yellow
+          : chalk.white;
+    line += ` ${color(statusDisplay)}`;
+  }
+
+  return line;
+}
+
+export async function skillsCommand(): Promise<void> {
+  const skills = getBundledSkills();
+
+  if (skills.length === 0) {
+    console.log(chalk.yellow('\nNo skills available yet.'));
+    return;
+  }
+
+  console.log(chalk.bold('\n🤖 Available Skills\n'));
+
+  const skillChoices = skills.map((skill) => ({
+    name: formatSkillChoice(skill),
+    value: skill.name,
+    short: skill.name,
+  }));
+
+  const choices = [
+    {
+      name: chalk.gray('← Exit'),
+      value: '__exit__',
+      short: 'Exit',
+    },
+    ...skillChoices,
+  ];
+
+  const { selectedSkill } = await inquirer.prompt<{ selectedSkill: string }>([
+    {
+      type: 'list',
+      name: 'selectedSkill',
+      message: 'Select a skill to view details or install:',
+      choices,
+      pageSize: 15,
+    },
+  ]);
+
+  if (selectedSkill === '__exit__') {
+    return;
+  }
+
+  const skill = skills.find((s) => s.name === selectedSkill);
+  if (!skill) {
+    console.error(chalk.red('Skill not found'));
+    return;
+  }
+
+  // Show skill details
+  console.log(chalk.bold(`\n📦 ${skill.name}`));
+  console.log(chalk.gray(`Version: ${skill.version}`));
+  if (skill.status) {
+    console.log(chalk.gray(`Status: ${skill.status}`));
+  }
+  console.log(`\n${skill.description}`);
+
+  if (skill.dependencies && skill.dependencies.length > 0) {
+    console.log(chalk.gray(`\nDependencies: ${skill.dependencies.join(', ')}`));
+  }
+
+  const installed = isSkillInstalled(skill.name);
+
+  const actions = installed
+    ? [
+        { name: '← Back', value: 'back' },
+        { name: 'Configure', value: 'configure' },
+        { name: 'Uninstall', value: 'uninstall' },
+      ]
+    : [
+        { name: '← Back', value: 'back' },
+        { name: 'Install', value: 'install' },
+      ];
+
+  const { action } = await inquirer.prompt<{ action: string }>([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: actions,
+    },
+  ]);
+
+  switch (action) {
+    case 'install': {
+      const result = installSkill(skill.name);
+      if (result.success) {
+        console.log(chalk.green(`\n✓ ${result.message}`));
+        // Prompt for config if skill has options
+        const manifest = loadSkillManifest(join(getBundledSkillsDir(), skill.name));
+        if (manifest?.config_schema && Object.keys(manifest.config_schema).length > 0) {
+          await promptForSkillConfig(skill.name, manifest.config_schema, true);
+        }
+      } else {
+        console.log(chalk.red(`\n✗ ${result.message}`));
+      }
+      break;
+    }
+    case 'configure': {
+      const manifest = loadSkillManifest(join(getBundledSkillsDir(), skill.name));
+      if (manifest?.config_schema && Object.keys(manifest.config_schema).length > 0) {
+        await promptForSkillConfig(skill.name, manifest.config_schema, false);
+      } else {
+        console.log(chalk.gray('\nThis skill has no configuration options.'));
+      }
+      break;
+    }
+    case 'uninstall': {
+      const result = uninstallSkill(skill.name);
+      if (result.success) {
+        console.log(chalk.green(`\n✓ ${result.message}`));
+      } else {
+        console.log(chalk.red(`\n✗ ${result.message}`));
+      }
+      break;
+    }
+    case 'back':
+      await skillsCommand();
+      break;
+  }
+}

package/src/commands/uninstall.ts

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+import { uninstallSkill, isSkillInstalled } from '../lib/skills.js';
+
+export async function uninstallCommand(skillName: string): Promise<void> {
+  if (!isSkillInstalled(skillName)) {
+    console.error(chalk.red(`\n✗ Skill '${skillName}' is not installed`));
+    process.exit(1);
+  }
+
+  const result = uninstallSkill(skillName);
+
+  if (result.success) {
+    console.log(chalk.green(`\n✓ ${result.message}`));
+  } else {
+    console.error(chalk.red(`\n✗ ${result.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/update.ts

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { getVersion } from '../lib/version.js';
+
+interface UpdateOptions {
+  skills?: boolean;
+  cli?: boolean;
+}
+
+export async function updateCommand(skill?: string, options?: UpdateOptions): Promise<void> {
+  // If specific skill specified, update just that skill
+  if (skill) {
+    console.log(chalk.yellow('\n⚠ Per-skill updates not implemented yet'));
+    console.log(chalk.gray('Skills are bundled with the CLI - run `droid update` to update all.'));
+    return;
+  }
+
+  // If --skills flag, update skills only
+  if (options?.skills) {
+    console.log(chalk.yellow('\n⚠ Skill-only updates not implemented yet'));
+    console.log(chalk.gray('Skills are bundled with the CLI - run `droid update` to update all.'));
+    return;
+  }
+
+  // Update CLI (and bundled skills with it)
+  console.log(chalk.bold('\n🤖 Updating Droid...\n'));
+
+  const currentVersion = getVersion();
+  console.log(chalk.gray(`Current version: ${currentVersion}`));
+
+  try {
+    // Check for latest version
+    const latestVersion = execSync('npm view @orderful/droid version 2>/dev/null', {
+      encoding: 'utf-8',
+    }).trim();
+
+    if (!latestVersion) {
+      console.log(chalk.yellow('\n⚠ Could not check for updates'));
+      return;
+    }
+
+    if (latestVersion === currentVersion) {
+      console.log(chalk.green('\n✓ Already on latest version'));
+      return;
+    }
+
+    console.log(chalk.gray(`Latest version: ${latestVersion}`));
+    console.log(chalk.gray('\nUpdating...'));
+
+    execSync('npm install -g @orderful/droid@latest', { stdio: 'inherit' });
+
+    console.log(chalk.green(`\n✓ Updated to v${latestVersion}`));
+  } catch {
+    // Package might not be published yet
+    console.log(chalk.yellow('\n⚠ Could not check for updates'));
+    console.log(chalk.gray('Package may not be published yet.'));
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+// Re-export types and utilities for potential programmatic usage
+export * from './lib/types.js';
+export * from './lib/config.js';
+export * from './lib/skills.js';
+export * from './lib/version.js';

package/src/lib/config.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { existsSync, mkdirSync, rmSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import YAML from 'yaml';
+import { AITool, BuiltInOutput } from './types.js';
+
+describe('config types', () => {
+  it('should have correct enum values', () => {
+    expect(AITool.ClaudeCode).toBe('claude-code');
+    expect(AITool.OpenCode).toBe('opencode');
+    expect(BuiltInOutput.Terminal).toBe('terminal');
+    expect(BuiltInOutput.Editor).toBe('editor');
+  });
+});
+
+describe('config value parsing', () => {
+  it('should parse dot notation keys correctly', () => {
+    const keys = 'skills.comments.version'.split('.');
+    expect(keys).toEqual(['skills', 'comments', 'version']);
+  });
+
+  it('should handle single key', () => {
+    const keys = 'user_tag'.split('.');
+    expect(keys).toEqual(['user_tag']);
+  });
+});
+
+describe('YAML serialization', () => {
+  it('should serialize config correctly', () => {
+    const config = {
+      ai_tool: 'claude-code',
+      user_tag: '@fry',
+      output_preference: 'terminal',
+      git_username: 'frytyler',
+      skills: {
+        comments: {
+          version: '0.1.0',
+          installed_at: '2025-01-01T00:00:00.000Z',
+        },
+      },
+    };
+
+    const yaml = YAML.stringify(config, { indent: 2 });
+    const parsed = YAML.parse(yaml);
+
+    expect(parsed).toEqual(config);
+  });
+
+  it('should handle empty skills object', () => {
+    const config = {
+      ai_tool: 'claude-code',
+      user_tag: '@user',
+      skills: {},
+    };
+
+    const yaml = YAML.stringify(config, { indent: 2 });
+    const parsed = YAML.parse(yaml);
+
+    expect(parsed.skills).toEqual({});
+  });
+});
+
+describe('config file operations', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `droid-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+  });
+
+  it('should create directory if it does not exist', () => {
+    const nestedDir = join(testDir, 'nested', 'path');
+    expect(existsSync(nestedDir)).toBe(false);
+
+    mkdirSync(nestedDir, { recursive: true });
+    expect(existsSync(nestedDir)).toBe(true);
+  });
+
+  it('should write and read YAML file', () => {
+    const configPath = join(testDir, 'config.yaml');
+    const config = { user_mention: '@test', ai_tool: 'claude-code' };
+
+    const content = YAML.stringify(config, { indent: 2 });
+    writeFileSync(configPath, content, 'utf-8');
+
+    const read = readFileSync(configPath, 'utf-8');
+    const parsed = YAML.parse(read);
+
+    expect(parsed.user_mention).toBe('@test');
+    expect(parsed.ai_tool).toBe('claude-code');
+  });
+});

package/src/lib/config.ts

@@ -0,0 +1,154 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import YAML from 'yaml';
+import { AITool, BuiltInOutput, type DroidConfig, type SkillOverrides } from './types.js';
+
+const CONFIG_DIR = join(homedir(), '.droid');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.yaml');
+
+const DEFAULT_CONFIG: DroidConfig = {
+  ai_tool: AITool.ClaudeCode,
+  user_mention: '@user',
+  output_preference: BuiltInOutput.Terminal,
+  git_username: '',
+  skills: {},
+};
+
+/**
+ * Ensure the config directory exists
+ */
+export function ensureConfigDir(): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Check if config file exists
+ */
+export function configExists(): boolean {
+  return existsSync(CONFIG_FILE);
+}
+
+/**
+ * Load the global config, or return defaults if none exists
+ */
+export function loadConfig(): DroidConfig {
+  ensureConfigDir();
+
+  if (!existsSync(CONFIG_FILE)) {
+    return { ...DEFAULT_CONFIG };
+  }
+
+  try {
+    const content = readFileSync(CONFIG_FILE, 'utf-8');
+    const config = YAML.parse(content) as Partial<DroidConfig>;
+    return { ...DEFAULT_CONFIG, ...config };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    console.error(`Error reading config: ${message}`);
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+/**
+ * Save the global config
+ */
+export function saveConfig(config: DroidConfig): void {
+  ensureConfigDir();
+
+  const content = YAML.stringify(config, { indent: 2 });
+  writeFileSync(CONFIG_FILE, content, 'utf-8');
+}
+
+/**
+ * Get a specific config value using dot notation
+ */
+export function getConfigValue(key: string): unknown {
+  const config = loadConfig();
+  const keys = key.split('.');
+  let value: unknown = config;
+
+  for (const k of keys) {
+    if (value === undefined || value === null || typeof value !== 'object') {
+      return undefined;
+    }
+    value = (value as Record<string, unknown>)[k];
+  }
+
+  return value;
+}
+
+/**
+ * Set a specific config value using dot notation
+ */
+export function setConfigValue(key: string, value: unknown): void {
+  const config = loadConfig();
+  const keys = key.split('.');
+  let current: Record<string, unknown> = config as unknown as Record<string, unknown>;
+
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (current[keys[i]] === undefined) {
+      current[keys[i]] = {};
+    }
+    current = current[keys[i]] as Record<string, unknown>;
+  }
+
+  current[keys[keys.length - 1]] = value;
+  saveConfig(config);
+}
+
+/**
+ * Get the path to the config file
+ */
+export function getConfigPath(): string {
+  return CONFIG_FILE;
+}
+
+/**
+ * Get the path to the config directory
+ */
+export function getConfigDir(): string {
+  return CONFIG_DIR;
+}
+
+/**
+ * Get skill-specific overrides path
+ */
+export function getSkillOverridesPath(skillName: string): string {
+  return join(CONFIG_DIR, 'skills', skillName, 'overrides.yaml');
+}
+
+/**
+ * Load skill-specific overrides
+ */
+export function loadSkillOverrides(skillName: string): SkillOverrides {
+  const overridesPath = getSkillOverridesPath(skillName);
+
+  if (!existsSync(overridesPath)) {
+    return {};
+  }
+
+  try {
+    const content = readFileSync(overridesPath, 'utf-8');
+    return (YAML.parse(content) as SkillOverrides) || {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Save skill-specific overrides
+ */
+export function saveSkillOverrides(skillName: string, overrides: SkillOverrides): void {
+  const overridesPath = getSkillOverridesPath(skillName);
+  const skillDir = join(CONFIG_DIR, 'skills', skillName);
+
+  if (!existsSync(skillDir)) {
+    mkdirSync(skillDir, { recursive: true });
+  }
+
+  const content = YAML.stringify(overrides, { indent: 2 });
+  writeFileSync(overridesPath, content, 'utf-8');
+}

package/src/lib/skill-config.ts

@@ -0,0 +1,93 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { saveSkillOverrides, loadConfig, loadSkillOverrides } from './config.js';
+import { ConfigOptionType, type SkillOverrides, type ConfigOption } from './types.js';
+
+/**
+ * Prompt user to configure a skill after install
+ */
+export async function promptForSkillConfig(
+  skillName: string,
+  configSchema: Record<string, ConfigOption>,
+  askFirst: boolean = true
+): Promise<void> {
+  const globalConfig = loadConfig();
+
+  if (askFirst) {
+    const { wantsConfigure } = await inquirer.prompt<{ wantsConfigure: boolean }>([
+      {
+        type: 'confirm',
+        name: 'wantsConfigure',
+        message: 'Would you like to configure this skill now?',
+        default: false,
+      },
+    ]);
+
+    if (!wantsConfigure) {
+      return;
+    }
+  }
+
+  console.log(chalk.bold(`\n⚙️  Configure ${skillName}\n`));
+
+  // Load existing overrides to use as defaults
+  const existingOverrides = loadSkillOverrides(skillName);
+
+  const questions = Object.entries(configSchema).map(([key, option]) => {
+    const baseQuestion = {
+      name: key,
+      message: option.description,
+    };
+
+    // Use existing override as default if present
+    const existingValue = existingOverrides[key];
+
+    switch (option.type) {
+      case ConfigOptionType.Boolean:
+        return {
+          ...baseQuestion,
+          type: 'confirm' as const,
+          default: existingValue ?? option.default ?? false,
+        };
+      case ConfigOptionType.Select:
+        return {
+          ...baseQuestion,
+          type: 'list' as const,
+          choices: option.options || [],
+          default: existingValue ?? option.default,
+        };
+      case ConfigOptionType.String:
+      default: {
+        // For user_mention, default to global config value if no existing override
+        let defaultValue = existingValue ?? option.default ?? '';
+        if (key === 'user_mention' && !existingValue && globalConfig.user_mention) {
+          defaultValue = globalConfig.user_mention;
+        }
+        return {
+          ...baseQuestion,
+          type: 'input' as const,
+          default: defaultValue,
+        };
+      }
+    }
+  });
+
+  const answers = await inquirer.prompt(questions);
+
+  // Filter out empty/default values to keep overrides minimal
+  const overrides: SkillOverrides = {};
+  for (const [key, value] of Object.entries(answers)) {
+    const schema = configSchema[key];
+    // Only save if different from default
+    if (value !== schema.default && value !== '' && value !== false) {
+      overrides[key] = value as string | boolean | number;
+    }
+  }
+
+  if (Object.keys(overrides).length > 0) {
+    saveSkillOverrides(skillName, overrides);
+    console.log(chalk.green(`\n✓ Configuration saved to ~/.droid/skills/${skillName}/overrides.yaml`));
+  } else {
+    console.log(chalk.gray('\nNo custom configuration set (using defaults).'));
+  }
+}