@kaynooo/cli-forgejo 0.20.0 → 0.21.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/README.md +1 -1
  2. package/dist/cli.js +93 -100
  3. package/package.json +2 -2
package/README.md CHANGED
@@ -16,7 +16,7 @@ Needs [tea](https://gitea.com/gitea/tea) logged in to the Forgejo instance (`tea
16
16
  | `ft ci [ref]` | waits for the push runs covering a commit on the default branch and prints each failed test's output; `--json` prints `{status, runs, failedJobs, url}`, `--quiet` only the announcement, the failures and the result |
17
17
  | `ft watch` | waits for the runs in progress, or `--after <id>` those newer than a run; `--json` and `--quiet` as `ft ci` |
18
18
  | `ft logs <run>` | what the failed jobs of a run say went wrong, `-j <name or id>` picks a job, `--full` for whole logs, `--json` for the run, its jobs and the failed ones with their excerpts |
19
- | `ft release <level>` | waits for the runs on HEAD, pushing it first when origin lacks it, then `bun pm version`, one atomic push of branch and tag, and waits for the runs and the registry; `-p <folder>` releases one workspace package as `<folder>-v<version>`; `--json` prints `{released, tag, package, version, status, runs, failedJobs, url}` (an array with several packages) |
19
+ | `ft release <level>` | waits for the runs on HEAD, pushing it first when origin lacks it, then `bun pm version`, one atomic push of branch and tag, and waits for the runs and the registry; `-p <folder>` releases one workspace package as `<folder>-v<version>`, `-p a,b` or `--all` several in one push and one test run; `--json` prints `{released, tag, package, version, status, runs, failedJobs, url}` (an array with several packages) |
20
20
  | `ft board` | open issues: available, taken by a live session, or claimed with no live session here, each claim with its boxes left and a stale one with its latest note (`-q <regex>` on titles, `--state available\|taken\|away`, `-L`, `-m <milestone>`, `--json`) |
21
21
  | `ft digest` | one screen for a session starting cold: the issues this session holds with their boxes left, claims no live session answers to, red or running CI on the default branch, unpushed commits, dirty files and TODO comments naming a closed issue (needs `todo-scan` on the PATH; empty sections left out, `--json`) |
22
22
  | `ft take <n>...` / `ft drop <n>...` | claims or gives back issues for the calling Claude Code session, `--lane` as `lane-<s>-<n>` |
package/dist/cli.js CHANGED
@@ -1726,6 +1726,8 @@ function commandPath(scope, argv) {
1726
1726
  }
1727
1727
  return path.length === 0 ? undefined : path.join(" ");
1728
1728
  }
1729
+ // ../kit/src/folders.ts
1730
+ var SKIPPED_FOLDERS = new Set(["node_modules", "vendor", "dist", "build", "target", "coverage", "venv", "__pycache__"]);
1729
1731
  // ../kit/src/git.ts
1730
1732
  import { basename, dirname as dirname4 } from "path";
1731
1733
  import process16 from "process";
