@hyperfrontend/project-scope§

const content = 'Hello World'
const withBom = addBom(content)
// => '\ufeffHello World'

const result = analyzeCommand({ depth: 'basic' })
if (result.exitCode === 0) {
  console.log(result.output)
  // => "Project Type: Library\nWorkspace: NX Monorepo\n..."
}

const result = analyzeCommand({
  path: './apps/frontend',
  format: 'json',
  depth: 'deep',
  exclude: ['node_modules', 'dist'],
})
// => { exitCode: 0, output: '{"type":"application",...}' }

const result = analyzeProject('./my-project')
console.log(result.projectType) // 'application' | 'library' | ...
console.log(result.frameworks)  // [{ id: 'react', name: 'React', ... }]

const result = angularDetector('/path/to/angular-app', {
  dependencies: { '@angular/core': '^17.0.0', '@angular/cli': '^17.0.0' }
})
// => {
//   id: 'angular',
//   name: 'Angular',
//   category: 'frontend',
//   version: '17.0.0',
//   confidence: 85,
//   detectedFrom: [
//     { type: 'package.json', field: 'dependencies.@angular/core' },
//     { type: 'package.json', field: 'dependencies.@angular/cli' }
//   ]
// }

const result = angularJSDetector('/path/to/project', {
  dependencies: { angular: '^1.8.0', 'angular-route': '^1.8.0' },
})
// => { id: 'angularjs', name: 'AngularJS', confidence: 85, version: '1.8.0', ... }

const result = astroDetector('/path/to/astro-project', {
  dependencies: { 'astro': '^4.0.0' }
})
// => {
//   id: 'astro',
//   name: 'Astro',
//   category: 'meta-framework',
//   version: '4.0.0',
//   confidence: 70,
//   detectedFrom: [{ type: 'package.json', field: 'dependencies.astro' }]
// }

const result = babelDetector('/path/to/project', {
  name: 'my-app',
  devDependencies: { '@babel/core': '^7.23.0', '@babel/preset-env': '^7.23.0' }
})
// => {
//   id: 'babel',
//   name: 'Babel',
//   version: '7.23.0',
//   confidence: 60,
//   detectedFrom: [
//     { type: 'package.json', field: 'dependencies.@babel/core' },
//     { type: 'package.json', field: 'dependencies (@babel packages)' }
//   ]
// }

const result = backboneDetector('/path/to/project', {
  dependencies: { backbone: '^1.4.0', underscore: '^1.13.0' },
})
// => { id: 'backbone', name: 'Backbone.js', confidence: 85, version: '1.4.0', ... }

const result = biomeDetector('/path/to/project', {
  devDependencies: { '@biomejs/biome': '^1.5.0' },
})
// => { id: 'biome', name: 'Biome', confidence: 70, version: '1.5.0', ... }

const fileBuffer = readFileSync('./config.json')
const content = bufferToString(fileBuffer)
// => '{"key": "value"}'

import { buildDependencyGraph } from '@hyperfrontend/project-scope'

const graph = buildDependencyGraph('./my-lib')
console.log('Root files:', graph.roots)   // Files not imported by anything
console.log('Leaf files:', graph.leaves)  // Files that don't import anything
console.log('Total nodes:', graph.nodes.size)

// Examine a specific node's dependencies
const node = graph.nodes.get('src/utils/helper.ts')
console.log('Depends on:', node?.dependencies)
console.log('Used by:', node?.dependents)

import { buildSimpleProjectGraph } from '@hyperfrontend/project-scope'

const graph = buildSimpleProjectGraph('/workspace')
console.log('Projects:', Object.keys(graph.nodes))
console.log('Dependencies:', graph.dependencies['my-app'])

// In tests
afterEach(() => {
  clearAllCaches()
})

import { clearConfigDetectionCache } from '@hyperfrontend/project-scope'

// Reset cache after modifying config files
clearConfigDetectionCache()

import { clearEntryPointCache } from '@hyperfrontend/project-scope'

// Reset cache before re-analyzing after file changes
clearEntryPointCache()

import { clearFrameworkIdentificationCache } from '@hyperfrontend/project-scope'

// Reset cache before re-identifying frameworks
clearFrameworkIdentificationCache()

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

const tree = createTree('./my-project')
tree.write('src/new-file.ts', 'export const hello = "world"')

// Preview changes without writing
const preview = commitChanges(tree, { dryRun: true })
console.log('Would create:', preview.created, 'files')

