607813f5d0
* feat(#1136): consume resolved capability state * chore(#1136): add capability state changeset
746 lines
29 KiB
JavaScript
746 lines
29 KiB
JavaScript
'use strict';
|
|
|
|
/**
|
|
* capability-state.test.cjs — behavioral tests for capability-state.cjs.
|
|
*
|
|
* ADR-857 phase 4b.
|
|
* Uses node:test + node:assert/strict.
|
|
* Pure-function tests (resolveCapabilityState) pass registry+Sets+config
|
|
* directly — no I/O. End-to-end tests use cmdCapabilityState + temp dirs.
|
|
*/
|
|
|
|
const { describe, test, before, after } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const os = require('node:os');
|
|
const path = require('node:path');
|
|
|
|
const { cleanup } = require('./helpers.cjs');
|
|
|
|
const {
|
|
resolveCapabilityState,
|
|
_isSafePropKey,
|
|
} = require('../gsd-core/bin/lib/capability-state.cjs');
|
|
|
|
// The real capability registry
|
|
const realRegistry = require('../gsd-core/bin/lib/capability-registry.cjs');
|
|
|
|
// ─── Synthetic registry fixture ───────────────────────────────────────────────
|
|
|
|
/**
|
|
* Build a minimal synthetic registry for a single capability with the given
|
|
* skills, steps, gates, contributions, and configSchema entries.
|
|
*/
|
|
function makeRegistry({
|
|
id = 'test-cap',
|
|
tier = 'standard',
|
|
skills = [],
|
|
steps = [],
|
|
gates = [],
|
|
contributions = [],
|
|
configSchema = {},
|
|
} = {}) {
|
|
return {
|
|
capabilities: {
|
|
[id]: {
|
|
id,
|
|
tier,
|
|
skills,
|
|
steps,
|
|
gates,
|
|
contributions,
|
|
config: {},
|
|
},
|
|
},
|
|
configSchema,
|
|
};
|
|
}
|
|
|
|
// ─── Temp project helpers ─────────────────────────────────────────────────────
|
|
|
|
let tmpProjectDir;
|
|
let tmpProjectDirFalse;
|
|
|
|
before(() => {
|
|
// Project with UI flags enabled
|
|
tmpProjectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cap-state-test-'));
|
|
const planningDir = path.join(tmpProjectDir, '.planning');
|
|
fs.mkdirSync(planningDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(planningDir, 'config.json'),
|
|
JSON.stringify({
|
|
workflow: {
|
|
ui_phase: true,
|
|
ui_review: true,
|
|
ui_safety_gate: true,
|
|
},
|
|
}),
|
|
'utf8',
|
|
);
|
|
|
|
// Project with all UI flags disabled
|
|
tmpProjectDirFalse = fs.mkdtempSync(path.join(os.tmpdir(), 'cap-state-false-'));
|
|
fs.mkdirSync(path.join(tmpProjectDirFalse, '.planning'), { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(path.join(tmpProjectDirFalse, '.planning'), 'config.json'),
|
|
JSON.stringify({
|
|
workflow: {
|
|
ui_phase: false,
|
|
ui_review: false,
|
|
ui_safety_gate: false,
|
|
},
|
|
}),
|
|
'utf8',
|
|
);
|
|
});
|
|
|
|
after(() => {
|
|
cleanup(tmpProjectDir);
|
|
cleanup(tmpProjectDirFalse);
|
|
});
|
|
|
|
// ─── _isSafePropKey helper ────────────────────────────────────────────────────
|
|
|
|
describe('_isSafePropKey', () => {
|
|
test('allows normal keys', () => {
|
|
assert.strictEqual(_isSafePropKey('ui'), true);
|
|
assert.strictEqual(_isSafePropKey('my-cap'), true);
|
|
assert.strictEqual(_isSafePropKey('cap123'), true);
|
|
});
|
|
|
|
test('blocks __proto__', () => {
|
|
assert.strictEqual(_isSafePropKey('__proto__'), false);
|
|
});
|
|
|
|
test('blocks constructor', () => {
|
|
assert.strictEqual(_isSafePropKey('constructor'), false);
|
|
});
|
|
|
|
test('blocks prototype', () => {
|
|
assert.strictEqual(_isSafePropKey('prototype'), false);
|
|
});
|
|
|
|
test('blocks non-string', () => {
|
|
assert.strictEqual(_isSafePropKey(null), false);
|
|
assert.strictEqual(_isSafePropKey(42), false);
|
|
assert.strictEqual(_isSafePropKey(undefined), false);
|
|
});
|
|
});
|
|
|
|
// ─── resolveCapabilityState — basic shapes ────────────────────────────────────
|
|
|
|
describe('resolveCapabilityState — basic shapes', () => {
|
|
test('empty registry → {capabilities:[]}', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: { capabilities: {} },
|
|
installedSkills: new Set(),
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
assert.deepStrictEqual(result, { capabilities: [] });
|
|
});
|
|
|
|
test('missing capabilities key → {capabilities:[]}', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: {},
|
|
installedSkills: new Set(),
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
assert.deepStrictEqual(result, { capabilities: [] });
|
|
});
|
|
|
|
test('null registry → {capabilities:[]}', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: null,
|
|
installedSkills: new Set(),
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
assert.deepStrictEqual(result, { capabilities: [] });
|
|
});
|
|
|
|
test('array registry → {capabilities:[]}', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: [],
|
|
installedSkills: new Set(),
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
assert.deepStrictEqual(result, { capabilities: [] });
|
|
});
|
|
|
|
test('malformed capabilities entry is skipped gracefully', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: { capabilities: { 'bad-cap': 'not-an-object' } },
|
|
installedSkills: new Set(),
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
assert.deepStrictEqual(result, { capabilities: [] });
|
|
});
|
|
});
|
|
|
|
// ─── resolveCapabilityState — installed dimension ────────────────────────────
|
|
|
|
describe('resolveCapabilityState — installed dimension', () => {
|
|
test('installedSkills="*" → installed=true for all caps', () => {
|
|
const registry = makeRegistry({ skills: ['ui-phase', 'ui-review'] });
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
assert.strictEqual(result.capabilities.length, 1);
|
|
assert.strictEqual(result.capabilities[0].installed, true);
|
|
});
|
|
|
|
test('all skills in installedSkills → installed=true', () => {
|
|
const registry = makeRegistry({ skills: ['ui-phase', 'ui-review'] });
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: new Set(['ui-phase', 'ui-review']),
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
assert.strictEqual(result.capabilities[0].installed, true);
|
|
});
|
|
|
|
test('one skill missing from installedSkills → installed=false', () => {
|
|
const registry = makeRegistry({ skills: ['ui-phase', 'ui-review'] });
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: new Set(['ui-phase']), // missing ui-review
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
assert.strictEqual(result.capabilities[0].installed, false);
|
|
});
|
|
|
|
test('empty skills array → installed=true vacuously', () => {
|
|
// A capability with zero skills has no skills to be absent, so it is
|
|
// vacuously installed and surfaced regardless of the installed/surfaced sets.
|
|
// This is intentional: capabilities that gate purely on config (no skills
|
|
// required) should report installed=true/surfaced=true when no skills are
|
|
// needed. Activation state is still governed by hook `when` keys.
|
|
const registry = makeRegistry({ skills: [] });
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: new Set(), // nothing installed — vacuous true still applies
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
assert.strictEqual(result.capabilities[0].installed, true);
|
|
assert.strictEqual(result.capabilities[0].surfaced, true);
|
|
});
|
|
});
|
|
|
|
// ─── resolveCapabilityState — surfaced dimension ──────────────────────────────
|
|
|
|
describe('resolveCapabilityState — surfaced dimension', () => {
|
|
test('all skills in surfacedSkills → surfaced=true', () => {
|
|
const registry = makeRegistry({ skills: ['ui-phase', 'ui-review'] });
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(['ui-phase', 'ui-review']),
|
|
config: {},
|
|
});
|
|
assert.strictEqual(result.capabilities[0].surfaced, true);
|
|
});
|
|
|
|
test('one skill missing from surfacedSkills → surfaced=false', () => {
|
|
const registry = makeRegistry({ skills: ['ui-phase', 'ui-review'] });
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(['ui-phase']), // missing ui-review
|
|
config: {},
|
|
});
|
|
assert.strictEqual(result.capabilities[0].surfaced, false);
|
|
});
|
|
|
|
test('empty skills array → surfaced=true vacuously', () => {
|
|
const registry = makeRegistry({ skills: [] });
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(), // nothing surfaced
|
|
config: {},
|
|
});
|
|
assert.strictEqual(result.capabilities[0].surfaced, true);
|
|
});
|
|
});
|
|
|
|
// ─── resolveCapabilityState — UI capability (real registry) ──────────────────
|
|
|
|
describe('resolveCapabilityState — UI capability with real registry', () => {
|
|
test('UI cap: installed=true when ui-phase + ui-review in installedSkills', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: realRegistry,
|
|
installedSkills: new Set(['ui-phase', 'ui-review']),
|
|
surfacedSkills: new Set(['ui-phase', 'ui-review']),
|
|
config: { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: true } },
|
|
cwd: tmpProjectDir,
|
|
});
|
|
const uiCap = result.capabilities.find((c) => c.id === 'ui');
|
|
assert.ok(uiCap, 'ui capability should be present');
|
|
assert.strictEqual(uiCap.installed, true);
|
|
assert.strictEqual(uiCap.surfaced, true);
|
|
assert.strictEqual(uiCap.enabled, true);
|
|
});
|
|
|
|
test('UI cap: installed=false when ui-review missing from installedSkills', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: realRegistry,
|
|
installedSkills: new Set(['ui-phase']), // missing ui-review
|
|
surfacedSkills: new Set(['ui-phase', 'ui-review']),
|
|
config: { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: true } },
|
|
cwd: tmpProjectDir,
|
|
});
|
|
const uiCap = result.capabilities.find((c) => c.id === 'ui');
|
|
assert.ok(uiCap);
|
|
assert.strictEqual(uiCap.installed, false);
|
|
assert.strictEqual(uiCap.enabled, false);
|
|
});
|
|
|
|
test('UI cap: surfaced=false when ui-review missing from surfacedSkills', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: realRegistry,
|
|
installedSkills: new Set(['ui-phase', 'ui-review']),
|
|
surfacedSkills: new Set(['ui-phase']), // missing ui-review
|
|
config: { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: true } },
|
|
cwd: tmpProjectDir,
|
|
});
|
|
const uiCap = result.capabilities.find((c) => c.id === 'ui');
|
|
assert.ok(uiCap);
|
|
assert.strictEqual(uiCap.surfaced, false);
|
|
assert.strictEqual(uiCap.enabled, false);
|
|
});
|
|
|
|
test('UI cap step hook: workflow.ui_phase true → active=true', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: realRegistry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(['ui-phase', 'ui-review']),
|
|
config: { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: true } },
|
|
cwd: tmpProjectDir,
|
|
});
|
|
const uiCap = result.capabilities.find((c) => c.id === 'ui');
|
|
assert.ok(uiCap);
|
|
// Find the plan:pre step (ui-phase step)
|
|
const planPreStep = uiCap.hooks.find(
|
|
(h) => h.kind === 'step' && h.when === 'workflow.ui_phase',
|
|
);
|
|
assert.ok(planPreStep, 'should have plan:pre step with when=workflow.ui_phase');
|
|
assert.strictEqual(planPreStep.configured, true);
|
|
assert.strictEqual(planPreStep.active, true);
|
|
});
|
|
|
|
test('UI cap step hook: surfaced=false and workflow.ui_phase true → configured=true but active=false', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: realRegistry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(),
|
|
config: { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: true } },
|
|
cwd: tmpProjectDir,
|
|
});
|
|
const uiCap = result.capabilities.find((c) => c.id === 'ui');
|
|
assert.ok(uiCap);
|
|
assert.strictEqual(uiCap.enabled, false);
|
|
const planPreStep = uiCap.hooks.find(
|
|
(h) => h.kind === 'step' && h.when === 'workflow.ui_phase',
|
|
);
|
|
assert.ok(planPreStep, 'should have plan:pre step with when=workflow.ui_phase');
|
|
assert.strictEqual(planPreStep.configured, true);
|
|
assert.strictEqual(planPreStep.active, false);
|
|
});
|
|
|
|
test('UI cap step hook: workflow.ui_phase false → active=false', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: realRegistry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(),
|
|
config: { workflow: { ui_phase: false, ui_review: false, ui_safety_gate: false } },
|
|
cwd: tmpProjectDirFalse,
|
|
});
|
|
const uiCap = result.capabilities.find((c) => c.id === 'ui');
|
|
assert.ok(uiCap);
|
|
const planPreStep = uiCap.hooks.find(
|
|
(h) => h.kind === 'step' && h.when === 'workflow.ui_phase',
|
|
);
|
|
assert.ok(planPreStep, 'should have plan:pre step with when=workflow.ui_phase');
|
|
assert.strictEqual(planPreStep.configured, false);
|
|
assert.strictEqual(planPreStep.active, false);
|
|
});
|
|
|
|
test('UI cap gate hook: workflow.ui_safety_gate true → active=true', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: realRegistry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(['ui-phase', 'ui-review']),
|
|
config: { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: true } },
|
|
cwd: tmpProjectDir,
|
|
});
|
|
const uiCap = result.capabilities.find((c) => c.id === 'ui');
|
|
assert.ok(uiCap);
|
|
const safetyGate = uiCap.hooks.find(
|
|
(h) => h.kind === 'gate' && h.when === 'workflow.ui_safety_gate',
|
|
);
|
|
assert.ok(safetyGate, 'should have gate with when=workflow.ui_safety_gate');
|
|
assert.strictEqual(safetyGate.configured, true);
|
|
assert.strictEqual(safetyGate.active, true);
|
|
});
|
|
|
|
test('UI cap gate hook: workflow.ui_safety_gate false → active=false', () => {
|
|
const result = resolveCapabilityState({
|
|
registry: realRegistry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(),
|
|
config: { workflow: { ui_phase: false, ui_review: false, ui_safety_gate: false } },
|
|
cwd: tmpProjectDirFalse,
|
|
});
|
|
const uiCap = result.capabilities.find((c) => c.id === 'ui');
|
|
assert.ok(uiCap);
|
|
const safetyGate = uiCap.hooks.find(
|
|
(h) => h.kind === 'gate' && h.when === 'workflow.ui_safety_gate',
|
|
);
|
|
assert.ok(safetyGate, 'should have gate with when=workflow.ui_safety_gate');
|
|
assert.strictEqual(safetyGate.configured, false);
|
|
assert.strictEqual(safetyGate.active, false);
|
|
});
|
|
});
|
|
|
|
// ─── resolveCapabilityState — hook activation ─────────────────────────────────
|
|
|
|
describe('resolveCapabilityState — hook activation details', () => {
|
|
test('hook with no `when` → active=true (unconditional)', () => {
|
|
const registry = makeRegistry({
|
|
steps: [{ point: 'plan:pre', ref: { skill: 'test-skill' } }], // no `when`
|
|
});
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
assert.strictEqual(result.capabilities.length, 1);
|
|
const hook = result.capabilities[0].hooks.find((h) => h.kind === 'step');
|
|
assert.ok(hook, 'step hook should be present');
|
|
assert.strictEqual(hook.when, undefined);
|
|
assert.strictEqual(hook.active, true);
|
|
});
|
|
|
|
test('hook with `when` resolving truthy → active=true', () => {
|
|
const registry = makeRegistry({
|
|
steps: [{ point: 'plan:pre', when: 'workflow.my_feature' }],
|
|
});
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(),
|
|
config: { workflow: { my_feature: true } },
|
|
});
|
|
const hook = result.capabilities[0].hooks.find((h) => h.kind === 'step');
|
|
assert.ok(hook);
|
|
assert.strictEqual(hook.active, true);
|
|
});
|
|
|
|
test('hook with `when` resolving falsy → active=false', () => {
|
|
const registry = makeRegistry({
|
|
steps: [{ point: 'plan:pre', when: 'workflow.my_feature' }],
|
|
});
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(),
|
|
config: { workflow: { my_feature: false } },
|
|
});
|
|
const hook = result.capabilities[0].hooks.find((h) => h.kind === 'step');
|
|
assert.ok(hook);
|
|
assert.strictEqual(hook.active, false);
|
|
});
|
|
|
|
test('mixed hooks: some active, some not', () => {
|
|
const registry = makeRegistry({
|
|
steps: [
|
|
{ point: 'plan:pre', when: 'workflow.feat_a' },
|
|
{ point: 'plan:post' }, // no when → unconditional
|
|
],
|
|
gates: [{ point: 'execute:wave:post', when: 'workflow.feat_b' }],
|
|
// contributions must be a real array (not an object) so hook enumeration works
|
|
contributions: [
|
|
{ point: 'plan:pre', into: 'context', when: 'workflow.feat_c' },
|
|
],
|
|
});
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(),
|
|
config: { workflow: { feat_a: false, feat_b: true, feat_c: true } },
|
|
});
|
|
const cap = result.capabilities[0];
|
|
// feat_a step: inactive
|
|
const featAStep = cap.hooks.find((h) => h.when === 'workflow.feat_a');
|
|
assert.ok(featAStep);
|
|
assert.strictEqual(featAStep.active, false);
|
|
// unconditional step: active
|
|
const unconditional = cap.hooks.find((h) => h.kind === 'step' && !h.when);
|
|
assert.ok(unconditional);
|
|
assert.strictEqual(unconditional.active, true);
|
|
// feat_b gate: active
|
|
const featBGate = cap.hooks.find((h) => h.when === 'workflow.feat_b');
|
|
assert.ok(featBGate);
|
|
assert.strictEqual(featBGate.active, true);
|
|
// feat_c contribution: active, enumerated correctly
|
|
const featCContrib = cap.hooks.find((h) => h.kind === 'contribution' && h.when === 'workflow.feat_c');
|
|
assert.ok(featCContrib, 'contribution hook should be enumerated from array');
|
|
assert.strictEqual(featCContrib.active, true);
|
|
});
|
|
|
|
test('empty-string `when` → active=false (aligned with loop-resolver)', () => {
|
|
// loop-resolver.isActive: `when.length === 0` → false
|
|
// capability-state must behave identically
|
|
const registry = makeRegistry({
|
|
steps: [{ point: 'plan:pre', when: '' }],
|
|
});
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
const hook = result.capabilities[0].hooks.find((h) => h.kind === 'step');
|
|
assert.ok(hook, 'step hook should be present');
|
|
assert.strictEqual(hook.when, '', 'original when value must be preserved');
|
|
assert.strictEqual(hook.active, false, 'empty-string when → inactive');
|
|
});
|
|
|
|
test('non-string `when` → active=false (aligned with loop-resolver)', () => {
|
|
// loop-resolver.isActive: `typeof when !== 'string'` → false
|
|
const registry = makeRegistry({
|
|
steps: [{ point: 'plan:pre', when: 42 }],
|
|
});
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
const hook = result.capabilities[0].hooks.find((h) => h.kind === 'step');
|
|
assert.ok(hook, 'step hook should be present');
|
|
assert.strictEqual(hook.when, 42, 'original non-string when value must be preserved');
|
|
assert.strictEqual(hook.active, false, 'non-string when → inactive');
|
|
});
|
|
});
|
|
|
|
// ─── resolveCapabilityState — determinism ─────────────────────────────────────
|
|
|
|
describe('resolveCapabilityState — determinism', () => {
|
|
test('sorted by id — two caps returned in lexicographic order', () => {
|
|
// contributions must be an array (not an object) for the hook enumeration to work
|
|
const registry = {
|
|
capabilities: {
|
|
'zzz-cap': { id: 'zzz-cap', tier: 'standard', skills: [], steps: [], gates: [], contributions: [] },
|
|
'aaa-cap': { id: 'aaa-cap', tier: 'standard', skills: [], steps: [], gates: [], contributions: [] },
|
|
'mmm-cap': { id: 'mmm-cap', tier: 'standard', skills: [], steps: [], gates: [], contributions: [] },
|
|
},
|
|
};
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
const ids = result.capabilities.map((c) => c.id);
|
|
assert.deepStrictEqual(ids, ['aaa-cap', 'mmm-cap', 'zzz-cap']);
|
|
});
|
|
|
|
test('two calls with same inputs produce identical output', () => {
|
|
const result1 = resolveCapabilityState({
|
|
registry: realRegistry,
|
|
installedSkills: new Set(['ui-phase', 'ui-review']),
|
|
surfacedSkills: new Set(['ui-phase']),
|
|
config: { workflow: { ui_phase: true, ui_review: false, ui_safety_gate: true } },
|
|
cwd: tmpProjectDir,
|
|
});
|
|
const result2 = resolveCapabilityState({
|
|
registry: realRegistry,
|
|
installedSkills: new Set(['ui-phase', 'ui-review']),
|
|
surfacedSkills: new Set(['ui-phase']),
|
|
config: { workflow: { ui_phase: true, ui_review: false, ui_safety_gate: true } },
|
|
cwd: tmpProjectDir,
|
|
});
|
|
assert.deepStrictEqual(result1, result2);
|
|
});
|
|
|
|
test('pure config-only resolution (cwd: undefined) — no I/O, deterministic', () => {
|
|
// When cwd is omitted, resolveCapabilityState does no filesystem I/O.
|
|
// Two calls with identical args must produce identical output regardless
|
|
// of any .planning/config.json files that may exist on disk.
|
|
const result1 = resolveCapabilityState({
|
|
registry: realRegistry,
|
|
installedSkills: new Set(['ui-phase', 'ui-review']),
|
|
surfacedSkills: new Set(['ui-phase', 'ui-review']),
|
|
config: { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: false } },
|
|
// no cwd
|
|
});
|
|
const result2 = resolveCapabilityState({
|
|
registry: realRegistry,
|
|
installedSkills: new Set(['ui-phase', 'ui-review']),
|
|
surfacedSkills: new Set(['ui-phase', 'ui-review']),
|
|
config: { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: false } },
|
|
// no cwd
|
|
});
|
|
assert.deepStrictEqual(result1, result2);
|
|
// Activation should come from the `config` arg only, not from disk
|
|
const uiCap = result1.capabilities.find((c) => c.id === 'ui');
|
|
assert.ok(uiCap, 'ui capability should be present');
|
|
const uiPhaseStep = uiCap.hooks.find(
|
|
(h) => h.kind === 'step' && h.when === 'workflow.ui_phase',
|
|
);
|
|
if (uiPhaseStep) {
|
|
assert.strictEqual(uiPhaseStep.active, true, 'should use config arg, not disk');
|
|
}
|
|
});
|
|
});
|
|
|
|
// ─── resolveCapabilityState — prototype pollution guard ──────────────────────
|
|
|
|
describe('resolveCapabilityState — prototype pollution guard', () => {
|
|
test('prototype-pollution capId is skipped; Object.prototype unpolluted', () => {
|
|
// Use Object.create(null) + Object.defineProperty to create a capabilities
|
|
// map with a real OWN '__proto__' key (not the prototype chain).
|
|
// The `{ __proto__: ... }` object literal syntax sets the prototype, not
|
|
// an own property — so it cannot exercise the guard. Using defineProperty
|
|
// ensures the key is an enumerable own property that Object.keys() returns.
|
|
const capabilitiesMap = Object.create(null);
|
|
Object.defineProperty(capabilitiesMap, '__proto__', {
|
|
value: { id: '__proto__', tier: 'standard', skills: [], steps: [], gates: [], contributions: [] },
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true,
|
|
});
|
|
Object.defineProperty(capabilitiesMap, 'safe-cap', {
|
|
value: { id: 'safe-cap', tier: 'standard', skills: [], steps: [], gates: [], contributions: [] },
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true,
|
|
});
|
|
const registry = { capabilities: capabilitiesMap };
|
|
const before = Object.prototype.toString.call({});
|
|
const result = resolveCapabilityState({
|
|
registry,
|
|
installedSkills: '*',
|
|
surfacedSkills: new Set(),
|
|
config: {},
|
|
});
|
|
const after = Object.prototype.toString.call({});
|
|
// Object.prototype must be unpolluted
|
|
assert.strictEqual(before, after);
|
|
// Verify no pollution occurred — a new plain object must not have a `polluted` property
|
|
assert.strictEqual(({}).polluted, undefined);
|
|
// Only the safe cap should appear
|
|
assert.strictEqual(result.capabilities.length, 1);
|
|
assert.strictEqual(result.capabilities[0].id, 'safe-cap');
|
|
});
|
|
});
|
|
|
|
// ─── cmdCapabilityState — end-to-end via gsd-tools CLI ──────────────────────
|
|
//
|
|
// Because cmdCapabilityState destructures `output` at module load time, patching
|
|
// core.cjs after the fact is ineffective. We instead invoke gsd-tools via
|
|
// spawnSync so each test gets a fresh process with stdout captured.
|
|
|
|
const { spawnSync } = require('node:child_process');
|
|
|
|
const gsdToolsPath = path.resolve(__dirname, '..', 'gsd-core', 'bin', 'gsd-tools.cjs');
|
|
|
|
function runCapabilityState(cwd, configDir) {
|
|
const result = spawnSync(
|
|
process.execPath,
|
|
[gsdToolsPath, 'capability', 'state', '--config-dir', configDir, '--raw', '--cwd', cwd],
|
|
{ encoding: 'utf8', timeout: 15000 },
|
|
);
|
|
return result;
|
|
}
|
|
|
|
describe('cmdCapabilityState — end-to-end via gsd-tools CLI', () => {
|
|
let tmpConfigDir;
|
|
let tmpConfigDirCore;
|
|
let tmpConfigDirUiDisabled;
|
|
|
|
before(() => {
|
|
// Tmp runtime config dir without .gsd-profile (defaults to 'full')
|
|
tmpConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cap-state-cfg-'));
|
|
|
|
// Tmp runtime config dir with core profile marker
|
|
tmpConfigDirCore = fs.mkdtempSync(path.join(os.tmpdir(), 'cap-state-cfg-core-'));
|
|
fs.writeFileSync(path.join(tmpConfigDirCore, '.gsd-profile'), 'core\n', 'utf8');
|
|
|
|
tmpConfigDirUiDisabled = fs.mkdtempSync(path.join(os.tmpdir(), 'cap-state-cfg-ui-disabled-'));
|
|
fs.writeFileSync(
|
|
path.join(tmpConfigDirUiDisabled, '.gsd-surface.json'),
|
|
JSON.stringify({
|
|
baseProfile: 'full',
|
|
disabledClusters: ['ui'],
|
|
explicitAdds: [],
|
|
explicitRemoves: [],
|
|
}, null, 2),
|
|
'utf8',
|
|
);
|
|
});
|
|
|
|
after(() => {
|
|
cleanup(tmpConfigDir);
|
|
cleanup(tmpConfigDirCore);
|
|
cleanup(tmpConfigDirUiDisabled);
|
|
});
|
|
|
|
test('emits envelope with runtimeConfigDir and capabilities array', () => {
|
|
const result = runCapabilityState(tmpProjectDir, tmpConfigDir);
|
|
assert.strictEqual(result.status, 0, `gsd-tools exited ${result.status}: ${result.stderr}`);
|
|
const envelope = JSON.parse(result.stdout);
|
|
assert.ok(typeof envelope === 'object' && envelope !== null, 'envelope must be an object');
|
|
assert.ok('runtimeConfigDir' in envelope, 'envelope must have runtimeConfigDir');
|
|
assert.ok(Array.isArray(envelope.capabilities), 'envelope.capabilities must be an array');
|
|
assert.ok(envelope.capabilities.length > 0, 'should have at least one capability');
|
|
});
|
|
|
|
test('with core profile marker: capabilities present (profile resolution does not throw)', () => {
|
|
const result = runCapabilityState(tmpProjectDir, tmpConfigDirCore);
|
|
assert.strictEqual(result.status, 0, `gsd-tools exited ${result.status}: ${result.stderr}`);
|
|
const envelope = JSON.parse(result.stdout);
|
|
assert.ok(Array.isArray(envelope.capabilities));
|
|
// ui capability should appear; installed=false because core profile doesn't include ui-phase/ui-review
|
|
const uiCap = envelope.capabilities.find((c) => c.id === 'ui');
|
|
assert.ok(uiCap, 'ui capability should be present in output');
|
|
assert.strictEqual(uiCap.installed, false, 'ui-phase/ui-review not in core profile');
|
|
});
|
|
|
|
test('runtimeConfigDir is echoed in the envelope', () => {
|
|
const result = runCapabilityState(tmpProjectDir, tmpConfigDir);
|
|
assert.strictEqual(result.status, 0, `gsd-tools exited ${result.status}: ${result.stderr}`);
|
|
const envelope = JSON.parse(result.stdout);
|
|
assert.strictEqual(envelope.runtimeConfigDir, tmpConfigDir);
|
|
});
|
|
|
|
test('surface-disabled UI capability reports enabled=false and inactive hooks', () => {
|
|
const result = runCapabilityState(tmpProjectDir, tmpConfigDirUiDisabled);
|
|
assert.strictEqual(result.status, 0, `gsd-tools exited ${result.status}: ${result.stderr}`);
|
|
const envelope = JSON.parse(result.stdout);
|
|
const uiCap = envelope.capabilities.find((c) => c.id === 'ui');
|
|
assert.ok(uiCap, 'ui capability should be present in output');
|
|
assert.strictEqual(uiCap.installed, true, 'full base profile still installs UI');
|
|
assert.strictEqual(uiCap.surfaced, false, 'surface disables UI capability skills');
|
|
assert.strictEqual(uiCap.enabled, false, 'disabled surface must disable the capability');
|
|
const planPreStep = uiCap.hooks.find(
|
|
(h) => h.kind === 'step' && h.when === 'workflow.ui_phase',
|
|
);
|
|
assert.ok(planPreStep, 'ui plan step should be present in diagnostic state');
|
|
assert.strictEqual(planPreStep.configured, true, 'project config/schema still configures UI on');
|
|
assert.strictEqual(planPreStep.active, false, 'effective hook activity must match workflow dispatch');
|
|
});
|
|
});
|