@chenguangyao/devflow-kit 0.1.43

package/src/cli/commands/doctor.js

@@ -0,0 +1,178 @@
+'use strict';
+const fs = require('fs/promises');
+const fsSync = require('fs');
+const path = require('path');
+const log = require('../../utils/log.js');
+const paths = require('../../core/paths.js');
+const config = require('../../core/config.js');
+const change = require('../../core/change.js');
+const state = require('../../core/state.js');
+const providers = require('../../providers/loader.js');
+const lifecycle = require('../../providers/lifecycle.js');
+
+const SCOPES = ['env', 'config', 'provider', 'cred', 'change', 'knowledge', 'overview', 'git'];
+
+async function audit(root, scopes) {
+  const wanted = (scopes && scopes.length) ? scopes : SCOPES;
+  const findings = [];
+  for (const scope of wanted) {
+    if (!SCOPES.includes(scope)) {
+      findings.push({ scope, level: 'warn', msg: `unknown scope: ${scope}` });
+      continue;
+    }
+    const fn = checkers[scope];
+    try {
+      const items = await fn(root);
+      for (const it of items) findings.push({ scope, ...it });
+    } catch (e) {
+      findings.push({ scope, level: 'error', msg: `check failed: ${e.message}` });
+    }
+  }
+  const errors = findings.filter((f) => f.level === 'error').length;
+  const warns  = findings.filter((f) => f.level === 'warn').length;
+  return { findings, errors, warns };
+}
+
+async function run({ flags = {}, cwd }) {
+  const root = cwd || process.cwd();
+  const wanted = flags.scope ? String(flags.scope).split(',').map((s) => s.trim()) : SCOPES;
+  const json = flags.json === true || flags.json === 'true';
+  const { findings } = await audit(root, wanted);
+
+  if (json) {
+    process.stdout.write(JSON.stringify({ findings }, null, 2) + '\n');
+    return;
+  }
+
+  let errors = 0, warns = 0;
+  for (const f of findings) {
+    if (f.level === 'error') { errors++; log.error(`[${f.scope}] ${f.msg}`); }
+    else if (f.level === 'warn') { warns++; log.warn(`[${f.scope}] ${f.msg}`); }
+    else if (f.level === 'ok') log.ok(`[${f.scope}] ${f.msg}`);
+    else log.info(`[${f.scope}] ${f.msg}`);
+  }
+  log.raw('');
+  if (errors > 0) {
+    log.error(`doctor: ${errors} error(s), ${warns} warning(s)`);
+    process.exitCode = 1;
+  } else if (warns > 0) {
+    log.warn(`doctor: ${warns} warning(s)`);
+  } else {
+    log.ok('doctor: all checks passed');
+  }
+}
+
+const checkers = {
+  async env() {
+    const items = [];
+    const node = process.versions.node;
+    const major = parseInt(node.split('.')[0], 10);
+    if (major < 20) items.push({ level: 'error', msg: `node ${node} < required 20` });
+    else items.push({ level: 'ok', msg: `node ${node}` });
+    return items;
+  },
+  async config(root) {
+    const items = [];
+    const file = paths.configFile(root);
+    if (!fsSync.existsSync(file)) {
+      items.push({ level: 'error', msg: `missing devflow/config.json. run "devflow init"` });
+    } else {
+      try {
+        const cfg = await config.read(root);
+        if (!cfg.version) items.push({ level: 'warn', msg: 'config.version missing' });
+        else items.push({ level: 'ok', msg: 'config.json present' });
+      } catch (e) {
+        items.push({ level: 'error', msg: `config.json parse error: ${e.message}` });
+      }
+    }
+    return items;
+  },
+  async provider(root) {
+    const items = [];
+    const list = await providers.listConfigured(root);
+    if (!list.length) items.push({ level: 'info', msg: 'no providers configured (using local fallbacks)' });
+    for (const p of list) {
+      let v;
+      try {
+        const inst = await providers.load(root, { name: p.name });
+        v = await inst.validate();
+      } catch (e) {
+        items.push({ level: 'warn', msg: `${p.name}: ${e.message.split('\n')[0]}` });
+        continue;
+      }
+      if (v.ok) items.push({ level: 'ok', msg: `${p.name} (${p.type}/${p.driver}) [${p.source}] ok` });
+      else if (v.needsLogin) items.push({ level: 'warn', msg: `${p.name}: needs login — run "devflow provider relogin ${p.name}"` });
+      else items.push({ level: 'warn', msg: `${p.name}: ${v.reason}` });
+    }
+    return items;
+  },
+  async cred(root) {
+    const items = [];
+    const findings = await lifecycle.securityCheck(root);
+    if (!findings.length) {
+      items.push({ level: 'ok', msg: 'no plaintext secrets / weak modes detected' });
+    } else {
+      for (const f of findings) {
+        items.push({ level: f.severity || 'warn', msg: `${f.file}: ${f.message}` });
+      }
+    }
+    // Also surface "no chmod info on Windows" → not an error
+    return items;
+  },
+  async change(root) {
+    const items = [];
+    const all = await change.listChanges(root);
+    if (!all.length) {
+      items.push({ level: 'info', msg: 'no in-progress changes' });
+      return items;
+    }
+    for (const slug of all) {
+      const stateFile = paths.stateFile(root, slug);
+      if (!fsSync.existsSync(stateFile)) {
+        items.push({ level: 'error', msg: `${slug}: missing state.json` });
+        continue;
+      }
+      try {
+        const st = await state.read(root, slug);
+        items.push({ level: 'ok', msg: `${slug}: phase=${st.currentPhase} level=${st.level}` });
+      } catch (e) {
+        items.push({ level: 'error', msg: `${slug}: state.json parse error: ${e.message}` });
+      }
+    }
+    return items;
+  },
+  async knowledge(root) {
+    const items = [];
+    const idx = path.join(paths.workspaceKnowledgeRoot(), 'index.json');
+    if (!fsSync.existsSync(idx)) {
+      items.push({ level: 'warn', msg: 'workspace knowledge/index.json missing (run devflow init)' });
+    } else items.push({ level: 'ok', msg: 'workspace knowledge/index.json present' });
+    return items;
+  },
+  async overview(root) {
+    const items = [];
+    const cfg = await config.read(root).catch(() => null);
+    if (!cfg) return items;
+    const ov = cfg.projectOverview || {};
+    if (ov.mode === 'reference') {
+      const ref = ov.referencedFile;
+      if (!ref) items.push({ level: 'warn', msg: 'projectOverview.mode=reference but no source detected' });
+      else if (!fsSync.existsSync(path.join(root, ref))) items.push({ level: 'error', msg: `referenced overview missing: ${ref}` });
+      else items.push({ level: 'ok', msg: `overview ref: ${ref}` });
+    } else {
+      items.push({ level: 'info', msg: `overview mode=${ov.mode}` });
+    }
+    return items;
+  },
+  async git(root) {
+    const items = [];
+    if (!fsSync.existsSync(path.join(root, '.git'))) {
+      items.push({ level: 'warn', msg: 'not a git repo' });
+      return items;
+    }
+    items.push({ level: 'ok', msg: 'git repo present' });
+    return items;
+  },
+};
+
+module.exports = { run, audit, SCOPES };

package/src/cli/commands/enable.js

@@ -0,0 +1,21 @@
+'use strict';
+const log = require('../../utils/log.js');
+const state = require('../../core/state.js');
+const helpers = require('./_helpers.js');
+
+async function run({ flags = {}, positional = [], cwd }) {
+  const root = cwd || process.cwd();
+  const feature = positional[0];
+  if (!feature) { log.error('usage: devflow enable <feature>'); process.exitCode = 2; return; }
+  const slug = await helpers.resolveSlug(root, flags, positional.slice(1));
+  if (!slug) { process.exitCode = 1; return; }
+  const st = await helpers.loadStateOrFail(root, slug);
+  if (!st) { process.exitCode = 1; return; }
+  st.enabled = st.enabled || {};
+  st.enabled[feature] = true;
+  state.logEvent(st, `enable ${feature}`);
+  await state.write(root, slug, st);
+  log.ok(`enabled: ${feature}`);
+}
+
+module.exports = { run };