workspace/

import { createWorkspaceFromDisk } from '@hyperfrontend/versioning'

const workspace = createWorkspaceFromDisk()

// Access projects
for (const project of workspace.projectList) {
  console.log(`${project.name}@${project.version}`)
}

// Get dependents of a package
const dependents = workspace.dependencyGraph.get('lib-utils')

import { findChangelogsInTree, discoverPackages } from '@hyperfrontend/versioning'

// Inside an Nx generator
export default function myGenerator(tree: Tree) {
  const { packages } = discoverPackages()
  const changelogs = findChangelogsInTree(tree, packages)

  for (const [projectPath, changelogPath] of changelogs) {
    console.log(`Found changelog at ${changelogPath}`)
  }
}

import { findProjectChangelogInTree } from '@hyperfrontend/versioning'

// Inside an Nx generator
export default function myGenerator(tree: Tree) {
  const changelogPath = findProjectChangelogInTree(tree, 'libs/my-lib')
  if (changelogPath) {
    const content = tree.read(changelogPath, 'utf-8')
    // Process changelog content
  }
}

import { updateDependencyReferencesInTree } from '@hyperfrontend/versioning'

// Inside an Nx generator
export default function syncDeps(tree: Tree) {
  const updates = new Map([
    ['@myorg/utils', '2.0.0'],
    ['@myorg/core', '3.1.0'],
  ])

  updateDependencyReferencesInTree(tree, 'apps/my-app/package.json', updates)
}

import { discoverProject, addDependent } from '@hyperfrontend/versioning'

const project = discoverProject('./libs/utils')
if (project) {
  const updated = addDependent(project, '@myorg/new-app')
  console.log('Dependents now:', updated.internalDependents)
}

import { createTree, commitChanges } from '@hyperfrontend/project-scope'
import { applyBumps, calculateCascadeBumps } from '@hyperfrontend/versioning'

const tree = createTree(workspaceRoot)
const cascadeResult = calculateCascadeBumps(workspace, directBumps)
const updateResult = applyBumps(tree, workspace, cascadeResult.bumps)

if (updateResult.success) {
  commitChanges(tree) // Atomic commit of all changes
  console.log(`Updated ${updateResult.updated.length} packages`)
} else {
  console.error('Some updates failed:', updateResult.failed)
  // No commitChanges() call - changes are discarded
}

import { buildDependencyGraph, discoverPackages } from '@hyperfrontend/versioning'

const { projects } = discoverPackages()
const analysis = buildDependencyGraph(projects)

// Get packages that depend on 'lib-utils'
const dependents = analysis.dependencyGraph.get('lib-utils') ?? []

// Get packages in topological order for building
const buildOrder = getTopologicalOrder(analysis)

import { calculateCascadeBumps } from '@hyperfrontend/versioning'

// If lib-utils is getting a minor bump
const result = calculateCascadeBumps(workspace, [
  { name: 'lib-utils', bumpType: 'minor' }
])

// result.bumps includes lib-utils and all packages that depend on it
for (const bump of result.bumps) {
  console.log(`${bump.name}: ${bump.currentVersion} -> ${bump.nextVersion}`)
}

import { discoverWorkspace, calculateCascadeBumpsFromPackage } from '@hyperfrontend/versioning'

const workspace = discoverWorkspace()
const result = calculateCascadeBumpsFromPackage(workspace, '@myorg/utils', 'minor')

console.log(`${result.totalAffected} packages will be bumped`)
for (const bump of result.bumps) {
  console.log(`${bump.name}: ${bump.currentVersion} -> ${bump.nextVersion}`)
}

import { createProject, readPackageJson } from '@hyperfrontend/versioning'

const packageJson = readPackageJson('./libs/my-lib/package.json')
const project = createProject({
  name: '@myorg/my-lib',
  version: '1.0.0',
  path: './libs/my-lib',
  packageJsonPath: './libs/my-lib/package.json',
  packageJson,
  changelogPath: './libs/my-lib/CHANGELOG.md',
})

import { createWorkspace, createWorkspaceConfig, createProject } from '@hyperfrontend/versioning'

const projects = new Map([['@myorg/utils', createProject({ ... })]])
const workspace = createWorkspace({
  root: '/path/to/workspace',
  type: 'nx',
  projects,
  config: createWorkspaceConfig(),
  dependencyGraph: new Map(),
  reverseDependencyGraph: new Map(),
})

import { createWorkspaceConfig } from '@hyperfrontend/versioning'

const config = createWorkspaceConfig({
  patterns: ['packages/*', 'libs/*'],
  exclude: ['node_modules', 'dist'],
})

