@simonfestl/husky-cli 0.3.0 → 0.5.0

package/dist/commands/task.js

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { getConfig } from "./config.js";
 import * as fs from "fs";
+import * as readline from "readline";
 export const taskCommand = new Command("task")
     .description("Manage tasks");
 // Helper: Get task ID from --id flag or HUSKY_TASK_ID env var
@@ -21,6 +22,19 @@ function ensureConfig() {
     }
     return config;
 }
+// Helper: Prompt for confirmation
+async function confirm(message) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`${message} (y/N): `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+        });
+    });
+}
 // husky task list
 taskCommand
     .command("list")
@@ -152,6 +166,132 @@ taskCommand
         process.exit(1);
     }
 });
+// husky task update <id>
+taskCommand
+    .command("update <id>")
+    .description("Update task properties")
+    .option("-t, --title <title>", "New title")
+    .option("-d, --description <desc>", "New description")
+    .option("--status <status>", "New status (backlog, in_progress, review, done)")
+    .option("--priority <priority>", "New priority (low, medium, high, urgent)")
+    .option("--assignee <assignee>", "New assignee (human, llm, unassigned)")
+    .option("--project <projectId>", "Link to project")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    // Build update payload with only changed fields
+    const updates = {};
+    if (options.title)
+        updates.title = options.title;
+    if (options.description)
+        updates.description = options.description;
+    if (options.status)
+        updates.status = options.status;
+    if (options.priority)
+        updates.priority = options.priority;
+    if (options.assignee)
+        updates.assignee = options.assignee;
+    if (options.project)
+        updates.projectId = options.project;
+    if (Object.keys(updates).length === 0) {
+        console.error("Error: No update options provided. Use --help for available options.");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/tasks/${id}`, {
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify(updates),
+        });
+        if (!res.ok) {
+            if (res.status === 404) {
+                console.error(`Error: Task ${id} not found`);
+            }
+            else {
+                console.error(`Error: API returned ${res.status}`);
+            }
+            process.exit(1);
+        }
+        const task = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(task, null, 2));
+        }
+        else {
+            console.log(`✓ Updated: ${task.title}`);
+            const changedFields = Object.keys(updates).join(", ");
+            console.log(`  Changed: ${changedFields}`);
+        }
+    }
+    catch (error) {
+        console.error("Error updating task:", error);
+        process.exit(1);
+    }
+});
+// husky task delete <id>
+taskCommand
+    .command("delete <id>")
+    .description("Delete a task")
+    .option("--force", "Skip confirmation prompt")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    // Confirm deletion unless --force is provided
+    if (!options.force) {
+        // First fetch task details to show what will be deleted
+        try {
+            const getRes = await fetch(`${config.apiUrl}/api/tasks/${id}`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            });
+            if (!getRes.ok) {
+                if (getRes.status === 404) {
+                    console.error(`Error: Task ${id} not found`);
+                }
+                else {
+                    console.error(`Error: API returned ${getRes.status}`);
+                }
+                process.exit(1);
+            }
+            const task = await getRes.json();
+            const confirmed = await confirm(`Delete task "${task.title}" (${id})?`);
+            if (!confirmed) {
+                console.log("Deletion cancelled.");
+                process.exit(0);
+            }
+        }
+        catch (error) {
+            console.error("Error fetching task:", error);
+            process.exit(1);
+        }
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/tasks/${id}`, {
+            method: "DELETE",
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            if (res.status === 404) {
+                console.error(`Error: Task ${id} not found`);
+            }
+            else {
+                console.error(`Error: API returned ${res.status}`);
+            }
+            process.exit(1);
+        }
+        if (options.json) {
+            console.log(JSON.stringify({ deleted: true, id }, null, 2));
+        }
+        else {
+            console.log(`✓ Deleted task ${id}`);
+        }
+    }
+    catch (error) {
+        console.error("Error deleting task:", error);
+        process.exit(1);
+    }
+});
 // husky task get [--id <id>] [--json]
 taskCommand
     .command("get")
@@ -601,6 +741,109 @@ taskCommand
         process.exit(1);
     }
 });
