@task-mcp/cli 1.0.4 → 1.0.5

package/README.md

@@ -24,64 +24,156 @@ bun add -g @task-mcp/cli
 bunx @task-mcp/cli
 ```
 
-## Usage
+## Quick Start
 
 ```bash
 # Show dashboard (default)
 task
 
-# Show dashboard for specific project
-task dashboard proj_abc123
-task d proj_abc123
+# Enter interactive mode
+task -i
+task interactive
+
+# Quick capture idea to inbox
+task inbox "Review API design tomorrow"
+
+# List pending tasks
+task list --status pending
+```
+
+## Commands
+
+### Dashboard
+
+```bash
+task                      # Show dashboard for all projects
+task dashboard            # Same as above
+task d                    # Alias
+task dashboard proj_123   # Show specific project
+```
 
-# List all tasks
-task list
-task ls
+### Interactive Mode
 
-# List tasks with filters
-task list --status pending --priority high
+```bash
+task -i                   # Start interactive mode
+task --interactive        # Same as above
+task interactive          # Full command
+task i                    # Alias
+```
+
+Interactive mode provides a menu-driven interface:
+- **d** - Dashboard view
+- **p** - Projects management
+- **t** - Tasks with filters
+- **a** - Analysis tools
+- **q** - Quick actions
+- **x** - Exit
+
+### Task List
+
+```bash
+task list                 # List active tasks
+task ls                   # Alias
+task list --all           # Include completed/cancelled
 task list --status pending,in_progress
-task list --all  # Include completed/cancelled
+task list --priority critical,high
+```
 
-# List projects
-task projects
-task p
-task projects --all  # Include archived
+### Projects
 
-# Help & version
-task help
-task version
+```bash
+task projects             # List active projects
+task p                    # Alias
+task projects --all       # Include archived
 ```
 
-## Commands
+### Inbox
 
-| Command | Alias | Description |
-|---------|-------|-------------|
-| `dashboard [id]` | `d` | Show project dashboard with stats and task table |
-| `list` | `ls` | List tasks with optional filters |
-| `projects` | `p` | List all projects |
-| `help` | - | Show help message |
-| `version` | - | Show version |
+Quick capture ideas and promote them to tasks later.
+
+```bash
+# Quick capture
+task inbox "Fix login bug tomorrow"
+task inbox "Review PR #123 #dev !high"
+
+# Subcommands
+task inbox                    # List pending items
+task inbox list               # Same as above
+task inbox list --all         # Include promoted/discarded
+task inbox get <id>           # Show item details
+task inbox promote <id>       # Promote to task
+task inbox discard <id>       # Discard item
+task inbox delete <id>        # Permanently delete
+task inbox count              # Show pending count
+```
+
+**Natural language parsing:**
+- `#tag` - Add tags
+- `!priority` - Set priority (critical, high, medium, low)
+- `@context` - Add context (focus, office, home)
+- Date words: tomorrow, next week, monday, etc.
+
+## Dashboard Widgets
+
+The dashboard displays 7 widgets:
+
+| Widget | Description |
+|--------|-------------|
+| **Overview** | Progress bar, status counts, priority breakdown |
+| **Schedule** | Overdue, today, this week task counts |
+| **Inbox** | Pending quick capture items |
+| **Work Queue** | Ready tasks, blocked tasks, bottlenecks, next task suggestion |
+| **Critical Path** | CPM analysis, path length, estimated duration |
+| **Analysis** | Complexity scores, tech stack distribution, risk levels |
+| **Hierarchy** | Task tree structure with subtasks |
 
 ## Options
 
 | Option | Description |
 |--------|-------------|
-| `--status <status>` | Filter by status (pending, in_progress, blocked, completed, cancelled) |
-| `--priority <priority>` | Filter by priority (critical, high, medium, low) |
-| `--all` | Include completed/cancelled tasks or archived projects |
+| `-i, --interactive` | Start interactive mode |
+| `--status <status>` | Filter by status (comma-separated) |
+| `--priority <priority>` | Filter by priority (comma-separated) |
+| `--all` | Include completed/cancelled/archived |
+| `--project <id>` | Specify project for inbox promote |
 
-## Dashboard Features
+### Status Values
+`pending`, `in_progress`, `blocked`, `completed`, `cancelled`
 
