@mison/ag-kit-cn 2.0.1

package/bin/core/builder.js

@@ -0,0 +1,80 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const ResourceLoader = require("./resource-loader");
+const ResourceTransformer = require("./transformer");
+const RuleGenerator = require("./generator");
+const pkg = require("../../package.json");
+
+class CodexBuilder {
+    /**
+     * Build a Codex structure from a legacy/source repository
+     * @param {string} sourceRoot Root of the repo (containing .agent/)
+     * @param {string} outputDir Directory to output the built .agents-compatible structure
+     */
+    static build(sourceRoot, outputDir) {
+        if (fs.existsSync(outputDir)) {
+            fs.rmSync(outputDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(outputDir, { recursive: true });
+
+        // 1. Load Resources
+        const loader = new ResourceLoader(sourceRoot);
+        const resources = loader.loadAll();
+
+        // 2. Transform
+        const transformResult = ResourceTransformer.transform(resources);
+
+        // 3. Execute File/Dir Copying based on Transform Map
+        for (const map of transformResult.mappedFiles) {
+             const dest = path.join(outputDir, map.destPath);
+             const destParent = path.dirname(dest);
+             
+             if (!fs.existsSync(destParent)) {
+                 fs.mkdirSync(destParent, { recursive: true });
+             }
+
+             if (map.isDir) {
+                 // Recursive copy
+                 CodexBuilder._copyDir(map.src, dest);
+             } else if (typeof map.content === "string") {
+                 fs.writeFileSync(dest, map.content);
+             } else {
+                 if (fs.existsSync(map.src)) {
+                    fs.copyFileSync(map.src, dest);
+                 }
+             }
+        }
+
+        // 4. Generate & Write Metadata
+        const { agentsMd, antigravityRules, codexJson } = RuleGenerator.generate(transformResult, pkg.version);
+        
+        fs.writeFileSync(path.join(outputDir, "codex.json"), `${JSON.stringify(codexJson, null, 2)}\n`);
+        fs.writeFileSync(path.join(outputDir, "AGENTS.md"), `${agentsMd}\n`);
+        fs.writeFileSync(path.join(outputDir, "antigravity.rules"), `${antigravityRules}\n`);
+
+        return {
+            outputDir,
+            stats: {
+                skills: resources.skills.length,
+                workflows: resources.workflows.length
+            }
+        };
+    }
+
+    static _copyDir(src, dest) {
+        fs.mkdirSync(dest, { recursive: true });
+        const entries = fs.readdirSync(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                CodexBuilder._copyDir(srcPath, destPath);
+            } else {
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+}
+
+module.exports = CodexBuilder;

package/bin/core/generator.js

@@ -0,0 +1,59 @@
+class RuleGenerator {
+    /**
+     * Generate content for AGENTS.md, antigravity.rules and codex.json
+     * @param {object} transformResult Result from Transformer
+     * @returns {object} { agentsMd: string, antigravityRules: string, codexJson: object }
+     */
+    static generate(transformResult, version) {
+        if (typeof version !== "string" || version.trim() === "") {
+            throw new Error("RuleGenerator.generate 需要显式传入版本号");
+        }
+        const { metadata } = transformResult;
+        
+        // 1. Generate codex.json
+        const codexJson = {
+            version: version,
+            updatedAt: new Date().toISOString(),
+            skills: metadata.map(m => ({
+                id: m.id,
+                originalName: m.originalName,
+                path: m.path
+            }))
+        };
+
+        // 2. Generate AGENTS.md managed section content
+        let agentsMd = `# AI Agent Capabilities (Codex Managed)\n\n`;
+        agentsMd += `> **Auto-generated by Antigravity Kit (Codex)**\n`;
+        agentsMd += `> Version: ${version}\n\n`;
+        
+        agentsMd += `## Available Skills\n\n`;
+        
+        for (const meta of metadata) {
+            agentsMd += `- **${meta.id}** (${meta.type})\n`;
+            agentsMd += `  - Path: \`${meta.path}\`\n`;
+        }
+        
+        agentsMd += `\n## Usage Rules\n\n`;
+        agentsMd += `1. Managed resources are synchronized under \`.agents/skills\`.\n`;
+        agentsMd += `2. Do not rename managed skill folders manually.\n`;
+        agentsMd += `3. Use \`ag-kit doctor --target codex --fix\` to recover missing managed artifacts.\n`;
+
+        // 3. Generate risk controls
+        let antigravityRules = `# Antigravity Risk Controls (Codex Managed)\n\n`;
+        antigravityRules += `version: ${version}\n`;
+        antigravityRules += `generated_at: ${new Date().toISOString()}\n\n`;
+        antigravityRules += `## Controls\n`;
+        antigravityRules += `- Managed skills are stored under \`.agents/skills\`.\n`;
+        antigravityRules += `- Keep generated skill IDs stable to avoid selector drift.\n`;
+        antigravityRules += `- If integrity checks fail, run \`ag-kit doctor --target codex --fix\`.\n`;
+        antigravityRules += `- Before destructive updates, preserve manual edits in source control.\n`;
+
+        return {
+            agentsMd,
+            antigravityRules,
+            codexJson
+        };
+    }
+}
+
+module.exports = RuleGenerator;

package/bin/core/resource-loader.js

@@ -0,0 +1,64 @@
+const fs = require("fs");
+const path = require("path");
+
+class ResourceLoader {
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+        this.skillsDir = path.join(rootDir, ".agent", "skills");
+        this.workflowsDir = path.join(rootDir, ".agent", "workflows");
+    }
+
+    /**
+     * Load all skills and workflows
+     */
+    loadAll() {
+        return {
+            skills: this.loadSkills(),
+            workflows: this.loadWorkflows()
+        };
+    }
+
+    loadSkills() {
+        if (!fs.existsSync(this.skillsDir)) return [];
+        
+        const skills = [];
+        const entries = fs.readdirSync(this.skillsDir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const skillPath = path.join(this.skillsDir, entry.name);
+                const skillFile = path.join(skillPath, "SKILL.md");
+                
+                if (fs.existsSync(skillFile)) {
+                    skills.push({
+                        name: entry.name,
+                        path: skillPath,
+                        entryFile: "SKILL.md", // Relative to skillPath
+                        type: "skill"
+                    });
+                }
+            }
+        }
+        return skills;
+    }
+
+    loadWorkflows() {
+        if (!fs.existsSync(this.workflowsDir)) return [];
+        
+        const workflows = [];
+        const entries = fs.readdirSync(this.workflowsDir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith(".md")) {
+                workflows.push({
+                    name: path.basename(entry.name, ".md"),
+                    path: path.join(this.workflowsDir, entry.name),
+                    type: "workflow"
+                });
+            }
+        }
+        return workflows;
+    }
+}
+
+module.exports = ResourceLoader;

package/bin/core/transformer.js

@@ -0,0 +1,208 @@
+const fs = require("fs");
+const path = require("path");
+
+class ResourceTransformer {
+    /**
+     * Transform raw resources into Codex-compatible structure
+     * @param {object} resources { skills: [], workflows: [] }
+     * @returns {object} { mappedFiles: [], metadata: [] }
+     */
+    static transform(resources) {
+        const result = {
+            mappedFiles: [], // List of { src, destPath }
+            metadata: []     // List of desc for rules
+        };
+        const usedIds = new Set();
+
+        function allocateUniqueId(baseId) {
+            let candidate = baseId;
+            let suffix = 2;
+            while (usedIds.has(candidate)) {
+                candidate = `${baseId}-${suffix}`;
+                suffix += 1;
+            }
+            usedIds.add(candidate);
+            return candidate;
+        }
+
+        function stripWrappingQuotes(value) {
+            const trimmed = String(value || "").trim();
+            if ((trimmed.startsWith("\"") && trimmed.endsWith("\"")) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+                return trimmed.slice(1, -1);
+            }
+            return trimmed;
+        }
+
+        function foldYamlBlock(lines) {
+            const paragraphs = [];
+            let current = [];
+
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed) {
+                    if (current.length > 0) {
+                        paragraphs.push(current.join(" "));
+                        current = [];
+                    }
+                    continue;
+                }
+                current.push(trimmed);
+            }
+
+            if (current.length > 0) {
+                paragraphs.push(current.join(" "));
+            }
+
+            return paragraphs.join("\n");
+        }
+
+        function collectIndentedLines(lines, startIndex) {
+            const collected = [];
+            let idx = startIndex;
+            let baseIndent = -1;
+
+            while (idx < lines.length) {
+                const line = lines[idx];
+                if (line.trim() === "") {
+                    if (collected.length > 0) {
+                        collected.push("");
+                    }
+                    idx += 1;
+                    continue;
+                }
+
+                const indentMatch = line.match(/^(\s+)/);
+                if (!indentMatch) {
+                    break;
+                }
+
+                const indentLength = indentMatch[1].length;
+                if (baseIndent < 0) {
+                    baseIndent = indentLength;
+                }
+                if (indentLength < baseIndent) {
+                    break;
+                }
+
+                collected.push(line.slice(baseIndent));
+                idx += 1;
+            }
+
+            return { lines: collected, nextIndex: idx - 1 };
+        }
+
+        function parseFrontmatter(content) {
+            const normalized = String(content || "").replace(/\r\n?/g, "\n");
+            if (!normalized.startsWith("---\n")) {
+                return { frontmatter: {}, body: normalized };
+            }
+
+            const match = normalized.match(/^---\n([\s\S]*?)\n---(?:\n|$)/);
+            if (!match) {
+                return { frontmatter: {}, body: normalized };
+            }
+
+            const fmRaw = match[1];
+            const frontmatter = {};
+            const lines = fmRaw.split("\n");
+
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const keyMatch = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+                if (!keyMatch) continue;
+
+                const key = keyMatch[1];
+                const inlineValue = keyMatch[2];
+                if (!key) continue;
+
+                if (inlineValue === "|" || inlineValue === ">") {
+                    const block = collectIndentedLines(lines, i + 1);
+                    i = Math.max(i, block.nextIndex);
+                    frontmatter[key] = inlineValue === ">"
+                        ? foldYamlBlock(block.lines)
+                        : block.lines.join("\n").trim();
+                    continue;
+                }
+
+                if (inlineValue.trim() === "") {
+                    const block = collectIndentedLines(lines, i + 1);
+                    if (block.lines.length > 0) {
+                        i = Math.max(i, block.nextIndex);
+                        frontmatter[key] = block.lines.join("\n").trim();
+                    } else {
+                        frontmatter[key] = "";
+                    }
+                    continue;
+                }
+
+                frontmatter[key] = stripWrappingQuotes(inlineValue);
+            }
+
+            const body = normalized.slice(match[0].length);
+            return { frontmatter, body };
+        }
+
+        // 1. Process Skills
+        // Strategy: Skill folder -> skills/<name>/SKILL.md
+        for (const skill of resources.skills) {
+            const codexName = allocateUniqueId(skill.name);
+            const destDir = `skills/${codexName}`;
+
+            // Keep the full skill folder to preserve resources/scripts exactly.
+            result.mappedFiles.push({
+                src: skill.path, // The folder
+                destPath: destDir,
+                isDir: true
+            });
+
+            result.metadata.push({
+                id: codexName,
+                originalName: skill.name,
+                type: "skill",
+                path: `${destDir}/SKILL.md`
+            });
+        }
+
+        // 2. Process Workflows
+        // Codex only understands skills. Convert each workflow markdown to a valid SKILL.md.
+        for (const workflow of resources.workflows) {
+            const codexName = allocateUniqueId(`workflow-${workflow.name}`);
+            const destDir = `skills/${codexName}`;
+
+            const rawWorkflow = fs.existsSync(workflow.path)
+                ? fs.readFileSync(workflow.path, "utf8")
+                : "";
+            const parsed = parseFrontmatter(rawWorkflow);
+            const descriptionRaw = parsed.frontmatter.description
+                || `Antigravity workflow bridge for /${workflow.name}`;
+            const description = JSON.stringify(String(descriptionRaw).replace(/\s+/g, " ").trim());
+
+            const generatedSkill = [
+                "---",
+                `name: ${codexName}`,
+                `description: ${description}`,
+                "---",
+                "",
+                parsed.body.trimStart(),
+                "",
+            ].join("\n");
+
+            result.mappedFiles.push({
+                content: generatedSkill,
+                destPath: `${destDir}/SKILL.md`,
+                isDir: false
+            });
+
+            result.metadata.push({
+                id: codexName,
+                originalName: workflow.name,
+                type: "workflow-as-skill",
+                path: `${destDir}/SKILL.md`
+            });
+        }
+
+        return result;
+    }
+}
+
+module.exports = ResourceTransformer;

