sauron-cli 1.3.0 → 1.4.1

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

@@ -1,110 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,201 +0,0 @@
-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',
-    ]);
-  });
-});