@eunjae/il 0.0.1 → 1.0.0

package/dist/scripts/il.js

@@ -1,396 +0,0 @@
-#!/usr/bin/env node
-import path from 'node:path';
-import { Command } from 'commander';
-import { readAliases } from '../lib/aliasRepo';
-import { reconcileAliases } from '../lib/aliasReconcile';
-import { resolveGithubToken } from '../lib/config';
-import { APP_DIR } from '../lib/constants';
-import { applyTaskEdit } from '../lib/edit';
-import { formatTaskDetails, formatTaskListLine, buildAliasLookup } from '../lib/format';
-import { ensureLockIgnored } from '../lib/gitignore';
-import { withWorkspaceLock } from '../lib/lock';
-import { buildPrAttachment, fetchGitHubPr, parseGitHubPrUrl } from '../lib/pr';
-import { taskSchema } from '../lib/schema';
-import { taskMatchesQuery } from '../lib/search';
-import { buildTask } from '../lib/taskFactory';
-import { appendDayAssignment, appendLog, applyTransition, isAssignedOnDate } from '../lib/taskOperations';
-import { createTaskInStore } from '../lib/taskStore';
-import { listAllTasks, listTasksByStatus, moveTaskFile, saveTask } from '../lib/taskRepo';
-import { resolveTask } from '../lib/taskResolver';
-import { nowIso, todayDate } from '../lib/time';
-import { taskStatuses, taskTypes } from '../lib/types';
-import { ensureWorkspaceLayout, findGitRoot, resolveWorkspace } from '../lib/workspace';
-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);
-};
-program
-    .name('il')
-    .description('Terminal task manager')
-    .option('--store <path>', 'explicit workspace path')
-    .option('--global', 'use global workspace')
-    .option('--repo', 'use repo workspace');
-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 token = await resolveGithubToken(workspaceRoot);
-            const fetched = await fetchGitHubPr(parsed, token);
-            prAttachment = buildPrAttachment(parsed, fetched ?? undefined);
-            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 aliases = await readAliases(workspaceRoot);
-    const aliasLookup = buildAliasLookup(aliases);
-    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 aliases = await readAliases(workspaceRoot);
-    const aliasLookup = buildAliasLookup(aliases);
-    const alias = aliasLookup.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 aliases = await readAliases(workspaceRoot);
-    const aliasLookup = buildAliasLookup(aliases);
-    const tasks = await listAllTasks(workspaceRoot);
-    const lines = tasks
-        .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;
-    });
-    printLines(lines);
-}));
-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 aliases = await readAliases(workspaceRoot);
-        const aliasLookup = buildAliasLookup(aliases);
-        const tasks = await listAllTasks(workspaceRoot);
-        const assigned = tasks.filter((stored) => isAssignedOnDate(stored.task, date));
-        const lines = assigned.map((stored) => formatTaskListLine(stored.task, aliasLookup.get(stored.task.id)));
-        printLines(lines);
-        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 token = await resolveGithubToken(workspaceRoot);
-        const fetched = await fetchGitHubPr(parsed, token);
-        const stored = await resolveTask(workspaceRoot, identifier);
-        const updated = {
-            ...stored.task,
-            metadata: {
-                ...stored.task.metadata,
-                pr: buildPrAttachment(parsed, fetched ?? stored.task.metadata.pr?.fetched)
-            },
-            updated_at: nowIso()
-        };
-        const logMessage = options.message ?? `Attached PR ${url}`;
-        const next = appendLog(updated, logMessage);
-        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 token = await resolveGithubToken(workspaceRoot);
-        const fetched = await fetchGitHubPr(parsed, token);
-        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`);
-    });
-}));
-const aliasCommand = program.command('alias').description('alias helpers');
-aliasCommand
-    .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);