sauron-cli 1.1.3 → 1.3.0

package/OpenSpec-main/test/core/command-generation/generator.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect } from 'vitest';
+import { generateCommand, generateCommands } from '../../../src/core/command-generation/generator.js';
+import { claudeAdapter } from '../../../src/core/command-generation/adapters/claude.js';
+import { cursorAdapter } from '../../../src/core/command-generation/adapters/cursor.js';
+import type { CommandContent, ToolCommandAdapter } from '../../../src/core/command-generation/types.js';
+
+describe('command-generation/generator', () => {
+  const sampleContent: CommandContent = {
+    id: 'explore',
+    name: 'OpenSpec Explore',
+    description: 'Enter explore mode',
+    category: 'Workflow',
+    tags: ['workflow'],
+    body: 'Command body here.',
+  };
+
+  describe('generateCommand', () => {
+    it('should generate command with path and content using Claude adapter', () => {
+      const result = generateCommand(sampleContent, claudeAdapter);
+
+      expect(result.path).toContain('.claude');
+      expect(result.path).toContain('explore.md');
+      expect(result.fileContent).toContain('name: OpenSpec Explore');
+      expect(result.fileContent).toContain('Command body here.');
+    });
+
+    it('should generate command with path and content using Cursor adapter', () => {
+      const result = generateCommand(sampleContent, cursorAdapter);
+
+      expect(result.path).toContain('.cursor');
+      expect(result.path).toContain('opsx-explore.md');
+      expect(result.fileContent).toContain('name: /opsx-explore');
+      expect(result.fileContent).toContain('id: opsx-explore');
+      expect(result.fileContent).toContain('Command body here.');
+    });
+
+    it('should use command id for path', () => {
+      const content: CommandContent = { ...sampleContent, id: 'custom-cmd' };
+      const result = generateCommand(content, claudeAdapter);
+
+      expect(result.path).toContain('custom-cmd.md');
+    });
+
+    it('should work with custom adapter', () => {
+      const customAdapter: ToolCommandAdapter = {
+        toolId: 'custom',
+        getFilePath: (id) => `.custom/${id}.txt`,
+        formatFile: (content) => `# ${content.name}\n\n${content.body}`,
+      };
+
+      const result = generateCommand(sampleContent, customAdapter);
+
+      expect(result.path).toBe('.custom/explore.txt');
+      expect(result.fileContent).toBe('# OpenSpec Explore\n\nCommand body here.');
+    });
+  });
+
+  describe('generateCommands', () => {
+    it('should generate multiple commands', () => {
+      const contents: CommandContent[] = [
+        { ...sampleContent, id: 'explore', name: 'Explore' },
+        { ...sampleContent, id: 'new', name: 'New' },
+        { ...sampleContent, id: 'apply', name: 'Apply' },
+      ];
+
+      const results = generateCommands(contents, claudeAdapter);
+
+      expect(results).toHaveLength(3);
+      expect(results[0].path).toContain('explore.md');
+      expect(results[1].path).toContain('new.md');
+      expect(results[2].path).toContain('apply.md');
+    });
+
+    it('should return empty array for empty input', () => {
+      const results = generateCommands([], claudeAdapter);
+      expect(results).toEqual([]);
+    });
+
+    it('should preserve order of input', () => {
+      const contents: CommandContent[] = [
+        { ...sampleContent, id: 'c', name: 'C' },
+        { ...sampleContent, id: 'a', name: 'A' },
+        { ...sampleContent, id: 'b', name: 'B' },
+      ];
+
+      const results = generateCommands(contents, claudeAdapter);
+
+      expect(results[0].path).toContain('c.md');
+      expect(results[1].path).toContain('a.md');
+      expect(results[2].path).toContain('b.md');
+    });
+
+    it('should generate each command independently', () => {
+      const contents: CommandContent[] = [
+        { id: 'a', name: 'A', description: 'DA', category: 'C1', tags: ['t1'], body: 'B1' },
+        { id: 'b', name: 'B', description: 'DB', category: 'C2', tags: ['t2'], body: 'B2' },
+      ];
+
+      const results = generateCommands(contents, claudeAdapter);
+
+      expect(results[0].fileContent).toContain('name: A');
+      expect(results[0].fileContent).toContain('B1');
+      expect(results[0].fileContent).not.toContain('name: B');
+
+      expect(results[1].fileContent).toContain('name: B');
+      expect(results[1].fileContent).toContain('B2');
+      expect(results[1].fileContent).not.toContain('name: A');
+    });
+  });
+});

