depth-first-thinking 2.0.7 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "depth-first-thinking",
-	"version": "2.0.7",
+	"version": "2.1.0",
 	"description": "A terminal-based task manager with depth-first navigation. Break down tasks into subtasks, navigate recursively, and track progress.",
 	"keywords": [
 		"cli",
@@ -28,16 +28,16 @@
 	"type": "module",
 	"packageManager": "bun@1.3.2",
 	"bin": {
-		"dft": "dist/dft"
+		"dft": "src/index.ts"
 	},
-	"files": ["dist", "README.md", "LICENSE"],
+	"files": ["src", "README.md", "LICENSE"],
 	"engines": {
 		"bun": ">=1.0.0"
 	},
 	"scripts": {
 		"preinstall": "node -e \"if(process.env.npm_execpath && !process.env.npm_execpath.includes('bun')){console.error('\\x1b[31mError: Use bun to install dependencies\\x1b[0m\\n\\nInstall bun: https://bun.sh');process.exit(1)}\"",
 		"dev": "bun run --watch src/index.ts",
-		"build": "bun build src/index.ts --compile --outfile dist/dft && chmod +x dist/dft",
+		"build": "bun build src/index.ts --target bun --minify --outdir dist",
 		"format": "bunx biome format --write src",
 		"format:check": "bunx biome format src",
 		"lint": "bunx biome lint src",
@@ -46,7 +46,7 @@
 		"check:fix": "bunx biome check --write src",
 		"check-types": "bunx tsc --noEmit",
 		"test": "bun test",
-		"prepublishOnly": "bun run check && bun run check-types && bun run build",
+		"prepublishOnly": "bun run check && bun run check-types",
 		"prepare": "husky",
 		"ci": "bun run format && bun run lint && bun run check-types"
 	},

package/src/commands/delete.ts

@@ -0,0 +1,53 @@
+import { deleteProject, projectExists } from "../data/storage";
+import { ExitCodes } from "../data/types";
+
+async function promptConfirmation(message: string): Promise<boolean> {
+	process.stdout.write(`${message} (y/N): `);
+
+	return new Promise((resolve) => {
+		const stdin = process.stdin;
+		stdin.setRawMode?.(false);
+
+		const onData = (data: Buffer) => {
+			const input = data.toString().trim().toLowerCase();
+			stdin.removeListener("data", onData);
+			resolve(input === "y" || input === "yes");
+		};
+
+		stdin.once("data", onData);
+		stdin.resume();
+	});
+}
+
+export async function deleteCommand(
+	projectName: string,
+	options: { yes?: boolean },
+): Promise<void> {
+	const normalizedName = projectName.toLowerCase();
+
+	if (!(await projectExists(normalizedName))) {
+		console.error(
+			`Project '${normalizedName}' not found. Use 'dft list' to see available projects.`,
+		);
+		process.exit(ExitCodes.NOT_FOUND);
+	}
+
+	if (!options.yes) {
+		const confirmed = await promptConfirmation(
+			`Are you sure you want to delete project '${normalizedName}'?`,
+		);
+		if (!confirmed) {
+			console.log("Cancelled.");
+			process.exit(ExitCodes.CANCELLED);
+		}
+	}
+
+	try {
+		await deleteProject(normalizedName);
+		console.log(`Deleted project '${normalizedName}'`);
+		process.exit(ExitCodes.SUCCESS);
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Failed to delete project");
+		process.exit(ExitCodes.FILESYSTEM_ERROR);
+	}
+}

package/src/commands/list.ts

@@ -0,0 +1,19 @@
+import { listProjects } from "../data/storage";
+
+export async function listCommand(): Promise<void> {
+	const projects = await listProjects();
+
+	if (projects.length === 0) {
+		console.log("No projects found. Create one with 'dft new <name>'");
+		process.exit(0);
+	}
+
+	console.log("Projects:");
+	for (const project of projects) {
+		const taskCount = project.nodeCount - 1;
+		const taskWord = taskCount === 1 ? "task" : "tasks";
+		console.log(`  • ${project.name} (${taskCount} ${taskWord})`);
+	}
+
+	process.exit(0);
+}

package/src/commands/new.ts

@@ -0,0 +1,47 @@
+import { v4 as uuidv4 } from "uuid";
+import { projectExists, saveProject } from "../data/storage";
+import type { Project } from "../data/types";
+import { ExitCodes } from "../data/types";
+import { validateProjectName } from "../utils/validation";
+
+export async function newCommand(projectName: string): Promise<void> {
+	const nameValidation = validateProjectName(projectName);
+	if (!nameValidation.isValid) {
+		console.error(nameValidation.error);
+		process.exit(ExitCodes.INVALID_NAME);
+	}
+
+	const normalizedName = projectName.toLowerCase();
+
+	if (await projectExists(normalizedName)) {
+		console.error(
+			`Project '${normalizedName}' already exists. Use 'dft open ${normalizedName}' to work on it.`,
+		);
+		process.exit(ExitCodes.ALREADY_EXISTS);
+	}
+
+	const now = new Date().toISOString();
+	const project: Project = {
+		project_name: normalizedName,
+		version: "1.0.0",
+		created_at: now,
+		modified_at: now,
+		root: {
+			id: uuidv4(),
+			title: "root",
+			status: "open",
+			children: [],
+			created_at: now,
+			completed_at: null,
+		},
+	};
+
+	try {
+		await saveProject(project);
+		console.log(`Created project '${normalizedName}'`);
+		process.exit(ExitCodes.SUCCESS);
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Failed to create project");
+		process.exit(ExitCodes.FILESYSTEM_ERROR);
+	}
+}

package/src/commands/open.ts

@@ -0,0 +1,38 @@
+import { loadProject, saveProject } from "../data/storage";
+import type { Project } from "../data/types";
+import { ExitCodes } from "../data/types";
+import { startTUI } from "../tui/app";
+
+export async function openCommand(projectName: string): Promise<void> {
+	const normalizedName = projectName.toLowerCase();
+
+	let project: Project;
+	try {
+		project = await loadProject(normalizedName);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Failed to load project";
+
+		if (message.includes("not found")) {
+			console.error(message);
+			process.exit(ExitCodes.NOT_FOUND);
+		} else {
+			console.error(message);
+			process.exit(ExitCodes.CORRUPTED);
+		}
+	}
+
+	project.open_count = (project.open_count ?? 0) + 1;
+	try {
+		await saveProject(project);
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Failed to update open count");
+	}
+
+	try {
+		await startTUI(project);
+		process.exit(ExitCodes.SUCCESS);
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "TUI error occurred");
+		process.exit(ExitCodes.TUI_ERROR);
+	}
+}

