@da1z/chop 0.0.1

package/src/storage/storage-resolver.ts

@@ -0,0 +1,63 @@
+import { NotInitializedError } from "../errors.ts";
+import {
+  getLocalStorageDir,
+  getTasksFilePath,
+  getArchivedTasksFilePath,
+} from "../config/paths.ts";
+import type { StorageLocation } from "../types.ts";
+
+export interface StorageInfo {
+  location: StorageLocation;
+  tasksPath: string;
+  archivedPath: string;
+}
+
+// Resolve which storage location to use for the current project
+// Resolution order: local (.chop/) first, then global
+export async function resolveStorage(): Promise<StorageInfo> {
+  // Check for local storage first
+  const localTasksPath = await getTasksFilePath("local");
+  const localFile = Bun.file(localTasksPath);
+
+  if (await localFile.exists()) {
+    return {
+      location: "local",
+      tasksPath: localTasksPath,
+      archivedPath: await getArchivedTasksFilePath("local"),
+    };
+  }
+
+  // Check for global storage
+  const globalTasksPath = await getTasksFilePath("global");
+  const globalFile = Bun.file(globalTasksPath);
+
+  if (await globalFile.exists()) {
+    return {
+      location: "global",
+      tasksPath: globalTasksPath,
+      archivedPath: await getArchivedTasksFilePath("global"),
+    };
+  }
+
+  // Neither exists
+  throw new NotInitializedError();
+}
+
+// Check if the project has been initialized
+export async function isInitialized(): Promise<boolean> {
+  try {
+    await resolveStorage();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Check if local storage exists (for init command)
+export async function hasLocalStorage(): Promise<boolean> {
+  const localDir = await getLocalStorageDir();
+  const localDirFile = Bun.file(localDir);
+  // Check if the directory exists by checking for tasks.json
+  const localTasksPath = await getTasksFilePath("local");
+  return await Bun.file(localTasksPath).exists();
+}

package/src/storage/task-store.ts

@@ -0,0 +1,173 @@
+import { mkdir } from "node:fs/promises";
+import { dirname } from "path";
+import type { Task, TasksFile, StorageLocation } from "../types.ts";
+import { withLock } from "./file-lock.ts";
+import { resolveStorage, type StorageInfo } from "./storage-resolver.ts";
+import { getLockFilePath, getTasksFilePath, getArchivedTasksFilePath } from "../config/paths.ts";
+
+// Create an empty tasks file structure
+function createEmptyTasksFile(): TasksFile {
+  return {
+    version: 1,
+    lastSequence: 0,
+    tasks: [],
+  };
+}
+
+// Task store class for managing tasks with file locking
+export class TaskStore {
+  private storageInfo: StorageInfo;
+
+  private constructor(storageInfo: StorageInfo) {
+    this.storageInfo = storageInfo;
+  }
+
+  // Create a TaskStore instance by resolving storage location
+  static async create(): Promise<TaskStore> {
+    const storageInfo = await resolveStorage();
+    return new TaskStore(storageInfo);
+  }
+
+  // Create a TaskStore for a specific location (used by init)
+  static async createForLocation(location: StorageLocation): Promise<TaskStore> {
+    const tasksPath = await getTasksFilePath(location);
+    const archivedPath = await getArchivedTasksFilePath(location);
+    return new TaskStore({ location, tasksPath, archivedPath });
+  }
+
+  // Get the lock file path
+  private get lockPath(): string {
+    return getLockFilePath(this.storageInfo.tasksPath);
+  }
+
+  // Read tasks file (with lock)
+  async readTasks(): Promise<TasksFile> {
+    return withLock(this.lockPath, async () => {
+      const file = Bun.file(this.storageInfo.tasksPath);
+      if (!(await file.exists())) {
+        return createEmptyTasksFile();
+      }
+      const content = await file.text();
+      return JSON.parse(content) as TasksFile;
+    });
+  }
+
+  // Write tasks file (with lock) - internal use only
+  private async writeTasks(data: TasksFile): Promise<void> {
+    await Bun.write(this.storageInfo.tasksPath, JSON.stringify(data, null, 2));
+  }
+
+  // Atomic read-modify-write operation
+  async atomicUpdate<T>(
+    operation: (data: TasksFile) => { data: TasksFile; result: T }
+  ): Promise<T> {
+    return withLock(this.lockPath, async () => {
+      const file = Bun.file(this.storageInfo.tasksPath);
+      let data: TasksFile;
+
+      if (await file.exists()) {
+        const content = await file.text();
+        data = JSON.parse(content) as TasksFile;
+      } else {
+        data = createEmptyTasksFile();
+      }
+
+      const { data: newData, result } = operation(data);
+      await this.writeTasks(newData);
+      return result;
+    });
+  }
+
+  // Read archived tasks
+  async readArchivedTasks(): Promise<TasksFile> {
+    return withLock(this.lockPath, async () => {
+      const file = Bun.file(this.storageInfo.archivedPath);
+      if (!(await file.exists())) {
+        return createEmptyTasksFile();
+      }
+      const content = await file.text();
+      return JSON.parse(content) as TasksFile;
+    });
+  }
+
+  // Write archived tasks
+  private async writeArchivedTasks(data: TasksFile): Promise<void> {
+    await Bun.write(this.storageInfo.archivedPath, JSON.stringify(data, null, 2));
+  }
+
+  // Archive a task (move from tasks to archived)
+  async archiveTask(taskId: string): Promise<Task> {
+    return withLock(this.lockPath, async () => {
+      // Read both files
+      const tasksFile = Bun.file(this.storageInfo.tasksPath);
+      const tasksContent = await tasksFile.text();
+      const tasksData: TasksFile = JSON.parse(tasksContent);
+
+      const archivedFile = Bun.file(this.storageInfo.archivedPath);
+      let archivedData: TasksFile;
+      if (await archivedFile.exists()) {
+        const archivedContent = await archivedFile.text();
+        archivedData = JSON.parse(archivedContent);
+      } else {
+        archivedData = createEmptyTasksFile();
+      }
+
+      // Find and remove the task from active tasks
+      const taskIndex = tasksData.tasks.findIndex((t) => t.id === taskId);
+      if (taskIndex === -1) {
+        throw new Error(`Task ${taskId} not found`);
+      }
+
+      const task = tasksData.tasks.splice(taskIndex, 1)[0]!;
+      task.status = "archived";
+      task.updatedAt = new Date().toISOString();
+
+      // Add to archived
+      archivedData.tasks.push(task);
+
+      // Write both files
+      await this.writeTasks(tasksData);
+      await this.writeArchivedTasks(archivedData);
+
+      return task;
+    });
+  }
+
+  // Purge all archived tasks
+  async purgeArchived(): Promise<number> {
+    return withLock(this.lockPath, async () => {
+      const archivedFile = Bun.file(this.storageInfo.archivedPath);
+      if (!(await archivedFile.exists())) {
+        return 0;
+      }
+
+      const content = await archivedFile.text();
+      const data: TasksFile = JSON.parse(content);
+      const count = data.tasks.length;
+
+      // Clear archived tasks
+      data.tasks = [];
+      await this.writeArchivedTasks(data);
+
+      return count;
+    });
+  }
+
+  // Initialize storage (create directory and empty tasks file)
+  static async initialize(location: StorageLocation): Promise<void> {
+    const tasksPath = await getTasksFilePath(location);
+    const dir = dirname(tasksPath);
+
+    // Create directory if it doesn't exist
+    await mkdir(dir, { recursive: true });
+
+    // Create empty tasks file
+    const emptyTasks = createEmptyTasksFile();
+    await Bun.write(tasksPath, JSON.stringify(emptyTasks, null, 2));
+  }
+
+  // Get storage info
+  getStorageInfo(): StorageInfo {
+    return this.storageInfo;
+  }
+}

package/src/types.ts

@@ -0,0 +1,42 @@
+// Core task status
+export type TaskStatus = "draft" | "open" | "in-progress" | "done" | "archived";
+
+// Task model
+export interface Task {
+  id: string; // format: "a1b2c3d-1"
+  title: string;
+  description?: string;
+  status: TaskStatus;
+  dependsOn: string[]; // task IDs
+  createdAt: string; // ISO timestamp
+  updatedAt: string; // ISO timestamp
+}
+
+// Tasks file format (tasks.json)
+export interface TasksFile {
+  version: 1;
+  lastSequence: number;
+  tasks: Task[];
+}
+
+// Storage location type
+export type StorageLocation = "local" | "global";
+
+// Project-specific config
+export interface ProjectConfig {
+  storage: StorageLocation;
+}
+
+// Global config file format
+export interface Config {
+  defaultStorage: StorageLocation;
+  projects: Record<string, ProjectConfig>;
+}
+
+// Edit format for YAML editing
+export interface TaskEditData {
+  title: string;
+  description?: string;
+  status: TaskStatus;
+  depends_on: string[];
+}

package/src/utils/display.ts

@@ -0,0 +1,139 @@
+import type { Task } from "../types.ts";
+import { isBlocked } from "../models/task.ts";
+
+// ANSI color codes
+const colors = {
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m",
+};
+
+// Status display styles
+const statusStyles: Record<string, { text: string; color: string }> = {
+  draft: { text: "draft", color: colors.cyan },
+  open: { text: "open", color: colors.blue },
+  "in-progress": { text: "in-progress", color: colors.yellow },
+  done: { text: "done", color: colors.green },
+  archived: { text: "archived", color: colors.dim },
+};
+
+// Format a task status for display
+function formatStatus(status: string): string {
+  const style = statusStyles[status] || { text: status, color: colors.reset };
+  return `${style.color}${style.text}${colors.reset}`;
+}
+
+// Get visible length of a string (excluding ANSI codes)
+function visibleLength(str: string): number {
+  return str.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+
+// Pad a string to a specific width
+function pad(str: string, width: number): string {
+  const len = visibleLength(str);
+  const padding = width - len;
+  return str + " ".repeat(Math.max(0, padding));
+}
+
+// Truncate a string to a max visible length, accounting for ANSI codes
+function truncate(str: string, maxLength: number): string {
+  if (maxLength <= 0) return "";
+  if (visibleLength(str) <= maxLength) return str;
+
+  // Simple truncation: iterate through and count visible chars
+  let result = "";
+  let visible = 0;
+  let i = 0;
+
+  while (i < str.length && visible < maxLength - 1) {
+    // Check for ANSI escape sequence
+    if (str[i] === "\x1b" && str[i + 1] === "[") {
+      const end = str.indexOf("m", i);
+      if (end !== -1) {
+        result += str.slice(i, end + 1);
+        i = end + 1;
+        continue;
+      }
+    }
+    result += str[i];
+    visible++;
+    i++;
+  }
+
+  return result + "\u2026"; // ellipsis character
+}
+
+// Get terminal width or default
+function getTerminalWidth(): number {
+  return process.stdout.columns || 80;
+}
+
+// Format a single task for list display
+export function formatTaskRow(task: Task, allTasks: Task[]): string {
+  const blocked = task.status === "open" && isBlocked(task, allTasks);
+  const blockedMarker = blocked ? `${colors.dim}[blocked]${colors.reset} ` : "";
+
+  const id = pad(task.id, 12);
+  const status = pad(formatStatus(task.status), 22); // Extra width for ANSI codes
+
+  // Calculate available width for title: terminal width - id (12) - status (12) - spaces (2)
+  const termWidth = getTerminalWidth();
+  const titleMaxWidth = termWidth - 12 - 12 - 2;
+
+  const blockedMarkerLen = visibleLength(blockedMarker);
+  const titleWidth = titleMaxWidth - blockedMarkerLen;
+  const truncatedTitle = truncate(task.title, titleWidth);
+  const title = blockedMarker + truncatedTitle;
+
+  return `${id} ${status} ${title}`;
+}
+
+// Format task list as a table
+export function formatTaskTable(tasks: Task[], allTasks: Task[]): string {
+  if (tasks.length === 0) {
+    return "No tasks found.";
+  }
+
+  const header = `${pad("ID", 12)} ${pad("STATUS", 12)} TITLE`;
+  const separator = "-".repeat(60);
+  const rows = tasks.map((task) => formatTaskRow(task, allTasks));
+
+  return [header, separator, ...rows].join("\n");
+}
+
+// Format a single task for detailed display (after pop, add, etc.)
+export function formatTaskDetail(task: Task, allTasks?: Task[]): string {
+  const lines = [
+    `${colors.cyan}ID:${colors.reset} ${task.id}`,
+    `${colors.cyan}Title:${colors.reset} ${task.title}`,
+    `${colors.cyan}Status:${colors.reset} ${formatStatus(task.status)}`,
+  ];
+
+  if (task.description) {
+    lines.push(`${colors.cyan}Description:${colors.reset}`);
+    lines.push(task.description.split("\n").map((l) => `  ${l}`).join("\n"));
+  }
+
+  if (task.dependsOn.length > 0) {
+    lines.push(`${colors.cyan}Depends on:${colors.reset} ${task.dependsOn.join(", ")}`);
+  }
+
+  if (allTasks && task.status === "open" && isBlocked(task, allTasks)) {
+    lines.push(`${colors.yellow}Status: BLOCKED${colors.reset}`);
+  }
+
+  return lines.join("\n");
+}
+
+// Format success message
+export function success(message: string): string {
+  return `${colors.green}${message}${colors.reset}`;
+}
+
+// Format error message
+export function error(message: string): string {
+  return message; // Errors go to stderr, keep simple
+}

package/src/utils/git.ts

@@ -0,0 +1,80 @@
+import { $ } from "bun";
+import { NotInGitRepoError } from "../errors.ts";
+
+// Get the root directory of the current git repository
+export async function getGitRepoRoot(): Promise<string> {
+  try {
+    const result = await $`git rev-parse --show-toplevel`.text();
+    return result.trim();
+  } catch {
+    throw new NotInGitRepoError();
+  }
+}
+
+// Get the git remote origin URL (if available)
+export async function getGitRemoteUrl(): Promise<string | null> {
+  try {
+    const result = await $`git remote get-url origin`.text();
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+// Normalize a remote URL to a consistent project ID format
+// e.g., "git@github.com:user/repo.git" -> "github.com/user/repo"
+// e.g., "https://github.com/user/repo.git" -> "github.com/user/repo"
+function normalizeRemoteUrl(url: string): string {
+  // Remove .git suffix
+  let normalized = url.replace(/\.git$/, "");
+
+  // Handle SSH format: git@github.com:user/repo
+  if (normalized.startsWith("git@")) {
+    normalized = normalized.replace(/^git@/, "").replace(":", "/");
+  }
+
+  // Handle HTTPS format: https://github.com/user/repo
+  if (normalized.startsWith("https://")) {
+    normalized = normalized.replace(/^https:\/\//, "");
+  }
+
+  if (normalized.startsWith("http://")) {
+    normalized = normalized.replace(/^http:\/\//, "");
+  }
+
+  return normalized;
+}
+
+// Hash a string to create a short identifier
+function hashString(str: string): string {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash; // Convert to 32-bit integer
+  }
+  return Math.abs(hash).toString(16).slice(0, 8);
+}
+
+// Get a unique project identifier for the current repository
+// Uses remote URL if available, otherwise uses repo path hash
+export async function getProjectId(): Promise<string> {
+  const remoteUrl = await getGitRemoteUrl();
+  if (remoteUrl) {
+    return normalizeRemoteUrl(remoteUrl);
+  }
+
+  // Fall back to repo path hash for local-only repos
+  const repoRoot = await getGitRepoRoot();
+  return hashString(repoRoot);
+}
+
+// Check if we're inside a git repository
+export async function isInGitRepo(): Promise<boolean> {
+  try {
+    await $`git rev-parse --git-dir`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/prompts.ts

@@ -0,0 +1,88 @@
+import prompts from "prompts";
+
+// Prompt for a yes/no confirmation
+export async function confirm(message: string, defaultYes = false): Promise<boolean> {
+  const response = await prompts({
+    type: "confirm",
+    name: "value",
+    message,
+    initial: defaultYes,
+  });
+
+  // Handle cancellation (Ctrl+C)
+  if (response.value === undefined) {
+    process.exit(0);
+  }
+
+  return response.value;
+}
+
+// Prompt for text input
+export async function prompt(message: string, defaultValue?: string): Promise<string> {
+  const response = await prompts({
+    type: "text",
+    name: "value",
+    message,
+    initial: defaultValue,
+  });
+
+  // Handle cancellation (Ctrl+C)
+  if (response.value === undefined) {
+    process.exit(0);
+  }
+
+  return response.value;
+}
+
+// Prompt for a selection from a list of options
+export async function select<T extends string>(
+  message: string,
+  options: { value: T; label: string }[]
+): Promise<T> {
+  const response = await prompts({
+    type: "select",
+    name: "value",
+    message,
+    choices: options.map((opt) => ({
+      title: opt.label,
+      value: opt.value,
+    })),
+  });
+
+  // Handle cancellation (Ctrl+C)
+  if (response.value === undefined) {
+    process.exit(0);
+  }
+
+  return response.value;
+}
+
+// Prompt for selecting multiple tasks (for --depends-on without ID)
+export async function selectTasks(
+  message: string,
+  tasks: { id: string; title: string }[]
+): Promise<string[]> {
+  if (tasks.length === 0) {
+    console.log("No tasks available to select.");
+    return [];
+  }
+
+  const response = await prompts({
+    type: "multiselect",
+    name: "value",
+    message,
+    choices: tasks.map((task) => ({
+      title: `${task.id} - ${task.title}`,
+      value: task.id,
+    })),
+    hint: "- Space to select. Return to submit",
+    instructions: false,
+  });
+
+  // Handle cancellation (Ctrl+C)
+  if (response.value === undefined) {
+    process.exit(0);
+  }
+
+  return response.value;
+}

package/tests/errors.test.ts

@@ -0,0 +1,86 @@
+import { test, expect, describe } from "bun:test";
+import {
+  ChopError,
+  NotInGitRepoError,
+  NotInitializedError,
+  TaskNotFoundError,
+  LockError,
+  InvalidStatusError,
+  HasDependentsError,
+  AlreadyInitializedError,
+} from "../src/errors.ts";
+
+describe("ChopError", () => {
+  test("creates error with message prefix", () => {
+    const error = new ChopError("test message");
+    expect(error.message).toBe("Error: test message");
+    expect(error.name).toBe("ChopError");
+  });
+
+  test("is an instance of Error", () => {
+    const error = new ChopError("test");
+    expect(error).toBeInstanceOf(Error);
+  });
+});
+
+describe("NotInGitRepoError", () => {
+  test("creates error with correct message", () => {
+    const error = new NotInGitRepoError();
+    expect(error.message).toBe("Error: Not in a git repository");
+    expect(error.name).toBe("ChopError");
+  });
+});
+
+describe("NotInitializedError", () => {
+  test("creates error with correct message", () => {
+    const error = new NotInitializedError();
+    expect(error.message).toBe("Error: Project not initialized. Run 'chop init'");
+    expect(error.name).toBe("ChopError");
+  });
+});
+
+describe("TaskNotFoundError", () => {
+  test("creates error with task id in message", () => {
+    const error = new TaskNotFoundError("abc123");
+    expect(error.message).toBe("Error: Task abc123 not found");
+    expect(error.name).toBe("ChopError");
+  });
+});
+
+describe("LockError", () => {
+  test("creates error with correct message", () => {
+    const error = new LockError();
+    expect(error.message).toBe("Error: Cannot acquire lock. Another process is accessing tasks");
+    expect(error.name).toBe("ChopError");
+  });
+});
+
+describe("InvalidStatusError", () => {
+  test("creates error with status in message", () => {
+    const error = new InvalidStatusError("invalid-status");
+    expect(error.message).toBe("Error: Invalid status: invalid-status. Use: open, in-progress, or done");
+    expect(error.name).toBe("ChopError");
+  });
+});
+
+describe("HasDependentsError", () => {
+  test("creates error with single dependent id", () => {
+    const error = new HasDependentsError(["task1"]);
+    expect(error.message).toBe("Error: Task has unarchived dependents: task1");
+    expect(error.name).toBe("ChopError");
+  });
+
+  test("creates error with multiple dependent ids", () => {
+    const error = new HasDependentsError(["task1", "task2", "task3"]);
+    expect(error.message).toBe("Error: Task has unarchived dependents: task1, task2, task3");
+    expect(error.name).toBe("ChopError");
+  });
+});
+
+describe("AlreadyInitializedError", () => {
+  test("creates error with correct message", () => {
+    const error = new AlreadyInitializedError();
+    expect(error.message).toBe("Error: Project already initialized");
+    expect(error.name).toBe("ChopError");
+  });
+});