@treeseed/sdk 0.4.12 → 0.5.0

package/dist/operations/services/git-workflow.d.ts

@@ -1,24 +1,55 @@
 export declare const STAGING_BRANCH = "staging";
 export declare const PRODUCTION_BRANCH = "main";
+export declare function headCommit(repoDir: any, ref?: string): string;
 export declare function gitWorkflowRoot(cwd?: any): string;
 export declare function assertCleanWorktree(cwd?: any): string;
+export declare function assertCleanWorktrees(repoDirs: any): any;
 export declare function branchExists(repoDir: any, branchName: any): boolean;
 export declare function remoteBranchExists(repoDir: any, branchName: any): boolean;
 export declare function fetchOrigin(repoDir: any): void;
 export declare function ensureLocalBranchTracking(repoDir: any, branchName: any): void;
 export declare function checkoutBranch(repoDir: any, branchName: any): void;
+export declare function checkoutTaskBranchFromStaging(cwd: any, branchName: any, { createIfMissing, pushIfCreated }?: {
+    createIfMissing?: boolean | undefined;
+    pushIfCreated?: boolean | undefined;
+}): {
+    repoDir: string;
+    branchName: any;
+    baseBranch: string;
+    created: boolean;
+    resumed: boolean;
+    remoteBranch: boolean;
+};
 export declare function syncBranchWithOrigin(repoDir: any, branchName: any): void;
 export declare function createFeatureBranchFromStaging(cwd: any, branchName: any): {
     repoDir: string;
-    baseBranch: string;
     branchName: any;
+    baseBranch: string;
+    created: boolean;
+    resumed: boolean;
+    remoteBranch: boolean;
 };
 export declare function pushBranch(repoDir: any, branchName: any, { setUpstream }?: {
     setUpstream?: boolean | undefined;
 }): void;
 export declare function deleteLocalBranch(repoDir: any, branchName: any): void;
 export declare function deleteRemoteBranch(repoDir: any, branchName: any): boolean;
-export declare function mergeCurrentBranchIntoStaging(cwd: any, featureBranch: any): string;
+export declare function mergeCurrentBranchIntoStaging(cwd: any, featureBranch: any): {
+    repoDir: string;
+    targetBranch: string;
+    committed: boolean;
+    commitSha: string;
+    pushed: boolean;
+};
+export declare function squashMergeBranchIntoStaging(cwd: any, featureBranch: any, message: any, { pushTarget }?: {
+    pushTarget?: boolean | undefined;
+}): {
+    repoDir: string;
+    targetBranch: string;
+    committed: boolean;
+    commitSha: string;
+    pushed: boolean;
+};
 export declare function currentManagedBranch(cwd?: any): string;
 export declare function isTaskBranch(branchName: any): boolean;
 export declare function assertFeatureBranch(cwd?: any): string;
@@ -46,4 +77,17 @@ export declare function waitForStagingAutomation(repoDir: any): {
     reason?: undefined;
 };
 export declare function prepareReleaseBranches(cwd?: any): string;
-export declare function mergeStagingIntoMain(cwd?: any): string;
+export declare function mergeStagingIntoMain(cwd?: any): {
+    repoDir: string;
+    targetBranch: any;
+    commitSha: string;
+    pushed: boolean;
+};
+export declare function mergeBranchIntoTarget(cwd?: any, { sourceBranch, targetBranch, message, pushTarget }?: {
+    pushTarget?: boolean | undefined;
+}): {
+    repoDir: string;
+    targetBranch: any;
+    commitSha: string;
+    pushed: boolean;
+};

package/dist/operations/services/git-workflow.js

