@chenguangyao/devflow-kit 0.1.43

package/src/core/project-routing.js

@@ -0,0 +1,285 @@
+'use strict';
+
+const fs = require('fs/promises');
+const fsSync = require('fs');
+const path = require('path');
+const change = require('./change.js');
+
+const PROJECT_MARKERS = [
+  'pom.xml',
+  'build.gradle',
+  'build.gradle.kts',
+  'go.mod',
+  'package.json',
+  path.join('devflow', 'config.json'),
+  '.git',
+];
+
+const DEFAULT_IGNORE_DIRS = new Set([
+  '.git',
+  'node_modules',
+  'target',
+  'build',
+  'dist',
+  'vendor',
+  '.idea',
+  '.vscode',
+  '.devflow-worktrees',
+]);
+
+const TEXT_EXTENSIONS = new Set([
+  '.java', '.go', '.js', '.ts', '.tsx', '.jsx', '.vue',
+  '.xml', '.yml', '.yaml', '.json', '.md', '.properties',
+  '.sql', '.proto', '.gradle', '.kt', '.kts',
+]);
+
+async function discoverProjects(searchRoots, opts = {}) {
+  const roots = normalizeRoots(searchRoots);
+  const maxDepth = Number.isFinite(opts.maxDepth) ? opts.maxDepth : 3;
+  const found = new Map();
+
+  for (const root of roots) {
+    await walkProjectRoots(root, 0, maxDepth, found);
+  }
+
+  return Array.from(found.values())
+    .sort((a, b) => a.root.localeCompare(b.root));
+}
+
+async function routeProjects({ searchRoots, query, maxDepth, topK = 5 } = {}) {
+  const projects = await discoverProjects(searchRoots, { maxDepth });
+  const ranked = await rankProjects(projects, query || '', { topK });
+  return {
+    searchRoots: normalizeRoots(searchRoots),
+    candidates: ranked,
+    recommended: ranked
+      .filter((p) => p.confidence > 0)
+      .slice(0, topK)
+      .map((p, i) => ({
+        name: p.name,
+        root: p.root,
+        role: i === 0 ? 'primary' : 'dependency',
+        branch: change.currentBranch(p.root) || null,
+        confidence: p.confidence,
+        evidence: p.evidence,
+      })),
+  };
+}
+
+function explicitProjectRouting(projectRoots, { source = 'cli' } = {}) {
+  const roots = normalizeRoots(projectRoots);
+  const recommended = roots.map((root, i) => {
+    const branch = change.currentBranch(root);
+    return {
+      name: path.basename(root),
+      root,
+      role: i === 0 ? 'primary' : 'dependency',
+      branch: branch || null,
+      confidence: 1,
+      evidence: ['用户已指定'],
+    };
+  });
+  return {
+    status: 'explicit',
+    source,
+    searchRoots: roots,
+    queryTerms: [],
+    candidates: recommended,
+    recommended,
+    slugBranchSource: recommended[0] ? recommended[0].root : null,
+  };
+}
+
+async function writeProjectRootsArtifact(root, slug, projectRouting, { source = 'project-routing' } = {}) {
+  if (!projectRouting || !Array.isArray(projectRouting.recommended)) return null;
+  const doc = {
+    version: 1,
+    source,
+    status: projectRouting.status || null,
+    updatedAt: new Date().toISOString(),
+    searchRoots: projectRouting.searchRoots || [],
+    projects: projectRouting.recommended.map((p) => ({
+      name: p.name,
+      root: p.root,
+      role: p.role || null,
+      branch: p.branch || null,
+      confidence: p.confidence,
+      evidence: p.evidence || [],
+    })),
+    candidates: (projectRouting.candidates || []).slice(0, 10).map((p) => ({
+      name: p.name,
+      root: p.root,
+      marker: p.marker || null,
+      confidence: p.confidence,
+      evidence: p.evidence || [],
+    })),
+  };
+  await change.writeArtifact(root, slug, 'project-roots.json', JSON.stringify(doc, null, 2) + '\n');
+  return doc;
+}
+
+async function rankProjects(projects, query, opts = {}) {
+  const terms = extractTerms(query);
+  const topK = Number.isFinite(opts.topK) ? opts.topK : projects.length;
+  const ranked = [];
+
+  for (const project of projects) {
+    const evidence = [];
+    let score = scoreName(project, terms, evidence);
+    const hits = await searchProject(project.root, terms, { maxFiles: opts.maxFiles || 300 });
+    for (const h of hits) {
+      score += h.score;
+      evidence.push(h.text);
+    }
+    const confidence = terms.length ? Math.min(0.99, +(score / Math.max(terms.length * 5, 1)).toFixed(2)) : 0;
+    ranked.push({ ...project, score, confidence, evidence: dedupe(evidence).slice(0, 8) });
+  }
+
+  return ranked
+    .sort((a, b) => b.score - a.score || a.root.localeCompare(b.root))
+    .slice(0, topK);
+}
+
+function extractTerms(input) {
+  const text = String(input || '');
+  const out = [];
+  const seen = new Set();
+  const add = (term) => {
+    const s = String(term || '').trim();
+    if (!s || s.length < 2) return;
+    const key = s.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push(s);
+  };
+
+  for (const m of text.matchAll(/\/[A-Za-z0-9_./{}:-]{2,}/g)) add(m[0]);
+  for (const m of text.matchAll(/[A-Za-z][A-Za-z0-9_.$-]{2,}/g)) add(m[0]);
+  for (const m of text.matchAll(/[\u4e00-\u9fa5]{2,}/g)) add(m[0]);
+  return out.slice(0, 40);
+}
+
+async function walkProjectRoots(dir, depth, maxDepth, found) {
+  if (!fsSync.existsSync(dir)) return;
+  const real = path.resolve(dir);
+  const marker = firstProjectMarker(real);
+  if (marker) {
+    found.set(real, { name: path.basename(real), root: real, marker });
+    if (marker === '.git' && depth === 0 && depth < maxDepth) {
+      // A multi-project workspace can be a shallow git checkout whose children
+      // are the real service projects. Keep walking so entry routing can still
+      // pick a service branch before creating the change.
+    } else {
+      return;
+    }
+  }
+  if (depth >= maxDepth) return;
+
+  let entries;
+  try {
+    entries = await fs.readdir(real, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (DEFAULT_IGNORE_DIRS.has(e.name)) continue;
+    await walkProjectRoots(path.join(real, e.name), depth + 1, maxDepth, found);
+  }
+}
+
+function firstProjectMarker(dir) {
+  for (const marker of PROJECT_MARKERS) {
+    if (fsSync.existsSync(path.join(dir, marker))) return marker;
+  }
+  return null;
+}
+
+function scoreName(project, terms, evidence) {
+  let score = 0;
+  const haystack = `${project.name} ${project.root}`.toLowerCase();
+  for (const term of terms) {
+    if (haystack.includes(term.toLowerCase())) {
+      score += 2;
+      evidence.push(`project name/path matches "${term}"`);
+    }
+  }
+  return score;
+}
+
+async function searchProject(root, terms, opts = {}) {
+  if (!terms.length) return [];
+  const files = [];
+  await collectTextFiles(root, files, { maxFiles: opts.maxFiles || 300, maxDepth: opts.maxDepth || 8 });
+  const hits = [];
+  const lowerTerms = terms.map((t) => ({ raw: t, lower: t.toLowerCase() }));
+
+  for (const file of files) {
+    const rel = path.relative(root, file);
+    const relLower = rel.toLowerCase();
+    for (const term of lowerTerms) {
+      if (relLower.includes(term.lower)) {
+        hits.push({ score: 4, text: `file path matches "${term.raw}": ${rel}` });
+      }
+    }
+
+    let content;
+    try {
+      const stat = await fs.stat(file);
+      if (stat.size > 512 * 1024) continue;
+      content = await fs.readFile(file, 'utf8');
+    } catch {
+      continue;
+    }
+    const lower = content.toLowerCase();
+    for (const term of lowerTerms) {
+      const idx = lower.indexOf(term.lower);
+      if (idx !== -1) {
+        hits.push({ score: 3, text: `content matches "${term.raw}": ${rel}` });
+      }
+    }
+  }
+  return hits;
+}
+
+async function collectTextFiles(dir, out, opts, depth = 0) {
+  if (out.length >= opts.maxFiles || depth > opts.maxDepth) return;
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (out.length >= opts.maxFiles) return;
+    if (e.isDirectory()) {
+      if (DEFAULT_IGNORE_DIRS.has(e.name)) continue;
+      await collectTextFiles(path.join(dir, e.name), out, opts, depth + 1);
+      continue;
+    }
+    if (!e.isFile()) continue;
+    const ext = path.extname(e.name);
+    if (TEXT_EXTENSIONS.has(ext) || e.name === 'pom.xml' || e.name === 'go.mod') {
+      out.push(path.join(dir, e.name));
+    }
+  }
+}
+
+function normalizeRoots(searchRoots) {
+  const list = Array.isArray(searchRoots) ? searchRoots : [searchRoots || process.cwd()];
+  return dedupe(list.filter(Boolean).map((p) => path.resolve(String(p))));
+}
+
+function dedupe(items) {
+  return Array.from(new Set(items));
+}
+
+module.exports = {
+  discoverProjects,
+  rankProjects,
+  routeProjects,
+  explicitProjectRouting,
+  writeProjectRootsArtifact,
+  extractTerms,
+  PROJECT_MARKERS,
+};

