stackpack-cli 0.3.1 → 0.3.3

package/README.md

@@ -112,6 +112,8 @@ Framework-specific filtering applies automatically — e.g. React Router is hidd
 stackpack                          # interactive main menu
 stackpack new <project-name>       # create a project with an official creator
 stackpack new my-app --preset jc-react-stack
+stackpack install <preset> [name]  # express mode: whole stack in one shot
+stackpack i <preset> [name]        # same, shorter
 stackpack add                      # add integrations to the current project
 stackpack add --dry-run            # full plan, zero changes
 stackpack add --package-manager pnpm
@@ -120,6 +122,7 @@ stackpack save <name> [--local|--global]
 stackpack apply <name> [--dry-run] # apply a preset to the current project
 stackpack presets list
 stackpack presets show <name>
+stackpack presets edit <name>      # swap integrations, save back — no project touched
 stackpack presets delete <name>
 stackpack --no-color
 ```
@@ -137,6 +140,8 @@ StackPack requires **no sign-up, no login, no server, no telemetry**. Presets ar
 
 Presets never contain shell commands, executable code, absolute paths, credentials, or `.env` values — the schema rejects anything unexpected. Internet access is only needed to run official creators/initializers and install packages.
 
+One small exception, in the open: the interactive menu checks the npm registry (at most once per day, cached locally) to tell you when a newer StackPack version exists. It is an anonymous read-only request that sends nothing about you or your projects, never updates anything by itself, fails silently offline, and can be disabled completely by setting the `STACKPACK_NO_UPDATE_CHECK` environment variable.
+
 ## Safety
 
 - Nothing is installed before you confirm the reviewed plan.

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 //#region src/cli.ts
 if (process.argv.includes("--no-color")) process.env.NO_COLOR = "1";
-const { runCli } = await import("./program-D9mgsLIa.js");
+const { runCli } = await import("./program-Bq8-8HvQ.js");
 await runCli(process.argv);
 process.exit(process.exitCode ?? 0);
 //#endregion

package/dist/{program-D9mgsLIa.js → program-Bq8-8HvQ.js}

@@ -2477,16 +2477,45 @@ function testingLabel(selection) {
 	if (selection.testing.length === 0) return void 0;
 	return selection.testing.map((entry) => getRecipe(entry.id)?.name ?? entry.id).join(" + ");
 }
-/** Category rows turn green with a check once something is selected. */
-function categoryOption(value, label, selected) {
-	return selected ? {
+/**
+* Project inventory per category: what is already installed in the project
+* (detected from real files/packages), independent of this session's picks.
+*/
+function installedSummary(availabilities, category) {
+	const entries = availabilities.filter((a) => a.recipe.category === category && (a.compatibility === "already-installed" || a.compatibility === "partially-configured"));
+	if (entries.length === 0) return void 0;
+	return {
+		label: entries.map((a) => {
+			const version = a.detection.installedVersion;
+			const base = version ? `${a.recipe.name} ${version}` : a.recipe.name;
+			return a.compatibility === "partially-configured" ? `${base} — partial setup` : base;
+		}).join(" + "),
+		partial: entries.some((a) => a.compatibility === "partially-configured")
+	};
+}
+/**
+* Category rows show this session's picks first (green check), otherwise what
+* the project already has installed, otherwise that the slot is open.
+*/
+function categoryOption(value, label, selected, installed) {
+	if (selected) return {
 		value,
 		label: `${label} ${pc.green("✓")}`,
 		hint: pc.green(selected)
+	};
+	if (installed) return installed.partial ? {
+		value,
+		label: `${label} ${pc.yellow("⚠")}`,
+		hint: pc.yellow(`installed: ${installed.label}`)
 	} : {
+		value,
+		label: `${label} ${pc.green("●")}`,
+		hint: pc.dim(`installed: ${installed.label}`)
+	};
+	return {
 		value,
 		label,
-		hint: "Not selected"
+		hint: "Not installed"
 	};
 }
 function categoryHasVisibleRecipes(availabilities, category) {
@@ -2496,7 +2525,8 @@ function categoryHasVisibleRecipes(availabilities, category) {
 * The jumpable category dashboard. Selections persist in memory while the
 * user moves between categories; nothing is installed here.
 */
-async function runDashboard(context, selection) {
+async function runDashboard(context, selection, options = {}) {
+	const reviewLabel = options.reviewLabel ?? "Review and Install";
 	for (;;) {
 		const availabilities = filterIntegrations(context, allRecipes);
 		const count = selectedIntegrationCount(selection);
@@ -2504,13 +2534,13 @@ async function runDashboard(context, selection) {
 		const overrideCount = Object.keys(selection.versionOverrides).length;
 		p.log.info(`Selected integrations: ${count}   Additional packages: ${customCount}${overrideCount > 0 ? `   Version overrides: ${overrideCount}` : ""}`);
 		const options = [];
-		if (categoryHasVisibleRecipes(availabilities, "routing")) options.push(categoryOption("routing", "Routing", selectionLabel(selection.routing)));
-		options.push(categoryOption("state-management", "State Management", selectionLabel(selection.stateManagement)), categoryOption("data-fetching", "Data Fetching and API", selectionLabel(selection.dataFetching)), categoryOption("forms-validation", "Forms and Validation", selectionLabel(selection.formsAndValidation)), categoryOption("ui", "UI Components", selectionLabel(selection.ui)), categoryOption("orm", "Database / ORM", selectionLabel(selection.orm)), categoryOption("testing", "Testing", testingLabel(selection)), categoryOption("custom-packages", "Custom Packages", customCount > 0 ? `${customCount} package${customCount === 1 ? "" : "s"}` : void 0), {
+		if (categoryHasVisibleRecipes(availabilities, "routing")) options.push(categoryOption("routing", "Routing", selectionLabel(selection.routing), installedSummary(availabilities, "routing")));
+		options.push(categoryOption("state-management", "State Management", selectionLabel(selection.stateManagement), installedSummary(availabilities, "state-management")), categoryOption("data-fetching", "Data Fetching and API", selectionLabel(selection.dataFetching), installedSummary(availabilities, "data-fetching")), categoryOption("forms-validation", "Forms and Validation", selectionLabel(selection.formsAndValidation), installedSummary(availabilities, "forms-validation")), categoryOption("ui", "UI Components", selectionLabel(selection.ui), installedSummary(availabilities, "ui")), categoryOption("orm", "Database / ORM", selectionLabel(selection.orm), installedSummary(availabilities, "orm")), categoryOption("testing", "Testing", testingLabel(selection), installedSummary(availabilities, "testing")), categoryOption("custom-packages", "Custom Packages", customCount > 0 ? `${customCount} package${customCount === 1 ? "" : "s"}` : void 0), {
 			value: "versions",
 			label: "Edit Package Versions"
 		}, {
 			value: "review",
-			label: "Review and Install"
+			label: reviewLabel
 		});
 		switch (guard(await p.select({
 			message: "Choose a category",
@@ -3828,16 +3858,50 @@ function buildPresetFromSelection(params) {
 		versionOverrides: selection.versionOverrides
 	};
 }
+/**
+* True when the current selection still matches what the preset describes —
+* a save-and-load flow should not re-ask to save an unchanged setup.
+*/
+function selectionMatchesPreset(preset, selection) {
+	const dependencies = {};
+	const devDependencies = {};
+	for (const pkg of selection.customPackages) (pkg.dependencyType === "dependency" ? dependencies : devDependencies)[pkg.name] = pkg.version;
+	const current = {
+		integrations: selectedRecipes(selection).map(({ recipe, options }) => ({
+			id: recipe.id,
+			options
+		})),
+		dependencies,
+		devDependencies,
+		versionOverrides: selection.versionOverrides
+	};
+	const saved = {
+		integrations: preset.integrations.map(({ id, options }) => ({
+			id,
+			options
+		})),
+		dependencies: preset.customPackages.dependencies,
+		devDependencies: preset.customPackages.devDependencies,
+		versionOverrides: preset.versionOverrides
+	};
+	return JSON.stringify(current) === JSON.stringify(saved);
+}
 /** Post-install offer to save the applied setup as a preset. */
-async function offerToSavePreset(context, selection) {
+async function offerToSavePreset(context, selection, options = {}) {
 	if (context.framework === "unknown" || context.language === "unknown") return;
+	const source = options.sourcePreset;
+	if (source && selectionMatchesPreset(source, selection)) {
+		p.log.success(`Installed from preset "${source.displayName ?? source.name}" — nothing new to save. Good to go!`);
+		return;
+	}
 	if (!guard(await p.confirm({
-		message: "Save this setup as a preset?",
+		message: source ? `This setup was changed after loading preset "${source.name}". Save the updated setup as a preset?` : "Save this setup as a preset?",
 		initialValue: false
 	}))) return;
 	const name = guard(await p.text({
 		message: "Preset name",
 		placeholder: "my-react-stack",
+		initialValue: source?.name,
 		validate(value) {
 			const result = validatePresetName(value ?? "");
 			return result.ok ? void 0 : result.reason;
@@ -3902,7 +3966,7 @@ async function dashboardInstallLoop(params) {
 			continue;
 		}
 		if (result === "installed") {
-			await offerToSavePreset(params.context, params.selection);
+			await offerToSavePreset(params.context, params.selection, { sourcePreset: params.sourcePreset });
 			return "installed";
 		}
 		return result === "dry-run" ? "dry-run" : "cancelled";
@@ -3968,6 +4032,25 @@ async function directoryState(target) {
 		return "missing";
 	}
 }
+/**
+* Creating a project inside an existing project is allowed but easy to mix up
+* later (two nested package.json trees), so it needs an explicit confirmation.
+*/
+async function confirmIfInsideExistingProject() {
+	if (!await fs.access(path.join(process.cwd(), "package.json")).then(() => true).catch(() => false)) return true;
+	p.log.warn(`This folder is already a project (package.json found):\n  ${process.cwd()}\nThe new project would be created inside it — nested projects are easy to confuse later.`);
+	return guard(await p.select({
+		message: "Create the new project inside this existing project anyway?",
+		options: [{
+			value: "cancel",
+			label: "No, cancel",
+			hint: "cd to another folder first, then run stackpack again"
+		}, {
+			value: "continue",
+			label: "Yes, create it nested inside this project"
+		}]
+	})) === "continue";
+}
 async function askProjectName(initial) {
 	let candidate = initial;
 	for (;;) {
@@ -4078,9 +4161,47 @@ async function ensureDependenciesInstalled(destination, packageManager) {
 	const result = await realCommandRunner(baseInstallCommand(packageManager, destination));
 	if (result.exitCode !== 0) p.log.warn(`Dependency installation failed (exit code ${result.exitCode}). Run "${packageManager} install" inside the project to finish setup.`);
 }
+/**
+* Express install: create a project from a saved preset in one shot, like the
+* official create-* tools but with the whole stack. Skips the intermediate
+* confirmations of runNew; the review screen is the single decision point.
+*/
+async function runExpressInstall(presetName, projectNameArg, options = {}) {
+	p.intro("StackPack — express install");
+	const { preset, location } = await loadPreset(presetName, { projectRoot: process.cwd() });
+	p.log.info(`Preset: ${preset.displayName ?? preset.name} ${pc.dim(`(${location.scope} — ${preset.integrations.length} integrations)`)}`);
+	if (!await confirmIfInsideExistingProject()) throw new CancelledError();
+	const { name, destination } = await askProjectName(projectNameArg);
+	const creator = getCreator(preset.base.creator);
+	const config = await loadConfig();
+	const packageManager = options.packageManager ?? config.defaultPackageManager ?? "npm";
+	await runOfficialCreator(creator, name, { language: preset.base.language }, packageManager);
+	const context = await detectProject(destination, { packageManagerOverride: packageManager });
+	if (context.detection === "unsupported") {
+		p.log.warn("The generated project is not a supported React or Next.js project, so the preset's integrations cannot be applied.");
+		await ensureDependenciesInstalled(destination, packageManager);
+		p.outro(`Base project created at ${destination}. No integrations were installed.`);
+		return;
+	}
+	if (await dashboardInstallLoop({
+		context,
+		selection: presetToSelection(preset),
+		dryRun: false,
+		startAtReview: true,
+		sourcePreset: preset
+	}) === "cancelled") {
+		await ensureDependenciesInstalled(destination, packageManager);
+		p.outro(`Base project created at ${destination}. No integrations were installed.`);
+		return;
+	}
+	await ensureDependenciesInstalled(destination, packageManager);
+	p.note(`cd ${name}\n${packageManager} run dev`, "Next steps");
+	p.outro(`Project ready at ${destination} — good to go!`);
+}
 async function runNew(projectNameArg, options) {
 	p.intro("StackPack — new project");
 	p.log.message(pc.dim("Official project tooling with real-world integrations."));
+	if (!await confirmIfInsideExistingProject()) throw new CancelledError();
 	let preset;
 	if (options.preset) preset = (await loadPreset(options.preset, { projectRoot: process.cwd() })).preset;
 	else {
@@ -4179,14 +4300,16 @@ async function runNew(projectNameArg, options) {
 		context,
 		selection: preset ? presetToSelection(preset) : createEmptySelection(),
 		dryRun: false,
-		startAtReview: preset !== void 0
+		startAtReview: preset !== void 0,
+		sourcePreset: preset
 	}) === "cancelled") {
 		await ensureDependenciesInstalled(destination, packageManager);
 		p.outro(`Base project created at ${destination}. No integrations were installed.`);
 		return;
 	}
 	await ensureDependenciesInstalled(destination, packageManager);
-	p.outro(`Project ready at ${destination}`);
+	p.note(`cd ${name}\n${packageManager} run dev`, "Next steps");
+	p.outro(`Project ready at ${destination} — good to go!`);
 }
 //#endregion
 //#region src/project/git-status.ts
@@ -4436,7 +4559,8 @@ async function runApply(name, options) {
 		context,
 		selection: presetToSelection(preset),
 		dryRun: options.dryRun === true,
-		startAtReview: true
+		startAtReview: true,
+		sourcePreset: preset
 	});
 	if (outcome === "cancelled") throw new CancelledError();
 	p.outro(outcome === "dry-run" ? "Dry run finished." : `Preset "${name}" applied.`);
@@ -4545,6 +4669,11 @@ async function runPresetsBrowser(options = {}) {
 					value: "list",
 					label: "Back to preset list"
 				},
+				{
+					value: "edit",
+					label: "Edit this preset",
+					hint: "swap integrations, save back"
+				},
 				{
 					value: "delete",
 					label: "Delete this preset"
@@ -4556,6 +4685,10 @@ async function runPresetsBrowser(options = {}) {
 			]
 		}));
 		if (action === "menu") return;
+		if (action === "edit") {
+			await runPresetsEdit(selected.name, { cwd: projectRoot });
+			continue;
+		}
 		if (action === "delete") {
 			if (guard(await p.confirm({
 				message: `Delete preset "${selected.name}"?`,
@@ -4567,6 +4700,65 @@ async function runPresetsBrowser(options = {}) {
 		}
 	}
 }
+/**
+* Editing a preset never touches a real project, so the dashboard runs
+* against a synthetic context built from the preset's own project shape.
+*/
+function contextForPresetEditing(preset) {
+	return {
+		rootDirectory: process.cwd(),
+		framework: preset.project.framework,
+		buildTool: preset.project.buildTool,
+		language: preset.project.language,
+		packageManager: "npm",
+		packageManagerCandidates: [],
+		detection: "detected",
+		packageJson: {},
+		detectedFiles: [],
+		installedPackages: {}
+	};
+}
+/**
+* Save-and-load editing: open a preset in the dashboard, change integrations,
+* and write it back to the same file. No project is created or modified.
+*/
+async function runPresetsEdit(name, options = {}) {
+	const projectRoot = options.cwd ?? process.cwd();
+	const { preset, location } = await loadPreset(name, { projectRoot });
+	p.log.info(`Editing ${location.scope} preset: ${location.filePath}`);
+	p.log.message(pc.dim("Changes apply to the preset file only — no project is created or modified."));
+	const context = contextForPresetEditing(preset);
+	const selection = presetToSelection(preset);
+	if (await runDashboard(context, selection, { reviewLabel: "Finish editing" }) !== "review") return;
+	if (selectionMatchesPreset(preset, selection)) {
+		p.log.info(`No changes made — preset "${preset.name}" is untouched.`);
+		return;
+	}
+	const rebuilt = buildPresetFromSelection({
+		name: preset.name,
+		scope: location.scope,
+		context,
+		selection
+	});
+	if (!rebuilt) {
+		p.log.warn("This preset cannot be rebuilt (unknown framework or language). Nothing saved.");
+		return;
+	}
+	const updated = {
+		...rebuilt,
+		displayName: preset.displayName ?? preset.name,
+		createdAt: preset.createdAt
+	};
+	if (!guard(await p.confirm({
+		message: `Save changes to preset "${preset.name}"?`,
+		initialValue: true
+	}))) {
+		p.log.info("Changes discarded — the preset file was not modified.");
+		return;
+	}
+	const saved = await savePreset(updated, location.scope, { projectRoot });
+	p.log.success(`Preset updated: ${saved.filePath}`);
+}
 async function runPresetsDelete(name, options = {}) {
 	const storeOptions = { projectRoot: options.cwd ?? process.cwd() };
 	p.intro("StackPack — delete preset");
@@ -4581,8 +4773,62 @@ async function runPresetsDelete(name, options = {}) {
 	p.outro(`Deleted ${location.scope} preset: ${location.filePath}`);
 }
 //#endregion
+//#region src/utils/update-check.ts
+const PACKAGE_NAME = "stackpack-cli";
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const CHECK_INTERVAL_MS = 1440 * 60 * 1e3;
+const FETCH_TIMEOUT_MS = 2e3;
+function cacheFilePath() {
+	return path.join(getStoragePaths().cacheDir, "update-check.json");
+}
+async function readCachedLatest() {
+	try {
+		const raw = JSON.parse(await fs.readFile(cacheFilePath(), "utf8"));
+		return Date.now() - Date.parse(raw.checkedAt) < CHECK_INTERVAL_MS && semver.valid(raw.latest) ? raw.latest : null;
+	} catch {
+		return null;
+	}
+}
+async function fetchLatestFromRegistry() {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+	try {
+		const response = await fetch(REGISTRY_URL, { signal: controller.signal });
+		if (!response.ok) return null;
+		const data = await response.json();
+		if (typeof data.version !== "string" || !semver.valid(data.version)) return null;
+		const cache = {
+			checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			latest: data.version
+		};
+		await fs.mkdir(path.dirname(cacheFilePath()), { recursive: true });
+		await fs.writeFile(cacheFilePath(), JSON.stringify(cache), "utf8");
+		return data.version;
+	} catch {
+		return null;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* Anonymous, best-effort check for a newer published version. Never blocks
+* for more than ~2s, runs at most once per day (cached in ~/.stackpack/cache),
+* fails silently offline, and is disabled entirely by STACKPACK_NO_UPDATE_CHECK.
+* It never updates anything by itself — it only returns a notice to display.
+*/
+async function getUpdateNotice(currentVersion) {
+	if (process.env.STACKPACK_NO_UPDATE_CHECK) return null;
+	try {
+		const latest = await readCachedLatest() ?? await fetchLatestFromRegistry();
+		if (!latest || !semver.valid(currentVersion) || !semver.gt(latest, currentVersion)) return null;
+		return `Update available: ${currentVersion} → ${latest}\nRun: npm install -g ${PACKAGE_NAME}`;
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/version.ts
-const VERSION = "0.3.0";
+const VERSION = "0.3.3";
 //#endregion
 //#region src/program.ts
 const packageManagerOption = new Option("--package-manager <manager>", "package manager to use").choices([
@@ -4596,6 +4842,8 @@ async function runMainMenu() {
 	p.log.message("Official project tooling with real-world integrations.");
 	p.log.message("Presets stay on this device.");
 	p.log.message(pc.dim("Ctrl+C on any question brings you back to this menu instead of exiting."));
+	const updateNotice = await getUpdateNotice(VERSION);
+	if (updateNotice) p.log.warn(pc.yellow(updateNotice));
 	for (;;) {
 		const choice = await p.select({
 			message: "What would you like to do?",
@@ -4676,6 +4924,9 @@ async function runCli(argv) {
 	program.command("apply").description("Apply a saved preset's integrations to the current project").argument("<preset-name>", "preset to apply").option("--dry-run", "show the full plan without changing anything").action(async (name, options) => {
 		await runApply(name, options);
 	});
+	program.command("install").alias("i").description("Create a project from a saved preset in one shot (express mode)").argument("<preset-name>", "saved preset to install from").argument("[project-name]", "project folder to create (asked interactively if omitted)").addOption(packageManagerOption).action(async (presetName, projectName, options) => {
+		await runExpressInstall(presetName, projectName, options);
+	});
 	const presets = program.command("presets").description("Manage saved presets");
 	presets.command("list").description("List saved presets (global and project-local)").action(async () => {
 		await runPresetsList();
@@ -4683,6 +4934,9 @@ async function runCli(argv) {
 	presets.command("show").description("Show a preset's contents").argument("<preset-name>").action(async (name) => {
 		await runPresetsShow(name);
 	});
+	presets.command("edit").description("Edit a saved preset's integrations (no project is touched)").argument("<preset-name>").action(async (name) => {
+		await runPresetsEdit(name);
+	});
 	presets.command("delete").description("Delete a saved preset").argument("<preset-name>").action(async (name) => {
 		await runPresetsDelete(name);
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stackpack-cli",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Local-first, privacy-focused terminal integration builder for JavaScript and TypeScript projects. Official tooling first, presets stay on your device.",
   "type": "module",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "dist"
   ],
   "engines": {
-    "node": ">=18.17"
+    "node": ">=22"
   },
   "scripts": {
     "dev": "tsx src/cli.ts",