@getjack/jack 0.1.0 → 0.1.1

package/src/commands/projects.ts

@@ -1,19 +1,14 @@
-import { existsSync } from "node:fs";
 import { dirname } from "node:path";
-import { confirm } from "@inquirer/prompts";
-import { checkWorkerExists } from "../lib/cloudflare-api.ts";
+import { select } from "@inquirer/prompts";
 import { error, info, item, output as outputSpinner, success, warn } from "../lib/output.ts";
-import { getAllProjects, getProject, removeProject } from "../lib/registry.ts";
-import { getProjectNameFromDir, getRemoteManifest } from "../lib/storage/index.ts";
-
-interface ProjectStatus {
-	name: string;
-	localPath: string | null;
-	local: boolean;
-	deployed: boolean;
-	backedUp: boolean;
-	missing: boolean;
-}
+import {
+	cleanupStaleProjects,
+	getProjectStatus,
+	listAllProjects,
+	scanStaleProjects,
+	type ProjectStatus,
+} from "../lib/project-operations.ts";
+import { getProjectNameFromDir } from "../lib/storage/index.ts";
 
 /**
  * Main projects command - handles all project management
@@ -46,47 +41,17 @@ async function listProjects(args: string[]): Promise<void> {
 		cloud: args.includes("--cloud"),
 	};
 
-	const projects = await getAllProjects();
-	const projectNames = Object.keys(projects);
+	// Determine status for each project (with spinner for API calls)
+	outputSpinner.start("Checking project status...");
+	const statuses: ProjectStatus[] = await listAllProjects();
+	outputSpinner.stop();
 
-	if (projectNames.length === 0) {
+	if (statuses.length === 0) {
 		info("No projects found");
 		info("Create a project with: jack new <name>");
 		return;
 	}
 
-	// Determine status for each project
-	const statuses: ProjectStatus[] = [];
-
-	for (const name of projectNames) {
-		const project = projects[name];
-		if (!project) continue;
-
-		const local = project.localPath ? existsSync(project.localPath) : false;
-		const missing = project.localPath ? !local : false;
-
-		// Check if deployed
-		let deployed = false;
-		if (project.workerUrl) {
-			deployed = true;
-		} else {
-			deployed = await checkWorkerExists(name);
-		}
-
-		// Check if backed up
-		const manifest = await getRemoteManifest(name);
-		const backedUp = manifest !== null;
-
-		statuses.push({
-			name,
-			localPath: project.localPath,
-			local,
-			deployed,
-			backedUp,
-			missing,
-		});
-	}
-
 	// Filter based on flags
 	let filteredStatuses = statuses;
 	if (flags.local) {
@@ -112,9 +77,13 @@ async function listProjects(args: string[]): Promise<void> {
 
 	const groups = new Map<string, DirectoryGroup>();
 	const ungrouped: ProjectStatus[] = [];
+	const stale: ProjectStatus[] = [];
 
 	for (const status of filteredStatuses) {
-		if (status.localPath) {
+		// Stale projects go to their own section
+		if (status.missing) {
+			stale.push(status);
+		} else if (status.localPath && status.local) {
 			const parent = dirname(status.localPath);
 			if (!groups.has(parent)) {
 				groups.set(parent, { path: parent, projects: [] });
@@ -130,9 +99,9 @@ async function listProjects(args: string[]): Promise<void> {
 	info("Projects");
 	console.error("");
 
-	// Display directory groups
+	// Display directory groups (active local projects)
 	for (const [_parentPath, group] of groups) {
-		console.error(`${group.path}/`);
+		console.error(`${colors.dim}${group.path}/${colors.reset}`);
 		const sortedProjects = group.projects.sort((a, b) => a.name.localeCompare(b.name));
 
 		for (let i = 0; i < sortedProjects.length; i++) {
@@ -142,14 +111,14 @@ async function listProjects(args: string[]): Promise<void> {
 			const prefix = isLast ? "└──" : "├──";
 
 			const badges = buildStatusBadges(proj);
-			console.error(`  ${prefix} ${proj.name}  ${badges}`);
+			console.error(`  ${colors.dim}${prefix}${colors.reset} ${proj.name}  ${badges}`);
 		}
 		console.error("");
 	}
 
-	// Display ungrouped projects
+	// Display ungrouped projects (cloud-only, no local path)
 	if (ungrouped.length > 0) {
-		console.error("Other:");
+		console.error(`${colors.dim}Cloud only:${colors.reset}`);
 		for (const proj of ungrouped) {
 			const badges = buildStatusBadges(proj);
 			console.error(`  ${proj.name}  ${badges}`);
@@ -157,15 +126,48 @@ async function listProjects(args: string[]): Promise<void> {
 		console.error("");
 	}
 
+	// Display stale projects (local folder deleted)
+	if (stale.length > 0) {
+		console.error(`${colors.yellow}Stale (local folder deleted):${colors.reset}`);
+		for (const proj of stale) {
+			// Only show non-missing badges since the section header explains the issue
+			const badges = buildStatusBadges({ ...proj, missing: false });
+			console.error(`  ${colors.dim}${proj.name}${colors.reset}  ${badges}`);
+		}
+		console.error("");
+	}
+
 	// Summary
-	const localCount = statuses.filter((s) => s.local).length;
 	const deployedCount = statuses.filter((s) => s.deployed).length;
-	const localOnlyCount = statuses.filter((s) => s.local && !s.deployed).length;
+	const notDeployedCount = statuses.filter((s) => s.local && !s.deployed).length;
+	const staleCount = statuses.filter((s) => s.missing).length;
 
-	info(`${statuses.length} projects (${deployedCount} deployed, ${localOnlyCount} local-only)`);
+	const parts = [`${deployedCount} deployed`];
+	if (notDeployedCount > 0) {
+		parts.push(`${notDeployedCount} not deployed`);
+	}
+	if (staleCount > 0) {
+		parts.push(`${staleCount} stale`);
+	}
+	info(`${statuses.length} projects (${parts.join(", ")})`);
+	if (staleCount > 0) {
+		console.error(
+			`  ${colors.dim}Run 'jack projects cleanup' to remove stale entries${colors.reset}`,
+		);
+	}
 	console.error("");
 }
 
+// Color codes
+const colors = {
+	reset: "\x1b[0m",
+	dim: "\x1b[90m",
+	green: "\x1b[32m",
+	yellow: "\x1b[33m",
+	red: "\x1b[31m",
+	cyan: "\x1b[36m",
+};
+
 /**
  * Build status badge string for a project
  */
