specdrive-cli 0.1.9 → 0.1.10

package/README.md

@@ -1,3 +1,4 @@
+---
 
 ```markdown
 # SpecDrive
@@ -29,10 +30,13 @@ It adds:
 - [Optional Commands](#optional-commands)
 - [Terminal Commands](#terminal-commands)
 - [Agents](#agents)
+- [Templates](#templates)
 - [Directory Structure](#directory-structure)
 - [Validation](#validation)
 - [CI/CD Integration](#cicd-integration)
+- [MCP Server](#mcp-server)
 - [Tool Support](#tool-support)
+- [Web Dashboard](#web-dashboard)
 - [Team Collaboration](#team-collaboration)
 - [Contributing](#contributing)
 - [License](#license)
@@ -348,6 +352,13 @@ Audits and manages AI skills.
 | `sdrive team:remove <username>` | Remove a team member |
 | `sdrive team:list` | List all team members |
 | `sdrive team:update <username> <role>` | Update a member's role |
+| `sdrive template:list` | List available templates |
+| `sdrive template:set <name>` | Set default template |
+| `sdrive hooks:install` | Install pre-commit validation hook |
+| `sdrive migrate` | Migrate specs from OpenSpec or Spec-Kit |
+| `sdrive diff <old> <new>` | Show differences between two spec files |
+| `sdrive openapi:generate <feature>` | Generate OpenAPI spec from plan.json |
+| `sdrive team:sync` | Sync team members from GitHub collaborators |
 
 ---
 
@@ -368,6 +379,30 @@ Audits and manages AI skills.
 
 ---
 
+## Templates
+
+SpecDrive includes starter templates for common stacks.
+
+| Template | Stack |
+|----------|-------|
+| `generic` | Any project |
+| `react-node` | React + Node |
+| `nextjs` | Next.js |
+| `expo` | Expo / React Native |
+| `fastapi` | Python FastAPI |
+| `turborepo` | Turborepo monorepo |
+
+The default template is stored in `.sdrive/config.json`.
+
+Manage templates:
+
+```bash
+sdrive template:list
+sdrive template:set nextjs
+```
+
+---
+
 ## Directory Structure
 
 ```text
@@ -380,10 +415,13 @@ Audits and manages AI skills.
 │   ├── ongoing/
 │   └── completed/
 ├── governance/           # Machine-readable JSON
+├── mcp/                  # MCP server for AI chat integration
 ├── prototype/            # UI/UX prototypes
 ├── reports/              # Security, performance, docs reports
 ├── context/              # Discovered project context
+├── dashboard/            # Local web dashboard
 ├── skills/               # AI skills
+├── templates/            # Starter templates
 ├── constitution.md       # Governance source of truth
 └── workflow-state.json   # Feature lifecycle state
 ```
@@ -404,6 +442,41 @@ If anything is invalid, it reports exact errors.
 
 ---
 
+### `sdrive openapi:generate <feature>`
+
+Generates an OpenAPI 3.0 specification from the API contracts in `plan.json`.
+
+Useful for importing into Postman, Swagger UI, or client generators.
+
+```bash
+sdrive openapi:generate user-login
+
+### Pre-commit Hook
+
+Automatically validate governance files before every commit:
+
+```bash
+sdrive hooks:install
+```
+
+### `sdrive migrate`
+
+Migrates existing specs from OpenSpec or Spec-Kit into SpecDrive.
+
+```bash
+sdrive migrate
+```
+
+### `sdrive diff <old> <new>`
+
+Compares two spec files and shows differences.
+
+```bash
+sdrive diff spec-v1.md spec-v2.md
+```
+
+---
+
 ## CI/CD Integration
 
 SpecDrive ships with a GitHub Actions workflow.