package/OpenSpec-main/test/core/command-generation/registry.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from 'vitest';
+import { CommandAdapterRegistry } from '../../../src/core/command-generation/registry.js';
+
+describe('command-generation/registry', () => {
+  describe('get', () => {
+    it('should return Claude adapter for "claude"', () => {
+      const adapter = CommandAdapterRegistry.get('claude');
+      expect(adapter).toBeDefined();
+      expect(adapter?.toolId).toBe('claude');
+    });
+
+    it('should return Cursor adapter for "cursor"', () => {
+      const adapter = CommandAdapterRegistry.get('cursor');
+      expect(adapter).toBeDefined();
+      expect(adapter?.toolId).toBe('cursor');
+    });
+
+    it('should return Windsurf adapter for "windsurf"', () => {
+      const adapter = CommandAdapterRegistry.get('windsurf');
+      expect(adapter).toBeDefined();
+      expect(adapter?.toolId).toBe('windsurf');
+    });
+
+    it('should return Junie adapter for "junie"', () => {
+      const adapter = CommandAdapterRegistry.get('junie');
+      expect(adapter).toBeDefined();
+      expect(adapter?.toolId).toBe('junie');
+    });
+
+    it('should return undefined for unregistered tool', () => {
+      const adapter = CommandAdapterRegistry.get('unknown-tool');
+      expect(adapter).toBeUndefined();
+    });
+
+    it('should return undefined for empty string', () => {
+      const adapter = CommandAdapterRegistry.get('');
+      expect(adapter).toBeUndefined();
+    });
+  });
+
+  describe('getAll', () => {
+    it('should return array of all registered adapters', () => {
+      const adapters = CommandAdapterRegistry.getAll();
+      expect(Array.isArray(adapters)).toBe(true);
+      expect(adapters.length).toBeGreaterThanOrEqual(3); // At least Claude, Cursor, Windsurf
+    });
+
+    it('should include Claude, Cursor, and Windsurf adapters', () => {
+      const adapters = CommandAdapterRegistry.getAll();
+      const toolIds = adapters.map((a) => a.toolId);
+
+      expect(toolIds).toContain('claude');
+      expect(toolIds).toContain('cursor');
+      expect(toolIds).toContain('windsurf');
+    });
+  });
+
+  describe('has', () => {
+    it('should return true for registered tools', () => {
+      expect(CommandAdapterRegistry.has('claude')).toBe(true);
+      expect(CommandAdapterRegistry.has('cursor')).toBe(true);
+      expect(CommandAdapterRegistry.has('windsurf')).toBe(true);
+      expect(CommandAdapterRegistry.has('junie')).toBe(true);
+    });
+
+    it('should return false for unregistered tools', () => {
+      expect(CommandAdapterRegistry.has('unknown')).toBe(false);
+      expect(CommandAdapterRegistry.has('')).toBe(false);
+    });
+  });
+
+  describe('adapter functionality', () => {
+    it('registered adapters should have working getFilePath', () => {
+      const claudeAdapter = CommandAdapterRegistry.get('claude');
+      const cursorAdapter = CommandAdapterRegistry.get('cursor');
+      const windsurfAdapter = CommandAdapterRegistry.get('windsurf');
+
+      expect(claudeAdapter?.getFilePath('test')).toContain('.claude');
+      expect(cursorAdapter?.getFilePath('test')).toContain('.cursor');
+      expect(windsurfAdapter?.getFilePath('test')).toContain('.windsurf');
+    });
+
+    it('registered adapters should have working formatFile', () => {
+      const content = {
+        id: 'test',
+        name: 'Test',
+        description: 'Test desc',
+        category: 'Test',
+        tags: ['tag1'],
+        body: 'Body content',
+      };
+
+      // Tools that don't use YAML frontmatter (markdown headers or TOML or plain)
+      const noYamlFrontmatter = ['cline', 'kilocode', 'roocode', 'gemini', 'qwen'];
+
+      const adapters = CommandAdapterRegistry.getAll();
+      for (const adapter of adapters) {
+        const output = adapter.formatFile(content);
+        // All adapters should include the body content
+        expect(output).toContain('Body content');
+        // Only check for YAML frontmatter for tools that use it
+        if (!noYamlFrontmatter.includes(adapter.toolId)) {
+          expect(output).toContain('---');
+        }
+      }
+    });
+  });
+});

