soja-cli 1.4.0

package/dist/ui/hooks/use-layout.js

@@ -0,0 +1,36 @@
+import { useTerminalSize } from './use-terminal-size.js';
+import { APP_SLOGAN, WORDMARK, WORDMARK_WIDTH } from '../branding/brand.js';
+/** Full wordmark and slogan at the left of the footer; narrow terminals stack them. */
+export function footerRowsFor(columns) {
+    const inline = columns >= WORDMARK_WIDTH + APP_SLOGAN.length + 4;
+    const sloganWidth = inline ? columns - WORDMARK_WIDTH - 4 : columns - 2;
+    const brandRows = inline
+        ? Math.max(WORDMARK.length, Math.ceil(APP_SLOGAN.length / Math.max(1, sloganWidth)))
+        : WORDMARK.length + Math.ceil(APP_SLOGAN.length / Math.max(1, sloganWidth));
+    return 1 + FOOTER_BRAND_GAP_ROWS + brandRows;
+}
+/** A quiet row between the screen panel and the footer. */
+export const FOOTER_GAP_ROWS = 1;
+/** A quiet row between footer shortcuts and the brand. */
+export const FOOTER_BRAND_GAP_ROWS = 1;
+/** The screen panel's borders (top and bottom; left and right plus padding). */
+const PANEL_ROWS = 2;
+const PANEL_COLUMNS = 4;
+export const SIDEBAR_WIDTH = 26;
+/** From this width on, the sidebar is shown. */
+export const SIDEBAR_FROM = 110;
+export function layoutFor(columns, rows) {
+    const sidebar = columns >= SIDEBAR_FROM ? SIDEBAR_WIDTH : 0;
+    const barRows = 1 + FOOTER_GAP_ROWS + footerRowsFor(columns);
+    return {
+        width: Math.max(20, columns - sidebar - PANEL_COLUMNS),
+        height: Math.max(4, rows - barRows - PANEL_ROWS),
+        rows,
+        columns,
+        sidebar,
+    };
+}
+export function useLayout() {
+    const { columns, rows } = useTerminalSize();
+    return layoutFor(columns, rows);
+}

package/dist/ui/hooks/use-list.js

@@ -0,0 +1,28 @@
+import { useLayoutEffect, useRef, useState } from 'react';
+import { clampList, moveInList } from '../input/list-navigation.js';
+/** Selection + scrolling for a list of `count` items shown `height` rows at a time. */
+export function useList(count, height, vim = true, initialIndex = 0, onSelect) {
+    const onSelectRef = useRef(onSelect);
+    useLayoutEffect(() => {
+        onSelectRef.current = onSelect;
+    }, [onSelect]);
+    const [state, setState] = useState(() => clampList({ index: initialIndex, offset: 0 }, count, height));
+    const current = clampList(state, count, height);
+    return {
+        index: current.index,
+        offset: current.offset,
+        handleKey(input, key) {
+            const next = moveInList(current, input, key, count, height, vim);
+            if (!next)
+                return false;
+            setState(next);
+            onSelectRef.current?.(next.index);
+            return true;
+        },
+        select(index) {
+            const next = clampList({ index, offset: current.offset }, count, height);
+            setState(next);
+            onSelectRef.current?.(next.index);
+        },
+    };
+}

package/dist/ui/hooks/use-measure.js

@@ -0,0 +1,22 @@
+import { useEffect, useState } from 'react';
+/**
+ * Width and height of an element after layout. Ink's `useBoxMetrics` re-renders
+ * on every commit even when nothing changed (it sets `hasMeasured` again),
+ * which loops when a panel re-renders often; this only updates on a change.
+ */
+export function useMeasure(ref) {
+    const [size, setSize] = useState({ width: 0, height: 0 });
+    // After every render on purpose: layout can change without this component's props changing.
+    // It only sets state when the size really changed, so it cannot loop.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    useEffect(() => {
+        const layout = ref.current?.yogaNode?.getComputedLayout();
+        if (!layout)
+            return;
+        const width = Math.floor(layout.width);
+        const height = Math.floor(layout.height);
+        if (width !== size.width || height !== size.height)
+            setSize({ width, height });
+    });
+    return size;
+}

