@a5c-ai/git-a5c 1.0.2

package/test/cli.flow.integration.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import { runCli } from "../src/run.js";
+import { makeEmptyRepo } from "./_util.js";
+
+describe("CLI real workflow (maturization)", () => {
+  it("can run a basic issue + pr workflow end-to-end", async () => {
+    const repo = await makeEmptyRepo("a5cforge-cli-flow-");
+    process.env.A5C_ACTOR = "alice";
+
+    // 1) Create issue
+    let out = "";
+    let code = await runCli(["issue", "new", "--repo", repo, "--id", "issue-flow-1", "--title", "Flow issue", "--commit"], {
+      stdout: (s) => (out += s),
+      stderr: () => {}
+    });
+    expect(code).toBe(0);
+    expect(out.trim()).toBe("issue-flow-1");
+
+    // 2) Add a comment
+    out = "";
+    code = await runCli(["issue", "comment", "issue-flow-1", "--repo", repo, "--comment-id", "c-flow-1", "-m", "hello", "--commit"], {
+      stdout: (s) => (out += s),
+      stderr: () => {}
+    });
+    expect(code).toBe(0);
+    expect(out.trim()).toBe("c-flow-1");
+
+    // 3) Needs-human gate
+    out = "";
+    code = await runCli(["gate", "needs-human", "issue-flow-1", "--repo", repo, "--topic", "review", "-m", "needs eyes", "--commit"], {
+      stdout: (s) => (out += s),
+      stderr: () => {}
+    });
+    expect(code).toBe(0);
+    expect(out).toContain(".collab/");
+
+    // 4) Claim the work (agent dispatch is what an agent would react to)
+    out = "";
+    code = await runCli(["agent", "dispatch", "--repo", repo, "--entity", "issue-flow-1", "--dispatch-id", "d-flow-1", "--task", "implement"], {
+      stdout: (s) => (out += s),
+      stderr: () => {}
+    });
+    expect(code).toBe(0);
+    expect(out).toContain(".collab/agents/events/");
+
+    // 5) Create PR request
+    out = "";
+    code = await runCli(["pr", "request", "--repo", repo, "--id", "pr-flow-1", "--base", "refs/heads/main", "--title", "Do the thing", "--commit"], {
+      stdout: (s) => (out += s),
+      stderr: () => {}
+    });
+    expect(code).toBe(0);
+    expect(out.trim()).toBe("pr-flow-1");
+
+    // 6) Sanity: status + show JSON reflect the repo
+    out = "";
+    code = await runCli(["status", "--repo", repo, "--json"], { stdout: (s) => (out += s), stderr: () => {} });
+    expect(code).toBe(0);
+    const st = JSON.parse(out);
+    expect(st).toMatchObject({ treeish: "HEAD", issues: 1, prs: 1 });
+
+    out = "";
+    code = await runCli(["issue", "show", "issue-flow-1", "--repo", repo, "--json"], { stdout: (s) => (out += s), stderr: () => {} });
+    expect(code).toBe(0);
+    const issue = JSON.parse(out);
+    expect(issue.issueId).toBe("issue-flow-1");
+    expect(issue.comments.map((c: any) => c.commentId)).toContain("c-flow-1");
+
+    out = "";
+    code = await runCli(["pr", "show", "pr-flow-1", "--repo", repo, "--json"], { stdout: (s) => (out += s), stderr: () => {} });
+    expect(code).toBe(0);
+    const pr = JSON.parse(out);
+    expect(pr).toMatchObject({ prKey: "pr-flow-1", kind: "request" });
+
+    // 7) Journal includes the new events
+    process.env.A5C_NOW_ISO = new Date().toISOString();
+    out = "";
+    code = await runCli(["journal", "--repo", repo, "--since", "2h", "--types", "issue.*,comment.*,pr.*"], { stdout: (s) => (out += s), stderr: () => {} });
+    expect(code).toBe(0);
+    expect(out).toContain("issue.event.created");
+    expect(out).toContain("comment.created");
+    expect(out).toContain("pr.request.created");
+  }, 20_000);
+});
+
+

