harness-async 0.1.0

package/dist/src/cli/commands/run.js

@@ -0,0 +1,129 @@
+import { getRun, listRuns } from '../../core/run-manager.js';
+import { collectRunOutput, getRunAttachCommand, startTaskRun, stopTaskRun, syncRunState, } from '../../core/run-orchestrator.js';
+import { renderRunTable } from '../utils/output.js';
+export function registerRunCommand(program) {
+    const run = program.command('run').description('Manage task execution runs');
+    run
+        .command('start')
+        .description('Start a task run with a target tool')
+        .argument('[taskId]', 'Task ID')
+        .option('--tool <tool>', 'Tool name, for example claude or codex')
+        .option('--auto', 'Pick the next runnable task automatically')
+        .action(async (taskId, options) => {
+        try {
+            if (!options.tool) {
+                throw new Error('--tool is required');
+            }
+            const created = await startTaskRun({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                taskId: taskId ? Number(taskId) : undefined,
+                tool: options.tool,
+                auto: options.auto,
+            });
+            console.log(`Started run ${created.id} in tmux session ${created.tmuxSession}`);
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    run
+        .command('list')
+        .description('Run list on task executions')
+        .option('--task-id <id>', 'Filter runs by task ID')
+        .action(async (options) => {
+        try {
+            const runs = await listRuns({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                scope: 'project',
+                taskId: options.taskId ? Number(options.taskId) : undefined,
+            });
+            const synced = await Promise.all(runs.map(async (entry) => entry.status === 'running'
+                ? syncRunState({
+                    cwd: process.cwd(),
+                    homeDir: process.env.HA_HOME,
+                }, entry.id)
+                : entry));
+            console.log(renderRunTable(synced));
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    run
+        .command('show')
+        .description('Run show on task executions')
+        .argument('<runId>', 'Run ID')
+        .action(async (runId) => {
+        try {
+            const current = await syncRunState({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+            }, runId);
+            console.log(JSON.stringify(current, null, 2));
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    run
+        .command('logs')
+        .description('Run logs on task executions')
+        .argument('<runId>', 'Run ID')
+        .action(async (runId) => {
+        try {
+            const logs = await collectRunOutput({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+            }, runId);
+            console.log(logs || '(empty)');
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    run
+        .command('attach')
+        .description('Run attach on task executions')
+        .argument('<runId>', 'Run ID')
+        .action(async (runId) => {
+        try {
+            console.log(await getRunAttachCommand({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+            }, runId));
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    run
+        .command('stop')
+        .description('Run stop on task executions')
+        .argument('<runId>', 'Run ID')
+        .action(async (runId) => {
+        try {
+            await stopTaskRun({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+            }, runId);
+            const stopped = await getRun({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                runId,
+                scope: 'all',
+            });
+            console.log(`Stopped run ${stopped.id}`);
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+}

package/dist/src/cli/commands/schedule.js

@@ -0,0 +1,105 @@
+import { addSchedule, listSchedules, removeSchedule, triggerSchedule } from '../../core/scheduler.js';
+import { readConfig, resolveStoreDir } from '../../core/store.js';
+import { renderTable } from '../utils/output.js';
+export function registerScheduleCommand(program) {
+    const schedule = program
+        .command('schedule')
+        .description('Manage scheduled task creation and execution');
+    schedule
+        .command('add')
+        .description('Add a new schedule entry')
+        .requiredOption('--name <name>', 'Schedule name')
+        .requiredOption('--cron <expr>', 'Cron expression')
+        .option('--command <command>', 'Command to execute')
+        .option('--auto', 'Run the next unlocked L1 task automatically')
+        .option('--tool <tool>', 'Tool used with --auto, defaults to config.defaultAgent')
+        .action(async (options) => {
+        try {
+            const command = await resolveScheduleCommand(options);
+            const created = await addSchedule({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                name: options.name,
+                cron: options.cron,
+                command,
+            });
+            console.log(`Added schedule ${created.name}`);
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    schedule
+        .command('list')
+        .description('List configured schedule entries')
+        .action(async () => {
+        try {
+            const schedules = await listSchedules({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+            });
+            console.log(renderTable(schedules.map((entry) => ({
+                name: entry.name,
+                status: entry.enabled ? 'enabled' : 'disabled',
+                detail: `${entry.cron} | ${entry.command}`,
+            }))));
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    schedule
+        .command('remove')
+        .description('Remove a schedule entry')
+        .argument('<name>', 'Schedule name')
+        .action(async (name) => {
+        try {
+            await removeSchedule({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                name,
+            });
+            console.log(`Removed schedule ${name}`);
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    schedule
+        .command('trigger')
+        .description('Trigger a schedule entry immediately')
+        .argument('<name>', 'Schedule name')
+        .action(async (name) => {
+        try {
+            await triggerSchedule({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                name,
+            });
+            console.log(`Triggered schedule ${name}`);
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+}
+async function resolveScheduleCommand(options) {
+    if (options.auto) {
+        const storeDir = resolveStoreDir({
+            cwd: process.cwd(),
+            homeDir: process.env.HA_HOME,
+            scope: 'global',
+        });
+        const config = await readConfig(storeDir);
+        const tool = options.tool ?? config.defaultAgent;
+        return `ha run start --auto --tool ${tool}`;
+    }
+    if (!options.command) {
+        throw new Error('--command is required unless --auto is set');
+    }
+    return options.command;
+}

package/dist/src/cli/commands/task.js

@@ -0,0 +1,188 @@
+import { createTask, failTask, getTaskGraph, listTasks, showTask, updateTaskStatus, } from '../../core/task-manager.js';
+import { renderTaskGraphAscii, renderTaskGraphMermaid, renderTaskTable, } from '../utils/output.js';
+import { taskLevelSchema, taskStatusSchema } from '../../types/index.js';
+export function registerTaskCommand(program) {
+    const task = program.command('task').description('Create and inspect tasks');
+    task
+        .command('create')
+        .description('Create a new task from inline text or a markdown file')
+        .argument('[title]', 'Task title')
+        .option('--level <level>', 'Task level: L1, L2, or L3')
+        .option('--deps <ids>', 'Comma-separated dependency task IDs')
+        .option('--assignee <assignee>', 'Task assignee: claude, codex, human, or auto')
+        .option('--global', 'Create the task in ~/.ha instead of the project store')
+        .option('--file <file>', 'Import task content from a markdown file')
+        .addHelpText('after', '\nExamples:\n  $ ha task create "为认证模块编写单元测试" --level L1 --deps 2 --assignee claude\n  $ ha task create --global "每日 lint 检查" --level L1\n  $ ha task create --file ./my-task.md')
+        .action(async (title, options) => {
+        try {
+            const created = await createTask({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                title,
+                level: taskLevelSchema.parse(options.level ?? 'L1'),
+                assignee: options.assignee,
+                deps: parseDeps(options.deps),
+                scope: options.global ? 'global' : 'project',
+                file: options.file,
+            });
+            console.log(`Created task #${created.task.id}: ${created.task.title} [${created.task.level}]`);
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    task
+        .command('list')
+        .description('List tasks from project, global, or aggregated stores')
+        .option('--global', 'Read from ~/.ha')
+        .option('--all', 'Read from all configured stores')
+        .option('--level <level>', 'Filter by level')
+        .option('--status <status>', 'Filter by status')
+        .action(async (options) => {
+        try {
+            const tasks = await listTasks({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                scope: options.all ? 'all' : options.global ? 'global' : 'project',
+                level: options.level ? taskLevelSchema.parse(options.level) : undefined,
+                status: options.status ? taskStatusSchema.parse(options.status) : undefined,
+            });
+            console.log(renderTaskTable(tasks.map((item) => ({
+                id: item.id,
+                level: item.level,
+                status: item.status,
+                title: item.title,
+                updated: item.updated,
+            }))));
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    task
+        .command('show')
+        .description('Show the full markdown task document')
+        .argument('<id>', 'Task ID')
+        .action(async (id) => {
+        try {
+            const raw = await showTask({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                id: Number(id),
+            });
+            process.stdout.write(raw);
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    task
+        .command('update')
+        .description('Update task metadata or status')
+        .argument('<id>', 'Task ID')
+        .option('--status <status>', 'New task status')
+        .action(async (id, options) => {
+        try {
+            if (!options.status) {
+                throw new Error('--status is required');
+            }
+            const updated = await updateTaskStatus({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                id: Number(id),
+                status: taskStatusSchema.parse(options.status),
+                actor: 'system',
+            });
+            console.log(`Updated task #${updated.id} -> ${updated.status}`);
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    task
+        .command('complete')
+        .description('Mark a task as completed')
+        .argument('<id>', 'Task ID')
+        .action(async (id) => {
+        try {
+            const updated = await updateTaskStatus({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                id: Number(id),
+                status: 'completed',
+                actor: 'system',
+            });
+            console.log(`Completed task #${updated.id}`);
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    task
+        .command('fail')
+        .description('Mark a task as failed')
+        .argument('<id>', 'Task ID')
+        .option('--reason <reason>', 'Failure reason')
+        .action(async (id, options) => {
+        try {
+            const updated = await failTask({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                id: Number(id),
+                actor: 'system',
+                reason: options.reason,
+            });
+            console.log(`Failed task #${updated.id}`);
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+    task
+        .command('graph')
+        .description('Render the task DAG')
+        .option('--format <format>', 'Output format, for example ascii or mermaid')
+        .option('--all', 'Aggregate all configured stores')
+        .action(async (options) => {
+        try {
+            const graph = await getTaskGraph({
+                cwd: process.cwd(),
+                homeDir: process.env.HA_HOME,
+                scope: options.all ? 'all' : 'project',
+            });
+            if (options.format === 'mermaid') {
+                console.log(renderTaskGraphMermaid(graph.tasks.map((task) => ({
+                    id: task.id,
+                    level: task.level,
+                    title: task.title,
+                })), graph.edges));
+                return;
+            }
+            console.log(renderTaskGraphAscii(graph.tasks.map((task) => ({
+                id: task.id,
+                level: task.level,
+                status: task.status,
+                title: task.title,
+            })), graph.edges));
+        }
+        catch (error) {
+            process.exitCode = 1;
+            console.error(error.message);
+        }
+    });
+}
+function parseDeps(value) {
+    if (!value) {
+        return [];
+    }
+    return value
+        .split(',')
+        .map((part) => Number.parseInt(part.trim(), 10))
+        .filter((part) => Number.isFinite(part));
+}

package/dist/src/cli/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerDaemonCommand } from './commands/daemon.js';
+import { registerDoctorCommand } from './commands/doctor.js';
+import { registerHookCommand } from './commands/hook.js';
+import { registerInitCommand } from './commands/init.js';
+import { registerRunCommand } from './commands/run.js';
+import { registerScheduleCommand } from './commands/schedule.js';
+import { registerTaskCommand } from './commands/task.js';
+const program = new Command();
+program
+    .name('ha')
+    .description('Agent-first task orchestration CLI')
+    .showHelpAfterError()
+    .showSuggestionAfterError();
+registerInitCommand(program);
+registerDoctorCommand(program);
+registerHookCommand(program);
+registerTaskCommand(program);
+registerScheduleCommand(program);
+registerDaemonCommand(program);
+registerRunCommand(program);
+await program.parseAsync(process.argv);

package/dist/src/cli/utils/notify.js

@@ -0,0 +1,32 @@
+export function buildNotification(type, taskId, title) {
+    const taskLabel = `Task #${taskId} "${title}"`;
+    switch (type) {
+        case 'task.completed':
+            return { title: `${taskLabel} 已完成`, message: '任务已完成', open: 'http://localhost:3777' };
+        case 'task.failed':
+            return { title: `${taskLabel} 执行失败`, message: '任务执行失败', open: 'http://localhost:3777' };
+        case 'task.paused':
+            return { title: `${taskLabel} 会话已暂停`, message: '请检查 agent 会话状态', open: 'http://localhost:3777' };
+        case 'task.waiting-review':
+            return { title: `${taskLabel} 需要你的 review`, message: '任务等待 review', open: 'http://localhost:3777' };
+        case 'task.dependency_unlocked':
+            return { title: `Task #${taskId} 已解锁`, message: title, open: 'http://localhost:3777' };
+        default:
+            return null;
+    }
+}
+export async function notifyTaskEvent(event, adapter = defaultNotifyAdapter) {
+    const payload = buildNotification(event.type, event.taskId, event.title);
+    if (!payload) {
+        return;
+    }
+    await adapter(payload);
+}
+async function defaultNotifyAdapter(payload) {
+    const notifierModule = (await import('node-notifier'));
+    const notify = notifierModule.default?.notify ?? notifierModule.notify;
+    if (!notify) {
+        throw new Error('node-notifier notify function is unavailable');
+    }
+    notify(payload);
+}

package/dist/src/cli/utils/output.js

@@ -0,0 +1,94 @@
+import chalk from 'chalk';
+export function renderComingSoon(commandName) {
+    return `${commandName} is coming soon`;
+}
+export function renderTable(rows) {
+    const nameWidth = Math.max('Check'.length, ...rows.map((row) => row.name.length));
+    const statusWidth = Math.max('Status'.length, ...rows.map((row) => row.status.length));
+    const header = [
+        'Check'.padEnd(nameWidth),
+        'Status'.padEnd(statusWidth),
+        'Detail',
+    ].join(' | ');
+    const divider = [
+        '-'.repeat(nameWidth),
+        '-'.repeat(statusWidth),
+        '------',
+    ].join('-|-');
+    const lines = rows.map((row) => [row.name.padEnd(nameWidth), row.status.padEnd(statusWidth), row.detail].join(' | '));
+    return [header, divider, ...lines].join('\n');
+}
+export function renderTaskTable(tasks) {
+    const headers = ['ID', 'Level', 'Status', 'Title', 'Updated'];
+    const rows = tasks.map((task) => [
+        String(task.id),
+        colorizeLevel(task.level),
+        task.status,
+        task.title,
+        task.updated,
+    ]);
+    const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => stripAnsi(row[index] ?? '').length)));
+    const header = headers
+        .map((value, index) => value.padEnd(widths[index] ?? value.length))
+        .join(' | ');
+    const divider = widths.map((width) => '-'.repeat(width)).join('-|-');
+    const lines = rows.map((row) => row
+        .map((value, index) => padAnsi(value, widths[index] ?? stripAnsi(value).length))
+        .join(' | '));
+    return [header, divider, ...lines].join('\n');
+}
+export function renderTaskGraphAscii(tasks, edges) {
+    const lines = [];
+    for (const task of tasks) {
+        lines.push(`[${task.id}] [${task.level}] [${task.status}] ${task.title}`);
+        for (const edge of edges.filter((entry) => entry.to === task.id)) {
+            lines.push(`  └─ depends on [${edge.from}]`);
+        }
+    }
+    return lines.join('\n');
+}
+export function renderTaskGraphMermaid(tasks, edges) {
+    const nodes = tasks.map((task) => `${task.id}["[${task.level}] ${task.title}"]`);
+    const connectors = edges.map((edge) => `${edge.from}["${nodeLabel(tasks, edge.from)}"] --> ${edge.to}["${nodeLabel(tasks, edge.to)}"]`);
+    return ['graph TD', ...nodes, ...connectors].join('\n');
+}
+export function renderRunTable(runs) {
+    const headers = ['Run', 'Task', 'Tool', 'Status', 'Started', 'Session'];
+    const rows = runs.map((run) => [
+        run.id,
+        String(run.taskId),
+        run.tool,
+        run.status,
+        run.startedAt,
+        run.tmuxSession,
+    ]);
+    const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index]?.length ?? 0)));
+    return [
+        headers.map((header, index) => header.padEnd(widths[index] ?? header.length)).join(' | '),
+        widths.map((width) => '-'.repeat(width)).join('-|-'),
+        ...rows.map((row) => row
+            .map((value, index) => value.padEnd(widths[index] ?? value.length))
+            .join(' | ')),
+    ].join('\n');
+}
+function colorizeLevel(level) {
+    if (level === 'L1') {
+        return chalk.green(level);
+    }
+    if (level === 'L2') {
+        return chalk.yellow(level);
+    }
+    return chalk.red(level);
+}
+function nodeLabel(tasks, id) {
+    const task = tasks.find((entry) => entry.id === id);
+    return task ? `[${task.level}] ${task.title}` : String(id);
+}
+function stripAnsi(value) {
+    const escape = String.fromCharCode(27);
+    return value.replace(new RegExp(`${escape}\\[[0-9;]*m`, 'g'), '');
+}
+function padAnsi(value, width) {
+    const visibleLength = stripAnsi(value).length;
+    return `${value}${' '.repeat(Math.max(0, width - visibleLength))}`;
+}