javi-forge 0.1.0

package/src/lib/frontmatter.test.ts

@@ -0,0 +1,291 @@
+import { describe, it, expect } from 'vitest'
+import { parseFrontmatter, validateFrontmatter } from './frontmatter.js'
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// parseFrontmatter
+// ═══════════════════════════════════════════════════════════════════════════════
+describe('parseFrontmatter', () => {
+  it('parses valid frontmatter with content', () => {
+    const raw = `---
+name: my-skill
+description: A test skill
+---
+Some body content here.`
+    const result = parseFrontmatter(raw)
+    expect(result).not.toBeNull()
+    expect(result!.data).toEqual({ name: 'my-skill', description: 'A test skill' })
+    expect(result!.content).toBe('Some body content here.')
+  })
+
+  it('returns null when no closing ---', () => {
+    const raw = `---
+name: broken
+description: missing close`
+    expect(parseFrontmatter(raw)).toBeNull()
+  })
+
+  it('returns null for non-frontmatter text', () => {
+    const raw = 'Just some regular markdown text.'
+    expect(parseFrontmatter(raw)).toBeNull()
+  })
+
+  it('returns null for empty YAML block', () => {
+    const raw = `---
+---
+Body content`
+    // An empty YAML block parses to null, which triggers the null check
+    expect(parseFrontmatter(raw)).toBeNull()
+  })
+
+  it('returns null for invalid YAML', () => {
+    const raw = `---
+: : : invalid: [yaml
+---
+Body`
+    expect(parseFrontmatter(raw)).toBeNull()
+  })
+
+  it('returns null when YAML parses to a non-object (string)', () => {
+    const raw = `---
+just a string
+---
+Body`
+    expect(parseFrontmatter(raw)).toBeNull()
+  })
+
+  it('returns null when YAML parses to null', () => {
+    const raw = `---
+null
+---
+Body`
+    expect(parseFrontmatter(raw)).toBeNull()
+  })
+
+  it('handles frontmatter with empty content body', () => {
+    const raw = `---
+name: test
+---`
+    const result = parseFrontmatter(raw)
+    expect(result).not.toBeNull()
+    expect(result!.data).toEqual({ name: 'test' })
+    expect(result!.content).toBe('')
+  })
+
+  it('only uses first pair of --- delimiters', () => {
+    const raw = `---
+name: first
+---
+Some content
+---
+name: second
+---`
+    const result = parseFrontmatter(raw)
+    expect(result).not.toBeNull()
+    expect(result!.data).toEqual({ name: 'first' })
+    expect(result!.content).toContain('name: second')
+  })
+
+  it('handles complex nested YAML', () => {
+    const raw = `---
+name: complex-skill
+metadata:
+  version: 1.2.3
+  tags:
+    - typescript
+    - react
+  config:
+    nested: true
+    count: 42
+---
+Body content`
+    const result = parseFrontmatter(raw)
+    expect(result).not.toBeNull()
+    expect(result!.data['name']).toBe('complex-skill')
+    expect(result!.data['metadata']).toEqual({
+      version: '1.2.3',
+      tags: ['typescript', 'react'],
+      config: { nested: true, count: 42 },
+    })
+  })
+
+  it('handles leading whitespace before frontmatter', () => {
+    const raw = `  
+---
+name: trimmed
+---
+Body`
+    const result = parseFrontmatter(raw)
+    expect(result).not.toBeNull()
+    expect(result!.data['name']).toBe('trimmed')
+  })
+
+  it('verifies slice indices — content excludes closing delimiter', () => {
+    const raw = `---
+key: value
+---
+Exact content`
+    const result = parseFrontmatter(raw)
+    expect(result).not.toBeNull()
+    // Verify yamlBlock is trimmed correctly (no leading/trailing whitespace artifacts)
+    expect(result!.data).toEqual({ key: 'value' })
+    // Content should be exactly what follows after the closing ---
+    expect(result!.content).toBe('Exact content')
+  })
+
+  it('trims whitespace from yaml block', () => {
+    const raw = `---
+  spaced: true  
+---
+Body`
+    const result = parseFrontmatter(raw)
+    expect(result).not.toBeNull()
+    expect(result!.data).toEqual({ spaced: true })
+  })
+
+  it('rejects input starting with text then ---', () => {
+    // This should NOT match — the --- must be at the very start (after trimStart)
+    const raw = `text before
+---
+name: test
+---`
+    expect(parseFrontmatter(raw)).toBeNull()
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// validateFrontmatter
+// ═══════════════════════════════════════════════════════════════════════════════
+describe('validateFrontmatter', () => {
+  it('returns no errors for valid agent frontmatter', () => {
+    const fm = { name: 'my-agent', description: 'A valid agent description' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors).toEqual([])
+  })
+
+  it('returns no errors for valid skill with Trigger:', () => {
+    const fm = { name: 'my-skill', description: 'A valid skill. Trigger: when testing' }
+    const errors = validateFrontmatter(fm, 'skill')
+    expect(errors).toEqual([])
+  })
+
+  it('returns error for missing name', () => {
+    const fm = { description: 'Valid description here' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors).toHaveLength(1)
+    expect(errors[0].field).toBe('name')
+    expect(errors[0].message).toContain('required')
+  })
+
+  it('returns error for non-string name', () => {
+    const fm = { name: 42, description: 'Valid description here' }
+    const errors = validateFrontmatter(fm as any, 'agent')
+    expect(errors.some(e => e.field === 'name')).toBe(true)
+  })
+
+  it('returns error for name too short (1 char)', () => {
+    const fm = { name: 'a', description: 'Valid description here' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors.some(e => e.field === 'name' && e.message.includes('2-60'))).toBe(true)
+  })
+
+  it('accepts name exactly 2 chars', () => {
+    const fm = { name: 'ab', description: 'Valid description here' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors).toEqual([])
+  })
+
+  it('accepts name exactly 60 chars', () => {
+    const name = 'a'.repeat(60)
+    const fm = { name, description: 'Valid description here' }
+    const errors = validateFrontmatter(fm, 'agent')
+    // Name is 60 'a's — valid length but fails kebab-case (no hyphens needed for single segment of lowercase)
+    // Actually 'a' repeated 60 times IS valid kebab-case: /^[a-z0-9]+(-[a-z0-9]+)*$/
+    expect(errors.filter(e => e.message.includes('2-60'))).toEqual([])
+  })
+
+  it('returns error for name 61 chars', () => {
+    const name = 'a'.repeat(61)
+    const fm = { name, description: 'Valid description here' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors.some(e => e.field === 'name' && e.message.includes('2-60'))).toBe(true)
+  })
+
+  it('returns error for uppercase name', () => {
+    const fm = { name: 'MyAgent', description: 'Valid description here' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors.some(e => e.field === 'name' && e.message.includes('kebab-case'))).toBe(true)
+  })
+
+  it('returns error for name with spaces', () => {
+    const fm = { name: 'my agent', description: 'Valid description here' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors.some(e => e.field === 'name' && e.message.includes('kebab-case'))).toBe(true)
+  })
+
+  it('returns error for missing description', () => {
+    const fm = { name: 'my-agent' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors.some(e => e.field === 'description')).toBe(true)
+  })
+
+  it('returns error for description too short (9 chars)', () => {
+    const fm = { name: 'my-agent', description: '123456789' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors.some(e => e.field === 'description' && e.message.includes('10'))).toBe(true)
+  })
+
+  it('accepts description exactly 10 chars', () => {
+    const fm = { name: 'my-agent', description: '1234567890' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors.filter(e => e.field === 'description')).toEqual([])
+  })
+
+  it('returns error for skill without Trigger:', () => {
+    const fm = { name: 'my-skill', description: 'A valid skill description' }
+    const errors = validateFrontmatter(fm, 'skill')
+    expect(errors.some(e => e.field === 'description' && e.message.includes('Trigger:'))).toBe(true)
+  })
+
+  it('returns no Trigger: error for agent type', () => {
+    const fm = { name: 'my-agent', description: 'A valid agent description' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors.some(e => e.message.includes('Trigger:'))).toBe(false)
+  })
+
+  it('returns error for empty string name', () => {
+    const fm = { name: '', description: 'Valid description here' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors.some(e => e.field === 'name')).toBe(true)
+  })
+
+  it('returns error for empty string description', () => {
+    const fm = { name: 'my-agent', description: '' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors.some(e => e.field === 'description')).toBe(true)
+  })
+
+  it('returns multiple errors for multiple violations', () => {
+    const fm = { name: 'AB', description: 'short' }
+    const errors = validateFrontmatter(fm, 'skill')
+    // Name is uppercase → kebab error, description < 10 → length error, no Trigger: → skill error
+    expect(errors.length).toBeGreaterThanOrEqual(2)
+  })
+
+  it('validates name with numbers in kebab-case', () => {
+    const fm = { name: 'my-skill-v2', description: 'A valid description for testing' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors).toEqual([])
+  })
+
+  it('rejects name starting with hyphen', () => {
+    const fm = { name: '-invalid', description: 'A valid description for testing' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors.some(e => e.field === 'name' && e.message.includes('kebab-case'))).toBe(true)
+  })
+
+  it('rejects name ending with hyphen', () => {
+    const fm = { name: 'invalid-', description: 'A valid description for testing' }
+    const errors = validateFrontmatter(fm, 'agent')
+    expect(errors.some(e => e.field === 'name' && e.message.includes('kebab-case'))).toBe(true)
+  })
+})

package/src/lib/frontmatter.ts

@@ -0,0 +1,77 @@
+import YAML from 'yaml'
+
+export interface FrontmatterResult {
+  data: Record<string, unknown>
+  content: string
+}
+
+/**
+ * Extract YAML frontmatter from a markdown string.
+ * Frontmatter is delimited by --- at the start of the file.
+ */
+export function parseFrontmatter(raw: string): FrontmatterResult | null {
+  const trimmed = raw.trimStart()
+  if (!trimmed.startsWith('---')) return null
+
+  const endIdx = trimmed.indexOf('---', 3)
+  if (endIdx === -1) return null
+
+  const yamlBlock = trimmed.slice(3, endIdx).trim()
+  const content = trimmed.slice(endIdx + 3).trim()
+
+  try {
+    const data = YAML.parse(yamlBlock) as Record<string, unknown>
+    if (typeof data !== 'object' || data === null) return null
+    return { data, content }
+  } catch {
+    return null
+  }
+}
+
+export interface ValidationError {
+  field: string
+  message: string
+}
+
+const KEBAB_CASE_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/
+
+/**
+ * Validate frontmatter against schema rules for agent or skill definitions.
+ */
+export function validateFrontmatter(
+  frontmatter: Record<string, unknown>,
+  type: 'agent' | 'skill'
+): ValidationError[] {
+  const errors: ValidationError[] = []
+
+  // name: required, kebab-case, 2-60 chars
+  const name = frontmatter['name']
+  if (typeof name !== 'string' || !name) {
+    errors.push({ field: 'name', message: 'name is required and must be a string' })
+  } else {
+    if (name.length < 2 || name.length > 60) {
+      errors.push({ field: 'name', message: 'name must be 2-60 characters' })
+    }
+    if (!KEBAB_CASE_RE.test(name)) {
+      errors.push({ field: 'name', message: 'name must be kebab-case (e.g. my-skill-name)' })
+    }
+  }
+
+  // description: required, non-empty, min 10 chars
+  const desc = frontmatter['description']
+  if (typeof desc !== 'string' || !desc) {
+    errors.push({ field: 'description', message: 'description is required and must be a string' })
+  } else if (desc.length < 10) {
+    errors.push({ field: 'description', message: 'description must be at least 10 characters' })
+  }
+
+  // skill-specific: description should include "Trigger:" hint
+  if (type === 'skill' && typeof desc === 'string' && !desc.includes('Trigger:')) {
+    errors.push({
+      field: 'description',
+      message: 'skill description should include a "Trigger:" hint for auto-invoke',
+    })
+  }
+
+  return errors
+}

package/src/lib/template.test.ts

@@ -0,0 +1,226 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import path from 'path'
+
+// ── Mock fs-extra ────────────────────────────────────────────────────────────
+vi.mock('fs-extra', () => {
+  const mockFs = {
+    pathExists: vi.fn(),
+    readFile: vi.fn(),
+    readJson: vi.fn(),
+    copy: vi.fn(),
+    ensureDir: vi.fn(),
+  }
+  return { default: mockFs, ...mockFs }
+})
+
+import fs from 'fs-extra'
+import { renderTemplate, generateDependabotYml, getCITemplatePath, getCIDestination, generateCIWorkflow } from './template.js'
+import type { Stack, CIProvider } from '../types/index.js'
+
+const mockedFs = vi.mocked(fs)
+
+beforeEach(() => {
+  vi.resetAllMocks()
+})
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// getCITemplatePath (pure function)
+// ═══════════════════════════════════════════════════════════════════════════════
+describe('getCITemplatePath', () => {
+  it('returns correct path for node + github', () => {
+    const result = getCITemplatePath('node', 'github')
+    expect(result).not.toBeNull()
+    expect(result).toContain('github')
+    expect(result).toContain('ci-node.yml')
+  })
+
+  it('returns correct path for python + gitlab', () => {
+    const result = getCITemplatePath('python', 'gitlab')
+    expect(result).not.toBeNull()
+    expect(result).toContain('gitlab')
+    expect(result).toContain('gitlab-ci-python.yml')
+  })
+
+  it('returns null for unknown stack', () => {
+    const result = getCITemplatePath('haskell' as Stack, 'github')
+    expect(result).toBeNull()
+  })
+
+  it('returns null for unknown provider', () => {
+    const result = getCITemplatePath('node', 'bitbucket' as CIProvider)
+    expect(result).toBeNull()
+  })
+
+  it('returns non-null for all valid stack+provider combinations', () => {
+    const stacks: Stack[] = ['node', 'python', 'go', 'rust', 'java-gradle', 'java-maven']
+    const providers: CIProvider[] = ['github', 'gitlab', 'woodpecker']
+
+    for (const stack of stacks) {
+      for (const provider of providers) {
+        const result = getCITemplatePath(stack, provider)
+        expect(result).not.toBeNull()
+      }
+    }
+  })
+
+  it('returns null for elixir (no CI template)', () => {
+    // Elixir is not in the STACK_CI_MAP entries
+    const result = getCITemplatePath('elixir', 'github')
+    expect(result).toBeNull()
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// getCIDestination (pure function)
+// ═══════════════════════════════════════════════════════════════════════════════
+describe('getCIDestination', () => {
+  it('returns .github/workflows for github', () => {
+    expect(getCIDestination('github')).toBe('.github/workflows/ci.yml')
+  })
+
+  it('returns .gitlab-ci.yml for gitlab', () => {
+    expect(getCIDestination('gitlab')).toBe('.gitlab-ci.yml')
+  })
+
+  it('returns .woodpecker.yml for woodpecker', () => {
+    expect(getCIDestination('woodpecker')).toBe('.woodpecker.yml')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// renderTemplate
+// ═══════════════════════════════════════════════════════════════════════════════
+describe('renderTemplate', () => {
+  it('replaces a single placeholder', async () => {
+    mockedFs.readFile.mockResolvedValue('Hello __NAME__!' as never)
+    const result = await renderTemplate('/tpl/test.yml', { NAME: 'World' })
+    expect(result).toBe('Hello World!')
+  })
+
+  it('replaces multiple different placeholders', async () => {
+    mockedFs.readFile.mockResolvedValue('__GREETING__ __NAME__, age __AGE__' as never)
+    const result = await renderTemplate('/tpl/test.yml', {
+      GREETING: 'Hi',
+      NAME: 'Alice',
+      AGE: '30',
+    })
+    expect(result).toBe('Hi Alice, age 30')
+  })
+
+  it('returns content unchanged when no placeholders', async () => {
+    mockedFs.readFile.mockResolvedValue('No placeholders here.' as never)
+    const result = await renderTemplate('/tpl/test.yml', { NAME: 'World' })
+    expect(result).toBe('No placeholders here.')
+  })
+
+  it('replaces placeholder appearing multiple times', async () => {
+    mockedFs.readFile.mockResolvedValue('__X__ and __X__ again' as never)
+    const result = await renderTemplate('/tpl/test.yml', { X: 'val' })
+    expect(result).toBe('val and val again')
+  })
+
+  it('handles empty variable value', async () => {
+    mockedFs.readFile.mockResolvedValue('prefix__EMPTY__suffix' as never)
+    const result = await renderTemplate('/tpl/test.yml', { EMPTY: '' })
+    expect(result).toBe('prefixsuffix')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// generateDependabotYml
+// ═══════════════════════════════════════════════════════════════════════════════
+describe('generateDependabotYml', () => {
+  it('generates for a single stack', async () => {
+    mockedFs.readFile.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.includes('header.yml')) return 'version: 2\nupdates:\n' as never
+      if (p.includes('github-actions.yml')) return '  - package-ecosystem: github-actions\n' as never
+      if (p.includes('npm.yml')) return '  - package-ecosystem: npm\n' as never
+      return '' as never
+    })
+    mockedFs.pathExists.mockResolvedValue(true as never)
+
+    const result = await generateDependabotYml(['node'], true)
+    expect(result).toContain('version: 2')
+    expect(result).toContain('github-actions')
+    expect(result).toContain('npm')
+  })
+
+  it('deduplicates fragments for multiple stacks', async () => {
+    let npmCallCount = 0
+    mockedFs.readFile.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.includes('header.yml')) return 'header\n' as never
+      if (p.includes('github-actions.yml')) return 'gh-actions\n' as never
+      if (p.includes('npm.yml')) {
+        npmCallCount++
+        return 'npm-fragment\n' as never
+      }
+      return '' as never
+    })
+    mockedFs.pathExists.mockResolvedValue(true as never)
+
+    // Two node stacks — 'npm' fragment should only appear once
+    const result = await generateDependabotYml(['node', 'node'], true)
+    expect(npmCallCount).toBe(1)
+  })
+
+  it('includes github-actions fragment when includeGitHubActions is true', async () => {
+    let githubActionsRead = false
+    mockedFs.readFile.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.includes('header.yml')) return 'header\n' as never
+      if (p.includes('github-actions.yml')) {
+        githubActionsRead = true
+        return 'gh-actions\n' as never
+      }
+      return '' as never
+    })
+    mockedFs.pathExists.mockResolvedValue(true as never)
+
+    await generateDependabotYml([], true)
+    expect(githubActionsRead).toBe(true)
+  })
+
+  it('excludes github-actions fragment when includeGitHubActions is false', async () => {
+    let githubActionsRead = false
+    mockedFs.readFile.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.includes('header.yml')) return 'header\n' as never
+      if (p.includes('github-actions.yml')) {
+        githubActionsRead = true
+        return 'gh-actions\n' as never
+      }
+      return '' as never
+    })
+    mockedFs.pathExists.mockResolvedValue(true as never)
+
+    await generateDependabotYml([], false)
+    expect(githubActionsRead).toBe(false)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// generateCIWorkflow
+// ═══════════════════════════════════════════════════════════════════════════════
+describe('generateCIWorkflow', () => {
+  it('returns file content for valid stack+provider', async () => {
+    mockedFs.pathExists.mockResolvedValue(true as never)
+    mockedFs.readFile.mockResolvedValue('name: CI\non: push' as never)
+
+    const result = await generateCIWorkflow('node', 'github')
+    expect(result).not.toBeNull()
+    expect(result).toContain('name: CI')
+  })
+
+  it('returns null when no template mapping exists', async () => {
+    const result = await generateCIWorkflow('elixir', 'github')
+    expect(result).toBeNull()
+  })
+
+  it('returns null when template file does not exist on disk', async () => {
+    mockedFs.pathExists.mockResolvedValue(false as never)
+    const result = await generateCIWorkflow('node', 'github')
+    expect(result).toBeNull()
+  })
+})

package/src/lib/template.ts

@@ -0,0 +1,99 @@
+import fs from 'fs-extra'
+import path from 'path'
+import type { Stack, CIProvider } from '../types/index.js'
+import {
+  TEMPLATES_DIR,
+  DEPENDABOT_FRAGMENTS_DIR,
+  STACK_DEPENDABOT_MAP,
+  STACK_CI_MAP,
+} from '../constants.js'
+
+/**
+ * Read a template file and replace __VAR_NAME__ placeholders.
+ */
+export async function renderTemplate(
+  templatePath: string,
+  vars: Record<string, string>
+): Promise<string> {
+  let content = await fs.readFile(templatePath, 'utf-8')
+  for (const [key, value] of Object.entries(vars)) {
+    const placeholder = `__${key}__`
+    content = content.replaceAll(placeholder, value)
+  }
+  return content
+}
+
+/**
+ * Assemble a dependabot.yml from the header + stack-specific fragments.
+ * Always includes github-actions fragment when provider is GitHub.
+ */
+export async function generateDependabotYml(
+  stacks: Stack[],
+  includeGitHubActions = true
+): Promise<string> {
+  const headerPath = path.join(DEPENDABOT_FRAGMENTS_DIR, 'header.yml')
+  let content = await fs.readFile(headerPath, 'utf-8')
+
+  // Collect unique fragment names
+  const fragments = new Set<string>()
+  if (includeGitHubActions) fragments.add('github-actions')
+
+  for (const stack of stacks) {
+    const stackFragments = STACK_DEPENDABOT_MAP[stack] ?? []
+    for (const f of stackFragments) fragments.add(f)
+  }
+
+  // Append each fragment
+  for (const fragmentName of fragments) {
+    const fragmentPath = path.join(DEPENDABOT_FRAGMENTS_DIR, `${fragmentName}.yml`)
+    if (await fs.pathExists(fragmentPath)) {
+      const fragment = await fs.readFile(fragmentPath, 'utf-8')
+      content += '\n' + fragment
+    }
+  }
+
+  return content
+}
+
+/**
+ * Get the CI workflow template path for a given stack + provider combination.
+ * Returns null if no template exists for that combination.
+ */
+export function getCITemplatePath(stack: Stack, provider: CIProvider): string | null {
+  const providerMap = STACK_CI_MAP[provider]
+  if (!providerMap) return null
+
+  const filename = providerMap[stack]
+  if (!filename) return null
+
+  return path.join(TEMPLATES_DIR, provider, filename)
+}
+
+/**
+ * Generate the CI workflow file content for a given stack + provider.
+ */
+export async function generateCIWorkflow(
+  stack: Stack,
+  provider: CIProvider
+): Promise<string | null> {
+  const templatePath = getCITemplatePath(stack, provider)
+  if (!templatePath) return null
+
+  if (!await fs.pathExists(templatePath)) return null
+
+  return fs.readFile(templatePath, 'utf-8')
+}
+
+/**
+ * Get the destination path for a CI workflow file within a project.
+ */
+export function getCIDestination(provider: CIProvider): string {
+  switch (provider) {
+    case 'github':
+      return '.github/workflows/ci.yml'
+    case 'gitlab':
+      return '.gitlab-ci.yml'
+    case 'woodpecker':
+      return '.woodpecker.yml'
+  }
+}