tasktui 1.0.0

package/README.md

@@ -0,0 +1,21 @@
+# tasktui
+
+Run tasks in a multiplexed terminal with dependency management.
+
+## Install
+
+```sh
+$ npm install --save-dev task-tui
+```
+
+## Usage
+
+```
+$ task-tui --help
+
+	Usage
+	  $ tasktui [--config <PATH> | --help]
+
+	Options
+		--config Path to config file (default: ./tasktui.config.json)
+```

package/dist/app.d.ts

@@ -0,0 +1,3 @@
+declare const ui: import("./ui.js").UIComponents;
+export declare function loadAndProcessConfig(configPath?: string): void;
+export default ui;

package/dist/app.js

@@ -0,0 +1,71 @@
+import { render, showError } from './renderer.js';
+import { createState, getAllTasksInOrder } from './state.js';
+import { cleanup, ensureDependencies, spawnTask } from './tasks.js';
+import { createUI } from './ui.js';
+import { ensureError, loadConfig } from './utils.js';
+const ui = createUI();
+const state = createState();
+function handleMove(steps) {
+    const allTasks = getAllTasksInOrder(state);
+    if (allTasks.length === 0)
+        return;
+    const selectedIndex = allTasks.indexOf(state.selectedTask);
+    const newIndex = (selectedIndex + steps + allTasks.length) % allTasks.length;
+    const newTask = allTasks[newIndex];
+    if (newTask) {
+        state.selectedTask = newTask;
+        render(ui, state);
+    }
+}
+export function loadAndProcessConfig(configPath) {
+    try {
+        const config = loadConfig(configPath);
+        state.config = config;
+        const tasks = config?.tasks ?? {};
+        if (!Object.keys(tasks).length && state.init) {
+            cleanup(state);
+            process.exit(0);
+        }
+        state.init = true;
+        state.tasks = tasks;
+        // Process tasks
+        for (const [name, task] of Object.entries(tasks)) {
+            if (state.spawnedTasks.has(name))
+                continue;
+            state.spawnedTasks.add(name);
+            if (task.dependsOn.length) {
+                const allDepsExist = ensureDependencies(name, task.dependsOn, state);
+                if (!allDepsExist)
+                    continue;
+                state.queue.push({
+                    name,
+                    task,
+                    remainingDeps: task.dependsOn,
+                });
+                continue;
+            }
+            spawnTask(name, task, state, () => render(ui, state));
+        }
+        render(ui, state);
+    }
+    catch (e) {
+        const error = ensureError(e);
+        showError(error.message, ui, state);
+    }
+}
+// Key bindings
+ui.screen.key(['up', 'k'], () => {
+    handleMove(-1);
+});
+ui.screen.key(['down', 'j'], () => {
+    handleMove(1);
+});
+ui.screen.key(['C-c', 'q'], () => {
+    cleanup(state);
+    process.exit(0);
+});
+// Handle resize
+ui.screen.on('resize', () => {
+    render(ui, state);
+});
+export default ui;

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import meow from 'meow';
+import ui, { loadAndProcessConfig } from './app.js';
+const cli = meow(`
+	Usage
+	  $ tasktui [--config <PATH> | --help]
+
+	Options
+		--config Path to config file (default: ./tasktui.config.json)
+`, {
+    importMeta: import.meta,
+    flags: {
+        config: {
+            type: 'string',
+        },
+        help: {},
+    },
+});
+loadAndProcessConfig(cli.flags.config);
+ui.screen.render();

package/dist/components/SubprocessOutput.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { Task } from '../lib/types.js';
+export default function TaskWindow({ tasks, selected, }: {
+    tasks: Record<string, Task>;
+    selected: string;
+}): React.JSX.Element;

package/dist/components/SubprocessOutput.js

@@ -0,0 +1,21 @@
+import { Box, Text } from 'ink';
+import childProcess from 'node:child_process';
+import React, { useEffect, useState } from 'react';
+import stripAnsi from 'strip-ansi';
+export default function TaskWindow({ tasks, selected, }) {
+    const [buffers, setBuffers] = useState({});
+    useEffect(() => {
+        for (const [name, task] of Object.entries(tasks)) {
+            const subProcess = childProcess.spawn('sh', ['-c', task.command]);
+            subProcess.stdout.on('data', (newOutput) => {
+                const text = stripAnsi(newOutput.toString('utf8')).trim();
+                setBuffers(prev => {
+                    return { ...prev, [name]: text };
+                });
+            });
+        }
+    }, [tasks]);
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { dimColor: true }, selected),
+        React.createElement(Text, null, buffers[selected] ?? '')));
+}

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+declare const CONFIG_PATH = "./tasktui.config.json";
+export { CONFIG_PATH };

