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

package/tests/doctor.test.js

@@ -0,0 +1,94 @@
+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 CodexAdapter = require('../bin/adapters/codex');
+const GeminiAdapter = require('../bin/adapters/gemini');
+
+describe('Doctor Command', () => {
+    let workDir;
+
+    beforeEach(() => {
+        workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'doctor-test-'));
+        // Setup mock environment
+        // Gemini
+        fs.mkdirSync(path.join(workDir, '.agent', 'agents'), { recursive: true });
+        fs.mkdirSync(path.join(workDir, '.agent', 'skills'), { recursive: true });
+        fs.mkdirSync(path.join(workDir, '.agent', 'rules'), { recursive: true });
+        fs.mkdirSync(path.join(workDir, '.agent', 'workflows'), { recursive: true });
+        fs.writeFileSync(path.join(workDir, '.agent', 'agents', 'orchestrator.md'), '# orchestrator');
+        fs.writeFileSync(path.join(workDir, '.agent', 'skills', 'doc.md'), '# skills');
+        fs.writeFileSync(path.join(workDir, '.agent', 'rules', 'GEMINI.md'), '# rules');
+        fs.writeFileSync(path.join(workDir, '.agent', 'workflows', 'create.md'), '# workflow');
+        // Codex
+        fs.mkdirSync(path.join(workDir, '.agents'));
+        fs.writeFileSync(path.join(workDir, '.agents', 'manifest.json'), JSON.stringify({ version: 2, target: 'codex', files: {} }));
+    });
+
+    afterEach(() => {
+        fs.rmSync(workDir, { recursive: true, force: true });
+    });
+
+    test('GeminiAdapter checkIntegrity ok', () => {
+        const adapter = new GeminiAdapter(workDir, { quiet: true });
+        const res = adapter.checkIntegrity();
+        assert.strictEqual(res.status, 'ok');
+    });
+
+    test('GeminiAdapter checkIntegrity missing', () => {
+        fs.rmSync(path.join(workDir, '.agent'), { recursive: true });
+        const adapter = new GeminiAdapter(workDir, { quiet: true });
+        const res = adapter.checkIntegrity();
+        assert.strictEqual(res.status, 'missing');
+    });
+
+    test('GeminiAdapter checkIntegrity should flag missing required files', () => {
+        fs.rmSync(path.join(workDir, '.agent', 'rules', 'GEMINI.md'));
+        const adapter = new GeminiAdapter(workDir, { quiet: true });
+        const res = adapter.checkIntegrity();
+        assert.strictEqual(res.status, 'broken');
+        assert.ok(res.issues.some((issue) => issue.includes('.agent/rules/GEMINI.md')));
+    });
+
+    test('CodexAdapter checkIntegrity ok', () => {
+        const adapter = new CodexAdapter(workDir, { quiet: true });
+        const res = adapter.checkIntegrity();
+        assert.strictEqual(res.status, 'ok');
+    });
+
+    test('CodexAdapter checkIntegrity missing', () => {
+        fs.rmSync(path.join(workDir, '.agents'), { recursive: true });
+        const adapter = new CodexAdapter(workDir, { quiet: true });
+        const res = adapter.checkIntegrity();
+        assert.strictEqual(res.status, 'missing');
+    });
+
+    test('CodexAdapter checkIntegrity should flag legacy .codex directory', () => {
+        fs.mkdirSync(path.join(workDir, '.codex'), { recursive: true });
+        const adapter = new CodexAdapter(workDir, { quiet: true });
+        const res = adapter.checkIntegrity();
+        assert.strictEqual(res.status, 'broken');
+        assert.ok(res.issues.some((issue) => issue.includes('.codex')));
+    });
+
+    test('CodexAdapter checkIntegrity should flag invalid manifest JSON', () => {
+        fs.writeFileSync(path.join(workDir, '.agents', 'manifest.json'), '{invalid-json');
+        const adapter = new CodexAdapter(workDir, { quiet: true });
+        const res = adapter.checkIntegrity();
+        assert.strictEqual(res.status, 'broken');
+        assert.ok(res.issues.some((issue) => issue.includes('invalid JSON')));
+    });
+
+    test('CodexAdapter fixIntegrity should migrate legacy .codex directory', () => {
+        fs.rmSync(path.join(workDir, '.agents'), { recursive: true, force: true });
+        fs.mkdirSync(path.join(workDir, '.codex'), { recursive: true });
+        fs.writeFileSync(path.join(workDir, '.codex', 'manifest.json'), JSON.stringify({ version: 2, target: 'codex', files: {} }));
+        fs.writeFileSync(path.join(workDir, '.codex', 'legacy.txt'), 'legacy');
+        const adapter = new CodexAdapter(workDir, { quiet: true });
+        const res = adapter.fixIntegrity();
+        assert.ok(res.fixed);
+        assert.ok(fs.existsSync(path.join(workDir, '.agents')));
+        assert.ok(!fs.existsSync(path.join(workDir, '.codex')));
+    });
+});

