@joshuafolkken/kit 1.1435.0 → 1.1455.0

package/scripts/init/init-dry-run-report.ts

@@ -0,0 +1,150 @@
+import { json_value } from '#scripts/lib/json-value'
+
+type ChangeKind = 'create' | 'merge' | 'overwrite' | 'delete'
+
+interface FileChange {
+	path: string
+	before: string | undefined
+	after: string | undefined
+}
+
+type JsonRecord = Record<string, unknown>
+
+const PACKAGE_JSON = 'package.json'
+const JSON_EXTENSION = '.json'
+const KIND_WIDTH = 'overwrite'.length
+const NO_CHANGES = '  (no file changes)'
+
+// Every path whose content differs between the two snapshots, sorted, so a run reads the same twice.
+function changed_files(
+	before: ReadonlyMap<string, string>,
+	after: ReadonlyMap<string, string>,
+): Array<FileChange> {
+	const paths = [...new Set([...before.keys(), ...after.keys()])].toSorted((left, right) =>
+		left.localeCompare(right),
+	)
+
+	return paths
+		.filter((file) => before.get(file) !== after.get(file))
+		.map((file) => ({ path: file, before: before.get(file), after: after.get(file) }))
+}
+
+// A changed file is a merge when every line it had survives — the project's own content is kept —
+// and an overwrite when any of its lines is replaced or removed.
+function keeps_every_line(before: string, after: string): boolean {
+	const remaining = new Set(after.split('\n'))
+
+	return before.split('\n').every((line) => remaining.has(line))
+}
+
+function is_kept_array(before: ReadonlyArray<unknown>, after: unknown): boolean {
+	if (!Array.isArray(after)) return false
+	const remaining = new Set(after.map((value) => JSON.stringify(value)))
+
+	return before.every((value) => remaining.has(JSON.stringify(value)))
+}
+
+// A JSON file is rewritten whole when kit adds to it — `package.json` written out again, a list grown — so
+// it is compared by value: a merge when every value it had is still there, wherever the lines moved.
+function is_kept(before: unknown, after: unknown): boolean {
+	if (Array.isArray(before)) return is_kept_array(before, after)
+	if (!json_value.is_record(before) || !json_value.is_record(after)) return before === after
+
+	return Object.keys(before).every((key) => is_kept(before[key], after[key]))
+}
+
+// Undefined when either side is not plain JSON (a `tsconfig.json` with comments), which falls back
+// to the line test.
+function keeps_every_value(before: string, after: string): boolean | undefined {
+	const old_value = json_value.parse_or_undefined(before)
+	const new_value = json_value.parse_or_undefined(after)
+	if (old_value === undefined || new_value === undefined) return undefined
+
+	return is_kept(old_value, new_value)
+}
+
+function keeps_content(file: string, before: string, after: string): boolean {
+	const is_kept_by_value = file.endsWith(JSON_EXTENSION)
+		? keeps_every_value(before, after)
+		: undefined
+
+	return is_kept_by_value ?? keeps_every_line(before, after)
+}
+
+function change_kind(change: FileChange): ChangeKind {
+	if (change.before === undefined) return 'create'
+	if (change.after === undefined) return 'delete'
+
+	return keeps_content(change.path, change.before, change.after) ? 'merge' : 'overwrite'
+}
+
+function parse_record(content: string | undefined): JsonRecord {
+	const parsed = content === undefined ? undefined : json_value.parse_or_undefined(content)
+
+	return json_value.is_record(parsed) ? parsed : {}
+}
+
+function changed_keys(before: JsonRecord, after: JsonRecord): Array<string> {
+	const keys = [...new Set([...Object.keys(before), ...Object.keys(after)])]
+
+	return keys.filter((key) => JSON.stringify(before[key]) !== JSON.stringify(after[key]))
+}
+
+function entry_line(name: string, before: unknown, after: unknown): string {
+	if (before === undefined) return `+ ${name} ${JSON.stringify(after)}`
+	if (after === undefined) return `- ${name}`
+
+	return `~ ${name} ${JSON.stringify(before)} → ${JSON.stringify(after)}`
+}
+
+// A missing field reads as an empty object, so a block added or removed whole is listed too.
+function as_entries(value: unknown): JsonRecord | undefined {
+	if (value === undefined) return {}
+
+	return json_value.is_record(value) ? value : undefined
+}
+
+// A field that is an object (`scripts`, `devDependencies`) is listed entry by entry, so the plan
+// names each script and dependency rather than the whole block.
+function field_lines(key: string, before: unknown, after: unknown): Array<string> {
+	const old_entries = as_entries(before)
+	const new_entries = as_entries(after)
+
+	if (old_entries === undefined || new_entries === undefined) {
+		return [entry_line(key, before, after)]
+	}
+
+	return changed_keys(old_entries, new_entries).map((name) =>
+		entry_line(`${key}.${name}`, old_entries[name], new_entries[name]),
+	)
+}
+
+function package_json_lines(change: FileChange): Array<string> {
+	const before = parse_record(change.before)
+	const after = parse_record(change.after)
+
+	return changed_keys(before, after).flatMap((key) => field_lines(key, before[key], after[key]))
+}
+
+function change_lines(change: FileChange): Array<string> {
+	const head = `  ${change_kind(change).padEnd(KIND_WIDTH)} ${change.path}`
+	if (change.path !== PACKAGE_JSON || change.after === undefined) return [head]
+
+	return [head, ...package_json_lines(change).map((line) => `      ${line}`)]
+}
+
+function format_report(
+	title: string,
+	changes: ReadonlyArray<FileChange>,
+	dependency_lines: ReadonlyArray<string>,
+): string {
+	const files =
+		changes.length === 0 ? [NO_CHANGES] : changes.flatMap((change) => change_lines(change))
+	const dependencies = dependency_lines.map((line) => `  ${line}`)
+
+	return [title, '', 'Files:', ...files, '', 'Dependencies:', ...dependencies].join('\n')
+}
+
+const init_dry_run_report = { changed_files, change_kind, package_json_lines, format_report }
+export { init_dry_run_report }
+export type { ChangeKind, FileChange }