package/OpenSpec-main/test/core/command-generation/types.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from 'vitest';
+import type { CommandContent, ToolCommandAdapter, GeneratedCommand } from '../../../src/core/command-generation/types.js';
+
+describe('command-generation/types', () => {
+  describe('CommandContent interface', () => {
+    it('should allow creating valid command content', () => {
+      const content: CommandContent = {
+        id: 'explore',
+        name: 'OpenSpec Explore',
+        description: 'Enter explore mode for thinking',
+        category: 'Workflow',
+        tags: ['workflow', 'explore'],
+        body: 'This is the command body content.',
+      };
+
+      expect(content.id).toBe('explore');
+      expect(content.name).toBe('OpenSpec Explore');
+      expect(content.description).toBe('Enter explore mode for thinking');
+      expect(content.category).toBe('Workflow');
+      expect(content.tags).toEqual(['workflow', 'explore']);
+      expect(content.body).toBe('This is the command body content.');
+    });
+
+    it('should allow empty tags array', () => {
+      const content: CommandContent = {
+        id: 'test',
+        name: 'Test',
+        description: 'Test command',
+        category: 'Test',
+        tags: [],
+        body: 'Body',
+      };
+
+      expect(content.tags).toEqual([]);
+    });
+  });
+
+  describe('ToolCommandAdapter interface contract', () => {
+    it('should implement adapter with getFilePath and formatFile', () => {
+      const mockAdapter: ToolCommandAdapter = {
+        toolId: 'test-tool',
+        getFilePath(commandId: string): string {
+          return `.test/${commandId}.md`;
+        },
+        formatFile(content: CommandContent): string {
+          return `---\nname: ${content.name}\n---\n\n${content.body}\n`;
+        },
+      };
+
+      expect(mockAdapter.toolId).toBe('test-tool');
+      expect(mockAdapter.getFilePath('explore')).toBe('.test/explore.md');
+
+      const content: CommandContent = {
+        id: 'test',
+        name: 'Test Command',
+        description: 'Desc',
+        category: 'Cat',
+        tags: [],
+        body: 'Body content',
+      };
+
+      const formatted = mockAdapter.formatFile(content);
+      expect(formatted).toContain('name: Test Command');
+      expect(formatted).toContain('Body content');
+    });
+  });
+
+  describe('GeneratedCommand interface', () => {
+    it('should represent generated command output', () => {
+      const generated: GeneratedCommand = {
+        path: '.claude/commands/opsx/explore.md',
+        fileContent: '---\nname: Test\n---\n\nBody\n',
+      };
+
+      expect(generated.path).toBe('.claude/commands/opsx/explore.md');
+      expect(generated.fileContent).toContain('name: Test');
+    });
+  });
+});