package/tests/gemini-adapter.test.js

@@ -0,0 +1,30 @@
+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 GeminiAdapter = require("../bin/adapters/gemini");
+
+describe("GeminiAdapter", () => {
+    let workDir;
+
+    beforeEach(() => {
+        workDir = fs.mkdtempSync(path.join(os.tmpdir(), "gemini-adapter-test-"));
+    });
+
+    afterEach(() => {
+        fs.rmSync(workDir, { recursive: true, force: true });
+    });
+
+    test("update should work when source and target are the same directory", () => {
+        const agentDir = path.join(workDir, ".agent");
+        fs.mkdirSync(agentDir, { recursive: true });
+        fs.writeFileSync(path.join(agentDir, "SKILL.md"), "same-source-target", "utf8");
+
+        const adapter = new GeminiAdapter(workDir, { quiet: true });
+        adapter.update(agentDir);
+
+        assert.ok(fs.existsSync(path.join(agentDir, "SKILL.md")));
+        assert.strictEqual(fs.readFileSync(path.join(agentDir, "SKILL.md"), "utf8"), "same-source-target");
+    });
+});

package/tests/generator.test.js

@@ -0,0 +1,48 @@
+const { test, describe } = require('node:test');
+const assert = require('node:assert');
+const RuleGenerator = require('../bin/core/generator');
+
+describe('RuleGenerator', () => {
+    test('generate should keep codex managed guidance on .agents layout', () => {
+        const transformResult = {
+            metadata: [
+                {
+                    id: 'test-skill',
+                    originalName: 'test-skill',
+                    path: 'skills/test-skill/SKILL.md',
+                    type: 'skill',
+                },
+            ],
+        };
+
+        const { agentsMd, antigravityRules, codexJson } = RuleGenerator.generate(transformResult, '2.0.1');
+
+        assert.ok(agentsMd.includes('test-skill'));
+        assert.ok(agentsMd.includes('ag-kit doctor --target codex --fix'));
+        assert.ok(agentsMd.includes('.agents/skills'));
+
+        assert.ok(antigravityRules.includes('Managed skills are stored under `.agents/skills`.'));
+        assert.ok(!antigravityRules.includes('.codex'));
+
+        assert.strictEqual(codexJson.version, '2.0.1');
+        assert.strictEqual(codexJson.skills.length, 1);
+        assert.strictEqual(codexJson.skills[0].id, 'test-skill');
+    });
+
+    test('generate should work with empty metadata', () => {
+        const transformResult = { metadata: [] };
+        const { agentsMd, antigravityRules, codexJson } = RuleGenerator.generate(transformResult, '2.0.1');
+
+        assert.ok(agentsMd.includes('Codex Managed'));
+        assert.ok(antigravityRules.includes('Antigravity Risk Controls'));
+        assert.deepStrictEqual(codexJson.skills, []);
+    });
+
+    test('generate should require explicit version', () => {
+        const transformResult = { metadata: [] };
+        assert.throws(
+            () => RuleGenerator.generate(transformResult),
+            /需要显式传入版本号/,
+        );
+    });
+});

package/tests/git-helper.test.js

