@mison/ling 1.1.0 → 1.2.0

package/tests/spec-init-doctor.test.js

@@ -0,0 +1,233 @@
+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", "ling.js");
+
+function runCli(args, options = {}) {
+    const env = {
+        ...process.env,
+        LING_SKIP_UPSTREAM_CHECK: "1",
+        ...options.env,
+    };
+
+    return spawnSync(process.execPath, [CLI_PATH, ...args], {
+        cwd: options.cwd || REPO_ROOT,
+        env,
+        encoding: "utf8",
+    });
+}
+
+describe("Spec init/doctor", () => {
+    let tempRoot;
+    let workspaceRoot;
+
+    beforeEach(() => {
+        tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ling-spec-init-"));
+        workspaceRoot = path.join(tempRoot, "workspace");
+        fs.mkdirSync(workspaceRoot, { recursive: true });
+    });
+
+    afterEach(() => {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    });
+
+    test("spec init should create workspace assets and doctor should report installed", () => {
+        const env = {
+            LING_GLOBAL_ROOT: tempRoot,
+            LING_INDEX_PATH: path.join(tempRoot, "workspaces.json"),
+        };
+
+        const initResult = runCli(["spec", "init", "--path", workspaceRoot, "--quiet"], { env });
+        assert.strictEqual(initResult.status, 0, initResult.stderr || initResult.stdout);
+
+        assert.ok(fs.existsSync(path.join(workspaceRoot, "issues.csv")), "issues.csv should be created");
+        assert.ok(fs.existsSync(path.join(workspaceRoot, ".ling", "spec", "templates", "driver-prompt.md")), "spec templates should be created");
+        assert.ok(fs.existsSync(path.join(workspaceRoot, ".ling", "spec", "references", "gda-framework.md")), "spec references should be created");
+        assert.ok(fs.existsSync(path.join(workspaceRoot, ".ling", "spec", "profiles", "codex", "AGENTS.spec.md")), "spec profiles should be created");
+        assert.ok(
+            fs.existsSync(path.join(workspaceRoot, ".ling", "spec", "profiles", "codex", "ling.spec.rules.md")),
+            "spec profile rules should be created",
+        );
+        assert.ok(fs.existsSync(path.join(workspaceRoot, ".ling", "spec", "profiles", "gemini", "GEMINI.spec.md")), "spec profiles should be created");
+        assert.ok(fs.existsSync(path.join(workspaceRoot, "docs", "reviews")), "docs/reviews should exist");
+        assert.ok(fs.existsSync(path.join(workspaceRoot, "docs", "handoff")), "docs/handoff should exist");
+
+        const doctorResult = runCli(["spec", "doctor", "--path", workspaceRoot, "--quiet"], { env });
+        assert.strictEqual(doctorResult.status, 0, doctorResult.stderr || doctorResult.stdout);
+        assert.strictEqual((doctorResult.stdout || "").trim(), "installed");
+    });
+
+    test("spec init --csv-only should generate issues.csv and rely on global spec assets", () => {
+        const env = {
+            LING_GLOBAL_ROOT: tempRoot,
+            LING_INDEX_PATH: path.join(tempRoot, "workspaces.json"),
+        };
+
+        const enableResult = runCli(["spec", "enable", "--target", "codex", "--quiet"], { env });
+        assert.strictEqual(enableResult.status, 0, enableResult.stderr || enableResult.stdout);
+
+        const initResult = runCli(["spec", "init", "--path", workspaceRoot, "--csv-only", "--quiet"], { env });
+        assert.strictEqual(initResult.status, 0, initResult.stderr || initResult.stdout);
+
+        assert.ok(fs.existsSync(path.join(workspaceRoot, "issues.csv")), "issues.csv should be created");
+        assert.ok(fs.existsSync(path.join(workspaceRoot, "docs", "reviews")), "docs/reviews should exist");
+        assert.ok(fs.existsSync(path.join(workspaceRoot, "docs", "handoff")), "docs/handoff should exist");
+        assert.ok(!fs.existsSync(path.join(workspaceRoot, ".ling", "spec")), "spec assets should not be created in csv-only mode");
+
+        const doctorResult = runCli(["spec", "doctor", "--path", workspaceRoot, "--quiet"], { env });
+        assert.strictEqual(doctorResult.status, 0, doctorResult.stderr || doctorResult.stdout);
+        assert.strictEqual((doctorResult.stdout || "").trim(), "installed");
+    });
+
+    test("spec init without --path should initialize default spec-workspace and include targets", () => {
+        const nonTempRoot = fs.mkdtempSync(path.join(REPO_ROOT, ".tmp-ling-spec-global-"));
+        const indexPath = path.join(nonTempRoot, "workspaces.json");
+        const env = {
+            LING_GLOBAL_ROOT: nonTempRoot,
+            LING_INDEX_PATH: indexPath,
+        };
+
+        try {
+            const initResult = runCli(["spec", "init", "--spec-workspace", "--quiet"], { env });
+            assert.strictEqual(initResult.status, 0, initResult.stderr || initResult.stdout);
+
+            const defaultWorkspace = path.join(nonTempRoot, ".ling", "spec-workspace");
+            assert.ok(fs.existsSync(path.join(defaultWorkspace, "issues.csv")), "default workspace should include issues.csv");
+            assert.ok(
+                fs.existsSync(path.join(defaultWorkspace, ".ling", "spec", "templates", "driver-prompt.md")),
+                "default workspace should include spec templates",
+            );
+            assert.ok(fs.existsSync(path.join(defaultWorkspace, ".agent")), "default workspace should include gemini .agent");
+            assert.ok(fs.existsSync(path.join(defaultWorkspace, ".agents")), "default workspace should include codex .agents");
+
+            const doctorResult = runCli(["spec", "doctor", "--spec-workspace", "--quiet"], { env });
+            assert.strictEqual(doctorResult.status, 0, doctorResult.stderr || doctorResult.stdout);
+            assert.strictEqual((doctorResult.stdout || "").trim(), "installed");
+
+            assert.ok(fs.existsSync(indexPath), "workspace index should be created for non-temp global root");
+            const index = JSON.parse(fs.readFileSync(indexPath, "utf8"));
+            assert.ok(
+                (index.workspaces || []).some((workspace) => workspace && workspace.path === defaultWorkspace),
+                "default spec-workspace should be registered into index",
+            );
+        } finally {
+            fs.rmSync(nonTempRoot, { recursive: true, force: true });
+        }
+    });
+
+    test("spec doctor should report broken when multiple tasks are in 进行中", () => {
+        const env = {
+            LING_GLOBAL_ROOT: tempRoot,
+            LING_INDEX_PATH: path.join(tempRoot, "workspaces.json"),
+        };
+
+        const initResult = runCli(["spec", "init", "--path", workspaceRoot, "--quiet"], { env });
+        assert.strictEqual(initResult.status, 0, initResult.stderr || initResult.stdout);
+
+        const issuesPath = path.join(workspaceRoot, "issues.csv");
+        fs.writeFileSync(
+            issuesPath,
+            [
+                "ID,标题,内容,验收标准,审查要求,状态,标签",
+                "A,任务A,内容A,验收A,审查A,进行中,高优先级",
+                "B,任务B,内容B,验收B,审查B,进行中,高优先级",
+                "",
+            ].join("\n"),
+            "utf8",
+        );
+
+        const doctorResult = runCli(["spec", "doctor", "--path", workspaceRoot, "--quiet"], { env });
+        assert.strictEqual(doctorResult.status, 1, doctorResult.stderr || doctorResult.stdout);
+        assert.strictEqual((doctorResult.stdout || "").trim(), "broken");
+    });
+
+    test("spec doctor should report broken when issues.csv is missing but spec directory exists", () => {
+        const env = {
+            LING_GLOBAL_ROOT: tempRoot,
+            LING_INDEX_PATH: path.join(tempRoot, "workspaces.json"),
+        };
+
+        const initResult = runCli(["spec", "init", "--path", workspaceRoot, "--quiet"], { env });
+        assert.strictEqual(initResult.status, 0, initResult.stderr || initResult.stdout);
+
+        fs.rmSync(path.join(workspaceRoot, "issues.csv"), { force: true });
+
+        const doctorResult = runCli(["spec", "doctor", "--path", workspaceRoot, "--quiet"], { env });
+        assert.strictEqual(doctorResult.status, 1, doctorResult.stderr || doctorResult.stdout);
+        assert.strictEqual((doctorResult.stdout || "").trim(), "broken");
+    });
+
+    test("spec init should support --branch for spec assets", () => {
+        const gitCheck = spawnSync("git", ["--version"], { encoding: "utf8" });
+        if (gitCheck.status !== 0) {
+            return;
+        }
+
+        const sourceRepo = path.join(tempRoot, "spec-source-repo");
+        fs.mkdirSync(sourceRepo, { recursive: true });
+
+        const runGit = (args) =>
+            spawnSync("git", args, {
+                cwd: sourceRepo,
+                encoding: "utf8",
+            });
+
+        const initRes = runGit(["init", "--initial-branch", "main"]);
+        if (initRes.status !== 0) {
+            assert.strictEqual(runGit(["init"]).status, 0);
+            assert.strictEqual(runGit(["checkout", "-b", "main"]).status, 0);
+        }
+
+        const specRoot = path.join(sourceRepo, ".spec");
+        const templatesDir = path.join(specRoot, "templates");
+        const referencesDir = path.join(specRoot, "references");
+        const profilesCodexDir = path.join(specRoot, "profiles", "codex");
+        const profilesGeminiDir = path.join(specRoot, "profiles", "gemini");
+        fs.mkdirSync(templatesDir, { recursive: true });
+        fs.mkdirSync(referencesDir, { recursive: true });
+        fs.mkdirSync(profilesCodexDir, { recursive: true });
+        fs.mkdirSync(profilesGeminiDir, { recursive: true });
+
+        fs.writeFileSync(path.join(templatesDir, "issues.template.csv"), "ID,状态\nX,未开始\n", "utf8");
+        fs.writeFileSync(path.join(templatesDir, "driver-prompt.md"), "branch driver prompt", "utf8");
+        fs.writeFileSync(path.join(templatesDir, "review-report.md"), "branch review report", "utf8");
+        fs.writeFileSync(path.join(templatesDir, "phase-acceptance.md"), "branch acceptance", "utf8");
+        fs.writeFileSync(path.join(templatesDir, "handoff.md"), "branch handoff", "utf8");
+
+        fs.writeFileSync(path.join(referencesDir, "README.md"), "branch readme", "utf8");
+        fs.writeFileSync(path.join(referencesDir, "harness-engineering-digest.md"), "branch digest", "utf8");
+        fs.writeFileSync(path.join(referencesDir, "gda-framework.md"), "branch gda", "utf8");
+        fs.writeFileSync(path.join(referencesDir, "cse-quickstart.md"), "branch quickstart", "utf8");
+
+        fs.writeFileSync(path.join(profilesCodexDir, "AGENTS.spec.md"), "branch codex agents", "utf8");
+        fs.writeFileSync(path.join(profilesCodexDir, "ling.spec.rules.md"), "branch codex rules", "utf8");
+        fs.writeFileSync(path.join(profilesGeminiDir, "GEMINI.spec.md"), "branch gemini profile", "utf8");
+
+        assert.strictEqual(runGit(["add", "."]).status, 0);
+        assert.strictEqual(
+            runGit(["-c", "user.name=ling-test", "-c", "user.email=ling-test@example.com", "commit", "-m", "spec assets"]).status,
+            0,
+        );
+
+        const env = {
+            LING_GLOBAL_ROOT: tempRoot,
+            LING_REPO_URL: sourceRepo,
+            LING_INDEX_PATH: path.join(tempRoot, "workspaces.json"),
+        };
+
+        const initResult = runCli(["spec", "init", "--path", workspaceRoot, "--branch", "main", "--quiet"], { env });
+        assert.strictEqual(initResult.status, 0, initResult.stderr || initResult.stdout);
+
+        const installedPrompt = path.join(workspaceRoot, ".ling", "spec", "templates", "driver-prompt.md");
+        assert.strictEqual(fs.readFileSync(installedPrompt, "utf8"), "branch driver prompt");
+
+        const doctorResult = runCli(["spec", "doctor", "--path", workspaceRoot, "--quiet"], { env });
+        assert.strictEqual(doctorResult.status, 0, doctorResult.stderr || doctorResult.stdout);
+        assert.strictEqual((doctorResult.stdout || "").trim(), "installed");
+    });
+});

