@a5c-ai/git-a5c 1.0.5 → 1.0.7

package/src/time.ts

@@ -1,16 +0,0 @@
-export function parseSinceToEpochMs(since: string, nowMs: number): number {
-  // Accept:
-  // - ISO timestamp
-  // - durations like 2h, 15m, 30s, 7d
-  const iso = Date.parse(since);
-  if (Number.isFinite(iso)) return iso;
-
-  const m = /^(\d+)(s|m|h|d)$/.exec(since.trim());
-  if (!m) throw new Error(`Invalid --since: ${since}`);
-  const n = Number(m[1]);
-  const unit = m[2];
-  const mult = unit === "s" ? 1000 : unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : 86_400_000;
-  return nowMs - n * mult;
-}
-
-

package/test/_util.ts

@@ -1,88 +0,0 @@
-import { spawn } from "node:child_process";
-import fs from "node:fs/promises";
-import http from "node:http";
-import os from "node:os";
-import path from "node:path";
-
-export function run(cmd: string, args: string[], cwd: string): Promise<{ stdout: string; stderr: string }> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
-    const out: Buffer[] = [];
-    const err: Buffer[] = [];
-    child.stdout.on("data", (d) => out.push(Buffer.from(d)));
-    child.stderr.on("data", (d) => err.push(Buffer.from(d)));
-    child.on("error", reject);
-    child.on("close", (code) => {
-      const stdout = Buffer.concat(out).toString("utf8");
-      const stderr = Buffer.concat(err).toString("utf8");
-      if (code === 0) return resolve({ stdout, stderr });
-      reject(new Error(`${cmd} ${args.join(" ")} failed (code=${code}): ${stderr}`));
-    });
-  });
-}
-
-export async function copyDir(src: string, dst: string) {
-  await fs.mkdir(dst, { recursive: true });
-  const entries = await fs.readdir(src, { withFileTypes: true });
-  for (const e of entries) {
-    const s = path.join(src, e.name);
-    const d = path.join(dst, e.name);
-    if (e.isDirectory()) await copyDir(s, d);
-    else if (e.isFile()) await fs.copyFile(s, d);
-  }
-}
-
-export async function makeRepoFromFixture(fixtureName: string): Promise<string> {
-  const root = path.resolve(import.meta.dirname, "../../..");
-  const fixture = path.join(root, "fixtures", fixtureName);
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), `a5cforge-cli-${fixtureName}-`));
-  await copyDir(fixture, dir);
-  await run("git", ["init", "-q", "-b", "main"], dir);
-  await run("git", ["add", "-A"], dir);
-  await run("git", ["add", "-f", ".collab"], dir);
-  await run("git", ["-c", "user.name=test", "-c", "user.email=test@example.com", "commit", "-q", "-m", "fixture"], dir);
-  return dir;
-}
-
-export async function makeEmptyRepo(tmpPrefix = "a5cforge-cli-write-"): Promise<string> {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), tmpPrefix));
-  await run("git", ["init", "-q", "-b", "main"], dir);
-  await run("git", ["-c", "user.name=test", "-c", "user.email=test@example.com", "commit", "--allow-empty", "-q", "-m", "init"], dir);
-  return dir;
-}
-
-export function listenOnce(handler: (req: http.IncomingMessage, body: Buffer) => Promise<void> | void): Promise<{ url: string; close: () => Promise<void> }> {
-  const srv = http.createServer(async (req, res) => {
-    const chunks: Buffer[] = [];
-    req.on("data", (d) => chunks.push(Buffer.from(d)));
-    req.on("end", async () => {
-      try {
-        await handler(req, Buffer.concat(chunks));
-        res.statusCode = 200;
-        res.setHeader("content-type", "text/plain");
-        res.end("ok\n");
-      } catch (e: any) {
-        res.statusCode = 500;
-        res.setHeader("content-type", "text/plain");
-        res.end(String(e?.message ?? e));
-      }
-    });
-  });
-
-  return new Promise((resolve, reject) => {
-    srv.on("error", reject);
-    srv.listen(0, "127.0.0.1", () => {
-      const addr = srv.address();
-      if (!addr || typeof addr === "string") return reject(new Error("bad listen addr"));
-      resolve({
-        url: `http://127.0.0.1:${addr.port}`,
-        close: async () =>
-          await new Promise<void>((r) => {
-            srv.close(() => r());
-          })
-      });
-    });
-  });
-}
-
-

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

@@ -1,86 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

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

package/vitest.config.ts

@@ -1,20 +0,0 @@
-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
-      }
-    }
-  }
-});
-
-