package/test/cli.snapshots.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { runCli } from "../src/run.js";
+import { makeRepoFromFixture } from "./_util.js";
+
+describe("CLI (Phase 4)", () => {
+  it("status (repo-basic)", async () => {
+    const repo = await makeRepoFromFixture("repo-basic");
+    let out = "";
+    const code = await runCli(["status", "--repo", repo], { stdout: (s) => (out += s), stderr: () => {} });
+    expect(code).toBe(0);
+    expect(out).toBe(["treeish: HEAD", "issues: 2", "prs: 2", ""].join("\n"));
+  });
+
+  it("issue list (repo-basic)", async () => {
+    const repo = await makeRepoFromFixture("repo-basic");
+    let out = "";
+    const code = await runCli(["issue", "list", "--repo", repo], { stdout: (s) => (out += s), stderr: () => {} });
+    expect(code).toBe(0);
+    expect(out).toBe(["issue-1", "issue-2", ""].join("\n"));
+  });
+
+  it("pr show --json (repo-basic)", async () => {
+    const repo = await makeRepoFromFixture("repo-basic");
+    let out = "";
+    const code = await runCli(["pr", "show", "pr-2", "--json", "--repo", repo], { stdout: (s) => (out += s), stderr: () => {} });
+    expect(code).toBe(0);
+    const pr = JSON.parse(out);
+    expect(pr).toMatchObject({
+      prKey: "pr-2",
+      kind: "request",
+      baseRef: "refs/heads/main"
+    });
+    expect(pr.events).toHaveLength(2);
+  });
+
+  it("journal filters by --since and --types", async () => {
+    const repo = await makeRepoFromFixture("repo-basic");
+    process.env.A5C_NOW_ISO = "2025-12-19T14:50:00Z";
+    let out = "";
+    const code = await runCli(
+      ["journal", "--repo", repo, "--since", "20m", "--types", "pr.*"],
+      { stdout: (s) => (out += s), stderr: () => {} }
+    );
+    expect(code).toBe(0);
+    // Should include pr-related events only, newest first.
+    expect(out).toContain("pr.event.created");
+  });
+});
+
+

package/test/cli.webhook.integration.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { runCli } from "../src/run.js";
+import { makeEmptyRepo, run, listenOnce } from "./_util.js";
+
+async function makeRepoWithWebhooks(): Promise<string> {
+  const dir = await makeEmptyRepo("a5cforge-cli-webhook-");
+  await fs.mkdir(path.join(dir, ".collab"), { recursive: true });
+  await fs.writeFile(
+    path.join(dir, ".collab", "webhooks.json"),
+    JSON.stringify(
+      {
+        schema: "a5cforge/v1",
+        endpoints: [{ id: "e1", url: "https://example.invalid/webhook", events: ["git.ref.updated"], enabled: true }]
+      },
+      null,
+      2
+    ) + "\n",
+    "utf8"
+  );
+  await run("git", ["add", "-A"], dir);
+  await run("git", ["-c", "user.name=test", "-c", "user.email=test@example.com", "commit", "-q", "-m", "add webhooks"], dir);
+  return dir;
+}
+
+describe("CLI webhook helpers (Phase 8)", () => {
+  it("webhook status reads from treeish (HEAD)", async () => {
+    const repo = await makeRepoWithWebhooks();
+    let out = "";
+    const code = await runCli(["webhook", "status", "--repo", repo], { stdout: (s) => (out += s), stderr: () => {} });
+    expect(code).toBe(0);
+    expect(out).toContain("schema: a5cforge/v1");
+    expect(out).toContain("endpoints: 1");
+    expect(out).toContain("- e1: https://example.invalid/webhook (git.ref.updated)");
+  });
+
+  it("webhook test posts an envelope to the given url", async () => {
+    const repo = await makeRepoWithWebhooks();
+    let got: any = null;
+    const rcv = await listenOnce((req, body) => {
+      expect(req.method).toBe("POST");
+      expect(String(req.headers["content-type"] ?? "")).toContain("application/json");
+      got = JSON.parse(body.toString("utf8"));
+    });
+
+    try {
+      let out = "";
+      const code = await runCli(["webhook", "test", "--repo", repo, "--url", `${rcv.url}/recv`, "--type", "git.ref.updated"], {
+        stdout: (s) => (out += s),
+        stderr: () => {}
+      });
+      expect(code).toBe(0);
+      expect(out).toContain("status: 200");
+      expect(got).toMatchObject({ schema: "a5cforge/v1", type: "git.ref.updated", source: { serverId: "cli" } });
+    } finally {
+      await rcv.close();
+    }
+  });
+});
+
+