// Actually commit changes
const result = commitChanges(tree)
console.log('Created:', result.created, 'Updated:', result.updated)

const result = configCommand({ path: './my-project' })
if (result.exitCode === 0) {
  console.log(result.output)
  // => "TypeScript: tsconfig.json\nLinting: eslint.config.js\n..."
}

const result = configCommand({
  path: './my-project',
  type: 'tsconfig',
  showContents: true,
  format: 'json',
})
// => { exitCode: 0, output: '[{"type":"tsconfig","path":"tsconfig.json",...}]' }

// Basic cache
const cache = createCache<string, number>()
cache.set('answer', 42)
cache.get('answer') // 42

// Cache with TTL (expires after 60 seconds)
const ttlCache = createCache<string, object>({ ttl: 60000 })

// Cache with max size (evicts oldest when full)
const lruCache = createCache<string, object>({ maxSize: 100 })

// Combined options
const configCache = createCache<string, object>({
  ttl: 30000,
  maxSize: 50
})

throw createConfigError(
  'Invalid port number',
  'CONFIG_INVALID_PORT',
  { configFile: './app.config.json', value: -1 }
)

// Create nested directories
createDirectory('./output/reports/2024')

// Create single directory without parents
createDirectory('./logs', { recursive: false })

throw createFileSystemError(
  'Cannot read file',
  'FS_READ_ERROR',
  { path: './missing.txt', operation: 'read' }
)

throw createFsError(
  'Configuration file not found',
  'ENOENT',
  { path: './missing.json', operation: 'read' }
)

import { createFsTree, commitChanges } from '@hyperfrontend/project-scope'

const tree = createFsTree('/workspace')
tree.write('src/new-file.ts', 'export const value = 42')
tree.delete('old-file.ts')
commitChanges(tree) // Atomically apply all changes to disk

throw createParseError(
  'Invalid JSON syntax',
  'JSON_PARSE_ERROR',
  { file: './config.json', line: 42, column: 15 }
)

import { createStructuredError } from '@hyperfrontend/project-scope'

throw createStructuredError(
  'Configuration file not found',
  'CONFIG_NOT_FOUND',
  { path: './config.json', searched: ['./config.json', './settings.json'] }
)

import { createTree } from '@hyperfrontend/project-scope'

const tree = createTree('./my-project')

// Read files from tree
const content = tree.read('src/index.ts', 'utf-8')

// Make changes (buffered in memory)
tree.write('src/new-file.ts', 'export const x = 1')

// List pending changes
console.log(tree.listChanges())

import { createTreeFromDisk } from '@hyperfrontend/project-scope'

const tree = createTreeFromDisk('/path/to/project', { verbose: true })
const files = tree.children('/src')

throw createValidationError(
  'Email format is invalid',
  'INVALID_EMAIL',
  { field: 'email', value: 'not-an-email' }
)

import { cypressDetector } from '@hyperfrontend/project-scope'

const result = cypressDetector('./my-project')
if (result) {
  console.log(`Cypress ${result.version} detected (${result.confidence}% confidence)`)
  // => "Cypress 13.6.0 detected (95% confidence)"
}

const result = depsCommand({ path: './my-project' })
if (result.exitCode === 0) {
  console.log(result.output)
  // => "Dependencies\n============\nProduction (3):\n  react  ^18.2.0\n..."
}

const result = depsCommand({
  path: './my-project',
  type: 'development',
  format: 'json',
})
// => { exitCode: 0, output: '{"devDependencies":{"typescript":"^5.0.0",...}}' }

const pkg = {
  dependencies: { '@nestjs/core': '^10.0.0', '@nestjs/common': '^10.0.0' },
  devDependencies: { express: '^4.18.0' },
}

const results = detectBackendFrameworks('/path/to/project', pkg)
// => [
//   { id: 'nestjs', name: 'NestJS', confidence: 85, ... },
//   { id: 'express', name: 'Express', confidence: 80, ... },
// ]

const tools = detectBuildTools('/path/to/project', {
  name: 'my-app',
  devDependencies: {
    'vite': '^5.0.0',
    '@vitejs/plugin-react': '^4.0.0',
    '@babel/core': '^7.23.0'
  }
})
// => [
//   { id: 'vite', name: 'Vite', version: '5.0.0', confidence: 70, ... },
//   { id: 'babel', name: 'Babel', version: '7.23.0', confidence: 50, ... }
// ]

if (detectCaseSensitivity()) {
  // Linux: 'File.ts' and 'file.ts' are different files
} else {
  // Windows/macOS: treat as same file
}

