@nijaru/tk 0.0.1 → 0.0.2

package/src/cli.ts

@@ -4,7 +4,15 @@ import { version } from "../package.json";
 
 import * as storage from "./db/storage";
 import { parsePriority } from "./lib/priority";
-import { formatTaskList, formatTaskDetail, formatJson, formatConfig } from "./lib/format";
+import {
+  formatTaskList,
+  formatTaskDetail,
+  formatJson,
+  formatConfig,
+  green,
+  red,
+  yellow,
+} from "./lib/format";
 import { findRoot, setWorkingDir } from "./lib/root";
 import { parseId } from "./types";
 import type { Status } from "./types";
@@ -47,6 +55,13 @@ function parseEstimate(input: string | undefined): number | undefined {
   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
@@ -73,17 +88,23 @@ function parseDueDate(input: string | undefined): string | undefined {
           now.setMonth(now.getMonth() + n);
           break;
       }
-      return now.toISOString().split("T")[0];
+      return formatLocalDate(now);
     }
     throw new Error(`Invalid relative date: ${input}. Use format like +7d, +2w, +1m`);
   }
 
-  // Validate and normalize to YYYY-MM-DD
-  const date = new Date(input);
-  if (isNaN(date.getTime())) {
-    throw new Error(`Invalid date: ${input}. Use YYYY-MM-DD or +Nd format.`);
+  // 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
+    }
   }
-  return date.toISOString().split("T")[0];
+  throw new Error(`Invalid date: ${input}. Use YYYY-MM-DD or +Nd format.`);
 }
 
 function parseLabels(input: string | undefined): string[] | undefined {
@@ -121,23 +142,26 @@ function resolveId(input: string | undefined, context: string): string {
     throw new Error(`ID required: tk ${context} <id>`);
   }
 
-  // Try to resolve ambiguous ID (just a number)
+  // Try to resolve partial ID
   const resolved = storage.resolveId(input);
   if (resolved) return resolved;
 
-  // Check if it's a valid full ID
+  // Check if it's a valid full ID format
   if (parseId(input)) return input;
 
-  throw new Error(
-    `Invalid task ID: ${input}. Use format like tk-a1b2, or just the ref (a1b2) if unambiguous.`,
-  );
+  // 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(", ")}`,
+    );
+  }
+
+  throw new Error(`Task not found: ${input}`);
 }
 
 const rawArgs = process.argv.slice(2);
 
-// Global flags that can appear anywhere in the command
-const GLOBAL_FLAGS = new Set(["--json", "--help", "-h", "--version", "-V"]);
-
 function isFlag(arg: string): boolean {
   return arg.startsWith("-");
 }
@@ -158,23 +182,44 @@ if (dirFlag) {
   setWorkingDir(dirFlag);
 }
 
-// Extract global flags from anywhere in args
-const jsonFlag = argsWithoutDir.includes("--json");
-const helpFlag = argsWithoutDir.includes("--help") || argsWithoutDir.includes("-h");
-const versionFlag = argsWithoutDir.includes("--version") || argsWithoutDir.includes("-V");
-
 // Find command: first non-flag argument
-const command = argsWithoutDir.find((arg) => !isFlag(arg));
+const commandIndex = argsWithoutDir.findIndex((arg) => !isFlag(arg));
+const command = commandIndex >= 0 ? argsWithoutDir[commandIndex] : undefined;
 
-// Get args for command: everything except the command itself and global flags
-const args = argsWithoutDir.filter((arg) => arg !== command && !GLOBAL_FLAGS.has(arg));
+// Get args for command (before stripping flags)
+const postCommandArgs = commandIndex >= 0 ? argsWithoutDir.slice(commandIndex + 1) : [];
+const preCommandArgs = commandIndex >= 0 ? argsWithoutDir.slice(0, commandIndex) : argsWithoutDir;
+
+// Global flag detection:
+// --json can appear anywhere and should be stripped from args
+// --help/-h detected before command OR as first arg after command (not in message content)
+// --version/-V only detected before command
+const jsonFlag = argsWithoutDir.includes("--json");
+const helpFlag =
+  preCommandArgs.includes("--help") ||
+  preCommandArgs.includes("-h") ||
+  postCommandArgs[0] === "--help" ||
+  postCommandArgs[0] === "-h";
+const versionFlag = preCommandArgs.includes("--version") || preCommandArgs.includes("-V");
+
+// Strip --json from args (works from any position)
+// Strip --help/-h only if it's the first arg (to allow "tk ls --help")
+const args = postCommandArgs
+  .filter((arg) => arg !== "--json")
+  .filter((arg, i) => i !== 0 || (arg !== "--help" && arg !== "-h"));
 
 function output(data: unknown, formatted: string) {
   console.log(jsonFlag ? formatJson(data) : formatted);
 }
 
