taskplane 0.1.14 → 0.1.16

package/bin/taskplane.mjs

@@ -212,7 +212,6 @@ orchestrator:
   max_lanes: ${vars.max_lanes}
   worktree_location: "subdirectory"
   worktree_prefix: "${vars.worktree_prefix}"
-  integration_branch: "${vars.integration_branch}"
   batch_id_format: "timestamp"
   spawn_mode: "subprocess"
   tmux_prefix: "${vars.tmux_prefix}"
@@ -293,15 +292,17 @@ async function autoCommitTaskFiles(projectRoot, tasksRoot) {
 
 function discoverTaskAreaMetadata(projectRoot) {
 	const runnerPath = path.join(projectRoot, ".pi", "task-runner.yaml");
-	if (!fs.existsSync(runnerPath)) return { paths: [], contexts: [] };
+	if (!fs.existsSync(runnerPath)) return { paths: [], contexts: [], areaRepoIds: {} };
 
 	const raw = readYaml(runnerPath);
-	if (!raw) return { paths: [], contexts: [] };
+	if (!raw) return { paths: [], contexts: [], areaRepoIds: {} };
 
 	const lines = raw.split(/\r?\n/);
 	let inTaskAreas = false;
+	let currentAreaName = null;
 	const paths = new Set();
 	const contexts = new Set();
+	const areaRepoIds = {}; // area name → repo_id (only areas that declare one)
 
 	for (const line of lines) {
 		const trimmed = line.trim();
@@ -318,6 +319,13 @@ function discoverTaskAreaMetadata(projectRoot) {
 			break;
 		}
 
+		// Area name line (2-space indent): "  taskplane-tasks:"
+		const areaNameMatch = line.match(/^  ([A-Za-z0-9][A-Za-z0-9_-]*)\s*:\s*$/);
+		if (areaNameMatch) {
+			currentAreaName = areaNameMatch[1];
+			continue;
+		}
+
 		const pathMatch = line.match(/^\s{4}path:\s*["']?([^"'\n#]+)["']?\s*(?:#.*)?$/);
 		if (pathMatch?.[1]) {
 			paths.add(pathMatch[1].trim());
@@ -327,9 +335,18 @@ function discoverTaskAreaMetadata(projectRoot) {
 		if (contextMatch?.[1]) {
 			contexts.add(contextMatch[1].trim());
 		}
+
+		// Extract repo_id per area (workspace mode routing validation)
+		// Only store when trimmed value is non-empty — aligns with orchestrator
+		// config.ts behavior which ignores empty/whitespace repo_id values.
+		const repoIdMatch = line.match(/^\s{4}repo_id:\s*["']?([^"'\n#]+)["']?\s*(?:#.*)?$/);
+		const repoIdValue = repoIdMatch?.[1]?.trim();
+		if (repoIdValue && currentAreaName) {
+			areaRepoIds[currentAreaName] = repoIdValue;
+		}
 	}
 
-	return { paths: [...paths], contexts: [...contexts] };
+	return { paths: [...paths], contexts: [...contexts], areaRepoIds };
 }
 
 function discoverTaskAreaPaths(projectRoot) {
@@ -707,7 +724,6 @@ function getPresetVars(preset, projectRoot, tasksRootOverride = null) {
 	const { test: test_cmd, build: build_cmd } = detectStack(projectRoot);
 	return {
 		project_name: dirName,
-		integration_branch: "main",
 		max_lanes: 3,
 		worktree_prefix: `${slug}-wt`,
 		tmux_prefix: `${slug}-orch`,
@@ -725,7 +741,6 @@ async function getInteractiveVars(projectRoot, tasksRootOverride = null) {
 	const detected = detectStack(projectRoot);
 
 	const project_name = await ask("Project name", dirName);
-	const integration_branch = await ask("Default branch (fallback — orchestrator uses your current branch at runtime)", "main");
 	const max_lanes = parseInt(await ask("Max parallel lanes", "3")) || 3;
 	const tasks_root = tasksRootOverride || await ask("Tasks directory", "taskplane-tasks");
 	const default_area = await ask("Default area name", "general");
@@ -736,7 +751,6 @@ async function getInteractiveVars(projectRoot, tasksRootOverride = null) {
 	const slug = slugify(project_name);
 	return {
 		project_name,
-		integration_branch,
 		max_lanes,
 		worktree_prefix: `${slug}-wt`,
 		tmux_prefix: `${slug}-orch`,
@@ -769,6 +783,215 @@ function printFileList(vars, noExamples, preset, exampleTemplateDirs = []) {
 	console.log();
 }
 
+// ─── Workspace Mode Detection (for doctor) ─────────────────────────────────
+
+/**
+ * Lightweight workspace config loader for doctor diagnostics.
+ *
+ * Unlike the orchestrator's `loadWorkspaceConfig()` in workspace.ts (which
+ * throws on invalid config), this returns a result object so doctor can
+ * report errors as diagnostics and continue checking remaining items.
+ *
+ * Mode determination rules (mirrors workspace.ts):
+ * 1. No config file → { mode: "repo", config: null, error: null }
+ * 2. Config file present + valid → { mode: "workspace", config: {...}, error: null }
+ * 3. Config file present + invalid → { mode: "workspace", config: null, error: { code, message } }
+ *
+ * @param {string} projectRoot - Absolute path to the project root
+ * @returns {Promise<{ mode: string, config: object|null, error: object|null }>}
+ */
+function loadWorkspaceConfigForDoctor(projectRoot) {
+	const configFile = path.join(projectRoot, ".pi", "taskplane-workspace.yaml");
+
+	// 1. File existence — absent = repo mode
+	if (!fs.existsSync(configFile)) {
+		return { mode: "repo", config: null, error: null };
+	}
+
+	// 2. File read
+	let rawContent;
+	try {
+		rawContent = fs.readFileSync(configFile, "utf-8");
+	} catch (err) {
+		return {
+			mode: "workspace",
+			config: null,
+			error: {
+				code: "WORKSPACE_FILE_READ_ERROR",
+				message: `Cannot read workspace config file: ${err.message}`,
+			},
+		};
+	}
+
+	// 3. YAML parse using lightweight line-based extraction
+	// (avoids importing the yaml module for CLI startup speed)
+	let parsed;
+	try {
+		parsed = parseWorkspaceYaml(rawContent);
+	} catch (err) {
+		return {
+			mode: "workspace",
+			config: null,
+			error: {
+				code: "WORKSPACE_FILE_PARSE_ERROR",
+				message: `Cannot parse workspace config: ${err.message}`,
+			},
+		};
+	}
+
+	// 4. Schema validation: repos map present and non-empty
+	if (!parsed.repos || Object.keys(parsed.repos).length === 0) {
+		return {
+			mode: "workspace",
+			config: null,
+			error: {
+				code: "WORKSPACE_SCHEMA_INVALID",
+				message: "Workspace config must define at least one repo under 'repos'.",
+			},
+		};
+	}
+
+	// 5. Schema validation: routing present
+	if (!parsed.routing || (!parsed.routing.default_repo && !parsed.routing.tasks_root)) {
+		return {
+			mode: "workspace",
+			config: null,
+			error: {
+				code: "WORKSPACE_SCHEMA_INVALID",
+				message: "Workspace config must contain a 'routing' mapping with default_repo and tasks_root.",
+			},
+		};
+	}
+
+	// 6. Per-repo validation: path field present
+	const repoKeys = Object.keys(parsed.repos).sort();
+	for (const repoId of repoKeys) {
+		const repo = parsed.repos[repoId];
+		if (!repo.path) {
+			return {
+				mode: "workspace",
+				config: null,
+				error: {
+					code: "WORKSPACE_REPO_PATH_MISSING",
+					message: `Repo '${repoId}' is missing a 'path' field.`,
+				},
+			};
+		}
+	}
+
+	// 7. Routing validation
+	if (!parsed.routing.tasks_root) {
+		return {
+			mode: "workspace",
+			config: null,
+			error: {
+				code: "WORKSPACE_MISSING_TASKS_ROOT",
+				message: "Workspace config 'routing.tasks_root' is missing or empty.",
+			},
+		};
+	}
+
+	if (!parsed.routing.default_repo) {
+		return {
+			mode: "workspace",
+			config: null,
+			error: {
+				code: "WORKSPACE_MISSING_DEFAULT_REPO",
+				message: "Workspace config 'routing.default_repo' is missing or empty.",
+			},
+		};
+	}
+
+	const defaultRepoId = parsed.routing.default_repo;
+	if (!parsed.repos[defaultRepoId]) {
+		const available = Object.keys(parsed.repos).join(", ");
+		return {
+			mode: "workspace",
+			config: null,
+			error: {
+				code: "WORKSPACE_DEFAULT_REPO_NOT_FOUND",
+				message: `routing.default_repo '${defaultRepoId}' does not match any repo ID. Available: ${available}`,
+			},
+		};
+	}
+
+	// Valid workspace config — build summary for doctor display
+	return {
+		mode: "workspace",
+		config: {
+			repos: parsed.repos,
+			routing: {
+				tasksRoot: parsed.routing.tasks_root,
+				defaultRepo: defaultRepoId,
+			},
+			configPath: configFile,
+		},
+		error: null,
+	};
+}
+
+/**
+ * Lightweight YAML parser for workspace config.
+ * Extracts repos (id → { path, default_branch }) and routing fields.
+ * Does NOT handle all YAML — only the workspace config subset.
+ */
+function parseWorkspaceYaml(raw) {
+	const lines = raw.split(/\r?\n/);
+	const result = { repos: {}, routing: {} };
+	let section = null;       // "repos" | "routing" | null
+	let currentRepoId = null; // current repo being parsed
+
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+
+		// Top-level keys
+		if (/^repos\s*:\s*$/.test(trimmed)) {
+			section = "repos";
+			currentRepoId = null;
+			continue;
+		}
+		if (/^routing\s*:\s*$/.test(trimmed)) {
+			section = "routing";
+			currentRepoId = null;
+			continue;
+		}
+		// Any other top-level key ends current section
+		if (/^[a-z_]+\s*:/.test(line) && !line.startsWith(" ") && !line.startsWith("\t")) {
+			section = null;
+			currentRepoId = null;
+			continue;
+		}
+
+		if (section === "repos") {
+			// Repo ID line (2-space indent): "  api:"
+			const repoIdMatch = line.match(/^  ([a-z0-9][a-z0-9_-]*)\s*:\s*$/);
+			if (repoIdMatch) {
+				currentRepoId = repoIdMatch[1];
+				result.repos[currentRepoId] = {};
+				continue;
+			}
+			// Repo property lines (4-space indent): "    path: ../api-repo"
+			if (currentRepoId) {
+				const propMatch = line.match(/^\s{4}(\w+)\s*:\s*["']?([^"'\n#]+?)["']?\s*(?:#.*)?$/);
+				if (propMatch) {
+					result.repos[currentRepoId][propMatch[1]] = propMatch[2].trim();
+				}
+			}
+		}
+
+		if (section === "routing") {
+			// Routing property lines (2-space indent): "  default_repo: api"
+			const propMatch = line.match(/^\s{2}(\w+)\s*:\s*["']?([^"'\n#]+?)["']?\s*(?:#.*)?$/);
+			if (propMatch) {
+				result.routing[propMatch[1]] = propMatch[2].trim();
+			}
+		}
+	}
+
+	return result;
+}
+
 // ─── doctor ─────────────────────────────────────────────────────────────────
 
 function cmdDoctor() {
@@ -811,7 +1034,66 @@ function cmdDoctor() {
 	const installType = isProjectLocal ? "project-local" : "global";
 	console.log(`  ${OK} taskplane package installed ${c.dim}(v${pkgVersion}, ${installType})${c.reset}`);
 
-	// Check project config
+	// Detect workspace mode
+	const wsResult = loadWorkspaceConfigForDoctor(projectRoot);
+	const isWorkspaceMode = wsResult.mode === "workspace";
+
+	if (isWorkspaceMode) {
+		console.log();
+		if (wsResult.error) {
+			// Config present but invalid — report as failure
+			const codeHint = wsResult.error.code ? ` [${wsResult.error.code}]` : "";
+			console.log(`  ${FAIL} workspace mode detected but config is invalid${codeHint}`);
+			console.log(`     ${c.dim}${wsResult.error.message}${c.reset}`);
+			console.log(`     ${c.dim}→ Fix .pi/taskplane-workspace.yaml or remove it to use repo mode${c.reset}`);
+			issues++;
+		} else {
+			// Valid workspace config — show summary banner
+			const cfg = wsResult.config;
+			const repoIds = Object.keys(cfg.repos);
+			const repoCount = repoIds.length;
+			const defaultRepo = cfg.routing.defaultRepo;
+			const tasksRoot = cfg.routing.tasksRoot;
+			console.log(`  ${OK} workspace mode ${c.dim}(${repoCount} repo${repoCount !== 1 ? "s" : ""}, default: ${defaultRepo})${c.reset}`);
+			console.log(`     ${c.dim}repos: ${repoIds.join(", ")}${c.reset}`);
+			console.log(`     ${c.dim}tasks_root: ${tasksRoot}${c.reset}`);
+		}
+	}
+
+	// Step 1: Validate repo topology (workspace mode + valid config only)
+	if (isWorkspaceMode && wsResult.config) {
+		console.log();
+		const repoIds = Object.keys(wsResult.config.repos).sort();
+		for (const repoId of repoIds) {
+			const repo = wsResult.config.repos[repoId];
+			const resolvedPath = path.resolve(projectRoot, repo.path);
+
+			// Check path exists on disk
+			if (!fs.existsSync(resolvedPath)) {
+				console.log(`  ${FAIL} repo: ${repoId} — path not found: ${resolvedPath} [WORKSPACE_REPO_PATH_NOT_FOUND]`);
+				console.log(`     ${c.dim}→ Check repos.${repoId}.path in .pi/taskplane-workspace.yaml${c.reset}`);
+				issues++;
+				continue;
+			}
+
+			// Check path is a git repository
+			try {
+				execSync("git rev-parse --git-dir", {
+					cwd: resolvedPath,
+					stdio: ["pipe", "pipe", "pipe"],
+					timeout: 5000,
+				});
+				console.log(`  ${OK} repo: ${repoId} ${c.dim}(${resolvedPath})${c.reset}`);
+			} catch {
+				console.log(`  ${FAIL} repo: ${repoId} — not a git repository: ${resolvedPath} [WORKSPACE_REPO_NOT_GIT]`);
+				console.log(`     ${c.dim}→ Run: git init ${resolvedPath}${c.reset}`);
+				console.log(`     ${c.dim}  or fix repos.${repoId}.path in .pi/taskplane-workspace.yaml${c.reset}`);
+				issues++;
+			}
+		}
+	}
+
+	// Check project config (common — both modes)
 	console.log();
 	const configFiles = [
 		{ path: ".pi/task-runner.yaml", required: true },
@@ -822,20 +1104,30 @@ function cmdDoctor() {
 		{ path: ".pi/taskplane.json", required: false },
 	];
 
+	// In workspace mode, include workspace config in the config files check
+	if (isWorkspaceMode && !wsResult.error) {
+		configFiles.push({ path: ".pi/taskplane-workspace.yaml", required: true });
+	}
+
+	let missingRequiredConfigs = 0;
 	for (const { path: relPath, required } of configFiles) {
 		const exists = fs.existsSync(path.join(projectRoot, relPath));
 		if (exists) {
 			console.log(`  ${OK} ${relPath} exists`);
 		} else if (required) {
 			console.log(`  ${FAIL} ${relPath} missing`);
+			missingRequiredConfigs++;
 			issues++;
 		} else {
 			console.log(`  ${WARN} ${relPath} missing ${c.dim}(optional)${c.reset}`);
 		}
 	}
+	if (missingRequiredConfigs > 0) {
+		console.log(`     ${c.dim}→ Run: taskplane init${c.reset}`);
+	}
 
 	// Check task areas from config
-	const { paths: taskAreaPaths, contexts: taskAreaContexts } = discoverTaskAreaMetadata(projectRoot);
+	const { paths: taskAreaPaths, contexts: taskAreaContexts, areaRepoIds } = discoverTaskAreaMetadata(projectRoot);
 	if (taskAreaPaths.length > 0) {
 		console.log();
 		for (const areaPath of taskAreaPaths) {
@@ -858,6 +1150,22 @@ function cmdDoctor() {
 		}
 	}
 
+	// Validate area repo_id routing targets (workspace mode + valid config only)
+	if (isWorkspaceMode && wsResult.config && Object.keys(areaRepoIds).length > 0) {
+		const knownRepoIds = Object.keys(wsResult.config.repos).sort();
+		const areaNames = Object.keys(areaRepoIds).sort();
+		for (const areaName of areaNames) {
+			const repoId = areaRepoIds[areaName];
+			if (knownRepoIds.includes(repoId)) {
+				console.log(`  ${OK} area '${areaName}' repo_id: ${repoId}`);
+			} else {
+				console.log(`  ${FAIL} area '${areaName}' repo_id '${repoId}' does not match any workspace repo [AREA_REPO_ID_UNKNOWN]`);
+				console.log(`     ${c.dim}→ Available repos: ${knownRepoIds.join(", ")}. Fix repo_id in .pi/task-runner.yaml${c.reset}`);
+				issues++;
+			}
+		}
+	}
+
 	console.log();
 	if (issues === 0) {
 		console.log(`${OK} ${c.green}All checks passed!${c.reset}\n`);