@eunjae/il 0.0.1 → 1.0.0

package/dist/lib/schema.js

@@ -1,64 +0,0 @@
-import { z } from 'zod';
-import { taskStatuses, taskTypes } from './types';
-export const logEntrySchema = z.object({
-    ts: z.string(),
-    msg: z.string(),
-    status: z.enum(taskStatuses).optional()
-});
-export 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()
-});
-export const prAttachmentSchema = z.object({
-    url: z.string(),
-    provider: z.literal('github'),
-    repo: prRepoSchema.optional(),
-    number: z.number().int().positive().optional(),
-    fetched: prFetchedSchema.optional()
-});
-export const taskMetadataSchema = z.object({
-    url: z.string().optional(),
-    pr: prAttachmentSchema.optional()
-});
-export 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']
-        });
-    }
-});
-export const validateTaskOrThrow = (task) => {
-    return taskSchema.parse(task);
-};

package/dist/lib/search.js

@@ -1,17 +0,0 @@
-export 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;
-};

package/dist/lib/taskFactory.js

@@ -1,19 +0,0 @@
-import { generateStableRef, generateTaskId } from './id';
-import { nowIso } from './time';
-export 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: []
-    };
-};

package/dist/lib/taskOperations.js

@@ -1,57 +0,0 @@
-import { getNextStatus } from './fsm';
-import { nowIso } from './time';
-const defaultMessages = {
-    start: 'Started task',
-    pause: 'Paused task',
-    complete: 'Completed task',
-    cancel: 'Cancelled task'
-};
-export const appendLog = (task, message, status) => {
-    const log = {
-        ts: nowIso(),
-        msg: message,
-        status
-    };
-    return {
-        ...task,
-        logs: [...task.logs, log],
-        updated_at: nowIso()
-    };
-};
-export const applyTransition = (task, action, message) => {
-    const nextStatus = getNextStatus(task.status, action);
-    const logMessage = message ?? defaultMessages[action];
-    const log = {
-        ts: nowIso(),
-        msg: logMessage,
-        status: nextStatus
-    };
-    const updated = {
-        ...task,
-        status: nextStatus,
-        updated_at: nowIso(),
-        logs: [...task.logs, log]
-    };
-    return { task: updated, nextStatus };
-};
-export const isAssignedOnDate = (task, date) => {
-    const events = task.day_assignments.filter((entry) => entry.date === date);
-    if (events.length === 0) {
-        return false;
-    }
-    const lastEvent = events[events.length - 1];
-    return lastEvent.action === 'assign';
-};
-export const appendDayAssignment = (task, date, action, msg) => {
-    const event = {
-        date,
-        action,
-        ts: nowIso(),
-        msg
-    };
-    return {
-        ...task,
-        day_assignments: [...task.day_assignments, event],
-        updated_at: nowIso()
-    };
-};

package/dist/lib/taskRepo.js

