@getjack/jack 0.1.3 → 0.1.5

package/src/commands/projects.ts

@@ -1,8 +1,23 @@
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, resolve } from "node:path";
+import { resolve } from "node:path";
 import { promptSelect } from "../lib/hooks.ts";
 import { error, info, item, output as outputSpinner, success, warn } from "../lib/output.ts";
+import {
+	type ProjectListItem,
+	STATUS_ICONS,
+	buildTagColorMap,
+	colors,
+	filterByStatus,
+	filterByTag,
+	formatCloudSection,
+	formatErrorSection,
+	formatLocalSection,
+	formatTagsInline,
+	groupProjects,
+	sortByUpdated,
+	toListItems,
+} from "../lib/project-list.ts";
 import {
 	cleanupStaleProjects,
 	getProjectStatus,
@@ -51,133 +66,177 @@ export default async function projects(subcommand?: string, args: string[] = [])
 	}
 }
 
+/**
+ * Extract a flag value from args (e.g., --status live -> "live")
+ */
+function extractFlagValue(args: string[], flag: string): string | null {
+	const idx = args.indexOf(flag);
+	if (idx !== -1 && idx + 1 < args.length) {
+		return args[idx + 1] ?? null;
+	}
+	return null;
+}
+
+/**
+ * Extract multiple flag values from args (e.g., --tag api --tag prod -> ["api", "prod"])
+ */
+function extractFlagValues(args: string[], flag: string): string[] {
+	const values: string[] = [];
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] === flag && i + 1 < args.length) {
+			const value = args[i + 1];
+			if (value) values.push(value);
+		}
+	}
+	return values;
+}
+
 /**
  * List all projects with status indicators
  */