@@ -173,16 +175,16 @@ function buildStatusBadges(status: ProjectStatus): string {
 	const badges: string[] = [];
 
 	if (status.local) {
-		badges.push("[local]");
+		badges.push(`${colors.green}[local]${colors.reset}`);
 	}
 	if (status.deployed) {
-		badges.push("[deployed]");
+		badges.push(`${colors.green}[deployed]${colors.reset}`);
 	}
 	if (status.backedUp) {
-		badges.push("[backed-up]");
+		badges.push(`${colors.dim}[cloud]${colors.reset}`);
 	}
 	if (status.missing) {
-		badges.push("[missing]");
+		badges.push(`${colors.yellow}[local deleted]${colors.reset}`);
 	}
 
 	return badges.join(" ");
@@ -206,36 +208,33 @@ async function infoProject(args: string[]): Promise<void> {
 		}
 	}
 
-	const project = await getProject(name);
+	// Check actual status (with spinner for API calls)
+	outputSpinner.start("Fetching project info...");
+	const status = await getProjectStatus(name);
+	outputSpinner.stop();
 
-	if (!project) {
+	if (!status) {
 		error(`Project "${name}" not found in registry`);
 		info("List projects with: jack projects list");
 		process.exit(1);
 	}
 
-	// Check actual status
-	const localExists = project.localPath ? existsSync(project.localPath) : false;
-	const workerExists = await checkWorkerExists(name);
-	const manifest = await getRemoteManifest(name);
-	const backedUp = manifest !== null;
-
 	console.error("");
-	info(`Project: ${name}`);
+	info(`Project: ${status.name}`);
 	console.error("");
 
 	// Status section
 	const statuses: string[] = [];
-	if (localExists) {
+	if (status.local) {
 		statuses.push("local");
 	}
-	if (workerExists || project.workerUrl) {
+	if (status.deployed) {
 		statuses.push("deployed");
 	}
-	if (backedUp) {
+	if (status.backedUp) {
 		statuses.push("backed-up");
 	}
-	if (project.localPath && !localExists) {
+	if (status.missing) {
 		statuses.push("missing");
 	}
 
@@ -243,48 +242,53 @@ async function infoProject(args: string[]): Promise<void> {
 	console.error("");
 
 	// Local info
-	if (project.localPath) {
-		item(`Local path: ${project.localPath}`);
-		if (!localExists) {
+	if (status.localPath) {
+		item(`Local path: ${status.localPath}`);
+		if (status.missing) {
 			warn("  Path no longer exists");
 		}
 		console.error("");
 	}
 
 	// Deployment info
-	if (project.workerUrl) {
-		item(`Worker URL: ${project.workerUrl}`);
+	if (status.workerUrl) {
+		item(`Worker URL: ${status.workerUrl}`);
 	}
-	if (project.lastDeployed) {
-		item(`Last deployed: ${new Date(project.lastDeployed).toLocaleString()}`);
+	if (status.lastDeployed) {
+		item(`Last deployed: ${new Date(status.lastDeployed).toLocaleString()}`);
 	}
-	if (workerExists || project.workerUrl) {
+	if (status.deployed) {
 		console.error("");
 	}
 
 	// Cloud info
-	if (backedUp && manifest) {
-		item(`Cloud backup: ${manifest.files.length} files`);
-		item(`Last synced: ${new Date(manifest.lastSync).toLocaleString()}`);
+	if (status.backedUp && status.backupFiles !== null) {
+		item(`Cloud backup: ${status.backupFiles} files`);
+		if (status.backupLastSync) {
+			item(`Last synced: ${new Date(status.backupLastSync).toLocaleString()}`);
+		}
 		console.error("");
 	}
 
-	// Cloudflare info
-	item(`Account ID: ${project.cloudflare.accountId}`);
-	item(`Worker ID: ${project.cloudflare.workerId}`);
+	// Account info
+	if (status.accountId) {
+		item(`Account ID: ${status.accountId}`);
+	}
+	if (status.workerId) {
+		item(`Worker ID: ${status.workerId}`);
+	}
 	console.error("");
 
 	// Resources
-	if (project.resources.d1Databases.length > 0) {
-		item("D1 Databases:");
-		for (const db of project.resources.d1Databases) {
-			item(`  - ${db}`);
-		}
+	if (status.dbName) {
+		item(`Database: ${status.dbName}`);
 		console.error("");
 	}
 
 	// Timestamps
-	item(`Created: ${new Date(project.createdAt).toLocaleString()}`);
+	if (status.createdAt) {
+		item(`Created: ${new Date(status.createdAt).toLocaleString()}`);
+	}
 	console.error("");
 }
 
@@ -294,78 +298,70 @@ async function infoProject(args: string[]): Promise<void> {
 async function cleanupProjects(): Promise<void> {
 	outputSpinner.start("Scanning for stale projects...");
 
-	const projects = await getAllProjects();
-	const projectNames = Object.keys(projects);
-
-	if (projectNames.length === 0) {
+	const scan = await scanStaleProjects();
+	if (scan.total === 0) {
 		outputSpinner.stop();
 		info("No projects to clean up");
 		return;
 	}
 
-	interface StaleProject {
-		name: string;
-		reason: string;
-	}
-
-	const staleProjects: StaleProject[] = [];
-
-	// Check each project for issues
-	for (const name of projectNames) {
-		const project = projects[name];
-		if (!project) continue;
-
-		// Check if local path is missing
-		if (project.localPath && !existsSync(project.localPath)) {
-			staleProjects.push({
-				name,
-				reason: "Local path missing",
-			});
-			continue;
-		}
-
-		// Check if worker was deleted
-		const workerExists = await checkWorkerExists(name);
-		if (project.workerUrl && !workerExists) {
-			staleProjects.push({
-				name,
-				reason: "Worker deleted from Cloudflare",
-			});
-		}
-	}
-
 	outputSpinner.stop();
 
-	if (staleProjects.length === 0) {
+	if (scan.stale.length === 0) {
 		success("No stale projects found");
 		return;
 	}
 
-	// Show found issues
+	// Explain what cleanup does
 	console.error("");
-	warn(`Found ${staleProjects.length} stale project(s):`);
+	info("What cleanup does:");
+	item("Removes entries from jack's local tracking registry");
+	item("Does NOT undeploy live services");
+	item("Does NOT delete cloud backups or databases");
 	console.error("");
 
-	for (const stale of staleProjects) {
-		item(`${stale.name}: ${stale.reason}`);
+	// Show found issues
+	warn(`Found ${scan.stale.length} stale project(s):`);
+	console.error("");
+
+	// Check which have deployed workers
+	const deployedStale = scan.stale.filter((stale) => stale.workerUrl);
+
+	for (const stale of scan.stale) {
+		const hasWorker = stale.workerUrl
+			? ` ${colors.yellow}(still deployed)${colors.reset}`
+			: "";
+		item(`${stale.name}: ${stale.reason}${hasWorker}`);
 	}
 	console.error("");
 
+	if (deployedStale.length > 0) {
+		warn(`${deployedStale.length} project(s) are still deployed`);
+		info("To fully remove, run 'jack down <name>' first");
+		console.error("");
+	}
+
 	// Prompt to remove
-	const shouldRemove = await confirm({
-		message: "Remove these entries from registry?",
-		default: false,
+	console.error("  Esc to skip\n");
+	const action = await select({
+		message: "Remove these from jack's tracking? (deployed services stay live)",
+		choices: [
+			{ name: "1. Yes", value: "yes" },
+			{ name: "2. No", value: "no" },
+		],
 	});
 
-	if (!shouldRemove) {
+	if (action === "no") {
 		info("Cleanup cancelled");
 		return;
 	}
 
 	// Remove stale entries
-	for (const stale of staleProjects) {
-		await removeProject(stale.name);
-	}
+	await cleanupStaleProjects(scan.stale.map((stale) => stale.name));
 
-	success(`Removed ${staleProjects.length} stale project(s)`);
+	console.error("");
+	success(`Removed ${scan.stale.length} entry/entries from jack's registry`);
+	if (deployedStale.length > 0) {
+		info("Note: Deployed services are still live");
+	}
 }