soja-cli 1.4.0

package/dist/git/types.js

@@ -0,0 +1,16 @@
+import { SojaError } from '../domain/errors.js';
+/**
+ * A Git (or gh) command failed or is unavailable. `message` is safe to show;
+ * `code` lets interfaces offer a follow-up (force delete, abort merge,
+ * retry interactively); `suggestions` are next steps in plain words.
+ */
+export class GitError extends SojaError {
+    code;
+    suggestions;
+    constructor(message, options = {}) {
+        const suggestions = options.suggestions ?? (options.hint ? [options.hint] : []);
+        super(message, { hint: options.hint ?? suggestions[0], cause: options.cause });
+        this.code = options.code ?? 'failed';
+        this.suggestions = suggestions;
+    }
+}

package/dist/ui/App.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useApp } from 'ink';
+import { useEffect, useState } from 'react';
+import { toDisplayError } from '../utils/errors.js';
+import { AppStateProvider } from './app-state.js';
+import { Splash } from './branding/Splash.js';
+import { Layer } from './input/dispatcher.js';
+import { KeyProvider, useKeys } from './input/KeyProvider.js';
+import { SetupScreen } from './screens/SetupScreen.js';
+import { WelcomeScreen } from './screens/WelcomeScreen.js';
+import { TerminalSizeProvider } from './hooks/use-terminal-size.js';
+import { Shell } from './Shell.js';
+import { palette, symbols } from './theme/theme.js';
+function resolvePhase(state) {
+    if (state.failure)
+        return { kind: 'failed', error: state.failure };
+    // A session made by setup goes straight in; setup already showed the splash.
+    if (state.created)
+        return { kind: 'ready', session: state.created };
+    if (state.stored === null)
+        return { kind: 'setup' };
+    if (state.stored && state.splashDone)
+        return { kind: 'ready', session: state.stored };
+    return { kind: 'splash' };
+}
+export function App({ services, splashMs = 700, cwd = process.cwd(), initialRoute, updates, mouse = false, welcomeOnLocal = false }) {
+    return (_jsx(KeyProvider, { mouse: mouse, children: _jsx(TerminalSizeProvider, { children: _jsx(Boot, { services: services, splashMs: splashMs, cwd: cwd, initialRoute: initialRoute, updates: updates, welcomeOnLocal: welcomeOnLocal }) }) }));
+}
+function Boot({ services, splashMs, cwd, initialRoute, updates, welcomeOnLocal }) {
+    const { exit } = useApp();
+    // undefined while loading, null when setup is needed.
+    const [stored, setStored] = useState(undefined);
+    const [created, setCreated] = useState(null);
+    const [localSetup, setLocalSetup] = useState(false);
+    const [localChoiceDone, setLocalChoiceDone] = useState(false);
+    const [failure, setFailure] = useState(null);
+    const [splashDone, setSplashDone] = useState(splashMs <= 0);
+    useEffect(() => {
+        services.session.current().then(setStored, (error) => setFailure(toDisplayError(error)));
+    }, [services]);
+    useEffect(() => {
+        if (splashDone)
+            return;
+        const timer = setTimeout(() => setSplashDone(true), splashMs);
+        return () => clearTimeout(timer);
+    }, [splashDone, splashMs]);
+    const phase = resolvePhase({ stored, created, failure, splashDone });
+    useKeys(Layer.screen, (input) => {
+        if (phase.kind === 'failed' && input === 'q')
+            exit();
+        else if (phase.kind === 'splash')
+            setSplashDone(true);
+        else
+            return false;
+        return true;
+    }, phase.kind === 'splash' || phase.kind === 'failed');
+    switch (phase.kind) {
+        case 'splash':
+            return _jsx(Splash, {});
+        case 'setup':
+            return localSetup ? _jsx(SetupScreen, { services: services, onDone: setCreated }) : _jsx(WelcomeScreen, { onLocal: () => { setLocalSetup(true); setLocalChoiceDone(true); } });
+        case 'failed':
+            if (services.environment.mode === 'remote')
+                return _jsx(WelcomeScreen, { onLocal: () => exit() });
+            return (_jsxs(Box, { paddingX: 1, paddingTop: 1, flexDirection: "column", children: [_jsx(Text, { color: palette.danger, children: `${symbols.cross} ${phase.error.message}` }), phase.error.hint ? _jsx(Text, { dimColor: true, children: phase.error.hint }) : null, phase.error.debug ? _jsx(Text, { dimColor: true, children: phase.error.debug }) : null, _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "q quit" }) })] }));
+        case 'ready':
+            if (services.environment.mode === 'local' && welcomeOnLocal && !localChoiceDone)
+                return _jsx(WelcomeScreen, { onLocal: () => setLocalChoiceDone(true) });
+            return (_jsx(AppStateProvider, { services: services, cwd: cwd, initialSession: phase.session, ...(initialRoute ? { initialRoute } : {}), ...(updates ? { updates } : {}), children: _jsx(Shell, {}) }));
+    }
+}

