backlog.md 0.1.0 → 0.1.1

package/src/test/code-path.test.ts

@@ -1,204 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-	CODE_PATH_PATTERNS,
-	extractCodePaths,
-	isCodePath,
-	styleCodePath,
-	transformCodePaths,
-	transformCodePathsPlain,
-} from "../ui/code-path.ts";
-
-describe("Code path utilities", () => {
-	describe("CODE_PATH_PATTERNS", () => {
-		test("should match backticked file paths", () => {
-			const testCases = [
-				"`src/cli.ts`",
-				"`package.json`",
-				"`/Users/name/project/file.ts`",
-				"`./relative/path.js`",
-				"`../parent/file.md`",
-				"`C:\\Windows\\file.exe`",
-			];
-
-			for (const testCase of testCases) {
-				// Reset regex for each test case
-				CODE_PATH_PATTERNS.BACKTICKED_PATH.lastIndex = 0;
-				expect(CODE_PATH_PATTERNS.BACKTICKED_PATH.test(testCase)).toBe(true);
-			}
-		});
-
-		test("should not match non-path backticks", () => {
-			const testCases = ["`just code`", "`function name`", "`variable`", "`123`"];
-
-			for (const testCase of testCases) {
-				// Reset regex lastIndex
-				CODE_PATH_PATTERNS.BACKTICKED_PATH.lastIndex = 0;
-				const match = testCase.match(CODE_PATH_PATTERNS.BACKTICKED_PATH);
-				if (match) {
-					const content = match[0].slice(1, -1);
-					expect(isCodePath(content)).toBe(false);
-				}
-			}
-		});
-	});
-
-	describe("isCodePath", () => {
-		test("should detect file paths with extensions", () => {
-			expect(isCodePath("src/cli.ts")).toBe(true);
-			expect(isCodePath("package.json")).toBe(true);
-			expect(isCodePath("file.md")).toBe(true);
-			expect(isCodePath("/full/path/file.js")).toBe(true);
-		});
-
-		test("should detect paths with separators", () => {
-			expect(isCodePath("src/utils")).toBe(true);
-			expect(isCodePath("folder/subfolder")).toBe(true);
-			expect(isCodePath("/absolute/path")).toBe(true);
-			expect(isCodePath("C:\\Windows\\path")).toBe(true);
-		});
-
-		test("should not detect non-paths", () => {
-			expect(isCodePath("just text")).toBe(false);
-			expect(isCodePath("function")).toBe(false);
-			expect(isCodePath("variable")).toBe(false);
-			expect(isCodePath("123")).toBe(false);
-		});
-	});
-
-	describe("extractCodePaths", () => {
-		test("should extract file paths from text", () => {
-			const text = "Check `src/cli.ts` and `package.json` for details.";
-			const result = extractCodePaths(text);
-			expect(result).toEqual(["src/cli.ts", "package.json"]);
-		});
-
-		test("should ignore non-path backticks", () => {
-			const text = "Use `function` to call `src/cli.ts` method.";
-			const result = extractCodePaths(text);
-			expect(result).toEqual(["src/cli.ts"]);
-		});
-
-		test("should handle empty or no matches", () => {
-			expect(extractCodePaths("No paths here")).toEqual([]);
-			expect(extractCodePaths("Only `variables` here")).toEqual([]);
-			expect(extractCodePaths("")).toEqual([]);
-		});
-
-		test("should handle complex paths", () => {
-			const text = "Files: `/absolute/path/file.ts`, `./relative/file.js`, `../parent/file.md`";
-			const result = extractCodePaths(text);
-			expect(result).toEqual(["/absolute/path/file.ts", "./relative/file.js", "../parent/file.md"]);
-		});
-	});
-
-	describe("styleCodePath", () => {
-		test("should wrap path in gray styling tags", () => {
-			const result = styleCodePath("src/cli.ts");
-			expect(result).toBe("{gray-fg}`src/cli.ts`{/gray-fg}");
-		});
-
-		test("should handle paths with special characters", () => {
-			const result = styleCodePath("/path/with-dashes_and.underscores.ts");
-			expect(result).toBe("{gray-fg}`/path/with-dashes_and.underscores.ts`{/gray-fg}");
-		});
-	});
-
-	describe("transformCodePaths", () => {
-		test("should style isolated code paths", () => {
-			const text = "Check this file: `src/cli.ts`";
-			const result = transformCodePaths(text);
-			expect(result).toBe("Check this file:\n{gray-fg}`src/cli.ts`{/gray-fg}");
-		});
-
-		test("should extract and separate multiple paths in prose", () => {
-			const text = "Modify `src/cli.ts` and `src/ui/board.ts` to implement the feature.";
-			const result = transformCodePaths(text);
-			expect(result).toBe(
-				"Modify and to implement the feature.\n{gray-fg}`src/cli.ts`{/gray-fg}\n{gray-fg}`src/ui/board.ts`{/gray-fg}",
-			);
-		});
-
-		test("should preserve line breaks", () => {
-			const text = "First line with `file1.ts`\nSecond line with `file2.js`";
-			const result = transformCodePaths(text);
-			expect(result).toContain("First line with\n{gray-fg}`file1.ts`{/gray-fg}");
-			expect(result).toContain("Second line with\n{gray-fg}`file2.js`{/gray-fg}");
-		});
-
-		test("should handle text without code paths", () => {
-			const text = "This is just regular text with `variables` and `functions`.";
-			const result = transformCodePaths(text);
-			expect(result).toBe(text);
-		});
-
-		test("should handle empty input", () => {
-			expect(transformCodePaths("")).toBe("");
-			// biome-ignore lint/suspicious/noExplicitAny: testing null/undefined inputs
-			expect(transformCodePaths(null as any)).toBe(null);
-			// biome-ignore lint/suspicious/noExplicitAny: testing null/undefined inputs
-			expect(transformCodePaths(undefined as any)).toBe(undefined);
-		});
-
-		test("should handle only a path on a line", () => {
-			const text = "`src/cli.ts`";
-			const result = transformCodePaths(text);
-			expect(result).toBe("{gray-fg}`src/cli.ts`{/gray-fg}");
-		});
-	});
-
-	describe("transformCodePathsPlain", () => {
-		test("should preserve code paths in plain text", () => {
-			const text = "Check `src/cli.ts` and `package.json` files.";
-			const result = transformCodePathsPlain(text);
-			expect(result).toBe("Check `src/cli.ts` and `package.json` files.");
-		});
-
-		test("should ignore non-path backticks", () => {
-			const text = "Use `function` to call `src/cli.ts` method.";
-			const result = transformCodePathsPlain(text);
-			expect(result).toBe("Use `function` to call `src/cli.ts` method.");
-		});
-
-		test("should handle empty input", () => {
-			expect(transformCodePathsPlain("")).toBe("");
-			// biome-ignore lint/suspicious/noExplicitAny: testing null/undefined inputs
-			expect(transformCodePathsPlain(null as any)).toBe(null);
-			// biome-ignore lint/suspicious/noExplicitAny: testing null/undefined inputs
-			expect(transformCodePathsPlain(undefined as any)).toBe(undefined);
-		});
-	});
-
-	describe("comprehensive path detection", () => {
-		test("should capture 100% of code paths in test fixture", () => {
-			const testFixture = `
-Implementation details:
-- Update \`src/cli.ts\` to add new command
-- Modify \`src/ui/task-viewer.ts\` for display
-- Check \`package.json\` for dependencies
-- Test with \`/absolute/path/test.js\`
-- Relative paths: \`./src/utils.ts\` and \`../config/settings.json\`
-
-Also review the \`README.md\` file and \`biome.json\` configuration.
-Windows paths like \`C:\\Users\\name\\file.txt\` should work too.
-			`.trim();
-
-			const extractedPaths = extractCodePaths(testFixture);
-
-			// Verify we captured all expected paths
-			const expectedPaths = [
-				"src/cli.ts",
-				"src/ui/task-viewer.ts",
-				"package.json",
-				"/absolute/path/test.js",
-				"./src/utils.ts",
-				"../config/settings.json",
-				"README.md",
-				"biome.json",
-				"C:\\Users\\name\\file.txt",
-			];
-
-			expect(extractedPaths).toEqual(expectedPaths);
-			expect(extractedPaths.length).toBe(9);
-		});
-	});
-});

