Merge pull request #1305 from gsd-build/feat/forensics-1303

feat: add /gsd:forensics — post-mortem workflow investigation
This commit is contained in:
Tom Boucher
2026-03-21 18:30:46 -04:00
committed by GitHub
4 changed files with 581 additions and 2 deletions

View File

@@ -620,7 +620,7 @@ describe('copyCommandsAsCopilotSkills', () => {
// Count gsd-* directories — should be 31
const dirs = fs.readdirSync(tempDir, { withFileTypes: true })
.filter(e => e.isDirectory() && e.name.startsWith('gsd-'));
assert.strictEqual(dirs.length, 55, `expected 55 skill folders, got ${dirs.length}`);
assert.strictEqual(dirs.length, 56, `expected 56 skill folders, got ${dirs.length}`);
} finally {
fs.rmSync(tempDir, { recursive: true });
}
@@ -1114,7 +1114,7 @@ const { execFileSync } = require('child_process');
const crypto = require('crypto');
const INSTALL_PATH = path.join(__dirname, '..', 'bin', 'install.js');
const EXPECTED_SKILLS = 55;
const EXPECTED_SKILLS = 56;
const EXPECTED_AGENTS = 18;
function runCopilotInstall(cwd) {

258
tests/forensics.test.cjs Normal file
View File

@@ -0,0 +1,258 @@
/**
* GSD Forensics Tests
*
* Validates the forensics command and workflow files exist,
* follow expected patterns, and cover all anomaly detection types.
*/
const { test, describe } = require('node:test');
const assert = require('node:assert');
const fs = require('fs');
const path = require('path');
const os = require('os');
const repoRoot = path.resolve(__dirname, '..');
const commandPath = path.join(repoRoot, 'commands', 'gsd', 'forensics.md');
const workflowPath = path.join(repoRoot, 'get-shit-done', 'workflows', 'forensics.md');
describe('forensics command', () => {
test('command file exists', () => {
assert.ok(fs.existsSync(commandPath), 'commands/gsd/forensics.md should exist');
});
test('command has correct frontmatter', () => {
const content = fs.readFileSync(commandPath, 'utf-8');
assert.ok(content.includes('name: gsd:forensics'), 'should have correct command name');
assert.ok(content.includes('type: prompt'), 'should have type: prompt');
assert.ok(content.includes('argument-hint'), 'should have argument-hint');
});
test('command references workflow in execution_context', () => {
const content = fs.readFileSync(commandPath, 'utf-8');
assert.ok(
content.includes('workflows/forensics.md'),
'should reference the forensics workflow'
);
});
test('command has success_criteria section', () => {
const content = fs.readFileSync(commandPath, 'utf-8');
assert.ok(content.includes('<success_criteria>'), 'should have success_criteria');
});
test('command has critical_rules section', () => {
const content = fs.readFileSync(commandPath, 'utf-8');
assert.ok(content.includes('<critical_rules>'), 'should have critical_rules');
});
test('command enforces read-only investigation', () => {
const content = fs.readFileSync(commandPath, 'utf-8');
assert.ok(
content.toLowerCase().includes('read-only') || content.toLowerCase().includes('do not modify'),
'should enforce read-only investigation'
);
});
test('command requires evidence-grounded findings', () => {
const content = fs.readFileSync(commandPath, 'utf-8');
assert.ok(
content.includes('Ground findings') || content.includes('cite specific'),
'should require evidence-grounded analysis'
);
});
});
describe('forensics workflow', () => {
test('workflow file exists', () => {
assert.ok(fs.existsSync(workflowPath), 'workflows/forensics.md should exist');
});
test('workflow gathers evidence from all data sources', () => {
const content = fs.readFileSync(workflowPath, 'utf-8');
const sources = [
'git log',
'git status',
'STATE.md',
'ROADMAP.md',
'PLAN.md',
'SUMMARY.md',
'VERIFICATION.md',
'SESSION_REPORT',
'worktree',
];
for (const source of sources) {
assert.ok(
content.includes(source),
`workflow should reference data source: ${source}`
);
}
});
test('workflow detects all 6 anomaly types', () => {
const content = fs.readFileSync(workflowPath, 'utf-8');
const anomalies = [
'Stuck Loop',
'Missing Artifact',
'Abandoned Work',
'Crash',
'Scope Drift',
'Test Regression',
];
for (const anomaly of anomalies) {
assert.ok(
content.includes(anomaly),
`workflow should detect anomaly: ${anomaly}`
);
}
});
test('workflow writes report to forensics directory', () => {
const content = fs.readFileSync(workflowPath, 'utf-8');
assert.ok(
content.includes('.planning/forensics/report-'),
'should write to .planning/forensics/'
);
});
test('workflow includes redaction rules', () => {
const content = fs.readFileSync(workflowPath, 'utf-8');
assert.ok(
content.includes('Redaction') || content.includes('redact'),
'should include data redaction rules'
);
});
test('workflow offers interactive investigation', () => {
const content = fs.readFileSync(workflowPath, 'utf-8');
assert.ok(
content.includes('dig deeper') || content.includes('Interactive'),
'should offer interactive follow-up'
);
});
test('workflow offers GitHub issue creation', () => {
const content = fs.readFileSync(workflowPath, 'utf-8');
assert.ok(
content.includes('gh issue create'),
'should offer to create GitHub issue from findings'
);
});
test('workflow updates STATE.md', () => {
const content = fs.readFileSync(workflowPath, 'utf-8');
assert.ok(
content.includes('state record-session'),
'should update STATE.md via gsd-tools'
);
});
test('workflow has confidence levels for anomalies', () => {
const content = fs.readFileSync(workflowPath, 'utf-8');
assert.ok(
content.includes('HIGH') && content.includes('MEDIUM') && content.includes('LOW'),
'anomalies should have confidence levels'
);
});
});
describe('forensics report structure', () => {
test('report template has all required sections', () => {
const content = fs.readFileSync(workflowPath, 'utf-8');
const sections = [
'Evidence Summary',
'Git Activity',
'Planning State',
'Artifact Completeness',
'Anomalies Detected',
'Root Cause Hypothesis',
'Recommended Actions',
];
for (const section of sections) {
assert.ok(
content.includes(section),
`report should include section: "${section}"`
);
}
});
test('report includes artifact completeness table', () => {
const content = fs.readFileSync(workflowPath, 'utf-8');
assert.ok(
content.includes('PLAN') && content.includes('CONTEXT') && content.includes('RESEARCH') &&
content.includes('SUMMARY') && content.includes('VERIFICATION'),
'artifact table should check all 5 artifact types'
);
});
});
describe('forensics fixture-based tests', () => {
let tmpDir;
function setup() {
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-forensics-test-'));
}
function teardown() {
if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
}
test('detects missing artifacts in phase structure', () => {
setup();
try {
// Phase 1: complete
const phase1 = path.join(tmpDir, '.planning', 'phases', '01-setup');
fs.mkdirSync(phase1, { recursive: true });
fs.writeFileSync(path.join(phase1, '01-PLAN-A.md'), 'plan');
fs.writeFileSync(path.join(phase1, '01-SUMMARY.md'), 'summary');
fs.writeFileSync(path.join(phase1, '01-VERIFICATION.md'), 'verification');
// Phase 2: missing SUMMARY and VERIFICATION (anomaly)
const phase2 = path.join(tmpDir, '.planning', 'phases', '02-core');
fs.mkdirSync(phase2, { recursive: true });
fs.writeFileSync(path.join(phase2, '02-PLAN-A.md'), 'plan');
// Verify detection
const p1Files = fs.readdirSync(phase1);
const p2Files = fs.readdirSync(phase2);
assert.ok(p1Files.some(f => f.includes('SUMMARY')), 'phase 1 has SUMMARY');
assert.ok(p1Files.some(f => f.includes('VERIFICATION')), 'phase 1 has VERIFICATION');
assert.ok(!p2Files.some(f => f.includes('SUMMARY')), 'phase 2 missing SUMMARY (anomaly)');
assert.ok(!p2Files.some(f => f.includes('VERIFICATION')), 'phase 2 missing VERIFICATION (anomaly)');
} finally {
teardown();
}
});
test('forensics report directory can be created', () => {
setup();
try {
const forensicsDir = path.join(tmpDir, '.planning', 'forensics');
fs.mkdirSync(forensicsDir, { recursive: true });
const reportPath = path.join(forensicsDir, 'report-20260321-150000.md');
fs.writeFileSync(reportPath, '# Forensic Report\n');
assert.ok(fs.existsSync(reportPath), 'report file should be created');
const content = fs.readFileSync(reportPath, 'utf-8');
assert.ok(content.includes('Forensic Report'), 'report should have header');
} finally {
teardown();
}
});
test('handles project with no .planning directory', () => {
setup();
try {
// No .planning/ at all
const planningExists = fs.existsSync(path.join(tmpDir, '.planning'));
assert.strictEqual(planningExists, false, 'no .planning/ should exist');
// Forensics should still work with git data
const forensicsDir = path.join(tmpDir, '.planning', 'forensics');
fs.mkdirSync(forensicsDir, { recursive: true });
assert.ok(fs.existsSync(forensicsDir), 'forensics dir created on demand');
} finally {
teardown();
}
});
});