import { detectConfigs } from '@hyperfrontend/project-scope'

// Detect all config files
const configs = detectConfigs('./my-project')
for (const config of configs) {
  console.log(`${config.type}: ${config.path}`)
}
// Output:
// typescript: tsconfig.json
// eslint: eslint.config.js
// jest: jest.config.ts

// Detect specific config types only
const tsConfigs = detectConfigs('./my-project', ['typescript', 'eslint'])

const buffer = readFileSync('./data.txt')
const encoding = detectEncoding(buffer)
const content = buffer.toString(encoding)

const buffer = readFileSync('./document.txt')
const info = detectEncodingInfo(buffer)
if (info.type === 'text') {
  console.log(`Encoding: ${info.encoding}, BOM: ${info.hasBom}`)
}

const frameworks = detectFrontendFrameworks('/path/to/nextjs-app', {
  dependencies: { 'react': '^18.0.0', 'next': '^14.0.0' }
})
// => [
//   { id: 'nextjs', name: 'Next.js', category: 'meta-framework', confidence: 70, ... },
//   { id: 'react', name: 'React', category: 'frontend', confidence: 60, ... }
// ]

const results = detectLegacyFrameworks('/path/to/project', {
  dependencies: { jquery: '^3.6.0', backbone: '^1.4.0' },
})
// => [{ id: 'jquery', confidence: 80 }, { id: 'backbone', confidence: 70 }]

const ending = detectLineEnding('line1\nline2\n')
// => 'lf'

const mixed = detectLineEnding('line1\r\nline2\nline3')
// => 'mixed'

const results = detectLintingTools('/path/to/project', {
  devDependencies: { eslint: '^8.0.0', prettier: '^3.0.0' },
})
// => [{ id: 'eslint', confidence: 50 }, { id: 'prettier', confidence: 50 }]

const detections = detectMonorepoTools('/path/to/project')
// => [
//   { id: 'nx', name: 'NX', confidence: 90, configPath: 'nx.json', detectedFrom: [...] },
//   { id: 'npm-workspaces', name: 'npm Workspaces', confidence: 80, ... }
// ]

const platform = detectPlatform()
if (platform.isWindows) {
  // Windows-specific handling
}

import { detectProjectType } from '@hyperfrontend/project-scope'

const result = detectProjectType('./my-lib')
console.log(result.type)       // 'library' | 'application' | 'e2e' | 'tool' | 'plugin'
console.log(result.confidence) // 85
console.log(result.evidence)   // [{ factor: 'exports', confidence: 20, ... }]

import { detectTestingFrameworks } from '@hyperfrontend/project-scope'

const frameworks = detectTestingFrameworks('./my-project')
// => [
//   { id: 'jest', name: 'Jest', type: 'unit', confidence: 95, ... },
//   { id: 'cypress', name: 'Cypress', type: 'e2e', confidence: 85, ... }
// ]

// Results are sorted by confidence (highest first)
const primary = frameworks[0]?.name ?? 'None'
console.log(`Primary testing framework: ${primary}`)

import { detectTypeSystems } from '@hyperfrontend/project-scope'

const typeSystems = detectTypeSystems('./my-project')
// => [
//   { id: 'typescript', name: 'TypeScript', version: '5.3.0', strictMode: true, confidence: 95, ... },
//   { id: 'jsdoc', name: 'JSDoc', confidence: 40, ... }
// ]

const primary = typeSystems[0]?.name ?? 'None'
console.log(`Primary type system: ${primary}`)

import { discoverEntryPoints } from '@hyperfrontend/project-scope'

const entryPoints = discoverEntryPoints('./my-app')
for (const entry of entryPoints) {
  console.log(`${entry.path} (${entry.type}) - ${entry.confidence}% confidence`)
}
// Output:
// src/index.ts (main) - 100% confidence
// src/cli.ts (cli) - 85% confidence

import { discoverNxProjects } from '@hyperfrontend/project-scope'

const projects = discoverNxProjects('/workspace')
for (const [name, config] of projects) {
  console.log(`${name}: ${config.projectType} at ${config.root}`)
}

const result = emberDetector('/path/to/project', {
  dependencies: { 'ember-source': '^4.0.0' },
  devDependencies: { 'ember-cli': '^4.0.0' },
})
// => { id: 'ember', name: 'Ember.js', confidence: 90, version: '4.0.0', ... }

ensureDir('./output/reports')
// Directory now exists (created if missing)