package/dist/ui/Shell.js

@@ -0,0 +1,211 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from 'ink';
+import { useEffect } from 'react';
+import { useAppState } from './app-state.js';
+import { ActiveScope, ChromeProvider, useChromeHints } from './chrome/context.js';
+import { Sidebar } from './chrome/Sidebar.js';
+import { StatusBar } from './chrome/StatusBar.js';
+import { Toast } from './chrome/Toast.js';
+import { TopBar } from './chrome/TopBar.js';
+import { useCommandPalette } from './hooks/use-commands.js';
+import { FOOTER_GAP_ROWS, footerRowsFor, useLayout } from './hooks/use-layout.js';
+import { useQuery } from './hooks/use-query.js';
+import { Layer } from './input/dispatcher.js';
+import { useKeys } from './input/KeyProvider.js';
+import { CommitOverlay } from './overlays/CommitOverlay.js';
+import { ConfirmOverlay } from './overlays/ConfirmOverlay.js';
+import { GitLogOverlay } from './overlays/GitLogOverlay.js';
+import { GitRunOverlay } from './overlays/GitRunOverlay.js';
+import { NewTaskOverlay } from './overlays/NewTaskOverlay.js';
+import { PickerOverlay } from './overlays/PickerOverlay.js';
+import { PromptOverlay } from './overlays/PromptOverlay.js';
+import { SearchOverlay } from './overlays/SearchOverlay.js';
+import { HelpScreen } from './screens/HelpScreen.js';
+import { ProjectsScreen } from './screens/ProjectsScreen.js';
+import { TaskListScreen } from './screens/TaskListScreen.js';
+import { TaskScreen } from './screens/TaskScreen.js';
+import { WorkspacesScreen } from './screens/WorkspacesScreen.js';
+import { ChatScreen } from './screens/ChatScreen.js';
+import { AccessScreen } from './screens/AccessScreen.js';
+import { ApiClient } from '../data/remote/api-client.js';
+import { CredentialStore } from '../config/credentials.js';
+import { resolvePaths } from '../config/paths.js';
+/**
+ * The running app, laid out like a desktop application: title bar, sidebar,
+ * the screen stack in the main area, status bar, and floating windows and
+ * notices on top. Screens below the top stay mounted (hidden) so going back
+ * restores the selection you left.
+ */
+export function Shell() {
+    return (_jsx(ChromeProvider, { children: _jsx(Frame, {}) }));
+}
+function Frame() {
+    const { session, services, stack, route, overlay, openOverlay, go, quit, cwd, detectMerges, followPullRequests, syncStatus } = useAppState();
+    const hints = useChromeHints();
+    // New tasks default to the open project, or to the project linked to the repository SOJA runs in.
+    const here = useQuery(async () => (await services.projects.findByRepository(session, cwd))?.id ?? null, `cwd:${session.workspace.id}`);
+    const routeProjectId = route.name === 'project' ? route.projectId : null;
+    const newTaskProjectId = routeProjectId ?? here.data ?? null;
+    const openPalette = useCommandPalette(newTaskProjectId);
+    const projectId = routeProjectId;
+    const project = useQuery(async () => (projectId ? (await services.projects.get(session, projectId)).name : null), `header:${projectId ?? ''}`);
+    const chat = services.chat;
+    const chatTotals = useQuery(async () => (chat ? chat.totals(session) : null), `chat-totals:${session.workspace.id}`);
+    const accountBadge = useQuery(async () => {
+        if (services.environment.mode !== 'remote')
+            return false;
+        const token = new CredentialStore(resolvePaths().credentialsFile).token(services.environment.server);
+        if (!token)
+            return false;
+        const { user } = await new ApiClient(services.environment.server, token).get('/v1/profile');
+        return user.isCeo === true;
+    }, `account-badge:${session.user.id}`);
+    // On launch and whenever you come back to a task list, catch merges done elsewhere.
+    const onList = route.name === 'home' || route.name === 'project';
+    useEffect(() => {
+        if (onList && !overlay) {
+            void detectMerges();
+            void followPullRequests();
+        }
+    }, [onList, overlay, stack.length, detectMerges, followPullRequests]);
+    // With SOJA open, GitHub is checked every few minutes (merges and CI happen there).
+    useEffect(() => {
+        const timer = setInterval(() => void followPullRequests(), 180_000);
+        return () => clearInterval(timer);
+    }, [followPullRequests]);
+    useKeys(Layer.global, (input, key) => {
+        if (input === ':' || (key.ctrl && input === 'k'))
+            openPalette();
+        else if (key.ctrl || key.meta)
+            return false;
+        else if (input === '/')
+            openOverlay({ kind: 'search' });
+        else if (input === 'n')
+            openOverlay({ kind: 'new-task', projectId: newTaskProjectId });
+        else if (input === '?')
+            go({ type: 'push', route: { name: 'help' } });
+        else if (input === 'p')
+            go({ type: 'push', route: { name: 'projects' } });
+        else if (input === 'w')
+            go({ type: 'push', route: { name: 'workspaces' } });
+        else if (input === 'A')
+            go({ type: 'push', route: { name: 'access' } });
+        else if (input === '#' && chat)
+            go({ type: 'push', route: { name: 'chat' } });
+        else if (key.escape && stack.length > 1)
+            go({ type: 'pop' });
+        else if (input === 'q') {
+            if (stack.length > 1)
+                go({ type: 'pop' });
+            else
+                quit();
+        }
+        else
+            return false;
+        return true;
+    });
+    const { columns, rows, sidebar } = useLayout();
+    const { flash } = useAppState();
+    const server = services.environment.mode === 'remote' ? new URL(services.environment.server).host : undefined;
+    const syncLabel = syncLabelFor(syncStatus);
+    return (_jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [_jsx(TopBar, { columns: columns, workspace: session.workspace.name, trail: trailFor(route, project.data), username: session.user.username, isCeo: accountBadge.data === true, server: server, sync: syncLabel, chat: route.name === 'chat' ? undefined : (chatTotals.data ?? undefined) }), _jsxs(Box, { flexGrow: 1, flexShrink: 1, children: [sidebar ? _jsx(Sidebar, { width: sidebar, height: rows - 1 - FOOTER_GAP_ROWS - footerRowsFor(columns), active: !overlay }) : null, _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, children: stack.map((entry, index) => {
+                            const top = index === stack.length - 1;
+                            // The screen under a window stays visible, but only the window takes keys and clicks.
+                            const active = top && !overlay;
+                            return (_jsx(Box, { display: top ? 'flex' : 'none', flexDirection: "column", flexGrow: 1, children: _jsx(ActiveScope, { active: active, children: _jsx(ScreenFor, { route: entry, active: active }) }) }, `${index}:${JSON.stringify(entry)}`));
+                        }) })] }), _jsx(Box, { height: FOOTER_GAP_ROWS, flexShrink: 0 }), _jsx(StatusBar, { columns: columns, mode: overlay ? modeForOverlay(overlay) : modeFor(route), hints: hints, right: server ? undefined : 'local' }), overlay ? (_jsx(ActiveScope, { active: true, children: _jsx(OverlayFor, { overlay: overlay }) })) : null, flash ? _jsx(Toast, { flash: flash, columns: columns, rows: rows }) : null] }));
+}
+function ScreenFor({ route, active }) {
+    switch (route.name) {
+        case 'home':
+            return _jsx(TaskListScreen, { active: active, ...(route.filter ? { initialFilter: route.filter } : {}) });
+        case 'task':
+            return _jsx(TaskScreen, { active: active, taskRef: route.ref });
+        case 'projects':
+            return _jsx(ProjectsScreen, { active: active });
+        case 'project':
+            return _jsx(TaskListScreen, { active: active, projectId: route.projectId });
+        case 'workspaces':
+            return _jsx(WorkspacesScreen, { active: active });
+        case 'access':
+            return _jsx(AccessScreen, { active: active });
+        case 'help':
+            return _jsx(HelpScreen, {});
+        case 'chat':
+            return _jsx(ChatScreen, { active: active, ...(route.channel ? { initialChannel: route.channel } : {}) });
+    }
+}
+function OverlayFor({ overlay }) {
+    switch (overlay.kind) {
+        case 'confirm':
+            return _jsx(ConfirmOverlay, { spec: overlay }, overlay.title + (overlay.context ?? ''));
+        case 'picker':
+            return _jsx(PickerOverlay, { spec: overlay }, overlay.title + (overlay.context ?? ''));
+        case 'prompt':
+            return _jsx(PromptOverlay, { spec: overlay }, overlay.title + (overlay.context ?? ''));
+        case 'search':
+            return _jsx(SearchOverlay, { spec: overlay });
+        case 'new-task':
+            return _jsx(NewTaskOverlay, { spec: overlay });
+        case 'git-run':
+            return _jsx(GitRunOverlay, { spec: overlay }, `${overlay.title}:${overlay.context ?? ''}`);
+        case 'commit':
+            return _jsx(CommitOverlay, { spec: overlay });
+        case 'git-log':
+            return _jsx(GitLogOverlay, { spec: overlay });
+    }
+}
+function trailFor(route, projectName) {
+    switch (route.name) {
+        case 'project':
+            return projectName ? ['Projects', projectName] : ['Projects'];
+        case 'task':
+            return [route.ref];
+        case 'projects':
+            return ['Projects'];
+        case 'workspaces':
+            return ['Workspaces'];
+        case 'access':
+            return ['Access approvals'];
+        case 'help':
+            return ['Help'];
+        case 'chat':
+            return route.channel ? ['Chat', `#${route.channel.replace(/^#/, '')}`] : ['Chat'];
+        case 'home':
+            return [];
+    }
+}
+function modeFor(route) {
+    switch (route.name) {
+        case 'home':
+            return 'Tasks';
+        case 'project':
+            return 'Project';
+        default:
+            return route.name;
+    }
+}
+const OVERLAY_MODES = {
+    picker: 'Select',
+    confirm: 'Confirm',
+    prompt: 'Input',
+    search: 'Search',
+    'new-task': 'New task',
+    'git-run': 'Git',
+    commit: 'Commit',
+    'git-log': 'Git log',
+};
+function modeForOverlay(overlay) {
+    return OVERLAY_MODES[overlay.kind];
+}
+function syncLabelFor(status) {
+    if (!status)
+        return undefined;
+    if (status.syncing)
+        return { text: 'syncing…', tone: 'busy' };
+    if (status.online === false)
+        return { text: `offline${status.pending ? ` · ${status.pending} pending` : ''}`, tone: 'warn' };
+    if (status.pending)
+        return { text: `${status.pending} pending`, tone: status.lastError ? 'warn' : 'busy' };
+    return { text: 'synced', tone: 'ok' };
+}

