@chenguangyao/devflow-kit 0.1.43

package/src/providers/userconfig.js

@@ -0,0 +1,283 @@
+'use strict';
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+const paths = require('../core/paths.js');
+
+/**
+ * User-level config bootstrap.
+ *
+ *   ~/.devflow/
+ *   ├── providers.json   (chmod 0600)   ← single source of truth for ALL providers
+ *   ├── providers.example.json           ← filled provider examples, no real secrets
+ *   ├── projects.json    (chmod 0600)   ← non-secret project/deploy/test profiles
+ *   └── README.md                       ← usage notes (committed once on first install)
+ *
+ * Why a single file:
+ *   - All credentials live in one place → easy to back up, rotate, lock down
+ *   - File is shared across every project on the same machine
+ *   - Project-level <repo>/devflow/providers.json may override individual entries
+ *
+ * Security notes:
+ *   - Permissions: dir 0700, providers.json 0600 (we re-apply on every call so an
+ *     accidental chmod gets corrected). Other readable-by-group setups would let
+ *     other Unix users on the same host read tokens.
+ *   - Prefer `${env:VAR}` placeholders over inline secrets in providers.json so
+ *     tokens never sit on disk in plaintext when avoidable.
+ */
+
+const DEFAULT_PROVIDERS_JSON = '{}\n';
+const DEFAULT_PROVIDERS_EXAMPLE = {
+  _instructions: [
+    'Copy the providers you need into ~/.devflow/providers.json.',
+    'Public/shared endpoints are filled in; personal usernames, tokens, passwords, and webhook URLs should use ${env:VAR} placeholders.',
+    'Never commit providers.json or paste real secrets into reports, PR descriptions, or chat logs.'
+  ],
+  'intake.confluence': {
+    type: 'intake',
+    driver: 'confluence',
+    config: {
+      baseUrl: 'https://wiki.qingsonghealth.com',
+      token: '${env:CONFLUENCE_TOKEN}',
+      user: '${env:CONFLUENCE_USER}'
+    }
+  },
+  'ci.jenkins': {
+    type: 'ci',
+    driver: 'jenkins',
+    config: {
+      baseUrl: 'https://test-jenkins.qingsonghealth.com',
+      user: '${env:JENKINS_USER}',
+      token: '${env:JENKINS_TOKEN}',
+      triggerMethod: 'post'
+    }
+  },
+  'notify.smtp': {
+    type: 'notify',
+    driver: 'smtp',
+    config: {
+      host: 'smtp.exmail.qq.com',
+      port: 465,
+      secure: true,
+      user: '${env:SMTP_USER}',
+      pass: '${env:SMTP_PASS}',
+      from: '${env:SMTP_FROM}',
+      defaults: {
+        to: ['qa@example.com'],
+        cc: ['dev-team@example.com']
+      }
+    }
+  },
+  'kb.weknora': {
+    type: 'kb',
+    driver: 'weknora',
+    config: {
+      endpoint: '${env:WEKNORA_ENDPOINT}',
+      kb_id: '${env:WEKNORA_KB_ID}',
+      token: '${env:WEKNORA_API_KEY}'
+    }
+  },
+  'api.yapi': {
+    type: 'api',
+    driver: 'yapi',
+    config: {
+      baseUrl: 'https://yapi.qingsonghealth.com',
+      token: '${env:YAPI_TOKEN}',
+      projectId: '${env:YAPI_PROJECT_ID}',
+      syncPath: '/api/open/import_data'
+    }
+  },
+  'observability.sls': {
+    type: 'observability',
+    driver: 'sls',
+    config: {
+      endpoint: '${env:SLS_ENDPOINT}',
+      project: '${env:SLS_PROJECT}',
+      logstore: '${env:SLS_LOGSTORE}',
+      accessKeyId: '${env:ALIYUN_ACCESS_KEY_ID}',
+      accessKeySecret: '${env:ALIYUN_ACCESS_KEY_SECRET}'
+    }
+  },
+  'observability.oss': {
+    type: 'observability',
+    driver: 'oss',
+    config: {
+      endpoint: '${env:OSS_ENDPOINT}',
+      bucket: '${env:OSS_BUCKET}',
+      prefix: 'logs/',
+      accessKeyId: '${env:ALIYUN_ACCESS_KEY_ID}',
+      accessKeySecret: '${env:ALIYUN_ACCESS_KEY_SECRET}'
+    }
+  }
+};
+
+const README_TEMPLATE = `# devflow user config
+
+Files in this directory:
+
+| File | Purpose |
+| ---- | ------- |
+| \`providers.json\` | Single source of truth for all provider configs (chmod 0600) |
+| \`providers.example.json\` | Filled examples with public endpoints and env-var placeholders for personal secrets |
+| \`projects.json\` | Project deploy/test profiles imported from tools like publish-code (chmod 0600) |
+
+## providers.json schema
+
+\`\`\`jsonc
+{
+  // Key format: "<type>.<name>"
+  // - type:   intake | issue | vcs | ci | notify | kb | api | observability
+  // - name:   short id you pick (typically the driver name or an env qualifier)
+  "intake.confluence": {
+    "type": "intake",
+    "driver": "confluence",
+    "config": {
+      "baseUrl": "https://wiki.qingsonghealth.com",
+      "token": "\${env:CONFLUENCE_TOKEN}",
+      "user": "\${env:CONFLUENCE_USER}"
+    }
+  },
+  "ci.jenkins": {
+    "type": "ci",
+    "driver": "jenkins",
+    "config": {
+      "baseUrl": "https://test-jenkins.qingsonghealth.com",
+      "user": "\${env:JENKINS_USER}",
+      "token": "\${env:JENKINS_TOKEN}",
+      "triggerMethod": "post"
+    }
+  },
+  "notify.smtp": {
+    "type": "notify",
+    "driver": "smtp",
+    "config": {
+      "host": "smtp.example.com",
+      "port": 587,
+      "secure": false,
+      "user": "ci@example.com",
+      "pass": "\${env:SMTP_PASS}",
+      "from": "ci@example.com",
+      "defaults": {
+        "to": ["qa@example.com"],
+        "cc": ["dev-team@example.com"]
+      }
+    }
+  },
+  "kb.weknora": {
+    "type": "kb",
+    "driver": "weknora",
+    "config": {
+      "baseUrl": "https://weknora.example.com",
+      "kbId": "your-kb-id",
+      "auth": { "type": "bearer", "tokenEnv": "WEKNORA_TOKEN" }
+    }
+  }
+}
+\`\`\`
+
+## projects.json schema
+
+\`\`\`jsonc
+{
+  "version": 1,
+  "environments": {
+    "test": { "apiBaseUrl": "https://test-api.example.com" }
+  },
+  "projects": {
+    "go-member": {
+      "repoUrl": "https://code.example.com/health/go-member",
+      "gitlabProjectId": "3678",
+      "jenkins": {
+        "test": "https://jenkins.example.com/job/health_go-member-test/build?delay=0sec"
+      },
+      "tests": {
+        "smoke": { "command": "curl -fsS \${apiBaseUrl}/health" }
+      }
+    }
+  }
+}
+\`\`\`
+
+## Useful commands
+
+\`\`\`bash
+devflow provider list           # list configured providers (merges user + project)
+devflow provider status         # connectivity & auth check for each
+devflow provider add <name>     # interactive add
+devflow provider add --from <file>   # bulk import from JSON snippet
+devflow provider import publish-code --from <file>   # import project/Jenkins profiles
+devflow provider validate <n>   # config schema check
+devflow provider rotate <n>     # rotate token / cookie
+devflow provider audit          # security audit (plaintext tokens, file modes)
+devflow doctor --scope cred     # same audit + actionable hints
+\`\`\`
+
+## Resolution order (highest priority first)
+
+1. \`<repo>/devflow/providers.json\` (project override — checked into the repo if non-sensitive)
+2. \`~/.devflow/providers.json\` (this file — user-wide, 0600)
+3. Built-in \`local\` driver (zero-dep fallback for intake/issue/vcs/ci/notify/kb)
+
+## Secret hygiene
+
+- Never check \`~/.devflow/providers.json\` into git.
+- Prefer \`"\${env:VAR_NAME}"\` over inline secrets — devflow expands them at load time.
+- \`devflow provider audit\` flags fields that look like inline tokens (≥20 chars,
+  high-entropy) and warns you to switch to env-var references.
+`;
+
+/**
+ * Ensure ~/.devflow/ exists with an empty providers.json (0600), a populated
+ * providers.example.json, and README.
+ *
+ * Idempotent: never overwrites existing files. Always re-applies tight perms in
+ * case the user (or a tool) loosened them.
+ *
+ * Returns { dir, file, readme, created: { dir, providers, readme } } so callers
+ * can decide whether to print "created new config" vs "config already present".
+ */
+async function ensureUserConfig() {
+  const dir = paths.userConfigDir();
+  const file = paths.userProvidersFile();
+  const example = paths.userProvidersExampleFile();
+  const readme = path.join(dir, 'README.md');
+  const created = { dir: false, providers: false, example: false, readme: false };
+
+  if (!fs.existsSync(dir)) {
+    await fsp.mkdir(dir, { recursive: true, mode: 0o700 });
+    created.dir = true;
+  }
+  // Re-apply (idempotent) tight perms even if dir pre-existed
+  try { await fsp.chmod(dir, 0o700); } catch { /* not all FS support chmod */ }
+
+  if (!fs.existsSync(file)) {
+    // Open with O_CREAT | O_WRONLY | O_EXCL semantics so we don't race
+    const legacy = paths.legacyUserProvidersFile && paths.legacyUserProvidersFile();
+    if (legacy && fs.existsSync(legacy)) {
+      await fsp.copyFile(legacy, file);
+    } else {
+      await fsp.writeFile(file, DEFAULT_PROVIDERS_JSON, { mode: 0o600 });
+    }
+    created.providers = true;
+  }
+  try { await fsp.chmod(file, 0o600); } catch { /* ignore */ }
+
+  if (!fs.existsSync(example)) {
+    await fsp.writeFile(example, JSON.stringify(DEFAULT_PROVIDERS_EXAMPLE, null, 2) + '\n', 'utf8');
+    created.example = true;
+  }
+
+  if (!fs.existsSync(readme)) {
+    await fsp.writeFile(readme, README_TEMPLATE);
+    created.readme = true;
+  }
+
+  return { dir, file, example, readme, created };
+}
+
+module.exports = {
+  ensureUserConfig,
+  DEFAULT_PROVIDERS_JSON,
+  DEFAULT_PROVIDERS_EXAMPLE,
+  README_TEMPLATE,
+};

