specdrive-cli 0.1.10 → 0.1.12

package/scripts/migrate-speckit.js

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+const sdriveRoot = path.join(projectRoot, ".sdrive");
+
+const speckitDir = path.join(projectRoot, ".specify");
+const speckitSpecsDir = path.join(speckitDir, "specs");
+const speckitMemoryDir = path.join(speckitDir, "memory");
+const speckitConstitution = path.join(speckitMemoryDir, "constitution.md");
+
+if (!fs.existsSync(speckitDir)) {
+  console.error("❌ .specify/ folder not found. Nothing to migrate.");
+  process.exit(1);
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function readFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch (error) {
+    return null;
+  }
+}
+
+function listDirectories(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+}
+
+function stripNumberPrefix(name) {
+  // Spec-Kit uses 001-feature-name
+  return name.replace(/^[0-9]+[-_]/, "");
+}
+
+function slugify(name) {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function findInDir(dir, names) {
+  for (const name of names) {
+    const full = path.join(dir, name);
+    if (fs.existsSync(full)) return full;
+  }
+  return null;
+}
+
+function writeSpecDriveFeature(featureName, sourceDir) {
+  const featureFolder = path.join(
+    sdriveRoot,
+    "specs",
+    "ongoing",
+    featureName,
+    "v1"
+  );
+  const govFolder = path.join(sdriveRoot, "governance", featureName, "v1");
+
+  ensureDir(featureFolder);
+  ensureDir(govFolder);
+
+  const specSource = findInDir(sourceDir, ["spec.md", "specification.md"]);
+  const planSource = findInDir(sourceDir, ["plan.md", "technical-plan.md"]);
+  const tasksSource = findInDir(sourceDir, ["tasks.md", "todo.md"]);
+
+  const now = new Date().toISOString();
+
+  const specContent = specSource
+    ? readFile(specSource)
+    : `# ${featureName}\n\n(Migrated from Spec-Kit — no source spec found)`;
+
+  const planContent = planSource
+    ? readFile(planSource)
+    : `# Technical Plan: ${featureName} (migrated)\n\nThis plan was migrated from Spec-Kit. No technical plan was extracted.\n`;
+
+  const tasksContent = tasksSource
+    ? readFile(tasksSource)
+    : `# Execution Tasks: ${featureName}\n\n(Migrated from Spec-Kit — no tasks found)\n`;
+
+  // spec.md
+  fs.writeFileSync(
+    path.join(featureFolder, "spec.md"),
+    `---
+title: ${featureName}
+status: ongoing
+version: v1
+created: ${now}
+updated: ${now}
+retroactive: true
+migratedFrom: speckit
+---
+
+${specContent}
+`
+  );
+
+  // plan.md
+  fs.writeFileSync(path.join(featureFolder, "plan.md"), planContent);
+
+  // tasks.md
+  fs.writeFileSync(path.join(featureFolder, "tasks.md"), tasksContent);
+
+  // governance JSON
+  fs.writeFileSync(
+    path.join(govFolder, "spec.json"),
+    JSON.stringify(
+      {
+        feature: featureName,
+        title: featureName,
+        version: 1,
+        retroactive: true,
+        migratedFrom: "speckit",
+        overview: {
+          problemStatement: "(migrated from Spec-Kit)",
+          proposedSolution: "(migrated from Spec-Kit)",
+          targetAudience: "(migrated from Spec-Kit)"
+        },
+        userStories: [],
+        functionalRequirements: []
+      },
+      null,
+      2
+    )
+  );
+
+  fs.writeFileSync(
+    path.join(govFolder, "plan.json"),
+    JSON.stringify(
+      {
+        feature: featureName,
+        version: 1,
+        architecture: { approach: "(migrated)", components: [] },
+        dataModel: { entities: [], flowDescription: "(migrated)" }
+      },
+      null,
+      2
+    )
+  );
+
+  fs.writeFileSync(
+    path.join(govFolder, "tasks.json"),
+    JSON.stringify(
+      { feature: featureName, version: 1, phases: [] },
+      null,
+      2
+    )
+  );
+
+  fs.writeFileSync(
+    path.join(govFolder, "traceability.json"),
+    JSON.stringify(
+      { feature: featureName, version: 1, rows: [] },
+      null,
+      2
+    )
+  );
+
+  return {
+    feature: featureName,
+    source: path.relative(projectRoot, sourceDir),
+    spec: specSource ? path.relative(projectRoot, specSource) : null,
+    plan: planSource ? path.relative(projectRoot, planSource) : null,
+    tasks: tasksSource ? path.relative(projectRoot, tasksSource) : null
+  };
+}
+
+function migrateSpecs() {
+  const migrated = [];
+
+  if (!fs.existsSync(speckitSpecsDir)) {
+    return migrated;
+  }
+
+  const folders = listDirectories(speckitSpecsDir);
+
+  for (const folder of folders) {
+    const cleaned = stripNumberPrefix(folder);
+    const featureName = slugify(cleaned);
+    const sourceDir = path.join(speckitSpecsDir, folder);
+
+    const result = writeSpecDriveFeature(featureName, sourceDir);
+    migrated.push(result);
+    console.log(`✅ Migrated spec: ${featureName}`);
+  }
+
+  return migrated;
+}
+
+function migrateConstitution() {
+  if (!fs.existsSync(speckitConstitution)) {
+    return false;
+  }
+
+  const content = readFile(speckitConstitution);
+  if (!content) return false;
+
+  const targetConstitution = path.join(sdriveRoot, "constitution.md");
+
+  if (fs.existsSync(targetConstitution)) {
+    // Append instead of overwrite
+    const existing = readFile(targetConstitution) || "";
+    fs.writeFileSync(
+      targetConstitution,
+      `${existing}\n\n---\n\n## Migrated from Spec-Kit\n\n${content}\n`
+    );
+    console.log("✅ Appended Spec-Kit constitution to existing SpecDrive constitution.");
+  } else {
+    fs.writeFileSync(
+      targetConstitution,
+      `# Project Constitution\n\n> Migrated from Spec-Kit\n\n${content}\n`
+    );
+    console.log("✅ Created SpecDrive constitution from Spec-Kit constitution.");
+  }
+
+  return true;
+}
+
+function updateWorkflowState(migrated) {
+  const statePath = path.join(sdriveRoot, "workflow-state.json");
+
+  let state = { features: [] };
+  if (fs.existsSync(statePath)) {
+    state = JSON.parse(fs.readFileSync(statePath, "utf8"));
+  }
+
+  if (!state.onboarding) {
+    state.onboarding = {
+      mode: "brownfield",
+      date: new Date().toISOString(),
+      missing: [],
+      deferred: [],
+      retroactiveFeatures: [],
+      verifiedFeatures: [],
+      notes: ""
+    };
+  }
+
+  if (!state.onboarding.migrated) {
+    state.onboarding.migrated = [];
+  }
+
+  for (const item of migrated) {
+    const existing = state.features.find((f) => f.name === item.feature);
+
+    if (!existing) {
+      state.features.push({
+        name: item.feature,
+        currentVersion: "v1",
+        versions: [
+          {
+            id: "v1",
+            phase: "ongoing",
+            currentStep: "review",
+            gates: {
+              specification: "pending",
+              planning: "pending",
+              implementation: "pending",
+              review: "pending"
+            },
+            history: [
+              {
+                event: "feature_migrated",
+                timestamp: new Date().toISOString(),
+                by: "onboarding"
+              }
+            ]
+          }
+        ]
+      });
+    }
+
+    state.onboarding.migrated.push({
+      feature: item.feature,
+      from: "speckit",
+      date: new Date().toISOString(),
+      source: item.source
+    });
+
+    if (!state.onboarding.retroactiveFeatures.includes(item.feature)) {
+      state.onboarding.retroactiveFeatures.push(item.feature);
+    }
+  }
+
+  fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+}
+
+function main() {
+  console.log("🔍 Migrating from Spec-Kit...\n");
+
+  const migrated = migrateSpecs();
+  const constitutionMigrated = migrateConstitution();
+
+  if (migrated.length === 0 && !constitutionMigrated) {
+    console.log("\n⚠️  No Spec-Kit features or constitution found to migrate.");
+    process.exit(0);
+  }
+
+  updateWorkflowState(migrated);
+
+  console.log("");
+  console.log(`✅ Migration complete: ${migrated.length} features.`);
+  if (constitutionMigrated) {
+    console.log("✅ Constitution merged.");
+  }
+  console.log("");
+  console.log("Original .specify/ folder was NOT deleted.");
+  console.log("All migrated features are marked retroactive: true.");
+  console.log("");
+  console.log("Next: run sdrive validate to confirm the new files.");
+}
+
+main();

package/scripts/migrate.js

@@ -1,62 +1,12 @@
-#!/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();
+#!/usr/bin/env node
+
+console.error("⚠️  `sdrive migrate` is deprecated.");
+console.error("");
+console.error("Migration now happens during Brownfield Onboarding.");
+console.error("");
+console.error("Run:");
+console.error("   sdrive onboard");
+console.error("   /sdrive:onboard");
+console.error("");
+console.error("The Onboarding Agent will detect OpenSpec or Spec-Kit and offer to migrate.");
+process.exit(1);

package/scripts/onboard.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+const sdriveRoot = path.join(projectRoot, ".sdrive");
+const onboardingDir = path.join(sdriveRoot, "onboarding");
+
+const inventoryPath = path.join(onboardingDir, "inventory.json");
+const reportPath = path.join(onboardingDir, "report.md");
+
+const DETECT_FILES = {
+  manifests: [
+    "package.json",
+    "requirements.txt",
+    "pyproject.toml",
+    "go.mod",
+    "pubspec.yaml",
+    "Cargo.toml",
+    "pom.xml",
+    "build.gradle"
+  ],
+  docs: [
+    "README.md",
+    "CONTRIBUTING.md"
+  ],
+  codeRoots: [
+    "src",
+    "app",
+    "lib",
+    "pages",
+    "server",
+    "internal",
+    "cmd",
+    "pkg",
+    "api",
+    "apps",
+    "packages"
+  ],
+  ci: [
+    ".github/workflows",
+    ".gitlab-ci.yml"
+  ],
+  tests: [
+    "tests",
+    "__tests__",
+    "spec",
+    "test"
+  ],
+  configs: [
+    "tsconfig.json",
+    "jsconfig.json",
+    ".eslintrc",
+    ".eslintrc.js",
+    ".eslintrc.json",
+    ".prettierrc",
+    ".prettierrc.js",
+    ".prettierrc.json"
+  ],
+  specdrive: [
+    ".sdrive/constitution.md",
+    ".sdrive/skills",
+    ".sdrive/specs",
+    ".sdrive/governance",
+    ".sdrive/workflow-state.json",
+    ".sdrive/schemas",
+    ".sdrive/scripts",
+    ".sdrive/commands",
+    ".sdrive/agents",
+    ".sdrive/dashboard",
+    ".sdrive/mcp"
+  ],
+  externalSpecSystems: [
+    "openspec",
+    "openspec/specs",
+    "openspec/changes",
+    "openspec/archive",
+    ".specify",
+    ".specify/specs",
+    ".specify/memory"
+  ]
+};
+
+function exists(relativePath) {
+  return fs.existsSync(path.join(projectRoot, relativePath));
+}
+
+function countFiles(relativePath) {
+  const full = path.join(projectRoot, relativePath);
+
+  if (!fs.existsSync(full)) return 0;
+
+  const stat = fs.statSync(full);
+  if (!stat.isDirectory()) return 1;
+
+  let count = 0;
+  const walk = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      const fullEntry = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullEntry);
+      } else {
+        count++;
+      }
+    }
+  };
+  walk(full);
+  return count;
+}
+
+function scanSection(list) {
+  const result = [];
+  for (const relativePath of list) {
+    const present = exists(relativePath);
+    result.push({
+      path: relativePath,
+      present,
+      fileCount: present ? countFiles(relativePath) : 0
+    });
+  }
+  return result;
+}
+
+function detectExternalSpecSystems() {
+  const detection = {
+    openspec: {
+      detected: false,
+      specs: 0,
+      changes: 0,
+      archived: 0
+    },
+    speckit: {
+      detected: false,
+      specs: 0,
+      hasConstitution: false
+    }
+  };
+
+  // OpenSpec detection
+  const openspecDir = path.join(projectRoot, "openspec");
+  if (fs.existsSync(openspecDir)) {
+    detection.openspec.detected = true;
+
+    const specsDir = path.join(openspecDir, "specs");
+    const changesDir = path.join(openspecDir, "changes");
+    const archiveDir = path.join(openspecDir, "archive");
+
+    if (fs.existsSync(specsDir)) {
+      detection.openspec.specs = fs
+        .readdirSync(specsDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory()).length;
+    }
+
+    if (fs.existsSync(changesDir)) {
+      detection.openspec.changes = fs
+        .readdirSync(changesDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory()).length;
+    }
+
+    if (fs.existsSync(archiveDir)) {
+      detection.openspec.archived = fs
+        .readdirSync(archiveDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory()).length;
+    }
+  }
+
+  // Spec-Kit detection
+  const speckitDir = path.join(projectRoot, ".specify");
+  if (fs.existsSync(speckitDir)) {
+    detection.speckit.detected = true;
+
+    const specsDir = path.join(speckitDir, "specs");
+    const constitutionPath = path.join(speckitDir, "memory", "constitution.md");
+
+    if (fs.existsSync(specsDir)) {
+      detection.speckit.specs = fs
+        .readdirSync(specsDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory()).length;
+    }
+
+    if (fs.existsSync(constitutionPath)) {
+      detection.speckit.hasConstitution = true;
+    }
+  }
+
+  return detection;
+}
+
+function buildInventory() {
+  const inventory = {
+    projectRoot,
+    scannedAt: new Date().toISOString(),
+    mode: "brownfield",
+    sections: {
+      manifests: scanSection(DETECT_FILES.manifests),
+      docs: scanSection(DETECT_FILES.docs),
+      codeRoots: scanSection(DETECT_FILES.codeRoots),
+      ci: scanSection(DETECT_FILES.ci),
+      tests: scanSection(DETECT_FILES.tests),
+      configs: scanSection(DETECT_FILES.configs),
+      specdrive: scanSection(DETECT_FILES.specdrive),
+      externalSpecSystems: scanSection(DETECT_FILES.externalSpecSystems)
+    },
+    detectedSystems: detectExternalSpecSystems(),
+    missing: [],
+    present: [],
+    deferred: []
+  };
+
+  const flatten = (section) => section.map((item) => item);
+
+  const all = [
+    ...flatten(inventory.sections.manifests),
+    ...flatten(inventory.sections.docs),
+    ...flatten(inventory.sections.codeRoots),
+    ...flatten(inventory.sections.ci),
+    ...flatten(inventory.sections.tests),
+    ...flatten(inventory.sections.configs),
+    ...flatten(inventory.sections.specdrive)
+  ];
+
+  for (const item of all) {
+    if (item.present) {
+      inventory.present.push(item.path);
+    } else {
+      inventory.missing.push(item.path);
+    }
+  }
+
+  return inventory;
+}
+
+function buildReport(inventory) {
+  const lines = [];
+
+  lines.push("# Onboarding Report");
+  lines.push("");
+  lines.push(`Scanned at: ${inventory.scannedAt}`);
+  lines.push(`Project root: ${inventory.projectRoot}`);
+  lines.push("");
+
+  // External Spec Systems
+  const ext = inventory.detectedSystems || {};
+  if (ext.openspec?.detected || ext.speckit?.detected) {
+    lines.push("## Detected External Spec Systems");
+    if (ext.openspec?.detected) {
+      lines.push(`- ✅ OpenSpec`);
+      lines.push(`  - Specs: ${ext.openspec.specs}`);
+      lines.push(`  - Active changes: ${ext.openspec.changes}`);
+      lines.push(`  - Archived: ${ext.openspec.archived}`);
+    }
+    if (ext.speckit?.detected) {
+      lines.push(`- ✅ Spec-Kit`);
+      lines.push(`  - Specs: ${ext.speckit.specs}`);
+      lines.push(`  - Constitution: ${ext.speckit.hasConstitution ? "found" : "missing"}`);
+    }
+    lines.push("");
+    lines.push("> These can be migrated into SpecDrive during onboarding via the Onboarding Agent.");
+    lines.push("");
+  }
+
+  lines.push("## Present");
+  inventory.present.forEach((p) => lines.push(`- ✅ ${p}`));
+  lines.push("");
+  lines.push("## Missing");
+  inventory.missing.forEach((p) => lines.push(`- ❌ ${p}`));
+  lines.push("");
+  lines.push("## Deferred");
+  if (inventory.deferred.length === 0) {
+    lines.push("(none yet)");
+  } else {
+    inventory.deferred.forEach((p) => lines.push(`- ⚠️  ${p}`));
+  }
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+function main() {
+  fs.mkdirSync(onboardingDir, { recursive: true });
+
+  const inventory = buildInventory();
+  fs.writeFileSync(inventoryPath, JSON.stringify(inventory, null, 2));
+
+  const report = buildReport(inventory);
+  fs.writeFileSync(reportPath, report);
+
+  console.log(`✅ Inventory written: ${path.relative(projectRoot, inventoryPath)}`);
+  console.log(`✅ Report written:    ${path.relative(projectRoot, reportPath)}`);
+  console.log("");
+  console.log(`Present:  ${inventory.present.length}`);
+  console.log(`Missing:  ${inventory.missing.length}`);
+  console.log(`Deferred: ${inventory.deferred.length}`);
+
+  const ext = inventory.detectedSystems || {};
+  if (ext.openspec?.detected || ext.speckit?.detected) {
+    console.log("");
+    console.log("🔍 External Spec Systems Detected:");
+    if (ext.openspec?.detected) {
+      console.log(`   - OpenSpec (${ext.openspec.specs} specs, ${ext.openspec.changes} changes)`);
+    }
+    if (ext.speckit?.detected) {
+      console.log(`   - Spec-Kit (${ext.speckit.specs} specs)`);
+    }
+    console.log("");
+    console.log("   Run /sdrive:onboard to migrate them.");
+  }
+}
+
+main();