depth-first-thinking 2.0.7 → 2.0.9

package/src/data/operations.ts

@@ -0,0 +1,111 @@
+import { v4 as uuidv4 } from "uuid";
+import type { Node } from "./types";
+
+export function addChildNode(parent: Node, title: string): Node {
+	const newNode = {
+		id: uuidv4(),
+		title: title.trim(),
+		status: "open" as const,
+		children: [],
+		created_at: new Date().toISOString(),
+		completed_at: null,
+	};
+	parent.children.push(newNode);
+	return newNode;
+}
+
+export function editNodeTitle(node: Node, newTitle: string): void {
+	node.title = newTitle.trim();
+}
+
+export function markNodeDone(node: Node): void {
+	node.status = "done";
+	node.completed_at = new Date().toISOString();
+	for (const child of node.children) {
+		markNodeDone(child);
+	}
+}
+
+export function markNodeOpen(node: Node): void {
+	node.status = "open";
+	node.completed_at = null;
+}
+
+export function toggleNodeStatus(node: Node): void {
+	if (node.status === "open") {
+		markNodeDone(node);
+	} else {
+		markNodeOpen(node);
+	}
+}
+
+export function deleteNode(parent: Node, nodeId: string): boolean {
+	const index = parent.children.findIndex((c) => c.id === nodeId);
+	if (index === -1) return false;
+	parent.children.splice(index, 1);
+	return true;
+}
+
+export function findNode(root: Node, id: string): Node | null {
+	if (root.id === id) return root;
+	for (const child of root.children) {
+		const found = findNode(child, id);
+		if (found) return found;
+	}
+	return null;
+}
+
+export function findParent(root: Node, childId: string): Node | null {
+	for (const child of root.children) {
+		if (child.id === childId) return root;
+		const found = findParent(child, childId);
+		if (found) return found;
+	}
+	return null;
+}
+
+export function buildPathToNode(root: Node, targetId: string): string[] | null {
+	if (root.id === targetId) return [root.id];
+	for (const child of root.children) {
+		const path = buildPathToNode(child, targetId);
+		if (path) return [root.id, ...path];
+	}
+	return null;
+}
+
+export function getNodePath(root: Node, targetId: string): Node[] | null {
+	if (root.id === targetId) return [root];
+	for (const child of root.children) {
+		const path = getNodePath(child, targetId);
+		if (path) return [root, ...path];
+	}
+	return null;
+}
+
+export function getSiblings(parent: Node): Node[] {
+	return parent.children;
+}
+
+export function getSiblingIndex(siblings: Node[], nodeId: string): number {
+	return siblings.findIndex((s) => s.id === nodeId);
+}
+
+export function getPreviousSibling(siblings: Node[], nodeId: string): Node | null {
+	const index = getSiblingIndex(siblings, nodeId);
+	if (index <= 0) return null;
+	return siblings[index - 1];
+}
+
+export function getNextSibling(siblings: Node[], nodeId: string): Node | null {
+	const index = getSiblingIndex(siblings, nodeId);
+	if (index === -1 || index >= siblings.length - 1) return null;
+	return siblings[index + 1];
+}
+
+export function countDescendants(node: Node): number {
+	let count = node.children.length;
+	for (const child of node.children) {
+		count += countDescendants(child);
+	}
+	return count;
+}

package/src/data/storage.ts

