hadara 0.1.0-rc.0

package/dist/tui/terminal.js

@@ -0,0 +1,475 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TuiTerminalSession = void 0;
+exports.createTuiTerminalSession = createTuiTerminalSession;
+exports.decodeTuiInput = decodeTuiInput;
+const node_path_1 = __importDefault(require("node:path"));
+const node_worker_threads_1 = require("node:worker_threads");
+const read_model_1 = require("./read-model");
+const snapshot_1 = require("./snapshot");
+const cache_1 = require("./cache");
+const constants_1 = require("./constants");
+const state_1 = require("./state");
+class TuiTerminalSession {
+    input;
+    output;
+    options;
+    model;
+    state;
+    running = false;
+    rawModeEnabled = false;
+    loadingTick = 0;
+    loaded = false;
+    loading = false;
+    activeLoadId = 0;
+    loadingTimer = null;
+    logLine = 'loading: reading work console';
+    hitboxes = [];
+    onResize = () => {
+        if (!this.running)
+            return;
+        this.render();
+    };
+    onData = (chunk) => {
+        for (const key of decodeTuiInput(chunk)) {
+            if (!this.running)
+                return;
+            this.applyKey(key);
+        }
+    };
+    constructor(options) {
+        this.options = options;
+        this.input = options.input ?? process.stdin;
+        this.output = options.output ?? process.stdout;
+        this.model = (0, read_model_1.createTuiLoadingReadModel)();
+        this.state = (0, state_1.createTuiInteractionState)(this.model);
+    }
+    start() {
+        if (!this.running) {
+            this.running = true;
+            if (this.shouldEnableRawMode()) {
+                this.input.setRawMode?.(true);
+                this.rawModeEnabled = true;
+            }
+            this.input.resume();
+            this.input.on('data', this.onData);
+            this.output.on?.('resize', this.onResize);
+            if (this.options.terminalControl !== false)
+                this.output.write('\x1b[?25l\x1b[?1000h\x1b[?1006h');
+        }
+        if (!this.loaded) {
+            if (this.options.asyncLoading) {
+                return this.beginInitialLoadAsync();
+            }
+            this.completeInitialLoad();
+        }
+        return this.render();
+    }
+    stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        this.input.off('data', this.onData);
+        if (this.rawModeEnabled) {
+            this.input.setRawMode?.(false);
+            this.rawModeEnabled = false;
+        }
+        this.input.pause();
+        this.output.off?.('resize', this.onResize);
+        this.stopLoadingPulse();
+        if (this.options.terminalControl !== false)
+            this.output.write('\x1b[?1000l\x1b[?1006l\x1b[?25h');
+        this.options.onStop?.();
+    }
+    isRunning() {
+        return this.running;
+    }
+    getState() {
+        return this.state;
+    }
+    getModel() {
+        return this.model;
+    }
+    handleKey(key) {
+        if (!this.running)
+            return null;
+        return this.applyKey(key);
+    }
+    render() {
+        const snapshot = (0, snapshot_1.renderTuiSnapshot)(this.model, this.snapshotOptions());
+        this.hitboxes = snapshot.hitboxes;
+        if (this.options.terminalControl !== false)
+            this.output.write('\x1b[H\x1b[2J');
+        this.output.write(snapshot.text);
+        return {
+            text: snapshot.text,
+            state: this.state,
+            model: this.model
+        };
+    }
+    applyKey(key) {
+        const mouseResult = this.applyMouseKey(key);
+        if (mouseResult !== undefined)
+            return mouseResult;
+        const requestedState = (0, state_1.reduceTuiInteractionState)(this.state, this.model, key, this.stateReduceOptions());
+        const nextState = this.options.asyncLoading ? this.completePendingEffectsAsync(requestedState) : this.completePendingEffects(requestedState);
+        this.state = nextState;
+        if (this.state.quitRequested) {
+            this.stop();
+            return null;
+        }
+        return this.render();
+    }
+    completePendingEffectsAsync(requestedState) {
+        if (this.loading)
+            return requestedState;
+        if (requestedState.detailRefreshRequested) {
+            this.beginReadModelLoad('detail', `loading ${requestedState.selectedTaskId ?? 'selected task'} detail`, {
+                ...(0, state_1.tuiStateToReadModelOptions)(requestedState),
+                profile: 'fast'
+            });
+            return requestedState;
+        }
+        if (requestedState.refreshRequested) {
+            this.beginReadModelLoad('full', 'refreshing read models', { ...(0, state_1.tuiStateToReadModelOptions)(requestedState), profile: 'fast' });
+            return requestedState;
+        }
+        return requestedState;
+    }
+    completePendingEffects(requestedState) {
+        let nextState = requestedState;
+        if (nextState.detailRefreshRequested) {
+            this.renderLoadingFrames(`loading ${nextState.selectedTaskId ?? 'selected task'} detail`);
+            this.model = this.loadModel('detail', { ...(0, state_1.tuiStateToReadModelOptions)(nextState), profile: 'fast' });
+            nextState = (0, state_1.reduceTuiInteractionState)(nextState, this.model, 'detail-refresh-complete');
+            this.logLine = `loaded ${this.model.selectedTaskId ?? 'selected task'} detail`;
+        }
+        if (nextState.refreshRequested) {
+            this.renderLoadingFrames('refreshing read models');
+            this.model = this.loadModel('full', { ...(0, state_1.tuiStateToReadModelOptions)(nextState), profile: 'fast' });
+            nextState = (0, state_1.reduceTuiInteractionState)(nextState, this.model, 'refresh-complete');
+            this.logLine = 'refreshed read models';
+        }
+        return nextState;
+    }
+    completeInitialLoad() {
+        this.renderLoadingFrames('initial load: reading read models');
+        this.model = this.loadModel('fast', { profile: 'fast' });
+        this.state = (0, state_1.createTuiInteractionState)(this.model, {
+            panel: this.state.activePanel,
+            selectedTaskId: this.model.selectedTaskId,
+            document: this.state.documentFile,
+            taskSearch: this.state.taskSearch,
+            searchActive: this.state.searchActive,
+            taskListVisibleRows: this.taskListVisibleRows()
+        });
+        this.loaded = true;
+        this.logLine = 'ready: work console loaded';
+    }
+    beginInitialLoadAsync() {
+        return this.beginReadModelLoad('fast', 'initial load: reading read models', { profile: 'fast' }, true);
+    }
+    snapshotOptions() {
+        return (0, state_1.tuiStateToSnapshotOptions)(this.state, {
+            width: this.options.width ?? this.output.columns,
+            height: this.options.height ?? this.output.rows,
+            widthPolicy: this.options.widthPolicy,
+            includeGeneratedAt: this.options.includeGeneratedAt,
+            theme: this.options.theme ?? 'none',
+            logLine: this.logLine
+        });
+    }
+    renderLoading(message) {
+        this.loadingTick += 1;
+        this.logLine = message;
+        const snapshot = (0, snapshot_1.renderTuiSnapshot)(this.model, {
+            ...this.snapshotOptions(),
+            loading: true,
+            loadingTick: this.loadingTick,
+            logLine: message
+        });
+        this.hitboxes = snapshot.hitboxes;
+        if (this.options.terminalControl !== false)
+            this.output.write('\x1b[H\x1b[2J');
+        this.output.write(snapshot.text);
+        return {
+            text: snapshot.text,
+            state: this.state,
+            model: this.model
+        };
+    }
+    renderLoadingFrames(message) {
+        for (let frame = 0; frame < 4; frame += 1) {
+            this.renderLoading(message);
+        }
+    }
+    beginReadModelLoad(refresh, message, readOptions, initial = false) {
+        if (this.loading)
+            return this.render();
+        this.loading = true;
+        const loadId = (this.activeLoadId += 1);
+        this.logLine = message;
+        const result = this.renderLoading(message);
+        this.startLoadingPulse(message);
+        this.loadModelAsync(refresh, readOptions)
+            .then((model) => {
+            if (!this.running || loadId !== this.activeLoadId)
+                return;
+            this.model = model;
+            if (initial) {
+                this.state = (0, state_1.createTuiInteractionState)(this.model, {
+                    panel: this.state.activePanel,
+                    selectedTaskId: this.model.selectedTaskId,
+                    document: this.state.documentFile,
+                    taskSearch: this.state.taskSearch,
+                    searchActive: this.state.searchActive,
+                    taskListVisibleRows: this.taskListVisibleRows()
+                });
+                this.loaded = true;
+                this.logLine = 'ready: work console loaded';
+            }
+            else if (this.state.detailRefreshRequested) {
+                this.state = (0, state_1.reduceTuiInteractionState)(this.state, this.model, 'detail-refresh-complete');
+                this.logLine = `loaded ${this.model.selectedTaskId ?? 'selected task'} detail`;
+            }
+            else if (this.state.refreshRequested) {
+                this.state = (0, state_1.reduceTuiInteractionState)(this.state, this.model, 'refresh-complete');
+                this.logLine = 'refreshed read models';
+            }
+        })
+            .catch((error) => {
+            if (!this.running || loadId !== this.activeLoadId)
+                return;
+            this.logLine = `read-model load failed: ${error instanceof Error ? error.message : String(error)}`;
+            if (initial)
+                this.loaded = true;
+            if (this.state.detailRefreshRequested)
+                this.state = (0, state_1.reduceTuiInteractionState)(this.state, this.model, 'detail-refresh-failed');
+            if (this.state.refreshRequested)
+                this.state = (0, state_1.reduceTuiInteractionState)(this.state, this.model, 'refresh-failed');
+        })
+            .finally(() => {
+            if (!this.running || loadId !== this.activeLoadId)
+                return;
+            this.loading = false;
+            this.stopLoadingPulse();
+            this.render();
+        });
+        return result;
+    }
+    startLoadingPulse(message) {
+        this.stopLoadingPulse();
+        const frameMs = Math.max(16, Math.floor(this.options.loadingFrameMs ?? 180));
+        this.loadingTimer = setInterval(() => {
+            if (!this.running || !this.loading)
+                return;
+            this.renderLoading(message);
+        }, frameMs);
+        this.loadingTimer.unref?.();
+    }
+    stopLoadingPulse() {
+        if (!this.loadingTimer)
+            return;
+        clearInterval(this.loadingTimer);
+        this.loadingTimer = null;
+    }
+    applyMouseKey(key) {
+        const parsed = parseMouseKey(key);
+        if (!parsed)
+            return undefined;
+        const hitbox = resolveHitbox(this.hitboxes, parsed.x, parsed.y);
+        if (!hitbox)
+            return this.render();
+        if (hitbox.action === 'panel') {
+            const activePanel = (0, constants_1.resolveTuiPanelId)(hitbox.payload, this.state.activePanel);
+            this.state = { ...this.state, activePanel, searchActive: activePanel === 'tasks' ? this.state.searchActive : false };
+            return this.render();
+        }
+        if (hitbox.action === 'task') {
+            const rows = (0, state_1.getTuiTaskRows)(this.model, this.state);
+            const selectedIndex = rows.findIndex((row) => row.id === hitbox.payload);
+            if (selectedIndex >= 0) {
+                const selected = rows[selectedIndex];
+                const selectedState = {
+                    ...this.state,
+                    selectedTaskId: selected?.id ?? null,
+                    selectedTaskIndex: selectedIndex,
+                    taskListScroll: this.state.taskListScroll,
+                    documentScroll: 0
+                };
+                const requestedState = (0, state_1.reduceTuiInteractionState)(selectedState, this.model, 'enter', this.stateReduceOptions());
+                this.state = this.options.asyncLoading ? this.completePendingEffectsAsync(requestedState) : this.completePendingEffects(requestedState);
+                return this.render();
+            }
+        }
+        if (hitbox.action === 'document') {
+            this.state = (0, state_1.reduceTuiInteractionState)(this.state, this.model, hitbox.payload, this.stateReduceOptions());
+            return this.render();
+        }
+        return this.render();
+    }
+    shouldEnableRawMode() {
+        return this.options.enableRawMode !== false && Boolean(this.input.isTTY && this.input.setRawMode);
+    }
+    stateReduceOptions() {
+        return {
+            taskListVisibleRows: this.taskListVisibleRows(),
+            documentMaxScroll: (0, snapshot_1.getTuiDocumentScrollBounds)(this.model, this.snapshotOptions()).maxScroll
+        };
+    }
+    taskListVisibleRows() {
+        const terminalHeight = Math.max(10, Math.floor(this.options.height ?? this.output.rows ?? 32));
+        return (0, constants_1.tuiTaskVisibleRowsForAvailableRows)(Math.max(1, terminalHeight - 8));
+    }
+    loadModel(refresh, readOptions = {}) {
+        if (this.options.readModelLoader) {
+            const loaded = this.options.readModelLoader(refresh, readOptions);
+            if (loaded instanceof Promise)
+                throw new Error('Async readModelLoader requires asyncLoading mode.');
+            return loaded;
+        }
+        if (this.options.cache?.enabled) {
+            return (0, cache_1.createTuiReadModelWithCache)(this.options.projectRoot, {
+                ...readOptions,
+                cache: {
+                    enabled: true,
+                    root: this.options.cache.root,
+                    refresh
+                }
+            }).model;
+        }
+        return (0, read_model_1.createTuiReadModel)(this.options.projectRoot, readOptions);
+    }
+    loadModelAsync(refresh, readOptions = {}) {
+        if (this.options.readModelLoader)
+            return Promise.resolve(this.options.readModelLoader(refresh, readOptions));
+        const workerPath = node_path_1.default.join(__dirname, 'read-model-worker.js');
+        return new Promise((resolve, reject) => {
+            const worker = new node_worker_threads_1.Worker(workerPath, {
+                workerData: {
+                    projectRoot: this.options.projectRoot,
+                    refresh,
+                    readOptions,
+                    cache: this.options.cache
+                }
+            });
+            worker.once('message', (message) => {
+                if (message.ok)
+                    resolve(message.model);
+                else
+                    reject(new Error(message.error));
+            });
+            worker.once('error', reject);
+            worker.once('exit', (code) => {
+                if (code !== 0)
+                    reject(new Error(`TUI read-model worker exited with code ${code}`));
+            });
+        }).catch(() => Promise.resolve(this.loadModel(refresh, readOptions)));
+    }
+}
+exports.TuiTerminalSession = TuiTerminalSession;
+function createTuiTerminalSession(options) {
+    return new TuiTerminalSession(options);
+}
+function decodeTuiInput(input) {
+    const text = Buffer.isBuffer(input) ? input.toString('utf8') : input;
+    const keys = [];
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index] ?? '';
+        if (char === '\x03') {
+            keys.push('ctrl-c');
+        }
+        else if (char === '\t') {
+            keys.push('tab');
+        }
+        else if (char === '\r' || char === '\n') {
+            keys.push('enter');
+        }
+        else if (char === '\x7f' || char === '\b') {
+            keys.push('backspace');
+        }
+        else if (char === '\x1b') {
+            const mouse = matchMouseSequence(text.slice(index));
+            if (mouse) {
+                if (mouse.key)
+                    keys.push(mouse.key);
+                index += mouse.length - 1;
+                continue;
+            }
+            const sequence = matchEscapeSequence(text.slice(index));
+            keys.push(sequence.key);
+            index += sequence.length - 1;
+        }
+        else {
+            keys.push(char);
+        }
+    }
+    return keys;
+}
+function parseMouseKey(key) {
+    if (typeof key !== 'string')
+        return null;
+    const match = key.match(/^mouse:(\d+):(\d+)$/);
+    if (!match)
+        return null;
+    return { x: Number(match[1]), y: Number(match[2]) };
+}
+function matchMouseSequence(text) {
+    const match = text.match(/^\x1b\[<(\d+);(\d+);(\d+)([mM])/);
+    if (!match)
+        return null;
+    if (match[4] !== 'M' || Number(match[1]) !== 0) {
+        return {
+            key: null,
+            length: match[0].length
+        };
+    }
+    return {
+        key: `mouse:${Number(match[2])}:${Number(match[3])}`,
+        length: match[0].length
+    };
+}
+function resolveHitbox(hitboxes, x, y) {
+    return hitboxes.find((box) => x >= box.x1 && x <= box.x2 && y >= box.y1 && y <= box.y2) ?? null;
+}
+function matchEscapeSequence(text) {
+    if (text.startsWith('\x1b[A'))
+        return { key: 'up', length: 3 };
+    if (text.startsWith('\x1b[B'))
+        return { key: 'down', length: 3 };
+    if (text.startsWith('\x1b[C'))
+        return { key: 'right', length: 3 };
+    if (text.startsWith('\x1b[D'))
+        return { key: 'left', length: 3 };
+    if (text.startsWith('\x1bOA'))
+        return { key: 'up', length: 3 };
+    if (text.startsWith('\x1bOB'))
+        return { key: 'down', length: 3 };
+    if (text.startsWith('\x1bOC'))
+        return { key: 'right', length: 3 };
+    if (text.startsWith('\x1bOD'))
+        return { key: 'left', length: 3 };
+    const modifiedArrow = text.match(/^\x1b\[(?:1|0)?(?:;\d+)+([ABCD])/);
+    if (modifiedArrow) {
+        const keyByCode = { A: 'up', B: 'down', C: 'right', D: 'left' };
+        return { key: keyByCode[modifiedArrow[1] ?? ''] ?? 'escape', length: modifiedArrow[0].length };
+    }
+    if (text.startsWith('\x1b[Z'))
+        return { key: 'shift-tab', length: 3 };
+    if (text.startsWith('\x1b[H'))
+        return { key: 'home', length: 3 };
+    if (text.startsWith('\x1b[F'))
+        return { key: 'end', length: 3 };
+    if (text.startsWith('\x1b[1~'))
+        return { key: 'home', length: 4 };
+    if (text.startsWith('\x1b[4~'))
+        return { key: 'end', length: 4 };
+    if (text.startsWith('\x1b[5~'))
+        return { key: 'pageup', length: 4 };
+    if (text.startsWith('\x1b[6~'))
+        return { key: 'pagedown', length: 4 };
+    return { key: 'escape', length: 1 };
+}

package/dist/tui/theme.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTuiThemeName = normalizeTuiThemeName;
+exports.tuiFg = tuiFg;
+exports.tuiBg = tuiBg;
+exports.tuiSwatch = tuiSwatch;
+exports.tuiColorEnabled = tuiColorEnabled;
+const ANSI_RESET = '\x1b[0m';
+const THEME_HEX = {
+    hadara: {
+        canvas: '#0B1114',
+        panel: '#121D22',
+        panel2: '#17262C',
+        border: '#34434A',
+        text: '#DED6C2',
+        text2: '#BDB49D',
+        muted: '#848978',
+        dim: '#5D675F',
+        gold: '#C6A15F',
+        gold2: '#E0B96D',
+        teal: '#63AEB8',
+        teal2: '#82C7CE',
+        pass: '#82BE86',
+        warn: '#D0A45A',
+        fail: '#D97B73',
+        violet: '#A891DD',
+        white: '#F2EBD8',
+        black: '#081014'
+    },
+    contrast: {
+        canvas: '#050505',
+        panel: '#111111',
+        panel2: '#242424',
+        border: '#777777',
+        text: '#F3F3F3',
+        text2: '#D1D1D1',
+        muted: '#AAAAAA',
+        dim: '#777777',
+        gold: '#FFD166',
+        gold2: '#FFE08A',
+        teal: '#4ECDC4',
+        teal2: '#8CF5EA',
+        pass: '#74F174',
+        warn: '#FFD166',
+        fail: '#FF6B6B',
+        violet: '#C4A7FF',
+        white: '#FFFFFF',
+        black: '#000000'
+    }
+};
+function normalizeTuiThemeName(value, fallback = 'none') {
+    const normalized = String(value ?? '').toLowerCase();
+    if (normalized === 'hadara' || normalized === 'contrast' || normalized === 'none')
+        return normalized;
+    return fallback;
+}
+function tuiFg(theme, role, text) {
+    if (theme === 'none')
+        return text;
+    return `${ansiFg(theme, role)}${text}${ANSI_RESET}`;
+}
+function tuiBg(theme, role, text = '') {
+    if (theme === 'none')
+        return text;
+    return `${ansiBg(theme, role)}${text}${ANSI_RESET}`;
+}
+function tuiSwatch(theme, background, foreground, text) {
+    if (theme === 'none')
+        return text;
+    return `${ansiBg(theme, background)}${ansiFg(theme, foreground)}${text}${ANSI_RESET}`;
+}
+function tuiColorEnabled(theme) {
+    return theme !== 'none';
+}
+function ansiFg(theme, role) {
+    const [red, green, blue] = hexToRgb(THEME_HEX[theme][role]);
+    return `\x1b[38;2;${red};${green};${blue}m`;
+}
+function ansiBg(theme, role) {
+    const [red, green, blue] = hexToRgb(THEME_HEX[theme][role]);
+    return `\x1b[48;2;${red};${green};${blue}m`;
+}
+function hexToRgb(hex) {
+    const value = hex.replace('#', '');
+    return [Number.parseInt(value.slice(0, 2), 16), Number.parseInt(value.slice(2, 4), 16), Number.parseInt(value.slice(4, 6), 16)];
+}

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "hadara",
+  "version": "0.1.0-rc.0",
+  "private": false,
+  "license": "MIT",
+  "description": "HADARA: portable agentic development workbench",
+  "bin": {
+    "hadara": "./dist/cli/main.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ]
+}