principles-disciple 1.8.1 → 1.8.2

package/tests/core/init-flatten.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ensureWorkspaceTemplates } from '../../src/core/init.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+vi.mock('fs');
+
+describe('init-flatten', () => {
+    const mockLogger = {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    };
+
+    const mockApi = {
+        logger: mockLogger,
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+
+    it('should flatten core templates to workspace root and not create core subfolder', () => {
+        const workspaceDir = '/mock/workspace';
+        
+        vi.mocked(fs.existsSync).mockImplementation((p) => {
+            const pathStr = p.toString().replace(/\\/g, '/');
+            // Mock that common templates don't exist to simplify
+            if (pathStr.includes('templates/workspace')) return false;
+            // Mock that core templates DO exist
+            if (pathStr.includes('templates/langs/zh/core')) return true;
+            // Mock that pain templates don't exist to simplify
+            if (pathStr.includes('pain')) return false;
+            return false;
+        });
+
+        vi.mocked(fs.readdirSync).mockImplementation((p) => {
+            const pathStr = p.toString().replace(/\\/g, '/');
+            if (pathStr.endsWith('templates/langs/zh/core')) {
+                return ['AGENTS.md', 'SOUL.md'] as any;
+            }
+            return [] as any;
+        });
+
+        // Mock statSync to return not a directory for files
+        vi.mocked(fs.statSync).mockReturnValue({ isDirectory: () => false } as any);
+
+        ensureWorkspaceTemplates(mockApi as any, workspaceDir, 'zh');
+
+        // Check if copyFileSync was called for the files
+        const copyCalls = vi.mocked(fs.copyFileSync).mock.calls;
+        
+        // It should copy AGENTS.md directly to /mock/workspace/AGENTS.md
+        const agentsCall = copyCalls.find(c => c[1].toString().replace(/\\/g, '/').endsWith('/mock/workspace/AGENTS.md'));
+        expect(agentsCall).toBeDefined();
+        
+        // It should NOT copy to /mock/workspace/core/AGENTS.md
+        const wrongAgentsCall = copyCalls.find(c => c[1].toString().replace(/\\/g, '/').includes('/mock/workspace/core/'));
+        expect(wrongAgentsCall).toBeUndefined();
+
+        // Check logs
+        expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining('Flattening zh core templates to workspace root'));
+    });
+});

package/tests/core/init-refactor.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ensureWorkspaceTemplates } from '../../src/core/init.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+vi.mock('fs');
+
+describe('init - Directory Refactor', () => {
+    const mockLogger = {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    };
+
+    const mockApi = {
+        logger: mockLogger,
+    } as any;
+
+    // Use path.resolve for cross-platform compatibility
+    const workspaceDir = path.resolve('/mock/workspace');
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+
+    it('should copy files to new directory structure (.principles and .state)', () => {
+        vi.mocked(fs.existsSync).mockImplementation((p) => {
+            const pathStr = p.toString();
+            // Source templates exist
+            if (pathStr.includes('templates')) return true;
+            // Destination does not exist (force creation)
+            return false;
+        });
+
+        // Mock readdirSync for template directories
+        vi.mocked(fs.readdirSync).mockImplementation((p) => {
+            const pathStr = p.toString();
+            // Only return items for the main workspace templates directory
+            const isWorkspaceTemplates = pathStr.includes('templates') && 
+                                          pathStr.includes('workspace') && 
+                                          !pathStr.includes('.principles') && 
+                                          !pathStr.includes('.state');
+            if (isWorkspaceTemplates) {
+                return ['.principles', '.state', 'PLAN.md'] as any;
+            }
+            if (pathStr.includes('.principles')) return ['PROFILE.json', 'PRINCIPLES.md'] as any;
+            if (pathStr.includes('.state')) return ['WORKBOARD.json'] as any;
+            if (pathStr.includes('core')) return ['AGENTS.md', 'SOUL.md'] as any;
+            return [] as any;
+        });
+
+        vi.mocked(fs.statSync).mockImplementation((p) => {
+            const pathStr = p.toString();
+            // Precisely match directory names - must end with .principles or .state
+            // Use regex that handles both forward and backward slashes
+            const isDir = /[\\\/]\.principles$/.test(pathStr) || /[\\\/]\.state$/.test(pathStr);
+            return {
+                isDirectory: () => isDir
+            } as any;
+        });
+
+        vi.mocked(fs.mkdirSync).mockImplementation(() => undefined as any);
+
+        ensureWorkspaceTemplates(mockApi, workspaceDir);
+
+        // Verify that it tried to create the new hidden directories
+        expect(fs.mkdirSync).toHaveBeenCalledWith(expect.stringContaining('.principles'), expect.anything());
+        expect(fs.mkdirSync).toHaveBeenCalledWith(expect.stringContaining('.state'), expect.anything());
+
+        // Verify that PLAN.md is copied to root
+        expect(fs.copyFileSync).toHaveBeenCalledWith(
+            expect.stringMatching(/PLAN\.md$/),
+            path.join(workspaceDir, 'PLAN.md')
+        );
+
+        // Verify that PROFILE.json is copied to .principles
+        expect(fs.copyFileSync).toHaveBeenCalledWith(
+            expect.stringMatching(/PROFILE\.json$/),
+            path.join(workspaceDir, '.principles', 'PROFILE.json')
+        );
+    });
+});

