Add Ultracite and TanStack Intent to init flow

.changeset/npm-min-release-age.md

@@ -0,0 +1,5 @@
+---
+"@proofkit/cli": patch
+---
+
+Write npm min-release-age config during npm project scaffolding.

.changeset/ultracite-init.md

@@ -0,0 +1,5 @@
+---
+"@proofkit/cli": patch
+---
+
+Run Ultracite and TanStack Intent setup during project scaffolding.

packages/cli/package.json

@@ -38,7 +38,7 @@
     "package.json"
   ],
   "engines": {
-    "node": "^20.0.0 || ^22.0.0"
+    "node": "^22.0.0 || ^24.0.0 || ^26.0.0"
   },
   "scripts": {
     "typecheck": "node ./scripts/write-cli-version.mjs && tsc",

packages/cli/src/cli/init.ts

@@ -5,20 +5,24 @@ import fs from "fs-extra";
 import type { PackageJson } from "type-fest";
 
 import { DEFAULT_APP_NAME } from "~/consts.js";
+import { createPnpmWorkspaceFileContent } from "~/core/planInit.js";
 import { addAuth } from "~/generators/auth.js";
 import { runCodegenCommand } from "~/generators/fmdapi.js";
 import { debugOption, nonInteractiveOption } from "~/globalOptions.js";
 import { createBareProject } from "~/helpers/createProject.js";
 import { initializeGit } from "~/helpers/git.js";
 import { installDependencies } from "~/helpers/installDependencies.js";
+import { getIntentInstallCommand } from "~/helpers/intent.js";
 import { logNextSteps } from "~/helpers/logNextSteps.js";
 import { setImportAlias } from "~/helpers/setImportAlias.js";
+import { getBrowserOxlintConfig, getUltraciteInitCommand } from "~/helpers/ultracite.js";
 import { buildPkgInstallerMap } from "~/installers/index.js";
 import { initProgramState, isNonInteractiveMode, state } from "~/state.js";
 import { getVersion } from "~/utils/getProofKitVersion.js";
 import { getUserPkgManager } from "~/utils/getUserPkgManager.js";
 import { parseNameAndPath } from "~/utils/parseNameAndPath.js";
 import { type Settings, setSettings } from "~/utils/parseSettings.js";
+import { formatPackageManagerCommand } from "~/utils/projectFiles.js";
 import { validateAppName } from "~/utils/validateAppName.js";
 import { promptForFileMakerDataSource } from "./add/data-source/filemaker.js";
 import { select, text } from "./prompts.js";
@@ -132,9 +136,19 @@ type ProofKitPackageJSON = PackageJson & {
       version: string;
       onFail: "download";
     };
+    runtime: {
+      name: "node";
+      version: string;
+      onFail: "download";
+    };
+  };
+  engines?: {
+    node: string;
   };
 };
 