package/dist/constants.js

@@ -0,0 +1,2 @@
+const CONFIG_PATH = './tasktui.config.json';
+export { CONFIG_PATH };

package/dist/lib/constants.d.ts

@@ -0,0 +1,2 @@
+declare const CONFIG_PATH = "./task-tui.config.json";
+export { CONFIG_PATH };

package/dist/lib/constants.js

@@ -0,0 +1,2 @@
+const CONFIG_PATH = './task-tui.config.json';
+export { CONFIG_PATH };

package/dist/lib/types.d.ts

@@ -0,0 +1,15 @@
+import z from 'zod';
+export declare const TaskSchema: z.ZodObject<{
+    command: z.ZodString;
+    dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    cwd: z.ZodDefault<z.ZodString>;
+}, z.z.core.$strip>;
+export type Task = z.infer<typeof TaskSchema>;
+export declare const TasksConfigSchema: z.ZodObject<{
+    tasks: z.ZodRecord<z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        cwd: z.ZodDefault<z.ZodString>;
+    }, z.z.core.$strip>>;
+}, z.z.core.$strip>;
+export type TasksConfig = z.infer<typeof TasksConfigSchema>;

package/dist/lib/types.js

@@ -0,0 +1,9 @@
+import z from 'zod';
+export const TaskSchema = z.object({
+    command: z.string(),
+    dependsOn: z.string().array().default([]),
+    cwd: z.string().default(process.cwd()),
+});
+export const TasksConfigSchema = z.object({
+    tasks: z.record(z.string(), TaskSchema),
+});

package/dist/lib/utils.d.ts

@@ -0,0 +1,5 @@
+import z from 'zod';
+import { TasksConfig } from './types.js';
+export default function formatZodError(error: z.ZodError): string;
+export declare function loadConfig(configPath?: string): TasksConfig;
+export declare function ensureError(error: unknown): Error;

package/dist/lib/utils.js