ensureTrailingSlash('src/components')
// => 'src/components/'

ensureTrailingSlash('already/has/')
// => 'already/has/'

const result = esbuildDetector('/path/to/project', {
  name: 'my-lib',
  devDependencies: { 'esbuild': '^0.19.0' },
  scripts: { 'build': 'esbuild src/index.ts --bundle --outfile=dist/index.js' }
})
// => {
//   id: 'esbuild',
//   name: 'esbuild',
//   version: '0.19.0',
//   confidence: 80,
//   detectedFrom: [
//     { type: 'package.json', field: 'dependencies.esbuild' },
//     { type: 'package.json', field: 'scripts.build' }
//   ]
// }

const result = eslintDetector('/path/to/project', {
  devDependencies: { eslint: '^8.50.0', '@typescript-eslint/parser': '^6.0.0' },
  scripts: { lint: 'eslint src/' },
})
// => { id: 'eslint', name: 'ESLint', confidence: 65, version: '8.50.0', ... }

if (exists('./config.json')) {
  const config = readJsonFile('./config.json')
}

const pkg = {
  dependencies: { express: '^4.18.2', cors: '^2.8.5' },
  devDependencies: { '@types/express': '^4.17.17' },
}

const result = expressDetector('/path/to/project', pkg)
// => {
//   id: 'express',
//   name: 'Express',
//   version: '4.18.2',
//   confidence: 100,
//   detectedFrom: [
//     { type: 'package.json', field: 'dependencies.express' },
//     { type: 'package.json', field: 'dependencies.@types/express' },
//     { type: 'package.json', field: 'dependencies (express middleware)' },
//   ],
// }

const pkg = {
  dependencies: { fastify: '^4.24.0', '@fastify/cors': '^8.4.0' },
}

const result = fastifyDetector('/path/to/project', pkg)
// => {
//   id: 'fastify',
//   name: 'Fastify',
//   version: '4.24.0',
//   confidence: 95,
//   detectedFrom: [
//     { type: 'package.json', field: 'dependencies.fastify' },
//     { type: 'package.json', field: 'dependencies (fastify plugins)' },
//   ],
// }

import { buildDependencyGraph, findCircularDependencies } from '@hyperfrontend/project-scope'

const graph = buildDependencyGraph('/workspace')
const cycles = findCircularDependencies(graph)
cycles.forEach(c => console.log(`Cycle: ${c.cycle.join(' -> ')}`))

import { findConfigFile } from '@hyperfrontend/project-scope'

const tsConfig = findConfigFile('/project', 'typescript')
// => '/project/tsconfig.json'

const eslint = findConfigFile('/project', 'eslint')
// => '/project/.eslintrc.js' or null if not found

import { findDirectories } from '@hyperfrontend/project-scope'

const componentDirs = findDirectories('./src', 'components')
// => ['features/auth/components', 'features/dashboard/components']

import { findFiles } from '@hyperfrontend/project-scope'

// Find all TypeScript files
const tsFiles = findFiles('./src', '\*\*/*.ts')

// Find multiple file types
const configFiles = findFiles('./', ['\*.json', '\*.yaml', '\*.yml'])

// Limit results and get absolute paths
const first10 = findFiles('./src', '\*\*/*.ts', {
  maxResults: 10,
  absolutePaths: true
})

import { createTree, findFilesInTree } from '@hyperfrontend/project-scope'

const tree = createTree('/workspace')
const tsFiles = findFilesInTree(tree, '**/*.ts', { maxDepth: 3 })
// => ['src/index.ts', 'src/utils/helpers.ts']

import { findGitRoot } from '@hyperfrontend/project-scope'

const gitRoot = findGitRoot('./src/deep/nested/file.ts')
// => '/path/to/repository'

import { findNearestPackageJson } from '@hyperfrontend/project-scope'

const pkgDir = findNearestPackageJson('./src/deep/nested/file.ts')
// => '/path/to/project'

import { findNxWorkspaceRoot } from '@hyperfrontend/project-scope'

const root = findNxWorkspaceRoot('./libs/my-lib/src')
if (root) {
  console.log('Workspace root:', root) // e.g., '/home/user/my-monorepo'
}

import { findProjectRoot } from '@hyperfrontend/project-scope'

// Find project root from current directory
const root = findProjectRoot(process.cwd())
if (root) {
  console.log('Project root:', root)
}

// Find root from a deeply nested file
const root2 = findProjectRoot('./libs/my-lib/src/utils/helper.ts')

