banhaten 0.1.2 → 0.2.0

package/src/cli/install-receipt.js

@@ -0,0 +1,171 @@
+import path from "node:path"
+
+export function validateReceiptDestinations(installPlan, receipt, registry) {
+  if (!receipt) return
+
+  const conflicts = []
+  const recordedDestinations = receipt.installPlan?.destinations
+  const hasCompleteInstallPlan = Object.keys(installPlan.destinations).every(
+    (name) =>
+      typeof recordedDestinations?.[name] === "string" &&
+      recordedDestinations[name].trim().length > 0
+  )
+
+  if (hasCompleteInstallPlan) {
+    for (const [name, expected] of Object.entries(installPlan.destinations)) {
+      const recorded = recordedDestinations[name]
+      if (
+        recorded &&
+        normalizeReceiptTarget(recorded) !== normalizeReceiptTarget(expected)
+      ) {
+        conflicts.push(`${recorded} (${name})`)
+      }
+    }
+  } else {
+    validateLegacyReceiptDestinations(
+      installPlan,
+      receipt,
+      registry,
+      conflicts
+    )
+  }
+
+  const previousCssTarget = receipt.tokenCss?.target
+  if (
+    previousCssTarget &&
+    normalizeReceiptTarget(previousCssTarget) !==
+      normalizeReceiptTarget(installPlan.destinations.css)
+  ) {
+    conflicts.push(`${previousCssTarget} (token CSS)`)
+  }
+
+  if (conflicts.length > 0) {
+    throw new Error(
+      "the existing Banhaten receipt conflicts with the canonical install plan: " +
+        `${[...new Set(conflicts)].join(", ")}. ` +
+        "Move or remove the old generated files and .banhaten/installed.json before installing to the new destination."
+    )
+  }
+}
+
+export function normalizeReceiptTarget(target) {
+  return path.posix
+    .normalize(String(target).replaceAll("\\", "/"))
+    .replace(/^\.\//, "")
+}
+
+export function normalizeReceiptComponents(components) {
+  return Object.fromEntries(
+    Object.entries(components).map(([name, record]) => [
+      name,
+      {
+        ...record,
+        files: Array.isArray(record.files)
+          ? record.files.map((file) => ({
+              ...file,
+              target: normalizeReceiptTarget(file.target),
+            }))
+          : record.files,
+      },
+    ])
+  )
+}
+
+export function createInstallPlanReceipt(installPlan) {
+  return {
+    aliasRoots: sortObject(
+      Object.fromEntries(
+        Object.entries(installPlan.aliasRoots).map(([name, root]) => [
+          name,
+          root.relative,
+        ])
+      )
+    ),
+    destinations: sortObject({ ...installPlan.destinations }),
+  }
+}
+
+function validateLegacyReceiptDestinations(
+  installPlan,
+  receipt,
+  registry,
+  conflicts
+) {
+  const targetsByOwner = new Map()
+
+  for (const [target, record] of Object.entries(receipt.managedFiles || {})) {
+    addRecordedTarget(targetsByOwner, record.owner, target)
+  }
+  for (const [name, record] of Object.entries(receipt.components || {})) {
+    for (const file of Array.isArray(record.files) ? record.files : []) {
+      if (file?.target) addRecordedTarget(targetsByOwner, name, file.target)
+    }
+  }
+
+  for (const [owner, targets] of targetsByOwner) {
+    if (owner === "base") {
+      const allowedTargets = new Set(
+        (registry.base.files || []).map((file) =>
+          resolveLegacyRegistryTarget(installPlan, file.target)
+        )
+      )
+      for (const target of targets) {
+        if (!allowedTargets.has(normalizeReceiptTarget(target))) {
+          conflicts.push(`${target} (${owner})`)
+        }
+      }
+      continue
+    }
+
+    const allowedRoots = registry.components[owner]
+      ? [installPlan.destinations.ui]
+      : []
+
+    for (const target of targets) {
+      if (
+        allowedRoots.length > 0 &&
+        !allowedRoots.some((root) => isTargetWithin(root, target))
+      ) {
+        conflicts.push(`${target} (${owner})`)
+      }
+    }
+  }
+}
+
+function resolveLegacyRegistryTarget(installPlan, target) {
+  const replacements = {
+    "{{hooks}}": installPlan.destinations.hooks,
+    "{{ui}}": installPlan.destinations.ui,
+    "{{utils}}": installPlan.destinations.utils,
+  }
+  let resolved = target
+  for (const [placeholder, destination] of Object.entries(replacements)) {
+    resolved = resolved.replaceAll(placeholder, destination)
+  }
+  return normalizeReceiptTarget(resolved)
+}
+
+function addRecordedTarget(targetsByOwner, owner, target) {
+  if (!owner || !target) return
+  const targets = targetsByOwner.get(owner) ?? new Set()
+  targets.add(normalizeReceiptTarget(target))
+  targetsByOwner.set(owner, targets)
+}
+
+function isTargetWithin(root, target) {
+  const normalizedRoot = normalizeReceiptTarget(root)
+  const normalizedTarget = normalizeReceiptTarget(target)
+  if (normalizedRoot === ".") {
+    return normalizedTarget !== ".." && !normalizedTarget.startsWith("../")
+  }
+  return (
+    normalizedTarget === normalizedRoot ||
+    normalizedTarget.startsWith(`${normalizedRoot}/`)
+  )
+}
+
+function sortObject(value) {
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right))
+  )
+}

