@pyreon/mcp 0.13.0 → 0.14.0

package/src/tests/changelog.test.ts

@@ -0,0 +1,312 @@
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import {
+  compareVersions,
+  filterSince,
+  findChangelog,
+  formatChangelog,
+  formatChangelogIndex,
+  loadChangelogRegistry,
+  parseChangelog,
+  suggestChangelogs,
+} from '../changelog'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+// tests/ → src/ → mcp/ → tools/ → packages/ → repo root (5 ups)
+const REPO_ROOT = resolve(HERE, '../../../../../')
+
+describe('parseChangelog — synthetic inputs', () => {
+  it('returns an empty array on an empty file', () => {
+    expect(parseChangelog('')).toEqual([])
+  })
+
+  it('ignores prose before the first ## version heading', () => {
+    const doc = `# @pyreon/foo\n\nSome intro that should not land as a version.\n\n## 1.0.0\n\n- Added X`
+    const entries = parseChangelog(doc)
+    expect(entries).toHaveLength(1)
+    expect(entries[0]!.version).toBe('1.0.0')
+    expect(entries[0]!.changes).toEqual(['Added X'])
+  })
+
+  it('parses ceremonial empty-version bumps as { empty: true }', () => {
+    const doc = '# @pyreon/foo\n\n## 0.5.2\n\n## 0.5.1\n'
+    const entries = parseChangelog(doc)
+    expect(entries.map((e) => e.version)).toEqual(['0.5.2', '0.5.1'])
+    expect(entries.every((e) => e.empty)).toBe(true)
+  })
+
+  it('splits user-facing changes from dependency-update bullets', () => {
+    const doc = `
+## 0.13.0
+
+### Patch Changes
+
+- Added shiny new thing
+- Updated dependencies [[\`a1b2\`]]:
+  - @pyreon/core@0.13.0
+  - @pyreon/reactivity@0.13.0
+`
+    const [entry] = parseChangelog(doc)
+    expect(entry!.changes).toEqual(['Added shiny new thing'])
+    expect(entry!.dependencyUpdates).toHaveLength(1)
+    expect(entry!.dependencyUpdates[0]).toContain('@pyreon/core@0.13.0')
+    expect(entry!.empty).toBe(false)
+  })
+
+  it('joins multi-line bullet continuations into one entry', () => {
+    const doc = `
+## 0.13.0
+
+### Minor Changes
+
+- First line of a long change
+  second line indented
+  third line
+
+  - sub-bullet under the first change
+  - another sub-bullet
+
+- Separate top-level change
+`
+    const [entry] = parseChangelog(doc)
+    expect(entry!.changes).toHaveLength(2)
+    expect(entry!.changes[0]).toContain('First line')
+    expect(entry!.changes[0]).toContain('second line')
+    expect(entry!.changes[0]).toContain('sub-bullet')
+    expect(entry!.changes[1]).toContain('Separate top-level')
+  })
+
+  it('collapses ### Patch/Minor/Major Changes headings — keeps only bullets', () => {
+    const doc = `
+## 0.14.0
+
+### Major Changes
+
+- Big thing
+
+### Minor Changes
+
+- Small thing
+
+### Patch Changes
+
+- Tiny fix
+`
+    const [entry] = parseChangelog(doc)
+    expect(entry!.changes).toEqual(['Big thing', 'Small thing', 'Tiny fix'])
+  })
+})
+
+describe('loadChangelogRegistry — real repo', () => {
+  const registry = loadChangelogRegistry(REPO_ROOT)
+
+  it('discovers the monorepo root', () => {
+    expect(registry.root).toBe(REPO_ROOT)
+  })
+
+  it('loads at least 40 packages with CHANGELOG.md', () => {
+    expect(registry.byName.size).toBeGreaterThanOrEqual(40)
+  })
+
+  it('every loaded package has a @pyreon/ name + non-empty path', () => {
+    for (const [name, cl] of registry.byName) {
+      expect(name).toMatch(/^@pyreon\//)
+      expect(cl.path).toContain('CHANGELOG.md')
+      expect(cl.dir).not.toContain('node_modules')
+    }
+  })
+
+  it('finds @pyreon/query and parses its entries', () => {
+    const q = registry.byName.get('@pyreon/query')
+    expect(q).toBeDefined()
+    expect(q!.entries.length).toBeGreaterThan(0)
+    const substantive = q!.entries.filter((e) => !e.empty)
+    expect(substantive.length).toBeGreaterThan(0)
+  })
+})
+
+describe('findChangelog + suggestChangelogs', () => {
+  const registry = loadChangelogRegistry(REPO_ROOT)
+
+  it('finds by fully-qualified name', () => {
+    const q = findChangelog(registry, '@pyreon/query')
+    expect(q).toBeDefined()
+    expect(q!.packageName).toBe('@pyreon/query')
+  })
+
+  it('finds by short slug (auto-prefixes @pyreon/)', () => {
+    const q = findChangelog(registry, 'query')
+    expect(q).toBeDefined()
+    expect(q!.packageName).toBe('@pyreon/query')
+  })
+
+  it('returns null for an unknown package', () => {
+    expect(findChangelog(registry, 'nonexistent')).toBeNull()
+    expect(findChangelog(registry, '@pyreon/bogus')).toBeNull()
+  })
+
+  it('suggestChangelogs returns substring matches', () => {
+    const s = suggestChangelogs(registry, 'router')
+    expect(s).toContain('@pyreon/router')
+  })
+
+  it('suggestChangelogs caps at 5', () => {
+    const s = suggestChangelogs(registry, 'p') // matches many
+    expect(s.length).toBeLessThanOrEqual(5)
+  })
+})
+
+describe('formatChangelog', () => {
+  const registry = loadChangelogRegistry(REPO_ROOT)
+
+  it('renders a header with shown / total counts', () => {
+    const q = findChangelog(registry, 'query')!
+    const out = formatChangelog(q)
+    expect(out).toMatch(/^# @pyreon\/query — changelog \(\d+\/\d+ shown\)/)
+  })
+
+  it('respects the limit option', () => {
+    const q = findChangelog(registry, 'query')!
+    const limited = formatChangelog(q, { limit: 1 })
+    const versionHeadings = limited.split('\n').filter((l) => /^## /.test(l))
+    expect(versionHeadings).toHaveLength(1)
+  })
+
+  it('omits Updated-dependencies bullets by default', () => {
+    const q = findChangelog(registry, 'query')!
+    const out = formatChangelog(q, { limit: 10 })
+    expect(out).not.toContain('Updated dependencies')
+  })
+
+  it('includes Updated-dependencies when the option is true', () => {
+    const q = findChangelog(registry, 'query')!
+    const out = formatChangelog(q, { limit: 10, includeDependencyUpdates: true })
+    expect(out).toContain('Updated dependencies')
+  })
+
+  it('returns a "ceremonial bumps only" miss message for empty changelogs', () => {
+    const synthetic = {
+      packageName: '@pyreon/empty',
+      path: '/tmp/nonexistent/CHANGELOG.md',
+      dir: '/tmp/nonexistent',
+      entries: [
+        { version: '0.1.0', changes: [], dependencyUpdates: [], empty: true },
+        { version: '0.0.9', changes: [], dependencyUpdates: [], empty: true },
+      ],
+    }
+    const out = formatChangelog(synthetic)
+    expect(out).toContain('no substantive changes')
+    expect(out).toContain('ceremonial version bump')
+  })
+})
+
+describe('compareVersions', () => {
+  it('orders by numeric segments', () => {
+    expect(compareVersions('1.0.0', '2.0.0')).toBeLessThan(0)
+    expect(compareVersions('0.13.0', '0.12.15')).toBeGreaterThan(0) // 13 > 12
+    expect(compareVersions('0.12.15', '0.13.0')).toBeLessThan(0)
+    expect(compareVersions('0.0.9', '0.0.10')).toBeLessThan(0)
+    expect(compareVersions('1.0.0', '1.0.0')).toBe(0)
+  })
+
+  it('handles missing segments as 0', () => {
+    expect(compareVersions('1.0', '1.0.0')).toBe(0)
+    expect(compareVersions('1', '1.0.1')).toBeLessThan(0)
+  })
+
+  it('orders stable above pre-release', () => {
+    expect(compareVersions('1.0.0', '1.0.0-alpha.1')).toBeGreaterThan(0)
+    expect(compareVersions('1.0.0-alpha.1', '1.0.0')).toBeLessThan(0)
+  })
+
+  it('orders pre-releases lexicographically within the same core', () => {
+    expect(compareVersions('1.0.0-alpha.1', '1.0.0-beta.1')).toBeLessThan(0)
+    expect(compareVersions('1.0.0-alpha.3', '1.0.0-alpha.2')).toBeGreaterThan(0)
+  })
+
+  it('tolerates non-numeric segments as 0', () => {
+    // Not expected from changesets but shouldn't crash.
+    // "abc" parses to 0, so "abc.1" == "0.1" == [0, 1] and they tie.
+    expect(compareVersions('abc.1', '0.1')).toBe(0)
+    expect(compareVersions('', '0.0.0')).toBe(0)
+    // Numeric still wins over non-numeric.
+    expect(compareVersions('1.0.0', 'abc.0.0')).toBeGreaterThan(0)
+  })
+})
+
+describe('filterSince', () => {
+  const entries = [
+    { version: '0.13.0', changes: ['X'], dependencyUpdates: [], empty: false },
+    { version: '0.12.15', changes: ['Y'], dependencyUpdates: [], empty: false },
+    { version: '0.12.14', changes: ['Z'], dependencyUpdates: [], empty: false },
+  ]
+
+  it('returns entries strictly newer than the floor', () => {
+    const after = filterSince(entries, '0.12.15')
+    expect(after.map((e) => e.version)).toEqual(['0.13.0'])
+  })
+
+  it('returns all entries when the floor is below every entry', () => {
+    const after = filterSince(entries, '0.0.1')
+    expect(after).toHaveLength(3)
+  })
+
+  it('returns empty when the floor equals or exceeds every entry', () => {
+    expect(filterSince(entries, '0.13.0')).toEqual([])
+    expect(filterSince(entries, '1.0.0')).toEqual([])
+  })
+
+  it('preserves file order (newest-first)', () => {
+    const after = filterSince(entries, '0.12.13')
+    expect(after.map((e) => e.version)).toEqual(['0.13.0', '0.12.15', '0.12.14'])
+  })
+})
+
+describe('formatChangelog — since option', () => {
+  const changelog = {
+    packageName: '@pyreon/foo',
+    path: '/tmp/CHANGELOG.md',
+    dir: '/tmp',
+    entries: [
+      { version: '0.13.0', changes: ['Latest change'], dependencyUpdates: [], empty: false },
+      { version: '0.12.15', changes: ['Middle'], dependencyUpdates: [], empty: false },
+      { version: '0.12.14', changes: ['Oldest'], dependencyUpdates: [], empty: false },
+    ],
+  }
+
+  it('includes only versions strictly newer than `since`', () => {
+    const out = formatChangelog(changelog, { since: '0.12.15', limit: 10 })
+    expect(out).toContain('## 0.13.0')
+    expect(out).not.toContain('## 0.12.15')
+    expect(out).not.toContain('## 0.12.14')
+  })
+
+  it('shows a dedicated "no changes since vX" miss message', () => {
+    const out = formatChangelog(changelog, { since: '0.13.0' })
+    expect(out).toContain('no changes since v0.13.0')
+    expect(out).toContain('known latest substantive version is v0.13.0')
+  })
+
+  it('labels the header with the since floor', () => {
+    const out = formatChangelog(changelog, { since: '0.12.15' })
+    expect(out).toMatch(/^# @pyreon\/foo — changelog since v0\.12\.15 \(\d+\/\d+ shown\)/)
+  })
+})
+
+describe('formatChangelogIndex', () => {
+  const registry = loadChangelogRegistry(REPO_ROOT)
+
+  it('lists every package with its latest substantive version', () => {
+    const out = formatChangelogIndex(registry)
+    expect(out).toMatch(/^# Pyreon Changelogs \(\d+ packages\)/)
+    expect(out).toContain('**@pyreon/query**')
+    expect(out).toContain('**@pyreon/router**')
+  })
+
+  it('returns a helpful miss message when no packages/ dir', () => {
+    const empty = loadChangelogRegistry('/tmp')
+    const out = formatChangelogIndex(empty)
+    expect(out).toContain('No changelogs found')
+    expect(out).toContain('Pyreon monorepo')
+  })
+})

package/src/tests/manifest-snapshot.test.ts

@@ -0,0 +1,36 @@
+import {
+  renderApiReferenceEntries,
+  renderLlmsFullSection,
+  renderLlmsTxtLine,
+} from '@pyreon/manifest'
+import manifest from '../manifest'
+
+describe('gen-docs — mcp snapshot', () => {
+  it('renders a llms.txt bullet starting with the package prefix', () => {
+    const line = renderLlmsTxtLine(manifest)
+    expect(line.startsWith('- @pyreon/mcp —')).toBe(true)
+  })
+
+  it('renders a llms-full.txt section with the right header', () => {
+    const section = renderLlmsFullSection(manifest)
+    expect(section.startsWith('## @pyreon/mcp —')).toBe(true)
+    expect(section).toContain('```typescript')
+  })
+
+  it('renders MCP api-reference entries for every api[] item', () => {
+    const record = renderApiReferenceEntries(manifest)
+    expect(Object.keys(record).sort()).toEqual([
+      'mcp/audit_test_environment',
+      'mcp/diagnose',
+      'mcp/get_anti_patterns',
+      'mcp/get_api',
+      'mcp/get_browser_smoke_status',
+      'mcp/get_changelog',
+      'mcp/get_components',
+      'mcp/get_pattern',
+      'mcp/get_routes',
+      'mcp/migrate_react',
+      'mcp/validate',
+    ])
+  })
+})

package/src/tests/patterns-code.test.ts

@@ -0,0 +1,216 @@
+import { readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import ts from 'typescript'
+import { loadPatternRegistry } from '../patterns'
+
+// Code-quality test for the patterns corpus. Every ```ts / ```tsx /
+// ```js / ```jsx fenced code block is parsed by the TypeScript
+// compiler and any SYNTAX errors fail the build.
+//
+// What this catches: typos, unterminated strings, unbalanced braces,
+// bad JSX closing tags, missing commas, broken template literals —
+// the kinds of bugs review usually catches but sometimes doesn't.
+//
+// What this does NOT catch: semantic errors (type mismatches, unknown
+// identifiers, import resolution). A pattern snippet intentionally
+// uses `props` or `items` as stand-ins without declaring them — a
+// full type-check would produce false positives on every such block.
+// If that stricter gate is ever wanted, wrap each block in a
+// synthetic `function _()` harness with a compiler host that stubs
+// the unresolved symbols.
+//
+// If you add a block that needs to be excluded (illustrating a
+// syntax ERROR on purpose, say), give its language tag a suffix —
+// e.g. ```tsx-broken — which the test ignores.
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+// tests/ → src/ → mcp/ → tools/ → packages/ → repo root (5 ups)
+const REPO_ROOT = resolve(HERE, '../../../../../')
+
+// Language tags treated as TS/TSX-like (parsed with TSX script kind).
+const TS_LANGS = new Set(['ts', 'tsx', 'typescript'])
+const JS_LANGS = new Set(['js', 'jsx', 'javascript'])
+
+interface CodeBlock {
+  lang: string
+  source: string
+  startLine: number // 1-based line in the source markdown
+}
+
+function extractCodeBlocks(markdown: string): CodeBlock[] {
+  const lines = markdown.split('\n')
+  const blocks: CodeBlock[] = []
+  let inside: { lang: string; startLine: number; buf: string[] } | null = null
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!
+    const fence = /^```(.*)$/.exec(line)
+    if (fence) {
+      if (inside === null) {
+        // Opening fence; capture the language tag.
+        inside = { lang: fence[1]!.trim(), startLine: i + 2, buf: [] }
+      } else {
+        // Closing fence; flush.
+        blocks.push({ lang: inside.lang, source: inside.buf.join('\n'), startLine: inside.startLine })
+        inside = null
+      }
+    } else if (inside !== null) {
+      inside.buf.push(line)
+    }
+  }
+  return blocks
+}
+
+function isRelevantBlock(block: CodeBlock): boolean {
+  return TS_LANGS.has(block.lang) || JS_LANGS.has(block.lang)
+}
+
+function scriptKindFor(lang: string): ts.ScriptKind {
+  if (lang === 'tsx' || lang === 'typescript') return ts.ScriptKind.TSX
+  if (lang === 'ts') return ts.ScriptKind.TSX // treat `ts` blocks as TSX too — patterns often
+                                              // include inline JSX in "ts" blocks by convention
+  if (lang === 'jsx') return ts.ScriptKind.JSX
+  if (lang === 'js' || lang === 'javascript') return ts.ScriptKind.JSX // same rationale
+  return ts.ScriptKind.TSX
+}
+
+interface SyntaxFailure {
+  pattern: string
+  blockStartLine: number
+  lang: string
+  diagnostic: string
+  blockLine: number // line WITHIN the block (1-based)
+}
+
+// `SourceFile.parseDiagnostics` is an internal TS field — not on the
+// public .d.ts surface, but available at runtime after `createSourceFile`
+// with setParentNodes=true. Using a structural cast keeps the test
+// syntax-only (no Program / no type resolution) without pulling in a
+// heavier `transpileModule` pipeline.
+interface SourceFileWithParseDiagnostics extends ts.SourceFile {
+  readonly parseDiagnostics: readonly ts.Diagnostic[]
+}
+
+function checkBlock(
+  patternName: string,
+  block: CodeBlock,
+): SyntaxFailure[] {
+  const sf = ts.createSourceFile(
+    `${patternName}-block.tsx`,
+    block.source,
+    ts.ScriptTarget.ESNext,
+    true,
+    scriptKindFor(block.lang),
+  ) as SourceFileWithParseDiagnostics
+  const failures: SyntaxFailure[] = []
+  for (const d of sf.parseDiagnostics) {
+    const { line } = sf.getLineAndCharacterOfPosition(d.start ?? 0)
+    const message =
+      typeof d.messageText === 'string'
+        ? d.messageText
+        : ts.flattenDiagnosticMessageText(d.messageText, '\n')
+    failures.push({
+      pattern: patternName,
+      blockStartLine: block.startLine,
+      lang: block.lang,
+      diagnostic: message,
+      blockLine: line + 1,
+    })
+  }
+  return failures
+}
+
+describe('patterns content — every code block is syntactically valid', () => {
+  const registry = loadPatternRegistry(REPO_ROOT)
+
+  it.each(registry.patterns.map((p) => [p.name, p.path]))(
+    '%s code blocks parse without syntax errors',
+    (name, path) => {
+      const body = readFileSync(path, 'utf8')
+      const blocks = extractCodeBlocks(body).filter(isRelevantBlock)
+      expect(blocks.length).toBeGreaterThan(0) // every pattern has at least 1 code example
+
+      const failures: SyntaxFailure[] = []
+      for (const block of blocks) {
+        failures.push(...checkBlock(name, block))
+      }
+
+      if (failures.length > 0) {
+        // Render a readable failure message pointing at the exact
+        // line inside the pattern file so fixing is trivial.
+        const lines = failures.map(
+          (f) =>
+            `  ${f.pattern}:${f.blockStartLine + f.blockLine - 1} (${f.lang} block, line ${f.blockLine} of block): ${f.diagnostic}`,
+        )
+        throw new Error(`Syntax errors in pattern code blocks:\n${lines.join('\n')}`)
+      }
+    },
+  )
+})
+
+describe('extractCodeBlocks — parser contract', () => {
+  it('extracts every fenced block with its language tag', () => {
+    const md = `# Title
+
+Prose.
+
+\`\`\`ts
+const x: number = 1
+\`\`\`
+
+Some text.
+
+\`\`\`tsx
+const X = () => <div />
+\`\`\`
+
+\`\`\`bash
+echo hi
+\`\`\`
+`
+    const blocks = extractCodeBlocks(md)
+    expect(blocks).toHaveLength(3)
+    expect(blocks[0]!.lang).toBe('ts')
+    expect(blocks[1]!.lang).toBe('tsx')
+    expect(blocks[2]!.lang).toBe('bash')
+  })
+
+  it('carries the correct startLine for each block (1-based into source)', () => {
+    const md = `line 1
+line 2
+\`\`\`ts
+content line A
+content line B
+\`\`\`
+`
+    const blocks = extractCodeBlocks(md)
+    expect(blocks).toHaveLength(1)
+    // Opening fence on line 3 → content starts at line 4
+    expect(blocks[0]!.startLine).toBe(4)
+  })
+
+  it('is idempotent when run twice on the same input', () => {
+    const md = '```ts\nconst x = 1\n```\n'
+    expect(extractCodeBlocks(md)).toEqual(extractCodeBlocks(md))
+  })
+})
+
+describe('isRelevantBlock filter', () => {
+  it('includes ts, tsx, typescript, js, jsx, javascript', () => {
+    for (const lang of ['ts', 'tsx', 'typescript', 'js', 'jsx', 'javascript']) {
+      expect(isRelevantBlock({ lang, source: '', startLine: 1 })).toBe(true)
+    }
+  })
+
+  it('excludes bash, html, md, and untagged blocks', () => {
+    for (const lang of ['bash', 'html', 'md', '', 'sh', 'json']) {
+      expect(isRelevantBlock({ lang, source: '', startLine: 1 })).toBe(false)
+    }
+  })
+
+  it('excludes explicit -broken suffixes (intentional error demos)', () => {
+    expect(isRelevantBlock({ lang: 'tsx-broken', source: '', startLine: 1 })).toBe(false)
+    expect(isRelevantBlock({ lang: 'ts-broken', source: '', startLine: 1 })).toBe(false)
+  })
+})