harness-async 0.1.0

package/dist/src/core/store.js

@@ -0,0 +1,225 @@
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import matter from 'gray-matter';
+import { detectCycle } from './dag.js';
+import { readEvents } from './event-log.js';
+import { withLock } from './lock.js';
+import { configSchema, indexFileSchema, taskFrontmatterSchema, taskSchema, } from '../types/index.js';
+const INDEX_FILE = 'index.json';
+function slugifyTitle(title) {
+    return title
+        .trim()
+        .toLowerCase()
+        .replace(/[^\p{Letter}\p{Number}]+/gu, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80);
+}
+function formatTaskFilename(task) {
+    const slug = slugifyTitle(task.title) || `task-${task.id}`;
+    return `${String(task.id).padStart(3, '0')}-${slug}.md`;
+}
+function serializeFrontmatter(task) {
+    return {
+        id: task.id,
+        title: task.title,
+        level: task.level,
+        status: task.status,
+        deps: task.deps,
+        blocks: task.blocks,
+        assignee: task.assignee,
+        scope: task.scope,
+        project: task.project ?? null,
+        created: task.created,
+        updated: task.updated,
+        tags: task.tags,
+        checkpoint: task.checkpoint,
+        estimated_effort: task.estimatedEffort,
+    };
+}
+function parseFrontmatter(raw) {
+    const parsed = matter(raw);
+    const frontmatter = taskFrontmatterSchema.parse({
+        ...parsed.data,
+        estimatedEffort: parsed.data.estimated_effort,
+    });
+    return taskSchema.parse({
+        ...frontmatter,
+        project: frontmatter.project ?? null,
+        body: parsed.content.trimStart(),
+    });
+}
+export function defaultConfig() {
+    return configSchema.parse({
+        defaultAgent: 'claude',
+        notify: {
+            enabled: true,
+        },
+        dashboardPort: 3777,
+    });
+}
+export function defaultIndexFile(now) {
+    return indexFileSchema.parse({
+        version: 1,
+        nextId: 1,
+        tasks: {},
+        dag: {
+            edges: [],
+        },
+        lastUpdated: now,
+    });
+}
+export async function createTaskFile(tasksDir, task) {
+    await mkdir(tasksDir, { recursive: true });
+    const filePath = join(tasksDir, formatTaskFilename(task));
+    const raw = matter.stringify(task.body, serializeFrontmatter(task));
+    await writeFile(filePath, raw, 'utf8');
+    return filePath;
+}
+export async function readTaskFile(filePath) {
+    const raw = await readFile(filePath, 'utf8');
+    return parseFrontmatter(raw);
+}
+export async function updateTaskFile(filePath, updates) {
+    const current = await readTaskFile(filePath);
+    const updated = taskSchema.parse({
+        ...current,
+        ...updates,
+        updated: updates.updated ?? new Date().toISOString(),
+        body: updates.body ?? current.body,
+    });
+    const raw = matter.stringify(updated.body, serializeFrontmatter(updated));
+    await writeFile(filePath, raw, 'utf8');
+}
+export async function deleteTaskFile(filePath) {
+    await rm(filePath, { force: true });
+}
+export async function readIndex(storeDir) {
+    const raw = await readFile(join(storeDir, INDEX_FILE), 'utf8');
+    return indexFileSchema.parse(JSON.parse(raw));
+}
+export async function readConfig(storeDir) {
+    const raw = await readFile(join(storeDir, 'config.json'), 'utf8');
+    return configSchema.parse(JSON.parse(raw));
+}
+export async function writeIndex(storeDir, index) {
+    const filePath = join(storeDir, INDEX_FILE);
+    const tempPath = `${filePath}.tmp`;
+    await mkdir(storeDir, { recursive: true });
+    await writeFile(tempPath, `${JSON.stringify(indexFileSchema.parse(index), null, 2)}\n`, 'utf8');
+    await rename(tempPath, filePath);
+}
+function indexRecordFromTask(task, file) {
+    return {
+        level: task.level,
+        status: task.status,
+        deps: [...task.deps],
+        file,
+        scope: task.scope,
+    };
+}
+export function addToIndex(index, task, file) {
+    index.tasks[String(task.id)] = indexRecordFromTask(task, file);
+    index.nextId = Math.max(index.nextId, task.id + 1);
+    index.lastUpdated = task.updated;
+}
+export function updateInIndex(index, taskId, updates) {
+    const key = String(taskId);
+    const current = index.tasks[key];
+    if (!current) {
+        throw new Error(`Task ${taskId} not found in index`);
+    }
+    index.tasks[key] = {
+        ...current,
+        ...updates,
+    };
+}
+export function getFromIndex(index, taskId) {
+    return index.tasks[String(taskId)];
+}
+export function addDependency(index, taskId, depId) {
+    const task = getFromIndex(index, taskId);
+    if (!task) {
+        throw new Error(`Task ${taskId} not found in index`);
+    }
+    if (!task.deps.includes(depId)) {
+        task.deps.push(depId);
+    }
+    const edgeExists = index.dag.edges.some((edge) => edge.from === String(depId) && edge.to === String(taskId));
+    if (!edgeExists) {
+        index.dag.edges.push({
+            from: String(depId),
+            to: String(taskId),
+            type: 'depends-on',
+        });
+    }
+}
+export function removeDependency(index, taskId, depId) {
+    const task = getFromIndex(index, taskId);
+    if (!task) {
+        throw new Error(`Task ${taskId} not found in index`);
+    }
+    task.deps = task.deps.filter((id) => id !== depId);
+    index.dag.edges = index.dag.edges.filter((edge) => !(edge.from === String(depId) && edge.to === String(taskId)));
+}
+export function getDependents(index, taskId) {
+    return index.dag.edges
+        .filter((edge) => edge.from === String(taskId))
+        .map((edge) => Number(edge.to));
+}
+export function getDependencies(index, taskId) {
+    return getFromIndex(index, taskId)?.deps ?? [];
+}
+function resolveHomeDir(homeDir) {
+    return homeDir ?? process.env.HA_HOME ?? process.env.HOME ?? '';
+}
+export function resolveStoreDir(options) {
+    if (options.scope === 'global') {
+        return join(resolveHomeDir(options.homeDir), '.ha');
+    }
+    return join(options.cwd, '.ha');
+}
+export async function initializeStore(options) {
+    const now = options.now ?? new Date().toISOString();
+    const storeDir = resolveStoreDir(options);
+    const tasksDir = join(storeDir, 'tasks');
+    let created = false;
+    await mkdir(tasksDir, { recursive: true });
+    async function writeJsonIfMissing(filePath, value) {
+        try {
+            await readFile(filePath, 'utf8');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            created = true;
+            await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        }
+    }
+    async function writeTextIfMissing(filePath, value = '') {
+        try {
+            await readFile(filePath, 'utf8');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            created = true;
+            await writeFile(filePath, value, 'utf8');
+        }
+    }
+    await writeJsonIfMissing(join(storeDir, 'config.json'), defaultConfig());
+    await writeJsonIfMissing(join(storeDir, INDEX_FILE), defaultIndexFile(now));
+    await writeTextIfMissing(join(storeDir, 'events.ndjson'));
+    if (options.scope === 'global') {
+        await writeJsonIfMissing(join(storeDir, 'schedule.json'), []);
+        await writeJsonIfMissing(join(storeDir, 'daemon.json'), {});
+        await writeJsonIfMissing(join(storeDir, 'projects.json'), []);
+    }
+    return {
+        created,
+        scope: options.scope,
+        storeDir,
+    };
+}
+export { detectCycle, readEvents, withLock };

