@da1z/chop 0.0.1

package/src/commands/move.ts

@@ -0,0 +1,92 @@
+import type { Command } from "commander";
+import { TaskStore } from "../storage/task-store.ts";
+import { findTaskById } from "../models/task.ts";
+import { TaskNotFoundError, ChopError } from "../errors.ts";
+
+async function moveTask(id: string, position: "top" | "bottom"): Promise<void> {
+  const store = await TaskStore.create();
+
+  await store.atomicUpdate((data) => {
+    const task = findTaskById(id, data.tasks);
+
+    if (!task) {
+      throw new TaskNotFoundError(id);
+    }
+
+    // Find and remove the task from its current position
+    const index = data.tasks.findIndex((t) => t.id === task.id);
+    data.tasks.splice(index, 1);
+
+    // Insert at new position
+    if (position === "top") {
+      data.tasks.unshift(task);
+    } else {
+      data.tasks.push(task);
+    }
+
+    task.updatedAt = new Date().toISOString();
+
+    return { data, result: task };
+  });
+
+  console.log(`Moved task ${id} to ${position}`);
+}
+
+export function registerMoveCommand(program: Command): void {
+  program
+    .command("move <id>")
+    .alias("mv")
+    .description("Move a task in the queue")
+    .option("-t, --top", "Move to top of queue")
+    .option("-b, --bottom", "Move to bottom of queue")
+    .action(async (id: string, options) => {
+      try {
+        if (!options.top && !options.bottom) {
+          throw new ChopError("Must specify --top or --bottom");
+        }
+
+        await moveTask(id, options.top ? "top" : "bottom");
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else {
+          console.error("An unexpected error occurred");
+        }
+        process.exit(1);
+      }
+    });
+
+  // Shortcut: mt <id> = move <id> --top
+  program
+    .command("mt <id>")
+    .description("Move a task to top of queue (alias for move --top)")
+    .action(async (id: string) => {
+      try {
+        await moveTask(id, "top");
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else {
+          console.error("An unexpected error occurred");
+        }
+        process.exit(1);
+      }
+    });
+
+  // Shortcut: mb <id> = move <id> --bottom
+  program
+    .command("mb <id>")
+    .description("Move a task to bottom of queue (alias for move --bottom)")
+    .action(async (id: string) => {
+      try {
+        await moveTask(id, "bottom");
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else {
+          console.error("An unexpected error occurred");
+        }
+        process.exit(1);
+      }
+    });
+}

package/src/commands/pop.ts

@@ -0,0 +1,45 @@
+import type { Command } from "commander";
+import { TaskStore } from "../storage/task-store.ts";
+import { getNextAvailableTask } from "../models/task.ts";
+import { formatTaskDetail } from "../utils/display.ts";
+
+export function registerPopCommand(program: Command): void {
+  program
+    .command("pop")
+    .alias("p")
+    .description("Get the next available task and mark it as in-progress")
+    .action(async () => {
+      try {
+        const store = await TaskStore.create();
+
+        const result = await store.atomicUpdate((data) => {
+          const task = getNextAvailableTask(data.tasks);
+
+          if (!task) {
+            return { data, result: null };
+          }
+
+          // Mark as in-progress
+          task.status = "in-progress";
+          task.updatedAt = new Date().toISOString();
+
+          return { data, result: task };
+        });
+
+        if (!result) {
+          console.log("No tasks available");
+          return;
+        }
+
+        const tasksData = await store.readTasks();
+        console.log(formatTaskDetail(result, tasksData.tasks));
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else {
+          console.error("An unexpected error occurred");
+        }
+        process.exit(1);
+      }
+    });
+}

package/src/commands/purge.ts

