import { Bash } from "just-bash";
import { createGit } from "just-git";

const git = createGit({
  identity: { name: "Alice", email: "alice@example.com" },
});

const bash = new Bash({
  cwd: "/repo",
  customCommands: [git],
});

await bash.exec("git init");
await bash.exec("echo 'hello' > README.md");
await bash.exec("git add .");
await bash.exec('git commit -m "initial commit"');
await bash.exec("git log --oneline");

const git = createGit({
  identity: { name: "Agent Bot", email: "bot@company.com", locked: true },
  credentials: async (url) => ({ type: "bearer", token: "ghp_..." }),
  disabled: ["rebase"],
  network: false, // no HTTP access
});

// Audit log — record every command the agent runs
git.use(async (event, next) => {
  const result = await next();
  auditLog.push({ command: `git ${event.command}`, exitCode: result.exitCode });
  return result;
});

// Gate pushes on human approval
git.use(async (event, next) => {
  if (event.command === "push" && !(await getHumanApproval(event.rawArgs))) {
    return { stdout: "", stderr: "Push blocked — awaiting approval.\n", exitCode: 1 };
  }
  return next();
});

// Block commits that add large files (uses event.fs to read the worktree)
git.use(async (event, next) => {
  if (event.command === "add") {
    for (const path of event.rawArgs.filter((a) => !a.startsWith("-"))) {
      const resolved = path.startsWith("/") ? path : `${event.cwd}/${path}`;
      const stat = await event.fs.stat(resolved).catch(() => null);
      if (stat && stat.size > 5_000_000) {
        return { stdout: "", stderr: `Blocked: ${path} exceeds 5 MB\n`, exitCode: 1 };
      }
    }
  }
  return next();
});

// Block secrets from being committed
git.on("pre-commit", (event) => {
  const forbidden = event.index.entries.filter((e) => /\.(env|pem|key)$/.test(e.path));
  if (forbidden.length) {
    return { abort: true, message: `Blocked: ${forbidden.map((e) => e.path).join(", ")}` };
  }
});

// Enforce conventional commit messages
git.on("commit-msg", (event) => {
  if (!/^(feat|fix|docs|refactor|test|chore)(\(.+\))?:/.test(event.message)) {
    return { abort: true, message: "Commit message must follow conventional commits format" };
  }
});

// Feed agent activity to your UI or orchestration layer
git.on("post-commit", (event) => {
  onAgentCommit({ hash: event.hash, branch: event.branch, message: event.message });
});

import { Bash, InMemoryFs } from "just-bash";
import { createGit, findGitDir } from "just-git";

// Origin repo on its own filesystem
const originFs = new InMemoryFs();
const setupBash = new Bash({
  fs: originFs,
  cwd: "/repo",
  customCommands: [
    createGit({ identity: { name: "Setup", email: "setup@example.com", locked: true } }),
  ],
});
await setupBash.exec("git init");
await setupBash.exec("echo 'hello' > README.md");
await setupBash.exec("git add . && git commit -m 'initial'");

const originCtx = await findGitDir(originFs, "/repo");
const resolve = (url: string) => (url === "/origin" ? originCtx : null);

// Each agent gets its own filesystem + resolveRemote pointing to origin
const alice = new Bash({
  fs: new InMemoryFs(),
  cwd: "/repo",
  customCommands: [
    createGit({
      identity: { name: "Alice", email: "alice@example.com", locked: true },
      resolveRemote: resolve,
    }),
  ],
});

const bob = new Bash({
  fs: new InMemoryFs(),
  cwd: "/repo",
  customCommands: [
    createGit({
      identity: { name: "Bob", email: "bob@example.com", locked: true },
      resolveRemote: resolve,
    }),
  ],
});

await alice.exec("git clone /origin /repo");
await bob.exec("git clone /origin /repo");

// Alice and Bob work independently, push to origin, fetch each other's changes

import { createGit } from "just-git";

const git = createGit({ identity: { name: "Bot", email: "bot@example.com" } });

const result = await git.execute(["init"], {
  fs: myFileSystem, // any FileSystem implementation
  cwd: "/repo",
  env: new Map(),
  stdin: "",
});

console.log(result.exitCode); // 0