@cocreate/cli 1.54.2 → 1.56.1

package/src/coc.js

@@ -7,6 +7,7 @@ const execute = require("./execute");
 const addMeta = require("./addMeta");
 const { color } = require("./fonts");
 const { getConfig } = require("./getConfig");
+const fsp = require('fs').promises;
 
 // Configuration object for storing options
 let config = {};
@@ -16,140 +17,208 @@ const argv = process.argv.slice(2);
 
 // Define available command-line options
 const availableOptions = {
-	"--self": { key: "self", type: "boolean" },
-	"-s": { key: "self", type: "boolean" },
-	"--directory": { key: "directory", type: "string" },
-	"-d": { key: "directory", type: "string" },
-	"--config": { key: "config", type: "string" },
-	"-c": { key: "config", type: "string" }
+    "--self": { key: "self", type: "boolean" },
+    "-s": { key: "self", type: "boolean" },
+    "--directory": { key: "directory", type: "string" },
+    "-d": { key: "directory", type: "string" },
+    "--config": { key: "config", type: "string" },
+    "-c": { key: "config", type: "string" }
 };
 
 const options = {};
 const commandParts = [];
 for (let i = 0; i < argv.length; i++) {
-	let option = availableOptions[argv[i]];
-	if (option) {
-		if (option.type === "boolean") {
-			options[option.key] = true;
-		} else if (option.type === "string") {
-			options[option.key] = argv[i + 1];
-			argv.splice(i + 1, 1);
-		}
-	} else {
-		if (argv[i].match(/[\s'"]/)) {
-			commandParts.push(`'${argv[i].replace(/'/g, "\\'")}'`);
-		} else {
-			commandParts.push(argv[i]);
-		}
-	}
+    let option = availableOptions[argv[i]];
+    if (option) {
+        if (option.type === "boolean") {
+            options[option.key] = true;
+        } else if (option.type === "string") {
+            options[option.key] = argv[i + 1];
+            argv.splice(i + 1, 1);
+        }
+    } else {
+        if (argv[i].match(/[\s'"]/)) {
+            commandParts.push(`'${argv[i].replace(/'/g, "\\'")}'`);
+        } else {
+            commandParts.push(argv[i]);
+        }
+    }
 }
 
-command = commandParts.join(" ");
+let command = commandParts.join(" ");
 
 /**
  * Main function to execute commands across repositories.
  * @param {Object} config - The configuration object.
- * @param {Array} [repos=null] - List of repositories to process.
- * @param {string} [directory=null] - The directory path of the configuration.
+ * @param {Object} options - CLI options/flags.
  */
 async function main(config = {}, options) {
-	let directory = options["directory"] || process.cwd();
-	if (!config.repositories) {
-		let configString = options["config"];
-		if (configString) {
-			try {
-				config = JSON.parse(configString);
-				console.warn(
-					`${color.yellow}using supplied JSON configuration${color.reset}`
-				);
-			} catch (error) {
-				directory = configString;
-				config = await getConfig(directory);
-			}
-		} else {
-			config = await getConfig(directory);
-		}
-
-		if (!config.configPath) {
-			const package = await getConfig(directory, "package.json");
-			if (package.configPath) {
-				config.configPath = package.configPath;
-				const repoUrl =
-					package.repository && package.repository.url.substring(12);
-				config.repositories = [
-					{
-						path: package.configPath,
-						repo: repoUrl,
-						entry: package.main
-					}
-				];
-			} else {
-				console.error(
-					`${color.red}config file cannot be found${color.reset}`
-				);
-				process.exit(1);
-			}
-		}
-
-		directory = path.dirname(config.configPath);
-		console.warn(
-			`${color.yellow}using config ${config.configPath} ${color.reset}`
-		);
-	}
-
-	config.hideMessage = false;
-
-	// Add metadata to repositories if any are present
-	if (config.repositories && config.repositories.length) {
-		config.repositories = await addMeta(config.repositories, [], directory);
-	}
-
-	// Execute the command across repositories
-	const failed = await execute(command, config);
-
-	// Handle any failed command executions
-	if (failed && failed.length > 0) {
-		console.log(
-			color.red +
-				" **************** failures **************** " +
-				color.reset
-		);
-		for (const failure of failed) {
-			console.log(
-				color.red + `${failure.name}: ${failure.error}` + color.reset
-			);
-		}
-
-		// Prompt user to retry failed commands
-		await promptRetry(failed, config, options);
-	}
+    let directory = options["directory"] || process.cwd();
+    
+    // Check if any repository targets exist in the configuration
+    if (!config.repositories && !config.modules && !config.projects) {
+        let configString = options["config"];
+        if (configString) {
+            try {
+                config = JSON.parse(configString);
+                console.warn(
+                    `${color.yellow}using supplied JSON configuration${color.reset}`
+                );
+            } catch (error) {
+                directory = configString;
+                config = await getConfig(directory);
+            }
+        } else {
+            config = await getConfig(directory);
+        }
+
+        if (!config.configPath) {
+            const packageJson = await getConfig(directory, "package.json");
+            if (packageJson.configPath) {
+                config.configPath = packageJson.configPath;
+                const repoUrl =
+                    packageJson.repository && packageJson.repository.url.substring(12);
+                
+                // Fallback to old format if reading strictly from an old package.json pointer
+                config.repositories = [
+                    {
+                        path: packageJson.configPath,
+                        repo: repoUrl,
+                        entry: packageJson.main
+                    }
+                ];
+            } else {
+                console.warn(
+                    `${color.yellow}CoCreate.config.js not found. Generating a new one...${color.reset}`
+                );
+
+                const templatePath = path.resolve(__dirname, './config.template.js');
+                let templateConfig;
+                try {
+                    templateConfig = require(templatePath);
+                } catch (e) {
+                    console.error(`${color.red}Error loading config.template.js:`, e, color.reset);
+                    process.exit(1);
+                }
+                
+                // Customize the template with repository information from package.json
+                const currentRepoPath = '.'; // Current directory where config is generated
+                const repoUrl = packageJson.repository && packageJson.repository.url ? packageJson.repository.url.substring(packageJson.repository.url.indexOf('://') + 3) : '';
+                const projectName = packageJson.name || 'current';
+
+                // Use the new projects format for auto-generation
+                templateConfig.projects = {
+                    [projectName]: {
+                        path: currentRepoPath,
+                        repo: repoUrl,
+                        exclude: ["git"]
+                    }
+                };
+                
+                // Set initial organization_id and key from environment or placeholders
+                templateConfig.organization_id = process.env.organization_id || "YOUR_ORGANIZATION_ID";
+                templateConfig.key = process.env.key || "YOUR_API_KEY";
+                
+                // Resolve host domain if available from environment variable HOST_DOMAIN
+                if (process.env.host_domain) {
+                    templateConfig.host = templateConfig.host || { $branch: {} };
+                    templateConfig.host.$branch = templateConfig.host.$branch || {};
+                    templateConfig.host.$branch.master = `wss://${process.env.host_domain}`;
+                    templateConfig.host.$branch.dev = `wss://dev.${process.env.host_domain}`;
+                    templateConfig.host.$branch.test = `wss://test.${process.env.host_domain}`;
+                }
+
+                const newConfigPath = path.join(directory, 'CoCreate.config.js');
+                const configContent = `module.exports = ${JSON.stringify(templateConfig, null, 2)};`;
+
+                await fsp.writeFile(newConfigPath, configContent);
+
+                console.log(`${color.green}Generated CoCreate.config.js at ${newConfigPath}${color.reset}`);
+
+                // Use the newly generated template config
+                config = templateConfig;
+                config.configPath = newConfigPath; // Ensure configPath is set to the new file
+            }
+        }
+    }
+
+    directory = path.dirname(config.configPath);
+    console.warn(
+        `${color.yellow}using config ${config.configPath} ${color.reset}`
+    );
+
+    config.hideMessage = false;
+
+    // Add metadata to traditional repositories
+    if (config.repositories && config.repositories.length) {
+        config.repositories = await addMeta(config.repositories, [], directory);
+    }
+
+    // Add metadata to modules
+    if (config.modules) {
+        const moduleRepos = Object.values(config.modules).filter(r => typeof r === 'object' && r !== null && r.path);
+        if (moduleRepos.length) {
+            await addMeta(moduleRepos, [], directory);
+        }
+    }
+
+    // Add metadata to projects
+    if (config.projects) {
+        const projectRepos = Object.values(config.projects).filter(r => typeof r === 'object' && r !== null && r.path);
+        if (projectRepos.length) {
+            await addMeta(projectRepos, [], directory);
+        }
+    }
+
+    // Execute the command across targeted repositories/modules/projects
+    const failed = await execute(command, config);
+
+    // Handle any failed command executions
+    if (failed && failed.length > 0) {
+        console.log(
+            color.red +
+                "\n **************** failures **************** " +
+                color.reset
+        );
+        for (const failure of failed) {
+            console.log(
+                color.red + `${failure.name || failure.path}: ${failure.error}` + color.reset
+            );
+        }
+
+        // Prompt user to retry failed commands
+        await promptRetry(failed, config, options);
+    }
 }
 
 /**
  * Prompt the user to retry failed commands.
  * @param {Array} failed - List of failed commands.
  * @param {Object} config - Configuration object.
- * @param {string} directory - Path of the configuration directory.
+ * @param {Object} options - CLI options.
  */
 async function promptRetry(failed, config, options) {
-	const rl = readline.createInterface({
-		input: process.stdin,
-		output: process.stdout
-	});
-
-	rl.question(
-		"Do you want to retry the failed commands? (yes/no): ",
-		async (answer) => {
-			rl.close();
-			if (answer.toLowerCase() === "yes") {
-				config.repositories = failed;
-				await main(config, options);
-			} else {
-				process.exit(0);
-			}
-		}
-	);
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    rl.question(
+        "Do you want to retry the failed commands? (yes/no): ",
+        async (answer) => {
+            rl.close();
+            if (answer.toLowerCase() === "yes" || answer.toLowerCase() === "y") {
+                // Ensure we only retry the failed ones by clearing the existing modules/projects
+                config.repositories = failed;
+                delete config.modules;
+                delete config.projects;
+                await main(config, options);
+            } else {
+                process.exit(0);
+            }
+        }
+    );
 }
 
 // Call the main function with initial configuration
-main(config, options);
+main(config, options);

package/src/commands/clone.js

@@ -1,32 +1,81 @@
 const spawn = require("../spawn");
 const path = require("path");
-let fs = require("fs");
+const fs = require("fs");
 
+/**
+ * CLI-compatible clone command that resolves paths dynamically,
+ * clones missing repositories, and silently skips already cloned ones.
+ */
 module.exports = async function gitClone(repos, args) {
-	const failed = [];
-	const cwdPath = path.resolve(process.cwd());
-
-	for (let i = 0; i < repos.length; i++) {
-		// TODO: Check if path exist and if git.config or package.json  exist continue
-		if (cwdPath !== repos[i].absolutePath) {
-			if (!fs.existsSync(repos[i].directory))
-				fs.mkdirSync(repos[i].directory);
-
-			if (
-				!repos[i].repo.startsWith("http://") &&
-				!repos[i].repo.startsWith("https://")
-			)
-				repos[i].repo = "https://" + repos[i].repo;
-
-			let exitCode = await spawn("git", ["clone", `${repos[i].repo}`], {
-				stdio: "inherit",
-				cwd: repos[i].directory
-			});
-			if (exitCode !== 0) {
-				failed.push({ name: repos[i].name, error: `cloning failed` });
-			}
-		}
-	}
-
-	return failed;
-};
+    const failed = [];
+    const cwdPath = path.resolve(process.cwd());
+
+    for (let i = 0; i < repos.length; i++) {
+        const repo = repos[i];
+        if (!repo) continue;
+
+        const rawPath = repo.path || repo.absolutePath || repo.directory;
+        if (!rawPath) {
+            failed.push({ 
+                name: repo.name || `Repo #${i}`, 
+                error: "No path property defined in the configuration" 
+            });
+            continue;
+        }
+
+        repo.absolutePath = repo.absolutePath || path.resolve(cwdPath, rawPath);
+        repo.directory = repo.directory || path.dirname(repo.absolutePath);
+        repo.name = repo.name || path.basename(repo.absolutePath);
+
+        if (cwdPath === repo.absolutePath) {
+            continue;
+        }
+
+        const relativeRepoPath = path.relative(cwdPath, repo.absolutePath);
+
+        // Clean skip logging using path
+        if (fs.existsSync(repo.absolutePath)) {
+            console.log(`Already exists: ${relativeRepoPath} (Skipped)`);
+            continue;
+        }
+
+        if (!fs.existsSync(repo.directory)) {
+            try {
+                fs.mkdirSync(repo.directory, { recursive: true });
+            } catch (err) {
+                failed.push({ 
+                    name: repo.name, 
+                    error: `Failed to create directory ${repo.directory}: ${err.message}` 
+                });
+                continue;
+            }
+        }
+
+        if (!repo.repo) {
+            failed.push({ 
+                name: repo.name, 
+                error: "No git repository URL provided in config" 
+            });
+            continue;
+        }
+
+        let gitUrl = repo.repo;
+        if (!gitUrl.startsWith("http://") && !gitUrl.startsWith("https://")) {
+            gitUrl = "https://" + gitUrl;
+        }
+
+        // Clean success logging after process completes successfully
+        let exitCode = await spawn("git", ["clone", gitUrl], {
+            stdio: "inherit",
+            cwd: repo.directory
+        });
+
+        if (exitCode !== 0) {
+            failed.push({ name: repo.name, error: `cloning failed` });
+        } else {
+            console.log(`Successfully cloned: ${relativeRepoPath}`);
+        }
+    }
+
+    return failed;
+};

package/src/commands/delete.js

@@ -0,0 +1,70 @@
+const file = require("@cocreate/file");
+const path = require("path");
+const fs = require("fs");
+const { getConfig } = require("../getConfig");
+
+module.exports = async function del(directory, args) {
+	if (args && !Array.isArray(args)) args = [args];
+
+	directory = process.cwd();
+
+	// Process targets
+	if (!args || !args.length) {
+		const CoCreateConfig = await getConfig(directory);
+		if (CoCreateConfig && CoCreateConfig.configPath) {
+			const projectRoot = path.dirname(CoCreateConfig.configPath);
+			let rel = path.relative(projectRoot, process.cwd()).replace(/\\/g, '/');
+
+			// In the DB, 'src' is the root, so we must remove 'src' from the relative path
+			if (rel === 'src') {
+				rel = '';
+			} else if (rel.startsWith('src/')) {
+				rel = rel.substring(4);
+			} else if (rel === 'src') {
+				rel = '';
+			}
+
+			let target = '/' + rel.replace(/^\/+/, '');
+
+			await confirmAndDelete(CoCreateConfig, target);
+		} else {
+			console.log("Failed to read or parse CoCreate.config.js.");
+		}
+	} else {
+		// When explicit args are given, resolve config but do NOT change CWD
+		const CoCreateConfig = await getConfig(directory);
+		if (!CoCreateConfig || !CoCreateConfig.configPath) {
+			console.log("Failed to read or parse CoCreate.config.js for authentication.");
+			return;
+		}
+
+		for (let arg of args) {
+			let targetPath = String(arg).replace(/\\/g, '/');
+
+			// Normalize to DB path format
+			if (!targetPath.startsWith('/')) {
+				targetPath = '/' + targetPath.replace(/^\/+/,'');
+			}
+
+			await confirmAndDelete(CoCreateConfig, targetPath);
+		}
+	}
+
+	async function confirmAndDelete(CoCreateConfig, target) {
+		try {
+			if (typeof file.delete !== 'function') {
+				console.error('Delete not supported: @cocreate/file exposes no delete API.');
+				return;
+			}
+
+			const res = await file.delete(
+				CoCreateConfig,
+				CoCreateConfig.configPath,
+				target
+			);
+			console.log('Deleted:', (res && res.length) ? res.length : res, 'items for', target);
+		} catch (err) {
+			console.error('Delete failed for', target, err);
+		}
+	}
+};

package/src/commands/download.js

@@ -0,0 +1,72 @@
+const file = require("@cocreate/file");
+const path = require("path");
+const fs = require("fs");
+const { getConfig } = require("../getConfig");
+
+module.exports = async function download(directory, args) {
+	if (args && !Array.isArray(args)) args = [args];
+
+	directory = process.cwd();
+
+	// Process targets
+	if (!args || !args.length) {
+		const CoCreateConfig = await getConfig(directory);
+		if (CoCreateConfig && CoCreateConfig.configPath) {
+			const projectRoot = path.dirname(CoCreateConfig.configPath);
+			let rel = path.relative(projectRoot, process.cwd()).replace(/\\/g, '/');
+			
+			// In the DB, 'src' is the root, so we must remove 'src' from the relative path
+			if (rel === 'src') {
+				rel = '';
+			} else if (rel.startsWith('src/')) {
+				rel = rel.substring(4);
+			} else if (rel === 'src') {
+                rel = '';
+            }
+
+			let target = '/' + rel.replace(/^\/+/, '');
+			
+			await fetchAndWrite(CoCreateConfig, target);
+		} else {
+			console.log("Failed to read or parse CoCreate.config.js.");
+		}
+	} else {
+		// When an explicit argument is given, resolve config but do NOT change CWD
+		// so that the files are downloaded into the folder output was initiated from.
+		const CoCreateConfig = await getConfig(directory);
+		if (!CoCreateConfig || !CoCreateConfig.configPath) {
+			console.log("Failed to read or parse CoCreate.config.js for authentication.");
+			return;
+		}
+
+		for (let arg of args) {
+			let targetPath = String(arg).replace(/\\/g, '/');
+			
+			// Just use the requested string directly as the DB path
+			if (!targetPath.startsWith('/')) {
+				targetPath = '/' + targetPath.replace(/^\/+/, '');
+			}
+			
+			await fetchAndWrite(CoCreateConfig, targetPath);
+		}
+	}
+
+	async function fetchAndWrite(CoCreateConfig, target) {
+		try {
+			if (typeof file.download !== 'function') {
+				console.error('Download not supported: @cocreate/file exposes no download API.');
+				return;
+			}
+
+			const downloaded = await file.download(
+				CoCreateConfig,
+				CoCreateConfig.configPath,
+				target
+			);
+			console.log('Downloaded:', downloaded && downloaded.length ? downloaded.length : 0, 'files for', target);
+		} catch (err) {
+			console.error('Download failed for', target, err);
+		}
+	}
+};
+

package/src/commands/gitignore.js

@@ -0,0 +1,57 @@
+const path = require("path");
+const fs = require("fs");
+
+/**
+ * Updates .gitignore files across multiple repositories with descriptive path logging.
+ */
+module.exports = async function updateGitignore(repos, args) {
+    const failed = [];
+    const cwd = process.cwd();
+    const templatePath = path.join(cwd, ".gitignore");
+
+    if (!fs.existsSync(templatePath)) {
+        throw new Error(`No .gitignore template found in: ${cwd}`);
+    }
+
+    let templateContent;
+    try {
+        templateContent = fs.readFileSync(templatePath, "utf8");
+    } catch (error) {
+        throw new Error(`Failed to read the template file: ${error.message}`);
+    }
+
+    for (let i = 0; i < repos.length; i++) {
+        const repo = repos[i];
+        if (!repo) continue;
+        
+        try {
+            const rawPath = repo.absolutePath || repo.directory || repo.path;
+            if (!rawPath) continue;
+
+            const resolvedPath = path.resolve(cwd, rawPath);
+
+            if (!fs.existsSync(resolvedPath)) continue;
+            if (path.resolve(resolvedPath) === path.resolve(cwd)) continue;
+
+            const gitignorePath = path.join(resolvedPath, ".gitignore");
+
+            if (fs.existsSync(gitignorePath)) {
+                fs.unlinkSync(gitignorePath);
+            }
+
+            fs.writeFileSync(gitignorePath, templateContent, "utf8");
+            
+            // Log the clean relative path from where the command was executed
+            const relativeLogPath = path.relative(cwd, gitignorePath);
+            console.log(`Successfully updated: ${relativeLogPath}`);
+
+        } catch (error) {
+            failed.push({ 
+                name: repo.name || `Repo #${i}`, 
+                error: error.message 
+            });
+        }
+    }
+
+    return failed;
+};

package/src/commands/install.js

@@ -4,15 +4,12 @@ module.exports = async function (repos, args) {
 	let failed = [];
 	try {
 		let cloneFailed = await require("./clone.js")(repos, args);
-		if (cloneFailed) failed.push(cloneFailed);
+		if (cloneFailed && cloneFailed.length) failed.push(...cloneFailed);
 
 		repos = await addMeta(repos, failed);
 
-		let symlinkFailed = await require("./symlink.js")(repos, args);
-		if (symlinkFailed) failed.push(symlinkFailed);
-
 		let linkFailed = await require("./link.js")(repos, args);
-		if (linkFailed) failed.push(linkFailed);
+		if (linkFailed && linkFailed.length) failed.push(...linkFailed);
 	} catch (err) {
 		console.error(err);
 		failed.push({ name: "general", error: err.message });