@@ -0,0 +1,53 @@
+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 GitHelper = require('../bin/utils/git-helper');
+
+describe('GitHelper', () => {
+    let workDir;
+    let gitIgnorePath;
+
+    beforeEach(() => {
+        workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'git-helper-test-'));
+        gitIgnorePath = path.join(workDir, '.gitignore');
+    });
+
+    afterEach(() => {
+        fs.rmSync(workDir, { recursive: true, force: true });
+    });
+
+    test('removeIgnoreRules should remove target patterns', () => {
+        const content = `
+# Comment
+node_modules
+.agent
+src/
+.codex/
+        `.trim();
+        fs.writeFileSync(gitIgnorePath, content);
+
+        const result = GitHelper.removeIgnoreRules(workDir, ['.agent', '.codex'], { dryRun: false });
+        
+        assert.strictEqual(result.removedCount, 2);
+        
+        const newContent = fs.readFileSync(gitIgnorePath, 'utf8');
+        assert.ok(!newContent.includes('.agent'));
+        assert.ok(!newContent.includes('.codex'));
+        assert.ok(newContent.includes('node_modules'));
+    });
+
+    test('removeIgnoreRules should respect dryRun', () => {
+        const content = `.agent\n.codex`;
+        fs.writeFileSync(gitIgnorePath, content);
+
+        const result = GitHelper.removeIgnoreRules(workDir, ['.agent'], { dryRun: true });
+        
+        assert.strictEqual(result.removedCount, 1);
+        assert.strictEqual(result.dryRun, true);
+        
+        const newContent = fs.readFileSync(gitIgnorePath, 'utf8');
+        assert.strictEqual(newContent, content); // Should not change
+    });
+});

package/tests/global-sync.test.js

