@chenguangyao/devflow-kit 0.1.43

package/src/cli/commands/init.js

@@ -0,0 +1,341 @@
+'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 markers = require('../../core/markers.js');
+const templates = require('../../templates/index.js');
+const autodetect = require('../../core/autodetect.js');
+const skillsCmd = require('./skills.js');
+const userconfig = require('../../providers/userconfig.js');
+
+const IDE_TARGETS = {
+  claude: '.claude/CLAUDE.md',
+  cursor: '.cursor/rules/devflow.mdc',
+  agents: 'AGENTS.md',
+};
+
+const PROJECT_OVERVIEW_CANDIDATES = [
+  '.claude/CLAUDE.md',
+  'CLAUDE.md',
+  'PROJECT.md',
+  'AGENTS.md',
+  '.cursor/rules/project.mdc',
+  'docs/project-overview.md',
+  'docs/architecture.md',
+  'README.md',
+];
+
+async function run({ flags = {}, cwd }) {
+  const root = cwd || process.cwd();
+  log.info(`initializing devflow in ${root}`);
+
+  const targetsArg = flags.targets || flags.target;
+  const targets = (typeof targetsArg === 'string')
+    ? targetsArg.split(',').map((s) => s.trim()).filter(Boolean)
+    : ['claude', 'cursor', 'agents'];
+
+  const overviewMode = flags['overview-mode'] || flags.overviewMode || 'reference';
+
+  // IDE mode controls whether we write the per-project IDE marker files
+  // (.claude/CLAUDE.md, .cursor/rules/devflow.mdc, AGENTS.md):
+  //
+  //   full     — write workflow + project-overview to every selected target
+  //              (legacy behavior; useful when no user-wide skills are installed)
+  //   minimal  — skip all IDE writes; rely on user-wide skill +
+  //              devflow/config.json#projectOverview.referencedFile to brief the AI
+  //   none     — same as minimal but also doesn't print any "skipped" log noise
+  //
+  // Default = 'auto':
+  //   user-wide skills detected ? minimal : full
+  //
+  // Reasoning: when ~/.cursor/skills/devflow-kit/ is present, the orchestrator
+  // SKILL.md already documents every command and gate. Per-project IDE files
+  // become pure duplication of static workflow content — only the project-
+  // overview reference is per-project, but the skill reads that directly from
+  // devflow/config.json on session start, so even THAT can be skipped.
+  const ideModeRaw = flags.ide || flags['ide-mode'] || flags.ideMode || 'auto';
+  if (!['auto', 'full', 'minimal', 'none'].includes(ideModeRaw)) {
+    log.warn(`unknown --ide=${ideModeRaw} (expected: auto|full|minimal|none); falling back to auto`);
+  }
+  const ideMode = ['full', 'minimal', 'none'].includes(ideModeRaw)
+    ? ideModeRaw
+    : (skillsCmd.userSkillsInstalled() ? 'minimal' : 'full');
+
+  await ensureSkeleton(root);
+
+  // Ensure ~/.devflow/providers.json exists (empty skeleton, chmod 0600).
+  // All provider credentials live there by default; project-level
+  // <repo>/devflow/providers.json may override individual entries.
+  try {
+    const uc = await userconfig.ensureUserConfig();
+    if (uc.created.providers) {
+      log.ok(`user config: ${path.join('~', '.devflow', 'providers.json')} (created, empty)`);
+      if (uc.created.example) log.dim(`provider example: ${path.join('~', '.devflow', 'providers.example.json')}`);
+      log.dim('       fill it via "devflow provider add <name>" or edit directly');
+    } else {
+      log.dim(`user config: ${path.join('~', '.devflow', 'providers.json')} (already exists)`);
+    }
+  } catch (err) {
+    log.warn(`user config bootstrap failed: ${err.message}`);
+  }
+
+  const cfg = await config.ensure(root);
+  cfg.ide = cfg.ide || {};
+  cfg.ide.targets = targets;
+  cfg.ide.mode = ideMode;
+  cfg.projectOverview = cfg.projectOverview || {};
+  cfg.projectOverview.mode = overviewMode;
+
+  // Auto-detect project attributes (git remote / language / build tool / jenkins candidates)
+  const skipDetect = flags['no-detect'] === true || flags.detect === false;
+  if (!skipDetect) {
+    const d = await autodetect.detect(root);
+    cfg.detect = {
+      remoteUrl: d.remoteUrl || null,
+      remote: d.remote || null,
+      language: d.language,
+      buildTool: d.buildTool || null,
+      defaultBranch: d.defaultBranch || 'main',
+      jenkinsJobCandidates: d.jenkinsJobs,
+      detectedAt: new Date().toISOString(),
+    };
+    log.ok('autodetect:');
+    for (const line of autodetect.formatSummary(d).split('\n')) log.raw(line);
+  }
+
+  // Detect project overview source
+  const overviewSource = await detectProjectOverview(root, cfg.projectOverview.candidates || PROJECT_OVERVIEW_CANDIDATES);
+  cfg.projectOverview.referencedFile = overviewSource;
+  await config.write(root, cfg);
+
+  log.ok(`config: ${path.relative(root, paths.configFile(root))}`);
+
+  // Render workflow marker section (always)
+  const workflowBody = (await templates.load('ide/devflow-workflow.md')).trim();
+
+  // Render project overview marker section (mode-aware)
+  let overviewBody;
+  if (overviewMode === 'reference' && overviewSource) {
+    overviewBody = templates.render(
+      (await templates.load('ide/project-overview-reference.md')).trim(),
+      { overviewSource }
+    );
+  } else if (overviewMode === 'reference' && !overviewSource) {
+    overviewBody = `> 未检测到项目概览文件。可运行 \`df switch project-overview --mode=generate\` 让 devflow 生成,或手动创建 CLAUDE.md / PROJECT.md 后重跑 \`df sync project\`。`;
+  } else if (overviewMode === 'supplement' || overviewMode === 'generate') {
+    overviewBody = templates.render(
+      (await templates.load('ide/project-overview.md')).trim(),
+      {
+        overviewSource: overviewSource || '(none)',
+        stack: '(待填)',
+        frameworks: '(待填)',
+        packageManager: '(待填)',
+        modules: '- (待填)',
+        commands: '# 列出常用命令',
+        codingStyle: '- (待填)',
+        testingStyle: '- (待填)',
+      }
+    );
+  }
+
+  // IDE marker writes — gated by ideMode (see top of run() for rationale).
+  //
+  //   full      → every selected target gets workflow + project-overview marker
+  //   minimal   → no IDE files touched; one log line explains why
+  //   none      → silent skip
+  if (ideMode === 'full') {
+    for (const t of targets) {
+      const rel = IDE_TARGETS[t];
+      if (!rel) {
+        log.warn(`unknown ide target: ${t} (skip)`);
+        continue;
+      }
+      const file = path.join(root, rel);
+      if (overviewBody !== undefined) {
+        await markers.upsertSection(file, 'project-overview', overviewBody);
+      }
+      await markers.upsertSection(file, 'workflow', workflowBody);
+      log.ok(`ide: ${rel}`);
+    }
+  } else if (ideMode === 'minimal') {
+    log.ok('ide: minimal mode (skipped per-project IDE files)');
+    log.dim('     workflow content lives in user-wide skills: ~/.cursor/skills, ~/.claude/skills, ~/.agents/skills');
+    log.dim(`     project overview is read from devflow/config.json#projectOverview.referencedFile${overviewSource ? ` (= ${overviewSource})` : ' (none detected)'}`);
+    log.dim('     override per-project: devflow init --ide=full');
+
+    // If a previous `devflow init --ide=full` already populated IDE files,
+    // hint the user that those marker sections are now redundant. We don't
+    // delete them automatically — the file may have other (non-devflow)
+    // content the user cares about.
+    const stale = [];
+    for (const t of targets) {
+      const rel = IDE_TARGETS[t];
+      if (!rel) continue;
+      const file = path.join(root, rel);
+      if (!fsSync.existsSync(file)) continue;
+      try {
+        const content = await fs.readFile(file, 'utf8');
+        if (content.includes('BEGIN devflow:workflow')) stale.push(rel);
+      } catch { /* ignore */ }
+    }
+    if (stale.length) {
+      log.dim(`     note: ${stale.length} stale IDE file(s) from a previous --ide=full init: ${stale.join(', ')}`);
+      log.dim('           remove obsolete devflow markers via:  devflow update --ide-clean');
+    }
+  } // ideMode === 'none' → silent skip
+
+  // .gitignore additions
+  await ensureGitignore(root);
+
+  // Optional CI templates — render with detected default branch so the
+  // generated YAML matches whatever the repo actually uses (main vs master).
+  const withCi = flags['with-ci'] || flags.withCi;
+  if (withCi) {
+    const tokens = String(withCi).split(',').map((s) => s.trim()).filter(Boolean);
+    const defaultBranch = (cfg.detect && cfg.detect.defaultBranch) || 'main';
+    for (const t of tokens) await installCi(root, t, { defaultBranch });
+  }
+
+  // Skill install policy:
+  //   --no-skills                : skip
+  //   --skills-target=cursor,... : explicit project-local install
+  //   (default)                  : if user-wide skills already exist, skip; otherwise per-project install
+  const skipSkills = flags['no-skills'] === true || flags.skills === false;
+  if (!skipSkills) {
+    const skillsTargetArg = flags['skills-target'] || flags.skillsTarget;
+    if (skillsTargetArg) {
+      const skillTargets = String(skillsTargetArg).split(',').map((s) => s.trim()).filter(Boolean);
+      try {
+        const summary = await skillsCmd.installForInit(root, skillTargets, { quiet: true });
+        for (const s of summary) log.ok(`skills: ${s.count} installed → ${s.path}`);
+      } catch (err) {
+        log.warn(`skills install failed: ${err.message} (run "devflow skills install" manually)`);
+      }
+    } else if (skillsCmd.userSkillsInstalled()) {
+      log.ok('skills: user-wide install detected (~/.cursor/skills, ~/.claude/skills, ~/.agents/skills) — skipping per-project copy');
+      log.dim('       (override with --skills-target=cursor,claude,agents)');
+    } else {
+      try {
+        const summary = await skillsCmd.installForInit(root, targets, { quiet: true });
+        for (const s of summary) log.ok(`skills: ${s.count} installed → ${s.path}`);
+        log.dim('  tip: run `devflow skills install --scope=user` once to share skills across all projects');
+      } catch (err) {
+        log.warn(`skills auto-install failed: ${err.message} (run "devflow skills install" manually)`);
+      }
+    }
+  }
+
+  log.raw('');
+  log.ok('done. next:');
+  // Surface the wizard prominently if no providers are configured yet — this is
+  // the most common "I just installed it, now what?" moment.
+  try {
+    const userCfgFile = paths.userProvidersFile();
+    let userCfg = {};
+    if (fsSync.existsSync(userCfgFile)) {
+      try { userCfg = JSON.parse(await fs.readFile(userCfgFile, 'utf8')); } catch { /* ignore */ }
+    }
+    if (Object.keys(userCfg).length === 0) {
+      log.dim('  devflow provider setup                   # ★ interactive: pick & configure providers');
+    }
+  } catch { /* ignore */ }
+  log.dim('  devflow ingest <wiki-url|issue-id>      # primary entry');
+  log.dim('  devflow new <slug>                       # fallback (brainstorm)');
+  log.dim('  devflow status / devflow doctor          # inspect');
+}
+
+async function ensureSkeleton(root) {
+  // Flat knowledge dirs: ~/.devflow/workspace/knowledge/<中文名>/  e.g. 架构决策/
+  const { CATEGORY_TAG_NAMES, resolveTagInfo } = require('../../knowledge/categories.js');
+  const knowledgeCatDirs = Object.values(CATEGORY_TAG_NAMES).map(
+    (info) => path.join(paths.workspaceKnowledgeRoot(), info.name),
+  );
+  const dirs = [
+    paths.devflowDir(root),
+    paths.specsDir(root),
+    paths.changesDir(root),
+    paths.archiveDir(root),
+    ...knowledgeCatDirs,
+  ];
+  for (const d of dirs) await fs.mkdir(d, { recursive: true });
+
+  // knowledge index.json
+  const idx = path.join(paths.workspaceKnowledgeRoot(), 'index.json');
+  if (!fsSync.existsSync(idx)) {
+    const tpl = await templates.load('knowledge-index.json');
+    await fs.writeFile(idx, tpl, 'utf8');
+  }
+
+  // .meta.json placeholders
+  const metaTpl = await templates.load('meta.json');
+  for (const d of knowledgeCatDirs) {
+    const meta = path.join(d, '.meta.json');
+    if (!fsSync.existsSync(meta)) {
+      const dirName = path.basename(d);  // Chinese name, e.g. "架构决策"
+      await fs.writeFile(meta, templates.render(metaTpl, {
+        category: dirName,
+        tag_name: dirName,
+      }), 'utf8');
+    }
+  }
+}
+
+async function detectProjectOverview(root, candidates) {
+  for (const rel of candidates) {
+    const p = path.join(root, rel);
+    if (!fsSync.existsSync(p)) continue;
+    // skip if it's just a devflow-managed file
+    try {
+      const c = await fs.readFile(p, 'utf8');
+      if (c.includes('BEGIN devflow:project-overview') && !c.replace(/<!--[\s\S]*?-->/g, '').trim()) {
+        continue; // file is empty besides our markers
+      }
+    } catch { /* ignore */ }
+    return rel;
+  }
+  return null;
+}
+
+async function installCi(root, kind, opts = {}) {
+  const map = {
+    gh:        { tpl: 'ci/github.yml', target: '.github/workflows/devflow.yml' },
+    github:    { tpl: 'ci/github.yml', target: '.github/workflows/devflow.yml' },
+    gl:        { tpl: 'ci/gitlab.yml', target: '.gitlab-ci.devflow.yml' },
+    gitlab:    { tpl: 'ci/gitlab.yml', target: '.gitlab-ci.devflow.yml' },
+  };
+  const m = map[kind.toLowerCase()];
+  if (!m) { log.warn(`unknown ci target: ${kind} (skip)`); return; }
+  const targetAbs = path.join(root, m.target);
+  if (fsSync.existsSync(targetAbs)) { log.dim(`ci: ${m.target} (exists, skip)`); return; }
+  await fs.mkdir(path.dirname(targetAbs), { recursive: true });
+  const body = await templates.renderFile(m.tpl, {
+    defaultBranch: opts.defaultBranch || 'main',
+  });
+  await fs.writeFile(targetAbs, body, 'utf8');
+  log.ok(`ci: ${m.target} (branch=${opts.defaultBranch || 'main'})`);
+}
+
+async function ensureGitignore(root) {
+  const file = path.join(root, '.gitignore');
+  let content = '';
+  try { content = await fs.readFile(file, 'utf8'); } catch { /* new file */ }
+  const lines = content.split(/\r?\n/);
+  const want = [
+    '# devflow',
+    'devflow/changes/*/refs/screenshots/',
+    'devflow/.cache/',
+  ];
+  let changed = false;
+  for (const w of want) {
+    if (!lines.includes(w)) { lines.push(w); changed = true; }
+  }
+  if (changed) {
+    while (lines.length && lines[lines.length - 1] === '') lines.pop();
+    await fs.writeFile(file, lines.join('\n') + '\n', 'utf8');
+  }
+}
+
+module.exports = { run };