specdrive-cli 0.1.0

package/scripts/test-adapters.js

@@ -0,0 +1,128 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const projectRoot = process.cwd();
+const generatorPath = path.join(projectRoot, ".sdrive", "scripts", "generate-adapters.js");
+
+function testGeneratorCreatesAdapters() {
+  console.log("\n🧪 Test 1: Generator creates all adapters");
+
+  try {
+    execSync(`node "${generatorPath}"`, { stdio: "pipe" });
+  } catch (error) {
+    console.log("❌ FAIL: Generator failed.");
+    return false;
+  }
+
+  const expectedAdapters = [
+    ".github/copilot-instructions.md",
+    ".clinerules/sdrive.md",
+    ".claude/commands/sdrive.md",
+    ".cursor/rules/sdrive.md",
+    ".vscode/sdrive-commands.json"
+  ];
+
+  for (const adapter of expectedAdapters) {
+    const fullPath = path.join(projectRoot, adapter);
+    if (fs.existsSync(fullPath)) {
+      console.log(`  ✅ Found: ${adapter}`);
+    } else {
+      console.log(`  ❌ Missing: ${adapter}`);
+      return false;
+    }
+  }
+
+  console.log("✅ PASS: All adapters created.");
+  return true;
+}
+
+function testAdapterContent() {
+  console.log("\n🧪 Test 2: Adapter content includes SpecDrive instructions");
+
+  const adapterPath = path.join(projectRoot, ".github", "copilot-instructions.md");
+
+  if (!fs.existsSync(adapterPath)) {
+    console.log("❌ FAIL: Copilot adapter missing.");
+    return false;
+  }
+
+  const content = fs.readFileSync(adapterPath, "utf8");
+
+  if (content.includes(".sdrive/commands/manifest.json")) {
+    console.log("✅ PASS: Adapter contains manifest reference.");
+    return true;
+  }
+
+  console.log("❌ FAIL: Adapter missing manifest reference.");
+  return false;
+}
+
+function testSafetyRule() {
+  console.log("\n🧪 Test 3: Generator does not overwrite existing files");
+
+  const adapterPath = path.join(projectRoot, ".github", "copilot-instructions.md");
+
+  // Modify the file
+  fs.writeFileSync(adapterPath, "# Custom existing file\n", "utf8");
+
+  // Run generator
+  try {
+    execSync(`node "${generatorPath}"`, { stdio: "pipe" });
+  } catch (error) {
+    console.log("❌ FAIL: Generator failed.");
+    return false;
+  }
+
+  // Check content was not overwritten
+  const content = fs.readFileSync(adapterPath, "utf8");
+
+  if (content === "# Custom existing file\n") {
+    console.log("✅ PASS: Existing file was not overwritten.");
+    return true;
+  }
+
+  console.log("❌ FAIL: Existing file was overwritten.");
+  return false;
+}
+
+function cleanup() {
+  const adapters = [
+    ".github/copilot-instructions.md",
+    ".clinerules/sdrive.md",
+    ".claude/commands/sdrive.md",
+    ".cursor/rules/sdrive.md",
+    ".vscode/sdrive-commands.json"
+  ];
+
+  adapters.forEach((adapter) => {
+    const fullPath = path.join(projectRoot, adapter);
+    if (fs.existsSync(fullPath)) {
+      fs.rmSync(fullPath, { force: true });
+    }
+  });
+
+  console.log("\n🧹 Cleaned up adapters.");
+}
+
+function main() {
+  console.log("=== SpecDrive Adapter Tests ===\n");
+
+  let allPassed = true;
+
+  allPassed &= testGeneratorCreatesAdapters();
+  allPassed &= testAdapterContent();
+  allPassed &= testSafetyRule();
+
+  cleanup();
+
+  if (allPassed) {
+    console.log("\n✅ All adapter tests passed.");
+    process.exit(0);
+  } else {
+    console.log("\n❌ Some adapter tests failed.");
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/test-create.js

@@ -0,0 +1,14 @@
+const { execSync } = require("child_process");
+const path = require("path");
+
+const projectRoot = process.cwd();
+
+try {
+  execSync(`node ${path.join(projectRoot, ".sdrive", "src", "index.js")} create test-feature`, {
+    stdio: "inherit"
+  });
+  process.exit(0);
+} catch (error) {
+  console.error("Feature creation failed.");
+  process.exit(1);
+}

package/scripts/test-end-to-end.js

@@ -0,0 +1,141 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const projectRoot = process.cwd();
+
+function runCommand(command) {
+  try {
+    execSync(command, { stdio: "pipe" });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function resetEnvironment() {
+  console.log("🧹 Resetting test environment...");
+
+  const specDir = path.join(projectRoot, ".sdrive", "specs", "backlog", "test-feature");
+  const govDir = path.join(projectRoot, ".sdrive", "governance", "test-feature");
+
+  if (fs.existsSync(specDir)) {
+    fs.rmSync(specDir, { recursive: true, force: true });
+  }
+  if (fs.existsSync(govDir)) {
+    fs.rmSync(govDir, { recursive: true, force: true });
+  }
+
+  const workflowStatePath = path.join(projectRoot, ".sdrive", "workflow-state.json");
+  fs.writeFileSync(
+    workflowStatePath,
+    JSON.stringify({ features: [] }, null, 2)
+  );
+}
+
+function testFeatureCreation() {
+  console.log("\n🧪 Test 1: Feature creation");
+
+  const passed = runCommand(`node .sdrive/scripts/test-create.js`);
+
+  if (passed) {
+    console.log("✅ PASS: Feature created.");
+    return true;
+  }
+
+  console.log("❌ FAIL: Feature creation failed.");
+  return false;
+}
+
+function testSpecGeneration() {
+  console.log("\n🧪 Test 2: Spec generation");
+
+  const specPath = path.join(projectRoot, ".sdrive", "specs", "backlog", "test-feature", "spec.md");
+  const govPath = path.join(projectRoot, ".sdrive", "governance", "test-feature", "spec.json");
+
+  const specExists = fs.existsSync(specPath);
+  const govExists = fs.existsSync(govPath);
+
+  if (specExists && govExists) {
+    console.log("✅ PASS: Spec and governance files exist.");
+    return true;
+  }
+
+  console.log("❌ FAIL: Spec or governance files missing.");
+  return false;
+}
+
+function testTraceabilityGenerated() {
+  console.log("\n🧪 Test 3: Traceability matrix generated");
+
+  const tracePath = path.join(projectRoot, ".sdrive", "governance", "test-feature", "traceability.json");
+
+  if (fs.existsSync(tracePath)) {
+    console.log("✅ PASS: Traceability matrix exists.");
+    return true;
+  }
+
+  console.log("❌ FAIL: Traceability matrix missing.");
+  return false;
+}
+
+function testValidationPasses() {
+  console.log("\n🧪 Test 4: Governance validation passes");
+
+  const passed = runCommand("node .sdrive/scripts/validate-governance.js");
+
+  if (passed) {
+    console.log("✅ PASS: Governance validation passed.");
+    return true;
+  }
+
+  console.log("❌ FAIL: Governance validation failed.");
+  return false;
+}
+
+function testWorkflowState() {
+  console.log("\n🧪 Test 5: Workflow state updated");
+
+  const workflowStatePath = path.join(projectRoot, ".sdrive", "workflow-state.json");
+
+  if (!fs.existsSync(workflowStatePath)) {
+    console.log("❌ FAIL: workflow-state.json missing.");
+    return false;
+  }
+
+  const state = JSON.parse(fs.readFileSync(workflowStatePath, "utf8"));
+
+  if (state.features && Array.isArray(state.features)) {
+    console.log("✅ PASS: Workflow state has features array.");
+    return true;
+  }
+
+  console.log("❌ FAIL: Workflow state invalid.");
+  return false;
+}
+
+function main() {
+  console.log("=== SpecDrive End-to-End Tests ===\n");
+
+  resetEnvironment();
+
+  let allPassed = true;
+
+  allPassed &= testFeatureCreation();
+  allPassed &= testSpecGeneration();
+  allPassed &= testTraceabilityGenerated();
+  allPassed &= testValidationPasses();
+  allPassed &= testWorkflowState();
+
+  resetEnvironment();
+
+  if (allPassed) {
+    console.log("\n✅ All end-to-end tests passed.");
+    process.exit(0);
+  } else {
+    console.log("\n❌ Some end-to-end tests failed.");
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/test-router.js

@@ -0,0 +1,105 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const projectRoot = process.cwd();
+const routerPath = path.join(projectRoot, ".sdrive", "commands", "router.js");
+
+function runRouter(command, feature) {
+  try {
+    const args = feature ? ` ${feature}` : "";
+    execSync(`node "${routerPath}" ${command}${args}`, { stdio: "pipe" });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function testKnownCommand() {
+  console.log("\n🧪 Test 1: Known command should pass");
+  const passed = runRouter("/sdrive:constitution");
+
+  if (passed) {
+    console.log("✅ PASS: Router accepted /sdrive:constitution.");
+    return true;
+  }
+
+  console.log("❌ FAIL: Router rejected /sdrive:constitution.");
+  return false;
+}
+
+function testUnknownCommand() {
+  console.log("\n🧪 Test 2: Unknown command should fail");
+  const passed = runRouter("/sdrive:unknown");
+
+  if (!passed) {
+    console.log("✅ PASS: Router rejected unknown command.");
+    return true;
+  }
+
+  console.log("❌ FAIL: Router accepted unknown command.");
+  return false;
+}
+
+function testMissingFeatureForGatedCommand() {
+  console.log("\n🧪 Test 3: Gated command without feature should fail");
+
+  // /sdrive:propose has gates
+  const passed = runRouter("/sdrive:propose");
+
+  if (!passed) {
+    console.log("✅ PASS: Router blocked gated command without feature.");
+    return true;
+  }
+
+  console.log("❌ FAIL: Router allowed gated command without feature.");
+  return false;
+}
+
+function testFeatureConversion() {
+  console.log("\n🧪 Test 4: Natural feature description should convert to kebab-case");
+
+  // Test the function indirectly by checking output
+  const { execSync } = require("child_process");
+  try {
+    const output = execSync(
+      `node "${routerPath}" /sdrive:propose "User login with email"`,
+      { stdio: "pipe", encoding: "utf8" }
+    );
+    if (output.includes("user-login-with-email")) {
+      console.log("✅ PASS: Feature converted to kebab-case.");
+      return true;
+    }
+    console.log("❌ FAIL: Feature not converted correctly.");
+    return false;
+  } catch (error) {
+    // Command may fail due to gate, but conversion should still show
+    if (error.stdout && error.stdout.includes("user-login-with-email")) {
+      console.log("✅ PASS: Feature converted to kebab-case.");
+      return true;
+    }
+    console.log("❌ FAIL: Feature not converted correctly.");
+    return false;
+  }
+}
+
+function main() {
+  console.log("=== SpecDrive Router Tests ===\n");
+
+  let allPassed = true;
+
+  allPassed &= testKnownCommand();
+  allPassed &= testUnknownCommand();
+  allPassed &= testMissingFeatureForGatedCommand();
+  allPassed &= testFeatureConversion();
+
+  if (allPassed) {
+    console.log("\n✅ All router tests passed.");
+    process.exit(0);
+  } else {
+    console.log("\n❌ Some router tests failed.");
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/test-state-transitions.js

@@ -0,0 +1,148 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const projectRoot = process.cwd();
+const workflowStatePath = path.join(projectRoot, ".sdrive", "workflow-state.json");
+const gatesPath = path.join(projectRoot, ".sdrive", "commands", "gates.js");
+
+function resetState() {
+  const initialState = {
+    features: [
+      {
+        name: "test-feature",
+        phase: "backlog",
+        currentStep: "specification",
+        gates: {
+          specification: "pending",
+          planning: "pending",
+          implementation: "pending",
+          review: "pending"
+        },
+        history: [
+          {
+            event: "feature_created",
+            timestamp: new Date().toISOString()
+          }
+        ]
+      }
+    ]
+  };
+
+  fs.writeFileSync(workflowStatePath, JSON.stringify(initialState, null, 2));
+}
+
+function readState() {
+  return JSON.parse(fs.readFileSync(workflowStatePath, "utf8"));
+}
+
+function approveGate(gate) {
+  try {
+    execSync(`node ${path.join(projectRoot, ".sdrive", "src", "index.js")} approve ${gate}`, {
+      stdio: "pipe"
+    });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function testInitialState() {
+  console.log("\n🧪 Test 1: Initial state should be pending");
+  resetState();
+  const state = readState();
+  const feature = state.features[0];
+
+  if (
+    feature.gates.specification === "pending" &&
+    feature.gates.planning === "pending" &&
+    feature.gates.implementation === "pending" &&
+    feature.gates.review === "pending"
+  ) {
+    console.log("✅ PASS: All gates are pending initially.");
+    return true;
+  }
+
+  console.log("❌ FAIL: Initial gates are not pending.");
+  return false;
+}
+
+function testGateApproval() {
+  console.log("\n🧪 Test 2: Gate approval should update state");
+  resetState();
+
+  const passed = approveGate("specification");
+
+  if (!passed) {
+    console.log("❌ FAIL: Could not approve gate.");
+    return false;
+  }
+
+  const state = readState();
+  const feature = state.features[0];
+
+  if (feature.gates.specification === "approved") {
+    console.log("✅ PASS: specification gate approved.");
+    return true;
+  }
+
+  console.log("❌ FAIL: specification gate not approved.");
+  return false;
+}
+
+function testInvalidGate() {
+  console.log("\n🧪 Test 3: Invalid gate should be rejected");
+  resetState();
+
+  try {
+    execSync(`node ${path.join(projectRoot, ".sdrive", "src", "index.js")} approve invalid-gate`, {
+      stdio: "pipe"
+    });
+    console.log("❌ FAIL: Invalid gate was accepted.");
+    return false;
+  } catch (error) {
+    console.log("✅ PASS: Invalid gate was rejected.");
+    return true;
+  }
+}
+
+function testHistory() {
+  console.log("\n🧪 Test 4: History should record approvals");
+  resetState();
+
+  approveGate("specification");
+
+  const state = readState();
+  const feature = state.features[0];
+
+  if (feature.history.some((event) => event.event === "specification_approved")) {
+    console.log("✅ PASS: History recorded approval.");
+    return true;
+  }
+
+  console.log("❌ FAIL: History did not record approval.");
+  return false;
+}
+
+function main() {
+  console.log("=== SpecDrive State Transition Tests ===\n");
+
+  let allPassed = true;
+
+  allPassed &= testInitialState();
+  allPassed &= testGateApproval();
+  allPassed &= testInvalidGate();
+  allPassed &= testHistory();
+
+  resetState();
+
+  if (allPassed) {
+    console.log("\n✅ All state transition tests passed.");
+    process.exit(0);
+  } else {
+    console.log("\n❌ Some state transition tests failed.");
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/test-validator.js

@@ -0,0 +1,148 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const projectRoot = process.cwd();
+const govDir = path.join(projectRoot, ".sdrive", "governance", "test-feature");
+const validatorPath = path.join(projectRoot, ".sdrive", "scripts", "validate-governance.js");
+
+function createValidFiles() {
+  fs.mkdirSync(govDir, { recursive: true });
+
+  fs.writeFileSync(
+    path.join(govDir, "spec.json"),
+    JSON.stringify(
+      {
+        feature: "test-feature",
+        version: 1,
+        overview: {
+          problemStatement: "Test problem",
+          proposedSolution: "Test solution",
+          targetAudience: "Test users"
+        },
+        userStories: [
+          {
+            id: "US-001",
+            title: "Test story",
+            acceptanceCriteria: [
+              {
+                id: "AC-001",
+                text: "Given test, when test, then test"
+              }
+            ]
+          }
+        ],
+        functionalRequirements: [
+          {
+            id: "FR-001",
+            text: "The system MUST test"
+          }
+        ]
+      },
+      null,
+      2
+    )
+  );
+
+  fs.writeFileSync(
+    path.join(govDir, "traceability.json"),
+    JSON.stringify(
+      {
+        feature: "test-feature",
+        version: 1,
+        rows: [
+          {
+            requirementId: "FR-001",
+            acceptanceCriteriaIds: ["AC-001"],
+            status: "not_started"
+          }
+        ]
+      },
+      null,
+      2
+    )
+  );
+}
+
+function createInvalidFiles() {
+  fs.writeFileSync(
+    path.join(govDir, "spec.json"),
+    JSON.stringify(
+      {
+        feature: "test-feature",
+        version: 1,
+        overview: {},
+        userStories: []
+      },
+      null,
+      2
+    )
+  );
+}
+
+function runValidator() {
+  try {
+    execSync(`node "${validatorPath}"`, { stdio: "pipe" });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function testValidFiles() {
+  console.log("\n🧪 Test 1: Valid governance files should pass");
+  createValidFiles();
+
+  const passed = runValidator();
+
+  if (passed) {
+    console.log("✅ PASS: Validator accepted valid files.");
+  } else {
+    console.log("❌ FAIL: Validator rejected valid files.");
+  }
+
+  return passed;
+}
+
+function testInvalidFiles() {
+  console.log("\n🧪 Test 2: Invalid governance files should fail");
+  createInvalidFiles();
+
+  const passed = runValidator();
+
+  if (!passed) {
+    console.log("✅ PASS: Validator rejected invalid files.");
+  } else {
+    console.log("❌ FAIL: Validator accepted invalid files.");
+  }
+
+  return !passed;
+}
+
+function cleanup() {
+  if (fs.existsSync(govDir)) {
+    fs.rmSync(govDir, { recursive: true, force: true });
+  }
+  console.log("\n🧹 Cleaned up test files.");
+}
+
+function main() {
+  console.log("=== SpecDrive Validator Tests ===\n");
+
+  let allPassed = true;
+
+  allPassed &= testValidFiles();
+  allPassed &= testInvalidFiles();
+
+  cleanup();
+
+  if (allPassed) {
+    console.log("\n✅ All validator tests passed.");
+    process.exit(0);
+  } else {
+    console.log("\n❌ Some validator tests failed.");
+    process.exit(1);
+  }
+}
+
+main();