specdrive-cli 0.1.2 → 0.1.8

package/schemas/tasks.schema.json

@@ -1,38 +1,80 @@
 {
-  "": "http://json-schema.org/draft-07/schema#",
+  "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Execution Tasks",
   "type": "object",
   "properties": {
-    "feature": { "type": "string", "pattern": "^[a-z0-9-]+$" },
-    "version": { "type": "integer", "minimum": 1 },
+    "feature": {
+      "type": "string",
+      "pattern": "^[a-z0-9-]+$"
+    },
+    "version": {
+      "type": "integer",
+      "minimum": 1
+    },
     "phases": {
       "type": "array",
       "minItems": 1,
       "items": {
         "type": "object",
         "properties": {
-          "phaseId": { "type": "string", "pattern": "^P[0-9]+$" },
-          "name": { "type": "string" },
+          "phaseId": {
+            "type": "string",
+            "pattern": "^P[0-9]+$"
+          },
+          "name": {
+            "type": "string",
+            "minLength": 3
+          },
+          "dependencies": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "pattern": "^P[0-9]+$"
+            }
+          },
           "tasks": {
             "type": "array",
             "minItems": 1,
             "items": {
               "type": "object",
               "properties": {
-                "id": { "type": "string", "pattern": "^T[0-9]+\\.[0-9]+$" },
-                "title": { "type": "string" },
-                "description": { "type": "string" },
+                "id": {
+                  "type": "string",
+                  "pattern": "^T[0-9]+\\.[0-9]+$"
+                },
+                "title": {
+                  "type": "string",
+                  "minLength": 5
+                },
+                "description": {
+                  "type": "string"
+                },
                 "linkedRequirements": {
                   "type": "array",
-                  "items": { "type": "string", "pattern": "^(FR|NFR)-[0-9]{3}$" }
+                  "items": {
+                    "type": "string",
+                    "pattern": "^(FR|NFR)-[0-9]{3}$"
+                  },
+                  "minItems": 1
                 },
                 "linkedAcceptanceCriteria": {
                   "type": "array",
-                  "items": { "type": "string", "pattern": "^AC-[0-9]{3}$" }
+                  "items": {
+                    "type": "string",
+                    "pattern": "^AC-[0-9]{3}$"
+                  }
                 },
-                "completed": { "type": "boolean", "default": false }
+                "completed": {
+                  "type": "boolean",
+                  "default": false
+                }
               },
-              "required": ["id", "title", "linkedRequirements"]
+              "required": [
+                "id",
+                "title",
+                "linkedRequirements",
+                "completed"
+              ]
             }
           }
         },
@@ -40,5 +82,6 @@
       }
     }
   },
-  "required": ["feature", "version", "phases"]
-}
+  "required": ["feature", "version", "phases"],
+  "additionalProperties": false
+}

package/schemas/traceability.schema.json

@@ -1,34 +1,63 @@
 {
-  "": "http://json-schema.org/draft-07/schema#",
+  "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Traceability Matrix",
   "type": "object",
   "properties": {
-    "feature": { "type": "string", "pattern": "^[a-z0-9-]+$" },
-    "version": { "type": "integer", "minimum": 1 },
+    "feature": {
+      "type": "string",
+      "pattern": "^[a-z0-9-]+$"
+    },
+    "version": {
+      "type": "integer",
+      "minimum": 1
+    },
     "rows": {
       "type": "array",
+      "minItems": 1,
       "items": {
         "type": "object",
         "properties": {
-          "requirementId": { "type": "string", "pattern": "^(FR|NFR)-[0-9]{3}$" },
+          "requirementId": {
+            "type": "string",
+            "pattern": "^(FR|NFR)-[0-9]{3}$"
+          },
           "acceptanceCriteriaIds": {
             "type": "array",
-            "items": { "type": "string", "pattern": "^AC-[0-9]{3}$" }
+            "items": {
+              "type": "string",
+              "pattern": "^AC-[0-9]{3}$"
+            }
+          },
+          "planSection": {
+            "type": "string"
           },
-          "planSection": { "type": "string" },
           "taskIds": {
             "type": "array",
-            "items": { "type": "string", "pattern": "^T[0-9]+\\.[0-9]+$" }
+            "items": {
+              "type": "string",
+              "pattern": "^T[0-9]+\\.[0-9]+$"
+            }
           },
           "testIds": {
             "type": "array",
-            "items": { "type": "string", "pattern": "^TEST-[0-9]{3}$" }
+            "items": {
+              "type": "string",
+              "pattern": "^TEST-[0-9]{3}$"
+            }
           },
-          "status": { "enum": ["not_started", "in_progress", "complete"] }
+          "status": {
+            "enum": ["not_started", "in_progress", "complete"]
+          }
         },
-        "required": ["requirementId", "status"]
+        "required": [
+          "requirementId",
+          "acceptanceCriteriaIds",
+          "taskIds",
+          "status"
+        ]
       }
     }
   },
-  "required": ["feature", "version", "rows"]
-}
+  "required": ["feature", "version", "rows"],
+  "additionalProperties": false
+}

