generatesaas 0.1.0

package/dist/skill/content/scripts/complete-update.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+/**
+ * Complete the update process.
+ * Re-hashes all project files, updates template hashes from staging,
+ * updates .generatesaas/manifest.json, and cleans up staging + references.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { findProjectRoot, hashFile, walkDir, MANIFEST_FILE, HASHES_FILE, TEMPLATE_HASHES_FILE, STAGING_DIR, STAGING_META_FILE, INTERNAL_DIR } = require("./_helpers.js");
+
+const HASH_EXCLUSIONS = new Set([".git", "node_modules", ".pnpm-store", ".env", "data", INTERNAL_DIR]);
+
+/** Check if a relative path should be excluded from hashing. */
+function shouldExcludeFromHash(relativePath) {
+	const parts = relativePath.split("/");
+	for (const part of parts) {
+		if (HASH_EXCLUSIONS.has(part)) return true;
+		if (part.startsWith(".env") && !part.includes("example")) return true;
+	}
+	return false;
+}
+
+/** Recursively collect all file paths for project hashing. */
+function collectProjectFiles(dir, baseDir) {
+	const files = [];
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		const rel = path.relative(baseDir, fullPath);
+
+		if (shouldExcludeFromHash(rel)) continue;
+
+		if (entry.isDirectory()) {
+			files.push(...collectProjectFiles(fullPath, baseDir));
+		} else if (entry.isFile()) {
+			files.push(fullPath);
+		}
+	}
+
+	return files;
+}
+
+function main() {
+	const root = findProjectRoot();
+	if (!root) {
+		console.error("Error: .generatesaas/manifest.json not found. Run this from a GenerateSaaS project.");
+		process.exit(1);
+	}
+
+	// Determine the skill root
+	const scriptDir = __dirname;
+	const skillDir = path.dirname(scriptDir);
+	const refsDir = path.join(skillDir, "references");
+
+	const updateManifestPath = path.join(refsDir, "update-manifest.json");
+	if (!fs.existsSync(updateManifestPath)) {
+		console.error("Error: references/update-manifest.json not found. Run prepare-update.js first.");
+		process.exit(1);
+	}
+
+	const updateManifest = JSON.parse(fs.readFileSync(updateManifestPath, "utf-8"));
+	const targetVersion = updateManifest.targetVersion;
+
+	console.log(`Completing update to version ${targetVersion}...`);
+
+	// Compute and write new template hashes from staging BEFORE cleanup
+	const stagingDir = path.join(root, STAGING_DIR);
+	if (fs.existsSync(stagingDir)) {
+		console.log("Computing template hashes from staging...");
+		const stagingFiles = walkDir(stagingDir, stagingDir);
+		const templateHashes = {};
+		for (const rel of stagingFiles.sort()) {
+			templateHashes[rel] = hashFile(path.join(stagingDir, rel));
+		}
+		const templateHashesPath = path.join(root, TEMPLATE_HASHES_FILE);
+		fs.mkdirSync(path.dirname(templateHashesPath), { recursive: true });
+		fs.writeFileSync(templateHashesPath, JSON.stringify(templateHashes, null, "\t") + "\n", "utf-8");
+		console.log(`Tracked ${Object.keys(templateHashes).length} template hashes in ${TEMPLATE_HASHES_FILE}`);
+	}
+
+	// Clean up staging
+	if (fs.existsSync(stagingDir)) {
+		fs.rmSync(stagingDir, { recursive: true, force: true });
+		console.log("Cleaned up staging directory");
+	}
+	const metaPath = path.join(root, STAGING_META_FILE);
+	if (fs.existsSync(metaPath)) {
+		fs.rmSync(metaPath);
+	}
+
+	// Clean up references BEFORE hashing to avoid tracking temp files
+	if (fs.existsSync(refsDir)) {
+		fs.rmSync(refsDir, { recursive: true, force: true });
+	}
+	fs.mkdirSync(refsDir, { recursive: true });
+	fs.writeFileSync(path.join(refsDir, ".gitkeep"), "", "utf-8");
+	console.log("Cleaned up references/");
+
+	// Re-hash all project files
+	console.log("Hashing project files...");
+	const files = collectProjectFiles(root, root);
+	const fileHashes = {};
+	for (const file of files.sort()) {
+		const rel = path.relative(root, file);
+		fileHashes[rel] = hashFile(file);
+	}
+
+	// Update version in manifest
+	const manifestPath = path.join(root, MANIFEST_FILE);
+	const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+	manifest.version = targetVersion;
+
+	fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, "\t") + "\n", "utf-8");
+	console.log(`Updated manifest to version ${targetVersion}`);
+
+	// Write hashes to separate file
+	const hashesPath = path.join(root, HASHES_FILE);
+	fs.mkdirSync(path.dirname(hashesPath), { recursive: true });
+	fs.writeFileSync(hashesPath, JSON.stringify(fileHashes, null, "\t") + "\n", "utf-8");
+	console.log(`Tracked ${Object.keys(fileHashes).length} file hashes in ${HASHES_FILE}`);
+
+	console.log(`\nUpdate to ${targetVersion} complete!`);
+	console.log("Run 'pnpm install' if package.json was updated.");
+}
+
+try {
+	main();
+} catch (err) {
+	console.error("Error:", err.message);
+	process.exit(1);
+}

