depth-first-thinking 2.0.7 → 2.1.0

package/src/tui/navigation.ts

@@ -0,0 +1,143 @@
+import { findNode } from "../data/operations";
+import type { AppState, Node } from "../data/types";
+
+export interface NavigationResult {
+	success: boolean;
+	feedbackMessage?: string;
+}
+
+export function getCurrentList(state: AppState): Node[] {
+	if (state.navigationStack.length === 0) {
+		return state.project.root.children;
+	}
+
+	const parentId = state.navigationStack[state.navigationStack.length - 1];
+	const parent = findNode(state.project.root, parentId);
+
+	if (!parent) {
+		return state.project.root.children;
+	}
+
+	return parent.children;
+}
+
+export function getSelectedNode(state: AppState): Node | null {
+	const list = getCurrentList(state);
+	if (list.length === 0 || state.selectedIndex >= list.length) {
+		return null;
+	}
+	return list[state.selectedIndex] || null;
+}
+
+export function getCurrentParent(state: AppState): Node | null {
+	if (state.navigationStack.length === 0) {
+		return null;
+	}
+
+	const parentId = state.navigationStack[state.navigationStack.length - 1];
+	return findNode(state.project.root, parentId);
+}
+
+export function getBreadcrumbPath(state: AppState): Node[] {
+	const path: Node[] = [];
+
+	for (const nodeId of state.navigationStack) {
+		const node = findNode(state.project.root, nodeId);
+		if (node) {
+			path.push(node);
+		}
+	}
+
+	return path;
+}
+
+export function moveUp(state: AppState): NavigationResult {
+	const list = getCurrentList(state);
+
+	if (list.length === 0) {
+		return { success: false, feedbackMessage: "List is empty" };
+	}
+
+	if (state.selectedIndex <= 0) {
+		return { success: false, feedbackMessage: "At top" };
+	}
+
+	state.selectedIndex--;
+	return { success: true };
+}
+
+export function moveDown(state: AppState): NavigationResult {
+	const list = getCurrentList(state);
+
+	if (list.length === 0) {
+		return { success: false, feedbackMessage: "List is empty" };
+	}
+
+	if (state.selectedIndex >= list.length - 1) {
+		return { success: false, feedbackMessage: "At bottom" };
+	}
+
+	state.selectedIndex++;
+	return { success: true };
+}
+
+export function diveIn(state: AppState): NavigationResult {
+	const selected = getSelectedNode(state);
+
+	if (!selected) {
+		return { success: false, feedbackMessage: "Nothing selected" };
+	}
+
+	state.navigationStack.push(selected.id);
+	state.selectedIndex = 0;
+	return { success: true };
+}
+
+export function goBack(state: AppState): NavigationResult {
+	if (state.navigationStack.length === 0) {
+		return { success: false, feedbackMessage: "At root" };
+	}
+
+	state.navigationStack.pop();
+	state.selectedIndex = 0;
+	return { success: true };
+}
+
+export function initializeNavigation(state: AppState): void {
+	state.navigationStack = [];
+	state.selectedIndex = 0;
+}
+
+export function adjustSelectionAfterDelete(state: AppState, deletedIndex: number): void {
+	const list = getCurrentList(state);
+
+	if (list.length === 0) {
+		state.selectedIndex = 0;
+		return;
+	}
+
+	if (deletedIndex <= state.selectedIndex && state.selectedIndex > 0) {
+		state.selectedIndex--;
+	}
+
+	if (state.selectedIndex >= list.length) {
+		state.selectedIndex = list.length - 1;
+	}
+}
+
+export function ensureValidSelection(state: AppState): void {
+	const list = getCurrentList(state);
+
+	if (list.length === 0) {
+		state.selectedIndex = 0;
+		return;
+	}
+
+	if (state.selectedIndex < 0) {
+		state.selectedIndex = 0;
+	}
+
+	if (state.selectedIndex >= list.length) {
+		state.selectedIndex = list.length - 1;
+	}
+}