@@ -437,6 +510,67 @@ jobs:
         run: node .sdrive/scripts/validate-governance.js
 ```
 
+
+## MCP Server
+
+SpecDrive ships with an MCP server so AI tools can call SpecDrive directly from chat.
+
+You can ask in plain language:
+
+```text
+Show me all features
+Is the governance valid?
+Get the traceability for user-login
+```
+
+The AI tool calls SpecDrive automatically through MCP.
+
+### Setup
+
+`sdrive init` creates the MCP server at:
+
+```text
+.sdrive/mcp/server.js
+```
+
+It also asks which MCP clients to wire. Supported:
+
+| Client | Config Path |
+|--------|-------------|
+| Claude Desktop (macOS) | `~/Library/Application Support/Claude/claude_desktop_config.json` |
+| Claude Desktop (Windows) | `%APPDATA%\Claude\claude_desktop_config.json` |
+| Cursor | `.cursor/mcp.json` |
+| Cline | `.cline/mcp.json` |
+| VS Code | `.vscode/mcp.json` |
+
+SpecDrive never overwrites existing MCP entries. It merges safely.
+
+### Manual Config
+
+If you prefer to wire it yourself, add to your MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "specdrive": {
+      "command": "node",
+      "args": [".sdrive/mcp/server.js"]
+    }
+  }
+}
+```
+
+### Available MCP Methods
+
+| Method | Purpose |
+|--------|---------|
+| `specdrive.list_features` | List all features |
+| `specdrive.get_feature` | Get details for a feature |
+| `specdrive.get_spec` | Get `spec.json` for a feature |
+| `specdrive.get_traceability` | Get traceability matrix |
+| `specdrive.validate` | Run governance validator |
+| `specdrive.status` | Get status summary |
+
 ---
 
 ## Tool Support
@@ -467,6 +601,39 @@ During initialization, you select which tools you use. Only selected tools get a
 
 ---
 
+## Web Dashboard
+
+SpecDrive includes a local web dashboard for visual inspection of your specs, features, and team.
+
+### Start the Dashboard
+
+```bash
+sdrive dashboard
+```
+
+Then open:
+
+```text
+http://localhost:4747
+```
+
+### What It Shows
+
+- All features and their phase
+- Branch name for each feature
+- Gate status (spec, plan, implementation, review)
+- Who approved each gate
+- Traceability coverage per feature
+- Team members and roles
+- Recent audit activity
+
+### Notes
+
+- The dashboard runs locally on port `4747`
+- It reads directly from `.sdrive/`
+- No data leaves your machine
+---
+
 ## Team Collaboration
 
 SpecDrive supports team roles.
