@da1z/chop 0.0.1

package/src/commands/completion.ts

@@ -0,0 +1,232 @@
+import type { Command } from "commander";
+import { TaskStore } from "../storage/task-store.ts";
+
+// Generate bash completion script
+function generateBashCompletion(): string {
+  return `# Bash completion for chop
+# Add this to your ~/.bashrc or ~/.bash_profile:
+# eval "$(chop completion bash)"
+# or: eval "$(ch completion bash)"
+
+_chop_completions() {
+    local cur prev words cword
+
+    # Use bash-completion if available, otherwise fallback to basic parsing
+    if declare -F _init_completion >/dev/null 2>&1; then
+        _init_completion || return
+    else
+        cur="\${COMP_WORDS[COMP_CWORD]}"
+        prev="\${COMP_WORDS[COMP_CWORD-1]}"
+        words=("\${COMP_WORDS[@]}")
+        cword=$COMP_CWORD
+    fi
+
+    local commands="init add a list ls pop p done d status move mv mt mb archive ar purge edit e show s completion"
+
+    # If completing the first argument (command name)
+    if [[ $cword -eq 1 ]]; then
+        COMPREPLY=($(compgen -W "$commands" -- "$cur"))
+        return
+    fi
+
+    # If completing argument for commands that need task ID
+    local cmd="\${words[1]}"
+    case "$cmd" in
+        done|d|move|mv|mt|mb|archive|ar|edit|e|show|s)
+            # Get task IDs from chop
+            local task_ids
+            task_ids=$(chop completion --list-ids 2>/dev/null)
+            COMPREPLY=($(compgen -W "$task_ids" -- "$cur"))
+            return
+            ;;
+    esac
+}
+
+complete -F _chop_completions chop
+complete -F _chop_completions ch
+`;
+}
+
+// Generate zsh completion script
+function generateZshCompletion(): string {
+  return `#compdef chop ch
+# Zsh completion for chop
+# Add this to your ~/.zshrc:
+# eval "$(chop completion zsh)"
+# or: eval "$(ch completion zsh)"
+
+_chop() {
+    local -a commands
+    commands=(
+        'init:Initialize chop in current directory'
+        'add:Add a new task'
+        'a:Add a new task (alias)'
+        'list:List tasks'
+        'ls:List tasks (alias)'
+        'pop:Start working on next task'
+        'p:Pop next task (alias)'
+        'done:Mark a task as done'
+        'd:Mark done (alias)'
+        'status:Change task status'
+        'move:Move a task in the queue'
+        'mv:Move task (alias)'
+        'mt:Move task to top'
+        'mb:Move task to bottom'
+        'archive:Archive a task'
+        'ar:Archive task (alias)'
+        'purge:Purge archived tasks'
+        'edit:Edit a task'
+        'e:Edit task (alias)'
+        'show:Display full task info'
+        's:Show task (alias)'
+        'completion:Generate shell completions'
+    )
+
+    _arguments -C \\
+        '1: :->command' \\
+        '*: :->args'
+
+    case $state in
+        command)
+            _describe 'command' commands
+            ;;
+        args)
+            case $words[2] in
+                done|d|move|mv|mt|mb|archive|ar|edit|e|show|s)
+                    local -a task_ids
+                    task_ids=(\${(f)"$(chop completion --list-ids 2>/dev/null)"})
+                    _describe 'task id' task_ids
+                    ;;
+            esac
+            ;;
+    esac
+}
+
+compdef _chop chop
+compdef _chop ch
+`;
+}
+
+// Generate fish completion script
+function generateFishCompletion(): string {
+  return `# Fish completion for chop
+# Add this to your ~/.config/fish/completions/chop.fish:
+# chop completion fish > ~/.config/fish/completions/chop.fish
+# or: ch completion fish > ~/.config/fish/completions/ch.fish
+
+# Disable file completion by default
+complete -c chop -f
+complete -c ch -f
+
+# All commands including aliases
+set -l all_cmds init add a list ls pop p done d status move mv mt mb archive ar purge edit e show s completion
+
+# Commands for chop
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a init -d "Initialize chop in current directory"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a add -d "Add a new task"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a a -d "Add a new task (alias)"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a list -d "List tasks"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a ls -d "List tasks (alias)"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a pop -d "Start working on next task"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a p -d "Pop next task (alias)"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a done -d "Mark a task as done"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a d -d "Mark done (alias)"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a status -d "Change task status"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a move -d "Move a task in the queue"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a mv -d "Move task (alias)"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a mt -d "Move task to top"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a mb -d "Move task to bottom"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a archive -d "Archive a task"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a ar -d "Archive task (alias)"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a purge -d "Purge archived tasks"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a edit -d "Edit a task"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a e -d "Edit task (alias)"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a show -d "Display full task info"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a s -d "Show task (alias)"
+complete -c chop -n "not __fish_seen_subcommand_from $all_cmds" -a completion -d "Generate shell completions"
+
+# Task ID completion for commands that need it
+complete -c chop -n "__fish_seen_subcommand_from done d move mv mt mb archive ar edit e show s" -a "(chop completion --list-ids 2>/dev/null)"
+
+# Same for ch alias
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a init -d "Initialize chop in current directory"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a add -d "Add a new task"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a a -d "Add a new task (alias)"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a list -d "List tasks"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a ls -d "List tasks (alias)"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a pop -d "Start working on next task"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a p -d "Pop next task (alias)"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a done -d "Mark a task as done"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a d -d "Mark done (alias)"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a status -d "Change task status"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a move -d "Move a task in the queue"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a mv -d "Move task (alias)"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a mt -d "Move task to top"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a mb -d "Move task to bottom"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a archive -d "Archive a task"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a ar -d "Archive task (alias)"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a purge -d "Purge archived tasks"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a edit -d "Edit a task"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a e -d "Edit task (alias)"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a show -d "Display full task info"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a s -d "Show task (alias)"
+complete -c ch -n "not __fish_seen_subcommand_from $all_cmds" -a completion -d "Generate shell completions"
+
+complete -c ch -n "__fish_seen_subcommand_from done d move mv mt mb archive ar edit e show s" -a "(ch completion --list-ids 2>/dev/null)"
+`;
+}
+
+// Get list of task IDs for completion
+async function getTaskIds(): Promise<string[]> {
+  try {
+    const store = await TaskStore.create();
+    const data = await store.readTasks();
+    return data.tasks.map((task) => task.id);
+  } catch {
+    // Return empty array if we can't read tasks (e.g., not initialized)
+    return [];
+  }
+}
+
+export function registerCompletionCommand(program: Command): void {
+  program
+    .command("completion [shell]")
+    .description("Generate shell completion script")
+    .option("--list-ids", "List task IDs (internal use)")
+    .action(async (shell: string | undefined, options: { listIds?: boolean }) => {
+      // Internal option for listing task IDs during completion
+      if (options.listIds) {
+        const ids = await getTaskIds();
+        console.log(ids.join("\n"));
+        return;
+      }
+
+      // Determine shell type
+      const targetShell = shell || detectShell();
+
+      switch (targetShell) {
+        case "bash":
+          console.log(generateBashCompletion());
+          break;
+        case "zsh":
+          console.log(generateZshCompletion());
+          break;
+        case "fish":
+          console.log(generateFishCompletion());
+          break;
+        default:
+          console.error(`Unknown shell: ${targetShell}`);
+          console.error("Supported shells: bash, zsh, fish");
+          process.exit(1);
+      }
+    });
+}
+
+// Detect current shell from environment
+function detectShell(): string {
+  const shell = process.env.SHELL || "";
+  if (shell.includes("zsh")) return "zsh";
+  if (shell.includes("fish")) return "fish";
+  if (shell.includes("bash")) return "bash";
+  return "bash"; // Default to bash
+}

