@walker-di/fortalece-ai-sdk 0.2.0 → 0.3.1

package/dist/ci/__tests__/hmac.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hmac.test.d.ts.map

package/dist/ci/__tests__/hmac.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.test.d.ts","sourceRoot":"","sources":["../../../src/ci/__tests__/hmac.test.ts"],"names":[],"mappings":""}

package/dist/ci/__tests__/hmac.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { createHmac } from 'crypto';
+import { signWebhookBody, verifySignature } from '../hmac.js';
+/**
+ * 📌 HMAC Signing Tests
+ * Tests for GitHub-compatible webhook signature generation and verification
+ */
+describe('signWebhookBody', () => {
+    const secret = 'test-webhook-secret';
+    it('should generate sha256 prefixed signature for string body', () => {
+        const body = '{"event":"test"}';
+        const signature = signWebhookBody(secret, body);
+        expect(signature).toMatch(/^sha256=[a-f0-9]{64}$/);
+    });
+    it('should generate sha256 prefixed signature for object body', () => {
+        const body = { event: 'test', status: 'success' };
+        const signature = signWebhookBody(secret, body);
+        expect(signature).toMatch(/^sha256=[a-f0-9]{64}$/);
+    });
+    it('should generate same signature for string and equivalent JSON.stringify', () => {
+        const obj = { event: 'test' };
+        const str = JSON.stringify(obj);
+        const sigFromObj = signWebhookBody(secret, obj);
+        const sigFromStr = signWebhookBody(secret, str);
+        expect(sigFromObj).toBe(sigFromStr);
+    });
+    it('should generate correct GitHub-compatible signature', () => {
+        const body = '{"test":"data"}';
+        // Manually compute expected signature
+        const expected = 'sha256=' + createHmac('sha256', secret)
+            .update(body, 'utf8')
+            .digest('hex');
+        const actual = signWebhookBody(secret, body);
+        expect(actual).toBe(expected);
+    });
+    it('should generate different signatures for different secrets', () => {
+        const body = '{"test":"data"}';
+        const sig1 = signWebhookBody('secret1', body);
+        const sig2 = signWebhookBody('secret2', body);
+        expect(sig1).not.toBe(sig2);
+    });
+    it('should generate different signatures for different bodies', () => {
+        const sig1 = signWebhookBody(secret, '{"a":1}');
+        const sig2 = signWebhookBody(secret, '{"a":2}');
+        expect(sig1).not.toBe(sig2);
+    });
+});
+describe('verifySignature', () => {
+    const secret = 'verification-test-secret';
+    const body = '{"event":"build_success","status":"success"}';
+    it('should verify valid signature', () => {
+        const signature = signWebhookBody(secret, body);
+        const isValid = verifySignature(secret, body, signature);
+        expect(isValid).toBe(true);
+    });
+    it('should reject invalid signature', () => {
+        const isValid = verifySignature(secret, body, 'sha256=invalid');
+        expect(isValid).toBe(false);
+    });
+    it('should reject signature with wrong secret', () => {
+        const signatureWithWrongSecret = signWebhookBody('wrong-secret', body);
+        const isValid = verifySignature(secret, body, signatureWithWrongSecret);
+        expect(isValid).toBe(false);
+    });
+    it('should reject signature for modified body', () => {
+        const signature = signWebhookBody(secret, body);
+        const modifiedBody = '{"event":"build_success","status":"failed"}';
+        const isValid = verifySignature(secret, modifiedBody, signature);
+        expect(isValid).toBe(false);
+    });
+    it('should work with object bodies', () => {
+        const objBody = { event: 'test', data: { nested: true } };
+        const signature = signWebhookBody(secret, objBody);
+        const isValid = verifySignature(secret, objBody, signature);
+        expect(isValid).toBe(true);
+    });
+    it('should reject signature with different length', () => {
+        const isValid = verifySignature(secret, body, 'sha256=abc');
+        expect(isValid).toBe(false);
+    });
+});

