@dommaker/harness 0.16.0 → 0.16.1

package/src/sdd/__tests__/index-generator.test.ts

@@ -0,0 +1,150 @@
+// SDD Index Generator Tests (AC-9)
+// Tests: scan docs/sdd/ subdirs with requirement.md → generate _index.md
+// Format: slug|pmoNumber|status|title|tags
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// Import will fail until implementation exists — this is intentional RED
+import { SDDIndexGenerator } from '../index-generator';
+
+describe('SDDIndexGenerator', () => {
+  let tmpDir: string;
+  let sddDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sdd-index-test-'));
+    sddDir = path.join(tmpDir, 'docs', 'sdd');
+    fs.mkdirSync(sddDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function createSDD(slug: string, frontmatter: Record<string, unknown>): void {
+    const dir = path.join(sddDir, slug);
+    fs.mkdirSync(dir, { recursive: true });
+    const lines = ['---'];
+    for (const [key, value] of Object.entries(frontmatter)) {
+      if (Array.isArray(value)) {
+        lines.push(`${key}: [${value.map(v => `"${v}"`).join(', ')}]`);
+      } else {
+        lines.push(`${key}: "${value}"`);
+      }
+    }
+    lines.push('---');
+    lines.push('');
+    lines.push(`# ${frontmatter.title || slug}`);
+    fs.writeFileSync(path.join(dir, 'requirement.md'), lines.join('\n'));
+  }
+
+  it('generates index from SDD directories with requirement.md', () => {
+    createSDD('jwt-auth', {
+      slug: 'jwt-auth',
+      status: 'done',
+      title: 'JWT 认证系统',
+      tags: ['auth', 'security'],
+      pmoNumber: 'PM-001',
+    });
+    createSDD('user-management', {
+      slug: 'user-management',
+      status: 'confirmed',
+      title: '用户管理',
+      tags: ['user'],
+      pmoNumber: 'PM-002',
+    });
+
+    const generator = new SDDIndexGenerator(tmpDir);
+    const result = generator.regenerate();
+
+    expect(result.count).toBe(2);
+    expect(result.entries).toHaveLength(2);
+
+    // Verify _index.md was written
+    const indexPath = path.join(sddDir, '_index.md');
+    expect(fs.existsSync(indexPath)).toBe(true);
+
+    const content = fs.readFileSync(indexPath, 'utf-8');
+    expect(content).toContain('jwt-auth|PM-001|done|JWT 认证系统|auth,security');
+    expect(content).toContain('user-management|PM-002|confirmed|用户管理|user');
+  });
+
+  it('skips directories without requirement.md', () => {
+    createSDD('has-req', { slug: 'has-req', status: 'done', title: 'Has Req' });
+    // Create directory without requirement.md
+    fs.mkdirSync(path.join(sddDir, 'no-req'), { recursive: true });
+
+    const generator = new SDDIndexGenerator(tmpDir);
+    const result = generator.regenerate();
+
+    expect(result.count).toBe(1);
+    expect(result.entries[0].slug).toBe('has-req');
+  });
+
+  it('skips status: stale SDDs', () => {
+    createSDD('active-one', { slug: 'active-one', status: 'done', title: 'Active' });
+    createSDD('stale-one', { slug: 'stale-one', status: 'stale', title: 'Stale' });
+
+    const generator = new SDDIndexGenerator(tmpDir);
+    const result = generator.regenerate();
+
+    expect(result.count).toBe(1);
+    expect(result.entries[0].slug).toBe('active-one');
+  });
+
+  it('handles missing pmoNumber (empty column)', () => {
+    createSDD('no-pmo', { slug: 'no-pmo', status: 'done', title: 'No PMO' });
+
+    const generator = new SDDIndexGenerator(tmpDir);
+    const result = generator.regenerate();
+
+    expect(result.count).toBe(1);
+    // pmoNumber column should be empty: slug||status|title|tags
+    expect(result.entries[0].pmoNumber).toBe('');
+  });
+
+  it('handles missing tags (empty column)', () => {
+    createSDD('no-tags', { slug: 'no-tags', status: 'done', title: 'No Tags' });
+
+    const generator = new SDDIndexGenerator(tmpDir);
+    const result = generator.regenerate();
+
+    expect(result.count).toBe(1);
+    expect(result.entries[0].tags).toBe('');
+  });
+
+  it('throws when SDD directory does not exist', () => {
+    const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sdd-empty-'));
+
+    expect(() => new SDDIndexGenerator(emptyDir).regenerate()).toThrow(/not found/);
+
+    fs.rmSync(emptyDir, { recursive: true, force: true });
+  });
+
+  it('generates header with correct format', () => {
+    createSDD('test', { slug: 'test', status: 'done', title: 'Test' });
+
+    const generator = new SDDIndexGenerator(tmpDir);
+    generator.regenerate();
+
+    const indexPath = path.join(sddDir, '_index.md');
+    const content = fs.readFileSync(indexPath, 'utf-8');
+
+    expect(content).toContain('# SDD Index');
+    expect(content).toContain('Auto-generated');
+    expect(content).toContain('Total: 1 entries');
+    expect(content).toContain('slug|pmoNumber|status|title|tags');
+  });
+
+  it('sorts entries by slug', () => {
+    createSDD('zebra', { slug: 'zebra', status: 'done', title: 'Zebra' });
+    createSDD('alpha', { slug: 'alpha', status: 'done', title: 'Alpha' });
+
+    const generator = new SDDIndexGenerator(tmpDir);
+    const result = generator.regenerate();
+
+    expect(result.entries[0].slug).toBe('alpha');
+    expect(result.entries[1].slug).toBe('zebra');
+  });
+});

package/src/sdd/index-generator.ts

@@ -0,0 +1,109 @@
+// SDD Index Generator
+// Scans docs/sdd/*/requirement.md, generates docs/sdd/_index.md
+// Format: slug|pmoNumber|status|title|tags
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+
+const INDEX_FILENAME = '_index.md';
+
+interface SDDIndexEntry {
+  slug: string;
+  pmoNumber: string;
+  status: string;
+  title: string;
+  tags: string;
+}
+
+export interface SDDIndexResult {
+  count: number;
+  entries: SDDIndexEntry[];
+}
+
+export class SDDIndexGenerator {
+  private sddDir: string;
+
+  constructor(baseDir: string) {
+    this.sddDir = path.join(baseDir, 'docs', 'sdd');
+  }
+
+  regenerate(): SDDIndexResult {
+    if (!fs.existsSync(this.sddDir)) {
+      throw new Error(`SDD directory not found: ${this.sddDir}`);
+    }
+
+    const entries = this.scanEntries();
+    entries.sort((a, b) => a.slug.localeCompare(b.slug));
+
+    const content = this.buildContent(entries);
+    const indexPath = path.join(this.sddDir, INDEX_FILENAME);
+    fs.writeFileSync(indexPath, content, 'utf-8');
+
+    return { count: entries.length, entries };
+  }
+
+  private scanEntries(): SDDIndexEntry[] {
+    const entries: SDDIndexEntry[] = [];
+    const dirs = fs.readdirSync(this.sddDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+
+    for (const dir of dirs) {
+      const reqPath = path.join(this.sddDir, dir, 'requirement.md');
+      if (!fs.existsSync(reqPath)) continue;
+
+      const content = fs.readFileSync(reqPath, 'utf-8');
+      const fm = this.parseFrontmatter(content);
+      if (!fm) continue;
+
+      // Skip stale SDDs
+      const status = String(fm.status || 'unknown');
+      if (status === 'stale') continue;
+
+      entries.push({
+        slug: String(fm.slug || dir),
+        pmoNumber: String(fm.pmoNumber || ''),
+        status,
+        title: this.sanitize(String(fm.title || dir)),
+        tags: Array.isArray(fm.tags) ? fm.tags.join(',') : '',
+      });
+    }
+
+    return entries;
+  }
+
+  private parseFrontmatter(content: string): Record<string, unknown> | null {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return null;
+    try {
+      return yaml.load(match[1]) as Record<string, unknown> || null;
+    } catch {
+      return null;
+    }
+  }
+
+  private sanitize(s: string): string {
+    return s.replace(/\n/g, ' ').replace(/\|/g, '/').replace(/\s+/g, ' ').trim();
+  }
+
+  private buildContent(entries: SDDIndexEntry[]): string {
+    const header = [
+      '# SDD Index',
+      '# Auto-generated — run `harness sdd index` to rebuild',
+      `# Total: ${entries.length} entries`,
+      '#',
+      '# Usage:',
+      '#   grep "<pmoNumber>" docs/sdd/_index.md',
+      '#   Then Read the matching SDD directory for full content.',
+      '#',
+      '# slug|pmoNumber|status|title|tags',
+    ].join('\n');
+
+    const lines = entries.map(e =>
+      `${e.slug}|${e.pmoNumber}|${e.status}|${e.title}|${e.tags}`
+    );
+
+    return header + '\n' + lines.join('\n') + '\n';
+  }
+}