import { findRootDirectory } from '@hyperfrontend/project-scope'

// Find monorepo root by looking for nx.json or lerna.json
const root = findRootDirectory('./libs/my-lib', ['nx.json', 'lerna.json'])
// => '/path/to/monorepo'

// Find directory with a specific config
const configDir = findUpwardWhere('./deep/nested/path', (dir) =>
  existsSync(join(dir, '.eslintrc.js'))
)

import { findWorkspaceRoot } from '@hyperfrontend/project-scope'

const root = findWorkspaceRoot('./libs/my-lib')
if (root) {
  console.log('Monorepo root:', root) // e.g., '/home/user/my-monorepo'
}

import { flowDetector } from '@hyperfrontend/project-scope'

const result = flowDetector('./my-project')
if (result) {
  console.log(`Flow ${result.version} with config: ${result.configPath}`)
  // => "Flow 0.232.0 with config: .flowconfig"
}

const formatted = formatUnifiedDiff(diff)
console.log(formatted)
// --- a/src/app.ts
// +++ b/src/app.ts
// @@ -1,3 +1,3 @@
//  const x = 1;
// -const y = 2;
// +const y = 3;
//  const z = 4;

const result = gatsbyDetector('/path/to/gatsby-blog', {
  dependencies: {
    'gatsby': '^5.0.0',
    'gatsby-plugin-image': '^3.0.0',
    'gatsby-source-filesystem': '^5.0.0'
  }
})
// => {
//   id: 'gatsby',
//   name: 'Gatsby',
//   category: 'meta-framework',
//   version: '5.0.0',
//   confidence: 75,
//   detectedFrom: [
//     { type: 'package.json', field: 'dependencies.gatsby' },
//     { type: 'package.json', field: 'dependencies (gatsby plugins)' }
//   ]
// }

const tree = createTree('/workspace')
tree.write('new.txt', 'hello')
tree.delete('old.txt')

const diffs = generateAllDiffs(tree)
for (const diff of diffs) {
  console.log(formatUnifiedDiff(diff))
}

const change: FileChange = {
  path: 'src/app.ts',
  type: 'UPDATE',
  originalContent: Buffer.from('const x = 1;\n'),
  content: Buffer.from('const x = 2;\n'),
}
const diff = generateDiff(change)
// { path: 'src/app.ts', additions: 1, deletions: 1, lines: [...] }

import { getAllDependencies } from '@hyperfrontend/project-scope'

const allDeps = getAllDependencies(packageJson)
if ('typescript' in allDeps) {
  console.log('TypeScript version:', allDeps['typescript'])
}

getBasename('src/components/Button.tsx')
// => 'Button.tsx'

getBasename('src/components/Button.tsx', '.tsx')
// => 'Button'

const count = getCacheCount()
// => 3 (number of active caches)

import { getConfigPatternsByType } from '@hyperfrontend/project-scope'

const patterns = getConfigPatternsByType(['typescript', 'eslint'])
// => ['tsconfig.json', 'tsconfig.*.json', '.eslintrc', '.eslintrc.js', ...]

import { getDependencies } from '@hyperfrontend/project-scope'

const deps = getDependencies(packageJson)
console.log('Runtime:', Object.keys(deps.dependencies))
console.log('Dev:', Object.keys(deps.devDependencies))

import { getDependencyVersion } from '@hyperfrontend/project-scope'

const version = getDependencyVersion(packageJson, 'react')
// => '^18.2.0' or null

import { getDevDependencies } from '@hyperfrontend/project-scope'

const devDeps = getDevDependencies(packageJson)
// => { 'jest': '^29.0.0', 'typescript': '^5.0.0' }

getDirname('src/components/Button.tsx')
// => 'src/components'

getExtension('src/utils/helpers.ts')
// => '.ts'

getExtension('package.json')
// => '.json'

getFileNameWithoutExtension('src/utils/helpers.ts')
// => 'helpers'

const stats = getFileStat('./package.json')
if (stats) {
  console.log(`Size: ${stats.size} bytes`)
  console.log(`Modified: ${stats.modified}`)
}

const eol = getLineEnding()
const lines = ['line1', 'line2', 'line3']
const content = lines.join(eol)

import { getNxWorkspaceInfo } from '@hyperfrontend/project-scope'

const info = getNxWorkspaceInfo('/path/to/monorepo')
if (info) {
  console.log('NX version:', info.version)
  console.log('Apps dir:', info.workspaceLayout.appsDir)
}

