javi-forge 0.1.0

package/src/lib/common.test.ts

@@ -0,0 +1,318 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import path from 'path'
+
+// ── Mock fs-extra ────────────────────────────────────────────────────────────
+vi.mock('fs-extra', () => {
+  const mockFs = {
+    pathExists: vi.fn(),
+    readJson: vi.fn(),
+    readFile: vi.fn(),
+    copy: vi.fn(),
+    ensureDir: vi.fn(),
+  }
+  return { default: mockFs, ...mockFs }
+})
+
+import fs from 'fs-extra'
+import { detectStack, backupIfExists, isGitRepo } from './common.js'
+
+const mockedFs = vi.mocked(fs)
+
+beforeEach(() => {
+  vi.resetAllMocks()
+})
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// detectStack
+// ═══════════════════════════════════════════════════════════════════════════════
+describe('detectStack', () => {
+  function mockFileExists(existingFiles: string[]) {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      return existingFiles.some(f => p.endsWith(f))
+    })
+  }
+
+  it('detects build.gradle → java-gradle', async () => {
+    mockFileExists(['build.gradle'])
+    mockedFs.readFile.mockResolvedValue('sourceCompatibility = 21' as never)
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('java-gradle')
+    expect(result!.buildTool).toBe('gradle')
+    expect(result!.javaVersion).toBe('21')
+  })
+
+  it('detects build.gradle.kts → java-gradle', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle')) return false
+      if (p.endsWith('build.gradle.kts')) return true
+      return false
+    })
+    mockedFs.readFile.mockResolvedValue('jvmTarget = "17"' as never)
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('java-gradle')
+    expect(result!.javaVersion).toBe('17')
+  })
+
+  it('detects pom.xml → java-maven', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle') || p.endsWith('build.gradle.kts')) return false
+      if (p.endsWith('pom.xml')) return true
+      return false
+    })
+    mockedFs.readFile.mockResolvedValue('<java.version>21</java.version>' as never)
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('java-maven')
+    expect(result!.buildTool).toBe('maven')
+  })
+
+  it('detects package.json + pnpm-lock.yaml → node/pnpm', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle') || p.endsWith('build.gradle.kts') || p.endsWith('pom.xml')) return false
+      if (p.endsWith('package.json') || p.endsWith('pnpm-lock.yaml')) return true
+      return false
+    })
+    mockedFs.readJson.mockResolvedValue({} as never)
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('node')
+    expect(result!.buildTool).toBe('pnpm')
+  })
+
+  it('detects package.json + yarn.lock → node/yarn', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle') || p.endsWith('build.gradle.kts') || p.endsWith('pom.xml')) return false
+      if (p.endsWith('package.json') || p.endsWith('yarn.lock')) return true
+      if (p.endsWith('pnpm-lock.yaml')) return false
+      return false
+    })
+    mockedFs.readJson.mockResolvedValue({} as never)
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('node')
+    expect(result!.buildTool).toBe('yarn')
+  })
+
+  it('detects package.json alone → node/npm', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle') || p.endsWith('build.gradle.kts') || p.endsWith('pom.xml')) return false
+      if (p.endsWith('package.json')) return true
+      return false
+    })
+    mockedFs.readJson.mockResolvedValue({} as never)
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('node')
+    expect(result!.buildTool).toBe('npm')
+  })
+
+  it('detects pyproject.toml → python/pyproject', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle') || p.endsWith('build.gradle.kts') || p.endsWith('pom.xml') || p.endsWith('package.json')) return false
+      if (p.endsWith('pyproject.toml')) return true
+      return false
+    })
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('python')
+    expect(result!.buildTool).toBe('pyproject')
+  })
+
+  it('detects requirements.txt → python/pip', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle') || p.endsWith('build.gradle.kts') || p.endsWith('pom.xml') || p.endsWith('package.json')) return false
+      if (p.endsWith('pyproject.toml')) return false
+      if (p.endsWith('requirements.txt')) return true
+      if (p.endsWith('Pipfile')) return false
+      return false
+    })
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('python')
+    expect(result!.buildTool).toBe('pip')
+  })
+
+  it('detects Pipfile → python/pipenv', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle') || p.endsWith('build.gradle.kts') || p.endsWith('pom.xml') || p.endsWith('package.json')) return false
+      if (p.endsWith('pyproject.toml')) return false
+      if (p.endsWith('requirements.txt') || p.endsWith('setup.py')) return true
+      if (p.endsWith('Pipfile')) return true
+      return false
+    })
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('python')
+    expect(result!.buildTool).toBe('pipenv')
+  })
+
+  it('detects go.mod → go', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('go.mod')) return true
+      return false
+    })
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('go')
+    expect(result!.buildTool).toBe('go')
+  })
+
+  it('detects Cargo.toml → rust', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('Cargo.toml')) return true
+      return false
+    })
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('rust')
+    expect(result!.buildTool).toBe('cargo')
+  })
+
+  it('detects mix.exs → elixir', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('mix.exs')) return true
+      return false
+    })
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('elixir')
+    expect(result!.buildTool).toBe('mix')
+  })
+
+  it('returns null for empty directory', async () => {
+    mockedFs.pathExists.mockResolvedValue(false as never)
+    const result = await detectStack('/empty-project')
+    expect(result).toBeNull()
+  })
+
+  it('gives java-gradle precedence when both gradle + package.json exist', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle') || p.endsWith('package.json')) return true
+      return false
+    })
+    mockedFs.readFile.mockResolvedValue('sourceCompatibility = 21' as never)
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('java-gradle')
+  })
+
+  it('detects JavaVersion.VERSION_21 in build.gradle', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle')) return true
+      return false
+    })
+    mockedFs.readFile.mockResolvedValue('JavaVersion.VERSION_21' as never)
+    const result = await detectStack('/project')
+    expect(result!.javaVersion).toBe('21')
+  })
+
+  it('detects JavaVersion.VERSION_17 in build.gradle.kts', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle')) return false
+      if (p.endsWith('build.gradle.kts')) return true
+      return false
+    })
+    mockedFs.readFile.mockResolvedValue('JavaVersion.VERSION_17' as never)
+    const result = await detectStack('/project')
+    expect(result!.javaVersion).toBe('17')
+  })
+
+  it('detects maven.compiler.source in pom.xml', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle') || p.endsWith('build.gradle.kts')) return false
+      if (p.endsWith('pom.xml')) return true
+      return false
+    })
+    mockedFs.readFile.mockResolvedValue('<maven.compiler.source>17</maven.compiler.source>' as never)
+    const result = await detectStack('/project')
+    expect(result!.javaVersion).toBe('17')
+  })
+
+  it('returns undefined javaVersion when no version pattern matches', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle')) return true
+      return false
+    })
+    mockedFs.readFile.mockResolvedValue('apply plugin: java' as never)
+    const result = await detectStack('/project')
+    expect(result!.javaVersion).toBeUndefined()
+  })
+
+  it('handles readJson error for package.json gracefully', async () => {
+    mockedFs.pathExists.mockImplementation(async (filePath: unknown) => {
+      const p = String(filePath)
+      if (p.endsWith('build.gradle') || p.endsWith('build.gradle.kts') || p.endsWith('pom.xml')) return false
+      if (p.endsWith('package.json')) return true
+      return false
+    })
+    mockedFs.readJson.mockRejectedValue(new Error('invalid json') as never)
+    const result = await detectStack('/project')
+    expect(result).not.toBeNull()
+    expect(result!.stackType).toBe('node')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// backupIfExists
+// ═══════════════════════════════════════════════════════════════════════════════
+describe('backupIfExists', () => {
+  it('creates .bak and returns true when file exists', async () => {
+    mockedFs.pathExists.mockResolvedValue(true as never)
+    mockedFs.copy.mockResolvedValue(undefined as never)
+
+    const result = await backupIfExists('/project/ci.yml')
+    expect(result).toBe(true)
+    expect(mockedFs.copy).toHaveBeenCalledWith(
+      '/project/ci.yml',
+      '/project/ci.yml.bak',
+      { overwrite: true }
+    )
+  })
+
+  it('returns false when file does not exist', async () => {
+    mockedFs.pathExists.mockResolvedValue(false as never)
+
+    const result = await backupIfExists('/project/nonexistent.yml')
+    expect(result).toBe(false)
+    expect(mockedFs.copy).not.toHaveBeenCalled()
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// isGitRepo
+// ═══════════════════════════════════════════════════════════════════════════════
+describe('isGitRepo', () => {
+  it('returns true when .git exists', async () => {
+    mockedFs.pathExists.mockResolvedValue(true as never)
+    const result = await isGitRepo('/project')
+    expect(result).toBe(true)
+    expect(mockedFs.pathExists).toHaveBeenCalledWith(
+      path.join('/project', '.git')
+    )
+  })
+
+  it('returns false when .git does not exist', async () => {
+    mockedFs.pathExists.mockResolvedValue(false as never)
+    const result = await isGitRepo('/project')
+    expect(result).toBe(false)
+  })
+})

package/src/lib/common.ts

@@ -0,0 +1,127 @@
+import fs from 'fs-extra'
+import path from 'path'
+import type { Stack, StackDetection } from '../types/index.js'
+
+/**
+ * Detect the project stack by looking for well-known build/config files.
+ * Returns the first match (precedence order matters).
+ */
+export async function detectStack(projectDir: string): Promise<StackDetection | null> {
+  const exists = async (file: string) =>
+    fs.pathExists(path.join(projectDir, file))
+
+  // Java — Gradle
+  if (await exists('build.gradle') || await exists('build.gradle.kts')) {
+    const javaVersion = await detectJavaVersion(projectDir)
+    return { stackType: 'java-gradle', buildTool: 'gradle', javaVersion }
+  }
+
+  // Java — Maven
+  if (await exists('pom.xml')) {
+    const javaVersion = await detectJavaVersion(projectDir)
+    return { stackType: 'java-maven', buildTool: 'maven', javaVersion }
+  }
+
+  // Node.js
+  if (await exists('package.json')) {
+    const pkg = await fs.readJson(path.join(projectDir, 'package.json')).catch(() => ({}))
+    const buildTool = await exists('pnpm-lock.yaml') ? 'pnpm'
+      : await exists('yarn.lock') ? 'yarn'
+      : 'npm'
+    return { stackType: 'node', buildTool }
+  }
+
+  // Python
+  if (await exists('pyproject.toml') || await exists('requirements.txt') || await exists('setup.py')) {
+    const buildTool = await exists('pyproject.toml') ? 'pyproject'
+      : await exists('Pipfile') ? 'pipenv'
+      : 'pip'
+    return { stackType: 'python', buildTool }
+  }
+
+  // Go
+  if (await exists('go.mod')) {
+    return { stackType: 'go', buildTool: 'go' }
+  }
+
+  // Rust
+  if (await exists('Cargo.toml')) {
+    return { stackType: 'rust', buildTool: 'cargo' }
+  }
+
+  // Elixir
+  if (await exists('mix.exs')) {
+    return { stackType: 'elixir', buildTool: 'mix' }
+  }
+
+  return null
+}
+
+/** Try to detect Java version from gradle or maven config */
+async function detectJavaVersion(projectDir: string): Promise<string | undefined> {
+  // Try build.gradle
+  const gradleFile = path.join(projectDir, 'build.gradle')
+  if (await fs.pathExists(gradleFile)) {
+    const content = await fs.readFile(gradleFile, 'utf-8')
+    const match = content.match(/sourceCompatibility\s*=\s*['"]?(\d+)/)
+      || content.match(/JavaVersion\.VERSION_(\d+)/)
+    if (match) return match[1]
+  }
+
+  // Try build.gradle.kts
+  const ktsFile = path.join(projectDir, 'build.gradle.kts')
+  if (await fs.pathExists(ktsFile)) {
+    const content = await fs.readFile(ktsFile, 'utf-8')
+    const match = content.match(/jvmTarget\s*=\s*['"](\d+)['"]/)
+      || content.match(/JavaVersion\.VERSION_(\d+)/)
+    if (match) return match[1]
+  }
+
+  // Try pom.xml
+  const pomFile = path.join(projectDir, 'pom.xml')
+  if (await fs.pathExists(pomFile)) {
+    const content = await fs.readFile(pomFile, 'utf-8')
+    const match = content.match(/<java\.version>(\d+)</)
+      || content.match(/<maven\.compiler\.source>(\d+)</)
+    if (match) return match[1]
+  }
+
+  return undefined
+}
+
+/** Back up a file by copying to filePath.bak (only if it exists) */
+export async function backupIfExists(filePath: string): Promise<boolean> {
+  if (await fs.pathExists(filePath)) {
+    await fs.copy(filePath, `${filePath}.bak`, { overwrite: true })
+    return true
+  }
+  return false
+}
+
+/** Create a directory recursively if it doesn't exist */
+export async function ensureDirExists(dirPath: string): Promise<void> {
+  await fs.ensureDir(dirPath)
+}
+
+/** Check if a directory is a git repository */
+export async function isGitRepo(dir: string): Promise<boolean> {
+  return fs.pathExists(path.join(dir, '.git'))
+}
+
+/** Resolve the forge assets root (the package root directory) */
+export function getForgeRoot(): string {
+  // When running from dist/, go up one level
+  const thisDir = path.dirname(new URL(import.meta.url).pathname)
+  return path.resolve(thisDir, '..')
+}
+
+/** Stack display names */
+export const STACK_LABELS: Record<Stack, string> = {
+  'node':        'Node.js / TypeScript',
+  'python':      'Python',
+  'go':          'Go',
+  'rust':        'Rust',
+  'java-gradle': 'Java (Gradle)',
+  'java-maven':  'Java (Maven)',
+  'elixir':      'Elixir',
+}