package/dist/skill/content/scripts/prepare-update.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+/**
+ * Prepare update data from the local staging directory.
+ * Computes diffs between the staged template and current project files.
+ * Produces the same output as the old fetch-update.js but without any API calls.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { execFileSync } = require("node:child_process");
+const { findProjectRoot, ensureDir, hashFile, walkDir, TEMPLATE_HASHES_FILE, STAGING_DIR, STAGING_META_FILE } = require("./_helpers.js");
+
+function main() {
+	const root = findProjectRoot();
+	if (!root) {
+		console.error("Error: .generatesaas/manifest.json not found. Run this from a GenerateSaaS project.");
+		process.exit(1);
+	}
+
+	// Read staging metadata (written by the CLI `update` command)
+	const metaPath = path.join(root, STAGING_META_FILE);
+	if (!fs.existsSync(metaPath)) {
+		console.error("Error: No staged update found. Run 'generatesaas update' first.");
+		process.exit(1);
+	}
+	const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+	const { currentVersion, targetVersion, changelog } = meta;
+
+	// Verify staging directory exists
+	const stagingDir = path.join(root, STAGING_DIR);
+	if (!fs.existsSync(stagingDir)) {
+		console.error("Error: Staging directory not found. Run 'generatesaas update' first.");
+		process.exit(1);
+	}
+
+	console.log(`Preparing update: ${currentVersion} → ${targetVersion}`);
+
+	// Read old template hashes
+	const templateHashesPath = path.join(root, TEMPLATE_HASHES_FILE);
+	const oldHashes = fs.existsSync(templateHashesPath)
+		? JSON.parse(fs.readFileSync(templateHashesPath, "utf-8"))
+		: {};
+
+	// Walk staging dir and compute new template hashes
+	const stagingFiles = walkDir(stagingDir, stagingDir);
+	const newHashes = {};
+	for (const rel of stagingFiles) {
+		newHashes[rel] = hashFile(path.join(stagingDir, rel));
+	}
+
+	// Compare old vs new template hashes
+	const added = [];
+	const modified = [];
+	const removed = [];
+
+	// Files in new template
+	for (const filePath of Object.keys(newHashes)) {
+		if (!(filePath in oldHashes)) {
+			added.push(filePath);
+		} else if (newHashes[filePath] !== oldHashes[filePath]) {
+			modified.push(filePath);
+		}
+	}
+
+	// Files in old template but not in new
+	for (const filePath of Object.keys(oldHashes)) {
+		if (!(filePath in newHashes)) {
+			removed.push(filePath);
+		}
+	}
+
+	added.sort();
+	modified.sort();
+	removed.sort();
+
+	console.log(`  Added: ${added.length}, Modified: ${modified.length}, Removed: ${removed.length}`);
+
+	// Determine output directory
+	const scriptDir = __dirname;
+	const skillDir = path.dirname(scriptDir);
+	const refsDir = path.join(skillDir, "references");
+	ensureDir(refsDir);
+
+	// Write changelog
+	if (changelog) {
+		fs.writeFileSync(path.join(refsDir, "changelog.md"), changelog, "utf-8");
+		console.log("Written: references/changelog.md");
+	} else {
+		console.log("No changelog found for this version.");
+	}
+
+	// Generate and write diffs for modified files
+	const diffsDir = path.join(refsDir, "diffs");
+	ensureDir(diffsDir);
+	let diffCount = 0;
+
+	for (const filePath of modified) {
+		const userFile = path.join(root, filePath);
+		const stagingFile = path.join(stagingDir, filePath);
+
+		if (!fs.existsSync(userFile)) continue;
+
+		const diff = generateDiff(userFile, stagingFile, filePath);
+		if (diff) {
+			const diffPath = path.join(diffsDir, filePath + ".diff");
+			ensureDir(path.dirname(diffPath));
+			fs.writeFileSync(diffPath, diff, "utf-8");
+			diffCount++;
+		}
+	}
+	console.log(`Written: ${diffCount} diff files`);
+
+	// Write update manifest (same format as before)
+	const updateManifest = {
+		currentVersion,
+		targetVersion,
+		added,
+		modified,
+		removed,
+	};
+	fs.writeFileSync(
+		path.join(refsDir, "update-manifest.json"),
+		JSON.stringify(updateManifest, null, "\t") + "\n",
+		"utf-8"
+	);
+	console.log("Written: references/update-manifest.json");
+
+	console.log("\nNext: Review references/changelog.md, then run classify-files.js");
+}
+
+/** Generate a unified diff between two files. Returns null if diff is unavailable. */
+function generateDiff(userFile, stagingFile, relativePath) {
+	try {
+		execFileSync("diff", ["-u", userFile, stagingFile], { encoding: "utf-8" });
+		return null; // Files are identical (exit code 0)
+	} catch (err) {
+		if (err.status === 1 && err.stdout) {
+			// Exit code 1 = files differ, stdout contains the diff
+			// Replace absolute paths with relative ones for readability
+			return err.stdout
+				.replaceAll(userFile, `a/${relativePath}`)
+				.replaceAll(stagingFile, `b/${relativePath}`);
+		}
+		// diff command not available or other error
+		return null;
+	}
+}
+
+try {
+	main();
+} catch (err) {
+	console.error("Error:", err.message);
+	process.exit(1);
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+	"name": "generatesaas",
+	"version": "0.1.0",
+	"type": "module",
+	"description": "CLI for scaffolding and managing GenerateSaaS projects",
+	"bin": {
+		"generatesaas": "./dist/index.js"
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsup",
+		"postbuild": "rm -rf dist/skill/content && mkdir -p dist/skill && cp -r src/skill/content dist/skill/content",
+		"dev": "tsup --watch",
+		"check-types": "tsc --noEmit",
+		"test": "vitest run",
+		"prepublishOnly": "pnpm run build"
+	},
+	"dependencies": {
+		"@clack/prompts": "^1.1.0",
+		"commander": "^14.0.3",
+		"picocolors": "^1.1.1",
+		"tar": "^7.5.11"
+	},
+	"devDependencies": {
+		"@repo/tsconfig": "workspace:*",
+		"tsup": "^8.5.1",
+		"typescript": "^5.9.3",
+		"vitest": "^4.1.0"
+	},
+	"engines": {
+		"node": ">=22"
+	}
+}