@da1z/chop 0.0.1

package/tests/models/id-generator.test.ts

@@ -0,0 +1,46 @@
+import { test, expect, describe } from "bun:test";
+import { generateTaskId, parseTaskId } from "../../src/models/id-generator.ts";
+
+describe("generateTaskId", () => {
+  test("generates ID in correct format", () => {
+    const { id, newSequence } = generateTaskId(0);
+
+    // ID should be in format: 7-char-hash-sequence
+    expect(id).toMatch(/^[a-f0-9]{7}-\d+$/);
+    expect(newSequence).toBe(1);
+  });
+
+  test("increments sequence number", () => {
+    const { newSequence: seq1 } = generateTaskId(5);
+    const { newSequence: seq2 } = generateTaskId(10);
+
+    expect(seq1).toBe(6);
+    expect(seq2).toBe(11);
+  });
+
+  test("generates unique IDs", () => {
+    const ids = new Set<string>();
+    for (let i = 0; i < 100; i++) {
+      const { id } = generateTaskId(i);
+      ids.add(id);
+    }
+    expect(ids.size).toBe(100);
+  });
+});
+
+describe("parseTaskId", () => {
+  test("parses valid ID", () => {
+    const result = parseTaskId("a1b2c3d-42");
+    expect(result).toEqual({
+      hash: "a1b2c3d",
+      sequence: 42,
+    });
+  });
+
+  test("returns null for invalid ID", () => {
+    expect(parseTaskId("invalid")).toBeNull();
+    expect(parseTaskId("abc-1")).toBeNull(); // hash too short
+    expect(parseTaskId("a1b2c3d-")).toBeNull(); // missing sequence
+    expect(parseTaskId("a1b2c3d-abc")).toBeNull(); // non-numeric sequence
+  });
+});

package/tests/models/task.test.ts

