flow/

// Auto-detect repository
const flow = createFlow({
  repository: 'inferred'
})

// Explicit repository
const flow = createFlow({
  repository: {
    platform: 'github',
    baseUrl: 'https://github.com/owner/repo'
  }
})

import { addStep, createConventionalFlow, createNoopStep } from '@hyperfrontend/versioning'

const flow = createConventionalFlow()
const extended = addStep(flow, createNoopStep('custom', 'Custom Step'))

console.log(extended.steps.length)
// => original steps + 1

import { createAnalyzeCommitsStep, executeStep } from '@hyperfrontend/versioning'

const step = createAnalyzeCommitsStep()
const result = await executeStep(step, context)

// Access analyzed commits
console.log(result.stateUpdates?.commits)
// => [{ type: 'feat', subject: 'add feature' }, ...]

import { createBatchReleaseFlow, executeFlow } from '@hyperfrontend/versioning'

// Release multiple packages without individual commits
for (const pkg of ['lib-a', 'lib-b', 'lib-c']) {
  await executeFlow(createBatchReleaseFlow(), pkg, '/workspace')
}
// Then create a single combined commit

import { createCalculateBumpStep, executeStep } from '@hyperfrontend/versioning'

const step = createCalculateBumpStep()
const result = await executeStep(step, context)

// Get the calculated bump
console.log(result.stateUpdates?.bumpType)
// => 'minor'
console.log(result.stateUpdates?.nextVersion)
// => '1.2.0'

import { createCascadeDependenciesStep, executeStep } from '@hyperfrontend/versioning'

const step = createCascadeDependenciesStep()
const result = await executeStep(step, contextWithTrackDeps)

// Dependent packages are updated
console.log(result.message)

import { createChangelogOnlyFlow, executeFlow } from '@hyperfrontend/versioning'

const flow = createChangelogOnlyFlow()
const result = await executeFlow(flow, 'my-lib', '/workspace')

// Only changelog is updated, no version bump
console.log(result.state.changelogEntry)

import { createCheckDependentBumpsStep, executeStep } from '@hyperfrontend/versioning'

const step = createCheckDependentBumpsStep()
const result = await executeStep(step, contextWithTrackDeps)

// Result indicates if any dependents need bumps
console.log(result.message)

import { createCheckIdempotencyStep, executeStep } from '@hyperfrontend/versioning'

const step = createCheckIdempotencyStep()
const result = await executeStep(step, context)

// If version already published, step skips with bumpType: 'none'
if (result.status === 'skipped') {
  console.log('Version already published')
}

import { createCombinedChangelogStep, executeStep } from '@hyperfrontend/versioning'

const step = createCombinedChangelogStep()
const result = await executeStep(step, context)

// Single changelog for all packages
console.log(result.message)

import { createConventionalFlow, executeFlow } from '@hyperfrontend/versioning'

// Use defaults
const flow = createConventionalFlow()

// With overrides
const customFlow = createConventionalFlow({
  skipTag: false,
  releaseTypes: ['feat', 'fix'],
})

const result = await executeFlow(flow, 'lib-utils', '/workspace')

import { createDryRunFlow, executeFlow } from '@hyperfrontend/versioning'

const flow = createDryRunFlow('conventional')
const result = await executeFlow(flow, 'my-lib', '/workspace')

// Preview changes without modifying files
console.log('Would release:', result.state.nextVersion)

import { createFailedResult } from '@hyperfrontend/versioning'

// In a step handler:
try {
  await doOperation()
} catch (err) {
  return createFailedResult(err as Error, 'Operation failed')
}

import { createFetchRegistryStep, executeStep } from '@hyperfrontend/versioning'

const step = createFetchRegistryStep()
const result = await executeStep(step, context)

// Check if first release
if (result.stateUpdates?.isFirstRelease) {
  console.log('First release detected')
}

import { createFixedVersionFlow, executeFlow } from '@hyperfrontend/versioning'

