@os-eco/overstory-cli 0.6.1 → 0.6.5

package/src/doctor/dependencies.ts

@@ -1,10 +1,20 @@
 import { resolveBackend, trackerCliName } from "../tracker/factory.ts";
 import type { DoctorCheck, DoctorCheckFn } from "./types.ts";
 
+interface ToolSpec {
+	name: string;
+	versionFlag: string;
+	required: boolean;
+	/** Short alias to check if the primary tool is available. */
+	alias?: string;
+	/** npm package name for install hint (e.g. "@os-eco/mulch-cli"). */
+	installHint?: string;
+}
+
 /**
  * External dependency checks.
- * Validates that required CLI tools (git, bun, tmux, bd, mulch) are available
- * and that bd has functional CGO support for its Dolt database backend.
+ * Validates that required CLI tools (git, bun, tmux, tracker, mulch, overstory)
+ * and optional tools (cn) are available, including short alias availability.
  */
 export const checkDependencies: DoctorCheckFn = async (
 	config,
@@ -12,30 +22,56 @@ export const checkDependencies: DoctorCheckFn = async (
 ): Promise<DoctorCheck[]> => {
 	// Determine which tracker CLI to check based on config backend (resolve "auto")
 	const resolvedBackend = await resolveBackend(config.taskTracker.backend, config.project.root);
-	const trackerTool = {
-		name: trackerCliName(resolvedBackend),
-		versionFlag: "--version",
-		required: true,
-	};
+	const trackerName = trackerCliName(resolvedBackend);
 
-	const requiredTools = [
+	const tools: ToolSpec[] = [
 		{ name: "git", versionFlag: "--version", required: true },
 		{ name: "bun", versionFlag: "--version", required: true },
 		{ name: "tmux", versionFlag: "-V", required: true },
-		trackerTool,
-		{ name: "mulch", versionFlag: "--version", required: true },
+		{
+			name: trackerName,
+			versionFlag: "--version",
+			required: true,
+			installHint: trackerName === "sd" ? "@os-eco/seeds-cli" : undefined,
+		},
+		{
+			name: "mulch",
+			versionFlag: "--version",
+			required: true,
+			alias: "ml",
+			installHint: "@os-eco/mulch-cli",
+		},
+		{
+			name: "overstory",
+			versionFlag: "--version",
+			required: true,
+			alias: "ov",
+			installHint: "@os-eco/overstory-cli",
+		},
+		{
+			name: "cn",
+			versionFlag: "--version",
+			required: false,
+			installHint: "@os-eco/canopy-cli",
+		},
 	];
 
 	const checks: DoctorCheck[] = [];
 
-	for (const tool of requiredTools) {
-		const check = await checkTool(tool.name, tool.versionFlag, tool.required);
+	for (const tool of tools) {
+		const check = await checkTool(tool.name, tool.versionFlag, tool.required, tool.installHint);
 		checks.push(check);
+
+		// Check short alias availability if the main tool is available
+		if (tool.alias && check.status === "pass") {
+			const aliasCheck = await checkAlias(tool.name, tool.alias, tool.installHint);
+			checks.push(aliasCheck);
+		}
 	}
 
 	// If bd is available, probe for CGO/Dolt backend functionality.
 	// Only run for beads backend (CGO check is beads-specific).
-	if (trackerTool.name === "bd") {
+	if (trackerName === "bd") {
 		const bdCheck = checks.find((c) => c.name === "bd availability");
 		if (bdCheck?.status === "pass") {
 			const cgoCheck = await checkBdCgoSupport();
@@ -119,6 +155,57 @@ async function checkBdCgoSupport(): Promise<DoctorCheck> {
 	}
 }
 
+/**
+ * Check if a short alias for a CLI tool is available.
+ */
+async function checkAlias(
+	toolName: string,
+	alias: string,
+	installHint?: string,
+): Promise<DoctorCheck> {
+	try {
+		const proc = Bun.spawn([alias, "--version"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const exitCode = await proc.exited;
+
+		if (exitCode === 0) {
+			return {
+				name: `${alias} alias`,
+				category: "dependencies",
+				status: "pass",
+				message: `${alias} alias for ${toolName} is available`,
+				details: [`Short alias '${alias}' is configured`],
+			};
+		}
+
+		const hint = installHint
+			? `Reinstall ${installHint} to get the '${alias}' alias.`
+			: `Ensure '${alias}' alias is in your PATH.`;
+		return {
+			name: `${alias} alias`,
+			category: "dependencies",
+			status: "warn",
+			message: `${alias} alias for ${toolName} not working`,
+			details: [hint],
+			fixable: true,
+		};
+	} catch {
+		const hint = installHint
+			? `Reinstall ${installHint} to get the '${alias}' alias.`
+			: `Ensure '${alias}' alias is in your PATH.`;
+		return {
+			name: `${alias} alias`,
+			category: "dependencies",
+			status: "warn",
+			message: `${alias} alias for ${toolName} is not available`,
+			details: [`'${toolName}' works but short alias '${alias}' was not found.`, hint],
+			fixable: true,
+		};
+	}
+}
+
 /**
  * Check if a CLI tool is available by attempting to run it with a version flag.
  */
@@ -126,6 +213,7 @@ async function checkTool(
 	name: string,
 	versionFlag: string,
 	required: boolean,
+	installHint?: string,
 ): Promise<DoctorCheck> {
 	try {
 		const proc = Bun.spawn([name, versionFlag], {
@@ -150,25 +238,32 @@ async function checkTool(
 
 		// Non-zero exit code
 		const stderr = await new Response(proc.stderr).text();
+		const details: string[] = [];
+		if (stderr) details.push(stderr.trim());
+		if (installHint) details.push(`Install: npm install -g ${installHint}`);
 		return {
 			name: `${name} availability`,
 			category: "dependencies",
 			status: required ? "fail" : "warn",
 			message: `${name} command failed (exit code ${exitCode})`,
-			details: stderr ? [stderr.trim()] : undefined,
+			details: details.length > 0 ? details : undefined,
 			fixable: true,
 		};
 	} catch (error) {
 		// Command not found or spawn failed
+		const details: string[] = [];
+		if (installHint) {
+			details.push(`Install: npm install -g ${installHint}`);
+		} else {
+			details.push(`Install ${name} or ensure it is in your PATH`);
+		}
+		details.push(error instanceof Error ? error.message : String(error));
 		return {
 			name: `${name} availability`,
 			category: "dependencies",
 			status: required ? "fail" : "warn",
 			message: `${name} is not installed or not in PATH`,
-			details: [
-				`Install ${name} or ensure it is in your PATH`,
-				error instanceof Error ? error.message : String(error),
-			],
+			details,
 			fixable: true,
 		};
 	}

package/src/doctor/merge-queue.test.ts

@@ -77,13 +77,13 @@ describe("checkMergeQueue", () => {
 		const queue = createMergeQueue(dbPath);
 		queue.enqueue({
 			branchName: "feature/test",
-			beadId: "beads-abc",
+			taskId: "beads-abc",
 			agentName: "test-agent",
 			filesModified: ["src/test.ts"],
 		});
 		queue.enqueue({
 			branchName: "feature/another",
-			beadId: "beads-def",
+			taskId: "beads-def",
 			agentName: "another-agent",
 			filesModified: ["src/another.ts"],
 		});
@@ -194,13 +194,13 @@ describe("checkMergeQueue", () => {
 		const queue = createMergeQueue(dbPath);
 		queue.enqueue({
 			branchName: "feature/duplicate",
-			beadId: "beads-abc",
+			taskId: "beads-abc",
 			agentName: "test-agent",
 			filesModified: ["src/test.ts"],
 		});
 		queue.enqueue({
 			branchName: "feature/duplicate",
-			beadId: "beads-def",
+			taskId: "beads-def",
 			agentName: "another-agent",
 			filesModified: ["src/another.ts"],
 		});

package/src/e2e/init-sling-lifecycle.test.ts

@@ -52,7 +52,7 @@ describe("E2E: init→sling lifecycle on external project", () => {
 	});
 
 	test("init creates all expected artifacts", async () => {
-		await initCommand([]);
+		await initCommand({});
 
 		const overstoryDir = join(tempDir, ".overstory");
 
@@ -92,7 +92,7 @@ describe("E2E: init→sling lifecycle on external project", () => {
 	});
 
 	test("loadConfig returns valid config pointing to temp dir", async () => {
-		await initCommand([]);
+		await initCommand({});
 
 		const config = await loadConfig(tempDir);
 
@@ -110,7 +110,7 @@ describe("E2E: init→sling lifecycle on external project", () => {
 	});
 
 	test("manifest loads successfully with all 8 agents", async () => {
-		await initCommand([]);
+		await initCommand({});
 
 		const manifestPath = join(tempDir, ".overstory", "agent-manifest.json");
 		const agentDefsDir = join(tempDir, ".overstory", "agent-defs");
@@ -145,7 +145,7 @@ describe("E2E: init→sling lifecycle on external project", () => {
 	});
 
 	test("manifest capability index is consistent", async () => {
-		await initCommand([]);
+		await initCommand({});
 
 		const manifestPath = join(tempDir, ".overstory", "agent-manifest.json");
 		const agentDefsDir = join(tempDir, ".overstory", "agent-defs");
@@ -167,14 +167,14 @@ describe("E2E: init→sling lifecycle on external project", () => {
 	});
 
 	test("overlay generation works for external project", async () => {
-		await initCommand([]);
+		await initCommand({});
 
 		const agentDefsDir = join(tempDir, ".overstory", "agent-defs");
 		const baseDefinition = await Bun.file(join(agentDefsDir, "builder.md")).text();
 
 		const overlayConfig: OverlayConfig = {
 			agentName: "test-agent",
-			beadId: "test-bead-001",
+			taskId: "test-bead-001",
 			specPath: null,
 			branchName: "overstory/test-agent/test-bead-001",
 			worktreePath: join(tempDir, ".overstory", "worktrees", "test-agent"),
@@ -215,7 +215,7 @@ describe("E2E: init→sling lifecycle on external project", () => {
 		// init → load config → load manifest → generate overlay
 
 		// Step 1: Init
-		await initCommand([]);
+		await initCommand({});
 
 		// Step 2: Load config
 		const config = await loadConfig(tempDir);
@@ -241,7 +241,7 @@ describe("E2E: init→sling lifecycle on external project", () => {
 		const builderDef = await Bun.file(join(agentDefsDir, "builder.md")).text();
 		const overlayConfig: OverlayConfig = {
 			agentName: "lifecycle-builder",
-			beadId: "lifecycle-001",
+			taskId: "lifecycle-001",
 			specPath: join(tempDir, ".overstory", "specs", "lifecycle-001.md"),
 			branchName: "overstory/lifecycle-builder/lifecycle-001",
 			worktreePath: join(tempDir, ".overstory", "worktrees", "lifecycle-builder"),

package/src/errors.ts

@@ -152,7 +152,7 @@ export class MergeError extends OverstoryError {
 
 /**
  * Raised when input validation fails.
- * Examples: invalid agent names, malformed beadIds, bad CLI arguments.
+ * Examples: invalid agent names, malformed taskIds, bad CLI arguments.
  */
 export class ValidationError extends OverstoryError {
 	readonly field: string | null;