package/src/test/core.test.ts

@@ -1,330 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { rm } from "node:fs/promises";
-import { join } from "node:path";
-import { Core } from "../core/backlog.ts";
-import type { Task } from "../types/index.ts";
-
-const TEST_DIR = join(process.cwd(), "test-core");
-
-describe("Core", () => {
-	let core: Core;
-
-	beforeEach(async () => {
-		core = new Core(TEST_DIR);
-		await core.filesystem.ensureBacklogStructure();
-
-		// Initialize git repository for testing
-		await Bun.spawn(["git", "init"], { cwd: TEST_DIR }).exited;
-		await Bun.spawn(["git", "config", "user.name", "Test User"], { cwd: TEST_DIR }).exited;
-		await Bun.spawn(["git", "config", "user.email", "test@example.com"], { cwd: TEST_DIR }).exited;
-	});
-
-	afterEach(async () => {
-		try {
-			await rm(TEST_DIR, { recursive: true, force: true });
-		} catch {
-			// Ignore cleanup errors
-		}
-	});
-
-	describe("initialization", () => {
-		it("should have filesystem and git operations available", () => {
-			expect(core.filesystem).toBeDefined();
-			expect(core.gitOps).toBeDefined();
-		});
-
-		it("should initialize project with default config", async () => {
-			await core.initializeProject("Test Project");
-
-			const config = await core.filesystem.loadConfig();
-			expect(config?.projectName).toBe("Test Project");
-			expect(config?.statuses).toEqual(["To Do", "In Progress", "Done"]);
-			expect(config?.defaultStatus).toBe("To Do");
-		});
-	});
-
-	describe("task operations", () => {
-		const sampleTask: Task = {
-			id: "task-1",
-			title: "Test Task",
-			status: "To Do",
-			assignee: [],
-			createdDate: "2025-06-07",
-			labels: ["test"],
-			dependencies: [],
-			description: "This is a test task",
-		};
-
-		beforeEach(async () => {
-			await core.initializeProject("Test Project");
-		});
-
-		it("should create task without auto-commit", async () => {
-			await core.createTask(sampleTask, false);
-
-			const loadedTask = await core.filesystem.loadTask("task-1");
-			expect(loadedTask?.id).toBe("task-1");
-			expect(loadedTask?.title).toBe("Test Task");
-		});
-
-		it("should create task with auto-commit", async () => {
-			await core.createTask(sampleTask, true);
-
-			// Check if task file was created
-			const loadedTask = await core.filesystem.loadTask("task-1");
-			expect(loadedTask?.id).toBe("task-1");
-
-			// Check git status to see if there are uncommitted changes
-			const hasChanges = await core.gitOps.hasUncommittedChanges();
-
-			const lastCommit = await core.gitOps.getLastCommitMessage();
-			// For now, just check that we have a commit (could be initialization or task)
-			expect(lastCommit).toBeDefined();
-			expect(lastCommit.length).toBeGreaterThan(0);
-		});
-
-		it("should update task with auto-commit", async () => {
-			await core.createTask(sampleTask, true);
-
-			// Check original task
-			const originalTask = await core.filesystem.loadTask("task-1");
-			expect(originalTask?.title).toBe("Test Task");
-
-			const updatedTask = { ...sampleTask, title: "Updated Task" };
-			await core.updateTask(updatedTask, true);
-
-			// Check if task was updated
-			const loadedTask = await core.filesystem.loadTask("task-1");
-			expect(loadedTask?.title).toBe("Updated Task");
-
-			const lastCommit = await core.gitOps.getLastCommitMessage();
-			// For now, just check that we have a commit (could be initialization or task)
-			expect(lastCommit).toBeDefined();
-			expect(lastCommit.length).toBeGreaterThan(0);
-		});
-
-		it("should archive task with auto-commit", async () => {
-			await core.createTask(sampleTask, true);
-
-			const archived = await core.archiveTask("task-1", true);
-			expect(archived).toBe(true);
-
-			const lastCommit = await core.gitOps.getLastCommitMessage();
-			expect(lastCommit).toContain("backlog: Archive task task-1");
-		});
-
-		it("should demote task with auto-commit", async () => {
-			await core.createTask(sampleTask, true);
-
-			const demoted = await core.demoteTask("task-1", true);
-			expect(demoted).toBe(true);
-
-			const lastCommit = await core.gitOps.getLastCommitMessage();
-			expect(lastCommit).toContain("backlog: Demote task task-1");
-		});
-
-		it("should return false when archiving non-existent task", async () => {
-			const archived = await core.archiveTask("non-existent", true);
-			expect(archived).toBe(false);
-		});
-
-		it("should apply default status when task has empty status", async () => {
-			const taskWithoutStatus: Task = {
-				...sampleTask,
-				status: "",
-			};
-
-			await core.createTask(taskWithoutStatus, false);
-
-			const loadedTask = await core.filesystem.loadTask("task-1");
-			expect(loadedTask?.status).toBe("To Do"); // Should use default from config
-		});
-
-		it("should not override existing status", async () => {
-			const taskWithStatus: Task = {
-				...sampleTask,
-				status: "In Progress",
-			};
-
-			await core.createTask(taskWithStatus, false);
-
-			const loadedTask = await core.filesystem.loadTask("task-1");
-			expect(loadedTask?.status).toBe("In Progress");
-		});
-
-		it("should add description header when missing", async () => {
-			const taskNoHeader: Task = {
-				...sampleTask,
-				id: "task-2",
-				description: "Just text",
-			};
-
-			await core.createTask(taskNoHeader, false);
-			const loaded = await core.filesystem.loadTask("task-2");
-			expect(loaded?.description.startsWith("## Description")).toBe(true);
-		});
-
-		it("should not duplicate description header", async () => {
-			const taskWithHeader: Task = {
-				...sampleTask,
-				id: "task-3",
-				description: "## Description\n\nExisting",
-			};
-
-			await core.createTask(taskWithHeader, false);
-			const loaded = await core.filesystem.loadTask("task-3");
-			const matches = loaded?.description.match(/## Description/g) || [];
-			expect(matches.length).toBe(1);
-		});
-
-		it("should handle task creation without auto-commit when git fails", async () => {
-			// Create task in directory without git
-			const nonGitCore = new Core(join(TEST_DIR, "no-git"));
-			await nonGitCore.filesystem.ensureBacklogStructure();
-
-			// This should succeed even without git
-			await nonGitCore.createTask(sampleTask, false);
-
-			const loadedTask = await nonGitCore.filesystem.loadTask("task-1");
-			expect(loadedTask?.id).toBe("task-1");
-		});
-	});
-
-	describe("draft operations", () => {
-		const sampleDraft: Task = {
-			id: "task-draft",
-			title: "Draft Task",
-			status: "Draft",
-			assignee: [],
-			createdDate: "2025-06-07",
-			labels: [],
-			dependencies: [],
-			description: "Draft task",
-		};
-
-		beforeEach(async () => {
-			await core.initializeProject("Draft Project");
-		});
-
-		it("should create draft without auto-commit", async () => {
-			await core.createDraft(sampleDraft, false);
-
-			const loaded = await core.filesystem.loadDraft("task-draft");
-			expect(loaded?.id).toBe("task-draft");
-		});
-
-		it("should create draft with auto-commit", async () => {
-			await core.createDraft(sampleDraft, true);
-
-			const loaded = await core.filesystem.loadDraft("task-draft");
-			expect(loaded?.id).toBe("task-draft");
-
-			const lastCommit = await core.gitOps.getLastCommitMessage();
-			expect(lastCommit).toBeDefined();
-			expect(lastCommit.length).toBeGreaterThan(0);
-		});
-
-		it("should promote draft with auto-commit", async () => {
-			await core.createDraft(sampleDraft, true);
-
-			const promoted = await core.promoteDraft("task-draft", true);
-			expect(promoted).toBe(true);
-
-			const lastCommit = await core.gitOps.getLastCommitMessage();
-			expect(lastCommit).toContain("backlog: Promote draft task-draft");
-		});
-
-		it("should archive draft with auto-commit", async () => {
-			await core.createDraft(sampleDraft, true);
-
-			const archived = await core.archiveDraft("task-draft", true);
-			expect(archived).toBe(true);
-
-			const lastCommit = await core.gitOps.getLastCommitMessage();
-			expect(lastCommit).toContain("backlog: Archive draft task-draft");
-		});
-	});
-
-	describe("integration with config", () => {
-		it("should use custom default status from config", async () => {
-			// Initialize with custom config
-			await core.initializeProject("Custom Project");
-
-			// Update config with custom default status
-			const config = await core.filesystem.loadConfig();
-			if (config) {
-				config.defaultStatus = "Custom Status";
-				await core.filesystem.saveConfig(config);
-			}
-
-			const taskWithoutStatus: Task = {
-				id: "task-custom",
-				title: "Custom Task",
-				status: "",
-				assignee: [],
-				createdDate: "2025-06-07",
-				labels: [],
-				dependencies: [],
-				description: "Task without status",
-			};
-
-			await core.createTask(taskWithoutStatus, false);
-
-			const loadedTask = await core.filesystem.loadTask("task-custom");
-			expect(loadedTask?.status).toBe("Custom Status");
-		});
-
-		it("should fall back to To Do when config has no default status", async () => {
-			// Initialize project
-			await core.initializeProject("Fallback Project");
-
-			// Update config to remove default status
-			const config = await core.filesystem.loadConfig();
-			if (config) {
-				config.defaultStatus = undefined;
-				await core.filesystem.saveConfig(config);
-			}
-
-			const taskWithoutStatus: Task = {
-				id: "task-fallback",
-				title: "Fallback Task",
-				status: "",
-				assignee: [],
-				createdDate: "2025-06-07",
-				labels: [],
-				dependencies: [],
-				description: "Task without status",
-			};
-
-			await core.createTask(taskWithoutStatus, false);
-
-			const loadedTask = await core.filesystem.loadTask("task-fallback");
-			expect(loadedTask?.status).toBe("To Do");
-		});
-	});
-
-	describe("directory accessor integration", () => {
-		it("should use FileSystem directory accessors for git operations", async () => {
-			await core.initializeProject("Accessor Test");
-
-			const task: Task = {
-				id: "task-accessor",
-				title: "Accessor Test Task",
-				status: "To Do",
-				assignee: [],
-				createdDate: "2025-06-07",
-				labels: [],
-				dependencies: [],
-				description: "Testing directory accessors",
-			};
-
-			await core.createTask(task, true);
-
-			// Verify the task file was created in the correct directory
-			const tasksDir = core.filesystem.tasksDir;
-			const files = await Array.fromAsync(new Bun.Glob("*.md").scan({ cwd: tasksDir }));
-
-			expect(files.some((f) => f.startsWith("task-accessor"))).toBe(true);
-		});
-	});
-});