@@ -0,0 +1,41 @@
+import type { Command } from "commander";
+import { TaskStore } from "../storage/task-store.ts";
+import { confirm } from "../utils/prompts.ts";
+
+export function registerPurgeCommand(program: Command): void {
+  program
+    .command("purge")
+    .description("Permanently delete all archived tasks")
+    .action(async () => {
+      try {
+        const store = await TaskStore.create();
+        const archivedData = await store.readArchivedTasks();
+
+        if (archivedData.tasks.length === 0) {
+          console.log("No archived tasks to purge.");
+          return;
+        }
+
+        console.log(`Found ${archivedData.tasks.length} archived task(s).`);
+        const confirmed = await confirm(
+          "Permanently delete all archived tasks? This cannot be undone.",
+          false
+        );
+
+        if (!confirmed) {
+          console.log("Purge cancelled.");
+          return;
+        }
+
+        const count = await store.purgeArchived();
+        console.log(`Purged ${count} archived task(s).`);
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else {
+          console.error("An unexpected error occurred");
+        }
+        process.exit(1);
+      }
+    });
+}

package/src/commands/show.ts

@@ -0,0 +1,32 @@
+import type { Command } from "commander";
+import { TaskStore } from "../storage/task-store.ts";
+import { findTaskById } from "../models/task.ts";
+import { formatTaskDetail } from "../utils/display.ts";
+import { TaskNotFoundError } from "../errors.ts";
+
+export function registerShowCommand(program: Command): void {
+  program
+    .command("show <id>")
+    .alias("s")
+    .description("Display full task info by ID")
+    .action(async (id: string) => {
+      try {
+        const store = await TaskStore.create();
+        const tasksData = await store.readTasks();
+        const task = findTaskById(id, tasksData.tasks);
+
+        if (!task) {
+          throw new TaskNotFoundError(id);
+        }
+
+        console.log(formatTaskDetail(task, tasksData.tasks));
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else {
+          console.error("An unexpected error occurred");
+        }
+        process.exit(1);
+      }
+    });
+}

package/src/commands/status.ts

@@ -0,0 +1,43 @@
+import type { Command } from "commander";
+import { TaskStore } from "../storage/task-store.ts";
+import { findTaskById, isValidStatus } from "../models/task.ts";
+import { TaskNotFoundError, InvalidStatusError } from "../errors.ts";
+import type { TaskStatus } from "../types.ts";
+
+export function registerStatusCommand(program: Command): void {
+  program
+    .command("status <id> <status>")
+    .description("Change task status (draft, open, in-progress, done)")
+    .action(async (id: string, status: string) => {
+      try {
+        // Validate status
+        if (!isValidStatus(status) || status === "archived") {
+          throw new InvalidStatusError(status);
+        }
+
+        const store = await TaskStore.create();
+
+        await store.atomicUpdate((data) => {
+          const task = findTaskById(id, data.tasks);
+
+          if (!task) {
+            throw new TaskNotFoundError(id);
+          }
+
+          task.status = status as TaskStatus;
+          task.updatedAt = new Date().toISOString();
+
+          return { data, result: task };
+        });
+
+        console.log(`Changed task ${id} status to ${status}`);
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else {
+          console.error("An unexpected error occurred");
+        }
+        process.exit(1);
+      }
+    });
+}

package/src/config/paths.ts