package/bin/interactive.js

@@ -0,0 +1,65 @@
+const readline = require("readline");
+
+function createInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+
+function askQuestion(rl, query) {
+    return new Promise((resolve) => {
+        rl.question(query, (answer) => {
+            resolve(answer);
+        });
+    });
+}
+
+/**
+ * Prompt user to select targets from a list.
+ * Supports multiple selection by comma separated numbers or names.
+ * Currently simplified for 'gemini' and 'codex'.
+ * @param {object} options CLI options
+ * @returns {Promise<string[]>} List of selected targets
+ */
+async function selectTargets(options) {
+    if (options.nonInteractive) {
+        throw new Error("非交互模式下必须通过 --target 或 --targets 指定目标");
+    }
+
+    const rl = createInterface();
+    
+    try {
+        console.log("\n🎯 请选择要安装的目标 (多选请用逗号分隔):");
+        console.log("   1. Gemini (适用于 Cursor/VSCode)");
+        console.log("   2. Codex (兼容性增强版)");
+        
+        const answer = await askQuestion(rl, "\n请输入序号或名称（必填）: ");
+        const input = answer.trim();
+
+        if (!input) {
+            throw new Error("必须选择至少一个目标");
+        }
+        
+        const selection = [];
+        const parts = input.split(/[,，\s]+/);
+        
+        for (const part of parts) {
+            const p = part.toLowerCase();
+            if (p === "1" || p === "gemini") selection.push("gemini");
+            else if (p === "2" || p === "codex") selection.push("codex");
+        }
+
+        if (selection.length === 0) {
+            throw new Error("无效的目标选择，请输入 1 / 2 / gemini / codex（可多选）");
+        }
+
+        return [...new Set(selection)];
+    } finally {
+        rl.close();
+    }
+}
+
+module.exports = {
+    selectTargets
+};

