@mison/ag-kit-cn 3.0.0-beta.0 → 3.0.0

package/scripts/health-check.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("node:child_process");
+
+const ROOT_DIR = path.resolve(__dirname, "..");
+
+function logStep(message) {
+    console.log(`[health-check] ${message}`);
+}
+
+function runCommand(command, options = {}) {
+    const result = spawnSync(command, {
+        cwd: options.cwd || ROOT_DIR,
+        env: {
+            ...process.env,
+            ...options.env,
+        },
+        encoding: "utf8",
+        shell: true,
+    });
+
+    if (result.status !== 0) {
+        const detail = result.stderr || result.stdout || "";
+        throw new Error(`${command}\n${detail}`.trim());
+    }
+
+    return result.stdout || "";
+}
+
+function commandExists(command) {
+    const probe = spawnSync(command, {
+        encoding: "utf8",
+        shell: true,
+        stdio: "ignore",
+    });
+    return probe.status === 0;
+}
+
+function main() {
+    logStep("检查运行环境");
+    if (!commandExists("node --version")) {
+        throw new Error("缺少命令: node");
+    }
+
+    const packageRunner = commandExists("bun --version") ? "bun" : "npm";
+    if (!commandExists(`${packageRunner} --version`)) {
+        throw new Error(`缺少命令: ${packageRunner}`);
+    }
+
+    logStep("执行测试套件");
+    if (packageRunner === "bun") {
+        runCommand("bun run test");
+    } else {
+        runCommand("npm test --silent");
+    }
+
+    logStep("验证 CLI 核心链路");
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ag-kit-health-check-"));
+    try {
+        const workspaceDir = path.join(tempRoot, "workspace");
+        const indexPath = path.join(tempRoot, "workspaces.json");
+        const globalRoot = path.join(tempRoot, "global-root");
+        fs.mkdirSync(workspaceDir, { recursive: true });
+
+        const env = {
+            AG_KIT_INDEX_PATH: indexPath,
+            AG_KIT_GLOBAL_ROOT: globalRoot,
+            AG_KIT_SKIP_UPSTREAM_CHECK: "1",
+        };
+
+        runCommand(`node bin/ag-kit.js init --targets gemini,codex --path "${workspaceDir}" --quiet`, { env });
+
+        const status = runCommand(`node bin/ag-kit.js status --path "${workspaceDir}" --quiet`, { env }).trim();
+        if (status !== "installed") {
+            throw new Error(`status 结果异常: ${status}`);
+        }
+
+        runCommand(`node bin/ag-kit.js doctor --path "${workspaceDir}" --quiet`, { env });
+        runCommand(`node bin/ag-kit.js update --path "${workspaceDir}" --quiet`, { env });
+        runCommand("node bin/ag-kit.js update-all --dry-run --quiet", { env });
+        runCommand(`node bin/ag-kit.js exclude add --path "${workspaceDir}" --quiet`, { env });
+
+        const excluded = runCommand("node bin/ag-kit.js exclude list --quiet", { env });
+        if (!excluded.split(/\r?\n/).includes(workspaceDir)) {
+            throw new Error("exclude add 未生效");
+        }
+
+        runCommand(`node bin/ag-kit.js exclude remove --path "${workspaceDir}" --quiet`, { env });
+        const excludedAfter = runCommand("node bin/ag-kit.js exclude list --quiet", { env });
+        if (excludedAfter.split(/\r?\n/).includes(workspaceDir)) {
+            throw new Error("exclude remove 未生效");
+        }
+
+        runCommand("node bin/ag-kit.js global sync --quiet", { env });
+        const globalStatus = runCommand("node bin/ag-kit.js global status --quiet", { env }).trim();
+        if (globalStatus !== "installed") {
+            throw new Error(`global status 结果异常: ${globalStatus}`);
+        }
+
+        const globalChecks = [
+            path.join(globalRoot, ".codex", "skills", "workflow-plan", "SKILL.md"),
+            path.join(globalRoot, ".gemini", "skills", "clean-code", "SKILL.md"),
+            path.join(globalRoot, ".gemini", "antigravity", "skills", "clean-code", "SKILL.md"),
+        ];
+        for (const targetPath of globalChecks) {
+            if (!fs.existsSync(targetPath)) {
+                throw new Error(`global sync 未生成预期文件: ${targetPath}`);
+            }
+        }
+    } finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+
+    logStep("执行清理预检");
+    if (packageRunner === "bun") {
+        runCommand("bun run clean:dry-run");
+    } else {
+        runCommand("npm run clean:dry-run --silent");
+    }
+
+    console.log("✅ 健康检查通过");
+}
+
+try {
+    main();
+} catch (err) {
+    console.error(`❌ ${err.message}`);
+    process.exit(1);
+}

