specweave 0.21.3 → 0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specweave",
-  "version": "0.21.3",
+  "version": "0.22.0",
   "description": "Spec-driven development framework for Claude Code. AI-native workflow with living documentation, intelligent agents, and multilingual support (9 languages). Enterprise-grade traceability with permanent specs and temporary increments.",
   "type": "module",
   "main": "dist/index.js",
@@ -16,17 +16,18 @@
     "dev": "tsc --watch",
     "prepare": "npm run build",
     "prepublishOnly": "npm run rebuild",
-    "test:unit": "jest tests/unit --coverage",
-    "test:integration": "jest tests/integration --coverage",
+    "test:unit": "vitest run tests/unit --coverage",
+    "test:integration": "vitest run tests/integration --coverage",
     "test:smoke": "bash tests/smoke/smoke-test.sh",
     "test:e2e": "playwright test tests/e2e/ --grep-invert=\"(should default to claude adapter|should use claude adapter when explicitly requested|should use generic adapter|should create .claude|should initialize project with specweave init|should create correct directory structure|should handle non-interactive mode correctly|should validate config.json structure|should create .specweave directory structure|should create CLAUDE.md and AGENTS.md|should initialize git repository|should install SpecWeave|should scaffold SaaS|should create proper directory|should create required configuration|should install core skills|should install core agents|should have deployment|should have Stripe|ADO Sync|Increment Discipline Blocking|Self-Reflection|Increment Discipline Enforcement)\"",
     "test:all": "npm run test:unit && npm run test:integration && npm run test:e2e",
-    "test:coverage": "jest --coverage --coverageReporters=text --coverageReporters=lcov",
+    "test:coverage": "vitest run --coverage",
     "test": "npm run test:smoke",
     "benchmark": "ts-node tests/performance/run-all-benchmarks.ts",
     "validate:plugins": "node scripts/validate-plugin-manifests.cjs",
     "validate:platforms": "npx ts-node scripts/validate-platforms.ts",
     "metrics:dora": "node dist/src/metrics/dora-calculator.js",
+    "migrate:copy-sync": "node scripts/migrate-to-copy-based-sync.js",
     "generate:diagrams": "bash scripts/generate-diagram-svgs.sh",
     "docs:dev": "cd docs-site && npm start",
     "docs:build": "cd docs-site && npm run build",
@@ -94,15 +95,15 @@
     "@playwright/test": "^1.48.0",
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^9.0.7",
-    "@types/jest": "^30.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.10.0",
+    "@vitest/coverage-v8": "^2.1.0",
+    "@vitest/ui": "^2.1.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "dotenv": "^17.2.3",
     "gray-matter": "^4.0.3",
-    "jest": "^30.2.0",
-    "ts-jest": "^29.4.5",
-    "typescript": "^5.3.0"
+    "typescript": "^5.3.0",
+    "vitest": "^2.1.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-github/lib/CodeValidator.js