package/test/cli.write.integration.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { runCli } from "../src/run.js";
+import { makeEmptyRepo, run } from "./_util.js";
+
+describe("CLI write commands (Phase 5)", () => {
+  it("issue new --stage-only creates and stages a file", async () => {
+    const repo = await makeEmptyRepo();
+    let out = "";
+    const code = await runCli(["issue", "new", "--title", "T", "--repo", repo, "--stage-only"], {
+      stdout: (s) => (out += s),
+      stderr: () => {}
+    });
+    expect(code).toBe(0);
+    expect(out.trim()).toMatch(/^issue-/);
+    const st = (await run("git", ["status", "--porcelain"], repo)).stdout;
+    expect(st).toContain("A  ");
+    expect(st).toContain(".collab/");
+  });
+
+  it("hooks install is idempotent", async () => {
+    const repo = await makeEmptyRepo();
+    let out1 = "";
+    const c1 = await runCli(["hooks", "install", "--repo", repo], { stdout: (s) => (out1 += s), stderr: () => {} });
+    expect(c1).toBe(0);
+    expect(out1.trim()).toBe("ok");
+
+    let out2 = "";
+    const c2 = await runCli(["hooks", "install", "--repo", repo], { stdout: (s) => (out2 += s), stderr: () => {} });
+    expect(c2).toBe(0);
+    expect(out2.trim()).toBe("ok");
+  });
+
+  it("hooks uninstall only removes managed hooks", async () => {
+    const repo = await makeEmptyRepo();
+    // Install managed hook first.
+    await runCli(["hooks", "install", "--repo", repo], { stdout: () => {}, stderr: () => {} });
+
+    // Create an unmanaged hook and ensure uninstall doesn't delete it.
+    const hooksDir = (await run("git", ["rev-parse", "--git-path", "hooks"], repo)).stdout.trim();
+    await fs.mkdir(hooksDir, { recursive: true });
+    const unmanaged = path.join(hooksDir, "pre-commit");
+    await fs.writeFile(unmanaged, "#!/bin/sh\necho unmanaged\n", "utf8");
+
+    let out = "";
+    const code = await runCli(["hooks", "uninstall", "--repo", repo], { stdout: (s) => (out += s), stderr: () => {} });
+    expect(code).toBe(0);
+    expect(out.trim()).toBe("ok");
+
+    const still = await fs.readFile(unmanaged, "utf8");
+    expect(still).toContain("unmanaged");
+  });
+
+  it("agent dispatch writes agent.dispatch.created event", async () => {
+    const repo = await makeEmptyRepo();
+    process.env.A5C_ACTOR = "agent1";
+    let out = "";
+    const code = await runCli(["agent", "dispatch", "--repo", repo, "--entity", "issue-1", "--stage-only"], {
+      stdout: (s) => (out += s),
+      stderr: () => {}
+    });
+    expect(code).toBe(0);
+    expect(out).toContain(".collab/agents/events/");
+    const st = (await run("git", ["status", "--porcelain"], repo)).stdout;
+    expect(st).toContain(".collab/agents/events/");
+  });
+});
+
+

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src"]
+}
+
+

package/vitest.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    coverage: {
+      reportsDirectory: "coverage",
+      reporter: ["text", "lcov", "json-summary"],
+      include: ["src/**/*.ts"],
+      exclude: ["src/bin/**", "test/**", "**/*.d.ts"],
+      thresholds: {
+        statements: 55,
+        branches: 45,
+        functions: 65,
+        lines: 55
+      }
+    }
+  }
+});
+
+