@tutar/graph-engineering 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tutar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,10 @@
+# @tutar/graph-engineering
+
+为 GitHub 软件研发项目安装由项目自行拥有的 Graph Engineering Workflow Task。
+
+```bash
+npx --yes @tutar/graph-engineering@0.3.0 init pr-review
+npx --yes @tutar/graph-engineering@0.3.0 check pr-review
+```
+
+完整契约与支持边界见 [Graph Engineering](https://github.com/tutar/graph-engineering)。

package/bin/graph-engineering.mjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+import { resolve } from "node:path";
+import { checkTask, printCheck } from "../lib/check.mjs";
+import { initTask } from "../lib/init.mjs";
+import { migrate } from "../lib/migrate.mjs";
+
+function usage() {
+  return `Usage:
+  graph-engineering init <pr-review|development> [--dry-run] [--project <path>]
+  graph-engineering check <pr-review|development> [--json] [--project <path>]
+  graph-engineering migrate [--apply] [--project <path>]`;
+}
+
+function parse(argv) {
+  const [command, maybeTask, ...rest] = argv;
+  const options = { command, task: command === "migrate" ? null : maybeTask, projectRoot: process.cwd(), dryRun: false, json: false, apply: false };
+  const args = command === "migrate" ? [maybeTask, ...rest].filter(Boolean) : rest;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--project") {
+      if (!args[index + 1]) throw new Error("--project requires a path");
+      options.projectRoot = resolve(args[++index]);
+    } else if (arg === "--dry-run") options.dryRun = true;
+    else if (arg === "--json") options.json = true;
+    else if (arg === "--apply") options.apply = true;
+    else throw new Error(`unknown option: ${arg}`);
+  }
+  return options;
+}
+
+try {
+  const options = parse(process.argv.slice(2));
+  if (options.command === "init") {
+    const plan = await initTask(options.task, options);
+    if (plan.dryRun) {
+      process.stdout.write(`DRY RUN: install ${plan.task}\n${plan.files.map((file) => `+ ${file}`).join("\n")}\n`);
+    } else {
+      process.stdout.write(`Installed ${plan.task} (${plan.files.length} files).\n`);
+      const report = await checkTask(options.task, options);
+      printCheck(report, options);
+      if (report.blocking) process.exitCode = 1;
+    }
+  } else if (options.command === "check") {
+    const report = await checkTask(options.task, options);
+    printCheck(report, options);
+    if (report.blocking) process.exitCode = 1;
+  } else if (options.command === "migrate") {
+    const result = await migrate(options);
+    for (const line of result.summary) process.stdout.write(`${line}\n`);
+    if (result.requiresApply) process.stdout.write("ACTION REQUIRED: rerun with --apply in a non-interactive environment.\n");
+    else process.stdout.write(result.applied ? "Migration applied.\n" : "Migration cancelled.\n");
+  } else {
+    throw new Error(usage());
+  }
+} catch (error) {
+  process.stderr.write(`${error.message}\n`);
+  if (!String(error.message).startsWith("Usage:")) process.stderr.write(`${usage()}\n`);
+  process.exitCode = 1;
+}

package/lib/check.mjs