package/tests/core/init-v1.3.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ensureWorkspaceTemplates } from '../../src/core/init.js';
+import * as fs from 'fs';
+
+vi.mock('fs');
+
+describe('init v1.3 - simplified', () => {
+    const mockLogger = {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    describe('ensureWorkspaceTemplates - pain_memory', () => {
+        it('should attempt to create the pain memory directory', () => {
+            const workspaceDir = '/mock/workspace';
+            
+            // Allow EVERYTHING to exist to avoid bail-outs
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            // EXCEPT for the final pain directory, so we trigger mkdir
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                if (pathStr.includes('memory') || pathStr.includes('pain')) {
+                    if (pathStr.includes('templates')) return true; // Source templates exist
+                    return false; // Destination doesn't
+                }
+                return true;
+            });
+
+            vi.mocked(fs.readdirSync).mockReturnValue([] as any);
+
+            ensureWorkspaceTemplates({ logger: mockLogger } as any, workspaceDir, 'zh');
+
+            // Find if any mkdirSync call included 'pain'
+            const mkdirCalls = vi.mocked(fs.mkdirSync).mock.calls;
+            const hasPain = mkdirCalls.some(args => args[0].toString().includes('pain'));
+            
+            expect(hasPain).toBe(true);
+        });
+    });
+});