package/src/utils/formatting.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+import { formatCheckbox, truncate } from "./formatting";
+
+describe("truncate", () => {
+	test("returns text unchanged if shorter than max", () => {
+		expect(truncate("hello", 10)).toBe("hello");
+	});
+
+	test("returns text unchanged if equal to max", () => {
+		expect(truncate("hello", 5)).toBe("hello");
+	});
+
+	test("truncates with ellipsis if longer than max", () => {
+		expect(truncate("hello world", 8)).toBe("hello...");
+	});
+
+	test("handles very short max length", () => {
+		expect(truncate("hello", 4)).toBe("h...");
+	});
+});
+
+describe("formatCheckbox", () => {
+	test("returns [ ] for open status", () => {
+		expect(formatCheckbox("open")).toBe("[ ]");
+	});
+
+	test("returns [x] for done status", () => {
+		expect(formatCheckbox("done")).toBe("[x]");
+	});
+});

package/src/utils/formatting.ts

@@ -0,0 +1,10 @@
+export function truncate(text: string, maxLength: number): string {
+	if (text.length <= maxLength) {
+		return text;
+	}
+	return `${text.substring(0, maxLength - 3)}...`;
+}
+
+export function formatCheckbox(status: "open" | "done"): string {
+	return status === "done" ? "[x]" : "[ ]";
+}

package/src/utils/platform.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+import { getDataDir, getProjectPath, getProjectsDir } from "./platform";
+
+describe("getDataDir", () => {
+	test("returns a non-empty string", () => {
+		const dataDir = getDataDir();
+		expect(typeof dataDir).toBe("string");
+		expect(dataDir.length).toBeGreaterThan(0);
+	});
+});
+
+describe("getProjectsDir", () => {
+	test("includes depthfirst/projects", () => {
+		const projectsDir = getProjectsDir();
+		expect(projectsDir).toContain("depthfirst");
+		expect(projectsDir).toContain("projects");
+	});
+});
+
+describe("getProjectPath", () => {
+	test("returns path with .json extension", () => {
+		const path = getProjectPath("my-project");
+		expect(path).toEndWith(".json");
+	});
+
+	test("converts name to lowercase", () => {
+		const path = getProjectPath("MyProject");
+		expect(path).toContain("myproject.json");
+	});
+});

package/src/utils/platform.ts

@@ -0,0 +1,21 @@
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+
+export function getDataDir(): string {
+	switch (platform()) {
+		case "darwin":
+			return join(homedir(), "Library", "Application Support");
+		case "win32":
+			return process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+		default:
+			return process.env.XDG_DATA_HOME || join(homedir(), ".local", "share");
+	}
+}
+
+export function getProjectsDir(): string {
+	return join(getDataDir(), "depthfirst", "projects");
+}
+
+export function getProjectPath(name: string): string {
+	return join(getProjectsDir(), `${name.toLowerCase()}.json`);
+}

