* server's. A tool description reaches both.

 */

import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";

import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";

import { homedir } from "node:os";

import { dirname, join } from "node:path";

import { basename, dirname, join } from "node:path";

import { fileURLToPath } from "node:url";

/**

 */

const openAgentsWorkspace = (cwd: string): string | undefined => {

  if (!/openagents/i.test(cwd)) return undefined;

  return [

  const lines = [

    `This session is working in ${cwd}, which is part of OpenAgents. Two repositories carry`,

    "most of the work, and they are easy to confuse:",

    "",

    "",

    "They are separate repositories with separate issue lists, so name the one you mean when you",

    "read or write issues, and do not assume the current directory is the one being asked about.",

  ].join("\n");

  ];

  // Where the other one is, when it is checked out beside this one.

  //

  // Naming the two repositories without saying where the other one lives sent

  // a session looking for a CLI constant in the wrong tree: it guessed the

  // sibling path correctly, ran `git grep <pattern> ../openagents` — which git

  // refuses, because the path is outside the repository it is standing in —

  // and then fell back to grepping the whole workspace root, which holds every

  // read-only reference clone and took the tool's whole 120-second budget

  // before being stopped.

  const sibling = siblingCheckout(cwd);

  if (sibling !== undefined) {

    lines.push(

      "",

      `The other one is checked out at \`${sibling.path}\`. To search or read it, change`,

      `directory first — \`cd ${sibling.path} && git grep …\`. \`git grep\` refuses a path`,

      "outside the repository it is run in, and it is the one command most likely to be reached",

      "for here.",

      "",

      `Do not search \`${dirname(sibling.path)}\` itself. It is the workspace root, and it holds`,

      "large read-only clones of other people's repositories; a recursive grep there does not",

      "finish. Search one repository at a time.",

    );

  }

  return lines.join("\n");

};

/**

 * The other OpenAgents repository, if it is checked out beside this one.

 *

 * Checked rather than assumed: a machine with only one of the two would

 * otherwise be told to `cd` somewhere that does not exist, which is a worse

 * instruction than none.

 */

const siblingCheckout = (cwd: string): { readonly name: string; readonly path: string } | undefined => {

  const here = basename(cwd);

  const other = here === "openagents.com" ? "openagents" : here === "openagents" ? "openagents.com" : undefined;

  if (other === undefined) return undefined;

  const path = join(dirname(cwd), other);

  return existsSync(join(path, ".git")) ? { name: other, path } : undefined;

};

    expect(standingContext([], "/Users/x/work/something")).toBeUndefined();

  });

});

describe("finding the other OpenAgents repository", () => {

  const workspace = () => {

    const root = mkdtempSync(join(tmpdir(), "oa-work-"));

    for (const name of ["openagents", "openagents.com"]) {

      mkdirSync(join(root, name, ".git"), { recursive: true });

    }

    return root;

  };

  it("says where the sibling is, and how to reach it", () => {

    // The gap this closes: a session was told the two repositories exist and

    // not where the other one was. It guessed the path right, ran

    // `git grep <pattern> ../openagents`, and git refused it for being outside

    // the repository — then fell back to grepping the workspace root, which

    // holds every read-only reference clone, and spent the tool's whole

    // 120-second budget before being stopped.

    const root = workspace();

    const standing = standingContext([], join(root, "openagents.com")) ?? "";

    expect(standing).toContain(join(root, "openagents"));

    expect(standing).toContain("cd ");

    expect(standing).toContain("outside the repository");

  });

  it("warns off the workspace root by name", () => {

    const root = workspace();

    const standing = standingContext([], join(root, "openagents")) ?? "";

    expect(standing).toContain(join(root, "openagents.com"));

    expect(standing).toContain(`Do not search \`${root}\``);

  });

  it("says nothing about a sibling that is not checked out", () => {

    // Worse than no instruction: one telling the reader to `cd` somewhere that

    // does not exist.

    const root = mkdtempSync(join(tmpdir(), "oa-lone-"));

    mkdirSync(join(root, "openagents.com", ".git"), { recursive: true });

    const standing = standingContext([], join(root, "openagents.com")) ?? "";

    expect(standing).toContain("Two repositories carry");

    expect(standing).not.toContain("cd ");

    expect(standing).not.toContain("Do not search");

  });

  it("says nothing about a sibling for a directory that is neither", () => {

    const root = workspace();

    mkdirSync(join(root, "openagents-notes"), { recursive: true });

    const standing = standingContext([], join(root, "openagents-notes")) ?? "";

    expect(standing).toContain("Two repositories carry");

    expect(standing).not.toContain("cd ");

  });

});