@simonfestl/husky-cli 0.7.1 → 0.8.1

package/README.md

@@ -1,5 +1,8 @@
 # Husky CLI
 
+[![CLI Tests](https://github.com/simon-sfxecom/huskyv0/actions/workflows/cli-tests.yml/badge.svg)](https://github.com/simon-sfxecom/huskyv0/actions/workflows/cli-tests.yml)
+[![codecov](https://codecov.io/gh/simon-sfxecom/huskyv0/branch/main/graph/badge.svg?flag=cli)](https://codecov.io/gh/simon-sfxecom/huskyv0)
+
 CLI for Huskyv0 Task Orchestration with Claude Agent SDK integration.
 
 **Part of the [huskyv0 monorepo](https://github.com/simon-sfxecom/huskyv0)**
@@ -378,6 +381,47 @@ husky --version
 - Configuration management
 - API key authentication
 
+## Development
+
+### Testing
+
+The CLI has comprehensive test coverage using Vitest:
+
+```bash
+# Run all tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run with coverage
+npm run test:coverage
+
+# Run specific test file
+npm test tests/unit/commands/config.test.ts
+```
+
+**Test Structure:**
+- `tests/setup.ts` - Global test configuration (MSW, memfs, mocks)
+- `tests/unit/` - Unit tests for individual modules
+- `tests/integration/` - Integration tests for workflows
+- `tests/helpers/` - Reusable mocking utilities
+
+**Current Coverage:**
+- Config Command: ~29% lines, 60% functions
+- Worktree Library: ~55% lines, 70% branches, 65% functions
+- Total: 29 tests across 4 test files
+
+### Building
+
+```bash
+# Build TypeScript
+npm run build
+
+# Watch mode for development
+npm run dev
+```
+
 ## License
 
 MIT

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")
@@ -919,7 +1009,8 @@ function printTasks(tasks) {
         for (const task of statusTasks) {
             const agentStr = task.agent ? ` (${task.agent})` : "";
             const doneStr = status === "done" ? " ✓" : "";
-            console.log(`  ${task.id}  ${task.title.slice(0, 30).padEnd(30)}  ${task.priority}${agentStr}${doneStr}`);
+            const projectStr = (task.projectName || task.projectId)?.slice(0, 15).padEnd(15) || "—".padEnd(15);
+            console.log(`  ${task.id.slice(0, 10).padEnd(10)}  ${task.title.slice(0, 25).padEnd(25)}  ${projectStr}  ${task.priority.padEnd(6)}${agentStr}${doneStr}`);
         }
     }
     console.log("");

package/dist/commands/worktree.js

@@ -168,10 +168,11 @@ worktreeCommand
         process.exit(1);
     }
 });
-// husky worktree remove <session-name>
+// husky worktree remove <session-name> (alias: delete)
 worktreeCommand
     .command("remove <session-name>")
-    .description("Remove a worktree")
+    .alias("delete")
+    .description("Remove a worktree (alias: delete)")
     .option("-p, --project <path>", "Project directory (default: current directory)")
     .option("--delete-branch", "Also delete the associated branch")
     .option("--force", "Force removal even with uncommitted changes")

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.1",
+  "version": "0.8.1",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {
@@ -10,7 +10,12 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "start": "node dist/index.js"
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:unit": "vitest run tests/unit",
+    "test:integration": "vitest run tests/integration"
   },
   "dependencies": {
     "@anthropic-ai/claude-code": "^1.0.0",
@@ -19,7 +24,11 @@
   },
   "devDependencies": {
     "@types/node": "^22",
-    "typescript": "^5"
+    "typescript": "^5",
+    "vitest": "^2.1.8",
+    "@vitest/coverage-v8": "^2.1.8",
+    "msw": "^2.6.8",
+    "memfs": "^4.14.0"
   },
   "files": [
     "dist"
@@ -33,4 +42,4 @@
   "bugs": {
     "url": "https://github.com/simon-sfxecom/huskyv0/issues"
   }
-}
+}