-- **Progress Bar**: Visual task completion progress
-- **Priority Breakdown**: Tasks grouped by priority level
-- **Dependency Metrics**: Ready tasks, blocked tasks, most depended-on task
-- **Next Task Suggestion**: AI-powered recommendation for next task
-- **Task Table**: Full task list with status, priority, and dependencies
+### Priority Values
+`critical`, `high`, `medium`, `low`
 
 ## Data Location
 
-The CLI reads data from the `.tasks/` directory created by the task-mcp MCP server.
+The CLI reads data from the `.tasks/` directory created by the task-mcp MCP server:
+
+```
+.tasks/
+├── projects.json           # Project metadata
+├── inbox.json              # Quick capture items
+└── <project-id>/
+    └── tasks.json          # Tasks for each project
+```
+
+## Examples
+
+```bash
+# View all high-priority blocked tasks
+task list --status blocked --priority high
+
+# Start interactive mode for project exploration
+task -i
+
+# Capture idea and check inbox
+task inbox "Refactor auth module !critical #backend"
+task inbox list
+
+# Promote inbox item to task
+task inbox promote inb_abc123 --project proj_xyz
+
+# Show dashboard for specific project
+task d proj_main
+```
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@task-mcp/cli",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Zero-dependency CLI for task-mcp with Bun native visualization",
   "type": "module",
   "bin": {

package/src/__tests__/ansi.test.ts

@@ -0,0 +1,221 @@
+import { describe, expect, test } from "bun:test";
+import {
+  color,
+  style,
+  styled,
+  stripAnsi,
+  displayWidth,
+  pad,
+  truncate,
+  progressBar,
+  hline,
+  c,
+} from "../ansi.js";
+
+describe("ansi", () => {
+  describe("color", () => {
+    test("applies color code to text", () => {
+      const result = color("hello", "red");
+      expect(result).toContain("hello");
+      expect(result).toContain("\x1b[31m"); // red color code
+      expect(result).toContain("\x1b[0m"); // reset code
+    });
+
+    test("applies different colors", () => {
+      expect(color("test", "green")).toContain("\x1b[32m");
+      expect(color("test", "blue")).toContain("\x1b[34m");
+      expect(color("test", "cyan")).toContain("\x1b[36m");
+    });
+  });
+
+  describe("style", () => {
+    test("applies bold style", () => {
+      const result = style("hello", "bold");
+      expect(result).toContain("hello");
+      expect(result).toContain("\x1b[1m"); // bold code
+    });
+
+    test("applies dim style", () => {
+      const result = style("hello", "dim");
+      expect(result).toContain("\x1b[2m"); // dim code
+    });
+  });
+
+  describe("styled", () => {
+    test("combines color and style", () => {
+      const result = styled("hello", "red", "bold");
+      expect(result).toContain("hello");
+      expect(result).toContain("1;31m"); // bold + red
+    });
+
+    test("works without style", () => {
+      const result = styled("hello", "green");
+      expect(result).toContain("\x1b[32m");
+    });
+  });
+
+  describe("c convenience functions", () => {
+    test("c.red applies red color", () => {
+      expect(c.red("test")).toContain("\x1b[31m");
+    });
+
+    test("c.green applies green color", () => {
+      expect(c.green("test")).toContain("\x1b[32m");
+    });
+
+    test("c.bold applies bold style", () => {
+      expect(c.bold("test")).toContain("\x1b[1m");
+    });
+
+    test("semantic colors work", () => {
+      expect(c.success("ok")).toContain("\x1b[32m"); // green
+      expect(c.error("fail")).toContain("\x1b[31m"); // red
+      expect(c.warning("warn")).toContain("\x1b[33m"); // yellow
+    });
+  });
+
+  describe("stripAnsi", () => {
+    test("removes ANSI codes from string", () => {
+      const colored = "\x1b[31mhello\x1b[0m";
+      expect(stripAnsi(colored)).toBe("hello");
+    });
+
+    test("handles multiple ANSI codes", () => {
+      const styled = "\x1b[1;31mhello\x1b[0m \x1b[32mworld\x1b[0m";
+      expect(stripAnsi(styled)).toBe("hello world");
+    });
+
+    test("returns original string if no ANSI codes", () => {
+      expect(stripAnsi("hello world")).toBe("hello world");
+    });
+
+    test("handles empty string", () => {
+      expect(stripAnsi("")).toBe("");
+    });
+  });
+
+  describe("displayWidth", () => {
+    test("returns correct width for ASCII", () => {
+      expect(displayWidth("hello")).toBe(5);
+      expect(displayWidth("test")).toBe(4);
+    });
+
+    test("returns correct width for Korean (2 per char)", () => {
+      expect(displayWidth("안녕")).toBe(4); // 2 chars * 2 width
+      expect(displayWidth("테스트")).toBe(6); // 3 chars * 2 width
+    });
+
+    test("handles mixed ASCII and Korean", () => {
+      expect(displayWidth("hello안녕")).toBe(9); // 5 + 4
+    });
+
+    test("strips ANSI codes before calculating", () => {
+      const colored = c.red("hello");
+      expect(displayWidth(colored)).toBe(5);
+    });
+
+    test("handles empty string", () => {
+      expect(displayWidth("")).toBe(0);
+    });
+  });
+
+  describe("pad", () => {
+    test("pads string to width (left align)", () => {
+      expect(pad("hi", 5)).toBe("hi   ");
+    });
+
+    test("pads string to width (right align)", () => {
+      expect(pad("hi", 5, "right")).toBe("   hi");
+    });
+
+    test("pads string to width (center align)", () => {
+      expect(pad("hi", 6, "center")).toBe("  hi  ");
+    });
+
+    test("returns original string if already at width", () => {
+      expect(pad("hello", 5)).toBe("hello");
+    });
+
+    test("returns original string if longer than width", () => {
+      expect(pad("hello world", 5)).toBe("hello world");
+    });
+
+    test("handles ANSI codes correctly", () => {
+      const colored = c.red("hi");
+      const padded = pad(colored, 5);
+      expect(stripAnsi(padded)).toBe("hi   ");
+    });
+  });
+
+  describe("truncate", () => {
+    test("truncates long string with suffix", () => {
+      expect(truncate("hello world", 8)).toBe("hello...");
+    });
+
+    test("returns original string if within limit", () => {
+      expect(truncate("hello", 10)).toBe("hello");
+    });
+
+    test("uses custom suffix", () => {
+      expect(truncate("hello world", 8, "~")).toBe("hello w~");
+    });
+
+    test("handles Korean characters", () => {
+      const result = truncate("안녕하세요", 6);
+      expect(displayWidth(result)).toBeLessThanOrEqual(6);
+    });
+
+    test("handles empty string", () => {
+      expect(truncate("", 5)).toBe("");
+    });
+  });
+
+  describe("progressBar", () => {
+    test("creates progress bar at 0%", () => {
+      const bar = progressBar(0, 10);
+      expect(bar).toContain("0%");
+      expect(stripAnsi(bar)).toContain("░░░░░░░░░░░░░░░░░░░░");
+    });
+
+    test("creates progress bar at 50%", () => {
+      const bar = progressBar(5, 10);
+      expect(bar).toContain("50%");
+    });
+
+    test("creates progress bar at 100%", () => {
+      const bar = progressBar(10, 10);
+      expect(bar).toContain("100%");
+      expect(stripAnsi(bar)).toContain("████████████████████");
+    });
+
+    test("handles custom width", () => {
+      const bar = progressBar(5, 10, { width: 10, showPercent: false });
+      const stripped = stripAnsi(bar);
+      expect(stripped.length).toBe(10);
+    });
+
+    test("handles zero total", () => {
+      const bar = progressBar(0, 0);
+      expect(bar).toContain("0%");
+    });
+
+    test("hides percent when showPercent is false", () => {
+      const bar = progressBar(5, 10, { showPercent: false });
+      expect(bar).not.toContain("%");
+    });
+  });
+
+  describe("hline", () => {
+    test("creates horizontal line of specified width", () => {
+      expect(hline(5)).toBe("─────");
+    });
+
+    test("uses custom character", () => {
+      expect(hline(3, "=")).toBe("===");
+    });
+
+    test("handles zero width", () => {
+      expect(hline(0)).toBe("");
+    });
+  });
+});

package/src/__tests__/index.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, test } from "bun:test";
+import { parseArgs } from "../index.js";
+
+describe("parseArgs", () => {
+  // Helper: simulate argv with bun and script path
+  const argv = (...args: string[]) => ["bun", "script.ts", ...args];
+
+  describe("command parsing", () => {
+    test("defaults to dashboard when no command", () => {
+      const result = parseArgs(argv());
+      expect(result.command).toBe("dashboard");
+      expect(result.args).toEqual([]);
+    });
+
+    test("parses command from first positional arg", () => {
+      const result = parseArgs(argv("list"));
+      expect(result.command).toBe("list");
+    });
+
+    test("parses command and additional args", () => {
+      const result = parseArgs(argv("dashboard", "proj_123"));
+      expect(result.command).toBe("dashboard");
+      expect(result.args).toEqual(["proj_123"]);
+    });
+
+    test("parses multiple positional args", () => {
+      const result = parseArgs(argv("cmd", "arg1", "arg2"));
+      expect(result.command).toBe("cmd");
+      expect(result.args).toEqual(["arg1", "arg2"]);
+    });
+  });
+
+  describe("long flags (--flag)", () => {
+    test("parses --flag as boolean true", () => {
+      const result = parseArgs(argv("list", "--all"));
+      expect(result.flags.all).toBe(true);
+    });
+
+    test("parses --flag=value", () => {
+      const result = parseArgs(argv("list", "--status=pending"));
+      expect(result.flags.status).toBe("pending");
+    });
+
+    test("parses --flag value (space separated)", () => {
+      const result = parseArgs(argv("list", "--status", "pending"));
+      expect(result.flags.status).toBe("pending");
+    });
+
+    test("parses multiple flags", () => {
+      const result = parseArgs(argv("list", "--status", "pending", "--priority", "high", "--all"));
+      expect(result.flags.status).toBe("pending");
+      expect(result.flags.priority).toBe("high");
+      expect(result.flags.all).toBe(true);
+    });
+
+    test("flag value starting with dash is treated as boolean", () => {
+      const result = parseArgs(argv("list", "--flag", "--other"));
+      expect(result.flags.flag).toBe(true);
+      expect(result.flags.other).toBe(true);
+    });
+  });
+
+  describe("short flags (-f)", () => {
+    test("parses -f as boolean true", () => {
+      const result = parseArgs(argv("list", "-a"));
+      expect(result.flags.a).toBe(true);
+    });
+
+    test("parses -f value (space separated)", () => {
+      const result = parseArgs(argv("list", "-s", "pending"));
+      expect(result.flags.s).toBe("pending");
+    });
+
+    test("parses multiple short flags", () => {
+      const result = parseArgs(argv("list", "-s", "pending", "-p", "high"));
+      expect(result.flags.s).toBe("pending");
+      expect(result.flags.p).toBe("high");
+    });
+  });
+
+  describe("mixed flags and args", () => {
+    test("boolean flag before command consumes next arg as value", () => {
+      // Note: --all list is parsed as --all=list (list becomes value of all)
+      const result = parseArgs(argv("--all", "list"));
+      expect(result.command).toBe("dashboard"); // default, since 'list' was consumed
+      expect(result.flags.all).toBe("list");
+    });
+
+    test("explicit boolean flag with command works", () => {
+      // Use --all without value by putting flag after command
+      const result = parseArgs(argv("list", "--all"));
+      expect(result.command).toBe("list");
+      expect(result.flags.all).toBe(true);
+    });
+
+    test("flags after args are parsed correctly", () => {
+      const result = parseArgs(argv("list", "proj_123", "--all"));
+      expect(result.command).toBe("list");
+      expect(result.args).toEqual(["proj_123"]);
+      expect(result.flags.all).toBe(true);
+    });
+
+    test("complex mixed parsing", () => {
+      const result = parseArgs(argv(
+        "dashboard",
+        "proj_abc",
+        "--status=pending",
+        "-v",
+        "--priority", "high"
+      ));
+      expect(result.command).toBe("dashboard");
+      expect(result.args).toEqual(["proj_abc"]);
+      expect(result.flags.status).toBe("pending");
+      expect(result.flags.v).toBe(true);
+      expect(result.flags.priority).toBe("high");
+    });
+  });
+
+  describe("edge cases", () => {
+    test("handles empty argv (just bun and script)", () => {
+      const result = parseArgs(["bun", "script.ts"]);
+      expect(result.command).toBe("dashboard");
+      expect(result.args).toEqual([]);
+      expect(result.flags).toEqual({});
+    });
+
+    test("handles flag with empty value via =", () => {
+      const result = parseArgs(argv("list", "--status="));
+      expect(result.flags.status).toBe("");
+    });
+
+    test("handles help and version flags", () => {
+      expect(parseArgs(argv("--help")).command).toBe("dashboard");
+      expect(parseArgs(argv("--help")).flags.help).toBe(true);
+      expect(parseArgs(argv("-h")).flags.h).toBe(true);
+      expect(parseArgs(argv("--version")).flags.version).toBe(true);
+      expect(parseArgs(argv("-v")).flags.v).toBe(true);
+    });
+  });
+});