@lumoai/cli 1.0.0

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

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSameTeam = assertSameTeam;
+exports.normalizePriority = normalizePriority;
+exports.formatCreatedTaskLine = formatCreatedTaskLine;
+exports.taskCreate = taskCreate;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const tag_resolver_1 = require("../lib/tag-resolver");
+const resolve_1 = require("../lib/resolve");
+const ALLOWED_PRIORITIES = ['LOW', 'MEDIUM', 'HIGH', 'URGENT'];
+/**
+ * Assert that the sprint belongs to the same team as the newly created task.
+ * Throws with a human-readable message on mismatch (caller console.errors it).
+ */
+function assertSameTeam(task, sprint) {
+    if (task.teamId !== sprint.teamId) {
+        throw new Error(`Sprint binding skipped: sprint #${sprint.number} belongs to team "${sprint.teamId}", task belongs to "${task.teamId}"`);
+    }
+}
+/**
+ * Bind a newly created task to a sprint.
+ * - Resolves the sprint ref (number or UUID).
+ * - If resolveSprintId returned the UUID placeholder (teamId === ''), does a
+ *   follow-up GET /api/sprints/<id> to fill in { teamId, number, name }.
+ * - Asserts same-team, then POSTs to /api/sprints/<sprintId>/tasks.
+ * Returns the sprint info on success, or throws on failure.
+ */
+async function bindTaskToSprint(base, token, workspaceSlug, sprintRef, task) {
+    let sprint = await (0, resolve_1.resolveSprintId)(base, token, sprintRef, undefined, workspaceSlug);
+    // UUID path: resolveSprintId returns a placeholder with teamId === ''
+    if (sprint.teamId === '') {
+        const sprintRes = await fetch(`${base}/api/sprints/${sprint.id}`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!sprintRes.ok) {
+            throw new Error(`sprint lookup failed (HTTP ${sprintRes.status})`);
+        }
+        const { sprint: full } = (await sprintRes.json());
+        sprint = { id: full.id, number: full.number, name: full.name, teamId: full.teamId };
+    }
+    assertSameTeam(task, sprint);
+    const bindRes = await fetch(`${base}/api/sprints/${sprint.id}/tasks`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ taskId: task.id }),
+    });
+    if (!bindRes.ok) {
+        let errMsg = `sprint bind failed (HTTP ${bindRes.status})`;
+        try {
+            const errBody = (await bindRes.json());
+            if (errBody.error)
+                errMsg = errBody.error;
+        }
+        catch {
+            // ignore
+        }
+        throw new Error(errMsg);
+    }
+    return sprint;
+}
+/**
+ * Uppercase + validate a priority string. Returns null on unknown values so
+ * the caller can print a context-aware error.
+ */
+function normalizePriority(value) {
+    if (!value)
+        return null;
+    const upper = value.toUpperCase();
+    return ALLOWED_PRIORITIES.includes(upper)
+        ? upper
+        : null;
+}
+/**
+ * Format the single-line success output. Title is double-quoted; embedded
+ * double-quotes are backslash-escaped so the output stays parseable as one
+ * shell-safe token group. An optional Tags line is appended when tags are
+ * present.
+ */
+function formatCreatedTaskLine(task) {
+    const escapedTitle = task.title.replace(/"/g, '\\"');
+    const head = `Created ${task.identifier} "${escapedTitle}"  ${task.url}`;
+    if (task.tags && task.tags.length > 0) {
+        return `${head}\nTags: ${task.tags.join(', ')}`;
+    }
+    return head;
+}
+async function taskCreate(title, opts) {
+    if (!title || title.trim().length === 0) {
+        console.error('Error: missing <title>. Usage: lumo task create <title> [options]');
+        return 1;
+    }
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    // Priority: default LOW, validate if provided
+    let priority = 'LOW';
+    if (opts.priority !== undefined) {
+        const normalized = normalizePriority(opts.priority);
+        if (!normalized) {
+            console.error(`Error: invalid priority "${opts.priority}". Allowed: low, medium, high, urgent`);
+            return 1;
+        }
+        priority = normalized;
+    }
+    const envUrl = process.env.LUMO_API_URL?.trim();
+    const apiUrl = envUrl && envUrl.length > 0 ? envUrl : creds.apiUrl;
+    const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    const url = `${base}/api/tasks`;
+    let tagIds;
+    if ((opts.tag && opts.tag.length > 0) ||
+        (opts.tagId && opts.tagId.length > 0)) {
+        try {
+            tagIds = await (0, tag_resolver_1.resolveTagRefs)({ names: opts.tag ?? [], ids: opts.tagId ?? [] }, { apiUrl, token: creds.token });
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            return 1;
+        }
+    }
+    const body = {
+        title: title.trim(),
+        priority,
+    };
+    if (opts.description !== undefined)
+        body.description = opts.description;
+    if (opts.project !== undefined)
+        body.projectRef = opts.project;
+    if (opts.assignee !== undefined)
+        body.assigneeRef = opts.assignee;
+    if (opts.milestone !== undefined)
+        body.milestoneRef = opts.milestone;
+    if (tagIds && tagIds.length > 0)
+        body.tagIds = tagIds;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${creds.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+    }
+    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 === 201) {
+        const data = (await res.json());
+        const responseTagNames = (data.task.taskTags ?? []).map(t => t.name);
+        process.stdout.write(formatCreatedTaskLine({ ...data.task, tags: responseTagNames }) + '\n');
+        // Sprint binding (optional): if --sprint was passed, bind the new task.
+        if (opts.sprint) {
+            const workspaceSlug = creds.workspaceSlug ?? '';
+            try {
+                const sprint = await bindTaskToSprint(base, creds.token, workspaceSlug, opts.sprint, { id: data.task.id, teamId: data.task.teamId, identifier: data.task.identifier });
+                process.stdout.write(`Sprint: #${sprint.number} "${sprint.name}"\n`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                // Spec's literal mismatch output — print bare, no "Error:" prefix
+                if (msg.startsWith('Sprint binding skipped:')) {
+                    console.error(msg);
+                }
+                else {
+                    console.error(`Error: ${msg}`);
+                }
+                return 1;
+            }
+        }
+        return;
+    }
+    // Surface server error message when present, otherwise the status
+    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 create failed (HTTP ${res.status})`);
+    }
+    return 1;
+}

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTaskListTable = void 0;
+exports.resolveTaskListEndpoint = resolveTaskListEndpoint;
+exports.taskList = taskList;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const format_1 = require("../lib/format");
+const resolve_1 = require("../lib/resolve");
+var format_2 = require("../lib/format");
+Object.defineProperty(exports, "formatTaskListTable", { enumerable: true, get: function () { return format_2.formatTaskListTable; } });
+const ALLOWED_STATUSES = ['TODO', 'IN_PROGRESS', 'IN_REVIEW', 'DONE'];
+function resolveTaskListEndpoint(base, milestoneId) {
+    if (!milestoneId)
+        return `${base}/api/tasks/me`;
+    return `${base}/api/milestones/${milestoneId}/tasks?assigned=me`;
+}
+function normalizeStatusFilter(value) {
+    if (!value)
+        return null;
+    const upper = value.toUpperCase().replace(/-/g, '_');
+    return ALLOWED_STATUSES.includes(upper)
+        ? upper
+        : null;
+}
+async function taskList(opts) {
+    let statusFilter;
+    if (opts.status !== undefined) {
+        const n = normalizeStatusFilter(opts.status);
+        if (!n) {
+            console.error(`Error: invalid status "${opts.status}". Allowed: todo, in_progress, in_review, done`);
+            return 1;
+        }
+        statusFilter = n;
+    }
+    const limit = opts.limit !== undefined ? parseInt(opts.limit, 10) : undefined;
+    if (limit !== undefined && (Number.isNaN(limit) || limit < 1)) {
+        console.error(`Error: invalid --limit "${opts.limit}" (expected a positive integer)`);
+        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;
+    const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    let milestoneId;
+    if (opts.milestone !== undefined) {
+        try {
+            const resolved = await (0, resolve_1.resolveMilestoneId)(base, creds.token, opts.milestone, opts.project);
+            milestoneId = resolved.id;
+        }
+        catch (err) {
+            console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+            return 1;
+        }
+    }
+    const url = resolveTaskListEndpoint(base, milestoneId);
+    let res;
+    try {
+        res = await fetch(url, {
+            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 (res.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (!res.ok) {
+        console.error(`Error: task list failed (HTTP ${res.status})`);
+        return 1;
+    }
+    const data = (await res.json());
+    // Server returns the full assigned-to-me set. Filters are client-side
+    // because /api/tasks/me doesn't accept status/project query params yet
+    // — when it does, switch to query params and drop this filter block.
+    let tasks = data.tasks;
+    if (statusFilter)
+        tasks = tasks.filter(t => t.status === statusFilter);
+    if (opts.project) {
+        const ref = opts.project.toLowerCase();
+        tasks = tasks.filter(t => t.project.name.toLowerCase() === ref);
+    }
+    if (limit !== undefined)
+        tasks = tasks.slice(0, limit);
+    process.stdout.write((0, format_1.formatTaskListTable)(tasks) + '\n');
+}

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTaskShow = formatTaskShow;
+exports.taskShow = taskShow;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+/**
+ * Render task detail as a key:value block. Multi-line description is
+ * indented under a `Description:` label so the structure stays scannable.
+ */
+function formatTaskShow(task) {
+    const lines = [];
+    lines.push(`${task.identifier}  ${task.title}`);
+    lines.push(`Status:    ${task.status}`);
+    lines.push(`Priority:  ${task.priority}`);
+    lines.push(`Project:   ${task.project.name}`);
+    if (task.assignee) {
+        const detail = task.assignee.email && task.assignee.type === 'member'
+            ? `${task.assignee.label} <${task.assignee.email}>`
+            : task.assignee.label;
+        lines.push(`Assignee:  ${detail}`);
+    }
+    else {
+        lines.push('Assignee:  (unassigned)');
+    }
+    lines.push(`URL:       ${task.url}`);
+    if (task.description && task.description.trim().length > 0) {
+        lines.push('');
+        lines.push('Description:');
+        for (const line of task.description.split('\n')) {
+            lines.push(`  ${line}`);
+        }
+    }
+    return lines.join('\n');
+}
+async function taskShow(identifier) {
+    if (!identifier) {
+        console.error('Error: missing <identifier>. Usage: lumo task show <LUM-42>');
+        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;
+    const url = `${(0, api_1.trimTrailingSlash)(apiUrl)}/api/tasks/by-identifier/${encodeURIComponent(identifier)}`;
+    let res;
+    try {
+        res = await fetch(url, {
+            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 (res.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (res.status === 404) {
+        console.error(`Error: task ${identifier} not found in workspace ${creds.workspaceSlug}`);
+        return 1;
+    }
+    if (!res.ok) {
+        console.error(`Error: task show failed (HTTP ${res.status})`);
+        return 1;
+    }
+    const data = (await res.json());
+    process.stdout.write(formatTaskShow(data.task) + '\n');
+}