@simonfestl/husky-cli 0.3.0 → 0.5.1

package/dist/commands/completion.js

@@ -0,0 +1,400 @@
+import { Command } from "commander";
+export const completionCommand = new Command("completion")
+    .description("Generate shell completion scripts");
+// Command definitions for completion
+const COMMANDS = {
+    task: [
+        "list", "create", "get", "update", "delete", "start", "done", "status", "plan",
+        "wait-approval", "complete", "qa-start", "qa-status", "qa-approve", "qa-reject",
+        "qa-iteration", "qa-escalate", "merge-conflict"
+    ],
+    project: ["list", "create", "get", "update", "delete", "add-knowledge", "list-knowledge", "delete-knowledge"],
+    roadmap: [
+        "list", "create", "get", "update", "delete", "add-phase", "add-feature", "generate",
+        "list-features", "update-feature", "delete-feature", "convert-feature"
+    ],
+    workflow: [
+        "list", "create", "get", "update", "delete", "add-step", "update-step", "delete-step",
+        "generate-steps", "list-steps"
+    ],
+    idea: ["list", "create", "get", "update", "delete", "convert"],
+    department: ["list", "create", "get", "update", "delete"],
+    vm: ["list", "create", "get", "update", "delete", "start", "stop", "logs", "approve", "reject"],
+    jules: ["list", "create", "get", "update", "delete", "message", "approve", "activities", "sources"],
+    process: ["list", "create", "get", "update", "delete"],
+    strategy: [
+        "show", "set-vision", "set-mission", "add-value", "update-value", "delete-value",
+        "add-goal", "update-goal", "delete-goal", "add-persona", "update-persona", "delete-persona"
+    ],
+    settings: ["get", "set"],
+    "vm-config": ["list", "create", "get", "update", "delete"],
+    config: ["set", "get", "list", "test"],
+    changelog: ["generate", "list", "show", "publish", "delete"],
+    explain: [],
+    completion: ["bash", "zsh", "fish", "install"],
+    agent: [],
+};
+const MAIN_COMMANDS = Object.keys(COMMANDS).join(" ");
+// Common options across commands
+const COMMON_OPTIONS = "--json --force --status";
+// husky completion bash
+completionCommand
+    .command("bash")
+    .description("Output bash completion script")
+    .action(() => {
+    console.log(generateBashCompletion());
+});
+// husky completion zsh
+completionCommand
+    .command("zsh")
+    .description("Output zsh completion script")
+    .action(() => {
+    console.log(generateZshCompletion());
+});
+// husky completion fish
+completionCommand
+    .command("fish")
+    .description("Output fish completion script")
+    .action(() => {
+    console.log(generateFishCompletion());
+});
+// husky completion install
+completionCommand
+    .command("install")
+    .description("Print installation instructions for shell completions")
+    .action(() => {
+    console.log(`
+SHELL COMPLETION INSTALLATION
+
+Bash:
+  Add to your ~/.bashrc:
+    eval "$(husky completion bash)"
+
+  Or append to file:
+    husky completion bash >> ~/.bashrc
+    source ~/.bashrc
+
+Zsh:
+  Add to your ~/.zshrc:
+    eval "$(husky completion zsh)"
+
+  Or append to file:
+    husky completion zsh >> ~/.zshrc
+    source ~/.zshrc
+
+Fish:
+  Save to fish completions directory:
+    husky completion fish > ~/.config/fish/completions/husky.fish
+
+  Or create if directory doesn't exist:
+    mkdir -p ~/.config/fish/completions
+    husky completion fish > ~/.config/fish/completions/husky.fish
+
+After installation, restart your shell or source the config file.
+`);
+});
+function generateBashCompletion() {
+    const subcommandCases = Object.entries(COMMANDS)
+        .filter(([, subs]) => subs.length > 0)
+        .map(([cmd, subs]) => `    ${cmd})
+      COMPREPLY=( $(compgen -W "${subs.join(" ")}" -- \${cur}) )
+      return 0
+      ;;`)
+        .join("\n");
+    return `# Bash completion for husky CLI
+# Generated by husky completion bash
+
+_husky_completions() {
+  local cur prev words cword
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  # Main commands
+  local commands="${MAIN_COMMANDS}"
+
+  # Common options
+  local common_opts="${COMMON_OPTIONS}"
+
+  # Handle completion based on previous word
+  case "\${prev}" in
+    husky)
+      COMPREPLY=( $(compgen -W "\${commands}" -- \${cur}) )
+      return 0
+      ;;
+${subcommandCases}
+    --status)
+      COMPREPLY=( $(compgen -W "backlog in_progress review done pending running completed failed" -- \${cur}) )
+      return 0
+      ;;
+    --priority)
+      COMPREPLY=( $(compgen -W "low medium high urgent must should could wont" -- \${cur}) )
+      return 0
+      ;;
+    --assignee)
+      COMPREPLY=( $(compgen -W "human llm unassigned" -- \${cur}) )
+      return 0
+      ;;
+    --agent)
+      COMPREPLY=( $(compgen -W "claude-code gemini-cli aider custom" -- \${cur}) )
+      return 0
+      ;;
+    --type)
+      COMPREPLY=( $(compgen -W "global project architecture patterns decisions learnings" -- \${cur}) )
+      return 0
+      ;;
+    --value-stream)
+      COMPREPLY=( $(compgen -W "order_to_delivery procure_to_pay returns_management product_lifecycle customer_service marketing_sales finance_accounting hr_operations it_operations general" -- \${cur}) )
+      return 0
+      ;;
+    --action)
+      COMPREPLY=( $(compgen -W "manual semi_automated fully_automated" -- \${cur}) )
+      return 0
+      ;;
+    --work-status)
+      COMPREPLY=( $(compgen -W "planning in_progress review completed on_hold" -- \${cur}) )
+      return 0
+      ;;
+  esac
+
+  # If current word starts with -, complete options
+  if [[ \${cur} == -* ]]; then
+    COMPREPLY=( $(compgen -W "\${common_opts} --id --project --description --name --help" -- \${cur}) )
+    return 0
+  fi
+
+  # Default: complete with main commands
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "\${commands}" -- \${cur}) )
+  fi
+
+  return 0
+}
+
+complete -F _husky_completions husky
+`;
+}
+function generateZshCompletion() {
+    const subcommandCases = Object.entries(COMMANDS)
+        .filter(([, subs]) => subs.length > 0)
+        .map(([cmd, subs]) => `      ${cmd})
+        _values 'subcommand' ${subs.map(s => `'${s}'`).join(" ")}
+        ;;`)
+        .join("\n");
+    return `#compdef husky
+# Zsh completion for husky CLI
+# Generated by husky completion zsh
+
+_husky() {
+  local -a commands
+  commands=(
+    'task:Manage tasks'
+    'project:Manage projects and knowledge'
+    'roadmap:Manage roadmaps'
+    'workflow:Manage workflows and workflow steps'
+    'idea:Manage ideas'
+    'department:Manage departments'
+    'vm:Manage VM sessions'
+    'jules:Manage Jules AI coding sessions'
+    'process:Manage processes'
+    'strategy:Manage business strategy'
+    'settings:Manage application settings'
+    'vm-config:Manage VM configurations'
+    'config:Manage CLI configuration'
+    'changelog:Generate and manage changelogs'
+    'explain:Explain CLI commands for AI agents'
+    'completion:Generate shell completion scripts'
+    'agent:Interactive agent mode'
+  )
+
+  _arguments -C \\
+    '1: :->command' \\
+    '*: :->args'
+
+  case $state in
+    command)
+      _describe -t commands 'husky commands' commands
+      ;;
+    args)
+      case $words[2] in
+${subcommandCases}
+      esac
+      ;;
+  esac
+}
+
+# Common options completion
+_husky_common_options() {
+  _arguments \\
+    '--json[Output as JSON]' \\
+    '--force[Skip confirmation]' \\
+    '--status[Filter by status]:status:(backlog in_progress review done pending running completed failed)' \\
+    '--priority[Priority level]:priority:(low medium high urgent must should could wont)' \\
+    '--id[Task/Resource ID]:id:' \\
+    '--project[Project ID]:project:' \\
+    '--help[Show help]'
+}
+
+compdef _husky husky
+`;
+}
+function generateFishCompletion() {
+    const mainCommandCompletions = Object.entries(COMMANDS)
+        .map(([cmd, _]) => {
+        const desc = getCommandDescription(cmd);
+        return `complete -c husky -n "__fish_use_subcommand" -a "${cmd}" -d "${desc}"`;
+    })
+        .join("\n");
+    const subcommandCompletions = Object.entries(COMMANDS)
+        .filter(([, subs]) => subs.length > 0)
+        .flatMap(([cmd, subs]) => subs.map(sub => `complete -c husky -n "__fish_seen_subcommand_from ${cmd}" -a "${sub}" -d "${getSubcommandDescription(cmd, sub)}"`))
+        .join("\n");
+    return `# Fish completion for husky CLI
+# Generated by husky completion fish
+
+# Disable file completion by default
+complete -c husky -f
+
+# Main commands
+${mainCommandCompletions}
+
+# Subcommands
+${subcommandCompletions}
+
+# Common options
+complete -c husky -l json -d "Output as JSON"
+complete -c husky -l force -d "Skip confirmation"
+complete -c husky -l help -d "Show help"
+complete -c husky -l id -d "Task/Resource ID" -r
+complete -c husky -l project -d "Project ID" -r
+complete -c husky -l status -d "Filter by status" -r -a "backlog in_progress review done pending running completed failed"
+complete -c husky -l priority -d "Priority level" -r -a "low medium high urgent must should could wont"
+complete -c husky -l assignee -d "Assignee type" -r -a "human llm unassigned"
+complete -c husky -l agent -d "Agent type" -r -a "claude-code gemini-cli aider custom"
+complete -c husky -l type -d "Type filter" -r -a "global project architecture patterns decisions learnings"
+complete -c husky -l value-stream -d "Value stream" -r -a "order_to_delivery procure_to_pay returns_management product_lifecycle customer_service marketing_sales finance_accounting hr_operations it_operations general"
+complete -c husky -l action -d "Action type" -r -a "manual semi_automated fully_automated"
+complete -c husky -l work-status -d "Work status" -r -a "planning in_progress review completed on_hold"
+`;
+}
+function getCommandDescription(cmd) {
+    const descriptions = {
+        task: "Manage tasks",
+        project: "Manage projects and knowledge",
+        roadmap: "Manage roadmaps",
+        workflow: "Manage workflows and workflow steps",
+        idea: "Manage ideas",
+        department: "Manage departments",
+        vm: "Manage VM sessions",
+        jules: "Manage Jules AI coding sessions",
+        process: "Manage processes",
+        strategy: "Manage business strategy",
+        settings: "Manage application settings",
+        "vm-config": "Manage VM configurations",
+        config: "Manage CLI configuration",
+        changelog: "Generate and manage changelogs",
+        explain: "Explain CLI commands for AI agents",
+        completion: "Generate shell completion scripts",
+        agent: "Interactive agent mode",
+    };
+    return descriptions[cmd] || cmd;
+}
+function getSubcommandDescription(cmd, sub) {
+    // Common subcommand descriptions
+    const common = {
+        list: "List all",
+        create: "Create new",
+        get: "Get details",
+        update: "Update",
+        delete: "Delete",
+        start: "Start",
+        stop: "Stop",
+        show: "Show",
+    };
+    // Command-specific descriptions
+    const specific = {
+        task: {
+            done: "Mark task as done",
+            status: "Report task progress status",
+            plan: "Submit execution plan for approval",
+            "wait-approval": "Wait for plan approval",
+            complete: "Mark task as complete with result",
+            "qa-start": "Start QA validation",
+            "qa-status": "Get QA validation status",
+            "qa-approve": "Manually approve QA",
+            "qa-reject": "Manually reject QA",
+            "qa-iteration": "Add a QA iteration result",
+            "qa-escalate": "Escalate QA to human review",
+            "merge-conflict": "Resolve a Git merge conflict using AI",
+        },
+        project: {
+            "add-knowledge": "Add a knowledge entry",
+            "list-knowledge": "List knowledge entries",
+            "delete-knowledge": "Delete a knowledge entry",
+        },
+        roadmap: {
+            "add-phase": "Add a phase to a roadmap",
+            "add-feature": "Add a feature to a roadmap phase",
+            generate: "Generate roadmap with AI",
+            "list-features": "List all features in a roadmap",
+            "update-feature": "Update a roadmap feature",
+            "delete-feature": "Delete a feature from a roadmap",
+            "convert-feature": "Convert a roadmap feature to a task",
+        },
+        workflow: {
+            "add-step": "Add a step to a workflow",
+            "update-step": "Update a workflow step",
+            "delete-step": "Delete a workflow step",
+            "generate-steps": "AI-generate steps from an SOP document",
+            "list-steps": "List all steps in a workflow",
+        },
+        idea: {
+            convert: "Convert an idea to a task",
+        },
+        vm: {
+            logs: "Get VM logs",
+            approve: "Approve VM session plan",
+            reject: "Reject VM session plan",
+        },
+        jules: {
+            message: "Send a message to a Jules session",
+            approve: "Approve a Jules session plan",
+            activities: "Get session activities",
+            sources: "List available Jules sources",
+        },
+        strategy: {
+            "set-vision": "Set/update the company vision",
+            "set-mission": "Set/update the company mission",
+            "add-value": "Add a company value",
+            "update-value": "Update a company value",
+            "delete-value": "Delete a company value",
+            "add-goal": "Add a strategic goal",
+            "update-goal": "Update a strategic goal",
+            "delete-goal": "Delete a strategic goal",
+            "add-persona": "Add a target audience persona",
+            "update-persona": "Update a target audience persona",
+            "delete-persona": "Delete a target audience persona",
+        },
+        config: {
+            set: "Set a configuration value",
+            test: "Test API connection",
+        },
+        changelog: {
+            generate: "Generate a changelog from git commits",
+            publish: "Publish a changelog",
+        },
+        completion: {
+            bash: "Output bash completion script",
+            zsh: "Output zsh completion script",
+            fish: "Output fish completion script",
+            install: "Print installation instructions",
+        },
+    };
+    if (specific[cmd]?.[sub]) {
+        return specific[cmd][sub];
+    }
+    if (common[sub]) {
+        return `${common[sub]} ${cmd}`;
+    }
+    return sub;
+}