package/src/commands/done.ts

@@ -0,0 +1,38 @@
+import type { Command } from "commander";
+import { TaskStore } from "../storage/task-store.ts";
+import { findTaskById } from "../models/task.ts";
+import { TaskNotFoundError } from "../errors.ts";
+
+export function registerDoneCommand(program: Command): void {
+  program
+    .command("done <id>")
+    .alias("d")
+    .description("Mark a task as done")
+    .action(async (id: string) => {
+      try {
+        const store = await TaskStore.create();
+
+        await store.atomicUpdate((data) => {
+          const task = findTaskById(id, data.tasks);
+
+          if (!task) {
+            throw new TaskNotFoundError(id);
+          }
+
+          task.status = "done";
+          task.updatedAt = new Date().toISOString();
+
+          return { data, result: task };
+        });
+
+        console.log(`Marked task ${id} as done`);
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else {
+          console.error("An unexpected error occurred");
+        }
+        process.exit(1);
+      }
+    });
+}

package/src/commands/edit.ts

@@ -0,0 +1,228 @@
+import type { Command } from "commander";
+import { tmpdir } from "os";
+import { join } from "path";
+import { unlinkSync } from "node:fs";
+import { TaskStore } from "../storage/task-store.ts";
+import { findTaskById, isValidStatus } from "../models/task.ts";
+import { TaskNotFoundError, ChopError, InvalidStatusError } from "../errors.ts";
+import type { Task, TaskStatus, TaskEditData } from "../types.ts";
+
+// Convert a task to YAML-like format for editing
+function taskToYaml(task: Task): string {
+  const lines: string[] = [];
+
+  lines.push(`title: ${task.title}`);
+
+  if (task.description) {
+    lines.push("description: |");
+    for (const line of task.description.split("\n")) {
+      lines.push(`  ${line}`);
+    }
+  } else {
+    lines.push("description:");
+  }
+
+  lines.push(`status: ${task.status}`);
+
+  if (task.dependsOn.length > 0) {
+    lines.push("depends_on:");
+    for (const dep of task.dependsOn) {
+      lines.push(`  - ${dep}`);
+    }
+  } else {
+    lines.push("depends_on:");
+  }
+
+  return lines.join("\n") + "\n";
+}
+
+// Parse YAML-like format back to task edit data
+function yamlToTaskEdit(content: string): TaskEditData {
+  const lines = content.split("\n");
+  const result: TaskEditData = {
+    title: "",
+    status: "open",
+    depends_on: [],
+  };
+
+  let inDescription = false;
+  let descriptionLines: string[] = [];
+  let inDependsOn = false;
+
+  for (const line of lines) {
+    // Check for field starts
+    if (line.startsWith("title:")) {
+      inDescription = false;
+      inDependsOn = false;
+      result.title = line.slice("title:".length).trim();
+    } else if (line.startsWith("description:")) {
+      inDescription = true;
+      inDependsOn = false;
+      descriptionLines = [];
+      const inline = line.slice("description:".length).trim();
+      if (inline && inline !== "|") {
+        descriptionLines.push(inline);
+        inDescription = false;
+      }
+    } else if (line.startsWith("status:")) {
+      inDescription = false;
+      inDependsOn = false;
+      result.status = line.slice("status:".length).trim() as TaskStatus;
+    } else if (line.startsWith("depends_on:")) {
+      inDescription = false;
+      inDependsOn = true;
+      result.depends_on = [];
+    } else if (inDescription && (line.startsWith("  ") || line === "")) {
+      // Description continuation (indented lines)
+      if (line.startsWith("  ")) {
+        descriptionLines.push(line.slice(2));
+      } else if (line === "" && descriptionLines.length > 0) {
+        descriptionLines.push("");
+      }
+    } else if (inDependsOn && line.startsWith("  - ")) {
+      // Depends on list item
+      result.depends_on.push(line.slice(4).trim());
+    } else if (line.trim() && !line.startsWith(" ")) {
+      // New field - end description
+      inDescription = false;
+      inDependsOn = false;
+    }
+  }
+
+  // Set description if we collected any lines
+  if (descriptionLines.length > 0) {
+    // Trim trailing empty lines
+    while (descriptionLines.length > 0 && descriptionLines[descriptionLines.length - 1] === "") {
+      descriptionLines.pop();
+    }
+    result.description = descriptionLines.join("\n");
+  }
+
+  return result;
+}
+
+interface EditOptions {
+  title?: string;
+  desc?: string;
+}
+
+export function registerEditCommand(program: Command): void {
+  program
+    .command("edit <id>")
+    .alias("e")
+    .description("Edit a task in your default editor")
+    .option("-t, --title <title>", "Set task title directly")
+    .option("-d, --desc <description>", "Set task description directly")
+    .action(async (id: string, options: EditOptions) => {
+      try {
+        const store = await TaskStore.create();
+
+        // Inline edit mode: if --title or --desc provided, update directly
+        if (options.title !== undefined || options.desc !== undefined) {
+          // Validate title is not empty if provided
+          if (options.title !== undefined && options.title.trim() === "") {
+            throw new ChopError("Title cannot be empty");
+          }
+
+          const updatedTask = await store.atomicUpdate((data) => {
+            const task = findTaskById(id, data.tasks);
+            if (!task) {
+              throw new TaskNotFoundError(id);
+            }
+
+            if (options.title !== undefined) {
+              task.title = options.title.trim();
+            }
+            if (options.desc !== undefined) {
+              task.description = options.desc.trim() || undefined;
+            }
+            task.updatedAt = new Date().toISOString();
+
+            return { data, result: task };
+          });
+
+          console.log(`Updated task ${updatedTask.id}`);
+          return;
+        }
+
+        // Editor mode: open task in external editor
+        const data = await store.readTasks();
+
+        // Find the task
+        const task = findTaskById(id, data.tasks);
+        if (!task) {
+          throw new TaskNotFoundError(id);
+        }
+
+        // Create temp file with YAML content
+        const tempPath = join(tmpdir(), `chop-edit-${task.id}.yaml`);
+        const originalContent = taskToYaml(task);
+        await Bun.write(tempPath, originalContent);
+
+        // Get editor from environment and parse into command + args
+        const editorEnv = process.env.EDITOR || process.env.VISUAL || "vi";
+        const editorParts = editorEnv.split(/\s+/).filter(Boolean);
+        const editorCmd = editorParts[0] || "vi";
+        const editorArgs = [...editorParts.slice(1), tempPath];
+
+        // Open editor
+        const proc = Bun.spawn([editorCmd, ...editorArgs], {
+          stdin: "inherit",
+          stdout: "inherit",
+          stderr: "inherit",
+        });
+        await proc.exited;
+
+        // Read edited content
+        const editedContent = await Bun.file(tempPath).text();
+
+        // Check if content was changed
+        if (editedContent.trim() === "" || editedContent === originalContent) {
+          console.log("No changes made. Edit cancelled.");
+          // Clean up temp file
+          unlinkSync(tempPath);
+          return;
+        }
+
+        // Parse edited content
+        const editData = yamlToTaskEdit(editedContent);
+
+        // Validate
+        if (!editData.title) {
+          throw new ChopError("Title cannot be empty");
+        }
+
+        if (!isValidStatus(editData.status)) {
+          throw new InvalidStatusError(editData.status);
+        }
+
+        // Apply changes
+        await store.atomicUpdate((data) => {
+          const task = findTaskById(id, data.tasks);
+          if (!task) {
+            throw new TaskNotFoundError(id);
+          }
+
+          task.title = editData.title;
+          task.description = editData.description;
+          task.status = editData.status;
+          task.dependsOn = editData.depends_on;
+          task.updatedAt = new Date().toISOString();
+
+          return { data, result: task };
+        });
+
+        console.log(`Updated task ${task.id}`);
+
+        // Clean up temp file
+        unlinkSync(tempPath);
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else {
+          console.error("An unexpected error occurred");
+        }
+        process.exit(1);
+      }
+    });
+}