package/scripts/health-check.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+node "${ROOT_DIR}/scripts/health-check.js" "$@"

package/tests/atomic-writer.test.js

@@ -0,0 +1,47 @@
+const { test, describe, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const AtomicWriter = require('../bin/utils/atomic-writer');
+
+describe('AtomicWriter', () => {
+    let workDir;
+    let sourceDir;
+    let targetDir;
+
+    beforeEach(() => {
+        workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'atomic-test-'));
+        sourceDir = path.join(workDir, 'source');
+        targetDir = path.join(workDir, 'target');
+        
+        fs.mkdirSync(sourceDir);
+        fs.writeFileSync(path.join(sourceDir, 'data.txt'), 'version 1');
+    });
+
+    afterEach(() => {
+        fs.rmSync(workDir, { recursive: true, force: true });
+    });
+
+    test('atomicCopyDir should copy directory when target does not exist', () => {
+        AtomicWriter.atomicCopyDir(sourceDir, targetDir);
+        
+        assert.ok(fs.existsSync(targetDir));
+        assert.strictEqual(fs.readFileSync(path.join(targetDir, 'data.txt'), 'utf8'), 'version 1');
+    });
+
+    test('atomicCopyDir should overwrite existing directory', () => {
+        // Setup initial target
+        fs.mkdirSync(targetDir);
+        fs.writeFileSync(path.join(targetDir, 'old.txt'), 'old data');
+        
+        // Prepare new source
+        fs.writeFileSync(path.join(sourceDir, 'data.txt'), 'version 2');
+
+        AtomicWriter.atomicCopyDir(sourceDir, targetDir);
+
+        assert.ok(fs.existsSync(targetDir));
+        assert.strictEqual(fs.readFileSync(path.join(targetDir, 'data.txt'), 'utf8'), 'version 2');
+        assert.ok(!fs.existsSync(path.join(targetDir, 'old.txt')), 'Old file should be gone');
+    });
+});

package/tests/clean-script.test.js

@@ -0,0 +1,77 @@
+const { test, describe, beforeEach, afterEach } = require("node:test");
+const assert = require("node:assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { parseArgs, runClean } = require("../scripts/clean");
+
+describe("Clean Script", () => {
+    let tempRoot;
+
+    beforeEach(() => {
+        tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ag-kit-clean-test-"));
+    });
+
+    afterEach(() => {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    });
+
+    test("parseArgs should parse dry-run and quiet options", () => {
+        const options = parseArgs(["--dry-run", "--quiet"]);
+        assert.strictEqual(options.dryRun, true);
+        assert.strictEqual(options.quiet, true);
+    });
+
+    test("runClean should remove existing generated directories", () => {
+        const targetA = path.join(tempRoot, "web", ".next");
+        const targetB = path.join(tempRoot, "web", "node_modules");
+        fs.mkdirSync(targetA, { recursive: true });
+        fs.mkdirSync(targetB, { recursive: true });
+        fs.writeFileSync(path.join(targetA, "cache.txt"), "x");
+        fs.writeFileSync(path.join(targetB, "dep.txt"), "x");
+
+        const result = runClean({
+            rootDir: tempRoot,
+            quiet: true,
+            targets: ["web/.next", "web/node_modules"],
+        });
+
+        assert.strictEqual(result.removedCount, 2);
+        assert.ok(!fs.existsSync(targetA));
+        assert.ok(!fs.existsSync(targetB));
+    });
+
+    test("runClean dry-run should not remove directories", () => {
+        const target = path.join(tempRoot, "web", ".next");
+        fs.mkdirSync(target, { recursive: true });
+
+        const result = runClean({
+            rootDir: tempRoot,
+            dryRun: true,
+            quiet: true,
+            targets: ["web/.next"],
+        });
+
+        assert.strictEqual(result.wouldRemoveCount, 1);
+        assert.ok(fs.existsSync(target));
+    });
+
+    test("runClean should skip missing paths", () => {
+        const result = runClean({
+            rootDir: tempRoot,
+            quiet: true,
+            targets: ["web/.next"],
+        });
+
+        assert.strictEqual(result.skippedCount, 1);
+        assert.strictEqual(result.results[0].reason, "not_found");
+    });
+
+    test("package scripts should keep scoped test and clean commands", () => {
+        const packageJsonPath = path.resolve(__dirname, "..", "package.json");
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+        assert.strictEqual(packageJson.scripts.test, "node --test \"tests/**/*.test.js\"");
+        assert.strictEqual(packageJson.scripts.clean, "node scripts/clean.js");
+    });
+});