current state and a five-second heartbeat to standard error.

`repo view` and `repo clone` accept `-R, --repo <owner>/<name>`. When you omit a

repository, the CLI infers it only from an exact `/<owner>/<repo>.git` URL

on the selected OpenAgents API origin.

repository, the CLI infers it from this checkout's Git remotes.

A remote's name does not decide this; its URL does. The CLI reads every remote

and takes the first whose URL is an exact `/<owner>/<repo>.git` path on the

OpenAgents API origin in use, so a forge remote named `openagents` and one named

`origin` both work. A GitHub mirror is never inferred, whatever it is called,

because the forge is the authority for issues and projects and a mirror is not.

When more than one remote points at the forge, `origin` wins, then `openagents`,

then the rest in the order `git remote -v` lists them.

When no remote qualifies, the CLI names each remote it examined and why it was

rejected, and asks for `OWNER/REPO` instead.

`repo delete` permanently deletes a repository you own, including its Git

history, issues, projects, and import records. It accepts an explicit

Projects are repository-scoped, so every project command takes the same

`-R, --repo` and remote inference the issue commands take.

Every issue and project command accepts `-R, --repo <owner>/<name>` and falls

back to the origin remote the way `repo view` does. Issue and project numbers

are bare integers; a leading `#` is accepted and never required.

Every issue and project command accepts `-R, --repo <owner>/<name>` and

otherwise infers the repository from the forge remote the way `repo view` does,

whatever that remote is named. Issue and project numbers are bare integers; a

leading `#` is accepted and never required.

Add `--json` before a subcommand to return machine-readable output. Add

`--no-color`, or set `NO_COLOR`, to disable ANSI output. The clone command

    try: () => new URL(remoteUrl),

    catch: () =>

      new InputError({

        message: "The origin remote is not an admitted OpenAgents repository URL.",

        message: "That Git remote URL is not an admitted OpenAgents repository URL.",

      }),

  });

  const parts = remote.pathname.split("/");

    !repositoryWithSuffix.endsWith(".git")

  ) {

    return yield* new InputError({

      message: "The origin remote is not an admitted OpenAgents repository URL.",

      message: "That Git remote URL is not an admitted OpenAgents repository URL.",

    });

  }

  const repository = repositoryWithSuffix.slice(0, -4);

    try: () => [decodeURIComponent(owner), decodeURIComponent(repository)] as const,

    catch: () =>

      new InputError({

        message: "The origin remote is not an admitted OpenAgents repository URL.",

        message: "That Git remote URL is not an admitted OpenAgents repository URL.",

      }),

  });

  if (

    decodedRepository.length === 0

  ) {

    return yield* new InputError({

      message: "The origin remote is not an admitted OpenAgents repository URL.",

      message: "That Git remote URL is not an admitted OpenAgents repository URL.",

    });

  }

  return `${decodedOwner}/${decodedRepository}`;

});

export interface GitRemoteUrl {

  readonly name: string;

  readonly url: string;

}

/**

 * Reads `git remote -v` into one URL per remote.

 *

 * Each remote prints a fetch line and a push line. The fetch URL is the one a

 * repository is read from, so it wins; a remote configured for push alone

 * still contributes the URL it has.

 */

export const parseGitRemotes = (output: string): ReadonlyArray<GitRemoteUrl> => {

  const urls = new Map<string, string>();

  for (const rawLine of output.split("\n")) {

    const match = /^(\S+)\s+(.+)\s+\((fetch|push)\)$/u.exec(rawLine.trim());

    if (match === null) continue;

    const name = match[1];

    const url = match[2];

    if (name === undefined || url === undefined) continue;

    if (match[3] === "fetch" || !urls.has(name)) urls.set(name, url);

  }

  return [...urls].map(([name, url]) => ({ name, url }));

};

