@selesai/code 0.12.0 → 0.13.1

package/dist/extensions/pi-hermes-memory/tests/project-rebinding.test.ts

@@ -0,0 +1,115 @@
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+
+interface MockPi {
+  handlers: Record<string, Array<(event: any, ctx: any) => unknown>>;
+  tools: Record<string, { execute: (...args: any[]) => Promise<any> }>;
+  on(event: string, handler: (event: any, ctx: any) => unknown): void;
+  registerTool(def: { name: string; execute: (...args: any[]) => Promise<any> }): void;
+  registerCommand(): void;
+}
+
+describe("session project memory rebinding", () => {
+  it("writes project memory using session cwd when factory cwd differs", async () => {
+    const agentRoot = await fs.mkdtemp(path.join(os.tmpdir(), "pi-project-rebind-agent-"));
+    const launchDir = await fs.mkdtemp(path.join(os.tmpdir(), "pi-project-rebind-launch-"));
+    const targetDir = await fs.mkdtemp(path.join(os.tmpdir(), "pi-project-rebind-target-"));
+    const previousAgentRoot = process.env.SELESAI_CODING_AGENT_DIR;
+    const previousPiAgentRoot = process.env.PI_CODING_AGENT_DIR;
+    const previousCwd = process.cwd();
+    try {
+      await fs.writeFile(
+        path.join(agentRoot, "hermes-memory-config.json"),
+        JSON.stringify({
+          memoryMode: "legacy-inject",
+          reviewEnabled: false,
+          flushOnCompact: false,
+          flushOnShutdown: false,
+          autoConsolidate: false,
+          correctionDetection: false,
+          standingInstructionsEnabled: false,
+        }),
+      );
+      const launchMemoryDir = path.join(agentRoot, "projects-memory", path.basename(launchDir));
+      const sessionMemoryDir = path.join(agentRoot, "projects-memory", path.basename(targetDir));
+      await fs.mkdir(launchMemoryDir, { recursive: true });
+      await fs.mkdir(sessionMemoryDir, { recursive: true });
+      await fs.writeFile(
+        path.join(launchMemoryDir, "MEMORY.md"),
+        "launch-directory memory",
+      );
+      await fs.writeFile(
+        path.join(sessionMemoryDir, "MEMORY.md"),
+        "active-session memory",
+      );
+
+      process.env.SELESAI_CODING_AGENT_DIR = agentRoot;
+      // Tests run outside the extension loader (no jiti alias), so the
+      // upstream pi-coding-agent getAgentDir() still reads PI_CODING_AGENT_DIR.
+      process.env.PI_CODING_AGENT_DIR = agentRoot;
+      process.chdir(launchDir);
+      // Import after setting the agent dir so AGENT_ROOT is test-local.
+      const { default: registerExtension } = await import("../src/index.js");
+      const mockPi: MockPi = {
+        handlers: {},
+        tools: {},
+        on(event, handler) {
+          (this.handlers[event] ??= []).push(handler);
+        },
+        registerTool(def) {
+          this.tools[def.name] = def;
+        },
+        registerCommand() {},
+      };
+      registerExtension(mockPi as any);
+
+      const sessionStart = mockPi.handlers.session_start?.[0];
+      const resourcesDiscover = mockPi.handlers.resources_discover?.[0];
+      const beforeAgentStart = mockPi.handlers.before_agent_start?.[0];
+      assert.ok(sessionStart);
+      assert.ok(resourcesDiscover);
+      assert.ok(beforeAgentStart);
+      assert.ok(mockPi.tools.memory_add);
+
+      const sessionCtx = {
+        cwd: targetDir,
+        sessionManager: { getBranch: () => [] },
+        ui: { notify() {} },
+      };
+
+      // Pi lifecycle: session_start, then resources_discover, then tool execute.
+      await sessionStart({}, sessionCtx);
+      await resourcesDiscover({ cwd: targetDir, reason: "startup" }, sessionCtx);
+
+      const result = await beforeAgentStart({ systemPrompt: "base" }, sessionCtx) as { systemPrompt: string };
+      assert.match(result.systemPrompt, /active-session memory/);
+      assert.doesNotMatch(result.systemPrompt, /launch-directory memory/);
+
+      const writeResult = await mockPi.tools.memory_add.execute(
+        "tc-session-cwd",
+        { target: "project", content: "session-cwd write" },
+        undefined,
+        undefined,
+        { cwd: targetDir },
+      );
+      assert.equal(writeResult.details.success, true);
+
+      const sessionMemory = await fs.readFile(path.join(sessionMemoryDir, "MEMORY.md"), "utf-8");
+      const launchMemory = await fs.readFile(path.join(launchMemoryDir, "MEMORY.md"), "utf-8");
+      assert.match(sessionMemory, /session-cwd write/);
+      assert.doesNotMatch(launchMemory, /session-cwd write/);
+    } finally {
+      process.chdir(previousCwd);
+      if (previousAgentRoot === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+      else process.env.SELESAI_CODING_AGENT_DIR = previousAgentRoot;
+      if (previousPiAgentRoot === undefined) delete process.env.PI_CODING_AGENT_DIR;
+      else process.env.PI_CODING_AGENT_DIR = previousPiAgentRoot;
+      await fs.rm(agentRoot, { recursive: true, force: true });
+      await fs.rm(launchDir, { recursive: true, force: true });
+      await fs.rm(targetDir, { recursive: true, force: true });
+    }
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/project.test.ts

@@ -0,0 +1,120 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { detectProject, detectProjectSkills } from "../src/project.js";
+import { AGENT_ROOT } from "../src/paths.js";
+
+function git(cwd: string, ...args: string[]): void {
+  execFileSync("git", args, {
+    cwd,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: "t",
+      GIT_AUTHOR_EMAIL: "t@example.com",
+      GIT_COMMITTER_NAME: "t",
+      GIT_COMMITTER_EMAIL: "t@example.com",
+    },
+  });
+}
+
+/** Real repo with one commit plus a linked worktree, since #120 is entirely about worktree layout. */
+function makeRepoWithWorktree(): { root: string; repo: string; worktree: string } {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "hermes-project-")));
+  const repo = path.join(root, "my-project");
+  fs.mkdirSync(path.join(repo, "packages", "api"), { recursive: true });
+  git(root, "init", "-q", "-b", "main", "my-project");
+  fs.writeFileSync(path.join(repo, "README.md"), "x\n");
+  git(repo, "add", ".");
+  git(repo, "commit", "-qm", "init");
+
+  const worktree = path.join(root, "worktrees", "issue-123");
+  git(repo, "worktree", "add", "-q", "-b", "issue-123", worktree);
+
+  return { root, repo, worktree };
+}
+
+describe("project detection", () => {
+  it("detectProject returns null outside a project", () => {
+    const result = detectProject("projects-memory", os.homedir());
+    assert.deepStrictEqual(result, { name: null, memoryDir: null });
+  });
+
+  it("detectProject resolves the project memory directory from cwd", () => {
+    const cwd = "/tmp/demo-repo";
+    const result = detectProject("projects-memory", cwd);
+
+    assert.strictEqual(result.name, "demo-repo");
+    assert.strictEqual(
+      result.memoryDir,
+      path.join(AGENT_ROOT, "projects-memory", "demo-repo"),
+    );
+  });
+
+  it("detectProjectSkills appends the skills directory for dynamic discovery", () => {
+    const cwd = "/tmp/demo-repo";
+    const result = detectProjectSkills("projects-memory", cwd);
+
+    assert.strictEqual(result.name, "demo-repo");
+    assert.strictEqual(
+      result.skillsDir,
+      path.join(AGENT_ROOT, "projects-memory", "demo-repo", "skills"),
+    );
+  });
+});
+
+describe("git worktree project identity (#120)", () => {
+  it("gives a linked worktree the same project identity as its main checkout", () => {
+    const { root, repo, worktree } = makeRepoWithWorktree();
+    try {
+      assert.strictEqual(detectProject("projects-memory", repo).name, "my-project");
+      assert.strictEqual(detectProject("projects-memory", worktree).name, "my-project");
+      assert.strictEqual(
+        detectProject("projects-memory", worktree).memoryDir,
+        detectProject("projects-memory", repo).memoryDir,
+      );
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("scopes a subdirectory of the repository to the repository", () => {
+    const { root, repo } = makeRepoWithWorktree();
+    try {
+      assert.strictEqual(
+        detectProject("projects-memory", path.join(repo, "packages", "api")).name,
+        "my-project",
+      );
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps using an existing cwd-basename store instead of orphaning it", () => {
+    const { root, repo } = makeRepoWithWorktree();
+    const legacy = path.join(AGENT_ROOT, "projects-memory", "api");
+    const legacyPreexisting = fs.existsSync(legacy);
+    try {
+      fs.mkdirSync(legacy, { recursive: true });
+      assert.strictEqual(
+        detectProject("projects-memory", path.join(repo, "packages", "api")).name,
+        "api",
+      );
+    } finally {
+      if (!legacyPreexisting) fs.rmSync(legacy, { recursive: true, force: true });
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("falls back to the directory basename outside a repository", () => {
+    const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "hermes-nogit-")));
+    try {
+      assert.strictEqual(detectProject("projects-memory", dir).name, path.basename(dir));
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/run-all-timeout.test.ts

@@ -0,0 +1,107 @@
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+interface RunnerResult {
+  code: number | null;
+  stdout: string;
+  stderr: string;
+}
+
+async function createRunnerFixture(): Promise<string> {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "pi-run-all-timeout-"));
+  await fs.mkdir(path.join(root, "tests"));
+  await fs.copyFile(
+    path.join(REPO_ROOT, "tests/run-all.sh"),
+    path.join(root, "tests/run-all.sh"),
+  );
+  await fs.writeFile(path.join(root, "tests/sample.test.ts"), "// executed by the test double\n");
+  return root;
+}
+
+async function writeExecutable(file: string, content: string): Promise<void> {
+  await fs.writeFile(file, content, { mode: 0o755 });
+  await fs.chmod(file, 0o755);
+}
+
+function runRunner(root: string, env: Record<string, string>): Promise<RunnerResult> {
+  const { promise, resolve, reject } = Promise.withResolvers<RunnerResult>();
+  const child = spawn("bash", ["tests/run-all.sh"], {
+    cwd: root,
+    env: { ...process.env, ...env },
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.setEncoding("utf8");
+  child.stderr.setEncoding("utf8");
+  child.stdout.on("data", (chunk: string) => { stdout += chunk; });
+  child.stderr.on("data", (chunk: string) => { stderr += chunk; });
+  child.once("error", reject);
+  child.once("close", (code) => resolve({ code, stdout, stderr }));
+  return promise;
+}
+
+describe("tests/run-all.sh timeout guard", () => {
+  it("accepts TEST_TIMEOUT=0 and preserves the no-timeout fallback", async () => {
+    const root = await createRunnerFixture();
+    const bin = path.join(root, "bin");
+    await fs.mkdir(bin);
+    await writeExecutable(path.join(bin, "npx"), "#!/bin/sh\nexit 0\n");
+    try {
+      const result = await runRunner(root, {
+        PATH: `${bin}:${process.env.PATH ?? ""}`,
+        TEST_TIMEOUT: "0",
+      });
+      assert.equal(result.code, 0);
+      assert.match(result.stdout, /All 1 test files passed/);
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("reports the timed-out file and requests forced process-tree cleanup", async () => {
+    const root = await createRunnerFixture();
+    const bin = path.join(root, "bin");
+    const timeoutArgs = path.join(root, "timeout-args");
+    await fs.mkdir(bin);
+    await writeExecutable(path.join(bin, "npx"), "#!/bin/sh\nexit 0\n");
+    await writeExecutable(
+      path.join(bin, "timeout"),
+      `#!/bin/sh\nprintf '%s\\n' "$@" > "${timeoutArgs}"\nexit 124\n`,
+    );
+    try {
+      const result = await runRunner(root, {
+        PATH: `${bin}:${process.env.PATH ?? ""}`,
+        TEST_TIMEOUT: "0.1",
+      });
+      assert.equal(result.code, 1);
+      assert.match(result.stdout, />0\.1s\): tests\/sample\.test\.ts/);
+      assert.deepEqual(
+        (await fs.readFile(timeoutArgs, "utf8")).trim().split("\n").slice(0, 2),
+        ["--kill-after=5s", "0.1"],
+      );
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("rejects invalid and negative timeout values before running tests", async () => {
+    const root = await createRunnerFixture();
+    try {
+      for (const value of ["-1", "not-a-number"]) {
+        const result = await runRunner(root, { TEST_TIMEOUT: value });
+        assert.equal(result.code, 2);
+        assert.match(result.stderr, new RegExp(`Invalid TEST_TIMEOUT: ${value}`));
+      }
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/run-all.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# Run each test file in its own tsx process to avoid node:test runner hang.
+set -euo pipefail
+PASS=0
+
+TEST_TIMEOUT="${TEST_TIMEOUT:-120}"
+if [[ ! "$TEST_TIMEOUT" =~ ^[0-9]+([.][0-9]+)?$ ]]; then
+  echo "Invalid TEST_TIMEOUT: $TEST_TIMEOUT (expected a non-negative number of seconds)" >&2
+  exit 2
+fi
+
+TIMEOUT_BIN=()
+if [[ ! "$TEST_TIMEOUT" =~ ^0+([.]0+)?$ ]]; then
+  if command -v timeout >/dev/null 2>&1; then
+    TIMEOUT_BIN=(timeout)
+  elif command -v gtimeout >/dev/null 2>&1; then
+    TIMEOUT_BIN=(gtimeout)
+  fi
+fi
+
+run_test_file() {
+  local file="$1"
+  if ((${#TIMEOUT_BIN[@]} > 0)); then
+    "${TIMEOUT_BIN[@]}" --kill-after=5s "$TEST_TIMEOUT" npx tsx --test "$file"
+  else
+    npx tsx --test "$file"
+  fi
+}
+
+for f in $(find tests -name '*.test.ts' | sort); do
+  echo "--- $f ---"
+  if run_test_file "$f"; then
+    PASS=$((PASS + 1))
+  else
+    rc=$?
+    if [[ "$rc" -eq 124 && ${#TIMEOUT_BIN[@]} -gt 0 ]]; then
+      echo "TIMEOUT (>${TEST_TIMEOUT}s): $f"
+    else
+      echo "FAILED (exit $rc): $f"
+    fi
+    exit 1
+  fi
+done
+
+echo "All $PASS test files passed"