const sep = getPathSeparator()
const fullPath = ['src', 'utils', 'helpers.ts'].join(sep)

import { getPeerDependencies } from '@hyperfrontend/project-scope'

const peerDeps = getPeerDependencies(packageJson)
// => { 'react': '^18.0.0', 'react-dom': '^18.0.0' }

const info = getPlatformInfo()
console.log(info.os)           // => 'linux'
console.log(info.pathSeparator) // => '/'
console.log(info.lineEnding)    // => '\n'

import { getProductionDependencies } from '@hyperfrontend/project-scope'

const prodDeps = getProductionDependencies(packageJson)
// => { 'express': '^4.18.0', 'lodash': '^4.17.21' }

import { getProjectConfig } from '@hyperfrontend/project-scope'

const config = getProjectConfig('./libs/my-lib', '/workspace')
// => { name: 'my-lib', root: 'libs/my-lib', projectType: 'library' }

import { getProjectDependencies } from '@hyperfrontend/project-scope'

const deps = getProjectDependencies('/path/to/project')
console.log('Runtime:', deps.runtime)     // ['express', 'lodash']
console.log('Dev:', deps.development)     // ['jest', 'typescript']
console.log('Total:', deps.total)         // 15

import { getWorkspaces } from '@hyperfrontend/project-scope'

const patterns = getWorkspaces(packageJson)
// => ['packages/*', 'apps/*']

const buffer = readFileSync('./file.txt')
if (hasBom(buffer)) {
  // Strip BOM before processing
}

import { hasDependency } from '@hyperfrontend/project-scope'

// Check any dependency type
hasDependency(packageJson, 'lodash')

// Check only production dependencies
hasDependency(packageJson, 'lodash', ['dependencies'])

import { hasInstalledPackage } from '@hyperfrontend/project-scope'

if (hasInstalledPackage('/project', 'typescript')) {
  console.log('TypeScript is installed')
}

import { hasWorkspaces } from '@hyperfrontend/project-scope'

if (hasWorkspaces(packageJson)) {
  console.log('This is a monorepo')
}

const pkg = {
  dependencies: { hono: '^3.11.0', '@hono/node-server': '^1.3.0' },
}

const result = honoDetector('/path/to/project', pkg)
// => {
//   id: 'hono',
//   name: 'Hono',
//   version: '3.11.0',
//   confidence: 100,
//   detectedFrom: [
//     { type: 'package.json', field: 'dependencies.hono' },
//     { type: 'package.json', field: 'dependencies (@hono adapters)' },
//   ],
// }

import { identifyFrameworks } from '@hyperfrontend/project-scope'

const result = identifyFrameworks('./my-react-app')
console.log(result.summary)      // 'React + Next.js with Jest'
console.log(result.primary?.name) // 'React'
console.log(result.stack.frontend) // ['react', 'nextjs']
console.log(result.stack.testing)  // ['jest']

isAbsolute('/workspace/src/index.ts')
// => true

isAbsolute('./src/index.ts')
// => false

const caseSensitive = isCaseSensitiveFs()
// => true on Linux, false on Windows/macOS

if (isDirectory('./src')) {
  // Path exists and is a directory
}

if (isFile('./package.json')) {
  // Path exists and is a regular file
}

import { isNxProject } from '@hyperfrontend/project-scope'

if (isNxProject('./libs/my-lib')) {
  console.log('This is an NX project')
}

import { isNxWorkspace } from '@hyperfrontend/project-scope'

if (isNxWorkspace('./my-project')) {
  console.log('This is an NX monorepo')
}

if (isSymlink('./node_modules/.bin/tsc')) {
  // Path is a symbolic link
}

const buffer = readFileSync('./unknown-file')
if (isTextFile(buffer)) {
  const content = buffer.toString('utf-8')
}

if (isWindows()) {
  // Use Windows-specific paths or commands
}

import { jestDetector } from '@hyperfrontend/project-scope'

const result = jestDetector('./my-project')
if (result) {
  console.log(`Jest ${result.version} detected`)
  console.log('Sources:', result.detectedFrom.map(s => s.type))
  // => "Sources: ['package.json', 'config-file']"
}

const fullPath = join('src', 'components', 'Button.tsx')
// => 'src/components/Button.tsx' (or 'src\\components\\Button.tsx' on Windows)

joinPath('src', 'components', 'Button.tsx')
// => 'src/components/Button.tsx'

const configPath = joinPosix('config', 'settings', 'app.json')
// => 'config/settings/app.json'