package/dist/ci/cli.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * Fortalece AI CI CLI
+ * Command-line interface for sending CI notifications from GitHub Actions
+ *
+ * Usage:
+ *   npx @walker-di/fortalece-ai-sdk notify-ci --status building
+ *   npx @walker-di/fortalece-ai-sdk notify-ci --status success --preview-url https://preview.example.com
+ *   npx @walker-di/fortalece-ai-sdk notify-ci --status failed --error-message "Build failed"
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/ci/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/ci/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;GAQG"}

package/dist/ci/cli.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+/**
+ * Fortalece AI CI CLI
+ * Command-line interface for sending CI notifications from GitHub Actions
+ *
+ * Usage:
+ *   npx @walker-di/fortalece-ai-sdk notify-ci --status building
+ *   npx @walker-di/fortalece-ai-sdk notify-ci --status success --preview-url https://preview.example.com
+ *   npx @walker-di/fortalece-ai-sdk notify-ci --status failed --error-message "Build failed"
+ */
+import { notifyCi } from './notify.js';
+function parseArgs(args) {
+    const result = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const nextArg = args[i + 1];
+        switch (arg) {
+            case '--status':
+            case '-s':
+                result.status = nextArg;
+                i++;
+                break;
+            case '--webhook-url':
+            case '-u':
+                result.webhookUrl = nextArg;
+                i++;
+                break;
+            case '--webhook-secret':
+            case '-k':
+                result.webhookSecret = nextArg;
+                i++;
+                break;
+            case '--preview-url':
+            case '-p':
+                result.previewUrl = nextArg;
+                i++;
+                break;
+            case '--logs-url':
+            case '-l':
+                result.logsUrl = nextArg;
+                i++;
+                break;
+            case '--error-message':
+            case '-e':
+                result.errorMessage = nextArg;
+                i++;
+                break;
+            case '--work-item-id':
+            case '-w':
+                result.workItemId = nextArg;
+                i++;
+                break;
+            case '--service-name':
+                result.serviceName = nextArg;
+                i++;
+                break;
+            case '--help':
+            case '-h':
+                result.help = true;
+                break;
+        }
+    }
+    return result;
+}
+function printHelp() {
+    console.log(`
+Fortalece AI CI Notification CLI
+
+Usage:
+  npx @walker-di/fortalece-ai-sdk notify-ci [options]
+
+Options:
+  -s, --status <status>        Build status: building, success, or failed (required)
+  -u, --webhook-url <url>      Webhook URL (or set FORTALECE_WEBHOOK_URL env var)
+  -k, --webhook-secret <key>   Webhook secret (or set FORTALECE_WEBHOOK_SECRET env var)
+  -p, --preview-url <url>      Preview/deployment URL (optional)
+  -l, --logs-url <url>         Logs URL (optional)
+  -e, --error-message <msg>    Error message for failures (optional)
+  -w, --work-item-id <id>      Link to a specific work item (optional)
+      --service-name <name>    Service name (optional)
+  -h, --help                   Show this help message
+
+Environment Variables:
+  FORTALECE_WEBHOOK_URL        Webhook URL (alternative to --webhook-url)
+  FORTALECE_WEBHOOK_SECRET     Webhook secret (alternative to --webhook-secret)
+
+Examples:
+  # Notify build started
+  npx @walker-di/fortalece-ai-sdk notify-ci --status building
+
+  # Notify build success with preview URL
+  npx @walker-di/fortalece-ai-sdk notify-ci --status success --preview-url https://preview.example.com
+
+  # Notify build failure with error message
+  npx @walker-di/fortalece-ai-sdk notify-ci --status failed --error-message "Tests failed"
+
+  # Using environment variables (recommended for secrets)
+  FORTALECE_WEBHOOK_URL="\${{ secrets.FORTALECE_WEBHOOK_URL }}" \\
+  FORTALECE_WEBHOOK_SECRET="\${{ secrets.FORTALECE_WEBHOOK_SECRET }}" \\
+  npx @walker-di/fortalece-ai-sdk notify-ci --status success
+`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    // Check if first argument is 'notify-ci' (when called via npx)
+    if (args[0] === 'notify-ci') {
+        args.shift();
+    }
+    const parsed = parseArgs(args);
+    if (parsed.help) {
+        printHelp();
+        process.exit(0);
+    }
+    // Get webhook URL and secret from args or environment
+    const webhookUrl = parsed.webhookUrl || process.env.FORTALECE_WEBHOOK_URL;
+    const webhookSecret = parsed.webhookSecret || process.env.FORTALECE_WEBHOOK_SECRET;
+    if (!webhookUrl) {
+        console.error('Error: Missing webhook URL. Use --webhook-url or set FORTALECE_WEBHOOK_URL');
+        process.exit(1);
+    }
+    if (!webhookSecret) {
+        console.error('Error: Missing webhook secret. Use --webhook-secret or set FORTALECE_WEBHOOK_SECRET');
+        process.exit(1);
+    }
+    if (!parsed.status) {
+        console.error('Error: Missing --status. Must be: building, success, or failed');
+        process.exit(1);
+    }
+    if (!['building', 'success', 'failed'].includes(parsed.status)) {
+        console.error('Error: Invalid status. Must be: building, success, or failed');
+        process.exit(1);
+    }
+    console.log(`📤 Sending CI notification: ${parsed.status}...`);
+    const result = await notifyCi({
+        webhookUrl,
+        webhookSecret,
+        status: parsed.status,
+        previewUrl: parsed.previewUrl,
+        logsUrl: parsed.logsUrl,
+        errorMessage: parsed.errorMessage,
+        workItemId: parsed.workItemId,
+        serviceName: parsed.serviceName,
+    });
+    if (result.success) {
+        console.log('✅ CI notification sent successfully');
+        process.exit(0);
+    }
+    else {
+        console.error(`❌ Failed to send CI notification: ${result.error}`);
+        process.exit(1);
+    }
+}
+// Run CLI
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/ci/hmac.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Fortalece AI CI - HMAC Signing
+ * GitHub-compatible HMAC-SHA256 signature generation
+ */
+/**
+ * Sign a webhook body using HMAC-SHA256
+ * Compatible with GitHub's x-hub-signature-256 format
+ *
+ * @param secret - The webhook secret
+ * @param body - The request body (string or object)
+ * @returns The signature in format "sha256=<hex>"
+ */
+export declare function signWebhookBody(secret: string, body: string | object): string;
+/**
+ * Verify a webhook signature
+ *
+ * @param secret - The webhook secret
+ * @param body - The request body (string or object)
+ * @param signature - The signature to verify (format: "sha256=<hex>")
+ * @returns True if the signature is valid
+ */
+export declare function verifySignature(secret: string, body: string | object, signature: string): boolean;
+//# sourceMappingURL=hmac.d.ts.map

package/dist/ci/hmac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.d.ts","sourceRoot":"","sources":["../../src/ci/hmac.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAQ7E;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAcjG"}

package/dist/ci/hmac.js

@@ -0,0 +1,40 @@
+/**
+ * Fortalece AI CI - HMAC Signing
+ * GitHub-compatible HMAC-SHA256 signature generation
+ */
+import { createHmac } from 'crypto';
+/**
+ * Sign a webhook body using HMAC-SHA256
+ * Compatible with GitHub's x-hub-signature-256 format
+ *
+ * @param secret - The webhook secret
+ * @param body - The request body (string or object)
+ * @returns The signature in format "sha256=<hex>"
+ */
+export function signWebhookBody(secret, body) {
+    const payload = typeof body === 'string' ? body : JSON.stringify(body);
+    const signature = createHmac('sha256', secret)
+        .update(payload, 'utf8')
+        .digest('hex');
+    return `sha256=${signature}`;
+}
+/**
+ * Verify a webhook signature
+ *
+ * @param secret - The webhook secret
+ * @param body - The request body (string or object)
+ * @param signature - The signature to verify (format: "sha256=<hex>")
+ * @returns True if the signature is valid
+ */
+export function verifySignature(secret, body, signature) {
+    const expectedSignature = signWebhookBody(secret, body);
+    if (signature.length !== expectedSignature.length) {
+        return false;
+    }
+    // Timing-safe comparison
+    let result = 0;
+    for (let i = 0; i < signature.length; i++) {
+        result |= signature.charCodeAt(i) ^ expectedSignature.charCodeAt(i);
+    }
+    return result === 0;
+}

package/dist/ci/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Fortalece AI SDK - CI Module
+ *
+ * Node-safe entrypoint for GitHub Actions CI integration.
+ * No browser/Svelte dependencies.
+ *
+ * @example
+ * ```typescript
+ * import { notifyCi, notifyBuildSuccess } from '@walker-di/fortalece-ai-sdk/ci';
+ *
+ * // Notify build start
+ * await notifyCi({
+ *   webhookUrl: process.env.FORTALECE_WEBHOOK_URL,
+ *   webhookSecret: process.env.FORTALECE_WEBHOOK_SECRET,
+ *   status: 'building',
+ * });
+ *
+ * // Notify build success with preview URL
+ * await notifyBuildSuccess(
+ *   { webhookUrl, webhookSecret },
+ *   { previewUrl: 'https://preview.example.com' }
+ * );
+ * ```
+ */
+export { signWebhookBody, verifySignature } from './hmac.js';
+export { notifyCiEvent, notifyCi, notifyBuildStart, notifyBuildSuccess, notifyBuildFailure, } from './notify.js';
+export type { CiEventType, CiStatus, CiEventPayload, CiNotifyConfig, CiNotifyResponse, NotifyOptions, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ci/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ci/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAG7D,OAAO,EACL,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,WAAW,EACX,QAAQ,EACR,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,aAAa,GACd,MAAM,YAAY,CAAC"}

package/dist/ci/index.js

@@ -0,0 +1,28 @@
+/**
+ * Fortalece AI SDK - CI Module
+ *
+ * Node-safe entrypoint for GitHub Actions CI integration.
+ * No browser/Svelte dependencies.
+ *
+ * @example
+ * ```typescript
+ * import { notifyCi, notifyBuildSuccess } from '@walker-di/fortalece-ai-sdk/ci';
+ *
+ * // Notify build start
+ * await notifyCi({
+ *   webhookUrl: process.env.FORTALECE_WEBHOOK_URL,
+ *   webhookSecret: process.env.FORTALECE_WEBHOOK_SECRET,
+ *   status: 'building',
+ * });
+ *
+ * // Notify build success with preview URL
+ * await notifyBuildSuccess(
+ *   { webhookUrl, webhookSecret },
+ *   { previewUrl: 'https://preview.example.com' }
+ * );
+ * ```
+ */
+// Export HMAC utilities
+export { signWebhookBody, verifySignature } from './hmac.js';
+// Export notification functions
+export { notifyCiEvent, notifyCi, notifyBuildStart, notifyBuildSuccess, notifyBuildFailure, } from './notify.js';

package/dist/ci/notify.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Fortalece AI CI - Notify Functions
+ * Send CI events to Fortalece webhooks from GitHub Actions
+ */
+import type { CiEventPayload, CiNotifyConfig, CiNotifyResponse, NotifyOptions } from './types.js';
+/**
+ * Send a CI event to Fortalece webhook
+ *
+ * @param config - Webhook configuration
+ * @param payload - Event payload
+ * @returns Response from the webhook
+ */
+export declare function notifyCiEvent(config: CiNotifyConfig, payload: CiEventPayload): Promise<CiNotifyResponse>;
+/**
+ * Notify Fortalece about a CI event using GitHub Actions environment
+ * Automatically reads environment variables for context
+ *
+ * @param options - Notification options
+ * @returns Response from the webhook
+ */
+export declare function notifyCi(options: NotifyOptions): Promise<CiNotifyResponse>;
+/**
+ * Convenience function: Notify build started
+ */
+export declare function notifyBuildStart(config: CiNotifyConfig): Promise<CiNotifyResponse>;
+/**
+ * Convenience function: Notify build success
+ */
+export declare function notifyBuildSuccess(config: CiNotifyConfig, options?: {
+    previewUrl?: string;
+    logsUrl?: string;
+    workItemId?: string;
+}): Promise<CiNotifyResponse>;
+/**
+ * Convenience function: Notify build failure
+ */
+export declare function notifyBuildFailure(config: CiNotifyConfig, options?: {
+    errorMessage?: string;
+    logsUrl?: string;
+    workItemId?: string;
+}): Promise<CiNotifyResponse>;
+//# sourceMappingURL=notify.d.ts.map

package/dist/ci/notify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notify.d.ts","sourceRoot":"","sources":["../../src/ci/notify.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,cAAc,EAEd,cAAc,EACd,gBAAgB,EAEhB,aAAa,EACd,MAAM,YAAY,CAAC;AAqCpB;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,gBAAgB,CAAC,CAwC3B;AAED;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAkChF;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAExF;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACvE,OAAO,CAAC,gBAAgB,CAAC,CAQ3B;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACzE,OAAO,CAAC,gBAAgB,CAAC,CAQ3B"}

package/dist/ci/notify.js

@@ -0,0 +1,141 @@
+/**
+ * Fortalece AI CI - Notify Functions
+ * Send CI events to Fortalece webhooks from GitHub Actions
+ */
+import { signWebhookBody } from './hmac.js';
+/**
+ * Get GitHub Actions environment variables
+ */
+function getGitHubEnv() {
+    return {
+        repository: process.env.GITHUB_REPOSITORY || '',
+        branch: process.env.GITHUB_REF_NAME || process.env.GITHUB_HEAD_REF || '',
+        commit_sha: process.env.GITHUB_SHA || '',
+        github_run_id: process.env.GITHUB_RUN_ID,
+        github_run_number: process.env.GITHUB_RUN_NUMBER,
+        github_workflow: process.env.GITHUB_WORKFLOW,
+        github_actor: process.env.GITHUB_ACTOR,
+        build_url: process.env.GITHUB_SERVER_URL && process.env.GITHUB_REPOSITORY && process.env.GITHUB_RUN_ID
+            ? `${process.env.GITHUB_SERVER_URL}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`
+            : undefined,
+        build_id: process.env.GITHUB_RUN_ID,
+    };
+}
+/**
+ * Map status to event type
+ */
+function statusToEventType(status) {
+    switch (status) {
+        case 'building':
+            return 'build_start';
+        case 'success':
+            return 'build_success';
+        case 'failed':
+            return 'build_failure';
+        default:
+            return 'build_start';
+    }
+}
+/**
+ * Send a CI event to Fortalece webhook
+ *
+ * @param config - Webhook configuration
+ * @param payload - Event payload
+ * @returns Response from the webhook
+ */
+export async function notifyCiEvent(config, payload) {
+    const { webhookUrl, webhookSecret } = config;
+    if (!webhookUrl) {
+        return { success: false, error: 'Missing webhook URL' };
+    }
+    if (!webhookSecret) {
+        return { success: false, error: 'Missing webhook secret' };
+    }
+    const body = JSON.stringify(payload);
+    const signature = signWebhookBody(webhookSecret, body);
+    try {
+        const response = await fetch(webhookUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Hub-Signature-256': signature,
+                'X-Fortalece-Event': `ci:${payload.event}`,
+            },
+            body,
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            return {
+                success: false,
+                error: errorData.error || `HTTP ${response.status}`,
+            };
+        }
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Notify Fortalece about a CI event using GitHub Actions environment
+ * Automatically reads environment variables for context
+ *
+ * @param options - Notification options
+ * @returns Response from the webhook
+ */
+export async function notifyCi(options) {
+    const { webhookUrl, webhookSecret, status, previewUrl, logsUrl, errorMessage, workItemId, serviceName, } = options;
+    const githubEnv = getGitHubEnv();
+    const payload = {
+        event: statusToEventType(status),
+        status,
+        repository: githubEnv.repository || 'unknown/unknown',
+        branch: githubEnv.branch || 'unknown',
+        commit_sha: githubEnv.commit_sha || 'unknown',
+        work_item_id: workItemId,
+        build_id: githubEnv.build_id,
+        build_url: githubEnv.build_url,
+        logs_url: logsUrl,
+        preview_url: previewUrl,
+        service_name: serviceName,
+        error_message: errorMessage,
+        github_run_id: githubEnv.github_run_id,
+        github_run_number: githubEnv.github_run_number,
+        github_workflow: githubEnv.github_workflow,
+        github_actor: githubEnv.github_actor,
+    };
+    return notifyCiEvent({ webhookUrl, webhookSecret }, payload);
+}
+/**
+ * Convenience function: Notify build started
+ */
+export async function notifyBuildStart(config) {
+    return notifyCi({ ...config, status: 'building' });
+}
+/**
+ * Convenience function: Notify build success
+ */
+export async function notifyBuildSuccess(config, options) {
+    return notifyCi({
+        ...config,
+        status: 'success',
+        previewUrl: options?.previewUrl,
+        logsUrl: options?.logsUrl,
+        workItemId: options?.workItemId,
+    });
+}
+/**
+ * Convenience function: Notify build failure
+ */
+export async function notifyBuildFailure(config, options) {
+    return notifyCi({
+        ...config,
+        status: 'failed',
+        errorMessage: options?.errorMessage,
+        logsUrl: options?.logsUrl,
+        workItemId: options?.workItemId,
+    });
+}

package/dist/ci/types.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Fortalece AI CI Types
+ * Types for GitHub Actions integration
+ */
+export type CiEventType = 'build_start' | 'build_success' | 'build_failure' | 'rebuild';
+export type CiStatus = 'building' | 'success' | 'failed';
+/**
+ * CI Event Payload
+ * Sent from GitHub Actions to Fortalece webhook
+ */
+export interface CiEventPayload {
+    /** Event type */
+    event: CiEventType;
+    /** Build status */
+    status: CiStatus;
+    /** Repository in owner/repo format */
+    repository: string;
+    /** Branch name */
+    branch: string;
+    /** Commit SHA */
+    commit_sha: string;
+    /** Optional: Link to a specific work item */
+    work_item_id?: string;
+    /** Build ID */
+    build_id?: string;
+    /** Build URL (GitHub Actions run) */
+    build_url?: string;
+    /** Logs URL */
+    logs_url?: string;
+    /** Preview URL (for deployments) */
+    preview_url?: string;
+    /** Service name */
+    service_name?: string;
+    /** Error message (for failures) */
+    error_message?: string;
+    /** GitHub Actions environment metadata */
+    github_run_id?: string;
+    github_run_number?: string;
+    github_workflow?: string;
+    github_actor?: string;
+}
+/**
+ * Configuration for CI notifications
+ */
+export interface CiNotifyConfig {
+    /** Webhook URL (includes hookId) */
+    webhookUrl: string;
+    /** Webhook secret for HMAC signing */
+    webhookSecret: string;
+}
+/**
+ * Options for notify functions
+ */
+export interface NotifyOptions extends CiNotifyConfig {
+    /** Build status */
+    status: CiStatus;
+    /** Optional preview URL */
+    previewUrl?: string;
+    /** Optional logs URL */
+    logsUrl?: string;
+    /** Optional error message */
+    errorMessage?: string;
+    /** Optional work item ID to link the deployment */
+    workItemId?: string;
+    /** Optional service name */
+    serviceName?: string;
+}
+/**
+ * Response from Fortalece CI webhook
+ */
+export interface CiNotifyResponse {
+    success: boolean;
+    error?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/ci/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/ci/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,MAAM,MAAM,WAAW,GAAG,aAAa,GAAG,eAAe,GAAG,eAAe,GAAG,SAAS,CAAC;AACxF,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEzD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,iBAAiB;IACjB,KAAK,EAAE,WAAW,CAAC;IACnB,mBAAmB;IACnB,MAAM,EAAE,QAAQ,CAAC;IAEjB,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB;IACjB,UAAU,EAAE,MAAM,CAAC;IAEnB,6CAA6C;IAC7C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mBAAmB;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mCAAmC;IACnC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,0CAA0C;IAC1C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,oCAAoC;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,cAAc;IACnD,mBAAmB;IACnB,MAAM,EAAE,QAAQ,CAAC;IACjB,2BAA2B;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wBAAwB;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6BAA6B;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB"}

package/dist/ci/types.js

@@ -0,0 +1,5 @@
+/**
+ * Fortalece AI CI Types
+ * Types for GitHub Actions integration
+ */
+export {};