refactor: class-based units and abilities

apps/cli/package.json

@@ -55,6 +55,7 @@
     "mock-fs": "^5.5.0"
   },
   "dependencies": {
+    "@warriorjs/abilities": "workspace:^",
     "@warriorjs/core": "workspace:^",
     "@warriorjs/scoring": "workspace:^",
     "@warriorjs/tower-the-narrow-path": "workspace:^",

apps/cli/src/Tower.test.ts

@@ -6,7 +6,7 @@ describe('Tower', () => {
   let tower: Tower;
 
   beforeEach(() => {
-    tower = new Tower('foo', 'Foo', 'bar baz', ['level1', 'level2']);
+    tower = new Tower('foo', 'Foo', 'bar baz', 'warrior' as any, ['level1', 'level2'] as any);
   });
 
   test('has an id', () => {
@@ -21,6 +21,10 @@ describe('Tower', () => {
     expect(tower.description).toBe('bar baz');
   });
 
+  test('has a warrior', () => {
+    expect(tower.warrior).toEqual('warrior');
+  });
+
   test('has some levels', () => {
     expect(tower.levels).toEqual(['level1', 'level2']);
   });

apps/cli/src/Tower.ts

@@ -1,24 +1,32 @@
-import type { LevelConfig } from '@warriorjs/core';
+import type { LevelDefinition, WarriorDefinition } from '@warriorjs/core';
 
 /** Class representing a tower. */
 class Tower {
   id: string;
   name: string;
   description: string;
-  levels: LevelConfig[];
+  warrior: WarriorDefinition;
+  levels: LevelDefinition[];
 
-  constructor(id: string, name: string, description: string, levels: LevelConfig[]) {
+  constructor(
+    id: string,
+    name: string,
+    description: string,
+    warrior: WarriorDefinition,
+    levels: LevelDefinition[],
+  ) {
     this.id = id;
     this.name = name;
     this.description = description;
+    this.warrior = warrior;
     this.levels = levels;
   }
 
   hasLevel(levelNumber: number): boolean {
     return !!this.getLevel(levelNumber);
   }
 
-  getLevel(levelNumber: number): LevelConfig | undefined {
+  getLevel(levelNumber: number): LevelDefinition | undefined {
     return this.levels[levelNumber - 1];
   }
 

apps/cli/src/loadTowers.test.ts

@@ -25,6 +25,7 @@ test('loads internal towers', () => {
   mockRequire.mockReturnValue({
     name: 'The Narrow Path',
     description: 'A corridor of stone where the only way out is forward',
+    warrior: 'warrior',
     levels: ['level1', 'level2'],
   });
   mock({ '/path/to/node_modules/@warriorjs/cli': {} });
@@ -34,18 +35,25 @@ test('loads internal towers', () => {
     'the-narrow-path',
     'The Narrow Path',
     'A corridor of stone where the only way out is forward',
+    'warrior',
     ['level1', 'level2'],
   );
 });
 
 test('loads external official towers', () => {
   mockRequire.mockImplementation((path: string) => {
     if (path.includes('tower-foo')) {
-      return { name: 'Foo', description: 'bar', levels: ['level1', 'level2'] };
+      return {
+        name: 'Foo',
+        description: 'bar',
+        warrior: 'warrior',
+        levels: ['level1', 'level2'],
+      };
     }
     return {
       name: 'The Narrow Path',
       description: 'A corridor of stone where the only way out is forward',
+      warrior: 'warrior',
       levels: ['level1', 'level2'],
     };
   });
@@ -56,24 +64,30 @@ test('loads external official towers', () => {
         'tower-foo': {
           'package.json': '',
           'index.js':
-            "module.exports = { name: 'Foo', description: 'bar', levels: ['level1', 'level2'] }",
+            "module.exports = { name: 'Foo', description: 'bar', warrior: 'warrior, levels: ['level1', 'level2'] }",
         },
       },
     },
   });
   loadTowers();
   mock.restore();
-  expect(Tower).toHaveBeenCalledWith('foo', 'Foo', 'bar', ['level1', 'level2']);
+  expect(Tower).toHaveBeenCalledWith('foo', 'Foo', 'bar', 'warrior', ['level1', 'level2']);
 });
 
 test('loads external community towers', () => {
   mockRequire.mockImplementation((path: string) => {
     if (path.includes('warriorjs-tower-foo')) {
-      return { name: 'Foo', description: 'bar', levels: ['level1', 'level2'] };
+      return {
+        name: 'Foo',
+        description: 'bar',
+        warrior: 'warrior',
+        levels: ['level1', 'level2'],
+      };
     }
     return {
       name: 'The Narrow Path',
       description: 'A corridor of stone where the only way out is forward',
+      warrior: 'warrior',
       levels: ['level1', 'level2'],
     };
   });
@@ -85,19 +99,20 @@ test('loads external community towers', () => {
       'warriorjs-tower-foo': {
         'package.json': '',
         'index.js':
-          "module.exports = { name: 'Foo', description: 'bar', levels: ['level1', 'level2'] }",
+          "module.exports = { name: 'Foo', description: 'bar', warrior: 'warrior, levels: ['level1', 'level2'] }",
       },
     },
   });
   loadTowers();
   mock.restore();
-  expect(Tower).toHaveBeenCalledWith('foo', 'Foo', 'bar', ['level1', 'level2']);
+  expect(Tower).toHaveBeenCalledWith('foo', 'Foo', 'bar', 'warrior', ['level1', 'level2']);
 });
 
 test("ignores directories that are seemingly towers but don't have a package.json", () => {
   mockRequire.mockReturnValue({
     name: 'The Narrow Path',
     description: 'A corridor of stone where the only way out is forward',
+    warrior: 'warrior',
     levels: ['level1', 'level2'],
   });
   mock({
@@ -106,25 +121,26 @@ test("ignores directories that are seemingly towers but don't have a package.jso
         cli: {},
         'tower-foo': {
           'index.js':
-            "module.exports = { name: 'Foo', description: 'baz', levels: ['level1', 'level2'] }",
+            "module.exports = { name: 'Foo', description: 'baz', warrior: 'warrior, levels: ['level1', 'level2'] }",
         },
       },
       'warriorjs-tower-bar': {
         'index.js':
-          "module.exports = { name: 'Bar', description: 'baz', levels: ['level1', 'level2'] }",
+          "module.exports = { name: 'Bar', description: 'baz', warrior: 'warrior, levels: ['level1', 'level2'] }",
       },
     },
   });
   loadTowers();
   mock.restore();
-  expect(Tower).not.toHaveBeenCalledWith('foo', 'Foo', 'baz', ['level1', 'level2']);
-  expect(Tower).not.toHaveBeenCalledWith('bar', 'Bar', 'baz', ['level1', 'level2']);
+  expect(Tower).not.toHaveBeenCalledWith('foo', 'Foo', 'baz', 'warrior', ['level1', 'level2']);
+  expect(Tower).not.toHaveBeenCalledWith('bar', 'Bar', 'baz', 'warrior', ['level1', 'level2']);
 });
 
 test("doesn't throw when @warriorjs/cli doesn't exist", async () => {
   mockRequire.mockReturnValue({
     name: 'The Narrow Path',
     description: 'A corridor of stone where the only way out is forward',
+    warrior: 'warrior',
     levels: ['level1', 'level2'],
   });
   const { findUpSync } = await import('find-up');

apps/cli/src/loadTowers.ts

@@ -62,8 +62,8 @@ function loadTowers(): Tower[] {
   const uniqueInfo = [...new Map(allInfo.map((item) => [item.id, item])).values()];
   return uniqueInfo.map(({ id, requirePath }) => {
     const mod = require(requirePath);
-    const { name, description, levels } = mod.default || mod;
-    return new Tower(id, name, description, levels);
+    const { name, description, warrior, levels } = mod.default || mod;
+    return new Tower(id, name, description, warrior, levels);
   });
 }
 

apps/cli/src/utils/renderTypes.test.ts

@@ -1,34 +1,34 @@
+import { type AbilityMeta, Action, Sense } from '@warriorjs/core';
 import { describe, expect, test } from 'vitest';
 
 import renderTypes from './renderTypes.js';
 
-const mockAbilities = {
-  walk: () => ({
-    action: true,
-    description: 'Walks forward',
-    perform() {},
-    meta: {
-      params: [{ name: 'direction', type: 'Direction' as const, optional: true }],
-      returns: 'void' as const,
-    },
-  }),
-  feel: () => ({
-    description: 'Feels the space ahead',
-    perform() {},
-    meta: {
-      params: [{ name: 'direction', type: 'Direction' as const, optional: true }],
-      returns: 'Space' as const,
-    },
-  }),
-  health: () => ({
-    description: 'Returns current health',
-    perform() {},
-    meta: {
-      params: [] as any[],
-      returns: 'number' as const,
-    },
-  }),
-};
+class MockWalk extends Action {
+  readonly description = 'Walks forward';
+  readonly meta: AbilityMeta = {
+    params: [{ name: 'direction', type: 'Direction', optional: true }],
+    returns: 'void',
+  };
+  perform() {}
+}
+
+class MockFeel extends Sense {
+  readonly description = 'Feels the space ahead';
+  readonly meta: AbilityMeta = {
+    params: [{ name: 'direction', type: 'Direction', optional: true }],
+    returns: 'Space',
+  };
+  perform() {}
+}
+
+class MockHealth extends Sense {
+  readonly description = 'Returns current health';
+  readonly meta: AbilityMeta = {
+    params: [],
+    returns: 'number',
+  };
+  perform() {}
+}
 
 const profile: any = { language: 'typescript' };
 
@@ -38,7 +38,7 @@ function makeLevelConfig(abilities: Record<string, any>): any {
 
 describe('renderTypes', () => {
   test('renders types with a single action', () => {
-    expect(renderTypes(profile, makeLevelConfig({ walk: mockAbilities.walk }))).toBe(
+    expect(renderTypes(profile, makeLevelConfig({ walk: MockWalk }))).toBe(
       [
         '// @generated — Auto-generated each level. Do not edit.',
         '',
@@ -58,9 +58,9 @@ describe('renderTypes', () => {
       renderTypes(
         profile,
         makeLevelConfig({
-          health: mockAbilities.health,
-          walk: mockAbilities.walk,
-          feel: mockAbilities.feel,
+          health: MockHealth,
+          walk: MockWalk,
+          feel: MockFeel,
         }),
       ),
     ).toBe(
@@ -107,12 +107,7 @@ describe('renderTypes', () => {
   });
 
   test('omits Space and Unit interfaces when no abilities use Space', () => {
-    expect(
-      renderTypes(
-        profile,
-        makeLevelConfig({ walk: mockAbilities.walk, health: mockAbilities.health }),
-      ),
-    ).toBe(
+    expect(renderTypes(profile, makeLevelConfig({ walk: MockWalk, health: MockHealth }))).toBe(
       [
         '// @generated — Auto-generated each level. Do not edit.',
         '',
@@ -129,47 +124,24 @@ describe('renderTypes', () => {
     );
   });
 
-  test('skips abilities without meta', () => {
-    const noMetaAbility = () => ({
-      description: 'No meta',
-      perform() {},
-    });
-    expect(
-      renderTypes(profile, makeLevelConfig({ walk: mockAbilities.walk, legacy: noMetaAbility })),
-    ).toBe(
-      [
-        '// @generated — Auto-generated each level. Do not edit.',
-        '',
-        "export type Direction = 'forward' | 'right' | 'backward' | 'left';",
-        '',
-        'export interface Warrior {',
-        '  /** Walks forward */',
-        '  walk(direction?: Direction): void;',
-        '}',
-        '',
-      ].join('\n'),
-    );
-  });
-
   test('handles rest parameters', () => {
-    const restAbility = () => ({
-      action: true,
-      description: 'Does something with rest params',
-      perform() {},
-      meta: {
-        params: [{ name: 'targets', type: 'string', rest: true }],
-        returns: 'void' as const,
-      },
-    });
-    expect(renderTypes(profile, makeLevelConfig({ multi: restAbility }))).toBe(
+    class RestAction extends Action {
+      readonly description = 'Does something with rest params';
+      readonly meta: AbilityMeta = {
+        params: [{ name: 'targets', type: 'any', rest: true }],
+        returns: 'void',
+      };
+      perform() {}
+    }
+    expect(renderTypes(profile, makeLevelConfig({ multi: RestAction }))).toBe(
       [
         '// @generated — Auto-generated each level. Do not edit.',
         '',
         "export type Direction = 'forward' | 'right' | 'backward' | 'left';",
         '',
         'export interface Warrior {',
         '  /** Does something with rest params */',
-        '  multi(...targets: string[]): void;',
+        '  multi(...targets: any[]): void;',
         '}',
         '',
       ].join('\n'),