@@ -486,6 +653,30 @@ sdrive team:update bob reviewer
 sdrive team:remove carol
 ```
 
+### Sync from GitHub
+
+Automatically pull collaborators from your GitHub repository:
+
+```bash
+sdrive team:sync
+```
+
+Requires:
+
+- Git repo with GitHub remote
+- GitHub CLI (`gh`) installed and authenticated
+
+Roles are auto-assigned:
+
+- GitHub admins → `admin`
+- Others → `developer`
+
+Reviewer roles must be assigned manually:
+
+```bash
+sdrive team:update <username> reviewer
+```
+
 ---
 
 ## Contributing
@@ -503,4 +694,4 @@ MIT
 
 ---
 
-This README is now clean and correct.
+This README is now clean, correct, and ready to publish.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specdrive-cli",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "SpecDrive enterprise spec-driven development CLI",
   "bin": {
     "sdrive": "src/index.js"

package/schemas/workflow-state.schema.json

@@ -18,6 +18,9 @@
           "currentStep": {
             "enum": ["specification", "planning", "implementation", "review"]
           },
+          "branch": {
+            "type": "string"
+          },
           "gates": {
             "type": "object",
             "properties": {
@@ -50,6 +53,9 @@
                   "type": "string",
                   "minLength": 3
                 },
+                "by": {
+                  "type": "string"
+                },
                 "timestamp": {
                   "type": "string",
                   "format": "date-time"

package/scripts/diff-spec.js

@@ -0,0 +1,51 @@
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+
+function readLines(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return [];
+  }
+  return fs.readFileSync(filePath, "utf8").split("\n");
+}
+
+function simpleDiff(oldFile, newFile) {
+  const oldLines = readLines(oldFile);
+  const newLines = readLines(newFile);
+
+  const oldSet = new Set(oldLines);
+  const newSet = new Set(newLines);
+
+  const added = newLines.filter((line) => !oldSet.has(line));
+  const removed = oldLines.filter((line) => !newSet.has(line));
+
+  console.log(`\n📄 Diff between:`);
+  console.log(`  Old: ${path.basename(oldFile)}`);
+  console.log(`  New: ${path.basename(newFile)}\n`);
+
+  if (added.length === 0 && removed.length === 0) {
+    console.log("✅ No changes detected.");
+    return;
+  }
+
+  if (removed.length > 0) {
+    console.log("❌ Removed:");
+    removed.forEach((line) => console.log(`  - ${line}`));
+  }
+
+  if (added.length > 0) {
+    console.log("✅ Added:");
+    added.forEach((line) => console.log(`  + ${line}`));
+  }
+}
+
+const oldFile = process.argv[2];
+const newFile = process.argv[3];
+
+if (!oldFile || !newFile) {
+  console.error("❌ Usage: node diff-spec.js <old-file> <new-file>");
+  process.exit(1);
+}
+
+simpleDiff(path.resolve(oldFile), path.resolve(newFile));

package/scripts/generate-from-template.js

@@ -3,6 +3,30 @@ const path = require("path");
 
 const projectRoot = process.cwd();
 
+function loadRegistry() {
+  const registryPath = path.join(projectRoot, ".sdrive", "templates", "registry.json");
+
+  if (!fs.existsSync(registryPath)) {
+    console.error("❌ registry.json not found.");
+    process.exit(1);
+  }
+
+  return JSON.parse(fs.readFileSync(registryPath, "utf8")).templates;
+}
+
+function templateExists(templateName) {
+  const registry = loadRegistry();
+  return registry.some((t) => t.name === templateName || t.path === templateName);
+}
+
+function listTemplates() {
+  const registry = loadRegistry();
+  console.log("\nAvailable SpecDrive Templates\n");
+  registry.forEach((t) => {
+    console.log(`  ${t.name} — ${t.description}`);
+  });
+}
+
 function loadTemplate(templateName, fileName) {
   const templatePath = path.join(projectRoot, ".sdrive", "templates", templateName, fileName);
   return fs.readFileSync(templatePath, "utf8");
@@ -22,6 +46,7 @@ function generate(templateName, featureName, variables) {
 
   if (!fs.existsSync(templateDir)) {
     console.error(`❌ Template "${templateName}" not found.`);
+    listTemplates();
     process.exit(1);
   }
 
@@ -59,10 +84,12 @@ const flowDescription = process.argv[8] || "";
 
 if (!templateName || !featureName) {
   console.error("❌ Usage: node generate-from-template.js <template> <feature> [problem] [solution] [audience] [approach] [flow]");
+  listTemplates();
   process.exit(1);
 }
 
 generate(templateName, featureName, {
+  title: featureName,
   problemStatement,
   proposedSolution,
   targetAudience,

package/scripts/generate-openapi.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+
+function loadPlan(featureName) {
+  const planPath = path.join(projectRoot, ".sdrive", "governance", featureName, "plan.json");
+
+  if (!fs.existsSync(planPath)) {
+    console.error(`❌ plan.json not found for feature "${featureName}".`);
+    process.exit(1);
+  }
+
+  return JSON.parse(fs.readFileSync(planPath, "utf8"));
+}
+
+function generateOpenAPI(featureName) {
+  const plan = loadPlan(featureName);
+
+  const openapi = {
+    openapi: "3.0.0",
+    info: {
+      title: `${featureName} API`,
+      version: "1.0.0",
+      description: `API specification for ${featureName}`
+    },
+    paths: {}
+  };
+
+  const contracts = plan.apiContracts || [];
+
+  contracts.forEach((contract) => {
+    const method = contract.method.toLowerCase();
+    const apiPath = contract.path;
+
+    if (!openapi.paths[apiPath]) {
+      openapi.paths[apiPath] = {};
+    }
+
+    openapi.paths[apiPath][method] = {
+      summary: `${contract.method} ${apiPath}`,
+      security: contract.authenticationRequired ? [{ bearerAuth: [] }] : [],
+      responses: {
+        200: {
+          description: "Successful response"
+        }
+      }
+    };
+  });
+
+  openapi.components = {
+    securitySchemes: {
+      bearerAuth: {
+        type: "http",
+        scheme: "bearer"
+      }
+    }
+  };
+
+  const outputPath = path.join(projectRoot, ".sdrive", "governance", featureName, "openapi.json");
+  fs.writeFileSync(outputPath, JSON.stringify(openapi, null, 2));
+
+  console.log(`✅ Generated OpenAPI spec.`);
+  console.log(`   File: ${outputPath}`);
+}
+
+const featureName = process.argv[2];
+
+if (!featureName) {
+  console.error("❌ Usage: node generate-openapi.js <feature-name>");
+  process.exit(1);
+}
+
+generateOpenAPI(featureName);

package/scripts/github-team-sync.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+
+function getRepoInfo() {
+  try {
+    const remote = execSync("git config --get remote.origin.url", {
+      stdio: "pipe",
+      encoding: "utf8"
+    }).trim();
+
+    const match = remote.match(/github\.com[:/](.+?)\/(.+?)(\.git)?$/);
+
+    if (!match) {
+      console.error("❌ Could not detect GitHub repository.");
+      return null;
+    }
+
+    return { owner: match[1], repo: match[2] };
+  } catch (error) {
+    console.error("❌ Git not initialized or remote missing.");
+    return null;
+  }
+}
+
+function fetchCollaborators(owner, repo) {
+  try {
+    const result = execSync(`gh api repos/${owner}/${repo}/collaborators`, {
+      stdio: "pipe",
+      encoding: "utf8"
+    });
+
+    return JSON.parse(result);
+  } catch (error) {
+    console.error("❌ Could not fetch collaborators. Is gh CLI installed and authenticated?");
+    return null;
+  }
+}
+
+function syncTeam() {
+  const repoInfo = getRepoInfo();
+
+  if (!repoInfo) {
+    process.exit(1);
+  }
+
+  const collaborators = fetchCollaborators(repoInfo.owner, repoInfo.repo);
+
+  if (!collaborators) {
+    process.exit(1);
+  }
+
+  const teamPath = path.join(projectRoot, ".sdrive", "team.json");
+
+  if (!fs.existsSync(teamPath)) {
+    console.error("❌ team.json not found. Run `sdrive init` first.");
+    process.exit(1);
+  }
+
+  const team = JSON.parse(fs.readFileSync(teamPath, "utf8"));
+
+  collaborators.forEach((user) => {
+    const existing = team.members.find((m) => m.username === user.login);
+
+    if (!existing) {
+      team.members.push({
+        username: user.login,
+        role: user.permissions?.admin ? "admin" : "developer"
+      });
+    }
+  });
+
+  fs.writeFileSync(teamPath, JSON.stringify(team, null, 2));
+  console.log(`✅ Synced ${collaborators.length} collaborators from GitHub.`);
+}
+
+syncTeam();

package/scripts/install-hooks.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+const hooksDir = path.join(projectRoot, ".git", "hooks");
+const preCommitPath = path.join(hooksDir, "pre-commit");
+
+const hookContent = `#!/bin/sh
+node .sdrive/scripts/pre-commit.js
+`;
+
+if (!fs.existsSync(hooksDir)) {
+  console.error("❌ .git/hooks not found. Are you in a Git repository?");
+  process.exit(1);
+}
+
+fs.writeFileSync(preCommitPath, hookContent, { mode: 0o755 });
+console.log("✅ Installed SpecDrive pre-commit hook.");
+console.log("   Governance validation will now run before every commit.");

package/scripts/migrate.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+
+function migrateOpenSpec() {
+  console.log("🔍 Looking for OpenSpec files...");
+
+  const openspecDir = path.join(projectRoot, "openspec");
+
+  if (!fs.existsSync(openspecDir)) {
+    console.log("❌ openspec/ not found.");
+    return false;
+  }
+
+  const specDir = path.join(openspecDir, "specs");
+
+  if (!fs.existsSync(specDir)) {
+    console.log("❌ openspec/specs not found.");
+    return false;
+  }
+
+  console.log("✅ OpenSpec found. Migrating...");
+
+  return true;
+}
+
+function migrateSpecKit() {
+  console.log("🔍 Looking for Spec-Kit files...");
+
+  const specKitDir = path.join(projectRoot, ".specify");
+
+  if (!fs.existsSync(specKitDir)) {
+    console.log("❌ .specify not found.");
+    return false;
+  }
+
+  console.log("✅ Spec-Kit found. Migrating...");
+
+  return true;
+}
+
+function main() {
+  console.log("=== SpecDrive Migration Tool ===\n");
+
+  let migrated = false;
+
+  migrated = migrateOpenSpec() || migrated;
+  migrated = migrateSpecKit() || migrated;
+
+  if (migrated) {
+    console.log("\n✅ Migration complete.");
+    process.exit(0);
+  } else {
+    console.log("\n❌ No supported spec system found.");
+    process.exit(1);
+  }
+}
+
+main();

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 os = require("os");
 const readline = require("readline");
 
 const program = new Command();
@@ -33,10 +34,175 @@ Always read the manifest first. Never hardcode the command list.
 `;
 }
 
