211 lines
8.4 KiB
TypeScript
211 lines
8.4 KiB
TypeScript
import { cp, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
|
|
import { tmpdir } from 'node:os';
|
|
import { dirname, join, resolve } from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { afterEach, beforeEach, describe, expect, it } from 'vitest';
|
|
import {
|
|
extractClassesFromDir,
|
|
listPersonaClasses,
|
|
personaStatus,
|
|
resolvePersona,
|
|
} from './fleet-personas.js';
|
|
import { loadProfiles, validateProfile, type FleetProfile } from './fleet-profiles.js';
|
|
|
|
// The real, committed library: packages/mosaic/src/commands -> framework/fleet.
|
|
const frameworkFleet = resolve(
|
|
dirname(fileURLToPath(import.meta.url)),
|
|
'..',
|
|
'..',
|
|
'framework',
|
|
'fleet',
|
|
);
|
|
const realRolesDir = join(frameworkFleet, 'roles');
|
|
|
|
let tmp: string;
|
|
let rolesDir: string;
|
|
let overrideDir: string;
|
|
|
|
// A minimal baseline persona file with an inline `class:` + `domain:` marker.
|
|
function baselinePersona(klass: string, domain: string, marker = 'BASELINE'): string {
|
|
return `# ${klass} — fleet role definition
|
|
|
|
The **${klass}** is the ${marker} definition (\`class: ${klass}\`, \`domain: ${domain}\`).
|
|
`;
|
|
}
|
|
|
|
function overridePersona(klass: string, domain: string, marker = 'OVERRIDE'): string {
|
|
return `# ${klass} — fleet role definition (override)
|
|
|
|
The **${klass}** is the ${marker} definition (\`class: ${klass}\`, \`domain: ${domain}\`).
|
|
`;
|
|
}
|
|
|
|
beforeEach(async () => {
|
|
tmp = await mkdtemp(join(tmpdir(), 'h4-personas-'));
|
|
rolesDir = join(tmp, 'roles');
|
|
overrideDir = join(tmp, 'roles.local');
|
|
await mkdir(rolesDir, { recursive: true });
|
|
// Seed two baseline personas. (No override dir yet — created per test.)
|
|
await writeFile(join(rolesDir, 'ceo.md'), baselinePersona('ceo', 'executive'), 'utf8');
|
|
await writeFile(join(rolesDir, 'code.md'), baselinePersona('code', 'engineering'), 'utf8');
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await rm(tmp, { recursive: true, force: true });
|
|
});
|
|
|
|
describe('extractClassesFromDir (shared extraction)', () => {
|
|
it('records class + domain from inline markers and degrades on missing dir', async () => {
|
|
const base = await extractClassesFromDir(rolesDir);
|
|
expect(base.classes.has('ceo')).toBe(true);
|
|
expect(base.byClass.get('ceo')?.domain).toBe('executive');
|
|
const missing = await extractClassesFromDir(join(tmp, 'nope'));
|
|
expect(missing.classes.size).toBe(0);
|
|
});
|
|
});
|
|
|
|
describe('resolvePersona — override wins', () => {
|
|
it('resolves to the override when a class exists in BOTH layers', async () => {
|
|
await mkdir(overrideDir, { recursive: true });
|
|
await writeFile(join(overrideDir, 'ceo.md'), overridePersona('ceo', 'executive'), 'utf8');
|
|
|
|
const resolved = await resolvePersona('ceo', { rolesDir, overrideDir });
|
|
expect(resolved?.layer).toBe('override');
|
|
expect(resolved?.content).toContain('OVERRIDE');
|
|
expect(resolved?.file).toBe(join(overrideDir, 'ceo.md'));
|
|
});
|
|
|
|
it('resolves to the baseline when no override exists', async () => {
|
|
const resolved = await resolvePersona('code', { rolesDir, overrideDir });
|
|
expect(resolved?.layer).toBe('baseline');
|
|
expect(resolved?.content).toContain('BASELINE');
|
|
});
|
|
|
|
it('returns null for an unknown class', async () => {
|
|
expect(await resolvePersona('does-not-exist', { rolesDir, overrideDir })).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('custom add — override-only class', () => {
|
|
it('a class present only in roles.local/ appears in listPersonaClasses and resolves', async () => {
|
|
await mkdir(overrideDir, { recursive: true });
|
|
await writeFile(
|
|
join(overrideDir, 'mascot.md'),
|
|
overridePersona('mascot', 'fun', 'CUSTOM'),
|
|
'utf8',
|
|
);
|
|
|
|
const classes = await listPersonaClasses({ rolesDir, overrideDir });
|
|
expect(classes.has('mascot')).toBe(true);
|
|
// Baseline classes are still present (union).
|
|
expect(classes.has('ceo')).toBe(true);
|
|
|
|
const resolved = await resolvePersona('mascot', { rolesDir, overrideDir });
|
|
expect(resolved?.layer).toBe('override');
|
|
expect(resolved?.content).toContain('CUSTOM');
|
|
});
|
|
});
|
|
|
|
describe('personaStatus classification', () => {
|
|
it('classifies baseline / overridden / custom correctly', async () => {
|
|
await mkdir(overrideDir, { recursive: true });
|
|
// ceo: overridden (both). code: baseline (only base). mascot: custom (only override).
|
|
await writeFile(join(overrideDir, 'ceo.md'), overridePersona('ceo', 'executive'), 'utf8');
|
|
await writeFile(join(overrideDir, 'mascot.md'), overridePersona('mascot', 'fun'), 'utf8');
|
|
|
|
const status = await personaStatus({ rolesDir, overrideDir });
|
|
const byClass = new Map(status.map((s) => [s.klass, s]));
|
|
expect(byClass.get('ceo')?.status).toBe('overridden');
|
|
expect(byClass.get('code')?.status).toBe('baseline');
|
|
expect(byClass.get('mascot')?.status).toBe('custom');
|
|
// Domain surfaced.
|
|
expect(byClass.get('ceo')?.domain).toBe('executive');
|
|
});
|
|
});
|
|
|
|
describe('AC-NS-7 — update-survival simulation', () => {
|
|
it('override and custom-added class survive a baseline reseed', async () => {
|
|
// 1. User customizes ceo and adds a brand-new persona in the override layer.
|
|
await mkdir(overrideDir, { recursive: true });
|
|
await writeFile(join(overrideDir, 'ceo.md'), overridePersona('ceo', 'executive'), 'utf8');
|
|
await writeFile(
|
|
join(overrideDir, 'mascot.md'),
|
|
overridePersona('mascot', 'fun', 'CUSTOM'),
|
|
'utf8',
|
|
);
|
|
|
|
// 2. Simulate `mosaic update`: REPLACE the baseline roles/ entirely (as the
|
|
// framework reseed/rsync does), leaving roles.local/ untouched. The reseed
|
|
// even ships a NEW baseline ceo and adds a brand-new baseline persona.
|
|
await rm(rolesDir, { recursive: true, force: true });
|
|
await mkdir(rolesDir, { recursive: true });
|
|
await writeFile(
|
|
join(rolesDir, 'ceo.md'),
|
|
baselinePersona('ceo', 'executive', 'RESEEDED-BASELINE'),
|
|
'utf8',
|
|
);
|
|
await writeFile(join(rolesDir, 'code.md'), baselinePersona('code', 'engineering'), 'utf8');
|
|
await writeFile(join(rolesDir, 'new-role.md'), baselinePersona('new-role', 'ops'), 'utf8');
|
|
|
|
// 3. The override STILL wins (was not clobbered by the reseed).
|
|
const ceo = await resolvePersona('ceo', { rolesDir, overrideDir });
|
|
expect(ceo?.layer).toBe('override');
|
|
expect(ceo?.content).toContain('OVERRIDE');
|
|
expect(ceo?.content).not.toContain('RESEEDED-BASELINE');
|
|
|
|
// 4. The custom-added class still exists and resolves.
|
|
const mascot = await resolvePersona('mascot', { rolesDir, overrideDir });
|
|
expect(mascot?.layer).toBe('override');
|
|
expect(mascot?.content).toContain('CUSTOM');
|
|
|
|
// 5. New baseline personas from the reseed are now visible too.
|
|
const classes = await listPersonaClasses({ rolesDir, overrideDir });
|
|
expect(classes.has('new-role')).toBe(true);
|
|
expect(classes.has('mascot')).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('fleet-profiles validation accepts a custom (override-only) persona', () => {
|
|
it('a profile referencing an override-only class validates', async () => {
|
|
// Build a profiles dir + roles using the REAL library plus a custom persona.
|
|
const profilesDir = join(tmp, 'profiles');
|
|
const customRolesDir = join(tmp, 'real-roles');
|
|
const customOverrideDir = join(tmp, 'real-roles.local');
|
|
await mkdir(profilesDir, { recursive: true });
|
|
await cp(realRolesDir, customRolesDir, { recursive: true });
|
|
await mkdir(customOverrideDir, { recursive: true });
|
|
await writeFile(join(customOverrideDir, 'mascot.md'), overridePersona('mascot', 'fun'), 'utf8');
|
|
|
|
// A profile whose roster references the custom (override-only) persona.
|
|
const profileYaml = [
|
|
'id: custom-team',
|
|
'title: Custom Team',
|
|
'description: A team that uses a user-added persona.',
|
|
'lead: ceo',
|
|
'floor:',
|
|
' - ceo',
|
|
'roster:',
|
|
' - class: ceo',
|
|
' - class: mascot',
|
|
' reports_to: ceo',
|
|
].join('\n');
|
|
await writeFile(join(profilesDir, 'custom-team.yaml'), profileYaml, 'utf8');
|
|
|
|
// Override-aware loadProfiles must accept it (would throw if mascot unknown).
|
|
const profiles = await loadProfiles({
|
|
profilesDir,
|
|
rolesDir: customRolesDir,
|
|
overrideDir: customOverrideDir,
|
|
});
|
|
const team = profiles.find((p: FleetProfile) => p.id === 'custom-team');
|
|
expect(team).toBeDefined();
|
|
|
|
// And direct validation against the union confirms zero problems.
|
|
const validClasses = await listPersonaClasses({
|
|
rolesDir: customRolesDir,
|
|
overrideDir: customOverrideDir,
|
|
});
|
|
expect(validateProfile(team as FleetProfile, validClasses)).toEqual([]);
|
|
});
|
|
});
|