specdrive-cli 0.1.0

package/scripts/validate-governance.js

@@ -0,0 +1,166 @@
+const Ajv = require("ajv");
+const fs = require("fs");
+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}`);
+    process.exit(1);
+  }
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function validateData(data, schema, label) {
+  const validate = ajv.compile(schema);
+  const valid = validate(data);
+  if (valid) {
+    console.log(`✅ ${label} is valid.`);
+    return true;
+  } else {
+    console.log(`❌ ${label} is INVALID:`);
+    console.log(validate.errors);
+    return false;
+  }
+}
+
+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");
+}
+
+function validateFeature(featureName) {
+  const featureDir = path.join(governanceDir, featureName);
+  if (!fs.existsSync(featureDir)) {
+    console.log(`⚠️  Feature "${featureName}" has no governance folder. Skipping.`);
+    return true;
+  }
+
+  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.`);
+  }
+
+  // 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.`);
+  }
+
+  // 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.`);
+  }
+
+  // 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.`);
+  }
+
+  return !failed;
+}
+
+function discoverFeatures() {
+  const features = new Set();
+
+  // From governance folder
+  if (fs.existsSync(governanceDir)) {
+    const dirs = fs.readdirSync(governanceDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+    dirs.forEach((d) => features.add(d));
+  }
+
+  // From specs folder
+  const lifecycleFolders = ["backlog", "ongoing", "completed"];
+  lifecycleFolders.forEach((lifecycle) => {
+    const lifecyclePath = path.join(specsDir, lifecycle);
+    if (fs.existsSync(lifecyclePath)) {
+      const dirs = fs.readdirSync(lifecyclePath, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name);
+      dirs.forEach((d) => features.add(d));
+    }
+  });
+
+  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);
+  } else {
+    console.log("✅ Governance validation complete. All files are valid.");
+    process.exit(0);
+  }
+}
+
+main();

