stratanodex 0.1.0

package/dist/tui/screens/LoginScreen.js

@@ -0,0 +1,115 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useRef, useCallback } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { Spinner } from '@inkjs/ui';
+import open from 'open';
+import { createCliSession, pollCliSession } from '../../api/client.js';
+import { saveToken } from '../../utils/auth.js';
+import { ApiError } from '../../api/ApiError.js';
+import chalk from 'chalk';
+const AUTH_URL_BASE = process.env['STRATANODEX_AUTH_URL'] ?? 'https://stratanodex-landing-page.vercel.app';
+const POLL_INTERVAL_MS = 2000;
+export function LoginScreen({ replaceScreen, registerActions }) {
+    const [state, setState] = useState('creating');
+    const [errorMsg, setErrorMsg] = useState('');
+    const pollRef = useRef(null);
+    // Use a ref for the attempt counter so re-runs are stable
+    const attemptRef = useRef(0);
+    const stopPolling = useCallback(() => {
+        if (pollRef.current) {
+            clearInterval(pollRef.current);
+            pollRef.current = null;
+        }
+    }, []);
+    const startLogin = useCallback(async () => {
+        stopPolling();
+        setState('creating');
+        setErrorMsg('');
+        const attempt = ++attemptRef.current;
+        try {
+            // 1. Create CLI session on backend
+            const { code } = await createCliSession();
+            if (attemptRef.current !== attempt)
+                return; // stale attempt
+            // 2. Open browser to auth page — hash-routed, ?session= is inside the hash
+            const separator = AUTH_URL_BASE.includes('?') ? '&' : '?';
+            await open(`${AUTH_URL_BASE}${separator}session=${code}#auth`);
+            setState('waiting');
+            // 3. Poll until complete or error
+            pollRef.current = setInterval(async () => {
+                if (attemptRef.current !== attempt) {
+                    stopPolling();
+                    return;
+                }
+                try {
+                    const result = await pollCliSession(code);
+                    if (result.status === 'complete' && result.token) {
+                        stopPolling();
+                        saveToken(result.token);
+                        setState('success');
+                        // Brief flash, then navigate
+                        setTimeout(() => replaceScreen('home'), 600);
+                    }
+                    // status === 'pending' → keep polling, no state change
+                }
+                catch (_err) {
+                    stopPolling();
+                    if (attemptRef.current !== attempt)
+                        return;
+                    const statusCode = _err instanceof ApiError ? _err.statusCode : 0;
+                    if (statusCode === 410) {
+                        setErrorMsg('Session expired. Press R to retry.');
+                    }
+                    else if (statusCode === 404) {
+                        setErrorMsg('Session not found. Press R to retry.');
+                    }
+                    else {
+                        setErrorMsg('Connection lost. Press R to retry.');
+                    }
+                    setState('error');
+                }
+            }, POLL_INTERVAL_MS);
+        }
+        catch (e) {
+            if (attemptRef.current !== attempt)
+                return;
+            const status = e instanceof ApiError ? e.statusCode : 0;
+            if (status === 429) {
+                setErrorMsg('Too many retries. Wait a moment then press R.');
+            }
+            else {
+                setErrorMsg('Cannot reach backend. Check your connection and press R.');
+            }
+            setState('error');
+        }
+    }, [stopPolling, replaceScreen]);
+    // Register navigation actions
+    useEffect(() => {
+        registerActions({
+            onBack: () => {
+                stopPolling();
+                replaceScreen('welcome');
+            },
+            onQuit: () => {
+                stopPolling();
+                replaceScreen('welcome');
+            },
+        });
+    }, [registerActions, stopPolling, replaceScreen]);
+    // Mount-only effect — startLogin and stopPolling are stable refs
+    useEffect(() => {
+        startLogin();
+        return stopPolling;
+    }, []);
+    // Keyboard: R = retry, Q/ESC = cancel
+    useInput((input, key) => {
+        if (state === 'error' && (input === 'r' || input === 'R')) {
+            startLogin();
+        }
+        if (input === 'q' || input === 'Q' || key.escape) {
+            stopPolling();
+            replaceScreen('welcome');
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 3, paddingY: 2, gap: 1, children: [_jsx(Text, { bold: true, color: "#00bfff", children: "Authentication" }), state === 'creating' && (_jsx(Box, { flexDirection: "column", gap: 1, children: _jsx(Spinner, { label: chalk.hex('#8b949e')('  Connecting to server (may take ~15s on first launch)...') }) })), state === 'waiting' && (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Text, { color: "#00bfff", children: ['>', " Browser opened \u2014 complete login there"] }), _jsx(Spinner, { label: chalk.hex('#8b949e')('  Waiting for authentication...') }), _jsx(Text, { color: "#8b949e", dimColor: true, children: "Q to cancel" })] })), state === 'error' && (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Text, { color: "red", children: ["\u2715 ", errorMsg] }), _jsx(Text, { color: "#8b949e", dimColor: true, children: "R to retry \u00B7 Q to quit" })] })), state === 'success' && _jsx(Text, { color: "#00c896", children: "\u2713 Logged in successfully" })] }));
+}

