@nijaru/tk 0.0.2 → 0.0.4

package/src/cli.ts

@@ -4,6 +4,7 @@ import { version } from "../package.json";
 
 import * as storage from "./db/storage";
 import { parsePriority } from "./lib/priority";
+import { parseDueDate, parseEstimate } from "./lib/time";
 import {
   formatTaskList,
   formatTaskDetail,
@@ -12,19 +13,36 @@ import {
   green,
   red,
   yellow,
+  dim,
 } from "./lib/format";
 import { findRoot, setWorkingDir } from "./lib/root";
 import { parseId } from "./types";
-import type { Status } from "./types";
+import type { Status, TaskWithMeta } from "./types";
 import { BASH_COMPLETION, ZSH_COMPLETION, FISH_COMPLETION } from "./lib/completions";
+import { MAIN_HELP, COMMAND_HELP } from "./lib/help";
 
 const VALID_STATUSES: Status[] = ["open", "active", "done"];
 const PROJECT_PATTERN = /^[a-z][a-z0-9]*$/;
 
+const COMMON_OPTIONS = {
+  project: { type: "string", short: "P" },
+  priority: { type: "string", short: "p" },
+  labels: { type: "string", short: "l" },
+} as const;
+
+const TASK_MUTATION_OPTIONS = {
+  ...COMMON_OPTIONS,
+  description: { type: "string", short: "d" },
+  assignees: { type: "string", short: "A" },
+  parent: { type: "string" },
+  estimate: { type: "string" },
+  due: { type: "string" },
+} as const;
+
 function validateProject(name: string): void {
   if (!PROJECT_PATTERN.test(name)) {
     throw new Error(
-      `Invalid project name: ${name}. Use lowercase letters and numbers, starting with a letter.`,
+      `Invalid project name: ${name}. Use lowercase letters and numbers, starting with a letter (e.g., 'api', 'web2').`,
     );
   }
 }
@@ -39,74 +57,16 @@ function parseStatus(input: string | undefined): Status | undefined {
 
 function parseLimit(input: string | undefined): number | undefined {
   if (!input) return undefined;
-  const n = parseInt(input, 10);
-  if (isNaN(n) || n < 1) {
+  if (!/^\d+$/.test(input)) {
     throw new Error(`Invalid limit: ${input}. Must be a positive number.`);
   }
-  return n;
-}
-
-function parseEstimate(input: string | undefined): number | undefined {
-  if (!input) return undefined;
-  const n = parseInt(input, 10);
-  if (isNaN(n) || n < 0) {
-    throw new Error(`Invalid estimate: ${input}. Must be a non-negative number.`);
+  const n = Number(input);
+  if (n < 1) {
+    throw new Error(`Invalid limit: ${input}. Must be a positive number.`);
   }
   return n;
 }
 
-function formatLocalDate(date: Date): string {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-
-function parseDueDate(input: string | undefined): string | undefined {
-  if (!input) return undefined;
-  if (input === "-") return undefined; // clear
-
-  // Handle relative dates like +7d
-  if (input.startsWith("+")) {
-    const match = input.match(/^\+(\d+)([dwmh])$/);
-    if (match && match[1] && match[2]) {
-      const num = match[1];
-      const unit = match[2];
-      const n = parseInt(num, 10);
-      const now = new Date();
-      switch (unit) {
-        case "h":
-          now.setHours(now.getHours() + n);
-          break;
-        case "d":
-          now.setDate(now.getDate() + n);
-          break;
-        case "w":
-          now.setDate(now.getDate() + n * 7);
-          break;
-        case "m":
-          now.setMonth(now.getMonth() + n);
-          break;
-      }
-      return formatLocalDate(now);
-    }
-    throw new Error(`Invalid relative date: ${input}. Use format like +7d, +2w, +1m`);
-  }
-
-  // Validate YYYY-MM-DD format - return as-is to avoid timezone issues
-  const dateMatch = input.match(/^(\d{4})-(\d{2})-(\d{2})$/);
-  if (dateMatch) {
-    const [, , month, day] = dateMatch;
-    const m = parseInt(month!, 10);
-    const d = parseInt(day!, 10);
-    // Basic validation: month 1-12, day 1-31
-    if (m >= 1 && m <= 12 && d >= 1 && d <= 31) {
-      return input; // Return as-is, already in correct format
-    }
-  }
-  throw new Error(`Invalid date: ${input}. Use YYYY-MM-DD or +Nd format.`);
-}
-
 function parseLabels(input: string | undefined): string[] | undefined {
   if (!input) return undefined;
   return input
@@ -146,18 +106,32 @@ function resolveId(input: string | undefined, context: string): string {
   const resolved = storage.resolveId(input);
   if (resolved) return resolved;
 
-  // Check if it's a valid full ID format
-  if (parseId(input)) return input;
-
   // Check for ambiguous matches
   const matches = storage.findMatchingIds(input);
   if (matches.length > 1) {
     throw new Error(
-      `Ambiguous ID '${input}' matches ${matches.length} tasks: ${matches.join(", ")}`,
+      `Ambiguous ID '${input}' matches ${matches.length} tasks: ${matches.join(", ")}. Use more characters to narrow it down.`,
     );
   }
 
-  throw new Error(`Task not found: ${input}`);
+  // If it's a valid full ID format but doesn't exist, we still return it
+  // and let getTask handle the "not found" error consistently.
+  if (parseId(input)) return input;
+
+  throw new Error(`Task not found: ${input}. Run 'tk ls' to see available tasks.`);
+}
+
+/**
+ * Resolves an ID and fetches the task.
+ * Handles "Task not found" and cleanup output automatically.
+ */
+function resolveTask(input: string | undefined, context: string): TaskWithMeta {
+  const id = resolveId(input, context);
+  const result = storage.getTask(id);
+  if (!result) error(`Task not found: ${id}. Run 'tk ls' to see available tasks.`);
+
+  outputCleanup(id, result.cleanup);
+  return result.task;
 }
 
 const rawArgs = process.argv.slice(2);
@@ -223,258 +197,12 @@ function error(message: string): never {
   process.exit(1);
 }
 
-function showHelp() {
-  console.log(`tk v${version} - Task tracker for AI agents
-
-USAGE:
-  tk <command> [options]
-
-COMMANDS:
-  init         Initialize .tasks/ directory
-  add          Create task
-  ls, list     List tasks
-  ready        List ready tasks (open + unblocked)
-  show         Show task details
-  start        Start working (open -> active)
-  done         Complete task
-  reopen       Reopen task
-  edit         Edit task
-  log          Add log entry
-  block        Add blocker
-  unblock      Remove blocker
-  rm, remove   Delete task
-  clean        Remove old done tasks
-  check        Check for data issues
-  config       Show/set configuration
-  completions  Output shell completions
-
-GLOBAL OPTIONS:
-  -C <dir>     Run in different directory
-  --json       Output as JSON
-  -h, --help   Show help
-  -V           Show version
-
-Run 'tk <command> --help' for command-specific options.
-`);
+function showHelp(): void {
+  console.log(MAIN_HELP);
 }
 
-function showCommandHelp(cmd: string) {
-  const helps: Record<string, string> = {
-    init: `tk init - Initialize .tasks/ directory
-
-USAGE:
-  tk init [options]
-
-OPTIONS:
-  -P, --project <name>   Set default project name
-`,
-    add: `tk add - Create a new task
-
-USAGE:
-  tk add <title> [options]
-
-OPTIONS:
-  -p, --priority <0-4>       Priority (0=none, 1=urgent, 2=high, 3=medium, 4=low)
-  -P, --project <name>       Project prefix for ID
-  -d, --description <text>   Description
-  -l, --labels <csv>         Labels (comma-separated)
-  -A, --assignees <csv>      Assignees (comma-separated, @me for git user)
-  --parent <id>              Parent task ID
-  --estimate <n>             Estimate (user-defined units)
-  --due <date>               Due date (YYYY-MM-DD or +Nh/+Nd/+Nw/+Nm)
-
-EXAMPLES:
-  tk add "Fix login bug" -p 1
-  tk add "New feature" -P api -l bug,urgent
-  tk add "Sprint task" --due +7d
-`,
-    ls: `tk ls - List tasks
-
-USAGE:
-  tk ls [options]
-
-OPTIONS:
-  -s, --status <status>   Filter by status (open, active, done)
-  -p, --priority <0-4>    Filter by priority
-  -P, --project <name>    Filter by project
-  -l, --label <label>     Filter by label
-  --assignee <name>       Filter by assignee
-  --parent <id>           Filter by parent
-  --roots                 Show only root tasks (no parent)
-  --overdue               Show only overdue tasks
-  -n, --limit <n>         Limit results (default: 20)
-  -a, --all               Show all (no limit)
-
-EXAMPLES:
-  tk ls -s open -p 1      # Urgent open tasks
-  tk ls --overdue         # Overdue tasks
-  tk ls -P api --roots    # Root tasks in api project
-`,
-    list: `tk list - List tasks (alias for 'ls')
-
-Run 'tk ls --help' for options.
-`,
-    ready: `tk ready - List ready tasks (open + unblocked)
-
-USAGE:
-  tk ready
-
-Shows open tasks that are not blocked by any incomplete task.
-`,
-    show: `tk show - Show task details
-
-USAGE:
-  tk show <id>
-
-EXAMPLES:
-  tk show tk-1
-  tk show 1        # If unambiguous
-`,
-    start: `tk start - Start working on a task
-
-USAGE:
-  tk start <id>
-
-Changes status from open to active.
-`,
-    done: `tk done - Complete a task
-
-USAGE:
-  tk done <id>
-
-Changes status to done.
-`,
-    reopen: `tk reopen - Reopen a task
-
-USAGE:
-  tk reopen <id>
-
-Changes status back to open.
-`,
-    edit: `tk edit - Edit a task
-
-USAGE:
-  tk edit <id> [options]
-
-OPTIONS:
-  -t, --title <text>         New title
-  -d, --description <text>   New description
-  -p, --priority <0-4>       New priority
-  -l, --labels <csv>         Replace labels (use +tag/-tag to add/remove)
-  -A, --assignees <csv>      Replace assignees
-  --parent <id>              Set parent (use - to clear)
-  --estimate <n>             Set estimate (use - to clear)
-  --due <date>               Set due date (use - to clear)
-
-EXAMPLES:
-  tk edit tk-1 -t "New title"
-  tk edit tk-1 -l +urgent     # Add label
-  tk edit tk-1 --due -        # Clear due date
-`,
-    log: `tk log - Add a log entry to a task
-
-USAGE:
-  tk log <id> "<message>"
-
-Message must be quoted.
-
-EXAMPLES:
-  tk log tk-1 "Started implementation"
-  tk log tk-1 "Blocked on API changes"
-`,
-    block: `tk block - Add a blocker dependency
-
-USAGE:
-  tk block <task> <blocker>
-
-The first task becomes blocked by the second.
-
-EXAMPLES:
-  tk block tk-2 tk-1    # tk-2 is blocked by tk-1
-`,
-    unblock: `tk unblock - Remove a blocker dependency
-
-USAGE:
-  tk unblock <task> <blocker>
-
-EXAMPLES:
-  tk unblock tk-2 tk-1
-`,
-    rm: `tk rm - Delete a task
-
-USAGE:
-  tk rm <id>
-
-EXAMPLES:
-  tk rm tk-1
-`,
-    remove: `tk remove - Delete a task (alias for 'rm')
-
-USAGE:
-  tk remove <id>
-`,
-    clean: `tk clean - Remove old completed tasks
-
-USAGE:
-  tk clean [options]
-
-OPTIONS:
-  --older-than <days>   Age threshold in days (default: from config, 14)
-  -f, --force           Remove all done tasks (ignores age and disabled state)
-
-EXAMPLES:
-  tk clean                  # Remove done tasks older than config.clean_after days
-  tk clean --older-than 30  # Remove done tasks older than 30 days
-  tk clean --force          # Remove all done tasks regardless of age
-`,
-    check: `tk check - Check for data issues
-
-USAGE:
-  tk check
-
-Scans all tasks for issues. Auto-fixable issues (orphaned references, ID
-mismatches) are fixed automatically. Unfixable issues (corrupted JSON) are
-reported for manual intervention.
-
-Note: Auto-fixing also happens during normal task operations (show, done,
-edit, etc.) - this command is for bulk cleanup or diagnostics.
-
-EXAMPLES:
-  tk check                  # Scan and fix all tasks
-`,
-    config: `tk config - Show or set configuration
-
-USAGE:
-  tk config                              Show all config
-  tk config project                      Show default project
-  tk config project <name>               Set default project
-  tk config project <new> --rename <old> Rename project (old-* → new-*)
-  tk config alias                        List aliases
-  tk config alias <name> <path>          Add alias
-  tk config alias --rm <name>            Remove alias
-
-EXAMPLES:
-  tk config project api
-  tk config project lsmvec --rename cloudlsmvec
-  tk config alias web src/web
-`,
-    completions: `tk completions - Output shell completions
-
-USAGE:
-  tk completions <shell>
-
-SHELLS:
-  bash   Bash completion script
-  zsh    Zsh completion script
-  fish   Fish completion script
-
-EXAMPLES:
-  eval "$(tk completions bash)"   # Add to ~/.bashrc
-  eval "$(tk completions zsh)"    # Add to ~/.zshrc
-`,
-  };
-
-  const help = helps[cmd];
+function showCommandHelp(cmd: string): void {
+  const help = COMMAND_HELP[cmd];
   if (help) {
     console.log(help);
   } else {
@@ -526,7 +254,7 @@ function main() {
       if (info.exists) {
         output(
           { path: info.tasksDir, created: false },
-          green(`Already initialized: ${info.tasksDir}`),
+          dim(`Already initialized: ${info.tasksDir}`),
         );
       } else {
         const path = storage.initTasks(values.project);
@@ -538,16 +266,7 @@ function main() {
     case "add": {
       const { values, positionals } = parseArgs({
         args,
-        options: {
-          description: { type: "string", short: "d" },
-          priority: { type: "string", short: "p" },
-          project: { type: "string", short: "P" },
-          labels: { type: "string", short: "l" },
-          assignees: { type: "string", short: "A" },
-          parent: { type: "string" },
-          estimate: { type: "string" },
-          due: { type: "string" },
-        },
+        options: TASK_MUTATION_OPTIONS,
         allowPositionals: true,
       });
       const title = positionals[0]?.trim();
@@ -562,7 +281,8 @@ function main() {
       let parentId: string | undefined;
       if (values.parent) {
         const resolved = storage.resolveId(values.parent);
-        if (!resolved) error(`Parent task not found: ${values.parent}`);
+        if (!resolved)
+          error(`Parent task not found: ${values.parent}. Run 'tk ls' to see available tasks.`);
         parentId = resolved;
         const parentResult = storage.validateParent(parentId);
         if (!parentResult.ok) error(parentResult.error!);
@@ -588,10 +308,9 @@ function main() {
       const { values } = parseArgs({
         args,
         options: {
+          ...COMMON_OPTIONS,
+          label: COMMON_OPTIONS.labels, // alias for consistency
           status: { type: "string", short: "s" },
-          priority: { type: "string", short: "p" },
-          project: { type: "string", short: "P" },
-          label: { type: "string", short: "l" },
           assignee: { type: "string" },
           parent: { type: "string" },
           roots: { type: "boolean" },
@@ -609,7 +328,8 @@ function main() {
       let parentFilter: string | undefined;
       if (values.parent) {
         const resolved = storage.resolveId(values.parent);
-        if (!resolved) error(`Parent task not found: ${values.parent}`);
+        if (!resolved)
+          error(`Parent task not found: ${values.parent}. Run 'tk ls' to see available tasks.`);
         parentFilter = resolved;
       }
 
@@ -617,7 +337,7 @@ function main() {
         status,
         priority,
         project: values.project,
-        label: values.label,
+        label: values.label ?? values.labels,
         assignee: values.assignee,
         parent: parentFilter,
         roots: values.roots,
@@ -630,49 +350,40 @@ function main() {
 
     case "ready": {
       const list = storage.listReadyTasks();
-      output(list, formatTaskList(list));
+      output(
+        list,
+        formatTaskList(list, undefined, "No ready tasks. All tasks are either done or blocked."),
+      );
       break;
     }
 
     case "show": {
-      const id = resolveId(args[0], "show");
-      const result = storage.getTaskWithMeta(id);
-      if (!result) error(`Task not found: ${id}`);
-      outputCleanup(id, result.cleanup);
-      output(result.task, formatTaskDetail(result.task, result.task.logs));
+      const task = resolveTask(args[0], "show");
+      output(task, formatTaskDetail(task, task.logs));
       break;
     }
 
     case "start": {
-      const id = resolveId(args[0], "start");
-      const result = storage.getTask(id);
-      if (!result) error(`Task not found: ${id}`);
-      outputCleanup(id, result.cleanup);
-      if (result.task.status === "active")
-        error(`Task already active. Use 'tk done ${id}' to complete it.`);
-      if (result.task.status === "done") error(`Task already done. Use 'tk reopen ${id}' first.`);
-      const updated = storage.updateTaskStatus(id, "active");
-      output(updated, green(`Started: ${id}`));
+      const task = resolveTask(args[0], "start");
+      if (task.status === "active")
+        error(`Task already active. Use 'tk done ${task.id}' to complete it.`);
+      if (task.status === "done") error(`Task already done. Use 'tk reopen ${task.id}' first.`);
+      const updated = storage.updateTaskStatus(task.id, "active");
+      output(updated, green(`Started: ${task.id}`));
       break;
     }
 
     case "done": {
-      const id = resolveId(args[0], "done");
-      const result = storage.getTask(id);
-      if (!result) error(`Task not found: ${id}`);
-      outputCleanup(id, result.cleanup);
-      const updated = storage.updateTaskStatus(id, "done");
-      output(updated, green(`Completed: ${id}`));
+      const task = resolveTask(args[0], "done");
+      const updated = storage.updateTaskStatus(task.id, "done");
+      output(updated, green(`Completed: ${task.id}`));
       break;
     }
 
     case "reopen": {
-      const id = resolveId(args[0], "reopen");
-      const result = storage.getTask(id);
-      if (!result) error(`Task not found: ${id}`);
-      outputCleanup(id, result.cleanup);
-      const updated = storage.updateTaskStatus(id, "open");
-      output(updated, green(`Reopened: ${id}`));
+      const task = resolveTask(args[0], "reopen");
+      const updated = storage.updateTaskStatus(task.id, "open");
+      output(updated, green(`Reopened: ${task.id}`));
       break;
     }
 
@@ -680,21 +391,12 @@ function main() {
       const { values, positionals } = parseArgs({
         args,
         options: {
+          ...TASK_MUTATION_OPTIONS,
           title: { type: "string", short: "t" },
-          description: { type: "string", short: "d" },
-          priority: { type: "string", short: "p" },
-          labels: { type: "string", short: "l" },
-          assignees: { type: "string", short: "A" },
-          parent: { type: "string" },
-          estimate: { type: "string" },
-          due: { type: "string" },
         },
         allowPositionals: true,
       });
-      const id = resolveId(positionals[0], "edit");
-      const result = storage.getTask(id);
-      if (!result) error(`Task not found: ${id}`);
-      outputCleanup(id, result.cleanup);
+      const task = resolveTask(positionals[0], "edit");
 
       // Handle label modifications (+tag, -tag)
       let labels: string[] | undefined;
@@ -702,13 +404,11 @@ function main() {
         if (values.labels.startsWith("+")) {
           // Add label (avoid duplicates)
           const newLabel = values.labels.slice(1);
-          labels = result.task.labels.includes(newLabel)
-            ? result.task.labels
-            : [...result.task.labels, newLabel];
+          labels = task.labels.includes(newLabel) ? task.labels : [...task.labels, newLabel];
         } else if (values.labels.startsWith("-")) {
           // Remove label
           const removeLabel = values.labels.slice(1);
-          labels = result.task.labels.filter((l) => l !== removeLabel);
+          labels = task.labels.filter((l: string) => l !== removeLabel);
         } else {
           // Replace labels
           labels = parseLabels(values.labels);
@@ -721,13 +421,14 @@ function main() {
         resolvedParent = null;
       } else if (values.parent) {
         const resolved = storage.resolveId(values.parent);
-        if (!resolved) error(`Parent task not found: ${values.parent}`);
+        if (!resolved)
+          error(`Parent task not found: ${values.parent}. Run 'tk ls' to see available tasks.`);
         resolvedParent = resolved;
-        const parentResult = storage.validateParent(resolvedParent, id);
+        const parentResult = storage.validateParent(resolvedParent, task.id);
         if (!parentResult.ok) error(parentResult.error!);
       }
 
-      const updated = storage.updateTask(id, {
+      const updated = storage.updateTask(task.id, {
         title: values.title?.trim() || undefined,
         description: values.description,
         priority: values.priority ? parsePriority(values.priority) : undefined,
@@ -737,12 +438,12 @@ function main() {
         estimate: values.estimate === "-" ? null : (parseEstimate(values.estimate) ?? undefined),
         due_date: values.due === "-" ? null : (parseDueDate(values.due) ?? undefined),
       });
-      output(updated, green(`Updated: ${id}`));
+      output(updated, green(`Updated: ${task.id}`));
       break;
     }
 
     case "log": {
-      const id = resolveId(args[0], "log");
+      const task = resolveTask(args[0], "log");
       const message = args[1]?.trim();
       if (!message) error('Message required: tk log <id> "<message>"');
       if (args.length > 2) {
@@ -751,19 +452,19 @@ function main() {
             `  Got ${args.length - 1} arguments instead of 1`,
         );
       }
-      const result = storage.getTask(id);
-      if (!result) error(`Task not found: ${id}`);
-      outputCleanup(id, result.cleanup);
-      const entry = storage.addLogEntry(id, message);
-      output(entry, green(`Logged: ${id}`));
+      const entry = storage.addLogEntry(task.id, message);
+      output(entry, green(`Logged: ${task.id}`));
       break;
     }
 
     case "block": {
-      if (!args[0] || !args[1]) error("Usage: tk block <task> <blocker>");
+      if (!args[0] || !args[1])
+        error(
+          "Two IDs required: tk block <task> <blocker>. The first task becomes blocked by the second.",
+        );
       const taskId = resolveId(args[0], "block");
       const blockerId = resolveId(args[1], "block");
-      if (taskId === blockerId) error("Task cannot block itself");
+      if (taskId === blockerId) error("Task cannot block itself.");
       const result = storage.addBlock(taskId, blockerId);
       if (!result.ok) error(result.error!);
       output(
@@ -774,7 +475,7 @@ function main() {
     }
 
     case "unblock": {
-      if (!args[0] || !args[1]) error("Usage: tk unblock <task> <blocker>");
+      if (!args[0] || !args[1]) error("Two IDs required: tk unblock <task> <blocker>.");
       const taskId = resolveId(args[0], "unblock");
       const blockerId = resolveId(args[1], "unblock");
       const removed = storage.removeBlock(taskId, blockerId);
@@ -790,7 +491,7 @@ function main() {
     case "remove": {
       const id = resolveId(args[0], "rm");
       const deleted = storage.deleteTask(id);
-      if (!deleted) error(`Task not found: ${id}`);
+      if (!deleted) error(`Task not found: ${id}. Run 'tk ls' to see available tasks.`);
       output({ id, deleted: true }, green(`Deleted: ${id}`));
       break;
     }
@@ -809,11 +510,10 @@ function main() {
       // Get days from CLI or config
       let days: number | false;
       if (values["older-than"] !== undefined) {
-        const n = parseInt(values["older-than"], 10);
-        if (isNaN(n) || n < 0) {
+        if (!/^\d+$/.test(values["older-than"])) {
           error(`Invalid --older-than: ${values["older-than"]}. Use a number of days.`);
         }
-        days = n;
+        days = Number(values["older-than"]);
       } else {
         days = config.clean_after;
         // Validate config value at runtime
@@ -933,7 +633,7 @@ function main() {
             const alias = positionals[0];
             const path = positionals[1];
             if (!alias || !path || !alias.trim()) {
-              error("Alias name and path are required");
+              error("Alias name and path required: tk config alias <name> <path>");
             }
             const updated = storage.setAlias(alias, path);
             output(updated, green(`Added alias: ${alias} → ${path}`));
@@ -941,7 +641,10 @@ function main() {
             // List aliases
             const aliases = config.aliases;
             if (Object.keys(aliases).length === 0) {
-              output({ aliases: {} }, "No aliases defined.");
+              output(
+                { aliases: {} },
+                "No aliases defined. Add one with: tk config alias <name> <path>",
+              );
             } else {
               const lines = Object.entries(aliases)
                 .map(([a, p]) => `${a} → ${p}`)
@@ -952,7 +655,7 @@ function main() {
           break;
         }
         default:
-          error(`Unknown config command: ${subcommand}`);
+          error(`Unknown config command: ${subcommand}. Valid: project, alias.`);
       }
       break;
     }
@@ -970,7 +673,7 @@ function main() {
           console.log(FISH_COMPLETION);
           break;
         default:
-          error("Shell required: tk completions <bash|zsh|fish>");
+          error("Shell required: tk completions <bash|zsh|fish>. Add to your shell's rc file.");
       }
       break;
     }