+function outputCleanup(taskId: string, cleanup: storage.CleanupInfo | null) {
+  if (cleanup && !jsonFlag) {
+    console.error(storage.formatCleanupMessage(taskId, cleanup));
+  }
+}
+
 function error(message: string): never {
-  console.error(`Error: ${message}`);
+  console.error(red(`Error: ${message}`));
   process.exit(1);
 }
 
@@ -199,6 +244,7 @@ COMMANDS:
   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
 
@@ -328,7 +374,9 @@ EXAMPLES:
     log: `tk log - Add a log entry to a task
 
 USAGE:
-  tk log <id> <message>
+  tk log <id> "<message>"
+
+Message must be quoted.
 
 EXAMPLES:
   tk log tk-1 "Started implementation"
@@ -371,16 +419,28 @@ USAGE:
   tk clean [options]
 
 OPTIONS:
-  --older-than <duration>   Age threshold (default: 7d)
-  -a, --all                 Remove all done tasks (ignore age)
+  --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
 
-DURATION FORMAT:
-  7d = 7 days, 2w = 2 weeks, 24h = 24 hours
+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 clean                  # Remove done tasks older than 7 days
-  tk clean --older-than 30d
-  tk clean -a               # Remove all done tasks
+  tk check                  # Scan and fix all tasks
 `,
     config: `tk config - Show or set configuration
 
@@ -464,10 +524,13 @@ function main() {
       }
       const info = findRoot();
       if (info.exists) {
-        output({ path: info.tasksDir, created: false }, `Already initialized: ${info.tasksDir}`);
+        output(
+          { path: info.tasksDir, created: false },
+          green(`Already initialized: ${info.tasksDir}`),
+        );
       } else {
         const path = storage.initTasks(values.project);
-        output({ path, created: true }, `Initialized: ${path}`);
+        output({ path, created: true }, green(`Initialized: ${path}`));
       }
       break;
     }
@@ -573,37 +636,43 @@ function main() {
 
     case "show": {
       const id = resolveId(args[0], "show");
-      const task = storage.getTaskWithMeta(id);
-      if (!task) error(`Task not found: ${id}`);
-      output(task, formatTaskDetail(task, task.logs));
+      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));
       break;
     }
 
     case "start": {
       const id = resolveId(args[0], "start");
-      const task = storage.getTask(id);
-      if (!task) error(`Task not found: ${id}`);
-      if (task.status !== "open") error(`Task is ${task.status}, not open`);
+      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, `Started: ${id}`);
+      output(updated, green(`Started: ${id}`));
       break;
     }
 
     case "done": {
       const id = resolveId(args[0], "done");
-      const task = storage.getTask(id);
-      if (!task) error(`Task not found: ${id}`);
+      const result = storage.getTask(id);
+      if (!result) error(`Task not found: ${id}`);
+      outputCleanup(id, result.cleanup);
       const updated = storage.updateTaskStatus(id, "done");
-      output(updated, `Completed: ${id}`);
+      output(updated, green(`Completed: ${id}`));
       break;
     }
 
     case "reopen": {
       const id = resolveId(args[0], "reopen");
-      const task = storage.getTask(id);
-      if (!task) error(`Task not found: ${id}`);
+      const result = storage.getTask(id);
+      if (!result) error(`Task not found: ${id}`);
+      outputCleanup(id, result.cleanup);
       const updated = storage.updateTaskStatus(id, "open");
-      output(updated, `Reopened: ${id}`);
+      output(updated, green(`Reopened: ${id}`));
       break;
     }
 
@@ -623,8 +692,9 @@ function main() {
         allowPositionals: true,
       });
       const id = resolveId(positionals[0], "edit");
-      const task = storage.getTask(id);
-      if (!task) error(`Task not found: ${id}`);
+      const result = storage.getTask(id);
+      if (!result) error(`Task not found: ${id}`);
+      outputCleanup(id, result.cleanup);
 
       // Handle label modifications (+tag, -tag)
       let labels: string[] | undefined;
@@ -632,11 +702,13 @@ function main() {
         if (values.labels.startsWith("+")) {
           // Add label (avoid duplicates)
           const newLabel = values.labels.slice(1);
-          labels = task.labels.includes(newLabel) ? task.labels : [...task.labels, newLabel];
+          labels = result.task.labels.includes(newLabel)
+            ? result.task.labels
+            : [...result.task.labels, newLabel];
         } else if (values.labels.startsWith("-")) {
           // Remove label
           const removeLabel = values.labels.slice(1);
-          labels = task.labels.filter((l) => l !== removeLabel);
+          labels = result.task.labels.filter((l) => l !== removeLabel);
         } else {
           // Replace labels
           labels = parseLabels(values.labels);
@@ -665,18 +737,25 @@ function main() {
         estimate: values.estimate === "-" ? null : (parseEstimate(values.estimate) ?? undefined),
         due_date: values.due === "-" ? null : (parseDueDate(values.due) ?? undefined),
       });
-      output(updated, `Updated: ${id}`);
+      output(updated, green(`Updated: ${id}`));
       break;
     }
 
     case "log": {
       const id = resolveId(args[0], "log");
-      const message = args.slice(1).join(" ").trim();
-      if (!message) error("Message required: tk log <id> <message>");
-      const task = storage.getTask(id);
-      if (!task) error(`Task not found: ${id}`);
+      const message = args[1]?.trim();
+      if (!message) error('Message required: tk log <id> "<message>"');
+      if (args.length > 2) {
+        error(
+          'Message must be quoted: tk log <id> "<message>"\n' +
+            `  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, `Logged: ${id}`);
+      output(entry, green(`Logged: ${id}`));
       break;
     }
 