package/bin/utils/atomic-writer.js

@@ -0,0 +1,97 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+class AtomicWriter {
+    /**
+     * Atomically copy a directory structure.
+     * 1. Copies source to a temp directory.
+     * 2. Renames temp directory to target directory (atomic on POSIX, nearly atomic win32 move).
+     * 
+     * @param {string} sourceDir Source directory path
+     * @param {string} targetDir Target directory path
+     * @param {object} options { logger: function, force: boolean }
+     */
+    static atomicCopyDir(sourceDir, targetDir, options = {}) {
+        const log = options.logger || console.log;
+        const tempName = `.tmp-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+        const tempTarget = path.join(path.dirname(targetDir), tempName);
+
+        try {
+            // 1. Prepare temp dir
+            // Use copy logic (recursive)
+            AtomicWriter._copyDirRecursive(sourceDir, tempTarget);
+
+            // 2. Backup if exists (optional strategy, but standard atomic replace usually implies overwrite)
+            // If target exists, we need to remove it OR rename it away before renaming temp in?
+            // fs.rename overwrite behavior:
+            // - Linux/Mac: Atomic replacement if target exists (directory replacement rules apply).
+            // - Windows: rename fails if target exists.
+            
+            // 2. Atomic replacement logic:
+            // To be cross-platform safe and minimize the "missing target" window:
+            // 1. Rename existing targetDir to a temporary backup name.
+            // 2. Rename tempTarget to targetDir.
+            // 3. Delete the backup if 1 & 2 succeed.
+            if (fs.existsSync(targetDir)) {
+                const backupPath = `${targetDir}.bak-${Date.now()}-${Math.random().toString(36).substring(2, 5)}`;
+                try {
+                    fs.renameSync(targetDir, backupPath);
+                } catch (err) {
+                    // In some cases (e.g. Windows EPERM/EBUSY), rename might fail.
+                    // If we can't rename, the only fallback is direct deletion, but we prefer failing 
+                    // and asking user to stop processes than being non-atomic.
+                    throw new Error(`无法先行重命名旧目标目录 (${targetDir}): ${err.message}`);
+                }
+
+                try {
+                    fs.renameSync(tempTarget, targetDir);
+                } catch (err) {
+                    // Failed to move new content into place after moving old one out.
+                    // Attempt to restore the backup.
+                    try {
+                        fs.renameSync(backupPath, targetDir);
+                    } catch (restoreErr) {
+                        throw new Error(`临界失败: 无法将新版本移入目标且无法恢复旧版本。旧版本位于 ${backupPath}。错误: ${err.message}`);
+                    }
+                    throw err;
+                }
+
+                // Step 3: Success! Cleanup backup.
+                try {
+                    fs.rmSync(backupPath, { recursive: true, force: true });
+                } catch (cleanupErr) {
+                    // Not a critical failure for the operation itself, just messy.
+                    if (options.logger) options.logger(`[warn] 无法清理备份目录 ${backupPath}: ${cleanupErr.message}`);
+                }
+                return;
+            }
+            
+            // If target didn't exist or was removed (Win32 path)
+            fs.renameSync(tempTarget, targetDir);
+
+        } catch (err) {
+            // Cleanup temp
+            if (fs.existsSync(tempTarget)) {
+                fs.rmSync(tempTarget, { recursive: true, force: true });
+            }
+            throw new Error(`原子写入失败: ${err.message}`);
+        }
+    }
+
+    static _copyDirRecursive(src, dest) {
+        fs.mkdirSync(dest, { recursive: true });
+        const entries = fs.readdirSync(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                AtomicWriter._copyDirRecursive(srcPath, destPath);
+            } else {
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+}
+
+module.exports = AtomicWriter;

package/bin/utils/git-helper.js

@@ -0,0 +1,68 @@
+const fs = require("fs");
+const path = require("path");
+
+class GitHelper {
+    /**
+     * Remove ignore rules matching specific patterns from .gitignore
+     * @param {string} workspaceRoot Directory containing .gitignore
+     * @param {string[]} targetPatterns List of patterns to remove (e.g. ['.agent', '.codex'])
+     * @param {object} options { dryRun: boolean }
+     * @returns {object} { fileExists, removedCount, dryRun }
+     */
+    static removeIgnoreRules(workspaceRoot, targetPatterns, options) {
+        const gitIgnorePath = path.join(workspaceRoot, ".gitignore");
+        if (!fs.existsSync(gitIgnorePath)) {
+            return { fileExists: false, removedCount: 0, dryRun: options.dryRun };
+        }
+
+        const original = fs.readFileSync(gitIgnorePath, "utf8");
+        const lineEnding = original.includes("\r\n") ? "\r\n" : "\n";
+        const hadTrailingNewline = /\r?\n$/.test(original);
+        const lines = original.split(/\r?\n/);
+
+        const kept = [];
+        let removedCount = 0;
+
+        function isTargetRule(line) {
+             const trimmed = line.trim();
+             if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("!")) return false;
+             let pattern = trimmed;
+             // Remove leading/trailing patterns
+             while (pattern.startsWith("**/")) pattern = pattern.slice(3);
+             while (pattern.startsWith("/")) pattern = pattern.slice(1);
+             while (pattern.endsWith("/")) pattern = pattern.slice(0, -1);
+             while (pattern.endsWith("/**")) pattern = pattern.slice(0, -3);
+             
+             if (!pattern) return false;
+             const segments = pattern.split("/");
+             
+             // Check if any segment matches our target patterns
+             return segments.some((segment) => targetPatterns.includes(segment));
+        }
+
+        for (const line of lines) {
+            if (isTargetRule(line)) {
+                removedCount += 1;
+                continue;
+            }
+            kept.push(line);
+        }
+
+        if (removedCount === 0) {
+            return { fileExists: true, removedCount: 0, dryRun: options.dryRun };
+        }
+
+        let updated = kept.join(lineEnding);
+        if (hadTrailingNewline) {
+            updated += lineEnding;
+        }
+
+        if (!options.dryRun) {
+            fs.writeFileSync(gitIgnorePath, updated, "utf8");
+        }
+
+        return { fileExists: true, removedCount, dryRun: options.dryRun };
+    }
+}
+
+module.exports = GitHelper;