@@ -4147,12 +4149,11 @@ async function publishable() {
4147
4149
  // src/commands/release-plan.ts
4148
4150
  import { basename as basename2, join as join9, relative } from "path";
4149
4151
  import process23 from "process";
4150
- async function printPlan({ level, dir, prefix, branch, base, timeout, registry }) {
4152
+ async function planOf({ level, dir, prefix }, registry) {
4151
4153
  const file = Bun.file(join9(dir ?? ".", "package.json"));
4152
4154
  const pkg = await file.exists() ? await file.json() : undefined;
4153
4155
  const name = pkg?.name ?? basename2(dir ?? process23.cwd());
4154
4156
  const where = dir === undefined ? "" : ` in ${relative(process23.cwd(), dir) || "."}`;
4155
- const sha = base.slice(0, 7);
4156
4157
  let version;
4157
4158
  let bump;
4158
4159
  if (level === undefined) {
@@ -4169,13 +4170,20 @@ async function printPlan({ level, dir, prefix, branch, base, timeout, registry }
4169
4170
  bump = dir === undefined ? `bun pm version ${level}, which commits and tags ${prefix}${version}` : `bun pm version ${level} --no-git-tag-version${where}, then commit it with bun.lock refreshed and tag ${prefix}${version}`;
4170
4171
  console.log(`would release ${name} ${pkg.version} -> ${version}, tagged ${prefix}${version}`);
4171
4172
  }
4173
+ const registryStep = registry && pkg?.name !== undefined && pkg.private !== true ? `wait for the registry to serve ${pkg.name}@${version}` : `skip the registry for ${name}: ${registry ? "the package is private or unnamed" : "--no-registry"}`;
4174
+ return { tag: `${prefix}${version}`, bump, registryStep };
4175
+ }
4176
+ async function printPlan({ releases, branch, base, timeout, registry }) {
4177
+ const planned = [];
4178
+ for (const each of releases)
4179
+ planned.push(await planOf(each, registry));
4180
+ const sha = base.slice(0, 7);
4172
4181
  const pushed = await gitOk(["merge-base", "--is-ancestor", base, `origin/${branch}`]);
4173
- const registryStep = registry && pkg?.name !== undefined && pkg.private !== true ? `wait for the registry to serve ${pkg.name}@${version}` : `skip the registry: ${registry ? "the package is private or unnamed" : "--no-registry"}`;
4174
4182
  const steps = [
4175
4183
  pushed ? `wait for the runs on ${sha}, already on origin/${branch}` : `push ${branch} at ${sha}, which origin lacks, then wait for its runs`,
4176
- bump,
4177
- `push ${branch} and ${prefix}${version} in one atomic push, then wait for the runs it starts (${formatDuration(timeout)} at most)`,
4178
- registryStep
4184
+ ...planned.map((each) => each.bump),
4185
+ `push ${branch} and ${planned.map((each) => each.tag).join(", ")} in one atomic push, then wait for the runs it starts (${formatDuration(timeout)} at most)`,
4186
+ ...planned.map((each) => each.registryStep)
4179
4187
  ];
4180
4188
  console.log(steps.map((step, i) => ` ${i + 1}. ${step}`).join(`
4181
4189
  `));
@@ -4222,21 +4230,22 @@ async function waitForRegistry(name, version) {
4222
4230
  }
4223
4231
  return false;
4224
4232
  }
4225
- async function rollBack(preBump, tagsBefore, dir) {
4233
+ async function rollBack(preBump, dirs) {
4226
4234
  try {
4227
- for (const name of await tagsAt("HEAD")) {
4228
- if (!tagsBefore.has(name))
4229
- await git(["tag", "-d", name]);
4230
- }
4231
- await git(["reset", "--keep", preBump]);
4232
- if (dir !== undefined) {
4235
+ if (dirs.length > 0) {
4233
4236
  const root = await git(["rev-parse", "--show-toplevel"]);
4234
- const paths = [join10(dir, "package.json"), join10(root, "bun.lock")].map((path) => relative2(root, path));
4235
- const tracked = (await git(["ls-tree", "-r", "--full-tree", "--name-only", preBump, "--", ...paths])).split(`
4237
+ const paths = [...dirs.map((dir) => join10(dir, "package.json")), join10(root, "bun.lock")].map((path) => relative2(root, path));
4238
+ const tracked = (await git(["ls-tree", "-r", "--full-tree", "--name-only", "HEAD", "--", ...paths])).split(`
4236
4239
  `).filter((path) => path !== "");
4237
4240
  if (tracked.length > 0)
4238
- await git(["restore", `--source=${preBump}`, "--staged", "--worktree", "--", ...tracked.map((path) => join10(root, path))]);
4241
+ await git(["restore", "--source=HEAD", "--staged", "--worktree", "--", ...tracked.map((path) => join10(root, path))]);
4242
+ }
4243
+ for (const commit of (await git(["rev-list", `${preBump}..HEAD`])).split(`
4244
+ `).filter(Boolean)) {
4245
+ for (const name of await tagsAt(commit))
4246
+ await git(["tag", "-d", name]);
4239
4247
  }
4248
+ await git(["reset", "--keep", preBump]);
4240
4249
  } catch (error) {
4241
4250
  warn(`could not undo the bump, back to ${preBump.slice(0, 7)} by hand`, error instanceof Error ? error.message : String(error));
4242
4251
  }
@@ -4270,8 +4279,8 @@ ft release --tagged
4270
4279
  Cuts a release from the default branch: first the commit it sits on is pushed and its runs waited for, so failing tests stop it before anything is bumped or tagged. Then \`bun pm version\` commits and tags the bump, one atomic push sends the branch and its tag, and it waits for the runs the push started and for the registry to serve the version.
4271
4280
  --tagged releases a version commit already tagged at HEAD instead, for repos bumping with their own script; the runs waited for first are then those of the commit below it.
4272
4281
  --package releases one workspace package of a monorepo on its own, tagged \`<folder>-v<version>\` (\`ft release patch -p ft\` tags packages/ft as ft-v0.3.0).
4273
- --package takes several folders separated by commas, each optionally with its own level after a colon (\`-p ft:minor,db\` bumps ft by minor and db by the level given); --all takes every published package of the workspace. They are released one after the other and the run stops at the first one that fails, naming the ones not released.
4274
- A refused or interrupted push drops the bump commit and its tag, so a retry starts clean; with --tagged the commit and tag are yours and stay.
4282
+ --package takes several folders separated by commas, each optionally with its own level after a colon (\`-p ft:minor,db\` bumps ft by minor and db by the level given); --all takes every published package of the workspace. Each package gets its own bump commit and tag, and one atomic push sends the branch with every tag, so the tests run once for them all; the registry is then waited for package by package, stopping at the first one it does not serve.
4283
+ A refused or interrupted push drops the bump commits and their tags, so a retry starts clean; with --tagged the commit and tag are yours and stay.
4275
4284
  Once released, an open milestone titled like the version (\`1.2.0\`, \`v1.2.0\` or the tag) has its closed issues listed and is closed; a failure there only warns.
4276
4285
  --dry-run checks the same and prints the plan: the version bump, the tag, the pushes and the runs and registry it would wait for, changing nothing.
4277
4286
  --json prints {released, tag, package, version, status, runs, failedJobs, url} on stdout and the progress on stderr, an array of them with --package a,b or --all; it does not take --dry-run.
@@ -4279,16 +4288,13 @@ Exits 0 once released or planned, 1 when a run fails, origin refuses a push or t
4279
4288
  var options6 = {
4280
4289
  tagged: { type: "boolean", description: "push the version commit and tag already at HEAD instead of bumping" },
4281
4290
  package: { type: "string", short: "p", description: "workspace folder to release, a path or a name under packages/, several separated by commas" },
4282
- all: { type: "boolean", description: "release every published package of the workspace, one after the other" },
4291
+ all: { type: "boolean", description: "release every published package of the workspace in one push" },
4283
4292
  "no-registry": { type: "boolean", description: "do not wait for the registry to serve the new version" },
4284
4293
  "dry-run": { type: "boolean", description: "print what the release would do, changing nothing" },
4285
4294
  timeout: { type: "string", short: "t", description: "how long to wait for the runs (15m), a bare number in minutes" },
4286
4295
  json: jsonOption("what was released and how its runs ended")
4287
4296
  };
4288
4297
  async function release(args) {
4289
- return cut(args);
4290
- }
4291
- async function cut(args, sink) {
4292
4298
  const parsed = parse(args, usage6, options6);
4293
4299
  const { values, positionals } = parsed;
4294
4300
  const json = values.json === true;
@@ -4303,39 +4309,16 @@ async function cut(args, sink) {
4303
4309
  ${usage6}`);
4304
4310
  if (level !== undefined && !LEVELS.has(level) && !VERSION.test(level))
4305
4311
  fail(`${level} is no level nor x.y.z version`);
4306
- if (values.all === true || SEVERAL.test(values.package ?? "")) {
4307
- if (tagged || level === undefined)
4308
- fail("--all and several packages take a level, not --tagged");
4309
- if (values.all === true && values.package !== undefined)
4310
- fail("give --all or --package, not both");
4311
- const targets = parseTargets(values.package ?? (await publishable()).join(","), level);
4312
- const flags = [...json ? ["--json"] : [], ...values["dry-run"] === true ? ["--dry-run"] : [], ...values["no-registry"] === true ? ["--no-registry"] : [], ...values.timeout === undefined ? [] : ["--timeout", values.timeout]];
4313
- const results = [];
4314
- for (const [index, target] of targets.entries()) {
4315
- say(`== ${target.level} ${target.folder} (${index + 1}/${targets.length})`);
4316
- const stopped = () => console.error(`stopped at ${target.folder}, not released: ${targets.slice(index).map((each) => each.folder).join(", ")}`);
4317
- try {
4318
- const code = await cut([target.level, "--package", target.folder, ...flags], results);
4319
- if (code === 0)
4320
- continue;
4321
- stopped();
4322
- if (json)
4323
- printJson(results);
4324
- return code;
4325
- } catch (error) {
4326
- stopped();
4327
- if (json)
4328
- printJson(results);
4329
- throw error;
4330
- }
4331
- }
4332
- if (json)
4333
- printJson(results);
4334
- return 0;
4335
- }
4312
+ const several = values.all === true || SEVERAL.test(values.package ?? "");
4313
+ if (several && (tagged || level === undefined))
4314
+ fail("--all and several packages take a level, not --tagged");
4315
+ if (values.all === true && values.package !== undefined)
4316
+ fail("give --all or --package, not both");
4317
+ const targets = several && level !== undefined ? await Promise.all(parseTargets(values.package ?? (await publishable()).join(","), level).map(async (target) => ({ level: target.level, dir: await packageDir(target.folder) }))) : [{ level, dir: values.package === undefined ? undefined : await packageDir(values.package) }];
4318
+ if (targets.length === 0)
4319
+ fail("no package to release: --all found no published package, or --package named none");
4336
4320
  const timeout = duration(values.timeout, "timeout", 15 * 60000, "m");
4337
- const dir = values.package === undefined ? undefined : await packageDir(values.package);
4338
- const prefix = dir === undefined ? "v" : `${basename3(dir)}-v`;
4321
+ const prefixOf = (dir) => dir === undefined ? "v" : `${basename3(dir)}-v`;
4339
4322
  const branch = await defaultBranch();
4340
4323
  const current = await git(["branch", "--show-current"]);
4341
4324
  if (current !== branch)
@@ -4347,88 +4330,98 @@ ${usage6}`);
4347
4330
  fail(`origin/${branch} has commits HEAD lacks`, 2, runHint(`git pull --rebase origin ${branch}`));
4348
4331
  const base = await git(["rev-parse", tagged ? "HEAD~1" : "HEAD"]);
4349
4332
  if (values["dry-run"] === true)
4350
- return printPlan({ level, dir, prefix, branch, base, timeout, registry: values["no-registry"] !== true });
4333
+ return printPlan({ releases: targets.map(({ level, dir }) => ({ level, dir, prefix: prefixOf(dir) })), branch, base, timeout, registry: values["no-registry"] !== true });
4351
4334
  if (!await testsPass(base, branch, timeout, json))
4352
4335
  fail(`the runs on ${base.slice(0, 7)} failed, so nothing was bumped or tagged`, 1, runHint(`ft runs --sha ${base.slice(0, 7)}`, "list the runs, then ft logs <id> reads the failure"));
4353
4336
  const preBump = await git(["rev-parse", "HEAD"]);
4354
- const tagsBefore = new Set(await tagsAt("HEAD"));
4355
4337
  const before = (await recentRuns(1))[0]?.id ?? 0;
4356
4338
  const held = holdSignals();
4357
4339
  const signalOf = () => held.signal;
4358
- let tag = "";
4359
- let head = "";
4340
+ const bumped = [];
4360
4341
  let pushed = false;
4361
4342
  let isPushUnknown = false;
4362
4343
  try {
4363
- if (level !== undefined) {
4364
- const bump = dir === undefined ? await $2`bun pm version ${level}`.quiet().nothrow() : await $2`bun pm version ${level} --no-git-tag-version`.cwd(dir).quiet().nothrow();
4365
- if (bump.exitCode !== 0)
4366
- fail(`bun pm version ${level}: ${bump.stderr.toString().trim() || bump.stdout.toString().trim()}`);
4367
- if (dir !== undefined)
4368
- await commitPackageBump(dir, prefix);
4344
+ for (const { level, dir } of targets) {
4345
+ const prefix = prefixOf(dir);
4346
+ if (level !== undefined) {
4347
+ const bump = dir === undefined ? await $2`bun pm version ${level}`.quiet().nothrow() : await $2`bun pm version ${level} --no-git-tag-version`.cwd(dir).quiet().nothrow();
4348
+ if (bump.exitCode !== 0)
4349
+ fail(`bun pm version ${level}${dir === undefined ? "" : ` in ${basename3(dir)}`}: ${bump.stderr.toString().trim() || bump.stdout.toString().trim()}`);
4350
+ if (dir !== undefined)
4351
+ await commitPackageBump(dir, prefix);
4352
+ }
4353
+ const tag = (await tagsAt("HEAD")).find((name) => taggedVersion(name, prefix) !== undefined);
4354
+ if (tag === undefined)
4355
+ fail(tagged ? `HEAD carries no ${prefix}* tag` : `the bump made no ${prefix}* tag`);
4356
+ bumped.push({ dir, prefix, tag, head: await git(["rev-parse", "HEAD"]) });
4357
+ if (held.signal !== undefined)
4358
+ fail(`interrupted by ${held.signal} before the push`, exitCodeOf(null, held.signal));
4369
4359
  }
4370
- const found = (await tagsAt("HEAD")).find((name) => taggedVersion(name, prefix) !== undefined);
4371
- if (found === undefined)
4372
- fail(tagged ? `HEAD carries no ${prefix}* tag` : `the bump made no ${prefix}* tag`);
4373
- tag = found;
4374
- head = await git(["rev-parse", "HEAD"]);
4375
- if (held.signal !== undefined)
4376
- fail(`interrupted by ${held.signal} before the push`, exitCodeOf(null, held.signal));
4360
+ const tags = bumped.map((each) => each.tag);
4377
4361
  let push;
4378
4362
  try {
4379
- push = await runTool("git push", ["git", "push", "--atomic", "origin", `HEAD:refs/heads/${branch}`, `refs/tags/${tag}`], { timeoutMs: limits.pushMs, onStart: (child) => held.forward(child) });
4363
+ push = await runTool("git push", ["git", "push", "--atomic", "origin", `HEAD:refs/heads/${branch}`, ...tags.map((tag) => `refs/tags/${tag}`)], { timeoutMs: limits.pushMs, onStart: (child) => held.forward(child) });
4380
4364
  } catch (error) {
4381
4365
  isPushUnknown = true;
4382
- fail(`${error instanceof Error ? error.message : String(error)}, so ${tag} and its commit are kept: the push may have landed`, 2, `git ls-remote origin refs/tags/${tag} tells; if it is there, ft release --tagged waits for its runs`);
4366
+ fail(`${error instanceof Error ? error.message : String(error)}, so ${tags.join(", ")} and ${tags.length === 1 ? "its commit are" : "their commits are"} kept: the push may have landed`, 2, tags.length === 1 ? `git ls-remote origin refs/tags/${tags[0]} tells; if it is there, ft release --tagged waits for its runs` : `git ls-remote --tags origin tells; if they are there, ft watch --after ${before} waits for their runs`);
4383
4367
  }
4384
4368
  if (push.code !== 0) {
4385
4369
  const signal = signalOf();
4386
- fail(`origin refused the push${signal === undefined ? "" : `, or ${signal} interrupted it`}, so ${level === undefined ? `${tag} and its commit are kept for a retry` : `${tag} and its commit were dropped for a clean retry`}:
4370
+ const kept = tagged ? `${tags.join(", ")} and its commit are kept for a retry` : `${tags.join(", ")} and ${tags.length === 1 ? "its commit were" : "their commits were"} dropped for a clean retry`;
4371
+ fail(`origin refused the push${signal === undefined ? "" : `, or ${signal} interrupted it`}, so ${kept}:
4387
4372
  ${push.stderr.trim()}`, signal === undefined ? 1 : exitCodeOf(null, signal));
4388
4373
  }
4389
4374
  pushed = true;
4390
4375
  } finally {
4391
4376
  held.release();
4392
- if (!pushed && !isPushUnknown && level !== undefined)
4393
- await rollBack(preBump, tagsBefore, dir);
4377
+ if (!pushed && !isPushUnknown && !tagged)
4378
+ await rollBack(preBump, targets.flatMap((target) => target.dir === undefined ? [] : [target.dir]));
4394
4379
  }
4395
- const file = Bun.file(join11(dir ?? ".", "package.json"));
4396
- const pkg = await file.exists() ? await file.json() : undefined;
4397
- const version = tag.slice(prefix.length);
4380
+ const heads = new Set(bumped.map((each) => each.head));
4381
+ const manifests = await Promise.all(bumped.map(async (each) => {
4382
+ const file = Bun.file(join11(each.dir ?? ".", "package.json"));
4383
+ return await file.exists() ? await file.json() : undefined;
4384
+ }));
4385
+ const released = new Set;
4398
4386
  let followed = { code: 0, runs: [], failedJobs: [] };
4399
- const outcome = (released) => {
4387
+ const report = () => {
4400
4388
  if (!json)
4401
4389
  return;
4402
- const result = { released, tag, package: pkg?.name ?? null, version, ...ciJson(followed.runs, followed.failedJobs) };
4403
- if (sink === undefined)
4404
- printJson(result);
4405
- else
4406
- sink.push(result);
4390
+ const results = bumped.map((each, index) => {
4391
+ const own = followed.runs.filter((run) => run.prettyref === each.tag || run.prettyref === branch);
4392
+ return { released: released.has(each), tag: each.tag, package: manifests[index]?.name ?? null, version: each.tag.slice(each.prefix.length), ...ciJson(own, followed.failedJobs.filter((job) => own.some((run) => run.id === job.run))) };
4393
+ });
4394
+ printJson(several ? results : results[0]);
4407
4395
  };
4408
4396
  try {
4409
4397
  const late = signalOf();
4410
4398
  if (late !== undefined)
4411
- fail(`interrupted by ${late} after ${tag} was pushed: its runs are not waited for`, exitCodeOf(null, late));
4412
- say(`pushed ${branch} and ${tag}, waiting for their runs`);
4413
- followed = await followRuns((runs) => runs.filter((run) => run.id > before && run.commit_sha === head), timeout, undefined, NO_RUN2, json ? process24.stderr : process24.stdout, { json });
4399
+ fail(`interrupted by ${late} after ${bumped.map((each) => each.tag).join(", ")} ${bumped.length === 1 ? "was pushed: its runs are" : "were pushed: their runs are"} not waited for`, exitCodeOf(null, late));
4400
+ say(`pushed ${branch} and ${bumped.map((each) => each.tag).join(", ")}, waiting for their runs`);
4401
+ followed = await followRuns((runs) => runs.filter((run) => run.id > before && heads.has(run.commit_sha)), timeout, undefined, NO_RUN2, json ? process24.stderr : process24.stdout, { json });
4414
4402
  if (followed.code !== 0) {
4415
- outcome(false);
4403
+ report();
4416
4404
  return followed.code;
4417
4405
  }
4418
- if (values["no-registry"] === true || pkg?.name === undefined || pkg.private === true) {
4419
- say(`released ${tag}`);
4420
- await settleMilestone(version, tag, say);
4421
- outcome(true);
4422
- return 0;
4406
+ for (const [index, each] of bumped.entries()) {
4407
+ const pkg = manifests[index];
4408
+ const version = each.tag.slice(each.prefix.length);
4409
+ if (values["no-registry"] !== true && pkg?.name !== undefined && pkg.private !== true) {
4410
+ if (!await waitForRegistry(pkg.name, version)) {
4411
+ const rest = bumped.slice(index + 1).map((next) => next.tag);
4412
+ fail(`the runs passed but the registry does not serve ${pkg.name}@${version}${rest.length === 0 ? "" : `, so ${rest.join(", ")} ${rest.length === 1 ? "is" : "are"} pushed but not waited for`}: read the publish job with \`ft logs\``, 1);
4413
+ }
4414
+ say(`released ${pkg.name}@${version}`);
4415
+ } else {
4416
+ say(`released ${each.tag}`);
4417
+ }
4418
+ await settleMilestone(version, each.tag, say);
4419
+ released.add(each);
4423
4420
  }
4424
- if (!await waitForRegistry(pkg.name, version))
4425
- fail(`the runs passed but the registry does not serve ${pkg.name}@${version}: read the publish job with \`ft logs\``, 1);
4426
- say(`released ${pkg.name}@${version}`);
4427
- await settleMilestone(version, tag, say);
4428
- outcome(true);
4421
+ report();
4429
4422
  return 0;
4430
4423
  } catch (error) {
4431
- outcome(false);
4424
+ report();
4432
4425
  throw error;
4433
4426
  }
4434
4427
  }
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@kaynooo/cli-forgejo",
3
3
  "type": "module",
4
- "version": "0.20.0",
4
+ "version": "0.21.0",
5
5
  "description": "ft: Forgejo CI runs, logs, releases and issue checklists from the terminal, through tea.",
6
6
  "author": "Kaynooo <contact@kaynooo.fr>",
7
7
  "license": "MIT",
@@ -28,6 +28,6 @@
28
28
  "ft": "$npm_execpath src/cli.ts"
29
29
  },
30
30
  "devDependencies": {
31
- "@kaynooo/cli-kit": "0.25.0"
31
+ "@kaynooo/cli-kit": "0.27.1"
32
32
  }
33
33
  }