@da1z/chop 0.0.1 → 0.0.2

package/loop.sh

@@ -1,206 +0,0 @@
-#!/usr/bin/env bash
-
-# loop - Execute Claude Code N times to work on tasks with realtime progress
-# Usage: ./loop [N]
-#   N - Number of times to run Claude Code (default: 1)
-# Requires: bash 3.0+, jq
-
-set -e
-set -o pipefail
-
-# Handle interrupt signals gracefully
-cleanup() {
-  echo -e "\n${YELLOW:-}Interrupted. Exiting...${NC:-}"
-  exit 130
-}
-trap cleanup INT TERM
-
-N=${1:-1}
-
-if ! [[ "$N" =~ ^[0-9]+$ ]] || [ "$N" -lt 1 ]; then
-  echo "Error: N must be a positive integer"
-  echo "Usage: ./loop [N]"
-  exit 1
-fi
-
-# Check for jq dependency
-if ! command -v jq &>/dev/null; then
-  echo "Error: jq is required for parsing JSON output"
-  echo "Install with your package manager:"
-  echo "  macOS: brew install jq"
-  echo "  Ubuntu/Debian: sudo apt install jq"
-  exit 1
-fi
-
-PROMPT='Execute ch pop to get the task you need to work on. Implement the task and make sure all tests pass and there are no TypeScript errors. Before marking the task as done, use @agent-general-purpose to perform a code review of your changes - ensure the subagent is satisfied with the code quality, all tests pass, and there are no TypeScript errors. Only after the code review is approved, mark the task as done using ch done <id> and commit changes using pk branch create -am <message>.'
-
-# ANSI color codes
-BLUE='\033[0;34m'
-GREEN='\033[0;32m'
-YELLOW='\033[0;33m'
-CYAN='\033[0;36m'
-GRAY='\033[0;90m'
-BOLD='\033[1m'
-NC='\033[0m' # No Color
-
-# Parse and display stream-json output with realtime progress
-parse_stream() {
-  local turn=0
-
-  while IFS= read -r line; do
-    # Skip empty lines
-    [[ -z "$line" ]] && continue
-
-    # Parse JSON type
-    type=$(echo "$line" | jq -r '.type // empty' 2>/dev/null)
-    [[ -z "$type" ]] && continue
-
-    case "$type" in
-    system)
-      subtype=$(echo "$line" | jq -r '.subtype // empty')
-      if [[ "$subtype" == "init" ]]; then
-        model=$(echo "$line" | jq -r '.model // "unknown"')
-        session_id=$(echo "$line" | jq -r '.session_id // "unknown"')
-        echo -e "${GRAY}Session: ${session_id:0:8}... | Model: $model${NC}"
-      fi
-      ;;
-
-    assistant)
-      turn=$((turn + 1))
-      # Check for tool use or text response
-      content_type=$(echo "$line" | jq -r '.message.content[0].type // empty')
-
-      if [[ "$content_type" == "tool_use" ]]; then
-        tool_name=$(echo "$line" | jq -r '.message.content[0].name // "unknown"')
-
-        # Get tool-specific details
-        case "$tool_name" in
-        Bash)
-          desc=$(echo "$line" | jq -r '.message.content[0].input.description // empty')
-          cmd=$(echo "$line" | jq -r '.message.content[0].input.command // empty')
-
-          # Always show the command
-          if [[ -n "$desc" ]]; then
-            echo -e "${CYAN}[$turn]${NC} ${YELLOW}⚡ $tool_name${NC}: $desc"
-            echo -e "     ${GRAY}└─ $ ${cmd}${NC}"
-          else
-            echo -e "${CYAN}[$turn]${NC} ${YELLOW}⚡ $tool_name${NC}: ${GRAY}$ ${cmd}${NC}"
-          fi
-          ;;
-        Read)
-          file=$(echo "$line" | jq -r '.message.content[0].input.file_path // empty')
-          echo -e "${CYAN}[$turn]${NC} ${YELLOW}📖 $tool_name${NC}: ${GRAY}${file##*/}${NC}"
-          ;;
-        Edit | Write)
-          file=$(echo "$line" | jq -r '.message.content[0].input.file_path // empty')
-          echo -e "${CYAN}[$turn]${NC} ${YELLOW}✏️  $tool_name${NC}: ${GRAY}${file##*/}${NC}"
-          ;;
-        Glob)
-          pattern=$(echo "$line" | jq -r '.message.content[0].input.pattern // empty')
-          echo -e "${CYAN}[$turn]${NC} ${YELLOW}🔍 $tool_name${NC}: ${GRAY}$pattern${NC}"
-          ;;
-        Grep)
-          pattern=$(echo "$line" | jq -r '.message.content[0].input.pattern // empty')
-          echo -e "${CYAN}[$turn]${NC} ${YELLOW}🔎 $tool_name${NC}: ${GRAY}$pattern${NC}"
-          ;;
-        Task)
-          desc=$(echo "$line" | jq -r '.message.content[0].input.description // empty')
-          agent_type=$(echo "$line" | jq -r '.message.content[0].input.subagent_type // empty')
-          echo -e "${CYAN}[$turn]${NC} ${YELLOW}🤖 $tool_name${NC}: ${GRAY}$agent_type - $desc${NC}"
-          ;;
-        TodoWrite)
-          echo -e "${CYAN}[$turn]${NC} ${YELLOW}📝 $tool_name${NC}: ${GRAY}Updating task list${NC}"
-          ;;
-        WebSearch)
-          query=$(echo "$line" | jq -r '.message.content[0].input.query // empty')
-          echo -e "${CYAN}[$turn]${NC} ${YELLOW}🌐 $tool_name${NC}: ${GRAY}$query${NC}"
-          ;;
-        WebFetch)
-          url=$(echo "$line" | jq -r '.message.content[0].input.url // empty')
-          echo -e "${CYAN}[$turn]${NC} ${YELLOW}🌐 $tool_name${NC}: ${GRAY}$url${NC}"
-          ;;
-        LSP)
-          operation=$(echo "$line" | jq -r '.message.content[0].input.operation // empty')
-          file=$(echo "$line" | jq -r '.message.content[0].input.filePath // empty')
-          echo -e "${CYAN}[$turn]${NC} ${YELLOW}🔗 $tool_name${NC}: ${GRAY}$operation on ${file##*/}${NC}"
-          ;;
-        *)
-          echo -e "${CYAN}[$turn]${NC} ${YELLOW}🔧 $tool_name${NC}"
-          ;;
-        esac
-      elif [[ "$content_type" == "text" ]]; then
-        # Show a brief snippet of text response
-        text=$(echo "$line" | jq -r '.message.content[0].text // empty')
-        if [[ -n "$text" ]]; then
-          if [[ ${#text} -gt 80 ]]; then
-            echo -e "${CYAN}[$turn]${NC} ${BLUE}💬${NC} ${GRAY}${text:0:80}...${NC}"
-          else
-            echo -e "${CYAN}[$turn]${NC} ${BLUE}💬${NC} ${GRAY}${text}${NC}"
-          fi
-        fi
-      fi
-      ;;
-
-    user)
-      # Tool result - show brief status
-      is_error=$(echo "$line" | jq -r '.message.content[0].is_error // false')
-      if [[ "$is_error" == "true" ]]; then
-        echo -e "     ${GRAY}└─ ❌ Error${NC}"
-      fi
-      ;;
-
-    result)
-      subtype=$(echo "$line" | jq -r '.subtype // empty')
-      duration_ms=$(echo "$line" | jq -r '.duration_ms // 0')
-      num_turns=$(echo "$line" | jq -r '.num_turns // 0')
-      cost=$(echo "$line" | jq -r '.total_cost_usd // 0')
-
-      # Convert ms to readable format
-      duration_sec=$((duration_ms / 1000))
-      duration_min=$((duration_sec / 60))
-      duration_remainder=$((duration_sec % 60))
-
-      if [[ "$duration_min" -gt 0 ]]; then
-        duration_str="${duration_min}m ${duration_remainder}s"
-      else
-        duration_str="${duration_sec}s"
-      fi
-
-      # Format cost
-      cost_str=$(printf "%.4f" "$cost")
-
-      echo ""
-      if [[ "$subtype" == "success" ]]; then
-        echo -e "${GREEN}✅ Completed${NC} | ${GRAY}Turns: $num_turns | Duration: $duration_str | Cost: \$$cost_str${NC}"
-      else
-        echo -e "${YELLOW}⚠️  Finished with status: $subtype${NC} | ${GRAY}Turns: $num_turns | Duration: $duration_str | Cost: \$$cost_str${NC}"
-      fi
-      ;;
-    esac
-  done
-}
-
-echo -e "${BOLD}Starting loop: running Claude Code $N time(s)${NC}"
-
-for ((i = 1; i <= N; i++)); do
-  echo ""
-  echo -e "${BOLD}===========================================${NC}"
-  echo -e "${BOLD}Run $i of $N${NC}"
-  echo -e "${BOLD}===========================================${NC}"
-  echo ""
-
-  if [ "$N" -eq 1 ]; then
-    # Interactive mode for single run - no streaming
-    claude "$PROMPT"
-  else
-    # Non-interactive mode with streaming progress
-    # Use script to provide pseudo-TTY since docker sandbox requires TTY
-    claude -p "$PROMPT" --dangerously-skip-permissions --output-format stream-json --verbose | parse_stream
-  fi
-
-  echo ""
-  echo -e "${GREEN}Run $i completed${NC}"
-done
-
-echo ""
-echo -e "${BOLD}Loop finished: completed $N run(s)${NC}"