@@ -0,0 +1,133 @@
+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 { spawnSync } = require("node:child_process");
+
+const REPO_ROOT = path.resolve(__dirname, "..");
+const CLI_PATH = path.join(REPO_ROOT, "bin", "ag-kit.js");
+
+function runCli(args, options = {}) {
+    const env = {
+        ...process.env,
+        AG_KIT_SKIP_UPSTREAM_CHECK: "1",
+        ...options.env,
+    };
+
+    return spawnSync(process.execPath, [CLI_PATH, ...args], {
+        cwd: options.cwd || REPO_ROOT,
+        env,
+        encoding: "utf8",
+    });
+}
+
+describe("Global Sync", () => {
+    let tempDir;
+
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ag-kit-global-sync-test-"));
+    });
+
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    test("global status should report missing when no global skills installed", () => {
+        const result = runCli(["global", "status", "--quiet"], {
+            env: { AG_KIT_GLOBAL_ROOT: tempDir },
+        });
+        assert.strictEqual(result.status, 2);
+        assert.strictEqual((result.stdout || "").trim(), "missing");
+    });
+
+    test("global status should report broken when target root exists but skills are incomplete", () => {
+        fs.mkdirSync(path.join(tempDir, ".codex"), { recursive: true });
+
+        const result = runCli(["global", "status", "--quiet"], {
+            env: { AG_KIT_GLOBAL_ROOT: tempDir },
+        });
+        assert.strictEqual(result.status, 1);
+        assert.strictEqual((result.stdout || "").trim(), "broken");
+    });
+
+    test("global sync should install codex skills into $HOME/.codex/skills", () => {
+        const result = runCli(["global", "sync", "--target", "codex", "--quiet"], {
+            env: { AG_KIT_GLOBAL_ROOT: tempDir },
+        });
+        assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+
+        const skillsRoot = path.join(tempDir, ".codex", "skills");
+        assert.ok(fs.existsSync(skillsRoot), "missing global codex skills root");
+        assert.ok(fs.existsSync(path.join(skillsRoot, "clean-code", "SKILL.md")), "missing expected skill: clean-code");
+        assert.ok(fs.existsSync(path.join(skillsRoot, "workflow-plan", "SKILL.md")), "missing expected workflow skill: workflow-plan");
+    });
+
+    test("global sync should default to syncing codex and gemini when no target is provided", () => {
+        const result = runCli(["global", "sync", "--quiet"], {
+            env: { AG_KIT_GLOBAL_ROOT: tempDir },
+        });
+        assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+
+        const codexRoot = path.join(tempDir, ".codex", "skills");
+        assert.ok(fs.existsSync(path.join(codexRoot, "clean-code", "SKILL.md")), "missing expected codex skill: clean-code");
+        assert.ok(fs.existsSync(path.join(codexRoot, "workflow-plan", "SKILL.md")), "missing expected codex workflow skill: workflow-plan");
+
+        const geminiCliRoot = path.join(tempDir, ".gemini", "skills");
+        assert.ok(fs.existsSync(path.join(geminiCliRoot, "clean-code", "SKILL.md")), "missing expected gemini-cli skill: clean-code");
+
+        const antigravityRoot = path.join(tempDir, ".gemini", "antigravity", "skills");
+        assert.ok(fs.existsSync(path.join(antigravityRoot, "clean-code", "SKILL.md")), "missing expected antigravity skill: clean-code");
+    });
+
+    test("global status should report installed after global sync", () => {
+        const syncResult = runCli(["global", "sync", "--quiet"], {
+            env: { AG_KIT_GLOBAL_ROOT: tempDir },
+        });
+        assert.strictEqual(syncResult.status, 0, syncResult.stderr || syncResult.stdout);
+
+        const statusResult = runCli(["global", "status", "--quiet"], {
+            env: { AG_KIT_GLOBAL_ROOT: tempDir },
+        });
+        assert.strictEqual(statusResult.status, 0, statusResult.stderr || statusResult.stdout);
+        assert.strictEqual((statusResult.stdout || "").trim(), "installed");
+    });
+
+    test("global sync should install gemini skills into both ~/.gemini/skills and ~/.gemini/antigravity/skills", () => {
+        const result = runCli(["global", "sync", "--target", "gemini", "--quiet"], {
+            env: { AG_KIT_GLOBAL_ROOT: tempDir },
+        });
+        assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+
+        const geminiCliRoot = path.join(tempDir, ".gemini", "skills");
+        assert.ok(fs.existsSync(geminiCliRoot), "missing global gemini-cli skills root");
+        assert.ok(fs.existsSync(path.join(geminiCliRoot, "clean-code", "SKILL.md")), "missing expected gemini-cli skill: clean-code");
+
+        const antigravityRoot = path.join(tempDir, ".gemini", "antigravity", "skills");
+        assert.ok(fs.existsSync(antigravityRoot), "missing global antigravity skills root");
+        assert.ok(fs.existsSync(path.join(antigravityRoot, "clean-code", "SKILL.md")), "missing expected antigravity skill: clean-code");
+    });
+
+    test("global sync should create backup when overwriting an existing skill", () => {
+        const skillsRoot = path.join(tempDir, ".codex", "skills", "clean-code");
+        fs.mkdirSync(skillsRoot, { recursive: true });
+        fs.writeFileSync(path.join(skillsRoot, "SKILL.md"), "modified", "utf8");
+
+        const result = runCli(["global", "sync", "--target", "codex", "--quiet"], {
+            env: { AG_KIT_GLOBAL_ROOT: tempDir },
+        });
+        assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+
+        const backupRoot = path.join(tempDir, ".ag-kit", "backups", "global");
+        assert.ok(fs.existsSync(backupRoot), "missing backup root");
+
+        const timestamps = fs
+            .readdirSync(backupRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+        assert.ok(timestamps.length > 0, "backup timestamp directory missing");
+
+        const backupSkillPath = path.join(backupRoot, timestamps[0], "codex", "clean-code", "SKILL.md");
+        assert.ok(fs.existsSync(backupSkillPath), "backup for clean-code skill missing");
+    });
+});

package/tests/health-check-script.test.js