package/dist/tui/screens/NodeScreen.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { getNode } from '../../api/client.js';
+import { Spinner } from '../components/Spinner.js';
+import { Breadcrumb } from '../components/Breadcrumb.js';
+import { Keybindings } from '../components/Keybindings.js';
+const BINDINGS = '[b] back  [/] command';
+export function NodeScreen({ nodeId, pop, registerActions }) {
+    const [node, setNode] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        setLoading(true);
+        setError(null);
+        getNode(nodeId)
+            .then((data) => setNode(data))
+            .catch((e) => setError(e.message))
+            .finally(() => setLoading(false));
+    }, [nodeId]);
+    useEffect(() => {
+        registerActions({
+            onBack: () => pop(),
+        });
+    }, [pop, registerActions]);
+    if (loading) {
+        return (_jsx(Box, { paddingX: 2, children: _jsx(Spinner, { label: "Loading node details..." }) }));
+    }
+    if (error) {
+        return (_jsxs(Box, { paddingX: 2, flexDirection: "column", children: [_jsxs(Text, { color: "red", children: ["\u2717 ", error] }), _jsx(Box, { marginTop: 1, children: _jsx(Keybindings, { bindings: BINDINGS }) })] }));
+    }
+    if (!node) {
+        return (_jsxs(Box, { paddingX: 2, flexDirection: "column", children: [_jsx(Text, { color: "red", children: "Node not found." }), _jsx(Box, { marginTop: 1, children: _jsx(Keybindings, { bindings: BINDINGS }) })] }));
+    }
+    const STATUS_COLORS = {
+        TODO: '#8b949e',
+        IN_PROGRESS: '#00bfff',
+        DONE: '#00c896',
+    };
+    const PRIORITY_COLORS = {
+        LOW: '#00c896',
+        MEDIUM: '#f7b955',
+        HIGH: '#f85149',
+    };
+    const statusColor = STATUS_COLORS[node.status] || '#8b949e';
+    const priorityColor = node.priority ? PRIORITY_COLORS[node.priority] : '#4A4F57';
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsx(Breadcrumb, { parts: ['Node Details'] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, paddingLeft: 1, children: [_jsx(Text, { bold: true, color: "#EDEFF3", wrap: "wrap", children: node.title }), _jsxs(Box, { marginTop: 1, flexDirection: "column", gap: 1, children: [_jsxs(Box, { gap: 4, children: [_jsx(Box, { width: 15, children: _jsx(Text, { color: "#7D828B", children: "Status:" }) }), _jsx(Text, { color: statusColor, children: node.status.replace('_', ' ') })] }), _jsxs(Box, { gap: 4, children: [_jsx(Box, { width: 15, children: _jsx(Text, { color: "#7D828B", children: "Priority:" }) }), _jsx(Text, { color: priorityColor, children: node.priority || 'None' })] }), (node.startAt || node.endAt) && (_jsxs(_Fragment, { children: [node.startAt && (_jsxs(Box, { gap: 4, children: [_jsx(Box, { width: 15, children: _jsx(Text, { color: "#7D828B", children: "Start Date:" }) }), _jsx(Text, { children: new Date(node.startAt).toLocaleString() })] })), node.endAt && (_jsxs(Box, { gap: 4, children: [_jsx(Box, { width: 15, children: _jsx(Text, { color: "#7D828B", children: "End Date:" }) }), _jsx(Text, { children: new Date(node.endAt).toLocaleString() })] }))] })), node.reminderAt && (_jsxs(Box, { gap: 4, children: [_jsx(Box, { width: 15, children: _jsx(Text, { color: "#7D828B", children: "Reminder:" }) }), _jsx(Text, { children: new Date(node.reminderAt).toLocaleString() })] })), node.tags && node.tags.length > 0 && (_jsxs(Box, { gap: 4, marginTop: 1, children: [_jsx(Box, { width: 15, children: _jsx(Text, { color: "#7D828B", children: "Tags:" }) }), _jsx(Box, { gap: 1, flexWrap: "wrap", children: node.tags.map((t) => (_jsxs(Text, { color: "#00bfff", children: ["#", t.tag.name] }, t.tag.id))) })] })), node.notes && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "#7D828B", children: "Notes:" }), _jsx(Box, { marginTop: 1, paddingX: 2, borderStyle: "single", borderColor: "#30363d", flexDirection: "column", children: _jsx(Text, { color: "#c9d1d9", wrap: "wrap", children: node.notes }) })] }))] })] }), _jsx(Box, { marginTop: 2, children: _jsx(Keybindings, { bindings: BINDINGS }) })] }));
+}

