@simonfestl/husky-cli 0.9.6 → 1.0.0

package/dist/commands/task.js

@@ -6,6 +6,7 @@ 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";
+import { resolveProject, fetchProjects, formatProjectList } from "../lib/project-resolver.js";
 export const taskCommand = new Command("task")
     .description("Manage tasks");
 // Helper: Get task ID from --id flag or HUSKY_TASK_ID env var
@@ -221,7 +222,8 @@ taskCommand
 taskCommand
     .command("start <id>")
     .description("Start working on a task")
-    .action(async (id) => {
+    .option("--no-worktree", "Skip worktree creation")
+    .action(async (id, options) => {
     const config = getConfig();
     if (!config.apiUrl) {
         console.error("Error: API URL not configured.");
@@ -232,6 +234,15 @@ taskCommand
         const workerId = await ensureWorkerRegistered(config.apiUrl, config.apiKey || "");
         const sessionId = generateSessionId();
         await registerSession(config.apiUrl, config.apiKey || "", workerId, sessionId);
+        // Create worktree for isolation (unless --no-worktree)
+        let worktreeInfo = null;
+        if (options.worktree !== false) {
+            worktreeInfo = createWorktreeForTask(id);
+            if (worktreeInfo) {
+                console.log(`✓ Created worktree: ${worktreeInfo.path}`);
+                console.log(`  Branch: ${worktreeInfo.branch}`);
+            }
+        }
         const res = await fetch(`${config.apiUrl}/api/tasks/${id}/start`, {
             method: "POST",
             headers: {
@@ -242,6 +253,11 @@ taskCommand
                 agent: "claude-code",
                 workerId,
                 sessionId,
+                // Include worktree info if created
+                ...(worktreeInfo ? {
+                    worktreePath: worktreeInfo.path,
+                    worktreeBranch: worktreeInfo.branch,
+                } : {}),
             }),
         });
         if (!res.ok) {
@@ -251,6 +267,10 @@ taskCommand
         console.log(`✓ Started: ${task.title}`);
         console.log(`  Worker: ${workerId}`);
         console.log(`  Session: ${sessionId}`);
+        // Show hint to cd into worktree
+        if (worktreeInfo) {
+            console.log(`\n💡 To work in isolation: cd ${worktreeInfo.path}`);
+        }
     }
     catch (error) {
         console.error("Error starting task:", error);
@@ -262,6 +282,7 @@ taskCommand
     .command("done <id>")
     .description("Mark task as done")
     .option("--pr <url>", "Link to PR")
+    .option("--skip-qa", "Skip QA review and mark as done directly")
     .action(async (id, options) => {
     const config = getConfig();
     if (!config.apiUrl) {
@@ -275,25 +296,36 @@ taskCommand
                 "Content-Type": "application/json",
                 ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
             },
-            body: JSON.stringify({ prUrl: options.pr }),
+            body: JSON.stringify({
+                prUrl: options.pr,
+                skipQA: options.skipQa === true,
+            }),
         });
         if (!res.ok) {
             throw new Error(`API error: ${res.status}`);
         }
         const task = await res.json();
-        console.log(`✓ Completed: ${task.title}`);
+        if (task.qaTriggered) {
+            console.log(`✓ Task moved to review: ${task.title}`);
+            console.log(`  QA pipeline triggered - awaiting verification`);
+        }
+        else {
+            console.log(`✓ Completed: ${task.title}`);
+        }
+        if (task.message) {
+            console.log(`  ${task.message}`);
+        }
     }
     catch (error) {
         console.error("Error completing task:", error);
         process.exit(1);
     }
 });
-// husky task create <title>
 taskCommand
     .command("create <title>")
     .description("Create a new task")
     .option("-d, --description <desc>", "Task description")
-    .option("--project <projectId>", "Project ID")
+    .option("--project <project>", "Project name or ID")
     .option("--path <path>", "Path in project")
     .option("-p, --priority <priority>", "Priority (low, medium, high)", "medium")
     .action(async (title, options) => {
@@ -302,6 +334,29 @@ taskCommand
         console.error("Error: API URL not configured.");
         process.exit(1);
     }
+    let resolvedProjectId;
+    const resolverConfig = { apiUrl: config.apiUrl, apiKey: config.apiKey };
+    if (options.project) {
+        const resolved = await resolveProject(options.project, resolverConfig);
+        if (!resolved) {
+            const projects = await fetchProjects(resolverConfig);
+            console.error(`\n❌ Project "${options.project}" not found.\n`);
+            console.error(formatProjectList(projects));
+            process.exit(1);
+        }
+        if (resolved.resolvedBy === "name-match") {
+            console.log(`ℹ️  Resolved "${options.project}" → ${resolved.projectName} (${resolved.projectId})`);
+        }
+        if (resolved.resolvedBy === "fuzzy-match") {
+            const confirmed = await confirm(`Did you mean "${resolved.projectName}"? (${Math.round(resolved.confidence * 100)}% match)`);
+            if (!confirmed) {
+                console.log("Cancelled.");
+                process.exit(0);
+            }
+            console.log(`ℹ️  Using project: ${resolved.projectName} (${resolved.projectId})`);
+        }
+        resolvedProjectId = resolved.projectId;
+    }
     try {
         const res = await fetch(`${config.apiUrl}/api/tasks`, {
             method: "POST",
@@ -312,13 +367,14 @@ taskCommand
             body: JSON.stringify({
                 title,
                 description: options.description,
-                projectId: options.project,
+                projectId: resolvedProjectId,
                 linkedPath: options.path,
                 priority: options.priority,
             }),
         });
         if (!res.ok) {
-            throw new Error(`API error: ${res.status}`);
+            const errorData = await res.json().catch(() => ({}));
+            throw new Error(errorData.error || `API error: ${res.status}`);
         }
         const task = await res.json();
         console.log(`✓ Created: #${task.id} ${task.title}`);
@@ -328,7 +384,6 @@ taskCommand
         process.exit(1);
     }
 });
-// husky task update <id>
 taskCommand
     .command("update <id>")
     .description("Update task properties")
@@ -337,12 +392,12 @@ taskCommand
     .option("--status <status>", "New status (e.g., backlog, in_progress, review, done, or custom status)")
     .option("--priority <priority>", "New priority (low, medium, high, urgent)")
     .option("--assignee <assignee>", "New assignee (human, llm, unassigned)")
-    .option("--project <projectId>", "Link to project")
+    .option("--project <project>", "Link to project (name or ID)")
     .option("--no-worktree", "Skip automatic worktree creation when starting task")
     .option("--json", "Output as JSON")
     .action(async (id, options) => {
     const config = ensureConfig();
-    // Build update payload with only changed fields
+    const resolverConfig = { apiUrl: config.apiUrl, apiKey: config.apiKey };
     const updates = {};
     if (options.title)
         updates.title = options.title;
@@ -354,8 +409,27 @@ taskCommand
         updates.priority = options.priority;
     if (options.assignee)
         updates.assignee = options.assignee;
-    if (options.project)
-        updates.projectId = options.project;
+    if (options.project) {
+        const resolved = await resolveProject(options.project, resolverConfig);
+        if (!resolved) {
+            const projects = await fetchProjects(resolverConfig);
+            console.error(`\n❌ Project "${options.project}" not found.\n`);
+            console.error(formatProjectList(projects));
+            process.exit(1);
+        }
+        if (resolved.resolvedBy === "name-match") {
+            console.log(`ℹ️  Resolved "${options.project}" → ${resolved.projectName} (${resolved.projectId})`);
+        }
+        if (resolved.resolvedBy === "fuzzy-match") {
+            const confirmed = await confirm(`Did you mean "${resolved.projectName}"? (${Math.round(resolved.confidence * 100)}% match)`);
+            if (!confirmed) {
+                console.log("Cancelled.");
+                process.exit(0);
+            }
+            console.log(`ℹ️  Using project: ${resolved.projectName} (${resolved.projectId})`);
+        }
+        updates.projectId = resolved.projectId;
+    }
     if (Object.keys(updates).length === 0) {
         console.error("Error: No update options provided. Use --help for available options.");
         process.exit(1);
@@ -547,11 +621,23 @@ taskCommand
 });
 // husky task message <id> "message" - post status message to task
 taskCommand
-    .command("message <id> <message>")
+    .command("message [id] [message]")
     .description("Post a status message to a task")
-    .action(async (id, message) => {
+    .option("-m, --message <text>", "Message text (alternative to positional arg)")
+    .option("--id <taskId>", "Task ID (alternative to positional arg, or use HUSKY_TASK_ID)")
+    .action(async (idArg, messageArg, options) => {
     const config = ensureConfig();
-    const taskId = id;
+    // Support both: `husky task message <id> <msg>` and `husky task message -m <msg> --id <id>`
+    const taskId = idArg || options.id || process.env.HUSKY_TASK_ID;
+    const message = messageArg || options.message;
+    if (!taskId) {
+        console.error("Error: Task ID required. Use positional arg, --id, or set HUSKY_TASK_ID");
+        process.exit(1);
+    }
+    if (!message) {
+        console.error("Error: Message required. Use positional arg or -m/--message");
+        process.exit(1);
+    }
     try {
         const res = await fetch(`${config.apiUrl}/api/tasks/${taskId}/status`, {
             method: "POST",

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { Command } from "commander";
+import { createRequire } from "module";
 import { taskCommand } from "./commands/task.js";
 import { configCommand } from "./commands/config.js";
 import { agentCommand } from "./commands/agent.js";
@@ -10,7 +11,6 @@ import { projectCommand } from "./commands/project.js";
 import { ideaCommand } from "./commands/idea.js";
 import { departmentCommand } from "./commands/department.js";
 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";
@@ -20,15 +20,18 @@ import { completionCommand } from "./commands/completion.js";
 import { worktreeCommand } from "./commands/worktree.js";
 import { workerCommand } from "./commands/worker.js";
 import { bizCommand } from "./commands/biz.js";
-import { servicesCommand } from "./commands/services.js";
 import { printLLMContext, llmCommand } from "./commands/llm-context.js";
 import { runInteractiveMode } from "./commands/interactive.js";
 import { serviceAccountCommand } from "./commands/service-account.js";
+import { chatCommand } from "./commands/chat.js";
+// Read version from package.json
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
 const program = new Command();
 program
     .name("husky")
     .description("CLI for Huskyv0 Task Orchestration with Claude Agent")
-    .version("0.9.5")
+    .version(packageJson.version)
     .option("--llm", "Output LLM reference documentation (markdown)");
 program.addCommand(taskCommand);
 program.addCommand(configCommand);
@@ -40,7 +43,6 @@ program.addCommand(projectCommand);
 program.addCommand(ideaCommand);
 program.addCommand(departmentCommand);
 program.addCommand(workflowCommand);
-program.addCommand(julesCommand);
 program.addCommand(vmCommand);
 program.addCommand(vmConfigCommand);
 program.addCommand(processCommand);
@@ -50,8 +52,8 @@ program.addCommand(completionCommand);
 program.addCommand(worktreeCommand);
 program.addCommand(workerCommand);
 program.addCommand(bizCommand);
-program.addCommand(servicesCommand);
 program.addCommand(serviceAccountCommand);
+program.addCommand(chatCommand);
 program.addCommand(llmCommand);
 // Handle --llm flag specially
 if (process.argv.includes("--llm")) {

package/dist/lib/project-resolver.d.ts

@@ -0,0 +1,26 @@
+export interface Project {
+    id: string;
+    name: string;
+}
+export interface ResolveResult {
+    projectId: string;
+    projectName: string;
+    resolvedBy: "exact-id" | "name-match" | "fuzzy-match";
+    confidence: number;
+}
+export interface FuzzyMatch {
+    project: Project;
+    score: number;
+}
+interface Config {
+    apiUrl: string;
+    apiKey?: string;
+}
+export declare function fetchProjects(config: Config): Promise<Project[]>;
+export declare function resolveProject(input: string, config: Config, fuzzyThreshold?: number): Promise<ResolveResult | null>;
+export declare function formatProjectList(projects: Project[]): string;
+export declare function validateProjectId(projectId: string, config: Config): Promise<{
+    valid: boolean;
+    project?: Project;
+}>;
+export {};

package/dist/lib/project-resolver.js

@@ -0,0 +1,111 @@
+export async function fetchProjects(config) {
+    try {
+        const res = await fetch(`${config.apiUrl}/api/projects`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok)
+            return [];
+        return res.json();
+    }
+    catch {
+        return [];
+    }
+}
+function calculateLevenshteinDistance(a, b) {
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+        matrix[i] = [i];
+    }
+    for (let j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}
+function similarityScore(a, b) {
+    const normalizedA = a.toLowerCase().trim();
+    const normalizedB = b.toLowerCase().trim();
+    if (normalizedA === normalizedB)
+        return 1;
+    const maxLen = Math.max(normalizedA.length, normalizedB.length);
+    if (maxLen === 0)
+        return 1;
+    const distance = calculateLevenshteinDistance(normalizedA, normalizedB);
+    return 1 - (distance / maxLen);
+}
+function findClosestMatch(input, projects) {
+    if (projects.length === 0)
+        return null;
+    let bestMatch = null;
+    for (const project of projects) {
+        const nameScore = similarityScore(input, project.name);
+        const idScore = similarityScore(input, project.id);
+        const score = Math.max(nameScore, idScore);
+        if (!bestMatch || score > bestMatch.score) {
+            bestMatch = { project, score };
+        }
+    }
+    return bestMatch;
+}
+export async function resolveProject(input, config, fuzzyThreshold = 0.6) {
+    const projects = await fetchProjects(config);
+    if (projects.length === 0) {
+        return null;
+    }
+    const byId = projects.find((p) => p.id === input);
+    if (byId) {
+        return {
+            projectId: byId.id,
+            projectName: byId.name,
+            resolvedBy: "exact-id",
+            confidence: 1,
+        };
+    }
+    const byName = projects.find((p) => p.name.toLowerCase() === input.toLowerCase());
+    if (byName) {
+        return {
+            projectId: byName.id,
+            projectName: byName.name,
+            resolvedBy: "name-match",
+            confidence: 1,
+        };
+    }
+    const fuzzy = findClosestMatch(input, projects);
+    if (fuzzy && fuzzy.score >= fuzzyThreshold) {
+        return {
+            projectId: fuzzy.project.id,
+            projectName: fuzzy.project.name,
+            resolvedBy: "fuzzy-match",
+            confidence: fuzzy.score,
+        };
+    }
+    return null;
+}
+export function formatProjectList(projects) {
+    if (projects.length === 0) {
+        return "  No projects available.";
+    }
+    const lines = [];
+    lines.push("  Available projects:");
+    for (const p of projects) {
+        lines.push(`    - ${p.name} (ID: ${p.id})`);
+    }
+    return lines.join("\n");
+}
+export async function validateProjectId(projectId, config) {
+    const projects = await fetchProjects(config);
+    const project = projects.find((p) => p.id === projectId);
+    return {
+        valid: !!project,
+        project,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonfestl/husky-cli",
-  "version": "0.9.6",
+  "version": "1.0.0",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {

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

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