// Release with explicit version, ignoring commit analysis
const flow = createFixedVersionFlow('2.0.0')
const result = await executeFlow(flow, 'workspace', '/workspace')

console.log(result.state.nextVersion)
// => '2.0.0'

const myFlow = createFlow(
  'custom',
  'Custom Release Flow',
  [fetchStep, analyzeStep, bumpStep],
  { description: 'My custom versioning workflow' }
)

import { createGenerateChangelogStep, executeStep } from '@hyperfrontend/versioning'

const step = createGenerateChangelogStep()
const result = await executeStep(step, context)

// Access the generated changelog entry
const entry = result.stateUpdates?.changelogEntry
console.log(entry?.version, entry?.sections.length)
// => '1.2.0', 3

import { createGitCommitStep, executeStep } from '@hyperfrontend/versioning'

const step = createGitCommitStep()
const result = await executeStep(step, context)

// Get the created commit hash
console.log(result.stateUpdates?.commitHash)
// => 'a1b2c3d4e5f6...'

import { createIndependentFlow, executeFlow } from '@hyperfrontend/versioning'

const flow = createIndependentFlow()
const result = await executeFlow(flow, 'lib-utils', '/workspace')

// Check which dependents were bumped
console.log(result.state.cascadedBumps)

import { createMinimalFlow, executeFlow } from '@hyperfrontend/versioning'

const flow = createMinimalFlow()
const result = await executeFlow(flow, 'my-lib', '/workspace')

// Quick release without changelog or tags
console.log('Released:', result.state.nextVersion)

import { createNoopStep, executeStep } from '@hyperfrontend/versioning'

const step = createNoopStep('placeholder', 'Placeholder Step')
const result = await executeStep(step, context)

console.log(result.status)
// => 'success'

import { createPushTagStep, executeStep } from '@hyperfrontend/versioning'

const step = createPushTagStep()
const result = await executeStep(step, context)

// Tag is pushed to remote
console.log(result.message)
// => 'Pushed tag: my-lib@1.2.0'

import { createSkippedResult } from '@hyperfrontend/versioning'

// In a step handler:
if (!config.enabled) {
  return createSkippedResult('Feature disabled in config')
}

const fetchStep = createStep(
  'fetch-registry',
  'Fetch Registry Version',
  async (ctx) => {
    const version = await ctx.registry.getLatestVersion(ctx.packageName)
    return {
      status: 'success',
      stateUpdates: { publishedVersion: version },
      message: `Found published version: ${version}`
    }
  }
)

import { createSuccessResult } from '@hyperfrontend/versioning'

// In a step handler:
return createSuccessResult('Updated 3 files', {
  modifiedFiles: ['/path/a.ts', '/path/b.ts', '/path/c.ts']
})

import { createSyncAllPackagesStep, executeStep } from '@hyperfrontend/versioning'

const step = createSyncAllPackagesStep()
const result = await executeStep(step, context)

// All packages updated to same version
console.log(result.stateUpdates?.modifiedFiles)

import { createSyncedFlow, executeFlow } from '@hyperfrontend/versioning'

const flow = createSyncedFlow()
const result = await executeFlow(flow, 'workspace', '/workspace')

// All packages now share the same version
console.log(`Released v${result.state.nextVersion}`)

import { createTagStep, executeStep } from '@hyperfrontend/versioning'

const step = createTagStep()
const result = await executeStep(step, context)

// Get the created tag name
console.log(result.stateUpdates?.tagName)
// => 'my-lib@1.2.0'

import { createUpdatePackageStep, executeStep } from '@hyperfrontend/versioning'

const step = createUpdatePackageStep()
const result = await executeStep(step, context)

// package.json version field is updated
console.log(result.stateUpdates?.modifiedFiles)
// => ['/workspace/libs/my-lib/package.json']

import { createVersionFlow, executeFlow } from '@hyperfrontend/versioning'