+const NODE_RUNTIME_VERSION = "^24.11.0";
+
 const missingTypegenCommandPatterns = [
   /ERR_PNPM_RECURSIVE_EXEC_FIRST_FAIL[\s\S]*Command\s+["'`]typegen["'`]\s+not found/i,
   /Command\s+["'`]typegen["'`]\s+not found/i,
@@ -289,23 +303,40 @@ export const runInit = async (name?: string, opts?: CliFlags) => {
   pkgJson.proofkitMetadata = { initVersion: getVersion() };
 
   // ? Bun doesn't support this field (yet)
+  let pkgManagerVersion: string | undefined;
   if (pkgManager !== "bun") {
     const { stdout } = await execa(pkgManager, ["-v"], {
       cwd: projectDir,
     });
+    pkgManagerVersion = stdout.trim();
     pkgJson.packageManager = undefined;
     pkgJson.devEngines = {
       packageManager: {
         name: pkgManager,
-        version: stdout.trim(),
+        version: pkgManagerVersion,
+        onFail: "download",
+      },
+      runtime: {
+        name: "node",
+        version: NODE_RUNTIME_VERSION,
         onFail: "download",
       },
     };
   }
+  pkgJson.engines = {
+    node: NODE_RUNTIME_VERSION,
+  };
 
   fs.writeJSONSync(path.join(projectDir, "package.json"), pkgJson, {
     spaces: 2,
   });
+  if (pkgManager === "pnpm") {
+    fs.writeFileSync(
+      path.join(projectDir, "pnpm-workspace.yaml"),
+      createPnpmWorkspaceFileContent(state.appType ?? "browser"),
+      "utf8",
+    );
+  }
 
   // Ensure proofkit.json exists with shadcn settings
   const initialSettings: Settings = {
@@ -366,6 +397,24 @@ export const runInit = async (name?: string, opts?: CliFlags) => {
     await installDependencies({ projectDir });
   }
 
+  const ultraciteCommand = getUltraciteInitCommand({
+    appType: state.appType ?? "browser",
+    packageManager: pkgManager,
+    skipInstall: noInstall,
+  });
+  await execa(ultraciteCommand.command, ultraciteCommand.args, {
+    cwd: projectDir,
+    stdio: "pipe",
+  });
+  if ((state.appType ?? "browser") === "browser") {
+    fs.writeFileSync(path.join(projectDir, "oxlint.config.ts"), getBrowserOxlintConfig(), "utf8");
+  }
+  const intentCommand = getIntentInstallCommand(pkgManager);
+  await execa(intentCommand.command, intentCommand.args, {
+    cwd: projectDir,
+    stdio: "pipe",
+  });
+
   if (dataSource === "filemaker") {
     const shouldRunInitialCodegen = state.appType === "webviewer" && !(nonInteractive && !hasExplicitFileMakerInputs);
 
@@ -382,6 +431,26 @@ export const runInit = async (name?: string, opts?: CliFlags) => {
     }
   }
 
+  if (!noInstall) {
+    const [fixCommand, ...fixArgs] = formatPackageManagerCommand(pkgManager, "fix").split(" ");
+    if (!fixCommand) {
+      throw new Error(`Unable to resolve fix command for ${pkgManager}.`);
+    }
+    await execa(fixCommand, fixArgs, {
+      cwd: projectDir,
+      stdio: "pipe",
+    }).catch(() => undefined);
+
+    const [lintCommand, ...lintArgs] = formatPackageManagerCommand(pkgManager, "lint").split(" ");
+    if (!lintCommand) {
+      throw new Error(`Unable to resolve lint command for ${pkgManager}.`);
+    }
+    await execa(lintCommand, lintArgs, {
+      cwd: projectDir,
+      stdio: "pipe",
+    });
+  }
+
   if (!noGit) {
     await initializeGit(projectDir);
   }

packages/cli/src/consts.ts

@@ -11,10 +11,9 @@ export const cliName = "proofkit";
 export const npmName = "@proofkit/cli";
 export const DOCS_URL = "https://proofkit.proof.sh";
 
-export const AGENT_INSTRUCTIONS = [
-  "Use the ProofKit docs as the primary reference for this project: https://proofkit.proof.sh/docs",
-  "Before doing any AI-assisted development here, run `npx @tanstack/intent@latest install` in the project root to load skills relevant to this project",
-].join("\n");
+export function getAgentInstructions() {
+  return "Use the ProofKit docs as the primary reference for this project: https://proofkit.proof.sh/docs";
+}
 
 // Registry URL is injected at build time via tsdown define.
 declare const __REGISTRY_URL__: string;

packages/cli/src/core/executeInitPlan.ts

@@ -3,7 +3,7 @@ import { Chalk } from "chalk";
 import { Cause, Effect, Exit } from "effect";
 import { getOrUndefined } from "effect/Option";
 
-import { AGENT_INSTRUCTIONS } from "~/consts.js";
+import { getAgentInstructions } from "~/consts.js";
 import {
   CliContext,
   CodegenService,
@@ -19,7 +19,14 @@ import {
 import { DirectoryConflictError, FileSystemError, isCliError, UserCancelledError } from "~/core/errors.js";
 import { applyPackageJsonMutations } from "~/core/planInit.js";
 import type { InitPlan } from "~/core/types.js";
-import { normalizeImportAlias, replaceTextInFiles, updateTypegenConfig } from "~/utils/projectFiles.js";
+import { getIntentInstallCommand } from "~/helpers/intent.js";
+import { getBrowserOxlintConfig, getUltraciteInitCommand } from "~/helpers/ultracite.js";
+import {
+  formatPackageManagerCommand,
+  normalizeImportAlias,
+  replaceTextInFiles,
+  updateTypegenConfig,
+} from "~/utils/projectFiles.js";
 import { sortPackageJson } from "~/utils/sortPackageJson.js";
 
 const AGENT_METADATA_DIRS = new Set([".agents", ".claude", ".clawed", ".clinerules", ".cursor", ".windsurf"]);
@@ -78,6 +85,14 @@ function renderNextSteps(plan: InitPlan, additionalSteps: string[] = []) {
   return lines.join("\n");
 }
 
+function getPackageScriptCommand(plan: InitPlan, scriptName: string) {
+  const [command, ...args] = formatPackageManagerCommand(plan.request.packageManager, scriptName).split(" ");
+  if (!command) {
+    throw new Error(`Unable to resolve ${scriptName} command for ${plan.request.packageManager}.`);
+  }
+  return { command, args };
+}
+
 function getMeaningfulDirectoryEntries(entries: string[]) {
   return entries.filter((entry) => {
     if (AGENT_METADATA_DIRS.has(entry)) {
@@ -275,7 +290,7 @@ export const executeInitPlan = (plan: InitPlan) =>
         }),
     });
     yield* Effect.tryPromise({
-      try: () => replaceTextInFiles(projectFilesFs, plan.targetDir, "__AGENT_INSTRUCTIONS__", AGENT_INSTRUCTIONS),
+      try: () => replaceTextInFiles(projectFilesFs, plan.targetDir, "__AGENT_INSTRUCTIONS__", getAgentInstructions()),
       catch: (cause) =>
         new FileSystemError({
           message: "Unable to rewrite scaffold placeholders.",
@@ -380,14 +395,6 @@ export const executeInitPlan = (plan: InitPlan) =>
     }
 
     if (plan.tasks.runInstall) {
-      if (plan.request.packageManager === "pnpm") {
-        yield* processService.run("pnpm", ["self-update", "11"], {
-          cwd: plan.targetDir,
-          stdout: "pipe",
-          stderr: "pipe",
-        });
-      }
-
       let installArgs: string[] = ["install"];
       if (plan.request.packageManager === "yarn") {
         installArgs = [];
@@ -399,10 +406,61 @@ export const executeInitPlan = (plan: InitPlan) =>
       });
     }
 
+    if (plan.tasks.runUltraciteInit) {
+      const ultraciteCommand = getUltraciteInitCommand({
+        appType: plan.request.appType,
+        packageManager: plan.request.packageManager,
+        skipInstall: plan.request.noInstall,
+      });
+      yield* processService.run(ultraciteCommand.command, ultraciteCommand.args, {
+        cwd: plan.targetDir,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      if (plan.request.appType === "browser") {
+        yield* fs.writeFile(path.join(plan.targetDir, "oxlint.config.ts"), getBrowserOxlintConfig());
+      }
+    }
+
+    if (plan.tasks.runIntentInstall) {
+      const intentCommand = getIntentInstallCommand(plan.request.packageManager);
+      yield* processService.run(intentCommand.command, intentCommand.args, {
+        cwd: plan.targetDir,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+    }
+
     if (plan.tasks.runInitialCodegen) {
       yield* codegenService.runInitial(plan.targetDir, plan.request.packageManager);
     }
 
+    if (plan.tasks.runFix) {
+      const fixCommand = getPackageScriptCommand(plan, "fix");
+      yield* Effect.either(
+        processService.run(fixCommand.command, fixCommand.args, {
+          cwd: plan.targetDir,
+          stdout: "pipe",
+          stderr: "pipe",
+        }),
+      );
+    }
+
+    if (plan.tasks.runLint) {
+      const fixCommand = getPackageScriptCommand(plan, "fix");
+      const result = yield* Effect.either(
+        processService.run(fixCommand.command, fixCommand.args, {
+          cwd: plan.targetDir,
+          stdout: "pipe",
+          stderr: "pipe",
+        }),
+      );
+      if (result._tag === "Left") {
+        consoleService.warn("Lint fix did not succeed; continuing setup.");
+      }
+    }
+
     if (plan.tasks.initializeGit) {
       yield* gitService.initialize(plan.targetDir);
     }