specweave 0.26.14 → 0.27.0

package/plugins/specweave-ado/lib/enhanced-ado-sync.js

@@ -0,0 +1,170 @@
+import { AdoClientV2 } from "./ado-client-v2.js";
+import { EnhancedContentBuilder } from "../../../src/core/sync/enhanced-content-builder.js";
+import { SpecIncrementMapper } from "../../../src/core/sync/spec-increment-mapper.js";
+import { parseSpecContent } from "../../../src/core/spec-content-sync.js";
+import path from "path";
+import fs from "fs/promises";
+async function syncSpecToAdoWithEnhancedContent(options) {
+  const { specPath, organization, project, dryRun = false, verbose = false } = options;
+  try {
+    const baseSpec = await parseSpecContent(specPath);
+    if (!baseSpec) {
+      return {
+        success: false,
+        action: "error",
+        error: "Failed to parse spec content"
+      };
+    }
+    if (verbose) {
+      console.log(`\u{1F4C4} Parsed spec: ${baseSpec.identifier.compact}`);
+    }
+    const specId = baseSpec.identifier.full || baseSpec.identifier.compact;
+    const rootDir = await findSpecWeaveRoot(specPath);
+    const mapper = new SpecIncrementMapper(rootDir);
+    const mapping = await mapper.mapSpecToIncrements(specId);
+    if (verbose) {
+      console.log(`\u{1F517} Found ${mapping.increments.length} related increments`);
+    }
+    const taskMapping = buildTaskMapping(mapping.increments, organization, project);
+    const architectureDocs = await findArchitectureDocs(rootDir, specId);
+    const enhancedSpec = {
+      ...baseSpec,
+      summary: baseSpec.description,
+      taskMapping,
+      architectureDocs
+    };
+    const builder = new EnhancedContentBuilder();
+    const description = builder.buildExternalDescription(enhancedSpec);
+    if (verbose) {
+      console.log(`\u{1F4DD} Generated description: ${description.length} characters`);
+    }
+    if (dryRun) {
+      console.log("\u{1F50D} DRY RUN - Would create/update feature with:");
+      console.log(`   Title: ${baseSpec.title}`);
+      console.log(`   Description length: ${description.length}`);
+      return {
+        success: true,
+        action: "no-change",
+        tasksLinked: taskMapping?.tasks.length || 0
+      };
+    }
+    if (!organization || !project) {
+      return {
+        success: false,
+        action: "error",
+        error: "Azure DevOps organization/project not specified"
+      };
+    }
+    const profile = {
+      provider: "ado",
+      displayName: `${organization}/${project}`,
+      config: {
+        organization,
+        project
+      },
+      timeRange: { default: "1M", max: "6M" }
+    };
+    const pat = process.env.AZURE_DEVOPS_PAT || "";
+    const client = new AdoClientV2(profile, pat);
+    const existingFeature = await findExistingFeature(client, baseSpec.identifier.compact);
+    let result;
+    if (existingFeature) {
+      await client.updateWorkItem(existingFeature.id, {
+        title: `[${baseSpec.identifier.compact}] ${baseSpec.title}`,
+        description
+      });
+      result = {
+        success: true,
+        action: "updated",
+        featureId: existingFeature.id,
+        featureUrl: `https://dev.azure.com/${organization}/${project}/_workitems/edit/${existingFeature.id}`,
+        tasksLinked: taskMapping?.tasks.length || 0
+      };
+    } else {
+      const feature = await client.createEpic({
+        title: `[${baseSpec.identifier.compact}] ${baseSpec.title}`,
+        description,
+        tags: ["spec", "external-tool-sync"]
+      });
+      result = {
+        success: true,
+        action: "created",
+        featureId: feature.id,
+        featureUrl: `https://dev.azure.com/${organization}/${project}/_workitems/edit/${feature.id}`,
+        tasksLinked: taskMapping?.tasks.length || 0
+      };
+    }
+    if (verbose) {
+      console.log(`\u2705 ${result.action === "created" ? "Created" : "Updated"} feature #${result.featureId}`);
+    }
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      action: "error",
+      error: error.message
+    };
+  }
+}
+async function findSpecWeaveRoot(specPath) {
+  let currentDir = path.dirname(specPath);
+  while (true) {
+    const specweaveDir = path.join(currentDir, ".specweave");
+    try {
+      await fs.access(specweaveDir);
+      return currentDir;
+    } catch {
+      const parentDir = path.dirname(currentDir);
+      if (parentDir === currentDir) {
+        throw new Error(".specweave directory not found");
+      }
+      currentDir = parentDir;
+    }
+  }
+}
+function buildTaskMapping(increments, organization, project) {
+  if (increments.length === 0) return void 0;
+  const firstIncrement = increments[0];
+  const tasks = firstIncrement.tasks.map((task) => ({
+    id: task.id,
+    title: task.title,
+    userStories: task.userStories
+  }));
+  return {
+    incrementId: firstIncrement.id,
+    tasks,
+    tasksUrl: `https://dev.azure.com/${organization}/${project}/_git/repo?path=/.specweave/increments/${firstIncrement.id}/tasks.md`
+  };
+}
+async function findArchitectureDocs(rootDir, specId) {
+  const docs = [];
+  const archDir = path.join(rootDir, ".specweave/docs/internal/architecture");
+  try {
+    const adrDir = path.join(archDir, "adr");
+    try {
+      const adrs = await fs.readdir(adrDir);
+      const relatedAdrs = adrs.filter((file) => file.includes(specId.replace("spec-", "")));
+      for (const adr of relatedAdrs) {
+        docs.push({
+          type: "adr",
+          path: path.join(adrDir, adr),
+          title: adr.replace(".md", "").replace(/-/g, " ")
+        });
+      }
+    } catch {
+    }
+  } catch {
+  }
+  return docs;
+}
+async function findExistingFeature(client, specId) {
+  try {
+    const features = await client.queryWorkItems(`[System.Title] Contains '[${specId}]' AND [System.WorkItemType] = 'Feature'`);
+    return features[0] || null;
+  } catch {
+    return null;
+  }
+}
+export {
+  syncSpecToAdoWithEnhancedContent
+};