package/dist/tui/screens/TreeScreen.js

@@ -0,0 +1,182 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Tree screen - core screen
+import { useState, useEffect, useCallback } from 'react';
+import { Box, Text } from 'ink';
+import { useTree } from '../hooks/useTree.js';
+import { NodeRow } from '../components/NodeRow.js';
+import { Breadcrumb } from '../components/Breadcrumb.js';
+import { Keybindings } from '../components/Keybindings.js';
+import { Spinner } from '../components/Spinner.js';
+import { createRootNode, createChildNode, updateNode } from '../../api/client.js';
+const BINDINGS = '[↑↓] navigate  [→←] expand/collapse  [b] back  [/] command';
+/**
+ * Flatten the nested tree into a display list with depth, isLast, and parentLines
+ * metadata needed for rendering Figma-style connectors.
+ */
+function flattenForDisplay(roots, expandedIds, numberMap) {
+    const result = [];
+    function walk(children, depth, parentLines) {
+        const sorted = [...children].sort((a, b) => a.position - b.position);
+        sorted.forEach((node, index) => {
+            const isLast = index === sorted.length - 1;
+            const entry = {
+                node,
+                depth,
+                isLast,
+                parentLines: [...parentLines],
+            };
+            result.push(entry);
+            if (expandedIds.has(node.id) && (node.children ?? []).length > 0) {
+                // For children, pass whether this parent's level should draw a continuation line
+                const nextParentLines = [...parentLines, !isLast];
+                walk(node.children ?? [], depth + 1, nextParentLines);
+            }
+        });
+    }
+    walk(roots, 0, []);
+    return result;
+}
+export function TreeScreen({ push, pop, registerActions, listId, listName, folderName, onNodesLoaded, onSelectedNodeChanged, }) {
+    const { nodes, flatNodes, expandedIds, toggleExpand, numberMap, loading, error, refetch } = useTree(listId);
+    const [cursor, setCursor] = useState(0);
+    const [status, setStatus] = useState(null);
+    // Build display entries with tree metadata
+    const displayEntries = flattenForDisplay(nodes, expandedIds, numberMap);
+    // Bubble flat nodes up so CommandInput can resolve node refs for autocomplete
+    useEffect(() => {
+        if (onNodesLoaded)
+            onNodesLoaded(nodes);
+    }, [nodes, onNodesLoaded]);
+    // Report selected node to App
+    useEffect(() => {
+        const entry = displayEntries[cursor];
+        onSelectedNodeChanged?.(entry?.node.id);
+    }, [cursor, displayEntries, onSelectedNodeChanged]);
+    const handleCommand = useCallback(async (cmd) => {
+        const parts = cmd.trim().split(/\s+/);
+        // ── /add node <title> ────────────────────────────────────────────────
+        if (parts[0] === '/add' && parts[1] === 'node' && parts.length > 2) {
+            const title = parts.slice(2).join(' ');
+            setStatus('Adding node...');
+            createRootNode(listId, { title })
+                .then(() => {
+                setStatus(`✓ Added "${title}"`);
+                refetch();
+            })
+                .catch((e) => setStatus(`✗ ${e.message}`));
+            return;
+        }
+        // ── /add sub-node [index] <title> ────────────────────────────────────
+        if (parts[0] === '/add' && parts[1] === 'sub-node' && parts.length > 2) {
+            const afterCmd = parts.slice(2);
+            // Check if first arg looks like an index (e.g. "1", "1.2", "1.2.1")
+            const indexPattern = /^\d+(\.\d+)*$/;
+            let parentId = null;
+            let title;
+            if (indexPattern.test(afterCmd[0])) {
+                // /add sub-node <index> <title>
+                const idx = afterCmd[0];
+                title = afterCmd.slice(1).join(' ');
+                // Find node by its number
+                for (const [nodeId, num] of numberMap.entries()) {
+                    if (num === idx) {
+                        parentId = nodeId;
+                        break;
+                    }
+                }
+                if (!parentId) {
+                    setStatus(`✗ Node "${idx}" not found.`);
+                    return;
+                }
+                if (!title) {
+                    setStatus('✗ Please provide a title for the sub-node.');
+                    return;
+                }
+            }
+            else {
+                // /add sub-node <title> — use currently selected node
+                title = afterCmd.join(' ');
+                const entry = displayEntries[cursor];
+                if (!entry) {
+                    setStatus('✗ No node selected. Navigate to a node first.');
+                    return;
+                }
+                parentId = entry.node.id;
+            }
+            setStatus('Adding sub-node...');
+            createChildNode(parentId, { title })
+                .then(() => {
+                setStatus(`✓ Added sub-node "${title}"`);
+                refetch();
+            })
+                .catch((e) => setStatus(`✗ ${e.message}`));
+            return;
+        }
+        // ── /done <index> ────────────────────────────────────────────────────
+        if (parts[0] === '/done' && parts[1]) {
+            const arg = parts.slice(1).join(' ');
+            const node = flatNodes.find((n) => numberMap.get(n.id) === arg);
+            if (!node) {
+                setStatus(`✗ Node "${arg}" not found.`);
+                return;
+            }
+            setStatus('Marking done...');
+            updateNode(node.id, { status: 'DONE' })
+                .then(() => {
+                setStatus(`✓ Done: ${node.title}`);
+                refetch();
+            })
+                .catch((e) => setStatus(`✗ ${e.message}`));
+            return;
+        }
+        // ── /back ────────────────────────────────────────────────────────────
+        if (parts[0] === '/back') {
+            pop();
+        }
+    }, [flatNodes, displayEntries, cursor, numberMap, listId, refetch, pop]);
+    useEffect(() => {
+        const len = displayEntries.length;
+        registerActions({
+            onUp: () => setCursor((c) => Math.max(0, c - 1)),
+            onDown: () => setCursor((c) => Math.min(len - 1, c + 1)),
+            onRight: () => {
+                const entry = displayEntries[cursor];
+                if (entry)
+                    toggleExpand(entry.node.id);
+            },
+            onLeft: () => {
+                const entry = displayEntries[cursor];
+                if (entry)
+                    toggleExpand(entry.node.id);
+            },
+            onEnter: () => {
+                const entry = displayEntries[cursor];
+                if (entry) {
+                    push('node-details', { nodeId: entry.node.id });
+                }
+            },
+            onBack: () => pop(),
+            onCommand: handleCommand,
+            onRefetch: refetch,
+        });
+    }, [displayEntries, cursor, toggleExpand, pop, registerActions, handleCommand, refetch]);
+    const breadcrumbParts = [folderName, listName].filter(Boolean);
+    if (loading)
+        return (_jsx(Box, { paddingX: 2, children: _jsx(Spinner, { label: "Loading tree..." }) }));
+    if (error)
+        return (_jsx(Box, { paddingX: 2, children: _jsxs(Text, { color: "red", children: ["\u2717 ", error] }) }));
+    if (displayEntries.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [breadcrumbParts.length > 0 && _jsx(Breadcrumb, { parts: breadcrumbParts }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "#8b949e", dimColor: true, children: ["No tasks yet. Type", ' '] }), _jsxs(Text, { color: "#00bfff", children: ["/add node ", '<title>'] }), _jsxs(Text, { color: "#8b949e", dimColor: true, children: [' ', "to create one."] })] })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [breadcrumbParts.length > 0 && _jsx(Breadcrumb, { parts: breadcrumbParts }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: displayEntries.map((entry, i) => {
+                    const num = numberMap.get(entry.node.id) ?? '';
+                    // For root nodes: check if this is the last root-level entry
+                    let isLastRoot = false;
+                    if (entry.depth === 0) {
+                        // Look for the next root node after this one
+                        const nextRootIdx = displayEntries.findIndex((e, j) => j > i && e.depth === 0);
+                        isLastRoot = nextRootIdx === -1;
+                    }
+                    return (_jsx(NodeRow, { node: entry.node, number: num, depth: entry.depth, isSelected: i === cursor, isLast: entry.isLast, isLastRoot: isLastRoot, parentLines: entry.parentLines }, entry.node.id));
+                }) }), status && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: status }) })), _jsx(Box, { marginTop: 1, children: _jsx(Keybindings, { bindings: BINDINGS }) })] }));
+}