/**

 * Remote names tried first, in order.

 *

 * A name never admits a remote; only its URL does. This order decides between

 * remotes that already point at the API origin in use. `origin` comes first so

 * a checkout that resolved before this rule existed still resolves to the same

 * repository, then the forge name this project's own documentation uses. Any

 * other remote follows in the order `git remote -v` printed it, which git

 * emits by name, so the same checkout always answers the same way.

 */

const PREFERRED_REMOTE_NAMES: ReadonlyArray<string> = ["origin", "openagents"];

export const orderedRemoteNames = (names: ReadonlyArray<string>): ReadonlyArray<string> => [

  ...PREFERRED_REMOTE_NAMES.filter((preferred) => names.includes(preferred)),

  ...names.filter((name) => !PREFERRED_REMOTE_NAMES.includes(name)),

];

/** Why one remote is not the repository, in the words a reader can act on. */

const remoteRejection = (origin: string, url: string): string => {

  let remote: URL;

  try {

    remote = new URL(url);

  } catch {

    return "is not an HTTP URL";

  }

  if (remote.protocol !== "http:" && remote.protocol !== "https:") return "is not an HTTP URL";

  if (remote.origin !== origin) return `points at ${remote.origin}`;

  return "is not an OWNER/REPO.git path on that origin";

};

export const gitRunnerLayer = Layer.effect(

  GitRunner,

  Effect.gen(function* () {

      return { remote, nextPushArguments: ["push", "-u", remote, "HEAD"] };

    });

    /**

     * The repository this checkout belongs to, taken from its Git remotes.

     *

     * A remote's name is a local convention: this project's own contract names

     * the forge remote `openagents` and reserves `origin` for the GitHub

     * mirror, while other checkouts name the forge `origin`. The URL is the

     * fact, so a remote is admitted only when its URL is a repository URL on

     * the API origin this invocation is already talking to. A mirror is

     * therefore never inferred, whatever it is called.

     */

    const inferRepository = Effect.fn("GitRunner.inferRepository")(function* (

      origin: string,

      directory = ".",

    ) {

      const existing = yield* runGit(

        "git origin lookup",

        ["remote", "get-url", "--", "origin"],

        directory,

      );

      if (existing.exitCode !== 0 || existing.stdout.length === 0) {

      const listed = yield* runGit("git remote lookup", ["remote", "-v"], directory);

      if (listed.exitCode !== 0) {

        return yield* new InputError({

          message: `The CLI could not read the Git remotes of ${directory}. Pass OWNER/REPO instead.`,

        });

      }

      const remotes = parseGitRemotes(listed.stdout);

      if (remotes.length === 0) {

        return yield* new InputError({

          message: "Pass OWNER/REPO or configure an admitted OpenAgents origin remote.",

          message: `This checkout has no Git remotes. Pass OWNER/REPO, or add a remote for ${origin}.`,

        });

      }

      return yield* repositoryFromRemoteUrl(origin, existing.stdout);

      const byName = new Map(remotes.map((remote) => [remote.name, remote.url]));

      const rejected: Array<string> = [];

      for (const name of orderedRemoteNames([...byName.keys()])) {

        const url = byName.get(name);

        if (url === undefined) continue;

        const repository = yield* repositoryFromRemoteUrl(origin, url).pipe(

          Effect.orElseSucceed((): string | undefined => undefined),

        );

        if (repository !== undefined) return repository;

        rejected.push(`${name} ${remoteRejection(origin, url)}`);

      }

      return yield* new InputError({

        message:

          `No Git remote of this checkout is a repository on ${origin}, the OpenAgents origin in use: ` +

          `${rejected.join("; ")}. A remote's name does not decide this; its URL does. ` +

          "Pass OWNER/REPO instead.",

      });

    });

    const configureCredentialHelper = Effect.fn("GitRunner.configureCredentialHelper")(function* (

  GitRunner,

  gitCloneArgv,

  gitRunnerLayer,

  orderedRemoteNames,

  parseGitRemotes,

  repositoryFromRemoteUrl,

} from "../src/git-runner.js";

    }

  });

});

const FORGE = "http://localhost:4000";

/** A throwaway checkout carrying exactly the remotes a case is about. */