@@ -0,0 +1,227 @@
+import { mkdir, readdir, rename, rm } from "node:fs/promises";
+import { getProjectPath, getProjectsDir } from "../utils/platform";
+import type { Node, Project } from "./types";
+
+function validateNode(node: unknown, path = "root"): node is Node {
+	if (!node || typeof node !== "object") {
+		throw new Error(`Invalid node at ${path}: expected object`);
+	}
+
+	const n = node as Record<string, unknown>;
+
+	if (typeof n.id !== "string" || n.id.length !== 36) {
+		throw new Error(`Invalid node at ${path}: id must be a 36-character UUID`);
+	}
+
+	if (typeof n.title !== "string" || n.title.length < 1 || n.title.length > 200) {
+		throw new Error(`Invalid node at ${path}: title must be 1-200 characters`);
+	}
+
+	if (n.status !== "open" && n.status !== "done") {
+		throw new Error(`Invalid node at ${path}: status must be "open" or "done"`);
+	}
+
+	if (!Array.isArray(n.children)) {
+		throw new Error(`Invalid node at ${path}: children must be an array`);
+	}
+
+	if (typeof n.created_at !== "string") {
+		throw new Error(`Invalid node at ${path}: created_at must be a string`);
+	}
+
+	if (n.completed_at !== null && typeof n.completed_at !== "string") {
+		throw new Error(`Invalid node at ${path}: completed_at must be string or null`);
+	}
+
+	for (let i = 0; i < n.children.length; i++) {
+		validateNode(n.children[i], `${path}.children[${i}]`);
+	}
+
+	return true;
+}
+
+function validateProjectSchema(project: unknown): project is Project {
+	if (!project || typeof project !== "object") {
+		throw new Error("Project must be an object");
+	}
+
+	const p = project as Record<string, unknown>;
+
+	if (typeof p.project_name !== "string") {
+		throw new Error("Project must have a project_name string");
+	}
+
+	if (typeof p.version !== "string") {
+		throw new Error("Project must have a version string");
+	}
+
+	if (typeof p.created_at !== "string") {
+		throw new Error("Project must have a created_at timestamp");
+	}
+
+	if (typeof p.modified_at !== "string") {
+		throw new Error("Project must have a modified_at timestamp");
+	}
+
+	validateNode(p.root);
+
+	return true;
+}
+
+export async function ensureProjectsDir(): Promise<void> {
+	const dir = getProjectsDir();
+	await mkdir(dir, { recursive: true });
+}
+
+export async function projectExists(name: string): Promise<boolean> {
+	const path = getProjectPath(name);
+	const file = Bun.file(path);
+	return await file.exists();
+}
+
+export async function loadProject(name: string): Promise<Project> {
+	const path = getProjectPath(name);
+	const file = Bun.file(path);
+
+	if (!(await file.exists())) {
+		throw new Error(`Project '${name}' not found. Use 'dft list' to see available projects.`);
+	}
+
+	let project: unknown;
+	try {
+		project = await file.json();
+	} catch {
+		throw new Error(`Project '${name}' has invalid JSON. The file may be corrupted.`);
+	}
+
+	try {
+		validateProjectSchema(project);
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : "Unknown error";
+		throw new Error(`Project '${name}' has invalid structure: ${detail}`);
+	}
+
+	return project as Project;
+}
+
+export async function saveProject(project: Project): Promise<void> {
+	await ensureProjectsDir();
+
+	project.modified_at = new Date().toISOString();
+	const json = JSON.stringify(project, null, 2);
+	const projectPath = getProjectPath(project.project_name);
+	const tempPath = `${projectPath}.tmp`;
+
+	try {
+		await Bun.write(tempPath, json);
+		await rename(tempPath, projectPath);
+	} catch (error) {
+		try {
+			await rm(tempPath, { force: true });
+		} catch {
+			// Ignore cleanup errors
+		}
+		throw new Error(`Cannot write to project directory. Check permissions. ${error}`);
+	}
+}
+
+export async function listProjects(): Promise<
+	Array<{ name: string; nodeCount: number; createdAt: string }>
+> {
+	const dir = getProjectsDir();
+
+	let files: string[];
+	try {
+		files = await readdir(dir);
+	} catch {
+		return [];
+	}
+
+	const projects: Array<{
+		name: string;
+		nodeCount: number;
+		createdAt: string;
+	}> = [];
+
+	for (const file of files) {
+		if (!file.endsWith(".json")) continue;
+
+		const name = file.slice(0, -5);
+		try {
+			const project = await loadProject(name);
+			const countNodes = (node: Node): number => {
+				let count = 1;
+				for (const child of node.children) {
+					count += countNodes(child);
+				}
+				return count;
+			};
+			const nodeCount = countNodes(project.root);
+			projects.push({
+				name: project.project_name,
+				nodeCount,
+				createdAt: project.created_at,
+			});
+		} catch {
+			// Skip corrupted files
+		}
+	}
+
+	projects.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+
+	return projects;
+}
+
+export async function getMostOpenedProject(): Promise<string | null> {
+	const dir = getProjectsDir();
+
+	let files: string[];
+	try {
+		files = await readdir(dir);
+	} catch {
+		return null;
+	}
+
+	let mostOpenedProject: { name: string; openCount: number } | null = null;
+
+	for (const file of files) {
+		if (!file.endsWith(".json")) continue;
+
+		const name = file.slice(0, -5);
+		try {
+			const project = await loadProject(name);
+			const openCount = project.open_count ?? 0;
+
+			if (openCount > 0) {
+				if (
+					!mostOpenedProject ||
+					openCount > mostOpenedProject.openCount ||
+					(openCount === mostOpenedProject.openCount &&
+						project.project_name < mostOpenedProject.name)
+				) {
+					mostOpenedProject = {
+						name: project.project_name,
+						openCount,
+					};
+				}
+			}
+		} catch {}
+	}
+
+	return mostOpenedProject?.name ?? null;
+}
+
+export async function deleteProject(name: string): Promise<void> {
+	const path = getProjectPath(name);
+	const file = Bun.file(path);
+
+	if (!(await file.exists())) {
+		throw new Error(`Project '${name}' not found. Use 'dft list' to see available projects.`);
+	}
+
+	try {
+		await rm(path);
+	} catch {
+		throw new Error("Cannot delete project file. Check permissions.");
+	}
+}