package/specs/chop.md

@@ -1,313 +0,0 @@
-# Chop CLI Specification
-
-A simple, file-based task management CLI tool designed for developers working across multiple repositories.
-
-## Overview
-
-**Name:** `chop` (short alias: `ch`)
-**Purpose:** Queue-based task management with dependency support, optimized for multi-process concurrent access.
-
-## Core Concepts
-
-### Task Model
-
-Each task contains:
-- **ID**: Hybrid format - short hash (7 chars) + sequential number (e.g., `a1b2c3d-1`)
-- **Title**: Short description (required)
-- **Description**: Optional longer details
-- **Status**: `draft` | `open` | `in-progress` | `done` | `archived`
-- **Dependencies**: List of task IDs this task depends on
-- **Created**: Timestamp of creation
-- **Updated**: Timestamp of last modification
-
-### Project Detection
-
-Projects are identified by git repository:
-1. First, attempt to use git remote origin URL as project identifier (survives cloning to different paths)
-2. Fall back to git repository root path for local-only repos
-3. Error if run outside a git repository
-
-### Storage Strategy
-
-Two storage modes, configured per-project during `chop init`:
-
-1. **Local storage** (in-repo): `.chop/tasks.json` in repository root
-   - Can be committed (team shared) or gitignored (personal)
-
-2. **Global storage**: `~/.local/share/chop/<project-id>/tasks.json`
-   - Never pollutes the repository
-   - Project ID derived from remote URL or repo path
-
-**Resolution order:**
-1. Check for `.chop/tasks.json` in repo root
-2. Fall back to global storage location
-3. Error if neither exists (requires `chop init`)
-
-**Archive storage:** Archived tasks are moved to a separate file (`tasks.archived.json`) to avoid loading them into memory during normal operations.
-
-### Concurrency Model
-
-File locking with retry strategy to handle multiple processes:
-- Use OS-level file locks when reading/writing
-- Retry up to 5 times with exponential backoff (100ms, 200ms, 400ms, 800ms, 1600ms)
-- Critical for `chop pop` to ensure atomic "get + mark in-progress" operation
-- Works correctly across multiple checkouts of the same repository sharing global storage
-
-## Commands
-
-### Initialization
-
-```
-chop init
-```
-
-Interactive setup prompting for:
-1. Storage location: local (in-repo) or global
-2. If local: add to .gitignore? (y/n)
-
-Creates the storage directory and empty tasks file.
-
-### Adding Tasks
-
-```
-chop add <title> [options]
-```
-
-Options:
-- `--top` / `-t`: Add to top of queue (default: bottom)
-- `--bottom` / `-b`: Add to bottom of queue (explicit)
-- `--desc <description>` / `-d`: Add description
-- `--depends-on <id>`: Add dependency (can be repeated)
-
-If `--depends-on` is used without an ID, show interactive picker of existing tasks.
-
-Examples:
-```
-chop add "Implement login page"
-chop add "Write tests" --top
-chop add "Deploy to staging" --depends-on a1b2c3d-1 --depends-on e5f6g7h-2
-```
-
-### Listing Tasks
-
-```
-chop list [options]
-```
-
-Options:
-- `--open` / `-o`: Show only open tasks (default behavior)
-- `--progress` / `-p`: Show only in-progress tasks
-- `--done`: Show only done tasks
-- `--all` / `-a`: Show all non-archived tasks
-
-Output format (compact table):
-```
-ID          STATUS       TITLE
-a1b2c3d-1   open         Implement login page
-e5f6g7h-2   in-progress  Write unit tests
-f8g9h0i-3   open         [blocked] Deploy to staging
-```
-
-Tasks with incomplete dependencies are marked `[blocked]` but still shown.
-
-### Getting Next Task
-
-```
-chop pop
-```
-
-Atomically:
-1. Find the first `open` task (by creation order) that has no incomplete dependencies
-2. Mark it as `in-progress`
-3. Display the task details
-
-If no tasks available, print "No tasks available" and exit with code 0.
-
-Tasks with incomplete dependencies are silently skipped.
-
-### Completing Tasks
-
-```
-chop done <id>
-```
-
-Mark a task as `done`. Requires explicit task ID since multiple tasks can be in-progress.
-
-### Changing Status
-
-```
-chop status <id> <status>
-```
-
-Change task status to: `open`, `in-progress`, or `done`.
-
-Examples:
-```
-chop status a1b2c3d-1 in-progress
-chop status e5f6g7h-2 open
-```
-
-### Archiving Tasks
-
-```
-chop archive <id>
-```
-
-Move a task to archived storage. Requires confirmation.
-
-Cascade behavior:
-- If task has dependents (other tasks depend on it), show warning listing affected tasks
-- Prompt for confirmation to archive all affected tasks together
-- On confirm, archive the task and all its dependents
-
-When archiving a task that depends on other tasks, just remove the dependency links.
-
-### Purging Archives
-
-```
-chop purge
-```
-
-Permanently delete all archived tasks. Requires confirmation.
-
-### Editing Tasks
-
-```
-chop edit <id>
-```
-
-Opens task in `$EDITOR` (or `vi` if not set) as a temporary file with YAML/JSON format:
-```yaml
-title: Implement login page
-description: |
-  Create login form with email/password
-  Add validation and error handling
-status: open
-depends_on:
-  - a1b2c3d-1
-```
-
-Save and close to apply changes. Cancel (exit without saving or delete content) to abort.
-
-### Moving Tasks
-
-```
-chop move <id> [options]
-```
-
-Options:
-- `--top` / `-t`: Move to top of queue
-- `--bottom` / `-b`: Move to bottom of queue
-
-Examples:
-```
-chop move a1b2c3d-1 --top
-chop move e5f6g7h-2 --bottom
-```
-
-### Help
-
-```
-chop
-chop --help
-chop <command> --help
-```
-
-Running `chop` with no arguments shows help.
-
-## File Formats
-
-### tasks.json
-
-```json
-{
-  "version": 1,
-  "lastSequence": 3,
-  "tasks": [
-    {
-      "id": "a1b2c3d-1",
-      "title": "Implement login page",
-      "description": "Create login form with validation",
-      "status": "open",
-      "dependsOn": [],
-      "createdAt": "2024-01-15T10:30:00Z",
-      "updatedAt": "2024-01-15T10:30:00Z"
-    }
-  ]
-}
-```
-
-### tasks.archived.json
-
-Same format as tasks.json, containing only archived tasks.
-
-### config.json
-
-Located at `.chop/config.json` (local) or `~/.config/chop/config.json` (global):
-
-```json
-{
-  "defaultStorage": "global",
-  "projects": {
-    "github.com/user/repo": {
-      "storage": "local"
-    }
-  }
-}
-```
-
-## Error Handling
-
-Errors are concise one-liners:
-- `Error: Not in a git repository`
-- `Error: Project not initialized. Run 'chop init'`
-- `Error: Task a1b2c3d-1 not found`
-- `Error: Cannot acquire lock. Another process is accessing tasks`
-- `Error: Task has unarchived dependents: e5f6g7h-2, f8g9h0i-3`
-
-## Exit Codes
-
-- `0`: Success
-- `1`: Error (with message to stderr)
-
-## Implementation Notes
-
-### Technology Stack
-- Runtime: Bun
-- Language: TypeScript
-- Argument parsing: Built-in or minimal dependency
-- File locking: OS-level locks via Bun APIs
-
-### Concurrency Safety
-
-For operations that modify state (`pop`, `done`, `status`, `add`, etc.):
-1. Acquire exclusive file lock
-2. Read current state
-3. Validate operation is still valid
-4. Write updated state
-5. Release lock
-
-This ensures correctness when:
-- Multiple terminal sessions in same repo
-- Multiple checkouts of same repo sharing global storage
-- CI/CD pipelines running concurrent tasks
-
-### ID Generation
-
-1. Generate random bytes and create short hash (7 chars)
-2. Increment `lastSequence` counter
-3. Combine: `{hash}-{sequence}`
-
-This provides:
-- Uniqueness (hash prevents collisions)
-- Human-friendliness (sequence for easy reference)
-- Merge safety (hash portion prevents conflicts)
-
-## Future Considerations (Not in v1)
-
-- Shell completions (bash/zsh/fish)
-- Integration hooks (on-status-change scripts)
-- Cross-project dependencies
-- Priority levels
-- Tags/labels for filtering
-- Time tracking