-async function listProjects(_args: string[]): Promise<void> {
+async function listProjects(args: string[]): Promise<void> {
+	// Parse flags
+	const showAll = args.includes("--all") || args.includes("-a");
+	const statusFilter = extractFlagValue(args, "--status");
+	const tagFilters = extractFlagValues(args, "--tag");
+	const jsonOutput = args.includes("--json");
+	const localOnly = args.includes("--local");
+	const cloudOnly = args.includes("--cloud");
+
 	// Fetch all projects from registry and control plane
 	outputSpinner.start("Checking project status...");
 	const projects: ResolvedProject[] = await listAllProjects();
 	outputSpinner.stop();
 
-	if (projects.length === 0) {
-		info("No projects found");
-		info("Create a project with: jack new <name>");
-		return;
-	}
+	// Convert to list items
+	let items = toListItems(projects);
 
-	// Separate local projects from cloud-only projects
-	const localProjects: ResolvedProject[] = [];
-	const cloudOnlyProjects: ResolvedProject[] = [];
+	// Apply filters
+	if (statusFilter) items = filterByStatus(items, statusFilter);
+	if (localOnly) items = items.filter((i) => i.isLocal);
+	if (cloudOnly) items = items.filter((i) => i.isCloudOnly);
+	if (tagFilters.length > 0) items = filterByTag(items, tagFilters);
 
-	for (const proj of projects) {
-		if (proj.localPath && proj.sources.filesystem) {
-			localProjects.push(proj);
+	// Handle empty state
+	if (items.length === 0) {
+		if (jsonOutput) {
+			console.log("[]");
+			return;
+		}
+		info("No projects found");
+		if (statusFilter || localOnly || cloudOnly || tagFilters.length > 0) {
+			info("Try removing filters to see all projects");
 		} else {
-			cloudOnlyProjects.push(proj);
+			info("Create a project with: jack new <name>");
 		}
+		return;
 	}
 
-	// Group local projects by parent directory
-	interface DirectoryGroup {
-		displayPath: string;
-		projects: ResolvedProject[];
+	// JSON output to stdout (pipeable)
+	if (jsonOutput) {
+		console.log(JSON.stringify(items, null, 2));
+		return;
 	}
 
-	const groups = new Map<string, DirectoryGroup>();
-	const home = homedir();
-
-	for (const proj of localProjects) {
-		if (!proj.localPath) continue;
-		const parent = dirname(proj.localPath);
-		if (!groups.has(parent)) {
-			// Replace home directory with ~ for display
-			const displayPath = parent.startsWith(home) ? `~${parent.slice(home.length)}` : parent;
-			groups.set(parent, { displayPath, projects: [] });
-		}
-		groups.get(parent)?.projects.push(proj);
+	// Flat table for --all mode
+	if (showAll) {
+		renderFlatTable(items);
+		return;
 	}
 
-	// Display header
-	console.error("");
-	info("Your projects");
-	console.error("");
+	// Default: grouped view
+	renderGroupedView(items);
+}
 
-	// Display local project groups
-	for (const [_parentPath, group] of groups) {
-		console.error(`  ${colors.dim}${group.displayPath}/${colors.reset}`);
-		const sortedProjects = group.projects.sort((a, b) => a.name.localeCompare(b.name));
+/**
+ * Render the grouped view (default)
+ */
+function renderGroupedView(items: ProjectListItem[]): void {
+	const groups = groupProjects(items);
+	const total = items.length;
 
-		for (let i = 0; i < sortedProjects.length; i++) {
-			const proj = sortedProjects[i];
-			if (!proj) continue;
-			const isLast = i === sortedProjects.length - 1;
-			const prefix = isLast ? "└──" : "├──";
+	// Build consistent tag color map across all projects
+	const tagColorMap = buildTagColorMap(items);
 
-			const statusBadge = buildStatusBadge(proj);
-			console.error(`  ${colors.dim}${prefix}${colors.reset} ${proj.name}  ${statusBadge}`);
-		}
+	console.error("");
+	info(`${total} projects`);
+
+	// Section 1: Errors (always show all)
+	if (groups.errors.length > 0) {
 		console.error("");
+		console.error(formatErrorSection(groups.errors, { tagColorMap }));
 	}
 
-	// Display cloud-only projects
-	if (cloudOnlyProjects.length > 0) {
-		console.error(`  ${colors.dim}On jack cloud (no local files)${colors.reset}`);
-		const sortedCloudProjects = cloudOnlyProjects.sort((a, b) => a.name.localeCompare(b.name));
-
-		for (let i = 0; i < sortedCloudProjects.length; i++) {
-			const proj = sortedCloudProjects[i];
-			if (!proj) continue;
-			const isLast = i === sortedCloudProjects.length - 1;
-			const prefix = isLast ? "└──" : "├──";
-
-			const statusBadge = buildStatusBadge(proj);
-			console.error(`  ${colors.dim}${prefix}${colors.reset} ${proj.name}  ${statusBadge}`);
-		}
+	// Section 2: Local projects (grouped by parent dir)
+	if (groups.local.length > 0) {
 		console.error("");
+		console.error(
+			`  ${colors.dim}${STATUS_ICONS["local-only"]} Local (${groups.local.length})${colors.reset}`,
+		);
+		console.error(formatLocalSection(groups.local, { tagColorMap }));
 	}
 
-	// Summary
-	const liveCount = projects.filter((p) => p.status === "live").length;
-	const localOnlyCount = projects.filter((p) => p.status === "local-only").length;
-	const errorCount = projects.filter((p) => p.status === "error").length;
+	// Section 3: Cloud-only (show last N by updatedAt)
+	if (groups.cloudOnly.length > 0) {
+		const CLOUD_LIMIT = 5;
+		const sorted = sortByUpdated(groups.cloudOnly);
 
-	const parts: string[] = [];
-	if (liveCount > 0) parts.push(`${liveCount} live`);
-	if (localOnlyCount > 0) parts.push(`${localOnlyCount} local-only`);
-	if (errorCount > 0) parts.push(`${errorCount} error`);
+		console.error("");
+		console.error(
+			formatCloudSection(sorted, { limit: CLOUD_LIMIT, total: groups.cloudOnly.length, tagColorMap }),
+		);
+	}
 
-	const summary = parts.length > 0 ? ` (${parts.join(", ")})` : "";
-	info(`${projects.length} projects${summary}`);
+	// Footer hint
+	console.error("");
+	info("jack ls --all for full list, --status error to filter");
 	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 a user-friendly status badge for a project
+ * Render flat table (for --all mode)
  */
-function buildStatusBadge(project: ResolvedProject): string {
-	switch (project.status) {
-		case "live":
-			return `${colors.green}[live]${colors.reset} ${colors.cyan}${project.url || ""}${colors.reset}`;
-		case "local-only":
-			return `${colors.dim}[local only]${colors.reset}`;
-		case "error":
-			return `${colors.red}[error]${colors.reset} ${project.errorMessage || "deployment failed"}`;
-		case "syncing":
-			return `${colors.yellow}[syncing]${colors.reset}`;
-		default:
-			return "";
+function renderFlatTable(items: ProjectListItem[]): void {
+	// Sort: errors first, then by name
+	const sorted = [...items].sort((a, b) => {
+		if (a.status === "error" && b.status !== "error") return -1;
+		if (a.status !== "error" && b.status === "error") return 1;
+		return a.name.localeCompare(b.name);
+	});
+
+	// Build consistent tag color map
+	const tagColorMap = buildTagColorMap(items);
+
+	console.error("");
+	info(`${items.length} projects`);
+	console.error("");
+
+	// Header
+	console.error(`  ${colors.dim}${"NAME".padEnd(22)} ${"STATUS".padEnd(12)} URL${colors.reset}`);
+
+	// Rows
+	for (const item of sorted) {
+		const icon = STATUS_ICONS[item.status] || "?";
+		const statusColor =
+			item.status === "error" || item.status === "auth-expired"
+				? colors.red
+				: item.status === "live"
+					? colors.green
+					: item.status === "syncing"
+						? colors.yellow
+						: colors.dim;
+
+		const name = item.name.slice(0, 20).padEnd(22);
+		const tags = formatTagsInline(item.tags, tagColorMap);
+		const status = item.status.padEnd(12);
+		const url = item.url ? item.url.replace("https://", "") : "\u2014"; // em-dash
+
+		console.error(
+			`  ${statusColor}${icon}${colors.reset} ${name}${tags ? ` ${tags}` : ""} ${statusColor}${status}${colors.reset} ${url}`,
+		);
 	}
+
+	console.error("");
 }
 
 /**
@@ -368,8 +427,8 @@ async function removeProjectEntry(args: string[]): Promise<void> {
 
 	// Show where we'll remove from
 	const locations: string[] = [];
-	if (project.sources.registry) {
-		locations.push("local registry");
+	if (project.sources.filesystem) {
+		locations.push("local project");
 	}
 	if (project.sources.controlPlane) {
 		locations.push("jack cloud");
@@ -447,16 +506,15 @@ async function scanProjects(args: string[]): Promise<void> {
 
 	outputSpinner.start(`Scanning ${targetDir} for jack projects...`);
 
-	const { scanDirectoryForProjects, registerDiscoveredProjects } = await import(
-		"../lib/local-paths.ts"
-	);
+	const { scanAndRegisterProjects } = await import("../lib/paths-index.ts");
 
-	const discovered = await scanDirectoryForProjects(absoluteDir);
+	// scanAndRegisterProjects both discovers and registers projects
+	const discovered = await scanAndRegisterProjects(absoluteDir);
 	outputSpinner.stop();
 
 	if (discovered.length === 0) {
-		info("No jack projects found");
-		info("Projects must have a wrangler.toml or wrangler.jsonc file");
+		info("No linked jack projects found");
+		info("Projects must have a .jack/project.json file");
 		return;
 	}
 
@@ -467,17 +525,16 @@ async function scanProjects(args: string[]): Promise<void> {
 	for (let i = 0; i < discovered.length; i++) {
 		const proj = discovered[i];
 		if (!proj) continue;
+		// Extract project name from path
+		const projectName = proj.path.split("/").pop() || proj.projectId;
 		const displayPath = proj.path.startsWith(home) ? `~${proj.path.slice(home.length)}` : proj.path;
 		const isLast = i === discovered.length - 1;
 		const prefix = isLast ? "└──" : "├──";
 		console.error(
-			`  ${colors.dim}${prefix}${colors.reset} ${proj.name}  ${colors.dim}${displayPath}${colors.reset}`,
+			`  ${colors.dim}${prefix}${colors.reset} ${projectName}  ${colors.dim}${displayPath}${colors.reset}`,
 		);
 	}
 
-	// Register all discovered projects
-	await registerDiscoveredProjects(discovered);
-
 	console.error("");
 	success(`Registered ${discovered.length} local path(s)`);
 }

package/src/commands/secrets.ts

@@ -11,7 +11,7 @@ import { $ } from "bun";
 import { getControlApiUrl } from "../lib/control-plane.ts";
 import { JackError, JackErrorCode } from "../lib/errors.ts";
 import { error, info, output, success, warn } from "../lib/output.ts";
-import { type Project, getProject } from "../lib/registry.ts";
+import { type LocalProjectLink, readProjectLink } from "../lib/project-link.ts";
 import { getProjectNameFromDir } from "../lib/storage/index.ts";
 
 interface SecretsOptions {
@@ -68,7 +68,7 @@ function showHelp(): void {
  */
 async function resolveProjectContext(options: SecretsOptions): Promise<{
 	projectName: string;
-	project: Project | null;
+	link: LocalProjectLink | null;
 	isManaged: boolean;
 	projectId: string | null;
 }> {
@@ -86,11 +86,12 @@ async function resolveProjectContext(options: SecretsOptions): Promise<{
 		}
 	}
 
-	const project = await getProject(projectName);
-	const isManaged = project?.deploy_mode === "managed";
-	const projectId = project?.remote?.project_id ?? null;
+	// Read deploy mode from .jack/project.json
+	const link = await readProjectLink(process.cwd());
+	const isManaged = link?.deploy_mode === "managed";
+	const projectId = link?.project_id ?? null;
 
-	return { projectName, project, isManaged, projectId };
+	return { projectName, link, isManaged, projectId };
 }
 
 /**

package/src/commands/services.ts

@@ -3,7 +3,7 @@ import { fetchProjectResources } from "../lib/control-plane.ts";
 import { formatSize } from "../lib/format.ts";
 import { promptSelect } from "../lib/hooks.ts";
 import { error, info, item, output as outputSpinner, success, warn } from "../lib/output.ts";
-import { getProject } from "../lib/registry.ts";
+import { readProjectLink } from "../lib/project-link.ts";
 import { parseWranglerResources } from "../lib/resources.ts";
 import {
 	deleteDatabase,
@@ -43,12 +43,13 @@ async function ensureLocalProjectContext(projectName: string): Promise<void> {
  * For BYO: parse from wrangler.jsonc
  */
 async function resolveDatabaseInfo(projectName: string): Promise<ResolvedDatabaseInfo | null> {
-	const project = await getProject(projectName);
+	// Read deploy mode from .jack/project.json
+	const link = await readProjectLink(process.cwd());
 
 	// For managed projects, fetch from control plane
-	if (project?.deploy_mode === "managed" && project.remote?.project_id) {
+	if (link?.deploy_mode === "managed") {
 		try {
-			const resources = await fetchProjectResources(project.remote.project_id);
+			const resources = await fetchProjectResources(link.project_id);
 			const d1 = resources.find((r) => r.resource_type === "d1");
 			if (d1) {
 				return {

package/src/commands/tag.ts

@@ -0,0 +1,282 @@
+/**
+ * jack tag - Manage project tags
+ *
+ * Usage:
+ *   jack tag add <tags...>              Add tags to current project
+ *   jack tag add <project> <tags...>    Add tags to named project
+ *   jack tag remove <tags...>           Remove tags from current project
+ *   jack tag remove <project> <tags...> Remove tags from named project
+ *   jack tag list                       List all tags across projects
+ *   jack tag list [project]             List tags for a specific project
+ */
+
+import { error, info, item, success } from "../lib/output.ts";
+import { readProjectLink } from "../lib/project-link.ts";
+import {
+	addTags,
+	findProjectPathByName,
+	getAllTagsWithCounts,
+	getProjectTags,
+	removeTags,
+	validateTags,
+} from "../lib/tags.ts";
+
+export default async function tag(subcommand?: string, args: string[] = []): Promise<void> {
+	if (!subcommand) {
+		showHelp();
+		return;
+	}
+
+	switch (subcommand) {
+		case "add":
+			return await addTagsCommand(args);
+		case "remove":
+			return await removeTagsCommand(args);
+		case "list":
+			return await listTagsCommand(args);
+		case "--help":
+		case "-h":
+		case "help":
+			showHelp();
+			return;
+		default:
+			error(`Unknown subcommand: ${subcommand}`);
+			info("Available: add, remove, list");
+			process.exit(1);
+	}
+}
+
+/**
+ * Show help for the tag command
+ */
+function showHelp(): void {
+	console.error(`
+  jack tag - Manage project tags
+
+  Usage
+    $ jack tag add <tags...>              Add tags to current project
+    $ jack tag add <project> <tags...>    Add tags to named project
+    $ jack tag remove <tags...>           Remove tags from current project
+    $ jack tag remove <project> <tags...> Remove tags from named project
+    $ jack tag list                       List all tags across projects
+    $ jack tag list [project]             List tags for a specific project
+
+  Tag Format
+    Tags must be lowercase alphanumeric with optional colons and hyphens.
+    Examples: backend, api:v2, my-service, prod
+
+  Examples
+    $ jack tag add backend api          Add tags in project directory
+    $ jack tag add my-app backend       Add tag to my-app project
+    $ jack tag remove deprecated        Remove tag from current project
+    $ jack tag list                     Show all tags with counts
+    $ jack tag list my-app              Show tags for my-app
+`);
+}
+
+/**
+ * Resolve project path from arguments
+ * Returns [projectPath, remainingArgs]
+ *
+ * Logic:
+ * 1. If in a linked project directory, use cwd and all args are tags
+ * 2. If not in project directory, first arg might be project name
+ */
+async function resolveProjectAndTags(args: string[]): Promise<[string | null, string[]]> {
+	const cwd = process.cwd();
+
+	// Check if we're in a linked project directory
+	const link = await readProjectLink(cwd);
+
+	if (link) {
+		// In a project directory - all args are tags
+		return [cwd, args];
+	}
+
+	// Not in a project directory - first arg might be project name
+	if (args.length === 0) {
+		return [null, []];
+	}
+
+	const firstArg = args[0] as string; // Safe: we checked args.length > 0 above
+	const rest = args.slice(1);
+
+	// Try to find project by name
+	const projectPath = await findProjectPathByName(firstArg);
+
+	if (projectPath) {
+		// First arg was a project name
+		return [projectPath, rest];
+	}
+
+	// First arg wasn't a project name - we're not in a project directory
+	// and couldn't find a matching project
+	return [null, args];
+}
+
+/**
+ * Add tags to a project
+ */
+async function addTagsCommand(args: string[]): Promise<void> {
+	const [projectPath, tagArgs] = await resolveProjectAndTags(args);
+
+	if (!projectPath) {
+		error("Not in a project directory and no valid project name provided");
+		info("Run from a project directory or specify project name: jack tag add <project> <tags...>");
+		process.exit(1);
+	}
+
+	if (tagArgs.length === 0) {
+		error("No tags specified");
+		info("Usage: jack tag add <tags...>");
+		process.exit(1);
+	}
+
+	// Validate tags first
+	const validation = validateTags(tagArgs);
+	if (!validation.valid) {
+		error("Invalid tags:");
+		for (const { tag, reason } of validation.invalidTags) {
+			item(`"${tag}": ${reason}`);
+		}
+		process.exit(1);
+	}
+
+	const result = await addTags(projectPath, tagArgs);
+
+	if (!result.success) {
+		error(result.error || "Failed to add tags");
+		process.exit(1);
+	}
+
+	if (result.added && result.added.length > 0) {
+		success(`Added tags: ${result.added.join(", ")}`);
+	}
+
+	if (result.skipped && result.skipped.length > 0) {
+		info(`Already present: ${result.skipped.join(", ")}`);
+	}
+
+	if (result.tags.length > 0) {
+		info(`Current tags: ${result.tags.join(", ")}`);
+	}
+}
+
+/**
+ * Remove tags from a project
+ */
+async function removeTagsCommand(args: string[]): Promise<void> {
+	const [projectPath, tagArgs] = await resolveProjectAndTags(args);
+
+	if (!projectPath) {
+		error("Not in a project directory and no valid project name provided");
+		info(
+			"Run from a project directory or specify project name: jack tag remove <project> <tags...>",
+		);
+		process.exit(1);
+	}
+
+	if (tagArgs.length === 0) {
+		error("No tags specified");
+		info("Usage: jack tag remove <tags...>");
+		process.exit(1);
+	}
+
+	const result = await removeTags(projectPath, tagArgs);
+
+	if (!result.success) {
+		error(result.error || "Failed to remove tags");
+		process.exit(1);
+	}
+
+	if (result.removed && result.removed.length > 0) {
+		success(`Removed tags: ${result.removed.join(", ")}`);
+	}
+
+	if (result.skipped && result.skipped.length > 0) {
+		info(`Not found: ${result.skipped.join(", ")}`);
+	}
+
+	if (result.tags.length > 0) {
+		info(`Remaining tags: ${result.tags.join(", ")}`);
+	} else {
+		info("No tags remaining");
+	}
+}
+
+/**
+ * List tags for a project or all tags across projects
+ */
+async function listTagsCommand(args: string[]): Promise<void> {
+	const [projectArg] = args;
+
+	if (projectArg) {
+		// List tags for a specific project
+		await listProjectTags(projectArg);
+	} else {
+		// Check if we're in a project directory
+		const cwd = process.cwd();
+		const link = await readProjectLink(cwd);
+
+		if (link) {
+			// In a project directory - show tags for this project
+			await listProjectTagsForPath(cwd);
+		} else {
+			// Not in project directory - show all tags
+			await listAllTags();
+		}
+	}
+}
+
+/**
+ * List tags for a specific project by name
+ */
+async function listProjectTags(projectName: string): Promise<void> {
+	const projectPath = await findProjectPathByName(projectName);
+
+	if (!projectPath) {
+		error(`Project not found: ${projectName}`);
+		process.exit(1);
+	}
+
+	await listProjectTagsForPath(projectPath);
+}
+
+/**
+ * List tags for a project at a specific path
+ */
+async function listProjectTagsForPath(projectPath: string): Promise<void> {
+	const tags = await getProjectTags(projectPath);
+
+	console.error("");
+	if (tags.length === 0) {
+		info("No tags for this project");
+		info("Add tags with: jack tag add <tags...>");
+	} else {
+		info(`Tags (${tags.length}):`);
+		for (const tag of tags) {
+			item(tag);
+		}
+	}
+	console.error("");
+}
+
+/**
+ * List all tags across all projects with counts
+ */
+async function listAllTags(): Promise<void> {
+	const tagCounts = await getAllTagsWithCounts();
+
+	console.error("");
+	if (tagCounts.length === 0) {
+		info("No tags found across any projects");
+		info("Add tags with: jack tag add <tags...>");
+	} else {
+		info(`All tags (${tagCounts.length}):`);
+		for (const { tag, count } of tagCounts) {
+			const projectLabel = count === 1 ? "project" : "projects";
+			item(`${tag} (${count} ${projectLabel})`);
+		}
+	}
+	console.error("");
+}