@lumoai/cli 1.0.0

package/dist/cli/src/lib/resolve.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUuid = isUuid;
+exports.slugify = slugify;
+exports.resolveProjectId = resolveProjectId;
+exports.resolveTeamId = resolveTeamId;
+exports.resolveSprintId = resolveSprintId;
+exports.resolveMilestoneId = resolveMilestoneId;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUuid(value) {
+    return UUID_RE.test(value);
+}
+/**
+ * Mirror of `lib/utils/slugify` (server). Single source of truth for CLI
+ * slugification — must match the server byte-for-byte so a slug printed by
+ * `lumo project list` resolves correctly when passed as `--project <slug>`.
+ */
+function slugify(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+async function fetchJson(base, token, path) {
+    let res;
+    try {
+        res = await fetch(`${base}${path}`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Could not reach Lumo API at ${base} (${msg})`);
+    }
+    if (res.status === 401) {
+        throw new Error('API key invalid or revoked. Run `lumo auth login`.');
+    }
+    if (!res.ok) {
+        throw new Error(`Request failed (HTTP ${res.status}): ${path}`);
+    }
+    return (await res.json());
+}
+/**
+ * Resolve `--project <ref>` to a project id.
+ * - `ref` undefined and workspace has 1 visible project → auto-select
+ * - `ref` undefined and workspace has >1 visible project → throw
+ * - `ref` set → match by name or slug, case-insensitive
+ */
+async function resolveProjectId(base, token, ref) {
+    const { projects } = await fetchJson(base, token, '/api/projects');
+    const visible = projects.filter(p => !p.isIdea);
+    if (!ref) {
+        if (visible.length === 0)
+            throw new Error('workspace has no projects yet.');
+        if (visible.length === 1)
+            return visible[0].id;
+        throw new Error('workspace has multiple projects; pass --project <slug>.');
+    }
+    const needle = ref.trim().toLowerCase();
+    const match = visible.find(p => p.name.toLowerCase() === needle || slugify(p.name) === needle);
+    if (!match) {
+        throw new Error(`project "${ref}" not found. Try \`lumo project list\`.`);
+    }
+    return match.id;
+}
+/**
+ * Resolve `--team <ref>` to a team id + name.
+ * - `ref` undefined and workspace has 1 visible team → auto-select
+ * - `ref` undefined and workspace has >1 visible team → throw
+ * - `ref` is a UUID → return as-is (no fetch)
+ * - `ref` set → match by name or identifier (slug), case-insensitive
+ */
+async function resolveTeamId(base, token, ref) {
+    if (ref !== undefined && isUuid(ref)) {
+        return { id: ref, name: '' };
+    }
+    const { teams } = await fetchJson(base, token, '/api/teams');
+    if (!ref) {
+        if (teams.length === 0)
+            throw new Error('workspace has no teams yet.');
+        if (teams.length === 1)
+            return { id: teams[0].id, name: teams[0].name };
+        throw new Error('workspace has multiple teams; pass --team <slug>.');
+    }
+    const needle = ref.trim().toLowerCase();
+    const match = teams.find(t => t.name.toLowerCase() === needle ||
+        t.identifier.toLowerCase() === needle);
+    if (!match) {
+        throw new Error(`team "${ref}" not found. Try \`lumo team list\`.`);
+    }
+    return { id: match.id, name: match.name };
+}
+/**
+ * Resolve a sprint `<identifier>`:
+ * - If it's a UUID, return { id, number: 0, name: '', teamId: '' } — caller
+ *   fetches /api/sprints/<id> for full data.
+ * - If it's a positive integer, look up via /api/sprints/by-number scoped
+ *   to the caller's workspace.
+ *
+ * The /by-number endpoint hardcodes the product assumption that a workspace
+ * has at most one sprints-enabled team. If that constraint is ever lifted,
+ * this function will need a `--team` disambiguation step.
+ *
+ * `teamRef` is used to soften the disambiguation hint when --team was already
+ * attempted; today the endpoint still disambiguates via workspace_url only.
+ */
+async function resolveSprintId(base, token, identifier, teamRef, workspaceSlug) {
+    if (isUuid(identifier)) {
+        return { id: identifier, number: 0, name: '', teamId: '' };
+    }
+    const n = Number(identifier);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new Error(`sprint "${identifier}" must be a positive integer or a UUID.`);
+    }
+    const path = `/api/sprints/by-number?workspaceUrl=${encodeURIComponent(workspaceSlug)}&number=${n}`;
+    let res;
+    try {
+        res = await fetch(`${base}${path}`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Could not reach Lumo API at ${base} (${msg})`);
+    }
+    if (res.status === 404) {
+        // teamRef is currently informational only — surface the hint regardless,
+        // but soften the wording when --team was already attempted.
+        const hint = teamRef
+            ? 'Verify the sprint exists for the chosen --team, or pass the UUID.'
+            : 'If your workspace has multiple sprints-enabled teams, pass --team <name> or use the sprint UUID.';
+        throw new Error(`sprint #${n} not found in this workspace. ${hint}`);
+    }
+    if (res.status === 401) {
+        throw new Error('API key invalid or revoked. Run `lumo auth login`.');
+    }
+    if (!res.ok) {
+        throw new Error(`sprint lookup failed (HTTP ${res.status})`);
+    }
+    const body = (await res.json());
+    return {
+        id: body.sprint.id,
+        number: body.sprint.number,
+        name: body.sprint.name,
+        teamId: body.sprint.teamId,
+    };
+}
+/**
+ * Resolve a milestone `<identifier>`:
+ * - If it's a UUID, return as-is (project not fetched).
+ * - Otherwise, resolve the project (via `--project <ref>` or auto-select),
+ *   list its milestones, and match by name case-insensitively.
+ */
+async function resolveMilestoneId(base, token, identifier, projectRef) {
+    if (isUuid(identifier)) {
+        // Caller will fetch /api/milestones/<id> to learn the projectId & name.
+        return { id: identifier, name: '', projectId: '' };
+    }
+    const projectId = await resolveProjectId(base, token, projectRef);
+    const { milestones } = await fetchJson(base, token, `/api/projects/${projectId}/milestones`);
+    const needle = identifier.trim().toLowerCase();
+    const match = milestones.find(m => m.name.toLowerCase() === needle);
+    if (!match) {
+        throw new Error(`no milestone matches "${identifier}" in this project. Try \`lumo milestone list\`.`);
+    }
+    return { id: match.id, name: match.name, projectId };
+}

package/dist/cli/src/lib/tag-resolver.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTagRefs = resolveTagRefs;
+const api_1 = require("./api");
+async function resolveTagRefs(refs, deps) {
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    // Trim + reject empty
+    const trimmed = [];
+    for (const raw of refs.names) {
+        const t = raw.trim();
+        if (t.length === 0) {
+            throw new Error('tag names must not be empty');
+        }
+        trimmed.push(t);
+    }
+    // Dedupe case-insensitively, preserve first-seen casing
+    const seen = new Set();
+    const unique = [];
+    for (const t of trimmed) {
+        const key = t.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(t);
+    }
+    let nameIds = [];
+    if (unique.length > 0) {
+        const url = `${(0, api_1.trimTrailingSlash)(deps.apiUrl)}/api/tags/resolve`;
+        const res = await fetchImpl(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${deps.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ names: unique }),
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`tag resolve failed: ${res.status} ${res.statusText}: ${body}`);
+        }
+        const json = (await res.json());
+        nameIds = json.tags.map(t => t.id);
+    }
+    // Merge with explicit ids, dedupe
+    const out = new Set(nameIds);
+    for (const id of refs.ids)
+        out.add(id);
+    return [...out];
+}