package/scripts/init/init-dry-run.ts

@@ -0,0 +1,189 @@
+import { createHash } from 'node:crypto'
+import {
+	constants,
+	cpSync,
+	existsSync,
+	lstatSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	statSync,
+} from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { git_spawn_sync } from '#scripts/git/git-spawn-sync'
+import { resolve_tsx_runner } from '#scripts/josh/josh-logic'
+import { KIT_PACKAGE_NAME } from '#scripts/version/kit-descriptor'
+import { execaSync } from 'execa'
+import { init_bootstrap } from './init-bootstrap'
+import { init_dry_run_report, type FileChange } from './init-dry-run-report'
+import { init_install } from './init-install'
+import { PACKAGE_DIR, package_path } from './init-paths'
+import { project_profile, type ProjectProfile } from './project-profile'
+import { start_exec } from './start-exec'
+
+// `josh init --dry-run` and `josh start --dry-run` answer "what would the setup change?" without
+// a second copy of the setup's decisions: the real `josh init` runs on a scratch copy of the project,
+// and the plan is the difference it left there. Every create, merge and skip is decided by the code
+// that decides it for real, so the plan cannot drift from the run (#3830).
+
+interface DryRunRequest {
+	root: string
+	profile: ProjectProfile | undefined
+	// Whether the setup meets a repository — `josh start` creates one before its setup runs.
+	has_git: boolean
+	is_install: boolean
+}
+
+interface DryRunSplit {
+	is_dry_run: boolean
+	rest: ReadonlyArray<string>
+}
+
+const DRY_RUN_FLAG = '--dry-run'
+const INIT_SCRIPT = 'scripts/init/init.ts'
+const SCRATCH_PREFIX = 'josh-init-dry-run-'
+const DEFAULT_BRANCH = 'main'
+const TITLE = 'josh init --dry-run — nothing was written. The setup would:'
+
+function split_dry_run_flag(args: ReadonlyArray<string>): DryRunSplit {
+	return {
+		is_dry_run: args.includes(DRY_RUN_FLAG),
+		rest: args.filter((argument) => argument !== DRY_RUN_FLAG),
+	}
+}
+
+// A directory is copied unless the project scan skips it: an ignored one, or a link — followed, a
+// link to the project or an ancestor would copy it into itself until the path is too long.
+function is_copied_directory(source: string): boolean {
+	return (
+		!lstatSync(source).isSymbolicLink() &&
+		!project_profile.is_ignored_directory(path.basename(source))
+	)
+}
+
+// A link to a file is copied as the file it points to, so no write in the scratch copy can follow a
+// link back into the project; a dangling one is left out, as the project scan leaves out what it
+// cannot read. The root itself is always copied: `cpSync` filters it too, so a project in a
+// directory named `build` or `dist` would otherwise be planned as an empty one.
+function is_copied(root: string, source: string): boolean {
+	if (source === root) return true
+	if (!existsSync(source)) return false
+
+	return !statSync(source).isDirectory() || is_copied_directory(source)
+}
+
+// The scratch repository answers the setup's git questions as the project's does: one exists, and
+// its origin is the same URL, so a GitHub project is planned as one.
+function mirror_git(root: string, scratch: string): void {
+	start_exec.git_succeeds(['init', '--quiet', `--initial-branch=${DEFAULT_BRANCH}`], scratch)
+	const origin = git_spawn_sync.origin_url(root)
+
+	if (origin !== undefined) start_exec.git_succeeds(['remote', 'add', 'origin', origin], scratch)
+}
+
+function prepare_scratch(root: string, has_git: boolean): string {
+	const scratch = mkdtempSync(path.join(os.tmpdir(), SCRATCH_PREFIX))
+
+	// A copy-on-write clone where the file system supports one, so mirroring a large project costs
+	// next to nothing there; a plain copy elsewhere.
+	cpSync(root, scratch, {
+		recursive: true,
+		dereference: true,
+		mode: constants.COPYFILE_FICLONE,
+		filter: (source) => is_copied(root, source),
+	})
+	if (has_git) mirror_git(root, scratch)
+
+	return scratch
+}
+
+function digest_of(file: string): string {
+	return createHash('sha256').update(readFileSync(file)).digest('hex')
+}
+
+// A snapshot holds each file's digest, not its content, so a project with large files is compared
+// without holding them in memory; only the files the setup changed are read in full.
+function snapshot(root: string): Map<string, string> {
+	const files = project_profile.list_files(root)
+
+	return new Map(files.map((file) => [path.relative(root, file), digest_of(file)]))
+}
+
+function content_of(
+	root: string,
+	file: string,
+	digests: ReadonlyMap<string, string>,
+): string | undefined {
+	return digests.has(file) ? readFileSync(path.join(root, file), 'utf8') : undefined
+}
+
+// The project itself still holds what the scratch copy held before the setup ran.
+function changes_since(
+	request: DryRunRequest,
+	scratch: string,
+	before: ReadonlyMap<string, string>,
+): Array<FileChange> {
+	const after = snapshot(scratch)
+
+	return init_dry_run_report.changed_files(before, after).map((change) => ({
+		path: change.path,
+		before: content_of(request.root, change.path, before),
+		after: content_of(scratch, change.path, after),
+	}))
+}
+
+// `--no-install` keeps the install out of the scratch copy, and the hand-off variable keeps this
+// kit doing the setup itself — the scratch copy has no kit of its own to hand it to.
+function run_init(scratch: string, profile: ProjectProfile | undefined): void {
+	const runner = resolve_tsx_runner()
+	const profile_args = profile === undefined ? [] : ['--profile', profile]
+	const args = [package_path(INIT_SCRIPT), init_install.NO_INSTALL_FLAG, ...profile_args]
+	const result = execaSync(runner.executable, [...runner.leading_arguments, ...args], {
+		cwd: scratch,
+		env: { [init_bootstrap.HANDOFF_ENV]: '1' },
+		all: true,
+		reject: false,
+	})
+
+	if (result.exitCode !== 0) throw new Error(`the simulated josh init failed:\n${result.all}`)
+}
+
+function simulate(request: DryRunRequest): Array<FileChange> {
+	const scratch = prepare_scratch(request.root, request.has_git)
+
+	try {
+		const before = snapshot(scratch)
+
+		run_init(scratch, request.profile)
+
+		return changes_since(request, scratch, before)
+	} finally {
+		rmSync(scratch, { recursive: true, force: true })
+	}
+}
+
+// The same two questions the real run asks: whether to install at all, and whether this kit is the
+// project's own or hands the setup to the one it installs.
+function dependency_lines(root: string, is_install: boolean): Array<string> {
+	if (!is_install) return [`skip the install and the format (${init_install.NO_INSTALL_FLAG})`]
+	const steps = `run ${init_install.INSTALL_STEP.label}, then ${init_install.FORMAT_STEP.label}`
+
+	if (init_bootstrap.is_project_kit(PACKAGE_DIR, root)) return [steps]
+
+	return [`install ${KIT_PACKAGE_NAME} into the project and hand the setup to its josh init`, steps]
+}
+
+function plan_report(request: DryRunRequest, title: string = TITLE): string {
+	const changes = simulate(request)
+
+	return init_dry_run_report.format_report(
+		title,
+		changes,
+		dependency_lines(request.root, request.is_install),
+	)
+}
+
+const init_dry_run = { DRY_RUN_FLAG, split_dry_run_flag, plan_report }
+export { init_dry_run }
+export type { DryRunRequest }

