@specmarket/cli 0.0.5 → 0.0.6

package/src/commands/validate.ts

@@ -13,7 +13,6 @@ import {
 } from '@specmarket/shared';
 import type { ValidationResult } from '@specmarket/shared';
 import {
-  detectSpecFormat,
   fileExists,
   directoryExists,
   hasStoryFiles,
@@ -134,10 +133,10 @@ export async function detectCircularReferences(dir: string): Promise<string[]> {
 }
 
 /**
- * Format-specific validation for specmarket-legacy. Pushes to errors/warnings.
- * Zero behavior change from original validateSpec for legacy dirs.
+ * Content validation when spec_format is "specmarket" (spec.yaml + PROMPT.md + SPEC.md + SUCCESS_CRITERIA.md + stdlib).
+ * Pushes to errors/warnings.
  */
-async function validateLegacySpec(
+async function validateSpecmarketContent(
   dir: string,
   errors: string[],
   warnings: string[]
@@ -259,18 +258,17 @@ async function validateLegacySpec(
 }
 
 /**
- * Validates a spec directory. Detects format first, then runs universal checks
- * and format-specific validation. Returns ValidationResult with format and
- * formatDetectedBy when detection ran.
+ * Validates a spec directory. Single standard: specmarket.yaml is required for every spec.
+ * Format and metadata come from the sidecar; format-specific content checks run based on spec_format.
  */
 export async function validateSpec(specPath: string): Promise<ValidationResult> {
   const dir = resolve(specPath);
   const errors: string[] = [];
   const warnings: string[] = [];
+  let format: string | undefined;
+  let formatDetectedBy: 'sidecar' | 'heuristic' | undefined = 'sidecar';
 
-  const detection = await detectSpecFormat(dir);
-
-  // Universal: directory non-empty (at least one readable file)
+  // Universal: directory non-empty
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     const hasAnyFile = entries.some((e) => e.isFile());
@@ -281,9 +279,12 @@ export async function validateSpec(specPath: string): Promise<ValidationResult>
     errors.push('Directory is empty or unreadable');
   }
 
-  // If sidecar exists, validate with specmarketSidecarSchema and sanity-check estimates
   const sidecarPath = join(dir, SIDECAR_FILENAME);
-  if (await fileExists(sidecarPath)) {
+  const sidecarExists = await fileExists(sidecarPath);
+
+  if (!sidecarExists) {
+    errors.push(`${SIDECAR_FILENAME} is required for all specs (single source of truth for format and metadata)`);
+  } else {
     try {
       const raw = await readFile(sidecarPath, 'utf-8');
       const parsed = parseYaml(raw) as unknown;
@@ -296,24 +297,21 @@ export async function validateSpec(specPath: string): Promise<ValidationResult>
         }
       } else {
         const sidecar = sidecarResult.data;
+        format = sidecar.spec_format;
+
         if (sidecar.estimated_tokens !== undefined) {
           if (sidecar.estimated_tokens < 1000) {
             warnings.push(
-              `sidecar estimated_tokens (${sidecar.estimated_tokens}) seems very low.`
+              `estimated_tokens (${sidecar.estimated_tokens}) seems very low.`
             );
           }
           if (sidecar.estimated_tokens > 10_000_000) {
-            warnings.push(
-              `sidecar estimated_tokens (${sidecar.estimated_tokens}) seems very high.`
-            );
+            warnings.push(`estimated_tokens (${sidecar.estimated_tokens}) seems very high.`);
           }
         }
-        if (
-          sidecar.estimated_cost_usd !== undefined &&
-          sidecar.estimated_cost_usd < 0.01
-        ) {
+        if (sidecar.estimated_cost_usd !== undefined && sidecar.estimated_cost_usd < 0.01) {
           warnings.push(
-            `sidecar estimated_cost_usd ($${sidecar.estimated_cost_usd}) seems very low.`
+            `estimated_cost_usd ($${sidecar.estimated_cost_usd}) seems very low.`
           );
         }
         if (
@@ -321,103 +319,87 @@ export async function validateSpec(specPath: string): Promise<ValidationResult>
           sidecar.estimated_time_minutes < 1
         ) {
           warnings.push(
-            `sidecar estimated_time_minutes (${sidecar.estimated_time_minutes}) seems unrealistically low.`
+            `estimated_time_minutes (${sidecar.estimated_time_minutes}) seems unrealistically low.`
           );
         }
-      }
-    } catch (err) {
-      errors.push(
-        `${SIDECAR_FILENAME}: Failed to read or parse: ${(err as Error).message}`
-      );
-    }
-  }
-
-  // Format-specific validation. Run legacy validation when spec.yaml exists or
-  // when format is legacy (e.g. PROMPT+SUCCESS_CRITERIA but spec.yaml missing).
-  const hasSpecYaml = await fileExists(join(dir, 'spec.yaml'));
-  if (hasSpecYaml || detection.format === 'specmarket-legacy') {
-    await validateLegacySpec(dir, errors, warnings);
-  }
 
-  switch (detection.format) {
-    case 'specmarket-legacy':
-      break;
-    case 'speckit': {
-      const hasSpecMd = await fileExists(join(dir, 'spec.md'));
-      const hasTasksMd = await fileExists(join(dir, 'tasks.md'));
-      const hasPlanMd = await fileExists(join(dir, 'plan.md'));
-      const hasSpecifyDir = await directoryExists(join(dir, '.specify'));
-      if (!hasSpecMd) {
-        errors.push('speckit format requires spec.md');
-      }
-      if (!hasTasksMd && !hasPlanMd) {
-        errors.push('speckit format requires tasks.md or plan.md');
-      }
-      if (!hasSpecifyDir) {
-        warnings.push('speckit format: .specify/ directory is recommended');
-      }
-      break;
-    }
-    case 'bmad': {
-      const hasPrdMd = await fileExists(join(dir, 'prd.md'));
-      const hasStory = await hasStoryFiles(dir);
-      if (!hasPrdMd && !hasStory) {
-        errors.push('bmad format requires prd.md or story-*.md files');
-      }
-      const hasArch = await fileExists(join(dir, 'architecture.md'));
-      if (!hasArch) {
-        warnings.push('bmad format: architecture.md is recommended');
-      }
-      break;
-    }
-    case 'ralph': {
-      const prdPath = join(dir, 'prd.json');
-      if (!(await fileExists(prdPath))) {
-        errors.push('ralph format requires prd.json');
-        break;
-      }
-      try {
-        const raw = await readFile(prdPath, 'utf-8');
-        const data = JSON.parse(raw) as unknown;
-        if (
-          !data ||
-          typeof data !== 'object' ||
-          !('userStories' in data) ||
-          !Array.isArray((data as { userStories: unknown }).userStories)
-        ) {
-          errors.push('ralph format: prd.json must have userStories array');
-        }
-      } catch {
-        errors.push('ralph format: prd.json must be valid JSON with userStories array');
-      }
-      break;
-    }
-    case 'custom':
-    default: {
-      const hasMd = await hasMarkdownFiles(dir);
-      if (!hasMd) {
-        errors.push('custom format requires at least one .md file');
-        break;
-      }
-      // At least one .md file > 100 bytes
-      const textExtensions = new Set(['.md']);
-      const mdFiles = await collectFiles(dir, dir, textExtensions);
-      let hasSubstantialMd = false;
-      for (const f of mdFiles) {
-        try {
-          const content = await readFile(join(dir, f), 'utf-8');
-          if (content.length > 100) {
-            hasSubstantialMd = true;
+        // Format-specific content validation (based on sidecar.spec_format)
+        switch (format) {
+          case 'specmarket':
+            await validateSpecmarketContent(dir, errors, warnings);
+            break;
+          case 'speckit': {
+            const hasSpecMd = await fileExists(join(dir, 'spec.md'));
+            const hasTasksMd = await fileExists(join(dir, 'tasks.md'));
+            const hasPlanMd = await fileExists(join(dir, 'plan.md'));
+            const hasSpecifyDir = await directoryExists(join(dir, '.specify'));
+            if (!hasSpecMd) errors.push('speckit format requires spec.md');
+            if (!hasTasksMd && !hasPlanMd) errors.push('speckit format requires tasks.md or plan.md');
+            if (!hasSpecifyDir) warnings.push('speckit format: .specify/ directory is recommended');
+            break;
+          }
+          case 'bmad': {
+            const hasPrdMd = await fileExists(join(dir, 'prd.md'));
+            const hasStory = await hasStoryFiles(dir);
+            if (!hasPrdMd && !hasStory) errors.push('bmad format requires prd.md or story-*.md files');
+            const hasArch = await fileExists(join(dir, 'architecture.md'));
+            if (!hasArch) warnings.push('bmad format: architecture.md is recommended');
+            break;
+          }
+          case 'ralph': {
+            const prdPath = join(dir, 'prd.json');
+            if (!(await fileExists(prdPath))) {
+              errors.push('ralph format requires prd.json');
+              break;
+            }
+            try {
+              const raw = await readFile(prdPath, 'utf-8');
+              const data = JSON.parse(raw) as unknown;
+              if (
+                !data ||
+                typeof data !== 'object' ||
+                !('userStories' in data) ||
+                !Array.isArray((data as { userStories: unknown }).userStories)
+              ) {
+                errors.push('ralph format: prd.json must have userStories array');
+              }
+            } catch {
+              errors.push('ralph format: prd.json must be valid JSON with userStories array');
+            }
+            break;
+          }
+          case 'custom':
+          default: {
+            const hasMd = await hasMarkdownFiles(dir);
+            if (!hasMd) {
+              errors.push('custom format requires at least one .md file');
+              break;
+            }
+            const textExtensions = new Set(['.md']);
+            const mdFiles = await collectFiles(dir, dir, textExtensions);
+            let hasSubstantialMd = false;
+            for (const f of mdFiles) {
+              try {
+                const content = await readFile(join(dir, f), 'utf-8');
+                if (content.length > 100) {
+                  hasSubstantialMd = true;
+                  break;
+                }
+              } catch {
+                // skip
+              }
+            }
+            if (!hasSubstantialMd) {
+              errors.push('custom format requires at least one .md file larger than 100 bytes');
+            }
             break;
           }
-        } catch {
-          // skip
         }
       }
-      if (!hasSubstantialMd) {
-        errors.push('custom format requires at least one .md file larger than 100 bytes');
-      }
-      break;
+    } catch (err) {
+      errors.push(
+        `${SIDECAR_FILENAME}: Failed to read or parse: ${(err as Error).message}`
+      );
     }
   }
 
@@ -425,8 +407,8 @@ export async function validateSpec(specPath: string): Promise<ValidationResult>
     valid: errors.length === 0,
     errors,
     warnings,
-    format: detection.format,
-    formatDetectedBy: detection.detectedBy,
+    format,
+    formatDetectedBy,
   };
 }
 
@@ -439,7 +421,7 @@ export function createValidateCommand(): Command {
         const result = await validateSpec(specPath);
 
         if (result.format !== undefined) {
-          console.log(chalk.gray(`Detected format: ${result.format}`));
+          console.log(chalk.gray(`Format: ${result.format}`));
         }
 
         if (result.warnings.length > 0) {

package/src/lib/format-detection.test.ts

@@ -96,12 +96,12 @@ describe('format-detection', () => {
       expect(result.detectedBy).toBe('heuristic');
     });
 
-    it('legacy dir (spec.yaml + PROMPT.md + SUCCESS_CRITERIA.md) → specmarket-legacy, high', async () => {
+    it('specmarket dir (spec.yaml + PROMPT.md + SUCCESS_CRITERIA.md) → specmarket, high', async () => {
       await writeFile(join(tmpDir, 'spec.yaml'), 'name: x');
       await writeFile(join(tmpDir, 'PROMPT.md'), '# P');
       await writeFile(join(tmpDir, 'SUCCESS_CRITERIA.md'), '- [ ] C');
       const result = await detectSpecFormat(tmpDir);
-      expect(result.format).toBe('specmarket-legacy');
+      expect(result.format).toBe('specmarket');
       expect(result.confidence).toBe('high');
       expect(result.detectedBy).toBe('heuristic');
     });
@@ -213,11 +213,11 @@ describe('format-detection', () => {
       expect(result.format).toBe('custom');
     });
 
-    it('legacy requires all three files', async () => {
+    it('specmarket requires spec.yaml + PROMPT + SUCCESS_CRITERIA (no spec with only two)', async () => {
       await writeFile(join(tmpDir, 'spec.yaml'), 'x');
       await writeFile(join(tmpDir, 'PROMPT.md'), 'x');
       const result = await detectSpecFormat(tmpDir);
-      expect(result.format).not.toBe('specmarket-legacy');
+      expect(result.format).not.toBe('specmarket');
     });
   });
 });

package/src/lib/format-detection.ts

@@ -75,7 +75,7 @@ export async function tryReadSidecar(
 /**
  * Detect spec format for a directory. Priority:
  * 1. Sidecar specmarket.yaml with spec_format → use that value, high confidence
- * 2. specmarket-legacy: spec.yaml + PROMPT.md + SUCCESS_CRITERIA.md
+ * 2. specmarket: spec.yaml + PROMPT.md + SUCCESS_CRITERIA.md
  * 3. speckit: spec.md + (plan.md | tasks.md) + .specify/ directory
  * 4. bmad: prd.md + (architecture.md | story-*.md)
  * 5. ralph: prd.json with userStories[] array
@@ -97,14 +97,14 @@ export async function detectSpecFormat(dir: string): Promise<FormatDetectionResu
   const hasSuccessCriteria = await fileExists(join(dir, 'SUCCESS_CRITERIA.md'));
   if (hasSpecYaml && hasPromptMd && hasSuccessCriteria) {
     return {
-      format: 'specmarket-legacy',
+      format: 'specmarket',
       detectedBy: 'heuristic',
       confidence: 'high',
     };
   }
   if (hasPromptMd && hasSuccessCriteria) {
     return {
-      format: 'specmarket-legacy',
+      format: 'specmarket',
       detectedBy: 'heuristic',
       confidence: 'high',
     };