const result = jqueryDetector('/path/to/project', {
  dependencies: { jquery: '^3.6.0', 'jquery-ui': '^1.13.0' },
})
// => { id: 'jquery', name: 'jQuery', confidence: 90, version: '3.6.0', ... }

import { jsdocDetector } from '@hyperfrontend/project-scope'

const result = jsdocDetector('./my-project')
if (result) {
  console.log('JSDoc types detected')
  console.log('Sources:', result.detectedFrom.map(s => s.path ?? s.field))
  // => "Sources: ['jsconfig.json', 'src/utils.js (JSDoc annotations)']"
}

const pkg = {
  dependencies: { koa: '^2.14.2', 'koa-router': '^12.0.0' },
  devDependencies: { '@types/koa': '^2.13.9' },
}

const result = koaDetector('/path/to/project', pkg)
// => {
//   id: 'koa',
//   name: 'Koa',
//   version: '2.14.2',
//   confidence: 100,
//   detectedFrom: [
//     { type: 'package.json', field: 'dependencies.koa' },
//     { type: 'package.json', field: 'dependencies.@types/koa' },
//     { type: 'package.json', field: 'dependencies (koa middleware)' },
//   ],
// }

// Project with lerna.json config file
const result = lernaDetector('/path/to/lerna-project')
// => {
//   id: 'lerna',
//   name: 'Lerna',
//   confidence: 80,
//   configPath: 'lerna.json',
//   detectedFrom: [{ type: 'config-file', path: 'lerna.json' }]
// }

// Find project root by looking for common marker files
const projectRoot = locateByMarkers('./src/components', [
  'package.json',
  'nx.json',
  'tsconfig.base.json'
])
// => '/workspace/my-project'

const ignorePatterns = ['*.log', 'node_modules/**', '*.tmp']
const shouldIgnore = matchesAnyPattern('debug.log', ignorePatterns)
// => true

matchesExact('package.json', 'package.json')
// => true

matchesExact('src/package.json', 'package.json')
// => false

import { matchGlobPattern } from '@hyperfrontend/project-scope'

matchGlobPattern('src/utils/helper.ts', '\*\*/*.ts')     // true
matchGlobPattern('test.spec.ts', '\*.spec.ts')          // true
matchGlobPattern('config.json', '\*.{json,yaml}')       // true
matchGlobPattern('src/index.ts', 'src/\*.ts')           // true

// Memoize a detection function
const detectTechStackMemo = memoize(
  (path: string) => expensiveDetection(path),
  { ttl: 60000 }
)

const result1 = detectTechStackMemo('/path/to/project')
const result2 = detectTechStackMemo('/path/to/project') // Returns cached

// Clear the cache
detectTechStackMemo.cache.clear()

import { mochaDetector } from '@hyperfrontend/project-scope'

const result = mochaDetector('./my-project')
if (result) {
  console.log(`Mocha ${result.version} detected (${result.confidence}%)`)
  // => "Mocha 10.2.0 detected (95%)"
}

// Project with nest-cli.json and NestJS packages
const pkg = {
  dependencies: {
    '@nestjs/core': '^10.2.0',
    '@nestjs/common': '^10.2.0',
    '@nestjs/platform-express': '^10.2.0',
  },
}

const result = nestDetector('/path/to/nest-project', pkg)
// => {
//   id: 'nestjs',
//   name: 'NestJS',
//   version: '10.2.0',
//   configPath: 'nest-cli.json',  // if present
//   confidence: 100,
//   detectedFrom: [
//     { type: 'package.json', field: 'dependencies.@nestjs/core' },
//     { type: 'package.json', field: 'dependencies.@nestjs/common' },
//     { type: 'config-file', path: 'nest-cli.json' },
//     { type: 'package.json', field: 'dependencies (@nestjs packages)' },
//   ],
// }

const result = nextjsDetector('/path/to/nextjs-app', {
  dependencies: { 'next': '^14.0.0', 'react': '^18.0.0' }
})
// => {
//   id: 'nextjs',
//   name: 'Next.js',
//   category: 'meta-framework',
//   version: '14.0.0',
//   confidence: 70,
//   detectedFrom: [{ type: 'package.json', field: 'dependencies.next' }]
// }

// Normalize to Unix line endings
const normalized = normalizeLineEndings('line1\r\nline2\r\n', 'lf')
// => 'line1\nline2\n'

// Use platform default
const platformNormalized = normalizeLineEndings(content, 'auto')

const path = normalizePath('src\\components\\Button.tsx')
// => 'src/components/Button.tsx'

