@sentry/warden 0.0.0

package/src/cli/commands/add.ts

@@ -0,0 +1,447 @@
+import { existsSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import chalk from 'chalk';
+import select from '@inquirer/select';
+import { getRepoRoot } from '../git.js';
+import { loadWardenConfig, appendTrigger } from '../../config/index.js';
+import type { Trigger } from '../../config/schema.js';
+import { discoverAllSkills, type DiscoveredSkill } from '../../skills/loader.js';
+import {
+  fetchRemote,
+  discoverRemoteSkills,
+  parseRemoteRef,
+  type DiscoveredRemoteSkill,
+} from '../../skills/remote.js';
+import type { Reporter } from '../output/reporter.js';
+import type { CLIOptions } from '../args.js';
+import { ICON_CHECK } from '../output/icons.js';
+
+/** Custom theme for select prompts - white for selected, gray for unselected */
+const selectTheme = {
+  prefix: {
+    idle: '',
+    done: '',
+  },
+  icon: {
+    cursor: chalk.white('›'),
+  },
+  style: {
+    message: () => '', // We print heading separately
+    highlight: (text: string) => chalk.white(text),
+    disabled: (text: string) => chalk.dim(text),
+    description: (text: string) => chalk.white(text),
+    keysHelpTip: (keys: [key: string, action: string][]) => {
+      const keyStr = keys.map(([key, action]) => `${key} ${action}`).join(', ');
+      return `\n${chalk.dim(keyStr)}`;
+    },
+  },
+};
+
+/**
+ * Render the list of available local skills.
+ */
+function renderSkillList(
+  skills: Map<string, DiscoveredSkill>,
+  configuredSkills: Set<string>,
+  reporter: Reporter
+): void {
+  reporter.bold('Available Skills');
+  reporter.blank();
+
+  // Sort skills alphabetically by name
+  const sortedSkills = Array.from(skills.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+
+  for (const [name, discovered] of sortedSkills) {
+    const isConfigured = configuredSkills.has(name);
+    const dirTag = chalk.dim(`[${discovered.directory}]`);
+    const configuredTag = isConfigured ? chalk.dim(' (already configured)') : '';
+
+    if (reporter.mode.isTTY) {
+      const icon = isConfigured ? chalk.dim(ICON_CHECK) : ' ';
+      reporter.text(`  ${icon} ${chalk.bold(name)} ${dirTag}${configuredTag}`);
+      reporter.text(`    ${chalk.dim(discovered.skill.description)}`);
+    } else {
+      const status = isConfigured ? '[configured]' : '';
+      reporter.text(`${name} ${status} [${discovered.directory}]`);
+      reporter.text(`  ${discovered.skill.description}`);
+    }
+  }
+}
+
+/**
+ * Render the list of available remote skills.
+ */
+function renderRemoteSkillList(
+  skills: DiscoveredRemoteSkill[],
+  configuredSkills: Set<string>,
+  remote: string,
+  reporter: Reporter
+): void {
+  reporter.bold(`Available Skills from ${remote}`);
+  reporter.blank();
+
+  // Sort skills alphabetically by name
+  const sortedSkills = [...skills].sort((a, b) => a.name.localeCompare(b.name));
+
+  for (const skill of sortedSkills) {
+    const isConfigured = configuredSkills.has(skill.name);
+    const configuredTag = isConfigured ? chalk.dim(' (already configured)') : '';
+
+    if (reporter.mode.isTTY) {
+      const icon = isConfigured ? chalk.dim(ICON_CHECK) : ' ';
+      reporter.text(`  ${icon} ${chalk.bold(skill.name)}${configuredTag}`);
+      reporter.text(`    ${chalk.dim(skill.description)}`);
+    } else {
+      const status = isConfigured ? '[configured]' : '';
+      reporter.text(`${skill.name} ${status}`);
+      reporter.text(`  ${skill.description}`);
+    }
+  }
+}
+
+/**
+ * Prompt user to select a local skill interactively.
+ */
+async function promptSkillSelection(
+  skills: Map<string, DiscoveredSkill>,
+  configuredSkills: Set<string>,
+  reporter: Reporter,
+): Promise<string | null> {
+  // Filter out already configured skills for selection
+  const availableSkills = Array.from(skills.entries())
+    .filter(([name]) => !configuredSkills.has(name))
+    .sort((a, b) => a[0].localeCompare(b[0]));
+
+  if (availableSkills.length === 0) {
+    reporter.warning('All available skills are already configured.');
+    return null;
+  }
+
+  const choices = availableSkills.map(([name, discovered]) => {
+    return {
+      name: `${name} ${chalk.dim(`[${discovered.directory}]`)}`,
+      value: name,
+      description: discovered.skill.description,
+    };
+  });
+
+  reporter.bold('ADD SKILL');
+  reporter.blank();
+
+  try {
+    const answer = await select({
+      message: '',
+      choices,
+      theme: selectTheme,
+    });
+    // Clear the inquirer "done" line
+    process.stderr.write('\x1b[1A\x1b[2K');
+    return answer;
+  } catch {
+    // User cancelled (Ctrl+C or escape)
+    return null;
+  }
+}
+
+/**
+ * Prompt user to select a remote skill interactively.
+ */
+async function promptRemoteSkillSelection(
+  skills: DiscoveredRemoteSkill[],
+  configuredSkills: Set<string>,
+  reporter: Reporter,
+): Promise<string | null> {
+  // Filter out already configured skills for selection
+  const availableSkills = skills
+    .filter((s) => !configuredSkills.has(s.name))
+    .sort((a, b) => a.name.localeCompare(b.name));
+
+  if (availableSkills.length === 0) {
+    reporter.warning('All available skills are already configured.');
+    return null;
+  }
+
+  const choices = availableSkills.map((skill) => {
+    return {
+      name: skill.name,
+      value: skill.name,
+      description: skill.description,
+    };
+  });
+
+  reporter.bold('ADD REMOTE SKILL');
+  reporter.blank();
+
+  try {
+    const answer = await select({
+      message: '',
+      choices,
+      theme: selectTheme,
+    });
+    // Clear the inquirer "done" line
+    process.stderr.write('\x1b[1A\x1b[2K');
+    return answer;
+  } catch {
+    // User cancelled (Ctrl+C or escape)
+    return null;
+  }
+}
+
+/**
+ * Create a default trigger for a local skill.
+ */
+function createDefaultTrigger(skillName: string): Trigger {
+  return {
+    name: skillName,
+    event: 'pull_request',
+    actions: ['opened', 'synchronize', 'reopened'],
+    skill: skillName,
+  };
+}
+
+/**
+ * Create a trigger for a remote skill.
+ */
+function createRemoteTrigger(skillName: string, remote: string): Trigger {
+  return {
+    name: skillName,
+    event: 'pull_request',
+    actions: ['opened', 'synchronize', 'reopened'],
+    skill: skillName,
+    remote,
+  };
+}
+
+/**
+ * Run the add command for remote skills.
+ */
+async function runAddRemote(
+  options: CLIOptions,
+  reporter: Reporter,
+  configPath: string,
+  configuredSkills: Set<string>
+): Promise<number> {
+  const remote = options.remote ?? '';
+  if (!remote) {
+    reporter.error('Remote repository is required');
+    return 1;
+  }
+  const cwd = process.cwd();
+
+  // Validate remote ref format
+  try {
+    parseRemoteRef(remote);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    reporter.error(message);
+    return 1;
+  }
+
+  // Fetch remote repository
+  reporter.step(`Fetching skills from ${remote}...`);
+  try {
+    await fetchRemote(remote, {
+      onProgress: (msg) => reporter.debug(msg),
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    reporter.error(`Failed to fetch remote: ${message}`);
+    return 1;
+  }
+
+  // Discover skills in the remote
+  const remoteSkills = await discoverRemoteSkills(remote);
+
+  if (remoteSkills.length === 0) {
+    reporter.error(`No skills found in remote: ${remote}`);
+    return 1;
+  }
+
+  reporter.success(`Found ${remoteSkills.length} skill${remoteSkills.length === 1 ? '' : 's'}`);
+
+  // Handle --list: display remote skills and exit
+  if (options.list) {
+    reporter.blank();
+    renderRemoteSkillList(remoteSkills, configuredSkills, remote, reporter);
+    return 0;
+  }
+
+  // Get skill to add (from --skill or interactive prompt)
+  let skillName: string | null;
+
+  if (options.skill) {
+    skillName = options.skill;
+  } else if (reporter.mode.isTTY) {
+    reporter.blank();
+    skillName = await promptRemoteSkillSelection(remoteSkills, configuredSkills, reporter);
+    if (!skillName) {
+      return 0; // User quit or no skills available
+    }
+  } else {
+    reporter.error('Skill name required when not running interactively.');
+    reporter.tip(`Use: warden add --remote ${remote} --skill <name>`);
+    return 1;
+  }
+
+  // Validate skill exists in remote
+  const skill = remoteSkills.find((s) => s.name === skillName);
+  if (!skill) {
+    reporter.error(`Skill '${skillName}' not found in remote: ${remote}`);
+    reporter.blank();
+    reporter.tip('Available skills:');
+    for (const s of remoteSkills) {
+      reporter.text(`  - ${s.name}`);
+    }
+    return 1;
+  }
+
+  // Check for duplicate trigger
+  if (configuredSkills.has(skillName)) {
+    reporter.warning(`Trigger '${skillName}' already exists in warden.toml`);
+    reporter.skipped(relative(cwd, configPath), 'trigger already configured');
+    return 0;
+  }
+
+  // Append trigger to warden.toml
+  const trigger = createRemoteTrigger(skillName, remote);
+  try {
+    appendTrigger(configPath, trigger);
+    reporter.success(`Added trigger '${skillName}' to ${relative(cwd, configPath)}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    reporter.error(`Failed to update warden.toml: ${message}`);
+    return 1;
+  }
+
+  // Show success message
+  reporter.blank();
+  reporter.text(`The trigger will run on pull requests using skill from ${chalk.cyan(remote)}.`);
+  reporter.text(`Edit ${chalk.cyan('warden.toml')} to customize filters and output options.`);
+
+  return 0;
+}
+
+/**
+ * Run the add command.
+ */
+export async function runAdd(options: CLIOptions, reporter: Reporter): Promise<number> {
+  const cwd = process.cwd();
+
+  // 1. Check git repo
+  let repoRoot: string;
+  try {
+    repoRoot = getRepoRoot(cwd);
+  } catch {
+    reporter.error('Not a git repository. Run this command from a git repository.');
+    return 1;
+  }
+
+  // 2. Check warden.toml exists (deferred for --list without --remote)
+  const configPath = join(repoRoot, 'warden.toml');
+  const hasConfig = existsSync(configPath);
+
+  // 3. Load existing config if available
+  let configuredSkills = new Set<string>();
+  if (hasConfig) {
+    try {
+      const config = loadWardenConfig(repoRoot);
+      configuredSkills = new Set(config.triggers.map((t) => t.name));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      reporter.error(`Failed to load warden.toml: ${message}`);
+      return 1;
+    }
+  }
+
+  // 4. Handle remote skills with --remote flag
+  if (options.remote) {
+    // For remote skills, require warden.toml (unless --list)
+    if (!hasConfig && !options.list) {
+      reporter.error('warden.toml not found.');
+      reporter.tip('Run `warden init` first to create the configuration file.');
+      return 1;
+    }
+
+    return runAddRemote(options, reporter, configPath, configuredSkills);
+  }
+
+  // 5. Discover local skills
+  const skills = await discoverAllSkills(repoRoot, {
+    onWarning: (message) => reporter.warning(message),
+  });
+
+  if (skills.size === 0) {
+    reporter.error('No skills found.');
+    reporter.tip('Add skills to .warden/skills/, .agents/skills/, or .claude/skills/');
+    reporter.tip('Or use --remote to add remote skills: warden add --remote owner/repo --skill name');
+    return 1;
+  }
+
+  // 6. Handle --list: display skills and exit (works without warden.toml)
+  if (options.list) {
+    renderSkillList(skills, configuredSkills, reporter);
+    return 0;
+  }
+
+  // 7. For adding skills, require warden.toml
+  if (!hasConfig) {
+    reporter.error('warden.toml not found.');
+    reporter.tip('Run `warden init` first to create the configuration file.');
+    return 1;
+  }
+
+  // 8. Get skill to add (from arg or interactive prompt)
+  let skillName: string | null;
+
+  if (options.skill) {
+    // Non-interactive: skill specified as argument
+    skillName = options.skill;
+  } else if (reporter.mode.isTTY) {
+    // Interactive mode
+    skillName = await promptSkillSelection(skills, configuredSkills, reporter);
+    if (!skillName) {
+      return 0; // User quit or no skills available
+    }
+  } else {
+    // Non-TTY and no skill specified
+    reporter.error('Skill name required when not running interactively.');
+    reporter.tip('Use: warden add <skill-name> or warden add --list');
+    return 1;
+  }
+
+  // 9. Validate skill exists
+  if (!skills.has(skillName)) {
+    reporter.error(`Skill not found: ${skillName}`);
+    reporter.blank();
+    reporter.tip('Available skills:');
+    for (const name of skills.keys()) {
+      reporter.text(`  - ${name}`);
+    }
+    return 1;
+  }
+
+  // 10. Check for duplicate trigger
+  if (configuredSkills.has(skillName)) {
+    reporter.warning(`Trigger '${skillName}' already exists in warden.toml`);
+    reporter.skipped(relative(cwd, configPath), 'trigger already configured');
+    return 0;
+  }
+
+  // 11. Append trigger to warden.toml
+  const trigger = createDefaultTrigger(skillName);
+  try {
+    appendTrigger(configPath, trigger);
+    reporter.success(`Added trigger '${skillName}' to ${relative(cwd, configPath)}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    reporter.error(`Failed to update warden.toml: ${message}`);
+    return 1;
+  }
+
+  // 12. Show success message with next steps
+  reporter.blank();
+  reporter.text(`The trigger will run on pull requests.`);
+  reporter.text(`Edit ${chalk.cyan('warden.toml')} to customize filters and output options.`);
+
+  return 0;
+}

package/src/cli/commands/init.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execSync } from 'node:child_process';
+import { runInit } from './init.js';
+import { Reporter } from '../output/reporter.js';
+import { detectOutputMode } from '../output/tty.js';
+import { Verbosity } from '../output/verbosity.js';
+import type { CLIOptions } from '../args.js';
+
+function createMockReporter(): Reporter {
+  return new Reporter(detectOutputMode(false), Verbosity.Normal);
+}
+
+function createOptions(overrides: Partial<CLIOptions> = {}): CLIOptions {
+  return {
+    json: false,
+    help: false,
+    quiet: false,
+    verbose: 0,
+    fix: false,
+    force: false,
+    list: false,
+    git: false,
+    offline: false,
+    ...overrides,
+  };
+}
+
+describe('init command', () => {
+  let tempDir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `warden-init-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+    originalCwd = process.cwd();
+    process.chdir(tempDir);
+    // Initialize git repo for tests
+    execSync('git init', { cwd: tempDir, stdio: 'ignore' });
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('file creation', () => {
+    it('creates warden.toml and workflow in fresh repo', async () => {
+      const reporter = createMockReporter();
+      const exitCode = await runInit(createOptions(), reporter);
+
+      expect(exitCode).toBe(0);
+      expect(existsSync(join(tempDir, 'warden.toml'))).toBe(true);
+      expect(existsSync(join(tempDir, '.github', 'workflows', 'warden.yml'))).toBe(true);
+    });
+
+    it('creates warden.toml with correct content', async () => {
+      const reporter = createMockReporter();
+      await runInit(createOptions(), reporter);
+
+      const content = readFileSync(join(tempDir, 'warden.toml'), 'utf-8');
+      expect(content).toContain('version = 1');
+    });
+
+    it('creates workflow with correct content', async () => {
+      const reporter = createMockReporter();
+      await runInit(createOptions(), reporter);
+
+      const content = readFileSync(join(tempDir, '.github', 'workflows', 'warden.yml'), 'utf-8');
+      expect(content).toContain('name: Warden');
+      expect(content).toContain('pull_request');
+      expect(content).toContain('permissions:');
+      expect(content).toContain('pull-requests: write');
+      expect(content).toContain('checks: write');
+      expect(content).toContain('WARDEN_ANTHROPIC_API_KEY');
+      expect(content).toContain('getsentry/warden@v1');
+    });
+  });
+
+  describe('existing files', () => {
+    it('skips existing files without --force', async () => {
+      // Create existing files
+      writeFileSync(join(tempDir, 'warden.toml'), 'existing content');
+      mkdirSync(join(tempDir, '.github', 'workflows'), { recursive: true });
+      writeFileSync(join(tempDir, '.github', 'workflows', 'warden.yml'), 'existing workflow');
+
+      const reporter = createMockReporter();
+      await runInit(createOptions(), reporter);
+
+      // Files should not be overwritten
+      expect(readFileSync(join(tempDir, 'warden.toml'), 'utf-8')).toBe('existing content');
+      expect(readFileSync(join(tempDir, '.github', 'workflows', 'warden.yml'), 'utf-8')).toBe('existing workflow');
+    });
+
+    it('overwrites existing files with --force', async () => {
+      // Create existing files
+      writeFileSync(join(tempDir, 'warden.toml'), 'existing content');
+      mkdirSync(join(tempDir, '.github', 'workflows'), { recursive: true });
+      writeFileSync(join(tempDir, '.github', 'workflows', 'warden.yml'), 'existing workflow');
+
+      const reporter = createMockReporter();
+      await runInit(createOptions({ force: true }), reporter);
+
+      // Files should be overwritten with new content
+      const tomlContent = readFileSync(join(tempDir, 'warden.toml'), 'utf-8');
+      expect(tomlContent).toContain('version = 1');
+      expect(tomlContent).not.toBe('existing content');
+
+      const workflowContent = readFileSync(join(tempDir, '.github', 'workflows', 'warden.yml'), 'utf-8');
+      expect(workflowContent).toContain('name: Warden');
+      expect(workflowContent).not.toBe('existing workflow');
+    });
+  });
+
+  describe('error handling', () => {
+    it('fails when not in a git repository', async () => {
+      // Create a non-git directory
+      const nonGitDir = join(tmpdir(), `warden-non-git-${Date.now()}`);
+      mkdirSync(nonGitDir, { recursive: true });
+      process.chdir(nonGitDir);
+
+      try {
+        const reporter = createMockReporter();
+        const exitCode = await runInit(createOptions(), reporter);
+
+        expect(exitCode).toBe(1);
+        expect(existsSync(join(nonGitDir, 'warden.toml'))).toBe(false);
+      } finally {
+        process.chdir(originalCwd);
+        rmSync(nonGitDir, { recursive: true, force: true });
+      }
+    });
+  });
+});

package/src/cli/commands/init.ts

@@ -0,0 +1,132 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import chalk from 'chalk';
+import { getRepoRoot, getGitHubRepoUrl } from '../git.js';
+import type { Reporter } from '../output/reporter.js';
+import type { CLIOptions } from '../args.js';
+
+/**
+ * Template for warden.toml configuration file.
+ */
+function generateWardenToml(): string {
+  return `version = 1
+`;
+}
+
+/**
+ * Template for GitHub Actions workflow file.
+ */
+function generateWorkflowYaml(): string {
+  return `name: Warden
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: write
+  checks: write
+
+jobs:
+  review:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: getsentry/warden@v1
+        with:
+          anthropic-api-key: \${{ secrets.WARDEN_ANTHROPIC_API_KEY }}
+`;
+}
+
+/**
+ * Check for existing warden configuration files.
+ */
+function checkExistingFiles(repoRoot: string): {
+  hasWardenToml: boolean;
+  hasWorkflow: boolean;
+} {
+  const wardenTomlPath = join(repoRoot, 'warden.toml');
+  const workflowPath = join(repoRoot, '.github', 'workflows', 'warden.yml');
+
+  return {
+    hasWardenToml: existsSync(wardenTomlPath),
+    hasWorkflow: existsSync(workflowPath),
+  };
+}
+
+export interface InitOptions {
+  force: boolean;
+}
+
+/**
+ * Run the init command to scaffold warden configuration.
+ */
+export async function runInit(options: CLIOptions, reporter: Reporter): Promise<number> {
+  const cwd = process.cwd();
+
+  // Find repo root
+  let repoRoot: string;
+  try {
+    repoRoot = getRepoRoot(cwd);
+  } catch {
+    reporter.error('Not a git repository. Run this command from a git repository.');
+    return 1;
+  }
+
+  // Check for existing files
+  const existing = checkExistingFiles(repoRoot);
+
+  let filesCreated = 0;
+
+  // Create warden.toml
+  const wardenTomlPath = join(repoRoot, 'warden.toml');
+  if (existing.hasWardenToml && !options.force) {
+    reporter.skipped(relative(cwd, wardenTomlPath), 'already exists');
+  } else {
+    const content = generateWardenToml();
+    writeFileSync(wardenTomlPath, content, 'utf-8');
+    reporter.created(relative(cwd, wardenTomlPath));
+    filesCreated++;
+  }
+
+  // Create .github/workflows directory if needed
+  const workflowDir = join(repoRoot, '.github', 'workflows');
+  if (!existsSync(workflowDir)) {
+    mkdirSync(workflowDir, { recursive: true });
+  }
+
+  // Create workflow file
+  const workflowPath = join(workflowDir, 'warden.yml');
+  if (existing.hasWorkflow && !options.force) {
+    reporter.skipped(relative(cwd, workflowPath), 'already exists');
+  } else {
+    const content = generateWorkflowYaml();
+    writeFileSync(workflowPath, content, 'utf-8');
+    reporter.created(relative(cwd, workflowPath));
+    filesCreated++;
+  }
+
+  if (filesCreated === 0) {
+    reporter.blank();
+    reporter.tip('All configuration files already exist. Use --force to overwrite.');
+    return 0;
+  }
+
+  // Print next steps
+  reporter.blank();
+  reporter.bold('Next steps:');
+  reporter.text(`  1. Add a skill: ${chalk.cyan('warden add <skill-name>')}`);
+  reporter.text(`  2. Set ${chalk.cyan('WARDEN_ANTHROPIC_API_KEY')} in .env.local`);
+  reporter.text(`  3. Add ${chalk.cyan('WARDEN_ANTHROPIC_API_KEY')} to repository secrets`);
+
+  // Show GitHub secrets URL if available
+  const githubUrl = getGitHubRepoUrl(repoRoot);
+  if (githubUrl) {
+    reporter.text(`     ${chalk.dim(githubUrl + '/settings/secrets/actions')}`);
+  }
+
+  reporter.text('  4. Commit and open a PR to test');
+
+  return 0;
+}