package/src/commands/init.ts

@@ -0,0 +1,72 @@
+import type { Command } from "commander";
+import { AlreadyInitializedError } from "../errors.ts";
+import { isInitialized } from "../storage/storage-resolver.ts";
+import { TaskStore } from "../storage/task-store.ts";
+import type { StorageLocation } from "../types.ts";
+import { getGitRepoRoot } from "../utils/git.ts";
+import { confirm, select } from "../utils/prompts.ts";
+
+export function registerInitCommand(program: Command): void {
+  program
+    .command("init")
+    .description("Initialize chop for the current repository")
+    .action(async () => {
+      try {
+        // Check if already initialized
+        if (await isInitialized()) {
+          throw new AlreadyInitializedError();
+        }
+
+        // Prompt for storage location
+        const location = await select<StorageLocation>(
+          "Where would you like to store tasks?",
+          [
+            {
+              value: "local",
+              label: "Local (in .chop/ directory in this repo)",
+            },
+            { value: "global", label: "Global (~/.local/share/chop/)" },
+          ]
+        );
+
+        // Initialize storage
+        await TaskStore.initialize(location);
+
+        // If local, ask about gitignore
+        if (location === "local") {
+          const addToGitignore = await confirm(
+            "Add .chop/ to .gitignore? (Choose no to share tasks with your team)",
+            true
+          );
+
+          if (addToGitignore) {
+            const repoRoot = await getGitRepoRoot();
+            const gitignorePath = `${repoRoot}/.gitignore`;
+            const gitignoreFile = Bun.file(gitignorePath);
+
+            let content = "";
+            if (await gitignoreFile.exists()) {
+              content = await gitignoreFile.text();
+            }
+
+            // Check if .chop is already in gitignore
+            if (!content.includes(".chop")) {
+              const newContent =
+                content + (content.endsWith("\n") ? "" : "\n") + ".chop/\n";
+              await Bun.write(gitignorePath, newContent);
+              console.log("Added .chop/ to .gitignore");
+            }
+          }
+        }
+
+        console.log(`Initialized chop with ${location} storage.`);
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else {
+          console.error("An unexpected error occurred");
+        }
+        process.exit(1);
+      }
+    });
+}