package/schemas/workflow-state.schema.json

@@ -1,5 +1,5 @@
 {
-  "": "http://json-schema.org/draft-07/schema#",
+  "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Workflow State",
   "type": "object",
   "properties": {
@@ -8,26 +8,52 @@
       "items": {
         "type": "object",
         "properties": {
-          "name": { "type": "string", "pattern": "^[a-z0-9-]+$" },
-          "phase": { "enum": ["backlog", "ongoing", "completed", "blocked"] },
-          "currentStep": { "enum": ["specification", "planning", "implementation", "review"] },
+          "name": {
+            "type": "string",
+            "pattern": "^[a-z0-9-]+$"
+          },
+          "phase": {
+            "enum": ["backlog", "ongoing", "completed", "blocked"]
+          },
+          "currentStep": {
+            "enum": ["specification", "planning", "implementation", "review"]
+          },
           "gates": {
             "type": "object",
             "properties": {
-              "specification": { "enum": ["pending", "approved", "rejected"] },
-              "planning": { "enum": ["pending", "approved", "rejected"] },
-              "implementation": { "enum": ["pending", "in_progress", "approved", "rejected"] },
-              "review": { "enum": ["pending", "approved", "rejected"] }
+              "specification": {
+                "enum": ["pending", "approved", "rejected"]
+              },
+              "planning": {
+                "enum": ["pending", "approved", "rejected"]
+              },
+              "implementation": {
+                "enum": ["pending", "in_progress", "approved", "rejected"]
+              },
+              "review": {
+                "enum": ["pending", "approved", "rejected"]
+              }
             },
-            "required": ["specification", "planning", "implementation", "review"]
+            "required": [
+              "specification",
+              "planning",
+              "implementation",
+              "review"
+            ]
           },
           "history": {
             "type": "array",
             "items": {
               "type": "object",
               "properties": {
-                "event": { "type": "string" },
-                "timestamp": { "type": "string", "format": "date-time" }
+                "event": {
+                  "type": "string",
+                  "minLength": 3
+                },
+                "timestamp": {
+                  "type": "string",
+                  "format": "date-time"
+                }
               },
               "required": ["event", "timestamp"]
             }
@@ -37,5 +63,6 @@
       }
     }
   },
-  "required": ["features"]
-}
+  "required": ["features"],
+  "additionalProperties": false
+}

package/scripts/anti-redundancy.js

@@ -24,7 +24,7 @@ function getInstalledDependencies() {
   ];
 }
 
