@doquflow/cli 1.5.1 → 1.6.0

package/dist/commands/rewiki.js

@@ -0,0 +1,339 @@
+"use strict";
+/**
+ * docuflow rewiki
+ *
+ * Re-ingests all sources with the current extractor rules, migrates any
+ * synthesiss/ typo (defense-in-depth), backs up the existing wiki, and
+ * produces an audit report of removed / preserved pages.
+ *
+ * Usage:
+ *   docuflow rewiki                  # full migration with backup
+ *   docuflow rewiki --dry-run        # preview what would change, no writes
+ *   docuflow rewiki --no-backup      # skip backup (faster, irreversible)
+ *   docuflow rewiki --quiet          # suppress progress output
+ *
+ * Exit codes:
+ *   0 — success
+ *   2 — fatal error (.docuflow missing, server tools not found)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+// ─── Colour helpers ────────────────────────────────────────────────────────────
+const c = {
+    green: (s) => `\x1b[32m${s}\x1b[0m`,
+    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+    red: (s) => `\x1b[31m${s}\x1b[0m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+    dim: (s) => `\x1b[2m${s}\x1b[0m`,
+    bold: (s) => `\x1b[1m${s}\x1b[0m`,
+};
+// ─── Dynamic server tool loader (mirrors sync.ts pattern) ─────────────────────
+function loadServerTool(toolFile) {
+    const candidates = [
+        () => require(`@doquflow/server/dist/tools/${toolFile}`),
+        () => require(node_path_1.default.resolve(__dirname, "../../../server/dist/tools", toolFile)),
+        () => require(node_path_1.default.resolve(__dirname, "../../server/dist/tools", toolFile)),
+    ];
+    for (const attempt of candidates) {
+        try {
+            return attempt();
+        }
+        catch { }
+    }
+    throw new Error(`Cannot load server tool "${toolFile}". Run "npm run build" first.`);
+}
+function parseTags(content) {
+    const m = content.match(/^tags:\s*(\[.*?\])/m);
+    if (!m)
+        return [];
+    try {
+        return JSON.parse(m[1]);
+    }
+    catch {
+        return [];
+    }
+}
+async function scanWiki(wikiDir) {
+    const pages = [];
+    if (!node_fs_1.default.existsSync(wikiDir))
+        return pages;
+    const subdirs = await promises_1.default.readdir(wikiDir).catch(() => []);
+    for (const subdir of subdirs) {
+        const subdirPath = node_path_1.default.join(wikiDir, subdir);
+        const stat = await promises_1.default.stat(subdirPath).catch(() => null);
+        if (!stat?.isDirectory())
+            continue;
+        const files = await promises_1.default.readdir(subdirPath).catch(() => []);
+        for (const file of files) {
+            if (!file.endsWith(".md"))
+                continue;
+            const filePath = node_path_1.default.join(subdirPath, file);
+            const content = await promises_1.default.readFile(filePath, "utf8").catch(() => "");
+            const tags = parseTags(content);
+            pages.push({
+                filePath,
+                pageId: file.replace(/\.md$/, ""),
+                category: subdir,
+                tags,
+                isUserSaved: tags.includes("query_result"),
+            });
+        }
+    }
+    return pages;
+}
+// ─── Recursive copy ────────────────────────────────────────────────────────────
+async function copyDir(src, dest) {
+    await promises_1.default.mkdir(dest, { recursive: true });
+    const entries = await promises_1.default.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = node_path_1.default.join(src, entry.name);
+        const destPath = node_path_1.default.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDir(srcPath, destPath);
+        }
+        else {
+            await promises_1.default.copyFile(srcPath, destPath);
+        }
+    }
+}
+// ─── Count pages by category ───────────────────────────────────────────────────
+function countByCategory(pages) {
+    const counts = {};
+    for (const p of pages) {
+        counts[p.category] = (counts[p.category] ?? 0) + 1;
+    }
+    return counts;
+}
+async function run(options = {}) {
+    const projectPath = node_path_1.default.resolve(process.cwd());
+    const docuDir = node_path_1.default.join(projectPath, ".docuflow");
+    const sourcesDir = node_path_1.default.join(docuDir, "sources");
+    const wikiDir = node_path_1.default.join(docuDir, "wiki");
+    const dryRun = options.dryRun ?? false;
+    const quiet = options.quiet ?? false;
+    function info(msg) { if (!quiet)
+        console.log(msg); }
+    // ── Step 1: Pre-flight ──────────────────────────────────────────────────────
+    info(c.bold(`\n  🔄 DocuFlow Rewiki${dryRun ? c.yellow(" (dry-run)") : ""}\n`));
+    if (!node_fs_1.default.existsSync(docuDir)) {
+        console.error(c.red(`  ✗ .docuflow/ not found at ${projectPath}`));
+        console.error(`    Run "docuflow init" first.`);
+        process.exit(2);
+    }
+    if (!node_fs_1.default.existsSync(sourcesDir)) {
+        console.error(c.red(`  ✗ .docuflow/sources/ not found`));
+        console.error(`    Nothing to re-ingest.`);
+        process.exit(2);
+    }
+    // Count sources
+    const sourceFiles = (await promises_1.default.readdir(sourcesDir).catch(() => []))
+        .filter(f => f.endsWith(".md"));
+    info(`  📚 Sources: ${sourceFiles.length} file(s)`);
+    // Scan current wiki
+    const pagesBefore = await scanWiki(wikiDir);
+    const countsBefore = countByCategory(pagesBefore);
+    info(`  📖 Wiki pages before:`);
+    for (const [cat, n] of Object.entries(countsBefore)) {
+        info(`     ${cat}: ${n}`);
+    }
+    if (pagesBefore.length === 0) {
+        info(c.yellow(`     (none)`));
+    }
+    const userSavedPages = pagesBefore.filter(p => p.isUserSaved);
+    info(`  👤 User-saved synthesis pages: ${userSavedPages.length} (will be preserved)`);
+    if (dryRun) {
+        info(c.yellow(`\n  ℹ️  Dry-run mode — no files will be written.\n`));
+    }
+    // ── Step 2: Backup ──────────────────────────────────────────────────────────
+    let backupPath = "skipped";
+    if (!options.noBackup && !dryRun) {
+        const isoStamp = new Date().toISOString().replace(/[:.]/g, "-");
+        backupPath = node_path_1.default.join(docuDir, `wiki.backup-${isoStamp}`);
+        info(`\n  💾 Backing up wiki → ${c.cyan(node_path_1.default.relative(projectPath, backupPath))}`);
+        if (node_fs_1.default.existsSync(wikiDir)) {
+            await copyDir(wikiDir, backupPath);
+            info(c.green(`  ✅ Backup complete`));
+        }
+        else {
+            info(c.yellow(`  ⚠  wiki/ does not exist — skipping backup`));
+            backupPath = "skipped (wiki/ missing)";
+        }
+    }
+    else if (options.noBackup) {
+        info(`\n  ⚠  Backup skipped (--no-backup)`);
+    }
+    // ── Step 3: Migrate synthesiss/ typo (defense-in-depth) ────────────────────
+    const synthesissDir = node_path_1.default.join(wikiDir, "synthesiss");
+    const synthesesDir = node_path_1.default.join(wikiDir, "syntheses");
+    const migratedFiles = [];
+    if (!dryRun && node_fs_1.default.existsSync(synthesissDir)) {
+        info(`\n  🔧 Migrating synthesiss/ → syntheses/ (typo fix)`);
+        await promises_1.default.mkdir(synthesesDir, { recursive: true });
+        const files = await promises_1.default.readdir(synthesissDir).catch(() => []);
+        for (const f of files) {
+            const src = node_path_1.default.join(synthesissDir, f);
+            const dest = node_path_1.default.join(synthesesDir, f);
+            await promises_1.default.rename(src, dest);
+            migratedFiles.push(f);
+            info(c.dim(`     → ${f}`));
+        }
+        await promises_1.default.rmdir(synthesissDir).catch(() => { });
+        info(c.green(`  ✅ Migrated ${migratedFiles.length} file(s), removed synthesiss/`));
+    }
+    else if (dryRun && node_fs_1.default.existsSync(synthesissDir)) {
+        const files = await promises_1.default.readdir(synthesissDir).catch(() => []);
+        info(`\n  🔧 [dry-run] Would migrate ${files.length} file(s) from synthesiss/ → syntheses/`);
+        migratedFiles.push(...files);
+    }
+    // ── Step 4: Clear auto-generated pages & re-ingest ─────────────────────────
+    const pagesAfterIds = new Set();
+    let ingestErrors = 0;
+    const rejectedPages = [];
+    if (!dryRun) {
+        // Delete auto-generated pages (not user-saved) before re-ingesting
+        // so old noise pages are removed even if no new equivalent is created
+        info(`\n  🗑  Clearing auto-generated wiki pages...`);
+        let cleared = 0;
+        for (const page of pagesBefore) {
+            if (!page.isUserSaved) {
+                await promises_1.default.unlink(page.filePath).catch(() => { });
+                cleared++;
+            }
+        }
+        info(`     Cleared ${cleared} auto-generated page(s) (${userSavedPages.length} user-saved preserved)`);
+        // Load server tools
+        let ingestSource;
+        let updateIndex;
+        try {
+            ({ ingestSource } = loadServerTool("ingest-source"));
+            ({ updateIndex } = loadServerTool("update-index"));
+        }
+        catch (e) {
+            console.error(c.red(`  ✗ ${e.message}`));
+            process.exit(2);
+        }
+        // Re-ingest all sources
+        info(`\n  📥 Re-ingesting ${sourceFiles.length} source file(s)...`);
+        for (const filename of sourceFiles) {
+            try {
+                const result = await ingestSource({ project_path: projectPath, source_filename: filename });
+                const created = result.pages_created ?? [];
+                for (const id of created)
+                    pagesAfterIds.add(id);
+                info(`     ${c.green("✓")} ${filename} → ${created.length} page(s)`);
+            }
+            catch (e) {
+                info(c.red(`     ✗ ${filename}: ${e.message}`));
+                ingestErrors++;
+            }
+        }
+        // ── Step 5: Update index ────────────────────────────────────────────────
+        info(`\n  📋 Rebuilding index...`);
+        const indexResult = await updateIndex({ project_path: projectPath });
+        info(c.green(`  ✅ Index rebuilt — ${indexResult.entries_indexed ?? "?"} entries`));
+    }
+    else {
+        // Dry-run: simulate what would happen
+        info(`\n  📥 [dry-run] Would re-ingest ${sourceFiles.length} source file(s)`);
+        let { ingestSource } = (() => {
+            try {
+                return loadServerTool("ingest-source");
+            }
+            catch {
+                return { ingestSource: null };
+            }
+        })();
+        if (ingestSource) {
+            for (const filename of sourceFiles) {
+                try {
+                    const result = await ingestSource({ project_path: projectPath, source_filename: filename });
+                    for (const id of (result.pages_created ?? []))
+                        pagesAfterIds.add(id);
+                    info(`     ${c.dim("~")} ${filename} → ${(result.pages_created ?? []).length} page(s) (dry-run)`);
+                }
+                catch { }
+            }
+        }
+    }
+    // ── Pages removed = before - after - user-saved ───────────────────────────
+    for (const page of pagesBefore) {
+        if (!page.isUserSaved && !pagesAfterIds.has(page.pageId)) {
+            rejectedPages.push({ pageId: page.pageId, category: page.category });
+        }
+    }
+    // ── Step 6: Write report ────────────────────────────────────────────────────
+    const reportPath = node_path_1.default.join(docuDir, "rewiki-report.md");
+    const pagesAfter = dryRun ? pagesBefore : await scanWiki(wikiDir);
+    const countsAfter = countByCategory(pagesAfter);
+    const now = new Date().toISOString();
+    const reportLines = [
+        `# DocuFlow Rewiki Report`,
+        ``,
+        `**Timestamp:** ${now}`,
+        `**Dry-run:** ${dryRun}`,
+        `**Backup path:** ${backupPath}`,
+        ``,
+        `## Pages Before`,
+        ``,
+        ...Object.entries(countsBefore).map(([cat, n]) => `- ${cat}: ${n}`),
+        `- **Total:** ${pagesBefore.length}`,
+        ``,
+        `## Pages After`,
+        ``,
+        ...Object.entries(countsAfter).map(([cat, n]) => `- ${cat}: ${n}`),
+        `- **Total:** ${pagesAfter.length}`,
+        ``,
+        `## Removed Pages (${rejectedPages.length})`,
+        ``,
+        rejectedPages.length > 0
+            ? rejectedPages.map(p => `- \`${p.pageId}\` (${p.category})`).join("\n")
+            : "None.",
+        ``,
+        `## Preserved User-Saved Pages (${userSavedPages.length})`,
+        ``,
+        userSavedPages.length > 0
+            ? userSavedPages.map(p => `- \`${p.pageId}\``).join("\n")
+            : "None.",
+        ``,
+    ];
+    if (migratedFiles.length > 0) {
+        reportLines.push(`## synthesiss/ Migrations (${migratedFiles.length})`, ``, ...migratedFiles.map(f => `- ${f}`), ``);
+    }
+    const reportContent = reportLines.join("\n");
+    if (!dryRun) {
+        await promises_1.default.writeFile(reportPath, reportContent, "utf8");
+        info(`\n  📄 Report written → ${c.cyan(node_path_1.default.relative(projectPath, reportPath))}`);
+        // ── Step 7: Append to log.md ──────────────────────────────────────────────
+        const logPath = node_path_1.default.join(docuDir, "log.md");
+        const logEntry = `\n## [${now.split("T")[0]}] rewiki | removed ${rejectedPages.length}, kept ${pagesAfter.length - userSavedPages.length}, preserved ${userSavedPages.length} user pages\n`;
+        try {
+            await promises_1.default.appendFile(logPath, logEntry, "utf8");
+        }
+        catch { }
+    }
+    else {
+        info(`\n  📄 [dry-run] Report would be written to ${c.cyan(node_path_1.default.relative(projectPath, reportPath))}`);
+    }
+    // ── Summary ─────────────────────────────────────────────────────────────────
+    info(`\n  ─────────────────────────────────────────────`);
+    info(`  Sources re-ingested:  ${dryRun ? "(dry-run)" : sourceFiles.length}`);
+    info(`  Pages before:         ${pagesBefore.length}`);
+    info(`  Pages after:          ${dryRun ? "(dry-run)" : pagesAfter.length}`);
+    info(`  Removed:              ${rejectedPages.length}`);
+    info(`  Preserved (user):     ${userSavedPages.length}`);
+    if (migratedFiles.length > 0) {
+        info(`  synthesiss/ migrated: ${migratedFiles.length}`);
+    }
+    if (ingestErrors > 0) {
+        info(`  Ingest errors:        ${c.red(String(ingestErrors))}`);
+    }
+    info(`  ─────────────────────────────────────────────\n`);
+    if (ingestErrors > 0)
+        process.exit(1);
+}

package/dist/commands/ui.js

@@ -3,7 +3,7 @@
  * docuflow ui / docuflow start
  *
  * Starts the DocuFlow web interface — a single Express server on port 48821 that serves:
- *   • All /api/* routes (projects, wiki, health, activity, ask, search)
+ *   • All /api/* routes (projects, wiki, health, activity, ask, search, sync, init, watch)
  *   • Static Vite build from ui-dist/ (bundled with this CLI package)
  *   • SPA fallback — any non-API, non-asset route returns index.html
  *
@@ -23,6 +23,8 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const express_1 = __importDefault(require("express"));
 const cors_1 = __importDefault(require("cors"));
+const init_1 = require("./init");
+const watch_1 = require("./watch");
 function loadTool(file, exportName) {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     return require(`@doquflow/server/dist/tools/${file}`)[exportName];
@@ -203,6 +205,8 @@ async function run(opts = {}) {
     const queryWikiTool = loadTool('query-wiki', 'queryWiki');
     const wikiSearchTool = loadTool('wiki-search', 'wikiSearch');
     const buildGraphTool = loadTool('build-graph', 'buildGraph');
+    const ingestSourceTool = loadTool('ingest-source', 'ingestSource');
+    const updateIndexTool = loadTool('update-index', 'updateIndex');
     // ── 3. Express app ──────────────────────────────────────────────────────
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
@@ -359,6 +363,157 @@ async function run(opts = {}) {
             return res.status(500).json({ error: e.message });
         }
     });
+    // ── Sync: ingest all sources → rebuild index → lint ──────────────────────
+    app.post('/api/sync', async (req, res) => {
+        const { path: projectPath } = req.body;
+        if (!projectPath)
+            return res.status(400).json({ error: 'path required' });
+        const docuDir = node_path_1.default.join(projectPath, '.docuflow');
+        const sourcesDir = node_path_1.default.join(docuDir, 'sources');
+        if (!node_fs_1.default.existsSync(docuDir)) {
+            return res.status(400).json({ error: '.docuflow not found — run init first' });
+        }
+        try {
+            // Collect source files
+            let sourceFiles = [];
+            try {
+                sourceFiles = (await promises_1.default.readdir(sourcesDir)).filter(f => f.endsWith('.md'));
+            }
+            catch { /* sources/ may not exist yet */ }
+            // Ingest each source file
+            let pagesCreated = 0;
+            const errors = [];
+            for (const filename of sourceFiles) {
+                try {
+                    const r = await ingestSourceTool({ project_path: projectPath, source_filename: filename });
+                    pagesCreated += r.pages_created?.length ?? 0;
+                }
+                catch (e) {
+                    errors.push(`${filename}: ${e.message}`);
+                }
+            }
+            // Rebuild index and lint — wiki dir may be empty on a fresh/blank project
+            let health_score = 0;
+            try {
+                await updateIndexTool({ project_path: projectPath });
+                const lint = await lintWikiTool({ project_path: projectPath });
+                health_score = lint.health_score ?? 0;
+            }
+            catch { /* empty wiki dir — health_score stays 0 */ }
+            return res.json({
+                sources_processed: sourceFiles.length,
+                pages_created: pagesCreated,
+                health_score,
+                errors,
+            });
+        }
+        catch (e) {
+            return res.status(500).json({ error: e.message });
+        }
+    });
+    // ── Init: create .docuflow/ structure and register project ────────────────
+    app.post('/api/init', async (req, res) => {
+        const { path: projectPath } = req.body;
+        if (!projectPath)
+            return res.status(400).json({ error: 'path required' });
+        if (!node_fs_1.default.existsSync(projectPath)) {
+            return res.status(400).json({ error: 'path does not exist' });
+        }
+        try {
+            const result = await (0, init_1.runInit)(projectPath);
+            return res.json(result);
+        }
+        catch (e) {
+            return res.status(500).json({ error: e.message });
+        }
+    });
+    // ── Watch daemon status / stop / start ────────────────────────────────────
+    app.get('/api/watch/status', async (req, res) => {
+        const projectPath = req.query.path;
+        if (!projectPath)
+            return res.status(400).json({ error: 'path required' });
+        try {
+            const data = await (0, watch_1.readPidFile)(projectPath);
+            if (!data)
+                return res.json({ running: false });
+            const alive = (0, watch_1.isProcessAlive)(data.pid);
+            if (!alive)
+                return res.json({ running: false });
+            const uptimeMs = Date.now() - new Date(data.started_at).getTime();
+            const uptimeMin = Math.floor(uptimeMs / 60_000);
+            return res.json({
+                running: true,
+                pid: data.pid,
+                bridge: data.bridge,
+                started_at: data.started_at,
+                uptime: uptimeMin < 60 ? `${uptimeMin}m` : `${Math.floor(uptimeMin / 60)}h ${uptimeMin % 60}m`,
+            });
+        }
+        catch (e) {
+            return res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/api/watch/stop', async (req, res) => {
+        const { path: projectPath } = req.body;
+        if (!projectPath)
+            return res.status(400).json({ error: 'path required' });
+        try {
+            const data = await (0, watch_1.readPidFile)(projectPath);
+            if (!data || !(0, watch_1.isProcessAlive)(data.pid)) {
+                return res.json({ ok: true, message: 'Daemon not running' });
+            }
+            process.kill(data.pid, 'SIGTERM');
+            // Remove stale PID file — daemon will also try to clean it up on exit
+            setTimeout(async () => {
+                try {
+                    await promises_1.default.unlink((0, watch_1.getPidFilePath)(projectPath));
+                }
+                catch { /* already removed */ }
+            }, 2000);
+            return res.json({ ok: true, message: `Stopped watch daemon (PID ${data.pid})` });
+        }
+        catch (e) {
+            return res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/api/watch/start', async (req, res) => {
+        const { path: projectPath } = req.body;
+        if (!projectPath)
+            return res.status(400).json({ error: 'path required' });
+        if (!node_fs_1.default.existsSync(projectPath)) {
+            return res.status(400).json({ error: 'path does not exist' });
+        }
+        if (!node_fs_1.default.existsSync(node_path_1.default.join(projectPath, '.docuflow'))) {
+            return res.status(400).json({ error: '.docuflow not found — run init first' });
+        }
+        try {
+            // Check if already running
+            const existing = await (0, watch_1.readPidFile)(projectPath);
+            if (existing && (0, watch_1.isProcessAlive)(existing.pid)) {
+                return res.json({ ok: true, message: 'Watch daemon already running', pid: existing.pid });
+            }
+            // require.resolve fails in compiled ESM dist/ — fall back to the running entry point
+            let cliBin;
+            try {
+                cliBin = require.resolve('./index')
+                    .replace(/\.ts$/, '.js')
+                    .replace('/src/', '/dist/');
+            }
+            catch {
+                cliBin = process.argv[1];
+            }
+            const child = (0, node_child_process_1.spawn)(process.execPath, [cliBin, 'watch'], {
+                cwd: projectPath,
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+            return res.json({ ok: true, message: 'Watch daemon spawned' });
+        }
+        catch (e) {
+            return res.status(500).json({ error: e.message });
+        }
+    });
     // ── Static UI (must come after all /api/* routes) ─────────────────────
     app.use(express_1.default.static(uiDist));
     // SPA fallback — any unmatched route returns index.html so React Router

package/dist/index.js

@@ -130,6 +130,23 @@ else if (cmd === 'update' || cmd === 'upgrade') {
         check: hasFlag('--check'),
         force: hasFlag('--force'),
     }));
+    // ── recent — show recent DevLoop task activity ────────────────────────────────
+}
+else if (cmd === 'recent') {
+    const daysFlag = getFlagValue('--days');
+    const fmt = getFlagValue('--format');
+    Promise.resolve().then(() => __importStar(require('./commands/recent'))).then(m => m.run({
+        days: daysFlag ? (isNaN(parseInt(daysFlag, 10)) ? 7 : parseInt(daysFlag, 10)) : 7,
+        format: fmt ?? 'table',
+    }));
+    // ── rewiki — re-ingest all sources with new extractor rules ──────────────────
+}
+else if (cmd === 'rewiki') {
+    Promise.resolve().then(() => __importStar(require('./commands/rewiki'))).then(m => m.run({
+        dryRun: hasFlag('--dry-run'),
+        noBackup: hasFlag('--no-backup'),
+        quiet: hasFlag('--quiet', '-q'),
+    }));
 }
 else {
     console.log(`DocuFlow v${version}`);
@@ -175,6 +192,11 @@ else {
     console.log('  update --check          Check whether a newer version is published (no install)');
     console.log('  update --force          Reinstall even when already on the latest version');
     console.log('  upgrade                 Alias for "update"');
+    console.log('  recent [--days N] [--format table|md]   Show recent DevLoop task activity');
+    console.log('  rewiki                  Re-ingest all sources with current extractor rules (migration)');
+    console.log('  rewiki --dry-run        Preview what would change without writing anything');
+    console.log('  rewiki --no-backup      Skip wiki backup (faster, irreversible)');
+    console.log('  rewiki --quiet          Suppress output (CI mode)');
     console.log('');
     console.log('Options:');
     console.log('  --version, -v                    Print version number');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doquflow/cli",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "CLI for setting up Docuflow in your project",
   "author": "Docuflow <hello@doquflows.dev>",
   "license": "MIT",
@@ -31,7 +31,7 @@
     "build": "tsc && node -e \"const fs=require('fs'),p=require('path'),src=p.join(process.cwd(),'../ui/dist'),dst=p.join(process.cwd(),'ui-dist');if(!fs.existsSync(src)){console.log('Warning: packages/ui/dist not found — run npm run build:ui first');process.exit(0)}fs.mkdirSync(dst,{recursive:true});fs.cpSync(src,dst,{recursive:true,force:true});console.log('  ✓ ui-dist synced from packages/ui/dist ('+(fs.readdirSync(dst).length)+' files at root)')\""
   },
   "dependencies": {
-    "@doquflow/server": "1.5.1",
+    "@doquflow/server": "1.6.0",
     "cors": "^2.8.5",
     "express": "^4.19.2"
   },