+// ============================================
+// MERGE CONFLICT RESOLUTION
+// ============================================
+// husky task merge-conflict --file <path> --ours <content> --theirs <content> [--base <content>] [--context <text>]
+taskCommand
+    .command("merge-conflict")
+    .description("Resolve a Git merge conflict using AI")
+    .requiredOption("--file <path>", "Path to the conflicted file")
+    .requiredOption("--ours <content>", "Content from current branch (ours)")
+    .requiredOption("--theirs <content>", "Content from incoming branch (theirs)")
+    .option("--base <content>", "Content from common ancestor (for 3-way merge)")
+    .option("--context <text>", "Additional context about the merge")
+    .option("--json", "Output as JSON")
+    .option("--ours-file <path>", "Read ours content from file")
+    .option("--theirs-file <path>", "Read theirs content from file")
+    .option("--base-file <path>", "Read base content from file")
+    .action(async (options) => {
+    const config = ensureConfig();
+    // Read content from files if specified
+    let oursContent = options.ours;
+    let theirsContent = options.theirs;
+    let baseContent = options.base;
+    if (options.oursFile) {
+        try {
+            oursContent = fs.readFileSync(options.oursFile, "utf-8");
+        }
+        catch (error) {
+            console.error(`Error reading ours file ${options.oursFile}:`, error);
+            process.exit(1);
+        }
+    }
+    if (options.theirsFile) {
+        try {
+            theirsContent = fs.readFileSync(options.theirsFile, "utf-8");
+        }
+        catch (error) {
+            console.error(`Error reading theirs file ${options.theirsFile}:`, error);
+            process.exit(1);
+        }
+    }
+    if (options.baseFile) {
+        try {
+            baseContent = fs.readFileSync(options.baseFile, "utf-8");
+        }
+        catch (error) {
+            console.error(`Error reading base file ${options.baseFile}:`, error);
+            process.exit(1);
+        }
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/merge-conflict/resolve`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                filePath: options.file,
+                oursContent,
+                theirsContent,
+                baseContent,
+                context: options.context,
+            }),
+        });
+        if (!res.ok) {
+            const errorData = await res.json().catch(() => ({ error: `API error: ${res.status}` }));
+            throw new Error(errorData.error || `API error: ${res.status}`);
+        }
+        const result = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`\n  Merge Conflict Resolution: ${options.file}`);
+            console.log("  " + "=".repeat(50));
+            console.log(`\n  Confidence: ${result.confidence}%`);
+            // Confidence indicator
+            if (result.confidence >= 90) {
+                console.log("  Status:     High confidence - safe to use");
+            }
+            else if (result.confidence >= 70) {
+                console.log("  Status:     Good confidence - review recommended");
+            }
+            else if (result.confidence >= 50) {
+                console.log("  Status:     Medium confidence - careful review needed");
+            }
+            else {
+                console.log("  Status:     Low confidence - manual resolution recommended");
+            }
+            console.log(`\n  Explanation:`);
+            console.log(`  ${result.explanation}`);
+            console.log("\n  " + "-".repeat(50));
+            console.log("  Resolved Content:");
+            console.log("  " + "-".repeat(50));
+            console.log(result.resolvedContent);
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Error resolving merge conflict:", error);
+        process.exit(1);
+    }
+});
 function printTasks(tasks) {
     const byStatus = {
         backlog: [],
@@ -628,7 +871,7 @@ function printTasks(tasks) {
         for (const task of statusTasks) {
             const agentStr = task.agent ? ` (${task.agent})` : "";
             const doneStr = status === "done" ? " ✓" : "";
-            console.log(`  #${task.id.slice(0, 6)}  ${task.title.padEnd(30)}  ${task.priority}${agentStr}${doneStr}`);
+            console.log(`  ${task.id}  ${task.title.slice(0, 30).padEnd(30)}  ${task.priority}${agentStr}${doneStr}`);
         }
     }
     console.log("");

package/dist/commands/vm-config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const vmConfigCommand: Command;

package/dist/commands/vm-config.js

@@ -0,0 +1,318 @@
+import { Command } from "commander";
+import { getConfig } from "./config.js";
+import * as readline from "readline";
+export const vmConfigCommand = new Command("vm-config")
+    .description("Manage VM configurations");
+// Helper: Ensure API is configured
+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;
+}
+// Helper: Prompt for confirmation
+async function confirm(message) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`${message} (y/N): `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+        });
+    });
+}
+// husky vm-config list
+vmConfigCommand
+    .command("list")
+    .description("List all VM configurations")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = ensureConfig();
+    try {
+        const res = await fetch(`${config.apiUrl}/api/vm-configs`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        const configs = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(configs, null, 2));
+        }
+        else {
+            printVMConfigs(configs);
+        }
+    }
+    catch (error) {
+        console.error("Error fetching VM configs:", error);
+        process.exit(1);
+    }
+});
+// husky vm-config get <id>
+vmConfigCommand
+    .command("get <id>")
+    .description("Get VM configuration details")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    try {
+        const res = await fetch(`${config.apiUrl}/api/vm-configs/${id}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            if (res.status === 404) {
+                console.error(`Error: VM config ${id} not found`);
+            }
+            else {
+                console.error(`Error: API returned ${res.status}`);
+            }
+            process.exit(1);
+        }
+        const vmConfig = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(vmConfig, null, 2));
+        }
+        else {
+            printVMConfigDetail(vmConfig);
+        }
+    }
+    catch (error) {
+        console.error("Error fetching VM config:", error);
+        process.exit(1);
+    }
+});
+// husky vm-config create <name>
+vmConfigCommand
+    .command("create <name>")
+    .description("Create a new VM configuration")
+    .option("--machine-type <type>", "GCP machine type (e.g., e2-medium)", "e2-medium")
+    .option("--zone <zone>", "GCP zone", "europe-west1-b")
+    .option("--disk-size <size>", "Disk size in GB", "20")
+    .option("--image <image>", "Base image")
+    .option("--max-runtime <minutes>", "Max runtime in minutes", "60")
+    .option("--max-concurrent <n>", "Max concurrent VMs", "3")
+    .option("--daily-budget <usd>", "Daily budget in USD", "10")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+    const config = ensureConfig();
+    try {
+        const createPayload = {
+            name,
+            machineType: options.machineType,
+            zone: options.zone,
+            diskSizeGb: parseInt(options.diskSize, 10),
+            maxRuntimeMinutes: parseInt(options.maxRuntime, 10),
+            maxConcurrentVMs: parseInt(options.maxConcurrent, 10),
+            dailyBudgetUsd: parseFloat(options.dailyBudget),
+        };
+        if (options.image) {
+            createPayload.baseImage = options.image;
+        }
+        const res = await fetch(`${config.apiUrl}/api/vm-configs`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify(createPayload),
+        });
+        if (!res.ok) {
+            const errorData = await res.json().catch(() => ({}));
+            throw new Error(errorData.error || `API error: ${res.status}`);
+        }
+        const vmConfig = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(vmConfig, null, 2));
+        }
+        else {
+            console.log(`Created VM config: ${vmConfig.name}`);
+            console.log(`  ID:           ${vmConfig.id}`);
+            console.log(`  Machine Type: ${vmConfig.machineType}`);
+            console.log(`  Zone:         ${vmConfig.zone}`);
+            console.log(`  Disk Size:    ${vmConfig.diskSizeGb} GB`);
+        }
+    }
+    catch (error) {
+        console.error("Error creating VM config:", error);
+        process.exit(1);
+    }
+});
+// husky vm-config update <id>
+vmConfigCommand
+    .command("update <id>")
+    .description("Update a VM configuration")
+    .option("-n, --name <name>", "New name")
+    .option("--machine-type <type>", "GCP machine type (e.g., e2-medium)")
+    .option("--zone <zone>", "GCP zone")
+    .option("--disk-size <size>", "Disk size in GB")
+    .option("--image <image>", "Base image")
+    .option("--max-runtime <minutes>", "Max runtime in minutes")
+    .option("--max-concurrent <n>", "Max concurrent VMs")
+    .option("--daily-budget <usd>", "Daily budget in USD")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    // Build update payload
+    const updateData = {};
+    if (options.name)
+        updateData.name = options.name;
+    if (options.machineType)
+        updateData.machineType = options.machineType;
+    if (options.zone)
+        updateData.zone = options.zone;
+    if (options.diskSize)
+        updateData.diskSizeGb = parseInt(options.diskSize, 10);
+    if (options.image)
+        updateData.baseImage = options.image;
+    if (options.maxRuntime)
+        updateData.maxRuntimeMinutes = parseInt(options.maxRuntime, 10);
+    if (options.maxConcurrent)
+        updateData.maxConcurrentVMs = parseInt(options.maxConcurrent, 10);
+    if (options.dailyBudget)
+        updateData.dailyBudgetUsd = parseFloat(options.dailyBudget);
+    if (Object.keys(updateData).length === 0) {
+        console.error("Error: No update options provided. Use --help for available options.");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/vm-configs/${id}`, {
+            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: VM config ${id} not found`);
+            }
+            else {
+                const errorData = await res.json().catch(() => ({}));
+                console.error(`Error: ${errorData.error || `API returned ${res.status}`}`);
+            }
+            process.exit(1);
+        }
+        const vmConfig = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(vmConfig, null, 2));
+        }
+        else {
+            console.log(`VM config updated successfully`);
+            console.log(`  Name:         ${vmConfig.name}`);
+            console.log(`  Machine Type: ${vmConfig.machineType}`);
+            console.log(`  Zone:         ${vmConfig.zone}`);
+        }
+    }
+    catch (error) {
+        console.error("Error updating VM config:", error);
+        process.exit(1);
+    }
+});
+// husky vm-config delete <id>
+vmConfigCommand
+    .command("delete <id>")
+    .description("Delete a VM configuration")
+    .option("--force", "Skip confirmation")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    // Prevent deletion of default config
+    if (id === "default") {
+        console.error("Error: Cannot delete the default VM config");
+        process.exit(1);
+    }
+    // Confirm deletion unless --force is provided
+    if (!options.force) {
+        try {
+            const getRes = await fetch(`${config.apiUrl}/api/vm-configs/${id}`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            });
+            if (!getRes.ok) {
+                if (getRes.status === 404) {
+                    console.error(`Error: VM config ${id} not found`);
+                }
+                else {
+                    console.error(`Error: API returned ${getRes.status}`);
+                }
+                process.exit(1);
+            }
+            const vmConfig = await getRes.json();
+            const confirmed = await confirm(`Delete VM config "${vmConfig.name}" (${id})?`);
+            if (!confirmed) {
+                console.log("Deletion cancelled.");
+                process.exit(0);
+            }
+        }
+        catch (error) {
+            console.error("Error fetching VM config:", error);
+            process.exit(1);
+        }
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/vm-configs/${id}`, {
+            method: "DELETE",
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            if (res.status === 404) {
+                console.error(`Error: VM config ${id} not found`);
+            }
+            else {
+                const errorData = await res.json().catch(() => ({}));
+                console.error(`Error: ${errorData.error || `API returned ${res.status}`}`);
+            }
+            process.exit(1);
+        }
+        console.log(`VM config deleted`);
+    }
+    catch (error) {
+        console.error("Error deleting VM config:", error);
+        process.exit(1);
+    }
+});
+// Print helpers
+function printVMConfigs(configs) {
+    if (configs.length === 0) {
+        console.log("\n  No VM configs found.");
+        console.log("  Create one with: husky vm-config create <name>\n");
+        return;
+    }
+    console.log("\n  VM CONFIGURATIONS");
+    console.log("  " + "-".repeat(90));
+    console.log(`  ${"ID".padEnd(24)} ${"NAME".padEnd(20)} ${"MACHINE TYPE".padEnd(14)} ${"ZONE".padEnd(18)} DISK`);
+    console.log("  " + "-".repeat(90));
+    for (const cfg of configs) {
+        const truncatedName = cfg.name.length > 18 ? cfg.name.substring(0, 15) + "..." : cfg.name;
+        console.log(`  ${cfg.id.padEnd(24)} ${truncatedName.padEnd(20)} ${cfg.machineType.padEnd(14)} ${cfg.zone.padEnd(18)} ${cfg.diskSizeGb}GB`);
+    }
+    console.log("");
+}
+function printVMConfigDetail(vmConfig) {
+    console.log(`\n  VM Config: ${vmConfig.name}`);
+    console.log("  " + "-".repeat(60));
+    console.log(`  ID:              ${vmConfig.id}`);
+    console.log(`  Name:            ${vmConfig.name}`);
+    console.log("\n  GCP Settings:");
+    console.log(`    Machine Type:  ${vmConfig.machineType}`);
+    console.log(`    Zone:          ${vmConfig.zone}`);
+    console.log(`    Disk Size:     ${vmConfig.diskSizeGb} GB`);
+    console.log("\n  Limits:");
+    console.log(`    Max Runtime:   ${vmConfig.maxRuntimeMinutes} minutes`);
+    console.log(`    Max Concurrent: ${vmConfig.maxConcurrentVMs}`);
+    console.log(`    Daily Budget:  $${vmConfig.dailyBudgetUsd.toFixed(2)}`);
+    console.log("\n  Auto-Start:");
+    console.log(`    Enabled:       ${vmConfig.autoStartEnabled ? "Yes" : "No"}`);
+    console.log("\n  Review Settings:");
+    console.log(`    AI Review:     ${vmConfig.aiReviewEnabled ? "Enabled" : "Disabled"}`);
+    console.log(`    Human Review:  ${vmConfig.humanReviewRequired ? "Required" : "Optional"}`);
+    console.log(`    Auto-Approve:  ${vmConfig.autoApproveThreshold}% confidence threshold`);
+    console.log("\n  Retry Settings:");
+    console.log(`    Max Retries:   ${vmConfig.maxRetries}`);
+    console.log(`\n  Created:  ${new Date(vmConfig.createdAt).toLocaleString()}`);
+    console.log(`  Updated:  ${new Date(vmConfig.updatedAt).toLocaleString()}`);
+    console.log("");
+}

package/dist/commands/vm.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const vmCommand: Command;