package/plugins/specweave-ado/lib/project-selector.js

@@ -1,4 +1,4 @@
-import inquirer from "inquirer";
+import { select, checkbox, input, Separator } from "@inquirer/prompts";
 async function fetchAllAdoProjects(client) {
   console.log("\u{1F50D} Fetching Azure DevOps projects...");
   try {
@@ -31,29 +31,25 @@ async function selectAdoProjects(client, options = {}) {
   console.log("\u{1F4CB} Available Azure DevOps Projects:\n");
   console.log(`   Total: ${allProjects.length} projects
 `);
-  const { selectionMethod } = await inquirer.prompt([
-    {
-      type: "select",
-      name: "selectionMethod",
-      message: "How would you like to select projects?",
-      choices: [
-        {
-          name: `\u{1F4CB} Interactive (browse and select from ${allProjects.length} projects)`,
-          value: "interactive"
-        },
+  const selectionMethod = await select({
+    message: "How would you like to select projects?",
+    choices: [
+      {
+        name: `\u{1F4CB} Interactive (browse and select from ${allProjects.length} projects)`,
+        value: "interactive"
+      },
+      {
+        name: "\u270F\uFE0F  Manual entry (type project names)",
+        value: "manual"
+      },
+      ...allowSelectAll ? [
         {
-          name: "\u270F\uFE0F  Manual entry (type project names)",
-          value: "manual"
-        },
-        ...allowSelectAll ? [
-          {
-            name: `\u2728 Select all (${allProjects.length} projects)`,
-            value: "all"
-          }
-        ] : []
-      ]
-    }
-  ]);
+          name: `\u2728 Select all (${allProjects.length} projects)`,
+          value: "all"
+        }
+      ] : []
+    ]
+  });
   if (selectionMethod === "all") {
     return {
       selectedNames: allProjects.map((p) => p.name),
@@ -73,39 +69,36 @@ async function selectAdoProjects(client, options = {}) {
 }
 async function interactiveProjectSelection(allProjects, preSelected, minSelection, maxSelection, pageSize) {
   console.log("\u{1F4A1} Use <space> to select, <a> to toggle all, <i> to invert\n");
-  const choices = allProjects.map((p) => ({
-    name: formatProjectChoice(p),
-    value: p.name,
-    checked: preSelected.includes(p.name)
-  }));
-  choices.push(
-    new inquirer.Separator(),
+  const choices = [
+    ...allProjects.map((p) => ({
+      name: formatProjectChoice(p),
+      value: p.name,
+      checked: preSelected.includes(p.name)
+    })),
+    // Add separator and manual entry option at the end
+    new Separator(),
     {
       name: "\u270F\uFE0F  Enter project names manually instead",
       value: "__MANUAL__",
       checked: false
     }
-  );
-  const { selectedNames } = await inquirer.prompt([
-    {
-      type: "checkbox",
-      name: "selectedNames",
-      message: `Select Azure DevOps projects (${minSelection}${maxSelection ? `-${maxSelection}` : "+"} required):`,
-      choices,
-      pageSize,
-      loop: false,
-      validate: (selected) => {
-        const actualSelected = selected.filter((k) => k !== "__MANUAL__");
-        if (actualSelected.length < minSelection) {
-          return `Please select at least ${minSelection} project(s)`;
-        }
-        if (maxSelection && actualSelected.length > maxSelection) {
-          return `Please select at most ${maxSelection} project(s)`;
-        }
-        return true;
+  ];
+  const selectedNames = await checkbox({
+    message: `Select Azure DevOps projects (${minSelection}${maxSelection ? `-${maxSelection}` : "+"} required):`,
+    choices,
+    pageSize,
+    loop: false,
+    validate: (selected) => {
+      const actualSelected = selected.filter((k) => k !== "__MANUAL__");
+      if (actualSelected.length < minSelection) {
+        return `Please select at least ${minSelection} project(s)`;
       }
+      if (maxSelection && actualSelected.length > maxSelection) {
+        return `Please select at most ${maxSelection} project(s)`;
+      }
+      return true;
     }
-  ]);
+  });
   if (selectedNames.includes("__MANUAL__")) {
     return await manualProjectEntry(allProjects, minSelection, maxSelection);
   }
@@ -127,26 +120,22 @@ async function manualProjectEntry(allProjects, minSelection, maxSelection) {
     );
     console.log("");
   }
-  const { manualNames } = await inquirer.prompt([
-    {
-      type: "input",
-      name: "manualNames",
-      message: "Project names:",
-      validate: (input) => {
-        if (!input.trim()) {
-          return "Please enter at least one project name";
-        }
-        const names = input.split(",").map((n) => n.trim()).filter((n) => n.length > 0);
-        if (names.length < minSelection) {
-          return `Please enter at least ${minSelection} project name(s)`;
-        }
-        if (maxSelection && names.length > maxSelection) {
-          return `Please enter at most ${maxSelection} project name(s)`;
-        }
-        return true;
+  const manualNames = await input({
+    message: "Project names:",
+    validate: (inputValue) => {
+      if (!inputValue.trim()) {
+        return "Please enter at least one project name";
+      }
+      const names = inputValue.split(",").map((n) => n.trim()).filter((n) => n.length > 0);
+      if (names.length < minSelection) {
+        return `Please enter at least ${minSelection} project name(s)`;
       }
+      if (maxSelection && names.length > maxSelection) {
+        return `Please enter at most ${maxSelection} project name(s)`;
+      }
+      return true;
     }
-  ]);
+  });
   const selectedNames = manualNames.split(",").map((n) => n.trim()).filter((n) => n.length > 0);
   const knownNames = allProjects.map((p) => p.name);
   const unknownNames = selectedNames.filter((n) => !knownNames.includes(n));

package/plugins/specweave-ado/lib/project-selector.ts

@@ -9,7 +9,7 @@
  * - Validates project names
  */
 
-import inquirer from 'inquirer';
+import { select, checkbox, input, Separator } from '@inquirer/prompts';
 import { AdoClient } from '../../../src/integrations/ado/ado-client.js';
 
 // ============================================================================
@@ -101,31 +101,27 @@ export async function selectAdoProjects(
   console.log(`   Total: ${allProjects.length} projects\n`);
 
   // Decide selection method
-  const { selectionMethod } = await inquirer.prompt([
-    {
-      type: 'select',
-      name: 'selectionMethod',
-      message: 'How would you like to select projects?',
-      choices: [
-        {
-          name: `📋 Interactive (browse and select from ${allProjects.length} projects)`,
-          value: 'interactive',
-        },
-        {
-          name: '✏️  Manual entry (type project names)',
-          value: 'manual',
-        },
-        ...(allowSelectAll
-          ? [
-              {
-                name: `✨ Select all (${allProjects.length} projects)`,
-                value: 'all',
-              },
-            ]
-          : []),
-      ],
-    },
-  ]);
+  const selectionMethod = await select({
+    message: 'How would you like to select projects?',
+    choices: [
+      {
+        name: `📋 Interactive (browse and select from ${allProjects.length} projects)`,
+        value: 'interactive' as const,
+      },
+      {
+        name: '✏️  Manual entry (type project names)',
+        value: 'manual' as const,
+      },
+      ...(allowSelectAll
+        ? [
+            {
+              name: `✨ Select all (${allProjects.length} projects)`,
+              value: 'all' as const,
+            },
+          ]
+        : []),
+    ],
+  });
 
   if (selectionMethod === 'all') {
     return {
@@ -160,45 +156,40 @@ async function interactiveProjectSelection(
 ): Promise<ProjectSelectionResult> {
   console.log('💡 Use <space> to select, <a> to toggle all, <i> to invert\n');
 
-  const choices = allProjects.map((p) => ({
-    name: formatProjectChoice(p),
-    value: p.name,
-    checked: preSelected.includes(p.name),
-  }));
-
-  // Add manual entry option at the end
-  choices.push(
-    new inquirer.Separator(),
+  const choices = [
+    ...allProjects.map((p) => ({
+      name: formatProjectChoice(p),
+      value: p.name,
+      checked: preSelected.includes(p.name),
+    })),
+    // Add separator and manual entry option at the end
+    new Separator(),
     {
       name: '✏️  Enter project names manually instead',
       value: '__MANUAL__',
       checked: false,
-    } as any
-  );
+    },
+  ];
 
-  const { selectedNames } = await inquirer.prompt([
-    {
-      type: 'checkbox',
-      name: 'selectedNames',
-      message: `Select Azure DevOps projects (${minSelection}${maxSelection ? `-${maxSelection}` : '+'} required):`,
-      choices,
-      pageSize,
-      loop: false,
-      validate: (selected: string[]) => {
-        const actualSelected = selected.filter((k) => k !== '__MANUAL__');
-
-        if (actualSelected.length < minSelection) {
-          return `Please select at least ${minSelection} project(s)`;
-        }
-
-        if (maxSelection && actualSelected.length > maxSelection) {
-          return `Please select at most ${maxSelection} project(s)`;
-        }
-
-        return true;
-      },
+  const selectedNames = await checkbox({
+    message: `Select Azure DevOps projects (${minSelection}${maxSelection ? `-${maxSelection}` : '+'} required):`,
+    choices,
+    pageSize,
+    loop: false,
+    validate: (selected: readonly string[]) => {
+      const actualSelected = selected.filter((k) => k !== '__MANUAL__');
+
+      if (actualSelected.length < minSelection) {
+        return `Please select at least ${minSelection} project(s)`;
+      }
+
+      if (maxSelection && actualSelected.length > maxSelection) {
+        return `Please select at most ${maxSelection} project(s)`;
+      }
+
+      return true;
     },
-  ]);
+  });
 
   // Check if user chose manual entry
   if (selectedNames.includes('__MANUAL__')) {
@@ -235,33 +226,29 @@ async function manualProjectEntry(
     console.log('');
   }
 
-  const { manualNames } = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'manualNames',
-      message: 'Project names:',
-      validate: (input: string) => {
-        if (!input.trim()) {
-          return 'Please enter at least one project name';
-        }
-
-        const names = input
-          .split(',')
-          .map((n) => n.trim())
-          .filter((n) => n.length > 0);
-
-        if (names.length < minSelection) {
-          return `Please enter at least ${minSelection} project name(s)`;
-        }
-
-        if (maxSelection && names.length > maxSelection) {
-          return `Please enter at most ${maxSelection} project name(s)`;
-        }
-
-        return true;
-      },
+  const manualNames = await input({
+    message: 'Project names:',
+    validate: (inputValue: string) => {
+      if (!inputValue.trim()) {
+        return 'Please enter at least one project name';
+      }
+
+      const names = inputValue
+        .split(',')
+        .map((n) => n.trim())
+        .filter((n) => n.length > 0);
+
+      if (names.length < minSelection) {
+        return `Please enter at least ${minSelection} project name(s)`;
+      }
+
+      if (maxSelection && names.length > maxSelection) {
+        return `Please enter at most ${maxSelection} project name(s)`;
+      }
+
+      return true;
     },
-  ]);
+  });
 
   const selectedNames = manualNames
     .split(',')