draftgo-cli 1.0.4

package/src/commands/status.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const log = require('../logger');
+const { all } = require('../targets');
+const { readInstalledVersion, getPackageVersion } = require('../skill');
+const { loadProjectConfig } = require('../projectConfig');
+const { TOOL_NAMES, openToolSession, callStructured } = require('../mcp/tools');
+const { parseTimeout } = require('../timeout');
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function findField(value, keys) {
+  let candidates = [asObject(value)];
+  for (let depth = 0; depth < 4; depth += 1) {
+    const next = [];
+    for (const candidate of candidates) {
+      for (const key of keys) if (candidate[key] != null) return candidate[key];
+      for (const key of ['operation_registry', 'registry', 'response', 'data', 'value']) {
+        const nested = asObject(candidate[key]);
+        if (Object.keys(nested).length) next.push(nested);
+      }
+    }
+    candidates = next;
+  }
+  return null;
+}
+
+async function connectionDiagnostic(projectDir, options = {}) {
+  let config;
+  try {
+    config = loadProjectConfig(projectDir);
+  } catch (error) {
+    return { health: 'not_configured', connected: false, error: error.message };
+  }
+
+  const diagnostic = { health: 'unhealthy', connected: false, server: config.server };
+  try {
+    const session = await openToolSession(config, [TOOL_NAMES.apiSearch], { timeoutMs: options.timeoutMs });
+    const catalog = await callStructured(session, TOOL_NAMES.apiSearch, {
+      query: 'system', limit: 1,
+    }, { timeoutMs: options.timeoutMs });
+    diagnostic.connected = true;
+    diagnostic.server_version = asObject(session.initialized.serverInfo).version || null;
+    diagnostic.protocol_version = session.client.protocolVersion || null;
+    diagnostic.registry_revision = findField(catalog, ['registry_revision']) || null;
+    diagnostic.health = 'healthy';
+    return diagnostic;
+  } catch (error) {
+    diagnostic.error = error && error.message || String(error);
+    return diagnostic;
+  }
+}
+
+async function status(projectDir, _positional = [], flags = {}) {
+  const targets = all.map((target) => {
+    const value = target.status(projectDir);
+    return { name: target.name, display_name: target.displayName, installed: value.installed === true };
+  });
+  const connection = await connectionDiagnostic(projectDir, { timeoutMs: parseTimeout(flags.timeout) });
+  const result = {
+    project_dir: projectDir,
+    cli_version: getPackageVersion(),
+    skill_version: readInstalledVersion(projectDir) || null,
+    connection,
+    targets,
+  };
+  if (flags.output === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+
+  log.title('draftgo status');
+  log.info(`项目目录：${projectDir}`);
+  log.info(`CLI 版本：${result.cli_version}`);
+  log.info(`已装 skill 版本：${result.skill_version || '（未安装）'}`);
+  log.info(`服务端：${connection.server || '（未连接）'}`);
+  if (connection.health === 'healthy') {
+    log.ok(`连接健康：healthy${connection.server_version ? `（server ${connection.server_version}）` : ''}`);
+    log.info(`Registry revision：${connection.registry_revision || '-'}`);
+  } else {
+    log.warn(`连接健康：${connection.health}`);
+    if (connection.error) log.dim(`  ${connection.error}`);
+  }
+
+  console.log('');
+  console.log('AI 工具入口：');
+  for (const target of targets) {
+    const mark = target.installed ? log.c.green('✓') : log.c.gray('·');
+    console.log(`  ${mark} ${target.name.padEnd(12)} ${target.display_name}`);
+  }
+  return 0;
+}
+
+module.exports = status;
+module.exports.findField = findField;
+module.exports.connectionDiagnostic = connectionDiagnostic;

package/src/commands/uninstall.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const log = require('../logger');
+const { all, resolveTargets } = require('../targets');
+const { removePath } = require('../fsx');
+const { dgDir } = require('../paths');
+
+async function uninstall(projectDir, positional, flags) {
+  log.title('draftgo uninstall');
+
+  let resolved = [];
+  let unknown = [];
+  if (positional.length === 0) {
+    log.err('Please specify a target, or use `draftgo uninstall all` to remove every target.');
+    log.dim(`  Supported targets: ${all.map((i) => i.name).join(', ')}`);
+    return 1;
+  }
+  if (positional.includes('all')) {
+    resolved = all.slice();
+  } else {
+    ({ resolved, unknown } = resolveTargets(positional));
+    if (unknown.length) {
+      log.err(`未知 target：${unknown.join(', ')}`);
+      return 1;
+    }
+  }
+
+  log.step('移除入口文件');
+  for (const t of resolved) {
+    try {
+      const removed = t.uninstall(projectDir);
+      if (removed) log.ok(`${t.displayName} 入口已移除`);
+      else log.dim(`${t.displayName} 入口不存在，跳过`);
+    } catch (e) {
+      log.err(`${t.displayName} 卸载失败：${e.message}`);
+    }
+  }
+
+  // Each AI-tool skill directory is self-contained, so per-target uninstall
+  // already wiped its content above. Only --purge nukes runtime data under
+  // .draftgo/ (config/worklog/lessons/cache etc.).
+  if (flags.purge) {
+    if (removePath(dgDir(projectDir))) {
+      log.warn('已使用 --purge：.draftgo/（含 config/worklog/lessons 等运行时数据）已删除。');
+    }
+  }
+
+  log.title('完成');
+  return 0;
+}
+
+module.exports = uninstall;

package/src/commands/update.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const log = require('../logger');
+const { all, resolveTargets } = require('../targets');
+const { ensureRuntime, writeInstalledVersion, readInstalledVersion, getPackageVersion } = require('../skill');
+
+function installedTargetsNotRefreshed(projectDir, refreshedTargets) {
+  const refreshed = new Set(refreshedTargets.map((target) => target.name));
+  return all.filter((target) =>
+    !refreshed.has(target.name) && target.status(projectDir).installed);
+}
+
+function targetInstalled(projectDir, target) {
+  return typeof target.status === 'function' && target.status(projectDir).installed === true;
+}
+
+function installedTargets(projectDir) {
+  return all.filter((target) => targetInstalled(projectDir, target));
+}
+
+async function update(projectDir, positional) {
+  log.title('draftgo update');
+
+  const prev = readInstalledVersion(projectDir);
+  log.info(`当前已装 skill：${prev || '未安装'}，CLI 版本：${getPackageVersion()}`);
+
+  // Implicit update and `update all` only refresh existing Skills. An explicit
+  // target is a deliberate request and may install that target when it is missing.
+  let resolved = [];
+  let unknown = [];
+
+  if (positional.length === 0 || positional.includes('all')) {
+    resolved = installedTargets(projectDir);
+    if (resolved.length === 0) {
+      log.warn('未检测到已安装的 DraftGo Skill，无可刷新内容。');
+      log.dim('  需要新增 AI 工具时，请使用 `draftgo init <target>`。');
+      return 0;
+    }
+    log.info(`刷新目标：${resolved.map((r) => r.displayName).join(', ')}`);
+  } else {
+    ({ resolved, unknown } = resolveTargets(positional));
+    if (unknown.length) {
+      log.err(`未知 target：${unknown.join(', ')}`);
+      return 1;
+    }
+  }
+
+  ensureRuntime(projectDir);
+  log.step('用 CLI 内置版本覆盖各 AI 工具 skill 目录');
+  const failures = [];
+  for (const t of resolved) {
+    try {
+      const r = t.install(projectDir, { force: true });
+      log.ok(`${t.displayName.padEnd(16)} → ${r.path}`);
+    } catch (e) {
+      log.err(`${t.displayName} 更新失败：${e.message}`);
+      failures.push(t.displayName);
+    }
+  }
+  if (failures.length) {
+    log.err(`更新未完成，失败目标：${failures.join(', ')}`);
+    return 1;
+  }
+  const staleInstalled = installedTargetsNotRefreshed(projectDir, resolved);
+  if (staleInstalled.length) {
+    log.dim(
+      `  未更新全局 skill 版本标记；尚有未刷新的已安装目标：${staleInstalled
+        .map((target) => target.displayName).join(', ')}`,
+    );
+  } else {
+    writeInstalledVersion(projectDir);
+  }
+
+  log.title('完成');
+  return 0;
+}
+
+module.exports = update;
+module.exports.installedTargetsNotRefreshed = installedTargetsNotRefreshed;

package/src/commands/verify.js

@@ -0,0 +1,188 @@
+'use strict';
+
+const log = require('../logger');
+const check = require('./check');
+const visualVerify = require('./visualVerify');
+const { canonicalResourceType } = require('../worktree/types');
+const fs = require('fs');
+const path = require('path');
+const parse5 = require('parse5');
+const { loadProjectConfig } = require('../projectConfig');
+const { loadManifest, getEntry, absolutePath } = require('../worktree/manifest');
+
+function mode(value, fallback, flag) {
+  const normalized = String(value == null ? fallback : value).toLowerCase();
+  if (!['always', 'never'].includes(normalized)) throw new Error(`${flag} must be always or never.`);
+  return normalized;
+}
+
+function resources(positional) {
+  if (!positional.length) return [];
+  const [rawType, ...ids] = positional;
+  if (!ids.length) throw new Error('Usage: draftgo verify [<pages|nav|docs> <id...>] [--url <url>]');
+  const resourceType = canonicalResourceType(rawType);
+  return ids.map((resourceId) => ({ resourceType, resourceId: String(resourceId) }));
+}
+
+function viewports(flags) {
+  const value = String(flags.viewport || '').toLowerCase();
+  if (!value) return [{
+    name: flags.width || flags.height ? 'custom' : 'desktop',
+    width: flags.width || 1440,
+    height: flags.height || 900,
+  }];
+  if (value === 'mobile') return [{ name: 'mobile', width: 390, height: 844 }];
+  if (value === 'desktop') return [{ name: 'desktop', width: 1440, height: 900 }];
+  if (value === 'both') return [
+    { name: 'mobile', width: 390, height: 844 },
+    { name: 'desktop', width: 1440, height: 900 },
+  ];
+  throw new Error('--viewport must be mobile, desktop, or both.');
+}
+
+function visualRequest(flags, url) {
+  const uiMode = mode(flags.ui, 'never', '--ui');
+  const screenshotMode = String(flags.screenshot || 'never').toLowerCase();
+  if (!['always', 'never'].includes(screenshotMode)) {
+    throw new Error('--screenshot must be always or never.');
+  }
+  const screenshotRequested = screenshotMode !== 'never';
+  if ((uiMode === 'always' || screenshotRequested) && !url) {
+    throw new Error('Visual verification requires --url <http://localhost:port/path>.');
+  }
+  return {
+    uiMode,
+    screenshotMode,
+    captureOnly: uiMode === 'never' && screenshotMode === 'always',
+    run: Boolean(url) && (uiMode === 'always' || screenshotRequested),
+  };
+}
+
+function walkNodes(node, visit) {
+  if (!node) return;
+  visit(node);
+  for (const child of node.childNodes || []) walkNodes(child, visit);
+}
+
+async function verifyPageComponents(projectDir, selected) {
+  const pages = selected.filter(item => item.resourceType === 'pages');
+  if (!pages.length) return [];
+  const config = loadProjectConfig(projectDir);
+  const manifest = loadManifest(projectDir);
+  const uses = [];
+  for (const page of pages) {
+    const entry = getEntry(manifest, 'pages', page.resourceId);
+    if (!entry) continue;
+    const file = absolutePath(projectDir, entry.local_path);
+    const source = fs.readFileSync(file, 'utf8');
+    const document = parse5.parse(source);
+    const instances = new Set();
+    walkNodes(document, node => {
+      const attrs = new Map((node.attrs || []).map(attr => [attr.name, attr.value]));
+      const name = attrs.get('data-dg-use');
+      if (!name) return;
+      if (!/^([a-z][a-z0-9-]*)\/([a-z][a-z0-9-]*)$/.test(name)) throw new Error(`pages ${page.resourceId}: invalid data-dg-use "${name}"`);
+      const instance = attrs.get('data-dg-instance');
+      if (instance) { if (instances.has(instance)) throw new Error(`pages ${page.resourceId}: duplicate data-dg-instance "${instance}"`); instances.add(instance); }
+      uses.push({ page: page.resourceId, node, attrs, name });
+    });
+  }
+  const cache = new Map();
+  for (const use of uses) {
+    if (!cache.has(use.name)) {
+      const slug = use.name.split('/')[1];
+      const response = await fetch(`${config.server}/api/components?library=${encodeURIComponent(use.name.split('/')[0])}&q=${encodeURIComponent(slug)}&page_size=100`, { headers: { Authorization: `Bearer ${config.token}` } });
+      const payload = await response.json().catch(() => ({}));
+      if (!response.ok) throw new Error(`component lookup failed for ${use.name} (${response.status})`);
+      const items = payload.data?.items || payload.items || [];
+      cache.set(use.name, items.find(item => item.slug === slug && (item.library_slug === use.name.split('/')[0] || item.full_name === use.name)) || null);
+    }
+    const component = cache.get(use.name);
+    if (!component) throw new Error(`pages ${use.page}: component not found ${use.name}`);
+    if (!component.published || Number(component.published_revision || 0) < 1) throw new Error(`pages ${use.page}: component is not published ${use.name}`);
+    const definition = component.published;
+    const rootTag = String(definition.root_tag || '').toLowerCase();
+    if (rootTag && String(use.node.nodeName || '').toLowerCase() !== rootTag) throw new Error(`pages ${use.page}: ${use.name} requires <${rootTag}> but found <${use.node.nodeName}>`);
+    const props = new Map((definition.props || []).map(prop => [prop.name, prop]));
+    for (const [name, value] of use.attrs) {
+      if (!name.startsWith('data-dg-prop-')) continue;
+      const propName = name.slice('data-dg-prop-'.length);
+      const prop = props.get(propName);
+      if (!prop) throw new Error(`pages ${use.page}: unknown prop ${name} on ${use.name}`);
+      if (prop.type === 'boolean' && !['', 'true', 'false', '1', '0'].includes(String(value).toLowerCase())) {
+        throw new Error(`pages ${use.page}: invalid boolean prop ${name} on ${use.name}`);
+      }
+      if (prop.type === 'number' && !Number.isFinite(Number(value))) {
+        throw new Error(`pages ${use.page}: invalid number prop ${name} on ${use.name}`);
+      }
+    }
+    const slots = new Set((definition.slots || []).map(slot => slot.name));
+    for (const child of use.node.childNodes || []) {
+      const slot = (child.attrs || []).find(attr => attr.name === 'data-dg-slot')?.value;
+      if (slot && slots.size && !slots.has(slot)) throw new Error(`pages ${use.page}: unknown slot ${slot} on ${use.name}`);
+    }
+  }
+  return uses;
+}
+
+async function verify(projectDir, positional = [], flags = {}) {
+  let selected;
+  let remoteMode;
+  let visual;
+  const url = String(flags.url || '').trim();
+  try {
+    selected = resources(positional);
+    remoteMode = flags.remote ? 'always' : 'never';
+    visual = visualRequest(flags, url);
+    if (flags.output === 'json' && visual.run) throw new Error('Visual verification does not support --output json; run the explicit visual check separately.');
+  } catch (error) {
+    log.err(error.message);
+    return 1;
+  }
+
+  if (flags.output !== 'json') log.title('draftgo verify');
+  try { if (flags.remote) await verifyPageComponents(projectDir, selected); }
+  catch (error) { log.err(error.message); return 1; }
+  const checkCode = await check(projectDir, [], {
+    output: flags.output,
+    strict: flags.strict,
+    remote: remoteMode === 'always',
+    resourceKeys: selected.length
+      ? selected.map((entry) => `${entry.resourceType}:${entry.resourceId}`)
+      : null,
+  });
+  if (checkCode !== 0) return checkCode;
+
+  if (!visual.run) {
+    if (url) log.warn('--url was provided without --screenshot always or --ui always; visual verification was skipped.');
+    if (flags.output !== 'json') log.ok('Local verification passed; browser and business interactions were not tested.');
+    return 0;
+  }
+  let targets;
+  try { targets = viewports(flags); }
+  catch (error) { log.err(error.message); return 1; }
+  for (const viewport of targets) {
+    const uiFlags = {
+      ...flags,
+      url,
+      width: viewport.width,
+      height: viewport.height,
+      'capture-only': visual.captureOnly,
+    };
+    const code = await visualVerify(projectDir, [url], uiFlags);
+    if (code !== 0) return code;
+  }
+  if (visual.captureOnly) {
+    log.ok(`Visual capture completed (${targets.map((item) => item.name).join(', ')}).`);
+    return 0;
+  }
+  log.ok(`Unified verification passed (${targets.map((item) => item.name).join(', ')}).`);
+  return 0;
+}
+
+module.exports = verify;
+module.exports.mode = mode;
+module.exports.resources = resources;
+module.exports.viewports = viewports;
+module.exports.visualRequest = visualRequest;
+module.exports.verifyPageComponents = verifyPageComponents;