package/src/reports/aggregate.js

@@ -0,0 +1,185 @@
+'use strict';
+
+const fs = require('fs/promises');
+const fsSync = require('fs');
+const path = require('path');
+
+const ORDER = ['deploy', 'unit', 'integration', 'contract', 'remote', 'e2e', 'joint', 'smoke', 'self-test', 'regression', 'perf'];
+const LABELS = {
+  deploy: '部署',
+  unit: '单元测试',
+  integration: '集成测试',
+  contract: '调用链一致性',
+  remote: '远程 API',
+  e2e: '端到端',
+  joint: '联调测试',
+  smoke: '冒烟测试',
+  'self-test': '自测',
+  regression: '回归测试',
+  perf: '性能测试',
+};
+
+async function upsertReport({ reportsDir, slug, title, kind, body, meta = {} }) {
+  await fs.mkdir(reportsDir, { recursive: true });
+  const current = readAggregate(reportsDir);
+  const reports = current.reports.filter((r) => r.kind !== kind);
+  reports.push({
+    kind,
+    status: meta.status || 'pending',
+    total: meta.total == null ? null : meta.total,
+    passed: meta.passed == null ? null : meta.passed,
+    failed: meta.failed == null ? null : meta.failed,
+    coverage: meta.coverage || null,
+    failureType: meta.failureType || meta.failure_type || null,
+    ts: meta.ts || new Date().toISOString(),
+    body: stripFrontmatter(body || '').trim(),
+  });
+  const md = renderAggregate({ slug, title: title || current.title || slug, reports });
+  const file = path.join(reportsDir, 'test-report.md');
+  await fs.writeFile(file, md, 'utf8');
+  return file;
+}
+
+function readAggregate(reportsDir) {
+  const file = path.join(reportsDir, 'test-report.md');
+  let text = '';
+  try { text = fsSync.readFileSync(file, 'utf8'); } catch (_) { return { title: '', reports: [] }; }
+  const title = ((text.match(/^#\s+(.+)$/m) || [])[1] || '').replace(/^测试报告\s*-\s*/, '').trim();
+  const reports = [];
+  const re = /<!-- devflow:report ([a-z0-9_-]+):start -->\n<!-- devflow:report-meta ([\s\S]*?) -->\n([\s\S]*?)\n<!-- devflow:report \1:end -->/g;
+  let m;
+  while ((m = re.exec(text))) {
+    let meta = {};
+    try { meta = JSON.parse(m[2]); } catch (_) { meta = {}; }
+    reports.push({
+      kind: meta.kind || m[1],
+      status: meta.status || 'pending',
+      total: numberOrNull(meta.total),
+      passed: numberOrNull(meta.passed),
+      failed: numberOrNull(meta.failed),
+      coverage: meta.coverage || null,
+      failureType: meta.failureType || meta.failure_type || null,
+      ts: meta.ts || null,
+      file: 'test-report.md',
+      section: m[1],
+      body: (m[3] || '').trim(),
+    });
+  }
+  return { title, reports };
+}
+
+function renderAggregate({ slug, title, reports }) {
+  const sorted = sortReports(reports);
+  const status = overallStatus(sorted);
+  const totals = sumTotals(sorted);
+  const lines = [
+    '---',
+    `slug: ${slug || '-'}`,
+    'kind: test-report',
+    `status: ${status}`,
+    `total: ${totals.total == null ? '-' : totals.total}`,
+    `passed: ${totals.passed == null ? '-' : totals.passed}`,
+    `failed: ${totals.failed == null ? '-' : totals.failed}`,
+    `ts: ${new Date().toISOString()}`,
+    '---',
+    '',
+    `# 测试报告 - ${title || slug || '-'}`,
+    '',
+    '## 测试覆盖汇总',
+    '',
+    '| 类型 | 状态 | 用例 | 通过 | 失败 | 覆盖率 | 失败类型 |',
+    '| --- | --- | --- | --- | --- | --- | --- |',
+  ];
+  for (const r of sorted) {
+    lines.push(`| ${labelKind(r.kind)} | ${statusIcon(r.status)} | ${fmt(r.total)} | ${fmt(r.passed)} | ${fmt(r.failed)} | ${r.coverage || '-'} | ${r.failureType || '-'} |`);
+  }
+  lines.push('', '## 详细报告', '');
+  for (const r of sorted) {
+    const meta = {
+      kind: r.kind,
+      status: r.status || 'pending',
+      total: r.total,
+      passed: r.passed,
+      failed: r.failed,
+      coverage: r.coverage,
+      failureType: r.failureType,
+      ts: r.ts || new Date().toISOString(),
+    };
+    lines.push(`<!-- devflow:report ${r.kind}:start -->`);
+    lines.push(`<!-- devflow:report-meta ${JSON.stringify(meta)} -->`);
+    lines.push(normalizeSection(r));
+    lines.push(`<!-- devflow:report ${r.kind}:end -->`, '');
+  }
+  return lines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
+}
+
+function normalizeSection(r) {
+  const body = (r.body || '').trim();
+  if (!body) return `### ${labelKind(r.kind)}\n\n_(暂无详情)_`;
+  if (/^#{2,4}\s+/m.test(body)) return body;
+  if (/^#\s+/m.test(body)) return body.replace(/^#\s+/, '### ');
+  return `### ${labelKind(r.kind)}\n\n${body}`;
+}
+
+function stripFrontmatter(text) {
+  const s = String(text || '');
+  if (!s.startsWith('---')) return s;
+  const end = s.indexOf('\n---', 3);
+  return end >= 0 ? s.slice(end + 4).replace(/^\s+/, '') : s;
+}
+
+function sortReports(reports) {
+  return [...reports].sort((a, b) => {
+    const ai = ORDER.indexOf(a.kind);
+    const bi = ORDER.indexOf(b.kind);
+    return (ai < 0 ? 999 : ai) - (bi < 0 ? 999 : bi) || String(a.kind).localeCompare(String(b.kind));
+  });
+}
+
+function overallStatus(reports) {
+  if (!reports.length) return 'pending';
+  if (reports.some((r) => r.status === 'fail')) return 'fail';
+  if (reports.some((r) => r.status === 'blocked')) return 'blocked';
+  if (reports.some((r) => !r.status || r.status === 'pending' || r.status === 'draft')) return 'pending';
+  if (reports.some((r) => r.status === 'partial')) return 'partial';
+  return 'pass';
+}
+
+function sumTotals(reports) {
+  let seen = false;
+  const out = { total: 0, passed: 0, failed: 0 };
+  for (const r of reports) {
+    if (r.total != null || r.passed != null || r.failed != null) seen = true;
+    out.total += Number.isFinite(Number(r.total)) ? Number(r.total) : 0;
+    out.passed += Number.isFinite(Number(r.passed)) ? Number(r.passed) : 0;
+    out.failed += Number.isFinite(Number(r.failed)) ? Number(r.failed) : 0;
+  }
+  return seen ? out : { total: null, passed: null, failed: null };
+}
+
+function labelKind(k) { return LABELS[k] || k; }
+function statusIcon(s) {
+  if (s === 'pass') return '✅ 通过';
+  if (s === 'fail') return '❌ 失败';
+  if (s === 'blocked') return '⛔ 阻塞';
+  if (s === 'pending' || s === 'draft') return '⏳ 待补充';
+  if (s === 'partial') return '⚠️ 部分通过';
+  return s || '-';
+}
+function fmt(v) { return v == null || v === '' ? '-' : String(v); }
+function numberOrNull(v) {
+  if (v == null || v === '-') return null;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+}
+
+module.exports = {
+  upsertReport,
+  readAggregate,
+  renderAggregate,
+  stripFrontmatter,
+  overallStatus,
+  sumTotals,
+  labelKind,
+  statusIcon,
+};

package/src/reports/coverage.js

@@ -0,0 +1,163 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse coverage from common formats.
+ * Returns: { format, lines: { pct, covered, total }, statements?, branches?, functions? }
+ *
+ * Supported:
+ *  - 'json-summary'   istanbul / nyc / jest / vitest  (coverage-summary.json)
+ *  - 'lcov'           lcov.info
+ *  - 'cobertura'      coverage.xml (pytest --cov-report=xml, jacoco-cobertura, etc.)
+ *  - 'go-cover-out'   go's coverage.out (mode + per-file count)
+ *  - 'jacoco-xml'     target/site/jacoco/jacoco.xml
+ */
+function parseFile(format, file) {
+  if (!fs.existsSync(file)) return null;
+  const text = fs.readFileSync(file, 'utf8');
+  return parseText(format, text);
+}
+
+function parseText(format, text) {
+  switch (format) {
+    case 'json-summary': return parseJsonSummary(text);
+    case 'lcov':         return parseLcov(text);
+    case 'cobertura':    return parseCobertura(text);
+    case 'go-cover-out': return parseGoCoverOut(text);
+    case 'jacoco-xml':   return parseJacoco(text);
+    default: return null;
+  }
+}
+
+function parseJsonSummary(text) {
+  let json; try { json = JSON.parse(text); } catch { return null; }
+  const total = json.total;
+  if (!total) return null;
+  return {
+    format: 'json-summary',
+    lines:      pick(total.lines),
+    statements: pick(total.statements),
+    branches:   pick(total.branches),
+    functions:  pick(total.functions),
+  };
+}
+
+function pick(o) {
+  if (!o) return null;
+  return { pct: o.pct, covered: o.covered, total: o.total };
+}
+
+function parseLcov(text) {
+  let LF = 0, LH = 0, BF = 0, BH = 0, FNF = 0, FNH = 0;
+  for (const line of text.split(/\r?\n/)) {
+    const i = line.indexOf(':');
+    if (i < 0) continue;
+    const k = line.slice(0, i);
+    const v = parseInt(line.slice(i + 1), 10);
+    if (Number.isNaN(v)) continue;
+    if (k === 'LF') LF += v;
+    else if (k === 'LH') LH += v;
+    else if (k === 'BRF') BF += v;
+    else if (k === 'BRH') BH += v;
+    else if (k === 'FNF') FNF += v;
+    else if (k === 'FNH') FNH += v;
+  }
+  if (LF === 0) return null;
+  return {
+    format: 'lcov',
+    lines:     { pct: pct(LH, LF), covered: LH, total: LF },
+    branches:  BF > 0 ? { pct: pct(BH, BF), covered: BH, total: BF } : null,
+    functions: FNF > 0 ? { pct: pct(FNH, FNF), covered: FNH, total: FNF } : null,
+  };
+}
+
+function parseCobertura(text) {
+  // Look for top-level <coverage line-rate="0.85" ...> ... <coverage>...</coverage>
+  const m = text.match(/<coverage[^>]*line-rate="([\d.]+)"[^>]*>/);
+  if (!m) return null;
+  const lineRate = parseFloat(m[1]);
+  const branchM = text.match(/<coverage[^>]*branch-rate="([\d.]+)"[^>]*>/);
+  return {
+    format: 'cobertura',
+    lines:    { pct: round1(lineRate * 100), covered: null, total: null },
+    branches: branchM ? { pct: round1(parseFloat(branchM[1]) * 100), covered: null, total: null } : null,
+  };
+}
+
+function parseGoCoverOut(text) {
+  // Lines: "<file>:<startLine>.<col>,<endLine>.<col> <numStmt> <count>"
+  let total = 0, covered = 0;
+  for (const line of text.split(/\r?\n/)) {
+    if (!line || line.startsWith('mode:')) continue;
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 3) continue;
+    const numStmt = parseInt(parts[parts.length - 2], 10);
+    const count = parseInt(parts[parts.length - 1], 10);
+    if (!Number.isFinite(numStmt) || !Number.isFinite(count)) continue;
+    total += numStmt;
+    if (count > 0) covered += numStmt;
+  }
+  if (total === 0) return null;
+  return {
+    format: 'go-cover-out',
+    statements: { pct: pct(covered, total), covered, total },
+    lines:      { pct: pct(covered, total), covered, total }, // approximate
+  };
+}
+
+function parseJacoco(text) {
+  // Jacoco's root element has multiple <counter type="..." missed=".." covered=".."/>
+  const counters = {};
+  const re = /<counter\s+type="(\w+)"\s+missed="(\d+)"\s+covered="(\d+)"\s*\/?>/g;
+  // Restrict to top level: pick the LAST occurrence per type which is the project totals.
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    counters[m[1]] = { missed: parseInt(m[2], 10), covered: parseInt(m[3], 10) };
+  }
+  const sec = (key) => {
+    const c = counters[key];
+    if (!c) return null;
+    const total = c.missed + c.covered;
+    return total === 0 ? null : { pct: pct(c.covered, total), covered: c.covered, total };
+  };
+  const lines = sec('LINE');
+  if (!lines) return null;
+  return {
+    format: 'jacoco-xml',
+    lines,
+    statements: sec('INSTRUCTION'),
+    branches:   sec('BRANCH'),
+    functions:  sec('METHOD'),
+  };
+}
+
+function pct(num, denom) {
+  if (!denom) return 0;
+  return round1((num / denom) * 100);
+}
+function round1(n) { return Math.round(n * 10) / 10; }
+
+/**
+ * Best-effort discovery: try the explicit hint, then a list of common locations.
+ */
+function discover(root, hint) {
+  const candidates = [];
+  if (hint && hint.file) candidates.push({ format: hint.format, file: path.join(root, hint.file) });
+  candidates.push(
+    { format: 'json-summary', file: path.join(root, 'coverage', 'coverage-summary.json') },
+    { format: 'lcov',         file: path.join(root, 'coverage', 'lcov.info') },
+    { format: 'cobertura',    file: path.join(root, 'coverage.xml') },
+    { format: 'go-cover-out', file: path.join(root, 'coverage.out') },
+    { format: 'jacoco-xml',   file: path.join(root, 'target', 'site', 'jacoco', 'jacoco.xml') },
+  );
+  for (const c of candidates) {
+    if (fs.existsSync(c.file)) {
+      const r = parseFile(c.format, c.file);
+      if (r) return r;
+    }
+  }
+  return null;
+}
+
+module.exports = { parseFile, parseText, discover };