@@ -0,0 +1,30 @@
+const { test, describe } = require("node:test");
+const assert = require("node:assert");
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("node:child_process");
+
+describe("Health Check Script", () => {
+    test("health-check script should exist and be executable", () => {
+        const scriptPath = path.resolve(__dirname, "..", "scripts", "health-check.sh");
+        assert.ok(fs.existsSync(scriptPath), "missing scripts/health-check.sh");
+        fs.accessSync(scriptPath, fs.constants.X_OK);
+    });
+
+    test("health-check node entry should exist", () => {
+        const scriptPath = path.resolve(__dirname, "..", "scripts", "health-check.js");
+        assert.ok(fs.existsSync(scriptPath), "missing scripts/health-check.js");
+    });
+
+    test("health-check script should pass bash syntax check", () => {
+        const scriptPath = path.resolve(__dirname, "..", "scripts", "health-check.sh");
+        const result = spawnSync("bash", ["-n", scriptPath], { encoding: "utf8" });
+        assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+    });
+
+    test("package scripts should expose health-check command", () => {
+        const packageJsonPath = path.resolve(__dirname, "..", "package.json");
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+        assert.strictEqual(packageJson.scripts["health-check"], "node scripts/health-check.js");
+    });
+});

package/tests/managed-block.test.js

@@ -0,0 +1,41 @@
+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 { upsertManagedBlock } = require("../bin/utils/managed-block");
+
+describe("ManagedBlock", () => {
+    let tempDir;
+    let targetFile;
+
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "managed-block-test-"));
+        targetFile = path.join(tempDir, "AGENTS.md");
+    });
+
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    test("should append managed block without removing user content", () => {
+        fs.writeFileSync(targetFile, "# User Content\n\ncustom text\n", "utf8");
+        const result = upsertManagedBlock(targetFile, "codex-core-rules", "managed line");
+
+        assert.strictEqual(result.action, "appended");
+        const content = fs.readFileSync(targetFile, "utf8");
+        assert.ok(content.includes("User Content"));
+        assert.ok(content.includes("BEGIN AG-KIT MANAGED BLOCK: codex-core-rules"));
+        assert.ok(content.includes("managed line"));
+    });
+
+    test("should update existing managed block in place", () => {
+        upsertManagedBlock(targetFile, "codex-core-rules", "v1");
+        const result = upsertManagedBlock(targetFile, "codex-core-rules", "v2");
+
+        assert.strictEqual(result.action, "updated");
+        const content = fs.readFileSync(targetFile, "utf8");
+        assert.ok(content.includes("v2"));
+        assert.ok(!content.includes("v1"));
+    });
+});

package/tests/manifest.test.js

@@ -0,0 +1,97 @@
+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 ManifestManager = require('../bin/utils/manifest');
+
+describe('ManifestManager', () => {
+    let tempDir;
+
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'manifest-test-'));
+    });
+
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    test('computeHash should return correct sha256', () => {
+        const content = 'hello world';
+        // echo -n "hello world" | shasum -a 256
+        const expected = 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9';
+        assert.strictEqual(ManifestManager.computeHash(content), expected);
+    });
+
+    test('generateFromDir should exclude directories and map files', () => {
+        const file1 = path.join(tempDir, 'file1.txt');
+        const dir1 = path.join(tempDir, 'dir1');
+        const file2 = path.join(dir1, 'file2.txt');
+
+        fs.writeFileSync(file1, 'content1');
+        fs.mkdirSync(dir1);
+        fs.writeFileSync(file2, 'content2');
+
+        const manifest = ManifestManager.generateFromDir(tempDir);
+        
+        // Rel paths depend on OS separator, but manifest logic normalizes to /
+        assert.strictEqual(manifest['file1.txt'], ManifestManager.computeHash('content1'));
+        assert.strictEqual(manifest['dir1/file2.txt'], ManifestManager.computeHash('content2'));
+    });
+
+    test('checkDrift should detect modifications and missing files', () => {
+        const manifestPath = path.join(tempDir, 'manifest.json');
+        const file1 = path.join(tempDir, 'file1.txt');
+        
+        fs.writeFileSync(file1, 'original');
+        
+        const mgr = new ManifestManager(manifestPath);
+        mgr.manifest.files = ManifestManager.generateFromDir(tempDir);
+        mgr.save();
+
+        // 1. No Drift
+        let drift = mgr.checkDrift(tempDir);
+        assert.strictEqual(drift.modified.length, 0);
+        assert.strictEqual(drift.missing.length, 0);
+
+        // 2. Modified
+        fs.writeFileSync(file1, 'modified');
+        drift = mgr.checkDrift(tempDir);
+        assert.strictEqual(drift.modified.length, 1);
+        assert.strictEqual(drift.modified[0], 'file1.txt');
+
+        // 3. Missing
+        fs.rmSync(file1);
+        drift = mgr.checkDrift(tempDir);
+        assert.strictEqual(drift.missing.length, 1);
+        assert.strictEqual(drift.missing[0], 'file1.txt');
+    });
+
+    test('collectSmartOverwriteConflicts should only return true user conflicts', () => {
+        const manifestPath = path.join(tempDir, 'manifest.json');
+        const file1 = path.join(tempDir, 'file1.txt');
+
+        fs.writeFileSync(file1, 'original');
+
+        const mgr = new ManifestManager(manifestPath);
+        mgr.manifest.files = ManifestManager.generateFileEntriesFromDir(tempDir, { baseDir: tempDir });
+        mgr.save();
+
+        // user modified file
+        fs.writeFileSync(file1, 'user-modified');
+
+        const incoming = {
+            'file1.txt': {
+                hash: ManifestManager.computeHash('next-version'),
+                source: 'bundled/file1.txt',
+            },
+        };
+        const conflicts = mgr.collectSmartOverwriteConflicts(tempDir, incoming);
+        assert.deepStrictEqual(conflicts, ['file1.txt']);
+
+        // if local already equals incoming hash, no conflict backup needed
+        fs.writeFileSync(file1, 'next-version');
+        const noConflicts = mgr.collectSmartOverwriteConflicts(tempDir, incoming);
+        assert.deepStrictEqual(noConflicts, []);
+    });
+});

