@eunjae/il 0.0.1 → 1.0.0

package/dist/scripts/il.mjs

@@ -0,0 +1,977 @@
+#!/usr/bin/env node
+import { access, mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import writeFileAtomic from "write-file-atomic";
+import { z } from "zod";
+import { homedir } from "node:os";
+import { Octokit } from "octokit";
+import { DateTime } from "luxon";
+import lockfile from "proper-lockfile";
+import { createHash } from "node:crypto";
+import { ulid } from "ulid";
+
+//#region lib/json.ts
+const readJsonFile = async (filePath) => {
+	const raw = await readFile(filePath, "utf8");
+	return JSON.parse(raw);
+};
+const writeJsonAtomic = async (filePath, data) => {
+	await writeFileAtomic(filePath, `${JSON.stringify(data, null, 2)}\n`, {
+		encoding: "utf8",
+		fsync: true
+	});
+};
+
+//#endregion
+//#region lib/aliasRepo.ts
+const emptyAliases = () => ({
+	T: {},
+	R: {}
+});
+const aliasFilePath = (workspaceRoot) => path.join(workspaceRoot, "aliases.json");
+const fileExists$2 = async (filePath) => {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const readAliases = async (workspaceRoot) => {
+	const filePath = aliasFilePath(workspaceRoot);
+	if (!await fileExists$2(filePath)) return emptyAliases();
+	const data = await readJsonFile(filePath);
+	return {
+		T: data.T ?? {},
+		R: data.R ?? {}
+	};
+};
+const writeAliases = async (workspaceRoot, aliases) => {
+	await writeJsonAtomic(aliasFilePath(workspaceRoot), aliases);
+};
+const parseAlias = (alias) => {
+	const match = alias.match(/^([TR])(\d+)$/);
+	if (!match) return null;
+	return {
+		prefix: match[1],
+		key: match[2]
+	};
+};
+const formatAliasKey = (value) => String(value).padStart(2, "0");
+const allocateAliasInMap = (aliases, prefix, taskId) => {
+	const used = new Set(Object.keys(aliases[prefix]).map((key) => Number.parseInt(key, 10)));
+	let next = 1;
+	while (used.has(next)) next += 1;
+	const key = formatAliasKey(next);
+	aliases[prefix][key] = taskId;
+	return {
+		alias: `${prefix}${key}`,
+		aliases
+	};
+};
+const allocateAlias = async (workspaceRoot, prefix, taskId) => {
+	return allocateAliasInMap(await readAliases(workspaceRoot), prefix, taskId);
+};
+const resolveAlias = async (workspaceRoot, alias) => {
+	const parsed = parseAlias(alias);
+	if (!parsed) return null;
+	return (await readAliases(workspaceRoot))[parsed.prefix][parsed.key] ?? null;
+};
+
+//#endregion
+//#region lib/constants.ts
+const APP_NAME = "il";
+const APP_DIR = `.${APP_NAME}`;
+const LOCK_DIR = ".lock";
+const LOCK_FILE = "store.lock";
+const TASKS_DIR = "tasks";
+const STATUS_ORDER = [
+	"backlog",
+	"active",
+	"paused",
+	"completed",
+	"cancelled"
+];
+
+//#endregion
+//#region lib/types.ts
+const taskStatuses = [
+	"backlog",
+	"active",
+	"paused",
+	"completed",
+	"cancelled"
+];
+const taskTypes = ["regular", "pr_review"];
+
+//#endregion
+//#region lib/schema.ts
+const logEntrySchema = z.object({
+	ts: z.string(),
+	msg: z.string(),
+	status: z.enum(taskStatuses).optional()
+});
+const dayAssignmentSchema = z.object({
+	date: z.string(),
+	action: z.enum(["assign", "unassign"]),
+	ts: z.string(),
+	msg: z.string().optional()
+});
+const prRepoSchema = z.object({
+	host: z.string(),
+	owner: z.string(),
+	name: z.string()
+});
+const prFetchedSchema = z.object({
+	at: z.string(),
+	title: z.string(),
+	author: z.object({ login: z.string() }),
+	state: z.enum([
+		"open",
+		"closed",
+		"merged"
+	]),
+	draft: z.boolean(),
+	updated_at: z.string()
+});
+const prAttachmentSchema = z.object({
+	url: z.string(),
+	provider: z.literal("github"),
+	repo: prRepoSchema.optional(),
+	number: z.number().int().positive().optional(),
+	fetched: prFetchedSchema.optional()
+});
+const taskMetadataSchema = z.object({
+	url: z.string().optional(),
+	pr: prAttachmentSchema.optional()
+});
+const taskSchema = z.object({
+	id: z.string(),
+	ref: z.string(),
+	type: z.enum(taskTypes),
+	title: z.string(),
+	status: z.enum(taskStatuses),
+	created_at: z.string(),
+	updated_at: z.string(),
+	metadata: taskMetadataSchema,
+	logs: z.array(logEntrySchema),
+	day_assignments: z.array(dayAssignmentSchema)
+}).superRefine((task, ctx) => {
+	if (task.type === "pr_review" && !task.metadata.pr?.url) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "PR review tasks require metadata.pr.url",
+		path: [
+			"metadata",
+			"pr",
+			"url"
+		]
+	});
+});
+const validateTaskOrThrow = (task) => {
+	return taskSchema.parse(task);
+};
+
+//#endregion
+//#region lib/taskRepo.ts
+const taskFileName = (taskId) => `${taskId}.json`;
+const getStatusDir = (workspaceRoot, status) => path.join(workspaceRoot, TASKS_DIR, status);
+const getTaskPath = (workspaceRoot, status, taskId) => {
+	return path.join(getStatusDir(workspaceRoot, status), taskFileName(taskId));
+};
+const fileExists$1 = async (filePath) => {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const findTaskPathById = async (workspaceRoot, taskId) => {
+	for (const status of STATUS_ORDER) {
+		const candidate = getTaskPath(workspaceRoot, status, taskId);
+		if (await fileExists$1(candidate)) return {
+			filePath: candidate,
+			status
+		};
+	}
+	return null;
+};
+const loadTaskFromPath = async (filePath) => {
+	const parsed = await readJsonFile(filePath);
+	return taskSchema.parse(parsed);
+};
+const listTasksByStatus = async (workspaceRoot, status) => {
+	const statusDir = getStatusDir(workspaceRoot, status);
+	const entries = await readdir(statusDir, { withFileTypes: true });
+	return await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => {
+		const filePath = path.join(statusDir, entry.name);
+		return {
+			task: await loadTaskFromPath(filePath),
+			status,
+			filePath
+		};
+	}));
+};
+const listAllTasks = async (workspaceRoot) => {
+	return (await Promise.all(STATUS_ORDER.map((status) => listTasksByStatus(workspaceRoot, status)))).flat();
+};
+const saveTask = async (workspaceRoot, status, task) => {
+	const filePath = getTaskPath(workspaceRoot, status, task.id);
+	await writeJsonAtomic(filePath, task);
+	return filePath;
+};
+const moveTaskFile = async (workspaceRoot, taskId, fromStatus, toStatus) => {
+	const fromPath = getTaskPath(workspaceRoot, fromStatus, taskId);
+	const toPath = getTaskPath(workspaceRoot, toStatus, taskId);
+	await rename(fromPath, toPath);
+	return toPath;
+};
+
+//#endregion
+//#region lib/aliasReconcile.ts
+const reconcileAliases = async (workspaceRoot) => {
+	const aliases = await readAliases(workspaceRoot);
+	const tasks = await listAllTasks(workspaceRoot);
+	const tasksById = new Map(tasks.map((stored) => [stored.task.id, stored.task]));
+	const normalizePrefix = (prefix) => {
+		const next = {};
+		for (const [key, value] of Object.entries(aliases[prefix])) if (tasksById.has(value)) next[key] = value;
+		aliases[prefix] = next;
+	};
+	normalizePrefix("T");
+	normalizePrefix("R");
+	const existingIds = new Set([...Object.values(aliases.T), ...Object.values(aliases.R)]);
+	const missing = tasks.filter((stored) => !existingIds.has(stored.task.id)).sort((a, b) => a.task.created_at.localeCompare(b.task.created_at));
+	for (const stored of missing) allocateAliasInMap(aliases, stored.task.type === "pr_review" ? "R" : "T", stored.task.id);
+	await writeAliases(workspaceRoot, aliases);
+	return { updated: true };
+};
+
+//#endregion
+//#region lib/config.ts
+const fileExists = async (filePath) => {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const resolveGlobalConfigPath = () => {
+	const configHome = process.env.XDG_CONFIG_HOME ?? path.join(homedir(), ".config");
+	return path.join(configHome, APP_NAME, "config.json");
+};
+const readConfigFile = async (filePath) => {
+	if (!await fileExists(filePath)) return {};
+	return await readJsonFile(filePath) ?? {};
+};
+const resolveGithubToken = async (workspaceRoot) => {
+	if (process.env.IL_GITHUB_TOKEN) return process.env.IL_GITHUB_TOKEN;
+	const workspaceConfig = await readConfigFile(path.join(workspaceRoot, "config.json"));
+	if (workspaceConfig.github?.token) return workspaceConfig.github.token;
+	return (await readConfigFile(resolveGlobalConfigPath())).github?.token ?? null;
+};
+
+//#endregion
+//#region lib/time.ts
+const DEFAULT_ZONE = "Europe/Paris";
+const nowIso = () => {
+	const value = DateTime.now().setZone(DEFAULT_ZONE).toISO();
+	if (!value) throw new Error("Failed to generate timestamp");
+	return value;
+};
+const todayDate = (date) => {
+	const value = date ? DateTime.fromISO(date, { zone: DEFAULT_ZONE }).toISODate() : DateTime.now().setZone(DEFAULT_ZONE).toISODate();
+	if (!value) throw new Error("Failed to generate date");
+	return value;
+};
+
+//#endregion
+//#region lib/pr.ts
+const parseGitHubPrUrl = (value) => {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return null;
+	}
+	const parts = url.pathname.split("/").filter(Boolean);
+	if (parts.length < 4 || parts[2] !== "pull") return null;
+	const number = Number(parts[3]);
+	if (!Number.isInteger(number)) return null;
+	return {
+		url: value,
+		provider: "github",
+		repo: {
+			host: url.host,
+			owner: parts[0],
+			name: parts[1]
+		},
+		number
+	};
+};
+const buildPrAttachment = (parsed, fetched) => {
+	return {
+		url: parsed.url,
+		provider: "github",
+		repo: parsed.repo,
+		number: parsed.number,
+		fetched
+	};
+};
+const fetchGitHubPr = async (parsed, token) => {
+	if (!parsed.repo || !parsed.number) return null;
+	if (!token) return null;
+	const data = (await new Octokit({ auth: token }).rest.pulls.get({
+		owner: parsed.repo.owner,
+		repo: parsed.repo.name,
+		pull_number: parsed.number
+	})).data;
+	const state = data.merged ? "merged" : data.state === "open" ? "open" : "closed";
+	return {
+		at: nowIso(),
+		title: data.title,
+		author: { login: data.user?.login ?? "unknown" },
+		state,
+		draft: data.draft ?? false,
+		updated_at: data.updated_at
+	};
+};
+
+//#endregion
+//#region lib/edit.ts
+const parseValue = (raw) => {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return raw;
+	}
+};
+const applyTaskEdit = (task, dottedPath, rawValue) => {
+	if (dottedPath === "status" || dottedPath.startsWith("status.")) throw new Error("Use status commands to change status");
+	const value = parseValue(rawValue);
+	const updated = structuredClone(task);
+	const segments = dottedPath.split(".");
+	let current = updated;
+	for (const segment of segments.slice(0, -1)) {
+		if (!(segment in current)) current[segment] = {};
+		const next = current[segment];
+		if (typeof next !== "object" || next === null || Array.isArray(next)) throw new Error(`Cannot set ${dottedPath} on non-object path`);
+		current = next;
+	}
+	const last = segments[segments.length - 1];
+	current[last] = value;
+	if (dottedPath === "metadata.pr.url") {
+		if (typeof value !== "string") throw new Error("metadata.pr.url must be a string");
+		const parsed = parseGitHubPrUrl(value);
+		if (!parsed) throw new Error("Invalid PR URL");
+		updated.metadata.pr = buildPrAttachment(parsed, updated.metadata.pr?.fetched);
+	}
+	return validateTaskOrThrow({
+		...updated,
+		updated_at: nowIso()
+	});
+};
+
+//#endregion
+//#region lib/format.ts
+const buildAliasLookup = (aliases) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(aliases.T)) map.set(value, `T${key}`);
+	for (const [key, value] of Object.entries(aliases.R)) map.set(value, `R${key}`);
+	return map;
+};
+const formatTaskListLine = (task, alias) => {
+	return `${(alias ?? "--").padEnd(4)} ${task.ref.padEnd(9)} ${task.status.padEnd(9)} ${task.title}`;
+};
+const formatTaskDetails = (task, alias) => {
+	const lines = [];
+	lines.push(`${alias ?? "--"} ${task.ref} ${task.title}`);
+	lines.push(`id: ${task.id}`);
+	lines.push(`type: ${task.type}`);
+	lines.push(`status: ${task.status}`);
+	lines.push(`created: ${task.created_at}`);
+	lines.push(`updated: ${task.updated_at}`);
+	if (task.metadata.url) lines.push(`url: ${task.metadata.url}`);
+	if (task.metadata.pr?.url) {
+		lines.push(`pr: ${task.metadata.pr.url}`);
+		if (task.metadata.pr.fetched) {
+			const fetched = task.metadata.pr.fetched;
+			lines.push(`pr_state: ${fetched.state}`);
+			lines.push(`pr_title: ${fetched.title}`);
+			lines.push(`pr_author: ${fetched.author.login}`);
+			lines.push(`pr_updated_at: ${fetched.updated_at}`);
+			lines.push(`pr_refreshed_at: ${fetched.at}`);
+		}
+	}
+	if (task.logs.length > 0) {
+		lines.push("logs:");
+		for (const log of task.logs) {
+			const status = log.status ? ` [${log.status}]` : "";
+			lines.push(`- ${log.ts}${status} ${log.msg}`);
+		}
+	}
+	if (task.day_assignments.length > 0) {
+		lines.push("day_assignments:");
+		for (const entry of task.day_assignments) {
+			const msg = entry.msg ? ` (${entry.msg})` : "";
+			lines.push(`- ${entry.date} ${entry.action} ${entry.ts}${msg}`);
+		}
+	}
+	return lines.join("\n");
+};
+
+//#endregion
+//#region lib/gitignore.ts
+const lockEntry = `${APP_DIR}/.lock/`;
+const ensureLockIgnored = async (repoRoot) => {
+	const gitignorePath = path.join(repoRoot, ".gitignore");
+	let current = "";
+	try {
+		current = await readFile(gitignorePath, "utf8");
+	} catch {
+		current = "";
+	}
+	if (current.split("\n").some((line) => line.trim() === lockEntry)) return false;
+	const separator = current.endsWith("\n") || current.length === 0 ? "" : "\n";
+	await writeFile(gitignorePath, `${current}${separator}${lockEntry}\n`, "utf8");
+	return true;
+};
+
+//#endregion
+//#region lib/workspace.ts
+const exists = async (filePath) => {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const findGitRoot = async (startDir) => {
+	let current = path.resolve(startDir);
+	while (true) {
+		if (await exists(path.join(current, ".git"))) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+};
+const resolveGlobalWorkspaceRoot = () => {
+	const dataHome = process.env.XDG_DATA_HOME ?? path.join(homedir(), ".local", "share");
+	return path.join(dataHome, APP_NAME);
+};
+const resolveWorkspace = async (options) => {
+	if (options.store) return {
+		root: path.resolve(options.store),
+		kind: "explicit"
+	};
+	const repoRoot = await findGitRoot(options.cwd ?? process.cwd());
+	if (options.repo) {
+		if (!repoRoot) throw new Error("Not inside a git repository");
+		return {
+			root: path.join(repoRoot, APP_DIR),
+			kind: "repo"
+		};
+	}
+	if (options.global) return {
+		root: resolveGlobalWorkspaceRoot(),
+		kind: "global"
+	};
+	if (repoRoot) {
+		const repoWorkspace = path.join(repoRoot, APP_DIR);
+		if (await exists(repoWorkspace)) return {
+			root: repoWorkspace,
+			kind: "repo"
+		};
+	}
+	return {
+		root: resolveGlobalWorkspaceRoot(),
+		kind: "global"
+	};
+};
+const ensureWorkspaceLayout = async (workspaceRoot) => {
+	await mkdir(path.join(workspaceRoot, TASKS_DIR), { recursive: true });
+	await mkdir(path.join(workspaceRoot, LOCK_DIR), { recursive: true });
+	await Promise.all(STATUS_ORDER.map((status) => mkdir(path.join(workspaceRoot, TASKS_DIR, status), { recursive: true })));
+};
+
+//#endregion
+//#region lib/lock.ts
+const withWorkspaceLock = async (workspaceRoot, fn) => {
+	await ensureWorkspaceLayout(workspaceRoot);
+	const lockPath = path.join(workspaceRoot, LOCK_DIR, LOCK_FILE);
+	await writeFile(lockPath, "", { flag: "a" });
+	const release = await lockfile.lock(lockPath, {
+		stale: 6e4,
+		retries: {
+			retries: 5,
+			factor: 1.5,
+			minTimeout: 50,
+			maxTimeout: 1e3
+		}
+	});
+	try {
+		return await fn();
+	} finally {
+		await release();
+	}
+};
+
+//#endregion
+//#region lib/search.ts
+const taskMatchesQuery = (task, query) => {
+	const needle = query.toLowerCase();
+	const contains = (value) => value ? value.toLowerCase().includes(needle) : false;
+	if (contains(task.title)) return true;
+	if (task.logs.some((log) => contains(log.msg))) return true;
+	if (contains(task.metadata.pr?.url)) return true;
+	if (contains(task.metadata.pr?.fetched?.title)) return true;
+	return false;
+};
+
+//#endregion
+//#region lib/id.ts
+const BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+const base32Encode = (input) => {
+	let bits = 0;
+	let value = 0;
+	let output = "";
+	for (const byte of input) {
+		value = value << 8 | byte;
+		bits += 8;
+		while (bits >= 5) {
+			output += BASE32_ALPHABET[value >>> bits - 5 & 31];
+			bits -= 5;
+		}
+	}
+	if (bits > 0) output += BASE32_ALPHABET[value << 5 - bits & 31];
+	return output;
+};
+const generateTaskId = (taskType) => {
+	return `${taskType === "pr_review" ? "R" : "T"}${ulid()}`;
+};
+const generateStableRef = (taskType, taskId) => {
+	return `${taskType === "pr_review" ? "R" : "T"}-${base32Encode(createHash("sha256").update(taskId).digest()).slice(0, 6)}`;
+};
+
+//#endregion
+//#region lib/taskFactory.ts
+const buildTask = (input) => {
+	const id = generateTaskId(input.type);
+	const ref = generateStableRef(input.type, id);
+	const timestamp = nowIso();
+	return {
+		id,
+		ref,
+		type: input.type,
+		title: input.title,
+		status: "backlog",
+		created_at: timestamp,
+		updated_at: timestamp,
+		metadata: input.metadata ?? {},
+		logs: [],
+		day_assignments: []
+	};
+};
+
+//#endregion
+//#region lib/fsm.ts
+const transitionTable = {
+	backlog: {
+		start: "active",
+		cancel: "cancelled"
+	},
+	active: {
+		pause: "paused",
+		complete: "completed",
+		cancel: "cancelled"
+	},
+	paused: {
+		start: "active",
+		complete: "completed",
+		cancel: "cancelled"
+	},
+	completed: {},
+	cancelled: {}
+};
+const getNextStatus = (current, action) => {
+	const next = transitionTable[current][action];
+	if (!next) throw new Error(`Invalid transition: ${current} -> ${action}`);
+	return next;
+};
+
+//#endregion
+//#region lib/taskOperations.ts
+const defaultMessages = {
+	start: "Started task",
+	pause: "Paused task",
+	complete: "Completed task",
+	cancel: "Cancelled task"
+};
+const appendLog = (task, message, status) => {
+	const log = {
+		ts: nowIso(),
+		msg: message,
+		status
+	};
+	return {
+		...task,
+		logs: [...task.logs, log],
+		updated_at: nowIso()
+	};
+};
+const applyTransition = (task, action, message) => {
+	const nextStatus = getNextStatus(task.status, action);
+	const logMessage = message ?? defaultMessages[action];
+	const log = {
+		ts: nowIso(),
+		msg: logMessage,
+		status: nextStatus
+	};
+	return {
+		task: {
+			...task,
+			status: nextStatus,
+			updated_at: nowIso(),
+			logs: [...task.logs, log]
+		},
+		nextStatus
+	};
+};
+const isAssignedOnDate = (task, date) => {
+	const events = task.day_assignments.filter((entry) => entry.date === date);
+	if (events.length === 0) return false;
+	return events[events.length - 1].action === "assign";
+};
+const appendDayAssignment = (task, date, action, msg) => {
+	const event = {
+		date,
+		action,
+		ts: nowIso(),
+		msg
+	};
+	return {
+		...task,
+		day_assignments: [...task.day_assignments, event],
+		updated_at: nowIso()
+	};
+};
+
+//#endregion
+//#region lib/taskStore.ts
+const createTaskInStore = async (workspaceRoot, task) => {
+	const { alias, aliases } = await allocateAlias(workspaceRoot, task.type === "pr_review" ? "R" : "T", task.id);
+	await writeAliases(workspaceRoot, aliases);
+	await saveTask(workspaceRoot, task.status, task);
+	return {
+		alias,
+		task
+	};
+};
+
+//#endregion
+//#region lib/taskResolver.ts
+const stableRefPattern = /^[TR]-[A-Z0-9]{6}$/;
+const resolveTaskId = async (workspaceRoot, identifier) => {
+	const aliasMatch = await resolveAlias(workspaceRoot, identifier);
+	if (aliasMatch) return aliasMatch;
+	if (stableRefPattern.test(identifier)) {
+		const match = (await listAllTasks(workspaceRoot)).find((stored) => stored.task.ref === identifier);
+		if (!match) throw new Error(`Task not found for ref: ${identifier}`);
+		return match.task.id;
+	}
+	if (!await findTaskPathById(workspaceRoot, identifier)) throw new Error(`Task not found: ${identifier}`);
+	return identifier;
+};
+const resolveTask = async (workspaceRoot, identifier) => {
+	const found = await findTaskPathById(workspaceRoot, await resolveTaskId(workspaceRoot, identifier));
+	if (!found) throw new Error(`Task not found: ${identifier}`);
+	return {
+		task: await loadTaskFromPath(found.filePath),
+		status: found.status,
+		filePath: found.filePath
+	};
+};
+
+//#endregion
+//#region scripts/il.ts
+const program = new Command();
+const handleAction = (fn) => async (...args) => {
+	try {
+		await fn(...args);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		process.stderr.write(`${message}\n`);
+		process.exitCode = 1;
+	}
+};
+const resolveWorkspaceFor = async (ensure) => {
+	const opts = program.opts();
+	const workspace = await resolveWorkspace({
+		store: opts.store,
+		global: opts.global,
+		repo: opts.repo
+	});
+	if (ensure) await ensureWorkspaceLayout(workspace.root);
+	return workspace.root;
+};
+const printLines = (lines) => {
+	if (lines.length === 0) {
+		process.stdout.write("No tasks.\n");
+		return;
+	}
+	process.stdout.write(`${lines.join("\n")}\n`);
+};
+const isTaskStatus = (value) => {
+	return taskStatuses.includes(value);
+};
+const isPackageJson = (value) => {
+	return value !== null && typeof value === "object" && "version" in value;
+};
+const resolvePackageVersion = async () => {
+	let current = path.dirname(fileURLToPath(import.meta.url));
+	while (true) {
+		const candidate = path.join(current, "package.json");
+		try {
+			const raw = await readFile(candidate, "utf8");
+			const parsed = JSON.parse(raw);
+			if (isPackageJson(parsed) && typeof parsed.version === "string") return parsed.version;
+		} catch (error) {
+			if (!(error instanceof Error)) throw error;
+			if (error.code !== "ENOENT") throw error;
+		}
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+};
+const packageVersion = await resolvePackageVersion();
+program.name("il").description("Terminal task manager").option("--store <path>", "explicit workspace path").option("--global", "use global workspace").option("--repo", "use repo workspace");
+if (packageVersion) program.version(packageVersion);
+program.command("init").description("initialize repo workspace").action(handleAction(async () => {
+	const repoRoot = await findGitRoot(process.cwd());
+	if (!repoRoot) throw new Error("Not inside a git repository");
+	const workspaceRoot = path.join(repoRoot, APP_DIR);
+	await ensureWorkspaceLayout(workspaceRoot);
+	await ensureLockIgnored(repoRoot);
+	process.stdout.write(`Initialized workspace at ${workspaceRoot}\n`);
+}));
+program.command("where").description("show resolved workspace").action(handleAction(async () => {
+	const opts = program.opts();
+	const workspace = await resolveWorkspace({
+		store: opts.store,
+		global: opts.global,
+		repo: opts.repo
+	});
+	process.stdout.write(`${workspace.root} (${workspace.kind})\n`);
+}));
+program.command("add").description("add a task").argument("[title]", "task title").option("--type <type>", "regular|pr_review", "regular").option("--url <url>", "attach URL").option("--pr <url>", "attach PR URL").action(handleAction(async (title, options, command) => {
+	const taskType = options.type;
+	if (!taskTypes.includes(taskType)) throw new Error(`Invalid type: ${taskType}`);
+	if (taskType === "pr_review" && !options.pr) throw new Error("PR review tasks require --pr");
+	const workspaceRoot = await resolveWorkspaceFor(true);
+	await withWorkspaceLock(workspaceRoot, async () => {
+		let prAttachment;
+		let prTitle;
+		if (options.pr) {
+			const parsed = parseGitHubPrUrl(options.pr);
+			if (!parsed) throw new Error("Invalid PR URL");
+			const fetched = await fetchGitHubPr(parsed, await resolveGithubToken(workspaceRoot));
+			prAttachment = buildPrAttachment(parsed, fetched ?? void 0);
+			prTitle = fetched?.title ?? `PR #${parsed.number} ${parsed.repo.owner}/${parsed.repo.name}`;
+		}
+		const isExplicitTitle = Boolean(title);
+		let finalTitle = title ?? prTitle;
+		if (!finalTitle) throw new Error("Title is required when no PR URL is provided");
+		if (taskType === "pr_review" && !isExplicitTitle) finalTitle = `Review: ${finalTitle}`;
+		const metadata = {
+			url: options.url,
+			pr: prAttachment
+		};
+		const task = buildTask({
+			type: taskType,
+			title: finalTitle,
+			metadata
+		});
+		taskSchema.parse(task);
+		const created = await createTaskInStore(workspaceRoot, task);
+		process.stdout.write(`Created ${created.alias} ${created.task.ref} ${created.task.title}\n`);
+	});
+}));
+program.command("list").description("list tasks").argument("[status]", "task status").action(handleAction(async (status, command) => {
+	const workspaceRoot = await resolveWorkspaceFor(true);
+	const aliasLookup = buildAliasLookup(await readAliases(workspaceRoot));
+	if (status && !isTaskStatus(status)) throw new Error(`Invalid status: ${status}`);
+	const statuses = status ? [status] : [...taskStatuses];
+	const lines = [];
+	for (const currentStatus of statuses) {
+		const stored = await listTasksByStatus(workspaceRoot, currentStatus);
+		for (const entry of stored) {
+			const alias = aliasLookup.get(entry.task.id);
+			let line = formatTaskListLine(entry.task, alias);
+			if (entry.task.metadata.pr?.fetched?.state) line += ` PR:${entry.task.metadata.pr.fetched.state}`;
+			lines.push(line);
+		}
+	}
+	printLines(lines);
+}));
+program.command("show").description("show a task").argument("<id>", "task identifier").action(handleAction(async (identifier, command) => {
+	const workspaceRoot = await resolveWorkspaceFor(true);
+	const stored = await resolveTask(workspaceRoot, identifier);
+	const alias = buildAliasLookup(await readAliases(workspaceRoot)).get(stored.task.id);
+	process.stdout.write(`${formatTaskDetails(stored.task, alias)}\n`);
+}));
+const addTransitionCommand = (name) => {
+	program.command(name).description(`${name} a task`).argument("<id>", "task identifier").option("-m, --message <message>", "custom log message").action(handleAction(async (identifier, options, command) => {
+		const workspaceRoot = await resolveWorkspaceFor(true);
+		await withWorkspaceLock(workspaceRoot, async () => {
+			const stored = await resolveTask(workspaceRoot, identifier);
+			const { task: updated, nextStatus } = applyTransition(stored.task, name, options.message);
+			await saveTask(workspaceRoot, stored.status, updated);
+			await moveTaskFile(workspaceRoot, updated.id, stored.status, nextStatus);
+			process.stdout.write(`Updated ${updated.ref} -> ${nextStatus}\n`);
+		});
+	}));
+};
+addTransitionCommand("start");
+addTransitionCommand("pause");
+addTransitionCommand("complete");
+addTransitionCommand("cancel");
+program.command("log").description("append a log entry").argument("<id>", "task identifier").argument("<message>", "log message").option("--status <status>", "include status in log entry").action(handleAction(async (identifier, message, options, command) => {
+	const workspaceRoot = await resolveWorkspaceFor(true);
+	const status = options.status;
+	if (status && !taskStatuses.includes(status)) throw new Error(`Invalid status: ${status}`);
+	await withWorkspaceLock(workspaceRoot, async () => {
+		const stored = await resolveTask(workspaceRoot, identifier);
+		const updated = appendLog(stored.task, message, status);
+		await saveTask(workspaceRoot, stored.status, updated);
+		process.stdout.write(`Logged on ${updated.ref}\n`);
+	});
+}));
+program.command("edit").description("edit a task field").argument("<id>", "task identifier").argument("<path>", "dotted path").argument("<value>", "new value").action(handleAction(async (identifier, dottedPath, value, command) => {
+	const workspaceRoot = await resolveWorkspaceFor(true);
+	await withWorkspaceLock(workspaceRoot, async () => {
+		const stored = await resolveTask(workspaceRoot, identifier);
+		const updated = applyTaskEdit(stored.task, dottedPath, value);
+		await saveTask(workspaceRoot, stored.status, updated);
+		process.stdout.write(`Updated ${updated.ref}\n`);
+	});
+}));
+program.command("search").description("search tasks").argument("<query>", "search query").action(handleAction(async (query, command) => {
+	const workspaceRoot = await resolveWorkspaceFor(true);
+	const aliasLookup = buildAliasLookup(await readAliases(workspaceRoot));
+	printLines((await listAllTasks(workspaceRoot)).filter((stored) => taskMatchesQuery(stored.task, query)).map((stored) => {
+		const alias = aliasLookup.get(stored.task.id);
+		let line = formatTaskListLine(stored.task, alias);
+		if (stored.task.metadata.pr?.fetched?.state) line += ` PR:${stored.task.metadata.pr.fetched.state}`;
+		return line;
+	}));
+}));
+program.command("today").description("assign or list today tasks").argument("[id]", "task identifier").option("--date <date>", "YYYY-MM-DD").option("-m, --message <message>", "assignment message").action(handleAction(async (identifier, options, command) => {
+	const workspaceRoot = await resolveWorkspaceFor(true);
+	const date = todayDate(options.date);
+	if (!identifier) {
+		const aliasLookup = buildAliasLookup(await readAliases(workspaceRoot));
+		printLines((await listAllTasks(workspaceRoot)).filter((stored) => isAssignedOnDate(stored.task, date)).map((stored) => formatTaskListLine(stored.task, aliasLookup.get(stored.task.id))));
+		return;
+	}
+	await withWorkspaceLock(workspaceRoot, async () => {
+		const stored = await resolveTask(workspaceRoot, identifier);
+		if (isAssignedOnDate(stored.task, date)) {
+			process.stdout.write(`Already assigned ${stored.task.ref} to ${date}\n`);
+			return;
+		}
+		const updated = appendDayAssignment(stored.task, date, "assign", options.message);
+		await saveTask(workspaceRoot, stored.status, updated);
+		process.stdout.write(`Assigned ${updated.ref} to ${date}\n`);
+	});
+}));
+program.command("untoday").description("unassign a task from today").argument("<id>", "task identifier").option("--date <date>", "YYYY-MM-DD").action(handleAction(async (identifier, options, command) => {
+	const workspaceRoot = await resolveWorkspaceFor(true);
+	const date = todayDate(options.date);
+	await withWorkspaceLock(workspaceRoot, async () => {
+		const stored = await resolveTask(workspaceRoot, identifier);
+		if (!isAssignedOnDate(stored.task, date)) {
+			process.stdout.write(`Already unassigned ${stored.task.ref} from ${date}\n`);
+			return;
+		}
+		const updated = appendDayAssignment(stored.task, date, "unassign");
+		await saveTask(workspaceRoot, stored.status, updated);
+		process.stdout.write(`Unassigned ${updated.ref} from ${date}\n`);
+	});
+}));
+program.command("attach-pr").description("attach PR metadata to a task").argument("<id>", "task identifier").argument("<url>", "PR URL").option("-m, --message <message>", "log message").action(handleAction(async (identifier, url, options, command) => {
+	const workspaceRoot = await resolveWorkspaceFor(true);
+	await withWorkspaceLock(workspaceRoot, async () => {
+		const parsed = parseGitHubPrUrl(url);
+		if (!parsed) throw new Error("Invalid PR URL");
+		const fetched = await fetchGitHubPr(parsed, await resolveGithubToken(workspaceRoot));
+		const stored = await resolveTask(workspaceRoot, identifier);
+		const next = appendLog({
+			...stored.task,
+			metadata: {
+				...stored.task.metadata,
+				pr: buildPrAttachment(parsed, fetched ?? stored.task.metadata.pr?.fetched)
+			},
+			updated_at: nowIso()
+		}, options.message ?? `Attached PR ${url}`);
+		await saveTask(workspaceRoot, stored.status, next);
+		process.stdout.write(`Attached PR to ${next.ref}\n`);
+	});
+}));
+program.command("refresh").description("refresh PR metadata").argument("<id>", "task identifier").option("-m, --message <message>", "log message").action(handleAction(async (identifier, options, command) => {
+	const workspaceRoot = await resolveWorkspaceFor(true);
+	await withWorkspaceLock(workspaceRoot, async () => {
+		const stored = await resolveTask(workspaceRoot, identifier);
+		const prUrl = stored.task.metadata.pr?.url;
+		if (!prUrl) {
+			process.stdout.write("No PR attached.\n");
+			return;
+		}
+		const parsed = parseGitHubPrUrl(prUrl);
+		if (!parsed) throw new Error("Invalid PR URL");
+		const fetched = await fetchGitHubPr(parsed, await resolveGithubToken(workspaceRoot));
+		if (!fetched) throw new Error("No GitHub token configured");
+		const baseUpdated = {
+			...stored.task,
+			metadata: {
+				...stored.task.metadata,
+				pr: buildPrAttachment(parsed, fetched)
+			},
+			updated_at: nowIso()
+		};
+		const previousState = stored.task.metadata.pr?.fetched?.state;
+		const nextState = fetched.state;
+		const isTerminal = stored.task.status === "completed" || stored.task.status === "cancelled";
+		let finalTask = baseUpdated;
+		let nextStatus = stored.status;
+		if (!isTerminal && previousState !== nextState) {
+			if (nextState === "merged") {
+				const result = applyTransition(baseUpdated, "complete", options.message ?? "PR merged");
+				finalTask = result.task;
+				nextStatus = result.nextStatus;
+			} else if (nextState === "closed") {
+				const result = applyTransition(baseUpdated, "cancel", options.message ?? "PR closed without merge");
+				finalTask = result.task;
+				nextStatus = result.nextStatus;
+			}
+		}
+		await saveTask(workspaceRoot, stored.status, finalTask);
+		if (nextStatus !== stored.status) await moveTaskFile(workspaceRoot, finalTask.id, stored.status, nextStatus);
+		process.stdout.write(`Refreshed ${finalTask.ref}\n`);
+	});
+}));
+program.command("alias").description("alias helpers").command("reconcile").description("reconcile alias mapping").action(handleAction(async (command) => {
+	const workspaceRoot = await resolveWorkspaceFor(true);
+	await withWorkspaceLock(workspaceRoot, async () => {
+		await reconcileAliases(workspaceRoot);
+		process.stdout.write("Aliases reconciled.\n");
+	});
+}));
+program.parseAsync(process.argv);
+
+//#endregion
+export {  };