完善 skill_manager 的技能维护能力

tests/opencode/skillManagerTool.test.ts

@@ -0,0 +1,142 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { createSkillManagerTool } from "../../.opencode/tools/skill_manager.js";
+import { SessionRuntimeContextStore } from "../../src/sessions/runtimeContextStore.js";
+import { SkillStore } from "../../src/skills/store.js";
+
+describe("skill_manager tool", () => {
+  let tempDir: string;
+  let skillStore: SkillStore;
+  let contextStore: SessionRuntimeContextStore;
+
+  const toolContext = {
+    abort: new AbortController().signal,
+    agent: "test",
+    ask: (() => undefined) as never,
+    directory: "",
+    messageID: "message-1",
+    metadata: () => undefined,
+    sessionID: "session-1",
+    worktree: "",
+  };
+
+  const skillDocument = (body: string) =>
+    [
+      "---",
+      "name: pressure-review",
+      "description: Pressure review workflow.",
+      "---",
+      "",
+      body,
+    ].join("\n");
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "tjwater-skill-tool-"));
+    skillStore = new SkillStore(
+      join(tempDir, "skills"),
+      join(tempDir, "backup", "skills"),
+    );
+    contextStore = new SessionRuntimeContextStore(join(tempDir, "contexts"));
+    await contextStore.initialize();
+    await contextStore.write({
+      actorKey: "actor-1",
+      allowLearningWrite: true,
+      clientSessionId: "client-session-1",
+      projectKey: "project-1",
+      sessionId: "session-1",
+      traceId: "trace-1",
+    });
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { force: true, recursive: true });
+  });
+
+  it("dispatches skill-level write, overwrite, and remove actions", async () => {
+    const tool = createSkillManagerTool(
+      skillStore,
+      contextStore,
+      Promise.resolve(),
+    );
+
+    const writeResult = JSON.parse(
+      await tool.execute(
+        {
+          action: "write_skill",
+          content: skillDocument("# Pressure Review"),
+          reason: "verified reusable workflow",
+          skill_path: "workflow/pressure-review",
+        },
+        toolContext,
+      ) as string,
+    );
+    expect(writeResult.decision).toBe("accepted");
+    await expect(readFile(writeResult.target, "utf8")).resolves.toContain(
+      "# Pressure Review\n",
+    );
+
+    const updateResult = JSON.parse(
+      await tool.execute(
+        {
+          action: "write_skill",
+          content: skillDocument("# Updated Pressure Review"),
+          reason: "verified reusable workflow overwrite",
+          skill_path: "workflow/pressure-review",
+        },
+        toolContext,
+      ) as string,
+    );
+    expect(updateResult.decision).toBe("accepted");
+    await expect(readFile(updateResult.target, "utf8")).resolves.toContain(
+      "# Updated Pressure Review\n",
+    );
+
+    const removeResult = JSON.parse(
+      await tool.execute(
+        {
+          action: "remove_skill",
+          reason: "workflow is obsolete",
+          skill_path: "workflow/pressure-review",
+        },
+        toolContext,
+      ) as string,
+    );
+    expect(removeResult.decision).toBe("accepted");
+    await expect(readFile(removeResult.target, "utf8")).rejects.toThrow();
+  });
+
+  it("writes the root skills index through the reserved alias", async () => {
+    const tool = createSkillManagerTool(
+      skillStore,
+      contextStore,
+      Promise.resolve(),
+    );
+
+    const writeResult = JSON.parse(
+      await tool.execute(
+        {
+          action: "write_skill",
+          content: [
+            "---",
+            "name: skills",
+            "description: TJWater Skills root index.",
+            "---",
+            "",
+            "# TJWater Skills",
+          ].join("\n"),
+          reason: "refresh root skills index",
+          skill_path: "__root__",
+        },
+        toolContext,
+      ) as string,
+    );
+
+    expect(writeResult.decision).toBe("accepted");
+    await expect(readFile(writeResult.target, "utf8")).resolves.toContain(
+      "# TJWater Skills\n",
+    );
+  });
+});

tests/skills/store.test.ts

@@ -13,6 +13,16 @@ describe("SkillStore", () => {
   let backupRoot: string;
   let store: SkillStore;
 
+  const skillDocument = (name: string, body: string) =>
+    [
+      "---",
+      `name: ${name}`,
+      `description: ${name} workflow.`,
+      "---",
+      "",
+      body,
+    ].join("\n");
+
   beforeEach(async () => {
     originalCwd = process.cwd();
     tempDir = await mkdtemp(join(tmpdir(), "tjwater-skills-"));
@@ -64,4 +74,93 @@ describe("SkillStore", () => {
       target: "",
     });
   });
+
+  it("writes and overwrites the main skill file", async () => {
+    const skillPath = "workflow/pressure-review";
+    const writeResult = await store.writeSkill(
+      skillPath,
+      skillDocument("pressure-review", "# Pressure Review"),
+    );
+
+    expect(writeResult).toEqual({
+      changed: true,
+      detail: "skill written",
+      target: join(skillsRoot, "workflow", "pressure-review", "SKILL.md"),
+    });
+
+    const overwriteResult = await store.writeSkill(
+      skillPath,
+      skillDocument("pressure-review", "# Updated Pressure Review"),
+    );
+
+    expect(overwriteResult).toEqual({
+      changed: true,
+      detail: "skill written",
+      target: writeResult.target,
+    });
+    await expect(readFile(writeResult.target, "utf8")).resolves.toContain(
+      "# Updated Pressure Review\n",
+    );
+  });
+
+  it("writes the root skills index via the reserved alias", async () => {
+    const result = await store.writeSkill(
+      "__root__",
+      [
+        "---",
+        "name: skills",
+        "description: TJWater Skills root index.",
+        "---",
+        "",
+        "# TJWater Skills",
+      ].join("\n"),
+    );
+
+    expect(result).toEqual({
+      changed: true,
+      detail: "skill written",
+      target: join(skillsRoot, "SKILL.md"),
+    });
+    await expect(readFile(result.target, "utf8")).resolves.toContain(
+      "# TJWater Skills\n",
+    );
+  });
+
+  it("removes the main skill file", async () => {
+    const writeResult = await store.writeSkill(
+      "workflow/remove-me",
+      skillDocument("remove-me", "# Remove Me"),
+    );
+    const removeResult = await store.removeSkill("workflow/remove-me");
+
+    expect(removeResult).toEqual({
+      changed: true,
+      detail: "skill removed",
+      target: writeResult.target,
+    });
+    await expect(readFile(writeResult.target, "utf8")).rejects.toThrow();
+  });
+
+  it("rejects sensitive skill content", async () => {
+    const result = await store.writeSkill(
+      "workflow/unsafe",
+      "access_token=secret-value",
+    );
+
+    expect(result).toEqual({
+      changed: false,
+      detail: "skill content rejected by persistence policy",
+      target: "",
+    });
+  });
+
+  it("rejects skill content without required frontmatter", async () => {
+    const result = await store.writeSkill("workflow/incomplete", "# Incomplete");
+
+    expect(result).toEqual({
+      changed: false,
+      detail: "skill content rejected: expected SKILL.md frontmatter with name and description",
+      target: "",
+    });
+  });
 });