package/src/commands/tree.ts

@@ -0,0 +1,38 @@
+import { loadProject } from "../data/storage";
+import type { Node } from "../data/types";
+import { ExitCodes } from "../data/types";
+import { formatCheckbox } from "../utils/formatting";
+
+function printNode(node: Node, indent: number, showStatus: boolean): void {
+	const indentStr = "  ".repeat(indent);
+	const status = showStatus ? `${formatCheckbox(node.status)} ` : "";
+	console.log(`${indentStr}${status}${node.title}`);
+
+	for (const child of node.children) {
+		printNode(child, indent + 1, showStatus);
+	}
+}
+
+export async function treeCommand(
+	projectName: string,
+	options: { status?: boolean },
+): Promise<void> {
+	const normalizedName = projectName.toLowerCase();
+	const showStatus = options.status !== false;
+
+	try {
+		const project = await loadProject(normalizedName);
+		printNode(project.root, 0, showStatus);
+		process.exit(ExitCodes.SUCCESS);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Failed to load project";
+
+		if (message.includes("not found")) {
+			console.error(message);
+			process.exit(ExitCodes.NOT_FOUND);
+		} else {
+			console.error(message);
+			process.exit(ExitCodes.CORRUPTED);
+		}
+	}
+}

package/src/commands/update.ts