@@ -0,0 +1,102 @@
+import { spawnSync } from "node:child_process";
+import { join, resolve } from "node:path";
+import { TASKS } from "./constants.mjs";
+import { exists, listFiles, readJson, sha256, within } from "./files.mjs";
+import { readManifest } from "./manifest.mjs";
+import { taskTemplateRoot } from "./package-assets.mjs";
+
+function result(status, check, detail, blocking = false) { return { status, check, detail, blocking }; }
+function command(name, args = [], cwd) { return spawnSync(name, args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }); }
+
+export async function checkTask(task, { projectRoot = process.cwd() } = {}) {
+  if (!TASKS[task]) throw new Error(`unknown task: ${task}`);
+  projectRoot = resolve(projectRoot);
+  const results = [];
+  const git = command("git", ["rev-parse", "--show-toplevel"], projectRoot);
+  if (git.status !== 0) results.push(result("ACTION REQUIRED", "git-repository", "Run the command from a Git repository root.", true));
+  else if (resolve(git.stdout.trim()) !== projectRoot) results.push(result("ACTION REQUIRED", "git-repository", "Run the command from the Git repository root.", true));
+  else results.push(result("PASS", "git-repository", projectRoot));
+
+  const templateRoot = await taskTemplateRoot(task);
+  const files = await listFiles(templateRoot);
+  const present = [];
+  const changed = [];
+  for (const file of files) {
+    const target = within(projectRoot, file);
+    if (await exists(target)) {
+      present.push(file);
+      if (await sha256(target) !== await sha256(join(templateRoot, file))) changed.push(file);
+    }
+  }
+  if (present.length === 0) results.push(result("ACTION REQUIRED", "workflow-files", `${task} is not installed.`));
+  else if (present.length !== files.length) results.push(result("ACTION REQUIRED", "workflow-files", `Partial installation: ${present.length}/${files.length} files exist.`, true));
+  else if (changed.length > 0) results.push(result("UNVERIFIED", "workflow-files", `${changed.length} project-owned file(s) differ from the packaged template.`));
+  else results.push(result("PASS", "workflow-files", `${files.length} files match the packaged template.`));
+
+  try {
+    const manifest = await readManifest(projectRoot);
+    if (!manifest?.installations?.[task]) results.push(result("ACTION REQUIRED", "installation-manifest", "Installation source is not recorded."));
+    else results.push(result("PASS", "installation-manifest", `${manifest.installations[task].cliVersion} ${manifest.installations[task].sourceCommit}`));
+  } catch (error) {
+    results.push(result("ACTION REQUIRED", "installation-manifest", error.message, true));
+  }
+
+  for (const executable of ["gh", "codex"]) {
+    const probe = command(executable, ["--version"], projectRoot);
+    results.push(probe.status === 0
+      ? result("PASS", `${executable}-executable`, probe.stdout.split("\n")[0].trim())
+      : result("UNVERIFIED", `${executable}-executable`, `${executable} is not available locally; confirm it on the selected runner.`));
+  }
+
+  const gh = command("gh", ["repo", "view", "--json", "nameWithOwner"], projectRoot);
+  if (gh.status !== 0) {
+    results.push(result("UNVERIFIED", "github-repository", "GitHub repository access is unavailable from this environment."));
+  } else {
+    const nameWithOwner = JSON.parse(gh.stdout).nameWithOwner;
+    results.push(result("PASS", "github-repository", nameWithOwner));
+    if (TASKS[task].requiredLabels.length > 0) {
+      const labels = command("gh", ["label", "list", "--limit", "200", "--json", "name"], projectRoot);
+      if (labels.status !== 0) results.push(result("UNVERIFIED", "github-labels", "Unable to read repository labels."));
+      else {
+        const names = new Set(JSON.parse(labels.stdout).map(({ name }) => name));
+        const missing = TASKS[task].requiredLabels.filter((name) => !names.has(name));
+        results.push(missing.length === 0
+          ? result("PASS", "github-labels", "Required labels exist.")
+          : result("ACTION REQUIRED", "github-labels", `Create: ${missing.join(", ")}`));
+      }
+    }
+    const runners = command("gh", ["api", `repos/${nameWithOwner}/actions/runners`, "--paginate", "--slurp"], projectRoot);
+    if (runners.status !== 0) {
+      results.push(result("UNVERIFIED", "runner-labels", "Unable to inspect repository runners; confirm [self-hosted, Linux, X64, codex] in GitHub Settings."));
+    } else {
+      const expected = ["self-hosted", "Linux", "X64", "codex"];
+      const compatible = JSON.parse(runners.stdout).flatMap(({ runners }) => runners ?? []).some(({ labels }) => {
+        const names = new Set(labels.map(({ name }) => name));
+        return expected.every((label) => names.has(label));
+      });
+      results.push(compatible
+        ? result("PASS", "runner-labels", "A runner exposes [self-hosted, Linux, X64, codex].")
+        : result("ACTION REQUIRED", "runner-labels", "Register a dedicated runner with [self-hosted, Linux, X64, codex]."));
+    }
+    results.push(result("UNVERIFIED", "codex-runner-login", "Confirm that the Actions service user is logged in to Codex on the selected runner."));
+    if (task === "development") {
+      const permissions = command("gh", ["api", `repos/${nameWithOwner}/actions/permissions/workflow`], projectRoot);
+      if (permissions.status !== 0) results.push(result("UNVERIFIED", "actions-write-policy", "Unable to inspect the repository Actions workflow permission policy."));
+      else {
+        const policy = JSON.parse(permissions.stdout);
+        results.push(policy.default_workflow_permissions === "write"
+          ? result("PASS", "actions-write-policy", "Default workflow permissions allow write access; review the Workflow's explicit permissions before commit.")
+          : result("ACTION REQUIRED", "actions-write-policy", "Allow the Development workflow's required write permissions in GitHub Settings."));
+      }
+    }
+  }
+  return { task, ready: results.every(({ status }) => status === "PASS"), blocking: results.some(({ blocking }) => blocking), results };
+}
+
+export function printCheck(report, { json = false, stream = process.stdout } = {}) {
+  if (json) stream.write(`${JSON.stringify(report, null, 2)}\n`);
+  else {
+    for (const item of report.results) stream.write(`${item.status.padEnd(15)} ${item.check}: ${item.detail}\n`);
+    stream.write(`${report.ready ? "READY" : "ACTION REQUIRED"}: ${report.task}\n`);
+  }
+}