package/src/commands/add.ts

@@ -1,74 +0,0 @@
-import type { Command } from "commander";
-import { TaskStore } from "../storage/task-store.ts";
-import { createTask } from "../models/task.ts";
-import { selectTasks } from "../utils/prompts.ts";
-import { formatTaskDetail } from "../utils/display.ts";
-
-// Collect multiple --depends-on values
-function collectDependencies(value: string, previous: string[]): string[] {
-  return previous.concat([value]);
-}
-
-export function registerAddCommand(program: Command): void {
-  program
-    .command("add <title>")
-    .alias("a")
-    .description("Add a new task to the queue")
-    .option("-t, --top", "Add to top of queue")
-    .option("-b, --bottom", "Add to bottom of queue (default)")
-    .option("-d, --desc <description>", "Add description")
-    .option("--draft", "Create task as draft status")
-    .option("--depends-on [id]", "Add dependency (can be repeated)", collectDependencies, [])
-    .action(async (title: string, options) => {
-      try {
-        const store = await TaskStore.create();
-
-        // Handle interactive dependency selection if --depends-on used without value
-        let dependsOn: string[] = options.dependsOn;
-
-        // Check if --depends-on was used with no value (will be empty string)
-        if (dependsOn.includes("")) {
-          // Remove empty strings
-          dependsOn = dependsOn.filter((id: string) => id !== "");
-
-          // Show interactive picker
-          const tasksData = await store.readTasks();
-          const availableTasks = tasksData.tasks
-            .filter((t) => t.status !== "archived")
-            .map((t) => ({ id: t.id, title: t.title }));
-
-          const selectedIds = await selectTasks("Select tasks to depend on:", availableTasks);
-          dependsOn = [...dependsOn, ...selectedIds];
-        }
-
-        const newTask = await store.atomicUpdate((data) => {
-          const { task, newSequence } = createTask(data.lastSequence, {
-            title,
-            description: options.desc,
-            dependsOn,
-            status: options.draft ? "draft" : "open",
-          });
-
-          if (options.top) {
-            data.tasks.unshift(task);
-          } else {
-            data.tasks.push(task);
-          }
-
-          data.lastSequence = newSequence;
-
-          return { data, result: task };
-        });
-
-        console.log(`Added task: ${newTask.id}`);
-        console.log(formatTaskDetail(newTask));
-      } catch (error) {
-        if (error instanceof Error) {
-          console.error(error.message);
-        } else {
-          console.error("An unexpected error occurred");
-        }
-        process.exit(1);
-      }
-    });
-}