package/src/cli/jsonc.js

@@ -0,0 +1,203 @@
+// JSONC parsing and the tsconfig/jsconfig path-alias editor.
+
+import {
+  appendArrayElement,
+  createBracketRange,
+  expectArrayLiteralValue,
+  expectObjectLiteralValue,
+  findObjectProperty,
+  insertObjectProperty,
+  isWhitespace,
+  skipWhitespaceAndComments
+} from "./source-scanner.js"
+
+export function parseJsonc(content) {
+  return JSON.parse(stripTrailingJsonCommas(stripJsonComments(content)))
+}
+
+function stripJsonComments(content) {
+  let output = ""
+  let inString = false
+  let escaped = false
+
+  for (let index = 0; index < content.length; index += 1) {
+    const char = content[index]
+    const next = content[index + 1]
+
+    if (inString) {
+      output += char
+
+      if (escaped) {
+        escaped = false
+      } else if (char === "\\") {
+        escaped = true
+      } else if (char === "\"") {
+        inString = false
+      }
+
+      continue
+    }
+
+    if (char === "\"") {
+      inString = true
+      output += char
+      continue
+    }
+
+    if (char === "/" && next === "/") {
+      output += "  "
+      index += 2
+
+      while (index < content.length && content[index] !== "\n" && content[index] !== "\r") {
+        output += " "
+        index += 1
+      }
+
+      if (index < content.length) {
+        output += content[index]
+        if (content[index] === "\r" && content[index + 1] === "\n") {
+          index += 1
+          output += content[index]
+        }
+      }
+
+      continue
+    }
+
+    if (char === "/" && next === "*") {
+      output += "  "
+      index += 2
+
+      while (index < content.length) {
+        if (content[index] === "*" && content[index + 1] === "/") {
+          output += "  "
+          index += 1
+          break
+        }
+
+        output += content[index] === "\n" || content[index] === "\r" ? content[index] : " "
+        index += 1
+      }
+
+      continue
+    }
+
+    output += char
+  }
+
+  return output
+}
+
+function stripTrailingJsonCommas(content) {
+  let output = ""
+  let inString = false
+  let escaped = false
+
+  for (let index = 0; index < content.length; index += 1) {
+    const char = content[index]
+
+    if (inString) {
+      output += char
+      if (escaped) {
+        escaped = false
+      } else if (char === "\\") {
+        escaped = true
+      } else if (char === "\"") {
+        inString = false
+      }
+      continue
+    }
+
+    if (char === "\"") {
+      inString = true
+      output += char
+      continue
+    }
+
+    if (char === ",") {
+      let lookahead = index + 1
+      while (isWhitespace(content[lookahead])) lookahead += 1
+      if (content[lookahead] === "}" || content[lookahead] === "]") {
+        output += " "
+        continue
+      }
+    }
+
+    output += char
+  }
+
+  return output
+}
+
+// The scanner reports syntax problems without naming a dialect. Callers own
+// that context, so a malformed tsconfig never reads as a broken Vite config.
+function asTypescriptConfigError(error) {
+  if (error instanceof Error && !/^TypeScript config: /.test(error.message)) {
+    error.message = `TypeScript config: ${error.message}`
+  }
+  return error
+}
+
+export function updateJsoncAliasSource(source, options) {
+  try {
+    return updateJsoncAliasSourceUnchecked(source, options)
+  } catch (error) {
+    throw asTypescriptConfigError(error)
+  }
+}
+
+function updateJsoncAliasSourceUnchecked(source, { aliasPattern, targetPattern }) {
+  const rootStart = skipWhitespaceAndComments(source, 0)
+  if (source[rootStart] !== "{") {
+    throw new Error("TypeScript config must contain an object literal")
+  }
+
+  const rootRange = createBracketRange(source, rootStart, "{")
+  const compilerOptionsProperty = findObjectProperty(
+    source,
+    rootRange,
+    "compilerOptions"
+  )
+  const aliasPropertyText = `${JSON.stringify(aliasPattern)}: [${JSON.stringify(targetPattern)}],`
+
+  if (!compilerOptionsProperty) {
+    return insertObjectProperty(
+      source,
+      rootRange,
+      `"compilerOptions": {\n  "paths": {\n    ${aliasPropertyText}\n  },\n},`
+    )
+  }
+
+  const compilerOptionsRange = expectObjectLiteralValue(
+    source,
+    compilerOptionsProperty,
+    "TypeScript compilerOptions must be an object literal"
+  )
+  const pathsProperty = findObjectProperty(source, compilerOptionsRange, "paths")
+
+  if (!pathsProperty) {
+    return insertObjectProperty(
+      source,
+      compilerOptionsRange,
+      `"paths": {\n  ${aliasPropertyText}\n},`
+    )
+  }
+
+  const pathsRange = expectObjectLiteralValue(
+    source,
+    pathsProperty,
+    "TypeScript compilerOptions.paths must be an object literal"
+  )
+  const aliasProperty = findObjectProperty(source, pathsRange, aliasPattern)
+
+  if (!aliasProperty) {
+    return insertObjectProperty(source, pathsRange, aliasPropertyText)
+  }
+
+  const aliasTargets = expectArrayLiteralValue(
+    source,
+    aliasProperty,
+    `TypeScript path ${aliasPattern} must be an array literal`
+  )
+  return appendArrayElement(source, aliasTargets, JSON.stringify(targetPattern))
+}