package/dist/tui/screens/WelcomeScreen.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState, useRef } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { Spinner } from '@inkjs/ui';
+import chalk from 'chalk';
+import { getToken } from '../../utils/auth.js';
+import { getMe } from '../../api/client.js';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const { version } = require('../../../package.json');
+const LOGO_LINE_1 = '█▀▀ ▀█▀ █▀█ ▄▀█ ▀█▀ ▄▀█   █▄ █ █▀█ █▀▄ █▀▀ ▀▄▀';
+const LOGO_LINE_2 = '▄██  █  █▀▄ █▀█  █  █▀█   █ ▀█ █▄█ █▄▀ ██▄ █ █';
+export function WelcomeScreen({ replaceScreen, height, width }) {
+    const [status, setStatus] = useState('checking');
+    const done = useRef(false);
+    const transition = (loggedIn) => {
+        if (done.current)
+            return;
+        done.current = true;
+        replaceScreen(loggedIn ? 'dashboard' : 'login');
+    };
+    useInput(() => {
+        if (done.current)
+            return;
+        transition(!!getToken());
+    });
+    useEffect(() => {
+        const guestMode = process.env['STRATANODEX_GUEST'] === 'true';
+        if (guestMode) {
+            transition(true);
+            return;
+        }
+        const token = getToken();
+        if (!token) {
+            // No token at all — go to login
+            const t = setTimeout(() => transition(false), 1200);
+            return () => clearTimeout(t);
+        }
+        // Token exists — validate with the backend.
+        // Retry on network/timeout errors (cold start), only go to login on 401.
+        let cancelled = false;
+        const MAX_RETRIES = 3;
+        const RETRY_DELAY = 5000;
+        async function validateToken(attempt) {
+            if (cancelled)
+                return;
+            try {
+                await getMe();
+                if (cancelled)
+                    return;
+                setStatus('done');
+                setTimeout(() => transition(true), 600);
+            }
+            catch (err) {
+                if (cancelled)
+                    return;
+                const statusCode = err?.response?.status;
+                if (statusCode === 401) {
+                    // Token is genuinely invalid/expired — go to login
+                    setStatus('error');
+                    setTimeout(() => transition(false), 1000);
+                    return;
+                }
+                // Network error / timeout (cold start) — retry
+                if (attempt < MAX_RETRIES) {
+                    setStatus('checking');
+                    setTimeout(() => validateToken(attempt + 1), RETRY_DELAY);
+                }
+                else {
+                    // All retries exhausted but token still exists — go home anyway
+                    // and let the API interceptor handle 401s later
+                    setStatus('done');
+                    setTimeout(() => transition(true), 600);
+                }
+            }
+        }
+        validateToken(1);
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", height: height, width: width, children: [_jsx(Text, { children: chalk.hex('#003355')(LOGO_LINE_1) }), _jsx(Text, { children: chalk.hex('#004477')(LOGO_LINE_1) }), _jsx(Text, { children: chalk.hex('#00bfff').bold(LOGO_LINE_1) }), _jsx(Text, { children: chalk.hex('#00bfff').bold(LOGO_LINE_2) }), _jsx(Text, { children: chalk.hex('#004477')(LOGO_LINE_2) }), _jsx(Text, { children: chalk.hex('#003355')(LOGO_LINE_2) }), _jsx(Text, { children: " " }), _jsx(Text, { children: chalk.hex('#007799')(`CLI  ${version}`) }), _jsx(Text, { children: " " }), _jsx(Text, { children: " " }), status === 'checking' && (_jsx(Spinner, { label: chalk.hex('#004477')('  checking connection...') })), status === 'error' && (_jsx(Text, { children: chalk.hex('#440000')('connection failed · redirecting to login') }))] }));
+}

package/dist/tui/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/auth.js

@@ -0,0 +1,11 @@
+import Conf from 'conf';
+const store = new Conf({ projectName: 'stratanodex' });
+export function saveToken(token) {
+    store.set('token', token);
+}
+export function getToken() {
+    return store.get('token');
+}
+export function clearToken() {
+    store.delete('token');
+}

package/dist/utils/logger.js

@@ -0,0 +1,32 @@
+import path from 'path';
+import fs from 'fs';
+import Conf from 'conf';
+import { getConfig } from '../config.js';
+const confInstance = new Conf({ projectName: 'stratanodex' });
+const confDir = path.dirname(confInstance.path);
+const logFilePath = path.join(confDir, 'log.txt');
+fs.mkdirSync(confDir, { recursive: true });
+if (fs.existsSync(logFilePath)) {
+    const stats = fs.statSync(logFilePath);
+    if (stats.size > 10 * 1024 * 1024) {
+        fs.renameSync(logFilePath, path.join(confDir, 'log.old.txt'));
+    }
+}
+function writeLog(level, msg, data) {
+    const entry = JSON.stringify({
+        time: new Date().toISOString(),
+        level,
+        msg,
+        ...(data ?? {}),
+    });
+    fs.appendFileSync(logFilePath, entry + '\n');
+    if (getConfig().verbose) {
+        process.stderr.write(entry + '\n');
+    }
+}
+export const logger = {
+    info: (msg, data) => writeLog('info', msg, data),
+    error: (msg, data) => writeLog('error', msg, data),
+    debug: (msg, data) => writeLog('debug', msg, data),
+    warn: (msg, data) => writeLog('warn', msg, data),
+};

package/dist/utils/numbering.js

@@ -0,0 +1,38 @@
+/**
+ * Given a nested tree of nodes (root nodes with children[] embedded),
+ * returns a Map from nodeId → hierarchical number string e.g. "1.2.1".
+ * Numbers are never stored — computed at render time only.
+ */
+export function assignNumbers(nodes) {
+    const map = new Map();
+    function traverse(children, prefix) {
+        const sorted = [...children].sort((a, b) => a.position - b.position);
+        sorted.forEach((node, index) => {
+            const number = prefix ? `${prefix}.${index + 1}` : `${index + 1}`;
+            map.set(node.id, number);
+            if ((node.children ?? []).length > 0) {
+                traverse(node.children, number);
+            }
+        });
+    }
+    traverse(nodes, '');
+    return map;
+}
+/**
+ * DFS flatten — takes nested node tree, returns flat array in DFS order.
+ * Useful for resolving a display number like "1.2.1" to a node ID.
+ */
+export function flattenTree(nodes) {
+    const result = [];
+    function dfs(children) {
+        const sorted = [...children].sort((a, b) => a.position - b.position);
+        for (const node of sorted) {
+            result.push(node);
+            if ((node.children ?? []).length > 0) {
+                dfs(node.children);
+            }
+        }
+    }
+    dfs(nodes);
+    return result;
+}

package/dist/utils/recents.js

@@ -0,0 +1,24 @@
+// recents.ts — Persisted recent folders/lists store for the CLI.
+// Stores the last 10 opened folders & lists in a JSON file alongside the auth token.
+import Conf from 'conf';
+const MAX_RECENTS = 10;
+const store = new Conf({
+    projectName: 'stratanodex-cli',
+    defaults: { items: [] },
+});
+/** Record a folder/list being opened. Pushes to front and deduplicates. */
+export function recordRecent(entry) {
+    const key = `${entry.type}:${entry.id}`;
+    const existing = store.get('items', []);
+    const filtered = existing.filter((e) => `${e.type}:${e.id}` !== key);
+    const next = [{ ...entry, openedAt: Date.now() }, ...filtered].slice(0, MAX_RECENTS);
+    store.set('items', next);
+}
+/** Get the list of recent entries, most recent first. */
+export function getRecents() {
+    return store.get('items', []);
+}
+/** Clear all recents. */
+export function clearRecents() {
+    store.set('items', []);
+}

package/dist/utils/scoring.js

@@ -0,0 +1,29 @@
+/**
+ * Calculate daily points based on task completion.
+ * Must match backend scoring logic exactly.
+ *
+ * Buckets:
+ *   total === 0        → 0  (no tasks scheduled, no penalty)
+ *   done/total >= 0.90 → +3
+ *   done/total >= 0.60 → +2
+ *   done/total >= 0.30 → +1
+ *   done/total >  0.00 → 0
+ *   done === 0         → -1
+ */
+export function calculatePoints(done, total) {
+    done = Math.max(0, done);
+    total = Math.max(0, total);
+    if (total === 0)
+        return 0;
+    done = Math.min(done, total);
+    const ratio = done / total;
+    if (ratio >= 0.9)
+        return 3;
+    if (ratio >= 0.6)
+        return 2;
+    if (ratio >= 0.3)
+        return 1;
+    if (done > 0)
+        return 0;
+    return -1;
+}