package/tests/spec-profile.test.js

@@ -51,11 +51,14 @@ describe("Spec Profile", () => {
         const stateFile = path.join(tempRoot, ".ling", "spec", "state.json");
         const templatesDir = path.join(tempRoot, ".ling", "spec", "templates");
         const referencesDir = path.join(tempRoot, ".ling", "spec", "references");
+        const profilesDir = path.join(tempRoot, ".ling", "spec", "profiles");
 
         assert.ok(fs.existsSync(codexSkill), "missing installed codex spec skill");
         assert.ok(fs.existsSync(stateFile), "missing spec state");
         assert.ok(fs.existsSync(path.join(templatesDir, "issues.template.csv")), "missing spec template");
         assert.ok(fs.existsSync(path.join(referencesDir, "harness-engineering-digest.md")), "missing spec reference");
+        assert.ok(fs.existsSync(path.join(profilesDir, "codex", "AGENTS.spec.md")), "missing spec profile");
+        assert.ok(fs.existsSync(path.join(profilesDir, "codex", "ling.spec.rules.md")), "missing spec profile rules");
 
         const statusResult = runCli(["spec", "status", "--quiet"], { env });
         assert.strictEqual(statusResult.status, 0);
@@ -67,6 +70,7 @@ describe("Spec Profile", () => {
         assert.ok(!fs.existsSync(stateFile), "spec state should be removed after final disable");
         assert.ok(!fs.existsSync(templatesDir), "spec templates should be removed after final disable");
         assert.ok(!fs.existsSync(referencesDir), "spec references should be removed after final disable");
+        assert.ok(!fs.existsSync(profilesDir), "spec profiles should be removed after final disable");
     });
 
     test("spec disable should restore pre-existing skill backup", () => {
@@ -83,4 +87,84 @@ describe("Spec Profile", () => {
         assert.strictEqual(disableResult.status, 0, disableResult.stderr || disableResult.stdout);
         assert.strictEqual(fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf8"), "legacy skill");
     });
+
+    test("spec enable should repair missing assets and skills when state exists", () => {
+        const env = { LING_GLOBAL_ROOT: tempRoot };
+
+        const enableResult = runCli(["spec", "enable", "--target", "codex", "--quiet"], { env });
+        assert.strictEqual(enableResult.status, 0, enableResult.stderr || enableResult.stdout);
+
+        const templatesDir = path.join(tempRoot, ".ling", "spec", "templates");
+        const codexSkillDir = path.join(tempRoot, ".codex", "skills", "harness-engineering");
+        fs.rmSync(templatesDir, { recursive: true, force: true });
+        fs.rmSync(codexSkillDir, { recursive: true, force: true });
+
+        const brokenResult = runCli(["spec", "status", "--quiet"], { env });
+        assert.strictEqual(brokenResult.status, 1);
+        assert.strictEqual((brokenResult.stdout || "").trim(), "broken");
+
+        const repairResult = runCli(["spec", "enable", "--target", "codex", "--quiet"], { env });
+        assert.strictEqual(repairResult.status, 0, repairResult.stderr || repairResult.stdout);
+
+        const repairedStatus = runCli(["spec", "status", "--quiet"], { env });
+        assert.strictEqual(repairedStatus.status, 0);
+        assert.strictEqual((repairedStatus.stdout || "").trim(), "installed");
+
+        assert.ok(fs.existsSync(path.join(templatesDir, "issues.template.csv")), "templates should be repaired");
+        assert.ok(fs.existsSync(path.join(codexSkillDir, "SKILL.md")), "spec skill should be repaired");
+    });
+
+    test("spec enable should install antigravity skills independently", () => {
+        const env = { LING_GLOBAL_ROOT: tempRoot };
+
+        const enableResult = runCli(["spec", "enable", "--target", "antigravity", "--quiet"], { env });
+        assert.strictEqual(enableResult.status, 0, enableResult.stderr || enableResult.stdout);
+
+        const antigravitySkill = path.join(tempRoot, ".gemini", "antigravity", "skills", "harness-engineering", "SKILL.md");
+        const geminiSkill = path.join(tempRoot, ".gemini", "skills", "harness-engineering", "SKILL.md");
+        assert.ok(fs.existsSync(antigravitySkill), "missing installed antigravity spec skill");
+        assert.ok(!fs.existsSync(geminiSkill), "antigravity spec enable should not install gemini skill");
+
+        const statusResult = runCli(["spec", "status", "--quiet"], { env });
+        assert.strictEqual(statusResult.status, 0);
+        assert.strictEqual((statusResult.stdout || "").trim(), "installed");
+    });
+
+    test("spec status should report broken when an asset file is missing", () => {
+        const env = { LING_GLOBAL_ROOT: tempRoot };
+
+        const enableResult = runCli(["spec", "enable", "--target", "codex", "--quiet"], { env });
+        assert.strictEqual(enableResult.status, 0, enableResult.stderr || enableResult.stdout);
+
+        const driverPrompt = path.join(tempRoot, ".ling", "spec", "templates", "driver-prompt.md");
+        assert.ok(fs.existsSync(driverPrompt), "driver-prompt.md should exist after enable");
+        fs.rmSync(driverPrompt, { force: true });
+
+        const statusResult = runCli(["spec", "status", "--quiet"], { env });
+        assert.strictEqual(statusResult.status, 1);
+        assert.strictEqual((statusResult.stdout || "").trim(), "broken");
+
+        const repairResult = runCli(["spec", "enable", "--target", "codex", "--quiet"], { env });
+        assert.strictEqual(repairResult.status, 0, repairResult.stderr || repairResult.stdout);
+        assert.ok(fs.existsSync(driverPrompt), "driver-prompt.md should be repaired");
+    });
+
+    test("spec status should report broken when state.json is missing but assets exist", () => {
+        const env = { LING_GLOBAL_ROOT: tempRoot };
+
+        const templatesDir = path.join(tempRoot, ".ling", "spec", "templates");
+        fs.mkdirSync(templatesDir, { recursive: true });
+        fs.writeFileSync(path.join(templatesDir, "issues.template.csv"), "sentinel", "utf8");
+
+        const statusResult = runCli(["spec", "status", "--quiet"], { env });
+        assert.strictEqual(statusResult.status, 1);
+        assert.strictEqual((statusResult.stdout || "").trim(), "broken");
+
+        const repairResult = runCli(["spec", "enable", "--target", "codex", "--quiet"], { env });
+        assert.strictEqual(repairResult.status, 0, repairResult.stderr || repairResult.stdout);
+
+        const repairedStatus = runCli(["spec", "status", "--quiet"], { env });
+        assert.strictEqual(repairedStatus.status, 0);
+        assert.strictEqual((repairedStatus.stdout || "").trim(), "installed");
+    });
 });

package/tests/standards-compliance.test.js

@@ -144,6 +144,37 @@ describe('Standards Compliance', () => {
         assert.ok(!content.includes('$HOME/.agents/skills/'), 'should not contain deprecated global path: $HOME/.agents/skills/');
     });
 
+    test('README spec section should reflect implemented spec commands', () => {
+        const file = path.resolve('README.md');
+        const content = fs.readFileSync(file, 'utf8');
+
+        assert.ok(content.includes('ling spec init'), 'README should mention ling spec init');
+        assert.ok(content.includes('ling spec doctor'), 'README should mention ling spec doctor');
+        assert.ok(content.includes('~/.ling/spec/profiles/'), 'README should mention spec profiles path');
+        assert.ok(!content.includes('本版本尚未开放'), 'README should not claim spec project commands are unavailable');
+        assert.ok(!content.includes('spec init/remove/doctor'), 'README should not mention unsupported spec remove subcommand');
+    });
+
+    test('docs should describe gemini and antigravity as separate command targets', () => {
+        const readme = fs.readFileSync(path.resolve('README.md'), 'utf8');
+        const tech = fs.readFileSync(path.resolve('docs/TECH.md'), 'utf8');
+
+        assert.ok(readme.includes('ling init --target antigravity'), 'README should document project antigravity target');
+        assert.ok(readme.includes('ling global sync --target antigravity'), 'README should document global antigravity target');
+        assert.ok(tech.includes('`--target gemini` 只写入 gemini-cli；`--target antigravity` 只写入 antigravity'), 'TECH should describe split global targets');
+        assert.ok(!tech.includes('gemini 会同时写入 gemini-cli 与 antigravity'), 'TECH should not describe gemini as bundled antigravity target');
+    });
+
+    test('gitignore should whitelist curated reference materials only', () => {
+        const rootIgnore = fs.readFileSync(path.resolve('.gitignore'), 'utf8');
+        const referenceIgnore = fs.readFileSync(path.resolve('reference/.gitignore'), 'utf8');
+
+        assert.ok(rootIgnore.includes('!reference/official/**'), 'root .gitignore should keep reference/official tracked');
+        assert.ok(rootIgnore.includes('!reference/docs-archive/**'), 'root .gitignore should keep reference/docs-archive tracked');
+        assert.ok(referenceIgnore.includes('!official/**'), 'reference/.gitignore should keep official subtree tracked');
+        assert.ok(referenceIgnore.includes('!docs-archive/**'), 'reference/.gitignore should keep docs-archive subtree tracked');
+    });
+
     test('.agents script files should stay identical to reference snapshot', { skip: !HAS_REF_SCRIPTS_ROOT }, () => {
         const refScriptsRoot = REF_SCRIPTS_ROOT;
         const mismatches = [];