package/dist/ui/hooks/use-query.js

@@ -0,0 +1,29 @@
+import { useEffect, useState } from 'react';
+import { toDisplayError } from '../../utils/errors.js';
+import { useAppState } from '../app-state.js';
+/**
+ * Loads data through a service and reloads when `key` or the global data
+ * revision changes. Previous data stays on screen while reloading, so
+ * nothing flickers after a mutation.
+ */
+export function useQuery(load, key, topics = [key]) {
+    const { revision, queryVersion } = useAppState();
+    const requestKey = `${key}#${revision}#${queryVersion(topics)}`;
+    const [loaded, setLoaded] = useState({ key: '', data: undefined, error: null });
+    useEffect(() => {
+        let cancelled = false;
+        load().then((data) => {
+            if (!cancelled)
+                setLoaded({ key: requestKey, data, error: null });
+        }, (error) => {
+            if (!cancelled)
+                setLoaded({ key: requestKey, data: undefined, error: toDisplayError(error) });
+        });
+        return () => {
+            cancelled = true;
+        };
+        // `load` is recreated every render; `requestKey` describes what it loads.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [requestKey]);
+    return { data: loaded.data, error: loaded.error, loading: loaded.key !== requestKey };
+}

package/dist/ui/hooks/use-task-actions.js

@@ -0,0 +1,450 @@
+import { pullRequestWarnings } from '../../application/services/index.js';
+import { isClosed, PRIORITY_LABELS, STATUS_LABELS, TYPE_LABELS, } from '../../domain/task.js';
+import { toDisplayError } from '../../utils/errors.js';
+import { editInEditor } from '../../utils/editor.js';
+import { tildify } from '../../utils/text.js';
+import { useAppState } from '../app-state.js';
+import { useExternalTerminal } from '../input/KeyProvider.js';
+import { fromOption, memberOptions, NONE, priorityOptions, projectOptions, statusOptions, typeOptions } from '../overlays/options.js';
+/**
+ * Every edit you can make to a task, as overlay flows. Shared by the task
+ * list and the task detail so both behave identically.
+ */
+export function useTaskActions() {
+    const { services, session, openOverlay, run, notify, cwd, route, go } = useAppState();
+    const external = useExternalTerminal();
+    const { tasks } = services;
+    const report = (error) => {
+        const display = toDisplayError(error);
+        notify(display.message, 'error', display.hint);
+    };
+    /** A yes/no window with buttons; Cancel is the default so Enter never destroys anything by accident. */
+    const confirm = (title, message, yes, onYes) => openOverlay({
+        kind: 'confirm',
+        title,
+        message,
+        confirmLabel: yes,
+        // Anything that deletes is marked as dangerous; the rest only asks for a look.
+        tone: /delete|force|anyway/i.test(yes) ? 'danger' : 'warning',
+        onConfirm: () => onYes(),
+    });
+    const update = (task, changes, success) => run(() => tasks.update(session, task, changes), `${task.ref} ${success}`);
+    const actions = {
+        status(task) {
+            openOverlay({
+                kind: 'picker',
+                title: 'Status',
+                context: task.ref,
+                options: statusOptions,
+                initial: task.status,
+                onSelect: (value) => update(task, { status: value }, `moved to ${STATUS_LABELS[value]}`),
+            });
+        },
+        priority(task) {
+            openOverlay({
+                kind: 'picker',
+                title: 'Priority',
+                context: task.ref,
+                options: priorityOptions,
+                initial: task.priority,
+                onSelect: (value) => update(task, { priority: value }, `priority ${PRIORITY_LABELS[value]}`),
+            });
+        },
+        type(task) {
+            openOverlay({
+                kind: 'picker',
+                title: 'Type',
+                context: task.ref,
+                options: typeOptions,
+                initial: task.type,
+                onSelect: (value) => update(task, { type: value }, `is now a ${TYPE_LABELS[value]}`),
+            });
+        },
+        async assign(task) {
+            const members = await services.workspaces.members(session);
+            openOverlay({
+                kind: 'picker',
+                title: 'Assign',
+                context: task.ref,
+                options: memberOptions(members, session.user.id),
+                initial: task.assigneeId ?? NONE,
+                filterable: true,
+                onSelect: (value) => {
+                    const member = members.find((candidate) => candidate.id === value);
+                    return update(task, { assigneeId: fromOption(value) }, member ? `assigned to @${member.username}` : 'unassigned');
+                },
+                create: {
+                    label: (query) => `Add developer @${query.toLowerCase()} and assign`,
+                    onCreate: (query) => run(async () => {
+                        const displayName = query.charAt(0).toUpperCase() + query.slice(1);
+                        const user = await services.workspaces.addMember(session, { username: query, displayName });
+                        await tasks.update(session, task, { assigneeId: user.id });
+                    }, `${task.ref} assigned to @${query.toLowerCase()}`),
+                },
+            });
+        },
+        async project(task) {
+            const projects = await services.projects.list(session);
+            openOverlay({
+                kind: 'picker',
+                title: 'Project',
+                context: task.ref,
+                options: projectOptions(projects),
+                initial: task.projectId ?? NONE,
+                filterable: true,
+                onSelect: (value) => {
+                    const project = projects.find((candidate) => candidate.id === value);
+                    return update(task, { projectId: fromOption(value) }, project ? `moved to ${project.name}` : 'has no project');
+                },
+            });
+        },
+        async requester(task) {
+            const suggestions = await tasks.knownRequesters(session);
+            openOverlay({
+                kind: 'prompt',
+                title: 'Requested by',
+                context: task.ref,
+                initial: task.requester ?? '',
+                placeholder: suggestions[0] ?? 'Marketing, Finance, Admissions…',
+                suggestions,
+                allowEmpty: true,
+                onSubmit: (value) => update(task, { requester: value }, value.trim() ? `requested by ${value.trim()}` : 'has no requester'),
+            });
+        },
+        title(task) {
+            openOverlay({
+                kind: 'prompt',
+                title: 'Title',
+                context: task.ref,
+                initial: task.title,
+                onSubmit: (value) => update(task, { title: value }, 'renamed'),
+            });
+        },
+        /** Multi-line descriptions belong in a real editor: SOJA steps aside while $EDITOR runs. */
+        async description(task) {
+            let edited = null;
+            try {
+                await external(async () => {
+                    edited = await editInEditor(task.description ?? '', { name: `${task.ref}.md` });
+                });
+            }
+            catch (error) {
+                report(error);
+                return;
+            }
+            const text = edited;
+            if (text === null)
+                notify('The editor closed without saving. Nothing changed.');
+            else if (text === (task.description ?? ''))
+                notify('Description unchanged.');
+            else
+                await update(task, { description: text }, 'description saved');
+        },
+        descriptionInline(task) {
+            openOverlay({
+                kind: 'prompt',
+                title: 'Description',
+                context: task.ref,
+                initial: task.description ?? '',
+                placeholder: 'What is going on, where, and how to reproduce it',
+                allowEmpty: true,
+                onSubmit: (value) => update(task, { description: value }, 'description saved'),
+            });
+        },
+        branchName(task) {
+            openOverlay({
+                kind: 'prompt',
+                title: 'Branch',
+                context: `${task.ref} · recorded name, Git is not touched`,
+                initial: task.branch ?? '',
+                placeholder: 'fix/SOJA-12-short-name',
+                allowEmpty: true,
+                onSubmit: (value) => update(task, { branch: value }, value.trim() ? `branch ${value.trim()}` : 'branch cleared'),
+            });
+        },
+        comment(task) {
+            openOverlay({
+                kind: 'prompt',
+                title: 'Comment',
+                context: task.ref,
+                placeholder: 'Found it. The webhook retries on 500s…',
+                onSubmit: (value) => run(() => tasks.comment(session, task, value), `Comment added to ${task.ref}`),
+            });
+        },
+        /** `soja start` from the TUI: shows what will happen in Git, then does it. */
+        async branch(task) {
+            let plan;
+            try {
+                plan = await services.git.plan(session, task, cwd);
+            }
+            catch (error) {
+                report(error);
+                return;
+            }
+            const { branch, root } = plan;
+            const gitStep = plan.checkedOut
+                ? `Stay on ${branch}`
+                : plan.branchExists
+                    ? `Switch to ${branch}`
+                    : `Create ${branch} from ${plan.currentBranch ?? 'HEAD'}`;
+            const label = plan.linkProject ? `Link repository to ${plan.linkProject.name}, ${gitStep.charAt(0).toLowerCase()}${gitStep.slice(1)}` : gitStep;
+            const warning = plan.uncommitted > 0
+                ? plan.branchExists && !plan.checkedOut
+                    ? `${plan.uncommitted} uncommitted: commit or stash first`
+                    : `${plan.uncommitted} uncommitted change(s) come along`
+                : tildify(root);
+            openOverlay({
+                kind: 'picker',
+                title: 'Start on branch',
+                context: `${task.ref} · assign to you · In Progress`,
+                options: [
+                    { value: 'start', label, hint: warning },
+                    { value: 'cancel', label: 'Cancel', dim: true },
+                ],
+                onSelect: (value) => value === 'start'
+                    ? run(() => services.git.start(session, task, { cwd, link: plan.linkProject !== null }), `${task.ref} on ${branch}`)
+                    : undefined,
+            });
+        },
+        /** Choose files, then a message; commits on the task branch with live output. */
+        commit(task) {
+            openOverlay({ kind: 'commit', task });
+        },
+        async merge(task) {
+            let plan;
+            try {
+                plan = await services.git.mergePlan(session, task, cwd);
+            }
+            catch (error) {
+                report(error);
+                return;
+            }
+            if (plan.alreadyMerged) {
+                notify(`${plan.branch} is already merged into ${plan.into}.`, 'info', 'Delete it from the Git menu (g).');
+                return;
+            }
+            confirm(`Merge into ${plan.into}?`, `${plan.branch} → ${plan.into} · merge commit`, `Merge ${plan.branch} into ${plan.into}`, () => openOverlay({
+                kind: 'git-run',
+                title: 'Merge',
+                context: `${plan.branch} → ${plan.into}`,
+                run: async () => {
+                    const result = await services.git.merge(session, task, { cwd });
+                    return `Merged into ${result.into} (${result.hash.slice(0, 7)})`;
+                },
+                next: [
+                    { key: 'd', label: 'delete branch + mark Done', action: () => actions.deleteBranch(task, { markDone: true }) },
+                    { key: 'x', label: 'mark Done', action: () => void run(() => tasks.complete(session, task), `${task.ref} done. Nice.`) },
+                ],
+                recover: {
+                    merge_conflict: {
+                        key: 'a',
+                        label: 'abort merge',
+                        action: () => actions.abortMerge(task),
+                    },
+                },
+            }));
+        },
+        abortMerge(task) {
+            openOverlay({
+                kind: 'git-run',
+                title: 'Abort merge',
+                context: task.ref,
+                run: async () => {
+                    await services.git.abortMerge(session, task, cwd);
+                    return 'Merge aborted. The repository is back to how it was.';
+                },
+            });
+        },
+        /** Confirms, then deletes; an unmerged branch needs a second, explicit confirmation. */
+        deleteBranch(task, options = {}) {
+            const branch = task.branch;
+            if (!branch) {
+                notify(`${task.ref} has no branch.`, 'info');
+                return;
+            }
+            const execute = (force) => openOverlay({
+                kind: 'git-run',
+                title: force ? 'Delete unmerged branch' : 'Delete branch',
+                context: branch,
+                run: async () => {
+                    const result = await services.git.deleteBranch(session, task, { cwd, force });
+                    if (options.markDone)
+                        await tasks.complete(session, task);
+                    const switched = result.switchedTo ? ` Switched to ${result.switchedTo}.` : '';
+                    return `Deleted ${result.branch}.${switched}${options.markDone ? ` ${task.ref} is Done.` : ''}`;
+                },
+                recover: {
+                    not_merged: {
+                        key: 'f',
+                        label: 'delete anyway…',
+                        action: () => confirm('Delete an unmerged branch?', `${branch} has commits that are not merged. They will be lost.`, 'Yes, delete it and lose those commits', () => execute(true)),
+                    },
+                },
+            });
+            const doDelete = () => execute(false);
+            if (options.markDone)
+                doDelete();
+            else
+                confirm('Delete branch?', branch, `Delete ${branch}`, doDelete);
+        },
+        push(task) {
+            openOverlay({
+                kind: 'git-run',
+                title: 'Push',
+                context: task.branch ?? task.ref,
+                run: async (interactive) => {
+                    const result = await services.git.push(session, task, { cwd, interactive });
+                    return `Pushed ${result.branch} to origin`;
+                },
+            });
+        },
+        pullRequest(task) {
+            confirm('Open a pull request?', `${task.branch ?? task.ref} → ${task.baseBranch ?? 'base branch'} · pushes first`, `Push and open a PR for ${task.ref}`, () => openOverlay({
+                kind: 'git-run',
+                title: 'Pull request',
+                context: task.ref,
+                run: async (interactive) => {
+                    const result = await services.git.openPullRequest(session, task, { cwd, interactive });
+                    return `Pull request ${result.branch} → ${result.base}: ${result.url}`;
+                },
+            }));
+        },
+        /** Merges the task's PR on GitHub after showing what is still pending; optionally deletes the branch. */
+        async mergePullRequest(task) {
+            const state = await services.git.pullRequest(session, task, cwd);
+            if (state.status !== 'found') {
+                notify(state.reason, state.status === 'unavailable' ? 'error' : 'info', state.status === 'unavailable' ? state.hint : 'Open one from the Git menu (g).');
+                return;
+            }
+            const { pr } = state;
+            if (pr.state !== 'open') {
+                notify(`Pull request #${pr.number} is already ${pr.state}.`, 'info');
+                return;
+            }
+            const warnings = pullRequestWarnings(pr);
+            const execute = (deleteBranch) => openOverlay({
+                kind: 'git-run',
+                title: `Merge PR #${pr.number}`,
+                context: `${pr.head} → ${pr.base}`,
+                run: async () => {
+                    const result = await services.git.mergePullRequest(session, task, { cwd, deleteBranch });
+                    return `Merged PR #${result.pr.number} into ${result.pr.base} on GitHub. ${task.ref} is Done.${deleteBranch ? ` ${pr.head} deleted.` : ''}`;
+                },
+            });
+            openOverlay({
+                kind: 'picker',
+                title: `Merge PR #${pr.number} on GitHub?`,
+                context: `${pr.head} → ${pr.base} · merge commit${warnings.length ? ` · ${warnings.join(', ')}` : ''}`,
+                options: [
+                    { value: 'no', label: 'Cancel' },
+                    { value: 'merge', label: `Merge PR #${pr.number}`, tone: warnings.length ? 'warning' : 'success' },
+                    { value: 'merge-delete', label: `Merge and delete ${pr.head}`, tone: 'warning' },
+                ],
+                onSelect: (value) => {
+                    if (value === 'merge')
+                        execute(false);
+                    else if (value === 'merge-delete')
+                        execute(true);
+                },
+            });
+        },
+        /** Everything Git in one menu. */
+        gitMenu(task) {
+            const items = [
+                ['start', 'Start / switch to branch', 'b'],
+                ['commit', 'Commit…', 'C'],
+                ['push', 'Push branch', ''],
+                ['pullRequest', 'Open pull request…', ''],
+                ['mergePullRequest', 'Merge pull request on GitHub…', ''],
+                ['merge', 'Merge into base…', ''],
+                ['abortMerge', 'Abort merge', ''],
+                ['deleteBranch', 'Delete branch…', ''],
+                ['forget', 'Forget branch (Git untouched)', ''],
+                ['log', 'Git log', ''],
+            ];
+            openOverlay({
+                kind: 'picker',
+                title: 'Git',
+                context: task.branch ? `${task.ref} · ${task.branch}` : `${task.ref} · no branch yet`,
+                options: items.map(([value, label, key]) => ({ value, label, hint: key })),
+                onSelect: (value) => {
+                    if (value === 'start')
+                        void actions.branch(task);
+                    else if (value === 'commit')
+                        actions.commit(task);
+                    else if (value === 'push')
+                        actions.push(task);
+                    else if (value === 'pullRequest')
+                        actions.pullRequest(task);
+                    else if (value === 'mergePullRequest')
+                        void actions.mergePullRequest(task);
+                    else if (value === 'merge')
+                        void actions.merge(task);
+                    else if (value === 'abortMerge')
+                        actions.abortMerge(task);
+                    else if (value === 'deleteBranch')
+                        actions.deleteBranch(task);
+                    else if (value === 'forget')
+                        void run(() => services.git.forgetBranch(session, task), `${task.ref} has no branch now`);
+                    else if (value === 'log')
+                        openOverlay({ kind: 'git-log' });
+                },
+            });
+        },
+        toggleDone(task) {
+            return isClosed(task.status)
+                ? run(() => tasks.reopen(session, task), `${task.ref} reopened`)
+                : run(() => tasks.complete(session, task), `${task.ref} done. Nice.`);
+        },
+        edit(task) {
+            const fields = [
+                ['title', 'Title', 'e'],
+                ['description', 'Description in $EDITOR', 'd'],
+                ['descriptionInline', 'Description, one line', ''],
+                ['status', 'Status', 's'],
+                ['priority', 'Priority', 'p'],
+                ['assign', 'Assignee', 'a'],
+                ['project', 'Project', 'm'],
+                ['type', 'Type', 't'],
+                ['requester', 'Requester', 'r'],
+                ['branchName', 'Branch name', ''],
+            ];
+            const archived = task.archivedAt !== null;
+            openOverlay({
+                kind: 'picker',
+                title: 'Edit',
+                context: task.ref,
+                options: [
+                    ...fields.map(([value, label, key]) => ({ value, label, hint: key })),
+                    { value: 'archive', label: archived ? 'Restore from the archive' : 'Archive', hint: archived ? '' : 'hide from lists' },
+                    { value: 'delete', label: 'Delete permanently…', tone: 'danger', hint: 'owners' },
+                ],
+                onSelect: (value) => {
+                    if (value === 'archive')
+                        void actions.toggleArchive(task);
+                    else if (value === 'delete')
+                        actions.remove(task);
+                    else {
+                        const field = fields.find(([candidate]) => candidate === value)?.[0];
+                        if (field)
+                            void actions[field](task);
+                    }
+                },
+            });
+        },
+        toggleArchive(task) {
+            return task.archivedAt
+                ? run(() => tasks.restore(session, task), `${task.ref} is back in the lists`)
+                : run(() => tasks.archive(session, task), `${task.ref} archived. Find it with / or in Archived tasks.`);
+        },
+        /** Two confirmations: deleting takes the comments and the timeline with it, for everyone. */
+        remove(task) {
+            confirm('Delete this task for good?', `${task.ref} · ${task.title}`, `Delete ${task.ref}…`, () => confirm('Really delete it?', 'Its comments and timeline go too, for the whole team. Archive keeps it restorable.', `Yes, delete ${task.ref} permanently`, () => void run(async () => {
+                await tasks.remove(session, task);
+                if (route.name === 'task')
+                    go({ type: 'pop' });
+            }, `${task.ref} deleted`)));
+        },
+    };
+    return actions;
+}

package/dist/ui/hooks/use-terminal-size.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useWindowSize } from 'ink';
+import { createContext, useContext } from 'react';
+const SizeContext = createContext(null);
+/**
+ * One resize listener for the whole app. Ink's `useWindowSize` adds a
+ * listener per component; with dozens of panels that trips Node's
+ * "possible EventEmitter leak" warning and re-renders each one separately.
+ */
+export function TerminalSizeProvider({ children }) {
+    const { columns, rows } = useWindowSize();
+    return _jsx(SizeContext.Provider, { value: { columns, rows }, children: children });
+}
+export function useTerminalSize() {
+    const size = useContext(SizeContext);
+    // Outside the provider (isolated component tests): fall back to Ink's own hook.
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return size ?? useWindowSize();
+}