@assistkick/create 1.0.0

package/templates/product-system/smoke_test.ts

@@ -0,0 +1,219 @@
+/**
+ * Smoke test: require all lib modules, verify exports exist and work.
+ */
+
+import {
+  NODE_TYPES,
+  REQUIRED_SECTIONS,
+  VALID_RELATIONS,
+  VALID_STATUSES,
+  VALID_PRIORITIES,
+  SCORING_RULES,
+  COMMON_OPTIONAL_SECTIONS,
+} from './packages/shared/lib/constants.js';
+
+import {
+  readGraph,
+  writeGraph,
+  patchNode,
+  addEdge,
+  removeEdge,
+  nodeExists,
+  getNode,
+  getProjectRoot,
+} from './packages/shared/lib/graph.js';
+
+import {
+  readNode,
+  writeNode,
+  getSection,
+  setSection,
+  appendToSection,
+  moveLineAcrossSections,
+  deriveMetadata,
+  templateSections,
+} from './packages/shared/lib/markdown.js';
+
+import { scoreNode } from './packages/shared/lib/completeness.js';
+
+import {
+  assertNodeExists,
+  assertValidType,
+  assertValidRelation,
+  assertNoDuplicateEdge,
+  assertNoCycle,
+  assertUniqueName,
+} from './packages/shared/lib/validator.js';
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition, message) {
+  if (condition) {
+    passed++;
+  } else {
+    failed++;
+    console.error(`FAIL: ${message}`);
+  }
+}
+
+// --- constants.js ---
+assert(typeof NODE_TYPES === 'object', 'NODE_TYPES is an object');
+assert(Object.keys(NODE_TYPES).length === 12, 'NODE_TYPES has 12 types');
+assert(NODE_TYPES.feature === 'feat', 'feature prefix is feat');
+assert(NODE_TYPES.decision === 'dec', 'decision prefix is dec');
+assert(NODE_TYPES.open_question === 'oq', 'open_question prefix is oq');
+
+assert(Array.isArray(VALID_RELATIONS), 'VALID_RELATIONS is an array');
+assert(VALID_RELATIONS.includes('depends_on'), 'depends_on is a valid relation');
+assert(VALID_RELATIONS.includes('governed_by'), 'governed_by is a valid relation');
+assert(VALID_RELATIONS.length === 11, 'VALID_RELATIONS has 11 relations');
+
+assert(REQUIRED_SECTIONS.feature.includes('Description'), 'feature requires Description');
+assert(REQUIRED_SECTIONS.feature.includes('Acceptance Criteria'), 'feature requires Acceptance Criteria');
+assert(REQUIRED_SECTIONS.component.includes('Responsibilities'), 'component requires Responsibilities');
+
+assert(VALID_STATUSES.includes('draft'), 'draft is a valid status');
+assert(VALID_STATUSES.includes('defined'), 'defined is a valid status');
+
+assert(VALID_PRIORITIES.includes('blocking'), 'blocking is a valid priority');
+
+assert(typeof SCORING_RULES.feature === 'object', 'feature has scoring rules');
+assert(SCORING_RULES.feature.length === 4, 'feature has 4 scoring rules');
+
+// Verify scoring weights sum to 1.0 for each type
+for (const [type, rules] of Object.entries(SCORING_RULES)) {
+  const sum = rules.reduce((s, r) => s + r.weight, 0);
+  assert(Math.abs(sum - 1.0) < 0.01, `${type} scoring weights sum to ~1.0 (got ${sum})`);
+}
+
+// --- graph.js ---
+assert(typeof readGraph === 'function', 'readGraph is a function');
+assert(typeof writeGraph === 'function', 'writeGraph is a function');
+assert(typeof patchNode === 'function', 'patchNode is a function');
+assert(typeof addEdge === 'function', 'addEdge is a function');
+assert(typeof removeEdge === 'function', 'removeEdge is a function');
+assert(typeof nodeExists === 'function', 'nodeExists is a function');
+assert(typeof getNode === 'function', 'getNode is a function');
+assert(typeof getProjectRoot === 'function', 'getProjectRoot is a function');
+
+// Test reading a non-existent graph returns empty structure
+const emptyGraph = readGraph();
+assert(emptyGraph.version === '1.0', 'empty graph has version 1.0');
+assert(Array.isArray(emptyGraph.nodes), 'empty graph has nodes array');
+assert(Array.isArray(emptyGraph.edges), 'empty graph has edges array');
+assert(emptyGraph.nodes.length === 0, 'empty graph has no nodes');
+
+// --- markdown.js ---
+assert(typeof readNode === 'function', 'readNode is a function');
+assert(typeof writeNode === 'function', 'writeNode is a function');
+assert(typeof getSection === 'function', 'getSection is a function');
+assert(typeof setSection === 'function', 'setSection is a function');
+assert(typeof appendToSection === 'function', 'appendToSection is a function');
+assert(typeof moveLineAcrossSections === 'function', 'moveLineAcrossSections is a function');
+assert(typeof deriveMetadata === 'function', 'deriveMetadata is a function');
+assert(typeof templateSections === 'function', 'templateSections is a function');
+
+// Test templateSections
+const featSections = templateSections('feature');
+assert('Description' in featSections, 'feature template has Description');
+assert('Acceptance Criteria' in featSections, 'feature template has Acceptance Criteria');
+assert('Open Questions' in featSections, 'feature template has Open Questions');
+assert('Resolved Questions' in featSections, 'feature template has Resolved Questions (optional)');
+
+// --- completeness.js ---
+assert(typeof scoreNode === 'function', 'scoreNode is a function');
+
+// Test scoring with empty sections — only "no open questions" passes (+0.3)
+const emptyScore = scoreNode('feature', { status: 'draft' }, {});
+assert(emptyScore === 0.3, `empty feature scores 0.3 (got ${emptyScore})`);
+
+// Test scoring with partial content (desc + AC + has open questions = 0.2 + 0.3 = 0.5)
+const partialScore = scoreNode('feature', { status: 'draft' }, {
+  'Description': 'This is a long enough description that should pass the fifty character check easily.',
+  'Acceptance Criteria': '- Must work correctly',
+  'Open Questions': '- [ ] What about edge cases?',
+});
+assert(partialScore === 0.5, `partial feature scores 0.5 (got ${partialScore})`);
+
+// Test scoring with full content
+const fullScore = scoreNode('feature', { status: 'defined' }, {
+  'Description': 'This is a long enough description that should pass the fifty character check easily.',
+  'Acceptance Criteria': '- Must work correctly',
+  'Open Questions': '',
+});
+assert(fullScore === 1.0, `full feature scores 1.0 (got ${fullScore})`);
+
+// --- validator.js ---
+assert(typeof assertNodeExists === 'function', 'assertNodeExists is a function');
+assert(typeof assertValidType === 'function', 'assertValidType is a function');
+assert(typeof assertValidRelation === 'function', 'assertValidRelation is a function');
+assert(typeof assertNoDuplicateEdge === 'function', 'assertNoDuplicateEdge is a function');
+assert(typeof assertNoCycle === 'function', 'assertNoCycle is a function');
+assert(typeof assertUniqueName === 'function', 'assertUniqueName is a function');
+
+// Test assertValidType
+try {
+  assertValidType('feature');
+  passed++;
+} catch {
+  failed++;
+  console.error('FAIL: assertValidType should accept feature');
+}
+
+try {
+  assertValidType('invalid_type');
+  failed++;
+  console.error('FAIL: assertValidType should reject invalid_type');
+} catch {
+  passed++;
+}
+
+// Test assertValidRelation
+try {
+  assertValidRelation('depends_on');
+  passed++;
+} catch {
+  failed++;
+  console.error('FAIL: assertValidRelation should accept depends_on');
+}
+
+try {
+  assertValidRelation('invalid_relation');
+  failed++;
+  console.error('FAIL: assertValidRelation should reject invalid_relation');
+} catch {
+  passed++;
+}
+
+// Test section manipulation
+const testSections = { 'Open Questions': '- [ ] Question 1\n- [ ] Question 2' };
+setSection(testSections, 'Notes', 'Some notes');
+assert(testSections['Notes'] === 'Some notes', 'setSection works');
+
+appendToSection(testSections, 'Notes', 'More notes');
+assert(testSections['Notes'] === 'Some notes\nMore notes', 'appendToSection works');
+
+const moved = moveLineAcrossSections(testSections, 'Open Questions', 'Resolved Questions', 'Question 1');
+assert(moved === true, 'moveLineAcrossSections returns true on match');
+assert(!testSections['Open Questions'].includes('Question 1'), 'line removed from source');
+assert(testSections['Resolved Questions'].includes('Question 1'), 'line added to target');
+
+// Test deriveMetadata
+const meta = deriveMetadata({ status: 'draft' }, {
+  'Description': 'This is a long enough description that should pass the fifty character check easily.',
+  'Acceptance Criteria': '- Must work correctly',
+  'Open Questions': '- [ ] Unanswered question',
+}, 'feature');
+assert(meta.completeness === 0.5, `deriveMetadata completeness is 0.5 (got ${meta.completeness})`);
+assert(meta.open_questions_count === 1, `deriveMetadata oq count is 1 (got ${meta.open_questions_count})`);
+assert(meta.status === 'partially_defined', `deriveMetadata status is partially_defined (got ${meta.status})`);
+
+// Summary
+console.log(`\n${'='.repeat(40)}`);
+console.log(`Smoke test results: ${passed} passed, ${failed} failed`);
+console.log(`${'='.repeat(40)}`);
+
+if (failed > 0) {
+  process.exit(1);
+}