@simonfestl/husky-cli 0.7.2 → 0.8.1

package/dist/commands/config.d.ts

@@ -2,8 +2,10 @@ import { Command } from "commander";
 interface Config {
     apiUrl?: string;
     apiKey?: string;
+    workerId?: string;
+    workerName?: string;
 }
 export declare function getConfig(): Config;
-export declare function setConfig(key: "apiUrl" | "apiKey", value: string): void;
+export declare function setConfig(key: "apiUrl" | "apiKey" | "workerId" | "workerName", value: string): void;
 export declare const configCommand: Command;
 export {};

package/dist/commands/config.js

@@ -46,7 +46,7 @@ function saveConfig(config) {
     }
     writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
 }
-// Helper to set a single config value (used by interactive mode)
+// Helper to set a single config value (used by interactive mode and worker identity)
 export function setConfig(key, value) {
     const config = getConfig();
     config[key] = value;

package/dist/commands/task.js

@@ -3,6 +3,9 @@ import { getConfig } from "./config.js";
 import * as fs from "fs";
 import * as readline from "readline";
 import { paginateList, printPaginated } from "../lib/pagination.js";
+import { ensureWorkerRegistered, generateSessionId, registerSession } from "../lib/worker.js";
+import { WorktreeManager } from "../lib/worktree.js";
+import { execSync } from "child_process";
 export const taskCommand = new Command("task")
     .description("Manage tasks");
 // Helper: Get task ID from --id flag or HUSKY_TASK_ID env var
@@ -36,6 +39,33 @@ async function confirm(message) {
         });
     });
 }