package/lib/constants.mjs

@@ -0,0 +1,17 @@
+export const PRODUCT_VERSION = "0.3.0";
+export const TASKS = Object.freeze({
+  development: {
+    workflow: "github-development-ticket.yml",
+    profile: "github-development-ticket/current",
+    requiredLabels: ["ready-for-agent", "development-ticket", "in-progress"],
+  },
+  "pr-review": {
+    workflow: "github-pr-review.yml",
+    profile: "github-pr-review/codex/current",
+    requiredLabels: [],
+  },
+});
+
+export const MANIFEST_PATH = ".github/graph-engineering/installation.json";
+export const LEGACY_NAMESPACE = "loop-engineering";
+export const CURRENT_NAMESPACE = "graph-engineering";

package/lib/files.mjs

@@ -0,0 +1,83 @@
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { access, constants, copyFile, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const packageRoot = resolve(fileURLToPath(new URL("..", import.meta.url)));
+
+export async function exists(path) {
+  try { await access(path); return true; } catch { return false; }
+}
+
+export async function listFiles(root) {
+  const output = [];
+  async function visit(directory) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+      const path = join(directory, entry.name);
+      if (entry.isSymbolicLink()) throw new Error(`symbolic links are not allowed in package assets: ${path}`);
+      if (entry.isDirectory()) await visit(path);
+      else if (entry.isFile()) output.push(relative(root, path));
+      else throw new Error(`unsupported package asset: ${path}`);
+    }
+  }
+  await visit(root);
+  return output.sort();
+}
+
+export function within(root, relativePath) {
+  const target = resolve(root, relativePath);
+  if (target !== root && !target.startsWith(`${root}${sep}`)) throw new Error(`path escapes project root: ${relativePath}`);
+  return target;
+}
+
+export async function sha256(path) {
+  const content = await readFile(path);
+  return createHash("sha256").update(content).digest("hex");
+}
+
+export async function copyFiles({ sourceRoot, projectRoot, files }) {
+  const createdFiles = [];
+  const createdDirectories = new Set();
+  try {
+    for (const relativePath of files) {
+      const target = within(projectRoot, relativePath);
+      let directory = dirname(target);
+      const missing = [];
+      while (directory.startsWith(projectRoot) && !(await exists(directory))) {
+        missing.push(directory);
+        directory = dirname(directory);
+      }
+      await mkdir(dirname(target), { recursive: true });
+      for (const item of missing) createdDirectories.add(item);
+      await copyFile(join(sourceRoot, relativePath), target, constants.COPYFILE_EXCL);
+      createdFiles.push(target);
+    }
+  } catch (error) {
+    for (const path of createdFiles.reverse()) await rm(path, { force: true });
+    for (const path of [...createdDirectories].sort((a, b) => b.length - a.length)) {
+      try { await rm(path); } catch {}
+    }
+    throw error;
+  }
+}
+
+export async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+
+export async function writeJson(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, { flag: "wx" });
+}
+
+export async function isDirectory(path) {
+  try { return (await stat(path)).isDirectory(); } catch { return false; }
+}
+
+export function assertGitRoot(projectRoot) {
+  const result = spawnSync("git", ["-C", projectRoot, "rev-parse", "--show-toplevel"], { encoding: "utf8" });
+  if (result.status !== 0 || resolve(result.stdout.trim()) !== resolve(projectRoot)) {
+    throw new Error("run the command from a Git repository root or pass --project <root>");
+  }
+}

