@myclaw163/clawclaw-cli 0.6.65 → 0.6.66

package/src/lib/strategy-export.test.ts

@@ -1,232 +1,232 @@
-// src/lib/strategy-export.test.ts
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { existsSync, mkdirSync, writeFileSync, rmSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import {
-  rewriteBuiltinImports,
-  exportStrategy,
-  detectStaleOfficialStrategies,
-  readManifest,
-} from './strategy-export.js';
-
-describe('strategy-export', () => {
-  let testWorkspace: string;
-  let originalEnv: string | undefined;
-
-  beforeEach(() => {
-    testWorkspace = join(tmpdir(), `ccl-test-${Date.now()}`);
-    mkdirSync(testWorkspace, { recursive: true });
-    originalEnv = process.env.CLAWCLAW_WORKSPACE_DIR;
-    process.env.CLAWCLAW_WORKSPACE_DIR = testWorkspace;
-  });
-
-  afterEach(() => {
-    if (originalEnv !== undefined) {
-      process.env.CLAWCLAW_WORKSPACE_DIR = originalEnv;
-    } else {
-      delete process.env.CLAWCLAW_WORKSPACE_DIR;
-    }
-    rmSync(testWorkspace, { recursive: true, force: true });
-  });
-
-  describe('rewriteBuiltinImports', () => {
-    it('should rewrite ALL relative imports to @myclaw163/clawclaw-cli', () => {
-      const source = `
-import type { GameState } from '../sdk/types.js';
-import { Action } from '../sdk/action.js';
-import { dist, killCommitRange } from './game-utils.js';
-import { GoalRootStrategy } from './goals/goal-root-strategy.js';
-import { TaskOnlyTop } from './goals/task-only-top.js';
-import { parseGreetingArgs } from './greeting.js';
-import { TTS_TEXT_MAX_LENGTH } from '../lib/tts-keys.js';
-
-export const strategy = { id: 'test', description: 'test', create: () => ({ name: 'test', decide: () => [] }) };
-`;
-      const rewritten = rewriteBuiltinImports(source, 'test', '0.6.31');
-
-      expect(rewritten).toContain('// Exported from test@0.6.31');
-      // All relative imports should be rewritten
-      expect(rewritten).not.toContain("'../sdk/types.js'");
-      expect(rewritten).not.toContain("'../sdk/action.js'");
-      expect(rewritten).not.toContain("'./game-utils.js'");
-      expect(rewritten).not.toContain("'./goals/goal-root-strategy.js'");
-      expect(rewritten).not.toContain("'./goals/task-only-top.js'");
-      expect(rewritten).not.toContain("'./greeting.js'");
-      expect(rewritten).not.toContain("'../lib/tts-keys.js'");
-      // Verify rewritten imports use @myclaw163/clawclaw-cli
-      expect(rewritten).toContain("from '@myclaw163/clawclaw-cli'");
-    });
-
-    it('should preserve user imports from clawclaw-cli', () => {
-      const source = `
-import { Action } from 'clawclaw-cli';
-import type { GameState } from '../sdk/types.js';
-
-export const strategy = { id: 'test', description: 'test', create: () => ({ name: 'test', decide: () => [] }) };
-`;
-      const rewritten = rewriteBuiltinImports(source, 'test', '0.6.31');
-      expect(rewritten).toContain("import { Action } from 'clawclaw-cli'");
-      expect(rewritten).toContain("from 'clawclaw-cli'");
-    });
-  });
-
-  describe('exportStrategy', () => {
-    it('should export a formerly goal-based strategy with its knowledge sidecar', async () => {
-      await exportStrategy('kill-lone');
-
-      const strategiesDir = join(testWorkspace, 'strategies');
-      expect(existsSync(join(strategiesDir, 'kill-lone.ts'))).toBe(true);
-      expect(existsSync(join(strategiesDir, 'kill-lone.knowledge.md'))).toBe(true);
-    });
-
-    it('should export a valid strategy', async () => {
-      await exportStrategy('task-only');
-
-      const strategyFile = join(testWorkspace, 'strategies', 'task-only.ts');
-      const manifestFile = join(testWorkspace, 'strategies', '.official', 'manifest.json');
-
-      expect(existsSync(strategyFile)).toBe(true);
-      expect(existsSync(manifestFile)).toBe(true);
-
-      const strategy = readFileSync(strategyFile, 'utf8');
-      expect(strategy).toContain('// Exported from task-only@');
-      expect(strategy).toContain("from '@myclaw163/clawclaw-cli'");
-
-      const manifest = readManifest();
-      expect(manifest['task-only']).toBeDefined();
-      expect(manifest['task-only'].sourceHash).toBeDefined();
-    });
-
-    it('should reject strategy with unexported SDK symbol', async () => {
-      // Create a fake builtin strategy that imports a symbol not in the SDK
-      const fakeDir = join(testWorkspace, 'fake-builtin');
-      mkdirSync(fakeDir, { recursive: true });
-      const fakeFile = join(fakeDir, 'broken-strategy.ts');
-      writeFileSync(fakeFile, `
-import { TotallyMissingSymbol } from 'clawclaw-cli';
-export const strategy = {
-  id: 'broken-strategy',
-  description: 'test',
-  create: () => ({ name: 'broken', decide: () => [TotallyMissingSymbol] }),
-};
-`, 'utf8');
-
-      // Temporarily override locateBuiltinSource to point to our fake
-      const { rewriteBuiltinImports } = await import('./strategy-export.js');
-      const rewritten = rewriteBuiltinImports(
-        readFileSync(fakeFile, 'utf8'),
-        'broken-strategy',
-        '0.0.0'
-      );
-
-      // Validate should catch the missing symbol
-      const { validateExportable } = await import('./strategy-export.js') as any;
-      if (typeof validateExportable === 'function') {
-        const result = await validateExportable(rewritten);
-        expect(result.ok).toBe(false);
-        expect(result.error).toBeDefined();
-      }
-    });
-
-    it('should refuse to overwrite untracked files without --force', async () => {
-      const strategiesDir = join(testWorkspace, 'strategies');
-      mkdirSync(strategiesDir, { recursive: true });
-      writeFileSync(join(strategiesDir, 'task-only.ts'), '// user file', 'utf8');
-
-
-      await expect(exportStrategy('task-only')).rejects.toThrow(
-        'already exists and is not tracked. Use --force to overwrite.'
-      );
-    });
-
-    it('should overwrite untracked files with --force', async () => {
-      const strategiesDir = join(testWorkspace, 'strategies');
-      mkdirSync(strategiesDir, { recursive: true });
-      writeFileSync(join(strategiesDir, 'task-only.ts'), '// user file', 'utf8');
-
-      await exportStrategy('task-only', { force: true });
-
-      const strategy = readFileSync(join(strategiesDir, 'task-only.ts'), 'utf8');
-      expect(strategy).toContain('// Exported from task-only@');
-    });
-
-    it('should allow re-exporting tracked strategies without --force', async () => {
-      // First export
-      await exportStrategy('task-only');
-
-      const strategiesDir = join(testWorkspace, 'strategies');
-      const strategyFile = join(strategiesDir, 'task-only.ts');
-
-      // Modify the file
-      writeFileSync(strategyFile, '// user customized', 'utf8');
-
-      // Re-export without --force (should succeed because it's tracked)
-      await exportStrategy('task-only');
-
-      const strategy = readFileSync(strategyFile, 'utf8');
-      expect(strategy).toContain('// Exported from task-only@');
-    });
-
-    it('should reject non-existent strategies', async () => {
-      await expect(exportStrategy('non-existent-strategy')).rejects.toThrow(
-        "Built-in strategy 'non-existent-strategy' not found."
-      );
-    });
-  });
-
-  describe('detectStaleOfficialStrategies', () => {
-    it('should return empty array when no strategies are exported', () => {
-      expect(detectStaleOfficialStrategies()).toEqual([]);
-    });
-
-    it('should return empty array when all strategies are up to date', async () => {
-      await exportStrategy('task-only');
-      expect(detectStaleOfficialStrategies()).toEqual([]);
-    });
-
-    it('should return stale IDs when source hash mismatch', async () => {
-      await exportStrategy('task-only');
-
-      // Manually modify the manifest to simulate a stale hash
-      const manifestFile = join(testWorkspace, 'strategies', '.official', 'manifest.json');
-      const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
-      manifest['task-only'].sourceHash = 'stale-hash-value';
-      writeFileSync(manifestFile, JSON.stringify(manifest, null, 2), 'utf8');
-
-      expect(detectStaleOfficialStrategies()).toEqual(['task-only']);
-    });
-
-    it('should return multiple stale IDs', async () => {
-      await exportStrategy('task-only');
-      await exportStrategy('kill-lone');
-
-      // Make both stale
-      const manifestFile = join(testWorkspace, 'strategies', '.official', 'manifest.json');
-      const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
-      manifest['task-only'].sourceHash = 'stale-1';
-      manifest['kill-lone'].sourceHash = 'stale-2';
-      writeFileSync(manifestFile, JSON.stringify(manifest, null, 2), 'utf8');
-
-      const stale = detectStaleOfficialStrategies();
-      expect(stale).toContain('task-only');
-      expect(stale).toContain('kill-lone');
-      expect(stale).toHaveLength(2);
-    });
-
-    it('should detect stale when sidecar hash changes', async () => {
-      await exportStrategy('kill-lone');
-
-      // Verify kill-lone has a sidecar hash (it has a .knowledge.md)
-      const manifestFile = join(testWorkspace, 'strategies', '.official', 'manifest.json');
-      const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
-      expect(manifest['kill-lone'].sidecarHash).toBeDefined();
-
-      // Make sidecar stale
-      manifest['kill-lone'].sidecarHash = 'stale-sidecar';
-      writeFileSync(manifestFile, JSON.stringify(manifest, null, 2), 'utf8');
-
-      expect(detectStaleOfficialStrategies()).toEqual(['kill-lone']);
-    });
-  });
-});
+// src/lib/strategy-export.test.ts
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { existsSync, mkdirSync, writeFileSync, rmSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import {
+  rewriteBuiltinImports,
+  exportStrategy,
+  detectStaleOfficialStrategies,
+  readManifest,
+} from './strategy-export.js';
+
+describe('strategy-export', () => {
+  let testWorkspace: string;
+  let originalEnv: string | undefined;
+
+  beforeEach(() => {
+    testWorkspace = join(tmpdir(), `ccl-test-${Date.now()}`);
+    mkdirSync(testWorkspace, { recursive: true });
+    originalEnv = process.env.CLAWCLAW_WORKSPACE_DIR;
+    process.env.CLAWCLAW_WORKSPACE_DIR = testWorkspace;
+  });
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env.CLAWCLAW_WORKSPACE_DIR = originalEnv;
+    } else {
+      delete process.env.CLAWCLAW_WORKSPACE_DIR;
+    }
+    rmSync(testWorkspace, { recursive: true, force: true });
+  });
+
+  describe('rewriteBuiltinImports', () => {
+    it('should rewrite ALL relative imports to @myclaw163/clawclaw-cli', () => {
+      const source = `
+import type { GameState } from '../sdk/types.js';
+import { Action } from '../sdk/action.js';
+import { dist, killCommitRange } from './game-utils.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { TaskOnlyTop } from './goals/task-only-top.js';
+import { parseGreetingArgs } from './greeting.js';
+import { TTS_TEXT_MAX_LENGTH } from '../lib/tts-keys.js';
+
+export const strategy = { id: 'test', description: 'test', create: () => ({ name: 'test', decide: () => [] }) };
+`;
+      const rewritten = rewriteBuiltinImports(source, 'test', '0.6.31');
+
+      expect(rewritten).toContain('// Exported from test@0.6.31');
+      // All relative imports should be rewritten
+      expect(rewritten).not.toContain("'../sdk/types.js'");
+      expect(rewritten).not.toContain("'../sdk/action.js'");
+      expect(rewritten).not.toContain("'./game-utils.js'");
+      expect(rewritten).not.toContain("'./goals/goal-root-strategy.js'");
+      expect(rewritten).not.toContain("'./goals/task-only-top.js'");
+      expect(rewritten).not.toContain("'./greeting.js'");
+      expect(rewritten).not.toContain("'../lib/tts-keys.js'");
+      // Verify rewritten imports use @myclaw163/clawclaw-cli
+      expect(rewritten).toContain("from '@myclaw163/clawclaw-cli'");
+    });
+
+    it('should preserve user imports from clawclaw-cli', () => {
+      const source = `
+import { Action } from 'clawclaw-cli';
+import type { GameState } from '../sdk/types.js';
+
+export const strategy = { id: 'test', description: 'test', create: () => ({ name: 'test', decide: () => [] }) };
+`;
+      const rewritten = rewriteBuiltinImports(source, 'test', '0.6.31');
+      expect(rewritten).toContain("import { Action } from 'clawclaw-cli'");
+      expect(rewritten).toContain("from 'clawclaw-cli'");
+    });
+  });
+
+  describe('exportStrategy', () => {
+    it('should export a formerly goal-based strategy with its knowledge sidecar', async () => {
+      await exportStrategy('kill-lone');
+
+      const strategiesDir = join(testWorkspace, 'strategies');
+      expect(existsSync(join(strategiesDir, 'kill-lone.ts'))).toBe(true);
+      expect(existsSync(join(strategiesDir, 'kill-lone.knowledge.md'))).toBe(true);
+    });
+
+    it('should export a valid strategy', async () => {
+      await exportStrategy('task-only');
+
+      const strategyFile = join(testWorkspace, 'strategies', 'task-only.ts');
+      const manifestFile = join(testWorkspace, 'strategies', '.official', 'manifest.json');
+
+      expect(existsSync(strategyFile)).toBe(true);
+      expect(existsSync(manifestFile)).toBe(true);
+
+      const strategy = readFileSync(strategyFile, 'utf8');
+      expect(strategy).toContain('// Exported from task-only@');
+      expect(strategy).toContain("from '@myclaw163/clawclaw-cli'");
+
+      const manifest = readManifest();
+      expect(manifest['task-only']).toBeDefined();
+      expect(manifest['task-only'].sourceHash).toBeDefined();
+    });
+
+    it('should reject strategy with unexported SDK symbol', async () => {
+      // Create a fake builtin strategy that imports a symbol not in the SDK
+      const fakeDir = join(testWorkspace, 'fake-builtin');
+      mkdirSync(fakeDir, { recursive: true });
+      const fakeFile = join(fakeDir, 'broken-strategy.ts');
+      writeFileSync(fakeFile, `
+import { TotallyMissingSymbol } from 'clawclaw-cli';
+export const strategy = {
+  id: 'broken-strategy',
+  description: 'test',
+  create: () => ({ name: 'broken', decide: () => [TotallyMissingSymbol] }),
+};
+`, 'utf8');
+
+      // Temporarily override locateBuiltinSource to point to our fake
+      const { rewriteBuiltinImports } = await import('./strategy-export.js');
+      const rewritten = rewriteBuiltinImports(
+        readFileSync(fakeFile, 'utf8'),
+        'broken-strategy',
+        '0.0.0'
+      );
+
+      // Validate should catch the missing symbol
+      const { validateExportable } = await import('./strategy-export.js') as any;
+      if (typeof validateExportable === 'function') {
+        const result = await validateExportable(rewritten);
+        expect(result.ok).toBe(false);
+        expect(result.error).toBeDefined();
+      }
+    });
+
+    it('should refuse to overwrite untracked files without --force', async () => {
+      const strategiesDir = join(testWorkspace, 'strategies');
+      mkdirSync(strategiesDir, { recursive: true });
+      writeFileSync(join(strategiesDir, 'task-only.ts'), '// user file', 'utf8');
+
+
+      await expect(exportStrategy('task-only')).rejects.toThrow(
+        'already exists and is not tracked. Use --force to overwrite.'
+      );
+    });
+
+    it('should overwrite untracked files with --force', async () => {
+      const strategiesDir = join(testWorkspace, 'strategies');
+      mkdirSync(strategiesDir, { recursive: true });
+      writeFileSync(join(strategiesDir, 'task-only.ts'), '// user file', 'utf8');
+
+      await exportStrategy('task-only', { force: true });
+
+      const strategy = readFileSync(join(strategiesDir, 'task-only.ts'), 'utf8');
+      expect(strategy).toContain('// Exported from task-only@');
+    });
+
+    it('should allow re-exporting tracked strategies without --force', async () => {
+      // First export
+      await exportStrategy('task-only');
+
+      const strategiesDir = join(testWorkspace, 'strategies');
+      const strategyFile = join(strategiesDir, 'task-only.ts');
+
+      // Modify the file
+      writeFileSync(strategyFile, '// user customized', 'utf8');
+
+      // Re-export without --force (should succeed because it's tracked)
+      await exportStrategy('task-only');
+
+      const strategy = readFileSync(strategyFile, 'utf8');
+      expect(strategy).toContain('// Exported from task-only@');
+    });
+
+    it('should reject non-existent strategies', async () => {
+      await expect(exportStrategy('non-existent-strategy')).rejects.toThrow(
+        "Built-in strategy 'non-existent-strategy' not found."
+      );
+    });
+  });
+
+  describe('detectStaleOfficialStrategies', () => {
+    it('should return empty array when no strategies are exported', () => {
+      expect(detectStaleOfficialStrategies()).toEqual([]);
+    });
+
+    it('should return empty array when all strategies are up to date', async () => {
+      await exportStrategy('task-only');
+      expect(detectStaleOfficialStrategies()).toEqual([]);
+    });
+
+    it('should return stale IDs when source hash mismatch', async () => {
+      await exportStrategy('task-only');
+
+      // Manually modify the manifest to simulate a stale hash
+      const manifestFile = join(testWorkspace, 'strategies', '.official', 'manifest.json');
+      const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
+      manifest['task-only'].sourceHash = 'stale-hash-value';
+      writeFileSync(manifestFile, JSON.stringify(manifest, null, 2), 'utf8');
+
+      expect(detectStaleOfficialStrategies()).toEqual(['task-only']);
+    });
+
+    it('should return multiple stale IDs', async () => {
+      await exportStrategy('task-only');
+      await exportStrategy('kill-lone');
+
+      // Make both stale
+      const manifestFile = join(testWorkspace, 'strategies', '.official', 'manifest.json');
+      const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
+      manifest['task-only'].sourceHash = 'stale-1';
+      manifest['kill-lone'].sourceHash = 'stale-2';
+      writeFileSync(manifestFile, JSON.stringify(manifest, null, 2), 'utf8');
+
+      const stale = detectStaleOfficialStrategies();
+      expect(stale).toContain('task-only');
+      expect(stale).toContain('kill-lone');
+      expect(stale).toHaveLength(2);
+    });
+
+    it('should detect stale when sidecar hash changes', async () => {
+      await exportStrategy('kill-lone');
+
+      // Verify kill-lone has a sidecar hash (it has a .knowledge.md)
+      const manifestFile = join(testWorkspace, 'strategies', '.official', 'manifest.json');
+      const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
+      expect(manifest['kill-lone'].sidecarHash).toBeDefined();
+
+      // Make sidecar stale
+      manifest['kill-lone'].sidecarHash = 'stale-sidecar';
+      writeFileSync(manifestFile, JSON.stringify(manifest, null, 2), 'utf8');
+
+      expect(detectStaleOfficialStrategies()).toEqual(['kill-lone']);
+    });
+  });
+});