+// Helper: Check if current directory is a git repository
+function isGitRepo() {
+    try {
+        execSync("git rev-parse --is-inside-work-tree", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Helper: Create worktree for task when starting (auto-isolation)
+function createWorktreeForTask(taskId) {
+    if (!isGitRepo()) {
+        return null;
+    }
+    try {
+        const sessionName = `task-${taskId.slice(0, 8)}`;
+        const manager = new WorktreeManager(process.cwd());
+        const info = manager.createWorktree(sessionName);
+        return { path: info.path, branch: info.branch };
+    }
+    catch (error) {
+        // Worktree creation failed, but don't block task update
+        console.warn("⚠ Could not create worktree:", error instanceof Error ? error.message : error);
+        return null;
+    }
+}
 // husky task list
 taskCommand
     .command("list")
@@ -124,19 +154,29 @@ taskCommand
         process.exit(1);
     }
     try {
+        // Ensure worker is registered and create a session
+        const workerId = await ensureWorkerRegistered(config.apiUrl, config.apiKey || "");
+        const sessionId = generateSessionId();
+        await registerSession(config.apiUrl, config.apiKey || "", workerId, sessionId);
         const res = await fetch(`${config.apiUrl}/api/tasks/${id}/start`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
                 ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
             },
-            body: JSON.stringify({ agent: "claude-code" }),
+            body: JSON.stringify({
+                agent: "claude-code",
+                workerId,
+                sessionId,
+            }),
         });
         if (!res.ok) {
             throw new Error(`API error: ${res.status}`);
         }
         const task = await res.json();
         console.log(`✓ Started: ${task.title}`);
+        console.log(`  Worker: ${workerId}`);
+        console.log(`  Session: ${sessionId}`);
     }
     catch (error) {
         console.error("Error starting task:", error);
@@ -224,6 +264,7 @@ taskCommand
     .option("--priority <priority>", "New priority (low, medium, high, urgent)")
     .option("--assignee <assignee>", "New assignee (human, llm, unassigned)")
     .option("--project <projectId>", "Link to project")
+    .option("--no-worktree", "Skip automatic worktree creation when starting task")
     .option("--json", "Output as JSON")
     .action(async (id, options) => {
     const config = ensureConfig();
@@ -245,6 +286,15 @@ taskCommand
         console.error("Error: No update options provided. Use --help for available options.");
         process.exit(1);
     }
+    // Auto-create worktree when starting a task (unless --no-worktree)
+    let worktreeInfo = null;
+    if (options.status === "in_progress" && options.worktree !== false) {
+        worktreeInfo = createWorktreeForTask(id);
+        if (worktreeInfo) {
+            updates.worktreePath = worktreeInfo.path;
+            updates.worktreeBranch = worktreeInfo.branch;
+        }
+    }
     try {
         const res = await fetch(`${config.apiUrl}/api/tasks/${id}`, {
             method: "PATCH",
@@ -269,8 +319,13 @@ taskCommand
         }
         else {
             console.log(`✓ Updated: ${task.title}`);
-            const changedFields = Object.keys(updates).join(", ");
+            const changedFields = Object.keys(updates).filter(k => k !== 'worktreePath' && k !== 'worktreeBranch').join(", ");
             console.log(`  Changed: ${changedFields}`);
+            // Show worktree info if created
+            if (worktreeInfo) {
+                console.log(`  ⎇ Worktree: ${worktreeInfo.branch}`);
+                console.log(`    cd ${worktreeInfo.path}`);
+            }
         }
     }
     catch (error) {
@@ -416,6 +471,41 @@ taskCommand
         process.exit(1);
     }
 });
+// husky task message [--id <id>] -m <text>
+taskCommand
+    .command("message")
+    .description("Post a status message to a task")
+    .option("--id <id>", "Task ID (or use HUSKY_TASK_ID env var)")
+    .option("-m, --message <text>", "Status message", "")
+    .action(async (options) => {
+    const config = ensureConfig();
+    const taskId = getTaskId(options);
+    if (!options.message) {
+        console.error("Error: Message required. Use -m or --message");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/tasks/${taskId}/status`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                message: options.message,
+                timestamp: new Date().toISOString(),
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        console.log("✓ Status message posted");
+    }
+    catch (error) {
+        console.error("Error posting message:", error);
+        process.exit(1);
+    }
+});
 // husky task plan [--summary <text>] [--file <path>] [--stdin] [--id <id>]
 taskCommand
     .command("plan")

package/dist/lib/worker.d.ts

@@ -0,0 +1,14 @@
+interface WorkerIdentity {
+    workerId: string;
+    workerName: string;
+    hostname: string;
+    username: string;
+    platform: string;
+    agentVersion: string;
+}
+export declare function getWorkerIdentity(): WorkerIdentity;
+export declare function generateSessionId(): string;
+export declare function ensureWorkerRegistered(apiUrl: string, apiKey: string): Promise<string>;
+export declare function registerSession(apiUrl: string, apiKey: string, workerId: string, sessionId: string): Promise<void>;
+export declare function sessionHeartbeat(apiUrl: string, apiKey: string, sessionId: string, currentTaskId?: string | null): Promise<void>;
+export {};

package/dist/lib/worker.js

@@ -0,0 +1,113 @@
+import { getConfig, setConfig } from "../commands/config.js";
+import { hostname, userInfo, platform } from "os";
+import { randomUUID } from "crypto";
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+// Get or generate persistent worker identity (stored in ~/.husky/config.json)
+export function getWorkerIdentity() {
+    const config = getConfig();
+    // Generate worker ID if not exists
+    if (!config.workerId) {
+        const newId = `cli-${randomUUID().slice(0, 8)}`;
+        setConfig("workerId", newId);
+        config.workerId = newId;
+    }
+    // Generate worker name if not exists
+    if (!config.workerName) {
+        const name = `Claude Code @ ${hostname()}`;
+        setConfig("workerName", name);
+        config.workerName = name;
+    }
+    // Get agent version from package.json
+    let agentVersion = "unknown";
+    try {
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf-8"));
+        agentVersion = pkg.version;
+    }
+    catch {
+        // Ignore errors reading package.json
+    }
+    return {
+        workerId: config.workerId,
+        workerName: config.workerName,
+        hostname: hostname(),
+        username: userInfo().username,
+        platform: platform(),
+        agentVersion,
+    };
+}
+// Generate a unique session ID for this CLI instance
+export function generateSessionId() {
+    return `sess-${randomUUID().slice(0, 8)}`;
+}
+// Register or update worker with API, return workerId
+export async function ensureWorkerRegistered(apiUrl, apiKey) {
+    const identity = getWorkerIdentity();
+    // Try to get existing worker
+    const getRes = await fetch(`${apiUrl}/api/workers/${identity.workerId}`, {
+        headers: { "x-api-key": apiKey },
+    });
+    if (getRes.ok) {
+        // Worker exists, just return the ID
+        return identity.workerId;
+    }
+    if (getRes.status === 404) {
+        // Register new worker
+        const registerRes = await fetch(`${apiUrl}/api/workers`, {
+            method: "POST",
+            headers: { "x-api-key": apiKey, "Content-Type": "application/json" },
+            body: JSON.stringify({
+                name: identity.workerName,
+                type: "claude-code",
+                hostname: identity.hostname,
+                username: identity.username,
+                platform: identity.platform,
+                agentVersion: identity.agentVersion,
+            }),
+        });
+        if (!registerRes.ok) {
+            console.error(`Warning: Failed to register worker: ${registerRes.status}`);
+            return identity.workerId;
+        }
+        const worker = await registerRes.json();
+        // Update local config with server-assigned ID if different
+        if (worker.id !== identity.workerId) {
+            setConfig("workerId", worker.id);
+            return worker.id;
+        }
+    }
+    return identity.workerId;
+}
+// Register a new session with API
+export async function registerSession(apiUrl, apiKey, workerId, sessionId) {
+    try {
+        await fetch(`${apiUrl}/api/workers/sessions`, {
+            method: "POST",
+            headers: { "x-api-key": apiKey, "Content-Type": "application/json" },
+            body: JSON.stringify({
+                id: sessionId,
+                workerId,
+                pid: process.pid,
+                workingDirectory: process.cwd(),
+            }),
+        });
+    }
+    catch {
+        // Silently fail - session registration is optional
+    }
+}
+// Send session heartbeat
+export async function sessionHeartbeat(apiUrl, apiKey, sessionId, currentTaskId) {
+    try {
+        await fetch(`${apiUrl}/api/workers/sessions/${sessionId}/heartbeat`, {
+            method: "POST",
+            headers: { "x-api-key": apiKey, "Content-Type": "application/json" },
+            body: JSON.stringify({ currentTaskId }),
+        });
+    }
+    catch {
+        // Silently fail
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonfestl/husky-cli",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {
@@ -42,4 +42,4 @@
   "bugs": {
     "url": "https://github.com/simon-sfxecom/huskyv0/issues"
   }
-}
+}