package/scripts/init/init-install.ts

@@ -62,6 +62,13 @@ function run_post_init_steps(project_root: string): string | undefined {
 	return undefined
 }
 
-const init_install = { NO_INSTALL_FLAG, split_install_flag, did_step_succeed, run_post_init_steps }
+const init_install = {
+	NO_INSTALL_FLAG,
+	INSTALL_STEP,
+	FORMAT_STEP,
+	split_install_flag,
+	did_step_succeed,
+	run_post_init_steps,
+}
 export { init_install }
 export type { InstallStep }

package/scripts/init/init.ts

@@ -19,20 +19,27 @@ import { init_actions, PRETTIER_CONFIG_JS } from './init-actions'
 import { init_ai_copy } from './init-ai-copy'
 import { init_basic } from './init-basic'
 import { init_bootstrap } from './init-bootstrap'
+import { init_dry_run } from './init-dry-run'
 import { init_file_action } from './init-file-action'
 import { init_install } from './init-install'
 import { init_logic } from './init-logic'
 import { PACKAGE_DIR, PROJECT_ROOT } from './init-paths'
-import { kit_setup_state } from './kit-setup-state'
 import { package_manager_pin } from './package-manager-pin'
 import { project_profile, type ProjectProfile, type ProjectShape } from './project-profile'