package/src/core/projects.js

@@ -0,0 +1,200 @@
+'use strict';
+const fs = require('fs/promises');
+const fsSync = require('fs');
+const path = require('path');
+const paths = require('./paths.js');
+const userconfig = require('../providers/userconfig.js');
+const lifecycle = require('../providers/lifecycle.js');
+
+const DEFAULT_PROJECTS = {
+  version: 1,
+  environments: {},
+  projects: {},
+  defaults: {},
+};
+
+async function read() {
+  const file = paths.userProjectsFile();
+  if (!fsSync.existsSync(file)) {
+    const legacy = paths.legacyUserProjectsFile && paths.legacyUserProjectsFile();
+    if (legacy && fsSync.existsSync(legacy)) {
+      try {
+        const data = JSON.parse(await fs.readFile(legacy, 'utf8'));
+        return normalize(data);
+      } catch {
+        return clone(DEFAULT_PROJECTS);
+      }
+    }
+    return clone(DEFAULT_PROJECTS);
+  }
+  try {
+    const data = JSON.parse(await fs.readFile(file, 'utf8'));
+    return normalize(data);
+  } catch {
+    return clone(DEFAULT_PROJECTS);
+  }
+}
+
+async function write(cfg) {
+  await userconfig.ensureUserConfig();
+  const file = paths.userProjectsFile();
+  const data = normalize(cfg);
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, JSON.stringify(data, null, 2) + '\n', 'utf8');
+  await lifecycle.applySecureMode(file);
+  return file;
+}
+
+async function importPublishCodeConfig(file) {
+  const raw = JSON.parse(await fs.readFile(path.resolve(file), 'utf8'));
+  const cur = await read();
+  const out = normalize(cur);
+  const list = Array.isArray(raw.projectsList) ? raw.projectsList : [];
+  let imported = 0;
+  let skipped = 0;
+
+  for (const p of list) {
+    if (!p || !p.name) { skipped++; continue; }
+    out.projects[p.name] = {
+      ...(out.projects[p.name] || {}),
+      name: p.name,
+      id: p.id || undefined,
+      repoUrl: p.repoUrl || undefined,
+      gitlabProjectId: p.projectId ? String(p.projectId) : undefined,
+      tagFormat: p.tagFormat || undefined,
+      jenkins: compact({
+        test: p.testJenkinsUrl || undefined,
+        staging: p.stagingJenkinsUrl || undefined,
+      }),
+      deploy: mergeImportedDeployConfig(out.projects[p.name] && out.projects[p.name].deploy, p),
+    };
+    imported++;
+  }
+
+  if (raw.deployInfo && typeof raw.deployInfo === 'object') {
+    out.defaults.lastDeploy = compact({
+      project: raw.deployInfo.project_name,
+      currTag: raw.deployInfo.curr_tag_name,
+      oldTag: raw.deployInfo.old_tag_name,
+      modifyDesc: raw.deployInfo.modify_desc,
+      tester: raw.deployInfo.tester,
+      acceptor: raw.deployInfo.acceptor,
+      developerApprover: raw.deployInfo.developerApprover,
+    });
+  }
+
+  await write(out);
+  await seedProviderPlaceholders();
+  return { imported, skipped, file: paths.userProjectsFile() };
+}
+
+async function seedProviderPlaceholders() {
+  await userconfig.ensureUserConfig();
+  const file = paths.userProvidersFile();
+  let cur = {};
+  if (fsSync.existsSync(file)) {
+    try { cur = JSON.parse(await fs.readFile(file, 'utf8')); } catch { cur = {}; }
+  }
+  if (!cur['ci.jenkins']) {
+    cur['ci.jenkins'] = {
+      type: 'ci',
+      driver: 'jenkins',
+      config: {
+        user: '${env:JENKINS_USER}',
+        token: '${env:JENKINS_TOKEN}',
+      },
+    };
+  }
+  await fs.writeFile(file, JSON.stringify(cur, null, 2) + '\n', 'utf8');
+  await lifecycle.applySecureMode(file);
+}
+
+async function findProject(name) {
+  const cfg = await read();
+  const key = name || (cfg.defaults && cfg.defaults.lastDeploy && cfg.defaults.lastDeploy.project);
+  if (!key) return null;
+  return cfg.projects[key] || null;
+}
+
+async function resolveTestCommand({ project, env = 'test', kind, api = false }) {
+  const cfg = await read();
+  const p = project ? cfg.projects[project] : null;
+  const environment = cfg.environments && cfg.environments[env] ? cfg.environments[env] : {};
+  const tests = p && p.tests ? p.tests : {};
+  const profile = tests[kind] || {};
+  let command = profile.command;
+
+  if (!command && api) {
+    if (!environment.apiBaseUrl) {
+      return { command: null, reason: `apiBaseUrl missing for env=${env}` };
+    }
+    command = 'curl -fsS ${apiBaseUrl}/health';
+  }
+
+  if (!command) return { command: null, reason: `no ${kind} test command for project=${project || '-'}` };
+  return {
+    command: render(command, {
+      project,
+      env,
+      apiBaseUrl: environment.apiBaseUrl || '',
+    }),
+    framework: profile.framework || 'generic',
+    project,
+    env,
+  };
+}
+
+function normalize(data) {
+  return {
+    version: data.version || 1,
+    environments: data.environments || {},
+    projects: data.projects || {},
+    defaults: data.defaults || {},
+  };
+}
+
+function mergeImportedDeployConfig(existing, projectInput) {
+  const deploy = { ...(existing || {}) };
+  for (const [env, url] of [
+    ['test', projectInput.testJenkinsUrl],
+    ['staging', projectInput.stagingJenkinsUrl],
+  ]) {
+    if (!isUrl(url)) continue;
+    deploy[env] = {
+      ...(deploy[env] || {}),
+      includeDefaultParams: deploy[env] && deploy[env].includeDefaultParams !== undefined
+        ? deploy[env].includeDefaultParams
+        : false,
+    };
+  }
+  return deploy;
+}
+
+function render(s, vars) {
+  return String(s).replace(/\$\{([a-zA-Z0-9_]+)\}/g, (_, k) => vars[k] == null ? '' : String(vars[k]));
+}
+
+function compact(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== undefined && v !== null && v !== '') out[k] = v;
+  }
+  return out;
+}
+
+function clone(v) {
+  return JSON.parse(JSON.stringify(v));
+}
+
+function isUrl(value) {
+  return /^https?:\/\//i.test(String(value || ''));
+}
+
+module.exports = {
+  read,
+  write,
+  importPublishCodeConfig,
+  findProject,
+  resolveTestCommand,
+  _internals: { normalize, render, compact, mergeImportedDeployConfig },
+};