const path = normalizeToForwardSlashes('./src/../lib/utils')
// => 'lib/utils'

const path = normalizeToNative('src/components/Button.tsx')
// => 'src\\components\\Button.tsx' on Windows
// => 'src/components/Button.tsx' on Unix

// Project with workspaces in package.json and package-lock.json
const result = npmWorkspacesDetector('/path/to/npm-project')
// => {
//   id: 'npm-workspaces',
//   name: 'npm Workspaces',
//   confidence: 90,
//   configPath: 'package.json',
//   detectedFrom: [
//     { type: 'package.json', field: 'workspaces' },
//     { type: 'lockfile', path: 'package-lock.json' }
//   ]
// }

const result = nuxtDetector('/path/to/nuxt-app', {
  dependencies: { 'nuxt': '^3.0.0', 'vue': '^3.0.0' }
})
// => {
//   id: 'nuxt',
//   name: 'Nuxt',
//   category: 'meta-framework',
//   version: '3.0.0',
//   confidence: 70,
//   detectedFrom: [{ type: 'package.json', field: 'dependencies.nuxt' }]
// }

// Project with nx.json and apps/libs directories
const result = nxDetector('/path/to/nx-workspace')
// => {
//   id: 'nx',
//   name: 'NX',
//   confidence: 100,
//   configPath: 'nx.json',
//   version: '17.0.0',
//   workspaceLayout: { appsDir: 'apps', libsDir: 'libs' },
//   detectedFrom: [
//     { type: 'config-file', path: 'nx.json' },
//     { type: 'package.json', field: 'dependencies.nx' },
//     { type: 'directory', path: 'apps/ or libs/' }
//   ]
// }

offsetFromRoot('libs/utils/src')
// => '../../../'

offsetFromRoot('apps')
// => '../'

const result = parcelDetector('/path/to/project', {
  name: 'my-app',
  devDependencies: { 'parcel': '^2.10.0' },
  scripts: { 'dev': 'parcel src/index.html', 'build': 'parcel build src/index.html' }
})
// => {
//   id: 'parcel',
//   name: 'Parcel',
//   version: '2.10.0',
//   confidence: 80,
//   detectedFrom: [
//     { type: 'package.json', field: 'dependencies.parcel' },
//     { type: 'package.json', field: 'scripts.dev' },
//     { type: 'package.json', field: 'scripts.build' }
//   ]
// }

import { parseConfig } from '@hyperfrontend/project-scope'

const tsConfig = parseConfig('/project/tsconfig.json')
const eslintConfig = parseConfig('/project/.eslintrc.yml', 'eslint')

import { parseJsonConfig } from '@hyperfrontend/project-scope'

const config = parseJsonConfig(
  'tsconfig.json',
  '{ "extends": "./base.json", "compilerOptions": {} }',
  'typescript'
)
// => { type: 'typescript', path: 'tsconfig.json', data: {...}, extends: ['./base.json'] }

const parsed = parsePath('/workspace/src/index.ts')
// => { root: '/', dir: '/workspace/src', base: 'index.ts', ext: '.ts', name: 'index' }

import { parseYamlConfig } from '@hyperfrontend/project-scope'

const config = parseYamlConfig('.github/workflows/ci.yml', yamlContent, 'github-actions')
// => { type: 'github-actions', path: '...', format: 'yaml', data: {...} }

pathSegments('src/components/Button.tsx')
// => ['src', 'components', 'Button.tsx']

// On case-insensitive filesystem (Windows/macOS)
pathsEqual('src/App.tsx', 'src/app.tsx')
// => true

// On case-sensitive filesystem (Linux)
pathsEqual('src/App.tsx', 'src/app.tsx')
// => false

import { playwrightDetector } from '@hyperfrontend/project-scope'

const result = playwrightDetector('./my-project')
if (result) {
  console.log(`Playwright ${result.version} (${result.type} tests)`)
  // => "Playwright 1.42.0 (e2e tests)"
}

// Project with pnpm-workspace.yaml
const result = pnpmWorkspacesDetector('/path/to/pnpm-project')
// => {
//   id: 'pnpm-workspaces',
//   name: 'pnpm Workspaces',
//   confidence: 100,
//   configPath: 'pnpm-workspace.yaml',
//   detectedFrom: [
//     { type: 'config-file', path: 'pnpm-workspace.yaml' },
//     { type: 'lockfile', path: 'pnpm-lock.yaml' }
//   ]
// }