@selesai/code 0.13.0 → 0.13.1

package/dist/extensions/pi-hermes-memory/tests/handlers/preview-context.test.ts

@@ -0,0 +1,152 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { registerPreviewContextCommand } from "../../src/handlers/preview-context.js";
+import { MEMORY_POLICY_PROMPT, MEMORY_POLICY_PROMPT_COMPACT } from "../../src/constants.js";
+
+describe("registerPreviewContextCommand", () => {
+  function setup(opts: {
+    memoryBlock?: string;
+    projectBlock?: string;
+    projectName?: string;
+    withProjectStore?: boolean;
+    memoryMode?: "policy-only" | "legacy-inject";
+    memoryPolicyStyle?: "full" | "compact" | "custom" | "none";
+    memoryPolicyCustomText?: string;
+  }) {
+    const commands: { name: string; handler: Function }[] = [];
+    const notifyCalls: { message: string; severity: string }[] = [];
+
+    const mockPi = {
+      registerCommand: (name: string, conf: any) => {
+        commands.push({ name, handler: conf.handler });
+      },
+    } as any;
+
+    const store = {
+      formatForSystemPrompt: () => opts.memoryBlock ?? "",
+    } as any;
+
+    const projectStore = opts.withProjectStore
+      ? ({ formatProjectBlock: () => opts.projectBlock ?? "" } as any)
+      : null;
+
+    registerPreviewContextCommand(
+      mockPi,
+      store,
+      projectStore,
+      opts.projectName ?? "demo-project",
+      {
+        memoryMode: opts.memoryMode ?? "policy-only",
+        memoryPolicyStyle: opts.memoryPolicyStyle,
+        memoryPolicyCustomText: opts.memoryPolicyCustomText,
+      },
+    );
+
+    return {
+      handler: commands[0].handler,
+      notifyCalls,
+      ctx: {
+        ui: {
+          notify: (message: string, severity: string) => {
+            notifyCalls.push({ message, severity });
+          },
+        },
+      },
+    };
+  }
+
+  it("registers /memory-preview-context", () => {
+    const { handler } = setup({});
+    assert.ok(typeof handler === "function");
+  });
+
+  it("shows policy-only context by default", async () => {
+    const { handler, ctx, notifyCalls } = setup({
+      memoryBlock: "<memory-context>MEM</memory-context>",
+      projectBlock: "<memory-context>PROJECT</memory-context>",
+      withProjectStore: true,
+    });
+
+    await handler({}, ctx);
+    assert.strictEqual(notifyCalls.length, 1);
+    const out = notifyCalls[0].message;
+    assert.match(out, /Mode: policy-only/);
+    assert.match(out, /Policy style: full/);
+    assert.match(out, /Full Markdown memories are NOT injected/);
+    assert.match(out, /memory_search/);
+    assert.match(out, /target="failure"/);
+    assert.ok(out.includes(MEMORY_POLICY_PROMPT));
+    assert.match(out, /Blocks shown: 1/);
+  });
+
+  it("shows compact policy context when configured", async () => {
+    const { handler, ctx, notifyCalls } = setup({
+      memoryPolicyStyle: "compact",
+    });
+
+    await handler({}, ctx);
+    const out = notifyCalls[0].message;
+    assert.match(out, /Policy style: compact/);
+    assert.ok(out.includes(MEMORY_POLICY_PROMPT_COMPACT));
+    assert.match(out, /Blocks shown: 1/);
+  });
+
+  it("shows custom policy context when configured", async () => {
+    const customText = "<memory-policy>Custom preview policy.</memory-policy>";
+    const { handler, ctx, notifyCalls } = setup({
+      memoryPolicyStyle: "custom",
+      memoryPolicyCustomText: customText,
+    });
+
+    await handler({}, ctx);
+    const out = notifyCalls[0].message;
+    assert.match(out, /Policy style: custom/);
+    assert.ok(out.includes(customText));
+    assert.match(out, /Blocks shown: 1/);
+  });
+
+  it("shows no injected policy context when policy style is none", async () => {
+    const { handler, ctx, notifyCalls } = setup({
+      memoryPolicyStyle: "none",
+    });
+
+    await handler({}, ctx);
+    const out = notifyCalls[0].message;
+    assert.match(out, /Policy style: none/);
+    assert.match(out, /No memory policy context is injected/);
+    assert.doesNotMatch(out, /<memory-policy>/);
+    assert.match(out, /Blocks shown: 0/);
+  });
+
+  it("shows all available blocks in legacy mode", async () => {
+    const { handler, ctx, notifyCalls } = setup({
+      memoryBlock: "<memory-context>MEM</memory-context>",
+      projectBlock: "<memory-context>PROJECT</memory-context>",
+      withProjectStore: true,
+      projectName: "pi-hermes-memory",
+      memoryMode: "legacy-inject",
+    });
+
+    await handler({}, ctx);
+    assert.strictEqual(notifyCalls.length, 1);
+    const out = notifyCalls[0].message;
+    assert.match(out, /Injected Context Preview/);
+    assert.match(out, /MEMORY \+ USER \+ RECENT FAILURES/);
+    assert.match(out, /PROJECT MEMORY \(pi-hermes-memory\)/);
+    assert.match(out, /Blocks shown: 2/);
+  });
+
+  it("shows empty-state guidance when no blocks exist", async () => {
+    const { handler, ctx, notifyCalls } = setup({
+      memoryBlock: "",
+      projectBlock: "",
+      withProjectStore: false,
+      memoryMode: "legacy-inject",
+    });
+
+    await handler({}, ctx);
+    const out = notifyCalls[0].message;
+    assert.match(out, /No memory context blocks are currently injected/);
+    assert.match(out, /Blocks shown: 0/);
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/handlers/prompt-context.test.ts

@@ -0,0 +1,166 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { buildPromptContext } from "../../src/prompt-context.js";
+import { MEMORY_POLICY_PROMPT, MEMORY_POLICY_PROMPT_COMPACT } from "../../src/constants.js";
+
+describe("buildPromptContext", () => {
+  const store = {
+    formatForSystemPrompt: () => "<memory-context>MEMORY</memory-context>",
+  } as any;
+
+  const projectStore = {
+    formatProjectBlock: (projectName: string) => `<memory-context>PROJECT ${projectName}</memory-context>`,
+  } as any;
+
+  it("returns policy only in policy-only mode", async () => {
+    const result = await buildPromptContext(
+      { memoryMode: "policy-only" },
+      store,
+      projectStore,
+      "demo",
+    );
+
+    assert.strictEqual(result, MEMORY_POLICY_PROMPT);
+    assert.match(result, /memory_search/);
+    assert.match(result, /Accepted memory categories/);
+    assert.match(result, /category filters categorized failure\/lesson memories only/);
+    assert.match(result, /Use category only for categorized failure\/lesson searches/);
+    assert.match(result, /session_search: search indexed past conversation messages/);
+    assert.match(result, /skill_manage: list, view, create, patch, update, and delete procedural skills/);
+    assert.match(result, /Always pass scope explicitly on create/);
+    assert.match(result, /Do not create skills for one-off task state/);
+    assert.doesNotMatch(result, /category="preference"/);
+    assert.doesNotMatch(result, /inspect, and update procedural skills/);
+    assert.doesNotMatch(result, /memory_search: search relevant user, project, session, failure, and skill memories/);
+    assert.doesNotMatch(result, /MEMORY<\/memory-context>/);
+    assert.doesNotMatch(result, /PROJECT demo/);
+    assert.doesNotMatch(result, /SKILLS/);
+  });
+
+  it("returns the full policy prompt when policy style is full", async () => {
+    const result = await buildPromptContext(
+      { memoryMode: "policy-only", memoryPolicyStyle: "full" },
+      store,
+      projectStore,
+      "demo",
+    );
+
+    assert.strictEqual(result, MEMORY_POLICY_PROMPT);
+  });
+
+  it("returns the compact policy prompt when policy style is compact", async () => {
+    const result = await buildPromptContext(
+      { memoryMode: "policy-only", memoryPolicyStyle: "compact" },
+      store,
+      projectStore,
+      "demo",
+    );
+
+    assert.strictEqual(result, MEMORY_POLICY_PROMPT_COMPACT);
+    assert.match(result, /category filters categorized failure\/lesson memories only/);
+    assert.match(result, /scope is required: global for transferable workflows, project for repo-specific ones/);
+    assert.match(result, /Do not use memory_search for generic questions/);
+    assert.doesNotMatch(result, /MEMORY<\/memory-context>/);
+    assert.doesNotMatch(result, /PROJECT demo/);
+    assert.doesNotMatch(result, /SKILLS/);
+  });
+
+  it("returns custom policy text when policy style is custom", async () => {
+    const customText = "<memory-policy>Use local custom policy.</memory-policy>";
+    const result = await buildPromptContext(
+      { memoryMode: "policy-only", memoryPolicyStyle: "custom", memoryPolicyCustomText: customText },
+      store,
+      projectStore,
+      "demo",
+    );
+
+    assert.strictEqual(result, customText);
+  });
+
+  it("falls back to compact policy when custom policy text is blank", async () => {
+    const result = await buildPromptContext(
+      { memoryMode: "policy-only", memoryPolicyStyle: "custom", memoryPolicyCustomText: "  \n\t  " },
+      store,
+      projectStore,
+      "demo",
+    );
+
+    assert.strictEqual(result, MEMORY_POLICY_PROMPT_COMPACT);
+  });
+
+  it("returns empty context when policy style is none", async () => {
+    const result = await buildPromptContext(
+      { memoryMode: "policy-only", memoryPolicyStyle: "none" },
+      store,
+      projectStore,
+      "demo",
+    );
+
+    assert.strictEqual(result, "");
+  });
+
+  it("returns legacy memory blocks in legacy-inject mode", async () => {
+    const result = await buildPromptContext(
+      { memoryMode: "legacy-inject", memoryPolicyStyle: "compact" },
+      store,
+      projectStore,
+      "demo",
+    );
+
+    assert.match(result, /MEMORY/);
+    assert.match(result, /PROJECT demo/);
+    assert.doesNotMatch(result, /<memory-policy>/);
+  });
+
+  const standing = {
+    formatForSystemPrompt: () => "<standing-instructions>\n1. never run find /\n</standing-instructions>",
+  } as any;
+
+  it("appends standing instructions after the policy in policy-only mode", async () => {
+    const result = await buildPromptContext(
+      { memoryMode: "policy-only" },
+      store,
+      projectStore,
+      "demo",
+      standing,
+    );
+
+    assert.ok(result.startsWith(MEMORY_POLICY_PROMPT), "the policy still leads");
+    assert.match(result, /<standing-instructions>/);
+    assert.match(result, /never run find \//);
+    assert.doesNotMatch(result, /MEMORY<\/memory-context>/, "stored memories stay out of policy-only");
+  });
+
+  it("injects standing instructions even when the policy style is none", async () => {
+    const result = await buildPromptContext(
+      { memoryMode: "policy-only", memoryPolicyStyle: "none" },
+      store,
+      projectStore,
+      "demo",
+      standing,
+    );
+
+    assert.strictEqual(result, "<standing-instructions>\n1. never run find /\n</standing-instructions>");
+  });
+
+  it("puts standing instructions last in legacy-inject mode", async () => {
+    const result = await buildPromptContext(
+      { memoryMode: "legacy-inject" },
+      store,
+      projectStore,
+      "demo",
+      standing,
+    );
+
+    assert.ok(
+      result.indexOf("<standing-instructions>") > result.indexOf("PROJECT demo"),
+      "user directives read last, closest to the task",
+    );
+  });
+
+  it("injects nothing extra when no standing store is wired", async () => {
+    const result = await buildPromptContext({ memoryMode: "policy-only" }, store, projectStore, "demo");
+
+    assert.strictEqual(result, MEMORY_POLICY_PROMPT);
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/handlers/resources-discover.test.ts

@@ -0,0 +1,71 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import * as os from "node:os";
+import * as path from "node:path";
+import { resolveProjectSkillDiscovery, registerProjectSkillDiscoveryHandler } from "../../src/index.js";
+import { AGENT_ROOT } from "../../src/paths.js";
+import { SkillStore } from "../../src/store/skill-store.js";
+
+describe("resources_discover skill path resolution", () => {
+  it("registers resources_discover and returns skillPaths from handler", async () => {
+    const store = new SkillStore({
+      globalSkillsDir: "/tmp/global-skills",
+      projectSkillsDir: null,
+      projectName: null,
+      legacySkillsDir: "/tmp/legacy-skills",
+      migrationSentinelPath: "/tmp/.skills-migrated",
+    });
+
+    const handlers: Record<string, Function> = {};
+    const pi = {
+      on: (event: string, handler: Function) => {
+        handlers[event] = handler;
+      },
+    } as any;
+
+    registerProjectSkillDiscoveryHandler(pi, store, "projects-memory");
+    assert.ok(typeof handlers.resources_discover === "function");
+
+    const result = await handlers.resources_discover({ cwd: "/tmp/demo-repo" }, {});
+    const expectedPath = path.join(AGENT_ROOT, "projects-memory", "demo-repo", "skills");
+
+    assert.deepStrictEqual(result, { skillPaths: ["/tmp/global-skills", expectedPath] });
+  });
+
+  it("returns project skillPaths and updates skill store context", () => {
+    const store = new SkillStore({
+      globalSkillsDir: "/tmp/global-skills",
+      projectSkillsDir: null,
+      projectName: null,
+      legacySkillsDir: "/tmp/legacy-skills",
+      migrationSentinelPath: "/tmp/.skills-migrated",
+    });
+
+    const cwd = "/tmp/demo-repo";
+    const resource = resolveProjectSkillDiscovery(store, "projects-memory", cwd);
+    const expectedPath = path.join(AGENT_ROOT, "projects-memory", "demo-repo", "skills");
+
+    assert.deepStrictEqual(resource, { skillPaths: ["/tmp/global-skills", expectedPath] });
+    assert.strictEqual(store.getProjectName(), "demo-repo");
+    assert.strictEqual(store.getProjectSkillsDir(), expectedPath);
+  });
+
+  it("contributes no skill path when cwd is not a project", () => {
+    const store = new SkillStore({
+      globalSkillsDir: "/tmp/global-skills",
+      projectSkillsDir: "/tmp/old-project",
+      projectName: "old-project",
+      legacySkillsDir: "/tmp/legacy-skills",
+      migrationSentinelPath: "/tmp/.skills-migrated",
+    });
+
+    const resource = resolveProjectSkillDiscovery(store, "projects-memory", os.homedir());
+
+    // Outside a project only the extension's own global root is contributed.
+    // It is a directory of ours, kept apart from the skills a user installed
+    // themselves, so Pi has to be told about it (#126).
+    assert.deepStrictEqual(resource, { skillPaths: ["/tmp/global-skills"] });
+    assert.strictEqual(store.getProjectName(), null);
+    assert.strictEqual(store.getProjectSkillsDir(), null);
+  });
+});