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: { allowed: ["github.com"], fetch: customFetch },
});

// 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 });
});

git.on("post-push", (event) => {
  onAgentPush({ remote: event.remote, refs: event.refs });
});

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");

// Each agent gets its own filesystem + resolveRemote pointing to origin
function createAgent(name: string, email: string) {
  const agentFs = new InMemoryFs();
  const git = createGit({
    identity: { name, email, locked: true },
    resolveRemote: (url) => (url === "/origin" ? originCtx : null),
  });
  return new Bash({ fs: agentFs, cwd: "/repo", customCommands: [git] });
}

const alice = createAgent("Alice", "alice@example.com");
const bob = createAgent("Bob", "bob@example.com");

await alice.exec("git clone /origin /repo", { cwd: "/" });
await bob.exec("git clone /origin /repo", { cwd: "/" });

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