@hyperdrive.bot/cli 1.0.7 → 1.0.8

package/dist/commands/project/sync.js

@@ -0,0 +1,388 @@
+/**
+ * Project Sync Command
+ *
+ * Generates structured architecture summaries for repos in a project.
+ * For each repo: clone/pull → detect _bmad or invoke Claude → validate YAML → upload S3 → update DynamoDB.
+ */
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { execSync, spawn } from 'child_process';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync } from 'fs';
+import yaml from 'js-yaml';
+import ora from 'ora';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+// ============================================================================
+// Architecture Summary YAML Schema & Validation (inline for CLI — no server deps)
+// ============================================================================
+const VALID_ENTITY_TYPES = ['client', 'company', 'delivery', 'initiative', 'module', 'service', 'system', 'tool'];
+const REQUIRED_SUMMARY_KEYS = ['repo', 'domains', 'patterns', 'modules', 'entity_registry', 'tech_stack'];
+const ARCHITECTURE_YAML_SCHEMA = `repo:
+  name: "<repo-name>"
+  description: "<one-line description>"
+
+domains:
+  - name: "<domain-name>"
+    modules: [<module1>, <module2>]
+    key_files: [<path1>, <path2>]
+
+patterns:
+  handler_pattern: "<glob pattern for handlers>"
+  service_pattern: "<glob pattern for services>"
+  module_config: "<glob pattern for module config>"
+  test_pattern: "<glob pattern for tests>"
+
+modules: [<module1>, <module2>, ...]
+
+entity_registry:
+  - { name: "<entity-name>", type: "<client|company|delivery|initiative|module|service|system|tool>", path: "<relative-path>" }
+
+tech_stack:
+  runtime: "<e.g. nodejs-22>"
+  framework: "<e.g. serverless-v4>"
+  language: "<e.g. typescript>"
+  database: "<e.g. dynamodb>"
+  infrastructure: "<e.g. aws-lambda>"`;
+const ARCHITECTURE_ANALYSIS_PROMPT = `Analyze this code repository and produce a structured architecture summary in YAML format. Output ONLY valid YAML — no markdown fences, no explanations, no commentary.
+
+Analyze the following:
+1. Directory structure and key files
+2. Functional domains (groups of related modules)
+3. Code patterns (handler paths, service paths, test paths, module config paths)
+4. List of modules/packages
+5. Entity registry (named entities with type: client|company|delivery|initiative|module|service|system|tool)
+6. Technology stack (runtime, framework, language, database, infrastructure)
+
+Required YAML schema:
+${ARCHITECTURE_YAML_SCHEMA}
+
+Now analyze the repository and produce the YAML summary.`;
+export default class ProjectSync extends Command {
+    static args = {
+        project: Args.string({
+            description: 'Project slug or ID',
+            required: true,
+        }),
+    };
+    static description = 'Generate architecture summaries for project repos via Claude analysis';
+    static examples = [
+        '<%= config.bin %> project sync my-project',
+        '<%= config.bin %> project sync my-project --repo api',
+        '<%= config.bin %> project sync my-project --json',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        json: Flags.boolean({
+            description: 'Output result as JSON',
+        }),
+        repo: Flags.string({
+            description: 'Sync only a specific repo by name',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ProjectSync);
+        // Authenticate
+        let service;
+        const authSpinner = ora('Checking authentication...').start();
+        try {
+            service = new HyperdriveSigV4Service(flags.domain);
+            authSpinner.succeed('Authenticated');
+        }
+        catch (error) {
+            authSpinner.fail('Not authenticated');
+            this.error(`${error.message}\n\nPlease authenticate first with: ${chalk.cyan('hd auth login')}`);
+        }
+        // Resolve project by slug
+        const projectSpinner = ora(`Resolving project ${chalk.cyan(args.project)}...`).start();
+        let project;
+        try {
+            const result = await service.moduleGet({ slug: args.project });
+            project = { name: result.name || args.project, projectId: result.projectId || args.project, slug: result.slug || args.project };
+            projectSpinner.succeed(`Project: ${chalk.cyan(project.name)} (${project.slug})`);
+        }
+        catch (error) {
+            projectSpinner.fail('Project not found');
+            this.error(`Could not find project "${args.project}": ${error.response?.data?.message || error.message}`);
+        }
+        // List repos
+        const repoSpinner = ora('Fetching repositories...').start();
+        let repos;
+        try {
+            repos = await service.projectListRepos(project.projectId);
+            repoSpinner.succeed(`Found ${repos.length} repo(s)`);
+        }
+        catch (error) {
+            repoSpinner.fail('Failed to fetch repos');
+            this.error(`Could not list repos: ${error.response?.data?.message || error.message}`);
+        }
+        // Filter by --repo flag
+        if (flags.repo) {
+            repos = repos.filter(r => r.name === flags.repo);
+            if (repos.length === 0) {
+                this.error(`No repo named "${flags.repo}" found in project "${project.slug}"`);
+            }
+        }
+        if (repos.length === 0) {
+            this.log(chalk.yellow('No repositories to sync.'));
+            return;
+        }
+        this.log('');
+        this.log(chalk.blue(`Syncing ${repos.length} repo(s)...`));
+        this.log('');
+        // Process each repo
+        const results = [];
+        for (let i = 0; i < repos.length; i++) {
+            const repo = repos[i];
+            const prefix = chalk.dim(`[${i + 1}/${repos.length}]`);
+            const result = await this.syncRepo(service, project, repo, prefix);
+            results.push(result);
+        }
+        // Summary
+        this.log('');
+        const succeeded = results.filter(r => r.success).length;
+        const failed = results.filter(r => !r.success).length;
+        if (flags.json) {
+            this.log(JSON.stringify({ failed, project: project.slug, results, succeeded, total: repos.length }, null, 2));
+            return;
+        }
+        if (failed === 0) {
+            this.log(chalk.green(`Synced ${succeeded}/${repos.length} repos (0 failed)`));
+        }
+        else {
+            this.log(chalk.yellow(`Synced ${succeeded}/${repos.length} repos (${failed} failed)`));
+            for (const r of results.filter(r => !r.success)) {
+                this.log(chalk.red(`  ${r.name}: ${r.error}`));
+            }
+        }
+    }
+    async syncRepo(service, project, repo, prefix) {
+        const spinner = ora(`${prefix} ${chalk.cyan(repo.name)} — cloning...`).start();
+        let tmpDir = null;
+        try {
+            // Step 1: Clone
+            tmpDir = mkdtempSync(join(tmpdir(), `hd-sync-${repo.name}-`));
+            const clonePath = join(tmpDir, repo.name);
+            try {
+                execSync(`git clone --depth 1 --branch ${repo.defaultBranch} ${repo.gitRemote} ${clonePath}`, {
+                    stdio: 'pipe',
+                    timeout: 120_000, // 2 min clone timeout
+                });
+            }
+            catch (cloneError) {
+                throw new Error(`git clone failed: ${cloneError.stderr?.toString() || cloneError.message}`);
+            }
+            // Step 2: Detect _bmad or generate via Claude
+            spinner.text = `${prefix} ${chalk.cyan(repo.name)} — analyzing...`;
+            let yamlOutput = null;
+            let lastError = null;
+            const MAX_ATTEMPTS = 3;
+            // Check for _bmad docs
+            const bmadDocPath = this.detectBmadDocs(clonePath);
+            for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+                try {
+                    if (bmadDocPath) {
+                        // Use _bmad doc with simpler restructure prompt
+                        const docContent = readFileSync(bmadDocPath, 'utf-8');
+                        const prompt = `You are given an existing architecture documentation file. Convert it into the following YAML format. Output ONLY valid YAML, no markdown fences, no explanations.\n\nRequired YAML schema:\n${ARCHITECTURE_YAML_SCHEMA}\n\nHere is the architecture document to convert:\n\n${docContent}`;
+                        yamlOutput = await this.runClaude(prompt, clonePath);
+                    }
+                    else {
+                        // Full codebase analysis
+                        yamlOutput = await this.runClaude(ARCHITECTURE_ANALYSIS_PROMPT, clonePath);
+                    }
+                    // Validate
+                    this.validateYaml(yamlOutput);
+                    break; // Validation passed
+                }
+                catch (error) {
+                    lastError = error.message;
+                    this.log(chalk.dim(`  ${repo.name} attempt ${attempt}/${MAX_ATTEMPTS} failed: ${lastError}`));
+                    yamlOutput = null;
+                    if (attempt === MAX_ATTEMPTS) {
+                        throw new Error(`Validation failed after ${MAX_ATTEMPTS} attempts: ${lastError}`);
+                    }
+                }
+            }
+            if (!yamlOutput) {
+                throw new Error(`Generation failed: ${lastError}`);
+            }
+            // Step 2b: Extract entity registry from validated YAML and merge with gut config
+            spinner.text = `${prefix} ${chalk.cyan(repo.name)} — extracting entities...`;
+            const parsedYaml = yaml.load(yamlOutput);
+            let entityRegistry = (parsedYaml.entity_registry || []);
+            // Check for .gut/config.json and merge
+            const gutEntities = this.readGutEntities(clonePath);
+            if (gutEntities.length > 0) {
+                entityRegistry = this.mergeEntityRegistries(entityRegistry, gutEntities);
+                this.log(chalk.dim(`  ${repo.name}: merged ${entityRegistry.length} entities (${gutEntities.length} from gut)`));
+            }
+            else if (entityRegistry.length > 0) {
+                this.log(chalk.dim(`  ${repo.name}: found ${entityRegistry.length} entities from analysis`));
+            }
+            // Step 3: Upload to S3 via API
+            spinner.text = `${prefix} ${chalk.cyan(repo.name)} — uploading...`;
+            // The API handles S3 upload and DynamoDB update — call updateRepo with the summary content
+            await service.projectUpdateRepo(project.projectId, repo.repoId, {
+                architectureSummary: yamlOutput,
+                lastSyncedAt: new Date().toISOString(),
+            });
+            // Step 4: Update entity registry via dedicated endpoint
+            if (entityRegistry.length > 0) {
+                try {
+                    await service.projectUpdateEntities(project.projectId, repo.repoId, entityRegistry);
+                }
+                catch (entityError) {
+                    this.log(chalk.yellow(`  ${repo.name}: entity registry update failed: ${entityError.message}`));
+                }
+            }
+            spinner.succeed(`${prefix} ${chalk.cyan(repo.name)} — ${chalk.green('done')}`);
+            return { name: repo.name, success: true };
+        }
+        catch (error) {
+            spinner.fail(`${prefix} ${chalk.cyan(repo.name)} — ${chalk.red('failed')}`);
+            this.log(chalk.red(`  Error: ${error.message}`));
+            return { error: error.message, name: repo.name, success: false };
+        }
+        finally {
+            // Cleanup temp directory
+            if (tmpDir && existsSync(tmpDir)) {
+                try {
+                    rmSync(tmpDir, { force: true, recursive: true });
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+        }
+    }
+    detectBmadDocs(repoPath) {
+        const bmadDir = join(repoPath, '_bmad');
+        if (!existsSync(bmadDir))
+            return null;
+        try {
+            if (!statSync(bmadDir).isDirectory())
+                return null;
+            const files = readdirSync(bmadDir);
+            const archPatterns = [/^architecture.*\.md$/i, /^arch-.*\.md$/i];
+            for (const file of files) {
+                for (const pattern of archPatterns) {
+                    if (pattern.test(file)) {
+                        return join(bmadDir, file);
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore fs errors
+        }
+        return null;
+    }
+    runClaude(prompt, cwd) {
+        return new Promise((resolve, reject) => {
+            const TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+            const child = spawn('claude', ['-p', prompt, '--output-format', 'text'], {
+                cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: TIMEOUT_MS,
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('error', (error) => {
+                reject(new Error(`Claude CLI failed to start: ${error.message}`));
+            });
+            child.on('close', (code) => {
+                if (code !== 0) {
+                    reject(new Error(`Claude CLI exited with code ${code}: ${stderr.slice(0, 500)}`));
+                    return;
+                }
+                // Strip markdown code fences if present
+                let output = stdout.trim();
+                if (output.startsWith('```yaml')) {
+                    output = output.replace(/^```yaml\n?/, '').replace(/\n?```$/, '');
+                }
+                else if (output.startsWith('```')) {
+                    output = output.replace(/^```\n?/, '').replace(/\n?```$/, '');
+                }
+                resolve(output);
+            });
+        });
+    }
+    validateYaml(yamlString) {
+        const parsed = yaml.load(yamlString);
+        if (!parsed || typeof parsed !== 'object') {
+            throw new Error('YAML must be a non-null object');
+        }
+        for (const key of REQUIRED_SUMMARY_KEYS) {
+            if (!(key in parsed)) {
+                throw new Error(`Missing required top-level key: '${key}'`);
+            }
+        }
+        const repo = parsed.repo;
+        if (!repo || typeof repo !== 'object' || !repo.name || !repo.description) {
+            throw new Error("'repo' must have 'name' and 'description' string fields");
+        }
+        if (!Array.isArray(parsed.entity_registry)) {
+            throw new Error("'entity_registry' must be an array");
+        }
+        for (let i = 0; i < parsed.entity_registry.length; i++) {
+            const entry = parsed.entity_registry[i];
+            if (!entry.name)
+                throw new Error(`entity_registry[${i}]: 'name' is required`);
+            if (!entry.type)
+                throw new Error(`entity_registry[${i}]: 'type' is required`);
+            if (!VALID_ENTITY_TYPES.includes(entry.type)) {
+                throw new Error(`entity_registry[${i}]: invalid type '${entry.type}'`);
+            }
+            if (!entry.path)
+                throw new Error(`entity_registry[${i}]: 'path' is required`);
+        }
+        const techStack = parsed.tech_stack;
+        if (!techStack || typeof techStack !== 'object') {
+            throw new Error("'tech_stack' must be an object");
+        }
+        for (const field of ['runtime', 'framework', 'language', 'database', 'infrastructure']) {
+            if (!techStack[field]) {
+                throw new Error(`tech_stack.${field} is required`);
+            }
+        }
+    }
+    readGutEntities(repoPath) {
+        const gutConfigPath = join(repoPath, '.gut', 'config.json');
+        if (!existsSync(gutConfigPath))
+            return [];
+        try {
+            const content = readFileSync(gutConfigPath, 'utf-8');
+            const config = JSON.parse(content);
+            if (!config.entities || !Array.isArray(config.entities))
+                return [];
+            return config.entities
+                .filter((e) => e && typeof e === 'object' && e.name && e.type && e.path &&
+                VALID_ENTITY_TYPES.includes(e.type))
+                .map((e) => ({
+                name: e.name,
+                type: e.type,
+                path: e.path,
+                ...(e.repository && typeof e.repository === 'string' ? { repository: e.repository } : {}),
+                ...(e.description && typeof e.description === 'string' ? { description: e.description } : {}),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    mergeEntityRegistries(claudeEntities, gutEntities) {
+        const gutNameSet = new Set(gutEntities.map(e => e.name.toLowerCase()));
+        const uniqueClaude = claudeEntities.filter(e => !gutNameSet.has(e.name.toLowerCase()));
+        return [...gutEntities, ...uniqueClaude];
+    }
+}

package/dist/services/hyperdrive-sigv4.d.ts

@@ -136,6 +136,42 @@ interface GitAuthInitiateResponse {
     installUrl: string;
     state: string;
 }
+export type HookActionType = 'adhb-enrich' | 'ci-trigger' | 'slack-notify' | 'webhook';
+export interface SlackNotifyConfig {
+    channel: string;
+    template?: string;
+}
+export interface AdhbEnrichConfig {
+    priority?: 'high' | 'low' | 'normal';
+}
+export interface WebhookConfig {
+    headers?: Record<string, string>;
+    method: 'POST' | 'PUT';
+    url: string;
+}
+export interface CiTriggerConfig {
+    pipeline: string;
+    provider: 'github' | 'gitlab';
+    ref?: string;
+}
+export type HookActionConfig = AdhbEnrichConfig | CiTriggerConfig | SlackNotifyConfig | WebhookConfig;
+export interface HookResponse {
+    actionConfig: HookActionConfig;
+    actionType: HookActionType;
+    createdAt: string;
+    enabled: boolean;
+    hookId: string;
+    triggerStatus: string;
+    updatedAt: string;
+}
+export interface HookListResponse {
+    hooks: HookResponse[];
+}
+export interface HookCreateRequest {
+    actionConfig: HookActionConfig;
+    actionType: HookActionType;
+    triggerStatus: string;
+}
 /**
  * Hyperdrive API Service with AWS SigV4 authentication
  */
@@ -253,6 +289,28 @@ export declare class HyperdriveSigV4Service extends SigV4ApiClient {
         repos: GitRepoInfo[];
         totalCount: number;
     }>;
+    hookCreate(projectId: string, body: HookCreateRequest): Promise<HookResponse>;
+    hookDelete(projectId: string, hookId: string): Promise<{
+        message: string;
+    }>;
+    hookList(projectId: string): Promise<HookListResponse>;
+    hookUpdate(projectId: string, hookId: string, body: Partial<HookCreateRequest> & {
+        enabled?: boolean;
+    }): Promise<HookResponse>;
+    projectGetJiraStatuses(projectId: string): Promise<{
+        statuses: Array<{
+            id: string;
+            name: string;
+            category?: string;
+        }>;
+    }>;
+    jiraGetProjectStatuses(jiraProjectKey: string): Promise<{
+        statuses: Array<{
+            id: string;
+            name: string;
+            category?: string;
+        }>;
+    }>;
     jiraPreRegister(params: {
         jiraDomain: string;
     }): Promise<{
@@ -268,6 +326,73 @@ export declare class HyperdriveSigV4Service extends SigV4ApiClient {
         };
         success: boolean;
     }>;
+    projectAddRepo(projectId: string, repo: {
+        defaultBranch: string;
+        gitProvider: string;
+        gitRemote: string;
+        name: string;
+    }): Promise<{
+        defaultBranch: string;
+        gitProvider: string;
+        gitRemote: string;
+        name: string;
+        repoId: string;
+    }>;
+    projectFindByJiraKey(jiraProjectKey: string): Promise<{
+        jiraProjectKey: string;
+        projectId: string;
+        slug: string;
+    }>;
+    projectGetJiraConfig(projectId: string): Promise<{
+        createdAt: string;
+        jiraProjectKey: string;
+        statusMapping: Record<string, string>;
+        updatedAt: string;
+    }>;
+    projectListRepos(projectId: string): Promise<Array<{
+        architectureSummary?: string | null;
+        architectureSummaryUpdatedAt?: string | null;
+        createdAt: string;
+        defaultBranch: string;
+        gitRemote: string;
+        name: string;
+        provider: string;
+        repoId: string;
+        updatedAt: string;
+    }>>;
+    projectSetJiraConfig(projectId: string, config: {
+        jiraProjectKey: string;
+        statusMapping: Record<string, string>;
+    }): Promise<{
+        jiraProjectKey: string;
+        projectId: string;
+        statusMapping: Record<string, string>;
+    }>;
+    projectUpdateRepo(projectId: string, repoId: string, updateData: {
+        architectureSummary?: string | null;
+        defaultBranch?: string;
+        lastSyncedAt?: string;
+    }): Promise<{
+        architectureSummary?: string | null;
+        defaultBranch: string;
+        gitRemote: string;
+        lastSyncedAt?: string;
+        provider: string;
+        repoId: string;
+    }>;
+    projectUpdateEntities(projectId: string, repoId: string, entities: Array<{
+        name: string;
+        type: string;
+        path: string;
+        repository?: string;
+        description?: string;
+    }>): Promise<Array<{
+        name: string;
+        type: string;
+        path: string;
+        repository?: string;
+        description?: string;
+    }>>;
     makeTestRequest(): Promise<Record<string, unknown>>;
     moduleAnalyze(slug: string): Promise<{
         jobId: string;

package/dist/services/hyperdrive-sigv4.js

@@ -102,12 +102,57 @@ export class HyperdriveSigV4Service extends SigV4ApiClient {
         return this.makeSignedRequest('GET', `/git/repos?${queryParams}`);
     }
     // ============================================================================
+    // Hook Methods
+    // ============================================================================
+    async hookCreate(projectId, body) {
+        return this.makeSignedRequest('POST', `/hyperdrive/projects/${encodeURIComponent(projectId)}/hooks`, body);
+    }
+    async hookDelete(projectId, hookId) {
+        return this.makeSignedRequest('DELETE', `/hyperdrive/projects/${encodeURIComponent(projectId)}/hooks/${encodeURIComponent(hookId)}`);
+    }
+    async hookList(projectId) {
+        return this.makeSignedRequest('GET', `/hyperdrive/projects/${encodeURIComponent(projectId)}/hooks`);
+    }
+    async hookUpdate(projectId, hookId, body) {
+        return this.makeSignedRequest('PATCH', `/hyperdrive/projects/${encodeURIComponent(projectId)}/hooks/${encodeURIComponent(hookId)}`, body);
+    }
+    async projectGetJiraStatuses(projectId) {
+        return this.makeSignedRequest('GET', `/hyperdrive/projects/${encodeURIComponent(projectId)}/jira/statuses`);
+    }
+    // ============================================================================
     // Jira Integration Methods
     // ============================================================================
+    async jiraGetProjectStatuses(jiraProjectKey) {
+        return this.makeSignedRequest('GET', `/hyperdrive/jira/projects/${encodeURIComponent(jiraProjectKey)}/statuses`);
+    }
     async jiraPreRegister(params) {
         return this.makeSignedRequest('POST', '/hyperdrive/jira/pre-register', params);
     }
     // ============================================================================
+    // Hyperdrive Project Methods
+    // ============================================================================
+    async projectAddRepo(projectId, repo) {
+        return this.makeSignedRequest('POST', `/hyperdrive/projects/${encodeURIComponent(projectId)}/repos`, repo);
+    }
+    async projectFindByJiraKey(jiraProjectKey) {
+        return this.makeSignedRequest('GET', `/hyperdrive/projects/by-jira-key/${encodeURIComponent(jiraProjectKey)}`);
+    }
+    async projectGetJiraConfig(projectId) {
+        return this.makeSignedRequest('GET', `/hyperdrive/projects/${encodeURIComponent(projectId)}/jira-config`);
+    }
+    async projectListRepos(projectId) {
+        return this.makeSignedRequest('GET', `/hyperdrive/projects/${encodeURIComponent(projectId)}/repos`);
+    }
+    async projectSetJiraConfig(projectId, config) {
+        return this.makeSignedRequest('PUT', `/hyperdrive/projects/${encodeURIComponent(projectId)}/jira-config`, config);
+    }
+    async projectUpdateRepo(projectId, repoId, updateData) {
+        return this.makeSignedRequest('PATCH', `/hyperdrive/projects/${encodeURIComponent(projectId)}/repos/${encodeURIComponent(repoId)}`, updateData);
+    }
+    async projectUpdateEntities(projectId, repoId, entities) {
+        return this.makeSignedRequest('PUT', `/hyperdrive/projects/${encodeURIComponent(projectId)}/repos/${encodeURIComponent(repoId)}/entities`, entities);
+    }
+    // ============================================================================
     // Module Methods
     // ============================================================================
     async makeTestRequest() {

package/dist/utils/account-flow.d.ts

@@ -42,7 +42,7 @@ export declare function promptAccountDetails(existingData?: Partial<AccountAddDa
  * @param accountData - Account details to register
  * @returns AccountResult indicating success or failure
  */
-export declare function registerAccount(accountData: AccountAddData): Promise<AccountResult>;
+export declare function registerAccount(accountData: AccountAddData, tenantDomain?: string): Promise<AccountResult>;
 /**
  * Execute the AWS account add flow
  *
@@ -68,7 +68,7 @@ export declare function promptOpenCloudFormation(quickCreateUrl: string): Promis
 /**
  * Wait for role verification with polling
  */
-export declare function waitForRoleVerification(accountId: string, onProgress?: (message: string) => void): Promise<{
+export declare function waitForRoleVerification(accountId: string, onProgress?: (message: string) => void, tenantDomain?: string): Promise<{
     message?: string;
     verified: boolean;
 }>;

package/dist/utils/account-flow.js

@@ -97,10 +97,10 @@ export async function promptAccountDetails(existingData) {
  * @param accountData - Account details to register
  * @returns AccountResult indicating success or failure
  */
-export async function registerAccount(accountData) {
+export async function registerAccount(accountData, tenantDomain) {
     try {
         // Initialize API service
-        const service = new HyperdriveSigV4Service();
+        const service = new HyperdriveSigV4Service(tenantDomain);
         // Make API call to add account
         const result = await service.accountAdd({
             accountId: accountData.accountId,
@@ -190,8 +190,8 @@ const VERIFY_TIMEOUT = 300000; // 5 minutes
 /**
  * Wait for role verification with polling
  */
-export async function waitForRoleVerification(accountId, onProgress) {
-    const service = new HyperdriveSigV4Service();
+export async function waitForRoleVerification(accountId, onProgress, tenantDomain) {
+    const service = new HyperdriveSigV4Service(tenantDomain);
     const startTime = Date.now();
     let attemptCount = 0;
     while (Date.now() - startTime < VERIFY_TIMEOUT) {

package/dist/utils/git-flow.d.ts

@@ -3,6 +3,7 @@
  */
 export interface GitConnectOptions {
     callbackPort?: number;
+    domain?: string;
     logger?: (message: string) => void;
     provider?: 'github' | 'gitlab';
     timeout?: number;

package/dist/utils/git-flow.js

@@ -159,7 +159,7 @@ export function waitForCallback(expectedState, port = 8765, timeout = 5 * 60 * 1
  * @returns GitConnectResult indicating success or failure
  */
 export async function executeGitConnect(options = {}) {
-    const { callbackPort = 8765, logger = () => { }, // No-op by default
+    const { callbackPort = 8765, domain, logger = () => { }, // No-op by default
     provider: initialProvider, timeout = 5 * 60 * 1000, } = options;
     try {
         // Step 1: Determine provider (prompt if not specified)
@@ -175,7 +175,7 @@ export async function executeGitConnect(options = {}) {
             provider = selected;
         }
         // Step 2: Initialize API service
-        const service = new HyperdriveSigV4Service();
+        const service = new HyperdriveSigV4Service(domain);
         // Step 3: Initiate OAuth flow via API
         const authResponse = await service.gitAuthInitiate(provider);
         logger(`Opening browser for ${provider === 'github' ? 'GitHub' : 'GitLab'} authorization...`);

package/dist/utils/hook-flow.d.ts

@@ -0,0 +1,21 @@
+import type { HookActionType, HookResponse } from '../services/hyperdrive-sigv4.js';
+/**
+ * Prompt user to select a trigger status from available Jira statuses
+ */
+export declare function promptTriggerStatus(statuses: string[]): Promise<string>;
+/**
+ * Prompt user to select an action type
+ */
+export declare function promptActionType(): Promise<HookActionType>;
+/**
+ * Prompt for action-specific configuration based on action type
+ */
+export declare function promptActionConfig(actionType: HookActionType): Promise<Record<string, unknown>>;
+/**
+ * Prompt user to select a hook from a list
+ */
+export declare function promptSelectHook(hooks: HookResponse[]): Promise<HookResponse>;
+/**
+ * Prompt user to confirm hook deletion
+ */
+export declare function promptConfirmDelete(hook: HookResponse): Promise<boolean>;