package/dist/ui/app-state.js

@@ -0,0 +1,213 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useApp } from 'ink';
+import { createContext, useCallback, useContext, useEffect, useMemo, useReducer, useRef, useState } from 'react';
+import { toDisplayError } from '../utils/errors.js';
+import { navigate } from './navigation/routes.js';
+const AppStateContext = createContext(null);
+export function AppStateProvider({ services, cwd, initialSession, initialRoute, updates, children }) {
+    const { exit } = useApp();
+    const [session, setSession] = useState(initialSession);
+    const [stack, dispatch] = useReducer(navigate, navigate([{ name: 'home' }], { type: 'reset', ...(initialRoute ? { route: initialRoute } : {}) }));
+    const [overlay, setOverlay] = useState(null);
+    const [flash, setFlash] = useState(null);
+    const [revision, setRevision] = useState(0);
+    const [queryEpochs, setQueryEpochs] = useState({});
+    const [homeFilter, setHomeFilter] = useState(initialRoute?.name === 'home' && initialRoute.filter ? initialRoute.filter : 'mine');
+    useEffect(() => {
+        if (!flash)
+            return;
+        const timer = setTimeout(() => setFlash(null), flash.tone === 'error' ? 6000 : 3000);
+        return () => clearTimeout(timer);
+    }, [flash]);
+    const notify = useCallback((text, tone = 'info', hint) => {
+        setFlash({ id: Date.now(), text, tone, hint });
+    }, []);
+    const queryVersion = useCallback((topics) => topics.map((topic) => `${topic}:${queryEpochs[topic] ?? 0}`).join('|'), [queryEpochs]);
+    const invalidateQueries = useCallback((topics) => {
+        if (topics.length === 0)
+            return;
+        setQueryEpochs((current) => {
+            const next = { ...current };
+            for (const topic of new Set(topics))
+                next[topic] = (next[topic] ?? 0) + 1;
+            return next;
+        });
+    }, []);
+    const [syncStatus, setSyncStatus] = useState(null);
+    // Once per launch, and at most one GitHub request a day.
+    useEffect(() => {
+        if (!updates)
+            return;
+        let active = true;
+        void updates().then((update) => {
+            if (active && update?.available)
+                notify(`SOJA v${update.latest} is available`, 'info', 'Run `soja update` to install it.');
+        });
+        return () => {
+            active = false;
+        };
+    }, [updates, notify]);
+    const run = useCallback(async (action, success) => {
+        try {
+            await action();
+            setRevision((value) => value + 1);
+            if (services.sync)
+                void services.sync.status(session.workspace.id).then(setSyncStatus);
+            if (success)
+                notify(success, 'success');
+            return true;
+        }
+        catch (error) {
+            const display = toDisplayError(error);
+            notify(display.message, 'error', display.hint);
+            return false;
+        }
+    }, [notify, services, session.workspace.id]);
+    const lastScan = useRef(0);
+    const detectMerges = useCallback(async (only) => {
+        if (!only) {
+            if (Date.now() - lastScan.current < 10_000)
+                return;
+            lastScan.current = Date.now();
+        }
+        try {
+            const merged = (await services.git.detectMerges(session, cwd, only ? { only } : {})).filter((result) => result.kind === 'merged');
+            const [first] = merged;
+            if (!first)
+                return;
+            notify(merged.length === 1
+                ? `${first.task.ref} was merged into ${first.into} outside SOJA → Done`
+                : `${merged.length} tasks were merged outside SOJA → Done`, 'success');
+            setRevision((value) => value + 1);
+        }
+        catch {
+            // Detection is best effort; the task views report Git problems themselves.
+        }
+    }, [services, session, cwd, notify]);
+    const lastPrScan = useRef(0);
+    const followPullRequests = useCallback(async (only) => {
+        if (!only) {
+            if (Date.now() - lastPrScan.current < 120_000)
+                return;
+            lastPrScan.current = Date.now();
+        }
+        try {
+            const updates = await services.git.followPullRequests(session, cwd, only ? { only } : {});
+            const merged = updates.filter((update) => update.kind === 'merged');
+            const failed = updates.filter((update) => update.kind === 'checks_failed');
+            const [firstMerged] = merged;
+            const [firstFailed] = failed;
+            if (firstMerged) {
+                notify(merged.length === 1
+                    ? `${firstMerged.task.ref}: PR #${firstMerged.pr.number} was merged on GitHub → Done`
+                    : `${merged.length} pull requests were merged on GitHub → Done`, 'success');
+            }
+            else if (firstFailed) {
+                notify(failed.length === 1
+                    ? `${firstFailed.task.ref}: checks failed on PR #${firstFailed.pr.number} (${firstFailed.pr.checks.failing.join(', ')})`
+                    : `Checks failed on ${failed.length} pull requests`, 'error');
+            }
+            if (updates.length)
+                setRevision((value) => value + 1);
+        }
+        catch {
+            // Best effort: without gh, or offline, there is simply nothing new.
+        }
+    }, [services, session, cwd, notify]);
+    // Remote mode: sync on launch, every 30 s and shortly after changes; refresh views when it finishes.
+    useEffect(() => {
+        const sync = services.sync;
+        if (!sync)
+            return;
+        const workspaceId = session.workspace.id;
+        let active = true;
+        const updateStatus = () => {
+            void sync.status(workspaceId).then((status) => {
+                if (active)
+                    setSyncStatus(status);
+            });
+        };
+        // A sync only invalidates queries for entities that actually changed in the replica.
+        const onSync = (report) => {
+            updateStatus();
+            if (!report || !active)
+                return;
+            const topics = [];
+            if (report.changes.taskRefs.length) {
+                topics.push(`tasks:${workspaceId}`, `projects:${workspaceId}`, `sidebar-tasks:${workspaceId}`);
+                for (const ref of report.changes.taskRefs)
+                    topics.push(`task:${workspaceId}:${ref}`);
+            }
+            if (report.changes.projects)
+                topics.push(`projects:${workspaceId}`);
+            if (report.changes.members)
+                topics.push(`members:${workspaceId}`);
+            if (report.changes.chatChannelIds.length || report.changes.chatReads) {
+                topics.push(`chat-channels:${workspaceId}`, `sidebar-channels:${workspaceId}`, `chat-totals:${workspaceId}`);
+            }
+            for (const channelId of report.changes.chatMessageChannelIds) {
+                topics.push(`chat:${workspaceId}`, `chat-messages:${channelId}`, `chat-channels:${workspaceId}`, `sidebar-channels:${workspaceId}`, `chat-totals:${workspaceId}`, `chat-notices:${workspaceId}`);
+            }
+            invalidateQueries(topics);
+            if (report.chatRejected)
+                notify(`Chat: ${report.chatRejected} message change${report.chatRejected === 1 ? '' : 's'} not applied`, 'error', 'Open the chat (#) to get your text back.');
+            else if (report.conflicts || report.rejected) {
+                const parts = [
+                    report.conflicts && `${report.conflicts} conflict${report.conflicts === 1 ? '' : 's'}`,
+                    report.rejected && `${report.rejected} rejected change${report.rejected === 1 ? '' : 's'}`,
+                ];
+                notify(`Sync: ${parts.filter(Boolean).join(', ')}`, 'error', 'Open the task and press ! to review.');
+            }
+        };
+        const runSync = () => sync.syncNow(workspaceId);
+        const unsubscribe = sync.subscribe(onSync);
+        updateStatus();
+        // Real time (chat and "something changed"); each connection starts with a sync.
+        const stopLive = sync.startLive(workspaceId);
+        void runSync();
+        const interval = setInterval(() => void runSync(), 30_000);
+        return () => {
+            active = false;
+            unsubscribe();
+            stopLive();
+            clearInterval(interval);
+        };
+    }, [services, session.workspace.id, notify, invalidateQueries]);
+    const changeSession = useCallback((next) => {
+        setSession(next);
+        dispatch({ type: 'reset' });
+        setRevision((value) => value + 1);
+    }, []);
+    const value = useMemo(() => ({
+        services,
+        cwd,
+        session,
+        setSession: changeSession,
+        stack,
+        route: stack.at(-1) ?? { name: 'home' },
+        go: dispatch,
+        overlay,
+        openOverlay: setOverlay,
+        closeOverlay: (which) => setOverlay((current) => (!which || current === which ? null : current)),
+        flash,
+        notify,
+        revision,
+        queryVersion,
+        invalidateQueries,
+        run,
+        refresh: () => setRevision((value) => value + 1),
+        detectMerges,
+        followPullRequests,
+        syncStatus,
+        homeFilter,
+        setHomeFilter,
+        quit: exit,
+    }), [services, cwd, session, changeSession, stack, overlay, flash, notify, revision, queryVersion, invalidateQueries, run, detectMerges, followPullRequests, syncStatus, homeFilter, exit]);
+    return _jsx(AppStateContext.Provider, { value: value, children: children });
+}
+export function useAppState() {
+    const state = useContext(AppStateContext);
+    if (!state)
+        throw new Error('useAppState must be used inside <AppStateProvider>');
+    return state;
+}

