@joshuafolkken/kit 1.1387.0 → 1.1453.0

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-logic-toolchain.ts

@@ -0,0 +1,76 @@
+import { parse_jsonc } from '#scripts/config-merge/parse-jsonc'
+import { json_value } from '#scripts/lib/json-value'
+import { init_logic_json_merge } from './init-logic-json-merge'
+import { kit_development_versions } from './kit-development-versions'
+
+// The tools a consumer has to resolve itself, as opposed to the ones only kit's own ESLint config
+// imports. Those are optional kit peers, which pnpm does not install unlisted, so a consumer still
+// needs them — `josh init` writes them, `josh sync` leaves them to it (#3711). A tool belongs here
+// when the consumer runs its bin from the project root (eslint, prettier, tsc, playwright, cspell,
+// lefthook), when a config the consumer owns imports it (`playwright.config.ts` → @playwright/test,
+// @types/node), or when it is named by a string Prettier resolves from the consumer (the preset's
+// plugins). `josh init` and `josh sync` both read this one list, so a tool added here reaches a fresh
+// project and an already-initialized one alike.
+const CONSUMER_RESOLVED_TOOLS = [
+	'eslint',
+	'prettier',
+	'typescript',
+	'@playwright/test',
+	'@ianvs/prettier-plugin-sort-imports',
+	'prettier-plugin-svelte',
+	'prettier-plugin-tailwindcss',
+	'cspell',
+	'@types/node',
+]
+// Only a project with Git gets `lefthook.yml`, so only that one needs the bin.
+const LEFTHOOK_DEVELOPMENT_DEPENDENCY = 'lefthook'
+const DECLARING_FIELDS = [
+	'dependencies',
+	'devDependencies',
+	'peerDependencies',
+	'optionalDependencies',
+]
+
+function consumer_resolved_names(has_git: boolean): ReadonlyArray<string> {
+	return has_git
+		? [...CONSUMER_RESOLVED_TOOLS, LEFTHOOK_DEVELOPMENT_DEPENDENCY]
+		: CONSUMER_RESOLVED_TOOLS
+}
+
+// What `josh init` adds: every kit peer — the ones only kit's own configs import included — and the
+// tools above. Versions mirror kit's own devDependencies, so the consumer runs the toolchain kit is
+// verified with.
+function get_toolchain_development_dependencies(has_git: boolean): Record<string, string> {
+	return kit_development_versions.versions_of([
+		...kit_development_versions.peer_names(),
+		...consumer_resolved_names(has_git),
+	])
+}
+
+function is_declared(manifest: Record<string, unknown>, name: string): boolean {
+	return DECLARING_FIELDS.some((field) => {
+		const dependencies = manifest[field]
+
+		return json_value.is_record(dependencies) && Object.hasOwn(dependencies, name)
+	})
+}
+
+// What `josh sync` adds to an already-initialized consumer: only the tools above, and only the ones
+// the manifest declares nowhere — a tool kept under `dependencies` is present, not missing.
+function merge_consumer_resolved_development_deps(content: string, has_git: boolean): string {
+	const manifest = parse_jsonc(content)
+	const missing = consumer_resolved_names(has_git).filter((name) => !is_declared(manifest, name))
+
+	return init_logic_json_merge.merge_development_dependencies(
+		content,
+		kit_development_versions.versions_of(missing),
+	)
+}
+
+const init_logic_toolchain = {
+	consumer_resolved_names,
+	get_toolchain_development_dependencies,
+	merge_consumer_resolved_development_deps,
+}
+
+export { init_logic_toolchain }

package/scripts/init/init-logic.ts

@@ -7,6 +7,7 @@ import { init_logic_json_merge } from './init-logic-json-merge'
 import { init_logic_secretlint } from './init-logic-secretlint'
 import { init_logic_sonar } from './init-logic-sonar'
 import { init_logic_templates } from './init-logic-templates'
+import { init_logic_toolchain } from './init-logic-toolchain'
 import { init_logic_workspace } from './init-logic-workspace'
 import { init_logic_yaml_merge } from './init-logic-yaml-merge'
 
@@ -417,6 +418,7 @@ const init_logic = {
 	...init_logic_sonar,
 	...init_logic_json_merge,
 	...init_logic_secretlint,
+	...init_logic_toolchain,
 	...init_logic_yaml_merge,
 	...init_logic_deploy_vps,
 	...distributed_paths,

package/scripts/init/init.ts

@@ -19,21 +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_development_versions } from './kit-development-versions'
-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() })
 
@@ -71,27 +77,8 @@ function get_kit_self_dependency(): Record<string, string> {
 	return { [KIT_PACKAGE_NAME]: version }
 }
 
