ghost-dragon 4.2.1

package/dist/commands/scale.js

@@ -0,0 +1,191 @@
+/**
+ * dragon scale — DragonScale Commerce Platform management
+ *
+ * Manages Upalis/DragonScale deployments:
+ * - Status & health checks via API
+ * - Order management
+ * - Menu management
+ * - Database operations (backup, seed)
+ * - Deployment (pull, update)
+ */
+import { getProductPath } from '../config.js';
+import { exec, run, fetchJSON, label, success, error, info, warn, table } from '../utils.js';
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import { join } from 'path';
+export function registerScaleCommands(program, config) {
+    const scale = program
+        .command('scale')
+        .description('DragonScale — Commerce platform management');
+    // --- status ---
+    scale
+        .command('status')
+        .description('Check platform health & today\'s stats')
+        .option('-u, --url <url>', 'Base URL of the DragonScale instance')
+        .action(async (opts) => {
+        const url = opts.url || config.products.scale.url;
+        if (!url) {
+            error('No URL configured. Use --url or run: dragon init');
+            process.exit(1);
+        }
+        console.log(label('DragonScale'), 'Checking status...\n');
+        try {
+            const health = await fetchJSON(`${url}/api/health.php`);
+            console.log(`  Platform:  ${health.status === 'healthy' ? chalk.green('● Online') : chalk.red('● Down')}`);
+            console.log(`  PHP:       ${chalk.dim(health.checks?.php?.version || 'unknown')}`);
+            console.log(`  Database:  ${health.checks?.database?.status === 'connected' ? chalk.green('Connected') : chalk.red('Disconnected')}`);
+            console.log(`  Disk:      ${chalk.dim(health.checks?.filesystem?.status || 'unknown')}`);
+            success('Health check passed');
+        }
+        catch (e) {
+            error(`Cannot reach ${url}/api/health.php — ${e.message}`);
+        }
+    });
+    // --- orders ---
+    scale
+        .command('orders')
+        .description('List recent orders')
+        .option('-u, --url <url>', 'Base URL')
+        .option('-n, --limit <n>', 'Number of orders', '10')
+        .option('-s, --status <status>', 'Filter by status (pending, confirmed, preparing, ready, delivered)')
+        .action(async (opts) => {
+        const url = opts.url || config.products.scale.url;
+        if (!url) {
+            error('No URL configured.');
+            process.exit(1);
+        }
+        console.log(label('DragonScale'), 'Fetching orders...\n');
+        try {
+            const params = new URLSearchParams({ action: 'list', limit: opts.limit });
+            if (opts.status)
+                params.set('status', opts.status);
+            const data = await fetchJSON(`${url}/api/orders.php?${params}`);
+            if (data.orders?.length) {
+                table(data.orders.map((o) => ({
+                    ID: `#${o.id}`,
+                    Status: o.status,
+                    Type: o.order_type || '-',
+                    Total: `LKR ${o.total}`,
+                    Time: o.created_at || '-',
+                })));
+            }
+            else {
+                info('No orders found');
+            }
+        }
+        catch (e) {
+            error(`Failed to fetch orders: ${e.message}`);
+        }
+    });
+    // --- menu ---
+    scale
+        .command('menu')
+        .description('List menu items')
+        .option('-u, --url <url>', 'Base URL')
+        .option('-c, --category <id>', 'Filter by category ID')
+        .action(async (opts) => {
+        const url = opts.url || config.products.scale.url;
+        if (!url) {
+            error('No URL configured.');
+            process.exit(1);
+        }
+        console.log(label('DragonScale'), 'Fetching menu...\n');
+        try {
+            const params = new URLSearchParams({ action: 'all' });
+            if (opts.category)
+                params.set('category_id', opts.category);
+            const data = await fetchJSON(`${url}/api/menu.php?${params}`);
+            if (data.categories?.length) {
+                for (const cat of data.categories) {
+                    console.log(chalk.green.bold(`\n  ${cat.name}`));
+                    if (cat.items?.length) {
+                        for (const item of cat.items) {
+                            const status = item.available ? chalk.green('●') : chalk.red('○');
+                            console.log(`    ${status} ${item.name}  ${chalk.dim(`LKR ${item.price}`)}`);
+                        }
+                    }
+                }
+                console.log();
+            }
+            else {
+                info('No menu data');
+            }
+        }
+        catch (e) {
+            error(`Failed to fetch menu: ${e.message}`);
+        }
+    });
+    // --- deploy ---
+    scale
+        .command('deploy')
+        .description('Pull latest code & update production')
+        .action(async () => {
+        const path = getProductPath(config, 'scale');
+        const script = join(path, 'scripts/update-production.sh');
+        if (!existsSync(script)) {
+            error(`Deploy script not found: ${script}`);
+            process.exit(1);
+        }
+        console.log(label('DragonScale'), 'Deploying...\n');
+        const code = await run('bash', [script], path);
+        code === 0 ? success('Deployment complete') : error(`Deploy failed (exit ${code})`);
+    });
+    // --- backup ---
+    scale
+        .command('backup')
+        .description('Backup the database')
+        .option('-o, --output <dir>', 'Output directory', './backups')
+        .action(async (opts) => {
+        const path = getProductPath(config, 'scale');
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const outDir = join(path, opts.output);
+        console.log(label('DragonScale'), 'Backing up database...\n');
+        try {
+            exec(`mkdir -p "${outDir}"`);
+            // Try mysqldump first, fall back to sqlite
+            try {
+                exec(`mysqldump --defaults-file="${join(path, '.my.cnf')}" upalis > "${join(outDir, `backup-${timestamp}.sql`)}"`, path);
+            }
+            catch {
+                const dbFile = join(path, 'data', 'database.sqlite');
+                if (existsSync(dbFile)) {
+                    exec(`cp "${dbFile}" "${join(outDir, `backup-${timestamp}.sqlite`)}"`, path);
+                }
+                else {
+                    throw new Error('No database found to backup');
+                }
+            }
+            success(`Backup saved to ${outDir}/backup-${timestamp}.*`);
+        }
+        catch (e) {
+            error(`Backup failed: ${e.message}`);
+        }
+    });
+    // --- seed ---
+    scale
+        .command('seed')
+        .description('Seed database with sample data')
+        .action(async () => {
+        const path = getProductPath(config, 'scale');
+        console.log(label('DragonScale'), 'Seeding database...\n');
+        const code = await run('php', ['scripts/seed-production.php'], path);
+        code === 0 ? success('Seeding complete') : error(`Seed failed (exit ${code})`);
+    });
+    // --- logs ---
+    scale
+        .command('logs')
+        .description('Tail application logs')
+        .option('-n, --lines <n>', 'Number of lines', '50')
+        .option('-f, --follow', 'Follow log output')
+        .action(async (opts) => {
+        const path = getProductPath(config, 'scale');
+        const logFile = join(path, 'logs/app.log');
+        if (!existsSync(logFile)) {
+            warn(`No log file at ${logFile}`);
+            return;
+        }
+        const args = [opts.follow ? '-f' : `-n${opts.lines}`, logFile];
+        await run('tail', args, path);
+    });
+}
+//# sourceMappingURL=scale.js.map