@@ -1,67 +0,0 @@
-import { access, readdir, rename } from 'node:fs/promises';
-import path from 'node:path';
-import { STATUS_ORDER, TASKS_DIR } from './constants';
-import { readJsonFile, writeJsonAtomic } from './json';
-import { taskSchema } from './schema';
-const taskFileName = (taskId) => `${taskId}.json`;
-const getStatusDir = (workspaceRoot, status) => path.join(workspaceRoot, TASKS_DIR, status);
-export const getTaskPath = (workspaceRoot, status, taskId) => {
-    return path.join(getStatusDir(workspaceRoot, status), taskFileName(taskId));
-};
-const fileExists = async (filePath) => {
-    try {
-        await access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-export const findTaskPathById = async (workspaceRoot, taskId) => {
-    for (const status of STATUS_ORDER) {
-        const candidate = getTaskPath(workspaceRoot, status, taskId);
-        if (await fileExists(candidate)) {
-            return { filePath: candidate, status };
-        }
-    }
-    return null;
-};
-export const loadTaskFromPath = async (filePath) => {
-    const parsed = await readJsonFile(filePath);
-    return taskSchema.parse(parsed);
-};
-export const loadTaskById = async (workspaceRoot, taskId) => {
-    const found = await findTaskPathById(workspaceRoot, taskId);
-    if (!found) {
-        throw new Error(`Task not found: ${taskId}`);
-    }
-    const task = await loadTaskFromPath(found.filePath);
-    return { task, status: found.status, filePath: found.filePath };
-};
-export const listTasksByStatus = async (workspaceRoot, status) => {
-    const statusDir = getStatusDir(workspaceRoot, status);
-    const entries = await readdir(statusDir, { withFileTypes: true });
-    const tasks = await Promise.all(entries
-        .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
-        .map(async (entry) => {
-        const filePath = path.join(statusDir, entry.name);
-        const task = await loadTaskFromPath(filePath);
-        return { task, status, filePath };
-    }));
-    return tasks;
-};
-export const listAllTasks = async (workspaceRoot) => {
-    const all = await Promise.all(STATUS_ORDER.map((status) => listTasksByStatus(workspaceRoot, status)));
-    return all.flat();
-};
-export const saveTask = async (workspaceRoot, status, task) => {
-    const filePath = getTaskPath(workspaceRoot, status, task.id);
-    await writeJsonAtomic(filePath, task);
-    return filePath;
-};
-export 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;
-};

package/dist/lib/taskResolver.js

@@ -1,31 +0,0 @@
-import { resolveAlias } from './aliasRepo';
-import { findTaskPathById, listAllTasks, loadTaskFromPath } from './taskRepo';
-const stableRefPattern = /^[TR]-[A-Z0-9]{6}$/;
-export const resolveTaskId = async (workspaceRoot, identifier) => {
-    const aliasMatch = await resolveAlias(workspaceRoot, identifier);
-    if (aliasMatch) {
-        return aliasMatch;
-    }
-    if (stableRefPattern.test(identifier)) {
-        const tasks = await listAllTasks(workspaceRoot);
-        const match = tasks.find((stored) => stored.task.ref === identifier);
-        if (!match) {
-            throw new Error(`Task not found for ref: ${identifier}`);
-        }
-        return match.task.id;
-    }
-    const found = await findTaskPathById(workspaceRoot, identifier);
-    if (!found) {
-        throw new Error(`Task not found: ${identifier}`);
-    }
-    return identifier;
-};
-export const resolveTask = async (workspaceRoot, identifier) => {
-    const taskId = await resolveTaskId(workspaceRoot, identifier);
-    const found = await findTaskPathById(workspaceRoot, taskId);
-    if (!found) {
-        throw new Error(`Task not found: ${identifier}`);
-    }
-    const task = await loadTaskFromPath(found.filePath);
-    return { task, status: found.status, filePath: found.filePath };
-};

package/dist/lib/taskStore.js

@@ -1,9 +0,0 @@
-import { allocateAlias, writeAliases } from './aliasRepo';
-import { saveTask } from './taskRepo';
-export const createTaskInStore = async (workspaceRoot, task) => {
-    const prefix = task.type === 'pr_review' ? 'R' : 'T';
-    const { alias, aliases } = await allocateAlias(workspaceRoot, prefix, task.id);
-    await writeAliases(workspaceRoot, aliases);
-    await saveTask(workspaceRoot, task.status, task);
-    return { alias, task };
-};

package/dist/lib/time.js

@@ -1,18 +0,0 @@
-import { DateTime } from 'luxon';
-const DEFAULT_ZONE = 'Europe/Paris';
-export const nowIso = () => {
-    const value = DateTime.now().setZone(DEFAULT_ZONE).toISO();
-    if (!value) {
-        throw new Error('Failed to generate timestamp');
-    }
-    return value;
-};
-export 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;
-};

package/dist/lib/types.js

@@ -1,3 +0,0 @@
-export const taskStatuses = ['backlog', 'active', 'paused', 'completed', 'cancelled'];
-export const taskTypes = ['regular', 'pr_review'];
-export const taskActions = ['start', 'pause', 'complete', 'cancel'];

package/dist/lib/workspace.js

@@ -1,58 +0,0 @@
-import { access, mkdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import path from 'node:path';
-import { APP_DIR, APP_NAME, LOCK_DIR, STATUS_ORDER, TASKS_DIR } from './constants';
-const exists = async (filePath) => {
-    try {
-        await access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-export 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;
-    }
-};
-export const resolveGlobalWorkspaceRoot = () => {
-    const dataHome = process.env.XDG_DATA_HOME ?? path.join(homedir(), '.local', 'share');
-    return path.join(dataHome, APP_NAME);
-};
-export const resolveWorkspace = async (options) => {
-    if (options.store) {
-        return { root: path.resolve(options.store), kind: 'explicit' };
-    }
-    const cwd = options.cwd ?? process.cwd();
-    const repoRoot = await findGitRoot(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' };
-};
-export 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 })));
-};