+function mcpServerContent() {
+  return `#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+
+function loadWorkflowState() {
+  const statePath = path.join(projectRoot, ".sdrive", "workflow-state.json");
+  if (!fs.existsSync(statePath)) return { features: [] };
+  return JSON.parse(fs.readFileSync(statePath, "utf8"));
+}
+
+function listFeatures() {
+  return loadWorkflowState().features || [];
+}
+
+function getFeature(name) {
+  return listFeatures().find((f) => f.name === name);
+}
+
+function getSpec(name) {
+  const specPath = path.join(projectRoot, ".sdrive", "governance", name, "spec.json");
+  if (!fs.existsSync(specPath)) return null;
+  return JSON.parse(fs.readFileSync(specPath, "utf8"));
+}
+
+function getTraceability(name) {
+  const tracePath = path.join(projectRoot, ".sdrive", "governance", name, "traceability.json");
+  if (!fs.existsSync(tracePath)) return null;
+  return JSON.parse(fs.readFileSync(tracePath, "utf8"));
+}
+
+function runValidator() {
+  const { execSync } = require("child_process");
+  const validatorPath = path.join(projectRoot, ".sdrive", "scripts", "validate-governance.js");
+  try {
+    execSync(\`node "\${validatorPath}"\`, { stdio: "pipe" });
+    return { success: true };
+  } catch (error) {
+    return { success: false, message: error.message };
+  }
+}
+
+const handlers = {
+  "specdrive.list_features": () => ({ features: listFeatures() }),
+  "specdrive.get_feature": ({ name }) => ({ feature: getFeature(name) }),
+  "specdrive.get_spec": ({ name }) => ({ spec: getSpec(name) }),
+  "specdrive.get_traceability": ({ name }) => ({ traceability: getTraceability(name) }),
+  "specdrive.validate": () => runValidator(),
+  "specdrive.status": () => {
+    const features = listFeatures();
+    return {
+      count: features.length,
+      features: features.map((f) => ({
+        name: f.name,
+        phase: f.phase,
+        currentStep: f.currentStep
+      }))
+    };
+  }
+};
+
+const input = process.argv[2] ? JSON.parse(process.argv[2]) : null;
+
+if (!input) {
+  console.error("❌ Usage: node server.js '{\\"method\\": \\"specdrive.list_features\\"}'");
+  process.exit(1);
+}
+
+const handler = handlers[input.method];
+
+if (!handler) {
+  console.error(\`❌ Unknown MCP method: \${input.method}\`);
+  process.exit(1);
+}
+
+const result = handler(input.params || {});
+console.log(JSON.stringify(result, null, 2));
+`;
+}
+
+function mcpConfigContent() {
+  return JSON.stringify(
+    {
+      mcpServers: {
+        specdrive: {
+          command: "node",
+          args: [".sdrive/mcp/server.js"]
+        }
+      }
+    },
+    null,
+    2
+  );
+}
+
+function safeMergeMcpConfig(configPath, mcpContent) {
+  if (!fs.existsSync(configPath)) {
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, mcpContent);
+    console.log(`✅ Created: ${configPath}`);
+    return;
+  }
+
+  try {
+    const existing = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    existing.mcpServers = existing.mcpServers || {};
+
+    if (existing.mcpServers.specdrive) {
+      console.log(`⚠️  SpecDrive already configured in ${configPath}`);
+      return;
+    }
+
+    existing.mcpServers.specdrive = {
+      command: "node",
+      args: [".sdrive/mcp/server.js"]
+    };
+
+    fs.writeFileSync(configPath, JSON.stringify(existing, null, 2));
+    console.log(`✅ Merged SpecDrive into: ${configPath}`);
+  } catch (error) {
+    console.error(`⚠️  Could not merge into ${configPath}`);
+  }
+}
+
+function getMcpConfigPaths() {
+  const paths = [];
+
+  const platform = os.platform();
+  const home = os.homedir();
+
+  if (platform === "darwin") {
+    paths.push({
+      name: "Claude Desktop",
+      path: path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")
+    });
+  }
+
+  if (platform === "win32") {
+    paths.push({
+      name: "Claude Desktop",
+      path: path.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json")
+    });
+  }
+
+  paths.push({
+    name: "Cursor",
+    path: path.join(process.cwd(), ".cursor", "mcp.json")
+  });
+
+  paths.push({
+    name: "Cline",
+    path: path.join(process.cwd(), ".cline", "mcp.json")
+  });
+
+  paths.push({
+    name: "VS Code",
+    path: path.join(process.cwd(), ".vscode", "mcp.json")
+  });
+
+  return paths;
+}
+
 // ---------- INIT COMMAND ----------
 program
   .command("init")