package/lib/init.mjs

@@ -0,0 +1,29 @@
+import { resolve } from "node:path";
+import { TASKS } from "./constants.mjs";
+import { assertGitRoot, copyFiles, exists, listFiles, within } from "./files.mjs";
+import { nextManifest, readManifest, replaceManifest } from "./manifest.mjs";
+import { installationRecord, releaseMetadata, taskTemplateRoot } from "./package-assets.mjs";
+
+export async function initTask(task, { projectRoot = process.cwd(), dryRun = false } = {}) {
+  if (!TASKS[task]) throw new Error(`unknown task: ${task}`);
+  projectRoot = resolve(projectRoot);
+  assertGitRoot(projectRoot);
+  const sourceRoot = await taskTemplateRoot(task);
+  const files = await listFiles(sourceRoot);
+  const conflicts = [];
+  for (const file of files) if (await exists(within(projectRoot, file))) conflicts.push(file);
+  const existingManifest = await readManifest(projectRoot);
+  if (existingManifest?.installations?.[task]) conflicts.push(".github/graph-engineering/installation.json (task already recorded)");
+  if (conflicts.length > 0) throw new Error(`installation conflicts:\n${conflicts.map((item) => `- ${item}`).join("\n")}`);
+  const metadata = await releaseMetadata();
+  const manifest = nextManifest(existingManifest, installationRecord(task, metadata));
+  if (!dryRun) {
+    await copyFiles({ sourceRoot, projectRoot, files });
+    try { await replaceManifest(projectRoot, manifest); }
+    catch (error) {
+      for (const file of files.reverse()) await import("node:fs/promises").then(({ rm }) => rm(within(projectRoot, file), { force: true }));
+      throw error;
+    }
+  }
+  return { task, dryRun, files, manifest };
+}

package/lib/manifest.mjs

@@ -0,0 +1,31 @@
+import { dirname, join } from "node:path";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { MANIFEST_PATH, PRODUCT_VERSION } from "./constants.mjs";
+import { exists, within } from "./files.mjs";
+
+export async function readManifest(projectRoot) {
+  const path = within(projectRoot, MANIFEST_PATH);
+  if (!(await exists(path))) return null;
+  const value = JSON.parse(await readFile(path, "utf8"));
+  if (value.schemaVersion !== 1 || typeof value.installations !== "object" || Array.isArray(value.installations)) {
+    throw new Error(`${MANIFEST_PATH} is not a recognized Graph Engineering installation manifest`);
+  }
+  return value;
+}
+
+export function nextManifest(existing, record) {
+  return {
+    schemaVersion: 1,
+    product: "@tutar/graph-engineering",
+    productVersion: PRODUCT_VERSION,
+    installations: { ...(existing?.installations ?? {}), [record.task]: record },
+  };
+}
+
+export async function replaceManifest(projectRoot, value) {
+  const path = within(projectRoot, MANIFEST_PATH);
+  await mkdir(dirname(path), { recursive: true });
+  const temporary = `${path}.tmp-${process.pid}`;
+  await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { flag: "wx" });
+  try { await rename(temporary, path); } catch (error) { await rm(temporary, { force: true }); throw error; }
+}

package/lib/migrate.mjs

