@michaelxwb/code-flow 0.8.1 → 1.0.0

package/src/core/code-flow/validation.yml

@@ -1,59 +0,0 @@
-# validators 在每次 Stop 按“会话内编辑过的文件”匹配执行（quality_loop.stop_check）。
-# 全量测试 / e2e 等慢命令标 `heavy: true`：Stop 与任务 finish 都跳过（deferred_heavy），
-# 只由需求终验 verify-e2e / 归档与显式 /cf-validate 全量执行一次；结果按工作树内容指纹
-# 缓存，同一内容不会重复执行。
-validators:
-    - name: "Python 语法检查"
-      trigger: "**/*.py"
-      command: "python3 -m py_compile {files}"
-      timeout: 30000
-      on_fail: "检查语法错误"
-
-    - name: "TypeScript 类型检查"
-      trigger: "**/*.{ts,tsx}"
-      command: "npx tsc --noEmit"
-      timeout: 30000
-      skip_if_missing: true  # 未安装 typescript 时跳过（degrade 记录），不阻断
-      on_fail: "检查类型定义，参见 specs/frontend/quality-standards.md"
-
-    - name: "Vue 类型检查"
-      trigger: "**/*.vue"
-      command: "npx vue-tsc --noEmit"
-      timeout: 30000
-      skip_if_missing: true
-      on_fail: "检查 Vue 组件类型定义，参见 specs/frontend/component-specs.md"
-
-    - name: "ESLint"
-      trigger: "**/*.{ts,tsx,js,jsx,vue}"
-      command: "npx eslint {files}"
-      timeout: 15000
-      skip_if_missing: true
-      on_fail: "运行 npx eslint --fix 自动修复，参见 specs/frontend/quality-standards.md"
-
-    - name: "Stylelint"
-      trigger: "**/*.{css,scss,less}"
-      command: "npx stylelint {files}"
-      timeout: 15000
-      skip_if_missing: true
-      on_fail: "运行 npx stylelint --fix 自动修复，参见 specs/frontend/component-specs.md"
-
-    - name: "前端单元测试"
-      trigger: "**/*.{ts,tsx,js,jsx,vue}"
-      command: "npx vitest run --reporter=dot"
-      timeout: 60000
-      heavy: true
-      on_fail: "前端测试失败，检查组件渲染和 mock 是否需要更新"
-
-    - name: "Python 类型检查"
-      trigger: "**/*.py"
-      command: "python3 -m mypy {files}"
-      timeout: 30000
-      skip_if_missing: true  # 未安装 mypy 时跳过（degrade 记录），新项目不再被阻断
-      on_fail: "检查类型注解，参见 specs/backend/code-quality-performance.md"
-
-    - name: "Pytest"
-      trigger: "**/*.py"
-      command: "python3 -m pytest --tb=short -q"
-      timeout: 600000
-      heavy: true
-      on_fail: "测试失败，检查断言和 mock 是否需要更新"

package/src/migrate/runtime.js

