@gaia-ai/addon-deployment 0.6.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 keytec GmbH
+
+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,5 @@
+# @gaia-ai/addon-deployment
+
+GAIA deployment command plugin: `gaia deployment tickets` — the release batch computed from a git-log range.
+
+Part of the GAIA CLI. Install the meta package `@gaia-ai/gaia` to get the `gaia` CLI with all addons. Source: https://git.key-tec.de/keytec/gaia (gaia-cli/).

package/dist/src/deployment.d.ts

@@ -0,0 +1,34 @@
+import type { GaiaRemote } from '@gaia-ai/conductor/contract';
+import type { Command } from 'commander';
+export interface GatherResult {
+    range: string;
+    resolved: Array<{
+        identifier: string;
+        uuid: string;
+        title: string;
+    }>;
+    unresolved: string[];
+}
+/** Deduped GAIA-nnn from a git log, in first-seen order. */
+export declare function parseIdentifiers(gitLog: string): string[];
+/**
+ * Compute the release batch from a git-log delta: parse GAIA-nnn identifiers and
+ * resolve each to a ticket. Unresolved identifiers are reported, never fatal
+ * (the resolver returning null is not an error) — GAIA-153 AC-2.
+ */
+export declare function gatherBatch(opts: {
+    sinceRef: string;
+    toRef: string;
+    gitLog: string;
+    resolve: (id: string) => Promise<{
+        uuid: string;
+        title: string;
+    } | null>;
+}): Promise<GatherResult>;
+/**
+ * Register the `gaia deployment` command group. `tickets` computes the release's
+ * tickets (git-log identifier parse + resolve over the given range) and prints
+ * them as JSON — pure compute + report, it does not write `referenced_tickets`
+ * (the prepare-deployment skill does, via the documented dropsh path).
+ */
+export declare function registerDeployment(program: Command, resolveRemote: () => Promise<GaiaRemote>, resolveProject: () => Promise<string>, cwd: () => string): void;

package/dist/src/deployment.js

@@ -0,0 +1,63 @@
+import { exec } from '@gaia-ai/core';
+/** Deduped GAIA-nnn from a git log, in first-seen order. */
+export function parseIdentifiers(gitLog) {
+    const seen = new Set();
+    const out = [];
+    for (const m of gitLog.matchAll(/\bGAIA-\d+\b/g)) {
+        if (!seen.has(m[0])) {
+            seen.add(m[0]);
+            out.push(m[0]);
+        }
+    }
+    return out;
+}
+/**
+ * Compute the release batch from a git-log delta: parse GAIA-nnn identifiers and
+ * resolve each to a ticket. Unresolved identifiers are reported, never fatal
+ * (the resolver returning null is not an error) — GAIA-153 AC-2.
+ */
+export async function gatherBatch(opts) {
+    const resolved = [];
+    const unresolved = [];
+    for (const identifier of parseIdentifiers(opts.gitLog)) {
+        const hit = await opts.resolve(identifier);
+        if (hit) {
+            resolved.push({ identifier, ...hit });
+        }
+        else {
+            unresolved.push(identifier);
+        }
+    }
+    return { range: `${opts.sinceRef}..${opts.toRef}`, resolved, unresolved };
+}
+/**
+ * Register the `gaia deployment` command group. `tickets` computes the release's
+ * tickets (git-log identifier parse + resolve over the given range) and prints
+ * them as JSON — pure compute + report, it does not write `referenced_tickets`
+ * (the prepare-deployment skill does, via the documented dropsh path).
+ */
+export function registerDeployment(program, resolveRemote, resolveProject, cwd) {
+    const dep = program
+        .command('deployment')
+        .description('release / deployment helpers');
+    dep
+        .command('tickets')
+        .description("the release's tickets (git-log identifier parse + resolve over a range) as JSON")
+        .requiredOption('--since <ref>', "the env's currently-deployed ref (git range start)")
+        .requiredOption('--to <ref>', 'the post-merge env branch tip (git range end)')
+        .action(async (opts) => {
+        // Prefix each commit with a record separator (%x1e) so one commit's body
+        // cannot run into the next commit's header line; the identifier parse is
+        // separator-agnostic, but the boundary keeps the log unambiguous.
+        const gitLog = await exec('git', ['log', '--format=%x1e%H %s%n%b', `${opts.since}..${opts.to}`], { cwd: cwd() });
+        const remote = await resolveRemote();
+        const project = await resolveProject();
+        const result = await gatherBatch({
+            sinceRef: opts.since,
+            toRef: opts.to,
+            gitLog,
+            resolve: (id) => remote.resolveTicketByIdentifier(project, id),
+        });
+        console.log(JSON.stringify(result));
+    });
+}

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+import { type GaiaCommandPlugin } from '@gaia-ai/core';
+/** The `deployment` command plugin the host mounts (`gaia deployment …`). */
+declare const deploymentCommandPlugin: GaiaCommandPlugin;
+export default deploymentCommandPlugin;
+export { type GatherResult, gatherBatch, parseIdentifiers, registerDeployment, } from './deployment.js';