-// Each config `init` generates runs a CLI or imports types the consumer has to resolve itself:
-// `cspell.config.yaml` → cspell, `playwright.config.ts` → @types/node, `lefthook.yml` → lefthook.
-// Prettier, its preset plugins and @playwright/test come in as peers. Without them the first
-// `josh gate` after `pnpm install` fails.
-const TOOL_DEVELOPMENT_DEPENDENCIES = ['cspell', '@types/node']
-const LEFTHOOK_DEVELOPMENT_DEPENDENCY = 'lefthook'
-
-function tool_dependency_names(has_git: boolean): ReadonlyArray<string> {
-	return has_git
-		? [...TOOL_DEVELOPMENT_DEPENDENCIES, LEFTHOOK_DEVELOPMENT_DEPENDENCY]
-		: TOOL_DEVELOPMENT_DEPENDENCIES
-}
-
-// Versions mirror kit's own devDependencies, so the consumer runs the toolchain kit is verified with.
-function get_toolchain_development_dependencies(has_git: boolean): Record<string, string> {
-	return kit_development_versions.versions_of([
-		...kit_development_versions.peer_names(),
-		...tool_dependency_names(has_git),
-	])
-}
-
+// Each config `init` generates runs a CLI or imports types the consumer has to resolve itself, so
+// the toolchain is added here: without it the first `josh gate` after `pnpm install` fails.
 function apply_dependency_merges(content: string, has_git = true): string {
 	const migrated = init_logic.strip_managed_postinstall(content)
 	const suggested = init_logic.get_suggested_scripts_for_content(migrated)
@@ -103,7 +90,7 @@ function apply_dependency_merges(content: string, has_git = true): string {
 	)
 	const with_toolchain = init_logic.merge_development_dependencies(
 		merged,
-		get_toolchain_development_dependencies(has_git),
+		init_logic.get_toolchain_development_dependencies(has_git),
 	)
 	const with_secretlint = init_logic.merge_secretlint_development_deps(with_toolchain)
 
@@ -147,6 +134,7 @@ function merged_manifest(existing: string, shape: ProjectShape): string {
 	return init_basic.with_recorded_profile(
 		apply_package_json_merges(existing, shape.has_git),
 		shape.profile,
+		shape.has_workflow,
 	)
 }
 
@@ -284,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)
@@ -299,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) }
+}
 
-	if (hint !== undefined) console.info(`${hint}\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 request = parse_init_args(args)
+
+	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
@@ -325,10 +344,11 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
 const init = {
 	copy_ai_file: init_ai_copy.copy_ai_file,
 	apply_package_json_merges,
+	merged_manifest,
 	install_lefthook,
 	resolve_kit_package_manager,
 }
 
 // `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

@@ -4,6 +4,9 @@ import { repo_origin } from '#scripts/discovery/repo-origin'
 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'
 
@@ -13,10 +16,13 @@ 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
+	// Set up by `josh start` for the GitHub Issue workflow (`workflow-mark.ts`).
+	has_workflow: boolean
 }
 
 const IGNORED_DIRECTORIES = new Set(['.git', 'node_modules', 'dist', 'build', '.svelte-kit'])
@@ -123,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> {
@@ -136,26 +146,46 @@ function scan_directory(directory: string, pending: Array<string>): Array<string
 			.map((entry) => path.join(directory, entry.name)),
 	)
 
-	return entries.filter((entry) => entry.isFile()).map((entry) => path.extname(entry.name))
+	return entries.filter((entry) => entry.isFile()).map((entry) => path.join(directory, entry.name))
 }
 
-function file_extensions(root: string): Array<string> {
+// A file kit wrote says nothing about the project: counted, the `.pnpmfile.mjs` of the first
+// `josh init` would read as the user's Web file on the second and bring Prettier in
+// (joshuafolkken/kit#3713).
+function is_project_file(root: string, file: string): boolean {
+	const relative_path = path.relative(root, file).split(path.sep).join(path.posix.sep)
+
+	return !kit_written_paths.is_kit_written(relative_path)
+}
+
+// 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 extensions: Array<string> = []
+	const files: Array<string> = []
 
 	for (const directory of pending) {
-		extensions.push(...scan_directory(directory, pending))
+		files.push(...scan_directory(directory, pending))
 	}
 
-	return extensions
+	return files
 }
 
-function scan_files(root: string): { has_web: boolean; has_typescript: boolean } {
+function file_extensions(root: string): Array<string> {
+	return list_files(root)
+		.filter((file) => is_project_file(root, file))
+		.map((file) => path.extname(file))
+}
+
+// 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 {
@@ -164,18 +194,36 @@ function has_github_remote(root: string): boolean {
 	return url !== undefined && repo_origin.parse_origin_url(url) !== undefined
 }
 
+function has_git(root: string): boolean {
+	return existsSync(path.join(root, '.git'))
+}
+
+// The run is asked first, so a `josh start` whose setup has not written `package.json` yet reads it.
+function has_workflow(root: string): boolean {
+	return workflow_mark.is_requested() || workflow_mark.is_recorded(read_manifest(root))
+}
+
 function inspect_project(root: string, requested?: ProjectProfile): ProjectShape {
 	const profile = resolve_profile(root, requested)
 	const files = scan_files(root)
-	const has_git = existsSync(path.join(root, '.git'))
-
-	return { ...profile, ...files, has_git, has_github: has_git && has_github_remote(root) }
+	const is_git = has_git(root)
+
+	return {
+		...profile,
+		...files,
+		has_git: is_git,
+		has_github: is_git && has_github_remote(root),
+		has_workflow: has_workflow(root),
+	}
 }
 
 const project_profile = {
 	parse_profile,
 	resolve_profile,
+	has_git,
 	inspect_project,
+	is_ignored_directory,
+	list_files,
 	requested_profile,
 	with_legacy_profile_names,
 }