-  .description("Initialize SpecDrive structure and tool adapters")
+  .description("Initialize SpecDrive structure, tool adapters, and default template")
   .action(() => {
     const projectRoot = process.cwd();
     const sdriveRoot = path.join(projectRoot, ".sdrive");
@@ -56,7 +222,9 @@ program
       path.join(sdriveRoot, "reports", "performance"),
       path.join(sdriveRoot, "reports", "docs"),
       path.join(sdriveRoot, "context"),
-      path.join(sdriveRoot, "skills")
+      path.join(sdriveRoot, "skills"),
+      path.join(sdriveRoot, "templates"),
+      path.join(sdriveRoot, "mcp")
     ];
 
     dirs.forEach((dir) => {
@@ -76,6 +244,47 @@ program
       console.log("  Created: .sdrive/constitution.md");
     }
 
+    const configPath = path.join(sdriveRoot, "config.json");
+    if (!fs.existsSync(configPath)) {
+      fs.writeFileSync(configPath, JSON.stringify({ defaultTemplate: "generic" }, null, 2));
+      console.log("  Created: .sdrive/config.json");
+    }
+
+    const teamPath = path.join(sdriveRoot, "team.json");
+    if (!fs.existsSync(teamPath)) {
+      fs.writeFileSync(
+        teamPath,
+        JSON.stringify(
+          {
+            members: [],
+            rules: {
+              approval_required: ["admin", "reviewer"],
+              implementation_allowed: ["developer", "admin"]
+            }
+          },
+          null,
+          2
+        )
+      );
+      console.log("  Created: .sdrive/team.json");
+    }
+
+    // MCP server file
+    const mcpServerPath = path.join(sdriveRoot, "mcp", "server.js");
+    if (!fs.existsSync(mcpServerPath)) {
+      fs.writeFileSync(mcpServerPath, mcpServerContent());
+      fs.chmodSync(mcpServerPath, 0o755);
+      console.log("  Created: .sdrive/mcp/server.js");
+    }
+
+    // MCP config template
+    const mcpConfigPath = path.join(sdriveRoot, "mcp", "mcp.json");
+    if (!fs.existsSync(mcpConfigPath)) {
+      fs.writeFileSync(mcpConfigPath, mcpConfigContent());
+      console.log("  Created: .sdrive/mcp/mcp.json");
+    }
+
+    // Tool selection
     const toolsPath = path.join(sdriveRoot, "commands", "tools.json");
 
     if (!fs.existsSync(toolsPath)) {
@@ -126,10 +335,100 @@ program
         console.log(`✅ Generated: ${tool.adapterPath}`);
       });
 
-      console.log("\n✅ SpecDrive initialized successfully.");
+      const templates = ["generic", "react-node", "nextjs", "expo", "fastapi", "turborepo"];
+
+      console.log("\n📦 Select default template:\n");
+      templates.forEach((t, i) => console.log(`  ${i + 1}. ${t}`));
+
+      const rl2 = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      rl2.question("Template (default: 1): ", (templateAnswer) => {
+        rl2.close();
+
+        const idx = templateAnswer.trim() === "" ? 0 : parseInt(templateAnswer.trim()) - 1;
+        const selectedTemplate = templates[idx] || "generic";
+
+        const cfgPath = path.join(sdriveRoot, "config.json");
+        fs.writeFileSync(cfgPath, JSON.stringify({ defaultTemplate: selectedTemplate }, null, 2));
+
+        console.log(`\n✅ Default template set to: ${selectedTemplate}`);
+
+        // MCP wiring
+        const mcpPaths = getMcpConfigPaths();
+
+        console.log("\n🔌 MCP Client Wiring\n");
+        mcpPaths.forEach((p, i) => {
+          console.log(`  ${i + 1}. ${p.name} (${p.path})`);
+        });
+        console.log("  Or press Enter to skip MCP wiring.\n");
+
+        const rl3 = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+
+        rl3.question("Wire MCP clients: ", (mcpAnswer) => {
+          rl3.close();
+
+          if (mcpAnswer.trim() === "") {
+            console.log("\n⚠️  MCP wiring skipped.");
+            console.log("\n✅ SpecDrive initialized successfully.");
+            return;
+          }
+
+          const selectedIndexes = mcpAnswer.split(",").map((n) => parseInt(n.trim()) - 1);
+          const selectedPaths = selectedIndexes
+            .filter((i) => i >= 0 && i < mcpPaths.length)
+            .map((i) => mcpPaths[i]);
+
+          selectedPaths.forEach((p) => {
+            safeMergeMcpConfig(p.path, mcpConfigContent());
+          });
+
+          console.log("\n✅ SpecDrive initialized successfully.");
+        });
+      });
     });
   });
 
