specdrive-cli 0.1.2 → 0.1.8

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

@@ -27,10 +27,7 @@ function resetEnvironment() {
   }
 
   const workflowStatePath = path.join(projectRoot, ".sdrive", "workflow-state.json");
-  fs.writeFileSync(
-    workflowStatePath,
-    JSON.stringify({ features: [] }, null, 2)
-  );
+  fs.writeFileSync(workflowStatePath, JSON.stringify({ features: [] }, null, 2));
 }
 
 function testFeatureCreation() {

package/scripts/test-router.js

@@ -17,6 +17,7 @@ function runRouter(command, feature) {
 
 function testKnownCommand() {
   console.log("\n🧪 Test 1: Known command should pass");
+
   const passed = runRouter("/sdrive:constitution");
 
   if (passed) {
@@ -30,6 +31,7 @@ function testKnownCommand() {
 
 function testUnknownCommand() {
   console.log("\n🧪 Test 2: Unknown command should fail");
+
   const passed = runRouter("/sdrive:unknown");
 
   if (!passed) {
@@ -44,7 +46,6 @@ function testUnknownCommand() {
 function testMissingFeatureForGatedCommand() {
   console.log("\n🧪 Test 3: Gated command without feature should fail");
 
-  // /sdrive:propose has gates
   const passed = runRouter("/sdrive:propose");
 
   if (!passed) {
@@ -59,25 +60,30 @@ function testMissingFeatureForGatedCommand() {
 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;
     }
+
+    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;
   }

package/scripts/test-state-transitions.js

@@ -4,7 +4,6 @@ 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 = {

package/scripts/test-validator.js

@@ -14,16 +14,20 @@ function createValidFiles() {
     JSON.stringify(
       {
         feature: "test-feature",
+        title: "Test Feature",
         version: 1,
         overview: {
-          problemStatement: "Test problem",
-          proposedSolution: "Test solution",
+          problemStatement: "Test problem statement",
+          proposedSolution: "Test proposed solution",
           targetAudience: "Test users"
         },
         userStories: [
           {
             id: "US-001",
             title: "Test story",
+            role: "user",
+            want: "test",
+            benefit: "test",
             acceptanceCriteria: [
               {
                 id: "AC-001",
@@ -54,6 +58,7 @@ function createValidFiles() {
           {
             requirementId: "FR-001",
             acceptanceCriteriaIds: ["AC-001"],
+            taskIds: ["T1.1"],
             status: "not_started"
           }
         ]

package/scripts/validate-governance.js

@@ -4,24 +4,13 @@ const path = require("path");
 
 const ajv = new Ajv({ allErrors: true });
 
-// ---------- Resolve project root ----------
 const projectRoot = path.join(__dirname, "..", "..");
 
-// ---------- Load schemas ----------
 const schemaDir = path.join(projectRoot, ".sdrive", "schemas");
 const governanceDir = path.join(projectRoot, ".sdrive", "governance");
 const specsDir = path.join(projectRoot, ".sdrive", "specs");
 const workflowStatePath = path.join(projectRoot, ".sdrive", "workflow-state.json");
 
-const schemas = {
-  spec: loadJson(path.join(schemaDir, "spec.schema.json")),
-  plan: loadJson(path.join(schemaDir, "plan.schema.json")),
-  tasks: loadJson(path.join(schemaDir, "tasks.schema.json")),
-  traceability: loadJson(path.join(schemaDir, "traceability.schema.json")),
-  workflowState: loadJson(path.join(schemaDir, "workflow-state.schema.json")),
-};
-
-// ---------- Helper functions ----------
 function loadJson(filePath) {
   if (!fs.existsSync(filePath)) {
     console.error(`❌ Schema/file not found: ${filePath}`);
@@ -33,6 +22,7 @@ function loadJson(filePath) {
 function validateData(data, schema, label) {
   const validate = ajv.compile(schema);
   const valid = validate(data);
+
   if (valid) {
     console.log(`✅ ${label} is valid.`);
     return true;
@@ -43,21 +33,20 @@ function validateData(data, schema, label) {
   }
 }
 
-function featureExists(featureName) {
-  return fs.existsSync(path.join(governanceDir, featureName));
-}
-
 function validateWorkflowState() {
   if (!fs.existsSync(workflowStatePath)) {
     console.log("⚠️  workflow-state.json not found. Skipping.");
     return true;
   }
-  const workflowState = loadJson(workflowStatePath);
-  return validateData(workflowState, schemas.workflowState, "workflow-state.json");
+
+  const schema = loadJson(path.join(schemaDir, "workflow-state.schema.json"));
+  const data = loadJson(workflowStatePath);
+  return validateData(data, schema, "workflow-state.json");
 }
 
 function validateFeature(featureName) {
   const featureDir = path.join(governanceDir, featureName);
+
   if (!fs.existsSync(featureDir)) {
     console.log(`⚠️  Feature "${featureName}" has no governance folder. Skipping.`);
     return true;
@@ -65,41 +54,26 @@ function validateFeature(featureName) {
 
   let failed = false;
 
-  // Validate spec.json
-  const specPath = path.join(featureDir, "spec.json");
-  if (fs.existsSync(specPath)) {
-    const specData = loadJson(specPath);
-    failed |= !validateData(specData, schemas.spec, `${featureName}/spec.json`);
-  } else {
-    console.log(`⚠️  ${featureName}/spec.json not found. Skipping.`);
-  }
+  const files = [
+    { file: "spec.json", schema: "spec.schema.json" },
+    { file: "plan.json", schema: "plan.schema.json" },
+    { file: "tasks.json", schema: "tasks.schema.json" },
+    { file: "traceability.json", schema: "traceability.schema.json" }
+  ];
 
-  // Validate plan.json
-  const planPath = path.join(featureDir, "plan.json");
-  if (fs.existsSync(planPath)) {
-    const planData = loadJson(planPath);
-    failed |= !validateData(planData, schemas.plan, `${featureName}/plan.json`);
-  } else {
-    console.log(`⚠️  ${featureName}/plan.json not found. Skipping.`);
-  }
+  files.forEach(({ file, schema }) => {
+    const filePath = path.join(featureDir, file);
+    const schemaPath = path.join(schemaDir, schema);
 
-  // Validate tasks.json
-  const tasksPath = path.join(featureDir, "tasks.json");
-  if (fs.existsSync(tasksPath)) {
-    const tasksData = loadJson(tasksPath);
-    failed |= !validateData(tasksData, schemas.tasks, `${featureName}/tasks.json`);
-  } else {
-    console.log(`⚠️  ${featureName}/tasks.json not found. Skipping.`);
-  }
+    if (!fs.existsSync(filePath)) {
+      console.log(`⚠️  ${featureName}/${file} not found. Skipping.`);
+      return;
+    }
 
-  // Validate traceability.json
-  const traceabilityPath = path.join(featureDir, "traceability.json");
-  if (fs.existsSync(traceabilityPath)) {
-    const traceData = loadJson(traceabilityPath);
-    failed |= !validateData(traceData, schemas.traceability, `${featureName}/traceability.json`);
-  } else {
-    console.log(`⚠️  ${featureName}/traceability.json not found. Skipping.`);
-  }
+    const data = loadJson(filePath);
+    const schemaData = loadJson(schemaPath);
+    failed |= !validateData(data, schemaData, `${featureName}/${file}`);
+  });
 
   return !failed;
 }
@@ -107,53 +81,44 @@ function validateFeature(featureName) {
 function discoverFeatures() {
   const features = new Set();
 
-  // From governance folder
   if (fs.existsSync(governanceDir)) {
-    const dirs = fs.readdirSync(governanceDir, { withFileTypes: true })
+    fs.readdirSync(governanceDir, { withFileTypes: true })
       .filter((d) => d.isDirectory())
-      .map((d) => d.name);
-    dirs.forEach((d) => features.add(d));
+      .forEach((d) => features.add(d.name));
   }
 
-  // From specs folder
-  const lifecycleFolders = ["backlog", "ongoing", "completed"];
-  lifecycleFolders.forEach((lifecycle) => {
+  ["backlog", "ongoing", "completed"].forEach((lifecycle) => {
     const lifecyclePath = path.join(specsDir, lifecycle);
     if (fs.existsSync(lifecyclePath)) {
-      const dirs = fs.readdirSync(lifecyclePath, { withFileTypes: true })
+      fs.readdirSync(lifecyclePath, { withFileTypes: true })
         .filter((d) => d.isDirectory())
-        .map((d) => d.name);
-      dirs.forEach((d) => features.add(d));
+        .forEach((d) => features.add(d.name));
     }
   });
 
   return Array.from(features);
 }
 
-// ---------- Main ----------
 function main() {
   console.log("🔍 SpecDrive Governance Validation\n");
 
   let failed = false;
 
-  // Validate workflow state
   failed |= !validateWorkflowState();
 
-  // Discover features
   const features = discoverFeatures();
 
   if (features.length === 0) {
     console.log("⚠️  No features found under .sdrive/governance or .sdrive/specs.");
   }
 
-  // Validate each feature
   features.forEach((feature) => {
     console.log(`\n📁 Validating feature: ${feature}`);
     failed |= !validateFeature(feature);
   });
 
-  // Final summary
   console.log("\n----------------------------------------");
+
   if (failed) {
     console.log("❌ Validation FAILED. Fix the errors above.");
     process.exit(1);

package/src/index.js

@@ -4,6 +4,7 @@ const { Command } = require("commander");
 const { execSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
+const readline = require("readline");
 
 const program = new Command();
 
@@ -12,6 +13,26 @@ program
   .description("SpecDrive Enterprise Spec-Driven Development CLI")
   .version("0.1.0");
 
+function adapterContent(toolName) {
+  return `# SpecDrive Commands
+
+This project uses SpecDrive for spec-driven development.
+
+## How to use
+
+When the user types a /sdrive:* command, follow these steps:
+
+1. Read .sdrive/commands/manifest.json
+2. Find the matching command
+3. Read the agent file listed in agentFile
+4. Follow that agent's instructions exactly
+5. Run validators after writing files
+6. Stop at human approval gates
+
+Always read the manifest first. Never hardcode the command list.
+`;
+}
+
 // ---------- INIT COMMAND ----------
 program
   .command("init")
@@ -55,16 +76,58 @@ program
       console.log("  Created: .sdrive/constitution.md");
     }
 
-    const generatorPath = path.join(sdriveRoot, "scripts", "generate-adapters.js");
-    if (fs.existsSync(generatorPath)) {
-      try {
-        execSync(`node "${generatorPath}"`, { stdio: "inherit" });
-      } catch (error) {
-        console.warn("⚠️  Tool adapter generation skipped.");
-      }
+    const toolsPath = path.join(sdriveRoot, "commands", "tools.json");
+
+    if (!fs.existsSync(toolsPath)) {
+      console.log("\n⚠️  tools.json not found. Skipping tool selection.");
+      console.log("\n✅ SpecDrive initialized successfully.");
+      return;
     }
 
-    console.log("\n✅ SpecDrive initialized successfully.");
+    const tools = JSON.parse(fs.readFileSync(toolsPath, "utf8")).tools;
+
+    console.log("\n🔧 Select tools to set up (comma-separated numbers):\n");
+    tools.forEach((tool, index) => {
+      console.log(`  ${index + 1}. ${tool.name}`);
+    });
+    console.log("  Or press Enter to generate all.\n");
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    rl.question("Selection: ", (answer) => {
+      rl.close();
+
+      let selectedTools = tools;
+
+      if (answer.trim() !== "") {
+        const selectedIndexes = answer.split(",").map((n) => parseInt(n.trim()) - 1);
+        selectedTools = selectedIndexes
+          .filter((i) => i >= 0 && i < tools.length)
+          .map((i) => tools[i]);
+      }
+
+      selectedTools.forEach((tool) => {
+        const adapterFullPath = path.join(projectRoot, tool.adapterPath);
+        const adapterDir = path.dirname(adapterFullPath);
+
+        if (!fs.existsSync(adapterDir)) {
+          fs.mkdirSync(adapterDir, { recursive: true });
+        }
+
+        if (fs.existsSync(adapterFullPath)) {
+          console.log(`⚠️  Skipped existing: ${tool.adapterPath}`);
+          return;
+        }
+
+        fs.writeFileSync(adapterFullPath, adapterContent(tool.name));
+        console.log(`✅ Generated: ${tool.adapterPath}`);
+      });
+
+      console.log("\n✅ SpecDrive initialized successfully.");
+    });
   });
 
 // ---------- VALIDATE COMMAND ----------