@@ -0,0 +1,195 @@
+import fs from "fs-extra";
+import path from "path";
+class CodeValidator {
+  constructor(options = {}) {
+    this.options = {
+      minLines: options.minLines ?? 3,
+      minChars: options.minChars ?? 50,
+      projectRoot: options.projectRoot ?? process.cwd()
+    };
+  }
+  /**
+   * Validate that code exists for a task
+   *
+   * Extracts file paths from task description and verifies:
+   * 1. Files exist
+   * 2. Files have meaningful content
+   * 3. Files are not just stubs
+   *
+   * @param taskDescription - Task description with file paths
+   * @param taskId - Task ID for error messages
+   * @returns Validation result
+   */
+  async validateTask(taskDescription, taskId) {
+    const filePaths = this.extractFilePaths(taskDescription);
+    if (filePaths.length === 0) {
+      return {
+        taskId,
+        valid: true,
+        files: [],
+        reason: "No file paths specified in task description"
+      };
+    }
+    const fileResults = [];
+    let allValid = true;
+    const reasons = [];
+    for (const filePath of filePaths) {
+      const result = await this.validateFile(filePath);
+      fileResults.push(result);
+      if (!result.exists) {
+        allValid = false;
+        reasons.push(`File not found: ${filePath}`);
+      } else if (!result.hasContent) {
+        allValid = false;
+        reasons.push(`File has no meaningful content: ${filePath} (${result.reason})`);
+      }
+    }
+    return {
+      taskId,
+      valid: allValid,
+      files: fileResults,
+      reason: reasons.length > 0 ? reasons.join("; ") : void 0
+    };
+  }
+  /**
+   * Validate a single file
+   *
+   * @param filePath - Path to file (relative or absolute)
+   * @returns File validation result
+   */
+  async validateFile(filePath) {
+    const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(this.options.projectRoot, filePath);
+    const exists = await fs.pathExists(absolutePath);
+    if (!exists) {
+      return {
+        path: filePath,
+        exists: false,
+        hasContent: false,
+        lineCount: 0,
+        reason: "File does not exist"
+      };
+    }
+    const content = await fs.readFile(absolutePath, "utf-8");
+    const lines = content.split("\n");
+    const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+    if (nonEmptyLines.length < this.options.minLines) {
+      return {
+        path: filePath,
+        exists: true,
+        hasContent: false,
+        lineCount: nonEmptyLines.length,
+        reason: `Only ${nonEmptyLines.length} non-empty lines (minimum: ${this.options.minLines})`
+      };
+    }
+    const trimmedContent = content.trim();
+    if (trimmedContent.length < this.options.minChars) {
+      return {
+        path: filePath,
+        exists: true,
+        hasContent: false,
+        lineCount: nonEmptyLines.length,
+        reason: `Only ${trimmedContent.length} characters (minimum: ${this.options.minChars})`
+      };
+    }
+    const stubPatterns = [
+      /^\/\/\s*TODO:/i,
+      /^#\s*TODO:/i,
+      /^\s*throw new Error\(['"]Not implemented['"]\)/i,
+      /^\s*return null;?\s*$/m,
+      /^\s*pass\s*$/m,
+      // Python
+      /^\s*\.\.\.$/m
+      // TypeScript
+    ];
+    const isStub = stubPatterns.some((pattern) => pattern.test(trimmedContent));
+    if (isStub) {
+      return {
+        path: filePath,
+        exists: true,
+        hasContent: false,
+        lineCount: nonEmptyLines.length,
+        reason: "File contains stub/placeholder code"
+      };
+    }
+    return {
+      path: filePath,
+      exists: true,
+      hasContent: true,
+      lineCount: nonEmptyLines.length
+    };
+  }
+  /**
+   * Extract file paths from task description
+   *
+   * Supports multiple formats:
+   * - **Files**: src/foo.ts, src/bar.ts
+   * - **Files to create**: src/foo.ts
+   * - **Files to modify**: src/bar.ts
+   * - Inline code blocks with file paths
+   *
+   * @param description - Task description text
+   * @returns Array of file paths
+   */
+  extractFilePaths(description) {
+    const paths = /* @__PURE__ */ new Set();
+    const filesMatch = description.match(/\*\*Files\*\*:\s*([^\n]+)/i);
+    if (filesMatch) {
+      const filePaths = filesMatch[1].split(",").map((p) => p.trim());
+      filePaths.forEach((p) => paths.add(p));
+    }
+    const createMatch = description.match(/\*\*Files to create\*\*:\s*([^\n]+)/i);
+    if (createMatch) {
+      const filePaths = createMatch[1].split(",").map((p) => p.trim());
+      filePaths.forEach((p) => paths.add(p));
+    }
+    const modifyMatch = description.match(/\*\*Files to modify\*\*:\s*([^\n]+)/i);
+    if (modifyMatch) {
+      const filePaths = modifyMatch[1].split(",").map((p) => p.trim());
+      filePaths.forEach((p) => paths.add(p));
+    }
+    const inlineMatches = description.matchAll(/`([a-zA-Z0-9_\-./]+\.(ts|js|tsx|jsx|py|java|go|rs|cpp|c|h))`/g);
+    for (const match of inlineMatches) {
+      paths.add(match[1]);
+    }
+    const listMatches = description.matchAll(/^[-*]\s+([a-zA-Z0-9_\-./]+\.(ts|js|tsx|jsx|py|java|go|rs|cpp|c|h))/gm);
+    for (const match of listMatches) {
+      paths.add(match[1]);
+    }
+    return Array.from(paths);
+  }
+  /**
+   * Batch validate multiple tasks
+   *
+   * @param tasks - Array of {taskId, description}
+   * @returns Array of validation results
+   */
+  async validateTasks(tasks) {
+    const validationPromises = tasks.map(
+      (task) => this.validateTask(task.description, task.taskId)
+    );
+    return Promise.all(validationPromises);
+  }
+  /**
+   * Get summary of validation results
+   *
+   * @param results - Array of task validation results
+   * @returns Summary statistics
+   */
+  summarizeResults(results) {
+    const total = results.length;
+    const valid = results.filter((r) => r.valid).length;
+    const invalid = results.filter((r) => !r.valid).length;
+    const noFiles = results.filter((r) => r.files.length === 0).length;
+    const invalidTasks = results.filter((r) => !r.valid).map((r) => r.taskId);
+    return {
+      total,
+      valid,
+      invalid,
+      noFiles,
+      invalidTasks
+    };
+  }
+}
+export {
+  CodeValidator
+};

package/plugins/specweave-github/lib/CodeValidator.ts

@@ -0,0 +1,284 @@
+/**
+ * Code Validator
+ *
+ * Validates that completed tasks have actual code implementation.
+ * Prevents marking tasks as complete when:
+ * - Files don't exist
+ * - Files are empty or have trivial content
+ * - Implementation is incomplete
+ *
+ * Used by ThreeLayerSyncManager to enforce code-completion discipline.
+ *
+ * @module CodeValidator
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * File validation result
+ */
+export interface FileValidationResult {
+  path: string;
+  exists: boolean;
+  hasContent: boolean;
+  lineCount: number;
+  reason?: string; // Why validation failed
+}
+
+/**
+ * Task validation result
+ */
+export interface TaskValidationResult {
+  taskId: string;
+  valid: boolean;
+  files: FileValidationResult[];
+  reason?: string; // Summary of why task validation failed
+}
+
+/**
+ * CodeValidator options
+ */
+export interface CodeValidatorOptions {
+  minLines?: number; // Minimum lines for a file to be considered non-empty (default: 3)
+  minChars?: number; // Minimum characters for meaningful content (default: 50)
+  projectRoot?: string; // Project root for resolving relative paths
+}
+
+export class CodeValidator {
+  private options: Required<CodeValidatorOptions>;
+
+  constructor(options: CodeValidatorOptions = {}) {
+    this.options = {
+      minLines: options.minLines ?? 3,
+      minChars: options.minChars ?? 50,
+      projectRoot: options.projectRoot ?? process.cwd()
+    };
+  }
+
+  /**
+   * Validate that code exists for a task
+   *
+   * Extracts file paths from task description and verifies:
+   * 1. Files exist
+   * 2. Files have meaningful content
+   * 3. Files are not just stubs
+   *
+   * @param taskDescription - Task description with file paths
+   * @param taskId - Task ID for error messages
+   * @returns Validation result
+   */
+  async validateTask(taskDescription: string, taskId: string): Promise<TaskValidationResult> {
+    const filePaths = this.extractFilePaths(taskDescription);
+
+    if (filePaths.length === 0) {
+      // No file paths specified - consider it valid (task might be non-code)
+      return {
+        taskId,
+        valid: true,
+        files: [],
+        reason: 'No file paths specified in task description'
+      };
+    }
+
+    const fileResults: FileValidationResult[] = [];
+    let allValid = true;
+    const reasons: string[] = [];
+
+    for (const filePath of filePaths) {
+      const result = await this.validateFile(filePath);
+      fileResults.push(result);
+
+      if (!result.exists) {
+        allValid = false;
+        reasons.push(`File not found: ${filePath}`);
+      } else if (!result.hasContent) {
+        allValid = false;
+        reasons.push(`File has no meaningful content: ${filePath} (${result.reason})`);
+      }
+    }
+
+    return {
+      taskId,
+      valid: allValid,
+      files: fileResults,
+      reason: reasons.length > 0 ? reasons.join('; ') : undefined
+    };
+  }
+
+  /**
+   * Validate a single file
+   *
+   * @param filePath - Path to file (relative or absolute)
+   * @returns File validation result
+   */
+  async validateFile(filePath: string): Promise<FileValidationResult> {
+    // Resolve relative paths
+    const absolutePath = path.isAbsolute(filePath)
+      ? filePath
+      : path.join(this.options.projectRoot, filePath);
+
+    // Check if file exists
+    const exists = await fs.pathExists(absolutePath);
+    if (!exists) {
+      return {
+        path: filePath,
+        exists: false,
+        hasContent: false,
+        lineCount: 0,
+        reason: 'File does not exist'
+      };
+    }
+
+    // Read file content
+    const content = await fs.readFile(absolutePath, 'utf-8');
+    const lines = content.split('\n');
+    const nonEmptyLines = lines.filter(line => line.trim().length > 0);
+
+    // Check line count
+    if (nonEmptyLines.length < this.options.minLines) {
+      return {
+        path: filePath,
+        exists: true,
+        hasContent: false,
+        lineCount: nonEmptyLines.length,
+        reason: `Only ${nonEmptyLines.length} non-empty lines (minimum: ${this.options.minLines})`
+      };
+    }
+
+    // Check character count
+    const trimmedContent = content.trim();
+    if (trimmedContent.length < this.options.minChars) {
+      return {
+        path: filePath,
+        exists: true,
+        hasContent: false,
+        lineCount: nonEmptyLines.length,
+        reason: `Only ${trimmedContent.length} characters (minimum: ${this.options.minChars})`
+      };
+    }
+
+    // Check for stub patterns (common placeholder patterns)
+    const stubPatterns = [
+      /^\/\/\s*TODO:/i,
+      /^#\s*TODO:/i,
+      /^\s*throw new Error\(['"]Not implemented['"]\)/i,
+      /^\s*return null;?\s*$/m,
+      /^\s*pass\s*$/m, // Python
+      /^\s*\.\.\.$/m    // TypeScript
+    ];
+
+    const isStub = stubPatterns.some(pattern => pattern.test(trimmedContent));
+    if (isStub) {
+      return {
+        path: filePath,
+        exists: true,
+        hasContent: false,
+        lineCount: nonEmptyLines.length,
+        reason: 'File contains stub/placeholder code'
+      };
+    }
+
+    // All checks passed
+    return {
+      path: filePath,
+      exists: true,
+      hasContent: true,
+      lineCount: nonEmptyLines.length
+    };
+  }
+
+  /**
+   * Extract file paths from task description
+   *
+   * Supports multiple formats:
+   * - **Files**: src/foo.ts, src/bar.ts
+   * - **Files to create**: src/foo.ts
+   * - **Files to modify**: src/bar.ts
+   * - Inline code blocks with file paths
+   *
+   * @param description - Task description text
+   * @returns Array of file paths
+   */
+  extractFilePaths(description: string): string[] {
+    const paths: Set<string> = new Set();
+
+    // Pattern 1: **Files**: path1, path2, path3
+    const filesMatch = description.match(/\*\*Files\*\*:\s*([^\n]+)/i);
+    if (filesMatch) {
+      const filePaths = filesMatch[1].split(',').map(p => p.trim());
+      filePaths.forEach(p => paths.add(p));
+    }
+
+    // Pattern 2: **Files to create**: path1, path2
+    const createMatch = description.match(/\*\*Files to create\*\*:\s*([^\n]+)/i);
+    if (createMatch) {
+      const filePaths = createMatch[1].split(',').map(p => p.trim());
+      filePaths.forEach(p => paths.add(p));
+    }
+
+    // Pattern 3: **Files to modify**: path1, path2
+    const modifyMatch = description.match(/\*\*Files to modify\*\*:\s*([^\n]+)/i);
+    if (modifyMatch) {
+      const filePaths = modifyMatch[1].split(',').map(p => p.trim());
+      filePaths.forEach(p => paths.add(p));
+    }
+
+    // Pattern 4: Inline file references (e.g., `src/foo/bar.ts`)
+    const inlineMatches = description.matchAll(/`([a-zA-Z0-9_\-./]+\.(ts|js|tsx|jsx|py|java|go|rs|cpp|c|h))`/g);
+    for (const match of inlineMatches) {
+      paths.add(match[1]);
+    }
+
+    // Pattern 5: Markdown list items with file paths
+    const listMatches = description.matchAll(/^[-*]\s+([a-zA-Z0-9_\-./]+\.(ts|js|tsx|jsx|py|java|go|rs|cpp|c|h))/gm);
+    for (const match of listMatches) {
+      paths.add(match[1]);
+    }
+
+    return Array.from(paths);
+  }
+
+  /**
+   * Batch validate multiple tasks
+   *
+   * @param tasks - Array of {taskId, description}
+   * @returns Array of validation results
+   */
+  async validateTasks(tasks: Array<{ taskId: string; description: string }>): Promise<TaskValidationResult[]> {
+    // Use parallel validation for performance
+    const validationPromises = tasks.map(task =>
+      this.validateTask(task.description, task.taskId)
+    );
+
+    return Promise.all(validationPromises);
+  }
+
+  /**
+   * Get summary of validation results
+   *
+   * @param results - Array of task validation results
+   * @returns Summary statistics
+   */
+  summarizeResults(results: TaskValidationResult[]): {
+    total: number;
+    valid: number;
+    invalid: number;
+    noFiles: number;
+    invalidTasks: string[];
+  } {
+    const total = results.length;
+    const valid = results.filter(r => r.valid).length;
+    const invalid = results.filter(r => !r.valid).length;
+    const noFiles = results.filter(r => r.files.length === 0).length;
+    const invalidTasks = results.filter(r => !r.valid).map(r => r.taskId);
+
+    return {
+      total,
+      valid,
+      invalid,
+      noFiles,
+      invalidTasks
+    };
+  }
+}