package/tests/core/init.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ensureWorkspaceTemplates, ensureStateTemplates } from '../../src/core/init.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+vi.mock('fs');
+
+describe('init', () => {
+    const mockLogger = {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    };
+
+    const mockApi = {
+        logger: mockLogger,
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+
+    describe('ensureStateTemplates', () => {
+        it('should create stateDir if it does not exist', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+
+            ensureStateTemplates({ logger: mockLogger }, '/mock/state');
+
+            expect(fs.mkdirSync).toHaveBeenCalledWith('/mock/state', { recursive: true });
+        });
+
+        it('should not create stateDir if it already exists', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+
+            ensureStateTemplates({ logger: mockLogger }, '/mock/state');
+
+            expect(fs.mkdirSync).not.toHaveBeenCalled();
+        });
+
+        it('should copy pain_settings.json if missing', () => {
+            let existsPaths = new Set<string>();
+            
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                const normalizedPath = pathStr.replace(/\\/g, '/');
+                // Template exists, but destination does not
+                if (normalizedPath.includes('templates/pain_settings.json')) return true;
+                if (normalizedPath.endsWith('pain_settings.json')) return false;
+                if (normalizedPath.endsWith('stateDir')) return false;
+                return existsPaths.has(pathStr);
+            });
+
+            ensureStateTemplates({ logger: mockLogger }, '/mock/state');
+
+            expect(fs.copyFileSync).toHaveBeenCalled();
+        });
+
+        it('should not copy pain_settings.json if already exists', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+
+            ensureStateTemplates({ logger: mockLogger }, '/mock/state');
+
+            // Should not copy since files already exist
+            expect(fs.copyFileSync).not.toHaveBeenCalled();
+        });
+
+        it('should log error on failure', () => {
+            vi.mocked(fs.existsSync).mockImplementation(() => {
+                throw new Error('Test error');
+            });
+
+            ensureStateTemplates({ logger: mockLogger }, '/mock/state');
+
+            expect(mockLogger.error).toHaveBeenCalledWith(
+                expect.stringContaining('Failed to initialize state templates')
+            );
+        });
+
+        it('should use language-specific dictionary template', () => {
+            const stateDir = '/mock/state';
+            
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                const normalizedPath = pathStr.replace(/\\/g, '/');
+                // State dir exists
+                if (normalizedPath === stateDir) return true;
+                // pain_settings.json template exists
+                if (normalizedPath.includes('templates/pain_settings.json')) return true;
+                // zh-CN dictionary template exists
+                if (normalizedPath.includes('templates/langs/zh-CN/pain_dictionary.json')) return true;
+                // Destination files don't exist
+                if (normalizedPath.endsWith('pain_settings.json')) return false;
+                if (normalizedPath.endsWith('pain_dictionary.json')) return false;
+                return false;
+            });
+
+            ensureStateTemplates({ logger: mockLogger }, stateDir, 'zh-CN');
+
+            const copyCalls = vi.mocked(fs.copyFileSync).mock.calls;
+            const dictCall = copyCalls.find(c => c[1].toString().endsWith('pain_dictionary.json'));
+            expect(dictCall).toBeDefined();
+            const dictSrcPath = dictCall?.[0].toString().replace(/\\/g, '/');
+            expect(dictSrcPath).toContain('zh-CN');
+        });
+
+        it('should copy en dictionary as fallback when language-specific not found', () => {
+            const stateDir = '/mock/state';
+            
+            // Return true for most template checks, but destination files don't exist
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                const normalizedPath = pathStr.replace(/\\/g, '/');
+                // stateDir exists
+                if (normalizedPath === stateDir) return true;
+                // Template files exist
+                if (normalizedPath.includes('templates')) return true;
+                // Destination files don't exist (force copy)
+                return false;
+            });
+
+            ensureStateTemplates({ logger: mockLogger }, stateDir, 'zh-CN');
+
+            // Verify dictionary was copied
+            const copyCalls = vi.mocked(fs.copyFileSync).mock.calls;
+            const dictCall = copyCalls.find(c => c[1].toString().endsWith('pain_dictionary.json'));
+            expect(dictCall).toBeDefined();
+        });
+    });
+
+    describe('ensureWorkspaceTemplates', () => {
+        it('should handle missing common templates directory', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+
+            ensureWorkspaceTemplates(mockApi as any, '/mock/workspace');
+
+            // Should not throw, just skip
+            expect(mockLogger.error).not.toHaveBeenCalled();
+        });
+
+        it('should log error on failure', () => {
+            vi.mocked(fs.existsSync).mockImplementation(() => {
+                throw new Error('Test error');
+            });
+
+            ensureWorkspaceTemplates(mockApi as any, '/mock/workspace');
+
+            expect(mockLogger.error).toHaveBeenCalledWith(
+                expect.stringContaining('Failed to initialize workspace templates')
+            );
+        });
+
+        it('should warn when existing core guidance files contain legacy agent routing terms', () => {
+            const workspaceDir = '/mock/workspace';
+
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const normalizedPath = p.toString().replace(/\\/g, '/');
+                if (normalizedPath.includes('templates/workspace')) return false;
+                if (normalizedPath.includes('templates/langs/en/core')) return true;
+                if (normalizedPath.endsWith('/mock/workspace/AGENTS.md')) return true;
+                if (normalizedPath.endsWith('/mock/workspace/TOOLS.md')) return true;
+                if (normalizedPath.includes('pain')) return false;
+                if (normalizedPath.endsWith('/mock/workspace/.principles/PROFILE.json')) return false;
+                return false;
+            });
+
+            vi.mocked(fs.readdirSync).mockReturnValue(['AGENTS.md', 'TOOLS.md'] as any);
+            vi.mocked(fs.readFileSync).mockImplementation((p) => {
+                const normalizedPath = p.toString().replace(/\\/g, '/');
+                if (normalizedPath.endsWith('/mock/workspace/AGENTS.md')) {
+                    return 'Use pd_spawn_agent for sub-agents';
+                }
+                if (normalizedPath.endsWith('/mock/workspace/TOOLS.md')) {
+                    return 'Use sessions_list for all agent checks';
+                }
+                return '';
+            });
+
+            ensureWorkspaceTemplates(mockApi as any, workspaceDir, 'en');
+
+            expect(mockLogger.warn).toHaveBeenCalledWith(
+                expect.stringContaining('Outdated core guidance detected')
+            );
+        });
+    });
+});