@@ -0,0 +1,44 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import z from 'zod';
+import { CONFIG_PATH } from './constants.js';
+import { TasksConfigSchema } from './types.js';
+function getConfigPath(cliOption) {
+    if (cliOption)
+        return cliOption;
+    return CONFIG_PATH;
+}
+export default function formatZodError(error) {
+    if (error.issues.length === 0) {
+        return 'Unknown Zod error';
+    }
+    const issue = error.issues[0];
+    if (!issue)
+        return error.message;
+    const path = issue.path.join('.');
+    return `${issue.message} at '${path}' [code: ${issue.code}]`;
+}
+export function loadConfig(configPath) {
+    try {
+        const relativePath = path.join(process.cwd(), getConfigPath(configPath));
+        const raw = fs.readFileSync(relativePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return z.parse(TasksConfigSchema, parsed);
+    }
+    catch (e) {
+        const error = ensureError(e);
+        throw error;
+    }
+}
+export function ensureError(error) {
+    if (error instanceof z.ZodError)
+        return new Error(formatZodError(error));
+    if (error instanceof Error)
+        return error;
+    let stringified = '[Unable to stringify the thrown value]';
+    try {
+        stringified = JSON.stringify(error);
+    }
+    catch { }
+    return new Error(stringified);
+}

package/dist/renderer.d.ts

@@ -0,0 +1,4 @@
+import { AppState } from './state.js';
+import { UIComponents } from './ui.js';
+export declare function showError(message: string, ui: UIComponents, state: AppState): void;
+export declare function render(ui: UIComponents, state: AppState): void;

package/dist/renderer.js

@@ -0,0 +1,58 @@
+import { getOrderedTasks } from './state.js';
+export function showError(message, ui, state) {
+    state.error = message;
+    ui.errorBox.setContent(`{red-fg}Error: ${message}{/}`);
+    ui.errorBox.show();
+    ui.screen.render();
+}
+export function render(ui, state) {
+    const { running, queued, completed } = getOrderedTasks(state);
+    const lines = [];
+    // Running section
+    if (running.length > 0) {
+        lines.push(`{gray-fg} Running (${running.length}){/}`);
+        for (const name of running) {
+            const isSelected = name === state.selectedTask;
+            const color = isSelected ? 'yellow-fg' : 'white-fg';
+            lines.push(`{${color}}${name}{/}`);
+        }
+        lines.push('');
+    }
+    // Queued section
+    if (queued.length > 0) {
+        lines.push(`{gray-fg} Queued (${queued.length}){/}`);
+        for (const queueItem of queued) {
+            const isSelected = queueItem.name === state.selectedTask;
+            const color = isSelected ? 'yellow-fg' : 'gray-fg';
+            lines.push(`{${color}}${queueItem.name}{/}`);
+        }
+        lines.push('');
+    }
+    // Completed section
+    if (completed.length > 0) {
+        lines.push(`{gray-fg} Completed (${completed.length}){/}`);
+        for (const name of completed) {
+            const buffer = state.buffers[name];
+            const isSelected = name === state.selectedTask;
+            let statusSymbol = '✓';
+            let color = 'gray-fg';
+            if (buffer?.errored) {
+                statusSymbol = '✗';
+                color = 'red-fg';
+            }
+            if (isSelected) {
+                color = 'yellow-fg';
+            }
+            lines.push(`{${color}}${name}{/} ${statusSymbol}`);
+        }
+    }
+    ui.taskList.setContent(lines.join('\n'));
+    // Update output pane
+    if (state.selectedTask) {
+        ui.taskNameBox.setContent(`{gray-fg}${state.selectedTask}{/}`);
+        const output = state.buffers[state.selectedTask]?.text ?? '';
+        ui.taskOutputBox.setContent(output);
+        ui.taskOutputBox.setScrollPerc(100); // Auto-scroll to bottom
+    }
+    ui.screen.render();
+}

package/dist/state.d.ts

@@ -0,0 +1,31 @@
+import childProcess from 'node:child_process';
+import { Task, TasksConfig } from './types.js';
+export interface TaskBuffer {
+    running: boolean;
+    errored: boolean;
+    text: string;
+}
+export interface QueueItem {
+    name: string;
+    task: Task;
+    remainingDeps: string[];
+}
+export interface AppState {
+    init: boolean;
+    spawnedTasks: Set<string>;
+    childProcesses: Map<string, childProcess.ChildProcess>;
+    taskOrder: string[];
+    config?: TasksConfig;
+    tasks: Record<string, Task>;
+    error: string | null;
+    selectedTask: string;
+    buffers: Record<string, TaskBuffer>;
+    queue: QueueItem[];
+}
+export declare function createState(): AppState;
+export declare function getOrderedTasks(state: AppState): {
+    running: string[];
+    queued: QueueItem[];
+    completed: string[];
+};
+export declare function getAllTasksInOrder(state: AppState): string[];

package/dist/state.js

@@ -0,0 +1,24 @@
+export function createState() {
+    return {
+        init: false,
+        spawnedTasks: new Set(),
+        childProcesses: new Map(),
+        taskOrder: [],
+        config: undefined,
+        tasks: {},
+        error: null,
+        selectedTask: '',
+        buffers: {},
+        queue: [],
+    };
+}
+export function getOrderedTasks(state) {
+    const running = state.taskOrder.filter((name) => state.buffers[name]?.running);
+    const queued = state.queue;
+    const completed = state.taskOrder.filter((name) => state.buffers[name] && !state.buffers[name].running);
+    return { running, queued, completed };
+}
+export function getAllTasksInOrder(state) {
+    const { running, queued, completed } = getOrderedTasks(state);
+    return [...running, ...queued.map((q) => q.name), ...completed];
+}

package/dist/tasks.d.ts

@@ -0,0 +1,5 @@
+import { AppState } from './state.js';
+import { Task } from './types.js';
+export declare function ensureDependencies(task: string, deps: string[], state: AppState): boolean;
+export declare function spawnTask(name: string, task: Task, state: AppState, onUpdate: () => void): void;
+export declare function cleanup(state: AppState): void;

package/dist/tasks.js

@@ -0,0 +1,92 @@
+import childProcess from 'node:child_process';
+import ui from './app.js';
+import { showError } from './renderer.js';
+import { ensureError } from './utils.js';
+export function ensureDependencies(task, deps, state) {
+    let allDepsExist = true;
+    for (const dep of deps) {
+        if (!Object.keys(state.tasks).includes(dep)) {
+            state.buffers[task] = {
+                running: false,
+                text: `Cannot depend on ${dep} as it does not exist`,
+                errored: true,
+            };
+            state.taskOrder.push(task);
+            allDepsExist = false;
+            break;
+        }
+    }
+    return allDepsExist;
+}
+export function spawnTask(name, task, state, onUpdate) {
+    console.log(task.command);
+    const subProcess = childProcess.spawn('sh', ['-c', task.command], {
+        cwd: task.cwd,
+        env: {
+            ...process.env,
+            FORCE_COLOR: '1',
+            CLICOLOR_FORCE: '1',
+        },
+    });
+    state.childProcesses.set(name, subProcess);
+    subProcess.on('spawn', () => {
+        if (Object.keys(state.buffers).length === 0) {
+            state.selectedTask = name;
+        }
+        state.buffers[name] = { running: true, text: '', errored: false };
+        state.taskOrder.push(name);
+        onUpdate();
+    });
+    const handleOutput = (newOutput) => {
+        const text = newOutput.toString('utf8');
+        const currentText = state.buffers[name]?.text ?? '';
+        state.buffers[name] = {
+            running: true,
+            text: currentText + text,
+            errored: false,
+        };
+        if (state.selectedTask === name) {
+            onUpdate();
+        }
+    };
+    subProcess.stdout.on('data', handleOutput);
+    subProcess.stderr.on('data', handleOutput);
+    subProcess.on('close', (code) => {
+        const currentText = state.buffers[name]?.text ?? '';
+        state.buffers[name] = {
+            running: false,
+            text: currentText,
+            errored: code !== null && code !== 0,
+        };
+        state.childProcesses.delete(name);
+        // Check queue for dependent tasks
+        checkQueue(state, onUpdate);
+        onUpdate();
+    });
+    subProcess.on('error', (e) => {
+        const error = ensureError(e);
+        showError(error.message, ui, state);
+    });
+}
+function checkQueue(state, onUpdate) {
+    const next = [];
+    for (const queueItem of state.queue) {
+        const remaining = queueItem.remainingDeps.filter((dep) => {
+            const buffer = state.buffers[dep];
+            return buffer?.running || buffer?.errored || !buffer;
+        });
+        if (remaining.length === 0) {
+            spawnTask(queueItem.name, queueItem.task, state, onUpdate);
+            continue;
+        }
+        next.push({ ...queueItem, remainingDeps: remaining });
+    }
+    state.queue = next;
+}
+export function cleanup(state) {
+    for (const [_, proc] of state.childProcesses.entries()) {
+        if (!proc.killed) {
+            proc.kill('SIGTERM');
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+import z from 'zod';
+export declare const TaskSchema: z.ZodObject<{
+    command: z.ZodString;
+    dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    cwd: z.ZodDefault<z.ZodString>;
+}, z.z.core.$strip>;
+export type Task = z.infer<typeof TaskSchema>;
+export declare const TasksConfigSchema: z.ZodObject<{
+    tasks: z.ZodRecord<z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        cwd: z.ZodDefault<z.ZodString>;
+    }, z.z.core.$strip>>;
+}, z.z.core.$strip>;
+export type TasksConfig = z.infer<typeof TasksConfigSchema>;

package/dist/types.js

@@ -0,0 +1,9 @@
+import z from 'zod';
+export const TaskSchema = z.object({
+    command: z.string(),
+    dependsOn: z.string().array().default([]),
+    cwd: z.string().default(process.cwd()),
+});
+export const TasksConfigSchema = z.object({
+    tasks: z.record(z.string(), TaskSchema),
+});

package/dist/ui.d.ts

@@ -0,0 +1,11 @@
+import blessed from 'blessed';
+export interface UIComponents {
+    screen: blessed.Widgets.Screen;
+    sidebar: blessed.Widgets.BoxElement;
+    taskList: blessed.Widgets.BoxElement;
+    queueContainer: blessed.Widgets.BoxElement;
+    taskNameBox: blessed.Widgets.BoxElement;
+    taskOutputBox: blessed.Widgets.Log;
+    errorBox: blessed.Widgets.BoxElement;
+}
+export declare function createUI(): UIComponents;

package/dist/ui.js

@@ -0,0 +1,121 @@
+import blessed from 'blessed';
+export function createUI() {
+    // Create screen
+    const screen = blessed.screen({
+        smartCSR: true,
+        title: 'Task Runner',
+        fullUnicode: true,
+    });
+    // Create sidebar container
+    const sidebar = blessed.box({
+        parent: screen,
+        left: 0,
+        top: 0,
+        width: 25,
+        height: '100%',
+    });
+    // Add a vertical line separator
+    blessed.line({
+        parent: screen,
+        orientation: 'vertical',
+        left: 24,
+        top: 0,
+        height: '100%',
+        style: {
+            fg: 'white',
+        },
+    });
+    // Tasks list
+    const taskList = blessed.box({
+        parent: sidebar,
+        width: '100%',
+        height: 'shrink',
+        tags: true,
+    });
+    // Queue section
+    const queueContainer = blessed.box({
+        parent: sidebar,
+        top: 'center',
+        width: '100%',
+        height: 'shrink',
+        tags: true,
+    });
+    // Help text at bottom
+    blessed.box({
+        parent: sidebar,
+        bottom: 0,
+        width: '100%',
+        height: 1,
+        content: '{gray-fg}↑↓ - Navigate{/}',
+        tags: true,
+    });
+    // Output pane container
+    const outputPane = blessed.box({
+        parent: screen,
+        left: 25,
+        top: 0,
+        width: '100%-25',
+        height: '100%',
+    });
+    // Task name header
+    const taskNameBox = blessed.box({
+        parent: outputPane,
+        top: 0,
+        width: '100%',
+        height: 1,
+        content: '',
+        tags: true,
+        style: {
+            fg: 'gray',
+        },
+    });
+    // Task output (scrollable log)
+    const taskOutputBox = blessed.log({
+        parent: outputPane,
+        top: 1,
+        width: '100%',
+        height: '100%-1',
+        scrollable: true,
+        alwaysScroll: true,
+        scrollbar: {
+            ch: '█',
+            style: {
+                fg: 'white',
+            },
+        },
+        keys: true,
+        vi: true,
+        mouse: true,
+        tags: true,
+    });
+    // Error display
+    const errorBox = blessed.box({
+        parent: screen,
+        top: 'center',
+        left: 'center',
+        width: '80%',
+        height: 'shrink',
+        border: {
+            type: 'line',
+        },
+        style: {
+            fg: 'red',
+            border: {
+                fg: 'red',
+            },
+        },
+        tags: true,
+        hidden: true,
+    });
+    // Focus on output box for scrolling
+    taskOutputBox.focus();
+    return {
+        screen,
+        sidebar,
+        taskList,
+        queueContainer,
+        taskNameBox,
+        taskOutputBox,
+        errorBox,
+    };
+}

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+import z from 'zod';
+import { TasksConfig } from './types.js';
+export default function formatZodError(error: z.ZodError): string;
+export declare function loadConfig(configPath?: string): TasksConfig;
+export declare function ensureError(error: unknown): Error;

package/dist/utils.js

@@ -0,0 +1,44 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import z from 'zod';
+import { CONFIG_PATH } from './constants.js';
+import { TasksConfigSchema } from './types.js';
+function getConfigPath(cliOption) {
+    if (cliOption)
+        return cliOption;
+    return CONFIG_PATH;
+}
+export default function formatZodError(error) {
+    if (error.issues.length === 0) {
+        return 'Unknown Zod error';
+    }
+    const issue = error.issues[0];
+    if (!issue)
+        return error.message;
+    const path = issue.path.join('.');
+    return `${issue.message} at '${path}' [code: ${issue.code}]`;
+}
+export function loadConfig(configPath) {
+    try {
+        const relativePath = path.join(process.cwd(), getConfigPath(configPath));
+        const raw = fs.readFileSync(relativePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return z.parse(TasksConfigSchema, parsed);
+    }
+    catch (e) {
+        const error = ensureError(e);
+        throw error;
+    }
+}
+export function ensureError(error) {
+    if (error instanceof z.ZodError)
+        return new Error(formatZodError(error));
+    if (error instanceof Error)
+        return error;
+    let stringified = '[Unable to stringify the thrown value]';
+    try {
+        stringified = JSON.stringify(error);
+    }
+    catch { }
+    return new Error(stringified);
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "tasktui",
+  "description": "Run tasks in a multiplexed terminal with dependency management.",
+  "version": "1.0.0",
+  "license": "MIT",
+  "bin": "dist/cli.js",
+  "type": "module",
+  "engines": {
+    "node": ">=16"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "blessed": "^0.1.81",
+    "meow": "^11.0.0"
+  },
+  "devDependencies": {
+    "@sindresorhus/tsconfig": "^3.0.1",
+    "@types/blessed": "^0.1.25",
+    "@vdemedes/prettier-config": "^2.0.1",
+    "prettier": "^2.8.7",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.3",
+    "zod": "^4.1.12"
+  }
+}