package/dist/shared/src/index.js

@@ -0,0 +1,35 @@
+"use strict";
+// ── Agent Error types ────────────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tiptapToMarkdown = exports.markdownToTiptap = exports.AgentError = void 0;
+exports.userFriendlyError = userFriendlyError;
+class AgentError extends Error {
+    code;
+    cause;
+    constructor(code, message, cause) {
+        super(message);
+        this.code = code;
+        this.cause = cause;
+        this.name = 'AgentError';
+    }
+}
+exports.AgentError = AgentError;
+const USER_MESSAGES = {
+    SANDBOX_CREATE_FAILED: 'Could not start the execution environment. Please try again.',
+    CLONE_FAILED: 'Could not access the repository. Check your GitHub connection.',
+    AGENT_EXECUTION_FAILED: 'Agent encountered an error while writing code.',
+    PUSH_FAILED: 'Could not push to GitHub. Check repository permissions.',
+    PR_CREATE_FAILED: 'Code was written but PR creation failed. Check GitHub.',
+    TIMEOUT: 'Agent timed out after 10 minutes. The task may be too complex — try breaking it down.',
+    CLARIFY_TIMEOUT: 'Agent was waiting for clarification for 24 hours and has been stopped. Add more details to the spec and retry.',
+    SANDBOX_KILLED: 'The execution environment was shut down unexpectedly. This usually means the task took too long. Try breaking it into smaller steps.',
+    CONFIG_ERROR: 'Server configuration error. Please contact your administrator.',
+    UNKNOWN_ERROR: 'Something went wrong. Please try again.',
+};
+function userFriendlyError(code) {
+    return USER_MESSAGES[code] ?? USER_MESSAGES.UNKNOWN_ERROR;
+}
+// ── Markdown ↔ Tiptap converter ───────────────────────────────────────────────
+var markdown_tiptap_1 = require("./markdown-tiptap");
+Object.defineProperty(exports, "markdownToTiptap", { enumerable: true, get: function () { return markdown_tiptap_1.markdownToTiptap; } });
+Object.defineProperty(exports, "tiptapToMarkdown", { enumerable: true, get: function () { return markdown_tiptap_1.tiptapToMarkdown; } });

package/dist/shared/src/markdown-tiptap.js

@@ -0,0 +1,267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markdownToHtml = markdownToHtml;
+exports.markdownToTiptap = markdownToTiptap;
+exports.tiptapToMarkdown = tiptapToMarkdown;
+const markdown_it_1 = __importDefault(require("markdown-it"));
+const md = new markdown_it_1.default({ html: false, linkify: true, breaks: false });
+/**
+ * Render a markdown string to HTML.
+ *
+ * Shares the markdown-it instance with `markdownToTiptap` so the doc CLI
+ * pipeline (markdown → HTML for the Tiptap editor) and the agent pipeline
+ * (markdown → tiptap JSON) parse identically. Used by the documents API
+ * when a CLI caller posts `contentMarkdown`: the editor consumes the
+ * resulting HTML directly via `setContent` / `getHTML`.
+ */
+function markdownToHtml(input) {
+    if (!input)
+        return '';
+    return md.render(input);
+}
+/**
+ * Parse a markdown string into a Tiptap JSON doc node.
+ * Supports paragraphs, headings (h1-h6), bullet/ordered lists, fenced
+ * code blocks, blockquotes, and inline marks (bold, italic, code, link).
+ * Unsupported nodes degrade to plain text inside a paragraph.
+ */
+function markdownToTiptap(input) {
+    if (!input) {
+        return { type: 'doc', content: [] };
+    }
+    const tokens = md.parse(input, {});
+    const content = blocksFromTokens(tokens);
+    return { type: 'doc', content };
+}
+function blocksFromTokens(tokens) {
+    const out = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        switch (t.type) {
+            case 'paragraph_open': {
+                const end = findMatch(tokens, i, 'paragraph_close');
+                const inline = tokens[i + 1];
+                out.push({
+                    type: 'paragraph',
+                    content: inline ? inlineFromToken(inline) : [],
+                });
+                i = end;
+                break;
+            }
+            case 'heading_open': {
+                const level = parseInt(t.tag.replace('h', ''), 10);
+                const end = findMatch(tokens, i, 'heading_close');
+                const inline = tokens[i + 1];
+                out.push({
+                    type: 'heading',
+                    attrs: { level },
+                    content: inline ? inlineFromToken(inline) : [],
+                });
+                i = end;
+                break;
+            }
+            case 'bullet_list_open':
+            case 'ordered_list_open': {
+                const isOrdered = t.type === 'ordered_list_open';
+                const closeType = isOrdered ? 'ordered_list_close' : 'bullet_list_close';
+                const end = findMatch(tokens, i, closeType);
+                const slice = tokens.slice(i + 1, end);
+                out.push({
+                    type: isOrdered ? 'orderedList' : 'bulletList',
+                    content: listItemsFromTokens(slice),
+                });
+                i = end;
+                break;
+            }
+            case 'fence': {
+                out.push({
+                    type: 'codeBlock',
+                    attrs: { language: t.info || null },
+                    content: t.content ? [{ type: 'text', text: t.content }] : [],
+                });
+                break;
+            }
+            case 'blockquote_open': {
+                const end = findMatch(tokens, i, 'blockquote_close');
+                const slice = tokens.slice(i + 1, end);
+                out.push({ type: 'blockquote', content: blocksFromTokens(slice) });
+                i = end;
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return out;
+}
+function listItemsFromTokens(tokens) {
+    const items = [];
+    for (let i = 0; i < tokens.length; i++) {
+        if (tokens[i]?.type === 'list_item_open') {
+            const end = findMatch(tokens, i, 'list_item_close');
+            const inner = tokens.slice(i + 1, end);
+            items.push({ type: 'listItem', content: blocksFromTokens(inner) });
+            i = end;
+        }
+    }
+    return items;
+}
+function inlineFromToken(t) {
+    if (!t.children) {
+        return t.content ? [{ type: 'text', text: t.content }] : [];
+    }
+    const out = [];
+    const markStack = [];
+    for (const child of t.children) {
+        switch (child.type) {
+            case 'text':
+                if (child.content) {
+                    out.push(makeText(child.content, markStack));
+                }
+                break;
+            case 'softbreak':
+            case 'hardbreak':
+                out.push(makeText('\n', markStack));
+                break;
+            case 'code_inline':
+                out.push(makeText(child.content, [...markStack, { type: 'code' }]));
+                break;
+            case 'strong_open':
+                markStack.push({ type: 'bold' });
+                break;
+            case 'strong_close':
+                markStack.pop();
+                break;
+            case 'em_open':
+                markStack.push({ type: 'italic' });
+                break;
+            case 'em_close':
+                markStack.pop();
+                break;
+            case 'link_open': {
+                // markdown-it Token may expose attrGet or a raw attrs array
+                let href = '';
+                if (typeof child.attrGet === 'function') {
+                    href = child.attrGet('href') ?? '';
+                }
+                else {
+                    href = child.attrs?.find(a => a[0] === 'href')?.[1] ?? '';
+                }
+                markStack.push({ type: 'link', attrs: { href } });
+                break;
+            }
+            case 'link_close':
+                markStack.pop();
+                break;
+            default:
+                if (child.content) {
+                    out.push(makeText(child.content, markStack));
+                }
+        }
+    }
+    return out;
+}
+function makeText(text, marks) {
+    const node = { type: 'text', text };
+    if (marks.length > 0)
+        node.marks = marks.map(cloneMark);
+    return node;
+}
+function cloneMark(m) {
+    if (m.type === 'link')
+        return { type: 'link', attrs: { ...m.attrs } };
+    return { type: m.type };
+}
+function findMatch(tokens, start, closeType) {
+    const startLevel = tokens[start]?.level ?? 0;
+    for (let i = start + 1; i < tokens.length; i++) {
+        if (tokens[i]?.type === closeType && tokens[i]?.level === startLevel) {
+            return i;
+        }
+    }
+    return tokens.length - 1;
+}
+/**
+ * Render a Tiptap JSON doc node back to markdown text.
+ * Best-effort: paragraphs, headings, lists, code blocks, mention nodes.
+ * Returns '' for null/non-object input.
+ */
+function tiptapToMarkdown(doc) {
+    if (!doc || typeof doc !== 'object')
+        return '';
+    const node = doc;
+    if (!Array.isArray(node.content))
+        return '';
+    const lines = node.content.map(renderBlock).filter(Boolean);
+    return lines.join('\n');
+}
+function renderBlock(block) {
+    switch (block.type) {
+        case 'paragraph':
+            return renderInlines(block.content ?? []) + '\n';
+        case 'heading': {
+            const level = block.attrs?.level ?? 1;
+            return '#'.repeat(level) + ' ' + renderInlines(block.content ?? []) + '\n';
+        }
+        case 'bulletList':
+            return ((block.content ?? [])
+                .map(item => '- ' + renderListItem(item))
+                .join('\n') + '\n');
+        case 'orderedList':
+            return ((block.content ?? [])
+                .map((item, idx) => `${idx + 1}. ` + renderListItem(item))
+                .join('\n') + '\n');
+        case 'codeBlock': {
+            const lang = block.attrs?.language ?? '';
+            const body = (block.content ?? []).map(c => c.text ?? '').join('');
+            return '```' + lang + '\n' + body + '```\n';
+        }
+        case 'blockquote':
+            return ((block.content ?? [])
+                .map(b => '> ' + renderBlock(b))
+                .join('')
+                .trimEnd() + '\n');
+        default:
+            return '';
+    }
+}
+function renderListItem(item) {
+    const blocks = item.content ?? [];
+    return blocks.map(b => renderInlines(b.content ?? [])).join(' ');
+}
+function renderInlines(nodes) {
+    return nodes.map(renderInline).join('');
+}
+function renderInline(node) {
+    if (node.type === 'mention') {
+        const ident = node.attrs?.identifier ?? '';
+        return ident ? `@${ident}` : '';
+    }
+    if (node.type !== 'text')
+        return '';
+    let text = node.text ?? '';
+    if (!node.marks)
+        return text;
+    for (const mark of node.marks) {
+        switch (mark.type) {
+            case 'bold':
+                text = `**${text}**`;
+                break;
+            case 'italic':
+                text = `*${text}*`;
+                break;
+            case 'code':
+                text = `\`${text}\``;
+                break;
+            case 'link': {
+                const href = mark.attrs?.href ?? '';
+                text = `[${text}](${href})`;
+                break;
+            }
+        }
+    }
+    return text;
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@lumoai/cli",
+  "version": "1.0.0",
+  "description": "Lumo CLI — manage tasks and sessions from the terminal",
+  "license": "MIT",
+  "author": "cli@uselumo.ai",
+  "homepage": "https://github.com/Lumo-Workspace/lumo/tree/main/cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lumo-Workspace/lumo.git",
+    "directory": "cli"
+  },
+  "bugs": {
+    "url": "https://github.com/Lumo-Workspace/lumo/issues"
+  },
+  "keywords": [
+    "lumo",
+    "cli",
+    "task-management",
+    "project-management",
+    "claude-code"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "lumo": "./dist/cli/src/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && chmod +x dist/cli/src/index.js",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "dependencies": {
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25",
+    "typescript": "^5"
+  }
+}