package/dist/ui/branding/CompactLogo.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { palette, symbols } from '../theme/theme.js';
+import { APP_NAME } from './brand.js';
+/** One-line mark: the name and the cursor that ends the full wordmark. */
+export function CompactLogo() {
+    return (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: APP_NAME }), _jsx(Text, { color: palette.accent, children: symbols.cursor })] }));
+}

package/dist/ui/branding/Logo.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { brandGradient, palette } from '../theme/theme.js';
+import { WORDMARK, WORDMARK_CURSOR } from './brand.js';
+/** Colors a line column by column so the gradient runs left to right across the mark. */
+function gradientSegments(line) {
+    const width = WORDMARK[0]?.length ?? line.length;
+    const segments = [];
+    for (const [index, char] of [...line].entries()) {
+        const color = brandGradient[Math.min(brandGradient.length - 1, Math.floor((index / width) * brandGradient.length))];
+        const last = segments.at(-1);
+        if (last && last.color === color)
+            last.text += char;
+        else
+            segments.push({ text: char, color: color ?? palette.accent });
+    }
+    return segments;
+}
+/** The full SOJA wordmark with its trailing terminal cursor. */
+export function Logo({ cursorVisible = true }) {
+    return (_jsx(Box, { flexDirection: "column", children: WORDMARK.map((line, row) => (_jsxs(Text, { children: [gradientSegments(line).map((segment, index) => (_jsx(Text, { color: segment.color, children: segment.text }, index))), row === WORDMARK.length - 1 ? (_jsx(Text, { color: palette.accent, children: cursorVisible ? ` ${WORDMARK_CURSOR}` : '' })) : null] }, row))) }));
+}

