@simonfestl/husky-cli 0.8.1 → 0.8.3

package/dist/commands/task.js

@@ -49,6 +49,22 @@ function isGitRepo() {
         return false;
     }
 }
+// Helper: Get current Git remote URL (e.g., "simon-sfxecom/huskyv0")
+function getGitRepoIdentifier() {
+    if (!isGitRepo())
+        return null;
+    try {
+        const remoteUrl = execSync("git remote get-url origin", { encoding: "utf-8" }).trim();
+        // Extract owner/repo from various URL formats:
+        // https://github.com/owner/repo.git
+        // git@github.com:owner/repo.git
+        const match = remoteUrl.match(/[/:]([\w-]+\/[\w-]+?)(\.git)?$/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
 // Helper: Create worktree for task when starting (auto-isolation)
 function createWorktreeForTask(taskId) {
     if (!isGitRepo()) {
@@ -66,11 +82,43 @@ function createWorktreeForTask(taskId) {
         return null;
     }
 }
+// Helper: Find project ID by GitHub repo identifier
+async function findProjectByRepo(apiUrl, apiKey, repoIdentifier) {
+    try {
+        const res = await fetch(`${apiUrl}/api/projects`, {
+            headers: apiKey ? { "x-api-key": apiKey } : {},
+        });
+        if (!res.ok)
+            return null;
+        const projects = await res.json();
+        // Extract repo name (e.g., "huskyv0" from "simon-sfxecom/huskyv0")
+        const repoName = repoIdentifier.split("/").pop()?.toLowerCase() || "";
+        // Try to match by:
+        // 1. githubRepo field (exact or partial match)
+        // 2. Project name similarity to repo name
+        const project = projects.find((p) => {
+            // Check githubRepo field first
+            if (p.githubRepo?.toLowerCase().includes(repoIdentifier.toLowerCase())) {
+                return true;
+            }
+            // Fallback: Check if project name matches repo name (case-insensitive)
+            const projectNameLower = p.name.toLowerCase().replace(/[^a-z0-9]/g, "");
+            const repoNameClean = repoName.replace(/[^a-z0-9]/g, "");
+            return projectNameLower === repoNameClean || projectNameLower.includes(repoNameClean) || repoNameClean.includes(projectNameLower);
+        });
+        return project ? { id: project.id, name: project.name } : null;
+    }
+    catch {
+        return null;
+    }
+}
 // husky task list
 taskCommand
     .command("list")
     .description("List all tasks")
     .option("-s, --status <status>", "Filter by status")
+    .option("-a, --all", "Show all tasks (ignore current repo filter)")
+    .option("--project <id>", "Filter by project ID")
     .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")
@@ -86,13 +134,39 @@ taskCommand
         if (options.status) {
             url.searchParams.set("status", options.status);
         }
+        // Auto-detect project from current repo (unless --all or --project specified)
+        let autoDetectedProject = null;
+        let filterProjectId = null;
+        if (!options.all && !options.project) {
+            const repoIdentifier = getGitRepoIdentifier();
+            if (repoIdentifier) {
+                autoDetectedProject = await findProjectByRepo(config.apiUrl, config.apiKey, repoIdentifier);
+                if (autoDetectedProject) {
+                    filterProjectId = autoDetectedProject.id;
+                }
+            }
+        }
+        else if (options.project) {
+            filterProjectId = options.project;
+        }
+        // Note: We don't pass projectId to API to avoid Firestore index requirement
+        // Instead, we filter client-side which is fine for reasonable task counts
         const res = await fetch(url.toString(), {
             headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
         });
         if (!res.ok) {
             throw new Error(`API error: ${res.status}`);
         }
-        const tasks = await res.json();
+        let tasks = await res.json();
+        // Client-side filtering by projectId (avoids Firestore composite index)
+        if (filterProjectId) {
+            tasks = tasks.filter(t => t.projectId === filterProjectId);
+        }
+        // Show filter info if auto-detected project
+        if (autoDetectedProject && !options.json) {
+            console.log(`\n  📁 Filtering by project: ${autoDetectedProject.name}`);
+            console.log(`     Use --all to see all tasks\n`);
+        }
         // JSON output
         if (options.json) {
             console.log(JSON.stringify(tasks, null, 2));
@@ -103,12 +177,12 @@ taskCommand
             await paginateList({
                 items: tasks,
                 pageSize: 10,
-                title: "Tasks",
+                title: autoDetectedProject ? `Tasks (${autoDetectedProject.name})` : "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}`;
+                    return `  ${statusIcon} ${task.id.padEnd(20)} │ ${task.title.slice(0, 40).padEnd(40)} ${priorityIcon}`;
                 },
                 selectableItems: true,
                 onSelect: async (task) => {
@@ -131,7 +205,7 @@ taskCommand
             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}`;
+                return `  ${statusIcon} ${task.id.padEnd(20)} │ ${task.title}`;
             }, "Tasks");
             return;
         }
@@ -1005,12 +1079,15 @@ function printTasks(tasks) {
         if (statusTasks.length === 0)
             continue;
         console.log(`\n  ${label}`);
-        console.log("  " + "─".repeat(50));
+        console.log("  " + "─".repeat(95));
+        console.log(`  ${"ID".padEnd(20)}  ${"Title".padEnd(30)}  ${"Project".padEnd(15)}  ${"Project ID".padEnd(12)}  ${"Priority".padEnd(6)}`);
+        console.log("  " + "─".repeat(95));
         for (const task of statusTasks) {
             const agentStr = task.agent ? ` (${task.agent})` : "";
             const doneStr = status === "done" ? " ✓" : "";
-            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}`);
+            const projectName = task.projectName?.slice(0, 15).padEnd(15) || "—".padEnd(15);
+            const projectId = task.projectId?.slice(0, 12).padEnd(12) || "—".padEnd(12);
+            console.log(`  ${task.id.padEnd(20)}  ${task.title.slice(0, 30).padEnd(30)}  ${projectName}  ${projectId}  ${task.priority.padEnd(6)}${agentStr}${doneStr}`);
         }
     }
     console.log("");

package/dist/commands/worker.d.ts

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

package/dist/commands/worker.js

@@ -0,0 +1,210 @@
+import { Command } from "commander";
+import { getConfig } from "./config.js";
+import { getWorkerIdentity, ensureWorkerRegistered } from "../lib/worker.js";
+export const workerCommand = new Command("worker")
+    .description("Manage workers and sessions");
+// husky worker whoami - Show current worker identity
+workerCommand
+    .command("whoami")
+    .description("Show current worker identity")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const identity = getWorkerIdentity();
+    if (options.json) {
+        console.log(JSON.stringify(identity, null, 2));
+    }
+    else {
+        console.log("\n  Worker Identity");
+        console.log("  " + "─".repeat(40));
+        console.log(`  ID:       ${identity.workerId}`);
+        console.log(`  Name:     ${identity.workerName}`);
+        console.log(`  Host:     ${identity.hostname}`);
+        console.log(`  User:     ${identity.username}`);
+        console.log(`  Platform: ${identity.platform}`);
+        console.log(`  Version:  ${identity.agentVersion}`);
+        console.log("");
+    }
+});
+// husky worker register - Register worker with API
+workerCommand
+    .command("register")
+    .description("Register this worker with the API")
+    .action(async () => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    try {
+        const workerId = await ensureWorkerRegistered(config.apiUrl, config.apiKey || "");
+        const identity = getWorkerIdentity();
+        console.log(`✓ Worker registered: ${workerId}`);
+        console.log(`  Name: ${identity.workerName}`);
+    }
+    catch (error) {
+        console.error("Error registering worker:", error);
+        process.exit(1);
+    }
+});
+// husky worker list - List all registered workers
+workerCommand
+    .command("list")
+    .description("List all registered workers")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured.");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/workers`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        const workers = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(workers, null, 2));
+            return;
+        }
+        if (workers.length === 0) {
+            console.log("No workers registered.");
+            return;
+        }
+        console.log("\n  Registered Workers");
+        console.log("  " + "─".repeat(60));
+        for (const worker of workers) {
+            const statusIcon = worker.lastSeen && isRecent(worker.lastSeen) ? "🟢" : "⚪";
+            const typeIcon = worker.type === "claude-code" ? "🤖" : "👤";
+            console.log(`  ${statusIcon} ${typeIcon} ${worker.id.slice(0, 12).padEnd(12)} │ ${worker.name?.slice(0, 30).padEnd(30)} │ ${worker.hostname || "—"}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error fetching workers:", error);
+        process.exit(1);
+    }
+});
+// husky worker sessions - List active sessions
+workerCommand
+    .command("sessions")
+    .description("List active worker sessions")
+    .option("--all", "Show all sessions (not just active)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured.");
+        process.exit(1);
+    }
+    try {
+        const endpoint = options.all
+            ? `${config.apiUrl}/api/workers/sessions`
+            : `${config.apiUrl}/api/workers/sessions/active`;
+        const res = await fetch(endpoint, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        const sessions = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(sessions, null, 2));
+            return;
+        }
+        if (sessions.length === 0) {
+            console.log(options.all ? "No sessions found." : "No active sessions.");
+            return;
+        }
+        console.log(`\n  ${options.all ? "All" : "Active"} Sessions`);
+        console.log("  " + "─".repeat(70));
+        for (const session of sessions) {
+            const statusIcon = session.status === "active" ? "🟢" : "⚪";
+            const taskInfo = session.currentTaskId ? `Task: ${session.currentTaskId.slice(0, 8)}` : "No task";
+            const timeAgo = session.lastHeartbeat ? formatTimeAgo(session.lastHeartbeat) : "—";
+            console.log(`  ${statusIcon} ${session.id.slice(0, 12).padEnd(12)} │ ${session.workerId.slice(0, 12).padEnd(12)} │ ${taskInfo.padEnd(20)} │ ${timeAgo}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error fetching sessions:", error);
+        process.exit(1);
+    }
+});
+// husky worker activity - Show who is working on what
+workerCommand
+    .command("activity")
+    .description("Show current activity (who is working on what)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured.");
+        process.exit(1);
+    }
+    try {
+        // Fetch active sessions and in-progress tasks in parallel
+        const [sessionsRes, tasksRes] = await Promise.all([
+            fetch(`${config.apiUrl}/api/workers/sessions/active`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            }),
+            fetch(`${config.apiUrl}/api/tasks?status=in_progress`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            }),
+        ]);
+        if (!sessionsRes.ok || !tasksRes.ok) {
+            throw new Error("API error fetching activity");
+        }
+        const sessions = await sessionsRes.json();
+        const tasks = await tasksRes.json();
+        if (options.json) {
+            console.log(JSON.stringify({ sessions, tasks }, null, 2));
+            return;
+        }
+        console.log("\n  Current Activity");
+        console.log("  " + "═".repeat(70));
+        if (tasks.length === 0) {
+            console.log("  No tasks currently in progress.");
+        }
+        else {
+            for (const task of tasks) {
+                const agentIcon = task.agent?.includes("claude") ? "🤖" : task.agent ? "👤" : "❓";
+                const workerInfo = task.workerId ? `Worker: ${task.workerId.slice(0, 8)}` : "No worker";
+                console.log(`\n  ${agentIcon} ${task.title.slice(0, 50)}`);
+                console.log(`     ID: ${task.id.slice(0, 12)} │ ${task.agent || "unassigned"} │ ${workerInfo}`);
+                if (task.projectName) {
+                    console.log(`     Project: ${task.projectName}`);
+                }
+            }
+        }
+        console.log("\n  " + "─".repeat(70));
+        console.log(`  Active Sessions: ${sessions.length}`);
+        console.log(`  Tasks In Progress: ${tasks.length}`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error fetching activity:", error);
+        process.exit(1);
+    }
+});
+// Helper: Check if timestamp is recent (within 5 minutes)
+function isRecent(timestamp) {
+    const diff = Date.now() - new Date(timestamp).getTime();
+    return diff < 5 * 60 * 1000; // 5 minutes
+}
+// Helper: Format time ago
+function formatTimeAgo(timestamp) {
+    const diff = Date.now() - new Date(timestamp).getTime();
+    const minutes = Math.floor(diff / 60000);
+    const hours = Math.floor(diff / 3600000);
+    const days = Math.floor(diff / 86400000);
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    if (hours < 24)
+        return `${hours}h ago`;
+    return `${days}d ago`;
+}