package/src/commands/list.ts

@@ -0,0 +1,48 @@
+import type { Command } from "commander";
+import { TaskStore } from "../storage/task-store.ts";
+import { formatTaskTable } from "../utils/display.ts";
+import type { Task } from "../types.ts";
+
+export function registerListCommand(program: Command): void {
+  program
+    .command("list")
+    .alias("ls")
+    .description("List tasks")
+    .option("-o, --open", "Show only open and draft tasks (default)")
+    .option("-p, --progress", "Show only in-progress tasks")
+    .option("--done", "Show only done tasks")
+    .option("-a, --all", "Show all non-archived tasks")
+    .action(async (options) => {
+      try {
+        const store = await TaskStore.create();
+        const data = await store.readTasks();
+
+        let filteredTasks: Task[];
+
+        if (options.all) {
+          // All non-archived tasks
+          filteredTasks = data.tasks.filter((t) => t.status !== "archived");
+        } else if (options.progress) {
+          // Only in-progress
+          filteredTasks = data.tasks.filter((t) => t.status === "in-progress");
+        } else if (options.done) {
+          // Only done
+          filteredTasks = data.tasks.filter((t) => t.status === "done");
+        } else {
+          // Default: open and draft
+          filteredTasks = data.tasks.filter(
+            (t) => t.status === "open" || t.status === "draft"
+          );
+        }
+
+        console.log(formatTaskTable(filteredTasks, data.tasks));
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else {
+          console.error("An unexpected error occurred");
+        }
+        process.exit(1);
+      }
+    });
+}