package/dist/commands/config.d.ts

@@ -4,5 +4,6 @@ interface Config {
     apiKey?: string;
 }
 export declare function getConfig(): Config;
+export declare function setConfig(key: "apiUrl" | "apiKey", value: string): void;
 export declare const configCommand: Command;
 export {};

package/dist/commands/config.js

@@ -4,6 +4,29 @@ import { join } from "path";
 import { homedir } from "os";
 const CONFIG_DIR = join(homedir(), ".husky");
 const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+// API Key validation - must be at least 16 characters and alphanumeric with dashes/underscores
+function validateApiKey(key) {
+    if (key.length < 16) {
+        return { valid: false, error: "API key must be at least 16 characters long" };
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(key)) {
+        return { valid: false, error: "API key must only contain letters, numbers, dashes, and underscores" };
+    }
+    return { valid: true };
+}
+// URL validation
+function validateApiUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (!["http:", "https:"].includes(parsed.protocol)) {
+            return { valid: false, error: "API URL must use http or https protocol" };
+        }
+        return { valid: true };
+    }
+    catch {
+        return { valid: false, error: "Invalid URL format" };
+    }
+}
 export function getConfig() {
     try {
         if (!existsSync(CONFIG_FILE)) {
@@ -22,6 +45,12 @@ function saveConfig(config) {
     }
     writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
 }
+// Helper to set a single config value (used by interactive mode)
+export function setConfig(key, value) {
+    const config = getConfig();
+    config[key] = value;
+    saveConfig(config);
+}
 export const configCommand = new Command("config")
     .description("Manage CLI configuration");
 // husky config set <key> <value>
@@ -31,9 +60,19 @@ configCommand
     .action((key, value) => {
     const config = getConfig();
     if (key === "api-url") {
+        const validation = validateApiUrl(value);
+        if (!validation.valid) {
+            console.error(`Error: ${validation.error}`);
+            process.exit(1);
+        }
         config.apiUrl = value;
     }
     else if (key === "api-key") {
+        const validation = validateApiKey(value);
+        if (!validation.valid) {
+            console.error(`Error: ${validation.error}`);
+            process.exit(1);
+        }
         config.apiKey = value;
     }
     else {
@@ -42,7 +81,7 @@ configCommand
         process.exit(1);
     }
     saveConfig(config);
-    console.log(`✓ Set ${key} = ${key === "api-key" ? "***" : value}`);
+    console.log(`Set ${key} = ${key === "api-key" ? "***" : value}`);
 });
 // husky config get <key>
 configCommand
@@ -71,3 +110,64 @@ configCommand
     console.log(`  api-url: ${config.apiUrl || "(not set)"}`);
     console.log(`  api-key: ${config.apiKey ? "***" : "(not set)"}`);
 });