@@ -0,0 +1,101 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { cp, mkdir, mkdtemp, rm } from "node:fs/promises";
+import { MANIFEST_PATH, TASKS } from "./constants.mjs";
+import { assertGitRoot, copyFiles, exists, listFiles, sha256, within } from "./files.mjs";
+import { nextManifest, readManifest, replaceManifest } from "./manifest.mjs";
+import { installationRecord, legacyTemplateRoot, releaseMetadata, taskTemplateRoot } from "./package-assets.mjs";
+
+async function detect(projectRoot) {
+  const found = [];
+  for (const [task, definition] of Object.entries(TASKS)) {
+    if (await exists(within(projectRoot, `.github/workflows/${definition.workflow}`))) found.push(task);
+  }
+  return found;
+}
+
+async function validateBaseline(projectRoot, task, baselineRoot) {
+  const files = await listFiles(baselineRoot);
+  const mismatches = [];
+  for (const file of files) {
+    const target = within(projectRoot, file);
+    if (!(await exists(target)) || await sha256(target) !== await sha256(join(baselineRoot, file))) mismatches.push(file);
+  }
+  return { files, mismatches };
+}
+
+export async function migrate({ projectRoot = process.cwd(), apply = false, interactive = Boolean(process.stdin.isTTY) } = {}) {
+  projectRoot = resolve(projectRoot);
+  assertGitRoot(projectRoot);
+  const tasks = await detect(projectRoot);
+  if (tasks.length === 0) throw new Error("no supported Loop Engineering installation was detected");
+  if (await exists(within(projectRoot, MANIFEST_PATH))) throw new Error("a Graph Engineering installation manifest already exists");
+  const plans = [];
+  for (const task of tasks) {
+    const baselineRoot = await legacyTemplateRoot(task);
+    const validated = await validateBaseline(projectRoot, task, baselineRoot);
+    if (validated.mismatches.length > 0) {
+      throw new Error(`cannot safely migrate modified or unknown ${task} files:\n${validated.mismatches.map((item) => `- ${item}`).join("\n")}`);
+    }
+    const currentRoot = await taskTemplateRoot(task);
+    plans.push({ task, oldRoot: baselineRoot, oldFiles: validated.files, currentRoot, newFiles: await listFiles(currentRoot) });
+  }
+  const replacedPaths = new Set(plans.flatMap(({ oldFiles }) => oldFiles));
+  const conflicts = [];
+  for (const { newFiles } of plans) {
+    for (const file of newFiles) {
+      if (!replacedPaths.has(file) && await exists(within(projectRoot, file))) conflicts.push(file);
+    }
+  }
+  if (conflicts.length > 0) throw new Error(`migration conflicts:\n${[...new Set(conflicts)].map((item) => `- ${item}`).join("\n")}`);
+  const summary = plans.flatMap(({ task, oldFiles, newFiles }) => [
+    `${task}: remove ${oldFiles.length} recognized Loop Engineering files`,
+    ...oldFiles.map((file) => `- ${file}`),
+    `${task}: install ${newFiles.length} Graph Engineering files`,
+    ...newFiles.map((file) => `+ ${file}`),
+  ]);
+  if (!apply) {
+    if (!interactive) return { applied: false, requiresApply: true, tasks, summary };
+    const prompt = createInterface({ input, output });
+    const answer = await prompt.question(`${summary.join("\n")}\nApply migration? [y/N] `);
+    prompt.close();
+    if (!/^y(es)?$/i.test(answer.trim())) return { applied: false, requiresApply: false, tasks, summary };
+  }
+  const metadata = await releaseMetadata();
+  let manifest = await readManifest(projectRoot);
+  const backup = await mkdtemp(join(tmpdir(), "graph-engineering-migrate-"));
+  for (const plan of plans) {
+    for (const file of plan.oldFiles) {
+      const target = within(backup, file);
+      await mkdir(resolve(target, ".."), { recursive: true });
+      await cp(within(projectRoot, file), target);
+    }
+  }
+  const installed = [];
+  try {
+    for (const plan of plans) {
+      for (const file of plan.oldFiles) await rm(within(projectRoot, file), { force: true });
+      await copyFiles({ sourceRoot: plan.currentRoot, projectRoot, files: plan.newFiles });
+      installed.push(...plan.newFiles);
+      manifest = nextManifest(manifest, installationRecord(plan.task, metadata));
+    }
+    await replaceManifest(projectRoot, manifest);
+    await rm(within(projectRoot, ".github/loop-engineering"), { recursive: true, force: true });
+    await mkdir(within(projectRoot, ".github/graph-engineering"), { recursive: true });
+  } catch (error) {
+    for (const file of installed.reverse()) await rm(within(projectRoot, file), { force: true });
+    for (const plan of plans) {
+      for (const file of plan.oldFiles) {
+        const target = within(projectRoot, file);
+        await mkdir(resolve(target, ".."), { recursive: true });
+        await cp(within(backup, file), target);
+      }
+    }
+    throw error;
+  } finally {
+    await rm(backup, { recursive: true, force: true });
+  }
+  return { applied: true, requiresApply: false, tasks, summary };
+}