package/src/core/state.js

@@ -0,0 +1,200 @@
+'use strict';
+const fs = require('fs/promises');
+const path = require('path');
+const paths = require('./paths.js');
+const fsSync = require('fs');
+
+const STATE_VERSION = 1;
+
+const PHASES = [
+  'intake',
+  'requirement',
+  'design',
+  'plan',
+  'apply',
+  'review',
+  'verify',
+  'deliver',
+  'archive',
+];
+
+const DEFAULT_ENABLED = {
+  'tests.md': false,
+  'delta': false,
+  'reports.unit': false,
+  'reports.integration': false,
+  'reports.e2e': false,
+  'reports.smoke': false,
+  'reports.self_test': false,
+  'reports.regression': false,
+  'reports.perf': false,
+};
+
+function newState({ slug, title, level = 'L2', source }) {
+  const now = new Date().toISOString();
+  const phases = {};
+  for (const p of PHASES) phases[p] = { status: 'pending' };
+  return {
+    $schema: 'https://devflow.dev/schemas/state.schema.json',
+    version: STATE_VERSION,
+    slug,
+    title: title || slug,
+    level,
+    source: source || null,
+    currentPhase: 'intake',
+    phases,
+    checkpoints: [],
+    riskSignals: [],
+    iterations: { review: 0, apply: 0 },
+    enabled: applyLevelDefaults(level, { ...DEFAULT_ENABLED }),
+    providers: {},
+    auditLog: [{ ts: now, event: 'created' }],
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+function applyLevelDefaults(level, enabled) {
+  if (level === 'L0') {
+    enabled['reports.unit'] = true;
+  } else if (level === 'L1') {
+    enabled['reports.unit'] = true;
+    enabled['reports.smoke'] = true;
+  } else if (level === 'L2') {
+    enabled['reports.unit'] = true;
+    enabled['reports.integration'] = true;
+    enabled['reports.smoke'] = true;
+    enabled['reports.self_test'] = true;
+  } else if (level === 'L3') {
+    for (const k of Object.keys(enabled)) enabled[k] = true;
+    enabled['reports.perf'] = false;
+  }
+  return enabled;
+}
+
+async function read(root, slug) {
+  const file = resolveStateFile(root, slug);
+  const buf = await fs.readFile(file, 'utf8');
+  return JSON.parse(buf);
+}
+
+async function write(root, slug, state) {
+  state.updatedAt = new Date().toISOString();
+  const file = resolveStateFile(root, slug, { forWrite: true });
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+function resolveStateFile(root, slug, { forWrite = false } = {}) {
+  const workspace = paths.stateFile(root, slug);
+  const legacy = path.join(paths.devflowDir(root), 'changes', slug, 'state.json');
+  const legacyDir = path.dirname(legacy);
+  if (forWrite) {
+    if (fsSync.existsSync(workspace)) return workspace;
+    if (fsSync.existsSync(legacyDir)) return legacy;
+    return workspace;
+  }
+  if (fsSync.existsSync(workspace)) return workspace;
+  if (fsSync.existsSync(legacy)) return legacy;
+  return workspace;
+}
+
+function logEvent(state, event, extra) {
+  state.auditLog = state.auditLog || [];
+  state.auditLog.push({ ts: new Date().toISOString(), event, ...(extra || {}) });
+}
+
+function setPhase(state, phase, status) {
+  if (!state.phases[phase]) state.phases[phase] = {};
+  state.phases[phase].status = status;
+  state.phases[phase].ts = new Date().toISOString();
+  if (status === 'in_progress' || status === 'completed') {
+    state.currentPhase = phase;
+  }
+}
+
+function passCheckpoint(state, name) {
+  state.checkpoints = state.checkpoints || [];
+  state.checkpoints.push({
+    name,
+    status: 'passed',
+    ts: new Date().toISOString(),
+  });
+}
+
+function addRiskSignal(state, { type, reason, source = 'manual', evidence = [], status = 'open' }) {
+  if (!type) throw new Error('risk signal type is required');
+  state.riskSignals = state.riskSignals || [];
+  const now = new Date().toISOString();
+  const existing = state.riskSignals.find((r) => r.type === type && (r.status || 'open') === 'open');
+  if (existing) {
+    existing.reason = reason || existing.reason || '';
+    existing.source = source || existing.source || 'manual';
+    existing.evidence = mergeList(existing.evidence, evidence);
+    existing.updatedAt = now;
+    return existing;
+  }
+  const item = {
+    type,
+    status,
+    reason: reason || '',
+    source,
+    evidence: Array.isArray(evidence) ? evidence : [evidence].filter(Boolean),
+    createdAt: now,
+    updatedAt: now,
+  };
+  state.riskSignals.push(item);
+  return item;
+}
+
+function openRiskSignals(state, types) {
+  const allowed = types ? new Set(types) : null;
+  return (state.riskSignals || []).filter((r) => {
+    const status = r.status || 'open';
+    return status === 'open' && (!allowed || allowed.has(r.type));
+  });
+}
+
+function resolveRiskSignal(state, type, { evidence = [], reason = '' } = {}) {
+  return closeRiskSignal(state, type, 'resolved', { evidence, reason });
+}
+
+function acceptRiskSignal(state, type, { reason = '', evidence = [] } = {}) {
+  return closeRiskSignal(state, type, 'accepted', { evidence, reason });
+}
+
+function closeRiskSignal(state, type, status, { evidence = [], reason = '' } = {}) {
+  state.riskSignals = state.riskSignals || [];
+  const now = new Date().toISOString();
+  const targets = state.riskSignals.filter((r) => r.type === type && (r.status || 'open') === 'open');
+  for (const r of targets) {
+    r.status = status;
+    r.reason = reason || r.reason || '';
+    r.evidence = mergeList(r.evidence, evidence);
+    r.updatedAt = now;
+  }
+  return targets;
+}
+
+function mergeList(a = [], b = []) {
+  const left = Array.isArray(a) ? a : [a].filter(Boolean);
+  const right = Array.isArray(b) ? b : [b].filter(Boolean);
+  return [...new Set([...left, ...right].filter(Boolean))];
+}
+
+module.exports = {
+  STATE_VERSION,
+  PHASES,
+  DEFAULT_ENABLED,
+  newState,
+  applyLevelDefaults,
+  read,
+  write,
+  logEvent,
+  setPhase,
+  passCheckpoint,
+  addRiskSignal,
+  openRiskSignals,
+  resolveRiskSignal,
+  acceptRiskSignal,
+};