package/src/cli/package-install-state.js

@@ -0,0 +1,254 @@
+import fs from "node:fs/promises"
+import path from "node:path"
+
+import { inspectPackageManagerContext } from "./package-manager.js"
+import {
+  dependencyVersionSatisfies,
+  findPackageDependencies,
+} from "./package-version.js"
+
+const DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies",
+]
+
+export async function inspectPackageInstallState({
+  cwd,
+  packageJson,
+  requirements,
+}) {
+  const managerState = await inspectPackageManagerContext(cwd)
+  const { context } = managerState
+  const installedPackages = new Map()
+
+  for (const requirement of requirements) {
+    const installed = await findInstalledPackage(
+      cwd,
+      context.root,
+      requirement.name
+    )
+    if (
+      !installed ||
+      !dependencyVersionSatisfies(installed.version, requirement.range)
+    ) {
+      return { evidence: [], required: true }
+    }
+    installedPackages.set(requirement.name, installed)
+  }
+
+  if (!context.lockfilePath) {
+    return {
+      evidence: createCleanEvidence(managerState, installedPackages),
+      required: false,
+    }
+  }
+
+  if (context.manager !== "npm") {
+    return { evidence: [], required: true }
+  }
+
+  const lockEvidence = await readJsonEvidence(context.lockfilePath)
+  if (!lockEvidence) return { evidence: [], required: true }
+
+  const lockState = inspectNpmLock({
+    cwd,
+    lock: lockEvidence.value,
+    lockRoot: context.root,
+    packageJson,
+    requirements,
+  })
+  if (!lockState.compatible) return { evidence: [], required: true }
+
+  for (const [name, installed] of installedPackages) {
+    if (installed.version !== lockState.lockedVersions.get(name)) {
+      return { evidence: [], required: true }
+    }
+  }
+
+  return {
+    evidence: createCleanEvidence(
+      managerState,
+      installedPackages,
+      [lockEvidence]
+    ),
+    required: false,
+  }
+}
+
+function createCleanEvidence(
+  managerState,
+  installedPackages,
+  extra = []
+) {
+  return [
+    ...managerState.evidence,
+    ...extra,
+    ...[...installedPackages.values()].map(toEvidence),
+  ]
+}
+
+export function inspectNpmLock({
+  cwd,
+  lock,
+  lockRoot,
+  packageJson,
+  requirements,
+}) {
+  if (
+    !lock ||
+    typeof lock !== "object" ||
+    Array.isArray(lock) ||
+    ![2, 3].includes(lock.lockfileVersion) ||
+    !lock.packages ||
+    typeof lock.packages !== "object" ||
+    Array.isArray(lock.packages)
+  ) {
+    return { compatible: false, lockedVersions: new Map() }
+  }
+
+  const importerKey = path.relative(lockRoot, cwd).replaceAll("\\", "/")
+  const importer = lock.packages[importerKey]
+  if (!importer || typeof importer !== "object" || Array.isArray(importer)) {
+    return { compatible: false, lockedVersions: new Map() }
+  }
+
+  for (const section of DEPENDENCY_SECTIONS) {
+    if (!dependencySectionMatches(packageJson[section], importer[section])) {
+      return { compatible: false, lockedVersions: new Map() }
+    }
+  }
+
+  const lockedVersions = new Map()
+  for (const requirement of requirements) {
+    const lockedVersion = findModernLockedVersion(
+      lock.packages,
+      importerKey,
+      requirement.name
+    )
+    const declarations = findPackageDependencies(packageJson, requirement.name)
+    if (
+      !dependencyVersionSatisfies(lockedVersion, requirement.range) ||
+      declarations.length === 0 ||
+      declarations.some(
+        ({ version }) => !dependencyVersionSatisfies(lockedVersion, version)
+      )
+    ) {
+      return { compatible: false, lockedVersions: new Map() }
+    }
+    lockedVersions.set(requirement.name, lockedVersion)
+  }
+
+  return { compatible: true, lockedVersions }
+}
+
+function dependencySectionMatches(manifestSection, lockSection) {
+  const manifest = normalizeDependencySection(manifestSection)
+  const locked = normalizeDependencySection(lockSection)
+  if (!manifest || !locked) return false
+  const manifestEntries = Object.entries(manifest)
+  const lockedEntries = Object.entries(locked)
+
+  return manifestEntries.length === lockedEntries.length &&
+    manifestEntries.every(([name, range]) => locked[name] === range)
+}
+
+function normalizeDependencySection(value) {
+  if (value === undefined) return {}
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null
+}
+
+function findModernLockedVersion(packages, importerKey, name) {
+  let directory = importerKey
+
+  while (true) {
+    const prefix = directory ? `${directory}/` : ""
+    const entryKey = `${prefix}node_modules/${name}`
+    if (Object.hasOwn(packages, entryKey)) {
+      const entry = packages[entryKey]
+      return entry && typeof entry.version === "string" && !entry.link
+        ? entry.version
+        : null
+    }
+
+    if (!directory) return null
+    const parent = path.posix.dirname(directory)
+    directory = parent === "." ? "" : parent
+  }
+}
+
+async function findInstalledPackage(cwd, projectRoot, name) {
+  for (const nodeModulesPath of nodeModulesSearchPaths(cwd, projectRoot)) {
+    const manifestPath = path.join(
+      nodeModulesPath,
+      ...name.split("/"),
+      "package.json"
+    )
+
+    try {
+      const source = await fs.readFile(manifestPath)
+      const manifest = JSON.parse(source.toString("utf8"))
+      if (manifest.name === name && typeof manifest.version === "string") {
+        return { path: manifestPath, source, version: manifest.version }
+      }
+      return null
+    } catch (error) {
+      if (error.code === "ENOENT") continue
+      if (error instanceof SyntaxError) return null
+      throw error
+    }
+  }
+
+  return null
+}
+
+function nodeModulesSearchPaths(cwd, projectRoot) {
+  const paths = []
+  const boundary = path.resolve(projectRoot)
+  let directory = path.resolve(cwd)
+
+  while (true) {
+    paths.push(path.join(directory, "node_modules"))
+    if (directory === boundary) return paths
+
+    const parent = path.dirname(directory)
+    if (parent === directory || !isWithin(parent, boundary)) return paths
+    directory = parent
+  }
+}
+
+function isWithin(directory, boundary) {
+  const relative = path.relative(boundary, directory)
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
+}
+
+async function readJsonEvidence(filePath) {
+  const evidence = await readFileEvidence(filePath)
+  if (!evidence) return null
+
+  try {
+    return {
+      ...evidence,
+      value: JSON.parse(evidence.source.toString("utf8")),
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError) return null
+    throw error
+  }
+}
+
+async function readFileEvidence(filePath) {
+  try {
+    return { path: filePath, source: await fs.readFile(filePath) }
+  } catch (error) {
+    if (error.code === "ENOENT") return null
+    throw error
+  }
+}
+
+function toEvidence({ path: evidencePath, source }) {
+  return { path: evidencePath, source }
+}