@@ -1,213 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { spawnSync } = require('child_process');
-const runtime = require('../runtime');
-const pkg = require('../../package.json');
-
-function guardVersion(root) {
-  const version = fs.readFileSync(path.join(root, '.code-flow/.version'), 'utf8').trim();
-  if (!/^\d+\.\d+\.\d+$/.test(version)) throw new Error(`Invalid installed runtime version: ${version}`);
-  const installed = version.split('.').map(Number);
-  const target = pkg.version.split('.').map(Number);
-  for (let index = 0; index < 3; index++) {
-    if (installed[index] > target[index]) throw new Error(`Refusing runtime downgrade from ${version} to ${pkg.version}; update the CLI.`);
-    if (installed[index] < target[index]) return;
-  }
-}
-
-function walk(root, directory = '') {
-  const target = path.join(root, directory);
-  if (!fs.existsSync(target)) return [];
-  return fs.readdirSync(target, { withFileTypes: true }).flatMap(entry => {
-    if (entry.name === '__pycache__') return [];
-    const relative = path.join(directory, entry.name);
-    return entry.isDirectory() ? walk(root, relative) : [relative];
-  });
-}
-
-function platforms(root) {
-  const markers = { claude: '.claude/commands/cf-init.md', codex: '.agents/skills/cf-init/SKILL.md',
-    costrict: '.costrict/commands/cf-init.md', opencode: '.opencode/commands/cf-init.md' };
-  const found = Object.entries(markers).filter(([, marker]) => fs.existsSync(path.join(root, marker))).map(([name]) => name);
-  if (!found.length) throw new Error('No installed platform found; run code-flow init first.');
-  return found;
-}
-
-function inputs(root, installed) {
-  const core = path.join(__dirname, '../core/code-flow');
-  const files = [...Object.keys(runtime.artifactSources(installed)), ...walk(core).map(file => `.code-flow/${file}`),
-    '.code-flow/scripts/cf_codex_user_prompt_hook.py',
-    '.code-flow/.version', '.code-flow/.adapter-versions.json', '.code-flow/.runtime-install.json',
-    '.code-flow/.gitignore', 'AGENTS.md', 'CLAUDE.md', 'opencode.json', '.codex/config.toml',
-    ...Object.keys(runtime.hookContracts(installed))];
-  return [...new Set(files)].filter(file => fs.existsSync(path.join(root, file)));
-}
-
-function copyFile(root, target, relative) {
-  const destination = path.join(target, relative);
-  fs.mkdirSync(path.dirname(destination), { recursive: true });
-  fs.copyFileSync(path.join(root, relative), destination);
-}
-
-function writeJson(file, value) {
-  fs.writeFileSync(`${file}.tmp`, JSON.stringify(value, null, 2) + '\n');
-  fs.renameSync(`${file}.tmp`, file);
-}
-
-function staleScripts(root, installed) {
-  // 0.9 moved the flat cf_*.py implementation modules under codeflow/{hooks,cli};
-  // upgrades must remove the old flat files, keeping the 22 path-frozen shims.
-  const current = new Set(Object.keys(runtime.artifactSources(installed)));
-  return walk(root, '.code-flow/scripts')
-    .filter(file => file.endsWith('.py'))
-    .filter(file => !current.has(file.replace(/\\/g, '/')));
-}
-
-function prepare(root, locked = false) {
-  guardVersion(root);
-  const installed = platforms(root);
-  const id = `runtime-${Date.now()}-${process.pid}`;
-  const workspace = path.join(root, '.code-flow/migrations', id);
-  const staging = path.join(workspace, 'staging');
-  fs.mkdirSync(staging, { recursive: true });
-  fs.mkdirSync(path.join(workspace, 'backup'));
-  const stale = staleScripts(root, installed);
-  const original = [...new Set([...inputs(root, installed), ...stale])];
-  const sources = Object.fromEntries(original.map(file => [file, runtime.digest(path.join(root, file))]));
-  const journal = { schema_version: 1, id, root, platforms: installed,
-    status: 'staging', sources, hashes: {}, deletions: [], written: [] };
-  writeJson(path.join(workspace, 'journal.json'), journal);
-  if (locked) writeJson(path.join(root, '.code-flow/.runtime-migration.lock/owner.json'), { pid: process.pid, id });
-  for (const relative of original) {
-    copyFile(root, staging, relative);
-    copyFile(root, path.join(workspace, 'backup'), relative);
-  }
-  writeJson(path.join(staging, '.runtime-stage.json'), { root, id });
-  for (const platform of installed) {
-    const result = spawnSync(process.execPath, [path.join(__dirname, '../cli.js'), 'init', `--platform=${platform}`], {
-      cwd: staging, encoding: 'utf8', env: { ...process.env, CODE_FLOW_RUNTIME_STAGE: staging },
-    });
-    if (result.error || result.status !== 0) throw new Error(`Runtime staging failed: ${result.error || result.stderr || result.stdout}`);
-  }
-  for (const relative of stale) fs.rmSync(path.join(staging, relative), { force: true });
-  runtime.verify(staging);
-  const targets = walk(staging).filter(file => file !== '.runtime-stage.json' && !file.startsWith('.code-flow/backups/'));
-  const hashes = Object.fromEntries(targets.map(file => [file, runtime.digest(path.join(staging, file))]));
-  journal.deletions = original.filter(file => !fs.existsSync(path.join(staging, file)));
-  journal.hashes = hashes;
-  journal.status = 'prepared';
-  writeJson(path.join(workspace, 'journal.json'), journal);
-  return { workspace, journal, staging };
-}
-
-function restore(workspace, journal) {
-  const order = [...journal.written].reverse();
-  for (const relative of order) {
-    const target = path.join(journal.root, relative);
-    const backup = path.join(workspace, 'backup', relative);
-    if (fs.existsSync(backup)) copyFile(path.join(workspace, 'backup'), journal.root, relative);
-    else fs.rmSync(target, { force: true });
-  }
-  journal.status = 'rolled_back';
-  writeJson(path.join(workspace, 'journal.json'), journal);
-  return { status: journal.status, migration_id: journal.id };
-}
-
-function apply(root) {
-  let repairReason;
-  try {
-    runtime.verify(root, true);
-    return { status: 'already_migrated' };
-  } catch (error) {
-    repairReason = error.message;
-  }
-  const { workspace, journal, staging } = prepare(root, true);
-  try {
-    for (const [relative, hash] of Object.entries(journal.sources)) {
-      if (runtime.digest(path.join(root, relative)) !== hash) throw new Error(`Source changed during staging: ${relative}`);
-    }
-    journal.status = 'applying';
-    writeJson(path.join(workspace, 'journal.json'), journal);
-    const targets = Object.keys(journal.hashes).filter(file => file !== '.code-flow/.version');
-    for (const relative of journal.deletions) {
-      journal.written.push(relative);
-      writeJson(path.join(workspace, 'journal.json'), journal);
-      fs.rmSync(path.join(root, relative));
-    }
-    targets.push('.code-flow/.version');
-    for (const relative of targets) {
-      if (!journal.sources[relative] && fs.existsSync(path.join(root, relative))) throw new Error(`New target appeared: ${relative}`);
-      if (runtime.digest(path.join(staging, relative)) !== journal.hashes[relative]) throw new Error(`Staging drift: ${relative}`);
-      journal.written.push(relative);
-      writeJson(path.join(workspace, 'journal.json'), journal);
-      copyFile(staging, root, relative);
-    }
-    runtime.verify(root, true);
-    journal.status = 'committed';
-    writeJson(path.join(workspace, 'journal.json'), journal);
-    return { status: journal.status, migration_id: journal.id, platforms: journal.platforms, repair_reason: repairReason };
-  } catch (error) {
-    const result = restore(workspace, journal);
-    return { ...result, error: error.message };
-  }
-}
-
-function rollback(root, id) {
-  if (!/^runtime-\d+-\d+$/.test(id)) throw new Error('Invalid runtime migration id.');
-  const workspace = path.join(root, '.code-flow/migrations', id);
-  const journal = JSON.parse(fs.readFileSync(path.join(workspace, 'journal.json'), 'utf8'));
-  if (journal.root !== root) throw new Error('Migration belongs to a different project.');
-  if (journal.status === 'rolled_back') return { status: 'rolled_back', migration_id: id };
-  if (journal.status === 'committed') {
-    for (const [relative, hash] of Object.entries(journal.hashes)) {
-      if (runtime.digest(path.join(root, relative)) !== hash) throw new Error(`Rollback would overwrite subsequent changes: ${relative}`);
-    }
-  }
-  return restore(workspace, journal);
-}
-
-function withLock(root, values) {
-  const lock = path.join(root, '.code-flow/.runtime-migration.lock');
-  try {
-    fs.mkdirSync(lock);
-  } catch (error) {
-    if (error.code !== 'EEXIST') throw error;
-    const owner = JSON.parse(fs.readFileSync(path.join(lock, 'owner.json'), 'utf8'));
-    let live = true;
-    try { process.kill(owner.pid, 0); } catch (signalError) {
-      if (signalError.code !== 'ESRCH') throw signalError;
-      live = false;
-    }
-    if (live) throw new Error('Another runtime migration is running.');
-    if (values[0] !== '--rollback' || values[1] !== owner.id) {
-      throw new Error(`Interrupted migration; run code-flow migrate --runtime --rollback ${owner.id}`);
-    }
-    fs.rmSync(lock, { recursive: true });
-    fs.mkdirSync(lock);
-  }
-  writeJson(path.join(lock, 'owner.json'), { pid: process.pid, id: '' });
-  try {
-    return values[0] === '--apply' ? apply(root) : rollback(root, values[1]);
-  } finally {
-    fs.rmSync(lock, { recursive: true });
-  }
-}
-
-function run(root, values) {
-  if (values.length === 1 && values[0] === '--dry-run') {
-    const { workspace, journal } = prepare(root);
-    fs.rmSync(path.join(workspace, 'staging'), { recursive: true });
-    fs.rmSync(path.join(workspace, 'backup'), { recursive: true });
-    journal.status = 'previewed';
-    writeJson(path.join(workspace, 'journal.json'), journal);
-    return { status: journal.status, migration_id: journal.id, platforms: journal.platforms,
-      files: Object.keys(journal.hashes), apply: 'code-flow migrate --runtime --apply' };
-  }
-  if (values.length === 1 && values[0] === '--apply') return withLock(root, values);
-  if (values.length === 2 && values[0] === '--rollback') return withLock(root, values);
-  throw new Error('Choose --dry-run, --apply, or --rollback <id>.');
-}
-
-module.exports = { run };

