refactor: derive semantic cli routing

Author: thymikee

src/cli/commands/client-command.ts

@@ -6,7 +6,6 @@ import type {
 import type { CliFlags } from '../../utils/command-schema.ts';
 import { readCommandMessage } from '../../utils/success-text.ts';
 import { runSemanticCliCommand } from '../../commands/semantic-cli.ts';
-import type { SemanticCliCommand } from '../../commands/semantic-command-surface.ts';
 import { writeCommandMessage, writeCommandOutput } from './shared.ts';
 import type { ClientCommandHandlerMap } from './router-types.ts';
 
@@ -90,8 +89,7 @@ export const clientCommandMethodHandlers = {
 } satisfies ClientCommandHandlerMap;
 
 function runClientCommand(options: {
-  command: Extract<
-    SemanticCliCommand,
+  command:
     | 'wait'
     | 'alert'
     | 'appstate'
@@ -100,8 +98,7 @@ function runClientCommand(options: {
     | 'rotate'
     | 'app-switcher'
     | 'keyboard'
-    | 'clipboard'
-  >;
+    | 'clipboard';
   positionals: string[];
   flags: CliFlags;
   client: Parameters<typeof runSemanticCliCommand>[0]['client'];

src/cli/commands/generic.ts

@@ -22,7 +22,7 @@ import type {
 import { announceReplayTestRun } from '../../cli-test.ts';
 import { runSemanticCliCommand } from '../../commands/semantic-cli.ts';
 import {
-  listSemanticGenericCliCommands,
+  listSemanticCommandNames,
   type SemanticCliCommand,
 } from '../../commands/semantic-command-surface.ts';
 import { assertResolvedAppsFilter } from '../../commands/app-inventory-contract.ts';
@@ -40,30 +40,6 @@ type GenericClientCommandRunner = (params: {
   flags: CliFlags;
 }) => Promise<CommandRequestResult>;
 
-const semanticGenericCommands = listSemanticGenericCliCommands();
-
-const genericClientCommandRunners = Object.fromEntries(
-  semanticGenericCommands.map((command) => [
-    command,
-    async ({ client, positionals, flags }) => {
-      if (command === 'test') {
-        announceReplayTestRun({ json: flags.json });
-      }
-      return await runSemanticCliCommand({ client, command, positionals, flags });
-    },
-  ]),
-) as Record<(typeof semanticGenericCommands)[number], GenericClientCommandRunner>;
-
-export const genericClientCommandHandlers = Object.fromEntries(
-  Object.entries(genericClientCommandRunners).map(([command, run]) => [
-    command,
-    createGenericClientCommandHandler(
-      command as PublicCommandName,
-      run as GenericClientCommandRunner,
-    ),
-  ]),
-) as { [TCommand in keyof typeof genericClientCommandRunners]: ClientCommandHandler };
-
 const formattedSemanticCommandHandlers = {
   devices: createFormattedSemanticHandler('devices', {
     write: ({ flags, result }) => {
@@ -162,6 +138,42 @@ const formattedSemanticCommandHandlers = {
 
 export const dedicatedSemanticCommandHandlers = formattedSemanticCommandHandlers;
 
+const clientMethodCommandNames = commandNameSet([
+  'wait',
+  'alert',
+  'appstate',
+  'back',
+  'home',
+  'rotate',
+  'app-switcher',
+  'keyboard',
+  'clipboard',
+] as const satisfies readonly SemanticCliCommand[]);
+
+const semanticGenericCommands = listSemanticCommandNames().filter(isGenericSemanticCliCommand);
+
+const genericClientCommandRunners = Object.fromEntries(
+  semanticGenericCommands.map((command) => [
+    command,
+    async ({ client, positionals, flags }) => {
+      if (command === 'test') {
+        announceReplayTestRun({ json: flags.json });
+      }
+      return await runSemanticCliCommand({ client, command, positionals, flags });
+    },
+  ]),
+) as Record<(typeof semanticGenericCommands)[number], GenericClientCommandRunner>;
+
+export const genericClientCommandHandlers = Object.fromEntries(
+  Object.entries(genericClientCommandRunners).map(([command, run]) => [
+    command,
+    createGenericClientCommandHandler(
+      command as PublicCommandName,
+      run as GenericClientCommandRunner,
+    ),
+  ]),
+) as { [TCommand in keyof typeof genericClientCommandRunners]: ClientCommandHandler };
+
 function createGenericClientCommandHandler(
   command: PublicCommandName,
   run: GenericClientCommandRunner,
@@ -213,3 +225,16 @@ function withoutUnchanged(data: Record<string, unknown>): Record<string, unknown
   const { unchanged: _unchanged, ...outputData } = data;
   return outputData;
 }
+
+function isGenericSemanticCliCommand(command: SemanticCliCommand): boolean {
+  return (
+    !(command in formattedSemanticCommandHandlers) &&
+    !clientMethodCommandNames.has(command) &&
+    command !== 'screenshot' &&
+    command !== 'diff'
+  );
+}
+
+function commandNameSet<const TName extends string>(names: readonly TName[]): ReadonlySet<string> {
+  return new Set(names);
+}

src/commands/semantic-command-surface.ts

@@ -4,11 +4,7 @@ import { semanticClientCommands } from './semantic-client-commands.ts';
 import type { JsonSchema } from './semantic-contract.ts';
 import { bootSemanticCommand } from './semantic-device.ts';
 import { interactionSemanticCommands } from './semantic-interactions.ts';
-import {
-  isSemanticBatchCommand as isSemanticGrammarBatchCommand,
-  semanticBatchCommandNames,
-  type SemanticBatchCommand,
-} from './semantic-grammar.ts';
+import { semanticBatchCommandNames, type SemanticBatchCommand } from './semantic-grammar.ts';
 
 type AnySemanticCommandDefinition = {
   name: string;
@@ -18,123 +14,29 @@ type AnySemanticCommandDefinition = {
   invoke: (client: AgentDeviceClient, input: unknown) => Promise<unknown>;
 };
 
-type CommandSurfaceEntry<TDefinition extends AnySemanticCommandDefinition> = {
-  definition: TDefinition;
-  batch: boolean;
-  genericCli: boolean;
-};
-
-function commandSurfaceEntry<
-  TDefinition extends AnySemanticCommandDefinition,
-  const TMetadata extends Omit<CommandSurfaceEntry<TDefinition>, 'definition'>,
->(definition: TDefinition, metadata: TMetadata): { definition: TDefinition } & TMetadata {
-  return { definition, ...metadata };
-}
-
-const semanticGenericCliCommandNames = [
-  'boot',
-  'push',
-  'perf',
-  'click',
-  'get',
-  'replay',
-  'test',
-  'batch',
-  'press',
-  'longpress',
-  'swipe',
-  'gesture',
-  'focus',
-  'type',
-  'fill',
-  'scroll',
-  'trigger-app-event',
-  'record',
-  'trace',
-  'logs',
-  'network',
-  'react-native',
-  'find',
-  'is',
-  'settings',
-] as const;
-
-const semanticDedicatedCliCommandNames = [
-  'wait',
-  'alert',
-  'appstate',
-  'back',
-  'home',
-  'rotate',
-  'app-switcher',
-  'keyboard',
-  'clipboard',
-  'devices',
-  'apps',
-  'session',
-  'open',
-  'close',
-  'install',
-  'reinstall',
-  'install-from-source',
-  'snapshot',
-  'screenshot',
-  'diff',
-  'metro',
-] as const;
-
-const semanticCliCommandNames = [
-  ...semanticGenericCliCommandNames,
-  ...semanticDedicatedCliCommandNames,
-] as const;
-
-const genericCliNames = commandNameSet(semanticGenericCliCommandNames);
-
-const baseCommandSurface = [
-  commandSurfaceEntry(bootSemanticCommand, commandMetadata(bootSemanticCommand.name)),
-  ...interactionSemanticCommands.map((definition) =>
-    commandSurfaceEntry(definition, commandMetadata(definition.name)),
-  ),
-  ...semanticClientCommands.map((definition) =>
-    commandSurfaceEntry(definition, commandMetadata(definition.name)),
-  ),
-] as const;
-
 const batchSemanticCommand = createBatchSemanticCommand(semanticBatchCommandNames);
 
 const semanticCommandSurface = [
-  ...baseCommandSurface,
-  commandSurfaceEntry(batchSemanticCommand, {
-    batch: false,
-    genericCli: true,
-  }),
+  bootSemanticCommand,
+  ...interactionSemanticCommands,
+  ...semanticClientCommands,
+  batchSemanticCommand,
 ] as const;
 
-export type SemanticCommandName = (typeof semanticCommandSurface)[number]['definition']['name'];
-export type SemanticCliCommand = (typeof semanticCliCommandNames)[number];
+export type SemanticCommandName = (typeof semanticCommandSurface)[number]['name'];
+export type SemanticCliCommand = SemanticCommandName;
 export type { SemanticBatchCommand };
 
 const semanticCommandMap = new Map(
-  semanticCommandSurface.map((entry) => [entry.definition.name, entry.definition]),
+  semanticCommandSurface.map((definition) => [definition.name, definition]),
 );
 
-function commandMetadata(
-  name: string,
-): Omit<CommandSurfaceEntry<AnySemanticCommandDefinition>, 'definition'> {
-  return {
-    batch: isSemanticGrammarBatchCommand(name),
-    genericCli: genericCliNames.has(name),
-  };
-}
-
 export function listSemanticMcpToolDefinitions(): AnySemanticCommandDefinition[] {
-  return semanticCommandSurface.map((entry) => entry.definition);
+  return [...semanticCommandSurface];
 }
 
-export function listSemanticGenericCliCommands(): SemanticCliCommand[] {
-  return semanticCommandSurface
-    .filter((entry) => entry.genericCli)
-    .map((entry) => entry.definition.name as SemanticCliCommand);
+export function listSemanticCommandNames(): SemanticCommandName[] {
+  return semanticCommandSurface.map((definition) => definition.name);
 }
 
 export function isSemanticCommandName(name: string): name is SemanticCommandName {
@@ -152,7 +54,3 @@ export async function runSemanticCommand(
   }
   return await definition.invoke(client, input);
 }
-
-function commandNameSet<const TName extends string>(names: readonly TName[]): ReadonlySet<string> {
-  return new Set(names);
-}

src/commands/semantic-grammar.ts

@@ -825,7 +825,7 @@ function readBatchCliCommand(command: string, stepNumber: number): SemanticBatch
   );
 }
 
-export function isSemanticBatchCommand(name: string): name is SemanticBatchCommand {
+function isSemanticBatchCommand(name: string): name is SemanticBatchCommand {
   return semanticBatchNames.has(name);
 }