package/dist/ui/branding/Splash.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useAnimation } from 'ink';
+import { useTerminalSize } from '../hooks/use-terminal-size.js';
+import { Spinner } from '../kit/Spinner.js';
+import { palette } from '../theme/theme.js';
+import { APP_AUTHOR, APP_DESCRIPTION, APP_SLOGAN, APP_VERSION, WORDMARK_WIDTH } from './brand.js';
+import { CompactLogo } from './CompactLogo.js';
+import { Logo } from './Logo.js';
+/**
+ * SOJA's identity. Full screen and centered at launch; `compact` is the
+ * block the setup wizard puts above its card.
+ */
+export function Splash({ status, compact = false }) {
+    const { columns, rows } = useTerminalSize();
+    const { frame } = useAnimation({ interval: 530 });
+    const roomy = columns >= WORDMARK_WIDTH + 4;
+    const identity = (_jsxs(Box, { flexDirection: "column", alignItems: "center", paddingBottom: 1, children: [roomy ? _jsx(Logo, { cursorVisible: frame % 2 === 0 }) : _jsx(CompactLogo, {}), _jsxs(Box, { marginTop: 1, flexDirection: "column", alignItems: "center", children: [_jsx(Text, { color: palette.text, bold: true, children: APP_DESCRIPTION }), _jsx(Text, { color: palette.muted, children: APP_SLOGAN })] })] }));
+    if (compact)
+        return identity;
+    return (_jsxs(Box, { width: columns, height: rows, flexDirection: "column", alignItems: "center", justifyContent: "center", children: [identity, _jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: status ?? 'Opening your workspace…' }) }), _jsxs(Box, { marginTop: 1, gap: 2, children: [_jsx(Text, { color: palette.faint, children: APP_AUTHOR }), _jsx(Text, { color: palette.faint, children: `v${APP_VERSION}` })] })] }));
+}