@@ -0,0 +1,89 @@
+import { ExitCodes } from "../data/types";
+
+async function getCurrentVersion(): Promise<string> {
+	try {
+		// Resolve the package.json that belongs to this installed package,
+		// regardless of the current working directory.
+		const packageUrl = new URL("../../package.json", import.meta.url);
+		const packageJsonFile = Bun.file(packageUrl);
+
+		if (await packageJsonFile.exists()) {
+			const packageJson = (await packageJsonFile.json()) as { version?: string };
+			return packageJson.version ?? "unknown";
+		}
+
+		return "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+
+async function fetchLatestVersion(): Promise<string | null> {
+	try {
+		const response = await fetch("https://registry.npmjs.org/depth-first-thinking/latest");
+		if (!response.ok) {
+			return null;
+		}
+		const data = (await response.json()) as { version: string };
+		return data.version;
+	} catch {
+		return null;
+	}
+}
+
+function compareVersions(current: string, latest: string): number {
+	const currentParts = current.split(".").map(Number);
+	const latestParts = latest.split(".").map(Number);
+
+	for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+		const currentPart = currentParts[i] ?? 0;
+		const latestPart = latestParts[i] ?? 0;
+
+		if (latestPart > currentPart) return 1;
+		if (latestPart < currentPart) return -1;
+	}
+
+	return 0;
+}
+
+export async function updateCommand(): Promise<void> {
+	const currentVersion = await getCurrentVersion();
+	console.log(`Current version: ${currentVersion}`);
+
+	if (currentVersion === "unknown") {
+		console.log(
+			"Could not determine the current version. Please make sure dft is installed correctly.",
+		);
+		process.exit(ExitCodes.FILESYSTEM_ERROR);
+		return;
+	}
+
+	const latestVersion = await fetchLatestVersion();
+
+	if (!latestVersion) {
+		console.error("Failed to check for updates. Please check your internet connection.");
+		process.exit(ExitCodes.FILESYSTEM_ERROR);
+		return;
+	}
+
+	const comparison = compareVersions(currentVersion, latestVersion);
+
+	if (comparison === 0) {
+		console.log(`You are using the latest version (${currentVersion})`);
+		process.exit(ExitCodes.SUCCESS);
+		return;
+	}
+
+	if (comparison < 0) {
+		console.log(`Update available: ${latestVersion}`);
+		console.log("Run: bun install -g depth-first-thinking@latest");
+		console.log("Or: npm install -g depth-first-thinking@latest");
+		process.exit(ExitCodes.SUCCESS);
+		return;
+	}
+
+	console.log(
+		`You are using a newer version (${currentVersion}) than the published version (${latestVersion})`,
+	);
+	process.exit(ExitCodes.SUCCESS);
+}

package/src/data/operations.test.ts

@@ -0,0 +1,284 @@
+import { describe, expect, test } from "bun:test";
+import {
+	addChildNode,
+	buildPathToNode,
+	deleteNode,
+	editNodeTitle,
+	findNode,
+	findParent,
+	getNextSibling,
+	getNodePath,
+	getPreviousSibling,
+	getSiblingIndex,
+	markNodeDone,
+	markNodeOpen,
+	toggleNodeStatus,
+} from "./operations";
+import type { Node } from "./types";
+
+function createTestNode(title: string, id?: string): Node {
+	return {
+		id: id || crypto.randomUUID(),
+		title,
+		status: "open",
+		children: [],
+		created_at: new Date().toISOString(),
+		completed_at: null,
+	};
+}
+
+describe("addChildNode", () => {
+	test("creates node with correct properties", () => {
+		const parent = createTestNode("Parent");
+		const node = addChildNode(parent, "Test Title");
+		expect(node.title).toBe("Test Title");
+		expect(node.status).toBe("open");
+		expect(node.children).toEqual([]);
+		expect(node.completed_at).toBeNull();
+		expect(node.id).toHaveLength(36);
+	});
+
+	test("trims whitespace from title", () => {
+		const parent = createTestNode("Parent");
+		const node = addChildNode(parent, "  Spaced Title  ");
+		expect(node.title).toBe("Spaced Title");
+	});
+
+	test("adds child to parent", () => {
+		const parent = createTestNode("Parent");
+		const child = addChildNode(parent, "Child");
+
+		expect(parent.children).toHaveLength(1);
+		expect(parent.children[0]).toBe(child);
+		expect(child.title).toBe("Child");
+	});
+
+	test("preserves insertion order", () => {
+		const parent = createTestNode("Parent");
+		addChildNode(parent, "First");
+		addChildNode(parent, "Second");
+		addChildNode(parent, "Third");
+
+		expect(parent.children.map((c) => c.title)).toEqual(["First", "Second", "Third"]);
+	});
+});
+
+describe("editNodeTitle", () => {
+	test("updates the title", () => {
+		const node = createTestNode("Original");
+		editNodeTitle(node, "Updated");
+		expect(node.title).toBe("Updated");
+	});
+
+	test("trims whitespace", () => {
+		const node = createTestNode("Original");
+		editNodeTitle(node, "  New Title  ");
+		expect(node.title).toBe("New Title");
+	});
+});
+
+describe("markNodeDone", () => {
+	test("marks node as done", () => {
+		const node = createTestNode("Test");
+		markNodeDone(node);
+
+		expect(node.status).toBe("done");
+		expect(node.completed_at).not.toBeNull();
+	});
+
+	test("cascades to children", () => {
+		const parent = createTestNode("Parent");
+		const child = addChildNode(parent, "Child");
+		const grandchild = addChildNode(child, "Grandchild");
+
+		markNodeDone(parent);
+
+		expect(parent.status).toBe("done");
+		expect(child.status).toBe("done");
+		expect(grandchild.status).toBe("done");
+	});
+});
+
+describe("markNodeOpen", () => {
+	test("marks node as open", () => {
+		const node = createTestNode("Test");
+		markNodeDone(node); // First mark as done
+
+		markNodeOpen(node);
+
+		expect(node.status).toBe("open" as const);
+		expect(node.completed_at).toBeNull();
+	});
+
+	test("does not cascade to children", () => {
+		const parent = createTestNode("Parent");
+		const child = addChildNode(parent, "Child");
+		markNodeDone(parent);
+
+		markNodeOpen(parent);
+
+		expect(parent.status).toBe("open" as const);
+		expect(child.status).toBe("done" as const); // Still done
+	});
+});
+
+describe("toggleNodeStatus", () => {
+	test("toggles open to done", () => {
+		const node = createTestNode("Test");
+		toggleNodeStatus(node);
+		expect(node.status).toBe("done" as const);
+	});
+
+	test("toggles done to open", () => {
+		const node = createTestNode("Test");
+		markNodeDone(node); // First mark as done
+		toggleNodeStatus(node);
+		expect(node.status).toBe("open" as const);
+	});
+});
+
+describe("deleteNode", () => {
+	test("removes child from parent", () => {
+		const parent = createTestNode("Parent");
+		const child = addChildNode(parent, "Child");
+
+		const result = deleteNode(parent, child.id);
+
+		expect(result).toBe(true);
+		expect(parent.children).toHaveLength(0);
+	});
+
+	test("returns false if child not found", () => {
+		const parent = createTestNode("Parent");
+		const result = deleteNode(parent, "nonexistent");
+		expect(result).toBe(false);
+	});
+});
+
+describe("findNode", () => {
+	test("finds root node", () => {
+		const root = createTestNode("Root", "root-id");
+		const found = findNode(root, "root-id");
+		expect(found).toBe(root);
+	});
+
+	test("finds nested node", () => {
+		const root = createTestNode("Root");
+		const child = addChildNode(root, "Child");
+		const grandchild = addChildNode(child, "Grandchild");
+
+		const found = findNode(root, grandchild.id);
+		expect(found).toBe(grandchild);
+	});
+
+	test("returns null if not found", () => {
+		const root = createTestNode("Root");
+		const found = findNode(root, "nonexistent");
+		expect(found).toBeNull();
+	});
+});
+
+describe("findParent", () => {
+	test("finds parent of child", () => {
+		const root = createTestNode("Root");
+		const child = addChildNode(root, "Child");
+
+		const parent = findParent(root, child.id);
+		expect(parent).toBe(root);
+	});
+
+	test("finds parent of grandchild", () => {
+		const root = createTestNode("Root");
+		const child = addChildNode(root, "Child");
+		const grandchild = addChildNode(child, "Grandchild");
+
+		const parent = findParent(root, grandchild.id);
+		expect(parent).toBe(child);
+	});
+
+	test("returns null for root", () => {
+		const root = createTestNode("Root");
+		const parent = findParent(root, root.id);
+		expect(parent).toBeNull();
+	});
+});
+
+describe("getSiblingIndex", () => {
+	test("returns correct index", () => {
+		const siblings = [createTestNode("A", "a"), createTestNode("B", "b"), createTestNode("C", "c")];
+
+		expect(getSiblingIndex(siblings, "a")).toBe(0);
+		expect(getSiblingIndex(siblings, "b")).toBe(1);
+		expect(getSiblingIndex(siblings, "c")).toBe(2);
+	});
+
+	test("returns -1 if not found", () => {
+		const siblings = [createTestNode("A", "a")];
+		expect(getSiblingIndex(siblings, "nonexistent")).toBe(-1);
+	});
+});
+
+describe("getPreviousSibling", () => {
+	test("returns previous sibling", () => {
+		const siblings = [createTestNode("A", "a"), createTestNode("B", "b"), createTestNode("C", "c")];
+
+		expect(getPreviousSibling(siblings, "b")?.id).toBe("a");
+		expect(getPreviousSibling(siblings, "c")?.id).toBe("b");
+	});
+
+	test("returns null for first sibling", () => {
+		const siblings = [createTestNode("A", "a"), createTestNode("B", "b")];
+		expect(getPreviousSibling(siblings, "a")).toBeNull();
+	});
+});
+
+describe("getNextSibling", () => {
+	test("returns next sibling", () => {
+		const siblings = [createTestNode("A", "a"), createTestNode("B", "b"), createTestNode("C", "c")];
+
+		expect(getNextSibling(siblings, "a")?.id).toBe("b");
+		expect(getNextSibling(siblings, "b")?.id).toBe("c");
+	});
+
+	test("returns null for last sibling", () => {
+		const siblings = [createTestNode("A", "a"), createTestNode("B", "b")];
+		expect(getNextSibling(siblings, "b")).toBeNull();
+	});
+});
+
+describe("buildPathToNode", () => {
+	test("returns path to root", () => {
+		const root = createTestNode("Root", "root");
+		const path = buildPathToNode(root, "root");
+		expect(path).toEqual(["root"]);
+	});
+
+	test("returns path to nested node", () => {
+		const root = createTestNode("Root", "root");
+		const child = addChildNode(root, "Child");
+		child.id = "child";
+		const grandchild = addChildNode(child, "Grandchild");
+		grandchild.id = "grandchild";
+
+		const path = buildPathToNode(root, "grandchild");
+		expect(path).toEqual(["root", "child", "grandchild"]);
+	});
+
+	test("returns null if not found", () => {
+		const root = createTestNode("Root");
+		const path = buildPathToNode(root, "nonexistent");
+		expect(path).toBeNull();
+	});
+});
+
+describe("getNodePath", () => {
+	test("returns array of nodes", () => {
+		const root = createTestNode("Root", "root");
+		const child = addChildNode(root, "Child");
+
+		const path = getNodePath(root, child.id);
+		expect(path).toHaveLength(2);
+		expect(path?.[0]).toBe(root);
+		expect(path?.[1]).toBe(child);
+	});
+});