package/src/index.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+
+const { Command } = require("commander");
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const program = new Command();
+
+program
+  .name("sdrive")
+  .description("SpecDrive Enterprise Spec-Driven Development CLI")
+  .version("0.1.0");
+
+// ---------- INIT COMMAND ----------
+program
+  .command("init")
+  .description("Initialize SpecDrive structure and tool adapters")
+  .action(() => {
+    const projectRoot = process.cwd();
+    const sdriveRoot = path.join(projectRoot, ".sdrive");
+
+    // Create .sdrive directory structure
+    const dirs = [
+      path.join(sdriveRoot, "agents"),
+      path.join(sdriveRoot, "commands"),
+      path.join(sdriveRoot, "schemas"),
+      path.join(sdriveRoot, "specs", "backlog"),
+      path.join(sdriveRoot, "specs", "ongoing"),
+      path.join(sdriveRoot, "specs", "completed"),
+      path.join(sdriveRoot, "governance"),
+      path.join(sdriveRoot, "prototype", "css"),
+      path.join(sdriveRoot, "prototype", "js"),
+      path.join(sdriveRoot, "prototype", "screens"),
+      path.join(sdriveRoot, "reports", "security"),
+      path.join(sdriveRoot, "reports", "performance"),
+      path.join(sdriveRoot, "reports", "docs"),
+      path.join(sdriveRoot, "context"),
+      path.join(sdriveRoot, "skills")
+    ];
+
+    dirs.forEach((dir) => {
+      fs.mkdirSync(dir, { recursive: true });
+      console.log(`  Created: ${path.relative(projectRoot, dir)}`);
+    });
+
+    // Create workflow-state.json if missing
+    const workflowStatePath = path.join(sdriveRoot, "workflow-state.json");
+    if (!fs.existsSync(workflowStatePath)) {
+      fs.writeFileSync(workflowStatePath, JSON.stringify({ features: [] }, null, 2));
+      console.log("  Created: .sdrive/workflow-state.json");
+    }
+
+    // Create constitution.md if missing
+    const constitutionPath = path.join(sdriveRoot, "constitution.md");
+    if (!fs.existsSync(constitutionPath)) {
+      fs.writeFileSync(constitutionPath, "# SpecDrive Constitution\n\nInitialized by `sdrive init`.\n");
+      console.log("  Created: .sdrive/constitution.md");
+    }
+
+    // Generate tool adapters
+    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.");
+      }
+    }
+
+    console.log("\n✅ SpecDrive initialized successfully.");
+  });
+
+// ---------- VALIDATE COMMAND ----------
+program
+  .command("validate")
+  .description("Validate SpecDrive governance files")
+  .action(() => {
+    const projectRoot = process.cwd();
+    const validatorPath = path.join(projectRoot, ".sdrive", "scripts", "validate-governance.js");
+
+    if (!fs.existsSync(validatorPath)) {
+      console.error("❌ Validator not found. Run `sdrive init` first.");
+      process.exit(1);
+    }
+
+    try {
+      execSync(`node "${validatorPath}"`, { stdio: "inherit" });
+    } catch (error) {
+      console.error("\n❌ Validation failed.");
+      process.exit(1);
+    }
+  });
+
+// ---------- CREATE COMMAND ----------
+program
+  .command("create <feature>")
+  .description("Create a new feature scaffold (internal)")
+  .action((feature) => {
+    if (!/^[a-z0-9-]+$/.test(feature)) {
+      console.error("❌ Feature name must be lowercase letters, numbers, and hyphens only.");
+      process.exit(1);
+    }
+
+    const projectRoot = process.cwd();
+    const featureSpecDir = path.join(projectRoot, ".sdrive", "specs", "backlog", feature);
+    const featureGovDir = path.join(projectRoot, ".sdrive", "governance", feature);
+
+    if (fs.existsSync(featureSpecDir) || fs.existsSync(featureGovDir)) {
+      console.error(`❌ Feature "${feature}" already exists.`);
+      process.exit(1);
+    }
+
+    fs.mkdirSync(featureSpecDir, { recursive: true });
+    fs.mkdirSync(featureGovDir, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(featureSpecDir, "spec.md"),
+      `---\ntitle: ${feature}\nstatus: backlog\ncreated: ${new Date().toISOString()}\nupdated: ${new Date().toISOString()}\n---\n\n# ${feature}\n`
+    );
+
+    fs.writeFileSync(
+      path.join(featureSpecDir, "plan.md"),
+      `# Technical Plan: ${feature}\n`
+    );
+
+    fs.writeFileSync(
+      path.join(featureSpecDir, "tasks.md"),
+      `# Execution Tasks: ${feature}\n`
+    );
+
+    fs.writeFileSync(
+      path.join(featureGovDir, "spec.json"),
+      JSON.stringify({ feature, version: 1, overview: {}, userStories: [], functionalRequirements: [] }, null, 2)
+    );
+
+    fs.writeFileSync(
+      path.join(featureGovDir, "plan.json"),
+      JSON.stringify({ feature, version: 1, architecture: {}, dataModel: {} }, null, 2)
+    );
+
+    fs.writeFileSync(
+      path.join(featureGovDir, "tasks.json"),
+      JSON.stringify({ feature, version: 1, phases: [] }, null, 2)
+    );
+
+    fs.writeFileSync(
+      path.join(featureGovDir, "traceability.json"),
+      JSON.stringify({ feature, version: 1, rows: [] }, null, 2)
+    );
+
+    console.log(`✅ Feature "${feature}" created in backlog.`);
+  });
+
+// ---------- STATUS COMMAND ----------
+program
+  .command("status")
+  .description("Show feature lifecycle state")
+  .action(() => {
+    const projectRoot = process.cwd();
+    const workflowStatePath = path.join(projectRoot, ".sdrive", "workflow-state.json");
+
+    if (!fs.existsSync(workflowStatePath)) {
+      console.error("❌ workflow-state.json not found. Run `sdrive init` first.");
+      process.exit(1);
+    }
+
+    const state = JSON.parse(fs.readFileSync(workflowStatePath, "utf8"));
+
+    if (!state.features || state.features.length === 0) {
+      console.log("No features found.");
+      return;
+    }
+
+    console.log("\nSpecDrive Feature Status\n");
+
+    state.features.forEach((f) => {
+      console.log(`📁 ${f.name}`);
+      console.log(`   Phase:        ${f.phase}`);
+      console.log(`   Current Step: ${f.currentStep}`);
+      console.log(`   Gates:`);
+      console.log(`     specification: ${f.gates?.specification ?? "pending"}`);
+      console.log(`     planning:      ${f.gates?.planning ?? "pending"}`);
+      console.log(`     implementation: ${f.gates?.implementation ?? "pending"}`);
+      console.log(`     review:        ${f.gates?.review ?? "pending"}`);
+      console.log("");
+    });
+  });
+
+// ---------- APPROVE COMMAND ----------
+program
+  .command("approve <gate>")
+  .description("Approve a workflow gate (specification, planning, implementation, review)")
+  .action((gate) => {
+    const allowedGates = ["specification", "planning", "implementation", "review"];
+
+    if (!allowedGates.includes(gate)) {
+      console.error(`❌ Invalid gate. Allowed: ${allowedGates.join(", ")}`);
+      process.exit(1);
+    }
+
+    const projectRoot = process.cwd();
+    const workflowStatePath = path.join(projectRoot, ".sdrive", "workflow-state.json");
+
+    if (!fs.existsSync(workflowStatePath)) {
+      console.error("❌ workflow-state.json not found. Run `sdrive init` first.");
+      process.exit(1);
+    }
+
+    const state = JSON.parse(fs.readFileSync(workflowStatePath, "utf8"));
+
+    if (!state.features || state.features.length === 0) {
+      console.error("❌ No features found.");
+      process.exit(1);
+    }
+
+    const feature = state.features[0];
+
+    if (!feature.gates) {
+      feature.gates = {};
+    }
+
+    feature.gates[gate] = "approved";
+    feature.history = feature.history || [];
+    feature.history.push({
+      event: `${gate}_approved`,
+      timestamp: new Date().toISOString()
+    });
+
+    fs.writeFileSync(workflowStatePath, JSON.stringify(state, null, 2));
+
+    console.log(`✅ Gate "${gate}" approved for feature "${feature.name}".`);
+  });
+
+program.parse(process.argv);