package/dist/src/index.js

@@ -0,0 +1,34 @@
+import { composeConductorConfig, loadConductorConfig, selectRemote, } from '@gaia-ai/conductor';
+import { loadGaiaConfig, resolveConfigPath, } from '@gaia-ai/core';
+import { registerDeployment } from './deployment.js';
+// GAIA-224 (Finding 7): `deployment` is its own COMMAND-surface addon, no longer
+// a side-registration of the `conductor` command plugin. The release-batch
+// gathering (`src/deployment.ts`) was already fully dependency-inverted — it
+// takes the remote, the project and the cwd as thunks — so this module only has
+// to reproduce the thunks the conductor command plugin used to pass, over the
+// same split-config resolution:
+//   engine half     `conductor.config.js` via `loadConductorConfig`
+//   connection half `gaia.config.js`      via `loadGaiaConfig`
+// composed by `composeConductorConfig`, with the remote picked by `selectRemote`.
+//
+// The `@gaia-ai/conductor` import is the package MAIN (engine + config loader),
+// not the runtime-light `./contract` subpath — that cost is paid only when a
+// `gaia deployment …` subcommand actually dispatches, because the host mounts
+// this module lazily (the `./preset` accumulator is what `gaia --help` reads).
+/** Resolve + compose the full conductor config (engine + connection halves). */
+async function resolveConfig(host) {
+    const engine = await loadConductorConfig(resolveConfigPath());
+    const connection = await loadGaiaConfig(host, {});
+    return composeConductorConfig(engine, connection);
+}
+/** The `deployment` command plugin the host mounts (`gaia deployment …`). */
+const deploymentCommandPlugin = {
+    kind: 'command',
+    name: 'deployment',
+    describe: 'release / deployment helpers',
+    register(program, host) {
+        registerDeployment(program, async () => selectRemote(await resolveConfig(host)), async () => (await resolveConfig(host)).project, () => process.cwd());
+    },
+};
+export default deploymentCommandPlugin;
+export { gatherBatch, parseIdentifiers, registerDeployment, } from './deployment.js';

package/dist/src/preset.d.ts

@@ -0,0 +1,2 @@
+import type { GaiaPreset } from '@gaia-ai/core';
+export declare const commands: GaiaPreset['commands'];

package/dist/src/preset.js

@@ -0,0 +1,8 @@
+export const commands = (acc) => [
+    ...acc,
+    {
+        name: 'deployment',
+        plugin: '@gaia-ai/addon-deployment',
+        describe: 'release / deployment helpers',
+    },
+];

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@gaia-ai/addon-deployment",
+  "version": "0.6.1",
+  "description": "GAIA deployment command plugin: `gaia deployment tickets` — the release batch computed from a git-log range.",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": "./dist/src/index.js",
+    "./preset": "./dist/src/preset.js"
+  },
+  "files": [
+    "dist/src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://git.key-tec.de/keytec/gaia.git",
+    "directory": "gaia-cli/addons/deployment"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "peerDependencies": {
+    "@gaia-ai/conductor": "^0.6.1",
+    "@gaia-ai/core": "^0.6.1"
+  }
+}