@@ -0,0 +1,186 @@
+import { test, expect, describe } from "bun:test";
+import {
+  createTask,
+  isBlocked,
+  findDependents,
+  findAllDependents,
+  findTaskById,
+  isValidStatus,
+  getNextAvailableTask,
+} from "../../src/models/task.ts";
+import type { Task } from "../../src/types.ts";
+
+// Helper to create a mock task
+function mockTask(overrides: Partial<Task> = {}): Task {
+  return {
+    id: "abc1234-1",
+    title: "Test Task",
+    status: "open",
+    dependsOn: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+describe("createTask", () => {
+  test("creates task with required fields", () => {
+    const { task, newSequence } = createTask(0, { title: "My Task" });
+
+    expect(task.title).toBe("My Task");
+    expect(task.status).toBe("open");
+    expect(task.dependsOn).toEqual([]);
+    expect(task.id).toMatch(/^[a-f0-9]{7}-1$/);
+    expect(newSequence).toBe(1);
+  });
+
+  test("creates task with optional fields", () => {
+    const { task } = createTask(5, {
+      title: "My Task",
+      description: "A description",
+      dependsOn: ["abc1234-1"],
+    });
+
+    expect(task.description).toBe("A description");
+    expect(task.dependsOn).toEqual(["abc1234-1"]);
+  });
+
+  test("creates task with draft status", () => {
+    const { task } = createTask(0, {
+      title: "Draft Task",
+      status: "draft",
+    });
+
+    expect(task.status).toBe("draft");
+  });
+
+  test("creates task with open status by default", () => {
+    const { task } = createTask(0, { title: "Open Task" });
+
+    expect(task.status).toBe("open");
+  });
+});
+
+describe("isBlocked", () => {
+  test("returns false for task with no dependencies", () => {
+    const task = mockTask({ dependsOn: [] });
+    expect(isBlocked(task, [])).toBe(false);
+  });
+
+  test("returns false when all dependencies are done", () => {
+    const dep = mockTask({ id: "dep1234-1", status: "done" });
+    const task = mockTask({ dependsOn: ["dep1234-1"] });
+    expect(isBlocked(task, [dep, task])).toBe(false);
+  });
+
+  test("returns false when all dependencies are archived", () => {
+    const dep = mockTask({ id: "dep1234-1", status: "archived" });
+    const task = mockTask({ dependsOn: ["dep1234-1"] });
+    expect(isBlocked(task, [dep, task])).toBe(false);
+  });
+
+  test("returns true when dependency is open", () => {
+    const dep = mockTask({ id: "dep1234-1", status: "open" });
+    const task = mockTask({ dependsOn: ["dep1234-1"] });
+    expect(isBlocked(task, [dep, task])).toBe(true);
+  });
+
+  test("returns true when dependency is in-progress", () => {
+    const dep = mockTask({ id: "dep1234-1", status: "in-progress" });
+    const task = mockTask({ dependsOn: ["dep1234-1"] });
+    expect(isBlocked(task, [dep, task])).toBe(true);
+  });
+});
+
+describe("findDependents", () => {
+  test("finds direct dependents", () => {
+    const task1 = mockTask({ id: "task1-1" });
+    const task2 = mockTask({ id: "task2-2", dependsOn: ["task1-1"] });
+    const task3 = mockTask({ id: "task3-3", dependsOn: ["task1-1"] });
+    const task4 = mockTask({ id: "task4-4" });
+
+    const dependents = findDependents("task1-1", [task1, task2, task3, task4]);
+
+    expect(dependents).toHaveLength(2);
+    expect(dependents.map((t) => t.id)).toContain("task2-2");
+    expect(dependents.map((t) => t.id)).toContain("task3-3");
+  });
+});
+
+describe("findAllDependents", () => {
+  test("finds recursive dependents", () => {
+    const task1 = mockTask({ id: "task1-1" });
+    const task2 = mockTask({ id: "task2-2", dependsOn: ["task1-1"] });
+    const task3 = mockTask({ id: "task3-3", dependsOn: ["task2-2"] });
+    const task4 = mockTask({ id: "task4-4" });
+
+    const dependents = findAllDependents("task1-1", [task1, task2, task3, task4]);
+
+    expect(dependents).toHaveLength(2);
+    expect(dependents.map((t) => t.id)).toContain("task2-2");
+    expect(dependents.map((t) => t.id)).toContain("task3-3");
+  });
+});
+
+describe("findTaskById", () => {
+  test("finds exact match", () => {
+    const task = mockTask({ id: "abc1234-1" });
+    const result = findTaskById("abc1234-1", [task]);
+    expect(result).toBe(task);
+  });
+
+  test("finds partial match", () => {
+    const task = mockTask({ id: "abc1234-1" });
+    const result = findTaskById("abc1234", [task]);
+    expect(result).toBe(task);
+  });
+
+  test("returns undefined for no match", () => {
+    const task = mockTask({ id: "abc1234-1" });
+    const result = findTaskById("xyz9999-9", [task]);
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("isValidStatus", () => {
+  test("returns true for valid statuses", () => {
+    expect(isValidStatus("draft")).toBe(true);
+    expect(isValidStatus("open")).toBe(true);
+    expect(isValidStatus("in-progress")).toBe(true);
+    expect(isValidStatus("done")).toBe(true);
+    expect(isValidStatus("archived")).toBe(true);
+  });
+
+  test("returns false for invalid statuses", () => {
+    expect(isValidStatus("invalid")).toBe(false);
+    expect(isValidStatus("")).toBe(false);
+    expect(isValidStatus("OPEN")).toBe(false);
+  });
+});
+
+describe("getNextAvailableTask", () => {
+  test("returns first open unblocked task", () => {
+    const task1 = mockTask({ id: "task1-1", status: "done" });
+    const task2 = mockTask({ id: "task2-2", status: "open" });
+    const task3 = mockTask({ id: "task3-3", status: "open" });
+
+    const result = getNextAvailableTask([task1, task2, task3]);
+    expect(result?.id).toBe("task2-2");
+  });
+
+  test("skips blocked tasks", () => {
+    const task1 = mockTask({ id: "task1-1", status: "open" });
+    const task2 = mockTask({ id: "task2-2", status: "open", dependsOn: ["task1-1"] });
+
+    const result = getNextAvailableTask([task1, task2]);
+    expect(result?.id).toBe("task1-1");
+  });
+
+  test("returns undefined when no tasks available", () => {
+    const task1 = mockTask({ id: "task1-1", status: "done" });
+    const task2 = mockTask({ id: "task2-2", status: "in-progress" });
+
+    const result = getNextAvailableTask([task1, task2]);
+    expect(result).toBeUndefined();
+  });
+});

package/tests/storage/file-lock.test.ts

@@ -0,0 +1,152 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { withLock } from "../../src/storage/file-lock.ts";
+import { tmpdir } from "os";
+import { join } from "path";
+import { existsSync, unlinkSync, writeFileSync } from "node:fs";
+import { LockError } from "../../src/errors.ts";
+
+describe("withLock", () => {
+  const testLockPath = join(tmpdir(), `chop-test-${Date.now()}.lock`);
+
+  afterEach(() => {
+    // Clean up any leftover lock files
+    try {
+      if (existsSync(testLockPath)) {
+        unlinkSync(testLockPath);
+      }
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  test("acquires and releases lock", async () => {
+    let executed = false;
+
+    await withLock(testLockPath, async () => {
+      executed = true;
+      // Lock file should exist during operation
+      expect(existsSync(testLockPath)).toBe(true);
+    });
+
+    expect(executed).toBe(true);
+    // Lock file should be released after operation
+    expect(existsSync(testLockPath)).toBe(false);
+  });
+
+  test("releases lock on error", async () => {
+    const testError = new Error("Test error");
+
+    try {
+      await withLock(testLockPath, async () => {
+        throw testError;
+      });
+    } catch (error) {
+      expect(error).toBe(testError);
+    }
+
+    // Lock should still be released
+    expect(existsSync(testLockPath)).toBe(false);
+  });
+
+  test("returns operation result", async () => {
+    const result = await withLock(testLockPath, async () => {
+      return { value: 42 };
+    });
+
+    expect(result).toEqual({ value: 42 });
+  });
+
+  test("handles concurrent lock attempts", async () => {
+    const results: number[] = [];
+
+    // Start first lock operation
+    const op1 = withLock(testLockPath, async () => {
+      results.push(1);
+      await Bun.sleep(50);
+      results.push(2);
+      return "op1";
+    });
+
+    // Wait a bit then start second operation
+    await Bun.sleep(10);
+    const op2 = withLock(testLockPath, async () => {
+      results.push(3);
+      return "op2";
+    });
+
+    // Both should complete
+    const [r1, r2] = await Promise.all([op1, op2]);
+
+    expect(r1).toBe("op1");
+    expect(r2).toBe("op2");
+
+    // Operations should be serialized
+    // op1 should start first, complete, then op2 runs
+    expect(results[0]).toBe(1);
+    expect(results[1]).toBe(2);
+    expect(results[2]).toBe(3);
+  });
+
+  test("removes stale lock and acquires new lock", async () => {
+    // Create a stale lock file (timestamp from 2 minutes ago)
+    const staleLockInfo = {
+      pid: 99999,
+      timestamp: Date.now() - 120_000, // 2 minutes ago
+    };
+    writeFileSync(testLockPath, JSON.stringify(staleLockInfo));
+
+    let executed = false;
+
+    // Should detect stale lock, remove it, and acquire
+    await withLock(testLockPath, async () => {
+      executed = true;
+      expect(existsSync(testLockPath)).toBe(true);
+    });
+
+    expect(executed).toBe(true);
+    expect(existsSync(testLockPath)).toBe(false);
+  });
+
+  test("handles invalid lock file content as stale", async () => {
+    // Create a lock file with invalid JSON
+    writeFileSync(testLockPath, "invalid json content");
+
+    let executed = false;
+
+    // Should treat unparseable lock as stale and acquire
+    await withLock(testLockPath, async () => {
+      executed = true;
+    });
+
+    expect(executed).toBe(true);
+  });
+
+  test("throws LockError when lock cannot be acquired after retries", async () => {
+    // Create a fresh (non-stale) lock file that won't be removed
+    const freshLockInfo = {
+      pid: process.pid,
+      timestamp: Date.now(),
+    };
+    writeFileSync(testLockPath, JSON.stringify(freshLockInfo));
+
+    // Mock by making the lock file appear fresh every time by keeping it updated
+    const intervalId = setInterval(() => {
+      try {
+        writeFileSync(testLockPath, JSON.stringify({
+          pid: process.pid,
+          timestamp: Date.now(),
+        }));
+      } catch {
+        // Lock might be removed, ignore
+      }
+    }, 50);
+
+    try {
+      await expect(withLock(testLockPath, async () => {
+        return "should not execute";
+      })).rejects.toThrow(LockError);
+    } finally {
+      clearInterval(intervalId);
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@total-typescript/tsconfig/bundler/no-dom",
+  "compilerOptions": {
+    // Required for Bun's .ts extension imports
+    "allowImportingTsExtensions": true
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts", "index.ts"],
+  "exclude": ["node_modules", "dist"]
+}