package/lib/package-assets.mjs

@@ -0,0 +1,39 @@
+import { execFileSync } from "node:child_process";
+import { join, resolve } from "node:path";
+import { CURRENT_NAMESPACE, PRODUCT_VERSION, TASKS } from "./constants.mjs";
+import { exists, packageRoot, readJson } from "./files.mjs";
+
+export async function taskTemplateRoot(task) {
+  const bundled = join(packageRoot, "templates", task);
+  if (await exists(bundled)) return bundled;
+  const source = resolve(packageRoot, "../..", "workflow-tasks", task, "files");
+  if (await exists(source)) return source;
+  throw new Error(`missing packaged template for ${task}`);
+}
+
+export async function legacyTemplateRoot(task) {
+  const root = join(packageRoot, "migrations", "loop-engineering-927bd961", task);
+  if (!(await exists(root))) throw new Error("migration assets are missing; run this command from a published package or npm pack output");
+  return root;
+}
+
+export async function releaseMetadata() {
+  const path = join(packageRoot, "release-metadata.json");
+  if (await exists(path)) return readJson(path);
+  let sourceCommit = "working-tree";
+  try {
+    sourceCommit = execFileSync("git", ["rev-parse", "HEAD"], { cwd: resolve(packageRoot, "../.."), encoding: "utf8" }).trim();
+  } catch {}
+  return { productVersion: PRODUCT_VERSION, sourceCommit };
+}
+
+export function installationRecord(task, metadata) {
+  return {
+    cliVersion: PRODUCT_VERSION,
+    sourceCommit: metadata.sourceCommit,
+    task,
+    definition: TASKS[task].profile.split("/codex/")[0],
+    profile: TASKS[task].profile,
+    namespace: CURRENT_NAMESPACE,
+  };
+}

package/migrations/loop-engineering-927bd961/development/.github/loop-engineering/development-worktree.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+interrupted_ref="refs/loop-engineering/interrupted/${TARGET_BRANCH}"
+interrupted_stash_ref="refs/loop-engineering/interrupted-stash/${TARGET_BRANCH}"
+
+case "${1:-}" in
+  prepare)
+    if git show-ref --verify --quiet "${interrupted_ref}"; then
+      git switch --force-create "${TARGET_BRANCH}" "${interrupted_ref}"
+      git rebase "${BASE_BRANCH}"
+    elif git ls-remote --exit-code origin "refs/heads/${TARGET_BRANCH}" >/dev/null 2>&1; then
+      git fetch origin "${TARGET_BRANCH}"
+      git switch --create "${TARGET_BRANCH}" --track "origin/${TARGET_BRANCH}"
+    else
+      git switch --create "${TARGET_BRANCH}"
+    fi
+    ;;
+  restore)
+    if git show-ref --verify --quiet "${interrupted_stash_ref}"; then
+      git stash apply --index "${interrupted_stash_ref}"
+      git update-ref -d "${interrupted_stash_ref}"
+    fi
+    if git show-ref --verify --quiet "${interrupted_ref}"; then
+      git update-ref -d "${interrupted_ref}"
+    fi
+    ;;
+  *)
+    echo "usage: development-worktree.sh prepare|restore" >&2
+    exit 2
+    ;;
+esac