@davidwells/extract-deps 0.0.4 → 0.0.6

package/.claude/settings.local.json

@@ -1,7 +1,13 @@
 {
   "permissions": {
     "allow": [
-      "Bash(node:*)"
+      "Bash(node:*)",
+      "Bash(npm audit:*)",
+      "Bash(npm view:*)",
+      "Bash(npm pack:*)",
+      "Bash(tar:*)",
+      "Bash(npm install)",
+      "Bash(npm test)"
     ],
     "deny": [],
     "ask": []

package/examples/verify-basic.js

@@ -0,0 +1,45 @@
+// Basic verification of dependency graph
+const path = require('path')
+const { depGraph } = require('../src/dep-graph')
+
+const cjsFixture = path.resolve(__dirname, '../tests/fixtures/cjs-example/index.js')
+const esmFixture = path.resolve(__dirname, '../tests/fixtures/esm-fixture/index.js')
+
+console.log('Verifying CJS fixture...')
+try {
+  const graph = depGraph(cjsFixture)
+  console.log('✓ CJS fixture is valid - all imports resolve correctly')
+  console.log(`  Found ${graph.size} files in dependency graph\n`)
+} catch (error) {
+  console.error('✗ CJS fixture has errors:')
+  console.error(error.message)
+}
+
+console.log('foo')
+
+console.log('Verifying ESM fixture...')
+try {
+  const graph = depGraph(esmFixture)
+  console.log('✓ ESM fixture is valid - all imports resolve correctly')
+  console.log(`  Found ${graph.size} files in dependency graph\n`)
+} catch (error) {
+  console.error('✗ ESM fixture has errors:')
+  console.error(error.message)
+}
+
+console.log('Verifying with throwOnFirstError option...')
+try {
+  depGraph(cjsFixture, { throwOnFirstError: true })
+  console.log('✓ Validation passed (would have thrown on first error)\n')
+} catch (error) {
+  console.error('✗ First error encountered:')
+  console.error(error.message)
+}
+
+console.log('Building graph without verification (faster)...')
+const graph = depGraph(cjsFixture, { verifyGraph: false })
+console.log(`✓ Graph built without verification - ${graph.size} files`)
+
+console.log('\nVerification only (no graph building)...')
+depGraph(cjsFixture, { buildGraph: false })
+console.log('✓ Verification passed (no graph returned)')

package/examples/verify-build-graph.js

@@ -0,0 +1,58 @@
+// Build and explore dependency graph
+const path = require('path')
+const { depGraph } = require('../src/dep-graph')
+
+const fixture = path.resolve(__dirname, '../tests/fixtures/cjs-deep-example/index.js')
+
+console.log('Building dependency graph...\n')
+
+const graph = depGraph(fixture)
+
+console.log('=== Dependency Graph ===\n')
+
+// Display the graph
+for (const [file, deps] of graph) {
+  const fileName = path.basename(file)
+  const fileDir = path.relative(__dirname, path.dirname(file))
+
+  console.log(`${fileName} (${fileDir})`)
+
+  if (deps.length === 0) {
+    console.log('  └─ (no dependencies - leaf node)\n')
+  } else {
+    deps.forEach((dep, idx) => {
+      const depName = path.basename(dep)
+      const isLast = idx === deps.length - 1
+      const prefix = isLast ? '  └─' : '  ├─'
+      console.log(`${prefix} ${depName}`)
+    })
+    console.log()
+  }
+}
+
+console.log(`\nTotal files: ${graph.size}`)
+
+// Find leaf nodes (files with no dependencies)
+const leafNodes = []
+for (const [file, deps] of graph) {
+  if (deps.length === 0) {
+    leafNodes.push(path.basename(file))
+  }
+}
+
+console.log(`Leaf nodes: ${leafNodes.join(', ')}`)
+
+// Find root nodes (files not depended on by others in the graph)
+const allDeps = new Set()
+for (const deps of graph.values()) {
+  deps.forEach(dep => allDeps.add(dep))
+}
+
+const rootNodes = []
+for (const file of graph.keys()) {
+  if (!allDeps.has(file)) {
+    rootNodes.push(path.basename(file))
+  }
+}
+
+console.log(`Root nodes: ${rootNodes.join(', ')}`)

package/examples/verify-build-order.js

@@ -0,0 +1,113 @@
+// Calculate build order using topological sort
+const path = require('path')
+const { depGraph } = require('../src/dep-graph')
+
+/**
+ * Calculate build order using topological sort (Kahn's algorithm)
+ * @param {Map<string, string[]>} graph - Dependency graph
+ * @returns {string[]} - Files in build order (dependencies first)
+ */
+function calculateBuildOrder(graph) {
+  // Calculate in-degree (number of dependencies) for each file
+  const inDegree = new Map()
+  for (const [file, deps] of graph) {
+    inDegree.set(file, deps.length)
+  }
+
+  // Queue of files with no dependencies (can be built first)
+  const queue = []
+  for (const [file, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(file)
+    }
+  }
+
+  const buildOrder = []
+
+  while (queue.length > 0) {
+    const file = queue.shift()
+    buildOrder.push(file)
+
+    // Find all files that depend on this file and decrement their in-degree
+    for (const [dependent, deps] of graph) {
+      if (deps.includes(file)) {
+        const newDegree = inDegree.get(dependent) - 1
+        inDegree.set(dependent, newDegree)
+        if (newDegree === 0) {
+          queue.push(dependent)
+        }
+      }
+    }
+  }
+
+  return buildOrder
+}
+
+/**
+ * Group files by build level (parallel build opportunities)
+ * @param {Map<string, string[]>} graph - Dependency graph
+ * @returns {Array<string[]>} - Array of levels, each containing files that can be built in parallel
+ */
+function calculateBuildLevels(graph) {
+  const inDegree = new Map()
+  for (const [file, deps] of graph) {
+    inDegree.set(file, deps.length)
+  }
+
+  const levels = []
+  const processed = new Set()
+
+  while (processed.size < graph.size) {
+    const currentLevel = []
+
+    for (const [file, degree] of inDegree) {
+      if (degree === 0 && !processed.has(file)) {
+        currentLevel.push(file)
+      }
+    }
+
+    if (currentLevel.length === 0) break
+
+    levels.push(currentLevel)
+
+    for (const file of currentLevel) {
+      processed.add(file)
+      for (const [dependent, deps] of graph) {
+        if (deps.includes(file)) {
+          inDegree.set(dependent, inDegree.get(dependent) - 1)
+        }
+      }
+    }
+  }
+
+  return levels
+}
+
+const fixture = path.resolve(__dirname, '../tests/fixtures/cjs-deep-example/index.js')
+const graph = depGraph(fixture)
+
+console.log('=== Build Order Analysis ===\n')
+
+// Sequential build order
+const buildOrder = calculateBuildOrder(graph)
+console.log('Sequential build order (dependencies first):\n')
+buildOrder.forEach((file, index) => {
+  console.log(`${index + 1}. ${path.basename(file)}`)
+})
+
+console.log('\n=== Parallel Build Opportunities ===\n')
+
+// Parallel build levels
+const levels = calculateBuildLevels(graph)
+console.log('Files grouped by build level (same level can build in parallel):\n')
+
+levels.forEach((level, index) => {
+  console.log(`Level ${index + 1}: (${level.length} file${level.length === 1 ? '' : 's'})`)
+  level.forEach(file => {
+    console.log(`  - ${path.basename(file)}`)
+  })
+  console.log()
+})
+
+console.log(`Total build levels: ${levels.length}`)
+console.log(`Maximum parallelism: ${Math.max(...levels.map(l => l.length))} files`)

package/examples/verify-find-dependents.js

@@ -0,0 +1,74 @@
+// Find all files that depend on a specific file
+const path = require('path')
+const { depGraph } = require('../src/dep-graph')
+
+/**
+ * Find all files that directly depend on a target file
+ * @param {Map<string, string[]>} graph - Dependency graph
+ * @param {string} targetFile - File to find dependents for
+ * @returns {string[]} - Array of files that depend on targetFile
+ */
+function findDirectDependents(graph, targetFile) {
+  const dependents = []
+  for (const [file, deps] of graph) {
+    if (deps.includes(targetFile)) {
+      dependents.push(file)
+    }
+  }
+  return dependents
+}
+
+/**
+ * Find all files that transitively depend on a target file
+ * @param {Map<string, string[]>} graph - Dependency graph
+ * @param {string} targetFile - File to find dependents for
+ * @returns {Set<string>} - Set of all files that depend on targetFile (directly or indirectly)
+ */
+function findAllDependents(graph, targetFile) {
+  const allDependents = new Set()
+  const queue = [targetFile]
+
+  while (queue.length > 0) {
+    const current = queue.shift()
+    const directDependents = findDirectDependents(graph, current)
+
+    for (const dependent of directDependents) {
+      if (!allDependents.has(dependent)) {
+        allDependents.add(dependent)
+        queue.push(dependent)
+      }
+    }
+  }
+
+  return allDependents
+}
+
+const fixture = path.resolve(__dirname, '../tests/fixtures/cjs-deep-example/index.js')
+const graph = depGraph(fixture)
+
+// Find a commonly used file
+const targetFile = Array.from(graph.keys()).find(key => key.includes('d-three.js'))
+
+if (targetFile) {
+  console.log(`Analyzing dependencies for: ${path.basename(targetFile)}\n`)
+
+  const directDeps = findDirectDependents(graph, targetFile)
+  console.log('Direct dependents:')
+  if (directDeps.length === 0) {
+    console.log('  (none)')
+  } else {
+    directDeps.forEach(dep => {
+      console.log(`  - ${path.basename(dep)}`)
+    })
+  }
+
+  const allDeps = findAllDependents(graph, targetFile)
+  console.log(`\nAll dependents (transitive): ${allDeps.size}`)
+  if (allDeps.size > 0) {
+    Array.from(allDeps).forEach(dep => {
+      console.log(`  - ${path.basename(dep)}`)
+    })
+  }
+
+  console.log(`\nImpact: Changing this file affects ${allDeps.size} other file(s)`)
+}

package/examples/verify-impact-analysis.js

@@ -0,0 +1,97 @@
+// Analyze impact of changing files in the dependency graph
+const path = require('path')
+const { depGraph } = require('../src/dep-graph')
+
+/**
+ * Calculate impact metrics for each file in the graph
+ * @param {Map<string, string[]>} graph - Dependency graph
+ * @returns {Map<string, object>} - Map of file paths to impact metrics
+ */
+function analyzeImpact(graph) {
+  const impact = new Map()
+
+  for (const file of graph.keys()) {
+    // Count direct dependencies
+    const directDeps = graph.get(file).length
+
+    // Count direct dependents
+    let directDependents = 0
+    for (const [_, deps] of graph) {
+      if (deps.includes(file)) {
+        directDependents++
+      }
+    }
+
+    // Calculate transitive dependents
+    const transitiveDependents = new Set()
+    const queue = [file]
+    const visited = new Set([file])
+
+    while (queue.length > 0) {
+      const current = queue.shift()
+      for (const [f, deps] of graph) {
+        if (deps.includes(current) && !visited.has(f)) {
+          visited.add(f)
+          transitiveDependents.add(f)
+          queue.push(f)
+        }
+      }
+    }
+
+    impact.set(file, {
+      directDeps,
+      directDependents,
+      transitiveDependents: transitiveDependents.size,
+      isLeaf: directDeps === 0,
+      isRoot: directDependents === 0
+    })
+  }
+
+  return impact
+}
+
+const fixture = path.resolve(__dirname, '../tests/fixtures/cjs-deep-example/index.js')
+const graph = depGraph(fixture)
+
+console.log('=== Dependency Impact Analysis ===\n')
+
+const impact = analyzeImpact(graph)
+
+// Sort files by impact (most dependents first)
+const sortedFiles = Array.from(impact.entries())
+  .sort((a, b) => b[1].transitiveDependents - a[1].transitiveDependents)
+
+console.log('Files sorted by impact (files that affect the most others):\n')
+
+sortedFiles.forEach(([file, metrics], index) => {
+  const fileName = path.basename(file)
+  const impactLevel = metrics.transitiveDependents > 3 ? '🔴 HIGH' :
+                       metrics.transitiveDependents > 1 ? '🟡 MEDIUM' :
+                       '🟢 LOW'
+
+  console.log(`${index + 1}. ${fileName}`)
+  console.log(`   Impact: ${impactLevel}`)
+  console.log(`   Direct dependencies: ${metrics.directDeps}`)
+  console.log(`   Direct dependents: ${metrics.directDependents}`)
+  console.log(`   Total files affected: ${metrics.transitiveDependents}`)
+
+  if (metrics.isLeaf) {
+    console.log(`   Type: Leaf node (no dependencies)`)
+  }
+  if (metrics.isRoot) {
+    console.log(`   Type: Root node (nothing depends on it)`)
+  }
+
+  console.log()
+})
+
+console.log('=== Summary ===')
+console.log(`Total files: ${graph.size}`)
+
+const leafNodes = Array.from(impact.values()).filter(m => m.isLeaf).length
+const rootNodes = Array.from(impact.values()).filter(m => m.isRoot).length
+const highImpact = sortedFiles.filter(([_, m]) => m.transitiveDependents > 3).length
+
+console.log(`Leaf nodes: ${leafNodes}`)
+console.log(`Root nodes: ${rootNodes}`)
+console.log(`High impact files: ${highImpact}`)

package/examples/verify-package-entries.js

@@ -0,0 +1,74 @@
+// Verify package.json entry points
+const path = require('path')
+const { getPackageEntryPoints, verifyPackageEntries } = require('../src/verify-package-json-entries')
+
+const pkgPath = path.resolve(__dirname, '../package.json')
+
+console.log('=== Extract All Package Entry Points ===\n')
+const entryPoints = getPackageEntryPoints(pkgPath)
+console.log(`Found ${entryPoints.length} entry points:\n`)
+entryPoints.forEach(ep => {
+  console.log(`  ${ep.field}: ${ep.path}`)
+})
+
+console.log('\n=== Verify Entries and Collect Dependencies ===\n')
+const results = verifyPackageEntries(pkgPath, {
+  collectDeps: true,    // Collect dependency paths
+  verifyGraph: false    // Skip verification (faster, for CI use case)
+})
+
+console.log('Results per entry point:\n')
+results.entryPoints.forEach(ep => {
+  const status = ep.valid ? '✓' : '✗'
+  console.log(`${status} ${ep.field}`)
+  if (ep.deps) {
+    console.log(`  ${ep.deps.length} dependencies`)
+  }
+  if (ep.error) {
+    console.log(`  Error: ${ep.error.message}`)
+  }
+  console.log()
+})
+
+console.log(`\n=== Summary ===`)
+console.log(`Total entry points: ${results.entryPoints.length}`)
+console.log(`Valid: ${results.entryPoints.filter(ep => ep.valid).length}`)
+console.log(`Errors: ${results.errors.length}`)
+console.log(`Total unique dependencies across all entry points: ${results.allDeps.size}`)
+
+if (results.allDeps.size > 0) {
+  console.log('\n=== All Dependencies (for git change tracking) ===')
+  const allDeps = Array.from(results.allDeps)
+  allDeps.forEach(dep => {
+    console.log(`  ${path.relative(process.cwd(), dep)}`)
+  })
+}
+
+console.log('\n=== Example: CI Use Case ===')
+console.log(`
+// In your CI script, you can use this to check if any deps changed:
+const { verifyPackageEntries } = require('extract-deps/verify-package-json-entries')
+const { execSync } = require('child_process')
+
+const pkgPath = './package.json'
+const results = verifyPackageEntries(pkgPath, { verifyGraph: false })
+
+// Get all unique dependency file paths
+const allDepPaths = Array.from(results.allDeps)
+
+// Check which ones changed in git
+const changedFiles = execSync('git diff --name-only HEAD~1 HEAD')
+  .toString()
+  .split('\\n')
+  .filter(Boolean)
+
+const changedDeps = allDepPaths.filter(dep => {
+  const relativePath = path.relative(process.cwd(), dep)
+  return changedFiles.includes(relativePath)
+})
+
+console.log(\`Changed dependencies: \${changedDeps.length}\`)
+if (changedDeps.length > 0) {
+  console.log('Need to rebuild/retest')
+}
+`)

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@davidwells/extract-deps",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Get imports and requires from a codebase without AST",
   "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./dep-graph": "./src/dep-graph.js"
+  },
   "types": "types/index.d.ts",
   "author": "David Wells",
   "license": "MIT",
@@ -18,7 +22,7 @@
     "release:major": "npm version major && npm publish"
   },
   "dependencies": {
-    "inspect-parameters-declaration": "^0.1.0"
+    "@dual-bundle/import-meta-resolve": "^4.2.1"
   },
   "devDependencies": {
     "typescript": "^5.7.3",