+// husky config test
+configCommand
+    .command("test")
+    .description("Test API connection with configured credentials")
+    .action(async () => {
+    const config = getConfig();
+    // Check if configuration is complete
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    if (!config.apiKey) {
+        console.error("Error: API key not configured. Run: husky config set api-key <key>");
+        process.exit(1);
+    }
+    console.log("Testing API connection...");
+    try {
+        const url = new URL("/api/tasks", config.apiUrl);
+        const res = await fetch(url.toString(), {
+            headers: {
+                "x-api-key": config.apiKey,
+            },
+        });
+        if (res.ok) {
+            console.log(`API connection successful (API URL: ${config.apiUrl})`);
+        }
+        else if (res.status === 401) {
+            console.error(`API connection failed: Unauthorized (HTTP 401)`);
+            console.error("  Check your API key with: husky config set api-key <key>");
+            process.exit(1);
+        }
+        else if (res.status === 403) {
+            console.error(`API connection failed: Forbidden (HTTP 403)`);
+            console.error("  Your API key may not have the required permissions");
+            process.exit(1);
+        }
+        else {
+            console.error(`API connection failed: HTTP ${res.status}`);
+            try {
+                const body = await res.json();
+                if (body.error) {
+                    console.error(`  Error: ${body.error}`);
+                }
+            }
+            catch {
+                // Ignore JSON parse errors
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if (error instanceof TypeError && error.message.includes("fetch")) {
+            console.error(`API connection failed: Could not connect to ${config.apiUrl}`);
+            console.error("  Check your API URL with: husky config set api-url <url>");
+        }
+        else {
+            console.error(`API connection failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        process.exit(1);
+    }
+});

package/dist/commands/department.d.ts

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