package/dist/index.js

@@ -13,17 +13,17 @@ import { workflowCommand } from "./commands/workflow.js";
 import { julesCommand } from "./commands/jules.js";
 import { vmCommand } from "./commands/vm.js";
 import { vmConfigCommand } from "./commands/vm-config.js";
-import { processCommand } from "./commands/process.js";
 import { settingsCommand } from "./commands/settings.js";
 import { strategyCommand } from "./commands/strategy.js";
 import { completionCommand } from "./commands/completion.js";
 import { worktreeCommand } from "./commands/worktree.js";
+import { workerCommand } from "./commands/worker.js";
 import { runInteractiveMode } from "./commands/interactive.js";
 const program = new Command();
 program
     .name("husky")
     .description("CLI for Huskyv0 Task Orchestration with Claude Agent")
-    .version("0.7.1");
+    .version("0.8.1");
 program.addCommand(taskCommand);
 program.addCommand(configCommand);
 program.addCommand(agentCommand);
@@ -37,11 +37,11 @@ program.addCommand(workflowCommand);
 program.addCommand(julesCommand);
 program.addCommand(vmCommand);
 program.addCommand(vmConfigCommand);
-program.addCommand(processCommand);
 program.addCommand(settingsCommand);
 program.addCommand(strategyCommand);
 program.addCommand(completionCommand);
 program.addCommand(worktreeCommand);
+program.addCommand(workerCommand);
 // Check if no command was provided - run interactive mode
 if (process.argv.length <= 2) {
     runInteractiveMode();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonfestl/husky-cli",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "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"
   }
-}
+}