package/dist/commands/serve.d.ts

@@ -0,0 +1,16 @@
+/**
+ * dragon serve — Start the entire stack
+ *
+ * Spawns:
+ *  - PhantomDragon Control API (Python uvicorn :4091)
+ *  - PhantomDragon Control dashboard (Next.js :4090)
+ *  - DragonNet API (Fastify :4080)
+ *  - DragonNet dashboard (Next.js :4081)
+ *
+ * PID files at ~/.dragon/pids/ so `dragon down` can stop them cleanly.
+ * Foreground mode tails stdout; --detach forks to background.
+ */
+import type { Command } from 'commander';
+import type { DragonConfig } from '../config.js';
+export declare function registerServeCommands(program: Command, config: DragonConfig): void;
+//# sourceMappingURL=serve.d.ts.map

package/dist/commands/serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/commands/serve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AA+FhD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,QA6D3E"}

package/dist/commands/serve.js

@@ -0,0 +1,167 @@
+/**
+ * dragon serve — Start the entire stack
+ *
+ * Spawns:
+ *  - PhantomDragon Control API (Python uvicorn :4091)
+ *  - PhantomDragon Control dashboard (Next.js :4090)
+ *  - DragonNet API (Fastify :4080)
+ *  - DragonNet dashboard (Next.js :4081)
+ *
+ * PID files at ~/.dragon/pids/ so `dragon down` can stop them cleanly.
+ * Foreground mode tails stdout; --detach forks to background.
+ */
+import { label, success, error, info, warn } from '../utils.js';
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const PIDS_DIR = join(homedir(), '.dragon', 'pids');
+const LOGS_DIR = join(homedir(), '.dragon', 'logs');
+function ensureDirs() {
+    mkdirSync(PIDS_DIR, { recursive: true });
+    mkdirSync(LOGS_DIR, { recursive: true });
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function buildServices(config) {
+    const services = [];
+    const pentest = config.products.pentest.path;
+    if (pentest && existsSync(join(pentest, 'phantomdragon.py'))) {
+        services.push({
+            key: 'pd-control-api',
+            name: 'PhantomDragon Control API',
+            cwd: pentest,
+            cmd: 'python3',
+            args: ['-m', 'phantom_dragon_ai.control_api'],
+            port: config.products.pentest.controlPort,
+        });
+    }
+    // The Next.js dashboard lives in a sibling dir
+    const controlDash = pentest ? join(pentest, '..', 'phantomdragon-control') : '';
+    if (controlDash && existsSync(controlDash) && existsSync(join(controlDash, 'package.json'))) {
+        services.push({
+            key: 'pd-control-ui',
+            name: 'PhantomDragon Control UI',
+            cwd: controlDash,
+            cmd: 'npm',
+            args: ['run', 'dev'],
+            port: config.products.pentest.controlUiPort,
+        });
+    }
+    const net = config.products.net.path;
+    if (net && existsSync(join(net, 'pnpm-workspace.yaml'))) {
+        services.push({
+            key: 'dn-api',
+            name: 'DragonNet API',
+            cwd: net,
+            cmd: 'pnpm',
+            args: ['--filter', '@dragonnet/api', 'dev'],
+            port: config.products.net.apiPort,
+        });
+        services.push({
+            key: 'dn-ui',
+            name: 'DragonNet Dashboard',
+            cwd: net,
+            cmd: 'pnpm',
+            args: ['--filter', '@dragonnet/dashboard', 'dev'],
+            port: config.products.net.uiPort,
+        });
+    }
+    return services;
+}
+function startService(s) {
+    const logPath = join(LOGS_DIR, `${s.key}.log`);
+    const child = spawn(s.cmd, s.args, {
+        cwd: s.cwd,
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env, ...(s.env ?? {}) },
+    });
+    const { openSync, closeSync } = require('fs');
+    const fd = openSync(logPath, 'a');
+    child.stdout?.on('data', (chunk) => writeFileSync(logPath, chunk, { flag: 'a' }));
+    child.stderr?.on('data', (chunk) => writeFileSync(logPath, chunk, { flag: 'a' }));
+    child.unref();
+    closeSync(fd);
+    writeFileSync(join(PIDS_DIR, `${s.key}.pid`), String(child.pid));
+    return child.pid ?? 0;
+}
+export function registerServeCommands(program, config) {
+    program
+        .command('serve')
+        .description('Start the entire dragon stack (PhantomDragon Control + DragonNet)')
+        .option('--detach', 'Background mode (default: foreground)', false)
+        .action(async () => {
+        ensureDirs();
+        const services = buildServices(config);
+        if (services.length === 0) {
+            error('No products configured. Run: dragon init');
+            return;
+        }
+        console.log(label('Dragon'), 'Starting stack...\n');
+        for (const s of services) {
+            const pidFile = join(PIDS_DIR, `${s.key}.pid`);
+            if (existsSync(pidFile)) {
+                const oldPid = Number(readFileSync(pidFile, 'utf-8'));
+                if (pidAlive(oldPid)) {
+                    info(`${s.name} already running (pid ${oldPid})`);
+                    continue;
+                }
+            }
+            try {
+                const pid = startService(s);
+                success(`${s.name.padEnd(28)} ${chalk.dim(`pid ${pid}` + (s.port ? `  :${s.port}` : ''))}`);
+            }
+            catch (e) {
+                error(`${s.name} → ${e}`);
+            }
+        }
+        console.log();
+        info('Logs at ~/.dragon/logs/<service>.log');
+        info('Stop with: dragon down');
+    });
+    program
+        .command('down')
+        .description('Stop all dragon services')
+        .action(() => {
+        ensureDirs();
+        const files = readdirSync(PIDS_DIR).filter((f) => f.endsWith('.pid'));
+        if (files.length === 0) {
+            info('Nothing to stop.');
+            return;
+        }
+        for (const f of files) {
+            const pidPath = join(PIDS_DIR, f);
+            const pid = Number(readFileSync(pidPath, 'utf-8'));
+            const name = f.replace(/\.pid$/, '');
+            if (pidAlive(pid)) {
+                try {
+                    process.kill(-pid, 'SIGTERM');
+                }
+                catch {
+                    try {
+                        process.kill(pid, 'SIGTERM');
+                    }
+                    catch { /* swallow */ }
+                }
+                success(`Stopped ${name} (pid ${pid})`);
+            }
+            else {
+                warn(`${name} not running`);
+            }
+            try {
+                unlinkSync(pidPath);
+            }
+            catch { /* swallow */ }
+        }
+    });
+}
+//# sourceMappingURL=serve.js.map