package/dist/src/core/task-manager.js

@@ -0,0 +1,375 @@
+import { readFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { addDependency, addToIndex, createTaskFile, getDependents, getDependencies, readIndex, readTaskFile, updateTaskFile, updateInIndex, resolveStoreDir, withLock, writeIndex, } from './store.js';
+import { appendEvent } from './event-log.js';
+import { readEvents } from './event-log.js';
+import { getExecutionOrder } from './dag.js';
+import { taskLevelSchema, taskStatusSchema } from '../types/index.js';
+export async function createTask(input) {
+    const storeDir = resolveStoreDir({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        scope: input.scope,
+    });
+    const indexPath = join(storeDir, 'index.json');
+    return withLock(indexPath, async () => {
+        const index = await readIndex(storeDir);
+        const now = new Date().toISOString();
+        const deps = input.deps ?? [];
+        for (const depId of deps) {
+            if (!index.tasks[String(depId)]) {
+                throw new Error(`Dependency task ${depId} not found`);
+            }
+        }
+        const importedBody = input.file ? await readFile(input.file, 'utf8') : '';
+        const title = input.title ?? (input.file ? basename(input.file) : undefined);
+        if (!title) {
+            throw new Error('Task title is required');
+        }
+        const task = {
+            id: index.nextId,
+            title,
+            level: taskLevelSchema.parse(input.level),
+            status: 'pending',
+            deps,
+            blocks: [],
+            assignee: input.assignee ?? 'auto',
+            scope: input.scope,
+            project: input.scope === 'project' ? input.cwd : null,
+            created: now,
+            updated: now,
+            tags: [],
+            checkpoint: null,
+            estimatedEffort: 'medium',
+            body: importedBody,
+        };
+        const filePath = await createTaskFile(join(storeDir, 'tasks'), task);
+        addToIndex(index, task, basename(filePath));
+        for (const depId of deps) {
+            addDependency(index, task.id, depId);
+        }
+        await writeIndex(storeDir, index);
+        await appendEvent(storeDir, {
+            ts: now,
+            type: 'task.created',
+            taskId: task.id,
+            actor: 'system',
+            detail: {
+                title: task.title,
+                level: task.level,
+            },
+        });
+        return { task, filePath };
+    });
+}
+export async function listTasks(input) {
+    const stores = await resolveTaskStores(input);
+    const tasks = (await Promise.all(stores.map(async (storeDir) => readTasksFromStore(storeDir)))).flat();
+    return tasks.filter((task) => {
+        if (input.level && task.level !== input.level) {
+            return false;
+        }
+        if (input.status && task.status !== input.status) {
+            return false;
+        }
+        return true;
+    });
+}
+export async function showTask(input) {
+    const stores = await resolveTaskStores({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        scope: input.scope ?? 'project',
+    });
+    for (const storeDir of stores) {
+        try {
+            const index = await readIndex(storeDir);
+            const record = index.tasks[String(input.id)];
+            if (!record) {
+                continue;
+            }
+            return readFile(join(storeDir, 'tasks', record.file), 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error(`Task ${input.id} not found`);
+}
+export async function getTask(input) {
+    const location = await findTaskLocation({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        id: input.id,
+        scope: input.scope ?? 'project',
+    });
+    if (!location) {
+        throw new Error(`Task ${input.id} not found`);
+    }
+    return readTaskFile(location.filePath);
+}
+export async function getTaskEvents(input) {
+    const location = await findTaskLocation({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        id: input.id,
+        scope: input.scope ?? 'project',
+    });
+    if (!location) {
+        throw new Error(`Task ${input.id} not found`);
+    }
+    return readEvents(location.storeDir, {
+        taskId: input.id,
+    });
+}
+export function transitionTask(task, newStatus, depsSatisfied) {
+    const currentStatus = task.status;
+    const allowed = (currentStatus === 'pending' && newStatus === 'running' && depsSatisfied) ||
+        (currentStatus === 'running' && newStatus === 'waiting-review' && task.level === 'L2') ||
+        (currentStatus === 'running' && (newStatus === 'completed' || newStatus === 'failed' || newStatus === 'paused')) ||
+        (currentStatus === 'waiting-review' && newStatus === 'completed') ||
+        (currentStatus === 'failed' && newStatus === 'running' && depsSatisfied) ||
+        (currentStatus === 'paused' && newStatus === 'running' && depsSatisfied);
+    if (!allowed) {
+        throw new Error(`Invalid status transition: ${currentStatus} -> ${newStatus}`);
+    }
+    return {
+        ...task,
+        status: newStatus,
+        updated: new Date().toISOString(),
+    };
+}
+export async function updateTaskStatus(input) {
+    const location = await findTaskLocation(input);
+    if (!location) {
+        throw new Error(`Task ${input.id} not found`);
+    }
+    return withLock(join(location.storeDir, 'index.json'), async () => {
+        const index = await readIndex(location.storeDir);
+        const task = await readTaskFile(location.filePath);
+        const depsSatisfied = getDependencies(index, task.id).every((depId) => index.tasks[String(depId)]?.status === 'completed');
+        const nextTask = transitionTask(task, taskStatusSchema.parse(input.status), depsSatisfied);
+        const nextBody = input.reason && nextTask.status === 'failed'
+            ? appendFailureReason(task.body, input.reason)
+            : task.body;
+        await updateTaskFile(location.filePath, {
+            ...nextTask,
+            body: nextBody,
+        });
+        updateInIndex(index, task.id, {
+            status: nextTask.status,
+        });
+        index.lastUpdated = nextTask.updated;
+        await writeIndex(location.storeDir, index);
+        await appendEvent(location.storeDir, {
+            ts: nextTask.updated,
+            type: 'task.status_changed',
+            taskId: task.id,
+            actor: input.actor,
+            from: task.status,
+            to: nextTask.status,
+            detail: input.reason ? { reason: input.reason } : {},
+        });
+        if (nextTask.status === 'completed') {
+            for (const dependentId of getDependents(index, task.id)) {
+                const unlocked = getDependencies(index, dependentId).every((depId) => index.tasks[String(depId)]?.status === 'completed');
+                if (unlocked) {
+                    await appendEvent(location.storeDir, {
+                        ts: nextTask.updated,
+                        type: 'task.dependency_unlocked',
+                        taskId: dependentId,
+                        actor: input.actor,
+                        detail: {
+                            unlockedBy: task.id,
+                        },
+                    });
+                }
+            }
+        }
+        return {
+            ...nextTask,
+            body: nextBody,
+        };
+    });
+}
+export async function failTask(input) {
+    return updateTaskStatus({
+        ...input,
+        status: 'failed',
+    });
+}
+export async function getTaskGraph(input) {
+    const stores = await resolveTaskStores(input);
+    const tasks = (await Promise.all(stores.map(async (storeDir) => readTasksFromStore(storeDir)))).flat();
+    const edges = (await Promise.all(stores.map(async (storeDir) => {
+        try {
+            const index = await readIndex(storeDir);
+            return index.dag.edges.map((edge) => ({
+                from: Number(edge.from),
+                to: Number(edge.to),
+            }));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }))).flat();
+    const byId = new Map(tasks.map((task) => [task.id, task]));
+    const orderedTasks = getOrderedTasks(tasks, edges, byId);
+    return {
+        tasks: orderedTasks,
+        edges,
+    };
+}
+export async function findTaskLocation(input) {
+    return resolveTaskLocation(input);
+}
+export async function listRunnableTasks(input) {
+    const stores = await resolveTaskStores(input);
+    const tasksByStore = await Promise.all(stores.map(async (storeDir) => {
+        try {
+            const index = await readIndex(storeDir);
+            const tasks = await readTasksFromStore(storeDir);
+            return tasks.filter((task) => {
+                if (task.status !== 'pending') {
+                    return false;
+                }
+                return getDependencies(index, task.id).every((depId) => index.tasks[String(depId)]?.status === 'completed');
+            });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }));
+    return tasksByStore.flat().filter((task) => {
+        if (input.level && task.level !== input.level) {
+            return false;
+        }
+        if (input.status && task.status !== input.status) {
+            return false;
+        }
+        return true;
+    });
+}
+async function resolveTaskStores(input) {
+    if (input.scope === 'project') {
+        return [resolveStoreDir({ cwd: input.cwd, homeDir: input.homeDir, scope: 'project' })];
+    }
+    if (input.scope === 'global') {
+        return [resolveStoreDir({ cwd: input.cwd, homeDir: input.homeDir, scope: 'global' })];
+    }
+    const globalStore = resolveStoreDir({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        scope: 'global',
+    });
+    const projectStore = resolveStoreDir({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        scope: 'project',
+    });
+    const stores = new Set([projectStore, globalStore]);
+    try {
+        const projects = JSON.parse(await readFile(join(globalStore, 'projects.json'), 'utf8'));
+        for (const projectDir of projects) {
+            stores.add(join(projectDir, '.ha'));
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    return [...stores];
+}
+async function readTasksFromStore(storeDir) {
+    try {
+        const index = await readIndex(storeDir);
+        const records = Object.entries(index.tasks);
+        return Promise.all(records.map(async ([taskId, record]) => {
+            const task = await readTaskFile(join(storeDir, 'tasks', record.file));
+            return {
+                ...task,
+                id: Number(taskId),
+            };
+        }));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+async function resolveTaskLocation(input) {
+    const stores = await resolveTaskStores({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        scope: input.scope ?? 'project',
+    });
+    for (const storeDir of stores) {
+        try {
+            const index = await readIndex(storeDir);
+            const record = index.tasks[String(input.id)];
+            if (!record) {
+                continue;
+            }
+            return {
+                storeDir,
+                filePath: join(storeDir, 'tasks', record.file),
+            };
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                continue;
+            }
+            throw error;
+        }
+    }
+    return null;
+}
+function appendFailureReason(body, reason) {
+    const trimmedBody = body.trimEnd();
+    const prefix = trimmedBody.length > 0 ? `${trimmedBody}\n\n` : '';
+    return `${prefix}## Failure reason\n${reason}\n`;
+}
+function getOrderedTasks(tasks, edges, byId) {
+    const ids = tasks.map((task) => String(task.id));
+    const index = {
+        version: 1,
+        nextId: 1,
+        tasks: Object.fromEntries(tasks.map((task) => [
+            String(task.id),
+            {
+                level: task.level,
+                status: task.status,
+                deps: task.deps,
+                file: '',
+                scope: task.scope,
+            },
+        ])),
+        dag: {
+            edges: edges.map((edge) => ({
+                from: String(edge.from),
+                to: String(edge.to),
+                type: 'depends-on',
+            })),
+        },
+        lastUpdated: new Date().toISOString(),
+    };
+    const order = getExecutionOrder(index).filter((id) => ids.includes(String(id)));
+    if (order.length === 0) {
+        return [...tasks].sort((left, right) => left.id - right.id);
+    }
+    return order
+        .map((id) => byId.get(id))
+        .filter((task) => Boolean(task));
+}

package/dist/src/core/tmux.js

@@ -0,0 +1,51 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export function createTmuxRunner(tmuxBin = 'tmux') {
+    return async (args, options = {}) => {
+        const result = await execFileAsync(tmuxBin, args, {
+            cwd: options.cwd,
+        });
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+        };
+    };
+}
+export async function createTmuxSession(input) {
+    const runTmux = input.runTmux ?? createTmuxRunner();
+    const args = ['new-session', '-d', '-s', input.sessionName];
+    if (input.cwd) {
+        args.push('-c', input.cwd);
+    }
+    args.push(input.command);
+    await runTmux(args, { cwd: input.cwd });
+    if (input.logFile) {
+        await runTmux(['pipe-pane', '-o', '-t', input.sessionName, `cat >> ${quoteShell(input.logFile)}`], { cwd: input.cwd });
+    }
+}
+export function attachTmuxSession(sessionName) {
+    return `tmux attach -t ${sessionName}`;
+}
+export async function killTmuxSession(sessionName, options = {}) {
+    const runTmux = options.runTmux ?? createTmuxRunner();
+    await runTmux(['kill-session', '-t', sessionName], { cwd: options.cwd });
+}
+export async function isTmuxSessionAlive(sessionName, options = {}) {
+    const runTmux = options.runTmux ?? createTmuxRunner();
+    try {
+        await runTmux(['has-session', '-t', sessionName], { cwd: options.cwd });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getTmuxSessionOutput(sessionName, options = {}) {
+    const runTmux = options.runTmux ?? createTmuxRunner();
+    const result = await runTmux(['capture-pane', '-t', sessionName, '-p'], { cwd: options.cwd });
+    return result.stdout;
+}
+function quoteShell(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/dist/src/daemon.js

@@ -0,0 +1,35 @@
+import { join } from 'node:path';
+import { initializeStore } from './core/store.js';
+import { startDaemonRuntime } from './core/daemon.js';
+import { startDashboardServer } from './dashboard/server.js';
+const cwd = process.env.HA_PROJECT_ROOT ?? process.cwd();
+const homeDir = process.env.HA_HOME;
+await initializeStore({
+    cwd,
+    homeDir,
+    scope: 'global',
+});
+const runtime = await startDaemonRuntime({
+    cwd,
+    homeDir,
+    logger: (message) => {
+        console.error(message);
+    },
+});
+const dashboard = await startDashboardServer({
+    cwd,
+    homeDir,
+    port: Number(process.env.HA_DASHBOARD_PORT ?? '3777'),
+    staticDir: process.env.HA_DASHBOARD_STATIC_DIR ?? join(cwd, 'dist', 'dashboard'),
+});
+const shutdown = async () => {
+    await dashboard.stop();
+    await runtime.stop();
+    process.exit(0);
+};
+process.on('SIGINT', () => {
+    void shutdown();
+});
+process.on('SIGTERM', () => {
+    void shutdown();
+});