+import { working_tree } from './working-tree'
 
 const PACKAGE_JSON = 'package.json'
 const KIT_PACKAGE_NAME = '@joshuafolkken/kit'
 const LEFTHOOK_BIN = 'lefthook'
 const ARGUMENT_START_INDEX = 2
 const INSTALL_HINT = '→ run `pnpm install` to install what package.json lists'
-const INIT_USAGE = 'josh init [--profile basic|full] [--no-install]'
+const INIT_USAGE = 'josh init [--profile basic|full] [--no-install] [--dry-run]'
+
+interface InitRequest {
+	is_dry_run: boolean
+	is_install: boolean
+	requested: ProjectProfile | undefined
+}
 
 const engine_pin_schema = z.looseObject({ name: z.string(), version: z.string() })
 
@@ -265,14 +272,21 @@ function set_up_project(requested: ProjectProfile | undefined, is_install: boole
 	console.info('\n✅ Done.\n')
 }
 
-// True when this process set the project up — false when it refused, or handed the run to the
-// project's own kit, which then speaks for itself.
-function main(args: ReadonlyArray<string> = []): boolean {
-	if (did_refuse_self_run(PACKAGE_DIR, PROJECT_ROOT)) return false
-	const { is_install, rest } = init_install.split_install_flag(args)
-	// Validated before the hand-off, so a malformed invocation is refused before kit is installed.
-	const requested = project_profile.requested_profile(rest, INIT_USAGE)
+// A dry run sets nothing up, so it answers false and points nowhere onward.
+function print_dry_run({ requested, is_install }: InitRequest): false {
+	const has_git = project_profile.has_git(PROJECT_ROOT)
 
+	console.info(
+		init_dry_run.plan_report({ root: PROJECT_ROOT, profile: requested, has_git, is_install }),
+	)
+
+	return false
+}
+
+function did_set_up_here(
+	{ requested, is_install }: InitRequest,
+	args: ReadonlyArray<string>,
+): boolean {
 	const is_set_up_here = !is_install || !did_hand_off(args)
 
 	if (is_set_up_here) set_up_project(requested, is_install)
@@ -280,19 +294,43 @@ function main(args: ReadonlyArray<string> = []): boolean {
 	return is_set_up_here
 }
 
-// Only the command a person typed points onward to `josh start`: `josh start` calls `main` itself and
-// is already the next step.
-// A setup that failed after writing, such as a failed install, sets the exit code and points nowhere.
-function print_start_hint(): void {
-	if (process.exitCode !== undefined && process.exitCode !== 0) return
-	const hint = kit_setup_state.start_hint(PROJECT_ROOT)
+// The flags are peeled off first, so what remains is exactly the `--profile` pair.
+// Validated before the hand-off, so a malformed invocation is refused before kit is installed.
+function parse_init_args(args: ReadonlyArray<string>): InitRequest {
+	const { is_dry_run, rest: run_args } = init_dry_run.split_dry_run_flag(args)
+	const { is_install, rest } = init_install.split_install_flag(run_args)
+
+	return { is_dry_run, is_install, requested: project_profile.requested_profile(rest, INIT_USAGE) }
+}
+
+// True when this process set the project up — false when it refused, or handed the run to the
+// project's own kit, which then speaks for itself.
+function main(args: ReadonlyArray<string> = []): boolean {
+	if (did_refuse_self_run(PACKAGE_DIR, PROJECT_ROOT)) return false
+	const request = parse_init_args(args)
 
-	if (hint !== undefined) console.info(`${hint}\n`)
+	return request.is_dry_run ? print_dry_run(request) : did_set_up_here(request, args)
+}
+
+// Only the command a person typed is refused, before anything is written or installed. `josh start`
+// calls `main` itself and decides about its own tree (#3835); a handed-off run follows the check
+// its caller already passed, on a tree the kit install it just made has changed.
+function did_refuse_dirty_tree(): boolean {
+	const refusal = init_bootstrap.is_handed_off()
+		? undefined
+		: working_tree.dirty_tree_refusal(PROJECT_ROOT, 'josh init')
+
+	if (refusal === undefined) return false
+	console.error(`\n${refusal}\n`)
+	process.exitCode = 1
+
+	return true
 }
 
 function run_cli(args: ReadonlyArray<string>): void {
 	try {
-		if (main(args)) print_start_hint()
+		if (did_refuse_dirty_tree()) return
+		main(args)
 	} catch (error) {
 		console.error(`\n✖ ${error_text.message_of(error)}\n`)
 		process.exitCode = 1
@@ -312,5 +350,5 @@ const init = {
 }
 
 // `init` is the entry point; `main` is exported for its own unit test, the way `sync.ts` exports the
-// `main()` its self-run guard lives in.
-export { init, main }
+// `main()` its self-run guard lives in, and `run_cli` for the refusal only the typed command makes.
+export { init, main, run_cli }

package/scripts/init/kit-setup-state.ts

@@ -1,30 +1,24 @@
+import { json_value } from '#scripts/lib/json-value'
 import { KIT_PACKAGE_NAME } from '#scripts/version/kit-descriptor'
 import { start_exec } from './start-exec'
+import { workflow_mark } from './workflow-mark'
 
-const START_HINT =
-	'To use the GitHub Issue workflow, run pnpm exec josh start next: it puts this setup on GitHub, through a pull request when main already has commits.'
-
-// Whether the commit checked out records kit in its manifest — the sign that kit's setup has already
-// reached the branch, so `josh start` has no setup pull request to open.
+// Whether the commit checked out holds `josh start`'s setup — its manifest lists kit and records the
+// GitHub workflow mark — the sign that the setup has already reached the branch, so `josh start` has
+// no setup pull request to open. Kit alone is not enough: a committed `josh init` setup lacks the mark
+// and, on `basic`, `.claude/settings.json`, which `josh start`'s setup then writes and only a setup
+// pull request carries to `main` (#3835).
 function is_kit_committed(root: string): boolean {
 	// `./` resolves the path from `root` rather than from the repository's top level.
 	const manifest = start_exec.git_read(['show', 'HEAD:./package.json'], root)
 
-	return manifest?.includes(`"${KIT_PACKAGE_NAME}"`) ?? false
-}
-
-function is_git_work_tree(root: string): boolean {
-	return start_exec.git_succeeds(['rev-parse', '--is-inside-work-tree'], root)
-}
+	if (manifest?.includes(`"${KIT_PACKAGE_NAME}"`) !== true) return false
 
-// The line `josh init` ends with in a Git repository whose checkout does not hold kit yet: the setup is
-// still uncommitted, and `josh start` is what carries it to GitHub.
-function start_hint(root: string): string | undefined {
-	if (!is_git_work_tree(root) || is_kit_committed(root)) return undefined
+	const parsed = json_value.parse_or_undefined(manifest)
 
-	return START_HINT
+	return workflow_mark.is_recorded(json_value.is_record(parsed) ? parsed : undefined)
 }
 
-const kit_setup_state = { is_kit_committed, start_hint }
+const kit_setup_state = { is_kit_committed }
 
 export { kit_setup_state }

package/scripts/init/own-formatter.ts

@@ -0,0 +1,21 @@
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+
+// The configuration files of a formatter other than Prettier. A `basic` project holding one already
+// formats its own files, so `josh init` gives it no Prettier and `josh format` / `josh gate` skip it
+// (joshuafolkken/kit#3832).
+const OWN_FORMATTER_CONFIGS = [
+	'biome.json',
+	'biome.jsonc',
+	'dprint.json',
+	'dprint.jsonc',
+	'.dprint.json',
+	'.dprint.jsonc',
+]
+
+function find_config(root: string): string | undefined {
+	return OWN_FORMATTER_CONFIGS.find((name) => existsSync(path.join(root, name)))
+}
+
+const own_formatter = { find_config }
+export { own_formatter }

package/scripts/init/project-profile.ts

@@ -5,6 +5,7 @@ import { git_spawn_sync } from '#scripts/git/git-spawn-sync'
 import { json_value } from '#scripts/lib/json-value'
 import { KIT_PACKAGE_NAME } from '#scripts/version/kit-descriptor'
 import { kit_written_paths } from './kit-written-paths'
+import { own_formatter } from './own-formatter'
 import { workflow_mark } from './workflow-mark'
 
 type ProjectProfile = 'basic' | 'full'
@@ -15,7 +16,8 @@ interface ProfileResult {
 }
 
 interface ProjectShape extends ProfileResult {
-	has_web: boolean
+	// Web files, and no formatter of the project's own (`own-formatter.ts`).
+	should_use_prettier: boolean
 	has_typescript: boolean
 	has_git: boolean
 	has_github: boolean
@@ -127,8 +129,12 @@ function resolve_profile(root: string, requested?: ProjectProfile): ProfileResul
 	return inferred_profile(manifest)
 }
 
+function is_ignored_directory(name: string): boolean {
+	return IGNORED_DIRECTORIES.has(name)
+}
+
 function should_visit(entry: Dirent): boolean {
-	return entry.isDirectory() && !IGNORED_DIRECTORIES.has(entry.name)
+	return entry.isDirectory() && !is_ignored_directory(entry.name)
 }
 
 function scan_directory(directory: string, pending: Array<string>): Array<string> {
@@ -152,7 +158,9 @@ function is_project_file(root: string, file: string): boolean {
 	return !kit_written_paths.is_kit_written(relative_path)
 }
 
-function file_extensions(root: string): Array<string> {
+// Every file under `root` outside the directories no setup reads — the one walk the project scan and
+// the `josh init --dry-run` snapshot share.
+function list_files(root: string): Array<string> {
 	const pending = [root]
 	const files: Array<string> = []
 
@@ -160,15 +168,24 @@ function file_extensions(root: string): Array<string> {
 		files.push(...scan_directory(directory, pending))
 	}
 
-	return files.filter((file) => is_project_file(root, file)).map((file) => path.extname(file))
+	return files
+}
+
+function file_extensions(root: string): Array<string> {
+	return list_files(root)
+		.filter((file) => is_project_file(root, file))
+		.map((file) => path.extname(file))
 }
 
-function scan_files(root: string): { has_web: boolean; has_typescript: boolean } {
+// A project that formats with its own tool gets no Prettier even with Web files: two formatters
+// would rewrite each other's output (joshuafolkken/kit#3832).
+function scan_files(root: string): { should_use_prettier: boolean; has_typescript: boolean } {
 	const extensions = file_extensions(root)
 	const has_web = extensions.some((extension) => WEB_EXTENSIONS.has(extension))
+	const should_use_prettier = has_web && own_formatter.find_config(root) === undefined
 	const has_typescript = extensions.some((extension) => TYPESCRIPT_EXTENSIONS.has(extension))
 
-	return { has_web, has_typescript }
+	return { should_use_prettier, has_typescript }
 }
 
 function has_github_remote(root: string): boolean {
@@ -205,6 +222,8 @@ const project_profile = {
 	resolve_profile,
 	has_git,
 	inspect_project,
+	is_ignored_directory,
+	list_files,
 	requested_profile,
 	with_legacy_profile_names,
 }