package/dist/ui/branding/brand.js

@@ -0,0 +1,23 @@
+/**
+ * Single source of SOJA's identity. Plain strings only (no Ink) so the
+ * non-interactive CLI can use them too.
+ */
+export { APP_VERSION } from '../../config/version.js';
+export const APP_NAME = 'SOJA';
+export const APP_DESCRIPTION = 'Software Operations & Job Assistant';
+export const APP_SLOGAN = 'No dashboards. No browser. No bullshit. Just work.';
+export const APP_AUTHOR = 'Enmauel.biz';
+/** Where releases (and the installable package) are published. */
+export const APP_REPOSITORY = 'Mike28108/soja-cli';
+/**
+ * The wordmark: a rounded pixel font drawn with half blocks, so every
+ * terminal row carries two pixel rows and the mark stays three lines tall.
+ */
+export const WORDMARK = [
+    '▄█▀▀▀▀▀▀  ▄█▀▀▀▀█▄        ██  ▄█▀▀▀▀█▄',
+    ' ▀▀▀▀▀█▄  ██    ██        ██  ██▄▄▄▄██',
+    '▄▄▄▄▄▄█▀  ▀█▄▄▄▄█▀  ▀█▄▄▄▄█▀  ██    ██',
+];
+/** The terminal cursor that follows the wordmark. It is SOJA's signature. */
+export const WORDMARK_CURSOR = '▄▄▄';
+export const WORDMARK_WIDTH = Math.max(...WORDMARK.map((line) => line.length)) + 1 + WORDMARK_CURSOR.length;