// Create a conventional flow
const flow = createVersionFlow('conventional')

// Create an independent flow with custom config
const customFlow = createVersionFlow('independent', {
  skipTag: true,
  trackDeps: true,
})

const result = await executeFlow(flow, 'lib-utils', '/workspace')

import { createWriteChangelogStep, executeStep } from '@hyperfrontend/versioning'

const step = createWriteChangelogStep()
const result = await executeStep(step, context)

// CHANGELOG.md is updated with the new entry
console.log(result.message)
// => 'Updated CHANGELOG.md with version 1.2.0'

import { dryRun, createConventionalFlow } from '@hyperfrontend/versioning'

const flow = createConventionalFlow()
const result = await dryRun(flow, 'my-lib', '/workspace')

// Preview what would happen
console.log('Would bump to:', result.state.nextVersion)
// No files modified, no git operations performed

import { createConventionalFlow, executeFlow } from '@hyperfrontend/versioning'

const flow = createConventionalFlow({ dryRun: true })
const result = await executeFlow(flow, 'lib-utils', '/path/to/workspace')

console.log(result.summary)
// "Flow success in 234ms: 8 completed, 0 skipped, 0 failed. Version: 1.2.3 → 1.3.0"

import { getAvailablePresets } from '@hyperfrontend/versioning'

const presets = getAvailablePresets()
// => ['conventional', 'independent', 'synced']

import { getPresetDescription } from '@hyperfrontend/versioning'

console.log(getPresetDescription('independent'))
// => 'Version packages independently with dependency tracking'

import { getStep, createConventionalFlow } from '@hyperfrontend/versioning'

const flow = createConventionalFlow()
const step = getStep(flow, 'analyze-commits')

console.log(step?.name)
// => 'Analyze Commits'

import { hasStep, createConventionalFlow } from '@hyperfrontend/versioning'

const flow = createConventionalFlow()

console.log(hasStep(flow, 'create-commit'))
// => true
console.log(hasStep(flow, 'custom-step'))
// => false

import { insertStep, createConventionalFlow, createNoopStep } from '@hyperfrontend/versioning'

const flow = createConventionalFlow()
const modified = insertStep(flow, createNoopStep('early', 'Early Step'), 0)

console.log(modified.steps[0].id)
// => 'early'

import { insertStepAfter, createConventionalFlow, createNoopStep } from '@hyperfrontend/versioning'

const flow = createConventionalFlow()
const modified = insertStepAfter(flow, createNoopStep('validate', 'Validate'), 'analyze-commits'))

// 'validate' step now follows 'analyze-commits'

import { insertStepBefore, createConventionalFlow, createNoopStep } from '@hyperfrontend/versioning'

const flow = createConventionalFlow()
const modified = insertStepBefore(flow, createNoopStep('prep', 'Prepare'), 'create-commit'))

// 'prep' step now runs before 'create-commit'

import { removeStep, createConventionalFlow } from '@hyperfrontend/versioning'

const flow = createConventionalFlow()
const minimal = removeStep(flow, 'generate-changelog')

// Flow no longer has changelog step
console.log(minimal.steps.find(s => s.id === 'generate-changelog'))
// => undefined

import { replaceStep, createConventionalFlow, createNoopStep } from '@hyperfrontend/versioning'

const flow = createConventionalFlow()
const modified = replaceStep(flow, 'create-tag', createNoopStep('create-tag', 'Custom Tag'))

// 'create-tag' now uses custom implementation

import { validateFlow, createConventionalFlow } from '@hyperfrontend/versioning'

const flow = createConventionalFlow()
const errors = validateFlow(flow)

if (errors.length > 0) {
  console.error('Invalid flow:', errors)
}
// => []

import { withConfig, createConventionalFlow } from '@hyperfrontend/versioning'

const flow = createConventionalFlow()
const dryRunFlow = withConfig(flow, { dryRun: true })

// Flow now runs in dry-run mode