package/src/commands/archive.ts

@@ -1,72 +0,0 @@
-import type { Command } from "commander";
-import { TaskStore } from "../storage/task-store.ts";
-import { findTaskById, findAllDependents } from "../models/task.ts";
-import { TaskNotFoundError } from "../errors.ts";
-import { confirm } from "../utils/prompts.ts";
-
-export function registerArchiveCommand(program: Command): void {
-  program
-    .command("archive <id>")
-    .alias("ar")
-    .description("Archive a task")
-    .action(async (id: string) => {
-      try {
-        const store = await TaskStore.create();
-        const data = await store.readTasks();
-
-        // Find the task
-        const task = findTaskById(id, data.tasks);
-        if (!task) {
-          throw new TaskNotFoundError(id);
-        }
-
-        // Find all dependents (tasks that depend on this one)
-        const dependents = findAllDependents(task.id, data.tasks);
-        const unarchivedDependents = dependents.filter((t) => t.status !== "archived");
-
-        if (unarchivedDependents.length > 0) {
-          // Show warning about dependents
-          console.log(`Warning: The following tasks depend on ${task.id}:`);
-          for (const dep of unarchivedDependents) {
-            console.log(`  - ${dep.id}: ${dep.title}`);
-          }
-
-          const confirmed = await confirm(
-            "Archive this task and all its dependents?",
-            false
-          );
-
-          if (!confirmed) {
-            console.log("Archive cancelled.");
-            return;
-          }
-
-          // Archive all tasks (main task + all dependents)
-          const tasksToArchive = [task, ...unarchivedDependents];
-          for (const t of tasksToArchive) {
-            await store.archiveTask(t.id);
-          }
-
-          console.log(`Archived ${tasksToArchive.length} task(s)`);
-        } else {
-          // Confirm archiving single task
-          const confirmed = await confirm(`Archive task ${task.id}?`, true);
-
-          if (!confirmed) {
-            console.log("Archive cancelled.");
-            return;
-          }
-
-          await store.archiveTask(task.id);
-          console.log(`Archived task ${task.id}`);
-        }
-      } catch (error) {
-        if (error instanceof Error) {
-          console.error(error.message);
-        } else {
-          console.error("An unexpected error occurred");
-        }
-        process.exit(1);
-      }
-    });
-}