@chenguangyao/devflow-kit 0.1.43

package/src/cli/commands/knowledge.js

@@ -0,0 +1,523 @@
+'use strict';
+const fs = require('fs/promises');
+const fsSync = require('fs');
+const path = require('path');
+const readline = require('readline');
+const log = require('../../utils/log.js');
+const paths = require('../../core/paths.js');
+const change = require('../../core/change.js');
+const templates = require('../../templates/index.js');
+const helpers = require('./_helpers.js');
+const depositMod = require('../../knowledge/deposit.js');
+const mrMod = require('../../knowledge/mr.js');
+const sync = require('../../knowledge/sync.js');
+const migrate = require('../../knowledge/migrate.js');
+const query = require('../../knowledge/query.js');
+const loader = require('../../providers/loader.js');
+
+async function run({ sub, positional = [], flags = {}, cwd }) {
+  const root = cwd || process.cwd();
+  const action = sub || positional[0];
+  switch (action) {
+    case 'init':     return initKb(root, flags);
+    case 'query':    return runQuery(root, positional, flags);
+    case 'deposit':  return runDeposit(root, flags);
+    case 'sync':     return runSync(root, flags);
+    case 'reparse':  return runReparse(root, flags);
+    case 'validate': return validate(root, flags);
+    case 'migrate':  return runMigrate(root, flags);
+    case undefined:
+    case 'help':     return help();
+    default:
+      log.error(`unknown subcommand: ${action}`);
+      help();
+      process.exitCode = 2;
+  }
+}
+
+async function initKb(root, _flags) {
+  const dir = paths.workspaceKnowledgeRoot();
+  if (!fsSync.existsSync(dir)) {
+    log.error('workspace knowledge/ not present. run "devflow init" first.');
+    process.exitCode = 1; return;
+  }
+  log.ok(`workspace knowledge skeleton present: ${dir}`);
+}
+
+async function runQuery(root, args, flags) {
+  const q = args.join(' ').trim();
+  if (!q) { log.error('usage: devflow knowledge query "<keywords>"'); process.exitCode = 2; return; }
+  const keywords = q.split(/\s+/).filter(Boolean);
+  const slug = await helpers.resolveSlug(root, flags, []);
+  if (!slug) { process.exitCode = 1; return; }
+
+  const result = await query.query(root, { keywords, slug, k: parseInt(flags.k, 10) || 8, withRemote: !flags.localOnly });
+  // Pretty print to stdout.
+  log.info(`local hits: ${result.hits.length}, remote hits: ${result.remoteHits.length}`);
+  for (const h of result.hits) {
+    log.raw(`  ${h.score.toFixed(2).padStart(5)}  [${h.source || 'knowledge'}] ${h.path}${h.line > 0 ? ':' + h.line : ''}`);
+    if (h.snippet) log.dim('         ' + h.snippet);
+  }
+
+  // Persist into changes/<slug>/knowledge.md
+  const tpl = await templates.load('knowledge.md');
+  const lines = [];
+  lines.push('## 命中(本地)');
+  lines.push('');
+  for (const h of result.hits) {
+    lines.push(`- (score=${h.score}) **${h.source || 'knowledge'}** [${h.path}](${path.posix.join('..', '..', '..', h.path.split(path.sep).join('/'))})${h.line > 0 ? ' L' + h.line : ''}`);
+    if (h.snippet) lines.push(`  > ${h.snippet}`);
+  }
+  if (result.remoteHits.length) {
+    lines.push('');
+    lines.push('## 命中(远程)');
+    lines.push('');
+    for (const h of result.remoteHits) {
+      lines.push(`- (score=${h.score ?? '?'}) ${h.title || h.uuid}${h.url ? ` <${h.url}>` : ''}`);
+      if (h.snippet) lines.push(`  > ${h.snippet}`);
+    }
+  }
+  const body = templates.render(tpl, {
+    slug, title: slug, query: q, sources: result.remoteHits.length ? 'local + remote' : 'local',
+    date: new Date().toISOString(),
+  }) + '\n' + lines.join('\n') + '\n';
+  await change.writeArtifact(root, slug, 'knowledge.md', body);
+  log.ok(`changes/${slug}/knowledge.md written`);
+}
+
+async function runDeposit(root, flags) {
+  const slug = await helpers.resolveSlug(root, flags, []);
+  if (!slug) { process.exitCode = 1; return; }
+  const dryRun  = !!(flags.dryRun || flags['dry-run']);
+  const autoYes = !!(flags.yes || flags.y);
+  const mrMode  = !!(flags.mr || flags.MR);
+
+  // Step 0 (MR mode): detect kb-git provider and list external KB categories.
+  // Mirrors arb_knowledge.py ensure + list-tags before deposit.
+  // NOTE: load by name 'kb.git' (or find first kb provider with driver=git) to avoid
+  //       being shadowed by kb.weknora which shares the same type='kb'.
+  let kbGitProvider = null;
+  let externalTags  = null;
+  if (mrMode) {
+    try {
+      const all = await loader.listConfigured(root);
+      const gitEntry = all.find((e) => e.type === 'kb' && e.driver === 'git');
+      if (gitEntry) {
+        const p = await loader.load(root, { name: gitEntry.name });
+        kbGitProvider = p;
+        log.info(`检测到外部知识库仓库 (${gitEntry.name})，正在 ensure clone…`);
+        await p.ensure();
+        externalTags = await p.listTags();
+        printExternalTags(externalTags);
+      }
+    } catch (e) { log.dim(`kb-git not available: ${e.message}`); /* fall through to local mode */ }
+  }
+
+  // Phase 1: compute plan (always dry-run first).
+  // --mr implies force: skip sha256 noop check so existing files are always re-written and committed.
+  const plan = await depositMod.deposit(root, { slug, dryRun: true, force: mrMode });
+  if (!plan.length) {
+    log.warn('nothing to deposit (no knowledge/ files, design.md, or incident reports?)');
+    return;
+  }
+
+  // Phase 2: render plan table.
+  const actionable = plan.filter((p) => p.action !== 'noop');
+  const noops      = plan.filter((p) => p.action === 'noop');
+  printDepositTable(plan, { mrMode, hasExternal: !!kbGitProvider });
+
+  if (dryRun) {
+    if (mrMode) {
+      if (kbGitProvider) {
+        const mrDry = await kbGitProvider.depositAndCreateMr(root, { items: actionable, slug, dryRun: true });
+        log.info(`[dry-run] 外部仓库 MR mode: ${mrDry.message}`);
+      } else {
+        const mrDry = await mrMod.createKnowledgePr(root, { slug, items: actionable, dryRun: true });
+        log.info(`[dry-run] MR mode: ${mrDry.message || `branch ${mrDry.branch} → ${mrDry.baseBranch}`}`);
+      }
+    }
+    log.ok(`[dry-run] ${actionable.length} item(s) would be written, ${noops.length} unchanged.`);
+    return;
+  }
+  if (!actionable.length) {
+    log.ok('all items unchanged (noop).');
+    return;
+  }
+
+  // Phase 3: confirm (skip if --yes).
+  let selected = actionable;
+  if (!autoYes) {
+    selected = await interactiveConfirm(actionable, { mrMode });
+    if (!selected) { log.warn('deposit skipped.'); return; }
+  }
+
+  // Phase 4: write knowledge files locally.
+  await depositMod.executeItems(root, selected, slug);
+  const created = selected.filter((p) => p.action === 'create').length;
+  const updated = selected.filter((p) => p.action === 'update').length;
+  log.ok(`deposit done: create=${created} update=${updated} (${noops.length} unchanged)`);
+
+  // Phase 5 (MR mode): create branch + PR/MR.
+  if (mrMode) {
+    log.info('creating knowledge branch + PR/MR…');
+    try {
+      let mr;
+      if (kbGitProvider) {
+        // External repo mode (arb-knowledge pattern).
+        mr = await kbGitProvider.depositAndCreateMr(root, { items: selected, slug });
+        mr.mode = 'external';
+      } else {
+        mr = await mrMod.createKnowledgePr(root, { slug, items: selected });
+      }
+      _printMrResult(mr);
+    } catch (e) {
+      log.error(`MR creation failed: ${e.message}`);
+      log.dim('  knowledge files were written locally — commit and push manually if needed.');
+      process.exitCode = 1;
+    }
+  }
+}
+
+function _printMrResult(mr) {
+  const repoDesc = mr.mode === 'external' ? '外部知识库仓库' : '当前仓库';
+  switch (mr.status) {
+    case 'created':
+      log.ok(`PR/MR created (${repoDesc})`);
+      if (mr.url) log.raw(`  MR: ${mr.url}`);
+      if (mr.branch) log.dim(`  branch: ${mr.branch}${mr.baseBranch ? '  →  ' + mr.baseBranch : ''}`);
+      if (mr.commit_hash) log.dim(`  commit: ${mr.commit_hash.slice(0, 8)}`);
+      log.raw('');
+      log.info('下一步：');
+      log.raw('  • 请在 Git 平台上完成 MR Review（内容审核 + 合并）');
+      if (mr.mode === 'external') {
+        log.raw('  • 合并后 CI 自动同步到 WeKnora（新增条目 ID 由 CI 回写至 .meta.json）');
+      }
+      log.raw('  • 本 skill 到此结束，不等待 MR 合并');
+      break;
+    case 'pushed_no_mr':
+      log.warn(`branch pushed (${repoDesc}) but PR/MR creation failed: ${mr.error}`);
+      log.dim(`  branch ${mr.branch} pushed to origin — create the MR manually.`);
+      break;
+    case 'no_changes':
+      log.warn('no knowledge changes detected by git after deposit (already committed?)');
+      break;
+    case 'workspace_requires_kb_git':
+      log.error(mr.error || 'workspace knowledge MR requires kb.git provider');
+      log.dim('  请配置 kb.git，让 MR 提到外部知识库项目。');
+      process.exitCode = 1;
+      break;
+    default:
+      log.info(`status: ${mr.status}`);
+  }
+}
+
+/**
+ * Print the external KB repo's category list (mirrors arb_knowledge.py list-tags output).
+ * Helps AI / user know which directories exist and where to classify new knowledge.
+ */
+function printExternalTags(tags) {
+  if (!tags || !tags.length) {
+    log.dim('  (外部仓库暂无分类目录)');
+    return;
+  }
+  log.raw('');
+  log.info('外部知识库分类目录：');
+  log.raw(`  ${'分类'.padEnd(20)} ${'文档数'.padEnd(6)} 文档列表`);
+  log.raw(`  ${'─'.repeat(70)}`);
+  for (const t of tags) {
+    const name     = (t.tag_name || path.basename(t.directory)).slice(0, 20);
+    const count    = String(t.document_count || 0).padEnd(6);
+    const docList  = (t.documents || []).slice(0, 4).join(', ');
+    const more     = (t.documents || []).length > 4 ? ` …+${t.documents.length - 4}` : '';
+    log.raw(`  ${name.padEnd(20)} ${count} ${docList}${more}`);
+  }
+  log.raw('');
+}
+
+function printDepositTable(plan, { mrMode = false, hasExternal = false } = {}) {
+  const COL = { idx: 3, op: 2, cat: 22, target: 44, source: 18 };
+  const hr = '─'.repeat(COL.idx + COL.op + COL.cat + COL.target + COL.source + 8);
+  log.raw('');
+  log.raw(`  ${'#'.padEnd(COL.idx)} ${'op'.padEnd(COL.op)} ${'分类'.padEnd(COL.cat)} ${'知识文件'.padEnd(COL.target)} 来源`);
+  log.raw(`  ${hr}`);
+  let idx = 0;
+  for (const p of plan) {
+    if (p.action === 'noop') continue;
+    idx++;
+    const op  = p.action === 'create' ? 'A' : 'M';
+    const cat = `${p.domain}/${p.category}`;
+    const catStr = cat.length > COL.cat ? '…' + cat.slice(-(COL.cat - 1)) : cat;
+    const tgt = p.filename.length > COL.target ? '…' + p.filename.slice(-(COL.target - 1)) : p.filename;
+    const src = p.source.length > COL.source ? p.source.slice(0, COL.source - 1) + '…' : p.source;
+    log.raw(`  ${String(idx).padEnd(COL.idx)} ${op.padEnd(COL.op)} ${catStr.padEnd(COL.cat)} ${tgt.padEnd(COL.target)} ${src}`);
+  }
+  if (plan.some((p) => p.action === 'noop')) {
+    const nCount = plan.filter((p) => p.action === 'noop').length;
+    log.raw(`  ${'·'.padEnd(COL.idx + COL.op + 1)} (${nCount} 项未变更，已跳过)`);
+  }
+  log.raw('');
+
+  const total = plan.filter((p) => p.action !== 'noop').length;
+  log.dim(`  共 ${total} 个知识文档将被写入（每个 change 通常生成 2-3 个）`);
+  log.raw('');
+
+  if (mrMode) {
+    if (hasExternal) {
+      log.info('MR 模式 (外部仓库)：确认后写入外部知识库仓库 → 建分支 → 创建 MR。');
+      log.info('合并后 CI 自动同步到 WeKnora，新增文件 knowledge_id 由 CI 回写。');
+    } else {
+      log.info('MR 模式：确认后自动建分支 + 创建 PR/MR，reviewer 在 Git 平台 review 后合并。');
+    }
+    log.raw('');
+  }
+}
+
+/**
+ * Interactive confirmation prompt.
+ * Returns the confirmed subset of items, or null if skipped.
+ */
+async function interactiveConfirm(actionable, { mrMode = false } = {}) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise((res) => rl.question(q, res));
+
+  log.raw('  确认沉淀方式：');
+  log.raw(`    回车          = 全部确认${mrMode ? ' → 建分支 + 创建 PR/MR' : ''}`);
+  log.raw('    1,3,5         = 仅确认指定序号');
+  log.raw('    s / skip      = 跳过不写入');
+  log.raw('');
+
+  let answer;
+  try {
+    answer = (await ask('  > ')).trim();
+  } finally {
+    rl.close();
+  }
+
+  if (!answer || answer.toLowerCase() === 'all') {
+    return actionable;
+  }
+  if (answer.toLowerCase() === 's' || answer.toLowerCase() === 'skip') {
+    return null;
+  }
+
+  // Parse "1,3,5" or "1 3 5"
+  const indices = new Set(
+    answer.split(/[,\s]+/)
+      .map((s) => parseInt(s, 10) - 1)
+      .filter((i) => !isNaN(i) && i >= 0 && i < actionable.length),
+  );
+  if (!indices.size) {
+    log.warn('无效输入，跳过 deposit。');
+    return null;
+  }
+  return actionable.filter((_, i) => indices.has(i));
+}
+
+async function runSync(root, flags) {
+  const dryRun = !!(flags.dryRun || flags['dry-run']);
+  const force  = !!(flags.force  || flags.f);
+  const all    = !!flags.all;
+  const providerName = await resolveSyncProviderName(root, flags);
+  if (providerName === false) { process.exitCode = 1; return; }
+  let slug = null;
+  if (!all) {
+    slug = await helpers.resolveSlug(root, flags, []);
+    if (!slug) { process.exitCode = 1; return; }
+  }
+  if (force) log.warn('--force: clearing stored UUIDs, all files will be re-uploaded');
+  let result;
+  try {
+    result = await sync.sync(root, { dryRun, force, providerName, slug });
+  } catch (e) {
+    log.error(e.message);
+    process.exitCode = 1; return;
+  }
+  for (const a of result.actions) {
+    log.raw(`  ${a.kind.padEnd(7)} ${a.dir}/${a.name}${a.uuid ? '  (uuid=' + a.uuid + ')' : ''}${a.error ? '  !! ' + a.error : ''}`);
+  }
+  const s = result.summary;
+  const tagPart = s.tag ? ` tag=${s.tag}` : '';
+  if (!s.scanned && result.actions.length === 0) {
+    if (slug) {
+      log.warn(`no knowledge markdown found for current change "${slug}"; nothing was synced.`);
+      log.dim(`  checked: ${paths.workspaceKnowledgeDir(slug)}`);
+      log.dim(`           ${path.join(paths.devflowDir(root), 'changes', slug, 'knowledge')} (legacy)`);
+    } else {
+      log.warn('no knowledge markdown found under workspace knowledge roots; nothing was synced.');
+      log.dim(`  checked: ${paths.workspaceKnowledgeRoot()}`);
+      log.dim(`           ${path.join(paths.changesDir(root), '<slug>', 'knowledge')}`);
+      log.dim(`           ${paths.knowledgeDir(root)} (legacy)`);
+    }
+    return;
+  }
+  const scope = slug ? ` change=${slug}` : ' all';
+  log.ok(`${dryRun ? '[dry-run] ' : ''}scope=${scope} create=${s.create} update=${s.update} delete=${s.delete} noop=${s.noop}${tagPart}`);
+}
+
+async function resolveSyncProviderName(root, flags) {
+  if (flags.provider) return flags.provider;
+  const configured = await loader.listConfigured(root);
+  const kbProviders = configured.filter((p) => p.type === 'kb');
+  if (kbProviders.length === 0) return undefined;
+  if (kbProviders.length === 1) return kbProviders[0].name;
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    log.error('multiple kb providers configured; specify one with --provider=<name>.');
+    for (const p of kbProviders) log.dim(`  - ${p.name} (${p.driver}, ${p.source})`);
+    return false;
+  }
+
+  log.info('检测到多个知识库配置，请选择本次同步的业务线：');
+  kbProviders.forEach((p, i) => {
+    log.raw(`  ${i + 1}. ${p.name} (${p.driver}, ${p.source})`);
+  });
+  const answer = await ask('选择编号> ');
+  const idx = Number.parseInt(String(answer).trim(), 10);
+  if (!Number.isInteger(idx) || idx < 1 || idx > kbProviders.length) {
+    log.error('invalid provider selection.');
+    return false;
+  }
+  return kbProviders[idx - 1].name;
+}
+
+function ask(prompt) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => rl.question(prompt, (answer) => {
+    rl.close();
+    resolve(answer);
+  }));
+}
+
+/**
+ * devflow knowledge reparse
+ * Trigger re-parse/re-embedding for all knowledge items stored in .meta.json.
+ * Useful when WeKnora shows "暂存内容未参与检索" after configuring an embedding model.
+ */
+async function runReparse(root, flags) {
+  const { knowledgeRoots, readMeta } = require('../../knowledge/registry.js');
+  const roots = knowledgeRoots(root);
+  if (!roots.length) {
+    log.error('no workspace knowledge/ dir found');
+    process.exitCode = 1; return;
+  }
+
+  let provider;
+  try {
+    provider = await loader.load(root, flags.provider ? { name: flags.provider } : { type: 'kb' });
+  } catch (e) {
+    log.error(`failed to load kb provider: ${e.message}`);
+    process.exitCode = 1; return;
+  }
+  if (typeof provider.reparse !== 'function') {
+    log.error('current kb provider does not support reparse (only kb-weknora does)');
+    process.exitCode = 1; return;
+  }
+
+  // Collect all UUIDs from .meta.json files
+  const uuids = [];
+  const walk = async (dir) => {
+    const entries = await require('fs/promises').readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const full = require('path').join(dir, e.name);
+      if (e.isDirectory()) { await walk(full); continue; }
+      if (e.name !== '.meta.json') continue;
+      const meta = await readMeta(dir).catch(() => null);
+      if (!meta || !meta.files) continue;
+      for (const [name, info] of Object.entries(meta.files)) {
+        if (info.uuid) uuids.push({ uuid: info.uuid, name });
+      }
+    }
+  };
+  for (const kbDir of roots) await walk(kbDir);
+
+  if (!uuids.length) {
+    log.warn('no synced items found in .meta.json — run "devflow knowledge sync" first');
+    return;
+  }
+
+  log.info(`triggering reparse for ${uuids.length} item(s)...`);
+  let ok = 0, fail = 0;
+  for (const { uuid, name } of uuids) {
+    try {
+      await provider.reparse(uuid);
+      log.raw(`  ✓ ${name}  (${uuid})`);
+      ok++;
+    } catch (e) {
+      log.raw(`  ✗ ${name}  (${uuid})  ${e.message}`);
+      fail++;
+    }
+  }
+  log.ok(`reparse triggered: ${ok} ok, ${fail} failed`);
+  if (ok) log.dim('WeKnora will embed asynchronously — check status in a few minutes.');
+}
+
+async function validate(root, _flags) {
+  const { knowledgeRoots } = require('../../knowledge/registry.js');
+  const roots = knowledgeRoots(root);
+  if (!roots.length) { log.error('no workspace knowledge/ dir'); process.exitCode = 1; return; }
+  let issues = 0;
+  for (const dir of roots) {
+    for (const cat of await listCategories(dir)) {
+      const meta = path.join(cat, '.meta.json');
+      if (!fsSync.existsSync(meta)) {
+        log.warn(`missing .meta.json in ${cat}`);
+        issues++; continue;
+      }
+      try { JSON.parse(await fs.readFile(meta, 'utf8')); }
+      catch { log.error(`invalid .meta.json: ${meta}`); issues++; }
+    }
+  }
+  if (issues === 0) log.ok('knowledge: meta consistency ok');
+  else process.exitCode = 1;
+}
+
+async function runMigrate(root, flags) {
+  const from = flags.from || 'arb-7';
+  const to = flags.to || 'improved-9';
+  const dryRun = !!(flags.dryRun || flags['dry-run']);
+  let report;
+  try { report = await migrate.migrate(root, { from, to, dryRun }); }
+  catch (e) { log.error(e.message); process.exitCode = 1; return; }
+  log.info(`migrate ${from} -> ${to} (dryRun=${dryRun})`);
+  log.raw(`  moved:     ${report.moved}`);
+  log.raw(`  skipped:   ${report.skipped}`);
+  log.raw(`  conflicts: ${report.conflicts}`);
+  if (report.details.conflicts.length) {
+    log.warn('conflicts (no overwrite):');
+    for (const c of report.details.conflicts) log.raw(`    ${c.src} -> ${c.dst}`);
+  }
+  if (!dryRun) log.ok('report: devflow/knowledge/.migration.log');
+}
+
+async function listCategories(dir) {
+  const out = [];
+  const domains = await fs.readdir(dir, { withFileTypes: true });
+  for (const d of domains) {
+    if (!d.isDirectory()) continue;
+    const ds = path.join(dir, d.name);
+    const cats = await fs.readdir(ds, { withFileTypes: true });
+    for (const c of cats) if (c.isDirectory()) out.push(path.join(ds, c.name));
+  }
+  return out;
+}
+
+function help() {
+  log.raw(`devflow knowledge <init|query|deposit|sync|validate|migrate> [opts]
+
+  init                            ensure skeleton (created by devflow init)
+  query "<kw1> <kw2>"             local + remote search; writes changes/<slug>/knowledge.md
+                                  flags: --k=8 --local-only --slug=<slug>
+  deposit                         publish workspace knowledge/design/incident reports → knowledge/
+                                  shows plan + interactive confirm (--yes to skip, --dry-run to preview)
+                                  flags: --slug=<slug> --dry-run --yes --mr
+  deposit --mr                    after writing, auto-create branch + PR/MR for reviewer review
+                                  (needs gh / glab CLI, or a configured vcs provider)
+  sync                            push current change knowledge/ to kb provider (sha256 incremental)
+                                  flags: --slug=<slug> --provider=<name> --dry-run --all
+  validate                        check .meta.json consistency
+  migrate                         reshape arb-7 → improved-9 layout
+                                  flags: --from=arb-7 --to=improved-9 --dry-run
+`);
+}
+
+module.exports = { run };