const withRemotes = async (

  remotes: ReadonlyArray<readonly [string, string]>,

  assert: (directory: string) => Promise<void>,

) => {

  const directory = await mkdtemp(join(tmpdir(), "openagents-cli-remotes-"));

  try {

    execFileSync("git", ["init", "--quiet", directory]);

    for (const [name, url] of remotes) {

      execFileSync("git", ["-C", directory, "remote", "add", name, url]);

    }

    await assert(directory);

  } finally {

    await rm(directory, { recursive: true, force: true });

  }

};

const infer = (directory: string) =>

  Effect.runPromise(

    Effect.gen(function* () {

      const git = yield* GitRunner;

      return yield* git.inferRepository(FORGE, directory);

    }).pipe(Effect.provide(gitRunnerLayer.pipe(Layer.provide(NodeServices.layer)))),

  );

describe("repository inference from Git remotes", () => {

  it("reads one URL per remote and prefers the fetch URL", () => {

    expect(

      parseGitRemotes(

        [

          "openagents\thttp://localhost:4000/octavia/project.git (fetch)",

          "openagents\thttp://localhost:4000/octavia/project.git (push)",

          "mirror\thttps://github.com/octavia/project.git (fetch)",

          "mirror\tno-push (push)",

        ].join("\n"),

      ),

    ).toEqual([

      { name: "openagents", url: "http://localhost:4000/octavia/project.git" },

      { name: "mirror", url: "https://github.com/octavia/project.git" },

    ]);

  });

  it("tries origin, then the documented forge name, then the rest as listed", () => {

    expect(orderedRemoteNames(["upstream", "openagents", "origin"])).toEqual([

      "origin",

      "openagents",

      "upstream",

    ]);

    expect(orderedRemoteNames(["zulu", "alpha"])).toEqual(["zulu", "alpha"]);

  });

  it("infers from a forge remote named openagents, the name this project mandates", async () => {

    await withRemotes([["openagents", `${FORGE}/octavia/project.git`]], async (directory) => {

      await expect(infer(directory)).resolves.toBe("octavia/project");

    });

  });

  it("still infers where the forge remote is named origin", async () => {

    await withRemotes([["origin", `${FORGE}/octavia/project.git`]], async (directory) => {

      await expect(infer(directory)).resolves.toBe("octavia/project");

    });

  });

  it("ignores a GitHub mirror and takes the forge remote beside it", async () => {

    await withRemotes(

      [

        ["origin", "https://github.com/octavia/project.git"],

        ["openagents", `${FORGE}/octavia/forge-name.git`],

      ],

      async (directory) => {

        await expect(infer(directory)).resolves.toBe("octavia/forge-name");

      },

    );

  });

  it("prefers origin when both remotes are on the forge, so existing setups do not move", async () => {

    await withRemotes(

      [

        ["openagents", `${FORGE}/octavia/second.git`],

        ["origin", `${FORGE}/octavia/first.git`],

      ],

      async (directory) => {

        await expect(infer(directory)).resolves.toBe("octavia/first");

      },

    );

  });

  it("refuses a checkout whose only remote is a GitHub mirror, and says why", async () => {

    await withRemotes([["origin", "https://github.com/octavia/project.git"]], async (directory) => {

      await expect(infer(directory)).rejects.toThrow(/origin points at https:\/\/github\.com/u);

      await expect(infer(directory)).rejects.toThrow(/name does not decide this/u);

    });

  });

  it("names a remote on the forge whose path is not a repository", async () => {

    await withRemotes([["openagents", `${FORGE}/octavia/deep/project.git`]], async (directory) => {

      await expect(infer(directory)).rejects.toThrow(

        /openagents is not an OWNER\/REPO\.git path on that origin/u,

      );

    });

  });

  it("refuses a checkout with no remotes at all", async () => {

    await withRemotes([], async (directory) => {

      await expect(infer(directory)).rejects.toThrow(/has no Git remotes/u);

    });

  });

});