@@ -687,7 +766,10 @@ function main() {
       if (taskId === blockerId) error("Task cannot block itself");
       const result = storage.addBlock(taskId, blockerId);
       if (!result.ok) error(result.error!);
-      output({ task_id: taskId, blocked_by: blockerId }, `${taskId} blocked by ${blockerId}`);
+      output(
+        { task_id: taskId, blocked_by: blockerId },
+        green(`${taskId} blocked by ${blockerId}`),
+      );
       break;
     }
 
@@ -695,40 +777,101 @@ function main() {
       if (!args[0] || !args[1]) error("Usage: tk unblock <task> <blocker>");
       const taskId = resolveId(args[0], "unblock");
       const blockerId = resolveId(args[1], "unblock");
-      const success = storage.removeBlock(taskId, blockerId);
-      if (!success) error("Block not found");
-      output({ task_id: taskId, blocked_by: blockerId }, `${taskId} unblocked from ${blockerId}`);
+      const removed = storage.removeBlock(taskId, blockerId);
+      if (!removed) error(`${taskId} is not blocked by ${blockerId}`);
+      output(
+        { task_id: taskId, blocked_by: blockerId },
+        green(`${taskId} unblocked from ${blockerId}`),
+      );
       break;
     }
 
     case "rm":
     case "remove": {
       const id = resolveId(args[0], "rm");
-      const success = storage.deleteTask(id);
-      if (!success) error(`Task not found: ${id}`);
-      output({ id, deleted: true }, `Deleted: ${id}`);
+      const deleted = storage.deleteTask(id);
+      if (!deleted) error(`Task not found: ${id}`);
+      output({ id, deleted: true }, green(`Deleted: ${id}`));
       break;
     }
 
     case "clean": {
+      const config = storage.getConfig();
       const { values } = parseArgs({
         args,
         options: {
-          "older-than": { type: "string", default: "7d" },
-          done: { type: "boolean" },
-          all: { type: "boolean", short: "a" },
+          "older-than": { type: "string" },
+          force: { type: "boolean", short: "f" },
         },
         allowPositionals: true,
       });
-      const olderThan = values["older-than"] || "7d";
-      const ms = parseDuration(olderThan);
-      const status = values.done ? ("done" as Status) : undefined;
+
+      // 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) {
+          error(`Invalid --older-than: ${values["older-than"]}. Use a number of days.`);
+        }
+        days = n;
+      } else {
+        days = config.clean_after;
+        // Validate config value at runtime
+        if (days !== false && (typeof days !== "number" || days < 0 || !Number.isFinite(days))) {
+          error(
+            `Invalid clean_after in config: ${JSON.stringify(days)}. Must be a number or false.`,
+          );
+        }
+      }
+
+      if (days === false && !values.force) {
+        error("Cleaning is disabled (clean_after: false). Use --force to override.");
+      }
+
+      const ms = days === false ? 0 : days * 24 * 60 * 60 * 1000;
       const count = storage.cleanTasks({
         olderThanMs: ms,
-        status,
-        all: values.all,
+        force: values.force,
       });
