@lumoai/cli 1.0.0

package/dist/cli/src/commands/task-update.js

@@ -0,0 +1,468 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideSprintAction = decideSprintAction;
+exports.normalizeStatus = normalizeStatus;
+exports.buildUpdatePayload = buildUpdatePayload;
+exports.formatUpdatedTaskLine = formatUpdatedTaskLine;
+exports.taskUpdate = taskUpdate;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const task_create_1 = require("./task-create");
+const tag_resolver_1 = require("../lib/tag-resolver");
+const resolve_1 = require("../lib/resolve");
+const ALLOWED_STATUSES = ['TODO', 'IN_PROGRESS', 'IN_REVIEW', 'DONE'];
+/**
+ * Pure function: given the task's current sprint binding and the resolved
+ * sprint id from the --sprint flag ('' to clear), decide what action to take.
+ *
+ * `flag` is the **resolved** sprint id (or '' to clear). It is NOT the raw
+ * CLI flag value — the caller must resolve the sprint ref before calling this.
+ */
+function decideSprintAction(input) {
+    const { currentSprintId, flag } = input;
+    if (flag === '') {
+        // Clear intent
+        if (currentSprintId === null)
+            return { type: 'noop-clear' };
+        return { type: 'unbind', oldSprintId: currentSprintId };
+    }
+    // Bind intent (non-empty resolved sprint id)
+    if (currentSprintId === null)
+        return { type: 'bind', newSprintId: flag };
+    if (currentSprintId === flag)
+        return { type: 'noop-same', sprintId: flag };
+    return { type: 'rebind', oldSprintId: currentSprintId, newSprintId: flag };
+}
+/**
+ * Normalize a user-supplied status value. Accepts both `IN_PROGRESS` and
+ * `in-progress` forms; returns null on unknown values so the caller can
+ * print a context-aware error.
+ */
+function normalizeStatus(value) {
+    if (!value)
+        return null;
+    const upper = value.toUpperCase().replace(/-/g, '_');
+    return ALLOWED_STATUSES.includes(upper)
+        ? upper
+        : null;
+}
+/**
+ * Translate parsed CLI flags into the wire payload for
+ * `PATCH /api/tasks/by-identifier/[identifier]`. Empty-string description /
+ * assignee become `null` (clear). Caller is responsible for normalizing
+ * status / priority before passing them in.
+ */
+function buildUpdatePayload(opts) {
+    const payload = {};
+    const flagsGiven = [];
+    if (opts.title !== undefined) {
+        payload.title = opts.title;
+        flagsGiven.push('--title');
+    }
+    if (opts.description !== undefined) {
+        payload.description = opts.description === '' ? null : opts.description;
+        flagsGiven.push('--description');
+    }
+    if (opts.status !== undefined) {
+        payload.status = opts.status;
+        flagsGiven.push('--status');
+    }
+    if (opts.priority !== undefined) {
+        payload.priority = opts.priority;
+        flagsGiven.push('--priority');
+    }
+    if (opts.assignee !== undefined) {
+        payload.assigneeRef = opts.assignee === '' ? null : opts.assignee;
+        flagsGiven.push('--assignee');
+    }
+    if (opts.milestone !== undefined) {
+        payload.milestoneRef = opts.milestone === '' ? null : opts.milestone;
+        flagsGiven.push('--milestone');
+    }
+    return { payload, flagsGiven };
+}
+/**
+ * Single-line success output. Mirrors `formatCreatedTaskLine` for grep-
+ * ability — embedded double-quotes are backslash-escaped.
+ * Appends a Tags line when tags are present.
+ */
+function formatUpdatedTaskLine(task) {
+    const escapedTitle = task.title.replace(/"/g, '\\"');
+    const head = `Updated ${task.identifier} "${escapedTitle}"  ${task.url}`;
+    if (task.tags && task.tags.length > 0) {
+        return `${head}\nTags: ${task.tags.join(', ')}`;
+    }
+    return head;
+}
+async function taskUpdate(identifier, opts) {
+    if (!identifier || identifier.trim().length === 0) {
+        console.error('Error: missing <identifier>. Usage: lumo task update <LUM-42> [options]');
+        return 1;
+    }
+    // CLI-side mutex check: --tag/--tag-id (bulk replace) vs --add-tag/--add-tag-id/--remove-tag/--remove-tag-id (incremental)
+    // Must run BEFORE any network call.
+    const hasBulk = (opts.tag && opts.tag.length > 0) || (opts.tagId && opts.tagId.length > 0);
+    const hasIncremental = (opts.addTag && opts.addTag.length > 0) ||
+        (opts.addTagId && opts.addTagId.length > 0) ||
+        (opts.removeTag && opts.removeTag.length > 0) ||
+        (opts.removeTagId && opts.removeTagId.length > 0);
+    if (hasBulk && hasIncremental) {
+        console.error('Error: --tag/--tag-id are mutually exclusive with --add-tag/--add-tag-id/--remove-tag/--remove-tag-id');
+        return 1;
+    }
+    // Normalize status / priority before payload build.
+    let status;
+    if (opts.status !== undefined) {
+        const n = normalizeStatus(opts.status);
+        if (!n) {
+            console.error(`Error: invalid status "${opts.status}". Allowed: todo, in_progress, in_review, done`);
+            return 1;
+        }
+        status = n;
+    }
+    let priority;
+    if (opts.priority !== undefined) {
+        const n = (0, task_create_1.normalizePriority)(opts.priority);
+        if (!n) {
+            console.error(`Error: invalid priority "${opts.priority}". Allowed: low, medium, high, urgent`);
+            return 1;
+        }
+        priority = n;
+    }
+    const { payload, flagsGiven } = buildUpdatePayload({
+        ...opts,
+        ...(status !== undefined ? { status } : {}),
+        ...(priority !== undefined ? { priority } : {}),
+    });
+    // Tag fields count as "something to update" even when no other flags given
+    const hasTagFields = hasBulk || hasIncremental;
+    const hasSprintFlag = opts.sprint !== undefined;
+    if (flagsGiven.length === 0 && !hasTagFields && !hasSprintFlag) {
+        console.error('Error: provide at least one field to update (--title, --description, --status, --priority, --assignee, --milestone, --sprint, --tag, --add-tag, --remove-tag)');
+        return 1;
+    }
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const envUrl = process.env.LUMO_API_URL?.trim();
+    const apiUrl = envUrl && envUrl.length > 0 ? envUrl : creds.apiUrl;
+    // Resolve tag refs into ids
+    let tagIds;
+    let addTagIds;
+    let removeTagIds;
+    const deps = { apiUrl, token: creds.token };
+    try {
+        if (hasBulk) {
+            tagIds = await (0, tag_resolver_1.resolveTagRefs)({ names: opts.tag ?? [], ids: opts.tagId ?? [] }, deps);
+        }
+        else if (hasIncremental) {
+            if ((opts.addTag && opts.addTag.length > 0) ||
+                (opts.addTagId && opts.addTagId.length > 0)) {
+                addTagIds = await (0, tag_resolver_1.resolveTagRefs)({ names: opts.addTag ?? [], ids: opts.addTagId ?? [] }, deps);
+            }
+            if ((opts.removeTag && opts.removeTag.length > 0) ||
+                (opts.removeTagId && opts.removeTagId.length > 0)) {
+                // NOTE: --remove-tag <unknown-name> creates the Tag via find-or-create, then
+                // the detach is a no-op. Net effect: orphan Tag row. Acceptable v1 trade-off.
+                removeTagIds = await (0, tag_resolver_1.resolveTagRefs)({ names: opts.removeTag ?? [], ids: opts.removeTagId ?? [] }, deps);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        return 1;
+    }
+    if (tagIds !== undefined)
+        payload.tagIds = tagIds;
+    if (addTagIds !== undefined)
+        payload.addTagIds = addTagIds;
+    if (removeTagIds !== undefined)
+        payload.removeTagIds = removeTagIds;
+    const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    // Only do the PATCH when there are actual task fields to update.
+    // If --sprint is the only flag given, skip the PATCH entirely.
+    const hasPatchFields = flagsGiven.length > 0 || hasTagFields;
+    if (hasPatchFields) {
+        const patchUrl = `${base}/api/tasks/by-identifier/${encodeURIComponent(identifier)}`;
+        let res;
+        try {
+            res = await fetch(patchUrl, {
+                method: 'PATCH',
+                headers: {
+                    Authorization: `Bearer ${creds.token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+            return 1;
+        }
+        if (res.status === 401) {
+            console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+            return 1;
+        }
+        if (res.status === 200) {
+            const data = (await res.json());
+            // Read tag names off the response (present when tags were changed)
+            const responseTagNames = tagIds !== undefined ||
+                addTagIds !== undefined ||
+                removeTagIds !== undefined
+                ? (data.task.taskTags ?? []).map(t => t.name)
+                : undefined;
+            const taskLine = {
+                id: data.task.id,
+                identifier: data.task.identifier,
+                title: data.task.title,
+                url: data.task.url,
+            };
+            if (responseTagNames !== undefined)
+                taskLine.tags = responseTagNames;
+            process.stdout.write(formatUpdatedTaskLine(taskLine) + '\n');
+        }
+        else {
+            let serverMsg = null;
+            try {
+                const errBody = (await res.json());
+                if (typeof errBody.error === 'string')
+                    serverMsg = errBody.error;
+            }
+            catch {
+                // Body wasn't JSON; fall through to status-only message
+            }
+            if (serverMsg) {
+                console.error(`Error: ${serverMsg}`);
+            }
+            else {
+                console.error(`Error: task update failed (HTTP ${res.status})`);
+            }
+            return 1;
+        }
+    }
+    // Sprint flag handling — runs after successful PATCH (or as standalone op)
+    if (hasSprintFlag) {
+        // GET /api/tasks/by-identifier/<id> to learn currentSprintId and teamId
+        const showUrl = `${base}/api/tasks/by-identifier/${encodeURIComponent(identifier)}`;
+        let showRes;
+        try {
+            showRes = await fetch(showUrl, {
+                headers: { Authorization: `Bearer ${creds.token}` },
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+            return 1;
+        }
+        if (showRes.status === 401) {
+            console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+            return 1;
+        }
+        if (!showRes.ok) {
+            console.error(`Error: task lookup failed (HTTP ${showRes.status})`);
+            return 1;
+        }
+        const showData = (await showRes.json());
+        const task = showData.task;
+        // Resolve new sprint id ('' → clear, non-empty → resolve ref).
+        // Also store the sprint number/name once resolved so we don't need extra
+        // GETs for output formatting on bind/rebind/noop-same.
+        let resolvedSprintId = '';
+        let resolvedSprintNumber = null;
+        if (opts.sprint !== '') {
+            const workspaceSlug = creds.workspaceSlug ?? '';
+            let sprint;
+            try {
+                sprint = await (0, resolve_1.resolveSprintId)(base, creds.token, opts.sprint, undefined, workspaceSlug);
+            }
+            catch (err) {
+                console.error(`Error: ${err.message}`);
+                return 1;
+            }
+            // UUID path: resolveSprintId returns placeholder with teamId === ''
+            if (sprint.teamId === '') {
+                let sprintRes;
+                try {
+                    sprintRes = await fetch(`${base}/api/sprints/${sprint.id}`, {
+                        headers: { Authorization: `Bearer ${creds.token}` },
+                    });
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+                    return 1;
+                }
+                if (!sprintRes.ok) {
+                    console.error(`Error: sprint lookup failed (HTTP ${sprintRes.status})`);
+                    return 1;
+                }
+                const { sprint: full } = (await sprintRes.json());
+                sprint = {
+                    id: full.id,
+                    number: full.number,
+                    name: full.name,
+                    teamId: full.teamId,
+                };
+            }
+            // Cross-team check
+            if (sprint.teamId !== task.teamId) {
+                console.error(`Error: Sprint binding skipped: sprint #${sprint.number} belongs to a different team than task ${task.identifier}`);
+                return 1;
+            }
+            resolvedSprintId = sprint.id;
+            resolvedSprintNumber = sprint.number;
+        }
+        const action = decideSprintAction({
+            currentSprintId: task.sprintId,
+            flag: resolvedSprintId,
+        });
+        if (action.type === 'noop-clear') {
+            process.stdout.write(`Task ${task.identifier} has no sprint binding\n`);
+            return;
+        }
+        if (action.type === 'noop-same') {
+            // resolvedSprintNumber is always set when we reach this branch
+            const label = resolvedSprintNumber !== null
+                ? `#${resolvedSprintNumber}`
+                : action.sprintId;
+            process.stdout.write(`Task ${task.identifier} already in sprint ${label}\n`);
+            return;
+        }
+        if (action.type === 'unbind') {
+            // Fetch the old sprint number for display (we only know the id here)
+            let oldNumber = null;
+            try {
+                const sprintRes = await fetch(`${base}/api/sprints/${action.oldSprintId}`, { headers: { Authorization: `Bearer ${creds.token}` } });
+                if (sprintRes.ok) {
+                    const body = (await sprintRes.json());
+                    oldNumber = body.sprint.number;
+                }
+            }
+            catch {
+                // non-critical — we'll fall back to '-'
+            }
+            let deleteRes;
+            try {
+                deleteRes = await fetch(`${base}/api/sprints/${action.oldSprintId}/tasks/${task.id}`, {
+                    method: 'DELETE',
+                    headers: { Authorization: `Bearer ${creds.token}` },
+                });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+                return 1;
+            }
+            if (!deleteRes.ok) {
+                let errMsg = `sprint unbind failed (HTTP ${deleteRes.status})`;
+                try {
+                    const b = (await deleteRes.json());
+                    if (b.error)
+                        errMsg = b.error;
+                }
+                catch { /* ignore */ }
+                console.error(`Error: ${errMsg}`);
+                return 1;
+            }
+            const oldLabel = oldNumber !== null ? `#${oldNumber}` : action.oldSprintId;
+            process.stdout.write(`Unbound ${task.identifier} from sprint ${oldLabel}\n`);
+            return;
+        }
+        if (action.type === 'bind') {
+            let postRes;
+            try {
+                postRes = await fetch(`${base}/api/sprints/${action.newSprintId}/tasks`, {
+                    method: 'POST',
+                    headers: {
+                        Authorization: `Bearer ${creds.token}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ taskId: task.id }),
+                });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+                return 1;
+            }
+            if (!postRes.ok) {
+                let errMsg = `sprint bind failed (HTTP ${postRes.status})`;
+                try {
+                    const b = (await postRes.json());
+                    if (b.error)
+                        errMsg = b.error;
+                }
+                catch { /* ignore */ }
+                console.error(`Error: ${errMsg}`);
+                return 1;
+            }
+            // resolvedSprintNumber is set from the resolveSprintId call above
+            const newLabel = resolvedSprintNumber !== null ? `#${resolvedSprintNumber}` : action.newSprintId;
+            process.stdout.write(`Sprint: - → ${newLabel}\n`);
+            return;
+        }
+        if (action.type === 'rebind') {
+            // Fetch old sprint number for display (only know id from currentSprintId)
+            let oldNumber = null;
+            try {
+                const oldSprintRes = await fetch(`${base}/api/sprints/${action.oldSprintId}`, { headers: { Authorization: `Bearer ${creds.token}` } });
+                if (oldSprintRes.ok) {
+                    const b = (await oldSprintRes.json());
+                    oldNumber = b.sprint.number;
+                }
+            }
+            catch {
+                // non-critical
+            }
+            // Step 1: DELETE old sprint binding
+            let deleteRes;
+            try {
+                deleteRes = await fetch(`${base}/api/sprints/${action.oldSprintId}/tasks/${task.id}`, {
+                    method: 'DELETE',
+                    headers: { Authorization: `Bearer ${creds.token}` },
+                });
+            }
+            catch {
+                console.error(`Task may be in inconsistent sprint state, re-run or check Web UI`);
+                return 1;
+            }
+            if (!deleteRes.ok) {
+                console.error(`Task may be in inconsistent sprint state, re-run or check Web UI`);
+                return 1;
+            }
+            // Step 2: POST new sprint binding
+            let postRes;
+            try {
+                postRes = await fetch(`${base}/api/sprints/${action.newSprintId}/tasks`, {
+                    method: 'POST',
+                    headers: {
+                        Authorization: `Bearer ${creds.token}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ taskId: task.id }),
+                });
+            }
+            catch {
+                console.error(`Task may be in inconsistent sprint state, re-run or check Web UI`);
+                return 1;
+            }
+            if (!postRes.ok) {
+                console.error(`Task may be in inconsistent sprint state, re-run or check Web UI`);
+                return 1;
+            }
+            const oldLabel = oldNumber !== null ? `#${oldNumber}` : '-';
+            // resolvedSprintNumber is set from the resolveSprintId call above
+            const newLabel = resolvedSprintNumber !== null ? `#${resolvedSprintNumber}` : action.newSprintId;
+            process.stdout.write(`Sprint: ${oldLabel} → ${newLabel}\n`);
+            return;
+        }
+    }
+    // If only --sprint was given (no PATCH fields), we've already returned above.
+    // But if --sprint wasn't given and PATCH succeeded, we returned inside the
+    // PATCH success block. This path is unreachable in normal operation.
+    return;
+}

package/dist/cli/src/commands/whoami.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whoami = whoami;
+const config_1 = require("../lib/config");
+async function whoami() {
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.log('Not logged in');
+        console.log('Run `lumo auth login` to log in');
+        return 1;
+    }
+    console.log(`Logged in as ${creds.email}`);
+    console.log(`  Workspace: ${creds.workspaceName} (${creds.workspaceSlug})`);
+    console.log(`  Key: ${creds.apiKeyName} (${creds.apiKeyPrefix})`);
+    console.log(`  API: ${creds.apiUrl}`);
+}