package/src/utils/validation.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+import { isValidProjectName, isValidTitle, validateProjectName, validateTitle } from "./validation";
+
+describe("validateProjectName", () => {
+	test("accepts valid project names", () => {
+		expect(validateProjectName("my-project").isValid).toBe(true);
+		expect(validateProjectName("project123").isValid).toBe(true);
+		expect(validateProjectName("test_project").isValid).toBe(true);
+		expect(validateProjectName("a").isValid).toBe(true);
+	});
+
+	test("rejects empty names", () => {
+		const result = validateProjectName("");
+		expect(result.isValid).toBe(false);
+		expect(result.error).toContain("at least 1 character");
+	});
+
+	test("rejects names longer than 50 characters", () => {
+		const longName = "a".repeat(51);
+		const result = validateProjectName(longName);
+		expect(result.isValid).toBe(false);
+		expect(result.error).toContain("50 characters or less");
+	});
+
+	test("rejects names starting with non-alphanumeric", () => {
+		const result = validateProjectName("-project");
+		expect(result.isValid).toBe(false);
+		expect(result.error).toContain("start with a letter or number");
+	});
+
+	test("rejects names with invalid characters", () => {
+		const result = validateProjectName("my project");
+		expect(result.isValid).toBe(false);
+		expect(result.error).toContain("letters, numbers, hyphens, and underscores");
+	});
+
+	test("rejects reserved names", () => {
+		const reserved = ["list", "new", "delete", "open", "tree", "help", "version"];
+		for (const name of reserved) {
+			const result = validateProjectName(name);
+			expect(result.isValid).toBe(false);
+			expect(result.error).toContain("reserved name");
+		}
+	});
+});
+
+describe("isValidProjectName", () => {
+	test("returns true for valid names", () => {
+		expect(isValidProjectName("valid-name")).toBe(true);
+	});
+
+	test("returns false for invalid names", () => {
+		expect(isValidProjectName("")).toBe(false);
+		expect(isValidProjectName("list")).toBe(false);
+	});
+});
+
+describe("validateTitle", () => {
+	test("accepts valid titles", () => {
+		expect(validateTitle("Build authentication").isValid).toBe(true);
+		expect(validateTitle("a").isValid).toBe(true);
+	});
+
+	test("rejects empty titles", () => {
+		const result = validateTitle("");
+		expect(result.isValid).toBe(false);
+		expect(result.error).toContain("empty");
+	});
+
+	test("rejects whitespace-only titles", () => {
+		const result = validateTitle("   ");
+		expect(result.isValid).toBe(false);
+		expect(result.error).toContain("empty");
+	});
+
+	test("rejects titles longer than 200 characters", () => {
+		const longTitle = "a".repeat(201);
+		const result = validateTitle(longTitle);
+		expect(result.isValid).toBe(false);
+		expect(result.error).toContain("200 characters or less");
+	});
+});
+
+describe("isValidTitle", () => {
+	test("returns true for valid titles", () => {
+		expect(isValidTitle("Valid title")).toBe(true);
+	});
+
+	test("returns false for invalid titles", () => {
+		expect(isValidTitle("")).toBe(false);
+		expect(isValidTitle("   ")).toBe(false);
+	});
+});

package/src/utils/validation.ts

@@ -0,0 +1,74 @@
+const RESERVED_NAMES = ["list", "new", "delete", "open", "tree", "help", "version"];
+
+export function validateProjectName(name: string): {
+	isValid: boolean;
+	error?: string;
+} {
+	if (name.length < 1) {
+		return {
+			isValid: false,
+			error: "Project name must be at least 1 character long.",
+		};
+	}
+
+	if (name.length > 50) {
+		return {
+			isValid: false,
+			error: "Project name must be 50 characters or less.",
+		};
+	}
+
+	if (!/^[a-zA-Z0-9]/.test(name)) {
+		return {
+			isValid: false,
+			error: "Project name must start with a letter or number.",
+		};
+	}
+
+	if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+		return {
+			isValid: false,
+			error: "Project name can only contain letters, numbers, hyphens, and underscores.",
+		};
+	}
+
+	if (RESERVED_NAMES.includes(name.toLowerCase())) {
+		return {
+			isValid: false,
+			error: `'${name}' is a reserved name. Please choose another.`,
+		};
+	}
+
+	return { isValid: true };
+}
+
+export function isValidProjectName(name: string): boolean {
+	return validateProjectName(name).isValid;
+}
+
+export function validateTitle(title: string): {
+	isValid: boolean;
+	error?: string;
+} {
+	const trimmed = title.trim();
+
+	if (trimmed.length < 1) {
+		return {
+			isValid: false,
+			error: "Title cannot be empty or contain only whitespace.",
+		};
+	}
+
+	if (trimmed.length > 200) {
+		return {
+			isValid: false,
+			error: "Title must be 200 characters or less.",
+		};
+	}
+
+	return { isValid: true };
+}
+
+export function isValidTitle(title: string): boolean {
+	return validateTitle(title).isValid;
+}