package/OpenSpec-main/test/core/commands/change-command.list.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { ChangeCommand } from '../../../src/commands/change.js';
+import path from 'path';
+import { promises as fs } from 'fs';
+import os from 'os';
+
+describe('ChangeCommand.list', () => {
+  let cmd: ChangeCommand;
+  let tempRoot: string;
+  let originalCwd: string;
+
+  beforeAll(async () => {
+    cmd = new ChangeCommand();
+    originalCwd = process.cwd();
+    tempRoot = path.join(os.tmpdir(), `openspec-change-command-list-${Date.now()}`);
+    const changeDir = path.join(tempRoot, 'openspec', 'changes', 'demo');
+    await fs.mkdir(changeDir, { recursive: true });
+    const proposal = `# Change: Demo\n\n## Why\nTest list.\n\n## What Changes\n- **auth:** Add requirement`;
+    await fs.writeFile(path.join(changeDir, 'proposal.md'), proposal, 'utf-8');
+    await fs.writeFile(path.join(changeDir, 'tasks.md'), '- [x] Task 1\n- [ ] Task 2\n', 'utf-8');
+    process.chdir(tempRoot);
+  });
+
+  afterAll(async () => {
+    process.chdir(originalCwd);
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  });
+
+  it('returns JSON with expected shape', async () => {
+    // Capture console output
+    const logs: string[] = [];
+    const origLog = console.log;
+    try {
+      console.log = (msg?: any, ...args: any[]) => {
+        logs.push([msg, ...args].filter(Boolean).join(' '));
+      };
+
+      await cmd.list({ json: true });
+
+      const output = logs.join('\n');
+      const parsed = JSON.parse(output);
+      expect(Array.isArray(parsed)).toBe(true);
+      if (parsed.length > 0) {
+        const item = parsed[0];
+        expect(item).toHaveProperty('id');
+        expect(item).toHaveProperty('title');
+        expect(item).toHaveProperty('deltaCount');
+        expect(item).toHaveProperty('taskStatus');
+        expect(item.taskStatus).toHaveProperty('total');
+        expect(item.taskStatus).toHaveProperty('completed');
+      }
+    } finally {
+      console.log = origLog;
+    }
+  });
+
+  it('prints IDs by default and details with --long', async () => {
+    const logs: string[] = [];
+    const origLog = console.log;
+    try {
+      console.log = (msg?: any, ...args: any[]) => {
+        logs.push([msg, ...args].filter(Boolean).join(' '));
+      };
+      await cmd.list({});
+      const idsOnly = logs.join('\n');
+      expect(idsOnly).toMatch(/\w+/);
+      logs.length = 0;
+      await cmd.list({ long: true });
+      const longOut = logs.join('\n');
+      expect(longOut).toMatch(/:\s/);
+      expect(longOut).toMatch(/\[deltas\s\d+\]/);
+    } finally {
+      console.log = origLog;
+    }
+  });
+});

package/OpenSpec-main/test/core/commands/change-command.show-validate.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { ChangeCommand } from '../../../src/commands/change.js';
+import path from 'path';
+import { promises as fs } from 'fs';
+import os from 'os';
+
+describe('ChangeCommand.show/validate', () => {
+  let cmd: ChangeCommand;
+  let changeName: string;
+  let tempRoot: string;
+  let originalCwd: string;
+
+  beforeAll(async () => {
+    cmd = new ChangeCommand();
+    originalCwd = process.cwd();
+    tempRoot = path.join(os.tmpdir(), `openspec-change-command-${Date.now()}`);
+    const changesDir = path.join(tempRoot, 'openspec', 'changes', 'sample-change');
+    await fs.mkdir(changesDir, { recursive: true });
+    const proposal = `# Change: Sample Change\n\n## Why\nConsistency in tests.\n\n## What Changes\n- **auth:** Add requirement`;
+    await fs.writeFile(path.join(changesDir, 'proposal.md'), proposal, 'utf-8');
+    process.chdir(tempRoot);
+    changeName = 'sample-change';
+  });
+
+  afterAll(async () => {
+    process.chdir(originalCwd);
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  });
+
+  it('show --json prints JSON including deltas', async () => {
+    const logs: string[] = [];
+    const origLog = console.log;
+    try {
+      console.log = (msg?: any, ...args: any[]) => {
+        logs.push([msg, ...args].filter(Boolean).join(' '));
+      };
+
+      await cmd.show(changeName, { json: true });
+
+      const output = logs.join('\n');
+      const parsed = JSON.parse(output);
+      expect(parsed).toHaveProperty('deltas');
+      expect(Array.isArray(parsed.deltas)).toBe(true);
+    } finally {
+      console.log = origLog;
+    }
+  });
+
+  it('error when no change specified: prints available IDs', async () => {
+    const logsErr: string[] = [];
+    const origErr = console.error;
+    try {
+      console.error = (msg?: any, ...args: any[]) => {
+        logsErr.push([msg, ...args].filter(Boolean).join(' '));
+      };
+      await cmd.show(undefined as unknown as string, { json: false } as any);
+      // Should have set exit code and printed hint
+      expect(process.exitCode).toBe(1);
+      const errOut = logsErr.join('\n');
+      expect(errOut).toMatch(/No change specified/);
+      expect(errOut).toMatch(/Available IDs/);
+    } finally {
+      console.error = origErr;
+      process.exitCode = 0;
+    }
+  });
+
+  it('show --json --requirements-only returns minimal object with deltas (deprecated alias)', async () => {
+    const logs: string[] = [];
+    const origLog = console.log;
+    try {
+      console.log = (msg?: any, ...args: any[]) => {
+        logs.push([msg, ...args].filter(Boolean).join(' '));
+      };
+
+      await cmd.show(changeName, { json: true, requirementsOnly: true });
+
+      const output = logs.join('\n');
+      const parsed = JSON.parse(output);
+      expect(parsed).toHaveProperty('deltas');
+      expect(Array.isArray(parsed.deltas)).toBe(true);
+      if (parsed.deltas.length > 0) {
+        expect(parsed.deltas[0]).toHaveProperty('spec');
+        expect(parsed.deltas[0]).toHaveProperty('operation');
+        expect(parsed.deltas[0]).toHaveProperty('description');
+      }
+    } finally {
+      console.log = origLog;
+    }
+  });
+
+  it('validate --strict --json returns a report with valid boolean', async () => {
+    const logs: string[] = [];
+    const origLog = console.log;
+    try {
+      console.log = (msg?: any, ...args: any[]) => {
+        logs.push([msg, ...args].filter(Boolean).join(' '));
+      };
+
+      await cmd.validate(changeName, { strict: true, json: true });
+
+      const output = logs.join('\n');
+      const parsed = JSON.parse(output);
+      expect(parsed).toHaveProperty('valid');
+      expect(parsed).toHaveProperty('issues');
+      expect(Array.isArray(parsed.issues)).toBe(true);
+    } finally {
+      console.log = origLog;
+    }
+  });
+});

