Merge remote-tracking branch 'origin/next' into kimi-runtime-support
# Conflicts: # docs/ARCHITECTURE.md
This commit is contained in:
@@ -174,56 +174,65 @@ describe('bug-2808: SKILL.md name: uses hyphen form', () => {
|
||||
|
||||
// Use the real COMMANDS_DIR as the source via .gsd-source marker.
|
||||
// installRuntimeArtifacts('claude', configDir, 'global') writes to
|
||||
// configDir/skills/gsd-*/SKILL.md using the same converter as the shim did.
|
||||
// configDir/skills/ using the same converter as the shim did.
|
||||
// With the full profile, skills are nested: gsd-ns-<router>/skills/<stem>/SKILL.md
|
||||
const configDir = path.join(tmp, 'config');
|
||||
fs.mkdirSync(configDir, { recursive: true });
|
||||
fs.writeFileSync(path.join(configDir, '.gsd-source'), COMMANDS_DIR + '\n');
|
||||
installRuntimeArtifacts('claude', configDir, 'global', resolvedProfileFull);
|
||||
const skillsDir = path.join(configDir, 'skills');
|
||||
|
||||
// Don't filter the directory listing by `startsWith('gsd-')` — that
|
||||
// would silently hide exactly the kind of drift this test exists to
|
||||
// catch (a `gsd:extract-learnings` colon variant or a bare
|
||||
// `extract-learnings` without the namespace prefix would never be
|
||||
// collected, and the loop below would never see them). Capture every
|
||||
// generated directory and assert the namespace invariants explicitly.
|
||||
const skillDirs = fs.readdirSync(skillsDir, { withFileTypes: true })
|
||||
.filter((entry) => entry.isDirectory())
|
||||
.map((entry) => entry.name)
|
||||
.sort();
|
||||
|
||||
assert.ok(skillDirs.length > 0, 'expected generated skill directories under skillsDir');
|
||||
for (const dir of skillDirs) {
|
||||
assert.ok(
|
||||
dir.startsWith('gsd-'),
|
||||
`${dir}: generated skill directory must start with the canonical 'gsd-' namespace`,
|
||||
);
|
||||
assert.ok(
|
||||
!dir.includes(':'),
|
||||
`${dir}: generated skill directory must not contain the retired colon namespace separator`,
|
||||
);
|
||||
assert.ok(
|
||||
!dir.includes('_'),
|
||||
`${dir}: generated skill directory must use hyphens, not underscores`,
|
||||
);
|
||||
// Recursively collect all SKILL.md files under skills/ (handles both flat and
|
||||
// nested layouts). Don't filter any paths — that would silently hide exactly
|
||||
// the kind of drift this test exists to catch (a `gsd:extract-learnings`
|
||||
// colon variant or a bare `extract-learnings` without the namespace prefix
|
||||
// would never be collected, and the loop below would never see them).
|
||||
function collectSkillMds(dir) {
|
||||
const results = [];
|
||||
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
|
||||
const full = path.join(dir, entry.name);
|
||||
if (entry.isDirectory()) {
|
||||
results.push(...collectSkillMds(full));
|
||||
} else if (entry.name === 'SKILL.md') {
|
||||
results.push(full);
|
||||
}
|
||||
}
|
||||
return results;
|
||||
}
|
||||
|
||||
assert.ok(skillDirs.includes('gsd-extract-learnings'), 'autocomplete surface must include gsd-extract-learnings');
|
||||
assert.ok(!skillDirs.includes('gsd-extract_learnings'), 'autocomplete surface must not include gsd-extract_learnings');
|
||||
const allSkillMdPaths = collectSkillMds(skillsDir);
|
||||
assert.ok(allSkillMdPaths.length > 0, 'expected generated SKILL.md files under skillsDir');
|
||||
|
||||
for (const skillDir of skillDirs) {
|
||||
const skillContent = fs.readFileSync(path.join(skillsDir, skillDir, 'SKILL.md'), 'utf-8');
|
||||
// Validate every SKILL.md's name: field (the consumer-facing name used in
|
||||
// autocomplete). We also check that the containing dir name doesn't use
|
||||
// banned characters at any level of nesting.
|
||||
const allNames = [];
|
||||
for (const skillMdPath of allSkillMdPaths) {
|
||||
const relPath = path.relative(skillsDir, skillMdPath);
|
||||
const skillContent = fs.readFileSync(skillMdPath, 'utf-8');
|
||||
// Scope the name: lookup to the YAML frontmatter block so a stray
|
||||
// `name:` line in the body cannot satisfy the assertion.
|
||||
const fmMatch = skillContent.match(/^---\n([\s\S]*?)\n---/);
|
||||
assert.ok(fmMatch, `${skillDir}: generated SKILL.md must include frontmatter`);
|
||||
assert.ok(fmMatch, `${relPath}: generated SKILL.md must include frontmatter`);
|
||||
const nameLine = fmMatch[1].split('\n').find((l) => /^name:\s*/.test(l));
|
||||
assert.ok(nameLine, `${skillDir}: generated SKILL.md is missing name: frontmatter`);
|
||||
assert.ok(nameLine, `${relPath}: generated SKILL.md is missing name: frontmatter`);
|
||||
const name = nameLine.replace(/^name:\s*/, '').trim();
|
||||
assert.ok(name.startsWith('gsd-'), `${skillDir}: autocomplete name must start with gsd-, got ${name}`);
|
||||
assert.ok(!name.includes(':'), `${skillDir}: autocomplete name must not contain colon, got ${name}`);
|
||||
assert.ok(!name.includes('_'), `${skillDir}: autocomplete name must not contain underscore, got ${name}`);
|
||||
assert.ok(name.startsWith('gsd-'), `${relPath}: autocomplete name must start with gsd-, got ${name}`);
|
||||
assert.ok(!name.includes(':'), `${relPath}: autocomplete name must not contain colon, got ${name}`);
|
||||
assert.ok(!name.includes('_'), `${relPath}: autocomplete name must not contain underscore, got ${name}`);
|
||||
allNames.push(name);
|
||||
|
||||
// Also validate each path segment (dir name) in the relative path doesn't
|
||||
// contain the banned characters — catches mislabeled directory names.
|
||||
const segments = relPath.split(path.sep).slice(0, -1); // exclude 'SKILL.md' filename
|
||||
for (const seg of segments) {
|
||||
assert.ok(!seg.includes(':'), `${relPath}: dir segment "${seg}" must not contain colon`);
|
||||
assert.ok(!seg.includes('_'), `${relPath}: dir segment "${seg}" must use hyphens, not underscores`);
|
||||
}
|
||||
}
|
||||
|
||||
assert.ok(allNames.includes('gsd-extract-learnings'), 'autocomplete surface must include gsd-extract-learnings');
|
||||
assert.ok(!allNames.includes('gsd-extract_learnings'), 'autocomplete surface must not include gsd-extract_learnings');
|
||||
});
|
||||
|
||||
test('transformContentToHyphen (from fix-slash-commands.cjs) rewrites colon to hyphen for known commands', () => {
|
||||
|
||||
@@ -41,6 +41,53 @@ const REAL_COMMANDS_DIR = path.join(__dirname, '..', 'commands', 'gsd');
|
||||
const MANIFEST = loadSkillsManifest(REAL_COMMANDS_DIR);
|
||||
const RESOLVED_CORE = resolveProfile({ modes: ['core'], manifest: MANIFEST });
|
||||
|
||||
/**
|
||||
* Map from concrete skill stem → ns-* router stem.
|
||||
* Used for nesting runtimes (claude, cline, qwen, etc.) when the full profile
|
||||
* is installed: concrete skills live at <skillsRoot>/gsd-<router>/skills/<stem>/SKILL.md.
|
||||
*/
|
||||
const CHILD_ROUTER = {
|
||||
// ns-workflow
|
||||
'discuss-phase': 'ns-workflow', 'spec-phase': 'ns-workflow', 'plan-phase': 'ns-workflow',
|
||||
'execute-phase': 'ns-workflow', 'verify-work': 'ns-workflow', 'phase': 'ns-workflow',
|
||||
'progress': 'ns-workflow', 'ultraplan-phase': 'ns-workflow',
|
||||
'plan-review-convergence': 'ns-workflow', 'add-tests': 'ns-workflow',
|
||||
'ai-integration-phase': 'ns-workflow', 'autonomous': 'ns-workflow',
|
||||
'fast': 'ns-workflow', 'mvp-phase': 'ns-workflow', 'quick': 'ns-workflow',
|
||||
// ns-project
|
||||
'new-project': 'ns-project', 'new-milestone': 'ns-project', 'complete-milestone': 'ns-project',
|
||||
'audit-milestone': 'ns-project', 'milestone-summary': 'ns-project', 'import': 'ns-project',
|
||||
'ingest-docs': 'ns-project', 'profile-user': 'ns-project', 'review-backlog': 'ns-project',
|
||||
// ns-review
|
||||
'code-review': 'ns-review', 'audit-uat': 'ns-review', 'secure-phase': 'ns-review',
|
||||
'eval-review': 'ns-review', 'ui-review': 'ns-review', 'validate-phase': 'ns-review',
|
||||
'debug': 'ns-review', 'forensics': 'ns-review', 'audit-fix': 'ns-review',
|
||||
'review': 'ns-review', 'ui-phase': 'ns-review',
|
||||
// ns-context
|
||||
'map-codebase': 'ns-context', 'graphify': 'ns-context', 'docs-update': 'ns-context',
|
||||
'extract-learnings': 'ns-context',
|
||||
// ns-ideate
|
||||
'capture': 'ns-ideate', 'explore': 'ns-ideate', 'sketch': 'ns-ideate',
|
||||
'spike': 'ns-ideate',
|
||||
// ns-manage
|
||||
'config': 'ns-manage', 'workspace': 'ns-manage', 'workstreams': 'ns-manage',
|
||||
'thread': 'ns-manage', 'pause-work': 'ns-manage', 'resume-work': 'ns-manage',
|
||||
'update': 'ns-manage', 'ship': 'ns-manage', 'inbox': 'ns-manage',
|
||||
'pr-branch': 'ns-manage', 'undo': 'ns-manage', 'cleanup': 'ns-manage',
|
||||
'health': 'ns-manage', 'manager': 'ns-manage', 'settings': 'ns-manage',
|
||||
'stats': 'ns-manage', 'surface': 'ns-manage', 'help': 'ns-manage',
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the nested SKILL.md path for a concrete skill stem on cline
|
||||
* (prefix='gsd-'): <skillsRoot>/gsd-<router>/skills/<stem>/SKILL.md
|
||||
*/
|
||||
function nestedClineSkillPath(skillsRoot, stem) {
|
||||
const router = CHILD_ROUTER[stem];
|
||||
if (!router) throw new Error(`No router mapping for stem: ${stem}`);
|
||||
return path.join(skillsRoot, 'gsd-' + router, 'skills', stem, 'SKILL.md');
|
||||
}
|
||||
|
||||
// ─── (a) Converter unit test ─────────────────────────────────────────────────
|
||||
|
||||
const SAMPLE_COMMAND = `---
|
||||
@@ -347,11 +394,11 @@ describe('install() global cline — coexistence: skills AND .clinerules', () =>
|
||||
`skills/ directory must exist under ${tmpGlobalDir} after global cline install`
|
||||
);
|
||||
|
||||
// gsd-help is present in every profile (core, standard, full)
|
||||
const helpSkillFile = path.join(skillsDir, 'gsd-help', 'SKILL.md');
|
||||
// full profile: gsd-help is nested under gsd-ns-manage/skills/help/SKILL.md
|
||||
const helpSkillFile = nestedClineSkillPath(skillsDir, 'help');
|
||||
assert.ok(
|
||||
fs.existsSync(helpSkillFile),
|
||||
`skills/gsd-help/SKILL.md must exist under ${tmpGlobalDir} — skills emission broken for global cline`
|
||||
`${path.relative(tmpGlobalDir, helpSkillFile)} must exist under ${tmpGlobalDir} — skills emission broken for global cline`
|
||||
);
|
||||
});
|
||||
|
||||
@@ -438,8 +485,9 @@ describe('convertClaudeToCliineMarkdown — bare ~/.claude and CLAUDE_CONFIG_DIR
|
||||
|
||||
installRuntimeArtifacts('cline', configDir, 'global', RESOLVED_FULL);
|
||||
|
||||
const surfaceSkill = path.join(configDir, 'skills', 'gsd-surface', 'SKILL.md');
|
||||
assert.ok(fs.existsSync(surfaceSkill), 'gsd-surface/SKILL.md must exist for full profile');
|
||||
// full profile: surface is nested under gsd-ns-manage/skills/surface/SKILL.md
|
||||
const surfaceSkill = nestedClineSkillPath(path.join(configDir, 'skills'), 'surface');
|
||||
assert.ok(fs.existsSync(surfaceSkill), `${path.relative(configDir, surfaceSkill)} must exist for full profile`);
|
||||
|
||||
const content = fs.readFileSync(surfaceSkill, 'utf8');
|
||||
assert.ok(
|
||||
@@ -497,8 +545,9 @@ describe('_applyRuntimeRewrites — cline custom-dir embedded path (Fix 1)', ()
|
||||
|
||||
// gsd-surface SKILL.md references config paths; with a custom configDir
|
||||
// (not under $HOME), pathPrefix will be the absolute custom path.
|
||||
const surfaceSkill = path.join(configDir, 'skills', 'gsd-surface', 'SKILL.md');
|
||||
assert.ok(fs.existsSync(surfaceSkill), 'gsd-surface/SKILL.md must exist');
|
||||
// full profile: surface is nested under gsd-ns-manage/skills/surface/SKILL.md
|
||||
const surfaceSkill = nestedClineSkillPath(path.join(configDir, 'skills'), 'surface');
|
||||
assert.ok(fs.existsSync(surfaceSkill), `${path.relative(configDir, surfaceSkill)} must exist`);
|
||||
|
||||
const content = fs.readFileSync(surfaceSkill, 'utf8');
|
||||
// With a custom dir (path under /tmp, not ~/.cline), the output must NOT
|
||||
|
||||
140
tests/bug-866-profile-pipeline-temp-root.test.cjs
Normal file
140
tests/bug-866-profile-pipeline-temp-root.test.cjs
Normal file
@@ -0,0 +1,140 @@
|
||||
'use strict';
|
||||
/**
|
||||
* Regression test for bug #866: profile-pipeline temp output dirs must be
|
||||
* created under GSD_TEMP_DIR (path.join(os.tmpdir(), 'gsd')), not directly
|
||||
* under os.tmpdir() root where reapStaleTempFiles() never scans.
|
||||
*
|
||||
* Hardening (adversarial-review follow-up):
|
||||
* - TMPDIR/TEMP/TMP are redirected to a fixture-scoped directory so the child
|
||||
* process's os.tmpdir() returns an isolated root. This prevents the test from
|
||||
* touching the real shared temp root and keeps it out of the production
|
||||
* reaper's view.
|
||||
* - Both sides of the startsWith assertion are realpath-normalized to kill the
|
||||
* macOS /var ↔ /private/var symlink flakiness.
|
||||
* - An explicit exitCode === 0 assertion is added before JSON.parse so a
|
||||
* non-zero early-exit produces a clear failure rather than a confusing parse
|
||||
* error.
|
||||
*/
|
||||
|
||||
const { test, describe, beforeEach, afterEach } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
const { runGsdTools, createTempDir, cleanup } = require('./helpers.cjs');
|
||||
|
||||
describe('bug-866: profile-pipeline temp dirs under GSD_TEMP_DIR', () => {
|
||||
let tmpDir;
|
||||
let isolatedSysTmp;
|
||||
|
||||
beforeEach(() => {
|
||||
tmpDir = createTempDir('gsd-866-');
|
||||
// Create an isolated os.tmpdir() root inside the fixture so the child
|
||||
// process never writes to the real shared temp dir.
|
||||
isolatedSysTmp = path.join(tmpDir, 'systmp');
|
||||
fs.mkdirSync(isolatedSysTmp, { recursive: true });
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
cleanup(tmpDir);
|
||||
});
|
||||
|
||||
// Helper: create a minimal synthetic sessions directory structure
|
||||
function createSessions(root) {
|
||||
const sessionsDir = path.join(root, 'projects');
|
||||
const projectDir = path.join(sessionsDir, 'test-project-866');
|
||||
fs.mkdirSync(projectDir, { recursive: true });
|
||||
const messages = [
|
||||
{ type: 'user', userType: 'external', message: { content: 'fix the login bug' }, timestamp: Date.now() },
|
||||
{ type: 'assistant', message: { content: 'Sure.' }, timestamp: Date.now() },
|
||||
];
|
||||
fs.writeFileSync(
|
||||
path.join(projectDir, 'session-001.jsonl'),
|
||||
messages.map(m => JSON.stringify(m)).join('\n')
|
||||
);
|
||||
return sessionsDir;
|
||||
}
|
||||
|
||||
test('extract-messages output_file is under GSD_TEMP_DIR, not os.tmpdir() root', () => {
|
||||
const sessionsDir = createSessions(tmpDir);
|
||||
|
||||
// Pass the isolated tmp root so the child's os.tmpdir() = isolatedSysTmp.
|
||||
// Belt-and-suspenders: set all three env vars Node checks (TMPDIR=POSIX,
|
||||
// TEMP+TMP=Windows).
|
||||
const result = runGsdTools(
|
||||
['extract-messages', 'test-project-866', '--path', sessionsDir, '--raw'],
|
||||
tmpDir,
|
||||
{ TMPDIR: isolatedSysTmp, TEMP: isolatedSysTmp, TMP: isolatedSysTmp }
|
||||
);
|
||||
|
||||
// Explicit exitCode check first — parse errors are confusing on non-zero exit.
|
||||
assert.strictEqual(result.exitCode, 0, `extract-messages must exit 0; error: ${result.error}`);
|
||||
assert.ok(result.success, `extract-messages failed: ${result.error}`);
|
||||
|
||||
const out = JSON.parse(result.output);
|
||||
assert.ok(out.output_file, 'should have output_file in result');
|
||||
|
||||
const outputFile = out.output_file;
|
||||
|
||||
// The expected GSD_TEMP_DIR from the child's perspective: isolatedSysTmp/gsd
|
||||
const expectedGsdTempDir = path.join(isolatedSysTmp, 'gsd');
|
||||
|
||||
// Normalize both sides via realpath to kill macOS /var↔/private/var symlink
|
||||
// flakiness. Realpath the existing output_file's parent directory (the file
|
||||
// itself may have been cleaned up already, but the dir will exist).
|
||||
const expectedRoot = fs.realpathSync(expectedGsdTempDir);
|
||||
const outputDir = path.dirname(outputFile);
|
||||
// The output dir must exist since the tool just wrote there; realpath it.
|
||||
const actualDir = fs.realpathSync(outputDir);
|
||||
|
||||
assert.ok(
|
||||
actualDir.startsWith(expectedRoot + path.sep) || actualDir === expectedRoot,
|
||||
`output_file "${outputFile}" must be under GSD_TEMP_DIR "${expectedGsdTempDir}" (realpath: ${expectedRoot}); got dir "${actualDir}"`
|
||||
);
|
||||
|
||||
// Must NOT be directly under the isolated systmp root (i.e., no gsd-pipeline-*
|
||||
// at depth 1 of isolatedSysTmp).
|
||||
const rel = path.relative(isolatedSysTmp, outputFile);
|
||||
const depth1Dir = rel.split(path.sep)[0];
|
||||
assert.ok(
|
||||
!depth1Dir.startsWith('gsd-pipeline-'),
|
||||
`output_file must not be in isolatedSysTmp/gsd-pipeline-* but got depth-1 dir: "${depth1Dir}"`
|
||||
);
|
||||
});
|
||||
|
||||
test('profile-sample output_file is under GSD_TEMP_DIR, not os.tmpdir() root', () => {
|
||||
const sessionsDir = createSessions(tmpDir);
|
||||
|
||||
const result = runGsdTools(
|
||||
['profile-sample', '--path', sessionsDir, '--raw'],
|
||||
tmpDir,
|
||||
{ TMPDIR: isolatedSysTmp, TEMP: isolatedSysTmp, TMP: isolatedSysTmp }
|
||||
);
|
||||
|
||||
// Explicit exitCode check first.
|
||||
assert.strictEqual(result.exitCode, 0, `profile-sample must exit 0; error: ${result.error}`);
|
||||
assert.ok(result.success, `profile-sample failed: ${result.error}`);
|
||||
|
||||
const out = JSON.parse(result.output);
|
||||
assert.ok(out.output_file, 'should have output_file in result');
|
||||
|
||||
const outputFile = out.output_file;
|
||||
|
||||
const expectedGsdTempDir = path.join(isolatedSysTmp, 'gsd');
|
||||
|
||||
const expectedRoot = fs.realpathSync(expectedGsdTempDir);
|
||||
const outputDir = path.dirname(outputFile);
|
||||
const actualDir = fs.realpathSync(outputDir);
|
||||
|
||||
assert.ok(
|
||||
actualDir.startsWith(expectedRoot + path.sep) || actualDir === expectedRoot,
|
||||
`output_file "${outputFile}" must be under GSD_TEMP_DIR "${expectedGsdTempDir}" (realpath: ${expectedRoot}); got dir "${actualDir}"`
|
||||
);
|
||||
|
||||
const rel = path.relative(isolatedSysTmp, outputFile);
|
||||
const depth1Dir = rel.split(path.sep)[0];
|
||||
assert.ok(
|
||||
!depth1Dir.startsWith('gsd-profile-'),
|
||||
`output_file must not be in isolatedSysTmp/gsd-profile-* but got depth-1 dir: "${depth1Dir}"`
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -1,12 +1,13 @@
|
||||
'use strict';
|
||||
process.env.GSD_TEST_MODE = '1';
|
||||
|
||||
const { test, describe } = require('node:test');
|
||||
const { test, describe, afterEach } = 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 cp = require('node:child_process');
|
||||
const helpers = require('./helpers.cjs');
|
||||
|
||||
const ROOT = path.join(__dirname, '..');
|
||||
const SCRIPT = path.join(ROOT, 'scripts', 'changeset', 'cli.cjs');
|
||||
@@ -63,8 +64,11 @@ function createTaggedRepo() {
|
||||
}
|
||||
|
||||
describe('changeset github release notes: tag-range renderer (#3382)', () => {
|
||||
let _repo;
|
||||
afterEach(() => { helpers.cleanup(_repo); _repo = undefined; });
|
||||
|
||||
test('loads changed changeset slugs from a git tag range', () => {
|
||||
const repo = createTaggedRepo();
|
||||
const repo = (_repo = createTaggedRepo());
|
||||
const result = loadFragmentsFromRange({ repo, fromRef: 'v1.0.0', toRef: 'v1.0.1' });
|
||||
|
||||
assert.deepEqual(result.failures, []);
|
||||
@@ -78,7 +82,7 @@ describe('changeset github release notes: tag-range renderer (#3382)', () => {
|
||||
});
|
||||
|
||||
test('builds grouped GitHub release-note IR from parsed fragments', () => {
|
||||
const repo = createTaggedRepo();
|
||||
const repo = (_repo = createTaggedRepo());
|
||||
const { fragments } = loadFragmentsFromRange({ repo, fromRef: 'v1.0.0', toRef: 'v1.0.1' });
|
||||
const ir = buildGithubReleaseNotesIr({ fragments });
|
||||
|
||||
@@ -95,7 +99,7 @@ describe('changeset github release notes: tag-range renderer (#3382)', () => {
|
||||
});
|
||||
|
||||
test('CLI writes a notes file suitable for gh release edit --notes-file', () => {
|
||||
const repo = createTaggedRepo();
|
||||
const repo = (_repo = createTaggedRepo());
|
||||
const output = path.join(repo, 'release-notes.md');
|
||||
const result = cp.spawnSync(
|
||||
process.execPath,
|
||||
@@ -130,7 +134,7 @@ describe('changeset github release notes: tag-range renderer (#3382)', () => {
|
||||
});
|
||||
|
||||
test('rejects unsafe git refs before rendering a range', () => {
|
||||
const repo = createTaggedRepo();
|
||||
const repo = (_repo = createTaggedRepo());
|
||||
assert.throws(
|
||||
() => loadFragmentsFromRange({ repo, fromRef: '--help', toRef: 'v1.0.1' }),
|
||||
/Invalid git ref/,
|
||||
|
||||
@@ -10,16 +10,21 @@
|
||||
* content when claude_md_assembly.mode is "link".
|
||||
*/
|
||||
|
||||
const { test } = require('node:test');
|
||||
const { test, after } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const os = require('node:os');
|
||||
const helpers = require('./helpers.cjs');
|
||||
|
||||
const { cmdGenerateClaudeMd } = require('../gsd-core/bin/lib/profile-output.cjs');
|
||||
|
||||
const _dirsToClean = [];
|
||||
after(() => { for (const d of _dirsToClean) helpers.cleanup(d); });
|
||||
|
||||
function makeTempProject(files = {}) {
|
||||
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-2415-'));
|
||||
_dirsToClean.push(dir);
|
||||
fs.mkdirSync(path.join(dir, '.planning', 'codebase'), { recursive: true });
|
||||
for (const [rel, content] of Object.entries(files)) {
|
||||
const abs = path.join(dir, rel);
|
||||
|
||||
@@ -8,16 +8,21 @@
|
||||
* Tests for gsd-health MILESTONES.md drift detection (#2446).
|
||||
*/
|
||||
|
||||
const { test } = require('node:test');
|
||||
const { test, after } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const os = require('node:os');
|
||||
const helpers = require('./helpers.cjs');
|
||||
|
||||
const { cmdValidateHealth } = require('../gsd-core/bin/lib/verify.cjs');
|
||||
|
||||
const _dirsToClean = [];
|
||||
after(() => { for (const d of _dirsToClean) helpers.cleanup(d); });
|
||||
|
||||
function makeTempProject(files = {}) {
|
||||
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-2446-'));
|
||||
_dirsToClean.push(dir);
|
||||
fs.mkdirSync(path.join(dir, '.planning', 'milestones'), { recursive: true });
|
||||
for (const [rel, content] of Object.entries(files)) {
|
||||
const abs = path.join(dir, rel);
|
||||
|
||||
@@ -8,17 +8,22 @@
|
||||
* Tests for canonical artifact registry and gsd-health W019 lint (#2448).
|
||||
*/
|
||||
|
||||
const { test, describe } = require('node:test');
|
||||
const { test, describe, after } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const os = require('node:os');
|
||||
const helpers = require('./helpers.cjs');
|
||||
|
||||
const { isCanonicalPlanningFile, CANONICAL_EXACT } = require('../gsd-core/bin/lib/artifacts.cjs');
|
||||
const { cmdValidateHealth } = require('../gsd-core/bin/lib/verify.cjs');
|
||||
|
||||
const _dirsToClean = [];
|
||||
after(() => { for (const d of _dirsToClean) helpers.cleanup(d); });
|
||||
|
||||
function makeTempProject(files = {}) {
|
||||
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-2448-'));
|
||||
_dirsToClean.push(dir);
|
||||
fs.mkdirSync(path.join(dir, '.planning', 'phases'), { recursive: true });
|
||||
for (const [rel, content] of Object.entries(files)) {
|
||||
const abs = path.join(dir, rel);
|
||||
|
||||
@@ -208,6 +208,95 @@ describe('gsd-health --context flag is wired into command + workflow', () => {
|
||||
});
|
||||
});
|
||||
|
||||
// ── Namespace nesting completeness (#69) ──────────────────────────────
|
||||
// Guards that the install-layout nesting invariant (<=6 top-level entries)
|
||||
// is always satisfiable: every router's requires list points at real files,
|
||||
// every concrete skill is covered by at least one router, and each router's
|
||||
// body table stays in sync with its requires list.
|
||||
|
||||
const NS_FILES = NAMESPACE_SKILLS.map((ns) => ns.file);
|
||||
|
||||
/**
|
||||
* Parse the `requires:` flow-style array from a router file's raw content.
|
||||
* Matches `requires: [a, b, c]` anywhere (frontmatter or body — always in fm).
|
||||
*/
|
||||
function parseRouterRequires(content) {
|
||||
const m = content.match(/^requires:\s*\[([^\]]*)\]/m);
|
||||
if (!m) return [];
|
||||
return m[1].split(',').map((s) => s.trim()).filter(Boolean);
|
||||
}
|
||||
|
||||
describe('namespace nesting completeness (#69)', () => {
|
||||
// Build the concrete-skill set once (all *.md minus ns-*.md)
|
||||
const allFiles = fs.readdirSync(COMMANDS_DIR).filter((f) => f.endsWith('.md'));
|
||||
const concreteStemSet = new Set(
|
||||
allFiles
|
||||
.filter((f) => !f.startsWith('ns-'))
|
||||
.map((f) => f.replace(/\.md$/, '')),
|
||||
);
|
||||
|
||||
// Build per-router requires and the union over all routers
|
||||
const routerRequires = new Map(); // stem -> string[]
|
||||
for (const f of NS_FILES) {
|
||||
const stem = f.replace(/\.md$/, '');
|
||||
const content = fs.readFileSync(path.join(COMMANDS_DIR, f), 'utf-8');
|
||||
routerRequires.set(stem, parseRouterRequires(content));
|
||||
}
|
||||
const allRoutedStems = new Set([...routerRequires.values()].flat());
|
||||
|
||||
test('every router requires entry resolves to a real concrete skill file', () => {
|
||||
const bad = [];
|
||||
for (const [routerStem, children] of routerRequires) {
|
||||
for (const child of children) {
|
||||
if (!fs.existsSync(path.join(COMMANDS_DIR, `${child}.md`))) {
|
||||
bad.push(`${routerStem} → ${child}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
assert.deepStrictEqual(
|
||||
bad,
|
||||
[],
|
||||
`Router requires entries with no matching commands/gsd/<stem>.md: ${bad.join(', ')}`,
|
||||
);
|
||||
});
|
||||
|
||||
test('every concrete skill is routed by at least one namespace router', () => {
|
||||
const unrouted = [...concreteStemSet].filter((stem) => !allRoutedStems.has(stem));
|
||||
assert.deepStrictEqual(
|
||||
unrouted,
|
||||
[],
|
||||
`Concrete skills not routed by any ns-*.md (add to a router's requires:): ${unrouted.join(', ')}`,
|
||||
);
|
||||
});
|
||||
|
||||
test("each router's routing-table rows reference only its own required sub-skills (plus flag variants)", () => {
|
||||
const bad = [];
|
||||
for (const [routerStem, children] of routerRequires) {
|
||||
const childSet = new Set(children);
|
||||
const content = fs.readFileSync(path.join(COMMANDS_DIR, `${routerStem}.md`), 'utf-8');
|
||||
const fm = parseFrontmatter(content);
|
||||
// Extract gsd-<stem> tokens from table data rows (last cell), strip flags
|
||||
for (const line of fm._body.split('\n')) {
|
||||
if (!line.startsWith('|') || /^\|[\s\-:|]+\|?\s*$/.test(line)) continue;
|
||||
const cells = line.split('|').map((c) => c.trim()).filter(Boolean);
|
||||
if (cells.length < 2) continue;
|
||||
const lastCell = cells[cells.length - 1];
|
||||
for (const match of lastCell.matchAll(/\bgsd-([a-z][a-z0-9-]*)/g)) {
|
||||
const stem = match[1];
|
||||
if (!childSet.has(stem)) {
|
||||
bad.push(`${routerStem}: body table references gsd-${stem} but it's not in requires`);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
assert.deepStrictEqual(
|
||||
bad,
|
||||
[],
|
||||
`Routing table / requires mismatch:\n${bad.join('\n')}`,
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ── Cross-reference: every routed sub-skill must exist ─────────────────
|
||||
// This is the regression guard the original PR lacked. Without it,
|
||||
// post-#2790 consolidations can quietly invalidate router targets again.
|
||||
|
||||
@@ -43,6 +43,52 @@ function makeTmpDir(prefix) {
|
||||
return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
|
||||
}
|
||||
|
||||
/**
|
||||
* Map from concrete skill stem → ns-* router stem for nesting runtimes.
|
||||
* Derived from the authoritative ns-*.md `requires:` lists.
|
||||
*/
|
||||
const CHILD_ROUTER = {
|
||||
// ns-workflow
|
||||
'discuss-phase': 'ns-workflow', 'spec-phase': 'ns-workflow', 'plan-phase': 'ns-workflow',
|
||||
'execute-phase': 'ns-workflow', 'verify-work': 'ns-workflow', 'phase': 'ns-workflow',
|
||||
'progress': 'ns-workflow', 'ultraplan-phase': 'ns-workflow',
|
||||
'plan-review-convergence': 'ns-workflow', 'add-tests': 'ns-workflow',
|
||||
'ai-integration-phase': 'ns-workflow', 'autonomous': 'ns-workflow',
|
||||
'fast': 'ns-workflow', 'mvp-phase': 'ns-workflow', 'quick': 'ns-workflow',
|
||||
// ns-project
|
||||
'new-project': 'ns-project', 'new-milestone': 'ns-project', 'complete-milestone': 'ns-project',
|
||||
'audit-milestone': 'ns-project', 'milestone-summary': 'ns-project', 'import': 'ns-project',
|
||||
'ingest-docs': 'ns-project', 'profile-user': 'ns-project', 'review-backlog': 'ns-project',
|
||||
// ns-review
|
||||
'code-review': 'ns-review', 'audit-uat': 'ns-review', 'secure-phase': 'ns-review',
|
||||
'eval-review': 'ns-review', 'ui-review': 'ns-review', 'validate-phase': 'ns-review',
|
||||
'debug': 'ns-review', 'forensics': 'ns-review', 'audit-fix': 'ns-review',
|
||||
'review': 'ns-review', 'ui-phase': 'ns-review',
|
||||
// ns-context
|
||||
'map-codebase': 'ns-context', 'graphify': 'ns-context', 'docs-update': 'ns-context',
|
||||
'extract-learnings': 'ns-context',
|
||||
// ns-ideate
|
||||
'capture': 'ns-ideate', 'explore': 'ns-ideate', 'sketch': 'ns-ideate',
|
||||
'spike': 'ns-ideate',
|
||||
// ns-manage
|
||||
'config': 'ns-manage', 'workspace': 'ns-manage', 'workstreams': 'ns-manage',
|
||||
'thread': 'ns-manage', 'pause-work': 'ns-manage', 'resume-work': 'ns-manage',
|
||||
'update': 'ns-manage', 'ship': 'ns-manage', 'inbox': 'ns-manage',
|
||||
'pr-branch': 'ns-manage', 'undo': 'ns-manage', 'cleanup': 'ns-manage',
|
||||
'health': 'ns-manage', 'manager': 'ns-manage', 'settings': 'ns-manage',
|
||||
'stats': 'ns-manage', 'surface': 'ns-manage', 'help': 'ns-manage',
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the nested SKILL.md path for a concrete skill stem on Claude
|
||||
* (prefix='gsd-'): <skillsRoot>/gsd-<router>/skills/<stem>/SKILL.md
|
||||
*/
|
||||
function nestedClaudeSkillPath(skillsRoot, stem) {
|
||||
const router = CHILD_ROUTER[stem];
|
||||
if (!router) throw new Error(`No router mapping for stem: ${stem}`);
|
||||
return path.join(skillsRoot, 'gsd-' + router, 'skills', stem, 'SKILL.md');
|
||||
}
|
||||
|
||||
function readFrontmatter(mdPath) {
|
||||
const content = fs.readFileSync(mdPath, 'utf8');
|
||||
if (!content.startsWith('---')) return '';
|
||||
@@ -253,7 +299,7 @@ describe('#769 Claude global install: SKILL.md files preserve context: fork and
|
||||
|
||||
test('gsd-autonomous SKILL.md has context: fork after global install', () => {
|
||||
runClaudeGlobalInstall(claudeHome);
|
||||
const skillPath = path.join(claudeHome, 'skills', 'gsd-autonomous', 'SKILL.md');
|
||||
const skillPath = nestedClaudeSkillPath(path.join(claudeHome, 'skills'), 'autonomous');
|
||||
const fm = readFrontmatter(skillPath);
|
||||
assert.match(fm, /^context:[ \t]*fork$/m,
|
||||
`gsd-autonomous SKILL.md must have context: fork\nActual:\n${fm}`);
|
||||
@@ -261,7 +307,7 @@ describe('#769 Claude global install: SKILL.md files preserve context: fork and
|
||||
|
||||
test('gsd-autonomous SKILL.md has effort: xhigh after global install', () => {
|
||||
runClaudeGlobalInstall(claudeHome);
|
||||
const skillPath = path.join(claudeHome, 'skills', 'gsd-autonomous', 'SKILL.md');
|
||||
const skillPath = nestedClaudeSkillPath(path.join(claudeHome, 'skills'), 'autonomous');
|
||||
const fm = readFrontmatter(skillPath);
|
||||
assert.match(fm, /^effort:[ \t]*xhigh$/m,
|
||||
`gsd-autonomous SKILL.md must have effort: xhigh\nActual:\n${fm}`);
|
||||
@@ -269,7 +315,7 @@ describe('#769 Claude global install: SKILL.md files preserve context: fork and
|
||||
|
||||
test('gsd-execute-phase SKILL.md has context: fork after global install', () => {
|
||||
runClaudeGlobalInstall(claudeHome);
|
||||
const skillPath = path.join(claudeHome, 'skills', 'gsd-execute-phase', 'SKILL.md');
|
||||
const skillPath = nestedClaudeSkillPath(path.join(claudeHome, 'skills'), 'execute-phase');
|
||||
const fm = readFrontmatter(skillPath);
|
||||
assert.match(fm, /^context:[ \t]*fork$/m,
|
||||
`gsd-execute-phase SKILL.md must have context: fork\nActual:\n${fm}`);
|
||||
@@ -277,7 +323,7 @@ describe('#769 Claude global install: SKILL.md files preserve context: fork and
|
||||
|
||||
test('gsd-execute-phase SKILL.md has effort: xhigh after global install', () => {
|
||||
runClaudeGlobalInstall(claudeHome);
|
||||
const skillPath = path.join(claudeHome, 'skills', 'gsd-execute-phase', 'SKILL.md');
|
||||
const skillPath = nestedClaudeSkillPath(path.join(claudeHome, 'skills'), 'execute-phase');
|
||||
const fm = readFrontmatter(skillPath);
|
||||
assert.match(fm, /^effort:[ \t]*xhigh$/m,
|
||||
`gsd-execute-phase SKILL.md must have effort: xhigh\nActual:\n${fm}`);
|
||||
@@ -285,7 +331,7 @@ describe('#769 Claude global install: SKILL.md files preserve context: fork and
|
||||
|
||||
test('gsd-plan-phase SKILL.md has context: fork after global install', () => {
|
||||
runClaudeGlobalInstall(claudeHome);
|
||||
const skillPath = path.join(claudeHome, 'skills', 'gsd-plan-phase', 'SKILL.md');
|
||||
const skillPath = nestedClaudeSkillPath(path.join(claudeHome, 'skills'), 'plan-phase');
|
||||
const fm = readFrontmatter(skillPath);
|
||||
assert.match(fm, /^context:[ \t]*fork$/m,
|
||||
`gsd-plan-phase SKILL.md must have context: fork\nActual:\n${fm}`);
|
||||
@@ -293,7 +339,7 @@ describe('#769 Claude global install: SKILL.md files preserve context: fork and
|
||||
|
||||
test('gsd-plan-phase SKILL.md has effort: xhigh after global install', () => {
|
||||
runClaudeGlobalInstall(claudeHome);
|
||||
const skillPath = path.join(claudeHome, 'skills', 'gsd-plan-phase', 'SKILL.md');
|
||||
const skillPath = nestedClaudeSkillPath(path.join(claudeHome, 'skills'), 'plan-phase');
|
||||
const fm = readFrontmatter(skillPath);
|
||||
assert.match(fm, /^effort:[ \t]*xhigh$/m,
|
||||
`gsd-plan-phase SKILL.md must have effort: xhigh\nActual:\n${fm}`);
|
||||
@@ -301,7 +347,7 @@ describe('#769 Claude global install: SKILL.md files preserve context: fork and
|
||||
|
||||
test('gsd-progress SKILL.md has effort: low after global install', () => {
|
||||
runClaudeGlobalInstall(claudeHome);
|
||||
const skillPath = path.join(claudeHome, 'skills', 'gsd-progress', 'SKILL.md');
|
||||
const skillPath = nestedClaudeSkillPath(path.join(claudeHome, 'skills'), 'progress');
|
||||
const fm = readFrontmatter(skillPath);
|
||||
assert.match(fm, /^effort:[ \t]*low$/m,
|
||||
`gsd-progress SKILL.md must have effort: low\nActual:\n${fm}`);
|
||||
@@ -309,7 +355,7 @@ describe('#769 Claude global install: SKILL.md files preserve context: fork and
|
||||
|
||||
test('gsd-stats SKILL.md has effort: low after global install', () => {
|
||||
runClaudeGlobalInstall(claudeHome);
|
||||
const skillPath = path.join(claudeHome, 'skills', 'gsd-stats', 'SKILL.md');
|
||||
const skillPath = nestedClaudeSkillPath(path.join(claudeHome, 'skills'), 'stats');
|
||||
const fm = readFrontmatter(skillPath);
|
||||
assert.match(fm, /^effort:[ \t]*low$/m,
|
||||
`gsd-stats SKILL.md must have effort: low\nActual:\n${fm}`);
|
||||
|
||||
@@ -421,9 +421,10 @@ describe('install: manifest records mode for both profiles', () => {
|
||||
const manifestPath = path.join(targetDir, MANIFEST_NAME);
|
||||
if (!fs.existsSync(manifestPath)) return { mode: '<no manifest>', skillCount: 0, agentCount: 0 };
|
||||
const m = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
|
||||
const skillCount = new Set(
|
||||
Object.keys(m.files || {}).filter(k => k.startsWith('skills/')).map(k => k.split('/')[1]),
|
||||
).size;
|
||||
// Count SKILL.md files under skills/ (works for both flat and ns-nested layouts).
|
||||
const skillCount = Object.keys(m.files || {}).filter(
|
||||
k => k.startsWith('skills/') && k.endsWith('/SKILL.md'),
|
||||
).length;
|
||||
const agentCount = Object.keys(m.files || {}).filter(k => k.startsWith('agents/')).length;
|
||||
return { mode: m.mode, skillCount, agentCount };
|
||||
} finally {
|
||||
@@ -474,9 +475,10 @@ describe('install-minimal-backcompat: --minimal and --profile=core produce same
|
||||
const manifestPath = path.join(targetDir, MANIFEST_NAME);
|
||||
if (!fs.existsSync(manifestPath)) return { mode: null, skillCount: 0, profileMarker: null };
|
||||
const m = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
|
||||
const skillCount = new Set(
|
||||
Object.keys(m.files || {}).filter(k => k.startsWith('skills/')).map(k => k.split('/')[1]),
|
||||
).size;
|
||||
// Count SKILL.md files under skills/ (works for both flat and ns-nested layouts).
|
||||
const skillCount = Object.keys(m.files || {}).filter(
|
||||
k => k.startsWith('skills/') && k.endsWith('/SKILL.md'),
|
||||
).length;
|
||||
const markerPath = path.join(targetDir, '.gsd-profile');
|
||||
const profileMarker = fs.existsSync(markerPath) ? fs.readFileSync(markerPath, 'utf8').trim() : null;
|
||||
return { mode: m.mode, skillCount, profileMarker };
|
||||
|
||||
296
tests/install-nested-layout.test.cjs
Normal file
296
tests/install-nested-layout.test.cjs
Normal file
@@ -0,0 +1,296 @@
|
||||
// #69: namespace nested-skill install layout — multi-runtime parity
|
||||
|
||||
// allow-test-rule: source-text-is-the-product
|
||||
// Reads installed .md files (product artefacts) from a real install run —
|
||||
// testing their on-disk layout tests the deployed contract.
|
||||
|
||||
'use strict';
|
||||
|
||||
process.env.GSD_TEST_MODE = '1';
|
||||
|
||||
const { describe, test, before, after } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const os = require('node:os');
|
||||
|
||||
const ROOT = path.join(__dirname, '..');
|
||||
const COMMANDS_GSD = path.join(ROOT, 'commands', 'gsd');
|
||||
|
||||
const {
|
||||
installRuntimeArtifacts,
|
||||
} = require('../bin/install.js');
|
||||
|
||||
const { cleanup } = require('./helpers.cjs');
|
||||
|
||||
const {
|
||||
loadSkillsManifest,
|
||||
resolveProfile,
|
||||
} = require('../gsd-core/bin/lib/install-profiles.cjs');
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Runtime parity decision matrix (#69)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const NEST = [
|
||||
{ runtime: 'claude', scope: 'global', skillsSub: 'skills', prefix: 'gsd-' },
|
||||
{ runtime: 'cline', scope: 'global', skillsSub: 'skills', prefix: 'gsd-' },
|
||||
{ runtime: 'qwen', scope: 'global', skillsSub: 'skills', prefix: 'gsd-' },
|
||||
{ runtime: 'hermes', scope: 'global', skillsSub: 'skills/gsd', prefix: '' },
|
||||
{ runtime: 'augment', scope: 'global', skillsSub: 'skills', prefix: 'gsd-' },
|
||||
{ runtime: 'trae', scope: 'global', skillsSub: 'skills', prefix: 'gsd-' },
|
||||
{ runtime: 'antigravity', scope: 'global', skillsSub: 'skills', prefix: 'gsd-' },
|
||||
];
|
||||
|
||||
const FLAT = [
|
||||
{ runtime: 'cursor', scope: 'global', skillsSub: 'skills' },
|
||||
{ runtime: 'codex', scope: 'global', skillsSub: 'skills' },
|
||||
{ runtime: 'copilot', scope: 'global', skillsSub: 'skills' },
|
||||
{ runtime: 'windsurf', scope: 'global', skillsSub: 'skills' },
|
||||
{ runtime: 'codebuddy', scope: 'global', skillsSub: 'skills' },
|
||||
{ runtime: 'opencode', scope: 'global', skillsSub: 'skills' },
|
||||
{ runtime: 'kilo', scope: 'global', skillsSub: 'skills' },
|
||||
];
|
||||
|
||||
const ROUTER_STEMS = ['ns-context', 'ns-ideate', 'ns-manage', 'ns-project', 'ns-review', 'ns-workflow'];
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Parse the `requires:` flow-style array from a router file's raw content.
|
||||
* Matches `requires: [a, b, c]` (inline array form).
|
||||
*/
|
||||
function parseRouterRequires(content) {
|
||||
const m = content.match(/^requires:\s*\[([^\]]*)\]/m);
|
||||
if (!m) return [];
|
||||
return m[1].split(',').map((s) => s.trim()).filter(Boolean);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the requires list for a router stem from the source commands/gsd dir.
|
||||
*/
|
||||
function routerChildren(routerStem) {
|
||||
const srcFile = path.join(COMMANDS_GSD, `${routerStem}.md`);
|
||||
const content = fs.readFileSync(srcFile, 'utf-8');
|
||||
return parseRouterRequires(content);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a fresh temp dir, run installRuntimeArtifacts into it, and return
|
||||
* the tmpDir path. Caller must cleanup in finally.
|
||||
*/
|
||||
function runInstall(runtime, scope, resolved) {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), `gsd-nest-test-${runtime}-`));
|
||||
installRuntimeArtifacts(runtime, tmpDir, scope, resolved);
|
||||
return tmpDir;
|
||||
}
|
||||
|
||||
// Resolve the full profile once (shared by all installs)
|
||||
const MANIFEST = loadSkillsManifest(COMMANDS_GSD);
|
||||
const RESOLVED_FULL = resolveProfile({ modes: ['full'], manifest: MANIFEST });
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// NEST runtimes: should produce exactly 6 top-level router bundles
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
for (const { runtime, scope, skillsSub, prefix } of NEST) {
|
||||
describe(`${runtime} (nested layout)`, () => {
|
||||
let tmpDir;
|
||||
|
||||
before(() => {
|
||||
tmpDir = runInstall(runtime, scope, RESOLVED_FULL);
|
||||
});
|
||||
|
||||
after(() => {
|
||||
if (tmpDir) {
|
||||
try { cleanup(tmpDir); } catch { /* best-effort */ }
|
||||
}
|
||||
});
|
||||
|
||||
test(`${runtime}: exactly 6 top-level router bundles, no concrete skill at top level`, () => {
|
||||
const skillsDir = path.join(tmpDir, skillsSub);
|
||||
assert.ok(fs.existsSync(skillsDir), `skillsDir must exist: ${skillsDir}`);
|
||||
|
||||
// Find router bundle dirs (top-level, named <prefix>ns-*)
|
||||
const topLevel = fs.readdirSync(skillsDir);
|
||||
const routerDirs = topLevel.filter((n) => n.startsWith(`${prefix}ns-`));
|
||||
assert.strictEqual(
|
||||
routerDirs.length,
|
||||
6,
|
||||
`Expected exactly 6 router dirs under ${skillsDir}, got ${routerDirs.length}: [${routerDirs.join(', ')}]`,
|
||||
);
|
||||
|
||||
// Each router dir must be a real directory with a SKILL.md
|
||||
for (const rd of routerDirs) {
|
||||
const routerPath = path.join(skillsDir, rd);
|
||||
assert.ok(
|
||||
fs.statSync(routerPath).isDirectory(),
|
||||
`${rd} must be a directory`,
|
||||
);
|
||||
assert.ok(
|
||||
fs.existsSync(path.join(routerPath, 'SKILL.md')),
|
||||
`${rd}/SKILL.md must exist`,
|
||||
);
|
||||
}
|
||||
|
||||
// Sample concrete skills must NOT appear at top level
|
||||
for (const concreteSample of ['plan-phase', 'code-review']) {
|
||||
const concreteName = `${prefix}${concreteSample}`;
|
||||
assert.ok(
|
||||
!topLevel.includes(concreteName),
|
||||
`Concrete skill ${concreteName} must NOT be at top level for ${runtime}`,
|
||||
);
|
||||
}
|
||||
|
||||
// Total GSD-owned top-level entries must be EXACTLY 6 (only the routers).
|
||||
// For prefix='gsd-' runtimes: count dirs starting with 'gsd-'.
|
||||
// For hermes (prefix=''): count ALL dirs under skills/gsd (everything is GSD-owned).
|
||||
const gsdTopLevelCount = prefix !== ''
|
||||
? topLevel.filter((n) => n.startsWith(prefix)).length
|
||||
: topLevel.filter((n) => fs.statSync(path.join(skillsDir, n)).isDirectory()).length;
|
||||
assert.strictEqual(
|
||||
gsdTopLevelCount,
|
||||
6,
|
||||
`Expected exactly 6 total GSD-owned top-level skill dirs for ${runtime} (only routers), got ${gsdTopLevelCount}: [${topLevel.join(', ')}]`,
|
||||
);
|
||||
});
|
||||
|
||||
test(`${runtime}: every router has a skills/ subdir with its required children as nested SKILL.md`, () => {
|
||||
const skillsDir = path.join(tmpDir, skillsSub);
|
||||
|
||||
for (const routerStem of ROUTER_STEMS) {
|
||||
const routerDirName = `${prefix}${routerStem}`;
|
||||
const routerDir = path.join(skillsDir, routerDirName);
|
||||
assert.ok(
|
||||
fs.existsSync(routerDir),
|
||||
`Router dir must exist: ${routerDir}`,
|
||||
);
|
||||
|
||||
const childrenSubdir = path.join(routerDir, 'skills');
|
||||
assert.ok(
|
||||
fs.statSync(childrenSubdir).isDirectory(),
|
||||
`${routerDirName}/skills must be a directory`,
|
||||
);
|
||||
|
||||
const children = routerChildren(routerStem);
|
||||
assert.ok(children.length > 0, `Router ${routerStem} must have at least one child`);
|
||||
|
||||
for (const child of children) {
|
||||
const childSkillMd = path.join(childrenSubdir, child, 'SKILL.md');
|
||||
assert.ok(
|
||||
fs.existsSync(childSkillMd),
|
||||
`${routerDirName}/skills/${child}/SKILL.md must exist (child of ${routerStem})`,
|
||||
);
|
||||
assert.ok(
|
||||
fs.statSync(childSkillMd).isFile(),
|
||||
`${routerDirName}/skills/${child}/SKILL.md must be a file`,
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test(`${runtime}: every router body Read-reference resolves to a nested file`, () => {
|
||||
const skillsDir = path.join(tmpDir, skillsSub);
|
||||
|
||||
for (const routerStem of ROUTER_STEMS) {
|
||||
const routerDirName = `${prefix}${routerStem}`;
|
||||
const routerDir = path.join(skillsDir, routerDirName);
|
||||
const routerSkillMd = path.join(routerDir, 'SKILL.md');
|
||||
assert.ok(fs.existsSync(routerSkillMd), `${routerDirName}/SKILL.md must exist`);
|
||||
|
||||
const body = fs.readFileSync(routerSkillMd, 'utf-8');
|
||||
// Extract skills/<stem>/SKILL.md paths from Read-reference lines in the table
|
||||
const refs = [...body.matchAll(/skills\/([a-z0-9-]+)\/SKILL\.md/g)].map((m) => m[1]);
|
||||
|
||||
// There should be at least one reference in every nested router body
|
||||
assert.ok(
|
||||
refs.length > 0,
|
||||
`${routerDirName}/SKILL.md must contain at least one skills/<stem>/SKILL.md reference`,
|
||||
);
|
||||
|
||||
for (const stem of refs) {
|
||||
assert.ok(
|
||||
fs.existsSync(path.join(routerDir, 'skills', stem, 'SKILL.md')),
|
||||
`${routerDirName}/SKILL.md references skills/${stem}/SKILL.md but it does not exist on disk`,
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// claude extra: total top-level gsd- count must equal exactly 6
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('claude: total top-level gsd- entries == 6', () => {
|
||||
let tmpDir;
|
||||
|
||||
before(() => {
|
||||
tmpDir = runInstall('claude', 'global', RESOLVED_FULL);
|
||||
});
|
||||
|
||||
after(() => {
|
||||
if (tmpDir) {
|
||||
try { cleanup(tmpDir); } catch { /* best-effort */ }
|
||||
}
|
||||
});
|
||||
|
||||
test('claude: total top-level gsd- skill entries == 6', () => {
|
||||
const skillsDir = path.join(tmpDir, 'skills');
|
||||
assert.ok(fs.existsSync(skillsDir), 'skills/ dir must exist');
|
||||
|
||||
const topLevel = fs.readdirSync(skillsDir).filter((n) => n.startsWith('gsd-'));
|
||||
assert.strictEqual(
|
||||
topLevel.length,
|
||||
6,
|
||||
`Expected exactly 6 gsd-* top-level entries under claude/skills, got ${topLevel.length}: [${topLevel.join(', ')}]`,
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// FLAT runtimes: concrete skills stay top-level, no nesting
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
for (const { runtime, scope, skillsSub } of FLAT) {
|
||||
describe(`${runtime} (flat layout)`, () => {
|
||||
let tmpDir;
|
||||
|
||||
before(() => {
|
||||
tmpDir = runInstall(runtime, scope, RESOLVED_FULL);
|
||||
});
|
||||
|
||||
after(() => {
|
||||
if (tmpDir) {
|
||||
try { cleanup(tmpDir); } catch { /* best-effort */ }
|
||||
}
|
||||
});
|
||||
|
||||
test(`${runtime}: stays flat — concrete skills remain top-level, no nesting`, () => {
|
||||
const skillsDir = path.join(tmpDir, skillsSub);
|
||||
assert.ok(fs.existsSync(skillsDir), `skillsDir must exist: ${skillsDir}`);
|
||||
|
||||
const topLevel = fs.readdirSync(skillsDir);
|
||||
const gsdEntries = topLevel.filter((n) => n.startsWith('gsd-'));
|
||||
|
||||
// For flat runtimes, there should be many more than 6 top-level gsd- entries
|
||||
assert.ok(
|
||||
gsdEntries.length >= 60,
|
||||
`Flat runtime ${runtime} must have >= 60 gsd-* top-level entries (concrete skills), got ${gsdEntries.length}`,
|
||||
);
|
||||
|
||||
// No router dir should contain a skills/ subdirectory (nesting must not have been applied)
|
||||
const routerDirsPresent = topLevel.filter((n) => n.startsWith('gsd-ns-'));
|
||||
for (const rd of routerDirsPresent) {
|
||||
const nestedSkillsDir = path.join(skillsDir, rd, 'skills');
|
||||
assert.ok(
|
||||
!fs.existsSync(nestedSkillsDir),
|
||||
`Flat runtime ${runtime}: router dir ${rd} must NOT have a skills/ subdirectory (nesting must not apply)`,
|
||||
);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -53,6 +53,43 @@ const {
|
||||
walk,
|
||||
} = require('./helpers/install-shared.cjs');
|
||||
|
||||
/**
|
||||
* Map from concrete skill stem → ns-* router stem for nesting runtimes.
|
||||
* These runtimes nest concrete skills at <skillsRoot>/<prefix><router>/skills/<stem>/SKILL.md
|
||||
* (claude/cline/qwen/trae/augment/antigravity: prefix='gsd-'; hermes: prefix='').
|
||||
*/
|
||||
const CHILD_ROUTER = {
|
||||
// ns-workflow
|
||||
'discuss-phase': 'ns-workflow', 'spec-phase': 'ns-workflow', 'plan-phase': 'ns-workflow',
|
||||
'execute-phase': 'ns-workflow', 'verify-work': 'ns-workflow', 'phase': 'ns-workflow',
|
||||
'progress': 'ns-workflow', 'ultraplan-phase': 'ns-workflow',
|
||||
'plan-review-convergence': 'ns-workflow', 'add-tests': 'ns-workflow',
|
||||
'ai-integration-phase': 'ns-workflow', 'autonomous': 'ns-workflow',
|
||||
'fast': 'ns-workflow', 'mvp-phase': 'ns-workflow', 'quick': 'ns-workflow',
|
||||
// ns-project
|
||||
'new-project': 'ns-project', 'new-milestone': 'ns-project', 'complete-milestone': 'ns-project',
|
||||
'audit-milestone': 'ns-project', 'milestone-summary': 'ns-project', 'import': 'ns-project',
|
||||
'ingest-docs': 'ns-project', 'profile-user': 'ns-project', 'review-backlog': 'ns-project',
|
||||
// ns-review
|
||||
'code-review': 'ns-review', 'audit-uat': 'ns-review', 'secure-phase': 'ns-review',
|
||||
'eval-review': 'ns-review', 'ui-review': 'ns-review', 'validate-phase': 'ns-review',
|
||||
'debug': 'ns-review', 'forensics': 'ns-review', 'audit-fix': 'ns-review',
|
||||
'review': 'ns-review', 'ui-phase': 'ns-review',
|
||||
// ns-context
|
||||
'map-codebase': 'ns-context', 'graphify': 'ns-context', 'docs-update': 'ns-context',
|
||||
'extract-learnings': 'ns-context',
|
||||
// ns-ideate
|
||||
'capture': 'ns-ideate', 'explore': 'ns-ideate', 'sketch': 'ns-ideate',
|
||||
'spike': 'ns-ideate',
|
||||
// ns-manage
|
||||
'config': 'ns-manage', 'workspace': 'ns-manage', 'workstreams': 'ns-manage',
|
||||
'thread': 'ns-manage', 'pause-work': 'ns-manage', 'resume-work': 'ns-manage',
|
||||
'update': 'ns-manage', 'ship': 'ns-manage', 'inbox': 'ns-manage',
|
||||
'pr-branch': 'ns-manage', 'undo': 'ns-manage', 'cleanup': 'ns-manage',
|
||||
'health': 'ns-manage', 'manager': 'ns-manage', 'settings': 'ns-manage',
|
||||
'stats': 'ns-manage', 'surface': 'ns-manage', 'help': 'ns-manage',
|
||||
};
|
||||
|
||||
// ─── Section 1: getDirName / getGlobalConfigDir / getConfigDirFromHome ──────────
|
||||
|
||||
describe('getDirName — all runtimes', () => {
|
||||
@@ -286,7 +323,7 @@ describe('getConfigDirFromHome — spot-checks', () => {
|
||||
// Full E2E for runtimes that have distinct install paths (hermes nested layout,
|
||||
// qwen flat layout, trae flat layout). Others are covered by layout-loop tests.
|
||||
|
||||
describe('install/uninstall — hermes (nested skills/gsd/ layout)', () => {
|
||||
describe('install/uninstall — hermes (nested skills/gsd/<router>/skills/<stem>/ layout)', () => {
|
||||
let tmpDir;
|
||||
let previousCwd;
|
||||
|
||||
@@ -308,19 +345,28 @@ describe('install/uninstall — hermes (nested skills/gsd/ layout)', () => {
|
||||
assert.strictEqual(result.runtime, 'hermes');
|
||||
assert.strictEqual(result.configDir, fs.realpathSync(targetDir));
|
||||
|
||||
assert.ok(fs.existsSync(path.join(targetDir, 'skills', 'gsd', 'help', 'SKILL.md')));
|
||||
// hermes nests: skills/gsd/<router>/skills/<stem>/SKILL.md
|
||||
const hermesHelpPath = path.join(
|
||||
targetDir, 'skills', 'gsd', CHILD_ROUTER['help'], 'skills', 'help', 'SKILL.md'
|
||||
);
|
||||
assert.ok(fs.existsSync(hermesHelpPath),
|
||||
`help SKILL.md must exist at nested path: ${path.relative(targetDir, hermesHelpPath)}`);
|
||||
assert.ok(fs.existsSync(path.join(targetDir, 'skills', 'gsd', 'DESCRIPTION.md')),
|
||||
'DESCRIPTION.md at category root');
|
||||
assert.ok(fs.existsSync(path.join(targetDir, 'gsd-core', 'VERSION')));
|
||||
assert.ok(fs.existsSync(path.join(targetDir, 'agents')));
|
||||
|
||||
const manifest = writeManifest(targetDir, 'hermes');
|
||||
assert.ok(Object.keys(manifest.files).some(f => f.startsWith('skills/gsd/help/')),
|
||||
JSON.stringify(manifest.files));
|
||||
assert.ok(
|
||||
Object.keys(manifest.files).some(f =>
|
||||
f.startsWith('skills/gsd/' + CHILD_ROUTER['help'] + '/skills/help/')
|
||||
),
|
||||
JSON.stringify(manifest.files)
|
||||
);
|
||||
|
||||
uninstall(false, 'hermes');
|
||||
|
||||
assert.ok(!fs.existsSync(path.join(targetDir, 'skills', 'gsd', 'help')));
|
||||
assert.ok(!fs.existsSync(hermesHelpPath));
|
||||
assert.ok(!fs.existsSync(path.join(targetDir, 'skills', 'gsd')));
|
||||
assert.ok(!fs.existsSync(path.join(targetDir, 'gsd-core')));
|
||||
});
|
||||
@@ -377,7 +423,7 @@ describe('install/uninstall — hermes (nested skills/gsd/ layout)', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('install/uninstall — qwen (flat skills/gsd-* layout)', () => {
|
||||
describe('install/uninstall — qwen (nested skills/gsd-<router>/skills/<stem>/ layout)', () => {
|
||||
let tmpDir;
|
||||
let previousCwd;
|
||||
|
||||
@@ -399,20 +445,29 @@ describe('install/uninstall — qwen (flat skills/gsd-* layout)', () => {
|
||||
assert.strictEqual(result.runtime, 'qwen');
|
||||
assert.strictEqual(result.configDir, fs.realpathSync(targetDir));
|
||||
|
||||
assert.ok(fs.existsSync(path.join(targetDir, 'skills', 'gsd-help', 'SKILL.md')));
|
||||
// qwen nests: skills/gsd-<router>/skills/<stem>/SKILL.md
|
||||
const qwenHelpPath = path.join(
|
||||
targetDir, 'skills', 'gsd-' + CHILD_ROUTER['help'], 'skills', 'help', 'SKILL.md'
|
||||
);
|
||||
assert.ok(fs.existsSync(qwenHelpPath),
|
||||
`help SKILL.md must exist at nested path: ${path.relative(targetDir, qwenHelpPath)}`);
|
||||
assert.ok(fs.existsSync(path.join(targetDir, 'gsd-core', 'VERSION')));
|
||||
assert.ok(fs.existsSync(path.join(targetDir, 'agents')));
|
||||
|
||||
const manifest = writeManifest(targetDir, 'qwen');
|
||||
assert.ok(Object.keys(manifest.files).some(f => f.startsWith('skills/gsd-help/')));
|
||||
assert.ok(
|
||||
Object.keys(manifest.files).some(f =>
|
||||
f.startsWith('skills/gsd-' + CHILD_ROUTER['help'] + '/skills/help/')
|
||||
)
|
||||
);
|
||||
|
||||
uninstall(false, 'qwen');
|
||||
assert.ok(!fs.existsSync(path.join(targetDir, 'skills', 'gsd-help')));
|
||||
assert.ok(!fs.existsSync(qwenHelpPath));
|
||||
assert.ok(!fs.existsSync(path.join(targetDir, 'gsd-core')));
|
||||
});
|
||||
});
|
||||
|
||||
describe('install/uninstall — trae (flat skills/gsd-* layout)', () => {
|
||||
describe('install/uninstall — trae (nested skills/gsd-<router>/skills/<stem>/ layout)', () => {
|
||||
let tmpDir;
|
||||
let previousCwd;
|
||||
|
||||
@@ -440,15 +495,24 @@ describe('install/uninstall — trae (flat skills/gsd-* layout)', () => {
|
||||
configDir: fs.realpathSync(targetDir),
|
||||
});
|
||||
|
||||
assert.ok(fs.existsSync(path.join(targetDir, 'skills', 'gsd-help', 'SKILL.md')));
|
||||
// trae nests: skills/gsd-<router>/skills/<stem>/SKILL.md
|
||||
const traeHelpPath = path.join(
|
||||
targetDir, 'skills', 'gsd-' + CHILD_ROUTER['help'], 'skills', 'help', 'SKILL.md'
|
||||
);
|
||||
assert.ok(fs.existsSync(traeHelpPath),
|
||||
`help SKILL.md must exist at nested path: ${path.relative(targetDir, traeHelpPath)}`);
|
||||
assert.ok(fs.existsSync(path.join(targetDir, 'gsd-core', 'VERSION')));
|
||||
assert.ok(fs.existsSync(path.join(targetDir, 'agents')));
|
||||
|
||||
const manifest = writeManifest(targetDir, 'trae');
|
||||
assert.ok(Object.keys(manifest.files).some(f => f.startsWith('skills/gsd-help/')));
|
||||
assert.ok(
|
||||
Object.keys(manifest.files).some(f =>
|
||||
f.startsWith('skills/gsd-' + CHILD_ROUTER['help'] + '/skills/help/')
|
||||
)
|
||||
);
|
||||
|
||||
uninstall(false, 'trae');
|
||||
assert.ok(!fs.existsSync(path.join(targetDir, 'skills', 'gsd-help')));
|
||||
assert.ok(!fs.existsSync(traeHelpPath));
|
||||
assert.ok(!fs.existsSync(path.join(targetDir, 'gsd-core')));
|
||||
});
|
||||
});
|
||||
|
||||
80
tests/issue-69-surface-keeps-nested.test.cjs
Normal file
80
tests/issue-69-surface-keeps-nested.test.cjs
Normal file
@@ -0,0 +1,80 @@
|
||||
// #69 regression: applySurface must NOT re-flatten the nested skill layout
|
||||
//
|
||||
// Bug: stageSkillsForRuntimeAsSkills gated nesting on `resolvedProfile.skills === '*'`
|
||||
// (the sentinel). applySurface → resolveSurface materializes the full profile into a
|
||||
// concrete Set<string>, so the sentinel check was never true on the surface path.
|
||||
// Result: applySurface called kind.stage(resolved) → stageSkillsForRuntimeAsSkills with
|
||||
// a concrete Set → doNest = false → flat layout, overwriting the nested install.
|
||||
//
|
||||
// Fix (install-profiles.cts): gate nesting on full OR full-equivalent (all routerStems
|
||||
// present in the concrete Set) so that the surface path preserves nesting.
|
||||
|
||||
'use strict';
|
||||
|
||||
process.env.GSD_TEST_MODE = '1';
|
||||
|
||||
const { describe, test } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const os = require('node:os');
|
||||
|
||||
const ROOT = path.join(__dirname, '..');
|
||||
const COMMANDS_GSD = path.join(ROOT, 'commands', 'gsd');
|
||||
|
||||
const { installRuntimeArtifacts } = require('../bin/install.js');
|
||||
const { applySurface } = require('../gsd-core/bin/lib/surface.cjs');
|
||||
const { loadSkillsManifest, resolveProfile } = require('../gsd-core/bin/lib/install-profiles.cjs');
|
||||
const { resolveRuntimeArtifactLayout } = require('../gsd-core/bin/lib/runtime-artifact-layout.cjs');
|
||||
const { cleanup } = require('./helpers.cjs');
|
||||
|
||||
describe('issue-69: applySurface preserves nested skill layout (no re-flatten)', () => {
|
||||
test('claude global full: applySurface keeps 6 router dirs and nested gsd-ns-workflow/skills/plan-phase/SKILL.md', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-69-surface-'));
|
||||
t.after(() => { try { cleanup(tmpDir); } catch { /* best-effort */ } });
|
||||
|
||||
// Step 1: full install
|
||||
const manifest = loadSkillsManifest(COMMANDS_GSD);
|
||||
const resolved = resolveProfile({ modes: ['full'], manifest });
|
||||
installRuntimeArtifacts('claude', tmpDir, 'global', resolved);
|
||||
|
||||
const skillsDir = path.join(tmpDir, 'skills');
|
||||
|
||||
// Sanity: install must produce nested layout
|
||||
const topLevelAfterInstall = fs.readdirSync(skillsDir).filter((n) => n.startsWith('gsd-'));
|
||||
assert.strictEqual(
|
||||
topLevelAfterInstall.length,
|
||||
6,
|
||||
`Install must produce exactly 6 gsd-* top-level dirs (routers). Got ${topLevelAfterInstall.length}: [${topLevelAfterInstall.join(', ')}]`,
|
||||
);
|
||||
assert.ok(
|
||||
fs.existsSync(path.join(skillsDir, 'gsd-ns-workflow', 'skills', 'plan-phase', 'SKILL.md')),
|
||||
'After install: gsd-ns-workflow/skills/plan-phase/SKILL.md must exist',
|
||||
);
|
||||
|
||||
// Step 2: applySurface (full surface, no surface state file → resolves to full)
|
||||
const layout = resolveRuntimeArtifactLayout('claude', tmpDir, 'global');
|
||||
applySurface(tmpDir, layout, manifest);
|
||||
|
||||
// Step 3: assert nested layout is preserved after applySurface
|
||||
const topLevelAfterSurface = fs.readdirSync(skillsDir).filter((n) => n.startsWith('gsd-'));
|
||||
assert.strictEqual(
|
||||
topLevelAfterSurface.length,
|
||||
6,
|
||||
`After applySurface: expected exactly 6 gsd-* top-level dirs (routers only). Got ${topLevelAfterSurface.length}: [${topLevelAfterSurface.join(', ')}]. ` +
|
||||
'Re-flattening detected: applySurface must preserve nested layout (#69 regression).',
|
||||
);
|
||||
|
||||
// The nested SKILL.md must still exist (not re-flattened to top-level concrete dir)
|
||||
assert.ok(
|
||||
fs.existsSync(path.join(skillsDir, 'gsd-ns-workflow', 'skills', 'plan-phase', 'SKILL.md')),
|
||||
'After applySurface: gsd-ns-workflow/skills/plan-phase/SKILL.md must still exist (nested layout preserved)',
|
||||
);
|
||||
|
||||
// The concrete skill must NOT have been promoted to a top-level flat dir
|
||||
assert.ok(
|
||||
!fs.existsSync(path.join(skillsDir, 'gsd-plan-phase', 'SKILL.md')),
|
||||
'After applySurface: gsd-plan-phase/ must NOT exist at top level (#69 re-flatten regression guard)',
|
||||
);
|
||||
});
|
||||
});
|
||||
430
tests/phase-locator.test.cjs
Normal file
430
tests/phase-locator.test.cjs
Normal file
@@ -0,0 +1,430 @@
|
||||
/**
|
||||
* Tests for src/phase-locator.cts (compiled to gsd-core/bin/lib/phase-locator.cjs).
|
||||
*
|
||||
* Verifies behavioural contracts of the phase-locator helpers extracted from
|
||||
* core.cjs per ADR-857 rollout phase 2d (#881):
|
||||
* - searchPhaseInDir
|
||||
* - findPhaseInternal
|
||||
* - getArchivedPhaseDirs
|
||||
* - core.cjs re-export shims resolve to the exact same functions (shim-identity)
|
||||
*
|
||||
* Adversarial inputs: decimal/repeated phase ids, path-traversal-like names,
|
||||
* unicode, missing/empty phases dir, milestone-prefixed dirs.
|
||||
* Uses helpers.cjs createTempProject/cleanup for filesystem tests.
|
||||
*
|
||||
* Phase dir naming convention: zero-padded (e.g. "01-setup", "02-auth").
|
||||
* normalizePhaseName('1') → '01'; phaseTokenMatches('01-setup', '01') → true.
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
const { test, describe, afterEach } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
|
||||
const phaseLocator = require('../gsd-core/bin/lib/phase-locator.cjs');
|
||||
const core = require('../gsd-core/bin/lib/core.cjs');
|
||||
const { createTempProject, cleanup } = require('./helpers.cjs');
|
||||
|
||||
// ─── Shim-identity assertions ─────────────────────────────────────────────────
|
||||
|
||||
describe('phase-locator: shim-identity — core.cjs re-exports same function objects', () => {
|
||||
test('core.findPhaseInternal === phaseLocator.findPhaseInternal', () => {
|
||||
assert.strictEqual(core.findPhaseInternal, phaseLocator.findPhaseInternal);
|
||||
});
|
||||
|
||||
test('core.getArchivedPhaseDirs === phaseLocator.getArchivedPhaseDirs', () => {
|
||||
assert.strictEqual(core.getArchivedPhaseDirs, phaseLocator.getArchivedPhaseDirs);
|
||||
});
|
||||
|
||||
test('core.searchPhaseInDir === phaseLocator.searchPhaseInDir', () => {
|
||||
assert.strictEqual(core.searchPhaseInDir, phaseLocator.searchPhaseInDir);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── findPhaseInternal — basic active-phase lookup ────────────────────────────
|
||||
|
||||
describe('findPhaseInternal: active phase lookup', () => {
|
||||
let tmpDir;
|
||||
afterEach(() => { if (tmpDir) { cleanup(tmpDir); tmpDir = null; } });
|
||||
|
||||
test('returns null for falsy phase argument', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
assert.strictEqual(phaseLocator.findPhaseInternal(tmpDir, null), null);
|
||||
assert.strictEqual(phaseLocator.findPhaseInternal(tmpDir, ''), null);
|
||||
assert.strictEqual(phaseLocator.findPhaseInternal(tmpDir, 0), null);
|
||||
assert.strictEqual(phaseLocator.findPhaseInternal(tmpDir, undefined), null);
|
||||
});
|
||||
|
||||
test('returns null when phases dir does not exist', () => {
|
||||
// Use a raw tmpDir (no phases subdir) to simulate missing phases dir
|
||||
tmpDir = fs.mkdtempSync(path.join(require('node:os').tmpdir(), 'gsd-pl-test-'));
|
||||
fs.mkdirSync(path.join(tmpDir, '.planning'), { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '1');
|
||||
assert.strictEqual(result, null);
|
||||
});
|
||||
|
||||
test('returns null when phases dir is empty', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '1');
|
||||
assert.strictEqual(result, null);
|
||||
});
|
||||
|
||||
test('finds a simple phase by number (zero-padded dir)', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
// Phase dirs use zero-padded format: normalizePhaseName('1') = '01'
|
||||
const phaseDir = path.join(tmpDir, '.planning', 'phases', '01-setup');
|
||||
fs.mkdirSync(phaseDir, { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '1');
|
||||
assert.ok(result !== null, 'expected a result for phase 1');
|
||||
assert.strictEqual(result.found, true);
|
||||
assert.strictEqual(result.phase_number, '01');
|
||||
assert.strictEqual(result.phase_name, 'setup');
|
||||
assert.strictEqual(result.phase_slug, 'setup');
|
||||
assert.ok(result.directory.includes('01-setup'));
|
||||
assert.strictEqual(result.archived, undefined);
|
||||
});
|
||||
|
||||
test('finds phase by full normalized id', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const phaseDir = path.join(tmpDir, '.planning', 'phases', '02-auth');
|
||||
fs.mkdirSync(phaseDir, { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '02');
|
||||
assert.ok(result !== null);
|
||||
assert.strictEqual(result.phase_number, '02');
|
||||
assert.strictEqual(result.phase_name, 'auth');
|
||||
});
|
||||
|
||||
test('reports plans and summaries from phase directory', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const phaseDir = path.join(tmpDir, '.planning', 'phases', '01-impl');
|
||||
fs.mkdirSync(phaseDir, { recursive: true });
|
||||
fs.writeFileSync(path.join(phaseDir, 'FEATURE-PLAN.md'), '# Plan');
|
||||
fs.writeFileSync(path.join(phaseDir, 'FEATURE-SUMMARY.md'), '# Summary');
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '1');
|
||||
assert.ok(result !== null);
|
||||
assert.ok(result.plans.includes('FEATURE-PLAN.md'));
|
||||
assert.ok(result.summaries.includes('FEATURE-SUMMARY.md'));
|
||||
assert.deepEqual(result.incomplete_plans, []);
|
||||
});
|
||||
|
||||
test('includes incomplete plans (plans without corresponding summaries)', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const phaseDir = path.join(tmpDir, '.planning', 'phases', '03-work');
|
||||
fs.mkdirSync(phaseDir, { recursive: true });
|
||||
fs.writeFileSync(path.join(phaseDir, 'A-PLAN.md'), '# A Plan');
|
||||
fs.writeFileSync(path.join(phaseDir, 'B-PLAN.md'), '# B Plan');
|
||||
fs.writeFileSync(path.join(phaseDir, 'A-SUMMARY.md'), '# A Summary');
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '3');
|
||||
assert.ok(result !== null);
|
||||
assert.ok(result.incomplete_plans.includes('B-PLAN.md'));
|
||||
assert.ok(!result.incomplete_plans.includes('A-PLAN.md'));
|
||||
});
|
||||
|
||||
test('directory is a posix-style relative path from cwd', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const phaseDir = path.join(tmpDir, '.planning', 'phases', '01-setup');
|
||||
fs.mkdirSync(phaseDir, { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '1');
|
||||
assert.ok(result !== null);
|
||||
assert.ok(!result.directory.includes('\\'), 'directory should use forward slashes');
|
||||
assert.ok(result.directory.startsWith('.planning/phases/'));
|
||||
});
|
||||
|
||||
test('returns null when requested phase is not present', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
fs.mkdirSync(path.join(tmpDir, '.planning', 'phases', '02-other'), { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '1');
|
||||
assert.strictEqual(result, null);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── findPhaseInternal — decimal/complex phase ids ────────────────────────────
|
||||
|
||||
describe('findPhaseInternal: decimal and complex phase ids (adversarial)', () => {
|
||||
let tmpDir;
|
||||
afterEach(() => { if (tmpDir) { cleanup(tmpDir); tmpDir = null; } });
|
||||
|
||||
test('finds decimal sub-phase (e.g. 01.1)', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
// normalizePhaseName('1.1') = '01.1'
|
||||
const phaseDir = path.join(tmpDir, '.planning', 'phases', '01.1-subsection');
|
||||
fs.mkdirSync(phaseDir, { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '1.1');
|
||||
assert.ok(result !== null, 'should find decimal phase 1.1');
|
||||
assert.strictEqual(result.found, true);
|
||||
assert.strictEqual(result.phase_number, '01.1');
|
||||
});
|
||||
|
||||
test('decimal sub-phase dir is not matched by integer-only search', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
// Create only 01.1-sub, NOT 01-something: searching for '1' should return null
|
||||
const phaseDir = path.join(tmpDir, '.planning', 'phases', '01.1-sub');
|
||||
fs.mkdirSync(phaseDir, { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '1');
|
||||
// '01' does not match '01.1-sub' (they are distinct tokens)
|
||||
assert.strictEqual(result, null);
|
||||
});
|
||||
|
||||
test('handles phases with multi-segment names', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const phaseDir = path.join(tmpDir, '.planning', 'phases', '05-some-long-phase-name');
|
||||
fs.mkdirSync(phaseDir, { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '5');
|
||||
assert.ok(result !== null);
|
||||
assert.strictEqual(result.phase_name, 'some-long-phase-name');
|
||||
assert.strictEqual(result.phase_slug, 'some-long-phase-name');
|
||||
});
|
||||
|
||||
test('phase with unicode in name — does not throw', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
try {
|
||||
const phaseDir = path.join(tmpDir, '.planning', 'phases', '06-中文');
|
||||
fs.mkdirSync(phaseDir, { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '6');
|
||||
// If the filesystem supports unicode dir names, we get a result; if not, null is acceptable
|
||||
if (result !== null) {
|
||||
assert.strictEqual(result.found, true);
|
||||
assert.ok(typeof result.phase_name === 'string' || result.phase_name === null);
|
||||
}
|
||||
} catch (e) {
|
||||
// Some environments may not support unicode filenames; that's fine
|
||||
assert.ok(e instanceof Error);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// ─── findPhaseInternal — archived phase search ────────────────────────────────
|
||||
|
||||
describe('findPhaseInternal: archived milestone phase lookup', () => {
|
||||
let tmpDir;
|
||||
afterEach(() => { if (tmpDir) { cleanup(tmpDir); tmpDir = null; } });
|
||||
|
||||
test('finds archived phase when not in active phases', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const milestonesDir = path.join(tmpDir, '.planning', 'milestones', 'v1.0.0-phases');
|
||||
fs.mkdirSync(path.join(milestonesDir, '01-archived'), { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '1');
|
||||
assert.ok(result !== null, 'should find archived phase');
|
||||
assert.strictEqual(result.found, true);
|
||||
assert.strictEqual(result.archived, 'v1.0.0');
|
||||
assert.ok(result.directory.startsWith('.planning/milestones/v1.0.0-phases/'));
|
||||
});
|
||||
|
||||
test('prefers active phase over archived phase', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
// Set up both active and archived phase 01
|
||||
fs.mkdirSync(path.join(tmpDir, '.planning', 'phases', '01-active'), { recursive: true });
|
||||
const milestonesDir = path.join(tmpDir, '.planning', 'milestones', 'v1.0.0-phases');
|
||||
fs.mkdirSync(path.join(milestonesDir, '01-archived'), { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '1');
|
||||
assert.ok(result !== null);
|
||||
// Should return active (no archived property)
|
||||
assert.strictEqual(result.archived, undefined);
|
||||
assert.ok(result.directory.startsWith('.planning/phases/'));
|
||||
});
|
||||
|
||||
test('searches most recent milestone first (reverse sort)', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
// v1.2.0 archive has phase 03, v1.1.0 archive also has phase 03
|
||||
const v110 = path.join(tmpDir, '.planning', 'milestones', 'v1.1.0-phases');
|
||||
const v120 = path.join(tmpDir, '.planning', 'milestones', 'v1.2.0-phases');
|
||||
fs.mkdirSync(path.join(v110, '03-old'), { recursive: true });
|
||||
fs.mkdirSync(path.join(v120, '03-new'), { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '3');
|
||||
assert.ok(result !== null);
|
||||
// v1.2.0 is more recent; reverse-sort means it's checked first
|
||||
assert.strictEqual(result.archived, 'v1.2.0');
|
||||
});
|
||||
|
||||
test('returns null when phase exists in neither active nor archive', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const milestonesDir = path.join(tmpDir, '.planning', 'milestones', 'v1.0.0-phases');
|
||||
fs.mkdirSync(path.join(milestonesDir, '02-other'), { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '99');
|
||||
assert.strictEqual(result, null);
|
||||
});
|
||||
|
||||
test('returns null when milestones dir does not exist', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
// No .planning/milestones dir — only .planning/phases (empty)
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '1');
|
||||
assert.strictEqual(result, null);
|
||||
});
|
||||
|
||||
test('ignores non-matching milestone dir names (not vX.Y.Z-phases)', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
// Directory that doesn't match /^v[\d.]+-phases$/ should be skipped
|
||||
const badDir = path.join(tmpDir, '.planning', 'milestones', 'not-a-phases-dir');
|
||||
fs.mkdirSync(path.join(badDir, '01-phase'), { recursive: true });
|
||||
const result = phaseLocator.findPhaseInternal(tmpDir, '1');
|
||||
assert.strictEqual(result, null);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── getArchivedPhaseDirs ─────────────────────────────────────────────────────
|
||||
|
||||
describe('getArchivedPhaseDirs', () => {
|
||||
let tmpDir;
|
||||
afterEach(() => { if (tmpDir) { cleanup(tmpDir); tmpDir = null; } });
|
||||
|
||||
test('returns empty array when .planning/milestones does not exist', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const result = phaseLocator.getArchivedPhaseDirs(tmpDir);
|
||||
assert.deepEqual(result, []);
|
||||
});
|
||||
|
||||
test('returns empty array when milestones dir has no matching phase-archive dirs', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const milestonesDir = path.join(tmpDir, '.planning', 'milestones');
|
||||
fs.mkdirSync(milestonesDir, { recursive: true });
|
||||
fs.mkdirSync(path.join(milestonesDir, 'not-phases-dir'));
|
||||
const result = phaseLocator.getArchivedPhaseDirs(tmpDir);
|
||||
assert.deepEqual(result, []);
|
||||
});
|
||||
|
||||
test('returns phase entries from a single milestone archive', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const archiveDir = path.join(tmpDir, '.planning', 'milestones', 'v1.0.0-phases');
|
||||
fs.mkdirSync(path.join(archiveDir, '01-feature'), { recursive: true });
|
||||
fs.mkdirSync(path.join(archiveDir, '02-bugfix'), { recursive: true });
|
||||
const result = phaseLocator.getArchivedPhaseDirs(tmpDir);
|
||||
assert.ok(Array.isArray(result));
|
||||
assert.strictEqual(result.length, 2);
|
||||
const names = result.map(r => r.name).sort();
|
||||
assert.deepEqual(names, ['01-feature', '02-bugfix']);
|
||||
});
|
||||
|
||||
test('result entries have correct shape', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const archiveDir = path.join(tmpDir, '.planning', 'milestones', 'v2.1.0-phases');
|
||||
fs.mkdirSync(path.join(archiveDir, '03-auth'), { recursive: true });
|
||||
const result = phaseLocator.getArchivedPhaseDirs(tmpDir);
|
||||
assert.strictEqual(result.length, 1);
|
||||
const entry = result[0];
|
||||
assert.strictEqual(entry.name, '03-auth');
|
||||
assert.strictEqual(entry.milestone, 'v2.1.0');
|
||||
assert.strictEqual(entry.basePath, path.join('.planning', 'milestones', 'v2.1.0-phases'));
|
||||
assert.strictEqual(entry.fullPath, path.join(archiveDir, '03-auth'));
|
||||
});
|
||||
|
||||
test('aggregates phases from multiple milestone archives (most recent first)', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const v1Dir = path.join(tmpDir, '.planning', 'milestones', 'v1.0.0-phases');
|
||||
const v2Dir = path.join(tmpDir, '.planning', 'milestones', 'v2.0.0-phases');
|
||||
fs.mkdirSync(path.join(v1Dir, '01-old'), { recursive: true });
|
||||
fs.mkdirSync(path.join(v2Dir, '01-new'), { recursive: true });
|
||||
const result = phaseLocator.getArchivedPhaseDirs(tmpDir);
|
||||
assert.strictEqual(result.length, 2);
|
||||
// Reverse sort: v2.0.0 comes before v1.0.0
|
||||
const milestones = result.map(r => r.milestone);
|
||||
assert.strictEqual(milestones[0], 'v2.0.0');
|
||||
assert.strictEqual(milestones[1], 'v1.0.0');
|
||||
});
|
||||
|
||||
test('adversarial: milestone-prefixed dir names that do not match pattern are skipped', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const milestonesDir = path.join(tmpDir, '.planning', 'milestones');
|
||||
fs.mkdirSync(milestonesDir, { recursive: true });
|
||||
// These should all be ignored (do not match /^v[\d.]+-phases$/):
|
||||
for (const bad of ['v1.0.0', 'phases', 'v1.0.0-phase', 'v-phases', '1.0.0-phases']) {
|
||||
fs.mkdirSync(path.join(milestonesDir, bad), { recursive: true });
|
||||
fs.mkdirSync(path.join(milestonesDir, bad, '01-sub'), { recursive: true });
|
||||
}
|
||||
const result = phaseLocator.getArchivedPhaseDirs(tmpDir);
|
||||
assert.deepEqual(result, []);
|
||||
});
|
||||
|
||||
test('returns empty array for empty milestone archive dirs', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const archiveDir = path.join(tmpDir, '.planning', 'milestones', 'v1.0.0-phases');
|
||||
fs.mkdirSync(archiveDir, { recursive: true });
|
||||
// Archive dir exists but has no phase subdirs
|
||||
const result = phaseLocator.getArchivedPhaseDirs(tmpDir);
|
||||
assert.deepEqual(result, []);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── searchPhaseInDir — direct tests ─────────────────────────────────────────
|
||||
|
||||
describe('searchPhaseInDir: direct filesystem search', () => {
|
||||
let tmpDir;
|
||||
afterEach(() => { if (tmpDir) { cleanup(tmpDir); tmpDir = null; } });
|
||||
|
||||
test('returns null for non-existent baseDir', () => {
|
||||
const result = phaseLocator.searchPhaseInDir('/nonexistent-dir-xyz-' + Date.now(), 'rel/base', '01');
|
||||
assert.strictEqual(result, null);
|
||||
});
|
||||
|
||||
test('returns null when no matching subdirectory exists', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const phasesDir = path.join(tmpDir, '.planning', 'phases');
|
||||
fs.mkdirSync(path.join(phasesDir, '02-other'), { recursive: true });
|
||||
const result = phaseLocator.searchPhaseInDir(phasesDir, '.planning/phases', '01');
|
||||
assert.strictEqual(result, null);
|
||||
});
|
||||
|
||||
test('finds matching dir and returns correct structure', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const phasesDir = path.join(tmpDir, '.planning', 'phases');
|
||||
fs.mkdirSync(path.join(phasesDir, '01-hello'), { recursive: true });
|
||||
const result = phaseLocator.searchPhaseInDir(phasesDir, '.planning/phases', '01');
|
||||
assert.ok(result !== null);
|
||||
assert.strictEqual(result.found, true);
|
||||
assert.strictEqual(result.phase_number, '01');
|
||||
assert.strictEqual(result.phase_name, 'hello');
|
||||
assert.strictEqual(result.phase_slug, 'hello');
|
||||
assert.strictEqual(result.directory, '.planning/phases/01-hello');
|
||||
});
|
||||
|
||||
test('relBase is prepended to directory in result', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const archiveDir = path.join(tmpDir, '.planning', 'milestones', 'v1.0.0-phases');
|
||||
fs.mkdirSync(path.join(archiveDir, '03-feat'), { recursive: true });
|
||||
const result = phaseLocator.searchPhaseInDir(archiveDir, '.planning/milestones/v1.0.0-phases', '03');
|
||||
assert.ok(result !== null);
|
||||
assert.strictEqual(result.directory, '.planning/milestones/v1.0.0-phases/03-feat');
|
||||
});
|
||||
|
||||
test('adversarial: dir with normal name does not produce path traversal', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const phasesDir = path.join(tmpDir, '.planning', 'phases');
|
||||
fs.mkdirSync(path.join(phasesDir, '01-normal-phase'), { recursive: true });
|
||||
const result = phaseLocator.searchPhaseInDir(phasesDir, '.planning/phases', '01');
|
||||
assert.ok(result !== null);
|
||||
// The directory value should not escape its base
|
||||
assert.ok(!result.directory.includes('..'));
|
||||
});
|
||||
|
||||
test('adversarial: phase number with repeated decimal segments (e.g. 1.1.1)', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const phasesDir = path.join(tmpDir, '.planning', 'phases');
|
||||
fs.mkdirSync(path.join(phasesDir, '01.1.1-deep'), { recursive: true });
|
||||
// Result may be found or null depending on normalization; must not throw
|
||||
const result = phaseLocator.searchPhaseInDir(phasesDir, '.planning/phases', '01.1.1');
|
||||
assert.ok(result === null || typeof result.found === 'boolean');
|
||||
});
|
||||
|
||||
test('returns has_research/has_context/has_verification/has_reviews as booleans', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const phasesDir = path.join(tmpDir, '.planning', 'phases');
|
||||
const phaseDir = path.join(phasesDir, '01-test');
|
||||
fs.mkdirSync(phaseDir, { recursive: true });
|
||||
const result = phaseLocator.searchPhaseInDir(phasesDir, '.planning/phases', '01');
|
||||
assert.ok(result !== null);
|
||||
assert.strictEqual(typeof result.has_research, 'boolean');
|
||||
assert.strictEqual(typeof result.has_context, 'boolean');
|
||||
assert.strictEqual(typeof result.has_verification, 'boolean');
|
||||
assert.strictEqual(typeof result.has_reviews, 'boolean');
|
||||
assert.strictEqual(result.has_research, false);
|
||||
assert.strictEqual(result.has_context, false);
|
||||
});
|
||||
|
||||
test('adversarial: empty phases dir (no subdirs) returns null', () => {
|
||||
tmpDir = createTempProject('gsd-pl-test-');
|
||||
const phasesDir = path.join(tmpDir, '.planning', 'phases');
|
||||
const result = phaseLocator.searchPhaseInDir(phasesDir, '.planning/phases', '01');
|
||||
assert.strictEqual(result, null);
|
||||
});
|
||||
});
|
||||
@@ -467,7 +467,7 @@ describe('roadmap-parser: getMilestonePhaseFilter', () => {
|
||||
assert.strictEqual(filter.phaseCount, 1, 'deduplication: only 1 unique phase');
|
||||
});
|
||||
|
||||
test('adversarial: characterizes current fence-blind behavior for backtick fence (pending #875)', () => {
|
||||
test('adversarial: phase heading inside backtick fence is excluded (fix #875)', () => {
|
||||
writeRoadmap(tmpDir, [
|
||||
'## v1.0: Real',
|
||||
'```',
|
||||
@@ -478,10 +478,10 @@ describe('roadmap-parser: getMilestonePhaseFilter', () => {
|
||||
].join('\n'));
|
||||
|
||||
const filter = getMilestonePhaseFilter(tmpDir);
|
||||
// KNOWN BUG #875: getMilestonePhaseFilter is fence-blind — phase headings inside
|
||||
// fenced code blocks are incorrectly parsed as real phases. Flip to false when #875 is fixed.
|
||||
// Phase headings inside fenced code blocks must NOT be counted as real phases.
|
||||
// getMilestonePhaseFilter is fence-aware (fix #875).
|
||||
assert.strictEqual(filter('01-real'), true, 'real phase matches');
|
||||
assert.strictEqual(filter('999-fake'), true, 'characterization: getMilestonePhaseFilter is currently fence-blind (KNOWN BUG #875) — flip to false when #875 is fixed');
|
||||
assert.strictEqual(filter('999-fake'), false, 'fenced phase heading is correctly excluded');
|
||||
});
|
||||
|
||||
test('adversarial: unclosed fence block — does not crash', () => {
|
||||
@@ -501,7 +501,7 @@ describe('roadmap-parser: getMilestonePhaseFilter', () => {
|
||||
assert.ok(typeof filter === 'function', 'filter is a function');
|
||||
});
|
||||
|
||||
test('adversarial: characterizes current fence-blind behavior for tilde fence (pending #875)', () => {
|
||||
test('adversarial: phase heading inside tilde fence is excluded (fix #875)', () => {
|
||||
writeRoadmap(tmpDir, [
|
||||
'## v1.0: Tilde',
|
||||
'~~~',
|
||||
@@ -511,10 +511,35 @@ describe('roadmap-parser: getMilestonePhaseFilter', () => {
|
||||
].join('\n'));
|
||||
|
||||
const filter = getMilestonePhaseFilter(tmpDir);
|
||||
// KNOWN BUG #875: getMilestonePhaseFilter is fence-blind — phase headings inside
|
||||
// tilde-fenced code blocks are incorrectly parsed as real phases. Flip to false when #875 is fixed.
|
||||
// Phase headings inside tilde-fenced code blocks must NOT be counted as real phases.
|
||||
// getMilestonePhaseFilter is fence-aware (fix #875).
|
||||
assert.strictEqual(filter('01-real'), true, 'real phase matches despite tilde fence');
|
||||
assert.strictEqual(filter('999-fake'), true, 'characterization: getMilestonePhaseFilter is currently fence-blind (KNOWN BUG #875) — flip to false when #875 is fixed');
|
||||
assert.strictEqual(filter('999-fake'), false, 'tilde-fenced phase heading is correctly excluded');
|
||||
});
|
||||
|
||||
test('adversarial: phase heading inside fence is excluded with CRLF endings (fix #875)', () => {
|
||||
const crlf = '## v1.0: CRLF Fence\r\n```\r\n### Phase 999: Fake\r\n```\r\n### Phase 1: Real\r\n';
|
||||
writeRoadmap(tmpDir, crlf);
|
||||
const filter = getMilestonePhaseFilter(tmpDir);
|
||||
assert.strictEqual(filter('01-real'), true, 'real phase matches in CRLF file');
|
||||
assert.strictEqual(filter('999-fake'), false, 'fenced phase excluded in CRLF file');
|
||||
});
|
||||
|
||||
test('adversarial: phase headings in back-to-back fences are excluded (fix #875)', () => {
|
||||
writeRoadmap(tmpDir, [
|
||||
'## v1.0: Adjacent',
|
||||
'```',
|
||||
'### Phase 998: Fake A',
|
||||
'```',
|
||||
'```',
|
||||
'### Phase 999: Fake B',
|
||||
'```',
|
||||
'### Phase 1: Real',
|
||||
].join('\n'));
|
||||
const filter = getMilestonePhaseFilter(tmpDir);
|
||||
assert.strictEqual(filter('01-real'), true, 'real phase matches');
|
||||
assert.strictEqual(filter('998-fake'), false, 'first fenced phase excluded');
|
||||
assert.strictEqual(filter('999-fake'), false, 'second fenced phase excluded');
|
||||
});
|
||||
|
||||
test('adversarial: CRLF line endings in roadmap', () => {
|
||||
|
||||
@@ -440,20 +440,40 @@ describe('stage — skills kind (claude global)', () => {
|
||||
assert.ok(entries.length >= 1, 'at least one skill dir should be staged');
|
||||
});
|
||||
|
||||
test('stage with skills="*" stages all commands/gsd/*.md as skills', () => {
|
||||
test('stage with skills="*" nests all commands/gsd/*.md under 6 routers (claude)', () => {
|
||||
const layout = resolveRuntimeArtifactLayout('claude', FAKE_STAGE_DIR, 'global');
|
||||
const skillsKind = layout.kinds.find(k => k.kind === 'skills');
|
||||
assert.ok(skillsKind, 'should have a skills kind');
|
||||
|
||||
const stagedDir = skillsKind.stage(PROFILE_FULL);
|
||||
assert.ok(fs.existsSync(stagedDir), 'stagedDir must exist');
|
||||
const entries = fs.readdirSync(stagedDir);
|
||||
assert.ok(entries.length > 10, `full profile should have many skills, got ${entries.length}`);
|
||||
for (const entry of entries) {
|
||||
assert.ok(entry.startsWith('gsd-'), `entry should start with gsd-: ${entry}`);
|
||||
const skillMd = path.join(stagedDir, entry, 'SKILL.md');
|
||||
assert.ok(fs.existsSync(skillMd), `SKILL.md must exist in ${entry}`);
|
||||
|
||||
// Claude is a NESTING runtime: full profile produces exactly 6 gsd-ns-* router dirs.
|
||||
const topEntries = fs.readdirSync(stagedDir);
|
||||
assert.strictEqual(topEntries.length, 6, `full profile should have exactly 6 router dirs, got ${topEntries.length}`);
|
||||
for (const entry of topEntries) {
|
||||
assert.ok(entry.startsWith('gsd-ns-'), `top-level entry should be a gsd-ns-* router: ${entry}`);
|
||||
// Each router has its own SKILL.md.
|
||||
const routerSkillMd = path.join(stagedDir, entry, 'SKILL.md');
|
||||
assert.ok(fs.existsSync(routerSkillMd), `router SKILL.md must exist in ${entry}`);
|
||||
// Each router has a skills/ subdirectory with nested children.
|
||||
const skillsSubdir = path.join(stagedDir, entry, 'skills');
|
||||
assert.ok(fs.existsSync(skillsSubdir), `skills/ subdir must exist in ${entry}`);
|
||||
assert.ok(fs.statSync(skillsSubdir).isDirectory(), `${entry}/skills must be a directory`);
|
||||
}
|
||||
|
||||
// Total SKILL.md files across all routers + nested children must be large (proves no skill was dropped).
|
||||
function countSkillMdFiles(dir) {
|
||||
let count = 0;
|
||||
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
|
||||
const fullPath = path.join(dir, entry.name);
|
||||
if (entry.isDirectory()) count += countSkillMdFiles(fullPath);
|
||||
else if (entry.name === 'SKILL.md') count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
const totalSkillMd = countSkillMdFiles(stagedDir);
|
||||
assert.ok(totalSkillMd >= 60, `full profile should have >= 60 total SKILL.md files (routers + children), got ${totalSkillMd}`);
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
Reference in New Issue
Block a user