package/dist/ui/chrome/Sidebar.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { FILTER_LABELS } from '../../application/filters.js';
+import { isClosed } from '../../domain/task.js';
+import { useAppState } from '../app-state.js';
+import { useQuery } from '../hooks/use-query.js';
+import { Clickable } from '../kit/Clickable.js';
+import { palette, symbols } from '../theme/theme.js';
+const VIEWS = ['mine', 'all', 'todo', 'in_progress', 'review', 'blocked', 'done'];
+const VIEW_LABELS = { ...FILTER_LABELS, mine: 'My work', all: 'All open' };
+/**
+ * Where everything is, always visible on wide terminals: the task views
+ * with their counts, the chat channels, the projects. Everything is clickable;
+ * the keyboard shortcuts stay the same.
+ */
+export function Sidebar({ width, height, active }) {
+    const { services, session, route, go, homeFilter, setHomeFilter } = useAppState();
+    const counts = useQuery(async () => {
+        const [open, done] = await Promise.all([services.tasks.list(session, 'all'), services.tasks.list(session, 'done')]);
+        const byView = { mine: 0, all: open.length, todo: 0, in_progress: 0, review: 0, blocked: 0, done: done.length, archived: 0 };
+        for (const task of open) {
+            if (task.assigneeId === session.user.id && !isClosed(task.status))
+                byView.mine += 1;
+            if (task.status === 'todo' || task.status === 'in_progress' || task.status === 'review' || task.status === 'blocked')
+                byView[task.status] += 1;
+        }
+        return byView;
+    }, `sidebar-counts:${session.workspace.id}`, [`sidebar-tasks:${session.workspace.id}`]);
+    const projects = useQuery(() => services.projects.list(session), `sidebar-projects:${session.workspace.id}`, [`projects:${session.workspace.id}`, `tasks:${session.workspace.id}`]);
+    const chat = services.chat;
+    const channels = useQuery(async () => (chat ? chat.channels(session) : []), `sidebar-channels:${session.workspace.id}`, [`sidebar-channels:${session.workspace.id}`]);
+    const onHome = route.name === 'home';
+    const openView = (filter) => {
+        setHomeFilter(filter);
+        go({ type: 'reset' });
+    };
+    const open = (next) => go({ type: 'reset', route: next });
+    const openChannels = (channels.data ?? []).filter((channel) => !channel.archivedAt);
+    // Leave room for the sections that follow; long lists are cut with a "more" line.
+    const projectRows = Math.max(1, height - VIEWS.length - 8 - (chat ? Math.min(openChannels.length, 5) + 2 : 0));
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, flexShrink: 0, paddingX: 1, overflow: "hidden", children: [_jsx(Section, { title: "TASKS" }), VIEWS.map((view) => (_jsx(Item, { label: VIEW_LABELS[view], count: counts.data?.[view], selected: onHome && homeFilter === view, onClick: () => openView(view), active: active }, view))), chat ? (_jsxs(_Fragment, { children: [_jsx(Section, { title: "CHAT" }), openChannels.slice(0, 5).map((channel) => (_jsx(Item, { label: `#${channel.name}`, count: channel.unread || undefined, highlight: channel.mentions > 0 ? 'mention' : channel.unread > 0 ? 'unread' : undefined, selected: route.name === 'chat' && route.channel === channel.name, onClick: () => open({ name: 'chat', channel: channel.name }), active: active }, channel.id)))] })) : null, _jsx(Section, { title: "PROJECTS" }), (projects.data ?? []).slice(0, projectRows).map((project) => (_jsx(Item, { label: project.name, count: project.active || undefined, selected: route.name === 'project' && route.projectId === project.id, onClick: () => open({ name: 'project', projectId: project.id }), active: active }, project.id))), (projects.data?.length ?? 0) > projectRows ? (_jsx(Item, { label: `${symbols.ellipsis} all projects`, selected: route.name === 'projects', onClick: () => open({ name: 'projects' }), active: active, muted: true })) : null, (projects.data?.length ?? 0) === 0 && !projects.loading ? _jsx(Text, { color: palette.faint, children: '  none yet · p' }) : null] }));
+}
+function Section({ title }) {
+    return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: palette.faint, bold: true, children: title }) }));
+}
+function Item({ label, count, selected, onClick, active, highlight, muted = false, }) {
+    const background = selected ? { backgroundColor: palette.selection } : {};
+    const countColor = highlight === 'mention' ? palette.warning : highlight === 'unread' ? palette.accent : palette.faint;
+    return (_jsx(Clickable, { onClick: onClick, active: active, children: _jsxs(Box, { justifyContent: "space-between", flexGrow: 1, ...background, children: [_jsxs(Text, { wrap: "truncate-end", ...background, children: [_jsx(Text, { color: palette.accent, children: selected ? symbols.pointer : ' ' }), _jsx(Text, { color: selected ? palette.text : muted ? palette.muted : palette.barText, bold: selected, children: label })] }), count !== undefined ? (_jsx(Text, { ...background, color: countColor, bold: Boolean(highlight), children: `${count} ` })) : null] }) }));
+}