package/dist/commands/tui.d.ts

@@ -0,0 +1,17 @@
+/**
+ * dragon tui — the operator command-center. Full-screen, in the ghosts.lk visual
+ * language: near-black depth, a brushed-chrome phantom sigil + wordmark, two-column
+ * live panels (system · signal) with a traces-per-hour sparkline + disk gauge, and a
+ * pulsing emerald OPSEC bar.
+ *
+ * Rendered like a flagship TUI (see the advanced-tui-design + terminal-subcell-graphics
+ * skills): runs on the ALTERNATE screen buffer (htop-style, restores your scrollback),
+ * hides the cursor, and paints each frame inside SYNCHRONIZED OUTPUT (DEC ?2026) with
+ * per-line clear-to-EOL — so frames are atomic and flicker-free. `q` / Ctrl-C to quit.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import type { Command } from 'commander';
+import { type DragonConfig } from '../config.js';
+export declare function registerTuiCommands(program: Command, _config: DragonConfig): void;
+//# sourceMappingURL=tui.d.ts.map

package/dist/commands/tui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui.d.ts","sourceRoot":"","sources":["../../src/commands/tui.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,cAAc,CAAA;AA2B5D,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,QAmF1E"}

package/dist/commands/tui.js

@@ -0,0 +1,138 @@
+/**
+ * dragon tui — the operator command-center. Full-screen, in the ghosts.lk visual
+ * language: near-black depth, a brushed-chrome phantom sigil + wordmark, two-column
+ * live panels (system · signal) with a traces-per-hour sparkline + disk gauge, and a
+ * pulsing emerald OPSEC bar.
+ *
+ * Rendered like a flagship TUI (see the advanced-tui-design + terminal-subcell-graphics
+ * skills): runs on the ALTERNATE screen buffer (htop-style, restores your scrollback),
+ * hides the cursor, and paints each frame inside SYNCHRONIZED OUTPUT (DEC ?2026) with
+ * per-line clear-to-EOL — so frames are atomic and flicker-free. `q` / Ctrl-C to quit.
+ *
+ * Copyright 2026 Ghost Protocol (Pvt) Ltd. All Rights Reserved.
+ */
+import { loadConfig } from '../config.js';
+import { C } from '../utils.js';
+import { panel, chrome, chromeRule, joinColumns, emerald, brailleChart, gauge } from '../ui.js';
+import { resolveAuth } from '../auth.js';
+import { resolveProvider } from '../brain/index.js';
+import { loadSkillLibrary } from '../agent/skills.js';
+import { existsSync, statfsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { stdin, stdout } from 'node:process';
+const SIGIL = ['   ▄▄▄▄▄   ', '  ▟█████▙  ', '  █ ▘ ▘ █  ', '  ▜█████▛  ', '   ▘▘ ▘▘   '];
+const SIGIL_W = 11;
+const VER = '4.2.1';
+const PULSE = ['·', '•', '●', '•']; // heartbeat
+const dot = (on) => (on ? emerald('●') : C.faint('○'));
+const indent = (s) => s.split('\n').map((l) => '  ' + l).join('\n');
+// Terminal control. ?1049 = alt screen, ?25 = cursor, ?2026 = synchronized output.
+const ENTER = '\x1b[?1049h\x1b[?25l';
+const LEAVE = '\x1b[?25h\x1b[?1049l';
+/** Atomic, flicker-free frame: sync-begin → home → per-line clear-to-EOL → clear-below → sync-end. */
+function paint(content) {
+    const lines = content.split('\n');
+    stdout.write('\x1b[?2026h\x1b[H' + lines.map((l) => l + '\x1b[K').join('\n') + '\x1b[J\x1b[?2026l');
+}
+export function registerTuiCommands(program, _config) {
+    program
+        .command('tui')
+        .description('Live operator command-center (press q to quit)')
+        .action(async () => {
+        const skills = loadSkillLibrary().count;
+        const ollama = ['/usr/local/bin/ollama', '/usr/bin/ollama', join(homedir(), '.local/bin/ollama')].some(existsSync);
+        const wyrmReady = [process.env.WYRM_MCP_BIN, join(homedir(), '.npm-global/bin/wyrm-mcp')].filter(Boolean).some((p) => existsSync(p));
+        let frame = 0;
+        const draw = () => {
+            const cols = Math.max(64, Math.min(stdout.columns || 100, 124));
+            const inner = cols - 4;
+            const wide = cols >= 92;
+            const leftW = wide ? Math.min(44, Math.floor(inner / 2) - 2) : inner;
+            const rightW = wide ? inner - leftW - 3 : inner;
+            const actMax = (wide ? rightW : inner) - 8;
+            const pulse = emerald(PULSE[frame % PULSE.length]);
+            const cfg = loadConfig();
+            const a = resolveAuth();
+            const active = resolveProvider();
+            const ready = {
+                claude: !!(process.env.ANTHROPIC_API_KEY || cfg.brain?.keys?.anthropic),
+                worker: a.mode !== 'none', local: ollama,
+                openai: !!(process.env.OPENAI_API_KEY || cfg.brain?.keys?.openai),
+                custom: !!(process.env.DRAGON_OPENAI_BASE || cfg.brain?.customBaseURL), ghost: false,
+            };
+            let diskFrac = 0;
+            let diskFree = '—';
+            try {
+                const st = statfsSync(process.cwd());
+                const free = st.bavail * st.bsize;
+                const total = st.blocks * st.bsize;
+                diskFrac = total ? 1 - free / total : 0;
+                diskFree = `${(free / 1e9).toFixed(0)}G free`;
+            }
+            catch { /* skip */ }
+            let traces = 0;
+            let recent = [];
+            const hours = new Array(24).fill(0);
+            try {
+                const lines = readFileSync(join(homedir(), '.dragon', 'traces', `${new Date().toISOString().slice(0, 10)}.jsonl`), 'utf-8').trim().split('\n').filter(Boolean);
+                traces = lines.length;
+                for (const l of lines) {
+                    try {
+                        const t = JSON.parse(l);
+                        hours[new Date(t.ts).getHours()]++;
+                    }
+                    catch { /* skip */ }
+                }
+                recent = lines.slice(-3).map((l) => { try {
+                    return (JSON.parse(l).prompt || '').replace(/\s+/g, ' ').trim();
+                }
+                catch {
+                    return '';
+                } }).filter(Boolean);
+            }
+            catch { /* none today */ }
+            // ── hero ──
+            const hero = joinColumns(SIGIL.map((l) => chrome(l)).join('\n'), ['', chrome('G H O S T   P R O T O C O L'), `${C.faint('▌')} ${emerald('OPERATOR CONSOLE')} ${C.faint('//')} ${C.info('DRAGON v' + VER)}`, C.faint('on-host coding + ops agent · sovereign-capable · ghosts.lk'), ''].join('\n'), SIGIL_W);
+            // ── panels ──
+            const sysLines = [
+                `${C.faint('brain ')} ${dot(ready[active] ?? false)} ${C.info(active)}`,
+                `${C.faint('auth  ')} ${dot(a.mode !== 'none')} ${a.mode === 'none' ? C.faint('signed out') : C.info(a.email || a.mode)}`,
+                `${C.faint('memory')} ${dot(wyrmReady)} ${wyrmReady ? C.info('Wyrm') : C.faint('—')}    ${C.faint('ollama')} ${dot(ollama)}`,
+                `${C.faint('skills')} ${C.info(String(skills))}`,
+                `${C.faint('disk  ')} ${gauge(diskFrac, 12)} ${C.faint(diskFree)}`,
+            ];
+            const chartW = Math.max(16, Math.min(actMax, 40));
+            const peak = Math.max(...hours, 1);
+            const actLines = [
+                ...(recent.length ? recent.map((r) => `${C.faint('›')} ${C.info(r.slice(0, actMax))}`) : [C.faint('no agent activity today')]),
+                '',
+                `${C.faint('24h traces')} ${C.faint('· peak')} ${emerald(String(peak))}`,
+                ...brailleChart(hours, { width: chartW, height: 3, area: true }),
+                `${pulse} ${C.faint(`listening · ${traces} traces today`)}`,
+            ];
+            const body = wide
+                ? joinColumns(panel(sysLines, { title: chrome('SYSTEM'), width: leftW }), panel(actLines, { title: chrome('SIGNAL'), width: rightW }), leftW)
+                : panel(sysLines, { title: chrome('SYSTEM'), width: inner }) + '\n' + panel(actLines, { title: chrome('SIGNAL'), width: inner });
+            const bar = `  ${pulse} ${C.faint('SYS')} ${emerald('OK')}  ${C.faint('· brain')} ${C.info(active)}  ${C.faint('· skills')} ${C.info(String(skills))}  ${C.faint('·')} ${C.info(new Date().toLocaleTimeString())}  ${C.faint('· q quit')}`;
+            paint('\n' + indent(hero) + '\n  ' + chromeRule(inner) + '\n\n' + indent(body) + '\n\n' + bar);
+        };
+        stdout.write(ENTER);
+        draw();
+        const iv = setInterval(() => { frame++; draw(); }, 1000);
+        const quit = () => { clearInterval(iv); if (stdin.isTTY) {
+            try {
+                stdin.setRawMode(false);
+            }
+            catch { /* ignore */ }
+        } stdout.write(LEAVE); process.exit(0); };
+        process.on('SIGINT', quit);
+        if (stdin.isTTY) {
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.on('data', (d) => { const s = d.toString(); if (s === 'q' || s === 'Q' || d[0] === 3)
+                quit(); });
+        }
+    });
+}
+//# sourceMappingURL=tui.js.map

package/dist/commands/wyrm.d.ts

@@ -0,0 +1,20 @@
+/**
+ * dragon wyrm — Wyrm AI Memory System bridge.
+ *
+ *   dragon wyrm status        — health + stats from the running HTTP API
+ *   dragon wyrm serve         — start the Wyrm HTTP API on :3333
+ *   dragon wyrm mcp           — start the Wyrm MCP server over stdio
+ *   dragon wyrm projects      — list registered projects
+ *   dragon wyrm scan <path>   — discover git projects under <path>
+ *   dragon wyrm search <q>    — search across all memory
+ *   dragon wyrm quests        — list active quests
+ *   dragon wyrm maintenance   — vacuum + archive the database
+ *
+ * Endpoints + binary paths match Wyrm v5.x (packages/mcp-server). The
+ * earlier shape (`/api/health`, `npx wyrm`, `wyrm-deploy`) was written
+ * against a v3-era layout that no longer exists.
+ */
+import type { Command } from 'commander';
+import type { DragonConfig } from '../config.js';
+export declare function registerWyrmCommands(program: Command, config: DragonConfig): void;
+//# sourceMappingURL=wyrm.d.ts.map

package/dist/commands/wyrm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wyrm.d.ts","sourceRoot":"","sources":["../../src/commands/wyrm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AA2DhD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,QA+L1E"}