Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

8.6 KB
Raw Blame
import 'package:flutter_test/flutter_test.dart';
import 'package:harness/shortcuts/keymap.dart';
import 'package:harness/shortcuts/keymap_commands.dart';

const commands = {'swarm.new', 'pane.focus_left', 'picker.next'};
KeyBinding bind(
  String keys,
  String? command, [
  KeymapContext context = KeymapContext.workspace,
]) => KeyBinding(
  keys: keys.split(' ').map(KeyStroke.parse),
  command: command,
  context: context,
);
KeymapMatch match(
  ResolvedKeymap map,
  String keys, [
  KeymapContext context = KeymapContext.terminal,
]) => map.match(context, keys.split(' ').map(KeyStroke.parse));

void main() {
  test('Launch and Project actions have no default text shortcuts', () {
    final commands = {
      'creation.agent',
      'creation.project',
      'creation.task',
      'creation.project_machine',
      'creation.options',
      'creation.project_new',
      'creation.project_existing',
      'creation.project_repository',
      for (var i = 1; i <= 9; i++) 'creation.project_recent_$i',
    };
    expect(
      harnessDefaultKeymap
          .bindingsFor(KeymapContext.project)
          .where((binding) => commands.contains(binding.command)),
      isEmpty,
    );
    expect(
      match(harnessDefaultKeymap, 'up', KeymapContext.project).command,
      'picker.previous',
    );
    expect(
      match(harnessDefaultKeymap, 'down', KeymapContext.project).command,
      'picker.next',
    );
    expect(
      match(harnessDefaultKeymap, 'enter', KeymapContext.project).command,
      'picker.accept',
    );
  });

  test(
    'project bindings override picker defaults and inherit custom navigation',
    () {
      final defaults = [
        bind('o', 'creation.options', KeymapContext.picker),
        bind('o', 'creation.project_existing', KeymapContext.project),
        bind('ctrl+n', 'picker.next', KeymapContext.picker),
      ];
      final original = ResolvedKeymap(defaults, const KeymapConfig.empty());
      expect(
        match(original, 'o', KeymapContext.picker).command,
        'creation.options',
      );
      expect(
        match(original, 'o', KeymapContext.project).command,
        'creation.project_existing',
      );
      final custom = ResolvedKeymap(
        defaults,
        KeymapConfig([
          bind('o', null, KeymapContext.project),
          bind('f', 'creation.project_existing', KeymapContext.project),
          bind('ctrl+n', null, KeymapContext.picker),
          bind('j', 'picker.next', KeymapContext.picker),
        ]),
      );
      expect(
        match(custom, 'o', KeymapContext.picker).command,
        'creation.options',
      );
      expect(match(custom, 'o', KeymapContext.project).matched, isFalse);
      expect(match(custom, 'f', KeymapContext.picker).matched, isFalse);
      expect(
        match(custom, 'f', KeymapContext.project).command,
        'creation.project_existing',
      );
      expect(match(custom, 'ctrl+n', KeymapContext.project).matched, isFalse);
      expect(match(custom, 'j', KeymapContext.project).command, 'picker.next');
    },
  );

  test('retired Navigate and preview bindings preserve other shortcuts', () {
    final config = KeymapConfig.parse('''{"bindings":[
      {"keys":"cmd+i","command":"picker.preview","when":"picker"},
      {"keys":"cmd+o","command":"navigation.quick_open"},
      {"keys":"cmd+shift+y","command":"team.open"},
      {"keys":"cmd+ctrl+h","command":"pane.focus_left"}
    ]}''', commands: commands);
    expect(config.bindings.single.command, 'pane.focus_left');
  });

  test('dotfile accepts comments, aliases and trailing commas', () {
    final config = KeymapConfig.parse('''
      // Keep the defaults and add my preferred movement key.
      {
        "version": 1,
        "bindings": [
          {"keys": "SUPER + CONTROL + H", "command": "pane.focus_left", "when": "terminal"},
          /* Leave this chord to my terminal. */
          {"keys": "cmd+alt+left", "command": null},
        ],
      }
    ''', commands: commands);
    final map = ResolvedKeymap([
      bind('cmd+alt+left', 'pane.focus_left'),
    ], config);
    expect(match(map, 'cmd+ctrl+h').command, 'pane.focus_left');
    expect(match(map, 'cmd+alt+left').matched, false);
    expect(match(map, 'cmd+ctrl+h', KeymapContext.workspace).matched, false);
  });

  test('string escapes and comment-like strings retain their exact value', () {
    const command = 'url://a"/*b*/';
    final config = KeymapConfig.parse(
      r'{"bindings":[{"keys":"cmd+t","command":"url://a\"/*b*/"}]}',
      commands: {command},
    );
    expect(config.bindings.single.command, command);
  });

  test('invalid edits are rejected with actionable diagnostics', () {
    for (final source in [
      '{"version":2}',
      '{"binding":[]}',
      '{"bindings":[{"keys":"cmd+t","command":"unknown"}]}',
      '{"bindings":[{"keys":"cmd+t"}]}',
      '{"bindings":[{"keys":"cmd+t","command":null,"when":"typo"}]}',
      '{"bindings":[{"keys":"cmd+cmd+t","command":null}]}',
      '{"bindings":[{"keys":"cmd","command":null}]}',
      '{"bindings":[{"keys":"made-up","command":null}]}',
      '{"bindings":[{"keys":"a b c d e","command":null}]}',
      '{"bindings":[{"keys":"cmd+t","command":null},{"keys":"super+t","command":null}]}',
      '{"bindings":[,]}',
      '{,}',
      '/* unfinished',
    ]) {
      expect(
        () => KeymapConfig.parse(source, commands: commands),
        throwsFormatException,
        reason: source,
      );
    }
  });

  test('decoder offsets still point into the original commented file', () {
    const source = '/* comment */\n{"bindings": ?}';
    try {
      KeymapConfig.parse(source, commands: commands);
      fail('Expected syntax error');
    } on FormatException catch (error) {
      expect(error.offset, source.indexOf('?'));
    }
  });

  test('terminal overrides do not change workspace or modal picker keys', () {
    final map = ResolvedKeymap([
      bind('cmd+t', 'swarm.new'),
      bind('ctrl+n', 'picker.next', KeymapContext.picker),
    ], KeymapConfig([bind('cmd+t', null, KeymapContext.terminal)]));
    expect(match(map, 'cmd+t').matched, false);
    expect(match(map, 'cmd+t', KeymapContext.workspace).command, 'swarm.new');
    expect(match(map, 'cmd+t', KeymapContext.picker).command, 'swarm.new');
    expect(match(map, 'ctrl+n', KeymapContext.picker).command, 'picker.next');
    expect(match(map, 'ctrl+n', KeymapContext.terminal).matched, false);
  });

  test('explicit workspace overrides also replace terminal defaults', () {
    final map = ResolvedKeymap([
      bind('cmd+t', 'swarm.new'),
      bind('cmd+t', 'pane.focus_left', KeymapContext.terminal),
    ], KeymapConfig([bind('cmd+t', null)]));
    expect(match(map, 'cmd+t').matched, false);
  });

  test('sequences need explicit removal of an ambiguous shorter binding', () {
    final defaults = [bind('cmd+t', 'swarm.new')];
    final sequence = bind('cmd+t h', 'pane.focus_left');
    expect(
      () => ResolvedKeymap(defaults, KeymapConfig([sequence])),
      throwsFormatException,
    );
    final map = ResolvedKeymap(
      defaults,
      KeymapConfig([bind('cmd+t', null), sequence]),
    );
    expect(match(map, 'cmd+t').prefix, true);
    expect(match(map, 'cmd+t').command, null);
    expect(match(map, 'cmd+t h').command, 'pane.focus_left');
    expect(match(map, 'cmd+t l').matched, false);
    expect(match(map, 'cmd+t h j').matched, false);
  });

  test(
    'prefix ambiguity is rejected in both insertion orders and across scopes',
    () {
      expect(
        () => ResolvedKeymap([
          bind('cmd+t h', 'pane.focus_left'),
          bind('cmd+t', 'swarm.new'),
        ], const KeymapConfig.empty()),
        throwsFormatException,
      );
      expect(
        () => ResolvedKeymap([
          bind('cmd+t h', 'pane.focus_left', KeymapContext.terminal),
        ], KeymapConfig([bind('cmd+t', 'swarm.new')])),
        throwsFormatException,
      );
    },
  );

  test('unbinding a prefix releases its entire inherited sequence tree', () {
    final map = ResolvedKeymap([
      bind('cmd+t h', 'pane.focus_left'),
      bind('cmd+t p', 'swarm.new'),
    ], KeymapConfig([bind('cmd+t', null)]));
    expect(match(map, 'cmd+t').matched, false);
    expect(match(map, 'cmd+t h').matched, false);
  });

  test(
    'oversized binding lists and unknown fields fail instead of being ignored',
    () {
      expect(
        () => KeymapConfig.parse(
          '{"bindings":[${List.filled(513, '{}').join(',')}]}',
          commands: commands,
        ),
        throwsFormatException,
      );
      expect(
        () => KeymapConfig.parse(
          '{"bindings":[{"keys":"cmd+t","command":null,"scope":"terminal"}]}',
          commands: commands,
        ),
        throwsFormatException,
      );
    },
  );
}