@simonfestl/husky-cli 0.6.0 → 0.6.2

package/README.md

@@ -39,6 +39,8 @@ husky
 husky task list                              # List all tasks
 husky task list --status in_progress         # Filter by status
 husky task list --json                       # JSON output
+husky task list -i                           # Interactive pagination
+husky task list --per-page 10 --page 2       # Paginated output
 husky task create "Fix login bug" --priority high
 husky task get <task-id>
 husky task start <task-id>
@@ -50,7 +52,9 @@ husky task delete <task-id>
 ### Project Management
 
 ```bash
-husky project list
+husky project list                           # List all projects
+husky project list -i                        # Interactive pagination
+husky project list --per-page 5 --page 1     # Paginated output
 husky project create "New Project" --description "..."
 husky project get <project-id>
 husky project update <project-id> --status active
@@ -63,7 +67,9 @@ husky project delete-knowledge <project-id> <knowledge-id>
 ### Workflow Management
 
 ```bash
-husky workflow list
+husky workflow list                          # List all workflows
+husky workflow list -i                       # Interactive pagination
+husky workflow list --per-page 5             # Paginated output
 husky workflow create "Onboarding" --department <id>
 husky workflow get <workflow-id>
 husky workflow update <workflow-id> --name "Updated"
@@ -78,7 +84,9 @@ husky workflow generate-mermaid <workflow-id>  # Mermaid diagram
 ### Idea Management
 
 ```bash
-husky idea list
+husky idea list                              # List all ideas
+husky idea list -i                           # Interactive pagination
+husky idea list --per-page 10                # Paginated output
 husky idea create "New feature idea" --category feature
 husky idea get <idea-id>
 husky idea update <idea-id> --status approved
@@ -160,6 +168,8 @@ husky roadmap create "Q1 2025" --description "..."
 husky roadmap update <roadmap-id> --name "Updated"
 husky roadmap delete <roadmap-id>
 husky roadmap add-phase <roadmap-id> --name "Phase 1"
+husky roadmap update-phase <roadmap-id> <phase-id> --name "Updated"
+husky roadmap delete-phase <roadmap-id> <phase-id> --force
 husky roadmap add-feature <roadmap-id> --phase <id> --title "Feature"
 husky roadmap list-features <roadmap-id>
 husky roadmap update-feature <roadmap-id> <feature-id> --status done
@@ -187,6 +197,20 @@ husky vm-config update <config-id> --machine-type e2-standard-2
 husky vm-config delete <config-id>
 ```
 
+### Git Worktree Management
+
+```bash
+husky worktree list                          # List all worktrees
+husky worktree create <session-name>         # Create worktree
+husky worktree info <session-name>           # Show details
+husky worktree status [session-name]         # Show status
+husky worktree cd <session-name>             # Print path
+husky worktree merge <session-name>          # Merge to base
+husky worktree remove <session-name>         # Remove worktree
+husky worktree branches                      # List husky/* branches
+husky worktree cleanup                       # Clean stale worktrees
+```
+
 ### Settings
 
 ```bash
@@ -221,6 +245,35 @@ husky completion zsh >> ~/.zshrc
 husky completion fish > ~/.config/fish/completions/husky.fish
 ```
 
+## Pagination
+
+List commands support pagination with two modes:
+
+### Interactive Pagination (`-i`)
+
+Navigate through results using arrow keys:
+
+```bash
+husky task list -i          # Interactive mode with arrow key navigation
+husky project list -i       # Works for projects, ideas, workflows
+```
+
+Features:
+- Use `↑`/`↓` to navigate items
+- `←` Previous page / `→` Next page
+- Press `Enter` to select and view details
+- Press `Esc` or select "Exit" to return
+
+### Static Pagination (`--page`, `--per-page`)
+
+For scripting or quick page views:
+
+```bash
+husky task list --per-page 10            # Show first 10 items
+husky task list --per-page 10 --page 2   # Show items 11-20
+husky idea list -n 5 -p 3                # Short form: 5 items, page 3
+```
+
 ## Environment Variables
 
 | Variable | Description |
@@ -283,6 +336,22 @@ husky --version
 
 ## Changelog
 