import { discoverWorkspace, dependsOn } from '@hyperfrontend/versioning'

const workspace = discoverWorkspace()
if (dependsOn(workspace, '@myorg/app', '@myorg/utils')) {
  console.log('@myorg/app directly depends on @myorg/utils')
}

import { discoverAllChangelogs } from '@hyperfrontend/versioning'

const changelogs = discoverAllChangelogs('/path/to/workspace')
for (const changelog of changelogs) {
  console.log(`${changelog.projectPath} -> ${changelog.path}`)
}

import { discoverPackages } from '@hyperfrontend/versioning'

// Discover all packages in current workspace
const result = discoverPackages()

// Discover with custom patterns
const result = discoverPackages({
  patterns: ['packages/*/package.json'],
  includeChangelogs: true
})

// Access discovered projects
for (const project of result.projects) {
  console.log(`${project.name}@${project.version}`)
}

import { discoverProject } from '@hyperfrontend/versioning'

const project = discoverProject('./libs/utils')
if (project) {
  console.log(`Found ${project.name}@${project.version}`)
}

// Also accepts direct package.json path
const project2 = discoverProject('./libs/utils/package.json')

import { discoverProjectByName } from '@hyperfrontend/versioning'

const project = discoverProjectByName('@myorg/utils')
if (project) {
  console.log(`Found at ${project.path}`)
}

// With custom workspace root
const project2 = discoverProjectByName('@myorg/core', { workspaceRoot: '/custom/path' })

import { findChangelogs, discoverPackages } from '@hyperfrontend/versioning'

const { packages } = discoverPackages()
const changelogs = findChangelogs('/workspace', packages)

for (const [projectPath, changelogPath] of changelogs) {
  console.log(`${projectPath} -> ${changelogPath}`)
}

const internalDeps = findInternalDependencies(packageJson, allPackageNames)
// ['@scope/lib-a', '@scope/lib-b']

import { findInternalDependenciesWithTypes, readPackageJson } from '@hyperfrontend/versioning'

const packageJson = readPackageJson('./libs/my-lib/package.json')
const workspacePackages = new Set(['@myorg/utils', '@myorg/core'])

const edges = findInternalDependenciesWithTypes('@myorg/my-lib', packageJson, workspacePackages)
for (const edge of edges) {
  console.log(`${edge.from} -> ${edge.to} (${edge.type})`)
}

import { findProjectChangelog } from '@hyperfrontend/versioning'

const changelogPath = findProjectChangelog('./libs/my-lib')
if (changelogPath) {
  console.log('Found changelog:', changelogPath)
}

import { discoverWorkspace, getDependencies } from '@hyperfrontend/versioning'

const workspace = discoverWorkspace()
const deps = getDependencies(workspace, '@myorg/app')
console.log(`@myorg/app depends on:`, deps)

import { discoverProject, getDependencyCount } from '@hyperfrontend/versioning'

const project = discoverProject('./libs/my-lib')
if (project) {
  console.log(`${project.name} depends on ${getDependencyCount(project)} internal packages`)
}

import { discoverProject, getDependentCount } from '@hyperfrontend/versioning'

const project = discoverProject('./libs/utils')
if (project) {
  console.log(`${project.name} is used by ${getDependentCount(project)} packages`)
}

import { discoverWorkspace, getDependents } from '@hyperfrontend/versioning'

const workspace = discoverWorkspace()
const dependents = getDependents(workspace, '@myorg/utils')
console.log(`Packages depending on @myorg/utils:`, dependents)

import { getExpectedChangelogPath } from '@hyperfrontend/versioning'

const changelogPath = getExpectedChangelogPath('./libs/my-lib')
// => '/workspace/libs/my-lib/CHANGELOG.md'

const customPath = getExpectedChangelogPath('./libs/my-lib', 'HISTORY.md')
// => '/workspace/libs/my-lib/HISTORY.md'

import { discoverWorkspace, getProject } from '@hyperfrontend/versioning'

const workspace = discoverWorkspace()
const project = getProject(workspace, '@myorg/utils')
if (project) {
  console.log(`Version: ${project.version}`)
}

import { discoverWorkspace, getProjectCount } from '@hyperfrontend/versioning'

const workspace = discoverWorkspace()
console.log(`Workspace contains ${getProjectCount(workspace)} projects`)

import { discoverWorkspace, getProjectNames } from '@hyperfrontend/versioning'

const workspace = discoverWorkspace()
const names = getProjectNames(workspace)
console.log(`Found ${names.length} projects:`, names)

