generatesaas 0.7.1 → 0.8.1

package/dist/skill/content/scripts/classify-files.js

@@ -2,13 +2,168 @@
 
 /**
  * Classify project files for update.
- * Compares local file hashes against the manifest to determine which files
- * the user has customized and which are safe to auto-update.
+ * Compares local file hashes against the TEMPLATE hashes (not project hashes)
+ * to determine which files the user has customized and which are safe to auto-update.
+ * Also scans imports to detect cross-dependencies between categories.
  */
 
 const fs = require("node:fs");
 const path = require("node:path");
-const { findProjectRoot, hashFile, HASHES_FILE } = require("./_helpers.js");
+const { findProjectRoot, hashFile, TEMPLATE_HASHES_FILE, HASHES_FILE, STAGING_DIR } = require("./_helpers.js");
+
+// ── Import Scanning ──
+
+/**
+ * Extract local import paths from file content.
+ * Only captures relative (./, ../), alias (~/, @/), and # imports — skips packages.
+ */
+function extractImports(content, filePath) {
+	// For Vue SFCs, extract all script block contents (both <script> and <script setup>)
+	if (filePath.endsWith(".vue")) {
+		const blocks = [...content.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)];
+		content = blocks.map((m) => m[1]).join("\n");
+	}
+
+	const imports = new Set();
+
+	const patterns = [
+		/(?:import|export)\s[\s\S]*?from\s+['"]([^'"]+)['"]/g,
+		/(?:require|import)\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+	];
+
+	for (const pattern of patterns) {
+		let m;
+		while ((m = pattern.exec(content)) !== null) {
+			const p = m[1];
+			if (p.startsWith(".") || p.startsWith("~/") || p.startsWith("@/") || p.startsWith("#")) {
+				imports.add(p);
+			}
+		}
+	}
+
+	return [...imports];
+}
+
+/**
+ * Try to match an import specifier to a file path in the known set.
+ * Returns the matched path or null.
+ */
+function matchImportToFile(importPath, fromFilePath, knownFileSet) {
+	let basePath;
+
+	if (importPath.startsWith("./") || importPath.startsWith("../")) {
+		basePath = path.normalize(path.join(path.dirname(fromFilePath), importPath));
+	} else if (importPath.startsWith("~/") || importPath.startsWith("@/") || importPath.startsWith("#")) {
+		// Alias — strip prefix. ~ and @ typically resolve from the app root.
+		basePath = importPath.replace(/^[~@#]\//, "");
+	} else {
+		return null;
+	}
+
+	// Normalize separators and strip leading ./
+	basePath = basePath.split(path.sep).join("/");
+	if (basePath.startsWith("./")) basePath = basePath.slice(2);
+
+	const extensions = ["", ".ts", ".js", ".vue", ".tsx", ".jsx", "/index.ts", "/index.js", "/index.vue"];
+	for (const ext of extensions) {
+		const candidate = basePath + ext;
+		if (knownFileSet.has(candidate)) return candidate;
+	}
+
+	// For alias imports, also try matching as a suffix of known files
+	if (!importPath.startsWith("./") && !importPath.startsWith("../")) {
+		const suffix = "/" + basePath;
+		for (const ext of extensions) {
+			const needle = suffix + ext;
+			for (const known of knownFileSet) {
+				if (known.endsWith(needle)) return known;
+			}
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Scan files for imports and build cross-dependency map between categories.
+ */
+function buildCrossDependencies(root, classification, stagingDir) {
+	const unmodifiedSet = new Set(classification.unmodified);
+	const modifiedSet = new Set(classification.modified);
+
+	// All files involved in the update
+	const allUpdateFiles = new Set([
+		...classification.unmodified,
+		...classification.modified,
+		...classification.new,
+		...classification.deleted,
+		...classification.removed,
+	]);
+
+	const crossDeps = {
+		modifiedImportsUnmodified: {},
+		unmodifiedImportsModified: {},
+		newImportsModified: {},
+	};
+
+	function addDep(bucket, key, value) {
+		if (!bucket[key]) bucket[key] = [];
+		if (!bucket[key].includes(value)) bucket[key].push(value);
+	}
+
+	function scanFileContent(filePath, content, sourceCategory) {
+		const imports = extractImports(content, filePath);
+		for (const imp of imports) {
+			const resolved = matchImportToFile(imp, filePath, allUpdateFiles);
+			if (!resolved) continue;
+
+			if (sourceCategory === "modified" && unmodifiedSet.has(resolved)) {
+				addDep(crossDeps.modifiedImportsUnmodified, filePath, resolved);
+			}
+			if (sourceCategory === "unmodified" && modifiedSet.has(resolved)) {
+				addDep(crossDeps.unmodifiedImportsModified, filePath, resolved);
+			}
+			if (sourceCategory === "new" && modifiedSet.has(resolved)) {
+				addDep(crossDeps.newImportsModified, filePath, resolved);
+			}
+		}
+	}
+
+	function readSafe(fullPath) {
+		try { return fs.readFileSync(fullPath, "utf-8"); } catch { return null; }
+	}
+
+	// Scan modified files (user's current versions)
+	for (const f of classification.modified) {
+		const content = readSafe(path.join(root, f));
+		if (content) scanFileContent(f, content, "modified");
+	}
+
+	// Scan unmodified files — both current AND staging versions
+	// (staging is what will actually be placed, so its imports matter)
+	for (const f of classification.unmodified) {
+		const content = readSafe(path.join(root, f));
+		if (content) scanFileContent(f, content, "unmodified");
+
+		const stagingContent = readSafe(path.join(stagingDir, f));
+		if (stagingContent) scanFileContent(f, stagingContent, "unmodified");
+	}
+
+	// Scan new files from staging
+	for (const f of classification.new) {
+		const stagingContent = readSafe(path.join(stagingDir, f));
+		if (stagingContent) scanFileContent(f, stagingContent, "new");
+	}
+
+	// Remove empty entries
+	for (const key of Object.keys(crossDeps)) {
+		if (Object.keys(crossDeps[key]).length === 0) delete crossDeps[key];
+	}
+
+	return Object.keys(crossDeps).length > 0 ? crossDeps : undefined;
+}
+
+// ── Main ──
 
 function main() {
 	const root = findProjectRoot();
@@ -17,7 +172,6 @@ function main() {
 		process.exit(1);
 	}
 
-	// Determine the skill root
 	const scriptDir = __dirname;
 	const skillDir = path.dirname(scriptDir);
 	const refsDir = path.join(skillDir, "references");
@@ -29,10 +183,28 @@ function main() {
 	}
 
 	const updateManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+
+	// Use template hashes (what the template looked like) for classification.
+	// This correctly detects user modifications even after previous merges,
+	// because merged files differ from the template while unmodified files match it.
+	// Falls back to project hashes for backward compatibility.
+	const templateHashesPath = path.join(root, TEMPLATE_HASHES_FILE);
 	const hashesPath = path.join(root, HASHES_FILE);
-	const fileHashes = fs.existsSync(hashesPath)
-		? JSON.parse(fs.readFileSync(hashesPath, "utf-8"))
-		: {};
+
+	let baselineHashes;
+	let hashSource;
+	if (fs.existsSync(templateHashesPath)) {
+		baselineHashes = JSON.parse(fs.readFileSync(templateHashesPath, "utf-8"));
+		hashSource = "template-hashes.json";
+	} else if (fs.existsSync(hashesPath)) {
+		baselineHashes = JSON.parse(fs.readFileSync(hashesPath, "utf-8"));
+		hashSource = "hashes.json (fallback)";
+	} else {
+		baselineHashes = {};
+		hashSource = "none (treating all as modified)";
+	}
+
+	console.log(`Using ${hashSource} for classification baseline.`);
 
 	const classification = {
 		targetVersion: updateManifest.targetVersion,
@@ -46,21 +218,20 @@ function main() {
 	// Classify modified files (upstream changed, check if user also changed)
 	for (const filePath of updateManifest.modified) {
 		const fullPath = path.join(root, filePath);
-		const originalHash = fileHashes[filePath];
+		const baselineHash = baselineHashes[filePath];
 
 		if (!fs.existsSync(fullPath)) {
-			// User deleted this file
 			classification.deleted.push(filePath);
-		} else if (!originalHash) {
-			// No original hash — treat as modified to be safe
+		} else if (!baselineHash) {
+			// No baseline hash — treat as modified to be safe
 			classification.modified.push(filePath);
 		} else {
 			const currentHash = hashFile(fullPath);
-			if (currentHash === originalHash) {
-				// File unchanged by user — safe to auto-update
+			if (currentHash === baselineHash) {
+				// File matches the original template — safe to auto-update
 				classification.unmodified.push(filePath);
 			} else {
-				// User has customized this file — needs manual merge
+				// File differs from template — user has customized
 				classification.modified.push(filePath);
 			}
 		}
@@ -70,7 +241,6 @@ function main() {
 	for (const filePath of updateManifest.added) {
 		const fullPath = path.join(root, filePath);
 		if (fs.existsSync(fullPath)) {
-			// File already exists locally — treat as modified for safety
 			classification.modified.push(filePath);
 		} else {
 			classification.new.push(filePath);
@@ -83,7 +253,13 @@ function main() {
 		if (fs.existsSync(fullPath)) {
 			classification.removed.push(filePath);
 		}
-		// If already gone locally, nothing to do
+	}
+
+	// Scan for cross-category dependencies
+	const stagingDir = path.join(root, STAGING_DIR);
+	const crossDeps = buildCrossDependencies(root, classification, stagingDir);
+	if (crossDeps) {
+		classification.crossDependencies = crossDeps;
 	}
 
 	// Write classification
@@ -94,6 +270,7 @@ function main() {
 	);
 
 	// Print summary
+	console.log("");
 	console.log("File Classification Summary");
 	console.log("===========================");
 	console.log(`Target version: ${classification.targetVersion}`);
@@ -120,7 +297,31 @@ function main() {
 		console.log("");
 	}
 
-	console.log("Next: Run apply-auto.js to update safe files, then manually merge modified files.");
+	if (crossDeps) {
+		if (crossDeps.modifiedImportsUnmodified) {
+			console.log("Cross-dependencies: modified files import from unmodified (auto-apply) files:");
+			for (const [mod, deps] of Object.entries(crossDeps.modifiedImportsUnmodified)) {
+				console.log(`  ${mod} imports: ${deps.join(", ")}`);
+			}
+			console.log("");
+		}
+		if (crossDeps.unmodifiedImportsModified) {
+			console.log("Cross-dependencies: unmodified (auto-apply) files import from modified files:");
+			for (const [unmod, deps] of Object.entries(crossDeps.unmodifiedImportsModified)) {
+				console.log(`  ${unmod} imports: ${deps.join(", ")}`);
+			}
+			console.log("");
+		}
+		if (crossDeps.newImportsModified) {
+			console.log("Cross-dependencies: new files import from modified files:");
+			for (const [newFile, deps] of Object.entries(crossDeps.newImportsModified)) {
+				console.log(`  ${newFile} imports: ${deps.join(", ")}`);
+			}
+			console.log("");
+		}
+	}
+
+	console.log("Next: Review classification and cross-dependencies, then generate the update plan.");
 }
 
 try {

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

@@ -2,13 +2,18 @@
 
 /**
  * Complete the update process.
- * Re-hashes all project files, updates template hashes from staging,
- * updates .generatesaas/manifest.json, and cleans up staging + references.
+ * Updates the stored template directory from staging, re-hashes all project
+ * files, derives template-hashes.json from the template directory, updates
+ * .generatesaas/manifest.json, and cleans up staging + references.
+ *
+ * Reads .generatesaas/held-back.json (if present) to skip updating template
+ * files that were held back — their old template version is preserved so the
+ * next update generates correct diffs that include the missed changes.
  */
 
 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 { findProjectRoot, hashFile, walkDir, ensureDir, MANIFEST_FILE, HASHES_FILE, TEMPLATE_HASHES_FILE, TEMPLATE_DIR, STAGING_DIR, STAGING_META_FILE, INTERNAL_DIR } = require("./_helpers.js");
 
 const HASH_EXCLUSIONS = new Set([
 	".git", "node_modules", ".pnpm-store", ".env", ".env.test",
@@ -56,7 +61,6 @@ function main() {
 		process.exit(1);
 	}
 
-	// Determine the skill root
 	const scriptDir = __dirname;
 	const skillDir = path.dirname(scriptDir);
 	const refsDir = path.join(skillDir, "references");
@@ -72,16 +76,65 @@ function main() {
 
 	console.log(`Completing update to version ${targetVersion}...`);
 
-	// Compute and write new template hashes from staging BEFORE cleanup
+	// Read held-back files list (created by the AI for skipped/held-back files)
+	const heldBackPath = path.join(root, INTERNAL_DIR, "held-back.json");
+	const heldBack = new Set(
+		fs.existsSync(heldBackPath)
+			? JSON.parse(fs.readFileSync(heldBackPath, "utf-8"))
+			: []
+	);
+
+	if (heldBack.size > 0) {
+		console.log(`${heldBack.size} files were held back — preserving their old template versions.`);
+	}
+
+	// ── Update template directory from staging ──
 	const stagingDir = path.join(root, STAGING_DIR);
+	const templateDir = path.join(root, TEMPLATE_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));
+		console.log("Updating template directory from staging...");
+		const stagingFiles = new Set(walkDir(stagingDir, stagingDir));
+
+		// Copy staging files to template dir (skip held-back — old version stays)
+		let copied = 0;
+		let skipped = 0;
+		for (const rel of stagingFiles) {
+			if (heldBack.has(rel)) {
+				skipped++;
+				continue;
+			}
+			const src = path.join(stagingDir, rel);
+			const dest = path.join(templateDir, rel);
+			ensureDir(path.dirname(dest));
+			fs.copyFileSync(src, dest);
+			copied++;
+		}
+		console.log(`  Copied ${copied} files to template dir (${skipped} held back).`);
+
+		// Remove files from template dir that were removed upstream
+		if (fs.existsSync(templateDir)) {
+			const templateFiles = walkDir(templateDir, templateDir);
+			let removed = 0;
+			for (const rel of templateFiles) {
+				if (!stagingFiles.has(rel) && !heldBack.has(rel)) {
+					fs.rmSync(path.join(templateDir, rel));
+					removed++;
+				}
+			}
+			if (removed > 0) {
+				console.log(`  Removed ${removed} files no longer in template.`);
+			}
 		}
+
+		// Derive template-hashes.json from the template directory (source of truth)
+		console.log("Computing template hashes from template directory...");
 		const templateHashesPath = path.join(root, TEMPLATE_HASHES_FILE);
+		const allTemplateFiles = walkDir(templateDir, templateDir);
+		const templateHashes = {};
+		for (const rel of allTemplateFiles.sort()) {
+			templateHashes[rel] = hashFile(path.join(templateDir, rel));
+		}
 		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}`);
@@ -90,13 +143,18 @@ function main() {
 	// Clean up staging
 	if (fs.existsSync(stagingDir)) {
 		fs.rmSync(stagingDir, { recursive: true, force: true });
-		console.log("Cleaned up staging directory");
+		console.log("Cleaned up staging directory.");
 	}
 	const metaPath = path.join(root, STAGING_META_FILE);
 	if (fs.existsSync(metaPath)) {
 		fs.rmSync(metaPath);
 	}
 
+	// Clean up held-back file
+	if (fs.existsSync(heldBackPath)) {
+		fs.rmSync(heldBackPath);
+	}
+
 	// Clean up references BEFORE hashing to avoid tracking temp files
 	if (fs.existsSync(refsDir)) {
 		fs.rmSync(refsDir, { recursive: true, force: true });

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

@@ -9,7 +9,7 @@
 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");
+const { findProjectRoot, ensureDir, hashFile, walkDir, TEMPLATE_HASHES_FILE, TEMPLATE_DIR, STAGING_DIR, STAGING_META_FILE } = require("./_helpers.js");
 
 function main() {
 	const root = findProjectRoot();
@@ -91,17 +91,30 @@ function main() {
 	}
 
 	// Generate and write diffs for modified files
+	// Uses stored template files when available for pure upstream diffs (old template → new template).
+	// Falls back to user file → staging if no stored template exists (backward compat).
 	const diffsDir = path.join(refsDir, "diffs");
 	ensureDir(diffsDir);
 	let diffCount = 0;
 
+	const templateDir = path.join(root, TEMPLATE_DIR);
+
 	for (const filePath of [...modified, ...added]) {
-		const userFile = path.join(root, filePath);
 		const stagingFile = path.join(stagingDir, filePath);
+		const templateFile = path.join(templateDir, filePath);
+		const userFile = path.join(root, filePath);
 
-		if (!fs.existsSync(userFile)) continue;
+		if (!fs.existsSync(stagingFile)) continue;
+
+		let diff;
+		if (fs.existsSync(templateFile)) {
+			// Three-way capable: diff old template vs new template (pure upstream changes)
+			diff = generateDiff(templateFile, stagingFile, filePath);
+		} else if (fs.existsSync(userFile)) {
+			// Fallback: diff user file vs staging (old behavior)
+			diff = generateDiff(userFile, stagingFile, filePath);
+		}
 
-		const diff = generateDiff(userFile, stagingFile, filePath);
 		if (diff) {
 			const diffPath = path.join(diffsDir, filePath + ".diff");
 			ensureDir(path.dirname(diffPath));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "generatesaas",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "type": "module",
   "description": "CLI for scaffolding and managing GenerateSaaS projects",
   "bin": {