@nijaru/tk 0.0.1 → 0.0.2

package/src/db/storage.ts

@@ -45,10 +45,24 @@ function validatePathSafety(path: string, tasksDir: string): boolean {
     }
     return true;
   } catch {
-    return true;
+    // Fail closed: deny access on any error
+    return false;
   }
 }
 
+function isTaskOverdue(dueDate: string | null, status: Status): boolean {
+  if (!dueDate || status === "done") return false;
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  const parts = dueDate.split("-").map(Number);
+  const year = parts[0];
+  const month = parts[1];
+  const day = parts[2];
+  if (!year || !month || !day) return false;
+  const due = new Date(year, month - 1, day);
+  return due < today;
+}
+
 // --- Config Operations ---
 
 export function getConfig(): Config {
@@ -197,7 +211,10 @@ function readTaskFile(path: string, tasksDir?: string): Task | null {
   }
   try {
     const text = readFileSync(path, "utf-8");
-    return JSON.parse(text);
+    const parsed = JSON.parse(text);
+    // Validate structure to avoid crashes on malformed data
+    if (!isValidTaskStructure(parsed)) return null;
+    return parsed;
   } catch {
     return null;
   }
@@ -207,6 +224,134 @@ function writeTaskFile(path: string, task: Task): void {
   writeFileSync(path, JSON.stringify(task, null, 2));
 }
 
+/**
+ * Validate that a parsed object has the minimum required Task structure.
+ * Returns true if valid, false otherwise.
+ */
+function isValidTaskStructure(obj: unknown): obj is Task {
+  if (!obj || typeof obj !== "object") return false;
+  const t = obj as Record<string, unknown>;
+  return (
+    typeof t.project === "string" &&
+    typeof t.ref === "string" &&
+    typeof t.title === "string" &&
+    typeof t.status === "string" &&
+    Array.isArray(t.blocked_by)
+  );
+}
+
+/**
+ * Remove references to specific IDs from a task's blocked_by and parent fields.
+ * Returns true if the task was modified.
+ */
+function removeRefsFromTask(task: Task, shouldRemove: (id: string) => boolean): boolean {
+  let modified = false;
+
+  const originalLen = task.blocked_by.length;
+  task.blocked_by = task.blocked_by.filter((id) => !shouldRemove(id));
+  if (task.blocked_by.length !== originalLen) {
+    modified = true;
+  }
+
+  if (task.parent && shouldRemove(task.parent)) {
+    task.parent = null;
+    modified = true;
+  }
+
+  return modified;
+}
+
+// --- Auto-cleanup ---
+
+export interface CleanupInfo {
+  orphanedBlockers: string[];
+  orphanedParent: string | null;
+  idMismatch: { was: string; fixed: string } | null;
+}
+
+/**
+ * Clean orphaned references from a task. Returns info about what was cleaned.
+ * Writes to disk if any changes were made.
+ */
+function cleanTaskOrphans(
+  task: Task,
+  path: string,
+  expectedId: string,
+  tasksDir: string,
+): CleanupInfo {
+  const cleanup: CleanupInfo = {
+    orphanedBlockers: [],
+    orphanedParent: null,
+    idMismatch: null,
+  };
+
+  let modified = false;
+
+  // Check ID mismatch (filename vs content)
+  const actualId = taskId(task);
+  if (actualId !== expectedId) {
+    const parsed = parseId(expectedId);
+    if (parsed) {
+      cleanup.idMismatch = { was: actualId, fixed: expectedId };
+      task.project = parsed.project;
+      task.ref = parsed.ref;
+      modified = true;
+    }
+  }
+
+  // Check orphaned blocked_by references
+  const validBlockers: string[] = [];
+  for (const blockerId of task.blocked_by) {
+    if (existsSync(getTaskPath(tasksDir, blockerId))) {
+      validBlockers.push(blockerId);
+    } else {
+      cleanup.orphanedBlockers.push(blockerId);
+      modified = true;
+    }
+  }
+  if (cleanup.orphanedBlockers.length > 0) {
+    task.blocked_by = validBlockers;
+  }
+
+  // Check orphaned parent reference
+  if (task.parent && !existsSync(getTaskPath(tasksDir, task.parent))) {
+    cleanup.orphanedParent = task.parent;
+    task.parent = null;
+    modified = true;
+  }
+
+  // Write back if modified
+  if (modified) {
+    task.updated_at = new Date().toISOString();
+    writeTaskFile(path, task);
+  }
+
+  return cleanup;
+}
+
+function hasCleanup(info: CleanupInfo): boolean {
+  return (
+    info.orphanedBlockers.length > 0 || info.orphanedParent !== null || info.idMismatch !== null
+  );
+}
+
+export function formatCleanupMessage(taskId: string, info: CleanupInfo): string {
+  const parts: string[] = [];
+
+  if (info.orphanedBlockers.length > 0) {
+    const s = info.orphanedBlockers.length === 1 ? "reference" : "references";
+    parts.push(`${info.orphanedBlockers.length} orphaned ${s}`);
+  }
+  if (info.orphanedParent) {
+    parts.push("orphaned parent");
+  }
+  if (info.idMismatch) {
+    parts.push(`ID mismatch (was ${info.idMismatch.was})`);
+  }
+
+  return `(cleaned ${parts.join(", ")} from ${taskId})`;
+}
+
 function writeTaskFileExclusive(path: string, task: Task): boolean {
   try {
     writeFileSync(path, JSON.stringify(task, null, 2), { flag: "wx" });
@@ -351,7 +496,12 @@ export function createTask(options: CreateTaskOptions): Task & { id: string } {
   throw new Error(`Failed to create task after ${maxRetries} attempts`);
 }
 
-export function getTask(id: string): (Task & { id: string }) | null {
+export interface TaskResult {
+  task: Task & { id: string };
+  cleanup: CleanupInfo | null;
+}
+
+export function getTask(id: string): TaskResult | null {
   const tasksDir = getTasksDir();
   if (!existsSync(tasksDir)) return null;
 
@@ -359,10 +509,21 @@ export function getTask(id: string): (Task & { id: string }) | null {
   const task = readTaskFile(path, tasksDir);
   if (!task) return null;
 
-  return { ...task, id: taskId(task) };
+  // Auto-clean orphaned references
+  const cleanup = cleanTaskOrphans(task, path, id, tasksDir);
+
+  return {
+    task: { ...task, id: taskId(task) },
+    cleanup: hasCleanup(cleanup) ? cleanup : null,
+  };
+}
+
+export interface TaskWithMetaResult {
+  task: TaskWithMeta;
+  cleanup: CleanupInfo | null;
 }
 
-export function getTaskWithMeta(id: string): TaskWithMeta | null {
+export function getTaskWithMeta(id: string): TaskWithMetaResult | null {
   const tasksDir = getTasksDir();
   if (!existsSync(tasksDir)) return null;
 
@@ -370,7 +531,10 @@ export function getTaskWithMeta(id: string): TaskWithMeta | null {
   const task = readTaskFile(path, tasksDir);
   if (!task) return null;
 
-  // Check if any blockers are incomplete
+  // Auto-clean orphaned references
+  const cleanup = cleanTaskOrphans(task, path, id, tasksDir);
+
+  // Check if any blockers are incomplete (after cleanup, all blockers exist)
   let blockedByIncomplete = false;
   for (const blockerId of task.blocked_by) {
     const blockerTask = readTaskFile(getTaskPath(tasksDir, blockerId), tasksDir);
@@ -381,26 +545,14 @@ export function getTaskWithMeta(id: string): TaskWithMeta | null {
     }
   }
 
-  // Check if overdue (due date is before today, not including today)
-  let isOverdue = false;
-  if (task.due_date && task.status !== "done") {
-    const today = new Date();
-    today.setHours(0, 0, 0, 0);
-    const parts = task.due_date.split("-").map(Number);
-    const year = parts[0];
-    const month = parts[1];
-    const day = parts[2];
-    if (year && month && day) {
-      const dueDate = new Date(year, month - 1, day);
-      isOverdue = dueDate < today;
-    }
-  }
-
   return {
-    ...task,
-    id: taskId(task),
-    blocked_by_incomplete: blockedByIncomplete,
-    is_overdue: isOverdue,
+    task: {
+      ...task,
+      id: taskId(task),
+      blocked_by_incomplete: blockedByIncomplete,
+      is_overdue: isTaskOverdue(task.due_date, task.status),
+    },
+    cleanup: hasCleanup(cleanup) ? cleanup : null,
   };
 }
 
@@ -445,18 +597,7 @@ export function listTasks(options?: ListOptions): (Task & { id: string })[] {
     tasks = tasks.filter((t) => t.parent === null);
   }
   if (options?.overdue) {
-    const today = new Date();
-    today.setHours(0, 0, 0, 0);
-    tasks = tasks.filter((t) => {
-      if (!t.due_date || t.status === "done") return false;
-      const parts = t.due_date.split("-").map(Number);
-      const year = parts[0];
-      const month = parts[1];
-      const day = parts[2];
-      if (!year || !month || !day) return false;
-      const dueDate = new Date(year, month - 1, day);
-      return dueDate < today;
-    });
+    tasks = tasks.filter((t) => isTaskOverdue(t.due_date, t.status));
   }
 
   // Sort by priority (lower = more urgent), then created_at (newer first)
@@ -476,20 +617,33 @@ export function listReadyTasks(): (Task & { id: string })[] {
   const tasksDir = getTasksDir();
   if (!existsSync(tasksDir)) return [];
 
-  const openTasks = listTasks({ status: "open" });
-
-  const readyTasks = openTasks.filter((task) => {
-    for (const blockerId of task.blocked_by) {
-      const blockerTask = readTaskFile(getTaskPath(tasksDir, blockerId), tasksDir);
-      if (!blockerTask) continue;
-      if (blockerTask.status !== "done") {
-        return false;
+  // Get all tasks once and build status map for O(1) blocker lookups
+  const allTasks = getAllTasks(tasksDir);
+  const statusMap = new Map<string, Status>();
+  for (const task of allTasks) {
+    statusMap.set(taskId(task), task.status);
+  }
+
+  // Filter to open tasks that have no incomplete blockers
+  const readyTasks = allTasks
+    .filter((task) => task.status === "open")
+    .filter((task) => {
+      for (const blockerId of task.blocked_by) {
+        const blockerStatus = statusMap.get(blockerId);
+        // Missing blocker (orphaned ref) doesn't block
+        if (!blockerStatus) continue;
+        if (blockerStatus !== "done") return false;
       }
-    }
-    return true;
+      return true;
+    });
+
+  // Sort by priority (lower = more urgent), then created_at (newer first)
+  readyTasks.sort((a, b) => {
+    if (a.priority !== b.priority) return a.priority - b.priority;
+    return new Date(b.created_at).getTime() - new Date(a.created_at).getTime();
   });
 
-  return readyTasks;
+  return readyTasks.map((t) => ({ ...t, id: taskId(t) }));
 }
 
 export function updateTaskStatus(id: string, status: Status): (Task & { id: string }) | null {
@@ -546,11 +700,11 @@ export function deleteTask(id: string): boolean {
 
   unlinkSync(path);
 
-  // Remove this task from all blocked_by arrays
+  // Remove this task from all blocked_by arrays and parent references
   const allTasks = getAllTasks(tasksDir);
   for (const task of allTasks) {
-    if (task.blocked_by.includes(id)) {
-      task.blocked_by = task.blocked_by.filter((b) => b !== id);
+    const modified = removeRefsFromTask(task, (ref) => ref === id);
+    if (modified) {
       writeTaskFile(getTaskPath(tasksDir, taskId(task)), task);
     }
   }
@@ -560,8 +714,7 @@ export function deleteTask(id: string): boolean {
 
 export interface CleanOptions {
   olderThanMs?: number;
-  status?: Status;
-  all?: boolean;
+  force?: boolean; // ignore age threshold
 }
 
 export function cleanTasks(options: CleanOptions): number {
@@ -569,16 +722,15 @@ export function cleanTasks(options: CleanOptions): number {
   if (!existsSync(tasksDir)) return 0;
 
   const tasks = getAllTasks(tasksDir);
-  const cutoff = options.olderThanMs ? Date.now() - options.olderThanMs : 0;
+  // Clamp cutoff to prevent negative values from very large olderThanMs
+  const cutoff = options.olderThanMs ? Math.max(0, Date.now() - options.olderThanMs) : 0;
 
   const toDelete: string[] = [];
 
   for (const task of tasks) {
-    const validStatus = options.status ? task.status === options.status : task.status === "done";
+    if (task.status !== "done") continue;
 
-    if (!validStatus) continue;
-
-    if (!options.all && cutoff > 0) {
+    if (!options.force && cutoff > 0) {
       if (!task.completed_at) continue;
       if (new Date(task.completed_at).getTime() >= cutoff) continue;
     }
@@ -590,13 +742,13 @@ export function cleanTasks(options: CleanOptions): number {
     unlinkSync(getTaskPath(tasksDir, id));
   }
 
-  // Clean up dangling blocked_by references
+  // Clean up dangling blocked_by and parent references
   if (toDelete.length > 0) {
+    const toDeleteSet = new Set(toDelete);
     const remaining = getAllTasks(tasksDir);
     for (const task of remaining) {
-      const original = task.blocked_by.length;
-      task.blocked_by = task.blocked_by.filter((b) => !toDelete.includes(b));
-      if (task.blocked_by.length !== original) {
+      const modified = removeRefsFromTask(task, (id) => toDeleteSet.has(id));
+      if (modified) {
         writeTaskFile(getTaskPath(tasksDir, taskId(task)), task);
       }
     }
@@ -628,13 +780,6 @@ export function addLogEntry(taskIdStr: string, message: string): LogEntry {
   return entry;
 }
 
-export function getLogEntries(taskIdStr: string): LogEntry[] {
-  const tasksDir = getTasksDir();
-  const path = getTaskPath(tasksDir, taskIdStr);
-  const task = readTaskFile(path, tasksDir);
-  return task?.logs ?? [];
-}
-
 // --- Block Operations ---
 
 export function addBlock(taskIdStr: string, blockedBy: string): { ok: boolean; error?: string } {
@@ -682,25 +827,8 @@ export function removeBlock(taskIdStr: string, blockedBy: string): boolean {
   return true;
 }
 
-export function getBlockers(taskIdStr: string): string[] {
-  const tasksDir = getTasksDir();
-  const task = readTaskFile(getTaskPath(tasksDir, taskIdStr), tasksDir);
-  return task?.blocked_by ?? [];
-}
-
-export function getBlocking(taskIdStr: string): string[] {
-  const tasksDir = getTasksDir();
-  const allTasks = getAllTasks(tasksDir);
-  return allTasks.filter((t) => t.blocked_by.includes(taskIdStr)).map((t) => taskId(t));
-}
-
 // --- Utility ---
 
-export function tasksExist(): boolean {
-  const tasksDir = getTasksDir();
-  return existsSync(tasksDir);
-}
-
 export function initTasks(project?: string): string {
   const tasksDir = ensureTasksDir();
   const config = getConfig();
@@ -765,13 +893,100 @@ export function resolveId(input: string): string | null {
     return matches[0];
   }
 
-  // No match or ambiguous
   return null;
 }
 
+export function findMatchingIds(input: string): string[] {
+  const tasksDir = getTasksDir();
+  if (!existsSync(tasksDir)) return [];
+
+  const inputLower = input.toLowerCase();
+  const files = readdirSync(tasksDir);
+  const matches: string[] = [];
+
+  for (const file of files) {
+    if (!file.endsWith(".json") || file === "config.json") continue;
+    const id = file.slice(0, -5);
+    if (!parseId(id)) continue;
+    const ref = id.split("-")[1] ?? "";
+    if (id.startsWith(inputLower) || ref.startsWith(inputLower)) {
+      matches.push(id);
+    }
+  }
+
+  return matches;
+}
+
+// --- Health Check ---
+
+export interface CheckResult {
+  totalTasks: number;
+  cleaned: { task: string; info: CleanupInfo }[];
+  unfixable: { file: string; error: string }[];
+}
+
 /**
- * Validate that an ID is in the correct format.
+ * Run health check on all tasks.
+ * Auto-fixes orphaned refs/ID mismatches and reports unfixable issues.
  */
-export function isValidId(id: string): boolean {
-  return parseId(id) !== null;
+export function checkTasks(): CheckResult {
+  const tasksDir = getTasksDir();
+  const result: CheckResult = {
+    totalTasks: 0,
+    cleaned: [],
+    unfixable: [],
+  };
+
+  if (!existsSync(tasksDir)) return result;
+
+  const files = readdirSync(tasksDir).filter((f) => f.endsWith(".json") && f !== "config.json");
+
+  for (const file of files) {
+    const expectedId = file.slice(0, -5);
+
+    // Warn about unexpected files (non-task JSON)
+    if (!parseId(expectedId)) {
+      result.unfixable.push({
+        file,
+        error: "Invalid task ID format in filename",
+      });
+      continue;
+    }
+
+    const path = join(tasksDir, file);
+
+    // Try to read and parse
+    let parsed: unknown;
+    try {
+      const text = readFileSync(path, "utf-8");
+      parsed = JSON.parse(text);
+    } catch (e) {
+      // Corrupted JSON - unfixable
+      result.unfixable.push({
+        file,
+        error: e instanceof Error ? e.message : "Invalid JSON",
+      });
+      continue;
+    }
+
+    // Validate task structure
+    if (!isValidTaskStructure(parsed)) {
+      result.unfixable.push({
+        file,
+        error: "Invalid task structure (missing required fields)",
+      });
+      continue;
+    }
+
+    const task = parsed;
+    result.totalTasks++;
+
+    // Auto-clean (same as getTask does)
+    const cleanup = cleanTaskOrphans(task, path, expectedId, tasksDir);
+    if (hasCleanup(cleanup)) {
+      result.cleaned.push({ task: expectedId, info: cleanup });
+    }
+  }
+
+  return result;
 }

package/src/lib/completions.ts

@@ -12,7 +12,7 @@ _tk() {
     local cur prev words cword
     _init_completion || return
 
-    local commands="init add ls list ready show start done reopen edit log block unblock rm remove clean config completions help"
+    local commands="init add ls list ready show start done reopen edit log block unblock rm remove clean check config completions help"
     local global_opts="--json --help -h --version -V"
 
     # Find the command (first non-option word after 'tk')
@@ -85,7 +85,7 @@ _tk() {
             ;;
         clean)
             if [[ "$cur" == -* ]]; then
-                COMPREPLY=($(compgen -W "--older-than --done -a --all --json" -- "$cur"))
+                COMPREPLY=($(compgen -W "--older-than -f --force --json" -- "$cur"))
             fi
             ;;
         config)
@@ -142,6 +142,7 @@ _tk() {
         'rm:Delete task'
         'remove:Delete task'
         'clean:Remove old done tasks'
+        'check:Check task integrity'
         'config:Show/set configuration'
         'completions:Output shell completions'
         'help:Show help'
@@ -233,9 +234,12 @@ _tk() {
                     ;;
                 clean)
                     _arguments \\
-                        '--older-than[Duration]:duration:' \\
-                        '--done[Only done tasks]' \\
-                        '(-a --all)'{-a,--all}'[All statuses]' \\
+                        '--older-than[Days]:days:' \\
+                        '(-f --force)'{-f,--force}'[Force clean even if disabled]' \\
+                        '--json[Output as JSON]'
+                    ;;
+                check)
+                    _arguments \\
                         '--json[Output as JSON]'
                     ;;
                 config)
@@ -331,6 +335,7 @@ complete -c tk -n __tk_needs_command -f -a unblock -d 'Remove blocker'
 complete -c tk -n __tk_needs_command -f -a rm -d 'Delete task'
 complete -c tk -n __tk_needs_command -f -a remove -d 'Delete task'
 complete -c tk -n __tk_needs_command -f -a clean -d 'Remove old done tasks'
+complete -c tk -n __tk_needs_command -f -a check -d 'Check task integrity'
 complete -c tk -n __tk_needs_command -f -a config -d 'Show/set configuration'
 complete -c tk -n __tk_needs_command -f -a completions -d 'Output shell completions'
 complete -c tk -n __tk_needs_command -f -a help -d 'Show help'
@@ -401,11 +406,13 @@ complete -c tk -n '__tk_using_command unblock' -l json -d 'Output as JSON'
 complete -c tk -n '__tk_using_command log' -l json -d 'Output as JSON'
 
 # clean command
-complete -c tk -n '__tk_using_command clean' -l older-than -d 'Duration (e.g., 7d, 24h)'
-complete -c tk -n '__tk_using_command clean' -l done -d 'Only done tasks'
-complete -c tk -n '__tk_using_command clean' -s a -l all -d 'All statuses'
+complete -c tk -n '__tk_using_command clean' -l older-than -d 'Days threshold'
+complete -c tk -n '__tk_using_command clean' -s f -l force -d 'Force clean even if disabled'
 complete -c tk -n '__tk_using_command clean' -l json -d 'Output as JSON'
 
+# check command
+complete -c tk -n '__tk_using_command check' -l json -d 'Output as JSON'
+
 # config command
 complete -c tk -n '__tk_using_command config' -f -a 'project alias' -d 'Config option'
 complete -c tk -n '__tk_using_command config' -l rm -d 'Remove alias'

package/src/lib/format.ts

@@ -2,6 +2,12 @@ import type { Task, TaskWithMeta, LogEntry } from "../types";
 import { PRIORITY_COLORS, STATUS_COLORS, OVERDUE_COLOR, RESET } from "../types";
 import { formatPriority } from "./priority";
 
+// Message colors
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const DIM = "\x1b[2m";
+
 /**
  * Determines if color output should be used.
  * Respects NO_COLOR env var (https://no-color.org/) and TTY detection.
@@ -16,6 +22,26 @@ export function shouldUseColor(): boolean {
   return true;
 }
 
+/** Format text green (success) */
+export function green(msg: string): string {
+  return shouldUseColor() ? `${GREEN}${msg}${RESET}` : msg;
+}
+
+/** Format text red (error) */
+export function red(msg: string): string {
+  return shouldUseColor() ? `${RED}${msg}${RESET}` : msg;
+}
+
+/** Format text yellow (warning) */
+export function yellow(msg: string): string {
+  return shouldUseColor() ? `${YELLOW}${msg}${RESET}` : msg;
+}
+
+/** Format text dim/muted */
+export function dim(msg: string): string {
+  return shouldUseColor() ? `${DIM}${msg}${RESET}` : msg;
+}
+
 function formatId(id: string): string {
   // Truncate project prefix to 6 chars, keep full 4-char ref
   // "myproject-a1b2" -> "myproj-a1b2"

package/src/types.ts

@@ -81,7 +81,7 @@ export interface Config {
     assignees: string[];
   };
   aliases: Record<string, string>; // alias -> path for auto-project detection
-  auto_project: boolean;
+  clean_after: number | false; // days to keep done tasks, or false to disable
 }
 
 export const DEFAULT_CONFIG: Config = {
@@ -93,7 +93,7 @@ export const DEFAULT_CONFIG: Config = {
     assignees: [],
   },
   aliases: {},
-  auto_project: false,
+  clean_after: 14,
 };
 
 export const PRIORITY_LABELS: Record<Priority, string> = {