@lumoai/cli 1.0.0

package/dist/cli/src/commands/sprint-summary.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSprintSummary = formatSprintSummary;
+exports.sprintSummary = sprintSummary;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const resolve_1 = require("../lib/resolve");
+function formatSprintSummary(input) {
+    const { number, name, stats, tldr, report } = input;
+    const lines = [`Sprint: #${number} ${name}`];
+    if (stats === null && tldr === null && report === null) {
+        lines.push('', '(no summary generated yet)');
+        return lines.join('\n');
+    }
+    if (stats !== null) {
+        lines.push(`Done:   ${stats.done} / ${stats.total}`);
+    }
+    if (tldr) {
+        lines.push('', tldr);
+    }
+    if (report) {
+        lines.push('', report);
+    }
+    return lines.join('\n');
+}
+async function sprintSummary(identifier, opts) {
+    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);
+    const workspaceSlug = creds.workspaceSlug ?? '';
+    let resolved;
+    try {
+        resolved = await (0, resolve_1.resolveSprintId)(base, creds.token, identifier, opts.team, workspaceSlug);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    // Fill in number/name if identifier was a UUID (same pattern as sprint-start.ts).
+    let displayNumber = resolved.number;
+    let displayName = resolved.name;
+    if (!displayName) {
+        const r = await fetch(`${base}/api/sprints/${resolved.id}`, {
+            headers: { Authorization: `Bearer ${creds.token}` },
+        });
+        if (r.ok) {
+            const { sprint } = (await r.json());
+            displayNumber = sprint.number;
+            displayName = sprint.name;
+        }
+    }
+    // Optional retry: POST to /summary/retry first. Expect 202 (queued).
+    if (opts.retry) {
+        let retryRes;
+        try {
+            retryRes = await fetch(`${base}/api/sprints/${resolved.id}/summary/retry`, {
+                method: 'POST',
+                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 (retryRes.status === 401) {
+            console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+            return 1;
+        }
+        if (!retryRes.ok && retryRes.status !== 202) {
+            let errMsg = `summary retry failed (HTTP ${retryRes.status})`;
+            try {
+                const errBody = (await retryRes.json());
+                if (errBody.error)
+                    errMsg = errBody.error;
+            }
+            catch {
+                // ignore
+            }
+            console.error(`Error: ${errMsg}`);
+            return 1;
+        }
+        // 202 means queued; regeneration is async. The GET below may still return
+        // the old summary or 404 — warn the user.
+        console.error('Note: summary regeneration queued. Result below may still be the previous summary.');
+    }
+    // GET /api/sprints/<id>/summary — returns SprintSummary row directly or 404.
+    let summaryRes;
+    try {
+        summaryRes = await fetch(`${base}/api/sprints/${resolved.id}/summary`, {
+            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 (summaryRes.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    let stats = null;
+    let tldr = null;
+    let report = null;
+    if (summaryRes.ok) {
+        const body = (await summaryRes.json());
+        stats = body.stats ?? null;
+        tldr = body.tldr ?? null;
+        report = body.report ?? null;
+    }
+    else if (summaryRes.status !== 404) {
+        let errMsg = `sprint summary failed (HTTP ${summaryRes.status})`;
+        try {
+            const errBody = (await summaryRes.json());
+            if (errBody.error)
+                errMsg = errBody.error;
+        }
+        catch {
+            // ignore
+        }
+        console.error(`Error: ${errMsg}`);
+        return 1;
+    }
+    // 404 → fall through with all-null; formatSprintSummary renders the friendly marker.
+    process.stdout.write(formatSprintSummary({
+        number: displayNumber,
+        name: displayName,
+        stats,
+        tldr,
+        report,
+    }) + '\n');
+}

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

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSprintUpdatePayload = buildSprintUpdatePayload;
+exports.formatSprintUpdateSummary = formatSprintUpdateSummary;
+exports.sprintUpdate = sprintUpdate;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const resolve_1 = require("../lib/resolve");
+function buildSprintUpdatePayload(opts) {
+    const payload = {};
+    const flagsGiven = [];
+    if (opts.name !== undefined) {
+        payload.name = opts.name;
+        flagsGiven.push('--name');
+    }
+    if (opts.start !== undefined) {
+        payload.startDate = opts.start;
+        flagsGiven.push('--start');
+    }
+    if (opts.end !== undefined) {
+        payload.endDate = opts.end;
+        flagsGiven.push('--end');
+    }
+    return { payload, flagsGiven };
+}
+function fmtDate(v) {
+    if (!v)
+        return '-';
+    return v.slice(0, 10);
+}
+function formatSprintUpdateSummary(before, after) {
+    const changes = [];
+    if (after.name !== undefined && after.name !== before.name) {
+        changes.push(`name "${before.name}" → "${after.name}"`);
+    }
+    if (after.startDate !== undefined) {
+        changes.push(`start → ${fmtDate(after.startDate)}`);
+    }
+    if (after.endDate !== undefined) {
+        changes.push(`end → ${fmtDate(after.endDate)}`);
+    }
+    return `Updated sprint #${before.number} "${before.name}": ${changes.join(', ')}`;
+}
+async function sprintUpdate(identifier, opts) {
+    // Reject empty strings — these fields can't be cleared.
+    if (opts.name !== undefined && opts.name === '') {
+        console.error('Error: --name cannot be empty.');
+        return 1;
+    }
+    if (opts.start !== undefined && opts.start === '') {
+        console.error('Error: --start cannot be empty.');
+        return 1;
+    }
+    if (opts.end !== undefined && opts.end === '') {
+        console.error('Error: --end cannot be empty.');
+        return 1;
+    }
+    const { payload, flagsGiven } = buildSprintUpdatePayload(opts);
+    if (flagsGiven.length === 0) {
+        console.error('Error: provide at least one field to update (--name, --start, --end)');
+        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 sprintId;
+    let resolvedNumber;
+    let resolvedName;
+    try {
+        const resolved = await (0, resolve_1.resolveSprintId)(base, creds.token, identifier, opts.team, creds.workspaceSlug);
+        sprintId = resolved.id;
+        resolvedNumber = resolved.number;
+        resolvedName = resolved.name;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    // Fetch current values to populate the before-snapshot for the summary.
+    // When resolveSprintId short-circuited on UUID, number/name are empty — we
+    // always GET to get a consistent snapshot regardless of identifier form.
+    let beforeRes;
+    try {
+        beforeRes = await fetch(`${base}/api/sprints/${sprintId}`, {
+            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 (beforeRes.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (!beforeRes.ok) {
+        console.error(`Error: sprint fetch failed (HTTP ${beforeRes.status})`);
+        return 1;
+    }
+    const { sprint: before } = (await beforeRes.json());
+    // Use resolved values if available (number-based lookup already returned them).
+    const beforeSnapshot = {
+        number: before.number || resolvedNumber,
+        name: before.name || resolvedName,
+        ...(before.startDate !== undefined && { startDate: before.startDate }),
+        ...(before.endDate !== undefined && { endDate: before.endDate }),
+    };
+    let res;
+    try {
+        res = await fetch(`${base}/api/sprints/${sprintId}`, {
+            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.ok) {
+        let errMsg = `sprint update failed (HTTP ${res.status})`;
+        try {
+            const errBody = (await res.json());
+            if (errBody.error)
+                errMsg = errBody.error;
+        }
+        catch {
+            // body wasn't JSON; keep the status-only message
+        }
+        console.error(`Error: ${errMsg}`);
+        return 1;
+    }
+    process.stdout.write(formatSprintUpdateSummary(beforeSnapshot, payload) + '\n');
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskComment = taskComment;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+/**
+ * `lumo task comment <LUM-N> <body>`
+ *
+ * Two HTTP calls: resolve LUM-N → task DB id, then POST the comment to
+ * `/api/tasks/:id/comments`. The comments endpoint accepts both Clerk and
+ * bearer auth (dual-auth) — see lib/auth/identity.ts.
+ *
+ * Body is taken verbatim as the comment text. Multi-line bodies work via
+ * shell quoting. We do not support markdown @-mention chip syntax from the
+ * CLI; plain text only.
+ */
+async function taskComment(identifier, body) {
+    if (!identifier) {
+        console.error('Error: missing <identifier>. Usage: lumo task comment <LUM-42> "comment body"');
+        return 1;
+    }
+    if (!body || body.trim().length === 0) {
+        console.error('Error: missing <body>. Usage: lumo task comment <LUM-42> "comment body"');
+        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);
+    // 1. Resolve LUM-N → DB id (the comments endpoint takes DB id).
+    let resolveRes;
+    try {
+        resolveRes = await fetch(`${base}/api/tasks/resolve/${encodeURIComponent(identifier)}`, { 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 (resolveRes.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (resolveRes.status === 404) {
+        console.error(`Error: task ${identifier} not found in workspace ${creds.workspaceSlug}`);
+        return 1;
+    }
+    if (!resolveRes.ok) {
+        console.error(`Error: resolve failed (HTTP ${resolveRes.status})`);
+        return 1;
+    }
+    const resolved = (await resolveRes.json());
+    // 2. POST the comment.
+    let postRes;
+    try {
+        postRes = await fetch(`${base}/api/tasks/${encodeURIComponent(resolved.id)}/comments`, {
+            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 (postRes.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (postRes.status !== 201) {
+        let serverMsg = null;
+        try {
+            const errBody = (await postRes.json());
+            if (typeof errBody.error === 'string')
+                serverMsg = errBody.error;
+        }
+        catch {
+            // Body wasn't JSON
+        }
+        console.error(serverMsg
+            ? `Error: ${serverMsg}`
+            : `Error: comment create failed (HTTP ${postRes.status})`);
+        return 1;
+    }
+    const data = (await postRes.json());
+    process.stdout.write(`Commented on ${resolved.identifier}  (comment ${data.comment.id})\n`);
+}

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskContext = taskContext;
+exports.formatTaskContextMarkdown = formatTaskContextMarkdown;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+async function taskContext(identifier) {
+    if (!identifier) {
+        console.error('Error: missing <identifier>. Usage: lumo task context <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/context/${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: context fetch failed (HTTP ${res.status})`);
+        return 1;
+    }
+    const data = (await res.json());
+    const now = new Date();
+    process.stdout.write(formatTaskContextMarkdown(data, now));
+}
+/**
+ * Render a TaskContextResponse as the agent-facing markdown handoff. Pure
+ * function; the `now` parameter makes "X ago" phrasing deterministic in
+ * tests.
+ */
+function formatTaskContextMarkdown(data, now) {
+    const lines = [];
+    lines.push(`# Task: ${data.task.identifier}`);
+    lines.push(`**Title**: ${data.task.title}`);
+    lines.push(`**Status**: ${data.task.status}`);
+    if (data.task.milestone) {
+        const target = data.task.milestone.targetDate
+            ? `, target ${data.task.milestone.targetDate.slice(0, 10)}`
+            : '';
+        lines.push(`**Milestone**: ${data.task.milestone.name} (${data.task.milestone.status}${target})`);
+    }
+    if (data.task.description && data.task.description.trim().length > 0) {
+        lines.push(`**Description**: ${data.task.description}`);
+    }
+    lines.push('');
+    // Frontload memory before sessions: it's cold context the agent should see
+    // first. Server returns "" when empty, in which case we skip the section.
+    if (data.memorySection && data.memorySection.trim().length > 0) {
+        lines.push(data.memorySection.trimEnd());
+        lines.push('');
+    }
+    if (data.slackContextSection && data.slackContextSection.trim().length > 0) {
+        lines.push(data.slackContextSection.trimEnd());
+        lines.push('');
+    }
+    if (data.webLinkSection && data.webLinkSection.trim().length > 0) {
+        lines.push(data.webLinkSection.trimEnd());
+        lines.push('');
+    }
+    if (data.sessions.length === 0) {
+        lines.push('## Previous Sessions (0)');
+        lines.push('');
+        lines.push('_No prior coding sessions for this task._');
+        lines.push('');
+        return lines.join('\n');
+    }
+    lines.push(`## Previous Sessions (${data.sessions.length})`);
+    lines.push('');
+    for (const s of data.sessions) {
+        const shortId = s.id.slice(0, 8);
+        const ago = relativeTime(new Date(s.lastActivityAt), now);
+        const dur = formatDuration(s.durationMs);
+        lines.push(`### Session ${shortId} · ${ago} · ${dur}`);
+        lines.push(`**Summary**: ${s.headline}`);
+        if (s.unresolved.length > 0) {
+            lines.push('**Unresolved**:');
+            for (const u of s.unresolved)
+                lines.push(`- ${u}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function formatDuration(ms) {
+    if (ms < 60_000) {
+        return `${Math.max(1, Math.round(ms / 1000))}s`;
+    }
+    const totalMinutes = Math.round(ms / 60_000);
+    if (totalMinutes < 60)
+        return `${totalMinutes}min`;
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    return minutes === 0 ? `${hours}h` : `${hours}h ${minutes}min`;
+}
+function relativeTime(then, now) {
+    const diffMs = now.getTime() - then.getTime();
+    const seconds = Math.floor(diffMs / 1000);
+    if (seconds < 60)
+        return 'just now';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}min ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days === 1)
+        return 'yesterday';
+    if (days < 7)
+        return `${days} days ago`;
+    const weeks = Math.floor(days / 7);
+    if (weeks < 5)
+        return `${weeks}w ago`;
+    const months = Math.floor(days / 30);
+    return `${months}mo ago`;
+}