package/src/cli/commands/logs.js

@@ -0,0 +1,43 @@
+'use strict';
+const log = require('../../utils/log.js');
+const providers = require('../../providers/loader.js');
+
+async function run({ sub, flags = {}, positional = [], cwd } = {}) {
+  const root = cwd || process.cwd();
+  const action = sub || positional[0] || 'query';
+  if (action !== 'query') {
+    log.error('usage: devflow logs query [--provider=<name>] [--query=...] [--trace-id=...] [--request-id=...] [--since=15m] [--limit=50] [--dry-run]');
+    process.exitCode = 2;
+    return;
+  }
+  const provider = await providers.load(root, flags.provider ? { name: flags.provider } : { type: 'observability' });
+  if (typeof provider.query !== 'function') {
+    log.error(`provider ${provider.name || provider.driver} does not support log query`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = await provider.query({
+    query: flags.query || positional[1] || '',
+    traceId: flags.traceId || flags['trace-id'] || '',
+    requestId: flags.requestId || flags['request-id'] || '',
+    since: flags.since || '15m',
+    limit: Number(flags.limit || 50),
+    dryRun: flags.dryRun === true || flags['dry-run'] === true,
+  });
+  printResult(result);
+  if (result.status === 'fail') process.exitCode = 1;
+}
+
+function printResult(result) {
+  log.ok(`logs query: ${result.status}`);
+  if (result.command) log.dim(`command: ${result.command}`);
+  if (result.request) {
+    log.raw(JSON.stringify(result.request, null, 2));
+  }
+  if (result.output) log.raw(result.output);
+  if (Array.isArray(result.items) && result.items.length) {
+    for (const item of result.items) log.raw(typeof item === 'string' ? item : JSON.stringify(item));
+  }
+}
+
+module.exports = { run, _internals: { printResult } };