package/tests/package-tarball.test.js

@@ -0,0 +1,27 @@
+const { test, describe } = require("node:test");
+const assert = require("node:assert");
+const path = require("path");
+const { spawnSync } = require("node:child_process");
+
+const REPO_ROOT = path.resolve(__dirname, "..");
+
+describe("Package Tarball", () => {
+    test("npm pack --dry-run should include maintenance scripts and tests", () => {
+        const result = spawnSync("npm", ["pack", "--json", "--dry-run"], {
+            cwd: REPO_ROOT,
+            encoding: "utf8",
+        });
+        assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+
+        const payload = JSON.parse(result.stdout);
+        assert.ok(Array.isArray(payload) && payload.length > 0, "missing npm pack json payload");
+
+        const files = new Set(payload[0].files.map((item) => item.path));
+        assert.ok(files.has("scripts/clean.js"), "tarball missing scripts/clean.js");
+        assert.ok(files.has("scripts/ci-verify.js"), "tarball missing scripts/ci-verify.js");
+        assert.ok(files.has("scripts/health-check.js"), "tarball missing scripts/health-check.js");
+        assert.ok(files.has("scripts/health-check.sh"), "tarball missing scripts/health-check.sh");
+        assert.ok(files.has("tests/cli-smoke.test.js"), "tarball missing tests/cli-smoke.test.js");
+        assert.ok(files.has("tests/global-sync.test.js"), "tarball missing tests/global-sync.test.js");
+    });
+});

package/tests/phase-c.test.js