+// ---------- TEMPLATE COMMANDS ----------
+program
+  .command("template:list")
+  .description("List available templates")
+  .action(() => {
+    const templates = ["generic", "react-node", "nextjs", "expo", "fastapi", "turborepo"];
+    console.log("\nAvailable Templates\n");
+    templates.forEach((t) => console.log(`  ${t}`));
+  });
+
+program
+  .command("template:set <name>")
+  .description("Set default template")
+  .action((name) => {
+    const templates = ["generic", "react-node", "nextjs", "expo", "fastapi", "turborepo"];
+
+    if (!templates.includes(name)) {
+      console.error(`❌ Invalid template. Run \`sdrive template:list\` to see available templates.`);
+      process.exit(1);
+    }
+
+    const configPath = path.join(process.cwd(), ".sdrive", "config.json");
+
+    if (!fs.existsSync(configPath)) {
+      console.error("❌ config.json not found. Run `sdrive init` first.");
+      process.exit(1);
+    }
+
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    config.defaultTemplate = name;
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+    console.log(`✅ Default template set to: ${name}`);
+  });
+
 // ---------- VALIDATE COMMAND ----------
 program
   .command("validate")
@@ -178,19 +477,12 @@ program
       `---\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(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)
+      JSON.stringify({ feature, title: feature, version: 1, overview: {}, userStories: [], functionalRequirements: [] }, null, 2)
     );
 
     fs.writeFileSync(
@@ -292,7 +584,6 @@ program
   });
 
 // ---------- TEAM COMMANDS ----------
-
 program
   .command("team:add <username> <role>")
   .description("Add a new team member")
@@ -306,9 +597,7 @@ program
 
     const team = JSON.parse(fs.readFileSync(teamPath, "utf8"));
 
-    if (!team.members) {
-      team.members = [];
-    }
+    if (!team.members) team.members = [];
 
     const existing = team.members.find((m) => m.username === username);
     if (existing) {
@@ -398,4 +687,122 @@ program
     console.log(`✅ Updated ${username} to ${role}.`);
   });
 
+program
+  .command("team:sync")
+  .description("Sync team members from GitHub collaborators")
+  .action(() => {
+    const scriptPath = path.join(process.cwd(), ".sdrive", "scripts", "github-team-sync.js");
+
+    if (!fs.existsSync(scriptPath)) {
+      console.error("❌ github-team-sync.js not found. Run `sdrive init` first.");
+      process.exit(1);
+    }
+
+    try {
+      execSync(`node "${scriptPath}"`, { stdio: "inherit" });
+    } catch (error) {
+      console.error("❌ Team sync failed.");
+      process.exit(1);
+    }
+  });
+
+// ---------- HOOKS ----------
+program
+  .command("hooks:install")
+  .description("Install SpecDrive pre-commit hook")
+  .action(() => {
+    const scriptPath = path.join(process.cwd(), ".sdrive", "scripts", "install-hooks.js");
+
+    if (!fs.existsSync(scriptPath)) {
+      console.error("❌ install-hooks.js not found. Run `sdrive init` first.");
+      process.exit(1);
+    }
+
+    try {
+      execSync(`node "${scriptPath}"`, { stdio: "inherit" });
+    } catch (error) {
+      console.error("❌ Hook installation failed.");
+      process.exit(1);
+    }
+  });
+
+// ---------- MIGRATE ----------
+program
+  .command("migrate")
+  .description("Migrate specs from OpenSpec or Spec-Kit")
+  .action(() => {
+    const scriptPath = path.join(process.cwd(), ".sdrive", "scripts", "migrate.js");
+
+    if (!fs.existsSync(scriptPath)) {
+      console.error("❌ migrate.js not found. Run `sdrive init` first.");
+      process.exit(1);
+    }
+
+    try {
+      execSync(`node "${scriptPath}"`, { stdio: "inherit" });
+    } catch (error) {
+      console.error("❌ Migration failed.");
+      process.exit(1);
+    }
+  });
+
+// ---------- DIFF ----------
+program
+  .command("diff <oldFile> <newFile>")
+  .description("Show differences between two spec files")
+  .action((oldFile, newFile) => {
+    const scriptPath = path.join(process.cwd(), ".sdrive", "scripts", "diff-spec.js");
+
+    if (!fs.existsSync(scriptPath)) {
+      console.error("❌ diff-spec.js not found. Run `sdrive init` first.");
+      process.exit(1);
+    }
+
+    try {
+      execSync(`node "${scriptPath}" "${oldFile}" "${newFile}"`, { stdio: "inherit" });
+    } catch (error) {
+      console.error("❌ Diff failed.");
+      process.exit(1);
+    }
+  });
+
+// ---------- OPENAPI ----------
+program
+  .command("openapi:generate <feature>")
+  .description("Generate OpenAPI spec from plan.json API contracts")
+  .action((feature) => {
+    const scriptPath = path.join(process.cwd(), ".sdrive", "scripts", "generate-openapi.js");
+
+    if (!fs.existsSync(scriptPath)) {
+      console.error("❌ generate-openapi.js not found. Run `sdrive init` first.");
+      process.exit(1);
+    }
+
+    try {
+      execSync(`node "${scriptPath}" "${feature}"`, { stdio: "inherit" });
+    } catch (error) {
+      console.error("❌ OpenAPI generation failed.");
+      process.exit(1);
+    }
+  });
+
+  program
+  .command("dashboard")
+  .description("Start SpecDrive web dashboard")
+  .action(() => {
+    const scriptPath = path.join(process.cwd(), ".sdrive", "dashboard", "server.js");
+
+    if (!fs.existsSync(scriptPath)) {
+      console.error("❌ Dashboard not found. Run `sdrive init` first.");
+      process.exit(1);
+    }
+
+    try {
+      execSync(`node "${scriptPath}"`, { stdio: "inherit" });
+    } catch (error) {
+      console.error("❌ Dashboard failed to start.");
+      process.exit(1);
+    }
+  });
+
 program.parse(process.argv);