import { createGit } from "just-git";

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

await git.exec("git init", { fs, cwd: "/repo" });
await git.exec("git add .", { fs, cwd: "/repo" });
await git.exec('git commit -m "initial commit"', { fs, cwd: "/repo" });
await git.exec("git log --oneline", { fs, cwd: "/repo" });

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

const bash = new Bash({
  cwd: "/repo",
  customCommands: [createGit({ identity: { name: "Alice", email: "alice@example.com" } })],
});

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

import { createGitServer, SqliteStorage } from "just-git/server";
import { Database } from "bun:sqlite";

const storage = new SqliteStorage(new Database("repos.sqlite"));

const server = createGitServer({
  resolveRepo: (path) => storage.repo(path),
  hooks: {
    preReceive: ({ updates }) => {
      if (updates.some((u) => u.ref === "refs/heads/main" && !u.isFF))
        return { reject: true, message: "no force-push to main" };
    },
    postReceive: ({ repoPath, updates }) => {
      console.log(`${repoPath}: ${updates.length} ref(s) updated`);
    },
  },
});

Bun.serve({ fetch: server.fetch });
// git clone http://localhost:3000/my-repo ← works with real git

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

import { createGit, type GitHooks } from "just-git";
import { getChangedFiles } from "just-git/repo";

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

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

    // Feed agent activity to your UI — with changed file list
    postCommit: async ({ repo, hash, branch, parents }) => {
      const files = await getChangedFiles(repo, parents[0] ?? null, hash);
      onAgentCommit({ hash, branch, changedFiles: files });
    },

    // Audit log — record every command
    afterCommand: ({ command, args, result }) => {
      auditLog.push({ command: `git ${command}`, exitCode: result.exitCode });
    },

    // Gate pushes on human approval
    beforeCommand: async ({ command }) => {
      if (command === "push" && !(await getHumanApproval())) {
        return { reject: true, message: "Push blocked — awaiting approval." };
      }
    },
  },
});

import { createGit, composeGitHooks } from "just-git";

const git = createGit({
  hooks: composeGitHooks(auditHooks, policyHooks, loggingHooks),
});

import {
  readCommit,
  readFileAtCommit,
  getChangedFiles,
  resolveRef,
  listBranches,
  diffTrees,
  flattenTree,
  createCommit,
  writeBlob,
  writeTree,
  mergeTrees,
  checkoutTo,
  readonlyRepo,
} from "just-git/repo";

// Read a file at a specific commit
const content = await readFileAtCommit(repo, commitHash, "src/index.ts");

// Diff two commits
const changes = await getChangedFiles(repo, parentHash, commitHash);

// Merge two branches at the tree level (no worktree needed)
const result = await mergeTrees(repo, oursCommit, theirsCommit);
if (!result.clean) console.log("conflicts:", result.conflicts);

import { Bash, InMemoryFs } from "just-bash";
import { createGit, findRepo } 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 alice = new Bash({
  fs: new InMemoryFs(),
  cwd: "/repo",
  customCommands: [
    createGit({
      identity: { name: "Alice", email: "alice@example.com", locked: true },
      resolveRemote: () => findRepo(originFs, "/repo"),
    }),
  ],
});

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

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