+### v0.6.2 (2026-01-06)
+- Added: Interactive pagination for list commands (`-i` flag)
+- Added: Static pagination (`--page`, `--per-page` flags)
+- Improved: Tasks, projects, ideas, workflows now support pagination
+
+### v0.6.1 (2026-01-06)
+- Added: Roadmap phase management (`update-phase`, `delete-phase`)
+- Fixed: Various bug fixes
+
+### v0.6.0 (2026-01-06)
+- Added: Git Worktree support for multi-agent isolation
+- Added: `husky worktree` commands (create, list, merge, remove, etc.)
+- Added: MergeLock mechanism for safe concurrent operations
+- Refactored: Interactive mode into modular components
+- Improved: Based on Auto-Claude's worktree architecture
+
 ### v0.5.0 (2026-01-06)
 - Full Dashboard feature parity (69 new commands)
 - Added: project, workflow, idea, department, vm, jules, process, strategy, settings, vm-config commands

package/dist/commands/idea.js

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { getConfig } from "./config.js";
+import { paginateList, printPaginated } from "../lib/pagination.js";
 export const ideaCommand = new Command("idea")
     .description("Manage ideas");
 // Helper: Ensure API is configured
@@ -11,12 +12,22 @@ function ensureConfig() {
     }
     return config;
 }
+// Status labels and icons
+const STATUS_CONFIG = {
+    draft: { label: "Draft", icon: "📝" },
+    active: { label: "Active", icon: "💡" },
+    archived: { label: "Archived", icon: "📦" },
+    converted: { label: "Converted", icon: "✅" },
+};
 // husky idea list
 ideaCommand
     .command("list")
     .description("List all ideas")
     .option("--status <status>", "Filter by status (draft, active, archived, converted)")
     .option("--json", "Output as JSON")