@@ -6,6 +6,17 @@ const RESERVED_BRANCHES = /* @__PURE__ */ new Set([STAGING_BRANCH, PRODUCTION_BR
 function runGit(args, { cwd, capture = false } = {}) {
   return run("git", args, { cwd, capture });
 }
+function repoHasStagedChanges(repoDir) {
+  try {
+    runGit(["diff", "--cached", "--quiet"], { cwd: repoDir });
+    return false;
+  } catch {
+    return true;
+  }
+}
+function headCommit(repoDir, ref = "HEAD") {
+  return runGit(["rev-parse", ref], { cwd: repoDir, capture: true }).trim();
+}
 function gitWorkflowRoot(cwd = workspaceRoot()) {
   return repoRoot(cwd);
 }
@@ -16,6 +27,12 @@ function assertCleanWorktree(cwd = workspaceRoot()) {
   }
   return root;
 }
+function assertCleanWorktrees(repoDirs) {
+  for (const repoDir of repoDirs) {
+    assertCleanWorktree(repoDir);
+  }
+  return repoDirs;
+}
 function branchExists(repoDir, branchName) {
   try {
     runGit(["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoDir });
@@ -48,6 +65,63 @@ function ensureLocalBranchTracking(repoDir, branchName) {
 function checkoutBranch(repoDir, branchName) {
   runGit(["checkout", branchName], { cwd: repoDir });
 }
+function checkoutTaskBranchFromStaging(cwd, branchName, { createIfMissing = true, pushIfCreated = false } = {}) {
+  const repoDir = assertCleanWorktree(cwd);
+  fetchOrigin(repoDir);
+  syncBranchWithOrigin(repoDir, STAGING_BRANCH);
+  if (currentBranch(repoDir) === branchName) {
+    return {
+      repoDir,
+      branchName,
+      baseBranch: STAGING_BRANCH,
+      created: false,
+      resumed: true,
+      remoteBranch: remoteBranchExists(repoDir, branchName)
+    };
+  }
+  if (branchExists(repoDir, branchName)) {
+    checkoutBranch(repoDir, branchName);
+    if (remoteBranchExists(repoDir, branchName)) {
+      runGit(["pull", "--rebase", "origin", branchName], { cwd: repoDir });
+    }
+    return {
+      repoDir,
+      branchName,
+      baseBranch: STAGING_BRANCH,
+      created: false,
+      resumed: true,
+      remoteBranch: remoteBranchExists(repoDir, branchName)
+    };
+  }
+  if (remoteBranchExists(repoDir, branchName)) {
+    runGit(["checkout", "-b", branchName, `origin/${branchName}`], { cwd: repoDir });
+    runGit(["pull", "--rebase", "origin", branchName], { cwd: repoDir });
+    return {
+      repoDir,
+      branchName,
+      baseBranch: STAGING_BRANCH,
+      created: false,
+      resumed: true,
+      remoteBranch: true
+    };
+  }
+  if (!createIfMissing) {
+    throw new Error(`Branch "${branchName}" does not exist locally or on origin.`);
+  }
+  checkoutBranch(repoDir, STAGING_BRANCH);
+  runGit(["checkout", "-b", branchName], { cwd: repoDir });
+  if (pushIfCreated) {
+    pushBranch(repoDir, branchName, { setUpstream: true });
+  }
+  return {
+    repoDir,
+    branchName,
+    baseBranch: STAGING_BRANCH,
+    created: true,
+    resumed: false,
+    remoteBranch: pushIfCreated
+  };
+}
 function syncBranchWithOrigin(repoDir, branchName) {
   fetchOrigin(repoDir);
   if (!branchExists(repoDir, branchName) && remoteBranchExists(repoDir, branchName)) {
@@ -60,18 +134,14 @@ function syncBranchWithOrigin(repoDir, branchName) {
   }
 }
 function createFeatureBranchFromStaging(cwd, branchName) {
-  const repoDir = assertCleanWorktree(cwd);
-  fetchOrigin(repoDir);
-  if (branchExists(repoDir, branchName) || remoteBranchExists(repoDir, branchName)) {
+  const result = checkoutTaskBranchFromStaging(cwd, branchName, {
+    createIfMissing: true,
+    pushIfCreated: false
+  });
+  if (!result.created) {
     throw new Error(`Branch "${branchName}" already exists locally or on origin.`);
   }
-  syncBranchWithOrigin(repoDir, STAGING_BRANCH);
-  runGit(["checkout", "-b", branchName], { cwd: repoDir });
-  return {
-    repoDir,
-    baseBranch: STAGING_BRANCH,
-    branchName
-  };
+  return result;
 }
 function pushBranch(repoDir, branchName, { setUpstream = false } = {}) {
   const args = setUpstream ? ["push", "-u", "origin", branchName] : ["push", "origin", branchName];
@@ -91,12 +161,28 @@ function deleteRemoteBranch(repoDir, branchName) {
   return true;
 }
 function mergeCurrentBranchIntoStaging(cwd, featureBranch) {
+  return squashMergeBranchIntoStaging(cwd, featureBranch, `stage: ${featureBranch}`);
+}
+function squashMergeBranchIntoStaging(cwd, featureBranch, message, { pushTarget = true } = {}) {
   const repoDir = assertCleanWorktree(cwd);
   fetchOrigin(repoDir);
   syncBranchWithOrigin(repoDir, STAGING_BRANCH);
-  runGit(["merge", "--no-ff", featureBranch, "-m", `merge: ${featureBranch} -> ${STAGING_BRANCH}`], { cwd: repoDir });
-  pushBranch(repoDir, STAGING_BRANCH);
-  return repoDir;
+  runGit(["merge", "--squash", featureBranch], { cwd: repoDir });
+  let committed = false;
+  if (repoHasStagedChanges(repoDir)) {
+    runGit(["commit", "-m", message], { cwd: repoDir });
+    committed = true;
+  }
+  if (pushTarget) {
+    pushBranch(repoDir, STAGING_BRANCH);
+  }
+  return {
+    repoDir,
+    targetBranch: STAGING_BRANCH,
+    committed,
+    commitSha: headCommit(repoDir),
+    pushed: pushTarget
+  };
 }
 function currentManagedBranch(cwd = workspaceRoot()) {
   return currentBranch(gitWorkflowRoot(cwd));
@@ -180,23 +266,40 @@ function prepareReleaseBranches(cwd = workspaceRoot()) {
   return repoDir;
 }
 function mergeStagingIntoMain(cwd = workspaceRoot()) {
+  return mergeBranchIntoTarget(cwd, {
+    sourceBranch: STAGING_BRANCH,
+    targetBranch: PRODUCTION_BRANCH,
+    message: `release: ${STAGING_BRANCH} -> ${PRODUCTION_BRANCH}`,
+    pushTarget: true
+  });
+}
+function mergeBranchIntoTarget(cwd = workspaceRoot(), { sourceBranch, targetBranch, message, pushTarget = true } = {}) {
   const repoDir = prepareReleaseBranches(cwd);
-  checkoutBranch(repoDir, PRODUCTION_BRANCH);
-  if (remoteBranchExists(repoDir, PRODUCTION_BRANCH)) {
-    runGit(["pull", "--rebase", "origin", PRODUCTION_BRANCH], { cwd: repoDir });
+  checkoutBranch(repoDir, targetBranch);
+  if (remoteBranchExists(repoDir, targetBranch)) {
+    runGit(["pull", "--rebase", "origin", targetBranch], { cwd: repoDir });
   }
-  runGit(["merge", "--no-ff", STAGING_BRANCH, "-m", `release: ${STAGING_BRANCH} -> ${PRODUCTION_BRANCH}`], { cwd: repoDir });
+  runGit(["merge", "--no-ff", sourceBranch, "-m", message], { cwd: repoDir });
   pushBranch(repoDir, STAGING_BRANCH);
-  pushBranch(repoDir, PRODUCTION_BRANCH);
-  return repoDir;
+  if (pushTarget) {
+    pushBranch(repoDir, targetBranch);
+  }
+  return {
+    repoDir,
+    targetBranch,
+    commitSha: headCommit(repoDir),
+    pushed: pushTarget
+  };
 }
 export {
   PRODUCTION_BRANCH,
   STAGING_BRANCH,
   assertCleanWorktree,
+  assertCleanWorktrees,
   assertFeatureBranch,
   branchExists,
   checkoutBranch,
+  checkoutTaskBranchFromStaging,
   createDeprecatedTaskTag,
   createFeatureBranchFromStaging,
   currentManagedBranch,
@@ -205,13 +308,16 @@ export {
   ensureLocalBranchTracking,
   fetchOrigin,
   gitWorkflowRoot,
+  headCommit,
   isTaskBranch,
   listTaskBranches,
+  mergeBranchIntoTarget,
   mergeCurrentBranchIntoStaging,
   mergeStagingIntoMain,
   prepareReleaseBranches,
   pushBranch,
   remoteBranchExists,
+  squashMergeBranchIntoStaging,
   syncBranchWithOrigin,
   taskTagSlug,
   waitForStagingAutomation

package/dist/operations/services/github-automation.d.ts

@@ -1,7 +1,67 @@
+export interface GitHubRepositoryProvisionInput {
+    owner: string;
+    name: string;
+    description?: string | null;
+    visibility?: 'private' | 'public' | 'internal';
+    homepageUrl?: string | null;
+    topics?: string[];
+}
+export interface GitHubProvisionedRepository {
+    slug: string;
+    owner: string;
+    name: string;
+    url: string;
+    sshUrl: string;
+    httpsUrl: string;
+    visibility: 'private' | 'public' | 'internal';
+    defaultBranch: string;
+}
 export declare function getGitHubAutomationMode(): "stub" | "real";
 export declare function parseGitHubRepositoryFromRemote(remoteUrl: any): string | null;
 export declare function resolveGitHubRepositorySlug(tenantRoot: any): string;
 export declare function maybeResolveGitHubRepositorySlug(tenantRoot: any): string | null;
+export declare function resolveDefaultGitHubOwner(): string;
+export declare function createGitHubRepository(input: any): {
+    visibility: any;
+    defaultBranch: string;
+    mode: string;
+    slug: string;
+    owner: string;
+    name: string;
+    sshUrl: string;
+    httpsUrl: string;
+    url: string;
+} | {
+    owner: string;
+    name: string;
+    url: string;
+    visibility: string;
+    defaultBranch: string;
+    slug: string;
+    sshUrl: string;
+    httpsUrl: string;
+};
+export declare function initializeGitHubRepositoryWorkingTree(cwd: any, repository: any, { defaultBranch, createStaging, commitMessage, remoteName, push, }?: {
+    defaultBranch?: string | undefined;
+    createStaging?: boolean | undefined;
+    commitMessage?: string | undefined;
+    remoteName?: string | undefined;
+    push?: boolean | undefined;
+}): {
+    repository: any;
+    remoteName: string;
+    defaultBranch: string;
+    stagingBranch: string | null;
+    pushed: boolean;
+    mode: string;
+} | {
+    repository: any;
+    remoteName: string;
+    defaultBranch: string;
+    stagingBranch: string | null;
+    pushed: boolean;
+    mode?: undefined;
+};
 export declare function resolveGitRepositoryRoot(tenantRoot: any): any;
 export declare function requiredGitHubEnvironment(tenantRoot: any, { scope, purpose }?: {
     scope?: string | undefined;
@@ -190,3 +250,28 @@ export declare function ensureGitHubDeployAutomation(tenantRoot: any, { dryRun }
         mode?: undefined;
     };
 };
+export declare function waitForGitHubWorkflowCompletion(tenantRoot: any, { repository, workflow, headSha, branch, timeoutSeconds, pollSeconds, }?: {
+    workflow?: string | undefined;
+    timeoutSeconds?: number | undefined;
+    pollSeconds?: number | undefined;
+}): {
+    status: string;
+    reason: string;
+    repository: any;
+    workflow: string;
+    headSha: any;
+    branch: any;
+    runId?: undefined;
+    conclusion?: undefined;
+    url?: undefined;
+} | {
+    status: string;
+    repository: any;
+    workflow: string;
+    runId: any;
+    headSha: any;
+    conclusion: any;
+    url: any;
+    reason?: undefined;
+    branch?: undefined;
+};

package/dist/operations/services/github-automation.js

@@ -7,6 +7,9 @@ function envOrNull(key) {
   const value = process.env[key];
   return typeof value === "string" && value.length > 0 ? value : null;
 }
+function slugifySegment(value, fallback = "project") {
+  return String(value ?? "").trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 96) || fallback;
+}
 function getGitHubAutomationMode() {
   return process.env.TREESEED_GITHUB_AUTOMATION_MODE === "stub" ? "stub" : "real";
 }
@@ -53,6 +56,36 @@ function runGh(args, { cwd, allowFailure = false, capture = true, input } = {})
   }
   return result;
 }
+function sleepSeconds(seconds) {
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    return;
+  }
+  spawnSync("sleep", [String(seconds)], {
+    stdio: "ignore"
+  });
+}
+function resolveGitHubRemoteUrls(owner, name) {
+  const normalizedOwner = slugifySegment(owner, "owner");
+  const normalizedName = slugifySegment(name, "repo");
+  return {
+    slug: `${normalizedOwner}/${normalizedName}`,
+    owner: normalizedOwner,
+    name: normalizedName,
+    sshUrl: `git@github.com:${normalizedOwner}/${normalizedName}.git`,
+    httpsUrl: `https://github.com/${normalizedOwner}/${normalizedName}.git`,
+    url: `https://github.com/${normalizedOwner}/${normalizedName}`
+  };
+}
+function ensureGitIdentity(cwd) {
+  const currentName = runGit(["config", "--get", "user.name"], { cwd, allowFailure: true }).stdout?.trim() ?? "";
+  const currentEmail = runGit(["config", "--get", "user.email"], { cwd, allowFailure: true }).stdout?.trim() ?? "";
+  if (!currentName) {
+    runGit(["config", "user.name", envOrNull("TREESEED_GITHUB_COMMITTER_NAME") ?? "Treeseed Launch"], { cwd });
+  }
+  if (!currentEmail) {
+    runGit(["config", "user.email", envOrNull("TREESEED_GITHUB_COMMITTER_EMAIL") ?? "launch@knowledge.coop"], { cwd });
+  }
+}
 function resolveGitHubRepositorySlug(tenantRoot) {
   const remoteResult = runGit(["remote", "get-url", "origin"], { cwd: tenantRoot });
   const remoteUrl = remoteResult.stdout?.trim() ?? "";
@@ -69,6 +102,116 @@ function maybeResolveGitHubRepositorySlug(tenantRoot) {
     return null;
   }
 }
+function resolveDefaultGitHubOwner() {
+  const explicit = envOrNull("TREESEED_KNOWLEDGE_COOP_GITHUB_OWNER");
+  if (explicit) {
+    return explicit;
+  }
+  try {
+    const repository = maybeResolveGitHubRepositorySlug(process.cwd());
+    if (repository?.includes("/")) {
+      return repository.split("/")[0];
+    }
+  } catch {
+  }
+  return "treeseed-ai";
+}
+function createGitHubRepository(input) {
+  const visibility = input.visibility ?? "private";
+  const remotes = resolveGitHubRemoteUrls(input.owner, input.name);
+  if (isGitHubAutomationStubbed()) {
+    return {
+      ...remotes,
+      visibility,
+      defaultBranch: "main",
+      mode: "stub"
+    };
+  }
+  const existing = runGh(["repo", "view", remotes.slug, "--json", "name,owner,url,isPrivate,defaultBranchRef,visibility"], {
+    allowFailure: true
+  });
+  if (existing.status !== 0) {
+    const args = ["repo", "create", remotes.slug, "--disable-wiki", "--confirm"];
+    if (visibility === "public") {
+      args.push("--public");
+    } else if (visibility === "internal") {
+      args.push("--internal");
+    } else {
+      args.push("--private");
+    }
+    if (input.description) {
+      args.push("--description", input.description);
+    }
+    if (input.homepageUrl) {
+      args.push("--homepage", input.homepageUrl);
+    }
+    runGh(args, { capture: false });
+  }
+  if (Array.isArray(input.topics) && input.topics.length > 0) {
+    runGh(
+      ["repo", "edit", remotes.slug, ...input.topics.flatMap((topic) => ["--add-topic", slugifySegment(topic, "treeseed")])],
+      { capture: false }
+    );
+  }
+  const viewed = runGh(["repo", "view", remotes.slug, "--json", "name,owner,url,isPrivate,defaultBranchRef,visibility"], {});
+  const payload = JSON.parse(viewed.stdout || "{}");
+  return {
+    ...remotes,
+    owner: String(payload.owner?.login ?? remotes.owner),
+    name: String(payload.name ?? remotes.name),
+    url: String(payload.url ?? remotes.url),
+    visibility: String(payload.visibility ?? (payload.isPrivate === true ? "private" : visibility)),
+    defaultBranch: String(payload.defaultBranchRef?.name ?? "main")
+  };
+}
+function initializeGitHubRepositoryWorkingTree(cwd, repository, {
+  defaultBranch = "main",
+  createStaging = true,
+  commitMessage = "Initialize Knowledge Coop hub",
+  remoteName = "origin",
+  push = true
+} = {}) {
+  if (isGitHubAutomationStubbed()) {
+    return {
+      repository,
+      remoteName,
+      defaultBranch,
+      stagingBranch: createStaging ? "staging" : null,
+      pushed: false,
+      mode: "stub"
+    };
+  }
+  runGit(["init", "-b", defaultBranch], { cwd, allowFailure: true });
+  ensureGitIdentity(cwd);
+  const currentRemote = runGit(["remote", "get-url", remoteName], { cwd, allowFailure: true }).stdout?.trim() ?? "";
+  if (!currentRemote) {
+    runGit(["remote", "add", remoteName, repository.sshUrl], { cwd });
+  } else if (currentRemote !== repository.sshUrl && currentRemote !== repository.httpsUrl) {
+    runGit(["remote", "set-url", remoteName, repository.sshUrl], { cwd });
+  }
+  runGit(["add", "-A"], { cwd });
+  const hasChanges = runGit(["status", "--porcelain"], { cwd }).stdout?.trim().length > 0;
+  if (hasChanges) {
+    runGit(["commit", "-m", commitMessage], { cwd });
+  }
+  if (push) {
+    runGit(["push", "-u", remoteName, defaultBranch], { cwd, capture: false });
+  }
+  if (createStaging) {
+    runGit(["checkout", "-B", "staging"], { cwd });
+    if (push) {
+      runGit(["push", "-u", remoteName, "staging"], { cwd, capture: false });
+    }
+    runGit(["checkout", defaultBranch], { cwd });
+  }
+  return {
+    repository,
+    remoteName,
+    defaultBranch,
+    stagingBranch: createStaging ? "staging" : null,
+    pushed: push
+  };
+}
 function resolveGitRepositoryRoot(tenantRoot) {
   const result = runGit(["rev-parse", "--show-toplevel"], { cwd: tenantRoot, allowFailure: true });
   return result.status === 0 ? result.stdout.trim() : tenantRoot;
@@ -291,7 +434,80 @@ function ensureGitHubDeployAutomation(tenantRoot, { dryRun = false } = {}) {
     environment
   };
 }
+function waitForGitHubWorkflowCompletion(tenantRoot, {
+  repository,
+  workflow = "publish.yml",
+  headSha,
+  branch,
+  timeoutSeconds = 600,
+  pollSeconds = 5
+} = {}) {
+  if (isGitHubAutomationStubbed()) {
+    return {
+      status: "skipped",
+      reason: "stubbed",
+      repository: repository ?? maybeResolveGitHubRepositorySlug(tenantRoot),
+      workflow,
+      headSha: headSha ?? null,
+      branch: branch ?? null
+    };
+  }
+  const repo = repository ?? resolveGitHubRepositorySlug(tenantRoot);
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutSeconds * 1e3) {
+    const result = runGh([
+      "run",
+      "list",
+      "--repo",
+      repo,
+      "--workflow",
+      workflow,
+      "--limit",
+      "20",
+      "--json",
+      "databaseId,headSha,headBranch,status,conclusion,event,displayTitle,url"
+    ], { cwd: tenantRoot });
+    const runs = JSON.parse(result.stdout || "[]");
+    const match = runs.find((run) => {
+      if (headSha && run?.headSha !== headSha) {
+        return false;
+      }
+      if (branch && run?.headBranch !== branch) {
+        return false;
+      }
+      return true;
+    });
+    if (match?.databaseId) {
+      runGh(["run", "watch", String(match.databaseId), "--repo", repo, "--exit-status"], {
+        cwd: tenantRoot,
+        capture: false
+      });
+      const finalResult = runGh([
+        "run",
+        "view",
+        String(match.databaseId),
+        "--repo",
+        repo,
+        "--json",
+        "status,conclusion,url,workflowName,headSha"
+      ], { cwd: tenantRoot });
+      const finalRun = JSON.parse(finalResult.stdout || "{}");
+      return {
+        status: "completed",
+        repository: repo,
+        workflow,
+        runId: match.databaseId,
+        headSha: finalRun.headSha ?? match.headSha ?? null,
+        conclusion: finalRun.conclusion ?? match.conclusion ?? null,
+        url: finalRun.url ?? match.url ?? null
+      };
+    }
+    sleepSeconds(pollSeconds);
+  }
+  throw new Error(`Timed out waiting for GitHub workflow ${workflow} in ${repo}.`);
+}
 export {
+  createGitHubRepository,
   ensureDeployWorkflow,
   ensureGitHubDeployAutomation,
   ensureGitHubEnvironment,
@@ -300,6 +516,7 @@ export {
   ensureStandardizedGitHubWorkflows,
   formatMissingSecretsReport,
   getGitHubAutomationMode,
+  initializeGitHubRepositoryWorkingTree,
   listGitHubSecretNames,
   listGitHubVariableNames,
   maybeResolveGitHubRepositorySlug,
@@ -308,6 +525,8 @@ export {
   renderHostedProjectWorkflow,
   requiredGitHubEnvironment,
   requiredGitHubSecrets,
+  resolveDefaultGitHubOwner,
   resolveGitHubRepositorySlug,
-  resolveGitRepositoryRoot
+  resolveGitRepositoryRoot,
+  waitForGitHubWorkflowCompletion
 };