@blogic-cz/agent-tools 0.3.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/agent-tools",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "CLI tools for AI coding agent workflows — GitHub, database, Kubernetes, Azure DevOps, logs, and sessions",
   "keywords": [
     "agent",

package/src/db-tool/service.ts

@@ -79,10 +79,11 @@ export class DbService extends ServiceMap.Service<
 
           const envVars: Record<string, string> = {};
           const regex = /^export\s+([A-Z_][A-Z0-9_]*)=["']?([^"'\n]+)["']?/gm;
-          let match: RegExpExecArray | null;
+          let match = regex.exec(content);
 
-          while ((match = regex.exec(content)) !== null) {
+          while (match !== null) {
             envVars[match[1]] = match[2];
+            match = regex.exec(content);
           }
 
           yield* Ref.set(zshrcEnvCache, envVars);
@@ -214,7 +215,7 @@ export class DbService extends ServiceMap.Service<
         ) => {
           const args = [
             "-h",
-            "localhost",
+            config.host,
             "-p",
             String(config.port),
             "-U",
@@ -506,14 +507,18 @@ export class DbService extends ServiceMap.Service<
           }
 
           const isLocal = LOCALHOST_HOSTS.has(envConfig.host);
+          const isLocalEnvironment = env === "local";
+          const needsTunnel = dbConfig.kubectl !== undefined && !isLocalEnvironment && isLocal;
 
           return {
+            host: envConfig.host,
             user: envConfig.user,
             database: envConfig.database,
+            password: envConfig.password,
             passwordEnvVar: envConfig.passwordEnvVar,
             port: envConfig.port,
-            needsTunnel: !isLocal && dbConfig.kubectl !== undefined,
-            allowMutations: isLocal,
+            needsTunnel,
+            allowMutations: isLocalEnvironment,
           };
         };
 

package/src/db-tool/types.ts

@@ -4,6 +4,7 @@ export type { Environment, OutputFormat };
 export type SchemaMode = "tables" | "columns" | "full" | "relationships";
 
 export type DbConfig = {
+  host: string;
   user: string;
   database: string;
   password?: string;

package/src/gh-tool/index.ts

@@ -34,6 +34,14 @@ import {
   prReplyAndResolveCommand,
   prReviewTriageCommand,
 } from "./pr/index";
+import {
+  releaseCreateCommand,
+  releaseDeleteCommand,
+  releaseEditCommand,
+  releaseListCommand,
+  releaseStatusCommand,
+  releaseViewCommand,
+} from "./release";
 import { repoInfoCommand, repoListCommand, repoSearchCodeCommand } from "./repo";
 import { GitHubService } from "./service";
 import {
@@ -108,6 +116,18 @@ const workflowCommand = Command.make("workflow", {}).pipe(
   ]),
 );
 
+const releaseCommand = Command.make("release", {}).pipe(
+  Command.withDescription("Release operations (create, list, view, edit, delete, status)"),
+  Command.withSubcommands([
+    releaseCreateCommand,
+    releaseListCommand,
+    releaseViewCommand,
+    releaseEditCommand,
+    releaseDeleteCommand,
+    releaseStatusCommand,
+  ]),
+);
+
 const mainCommand = Command.make("gh-tool", {}).pipe(
   Command.withDescription(
     `GitHub CLI Tool for Coding Agents
@@ -130,9 +150,12 @@ WORKFLOW FOR AI AGENTS:
   12. Use 'workflow view --run N' to inspect a specific run with jobs/steps
   13. Use 'workflow logs --run N' to get logs (failed jobs by default)
   14. Use 'workflow job-logs --run N --job "build-web-app"' to get clean parsed logs for a specific job
-  15. Use 'workflow watch --run N' to watch until completion`,
+  15. Use 'workflow watch --run N' to watch until completion
+  16. Use 'release status' to inspect latest release + repository context
+  17. Use 'release create --tag vX.Y.Z --generate-notes' to publish a release
+  18. Use 'release edit/view/list/delete' to maintain existing releases`,
   ),
-  Command.withSubcommands([prCommand, issueCommand, repoCommand, workflowCommand]),
+  Command.withSubcommands([prCommand, issueCommand, repoCommand, workflowCommand, releaseCommand]),
 );
 
 const cli = Command.run(mainCommand, {

package/src/gh-tool/release.ts

@@ -0,0 +1,561 @@
+import { Command, Flag } from "effect/unstable/cli";
+import { Effect, Option } from "effect";
+
+import { formatOption, logFormatted } from "#shared";
+import { GitHubService } from "./service";
+
+type ReleaseListItem = {
+  tagName: string;
+  name: string;
+  isDraft: boolean;
+  isPrerelease: boolean;
+  createdAt: string;
+  publishedAt: string | null;
+};
+
+type ReleaseAuthor = {
+  login: string;
+};
+
+type ReleaseAsset = {
+  name: string;
+  size: number;
+  downloadCount: number;
+  contentType: string;
+  createdAt: string;
+  updatedAt: string;
+  url: string;
+};
+
+type ReleaseDetail = {
+  tagName: string;
+  name: string;
+  isDraft: boolean;
+  isPrerelease: boolean;
+  createdAt: string;
+  publishedAt: string | null;
+  url: string;
+  body: string;
+  targetCommitish: string;
+  author: ReleaseAuthor | null;
+  assets: ReleaseAsset[];
+};
+
+type ReleaseCreateResult = {
+  created: true;
+  tagName: string;
+  name: string;
+  url: string;
+  isDraft: boolean;
+  isPrerelease: boolean;
+};
+
+type ReleaseEditResult = {
+  edited: true;
+  tagName: string;
+  name: string;
+  url: string;
+  isDraft: boolean;
+  isPrerelease: boolean;
+};
+
+type ReleaseDeleteResult = {
+  deleted: boolean;
+  tagName: string;
+  tagCleaned: boolean;
+  dryRun?: true;
+  message?: string;
+};
+
+type LatestRelease = {
+  tagName: string;
+  name: string;
+  createdAt: string;
+  url: string;
+};
+
+type ReleaseStatusResult = {
+  latestRelease: LatestRelease | null;
+  repo: {
+    owner: string;
+    name: string;
+    defaultBranch: string;
+    url: string;
+  };
+};
+
+const listReleases = Effect.fn("release.listReleases")(function* (opts: {
+  limit: number;
+  repo: string | null;
+}) {
+  const gh = yield* GitHubService;
+
+  const args = [
+    "release",
+    "list",
+    "--json",
+    "tagName,name,isDraft,isPrerelease,createdAt,publishedAt",
+    "--limit",
+    String(opts.limit),
+  ];
+
+  if (opts.repo !== null) {
+    args.push("--repo", opts.repo);
+  }
+
+  return yield* gh.runGhJson<ReleaseListItem[]>(args);
+});
+
+const viewRelease = Effect.fn("release.viewRelease")(function* (opts: {
+  tag: string;
+  repo: string | null;
+}) {
+  const gh = yield* GitHubService;
+
+  const args = [
+    "release",
+    "view",
+    opts.tag,
+    "--json",
+    "tagName,name,isDraft,isPrerelease,createdAt,publishedAt,url,body,targetCommitish,author,assets",
+  ];
+
+  if (opts.repo !== null) {
+    args.push("--repo", opts.repo);
+  }
+
+  return yield* gh.runGhJson<ReleaseDetail>(args);
+});
+
+const createRelease = Effect.fn("release.createRelease")(function* (opts: {
+  tag: string;
+  title: string | null;
+  body: string | null;
+  notesFile: string | null;
+  draft: boolean;
+  prerelease: boolean;
+  generateNotes: boolean;
+  notesStartTag: string | null;
+  target: string | null;
+  verifyTag: boolean;
+  latest: boolean | null;
+  repo: string | null;
+}) {
+  const gh = yield* GitHubService;
+
+  const args = ["release", "create", opts.tag];
+
+  if (opts.title !== null) {
+    args.push("--title", opts.title);
+  }
+
+  if (opts.body !== null) {
+    args.push("--notes", opts.body);
+  }
+
+  if (opts.notesFile !== null) {
+    args.push("--notes-file", opts.notesFile);
+  }
+
+  if (opts.draft) {
+    args.push("--draft");
+  }
+
+  if (opts.prerelease) {
+    args.push("--prerelease");
+  }
+
+  if (opts.generateNotes) {
+    args.push("--generate-notes");
+  }
+
+  if (opts.notesStartTag !== null) {
+    args.push("--notes-start-tag", opts.notesStartTag);
+  }
+
+  if (opts.target !== null) {
+    args.push("--target", opts.target);
+  }
+
+  if (opts.verifyTag) {
+    args.push("--verify-tag");
+  }
+
+  if (opts.latest !== null) {
+    args.push(`--latest=${opts.latest ? "true" : "false"}`);
+  }
+
+  if (opts.repo !== null) {
+    args.push("--repo", opts.repo);
+  }
+
+  const result = yield* gh.runGh(args);
+  const lines = result.stdout
+    .trim()
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+
+  const url = lines.length > 0 ? lines[lines.length - 1] : "";
+
+  const created: ReleaseCreateResult = {
+    created: true,
+    tagName: opts.tag,
+    name: opts.title ?? opts.tag,
+    url,
+    isDraft: opts.draft,
+    isPrerelease: opts.prerelease,
+  };
+
+  return created;
+});
+
+const editRelease = Effect.fn("release.editRelease")(function* (opts: {
+  tag: string;
+  title: string | null;
+  body: string | null;
+  draft: boolean | null;
+  prerelease: boolean | null;
+  latest: boolean | null;
+  repo: string | null;
+}) {
+  const gh = yield* GitHubService;
+
+  const args = ["release", "edit", opts.tag];
+
+  if (opts.title !== null) {
+    args.push("--title", opts.title);
+  }
+
+  if (opts.body !== null) {
+    args.push("--notes", opts.body);
+  }
+
+  if (opts.draft !== null) {
+    args.push(`--draft=${opts.draft ? "true" : "false"}`);
+  }
+
+  if (opts.prerelease !== null) {
+    args.push(`--prerelease=${opts.prerelease ? "true" : "false"}`);
+  }
+
+  if (opts.latest !== null) {
+    args.push(`--latest=${opts.latest ? "true" : "false"}`);
+  }
+
+  if (opts.repo !== null) {
+    args.push("--repo", opts.repo);
+  }
+
+  yield* gh.runGh(args);
+
+  const updated = yield* viewRelease({
+    tag: opts.tag,
+    repo: opts.repo,
+  });
+
+  const edited: ReleaseEditResult = {
+    edited: true,
+    tagName: updated.tagName,
+    name: updated.name,
+    url: updated.url,
+    isDraft: updated.isDraft,
+    isPrerelease: updated.isPrerelease,
+  };
+
+  return edited;
+});
+
+const deleteRelease = Effect.fn("release.deleteRelease")(function* (opts: {
+  tag: string;
+  cleanupTag: boolean;
+  confirm: boolean;
+  repo: string | null;
+}) {
+  const gh = yield* GitHubService;
+
+  if (!opts.confirm) {
+    const scope = opts.repo !== null ? ` in ${opts.repo}` : "";
+    const cleanup = opts.cleanupTag ? " and its git tag" : "";
+
+    const dryRun: ReleaseDeleteResult = {
+      deleted: false,
+      tagName: opts.tag,
+      tagCleaned: opts.cleanupTag,
+      dryRun: true,
+      message: `Dry run: would delete release ${opts.tag}${cleanup}${scope}. Re-run with --confirm to execute.`,
+    };
+
+    return dryRun;
+  }
+
+  const args = ["release", "delete", opts.tag, "--yes"];
+
+  if (opts.cleanupTag) {
+    args.push("--cleanup-tag");
+  }
+
+  if (opts.repo !== null) {
+    args.push("--repo", opts.repo);
+  }
+
+  yield* gh.runGh(args);
+
+  const deleted: ReleaseDeleteResult = {
+    deleted: true,
+    tagName: opts.tag,
+    tagCleaned: opts.cleanupTag,
+  };
+
+  return deleted;
+});
+
+const releaseStatus = Effect.fn("release.releaseStatus")(function* (repo: string | null) {
+  const gh = yield* GitHubService;
+
+  const args = ["release", "list", "--json", "tagName,name,createdAt,url", "--limit", "1"];
+  if (repo !== null) {
+    args.push("--repo", repo);
+  }
+
+  const [repoInfo, releases] = yield* Effect.all([
+    gh.getRepoInfo(),
+    gh.runGhJson<LatestRelease[]>(args),
+  ]);
+
+  const result: ReleaseStatusResult = {
+    latestRelease: releases.length > 0 ? releases[0] : null,
+    repo: {
+      owner: repoInfo.owner,
+      name: repoInfo.name,
+      defaultBranch: repoInfo.defaultBranch,
+      url: repoInfo.url,
+    },
+  };
+
+  return result;
+});
+
+export const releaseCreateCommand = Command.make(
+  "create",
+  {
+    body: Flag.string("body").pipe(
+      Flag.withDescription("Release notes body (markdown)"),
+      Flag.optional,
+    ),
+    draft: Flag.boolean("draft").pipe(
+      Flag.withDescription("Create as draft release"),
+      Flag.withDefault(false),
+    ),
+    format: formatOption,
+    generateNotes: Flag.boolean("generate-notes").pipe(
+      Flag.withDescription("Automatically generate release notes"),
+      Flag.withDefault(false),
+    ),
+    latest: Flag.boolean("latest").pipe(
+      Flag.withDescription("Mark this release as latest (true/false). Omit to leave unchanged"),
+      Flag.optional,
+    ),
+    notesFile: Flag.string("notes-file").pipe(
+      Flag.withDescription("Path to release notes file (passed to gh --notes-file)"),
+      Flag.optional,
+    ),
+    notesStartTag: Flag.string("notes-start-tag").pipe(
+      Flag.withDescription("Tag to start generating notes from"),
+      Flag.optional,
+    ),
+    prerelease: Flag.boolean("prerelease").pipe(
+      Flag.withDescription("Mark as pre-release"),
+      Flag.withDefault(false),
+    ),
+    repo: Flag.string("repo").pipe(
+      Flag.withDescription("Target repository (owner/name). Defaults to current repo"),
+      Flag.optional,
+    ),
+    tag: Flag.string("tag").pipe(Flag.withDescription("Tag name for release (e.g., v1.2.3)")),
+    target: Flag.string("target").pipe(
+      Flag.withDescription("Target branch or commit SHA for tag"),
+      Flag.optional,
+    ),
+    title: Flag.string("title").pipe(
+      Flag.withDescription("Release title (defaults to tag)"),
+      Flag.optional,
+    ),
+    verifyTag: Flag.boolean("verify-tag").pipe(
+      Flag.withDescription("Abort if tag does not already exist in remote"),
+      Flag.withDefault(false),
+    ),
+  },
+  ({
+    body,
+    draft,
+    format,
+    generateNotes,
+    latest,
+    notesFile,
+    notesStartTag,
+    prerelease,
+    repo,
+    tag,
+    target,
+    title,
+    verifyTag,
+  }) =>
+    Effect.gen(function* () {
+      const result = yield* createRelease({
+        tag,
+        title: Option.getOrNull(title),
+        body: Option.getOrNull(body),
+        notesFile: Option.getOrNull(notesFile),
+        draft,
+        prerelease,
+        generateNotes,
+        notesStartTag: Option.getOrNull(notesStartTag),
+        target: Option.getOrNull(target),
+        verifyTag,
+        latest: Option.getOrNull(latest),
+        repo: Option.getOrNull(repo),
+      });
+
+      yield* logFormatted(result, format);
+    }),
+).pipe(
+  Command.withDescription(
+    "Create a release (supports --notes-file, --generate-notes, --target, --verify-tag, --latest)",
+  ),
+);
+
+export const releaseListCommand = Command.make(
+  "list",
+  {
+    format: formatOption,
+    limit: Flag.integer("limit").pipe(
+      Flag.withDescription("Maximum number of releases to return"),
+      Flag.withDefault(10),
+    ),
+    repo: Flag.string("repo").pipe(
+      Flag.withDescription("Target repository (owner/name). Defaults to current repo"),
+      Flag.optional,
+    ),
+  },
+  ({ format, limit, repo }) =>
+    Effect.gen(function* () {
+      const releases = yield* listReleases({
+        limit,
+        repo: Option.getOrNull(repo),
+      });
+
+      yield* logFormatted(releases, format);
+    }),
+).pipe(Command.withDescription("List releases"));
+
+export const releaseViewCommand = Command.make(
+  "view",
+  {
+    format: formatOption,
+    repo: Flag.string("repo").pipe(
+      Flag.withDescription("Target repository (owner/name). Defaults to current repo"),
+      Flag.optional,
+    ),
+    tag: Flag.string("tag").pipe(Flag.withDescription("Release tag to view (e.g., v1.2.3)")),
+  },
+  ({ format, repo, tag }) =>
+    Effect.gen(function* () {
+      const release = yield* viewRelease({
+        tag,
+        repo: Option.getOrNull(repo),
+      });
+
+      yield* logFormatted(release, format);
+    }),
+).pipe(Command.withDescription("View release details by tag"));
+
+export const releaseEditCommand = Command.make(
+  "edit",
+  {
+    body: Flag.string("body").pipe(
+      Flag.withDescription("New release notes body (markdown)"),
+      Flag.optional,
+    ),
+    draft: Flag.boolean("draft").pipe(
+      Flag.withDescription("Set draft status (true/false). Omit to keep current value"),
+      Flag.optional,
+    ),
+    format: formatOption,
+    latest: Flag.boolean("latest").pipe(
+      Flag.withDescription("Set latest status (true/false). Omit to keep current value"),
+      Flag.optional,
+    ),
+    prerelease: Flag.boolean("prerelease").pipe(
+      Flag.withDescription("Set prerelease status (true/false). Omit to keep current value"),
+      Flag.optional,
+    ),
+    repo: Flag.string("repo").pipe(
+      Flag.withDescription("Target repository (owner/name). Defaults to current repo"),
+      Flag.optional,
+    ),
+    tag: Flag.string("tag").pipe(Flag.withDescription("Release tag to edit (e.g., v1.2.3)")),
+    title: Flag.string("title").pipe(Flag.withDescription("New release title"), Flag.optional),
+  },
+  ({ body, draft, format, latest, prerelease, repo, tag, title }) =>
+    Effect.gen(function* () {
+      const edited = yield* editRelease({
+        tag,
+        title: Option.getOrNull(title),
+        body: Option.getOrNull(body),
+        draft: Option.getOrNull(draft),
+        prerelease: Option.getOrNull(prerelease),
+        latest: Option.getOrNull(latest),
+        repo: Option.getOrNull(repo),
+      });
+
+      yield* logFormatted(edited, format);
+    }),
+).pipe(Command.withDescription("Edit an existing release"));
+
+export const releaseDeleteCommand = Command.make(
+  "delete",
+  {
+    cleanupTag: Flag.boolean("cleanup-tag").pipe(
+      Flag.withDescription("Also delete the git tag from remote"),
+      Flag.withDefault(false),
+    ),
+    confirm: Flag.boolean("confirm").pipe(
+      Flag.withDescription("Actually delete release (without this flag, only shows dry-run)"),
+      Flag.withDefault(false),
+    ),
+    format: formatOption,
+    repo: Flag.string("repo").pipe(
+      Flag.withDescription("Target repository (owner/name). Defaults to current repo"),
+      Flag.optional,
+    ),
+    tag: Flag.string("tag").pipe(Flag.withDescription("Release tag to delete (e.g., v1.2.3)")),
+  },
+  ({ cleanupTag, confirm, format, repo, tag }) =>
+    Effect.gen(function* () {
+      const result = yield* deleteRelease({
+        tag,
+        cleanupTag,
+        confirm,
+        repo: Option.getOrNull(repo),
+      });
+
+      yield* logFormatted(result, format);
+    }),
+).pipe(Command.withDescription("Delete a release (dry-run by default, use --confirm to execute)"));
+
+export const releaseStatusCommand = Command.make(
+  "status",
+  {
+    format: formatOption,
+    repo: Flag.string("repo").pipe(
+      Flag.withDescription("Target repository (owner/name). Defaults to current repo"),
+      Flag.optional,
+    ),
+  },
+  ({ format, repo }) =>
+    Effect.gen(function* () {
+      const status = yield* releaseStatus(Option.getOrNull(repo));
+      yield* logFormatted(status, format);
+    }),
+).pipe(Command.withDescription("Show release readiness status (latest release + repository info)"));