@nijaru/tk 0.0.1

package/src/db/storage.ts

@@ -0,0 +1,777 @@
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  unlinkSync,
+  readFileSync,
+  writeFileSync,
+  realpathSync,
+  lstatSync,
+} from "fs";
+import { join, resolve, basename } from "path";
+import { getTasksDir, getWorkingDir } from "../lib/root";
+import type { Task, Config, Status, Priority, TaskWithMeta, LogEntry } from "../types";
+import { DEFAULT_CONFIG, taskId, parseId, generateRef } from "../types";
+
+// --- Path Utilities ---
+
+function ensureTasksDir(): string {
+  const tasksDir = getTasksDir();
+  if (!existsSync(tasksDir)) {
+    mkdirSync(tasksDir, { recursive: true });
+  }
+  return tasksDir;
+}
+
+function getTaskPath(tasksDir: string, id: string): string {
+  return join(tasksDir, `${id}.json`);
+}
+
+function getConfigPath(tasksDir: string): string {
+  return join(tasksDir, "config.json");
+}
+
+function validatePathSafety(path: string, tasksDir: string): boolean {
+  try {
+    if (existsSync(path)) {
+      const stats = lstatSync(path);
+      if (stats.isSymbolicLink()) {
+        const realPath = realpathSync(path);
+        const resolvedTasksDir = resolve(tasksDir);
+        if (!realPath.startsWith(resolvedTasksDir)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  } catch {
+    return true;
+  }
+}
+
+// --- Config Operations ---
+
+export function getConfig(): Config {
+  const tasksDir = getTasksDir();
+  const configPath = getConfigPath(tasksDir);
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const text = readFileSync(configPath, "utf-8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(text) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function saveConfig(config: Config): void {
+  const tasksDir = ensureTasksDir();
+  const configPath = getConfigPath(tasksDir);
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+export function updateConfig(updates: Partial<Config>): Config {
+  const config = getConfig();
+  Object.assign(config, updates);
+  saveConfig(config);
+  return config;
+}
+
+export function setDefaultProject(project: string): Config {
+  return updateConfig({ project });
+}
+
+export interface RenameResult {
+  renamed: string[];
+  referencesUpdated: number;
+}
+
+export function renameProject(oldProject: string, newProject: string): RenameResult {
+  const tasksDir = getTasksDir();
+  if (!existsSync(tasksDir)) {
+    throw new Error("No .tasks/ directory found");
+  }
+
+  const allTasks = getAllTasks(tasksDir);
+
+  // Find tasks to rename
+  const toRename = allTasks.filter((t) => t.project === oldProject);
+  if (toRename.length === 0) {
+    throw new Error(`No tasks found with project "${oldProject}"`);
+  }
+
+  // Check for collisions
+  const existingIds = new Set(allTasks.map((t) => taskId(t)));
+  for (const task of toRename) {
+    const newId = `${newProject}-${task.ref}`;
+    if (existingIds.has(newId)) {
+      throw new Error(`Cannot rename: "${newId}" already exists`);
+    }
+  }
+
+  // Build old→new ID mapping
+  const idMap = new Map<string, string>();
+  for (const task of toRename) {
+    const oldId = taskId(task);
+    const newId = `${newProject}-${task.ref}`;
+    idMap.set(oldId, newId);
+  }
+
+  // Update references in ALL tasks and rename files
+  let referencesUpdated = 0;
+  for (const task of allTasks) {
+    let modified = false;
+
+    // Update blocked_by references
+    if (task.blocked_by.length > 0) {
+      const newBlockedBy = task.blocked_by.map((id) => {
+        const newId = idMap.get(id);
+        if (newId) {
+          referencesUpdated++;
+          return newId;
+        }
+        return id;
+      });
+      if (newBlockedBy.some((id, i) => id !== task.blocked_by[i])) {
+        task.blocked_by = newBlockedBy;
+        modified = true;
+      }
+    }
+
+    // Update parent reference
+    if (task.parent && idMap.has(task.parent)) {
+      task.parent = idMap.get(task.parent)!;
+      referencesUpdated++;
+      modified = true;
+    }
+
+    // If this task is being renamed
+    if (task.project === oldProject) {
+      const oldPath = getTaskPath(tasksDir, taskId(task));
+      task.project = newProject;
+      const newPath = getTaskPath(tasksDir, taskId(task));
+
+      // Write to new path, delete old
+      writeFileSync(newPath, JSON.stringify(task, null, 2));
+      unlinkSync(oldPath);
+    } else if (modified) {
+      // Just update references in non-renamed task
+      const path = getTaskPath(tasksDir, taskId(task));
+      writeFileSync(path, JSON.stringify(task, null, 2));
+    }
+  }
+
+  // Update default project in config
+  const config = getConfig();
+  if (config.project === oldProject) {
+    updateConfig({ project: newProject });
+  }
+
+  return {
+    renamed: toRename.map((t) => `${newProject}-${t.ref}`),
+    referencesUpdated,
+  };
+}
+
+export function setAlias(alias: string, path: string): Config {
+  const config = getConfig();
+  config.aliases[alias] = path;
+  saveConfig(config);
+  return config;
+}
+
+export function removeAlias(alias: string): Config {
+  const config = getConfig();
+  delete config.aliases[alias];
+  saveConfig(config);
+  return config;
+}
+
+// --- Task File Operations ---
+
+function readTaskFile(path: string, tasksDir?: string): Task | null {
+  if (!existsSync(path)) return null;
+  if (tasksDir && !validatePathSafety(path, tasksDir)) {
+    return null;
+  }
+  try {
+    const text = readFileSync(path, "utf-8");
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function writeTaskFile(path: string, task: Task): void {
+  writeFileSync(path, JSON.stringify(task, null, 2));
+}
+
+function writeTaskFileExclusive(path: string, task: Task): boolean {
+  try {
+    writeFileSync(path, JSON.stringify(task, null, 2), { flag: "wx" });
+    return true;
+  } catch (e) {
+    if (e instanceof Error && "code" in e && e.code === "EEXIST") {
+      return false;
+    }
+    throw e;
+  }
+}
+
+function getAllTasks(tasksDir: string): Task[] {
+  if (!existsSync(tasksDir)) return [];
+  const files = readdirSync(tasksDir).filter((f) => f.endsWith(".json") && f !== "config.json");
+  const tasks: Task[] = [];
+  for (const file of files) {
+    const task = readTaskFile(join(tasksDir, file), tasksDir);
+    if (task) tasks.push(task);
+  }
+  return tasks;
+}
+
+// --- Cycle Detection ---
+
+function wouldCreateBlockCycle(tasksDir: string, taskIdStr: string, blockerId: string): boolean {
+  const visited = new Set<string>();
+  const stack = [blockerId];
+
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    if (current === taskIdStr) return true;
+    if (visited.has(current)) continue;
+    visited.add(current);
+
+    const task = readTaskFile(getTaskPath(tasksDir, current), tasksDir);
+    if (task) {
+      for (const dep of task.blocked_by) {
+        stack.push(dep);
+      }
+    }
+  }
+  return false;
+}
+
+function wouldCreateParentCycle(tasksDir: string, taskIdStr: string, parentId: string): boolean {
+  const visited = new Set<string>();
+  let current: string | null = parentId;
+
+  while (current) {
+    if (current === taskIdStr) return true;
+    if (visited.has(current)) return true;
+    visited.add(current);
+
+    const task = readTaskFile(getTaskPath(tasksDir, current), tasksDir);
+    current = task?.parent ?? null;
+  }
+  return false;
+}
+
+// --- Parent Validation ---
+
+export function validateParent(
+  parentId: string,
+  currentTaskId?: string,
+): { ok: boolean; error?: string } {
+  if (!parseId(parentId)) {
+    return { ok: false, error: `Invalid parent ID format: ${parentId}` };
+  }
+
+  if (currentTaskId && parentId === currentTaskId) {
+    return { ok: false, error: "Task cannot be its own parent" };
+  }
+
+  const tasksDir = getTasksDir();
+
+  const parentPath = getTaskPath(tasksDir, parentId);
+  if (!existsSync(parentPath)) {
+    return { ok: false, error: `Parent task not found: ${parentId}` };
+  }
+
+  if (currentTaskId && wouldCreateParentCycle(tasksDir, currentTaskId, parentId)) {
+    return { ok: false, error: "Would create circular parent relationship" };
+  }
+
+  return { ok: true };
+}
+
+// --- Task CRUD ---
+
+export interface CreateTaskOptions {
+  title: string;
+  description?: string;
+  priority?: Priority;
+  project?: string;
+  labels?: string[];
+  assignees?: string[];
+  parent?: string;
+  estimate?: number;
+  due_date?: string;
+}
+
+export function createTask(options: CreateTaskOptions): Task & { id: string } {
+  const tasksDir = ensureTasksDir();
+  const config = getConfig();
+  const project = options.project ?? config.project;
+  const now = new Date().toISOString();
+
+  // Generate random ref with collision detection
+  const maxRetries = 10;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    const ref = generateRef();
+    const id = `${project}-${ref}`;
+
+    const task: Task = {
+      project,
+      ref,
+      title: options.title,
+      description: options.description ?? null,
+      status: "open",
+      priority: options.priority ?? config.defaults.priority,
+      labels: options.labels ?? [...config.defaults.labels],
+      assignees: options.assignees ?? [...config.defaults.assignees],
+      parent: options.parent ?? null,
+      blocked_by: [],
+      estimate: options.estimate ?? null,
+      due_date: options.due_date ?? null,
+      logs: [],
+      created_at: now,
+      updated_at: now,
+      completed_at: null,
+      external: {},
+    };
+
+    const path = getTaskPath(tasksDir, id);
+    if (writeTaskFileExclusive(path, task)) {
+      return { ...task, id };
+    }
+    // Collision (extremely rare with 4 chars) - retry with new ref
+  }
+
+  throw new Error(`Failed to create task after ${maxRetries} attempts`);
+}
+
+export function getTask(id: string): (Task & { id: string }) | null {
+  const tasksDir = getTasksDir();
+  if (!existsSync(tasksDir)) return null;
+
+  const path = getTaskPath(tasksDir, id);
+  const task = readTaskFile(path, tasksDir);
+  if (!task) return null;
+
+  return { ...task, id: taskId(task) };
+}
+
+export function getTaskWithMeta(id: string): TaskWithMeta | null {
+  const tasksDir = getTasksDir();
+  if (!existsSync(tasksDir)) return null;
+
+  const path = getTaskPath(tasksDir, id);
+  const task = readTaskFile(path, tasksDir);
+  if (!task) return null;
+
+  // Check if any blockers are incomplete
+  let blockedByIncomplete = false;
+  for (const blockerId of task.blocked_by) {
+    const blockerTask = readTaskFile(getTaskPath(tasksDir, blockerId), tasksDir);
+    if (!blockerTask) continue;
+    if (blockerTask.status !== "done") {
+      blockedByIncomplete = true;
+      break;
+    }
+  }
+
+  // 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,
+  };
+}
+
+export interface ListOptions {
+  status?: Status;
+  priority?: Priority;
+  project?: string;
+  label?: string;
+  assignee?: string;
+  parent?: string;
+  roots?: boolean;
+  overdue?: boolean;
+  limit?: number;
+}
+
+export function listTasks(options?: ListOptions): (Task & { id: string })[] {
+  const tasksDir = getTasksDir();
+  if (!existsSync(tasksDir)) return [];
+
+  let tasks = getAllTasks(tasksDir);
+
+  // Apply filters
+  if (options?.status) {
+    tasks = tasks.filter((t) => t.status === options.status);
+  }
+  if (options?.priority !== undefined) {
+    tasks = tasks.filter((t) => t.priority === options.priority);
+  }
+  if (options?.project) {
+    tasks = tasks.filter((t) => t.project === options.project);
+  }
+  if (options?.label) {
+    tasks = tasks.filter((t) => t.labels.includes(options.label!));
+  }
+  if (options?.assignee) {
+    tasks = tasks.filter((t) => t.assignees.includes(options.assignee!));
+  }
+  if (options?.parent) {
+    tasks = tasks.filter((t) => t.parent === options.parent);
+  }
+  if (options?.roots) {
+    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;
+    });
+  }
+
+  // Sort by priority (lower = more urgent), then created_at (newer first)
+  tasks.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();
+  });
+
+  if (options?.limit) {
+    tasks = tasks.slice(0, options.limit);
+  }
+
+  return tasks.map((t) => ({ ...t, id: taskId(t) }));
+}
+
+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;
+      }
+    }
+    return true;
+  });
+
+  return readyTasks;
+}
+
+export function updateTaskStatus(id: string, status: Status): (Task & { id: string }) | null {
+  const tasksDir = getTasksDir();
+  const path = getTaskPath(tasksDir, id);
+  const task = readTaskFile(path, tasksDir);
+  if (!task) return null;
+
+  const now = new Date().toISOString();
+  task.status = status;
+  task.updated_at = now;
+  task.completed_at = status === "done" ? now : null;
+
+  writeTaskFile(path, task);
+  return { ...task, id: taskId(task) };
+}
+
+export interface UpdateTaskOptions {
+  title?: string;
+  description?: string;
+  priority?: Priority;
+  labels?: string[];
+  assignees?: string[];
+  parent?: string | null;
+  estimate?: number | null;
+  due_date?: string | null;
+}
+
+export function updateTask(id: string, updates: UpdateTaskOptions): (Task & { id: string }) | null {
+  const tasksDir = getTasksDir();
+  const path = getTaskPath(tasksDir, id);
+  const task = readTaskFile(path, tasksDir);
+  if (!task) return null;
+
+  const now = new Date().toISOString();
+  if (updates.title !== undefined) task.title = updates.title;
+  if (updates.description !== undefined) task.description = updates.description;
+  if (updates.priority !== undefined) task.priority = updates.priority;
+  if (updates.labels !== undefined) task.labels = updates.labels;
+  if (updates.assignees !== undefined) task.assignees = updates.assignees;
+  if (updates.parent !== undefined) task.parent = updates.parent;
+  if (updates.estimate !== undefined) task.estimate = updates.estimate;
+  if (updates.due_date !== undefined) task.due_date = updates.due_date;
+  task.updated_at = now;
+
+  writeTaskFile(path, task);
+  return { ...task, id: taskId(task) };
+}
+
+export function deleteTask(id: string): boolean {
+  const tasksDir = getTasksDir();
+  const path = getTaskPath(tasksDir, id);
+  if (!existsSync(path)) return false;
+
+  unlinkSync(path);
+
+  // Remove this task from all blocked_by arrays
+  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);
+      writeTaskFile(getTaskPath(tasksDir, taskId(task)), task);
+    }
+  }
+
+  return true;
+}
+
+export interface CleanOptions {
+  olderThanMs?: number;
+  status?: Status;
+  all?: boolean;
+}
+
+export function cleanTasks(options: CleanOptions): number {
+  const tasksDir = getTasksDir();
+  if (!existsSync(tasksDir)) return 0;
+
+  const tasks = getAllTasks(tasksDir);
+  const cutoff = options.olderThanMs ? 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 (!validStatus) continue;
+
+    if (!options.all && cutoff > 0) {
+      if (!task.completed_at) continue;
+      if (new Date(task.completed_at).getTime() >= cutoff) continue;
+    }
+
+    toDelete.push(taskId(task));
+  }
+
+  for (const id of toDelete) {
+    unlinkSync(getTaskPath(tasksDir, id));
+  }
+
+  // Clean up dangling blocked_by references
+  if (toDelete.length > 0) {
+    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) {
+        writeTaskFile(getTaskPath(tasksDir, taskId(task)), task);
+      }
+    }
+  }
+
+  return toDelete.length;
+}
+
+// --- Log Operations ---
+
+export function addLogEntry(taskIdStr: string, message: string): LogEntry {
+  const tasksDir = getTasksDir();
+  const path = getTaskPath(tasksDir, taskIdStr);
+  const task = readTaskFile(path, tasksDir);
+  if (!task) {
+    throw new Error(`Task not found: ${taskIdStr}`);
+  }
+
+  const now = new Date().toISOString();
+  const entry: LogEntry = {
+    ts: now,
+    msg: message,
+  };
+
+  task.logs.push(entry);
+  task.updated_at = now;
+  writeTaskFile(path, task);
+
+  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 } {
+  const tasksDir = ensureTasksDir();
+  const taskPath = getTaskPath(tasksDir, taskIdStr);
+  const blockerPath = getTaskPath(tasksDir, blockedBy);
+
+  const task = readTaskFile(taskPath, tasksDir);
+  if (!task) {
+    return { ok: false, error: `Task not found: ${taskIdStr}` };
+  }
+
+  if (!existsSync(blockerPath)) {
+    return { ok: false, error: `Blocker not found: ${blockedBy}` };
+  }
+
+  if (task.blocked_by.includes(blockedBy)) {
+    return { ok: false, error: "Already blocked by this task" };
+  }
+
+  if (wouldCreateBlockCycle(tasksDir, taskIdStr, blockedBy)) {
+    return { ok: false, error: "Would create circular dependency" };
+  }
+
+  task.blocked_by.push(blockedBy);
+  task.updated_at = new Date().toISOString();
+  writeTaskFile(taskPath, task);
+
+  return { ok: true };
+}
+
+export function removeBlock(taskIdStr: string, blockedBy: string): boolean {
+  const tasksDir = getTasksDir();
+  const taskPath = getTaskPath(tasksDir, taskIdStr);
+  const task = readTaskFile(taskPath, tasksDir);
+  if (!task) return false;
+
+  const idx = task.blocked_by.indexOf(blockedBy);
+  if (idx === -1) return false;
+
+  task.blocked_by.splice(idx, 1);
+  task.updated_at = new Date().toISOString();
+  writeTaskFile(taskPath, task);
+
+  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();
+
+  // Derive project from directory name if not specified
+  if (project) {
+    config.project = project;
+  } else if (config.project === DEFAULT_CONFIG.project) {
+    // Only auto-derive if still using default "tk"
+    const dirName = basename(getWorkingDir());
+    // Sanitize: lowercase, replace non-alphanumeric with empty, ensure starts with letter
+    const sanitized = dirName.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (sanitized && /^[a-z]/.test(sanitized)) {
+      config.project = sanitized;
+    }
+  }
+  saveConfig(config);
+  return tasksDir;
+}
+
+// --- ID Resolution ---
+
+/**
+ * Resolve a partial ID to a full ID.
+ * Matches by prefix - if input matches start of exactly one task ID, returns it.
+ * Returns null if no match or ambiguous (multiple matches).
+ *
+ * Optimized: only reads filenames, not file contents.
+ */
+export function resolveId(input: string): string | null {
+  const tasksDir = getTasksDir();
+  if (!existsSync(tasksDir)) return null;
+
+  // If it's already a full valid ID, check if task exists
+  if (parseId(input)) {
+    if (existsSync(getTaskPath(tasksDir, input))) {
+      return input;
+    }
+  }
+
+  const inputLower = input.toLowerCase();
+
+  // Read filenames only (no file content parsing)
+  const files = readdirSync(tasksDir);
+  const matches: string[] = [];
+
+  for (const file of files) {
+    if (!file.endsWith(".json") || file === "config.json") continue;
+
+    // Extract ID from filename: "project-ref.json" -> "project-ref"
+    const id = file.slice(0, -5);
+    if (!parseId(id)) continue;
+
+    // Match by full ID prefix or just ref prefix
+    const ref = id.split("-")[1] ?? "";
+    if (id.startsWith(inputLower) || ref.startsWith(inputLower)) {
+      matches.push(id);
+    }
+  }
+
+  if (matches.length === 1 && matches[0]) {
+    return matches[0];
+  }
+
+  // No match or ambiguous
+  return null;
+}
+
+/**
+ * Validate that an ID is in the correct format.
+ */
+export function isValidId(id: string): boolean {
+  return parseId(id) !== null;
+}