package/OpenSpec-main/test/core/completions/command-registry.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it } from 'vitest';
+import type { Command } from 'commander';
+
+import { COMMAND_REGISTRY } from '../../../src/core/completions/command-registry.js';
+import { program } from '../../../src/cli/index.js';
+import type {
+  CommandDefinition,
+  FlagDefinition,
+  PositionalDefinition,
+} from '../../../src/core/completions/types.js';
+
+function command(name: string) {
+  return COMMAND_REGISTRY.find((entry) => entry.name === name);
+}
+
+describe('command completion registry', () => {
+  function registryChildren(commandList: CommandDefinition[] | undefined): Map<string, CommandDefinition> {
+    return new Map((commandList ?? []).map((entry) => [entry.name, entry]));
+  }
+
+  function visibleChildCommands(command: Command): Command[] {
+    return command.commands.filter((child) => !(child as unknown as { _hidden?: boolean })._hidden);
+  }
+
+  function commandAliases(command: Command): string[] {
+    return command.aliases();
+  }
+
+  interface FlagShape {
+    name: string;
+    short?: string;
+    takesValue?: true;
+  }
+
+  interface PositionalShape {
+    name: string;
+    optional?: true;
+  }
+
+  function normalizeName(name: string): string {
+    return name.replace(/[^a-z0-9]/giu, '').toLowerCase();
+  }
+
+  function toFlagShape(flag: FlagDefinition): FlagShape {
+    return {
+      name: flag.name,
+      ...(flag.short ? { short: flag.short } : {}),
+      ...(flag.takesValue ? { takesValue: true as const } : {}),
+    };
+  }
+
+  function toCommanderFlagShape(command: Command): FlagShape[] {
+    return command.options
+      .filter((option) => !option.hidden)
+      .map((option) => ({
+        name: option.long.replace(/^--/u, ''),
+        ...(option.short ? { short: option.short.replace(/^-/, '') } : {}),
+        ...(option.required || option.optional ? { takesValue: true as const } : {}),
+      }));
+  }
+
+  function sortedFlags(flags: FlagShape[]): FlagShape[] {
+    return [...flags].sort((left, right) => left.name.localeCompare(right.name));
+  }
+
+  function toPositionalShape(positional: PositionalDefinition): PositionalShape {
+    return {
+      name: normalizeName(positional.name),
+      ...(positional.optional ? { optional: true as const } : {}),
+    };
+  }
+
+  function toCommanderPositionalShapes(command: Command): PositionalShape[] {
+    return command.registeredArguments.map((argument) => ({
+      name: normalizeName(argument.name()),
+      ...(argument.required ? {} : { optional: true as const }),
+    }));
+  }
+
+  function assertPositionalParity(
+    commandPath: string,
+    command: Command,
+    entry: CommandDefinition
+  ): void {
+    const commandPositionals = toCommanderPositionalShapes(command);
+
+    if (commandPositionals.length === 0) {
+      expect(entry.acceptsPositional ?? false, `${commandPath} accepts positional`).toBe(false);
+      expect(entry.positionals ?? [], `${commandPath} positionals`).toEqual([]);
+      return;
+    }
+
+    expect(entry.acceptsPositional, `${commandPath} accepts positional`).toBe(true);
+    expect(
+      (entry.positionals ?? []).map(toPositionalShape),
+      `${commandPath} positionals`
+    ).toEqual(commandPositionals);
+  }
+
+  function assertCommandShape(
+    commandPath: string,
+    command: Command,
+    entry: CommandDefinition
+  ): void {
+    expect(sortedFlags(entry.flags.map(toFlagShape)), `${commandPath} flags`).toEqual(
+      sortedFlags(toCommanderFlagShape(command))
+    );
+    assertPositionalParity(commandPath, command, entry);
+  }
+
+  function assertRegistryParity(
+    command: Command,
+    registry: CommandDefinition[],
+    parentPath = ''
+  ): void {
+    const registryByName = registryChildren(registry);
+
+    for (const child of visibleChildCommands(command)) {
+      const commandPath = parentPath ? `${parentPath} ${child.name()}` : child.name();
+      const names = [child.name(), ...commandAliases(child)];
+      for (const name of names) {
+        expect(registryByName.has(name), `missing completion entry for ${commandPath} alias ${name}`).toBe(true);
+      }
+
+      const entry = registryByName.get(child.name());
+      if (!entry) {
+        continue;
+      }
+
+      assertCommandShape(commandPath, child, entry);
+
+      for (const alias of commandAliases(child)) {
+        const aliasEntry = registryByName.get(alias);
+        expect(aliasEntry, `${commandPath} alias ${alias}`).toBeDefined();
+        if (aliasEntry) {
+          assertCommandShape(`${commandPath} alias ${alias}`, child, aliasEntry);
+        }
+      }
+
+      assertRegistryParity(child, entry.subcommands ?? [], commandPath);
+    }
+  }
+
+  it('matches visible Commander command flags and aliases', () => {
+    assertRegistryParity(program, COMMAND_REGISTRY);
+  });
+
+  it('tracks top-level workflow commands', () => {
+    for (const name of ['status', 'instructions', 'templates', 'schemas', 'new', 'set']) {
+      expect(command(name), `${name} command`).toBeDefined();
+    }
+
+    const newChange = command('new')?.subcommands?.find((entry) => entry.name === 'change');
+    expect(newChange?.flags.map((flag) => flag.name)).toEqual([
+      'description',
+      'goal',
+      'areas',
+      'initiative',
+      'store',
+      'store-path',
+      'schema',
+      'json',
+    ]);
+
+    const setChange = command('set')?.subcommands?.find((entry) => entry.name === 'change');
+    expect(setChange?.flags.map((flag) => flag.name)).toEqual([
+      'initiative',
+      'store',
+      'store-path',
+      'json',
+    ]);
+  });
+
+  it('tracks context-store commands and aliases', () => {
+    const contextStore = command('context-store');
+
+    expect(contextStore?.subcommands?.map((entry) => entry.name)).toEqual([
+      'setup',
+      'register',
+      'unregister',
+      'remove',
+      'list',
+      'ls',
+      'doctor',
+    ]);
+
+    const setup = contextStore?.subcommands?.find((entry) => entry.name === 'setup');
+    expect(setup?.flags.map((flag) => flag.name)).toEqual([
+      'path',
+      'init-git',
+      'no-init-git',
+      'json',
+    ]);
+
+    const remove = contextStore?.subcommands?.find((entry) => entry.name === 'remove');
+    expect(remove?.flags.map((flag) => flag.name)).toEqual([
+      'yes',
+      'json',
+    ]);
+  });
+});