@@ -0,0 +1,107 @@
+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 CodexAdapter = require('../bin/adapters/codex');
+const pkg = require('../package.json');
+
+describe('Phase C Integration', () => {
+    let workDir;
+    let geminiRepo;
+
+    beforeEach(() => {
+        workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'phase-c-test-'));
+        geminiRepo = path.join(workDir, 'gemini-repo');
+        
+        // Setup specialized Gemini-like structure
+        const agentDir = path.join(geminiRepo, '.agent');
+        const skillsDir = path.join(agentDir, 'skills');
+        const workflowsDir = path.join(agentDir, 'workflows');
+        
+        fs.mkdirSync(skillsDir, { recursive: true });
+        fs.mkdirSync(workflowsDir, { recursive: true });
+        
+        // Create a Skill
+        const skillPath = path.join(skillsDir, 'test-skill');
+        fs.mkdirSync(skillPath);
+        fs.writeFileSync(path.join(skillPath, 'SKILL.md'), '# Test Skill');
+        
+        // Create a Workflow
+        fs.writeFileSync(path.join(workflowsDir, 'test-flow.md'), '# Test Workflow');
+    });
+
+    afterEach(() => {
+        fs.rmSync(workDir, { recursive: true, force: true });
+    });
+
+    test('CodexAdapter should build from Gemini structure on the fly', () => {
+        const options = { quiet: true, force: true };
+        const adapter = new CodexAdapter(workDir, options);
+        
+        // Install from Gemini Repo Root
+        adapter.install(geminiRepo);
+        
+        const codexDir = path.join(workDir, '.agents');
+        // Verification 1: Structure Created
+        assert.ok(fs.existsSync(codexDir));
+        
+        // Verification 2: Transformation Happened
+        const builtSkill = path.join(codexDir, 'skills', 'test-skill', 'SKILL.md');
+        assert.ok(fs.existsSync(builtSkill));
+        
+        // Workflow: workflow-test-flow
+        const builtWorkflow = path.join(codexDir, 'skills', 'workflow-test-flow', 'SKILL.md');
+        assert.ok(fs.existsSync(builtWorkflow));
+        
+        // Verification 3: Manifest & Meta
+        assert.ok(fs.existsSync(path.join(codexDir, 'codex.json')));
+        assert.ok(fs.existsSync(path.join(codexDir, 'AGENTS.md')));
+        assert.ok(fs.existsSync(path.join(codexDir, 'antigravity.rules')));
+        
+        const agentsMd = fs.readFileSync(path.join(codexDir, 'AGENTS.md'), 'utf8');
+        assert.ok(agentsMd.includes('test-skill'));
+        assert.ok(agentsMd.includes('(Codex Managed)'));
+
+        // Verification 4: Workspace managed block injection
+        const workspaceAgents = fs.readFileSync(path.join(workDir, 'AGENTS.md'), 'utf8');
+        const workspaceRules = fs.readFileSync(path.join(workDir, 'antigravity.rules'), 'utf8');
+        assert.ok(workspaceAgents.includes('BEGIN AG-KIT MANAGED BLOCK: codex-core-rules'));
+        assert.ok(workspaceAgents.includes('test-skill'));
+        assert.ok(workspaceRules.includes('BEGIN AG-KIT MANAGED BLOCK: codex-risk-controls'));
+
+        const codexJson = JSON.parse(fs.readFileSync(path.join(codexDir, 'codex.json'), 'utf8'));
+        assert.strictEqual(codexJson.version, pkg.version);
+        assert.ok(agentsMd.includes(`Version: ${pkg.version}`));
+        assert.ok(workspaceRules.includes(`version: ${pkg.version}`));
+    });
+
+    test('CodexBuilder should avoid ID collisions between skills and workflows', () => {
+        const skillCollisionPath = path.join(geminiRepo, '.agent', 'skills', 'wf-test-flow');
+        fs.mkdirSync(skillCollisionPath, { recursive: true });
+        fs.writeFileSync(path.join(skillCollisionPath, 'SKILL.md'), '# Skill wf-test-flow');
+
+        const options = { quiet: true, force: true };
+        const adapter = new CodexAdapter(workDir, options);
+        adapter.install(geminiRepo);
+
+        const codexJson = JSON.parse(
+            fs.readFileSync(path.join(workDir, '.agents', 'codex.json'), 'utf8')
+        );
+        const collisionEntries = (codexJson.skills || []).filter(
+            (item) => item.originalName === 'wf-test-flow' || item.originalName === 'test-flow'
+        );
+
+        assert.strictEqual(collisionEntries.length, 2, 'skill/workflow should both be preserved');
+        assert.notStrictEqual(
+            collisionEntries[0].id,
+            collisionEntries[1].id,
+            'colliding IDs should be disambiguated',
+        );
+
+        for (const entry of collisionEntries) {
+            const skillFile = path.join(workDir, '.agents', entry.path);
+            assert.ok(fs.existsSync(skillFile), `missing transformed file: ${entry.path}`);
+        }
+    });
+});