const buildOrder = getTopologicalOrder(analysis)
for (const pkg of buildOrder) {
  await build(pkg)
}

import { discoverWorkspace, getTransitiveDependencies } from '@hyperfrontend/versioning'

const workspace = discoverWorkspace()
const allDeps = getTransitiveDependencies(workspace, '@myorg/app')

console.log(`@myorg/app transitively depends on ${allDeps.size} packages`)
for (const dep of allDeps) {
  console.log(`  - ${dep}`)
}

// If lib-a depends on lib-utils and app-main depends on lib-a
// Then getTransitiveDependents('lib-utils') returns ['lib-a', 'app-main']

import { hasChangelog } from '@hyperfrontend/versioning'

if (hasChangelog('./libs/my-lib')) {
  console.log('Project has a changelog')
}

import { discoverProject, hasInternalDependencies } from '@hyperfrontend/versioning'

const project = discoverProject('./libs/my-lib')
if (project && hasInternalDependencies(project)) {
  console.log(`${project.name} depends on:`, project.internalDependencies)
}

import { discoverProject, hasInternalDependents } from '@hyperfrontend/versioning'

const project = discoverProject('./libs/utils')
if (project && hasInternalDependents(project)) {
  console.log(`${project.name} is used by:`, project.internalDependents)
}

import { discoverWorkspace, hasProject } from '@hyperfrontend/versioning'

const workspace = discoverWorkspace()
if (hasProject(workspace, '@myorg/utils')) {
  console.log('Package exists in workspace')
}

import { discoverProject, hasChangelog } from '@hyperfrontend/versioning'

const project = discoverProject('./libs/my-lib')
if (project && !hasChangelog(project)) {
  console.log('Warning: No changelog found for', project.name)
}

import { discoverProject, isPrivate } from '@hyperfrontend/versioning'

const project = discoverProject('./apps/internal-app')
if (project && isPrivate(project)) {
  console.log('Skipping private package')
}

import { discoverProject, isPublishable } from '@hyperfrontend/versioning'

const project = discoverProject('./libs/my-lib')
if (project && isPublishable(project)) {
  console.log(`${project.name} can be published to npm`)
}

import { batchUpdateVersions, summarizeBatchUpdate } from '@hyperfrontend/versioning'

const result = batchUpdateVersions(workspace, updates)
console.log(summarizeBatchUpdate(result))
// Output:
// Successfully updated 3 package(s)
//
// Updated packages:
//   @myorg/utils: 1.0.0 -> 1.1.0
//   @myorg/core: 2.0.0 -> 2.1.0

import { calculateCascadeBumps, summarizeCascadeBumps } from '@hyperfrontend/versioning'

const result = calculateCascadeBumps(workspace, [{ name: '@myorg/utils', bumpType: 'patch' }])
console.log(summarizeCascadeBumps(result))
// Output:
// 3 package(s) affected:
//   - 1 direct bump(s)
//   - 2 cascade bump(s)

import { validateWorkspace, summarizeValidation } from '@hyperfrontend/versioning'

const report = validateWorkspace(workspace)
console.log(summarizeValidation(report))
// Output:
// Workspace validation passed
//   2 warning(s)

import { discoverWorkspace, transitivelyDependsOn } from '@hyperfrontend/versioning'

const workspace = discoverWorkspace()

if (transitivelyDependsOn(workspace, '@myorg/app', '@myorg/utils')) {
  console.log('Bumping @myorg/utils will affect @myorg/app')
}

import { updatePackageVersionInTree } from '@hyperfrontend/versioning'

// Inside an Nx generator
export default function bumpVersion(tree: Tree) {
  updatePackageVersionInTree(tree, 'libs/my-lib/package.json', '2.0.0')
}

import { discoverProject, validateProject } from '@hyperfrontend/versioning'

const project = discoverProject('./libs/my-lib')
if (project) {
  const result = validateProject(project)
  if (!result.valid) {
    console.error('Validation failed:', result.error)
  }
}

import { validateWorkspace } from '@hyperfrontend/versioning'

const report = validateWorkspace(workspace)

if (!report.valid) {
  console.error(`${report.errorCount} error(s) found`)
  for (const result of report.results) {
    if (!result.result.valid) {
      console.error(`  ${result.checkName}: ${result.result.error}`)
    }
  }
}

import { discoverProject, withDependents } from '@hyperfrontend/versioning'

const project = discoverProject('./libs/utils')
if (project) {
  const updated = withDependents(project, ['@myorg/app', '@myorg/web'])
  console.log('Updated dependents:', updated.internalDependents)
}