package/src/migrate/spec-workflow.js

@@ -1,253 +0,0 @@
-"use strict";
-
-const childProcess = require("node:child_process");
-const crypto = require("node:crypto");
-const fs = require("node:fs");
-const path = require("node:path");
-
-const PREFLIGHT = path.join(__dirname, "../core/code-flow/scripts/codeflow/spec/cf_spec_migrate.py");
-
-function walkFiles(root, directory = root) {
-  const files = [];
-  if (!fs.existsSync(directory)) return files;
-  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-    const full = path.join(directory, entry.name);
-    const relative = path.relative(root, full);
-    if (entry.isDirectory() && relative === path.join(".code-flow", "migrations")) continue;
-    if (entry.isDirectory()) files.push(...walkFiles(root, full));
-    else files.push(relative);
-  }
-  return files.sort();
-}
-
-function migrationFiles(root) {
-  const entries = [".code-flow", ".claude", ".codex", ".costrict", ".opencode", ".agents", "AGENTS.md", "CLAUDE.md"];
-  const files = [];
-  for (const entry of entries) {
-    const target = path.join(root, entry);
-    if (!fs.existsSync(target)) continue;
-    if (fs.statSync(target).isDirectory()) files.push(...walkFiles(root, target));
-    else files.push(entry);
-  }
-  return [...new Set(files)].sort();
-}
-
-function hash(data) {
-  return crypto.createHash("sha256").update(data).digest("hex");
-}
-
-function sourceHashes(root) {
-  const result = {};
-  for (const relative of migrationFiles(root)) {
-    result[relative] = hash(fs.readFileSync(path.join(root, relative)));
-  }
-  return result;
-}
-
-function pythonCommand() {
-  return process.env.PYTHON || "python3";
-}
-
-function preview(root) {
-  const project = fs.realpathSync(root);
-  const result = childProcess.spawnSync(
-    pythonCommand(), [PREFLIGHT, "preflight", "--root", project, "--json"],
-    { encoding: "utf8", shell: false }
-  );
-  if (result.status !== 0) throw new Error(result.stderr || result.stdout || "preflight failed");
-  return JSON.parse(result.stdout);
-}
-
-function migrationId(root, hashes) {
-  const seed = `${root}\0${JSON.stringify(hashes)}\0${Date.now()}`;
-  return `spec-workflow-${hash(seed).slice(0, 12)}`;
-}
-
-function copyBackup(root, backup, hashes) {
-  for (const relative of Object.keys(hashes)) {
-    const target = path.join(backup, relative);
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-    fs.copyFileSync(path.join(root, relative), target);
-  }
-}
-
-function writeJson(target, value) {
-  fs.writeFileSync(target, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-}
-
-function prepare(root) {
-  const project = fs.realpathSync(root);
-  const plan = preview(project);
-  const hashes = sourceHashes(project);
-  const id = migrationId(project, hashes);
-  const workspace = path.join(project, ".code-flow", "migrations", id);
-  const backup = path.join(workspace, "backup");
-  const staging = path.join(workspace, "staging");
-  fs.mkdirSync(backup, { recursive: true });
-  fs.mkdirSync(staging, { recursive: true });
-  copyBackup(project, backup, hashes);
-  const preparedPlan = { ...plan, migration_id: id, project_root: project, source_hashes: hashes };
-  const status = plan.unresolved.length ? "prepared_blocked" : "prepared";
-  writeJson(path.join(workspace, "migration-plan.json"), preparedPlan);
-  writeJson(path.join(workspace, "journal.json"), { version: 1, migration_id: id, status, operations: [] });
-  return { migration_id: id, status, workspace, plan: path.join(workspace, "migration-plan.json") };
-}
-
-function readJson(target) {
-  return JSON.parse(fs.readFileSync(target, "utf8"));
-}
-
-function journalPaths(planPath) {
-  const workspace = path.dirname(planPath);
-  return { workspace, journal: path.join(workspace, "journal.json"), staging: path.join(workspace, "staging"), backup: path.join(workspace, "backup") };
-}
-
-function sameHashes(first, second) {
-  return JSON.stringify(first) === JSON.stringify(second);
-}
-
-function runStaging(planPath, locations) {
-  const result = childProcess.spawnSync(
-    pythonCommand(), [PREFLIGHT, "stage", "--plan", planPath, "--staging", locations.staging, "--json"],
-    { encoding: "utf8", shell: false }
-  );
-  if (result.status !== 0) throw new Error(result.stdout || result.stderr || "staging failed");
-  return JSON.parse(result.stdout);
-}
-
-function verifyStaging(staging, manifest) {
-  for (const item of manifest.targets) {
-    const target = path.join(staging, item.path);
-    if (!fs.existsSync(target) || hash(fs.readFileSync(target)) !== item.sha256) {
-      throw new Error(`staging hash mismatch: ${item.path}`);
-    }
-  }
-}
-
-function persistJournal(target, journal, status) {
-  journal.status = status;
-  writeJson(target, journal);
-}
-
-function targetEntries(manifest) {
-  return manifest.targets.filter((item) => item.path !== ".code-flow/.version");
-}
-
-function commitEntry(project, staging, item, journal, journalPath) {
-  const source = path.join(staging, item.path);
-  const target = path.join(project, item.path);
-  journal.operations.push({ path: item.path, status: "renaming" });
-  writeJson(journalPath, journal);
-  fs.mkdirSync(path.dirname(target), { recursive: true });
-  if (fs.existsSync(target)) fs.rmSync(target, { recursive: true, force: true });
-  fs.renameSync(source, target);
-  journal.operations[journal.operations.length - 1].status = "committed";
-  writeJson(journalPath, journal);
-}
-
-function obsoletePaths(plan, manifest) {
-  const targets = new Set(manifest.targets.map((item) => item.path));
-  return Object.keys(plan.source_hashes).filter((item) => item.startsWith(".code-flow/") && item !== ".code-flow/.version" && !targets.has(item));
-}
-
-function removeObsolete(project, paths) {
-  for (const relative of paths) fs.rmSync(path.join(project, relative), { recursive: true, force: true });
-}
-
-function restoreBackup(plan, locations, manifest) {
-  for (const item of manifest.targets || []) {
-    if (item.path !== ".code-flow/.version") fs.rmSync(path.join(plan.project_root, item.path), { recursive: true, force: true });
-  }
-  for (const relative of Object.keys(plan.source_hashes)) {
-    const source = path.join(locations.backup, relative);
-    const target = path.join(plan.project_root, relative);
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-    fs.copyFileSync(source, target);
-  }
-}
-
-function rollback(planPath, error = "requested") {
-  const plan = readJson(planPath);
-  const locations = journalPaths(planPath);
-  const journal = readJson(locations.journal);
-  try {
-    restoreBackup(plan, locations, journal.manifest || { targets: [] });
-    // A rolled-back plan must be re-appliable: stale staging content makes the
-    // next `stage` refuse ("staging root must be a pre-created empty directory").
-    if (fs.existsSync(locations.staging)) fs.rmSync(locations.staging, { recursive: true, force: true });
-    fs.mkdirSync(locations.staging, { recursive: true });
-    journal.error = String(error);
-    journal.operations = [];
-    persistJournal(locations.journal, journal, "rolled_back");
-    return { status: "rolled_back", migration_id: plan.migration_id };
-  } catch (restoreError) {
-    journal.error = String(restoreError);
-    persistJournal(locations.journal, journal, "recovery_required");
-    return { status: "recovery_required", migration_id: plan.migration_id };
-  }
-}
-
-function targetsMatch(project, manifest) {
-  return targetEntries(manifest).every((item) => {
-    const target = path.join(project, item.path);
-    return fs.existsSync(target) && hash(fs.readFileSync(target)) === item.sha256;
-  });
-}
-
-function finishVersion(plan, journal, journalPath) {
-  fs.writeFileSync(path.join(plan.project_root, ".code-flow/.version"), "0.6.0", "utf8");
-  persistJournal(journalPath, journal, "committed");
-  return { status: "committed", migration_id: plan.migration_id };
-}
-
-function recoverCommitting(plan, journal, locations, options) {
-  if (!targetsMatch(plan.project_root, journal.manifest)) return rollback(path.join(locations.workspace, "migration-plan.json"), "target hash mismatch");
-  if (options.interruptBeforeVersion) return { status: "committing", migration_id: plan.migration_id };
-  return finishVersion(plan, journal, locations.journal);
-}
-
-function apply(planPath, options = {}) {
-  const plan = readJson(planPath);
-  const locations = journalPaths(planPath);
-  // Guard: a plan carries an absolute project_root; applying a plan from a
-  // different project (e.g. a copy or a stale path) would hash-check and
-  // mutate that other project instead of cwd. The CLI always passes
-  // projectRoot; direct library callers keep the previous behavior.
-  if (options.projectRoot) {
-    const expectedRoot = fs.realpathSync(options.projectRoot);
-    if (fs.realpathSync(plan.project_root) !== expectedRoot) {
-      throw new Error(`migration plan targets ${plan.project_root}, not ${expectedRoot}`);
-    }
-  }
-  const versionPath = path.join(plan.project_root, ".code-flow/.version");
-  if (fs.existsSync(versionPath) && fs.readFileSync(versionPath, "utf8").trim() === "0.6.0") return { status: "already_migrated", migration_id: plan.migration_id };
-  const journal = readJson(locations.journal);
-  if (journal.status === "committing") return recoverCommitting(plan, journal, locations, options);
-  if (plan.unresolved.length) throw new Error("migration plan has unresolved items");
-  if (!sameHashes(sourceHashes(plan.project_root), plan.source_hashes)) throw new Error("source hash drift");
-  try {
-    const manifest = runStaging(planPath, locations);
-    verifyStaging(locations.staging, manifest);
-    journal.manifest = manifest;
-    persistJournal(locations.journal, journal, "committing");
-    let completed = 0;
-    for (const item of targetEntries(manifest)) {
-      if (options.failAfter === completed) throw new Error(`injected rename failure ${completed}`);
-      if (options.exdevAfter === completed) {
-        const exdev = new Error("injected EXDEV");
-        exdev.code = "EXDEV";
-        throw exdev;
-      }
-      commitEntry(plan.project_root, locations.staging, item, journal, locations.journal);
-      completed += 1;
-    }
-    removeObsolete(plan.project_root, obsoletePaths(plan, manifest));
-    removeObsolete(plan.project_root, manifest.deletions || []);
-    if (options.interruptBeforeVersion) return { status: "committing", migration_id: plan.migration_id };
-    return finishVersion(plan, journal, locations.journal);
-  } catch (error) {
-    return rollback(planPath, error);
-  }
-}
-
-module.exports = { apply, preview, prepare, rollback, sourceHashes, walkFiles };