-function listFiles(dir, extensions = [".ts", ".tsx", ".js", ".jsx"]) {
+function listFiles(dir, extensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs"]) {
   if (!fs.existsSync(dir)) return [];
 
   let results = [];
@@ -97,35 +97,35 @@ function checkRedundancy(plannedItems) {
 
     switch (item.type) {
       case "component":
-        exists = existingAssets.components.some((path) => path.includes(item.name));
+        exists = existingAssets.components.some((p) => p.includes(item.name));
         if (exists) {
-          location = existingAssets.components.find((path) => path.includes(item.name));
+          location = existingAssets.components.find((p) => p.includes(item.name));
         }
         break;
       case "service":
       case "api":
-        exists = existingAssets.services.some((path) => path.includes(item.name));
+        exists = existingAssets.services.some((p) => p.includes(item.name));
         if (exists) {
-          location = existingAssets.services.find((path) => path.includes(item.name));
+          location = existingAssets.services.find((p) => p.includes(item.name));
         }
         break;
       case "hook":
-        exists = existingAssets.hooks.some((path) => path.includes(item.name));
+        exists = existingAssets.hooks.some((p) => p.includes(item.name));
         if (exists) {
-          location = existingAssets.hooks.find((path) => path.includes(item.name));
+          location = existingAssets.hooks.find((p) => p.includes(item.name));
         }
         break;
       case "utility":
-        exists = existingAssets.utils.some((path) => path.includes(item.name));
+        exists = existingAssets.utils.some((p) => p.includes(item.name));
         if (exists) {
-          location = existingAssets.utils.find((path) => path.includes(item.name));
+          location = existingAssets.utils.find((p) => p.includes(item.name));
         }
         break;
       case "model":
       case "entity":
-        exists = existingAssets.models.some((path) => path.includes(item.name));
+        exists = existingAssets.models.some((p) => p.includes(item.name));
         if (exists) {
-          location = existingAssets.models.find((path) => path.includes(item.name));
+          location = existingAssets.models.find((p) => p.includes(item.name));
         }
         break;
       case "package":

package/scripts/audit-log.js

@@ -8,7 +8,13 @@ function loadAuditLog() {
   if (!fs.existsSync(auditLogPath)) {
     return { events: [] };
   }
-  return JSON.parse(fs.readFileSync(auditLogPath, "utf8"));
+
+  try {
+    return JSON.parse(fs.readFileSync(auditLogPath, "utf8"));
+  } catch (error) {
+    console.error(`⚠️  Could not parse audit log: ${error.message}`);
+    return { events: [] };
+  }
 }
 
 function saveAuditLog(log) {
@@ -28,8 +34,14 @@ function logEvent(event, details = {}) {
   console.log(`📝 Audit: ${event}`);
 }
 
+function getRecentEvents(count = 10) {
+  const log = loadAuditLog();
+  return log.events.slice(-count).reverse();
+}
+
 module.exports = {
   logEvent,
   loadAuditLog,
-  saveAuditLog
+  saveAuditLog,
+  getRecentEvents
 };

package/scripts/generate-adapters.js

@@ -1,8 +1,3 @@
-// SAFETY RULE
-// NEVER overwrite existing files in .github/
-// If a file exists, ask the user before modifying it.
-// Only create new files if missing.
-
 const fs = require("fs");
 const path = require("path");
 
@@ -35,26 +30,11 @@ When the user types a /sdrive:* command, follow these steps:
 5. Run validators after writing files
 6. Stop at human approval gates
 
-## Command list
-
-- /sdrive:constitution — Create or update project constitution
-- /sdrive:propose — Create spec, traceability, plan, and tasks
-- /sdrive:design — Build UI/UX prototype
-- /sdrive:apply — Write production code
-- /sdrive:review — Final audit and merge
-- /sdrive:secure — Security audit
-- /sdrive:performance — Performance benchmark
-- /sdrive:docs — Generate documentation
-- /sdrive:sync — Cascade sync
-- /sdrive:skills — Manage AI skills
-
 Always read the manifest first. Never hardcode the command list.
 `;
 }
 
-function generate() {
-  const tools = loadTools();
-
+function generateForTools(tools) {
   tools.forEach((tool) => {
     const adapterFullPath = path.join(projectRoot, tool.adapterPath);
     const adapterDir = path.dirname(adapterFullPath);
@@ -63,19 +43,39 @@ function generate() {
       fs.mkdirSync(adapterDir, { recursive: true });
     }
 
-    // SAFETY GUARD
     if (fs.existsSync(adapterFullPath)) {
-      console.log(`⚠️  Skipped existing file: ${tool.adapterPath}`);
-      console.log("    SpecDrive never overwrites existing project files.");
-      console.log("    Delete the file or rename it to regenerate.\n");
+      console.log(`⚠️  Skipped existing: ${tool.adapterPath}`);
       return;
     }
 
     fs.writeFileSync(adapterFullPath, adapterContent(tool.name));
-    console.log(`✅ Generated adapter: ${tool.adapterPath}`);
+    console.log(`✅ Generated: ${tool.adapterPath}`);
   });
+}
+
+function generateAll() {
+  const tools = loadTools();
+  generateForTools(tools);
+  console.log("\n🎉 All adapters generated successfully.");
+}
+
+function generateSelected(indexes) {
+  const tools = loadTools();
+  const selectedTools = indexes
+    .map((i) => tools[i])
+    .filter((tool) => tool);
+
+  if (selectedTools.length === 0) {
+    console.error("❌ No valid tools selected.");
+    process.exit(1);
+  }
 
-  console.log("\n🎉 Adapter generation complete.");
+  generateForTools(selectedTools);
+  console.log("\n🎉 Selected adapters generated successfully.");
 }
 
-generate();
+module.exports = {
+  generateAll,
+  generateSelected,
+  loadTools
+};

package/scripts/generate-from-template.js

@@ -31,6 +31,7 @@ function generate(templateName, featureName, variables) {
 
   files.forEach((file) => {
     const templateFile = path.join(templateDir, file);
+
     if (!fs.existsSync(templateFile)) {
       return;
     }

package/scripts/load-plugins.js

@@ -22,11 +22,15 @@ function loadPlugins() {
       return;
     }
 
-    const pluginDef = JSON.parse(fs.readFileSync(pluginJsonPath, "utf8"));
-    plugins.push({
-      ...pluginDef,
-      path: path.join(pluginsDir, folder)
-    });
+    try {
+      const pluginDef = JSON.parse(fs.readFileSync(pluginJsonPath, "utf8"));
+      plugins.push({
+        ...pluginDef,
+        path: path.join(pluginsDir, folder)
+      });
+    } catch (error) {
+      console.warn(`⚠️  Skipping invalid plugin: ${folder}`);
+    }
   });
 
   return plugins;
@@ -51,7 +55,12 @@ function runPlugin(pluginName) {
   require(entryPath);
 }
 
+function listPlugins() {
+  return loadPlugins();
+}
+
 module.exports = {
   loadPlugins,
-  runPlugin
+  runPlugin,
+  listPlugins
 };

package/scripts/team.js

@@ -6,15 +6,25 @@ const teamPath = path.join(projectRoot, ".sdrive", "team.json");
 
 function loadTeam() {
   if (!fs.existsSync(teamPath)) {
-    console.error("❌ team.json not found.");
+    console.error("❌ team.json not found. Run `sdrive init` first.");
     process.exit(1);
   }
-  return JSON.parse(fs.readFileSync(teamPath, "utf8"));
+
+  try {
+    return JSON.parse(fs.readFileSync(teamPath, "utf8"));
+  } catch (error) {
+    console.error(`❌ Invalid team.json: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+function saveTeam(team) {
+  fs.writeFileSync(teamPath, JSON.stringify(team, null, 2));
 }
 
 function getUserRole(username) {
   const team = loadTeam();
-  const member = team.members.find((m) => m.username === username);
+  const member = team.members?.find((m) => m.username === username);
   return member ? member.role : null;
 }
 
@@ -23,7 +33,7 @@ function canApprove(username) {
   if (!role) return false;
 
   const team = loadTeam();
-  return team.rules.approval_required.includes(role);
+  return team.rules?.approval_required?.includes(role) || false;
 }
 
 function canImplement(username) {
@@ -31,11 +41,74 @@ function canImplement(username) {
   if (!role) return false;
 
   const team = loadTeam();
-  return team.rules.implementation_allowed.includes(role);
+  return team.rules?.implementation_allowed?.includes(role) || false;
+}
+
+function listMembers() {
+  const team = loadTeam();
+  return team.members || [];
+}
+
+function addMember(username, role) {
+  const team = loadTeam();
+
+  if (!team.members) {
+    team.members = [];
+  }
+
+  const existing = team.members.find((m) => m.username === username);
+  if (existing) {
+    console.error(`❌ User "${username}" already exists.`);
+    return false;
+  }
+
+  team.members.push({ username, role });
+  saveTeam(team);
+  console.log(`✅ Added ${username} as ${role}.`);
+  return true;
+}
+
+function removeMember(username) {
+  const team = loadTeam();
+
+  const before = team.members?.length || 0;
+  team.members = (team.members || []).filter((m) => m.username !== username);
+  const after = team.members.length;
+
+  if (before === after) {
+    console.error(`❌ User "${username}" not found.`);
+    return false;
+  }
+
+  saveTeam(team);
+  console.log(`✅ Removed ${username}.`);
+  return true;
+}
+
+function updateMember(username, role) {
+  const team = loadTeam();
+
+  const member = team.members?.find((m) => m.username === username);
+
+  if (!member) {
+    console.error(`❌ User "${username}" not found.`);
+    return false;
+  }
+
+  member.role = role;
+  saveTeam(team);
+  console.log(`✅ Updated ${username} to ${role}.`);
+  return true;
 }
 
 module.exports = {
+  loadTeam,
+  saveTeam,
   getUserRole,
   canApprove,
-  canImplement
+  canImplement,
+  listMembers,
+  addMember,
+  removeMember,
+  updateMember
 };

package/scripts/test-adapters.js

@@ -6,7 +6,7 @@ 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");
+  console.log("\n🧪 Test 1: Generator creates adapters");
 
   try {
     execSync(`node "${generatorPath}"`, { stdio: "pipe" });
@@ -15,20 +15,16 @@ function testGeneratorCreatesAdapters() {
     return false;
   }
 
-  const expectedAdapters = [
-    ".github/copilot-instructions.md",
-    ".clinerules/sdrive.md",
-    ".claude/commands/sdrive.md",
-    ".cursor/rules/sdrive.md",
-    ".vscode/sdrive-commands.json"
-  ];
+  const toolsPath = path.join(projectRoot, ".sdrive", "commands", "tools.json");
+  const tools = JSON.parse(fs.readFileSync(toolsPath, "utf8")).tools;
+
+  for (const tool of tools) {
+    const fullPath = path.join(projectRoot, tool.adapterPath);
 
-  for (const adapter of expectedAdapters) {
-    const fullPath = path.join(projectRoot, adapter);
     if (fs.existsSync(fullPath)) {
-      console.log(`  ✅ Found: ${adapter}`);
+      console.log(`  ✅ Found: ${tool.adapterPath}`);
     } else {
-      console.log(`  ❌ Missing: ${adapter}`);
+      console.log(`  ❌ Missing: ${tool.adapterPath}`);
       return false;
     }
   }
@@ -63,10 +59,8 @@ function testSafetyRule() {
 
   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) {
@@ -74,7 +68,6 @@ function testSafetyRule() {
     return false;
   }
 
-  // Check content was not overwritten
   const content = fs.readFileSync(adapterPath, "utf8");
 
   if (content === "# Custom existing file\n") {
@@ -87,20 +80,18 @@ function testSafetyRule() {
 }
 
 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 });
-    }
-  });
+  const toolsPath = path.join(projectRoot, ".sdrive", "commands", "tools.json");
+
+  if (fs.existsSync(toolsPath)) {
+    const tools = JSON.parse(fs.readFileSync(toolsPath, "utf8")).tools;
+
+    tools.forEach((tool) => {
+      const fullPath = path.join(projectRoot, tool.adapterPath);
+      if (fs.existsSync(fullPath)) {
+        fs.rmSync(fullPath, { force: true });
+      }
+    });
+  }
 
   console.log("\n🧹 Cleaned up adapters.");
 }