+    .option("-p, --page <num>", "Page number (starts at 1)", "1")
+    .option("-n, --per-page <num>", "Items per page (default: all)")
+    .option("-i, --interactive", "Interactive pagination with arrow keys")
     .action(async (options) => {
     const config = ensureConfig();
     try {
@@ -33,10 +44,47 @@ ideaCommand
         const ideas = await res.json();
         if (options.json) {
             console.log(JSON.stringify(ideas, null, 2));
+            return;
         }
-        else {
-            printIdeas(ideas);
+        // Interactive pagination mode
+        if (options.interactive) {
+            await paginateList({
+                items: ideas,
+                pageSize: 10,
+                title: "Ideas",
+                emptyMessage: "No ideas found.",
+                renderItem: (idea) => {
+                    const cfg = STATUS_CONFIG[idea.status] || { label: idea.status, icon: "○" };
+                    return `  ${cfg.icon} ${idea.title.slice(0, 40).padEnd(40)} │ ${cfg.label}`;
+                },
+                selectableItems: true,
+                onSelect: async (idea) => {
+                    console.clear();
+                    console.log(`\n  Idea: ${idea.title}`);
+                    console.log("  " + "─".repeat(50));
+                    console.log(`  ID:       ${idea.id}`);
+                    console.log(`  Status:   ${STATUS_CONFIG[idea.status]?.label || idea.status}`);
+                    if (idea.category)
+                        console.log(`  Category: ${idea.category}`);
+                    if (idea.description)
+                        console.log(`  Desc:     ${idea.description}`);
+                    console.log("");
+                },
+            });
+            return;
+        }
+        // Simple pagination mode
+        if (options.perPage) {
+            const pageNum = parseInt(options.page, 10) - 1;
+            const pageSize = parseInt(options.perPage, 10);
+            printPaginated(ideas, pageNum, pageSize, (idea) => {
+                const cfg = STATUS_CONFIG[idea.status] || { label: idea.status, icon: "○" };
+                return `  ${cfg.icon} ${idea.id.slice(0, 8)} │ ${idea.title}`;
+            }, "Ideas");
+            return;
         }
+        // Default list
+        printIdeas(ideas);
     }
     catch (error) {
         console.error("Error fetching ideas:", error);

package/dist/commands/project.js

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { getConfig } from "./config.js";
+import { paginateList, printPaginated } from "../lib/pagination.js";
 export const projectCommand = new Command("project")
     .description("Manage projects and knowledge");
 // Helper: Ensure API is configured
@@ -37,6 +38,9 @@ projectCommand
     .option("--status <status>", "Filter by status (active, archived)")
     .option("--work-status <workStatus>", "Filter by work status (planning, in_progress, review, completed, on_hold)")
     .option("--archived", "Include archived projects")
+    .option("-p, --page <num>", "Page number (starts at 1)", "1")
+    .option("-n, --per-page <num>", "Items per page (default: all)")
+    .option("-i, --interactive", "Interactive pagination with arrow keys")
     .action(async (options) => {
     const config = ensureConfig();
     try {
@@ -60,10 +64,51 @@ projectCommand
         }
         if (options.json) {
             console.log(JSON.stringify(projects, null, 2));
+            return;
         }
-        else {
-            printProjects(projects);
+        // Interactive pagination mode
+        if (options.interactive) {
+            await paginateList({
+                items: projects,
+                pageSize: 10,
+                title: "Projects",
+                emptyMessage: "No projects found.",
+                renderItem: (project) => {
+                    const statusIcon = project.status === "archived" ? "📦" : "📁";
+                    const workStatusLabel = WORK_STATUS_LABELS[project.workStatus] || project.workStatus;
+                    return `  ${statusIcon} ${project.name.slice(0, 30).padEnd(30)} │ ${workStatusLabel}`;
+                },
+                selectableItems: true,
+                onSelect: async (project) => {
+                    console.clear();
+                    console.log(`\n  Project: ${project.name}`);
+                    console.log("  " + "─".repeat(50));
+                    console.log(`  ID:         ${project.id}`);
+                    console.log(`  Status:     ${project.status}`);
+                    console.log(`  Work:       ${WORK_STATUS_LABELS[project.workStatus]}`);
+                    if (project.description)
+                        console.log(`  Desc:       ${project.description}`);
+                    if (project.techStack)
+                        console.log(`  Tech:       ${project.techStack}`);
+                    if (project.githubRepo)
+                        console.log(`  GitHub:     ${project.githubRepo}`);
+                    console.log("");
+                },
+            });
+            return;
+        }
+        // Simple pagination mode
+        if (options.perPage) {
+            const pageNum = parseInt(options.page, 10) - 1;
+            const pageSize = parseInt(options.perPage, 10);
+            printPaginated(projects, pageNum, pageSize, (project) => {
+                const statusIcon = project.status === "archived" ? "📦" : "📁";
+                return `  ${statusIcon} ${project.id.slice(0, 8)} │ ${project.name}`;
+            }, "Projects");
+            return;
         }
+        // Default: standard list
+        printProjects(projects);
     }
     catch (error) {
         console.error("Error fetching projects:", error);

package/dist/commands/roadmap.js

@@ -152,6 +152,113 @@ roadmapCommand
         process.exit(1);
     }
 });
+// husky roadmap update-phase <roadmapId> <phaseId>
+roadmapCommand
+    .command("update-phase <roadmapId> <phaseId>")
+    .description("Update a roadmap phase")
+    .option("-n, --name <name>", "New phase name")
+    .option("-d, --description <description>", "New phase description")
+    .option("--status <status>", "Phase status (planned, in_progress, completed)")
+    .option("--order <order>", "Phase order (0-based)")
+    .action(async (roadmapId, phaseId, options) => {
+    const config = ensureConfig();
+    // Build update payload
+    const updateData = { phaseId };
+    if (options.name)
+        updateData.name = options.name;
+    if (options.description)
+        updateData.description = options.description;
+    if (options.status) {
+        const validStatuses = ["planned", "in_progress", "completed"];
+        if (!validStatuses.includes(options.status)) {
+            console.error(`Error: Invalid status "${options.status}". Must be one of: ${validStatuses.join(", ")}`);
+            process.exit(1);
+        }
+        updateData.status = options.status;
+    }
+    if (options.order !== undefined) {
+        const order = parseInt(options.order, 10);
+        if (isNaN(order) || order < 0) {
+            console.error("Error: Order must be a non-negative integer");
+            process.exit(1);
+        }
+        updateData.order = order;
+    }
+    if (Object.keys(updateData).length === 1) {
+        console.error("Error: No update options provided. Use -n/--name, -d/--description, --status, or --order");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/roadmaps/${roadmapId}/phases`, {
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify(updateData),
+        });
+        if (!res.ok) {
+            if (res.status === 404) {
+                console.error(`Error: Roadmap or phase not found`);
+            }
+            else {
+                const errorBody = await res.json().catch(() => ({}));
+                console.error(`Error: API returned ${res.status}`, errorBody.error || "");
+            }
+            process.exit(1);
+        }
+        const roadmap = await res.json();
+        const updatedPhase = roadmap.phases.find((p) => p.id === phaseId);
+        console.log(`✓ Phase updated successfully`);
+        if (updatedPhase) {
+            console.log(`  Name:   ${updatedPhase.name}`);
+            console.log(`  Status: ${updatedPhase.status}`);
+            console.log(`  Order:  ${updatedPhase.order}`);
+        }
+    }
+    catch (error) {
+        console.error("Error updating phase:", error);
+        process.exit(1);
+    }
+});
+// husky roadmap delete-phase <roadmapId> <phaseId>
+roadmapCommand
+    .command("delete-phase <roadmapId> <phaseId>")
+    .description("Delete a phase from a roadmap (including all its features)")
+    .option("--force", "Skip confirmation")
+    .action(async (roadmapId, phaseId, options) => {
+    const config = ensureConfig();
+    if (!options.force) {
+        console.log("Warning: This will permanently delete the phase and all its features.");
+        console.log("Use --force to confirm deletion.");
+        process.exit(1);
+    }
+    try {
+        const url = new URL(`/api/roadmaps/${roadmapId}/phases`, config.apiUrl);
+        url.searchParams.set("phaseId", phaseId);
+        const res = await fetch(url.toString(), {
+            method: "DELETE",
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            if (res.status === 404) {
+                console.error(`Error: Roadmap or phase not found`);
+            }
+            else {
+                const errorBody = await res.json().catch(() => ({}));
+                console.error(`Error: API returned ${res.status}`, errorBody.error || "");
+            }
+            process.exit(1);
+        }
+        const roadmap = await res.json();
+        console.log(`✓ Phase deleted`);
+        console.log(`  Remaining phases: ${roadmap.phases.length}`);
+    }
+    catch (error) {
+        console.error("Error deleting phase:", error);
+        process.exit(1);
+    }
+});
 // husky roadmap add-feature <roadmapId> <phaseId> <title>
 roadmapCommand
     .command("add-feature <roadmapId> <phaseId> <title>")

package/dist/commands/task.js

@@ -2,6 +2,7 @@ import { Command } from "commander";
 import { getConfig } from "./config.js";
 import * as fs from "fs";
 import * as readline from "readline";
+import { paginateList, printPaginated } from "../lib/pagination.js";
 export const taskCommand = new Command("task")
     .description("Manage tasks");
 // Helper: Get task ID from --id flag or HUSKY_TASK_ID env var
@@ -40,6 +41,10 @@ taskCommand
     .command("list")
     .description("List all tasks")
     .option("-s, --status <status>", "Filter by status")
+    .option("-p, --page <num>", "Page number (starts at 1)", "1")
+    .option("-n, --per-page <num>", "Items per page (default: all)")
+    .option("-i, --interactive", "Interactive pagination with arrow keys")
+    .option("--json", "Output as JSON")
     .action(async (options) => {
     const config = getConfig();
     if (!config.apiUrl) {
@@ -58,6 +63,49 @@ taskCommand
             throw new Error(`API error: ${res.status}`);
         }
         const tasks = await res.json();
+        // JSON output
+        if (options.json) {
+            console.log(JSON.stringify(tasks, null, 2));
+            return;
+        }
+        // Interactive pagination mode
+        if (options.interactive) {
+            await paginateList({
+                items: tasks,
+                pageSize: 10,
+                title: "Tasks",
+                emptyMessage: "No tasks found.",
+                renderItem: (task) => {
+                    const statusIcon = task.status === "done" ? "✓" : task.status === "in_progress" ? "▶" : "○";
+                    const priorityIcon = task.priority === "urgent" ? "🔴" : task.priority === "high" ? "🟠" : "";
+                    return `  ${statusIcon} ${task.id.slice(0, 8)} │ ${task.title.slice(0, 40).padEnd(40)} ${priorityIcon}`;
+                },
+                selectableItems: true,
+                onSelect: async (task) => {
+                    console.clear();
+                    console.log(`\n  Task: ${task.title}`);
+                    console.log("  " + "─".repeat(50));
+                    console.log(`  ID:       ${task.id}`);
+                    console.log(`  Status:   ${task.status}`);
+                    console.log(`  Priority: ${task.priority}`);
+                    if (task.agent)
+                        console.log(`  Agent:    ${task.agent}`);
+                    console.log("");
+                },
+            });
+            return;
+        }
+        // Simple pagination mode
+        if (options.perPage) {
+            const pageNum = parseInt(options.page, 10) - 1;
+            const pageSize = parseInt(options.perPage, 10);
+            printPaginated(tasks, pageNum, pageSize, (task) => {
+                const statusIcon = task.status === "done" ? "✓" : task.status === "in_progress" ? "▶" : "○";
+                return `  ${statusIcon} ${task.id.slice(0, 8)} │ ${task.title}`;
+            }, "Tasks");
+            return;
+        }
+        // Default: grouped by status (original behavior)
         printTasks(tasks);
     }
     catch (error) {

package/dist/commands/workflow.js

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { getConfig } from "./config.js";
+import { paginateList, printPaginated } from "../lib/pagination.js";
 export const workflowCommand = new Command("workflow")
     .description("Manage workflows and workflow steps");
 // Helper: Ensure API is configured
@@ -11,12 +12,28 @@ function ensureConfig() {
     }
     return config;
 }
+// Status icons
+const STATUS_ICONS = {
+    draft: "📝",
+    active: "▶️",
+    paused: "⏸️",
+    archived: "📦",
+};
+// Action labels
+const ACTION_LABELS = {
+    manual: "Manual",
+    semi_automated: "Semi-Auto",
+    fully_automated: "Auto",
+};
 // husky workflow list
 workflowCommand
     .command("list")
     .description("List all workflows")
     .option("--value-stream <valueStream>", "Filter by value stream")
     .option("--json", "Output as JSON")
+    .option("-p, --page <num>", "Page number (starts at 1)", "1")
+    .option("-n, --per-page <num>", "Items per page (default: all)")
+    .option("-i, --interactive", "Interactive pagination with arrow keys")
     .action(async (options) => {
     const config = ensureConfig();
     try {
@@ -33,10 +50,49 @@ workflowCommand
         const workflows = await res.json();
         if (options.json) {
             console.log(JSON.stringify(workflows, null, 2));
-        }
-        else {
-            printWorkflows(workflows);
-        }
+            return;
+        }
+        // Interactive pagination mode
+        if (options.interactive) {
+            await paginateList({
+                items: workflows,
+                pageSize: 10,
+                title: "Workflows",
+                emptyMessage: "No workflows found.",
+                renderItem: (wf) => {
+                    const icon = STATUS_ICONS[wf.status] || "○";
+                    const action = ACTION_LABELS[wf.action] || wf.action;
+                    return `  ${icon} ${wf.name.slice(0, 35).padEnd(35)} │ ${action}`;
+                },
+                selectableItems: true,
+                onSelect: async (wf) => {
+                    console.clear();
+                    console.log(`\n  Workflow: ${wf.name}`);
+                    console.log("  " + "─".repeat(50));
+                    console.log(`  ID:          ${wf.id}`);
+                    console.log(`  Status:      ${wf.status}`);
+                    console.log(`  Action:      ${ACTION_LABELS[wf.action]}`);
+                    console.log(`  ValueStream: ${wf.valueStream}`);
+                    console.log(`  Autonomy:    ${wf.autonomyWeight}%`);
+                    if (wf.description)
+                        console.log(`  Desc:        ${wf.description}`);
+                    console.log("");
+                },
+            });
+            return;
+        }
+        // Simple pagination mode
+        if (options.perPage) {
+            const pageNum = parseInt(options.page, 10) - 1;
+            const pageSize = parseInt(options.perPage, 10);
+            printPaginated(workflows, pageNum, pageSize, (wf) => {
+                const icon = STATUS_ICONS[wf.status] || "○";
+                return `  ${icon} ${wf.id.slice(0, 8)} │ ${wf.name}`;
+            }, "Workflows");
+            return;
+        }
+        // Default list
+        printWorkflows(workflows);
     }
     catch (error) {
         console.error("Error fetching workflows:", error);
@@ -91,9 +147,9 @@ workflowCommand
     .command("create <name>")
     .description("Create a new workflow")
     .option("-d, --description <description>", "Workflow description")
-    .option("--value-stream <valueStream>", "Value stream", "general")
-    .option("--status <status>", "Workflow status (draft, active, paused, archived)", "draft")
-    .option("--action <action>", "Action type (manual, semi_automated, fully_automated)", "manual")
+    .option("--value-stream <valueStream>", "Value stream (order_to_delivery, procure_to_pay, returns_management, product_lifecycle, customer_service, finance_admin)", "customer_service")
+    .option("--status <status>", "Workflow status (owner_only, approval_needed, supervised, delegated, automated)", "owner_only")
+    .option("--action <action>", "Action type (automate, hire, document, fix, ok)", "document")
     .option("--json", "Output as JSON")
     .action(async (name, options) => {
     const config = ensureConfig();

package/dist/index.js

@@ -23,7 +23,7 @@ const program = new Command();
 program
     .name("husky")
     .description("CLI for Huskyv0 Task Orchestration with Claude Agent")
-    .version("0.5.2");
+    .version("0.6.0");
 program.addCommand(taskCommand);
 program.addCommand(configCommand);
 program.addCommand(agentCommand);

package/dist/lib/pagination.d.ts

@@ -0,0 +1,36 @@
+export interface PaginationOptions<T> {
+    items: T[];
+    pageSize?: number;
+    renderItem: (item: T, index: number) => string;
+    title?: string;
+    emptyMessage?: string;
+    selectableItems?: boolean;
+    onSelect?: (item: T) => Promise<void>;
+}
+export interface PaginationResult<T> {
+    selectedItem: T | null;
+    action: "select" | "exit";
+}
+/**
+ * Interactive paginated list with arrow key navigation
+ *
+ * @example
+ * await paginateList({
+ *   items: tasks,
+ *   pageSize: 10,
+ *   renderItem: (t, i) => `${t.id} - ${t.title}`,
+ *   title: "Tasks",
+ *   selectableItems: true,
+ *   onSelect: async (task) => console.log(`Selected: ${task.title}`)
+ * });
+ */
+export declare function paginateList<T>(options: PaginationOptions<T>): Promise<PaginationResult<T>>;
+/**
+ * Simple paginated display without interactivity
+ * Useful for CLI commands that just want to show paginated output
+ */
+export declare function printPaginated<T>(items: T[], page: number, pageSize: number, renderItem: (item: T, index: number) => string, title?: string): {
+    hasMore: boolean;
+    totalPages: number;
+    currentPage: number;
+};

package/dist/lib/pagination.js

@@ -0,0 +1,180 @@
+import { select } from "@inquirer/prompts";
+const NAVIGATION_SEPARATOR = "──────────────";
+/**
+ * Interactive paginated list with arrow key navigation
+ *
+ * @example
+ * await paginateList({
+ *   items: tasks,
+ *   pageSize: 10,
+ *   renderItem: (t, i) => `${t.id} - ${t.title}`,
+ *   title: "Tasks",
+ *   selectableItems: true,
+ *   onSelect: async (task) => console.log(`Selected: ${task.title}`)
+ * });
+ */
+export async function paginateList(options) {
+    const { items, pageSize = 10, renderItem, title = "Items", emptyMessage = "No items found.", selectableItems = false, onSelect, } = options;
+    if (items.length === 0) {
+        console.log(`\n  ${emptyMessage}`);
+        return { selectedItem: null, action: "exit" };
+    }
+    const totalPages = Math.ceil(items.length / pageSize);
+    let currentPage = 0;
+    while (true) {
+        const startIndex = currentPage * pageSize;
+        const endIndex = Math.min(startIndex + pageSize, items.length);
+        const pageItems = items.slice(startIndex, endIndex);
+        // Clear screen and show header
+        console.clear();
+        console.log(`\n  ${title} (${items.length} total)`);
+        console.log(`  Page ${currentPage + 1} of ${totalPages}`);
+        console.log("  " + "─".repeat(50));
+        // Build choices for current page
+        const choices = [];
+        // Add page items
+        pageItems.forEach((item, idx) => {
+            const globalIndex = startIndex + idx;
+            const displayText = renderItem(item, globalIndex);
+            choices.push({
+                name: displayText,
+                value: selectableItems ? `item:${globalIndex}` : `view:${globalIndex}`,
+                description: selectableItems ? "Select this item" : undefined,
+            });
+        });
+        // Add separator
+        choices.push({
+            name: NAVIGATION_SEPARATOR,
+            value: "separator",
+            description: "",
+        });
+        // Navigation options
+        const navOptions = [];
+        if (currentPage > 0) {
+            navOptions.push({
+                name: "← Previous Page",
+                value: "prev",
+                description: `Go to page ${currentPage}`,
+            });
+        }
+        if (currentPage < totalPages - 1) {
+            navOptions.push({
+                name: "→ Next Page",
+                value: "next",
+                description: `Go to page ${currentPage + 2}`,
+            });
+        }
+        if (totalPages > 2) {
+            navOptions.push({
+                name: "⇢ Jump to Page...",
+                value: "jump",
+                description: `Go to a specific page (1-${totalPages})`,
+            });
+        }
+        navOptions.push({
+            name: "✕ Exit",
+            value: "exit",
+            description: "Return to previous menu",
+        });
+        choices.push(...navOptions);
+        try {
+            const answer = await select({
+                message: "Navigate with ↑↓, select with Enter:",
+                choices,
+                pageSize: pageSize + 5, // Room for navigation
+            });
+            if (answer === "separator") {
+                // User selected separator, ignore and continue
+                continue;
+            }
+            if (answer === "prev") {
+                currentPage = Math.max(0, currentPage - 1);
+                continue;
+            }
+            if (answer === "next") {
+                currentPage = Math.min(totalPages - 1, currentPage + 1);
+                continue;
+            }
+            if (answer === "jump") {
+                const jumpChoice = await selectPageNumber(totalPages, currentPage);
+                if (jumpChoice !== null) {
+                    currentPage = jumpChoice;
+                }
+                continue;
+            }
+            if (answer === "exit") {
+                return { selectedItem: null, action: "exit" };
+            }
+            // Handle item selection
+            if (answer.startsWith("item:") || answer.startsWith("view:")) {
+                const index = parseInt(answer.split(":")[1], 10);
+                const selectedItem = items[index];
+                if (selectableItems && onSelect && selectedItem) {
+                    await onSelect(selectedItem);
+                }
+                return { selectedItem, action: "select" };
+            }
+        }
+        catch (error) {
+            // User pressed Ctrl+C or escape
+            return { selectedItem: null, action: "exit" };
+        }
+    }
+}
+/**
+ * Helper to select a page number
+ */
+async function selectPageNumber(totalPages, currentPage) {
+    const choices = [];
+    for (let i = 0; i < totalPages; i++) {
+        choices.push({
+            name: `Page ${i + 1}${i === currentPage ? " (current)" : ""}`,
+            value: i.toString(),
+        });
+    }
+    choices.push({
+        name: "Cancel",
+        value: "cancel",
+    });
+    try {
+        const answer = await select({
+            message: "Select page:",
+            choices,
+            pageSize: Math.min(totalPages + 1, 15),
+        });
+        if (answer === "cancel") {
+            return null;
+        }
+        return parseInt(answer, 10);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Simple paginated display without interactivity
+ * Useful for CLI commands that just want to show paginated output
+ */
+export function printPaginated(items, page, pageSize, renderItem, title) {
+    const totalPages = Math.ceil(items.length / pageSize);
+    const currentPage = Math.min(Math.max(0, page), totalPages - 1);
+    const startIndex = currentPage * pageSize;
+    const endIndex = Math.min(startIndex + pageSize, items.length);
+    const pageItems = items.slice(startIndex, endIndex);
+    if (title) {
+        console.log(`\n  ${title}`);
+        console.log("  " + "─".repeat(50));
+    }
+    pageItems.forEach((item, idx) => {
+        console.log(renderItem(item, startIndex + idx));
+    });
+    if (totalPages > 1) {
+        console.log("");
+        console.log(`  Page ${currentPage + 1} of ${totalPages} (${items.length} total)`);
+    }
+    return {
+        hasMore: currentPage < totalPages - 1,
+        totalPages,
+        currentPage,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonfestl/husky-cli",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {