@lumoai/cli 1.0.0 → 1.2.0

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

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setup = setup;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const hooks_template_1 = require("../lib/hooks-template");
+const line_prompt_1 = require("../lib/line-prompt");
+async function setup(options) {
+    if (options.user && options.project) {
+        process.stderr.write('Error: --user and --project are mutually exclusive.\n');
+        return 1;
+    }
+    const scope = await resolveScope(options);
+    if (!scope)
+        return 130;
+    const root = scope === 'user' ? os.homedir() : process.cwd();
+    const claudeDir = path.join(root, '.claude');
+    process.stdout.write(`\nInstalling Lumo for ${scope} scope: ${claudeDir}\n\n`);
+    installSkill(claudeDir, options.force === true);
+    mergeSettings(claudeDir);
+    printPostInstall();
+    return 0;
+}
+async function resolveScope(options) {
+    if (options.user)
+        return 'user';
+    if (options.project)
+        return 'project';
+    if (!process.stdin.isTTY) {
+        process.stdout.write('No --user/--project flag given and stdin is not a TTY. Defaulting to --project.\n');
+        return 'project';
+    }
+    const answer = (await (0, line_prompt_1.promptLine)('Install Lumo for [u]ser (~/.claude) or [p]roject (./.claude)? [u/P]: ')).toLowerCase();
+    if (answer === 'u' || answer === 'user')
+        return 'user';
+    if (answer === '' || answer === 'p' || answer === 'project')
+        return 'project';
+    process.stderr.write(`Unrecognized choice "${answer}". Aborting.\n`);
+    return null;
+}
+function installSkill(claudeDir, force) {
+    const skillDir = path.join(claudeDir, 'skills', 'lumo');
+    const skillDst = path.join(skillDir, 'SKILL.md');
+    // Asset bundled in cli/assets/skill.md, shipped via package.json "files".
+    // From dist/cli/src/commands/setup.js → ../../../../assets/skill.md
+    const skillSrc = path.resolve(__dirname, '../../../..', 'assets', 'skill.md');
+    if (!fs.existsSync(skillSrc)) {
+        throw new Error(`Bundled skill asset missing at ${skillSrc} — reinstall @lumoai/cli.`);
+    }
+    fs.mkdirSync(skillDir, { recursive: true });
+    if (fs.existsSync(skillDst) && !force) {
+        const srcStat = fs.statSync(skillSrc);
+        const dstStat = fs.statSync(skillDst);
+        if (srcStat.size === dstStat.size) {
+            const a = fs.readFileSync(skillSrc, 'utf8');
+            const b = fs.readFileSync(skillDst, 'utf8');
+            if (a === b) {
+                process.stdout.write(`✓ skill already up to date: ${skillDst}\n`);
+                return;
+            }
+        }
+        process.stdout.write(`⚠ ${skillDst} exists and differs from the bundled version.\n` +
+            `  Re-run with --force to overwrite.\n`);
+        return;
+    }
+    fs.copyFileSync(skillSrc, skillDst);
+    process.stdout.write(`✓ wrote skill: ${skillDst}\n`);
+}
+function mergeSettings(claudeDir) {
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    let existing = {};
+    if (fs.existsSync(settingsPath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`Cannot parse existing ${settingsPath}: ${msg}. Fix the JSON and re-run.`);
+        }
+    }
+    else {
+        fs.mkdirSync(claudeDir, { recursive: true });
+    }
+    const { merged, stats } = (0, hooks_template_1.mergeLumoHooks)(existing);
+    fs.writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + '\n');
+    if (stats.addedEvents.length === 0) {
+        process.stdout.write(`✓ hooks already wired in: ${settingsPath} (${stats.alreadyPresent.length} events)\n`);
+    }
+    else {
+        process.stdout.write(`✓ merged hooks into ${settingsPath} (added ${stats.addedEvents.length}, kept ${stats.alreadyPresent.length})\n`);
+    }
+}
+function printPostInstall() {
+    const onPath = isLumoOnPath();
+    const credsPath = path.join(process.env.LUMO_CONFIG_DIR || path.join(os.homedir(), '.lumo'), 'credentials.json');
+    const authed = fs.existsSync(credsPath);
+    process.stdout.write('\nNext steps:\n');
+    if (!onPath || isRunningUnderNpx()) {
+        process.stdout.write('  • Install the CLI globally so Claude Code hooks can find it:\n' +
+            '      npm install -g @lumoai/cli\n');
+    }
+    if (!authed) {
+        process.stdout.write('  • Authenticate so the CLI can sync with the Lumo server:\n' +
+            '      lumo auth login\n');
+    }
+    if (onPath && authed && !isRunningUnderNpx()) {
+        process.stdout.write('  • All set. Open Claude Code in this directory — the SKILL.md and\n' +
+            '    hooks are wired in.\n');
+    }
+    process.stdout.write('\n');
+}
+function isLumoOnPath() {
+    try {
+        // `command -v` is a POSIX shell builtin (`execSync` defaults to /bin/sh
+        // on Unix). `where` is a cmd.exe builtin on Windows.
+        (0, child_process_1.execSync)(process.platform === 'win32' ? 'where lumo' : 'command -v lumo', { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isRunningUnderNpx() {
+    const argv1 = process.argv[1] || '';
+    return /[\\/]_npx[\\/]/.test(argv1) || process.env.npm_command === 'exec';
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = update;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const update_check_1 = require("../lib/update-check");
+async function update() {
+    const pkg = require(path.resolve(__dirname, '../../../..', 'package.json'));
+    process.stdout.write(`Current: ${pkg.name}@${pkg.version}\n`);
+    process.stdout.write('Checking npm registry...\n');
+    const latest = await (0, update_check_1.fetchLatestVersion)(pkg.name, 5000);
+    if (!latest) {
+        process.stderr.write('Could not reach npm registry. Check your connection and try again.\n');
+        return 1;
+    }
+    if (latest === pkg.version) {
+        process.stdout.write(`Already on the latest version (${latest}).\n`);
+        return 0;
+    }
+    if (!(0, update_check_1.isNewer)(pkg.version, latest)) {
+        process.stdout.write(`Installed version (${pkg.version}) is ahead of the published latest (${latest}). Nothing to do.\n`);
+        return 0;
+    }
+    process.stdout.write(`Latest:  ${pkg.name}@${latest}\n\n`);
+    process.stdout.write(`Running: npm install -g ${pkg.name}@latest\n\n`);
+    return new Promise(resolve => {
+        const proc = (0, child_process_1.spawn)('npm', ['install', '-g', `${pkg.name}@latest`], {
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        proc.on('close', code => resolve(code ?? 0));
+        proc.on('error', err => {
+            process.stderr.write(`Failed to launch npm: ${err.message}\n`);
+            process.stderr.write(`Fallback: run \`npm install -g ${pkg.name}@latest\` manually.\n`);
+            resolve(1);
+        });
+    });
+}

package/dist/cli/src/index.js

@@ -78,9 +78,30 @@ const doc_share_1 = require("./commands/doc-share");
 const doc_unshare_1 = require("./commands/doc-unshare");
 const doc_share_list_1 = require("./commands/doc-share-list");
 const doc_move_1 = require("./commands/doc-move");
+const update_1 = require("./commands/update");
+const setup_1 = require("./commands/setup");
+const update_check_1 = require("./lib/update-check");
 // Resolve package.json relative to __dirname so this works regardless of how
 // deep the compiled output ends up (flat dist/ or nested dist/cli/src/).
 const pkg = require(path.resolve(__dirname, '../../..', 'package.json'));
+// Detached background-refresh worker: re-entry point for the spawn() in
+// maybeRefreshInBackground(). Fetches latest, writes cache, exits — skipping
+// commander.parseAsync() below.
+const isUpdateCheckWorker = process.argv[2] === '__update-check' && !!process.argv[3];
+if (isUpdateCheckWorker) {
+    (0, update_check_1.runBackgroundRefresh)(process.argv[3])
+        .catch(() => { })
+        .finally(() => process.exit(0));
+}
+else {
+    (0, update_check_1.printUpdateNoticeIfAny)(pkg.name, pkg.version);
+    (0, update_check_1.maybeRefreshInBackground)(pkg.name);
+}
+// One-shot cleanup of pre-LUM-46 local state. The session→task binding
+// is now server-authoritative; the legacy global pointer and the
+// per-session sentinel directory are both obsolete. Failures are
+// swallowed so a permission glitch doesn't prevent CLI invocation.
+;
 (() => {
     const dir = process.env.LUMO_CONFIG_DIR || path.join(os.homedir(), '.lumo');
     try {
@@ -124,6 +145,17 @@ program
     .command('whoami')
     .description('Show the currently logged-in identity')
     .action(wrap(whoami_1.whoami));
+program
+    .command('update')
+    .description(`Check npm for a newer ${pkg.name} and install it globally if available.`)
+    .action(wrap(update_1.update));
+program
+    .command('setup')
+    .description('Install the Lumo Claude Code skill and wire hook handlers into .claude/settings.json. Run via `npx @lumoai/cli setup` for first-time onboarding.')
+    .option('--user', 'Install into ~/.claude (applies across all projects for this user)')
+    .option('--project', 'Install into ./.claude (applies to the current project only)')
+    .option('--force', 'Overwrite an existing SKILL.md when its contents differ from the bundled version')
+    .action(wrap(options => (0, setup_1.setup)(options)));
 const session = program
     .command('session')
     .description('Manage per-terminal coding-session context');
@@ -485,8 +517,10 @@ hook
     .command('instructions-loaded')
     .description('Forward an InstructionsLoaded hook event to Lumo (reads JSON from stdin)')
     .action(wrap(() => (0, hook_1.hookCommand)('instructions-loaded')));
-program.parseAsync(process.argv).catch(err => {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`Error: ${msg}`);
-    process.exit(1);
-});
+if (!isUpdateCheckWorker) {
+    program.parseAsync(process.argv).catch(err => {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    });
+}

package/dist/cli/src/lib/hooks-template.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LUMO_HOOK_EVENTS = void 0;
+exports.buildLumoHookFragment = buildLumoHookFragment;
+exports.mergeLumoHooks = mergeLumoHooks;
+// Canonical list of Claude Code hook events that the Lumo CLI handles via
+// `lumo hook <event>`. Each entry maps a Claude Code event name (CamelCase,
+// matches settings.json keys) to the slug-form subcommand. Kept in sync with
+// the `hook` subcommand registrations in cli/src/index.ts and with the
+// repository's own .claude/settings.json.
+exports.LUMO_HOOK_EVENTS = [
+    ['PreToolUse', 'pre-tool-use'],
+    ['PostToolUse', 'post-tool-use'],
+    ['PostToolUseFailure', 'post-tool-use-failure'],
+    ['UserPromptSubmit', 'user-prompt-submit'],
+    ['Stop', 'stop'],
+    ['StopFailure', 'stop-failure'],
+    ['PermissionRequest', 'permission-request'],
+    ['PermissionDenied', 'permission-denied'],
+    ['SessionStart', 'session-start'],
+    ['SessionEnd', 'session-end'],
+    ['SubagentStart', 'subagent-start'],
+    ['SubagentStop', 'subagent-stop'],
+    ['WorktreeCreate', 'worktree-create'],
+    ['WorktreeRemove', 'worktree-remove'],
+    ['FileChanged', 'file-changed'],
+    ['ConfigChange', 'config-change'],
+    ['TaskCreated', 'task-created'],
+    ['TaskCompleted', 'task-completed'],
+    ['PostToolBatch', 'post-tool-batch'],
+    ['UserPromptExpansion', 'user-prompt-expansion'],
+    ['Notification', 'notification'],
+    ['Elicitation', 'elicitation'],
+    ['ElicitationResult', 'elicitation-result'],
+    ['CwdChanged', 'cwd-changed'],
+    ['InstructionsLoaded', 'instructions-loaded'],
+];
+// Build the settings.json fragment we want to install. We do not use a
+// matcher because the Lumo hook handlers ingest every event of a given type;
+// adding a matcher would silently drop events that have no `tool_name` (e.g.
+// SessionStart). Keep this in step with cli/src/commands/hook.ts dispatch.
+function buildLumoHookFragment() {
+    const hooks = {};
+    for (const [event, slug] of exports.LUMO_HOOK_EVENTS) {
+        hooks[event] = [
+            { hooks: [{ type: 'command', command: `lumo hook ${slug}` }] },
+        ];
+    }
+    return { hooks };
+}
+function mergeLumoHooks(existing) {
+    const base = existing ? JSON.parse(JSON.stringify(existing)) : {};
+    if (!base.hooks)
+        base.hooks = {};
+    const stats = { addedEvents: [], alreadyPresent: [] };
+    for (const [event, slug] of exports.LUMO_HOOK_EVENTS) {
+        const ourCmd = `lumo hook ${slug}`;
+        const groups = base.hooks[event] ?? [];
+        const present = groups.some(g => Array.isArray(g.hooks) && g.hooks.some(h => h.command === ourCmd));
+        if (present) {
+            stats.alreadyPresent.push(event);
+            base.hooks[event] = groups;
+            continue;
+        }
+        base.hooks[event] = [
+            ...groups,
+            { hooks: [{ type: 'command', command: ourCmd }] },
+        ];
+        stats.addedEvents.push(event);
+    }
+    return { merged: base, stats };
+}

package/dist/cli/src/lib/line-prompt.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptLine = promptLine;
+// Plain-text line prompt for interactive choices. Echoes input (unlike
+// promptSecret). Returns the trimmed line. Resolves with an empty string when
+// stdin ends before a newline (callers should fall back to a default).
+function promptLine(message) {
+    return new Promise(resolve => {
+        const stdin = process.stdin;
+        if (stdin.isTTY) {
+            process.stdout.write(message);
+        }
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        let buf = '';
+        const onData = (chunk) => {
+            buf += chunk;
+            const nl = buf.indexOf('\n');
+            if (nl === -1)
+                return;
+            cleanup();
+            resolve(buf.slice(0, nl).replace(/\r$/, '').trim());
+        };
+        const onEnd = () => {
+            cleanup();
+            resolve(buf.trim());
+        };
+        const cleanup = () => {
+            stdin.removeListener('data', onData);
+            stdin.removeListener('end', onEnd);
+            stdin.pause();
+        };
+        stdin.on('data', onData);
+        stdin.on('end', onEnd);
+    });
+}

package/dist/cli/src/lib/update-check.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNewer = isNewer;
+exports.fetchLatestVersion = fetchLatestVersion;
+exports.printUpdateNoticeIfAny = printUpdateNoticeIfAny;
+exports.maybeRefreshInBackground = maybeRefreshInBackground;
+exports.runBackgroundRefresh = runBackgroundRefresh;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const https = __importStar(require("https"));
+const child_process_1 = require("child_process");
+const CACHE_FILE = path.join(process.env.LUMO_CONFIG_DIR || path.join(os.homedir(), '.lumo'), 'update-check.json');
+const CHECK_INTERVAL_MS = 1000 * 60 * 60 * 24;
+function readCache() {
+    try {
+        const raw = fs.readFileSync(CACHE_FILE, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.lastChecked !== 'number' ||
+            typeof parsed.latest !== 'string')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(cache) {
+    try {
+        fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(cache));
+    }
+    catch {
+        /* swallow — the update check is non-essential */
+    }
+}
+// Compare two dotted version strings. Returns true iff `b` is strictly newer.
+// Handles the subset of semver we actually publish: MAJOR.MINOR.PATCH with
+// no pre-release tags. Unknown segments are treated as 0.
+function isNewer(current, candidate) {
+    const c = current.split('.').map(n => parseInt(n, 10) || 0);
+    const l = candidate.split('.').map(n => parseInt(n, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+        const cv = c[i] ?? 0;
+        const lv = l[i] ?? 0;
+        if (lv > cv)
+            return true;
+        if (lv < cv)
+            return false;
+    }
+    return false;
+}
+function fetchLatestVersion(name, timeoutMs = 2000) {
+    return new Promise(resolve => {
+        const url = `https://registry.npmjs.org/${encodeURIComponent(name).replace('%40', '@')}/latest`;
+        const req = https.get(url, { headers: { Accept: 'application/json' } }, res => {
+            if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
+                res.resume();
+                return resolve(null);
+            }
+            let data = '';
+            res.setEncoding('utf8');
+            res.on('data', chunk => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(typeof json.version === 'string' ? json.version : null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on('error', () => resolve(null));
+        req.setTimeout(timeoutMs, () => {
+            req.destroy();
+            resolve(null);
+        });
+    });
+}
+// Read cached latest version and emit a one-line notice to stderr when a
+// newer version is available. Safe to call on every CLI invocation.
+function printUpdateNoticeIfAny(name, current) {
+    const cache = readCache();
+    if (!cache)
+        return;
+    if (isNewer(current, cache.latest)) {
+        process.stderr.write(`\n  ⬆ Update available: ${name} ${current} → ${cache.latest}\n    Run: lumo update\n\n`);
+    }
+}
+// Spawn a detached child to refresh the cached latest version when the cache
+// is older than CHECK_INTERVAL_MS. The child re-enters the CLI entrypoint via
+// the `__update-check` sentinel arg and exits silently when done. Failures
+// here must never affect the foreground command.
+function maybeRefreshInBackground(name) {
+    const cache = readCache();
+    if (cache && Date.now() - cache.lastChecked < CHECK_INTERVAL_MS)
+        return;
+    try {
+        const child = (0, child_process_1.spawn)(process.execPath, [process.argv[1] || '', '__update-check', name], { detached: true, stdio: 'ignore' });
+        child.unref();
+    }
+    catch {
+        /* swallow */
+    }
+}
+// Entrypoint for the detached child. Called from index.ts when argv[2] is
+// the sentinel; performs the fetch and writes the cache, then exits.
+async function runBackgroundRefresh(name) {
+    const latest = await fetchLatestVersion(name, 5000);
+    if (latest)
+        writeCache({ lastChecked: Date.now(), latest });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumoai/cli",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Lumo CLI — manage tasks and sessions from the terminal",
   "license": "MIT",
   "author": "cli@uselumo.ai",
@@ -24,18 +24,19 @@
     "node": ">=18"
   },
   "bin": {
-    "lumo": "./dist/cli/src/index.js"
+    "lumo": "dist/cli/src/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "assets"
   ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc && chmod +x dist/cli/src/index.js",
+    "build": "tsc && chmod +x dist/cli/src/index.js && node ./scripts/bundle-assets.js",
     "dev": "tsc --watch",
-    "clean": "rm -rf dist",
+    "clean": "rm -rf dist assets",
     "prepublishOnly": "npm run clean && npm run build"
   },
   "dependencies": {