@nijaru/tk 0.0.1

package/src/lib/root.ts

@@ -0,0 +1,79 @@
+import { existsSync } from "fs";
+import { join, dirname, resolve } from "path";
+
+const TASKS_DIR = ".tasks";
+const GIT_DIR = ".git";
+
+// Global override for working directory (set via -C flag)
+let workingDir: string | null = null;
+
+export function setWorkingDir(dir: string | null): void {
+  workingDir = dir ? resolve(dir) : null;
+}
+
+export function getWorkingDir(): string {
+  return workingDir ?? process.cwd();
+}
+
+export interface RootInfo {
+  root: string;
+  tasksDir: string;
+  exists: boolean;
+}
+
+/**
+ * Find the project root by walking up directories.
+ * Looks for existing .tasks/ or .git/ directory.
+ * Returns cwd if neither found.
+ */
+export function findRoot(): RootInfo {
+  let current = getWorkingDir();
+
+  while (true) {
+    const tasksPath = join(current, TASKS_DIR);
+    if (existsSync(tasksPath)) {
+      return { root: current, tasksDir: tasksPath, exists: true };
+    }
+
+    const gitPath = join(current, GIT_DIR);
+    if (existsSync(gitPath)) {
+      return {
+        root: current,
+        tasksDir: join(current, TASKS_DIR),
+        exists: false,
+      };
+    }
+
+    const parent = dirname(current);
+    if (parent === current) break; // Reached filesystem root
+    current = parent;
+  }
+
+  // No .git or .tasks found, use working dir
+  const wd = getWorkingDir();
+  return {
+    root: wd,
+    tasksDir: join(wd, TASKS_DIR),
+    exists: false,
+  };
+}
+
+/**
+ * Get the tasks directory path, optionally requiring it to exist.
+ */
+export function getTasksDir(requireExists = false): string {
+  const info = findRoot();
+  if (requireExists && !info.exists) {
+    throw new TasksNotFoundError(info.root);
+  }
+  return info.tasksDir;
+}
+
+export class TasksNotFoundError extends Error {
+  constructor(searchedFrom: string) {
+    super(
+      `No .tasks/ directory found. Run 'tk add' to create one, or initialize with 'tk init'.\nSearched from: ${searchedFrom}`,
+    );
+    this.name = "TasksNotFoundError";
+  }
+}

package/src/types.ts

@@ -0,0 +1,130 @@
+export type Status = "open" | "active" | "done";
+export type Priority = 0 | 1 | 2 | 3 | 4;
+
+export interface LogEntry {
+  ts: string; // ISO 8601 timestamp
+  msg: string;
+}
+
+export interface ExternalLink {
+  number?: number;
+  repo?: string;
+  synced_at?: string;
+}
+
+export interface Task {
+  project: string;
+  ref: string; // random 4-char alphanumeric
+  title: string;
+  description: string | null;
+  status: Status;
+  priority: Priority;
+  labels: string[];
+  assignees: string[];
+  parent: string | null; // full ID like "api-a7b3"
+  blocked_by: string[];
+  estimate: number | null;
+  due_date: string | null; // ISO date string "2026-01-15"
+  logs: LogEntry[];
+  created_at: string; // ISO 8601
+  updated_at: string; // ISO 8601
+  completed_at: string | null; // ISO 8601
+  external: {
+    github?: ExternalLink;
+    linear?: ExternalLink;
+    jira?: ExternalLink;
+  };
+}
+
+// Computed ID from project + ref
+export function taskId(task: { project: string; ref: string }): string {
+  return `${task.project}-${task.ref}`;
+}
+
+// Parse "api-a7b3" into {project: "api", ref: "a7b3"}
+export function parseId(id: string): { project: string; ref: string } | null {
+  const match = id.match(/^([a-z][a-z0-9]*)-([a-z0-9]+)$/);
+  if (!match || !match[1] || !match[2]) return null;
+  return { project: match[1], ref: match[2] };
+}
+
+// Generate random 4-char ref (a-z0-9)
+export function generateRef(): string {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789"; // 36 chars
+  const maxValid = 252; // 36 * 7 - reject >= 252 to avoid modulo bias
+  const result: string[] = [];
+
+  while (result.length < 4) {
+    const bytes = new Uint8Array(4);
+    crypto.getRandomValues(bytes);
+    for (const b of bytes) {
+      if (b < maxValid && result.length < 4) {
+        result.push(chars[b % 36]!);
+      }
+    }
+  }
+  return result.join("");
+}
+
+export interface TaskWithMeta extends Task {
+  id: string; // computed from project-ref
+  blocked_by_incomplete: boolean;
+  is_overdue: boolean;
+}
+
+export interface Config {
+  version: number;
+  project: string; // default project
+  defaults: {
+    priority: Priority;
+    labels: string[];
+    assignees: string[];
+  };
+  aliases: Record<string, string>; // alias -> path for auto-project detection
+  auto_project: boolean;
+}
+
+export const DEFAULT_CONFIG: Config = {
+  version: 1,
+  project: "tk",
+  defaults: {
+    priority: 3,
+    labels: [],
+    assignees: [],
+  },
+  aliases: {},
+  auto_project: false,
+};
+
+export const PRIORITY_LABELS: Record<Priority, string> = {
+  0: "none",
+  1: "urgent",
+  2: "high",
+  3: "medium",
+  4: "low",
+};
+
+export const PRIORITY_FROM_NAME: Record<string, Priority> = {
+  none: 0,
+  urgent: 1,
+  high: 2,
+  medium: 3,
+  low: 4,
+};
+
+export const STATUS_COLORS: Record<Status, string> = {
+  open: "\x1b[33m", // yellow
+  active: "\x1b[36m", // cyan
+  done: "\x1b[32m", // green
+};
+
+export const PRIORITY_COLORS: Record<Priority, string> = {
+  0: "\x1b[90m", // gray (none)
+  1: "\x1b[31m", // red (urgent)
+  2: "\x1b[33m", // yellow (high)
+  3: "\x1b[0m", // default (medium)
+  4: "\x1b[90m", // gray (low)
+};
+
+export const OVERDUE_COLOR = "\x1b[31m"; // red
+export const RESET = "\x1b[0m";