-      output({ deleted: count }, `Cleaned ${count} tasks`);
+      output({ deleted: count }, green(`Cleaned ${count} tasks`));
+      break;
+    }
+
+    case "check": {
+      const checkResult = storage.checkTasks();
+
+      if (jsonFlag) {
+        output(checkResult, "");
+      } else {
+        // Report cleaned issues
+        if (checkResult.cleaned.length > 0) {
+          for (const { task, info } of checkResult.cleaned) {
+            console.log(storage.formatCleanupMessage(task, info));
+          }
+        }
+
+        // Report unfixable issues
+        if (checkResult.unfixable.length > 0) {
+          console.log(red("\nUnfixable issues (require manual intervention):"));
+          for (const { file, error: err } of checkResult.unfixable) {
+            console.log(red(`  ${file}: ${err}`));
+          }
+        }
+
+        // Summary
+        if (checkResult.cleaned.length === 0 && checkResult.unfixable.length === 0) {
+          console.log(green(`All ${checkResult.totalTasks} tasks OK`));
+        } else {
+          const parts: string[] = [];
+          if (checkResult.cleaned.length > 0) {
+            parts.push(yellow(`${checkResult.cleaned.length} fixed`));
+          }
+          if (checkResult.unfixable.length > 0) {
+            parts.push(red(`${checkResult.unfixable.length} unfixable`));
+          }
+          console.log(`\nChecked ${checkResult.totalTasks} tasks: ${parts.join(", ")}`);
+        }
+      }
       break;
     }
 
@@ -759,15 +902,17 @@ function main() {
             const result = storage.renameProject(values.rename, newProject);
             output(
               result,
-              `Renamed ${result.renamed.length} tasks: ${values.rename}-* → ${newProject}-*` +
-                (result.referencesUpdated > 0
-                  ? `\nUpdated ${result.referencesUpdated} references`
-                  : ""),
+              green(
+                `Renamed ${result.renamed.length} tasks: ${values.rename}-* → ${newProject}-*` +
+                  (result.referencesUpdated > 0
+                    ? `\nUpdated ${result.referencesUpdated} references`
+                    : ""),
+              ),
             );
           } else {
             validateProject(newProject);
             const updated = storage.setDefaultProject(newProject);
-            output(updated, `Default project: ${newProject}`);
+            output(updated, green(`Default project: ${newProject}`));
           }
           break;
         }
@@ -783,7 +928,7 @@ function main() {
 
           if (values.rm) {
             const updated = storage.removeAlias(values.rm);
-            output(updated, `Removed alias: ${values.rm}`);
+            output(updated, green(`Removed alias: ${values.rm}`));
           } else if (positionals.length >= 2) {
             const alias = positionals[0];
             const path = positionals[1];
@@ -791,7 +936,7 @@ function main() {
               error("Alias name and path are required");
             }
             const updated = storage.setAlias(alias, path);
-            output(updated, `Added alias: ${alias} → ${path}`);
+            output(updated, green(`Added alias: ${alias} → ${path}`));
           } else {
             // List aliases
             const aliases = config.aliases;
@@ -835,37 +980,13 @@ function main() {
   }
 }
 
-function parseDuration(s: string): number {
-  const match = s.match(/^(\d+)(s|m|h|d|w)$/);
-  if (!match || !match[1] || !match[2]) {
-    throw new Error(`Invalid duration: ${s}. Use format like 7d, 24h, 30m, 90s, or 2w`);
-  }
-  const num = match[1];
-  const unit = match[2];
-  const n = parseInt(num);
-  switch (unit) {
-    case "s":
-      return n * 1000;
-    case "m":
-      return n * 60 * 1000;
-    case "h":
-      return n * 60 * 60 * 1000;
-    case "d":
-      return n * 24 * 60 * 60 * 1000;
-    case "w":
-      return n * 7 * 24 * 60 * 60 * 1000;
-    default:
-      throw new Error(`Invalid duration unit: ${unit}`);
-  }
-}
-
 try {
   main();
 } catch (e) {
   if (e instanceof Error) {
-    console.error(`Error: ${e.message}`);
+    console.error(red(`Error: ${e.message}`));
   } else {
-    console.error("An unexpected error occurred");
+    console.error(red("An unexpected error occurred"));
   }
   process.exit(1);
 }