@selesai/code 0.13.0 → 0.13.2

package/dist/extensions/pi-hermes-memory/tests/tools/skill-tool.test.ts

@@ -0,0 +1,478 @@
+/**
+ * Unit tests for skill tool registration and execute function.
+ */
+
+import { describe, it } from "node:test";
+import * as assert from "node:assert/strict";
+import { registerSkillTool, SKILL_MANAGE_TOOL_NAME } from "../../src/tools/skill-tool.js";
+import { SkillStore } from "../../src/store/skill-store.js";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as fs from "node:fs/promises";
+
+let ROOT_DIR = "";
+let GLOBAL_SKILLS_DIR = "";
+let PROJECT_SKILLS_DIR = "";
+
+async function makeStore(withProject = true): Promise<SkillStore> {
+  ROOT_DIR = await fs.mkdtemp(path.join(os.tmpdir(), "pi-skill-tool-test-"));
+  GLOBAL_SKILLS_DIR = path.join(ROOT_DIR, "global-skills");
+  PROJECT_SKILLS_DIR = path.join(ROOT_DIR, "project-skills");
+  await fs.mkdir(GLOBAL_SKILLS_DIR, { recursive: true });
+  if (withProject) await fs.mkdir(PROJECT_SKILLS_DIR, { recursive: true });
+
+  return new SkillStore({
+    globalSkillsDir: GLOBAL_SKILLS_DIR,
+    projectSkillsDir: withProject ? PROJECT_SKILLS_DIR : null,
+    projectName: withProject ? "demo-project" : null,
+    legacySkillsDir: path.join(ROOT_DIR, "legacy-skills"),
+    migrationSentinelPath: path.join(ROOT_DIR, ".skill-migration"),
+  });
+}
+
+async function cleanup(): Promise<void> {
+  try {
+    await fs.rm(ROOT_DIR, { recursive: true, force: true });
+  } catch {
+    // ignore
+  }
+}
+
+describe("registerSkillTool", () => {
+  it("registers tool with name 'skill_manage'", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    registerSkillTool(mockPi, store);
+    await cleanup();
+
+    assert.strictEqual(captured.name, SKILL_MANAGE_TOOL_NAME);
+    assert.strictEqual(captured.label, "Skill Manager");
+    assert.ok(captured.description.length > 0);
+    assert.ok(captured.promptSnippet.length > 0);
+    assert.ok(Array.isArray(captured.promptGuidelines));
+    assert.ok(captured.parameters);
+  });
+
+  it("create requires name, description, a body or structured fields, and scope", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    registerSkillTool(mockPi, store);
+
+    let result = await captured.execute("tc-1", { action: "create", description: "desc", content: "body" }, undefined, undefined, undefined);
+    assert.strictEqual(JSON.parse(result.content[0].text).success, false);
+
+    result = await captured.execute("tc-1", { action: "create", name: "test", content: "body" }, undefined, undefined, undefined);
+    assert.strictEqual(JSON.parse(result.content[0].text).success, false);
+
+    result = await captured.execute("tc-1", { action: "create", name: "test", description: "desc" }, undefined, undefined, undefined);
+    const missingBody = JSON.parse(result.content[0].text);
+    assert.strictEqual(missingBody.success, false);
+    assert.match(missingBody.error, /Either content or structured fields are required/i);
+
+    result = await captured.execute("tc-1", {
+      action: "create",
+      name: "test",
+      description: "desc",
+      content: "body",
+    }, undefined, undefined, undefined);
+    const missingScope = JSON.parse(result.content[0].text);
+    assert.strictEqual(missingScope.success, false);
+    assert.match(missingScope.error, /scope is required/i);
+
+    await cleanup();
+  });
+
+  it("create succeeds with raw markdown content and returns skill_id", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", {
+      action: "create",
+      name: "test-skill",
+      description: "A test skill",
+      scope: "global",
+      content: "## Procedure\n1. Do it",
+    }, undefined, undefined, undefined);
+
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, true);
+    assert.strictEqual(parsed.skillId, "global:test-skill");
+    assert.strictEqual(parsed.scope, "global");
+
+    await cleanup();
+  });
+
+  it("create builds a valid skill body from structured fields", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", {
+      action: "create",
+      name: "debug-typescript-errors",
+      description: "Debug TypeScript build failures in this repo",
+      scope: "project",
+      when_to_use: "Use when the repo's TypeScript build fails locally or in CI.",
+      procedure_steps: [
+        "Run pnpm tsc --noEmit to get the full error list.",
+        "Fix dependency and config errors before leaf-module errors.",
+      ],
+      pitfalls: [
+        "Do not rely on editor-only diagnostics.",
+      ],
+      verification_steps: [
+        "pnpm tsc --noEmit exits successfully.",
+      ],
+    }, undefined, undefined, undefined);
+
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, true);
+
+    const created = await store.loadSkill(parsed.skillId);
+    assert.match(created?.body || "", /## When to Use/);
+    assert.match(created?.body || "", /## Procedure/);
+    assert.match(created?.body || "", /1\. Run pnpm tsc --noEmit/);
+    assert.match(created?.body || "", /## Pitfalls/);
+    assert.match(created?.body || "", /## Verification/);
+
+    await cleanup();
+  });
+
+  it("create supports explicit project scope", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", {
+      action: "create",
+      name: "release-app",
+      description: "Release this app",
+      scope: "project",
+      content: "## Procedure\n1. Run pnpm build",
+    }, undefined, undefined, undefined);
+
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, true);
+    assert.strictEqual(parsed.skillId, "project:demo-project:release-app");
+    assert.strictEqual(parsed.scope, "project");
+
+    await cleanup();
+  });
+
+  it("view without skill_id lists all skills", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    await store.create("skill-a", "First", "body a");
+    await store.create("skill-b", "Second", "body b", "project");
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", { action: "view" }, undefined, undefined, undefined);
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, true);
+    assert.strictEqual(parsed.skills.length, 2);
+
+    await cleanup();
+  });
+
+  it("view with skill_id returns full document", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    const created = await store.create("my-skill", "A skill", "## Body content here");
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", { action: "view", skill_id: created.skillId }, undefined, undefined, undefined);
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, true);
+    assert.strictEqual(parsed.name, "my-skill");
+    assert.ok(parsed.body.includes("## Body content here"));
+
+    await cleanup();
+  });
+
+  it("view with invalid skill_id returns error", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", { action: "view", skill_id: "global:missing" }, undefined, undefined, undefined);
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, false);
+    assert.ok(parsed.error.includes("not found"));
+
+    await cleanup();
+  });
+
+  it("patch requires skill_id, section, and content or structured fields", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    registerSkillTool(mockPi, store);
+
+    let result = await captured.execute("tc-1", { action: "patch", section: "Procedure", content: "new" }, undefined, undefined, undefined);
+    assert.strictEqual(JSON.parse(result.content[0].text).success, false);
+
+    result = await captured.execute("tc-1", { action: "patch", skill_id: "global:test", content: "new" }, undefined, undefined, undefined);
+    assert.strictEqual(JSON.parse(result.content[0].text).success, false);
+
+    result = await captured.execute("tc-1", { action: "patch", skill_id: "global:test", section: "Procedure" }, undefined, undefined, undefined);
+    assert.strictEqual(JSON.parse(result.content[0].text).success, false);
+
+    await cleanup();
+  });
+
+  it("patch accepts structured procedure_steps for a section update", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    const created = await store.create(
+      "patch-me",
+      "desc",
+      "## Procedure\n1. Old way\n\n## Pitfalls\n- Keep me\n\n## Verification\n1. Still works",
+    );
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", {
+      action: "patch",
+      skill_id: created.skillId,
+      section: "Procedure",
+      procedure_steps: ["Do the new first step", "Do the new second step"],
+    }, undefined, undefined, undefined);
+
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, true);
+
+    const doc = await store.loadSkill(created.skillId!);
+    assert.match(doc!.body, /## Procedure\n1\. Do the new first step\n2\. Do the new second step/);
+    assert.match(doc!.body, /## Pitfalls\n- Keep me/);
+    assert.match(doc!.body, /## Verification\n1\. Still works/);
+    assert.doesNotMatch(doc!.body, /Old way/);
+
+    await cleanup();
+  });
+
+  it("patch rejects JSON object content strings", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    const created = await store.create("patch-me", "desc", "## Procedure\n1. Keep");
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", {
+      action: "patch",
+      skill_id: created.skillId,
+      section: "Procedure",
+      content: '{"steps":["bad"]}',
+    }, undefined, undefined, undefined);
+
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, false);
+    assert.match(parsed.error, /JSON object/i);
+    assert.equal((await store.loadSkill(created.skillId!))!.version, 1);
+
+    await cleanup();
+  });
+
+  it("patch coerces JSON array content strings into Markdown lists", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    const created = await store.create("patch-me", "desc", "## Pitfalls\n- old");
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", {
+      action: "patch",
+      skill_id: created.skillId,
+      section: "Pitfalls",
+      content: '["Do not skip verification", "Do not wipe other sections"]',
+    }, undefined, undefined, undefined);
+
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, true);
+
+    const doc = await store.loadSkill(created.skillId!);
+    assert.match(doc!.body, /## Pitfalls\n- Do not skip verification\n- Do not wipe other sections/);
+    assert.doesNotMatch(doc!.body, /\[\"Do not skip verification\"/);
+
+    await cleanup();
+  });
+
+  it("update requires skill_id", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", { action: "update", description: "new desc" }, undefined, undefined, undefined);
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, false);
+    assert.ok(parsed.error.includes("skill_id"));
+
+    await cleanup();
+  });
+
+  it("update aliases to full skill rewrite", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    const created = await store.create("my-skill", "Old desc", "## Old body", "global");
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", {
+      action: "update",
+      skill_id: created.skillId,
+      description: "New desc",
+      content: "## New body",
+    }, undefined, undefined, undefined);
+
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, true);
+
+    const updated = await store.loadSkill(created.skillId!);
+    assert.strictEqual(updated?.description, "New desc");
+    assert.match(updated?.body || "", /New body/);
+
+    await cleanup();
+  });
+
+  it("update can rebuild the body from structured fields", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    const created = await store.create("my-skill", "Old desc", "## Old body", "global");
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", {
+      action: "update",
+      skill_id: created.skillId,
+      description: "New desc",
+      when_to_use: "Use when validating the new rewrite path.",
+      procedure_steps: ["Perform the new sequence."],
+      verification_steps: ["Confirm the new sequence works."],
+    }, undefined, undefined, undefined);
+
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, true);
+
+    const updated = await store.loadSkill(created.skillId!);
+    assert.match(updated?.body || "", /## When to Use/);
+    assert.match(updated?.body || "", /Perform the new sequence/);
+    assert.match(updated?.body || "", /No notable pitfalls recorded yet/);
+
+    await cleanup();
+  });
+
+  it("legacy edit alias still rewrites the skill", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    const created = await store.create("legacy-skill", "Old desc", "## Old body", "global");
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", {
+      action: "edit",
+      skill_id: created.skillId,
+      description: "Legacy desc",
+      content: "## Legacy body",
+    }, undefined, undefined, undefined);
+
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, true);
+
+    const updated = await store.loadSkill(created.skillId!);
+    assert.strictEqual(updated?.description, "Legacy desc");
+    assert.match(updated?.body || "", /Legacy body/);
+
+    await cleanup();
+  });
+
+  it("delete requires skill_id", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", { action: "delete" }, undefined, undefined, undefined);
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, false);
+    assert.ok(parsed.error.includes("skill_id"));
+
+    await cleanup();
+  });
+
+  it("unknown action returns error", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    const store = await makeStore();
+    registerSkillTool(mockPi, store);
+
+    const result = await captured.execute("tc-1", { action: "explode" }, undefined, undefined, undefined);
+    const parsed = JSON.parse(result.content[0].text);
+    assert.strictEqual(parsed.success, false);
+    assert.ok(parsed.error.includes("Unknown action"));
+
+    await cleanup();
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/tools/tool-result-renderer-wiring.test.ts

@@ -0,0 +1,40 @@
+import { describe, it } from "node:test";
+import * as assert from "node:assert/strict";
+import { registerMemoryTool } from "../../src/tools/memory-tool.js";
+import { registerMemorySearchTool } from "../../src/tools/memory-search-tool.js";
+import { registerSessionSearchTool } from "../../src/tools/session-search-tool.js";
+import { registerSkillTool } from "../../src/tools/skill-tool.js";
+
+function capture(register: (pi: any) => void): any {
+  let definition: any;
+  register({ registerTool(value: any) { definition = value; } });
+  return definition;
+}
+
+describe("tool result renderer wiring", () => {
+  it("registers renderResult on memory and memory_search", () => {
+    const memory = capture((pi) => registerMemoryTool(pi, {} as any, null));
+    const memorySearch = capture((pi) => registerMemorySearchTool(pi, {} as any));
+
+    assert.equal(typeof memory.renderResult, "function");
+    assert.equal(typeof memorySearch.renderResult, "function");
+  });
+
+  it("registers renderResult on both session_search variants", () => {
+    const legacy = capture((pi) => registerSessionSearchTool(pi, {} as any));
+    const anchors = capture((pi) => registerSessionSearchTool(
+      pi,
+      {} as any,
+      { variant: "anchors" },
+      { sessionsDir: "/path-independent-sessions" },
+    ));
+
+    assert.equal(typeof legacy.renderResult, "function");
+    assert.equal(typeof anchors.renderResult, "function");
+  });
+
+  it("registers renderResult on skill_manage", () => {
+    const skill = capture((pi) => registerSkillTool(pi, {} as any));
+    assert.equal(typeof skill.renderResult, "function");
+  });
+});

package/dist/extensions/pi-hermes-memory/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/extensions/pi-rewind-hook/README.md

@@ -12,7 +12,7 @@ Rewind metadata lives in the session itself as hidden entries, so rewind history
 
 ## Requirements
 
-- Pi agent v0.65.0+
+- Pi agent v0.74.0+
 - Node.js (for installation)
 - Git repository
 
@@ -181,6 +181,8 @@ Rewind restores the exact file state for the snapshot domain it owns:
 
 Before restoring target contents, it deletes paths present in the current snapshot but absent from the target snapshot, then restores the target snapshot into the worktree only.
 
+Submodules are supported only when their paths stay unchanged, their worktrees are clean and initialized, and each target commit is already available locally. Rewind checks out those target commits without fetching. Exact restore is refused with a clear error for dirty or unavailable submodule state, added or removed submodule paths, and nested submodules; uncommitted files inside submodules are not part of snapshots.
+
 Out of scope:
 
 - ignored files
@@ -240,6 +242,7 @@ grep '"customType":"rewind-' ~/.pi/agent/sessions/**/*.jsonl
 ## Limitations
 
 - Only works in git repositories
+- Submodule snapshots contain gitlink commits, not uncommitted nested files; unsupported submodule states are refused instead of reported as exact restores
 - Session metadata grows append-only; retention only trims git reachability
 - Discovery for retention is best-effort across discovered Pi session roots and explicit `parentSession` ancestors
 - Ignored files and empty directories are outside the snapshot model