@simonfestl/husky-cli 0.5.0 → 0.5.2

package/dist/commands/interactive/tasks.d.ts

@@ -0,0 +1 @@
+export declare function tasksMenu(): Promise<void>;

package/dist/commands/interactive/tasks.js

@@ -0,0 +1,415 @@
+import { select, input, confirm } from "@inquirer/prompts";
+import { ensureConfig, pressEnterToContinue, truncate } from "./utils.js";
+export async function tasksMenu() {
+    const config = ensureConfig();
+    const menuItems = [
+        { name: "List all tasks", value: "list" },
+        { name: "View task details", value: "view" },
+        { name: "Create new task", value: "create" },
+        { name: "Update task", value: "update" },
+        { name: "Start task", value: "start" },
+        { name: "Mark as done", value: "done" },
+        { name: "Delete task", value: "delete" },
+        { name: "Search by status", value: "search" },
+        { name: "Back to main menu", value: "back" },
+    ];
+    const choice = await select({
+        message: "Tasks:",
+        choices: menuItems,
+    });
+    switch (choice) {
+        case "list":
+            await listTasks(config);
+            break;
+        case "view":
+            await viewTask(config);
+            break;
+        case "create":
+            await createTask(config);
+            break;
+        case "update":
+            await updateTask(config);
+            break;
+        case "start":
+            await startTask(config);
+            break;
+        case "done":
+            await markTaskDone(config);
+            break;
+        case "delete":
+            await deleteTask(config);
+            break;
+        case "search":
+            await searchTasks(config);
+            break;
+        case "back":
+            return;
+    }
+}
+async function fetchTasks(config, status) {
+    const url = new URL("/api/tasks", config.apiUrl);
+    if (status)
+        url.searchParams.set("status", status);
+    const res = await fetch(url.toString(), {
+        headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+    });
+    if (!res.ok)
+        throw new Error(`API returned ${res.status}`);
+    return res.json();
+}
+async function fetchProjects(config) {
+    const res = await fetch(`${config.apiUrl}/api/projects`, {
+        headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+    });
+    if (!res.ok)
+        return [];
+    return res.json();
+}
+async function selectTask(config, message) {
+    const tasks = await fetchTasks(config);
+    if (tasks.length === 0) {
+        console.log("\n  No tasks found.\n");
+        await pressEnterToContinue();
+        return null;
+    }
+    const choices = tasks.map((t) => ({
+        name: `[${t.status}] ${truncate(t.title, 40)} (${t.priority})`,
+        value: t.id,
+    }));
+    choices.push({ name: "Cancel", value: "__cancel__" });
+    const taskId = await select({ message, choices });
+    if (taskId === "__cancel__")
+        return null;
+    return tasks.find((t) => t.id === taskId) || null;
+}
+async function listTasks(config) {
+    try {
+        const tasks = await fetchTasks(config);
+        console.log("\n  TASKS");
+        console.log("  " + "-".repeat(70));
+        if (tasks.length === 0) {
+            console.log("  No tasks found.");
+        }
+        else {
+            for (const task of tasks) {
+                const statusIcon = task.status === "done" ? "[x]" : task.status === "in_progress" ? "[>]" : "[ ]";
+                console.log(`  ${statusIcon} ${truncate(task.title, 50).padEnd(50)} [${task.priority}]`);
+                console.log(`      ID: ${task.id}`);
+            }
+        }
+        console.log("");
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error fetching tasks:", error);
+        await pressEnterToContinue();
+    }
+}
+async function viewTask(config) {
+    try {
+        const task = await selectTask(config, "Select task to view:");
+        if (!task)
+            return;
+        const res = await fetch(`${config.apiUrl}/api/tasks/${task.id}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            console.error(`\n  Error: API returned ${res.status}\n`);
+            await pressEnterToContinue();
+            return;
+        }
+        const fullTask = await res.json();
+        console.log(`\n  Task: ${fullTask.title}`);
+        console.log("  " + "-".repeat(50));
+        console.log(`  ID:          ${fullTask.id}`);
+        console.log(`  Status:      ${fullTask.status}`);
+        console.log(`  Priority:    ${fullTask.priority}`);
+        console.log(`  Assignee:    ${fullTask.assignee || "unassigned"}`);
+        if (fullTask.projectId) {
+            console.log(`  Project:     ${fullTask.projectId}`);
+        }
+        if (fullTask.description) {
+            console.log(`  Description: ${fullTask.description}`);
+        }
+        console.log("");
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error viewing task:", error);
+        await pressEnterToContinue();
+    }
+}
+async function createTask(config) {
+    try {
+        const title = await input({
+            message: "Task title:",
+            validate: (value) => (value.length > 0 ? true : "Title is required"),
+        });
+        const description = await input({
+            message: "Description (optional):",
+        });
+        const priority = await select({
+            message: "Priority:",
+            choices: [
+                { name: "Low", value: "low" },
+                { name: "Medium", value: "medium" },
+                { name: "High", value: "high" },
+            ],
+            default: "medium",
+        });
+        // Optional: Link to project
+        const projects = await fetchProjects(config);
+        let projectId;
+        if (projects.length > 0) {
+            const linkToProject = await confirm({
+                message: "Link to a project?",
+                default: false,
+            });
+            if (linkToProject) {
+                const projectChoices = projects.map((p) => ({ name: p.name, value: p.id }));
+                projectId = await select({ message: "Select project:", choices: projectChoices });
+            }
+        }
+        const res = await fetch(`${config.apiUrl}/api/tasks`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                title,
+                description: description || undefined,
+                priority,
+                projectId,
+            }),
+        });
+        if (!res.ok) {
+            console.error(`\n  Error: API returned ${res.status}\n`);
+            await pressEnterToContinue();
+            return;
+        }
+        const task = await res.json();
+        console.log(`\n  ✓ Task created!`);
+        console.log(`  ID: ${task.id}`);
+        console.log(`  Title: ${task.title}\n`);
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error creating task:", error);
+        await pressEnterToContinue();
+    }
+}
+async function updateTask(config) {
+    try {
+        const task = await selectTask(config, "Select task to update:");
+        if (!task)
+            return;
+        const updateChoices = [
+            { name: "Status", value: "status" },
+            { name: "Priority", value: "priority" },
+            { name: "Assignee", value: "assignee" },
+            { name: "Link to Project", value: "project" },
+            { name: "Title", value: "title" },
+            { name: "Description", value: "description" },
+            { name: "Cancel", value: "cancel" },
+        ];
+        const field = await select({ message: "What to update?", choices: updateChoices });
+        if (field === "cancel")
+            return;
+        let updateData = {};
+        switch (field) {
+            case "status":
+                updateData.status = await select({
+                    message: "New status:",
+                    choices: [
+                        { name: "Backlog", value: "backlog" },
+                        { name: "In Progress", value: "in_progress" },
+                        { name: "Review", value: "review" },
+                        { name: "Done", value: "done" },
+                    ],
+                    default: task.status,
+                });
+                break;
+            case "priority":
+                updateData.priority = await select({
+                    message: "New priority:",
+                    choices: [
+                        { name: "Low", value: "low" },
+                        { name: "Medium", value: "medium" },
+                        { name: "High", value: "high" },
+                        { name: "Urgent", value: "urgent" },
+                    ],
+                    default: task.priority,
+                });
+                break;
+            case "assignee":
+                updateData.assignee = await select({
+                    message: "Assign to:",
+                    choices: [
+                        { name: "Human", value: "human" },
+                        { name: "LLM Agent", value: "llm" },
+                        { name: "Unassigned", value: "unassigned" },
+                    ],
+                    default: task.assignee || "unassigned",
+                });
+                break;
+            case "project":
+                const projects = await fetchProjects(config);
+                if (projects.length === 0) {
+                    console.log("\n  No projects available.\n");
+                    await pressEnterToContinue();
+                    return;
+                }
+                const projectChoices = projects.map((p) => ({ name: p.name, value: p.id }));
+                projectChoices.push({ name: "Remove project link", value: "__none__" });
+                const projectId = await select({ message: "Select project:", choices: projectChoices });
+                updateData.projectId = projectId === "__none__" ? "" : projectId;
+                break;
+            case "title":
+                updateData.title = await input({
+                    message: "New title:",
+                    default: task.title,
+                    validate: (v) => (v.length > 0 ? true : "Title required"),
+                });
+                break;
+            case "description":
+                updateData.description = await input({
+                    message: "New description:",
+                    default: task.description || "",
+                });
+                break;
+        }
+        const res = await fetch(`${config.apiUrl}/api/tasks/${task.id}`, {
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify(updateData),
+        });
+        if (!res.ok) {
+            console.error(`\n  Error: API returned ${res.status}\n`);
+            await pressEnterToContinue();
+            return;
+        }
+        console.log(`\n  ✓ Task updated!\n`);
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error updating task:", error);
+        await pressEnterToContinue();
+    }
+}
+async function startTask(config) {
+    try {
+        const task = await selectTask(config, "Select task to start:");
+        if (!task)
+            return;
+        const res = await fetch(`${config.apiUrl}/api/tasks/${task.id}/start`, {
+            method: "POST",
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            console.error(`\n  Error: API returned ${res.status}\n`);
+            await pressEnterToContinue();
+            return;
+        }
+        console.log(`\n  ✓ Task started: ${task.title}\n`);
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error starting task:", error);
+        await pressEnterToContinue();
+    }
+}
+async function markTaskDone(config) {
+    try {
+        const task = await selectTask(config, "Select task to mark as done:");
+        if (!task)
+            return;
+        const prUrl = await input({
+            message: "PR URL (optional):",
+        });
+        const res = await fetch(`${config.apiUrl}/api/tasks/${task.id}/done`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({ prUrl: prUrl || undefined }),
+        });
+        if (!res.ok) {
+            console.error(`\n  Error: API returned ${res.status}\n`);
+            await pressEnterToContinue();
+            return;
+        }
+        console.log(`\n  ✓ Task marked as done: ${task.title}\n`);
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error marking task done:", error);
+        await pressEnterToContinue();
+    }
+}
+async function deleteTask(config) {
+    try {
+        const task = await selectTask(config, "Select task to delete:");
+        if (!task)
+            return;
+        const confirmed = await confirm({
+            message: `Delete "${task.title}"? This cannot be undone.`,
+            default: false,
+        });
+        if (!confirmed) {
+            console.log("\n  Cancelled.\n");
+            await pressEnterToContinue();
+            return;
+        }
+        const res = await fetch(`${config.apiUrl}/api/tasks/${task.id}`, {
+            method: "DELETE",
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            console.error(`\n  Error: API returned ${res.status}\n`);
+            await pressEnterToContinue();
+            return;
+        }
+        console.log(`\n  ✓ Task deleted.\n`);
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error deleting task:", error);
+        await pressEnterToContinue();
+    }
+}
+async function searchTasks(config) {
+    try {
+        const status = await select({
+            message: "Filter by status:",
+            choices: [
+                { name: "Backlog", value: "backlog" },
+                { name: "In Progress", value: "in_progress" },
+                { name: "Review", value: "review" },
+                { name: "Done", value: "done" },
+            ],
+        });
+        const tasks = await fetchTasks(config, status);
+        console.log(`\n  TASKS (${status.replace("_", " ").toUpperCase()})`);
+        console.log("  " + "-".repeat(70));
+        if (tasks.length === 0) {
+            console.log("  No tasks found with this status.");
+        }
+        else {
+            for (const task of tasks) {
+                console.log(`  - ${truncate(task.title, 50)} [${task.priority}]`);
+                console.log(`    ID: ${task.id}`);
+            }
+        }
+        console.log("");
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error searching tasks:", error);
+        await pressEnterToContinue();
+    }
+}

package/dist/commands/interactive/utils.d.ts

@@ -0,0 +1,15 @@
+export interface MenuItem {
+    name: string;
+    value: string;
+    description?: string;
+}
+export interface ValidConfig {
+    apiUrl: string;
+    apiKey?: string;
+}
+export declare function ensureConfig(): ValidConfig;
+export declare function clearScreen(): void;
+export declare function printHeader(): void;
+export declare function pressEnterToContinue(): Promise<void>;
+export declare function formatDate(dateStr: string | undefined): string;
+export declare function truncate(str: string, length: number): string;

package/dist/commands/interactive/utils.js

@@ -0,0 +1,54 @@
+import { input } from "@inquirer/prompts";
+import { getConfig } from "../config.js";
+// Helper: Ensure API is configured
+export function ensureConfig() {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    return config;
+}
+// Clear screen helper
+export function clearScreen() {
+    console.clear();
+}
+// Print header
+export function printHeader() {
+    const config = getConfig();
+    console.log("\n");
+    console.log("  🐕 Husky CLI - Interactive Mode");
+    console.log("  " + "─".repeat(35));
+    if (!config.apiUrl) {
+        console.log("");
+        console.log("  ⚠️  Getting Started:");
+        console.log("  Go to 'CLI Config' to set up your API URL and Key");
+    }
+    else {
+        console.log(`  Connected to: ${config.apiUrl.substring(0, 40)}`);
+    }
+    console.log("");
+}
+// Press Enter to continue
+export async function pressEnterToContinue() {
+    await input({
+        message: "Press Enter to continue...",
+    });
+}
+// Format date for display
+export function formatDate(dateStr) {
+    if (!dateStr)
+        return "-";
+    try {
+        return new Date(dateStr).toLocaleDateString();
+    }
+    catch {
+        return "-";
+    }
+}
+// Truncate string with ellipsis
+export function truncate(str, length) {
+    if (!str)
+        return "";
+    return str.length > length ? str.substring(0, length - 3) + "..." : str;
+}

package/dist/commands/interactive/vm-sessions.d.ts

@@ -0,0 +1 @@
+export declare function vmSessionsMenu(): Promise<void>;