@@ -0,0 +1,61 @@
+import { homedir } from "os";
+import { join } from "path";
+import { getGitRepoRoot, getProjectId } from "../utils/git.ts";
+
+// Get the global storage directory (~/.local/share/chop)
+export function getGlobalStorageDir(): string {
+  return join(homedir(), ".local", "share", "chop");
+}
+
+// Get the global config directory (~/.config/chop)
+export function getGlobalConfigDir(): string {
+  return join(homedir(), ".config", "chop");
+}
+
+// Get the local storage directory (.chop in repo root)
+export async function getLocalStorageDir(): Promise<string> {
+  const repoRoot = await getGitRepoRoot();
+  return join(repoRoot, ".chop");
+}
+
+// Get the path to the tasks file for a given storage location
+export async function getTasksFilePath(
+  location: "local" | "global"
+): Promise<string> {
+  if (location === "local") {
+    const localDir = await getLocalStorageDir();
+    return join(localDir, "tasks.json");
+  }
+
+  const projectId = await getProjectId();
+  return join(getGlobalStorageDir(), projectId, "tasks.json");
+}
+
+// Get the path to the archived tasks file
+export async function getArchivedTasksFilePath(
+  location: "local" | "global"
+): Promise<string> {
+  if (location === "local") {
+    const localDir = await getLocalStorageDir();
+    return join(localDir, "tasks.archived.json");
+  }
+
+  const projectId = await getProjectId();
+  return join(getGlobalStorageDir(), projectId, "tasks.archived.json");
+}
+
+// Get the lock file path for a given tasks file
+export function getLockFilePath(tasksFilePath: string): string {
+  return tasksFilePath + ".lock";
+}
+
+// Get the local config file path (.chop/config.json)
+export async function getLocalConfigPath(): Promise<string> {
+  const localDir = await getLocalStorageDir();
+  return join(localDir, "config.json");
+}
+
+// Get the global config file path (~/.config/chop/config.json)
+export function getGlobalConfigPath(): string {
+  return join(getGlobalConfigDir(), "config.json");
+}

package/src/errors.ts

@@ -0,0 +1,56 @@
+// Base error class for chop
+export class ChopError extends Error {
+  constructor(message: string) {
+    super(`Error: ${message}`);
+    this.name = "ChopError";
+  }
+}
+
+// Not in a git repository
+export class NotInGitRepoError extends ChopError {
+  constructor() {
+    super("Not in a git repository");
+  }
+}
+
+// Project not initialized
+export class NotInitializedError extends ChopError {
+  constructor() {
+    super("Project not initialized. Run 'chop init'");
+  }
+}
+
+// Task not found
+export class TaskNotFoundError extends ChopError {
+  constructor(id: string) {
+    super(`Task ${id} not found`);
+  }
+}
+
+// Cannot acquire lock
+export class LockError extends ChopError {
+  constructor() {
+    super("Cannot acquire lock. Another process is accessing tasks");
+  }
+}
+
+// Invalid task status
+export class InvalidStatusError extends ChopError {
+  constructor(status: string) {
+    super(`Invalid status: ${status}. Use: open, in-progress, or done`);
+  }
+}
+
+// Task has unarchived dependents
+export class HasDependentsError extends ChopError {
+  constructor(dependentIds: string[]) {
+    super(`Task has unarchived dependents: ${dependentIds.join(", ")}`);
+  }
+}
+
+// Already initialized
+export class AlreadyInitializedError extends ChopError {
+  constructor() {
+    super("Project already initialized");
+  }
+}

package/src/index.ts

@@ -0,0 +1,41 @@
+import { Command } from "commander";
+import { registerInitCommand } from "./commands/init.ts";
+import { registerAddCommand } from "./commands/add.ts";
+import { registerListCommand } from "./commands/list.ts";
+import { registerPopCommand } from "./commands/pop.ts";
+import { registerDoneCommand } from "./commands/done.ts";
+import { registerStatusCommand } from "./commands/status.ts";
+import { registerMoveCommand } from "./commands/move.ts";
+import { registerArchiveCommand } from "./commands/archive.ts";
+import { registerPurgeCommand } from "./commands/purge.ts";
+import { registerEditCommand } from "./commands/edit.ts";
+import { registerShowCommand } from "./commands/show.ts";
+import { registerCompletionCommand } from "./commands/completion.ts";
+
+const program = new Command();
+
+program
+  .name("chop")
+  .description("Queue-based task management CLI for developers")
+  .version("1.0.0");
+
+// Register all commands
+registerInitCommand(program);
+registerAddCommand(program);
+registerListCommand(program);
+registerPopCommand(program);
+registerDoneCommand(program);
+registerStatusCommand(program);
+registerMoveCommand(program);
+registerArchiveCommand(program);
+registerPurgeCommand(program);
+registerEditCommand(program);
+registerShowCommand(program);
+registerCompletionCommand(program);
+
+// Show help if no command provided
+if (process.argv.length === 2) {
+  program.help();
+}
+
+program.parse();

package/src/models/id-generator.ts

@@ -0,0 +1,39 @@
+// Generate a unique task ID in format: "a1b2c3d-N"
+// where the first part is a 7-char random hash and N is the sequence number
+
+export interface GeneratedId {
+  id: string;
+  newSequence: number;
+}
+
+// Generate a random 7-character hex hash
+function generateHash(): string {
+  const randomBytes = crypto.getRandomValues(new Uint8Array(4));
+  let hash = "";
+  for (const byte of randomBytes) {
+    hash += byte.toString(16).padStart(2, "0");
+  }
+  return hash.slice(0, 7);
+}
+
+// Generate a new task ID
+export function generateTaskId(lastSequence: number): GeneratedId {
+  const hash = generateHash();
+  const newSequence = lastSequence + 1;
+  return {
+    id: `${hash}-${newSequence}`,
+    newSequence,
+  };
+}
+
+// Parse a task ID into its components
+export function parseTaskId(id: string): { hash: string; sequence: number } | null {
+  const match = id.match(/^([a-f0-9]{7})-(\d+)$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    hash: match[1]!,
+    sequence: parseInt(match[2]!, 10),
+  };
+}

package/src/models/task.ts

@@ -0,0 +1,98 @@
+import type { Task, TaskStatus, TasksFile } from "../types.ts";
+import { generateTaskId } from "./id-generator.ts";
+
+export interface CreateTaskOptions {
+  title: string;
+  description?: string;
+  dependsOn?: string[];
+  status?: "draft" | "open";
+}
+
+// Create a new task
+export function createTask(
+  lastSequence: number,
+  options: CreateTaskOptions
+): { task: Task; newSequence: number } {
+  const { id, newSequence } = generateTaskId(lastSequence);
+  const now = new Date().toISOString();
+
+  const task: Task = {
+    id,
+    title: options.title,
+    description: options.description,
+    status: options.status ?? "open",
+    dependsOn: options.dependsOn || [],
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  return { task, newSequence };
+}
+
+// Check if a task is blocked (has incomplete dependencies)
+export function isBlocked(task: Task, tasks: Task[]): boolean {
+  if (task.dependsOn.length === 0) {
+    return false;
+  }
+
+  return task.dependsOn.some((depId) => {
+    const dep = tasks.find((t) => t.id === depId);
+    // Task is blocked if dependency exists and is not done/archived
+    return dep && dep.status !== "done" && dep.status !== "archived";
+  });
+}
+
+// Find tasks that depend on a given task (direct dependents)
+export function findDependents(taskId: string, tasks: Task[]): Task[] {
+  return tasks.filter((t) => t.dependsOn.includes(taskId));
+}
+
+// Find all tasks that depend on a given task (recursive)
+export function findAllDependents(taskId: string, tasks: Task[]): Task[] {
+  const allDependents = new Set<Task>();
+  const visited = new Set<string>();
+
+  function collectDependents(id: string): void {
+    if (visited.has(id)) return;
+    visited.add(id);
+
+    const directDependents = findDependents(id, tasks);
+    for (const dep of directDependents) {
+      allDependents.add(dep);
+      collectDependents(dep.id);
+    }
+  }
+
+  collectDependents(taskId);
+  return Array.from(allDependents);
+}
+
+// Find a task by ID (supports partial matching)
+export function findTaskById(id: string, tasks: Task[]): Task | undefined {
+  // Exact match first
+  const exact = tasks.find((t) => t.id === id);
+  if (exact) return exact;
+
+  // Partial match (starts with)
+  const partial = tasks.filter((t) => t.id.startsWith(id));
+  if (partial.length === 1) {
+    return partial[0];
+  }
+
+  return undefined;
+}
+
+// Validate a status string
+export function isValidStatus(status: string): status is TaskStatus {
+  return ["draft", "open", "in-progress", "done", "archived"].includes(status);
+}
+
+// Get the first available (open, unblocked) task
+export function getNextAvailableTask(tasks: Task[]): Task | undefined {
+  for (const task of tasks) {
+    if (task.status === "open" && !isBlocked(task, tasks)) {
+      return task;
+    }
+  }
+  return undefined;
+}

package/src/storage/file-lock.ts

@@ -0,0 +1,124 @@
+import {
+  closeSync,
+  existsSync,
+  openSync,
+  readFileSync,
+  unlinkSync,
+  writeSync,
+} from "node:fs";
+import { LockError } from "../errors.ts";
+
+// Retry delays in milliseconds (exponential backoff)
+const RETRY_DELAYS = [100, 200, 400, 800, 1600];
+
+// Stale lock threshold (60 seconds)
+const STALE_LOCK_MS = 60_000;
+
+interface LockInfo {
+  pid: number;
+  timestamp: number;
+}
+
+// Sleep for a given number of milliseconds
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Check if a lock file is stale
+function isLockStale(lockPath: string): boolean {
+  try {
+    const content = readFileSync(lockPath, "utf-8");
+    const lockInfo: LockInfo = JSON.parse(content);
+    const age = Date.now() - lockInfo.timestamp;
+    return age > STALE_LOCK_MS;
+  } catch {
+    // If we can't read the lock file, assume it's stale
+    return true;
+  }
+}
+
+// Try to acquire a lock file
+function tryAcquireLock(lockPath: string): boolean {
+  try {
+    // O_CREAT | O_EXCL | O_WRONLY - create exclusively, fail if exists
+    const fd = openSync(lockPath, "wx");
+    const lockInfo: LockInfo = {
+      pid: process.pid,
+      timestamp: Date.now(),
+    };
+    // Write to fd before closing to avoid race condition where lock file
+    // exists but is empty
+    writeSync(fd, JSON.stringify(lockInfo));
+    closeSync(fd);
+    return true;
+  } catch (error: unknown) {
+    // File already exists (another process has the lock)
+    if (
+      error &&
+      typeof error === "object" &&
+      "code" in error &&
+      error.code === "EEXIST"
+    ) {
+      return false;
+    }
+    // Some other error - rethrow
+    throw error;
+  }
+}
+
+// Release a lock file
+function releaseLock(lockPath: string): void {
+  try {
+    if (existsSync(lockPath)) {
+      unlinkSync(lockPath);
+    }
+  } catch {
+    // Ignore errors when releasing - the lock might already be gone
+  }
+}
+
+// Acquire a lock with retries
+async function acquireLock(lockPath: string): Promise<void> {
+  // First attempt
+  if (tryAcquireLock(lockPath)) {
+    return;
+  }
+
+  // Check if existing lock is stale and remove it
+  if (isLockStale(lockPath)) {
+    releaseLock(lockPath);
+    if (tryAcquireLock(lockPath)) {
+      return;
+    }
+  }
+
+  // Retry with exponential backoff
+  for (const delay of RETRY_DELAYS) {
+    await sleep(delay);
+
+    // Check for stale lock again
+    if (isLockStale(lockPath)) {
+      releaseLock(lockPath);
+    }
+
+    if (tryAcquireLock(lockPath)) {
+      return;
+    }
+  }
+
+  // Failed to acquire lock after all retries
+  throw new LockError();
+}
+
+// Execute an operation with a file lock
+export async function withLock<T>(
+  lockPath: string,
+  operation: () => Promise<T>
+): Promise<T> {
+  await acquireLock(lockPath);
+  try {
+    return await operation();
+  } finally {
+    releaseLock(lockPath);
+  }
+}