package/src/data/types.ts

@@ -0,0 +1,48 @@
+export type NodeStatus = "open" | "done";
+
+export interface Node {
+	id: string;
+	title: string;
+	status: NodeStatus;
+	children: Node[];
+	created_at: string;
+	completed_at: string | null;
+}
+
+export interface Project {
+	project_name: string;
+	version: string;
+	created_at: string;
+	modified_at: string;
+	root: Node;
+	open_count?: number;
+}
+
+export type ModalType = "new" | "edit" | "delete" | "help";
+
+export interface ModalState {
+	type: ModalType;
+	inputValue?: string;
+	errorMessage?: string;
+	selectedButton?: number;
+}
+
+export interface AppState {
+	project: Project;
+	navigationStack: string[];
+	selectedIndex: number;
+	modalState: ModalState | null;
+	feedbackMessage: string | null;
+	feedbackTimeout?: ReturnType<typeof setTimeout>;
+}
+
+export const ExitCodes = {
+	SUCCESS: 0,
+	INVALID_NAME: 1,
+	ALREADY_EXISTS: 2,
+	FILESYSTEM_ERROR: 3,
+	NOT_FOUND: 1,
+	CANCELLED: 2,
+	CORRUPTED: 2,
+	TUI_ERROR: 3,
+} as const;

package/src/index.ts

@@ -0,0 +1,123 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { deleteCommand } from "./commands/delete";
+import { listCommand } from "./commands/list";
+import { newCommand } from "./commands/new";
+import { openCommand } from "./commands/open";
+import { treeCommand } from "./commands/tree";
+import { updateCommand } from "./commands/update";
+import { getMostOpenedProject } from "./data/storage";
+import { isValidProjectName } from "./utils/validation";
+
+const program = new Command();
+
+program
+	.name("dft")
+	.description("Depth-First Thinking - Solve problems the depth-first way")
+	.version("1.0.0");
+
+program
+	.command("new <project_name>")
+	.aliases(["create", "init", "add"])
+	.description("Create a new project")
+	.action(async (projectName: string) => {
+		await newCommand(projectName);
+	});
+
+program
+	.command("list")
+	.aliases(["ls", "show", "projects"])
+	.description("List all projects sorted by creation date")
+	.action(async () => {
+		await listCommand();
+	});
+
+program
+	.command("delete <project_name>")
+	.aliases(["rm", "remove"])
+	.description("Delete an existing project")
+	.option("-y, --yes", "Skip confirmation prompt")
+	.action(async (projectName: string, options: { yes?: boolean }) => {
+		await deleteCommand(projectName, options);
+	});
+
+program
+	.command("open <project_name>")
+	.aliases(["use", "start", "run"])
+	.description("Launch the interactive TUI session")
+	.action(async (projectName: string) => {
+		await openCommand(projectName);
+	});
+
+program
+	.command("tree <project_name>")
+	.aliases(["view"])
+	.description("Print the tree structure to stdout")
+	.option("--show-status", "Show status markers (default: true)")
+	.option("--no-status", "Hide status markers")
+	.action(async (projectName: string, options: { status?: boolean }) => {
+		await treeCommand(projectName, options);
+	});
+
+program
+	.command("update")
+	.aliases(["upgrade", "check-update"])
+	.description("Check for updates to dft")
+	.action(async () => {
+		await updateCommand();
+	});
+
+const knownCommands = [
+	"new",
+	"create",
+	"init",
+	"add",
+	"list",
+	"ls",
+	"show",
+	"projects",
+	"delete",
+	"rm",
+	"remove",
+	"open",
+	"use",
+	"start",
+	"run",
+	"tree",
+	"view",
+	"update",
+	"upgrade",
+	"check-update",
+	"help",
+];
+
+async function main() {
+	const args = process.argv.slice(2);
+
+	if (args.length === 0) {
+		const mostOpenedProject = await getMostOpenedProject();
+		if (mostOpenedProject) {
+			await openCommand(mostOpenedProject);
+			return;
+		}
+		await listCommand();
+		return;
+	}
+
+	if (
+		args.length > 0 &&
+		!args[0].startsWith("-") &&
+		!knownCommands.includes(args[0]) &&
+		isValidProjectName(args[0])
+	) {
+		process.argv.splice(2, 0, "open");
+	}
+
+	await program.parseAsync(process.argv);
+}
+
+main().catch((error) => {
+	console.error("Error:", error.message || error);
+	process.exit(1);
+});