@hyperdrive.bot/gut 0.1.6 → 0.1.9

package/dist/services/git.service.js

@@ -0,0 +1,188 @@
+import { spawn, spawnSync } from 'node:child_process';
+import path from 'node:path';
+export class GitService {
+    async add(repoPath, files) {
+        const args = ['add', ...files];
+        await this.exec(args, { cwd: repoPath });
+    }
+    async addRemote(repoPath, name, url) {
+        await this.exec(['remote', 'add', name, url], { cwd: repoPath });
+    }
+    async checkout(repoPath, branch) {
+        await this.exec(['checkout', branch], { cwd: repoPath });
+    }
+    async clone(url, destination, depth) {
+        const args = ['clone', url, destination];
+        if (depth) {
+            args.push('--depth', depth.toString());
+        }
+        await this.exec(args);
+    }
+    async commit(repoPath, message, options) {
+        const args = ['commit'];
+        if (options?.all) {
+            args.push('-a');
+        }
+        if (options?.amend) {
+            args.push('--amend');
+        }
+        args.push('-m', message);
+        await this.exec(args, { cwd: repoPath });
+    }
+    async createBranch(repoPath, branch, checkout = true) {
+        if (checkout) {
+            await this.exec(['checkout', '-b', branch], { cwd: repoPath });
+        }
+        else {
+            await this.exec(['branch', branch], { cwd: repoPath });
+        }
+    }
+    async exec(args, options) {
+        return new Promise((resolve, reject) => {
+            const gitProcess = spawn('git', args, {
+                cwd: options?.cwd || process.cwd(),
+                env: options?.env || process.env,
+            });
+            let stdout = '';
+            let stderr = '';
+            gitProcess.stdout.on('data', data => {
+                stdout += data.toString();
+            });
+            gitProcess.stderr.on('data', data => {
+                stderr += data.toString();
+            });
+            gitProcess.on('close', code => {
+                if (code === 0) {
+                    resolve(stdout);
+                }
+                else {
+                    reject(new Error(`Git command failed: ${stderr || stdout}`));
+                }
+            });
+            gitProcess.on('error', error => {
+                reject(error);
+            });
+        });
+    }
+    execSync(args, options) {
+        const result = spawnSync('git', args, {
+            cwd: options?.cwd || process.cwd(),
+            encoding: 'utf8',
+            env: options?.env || process.env,
+        });
+        if (result.error) {
+            throw result.error;
+        }
+        if (result.status !== 0) {
+            throw new Error(`Git command failed: ${result.stderr || result.stdout}`);
+        }
+        return result.stdout;
+    }
+    async fetch(repoPath) {
+        await this.exec(['fetch'], { cwd: repoPath });
+    }
+    async getCurrentBranch(repoPath) {
+        const branch = await this.exec(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: repoPath });
+        return branch.trim();
+    }
+    async getRemoteUrl(repoPath, remote = 'origin') {
+        try {
+            const url = await this.exec(['remote', 'get-url', remote], { cwd: repoPath });
+            return url.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    async getStatus(repoPath) {
+        const branch = await this.getCurrentBranch(repoPath);
+        const statusOutput = await this.exec(['status', '--porcelain'], { cwd: repoPath });
+        const changes = [];
+        const untracked = [];
+        for (const line of statusOutput.split('\n')) {
+            if (line.startsWith('??')) {
+                untracked.push(line.slice(3));
+            }
+            else if (line.trim()) {
+                changes.push(line);
+            }
+        }
+        // Get ahead/behind info
+        let ahead = 0;
+        let behind = 0;
+        try {
+            const trackingBranch = await this.exec(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], { cwd: repoPath });
+            if (trackingBranch.trim()) {
+                const aheadBehind = await this.exec(['rev-list', '--left-right', '--count', `${trackingBranch.trim()}...HEAD`], { cwd: repoPath });
+                const [behindStr, aheadStr] = aheadBehind.trim().split('\t');
+                behind = Number.parseInt(behindStr, 10) || 0;
+                ahead = Number.parseInt(aheadStr, 10) || 0;
+            }
+        }
+        catch {
+            // No tracking branch
+        }
+        return {
+            ahead,
+            behind,
+            branch,
+            changes,
+            entity: path.basename(repoPath),
+            hasChanges: changes.length > 0 || untracked.length > 0,
+            path: repoPath,
+            untracked,
+        };
+    }
+    async hasChanges(repoPath) {
+        const status = await this.getStatus(repoPath);
+        return status.hasChanges;
+    }
+    async hasRemote(repoPath, remote = 'origin') {
+        try {
+            const remotes = await this.exec(['remote'], { cwd: repoPath });
+            return remotes.split('\n').includes(remote);
+        }
+        catch {
+            return false;
+        }
+    }
+    async init(repoPath) {
+        await this.exec(['init'], { cwd: repoPath });
+    }
+    async isRepository(repoPath) {
+        try {
+            await this.exec(['rev-parse', '--git-dir'], { cwd: repoPath });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async pull(repoPath, options) {
+        const args = ['pull'];
+        if (options?.rebase) {
+            args.push('--rebase');
+        }
+        if (options?.noFf) {
+            args.push('--no-ff');
+        }
+        if (options?.strategy) {
+            args.push('--strategy', options.strategy);
+        }
+        await this.exec(args, { cwd: repoPath });
+    }
+    async push(repoPath, options) {
+        const args = ['push'];
+        if (options?.force) {
+            args.push('--force');
+        }
+        if (options?.tags) {
+            args.push('--tags');
+        }
+        if (options?.setUpstream) {
+            const branch = await this.getCurrentBranch(repoPath);
+            args.push('--set-upstream', 'origin', branch);
+        }
+        await this.exec(args, { cwd: repoPath });
+    }
+}

package/dist/services/gut-api.service.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Gut API Service with AWS SigV4 authentication
+ *
+ * Extends @devsquad/cli-auth SigV4ApiClient for gut-specific API methods.
+ */
+import { SigV4ApiClient } from '@hyperdrive.bot/cli-auth';
+import type { FocusTicketResponse, GutTicket, GutTicketStatus, HintResponse, ListTicketsResponse, SyncResponse } from '../models/ticket.model.js';
+/**
+ * Update ticket request
+ */
+export interface UpdateTicketRequest {
+    confidence?: number;
+    phase?: string;
+    status?: GutTicketStatus;
+}
+/**
+ * Gut API Service with SigV4 authentication
+ */
+export declare class GutApiService extends SigV4ApiClient {
+    constructor(domain?: string);
+    /**
+     * List tickets with optional status filter
+     */
+    listTickets(options?: {
+        limit?: number;
+        nextToken?: string;
+        status?: GutTicketStatus;
+    }): Promise<ListTicketsResponse>;
+    /**
+     * Get a ticket by ID
+     */
+    getTicket(ticketId: string): Promise<GutTicket | null>;
+    /**
+     * Get focus context for a ticket
+     */
+    focusTicket(ticketId: string): Promise<FocusTicketResponse>;
+    /**
+     * Add a hint to a ticket
+     */
+    addHint(ticketId: string, hint: string, givenBy: string): Promise<HintResponse>;
+    /**
+     * Sync ticket with external source
+     */
+    syncTicket(ticketId: string, direction?: 'pull' | 'push'): Promise<SyncResponse>;
+    /**
+     * Update a ticket
+     */
+    updateTicket(ticketId: string, updates: UpdateTicketRequest): Promise<GutTicket>;
+    /**
+     * Test API connection
+     */
+    testConnection(): Promise<Record<string, unknown>>;
+}

package/dist/services/gut-api.service.js

@@ -0,0 +1,99 @@
+/**
+ * Gut API Service with AWS SigV4 authentication
+ *
+ * Extends @devsquad/cli-auth SigV4ApiClient for gut-specific API methods.
+ */
+import { SigV4ApiClient } from '@hyperdrive.bot/cli-auth';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { GUT_AUTH_CONFIG } from './auth.service.js';
+// Get CLI version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+let CLI_VERSION = '0.1.0';
+try {
+    const packageJson = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf-8'));
+    CLI_VERSION = packageJson.version;
+}
+catch {
+    // Use default version if package.json can't be read
+}
+/**
+ * Gut API Service with SigV4 authentication
+ */
+export class GutApiService extends SigV4ApiClient {
+    constructor(domain) {
+        super({
+            apiUrlOverride: process.env.GUT_API_ENDPOINT,
+            authConfig: GUT_AUTH_CONFIG,
+            cliName: 'gut-cli',
+            cliVersion: CLI_VERSION,
+            domain,
+            regionOverride: process.env.GUT_AWS_REGION,
+        });
+    }
+    // ============================================================================
+    // Ticket Methods
+    // ============================================================================
+    /**
+     * List tickets with optional status filter
+     */
+    async listTickets(options) {
+        const params = new URLSearchParams();
+        if (options?.status)
+            params.set('status', options.status);
+        if (options?.limit)
+            params.set('limit', String(options.limit));
+        if (options?.nextToken)
+            params.set('nextToken', options.nextToken);
+        const queryString = params.toString();
+        const endpoint = `/gut/tickets${queryString ? `?${queryString}` : ''}`;
+        return this.makeSignedRequest('GET', endpoint);
+    }
+    /**
+     * Get a ticket by ID
+     */
+    async getTicket(ticketId) {
+        try {
+            return await this.makeSignedRequest('GET', `/gut/tickets/${encodeURIComponent(ticketId)}`);
+        }
+        catch (error) {
+            const err = error;
+            if (err.response?.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get focus context for a ticket
+     */
+    async focusTicket(ticketId) {
+        return this.makeSignedRequest('POST', `/gut/tickets/${encodeURIComponent(ticketId)}/focus`);
+    }
+    /**
+     * Add a hint to a ticket
+     */
+    async addHint(ticketId, hint, givenBy) {
+        return this.makeSignedRequest('POST', `/gut/tickets/${encodeURIComponent(ticketId)}/hints`, { hint, givenBy });
+    }
+    /**
+     * Sync ticket with external source
+     */
+    async syncTicket(ticketId, direction = 'push') {
+        return this.makeSignedRequest('POST', `/gut/tickets/${encodeURIComponent(ticketId)}/sync?direction=${direction}`);
+    }
+    /**
+     * Update a ticket
+     */
+    async updateTicket(ticketId, updates) {
+        return this.makeSignedRequest('PATCH', `/gut/tickets/${encodeURIComponent(ticketId)}`, updates);
+    }
+    /**
+     * Test API connection
+     */
+    async testConnection() {
+        return this.makeSignedRequest('GET', '/gut/health');
+    }
+}

package/dist/services/ticket.service.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Ticket Service
+ *
+ * Handles API calls to the gut backend for ticket operations.
+ * Uses AWS SigV4 signing when authenticated, or falls back to token-based auth.
+ */
+import type { FocusTicketResponse, GutTicket, GutTicketStatus, HintResponse, ListTicketsResponse, SyncResponse } from '../models/ticket.model.js';
+import type { ConfigService } from './config.service.js';
+import { type UpdateTicketRequest } from './gut-api.service.js';
+/**
+ * Ticket service configuration for unauthenticated mode
+ */
+interface TicketServiceConfig {
+    apiEndpoint: string;
+    region: string;
+    tenantId: string;
+}
+/**
+ * Ticket service for gut API operations
+ *
+ * This service supports two modes:
+ * 1. Authenticated mode: Uses SigV4 signing via GutApiService
+ * 2. Unauthenticated mode: Uses simple fetch with optional bearer token
+ */
+export declare class TicketService {
+    private readonly apiService;
+    private readonly config;
+    private readonly configService;
+    private readonly useAuth;
+    constructor(configService: ConfigService);
+    /**
+     * List tickets with optional status filter
+     */
+    listTickets(options?: {
+        limit?: number;
+        nextToken?: string;
+        status?: GutTicketStatus;
+    }): Promise<ListTicketsResponse>;
+    /**
+     * Get a ticket by ID
+     */
+    getTicket(ticketId: string): Promise<GutTicket | null>;
+    /**
+     * Get focus context for a ticket
+     */
+    focusTicket(ticketId: string): Promise<FocusTicketResponse>;
+    /**
+     * Add a hint to a ticket
+     */
+    addHint(ticketId: string, hint: string, givenBy: string): Promise<HintResponse>;
+    /**
+     * Sync ticket with external source
+     */
+    syncTicket(ticketId: string, direction?: 'pull' | 'push'): Promise<SyncResponse>;
+    /**
+     * Update a ticket
+     */
+    updateTicket(ticketId: string, updates: UpdateTicketRequest): Promise<GutTicket>;
+    /**
+     * Download manifest for a ticket
+     */
+    downloadManifest(manifestUrl: string, outputPath: string): Promise<void>;
+    /**
+     * Check if API is configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Check if using authenticated mode
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Get current configuration (for debugging)
+     */
+    getConfig(): TicketServiceConfig;
+    /**
+     * Make a fetch request (for unauthenticated mode)
+     */
+    private makeFetchRequest;
+    /**
+     * Load configuration from environment or config file
+     */
+    private loadConfig;
+}
+export {};

package/dist/services/ticket.service.js

@@ -0,0 +1,207 @@
+/**
+ * Ticket Service
+ *
+ * Handles API calls to the gut backend for ticket operations.
+ * Uses AWS SigV4 signing when authenticated, or falls back to token-based auth.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { GutApiService } from './gut-api.service.js';
+/**
+ * Ticket service for gut API operations
+ *
+ * This service supports two modes:
+ * 1. Authenticated mode: Uses SigV4 signing via GutApiService
+ * 2. Unauthenticated mode: Uses simple fetch with optional bearer token
+ */
+export class TicketService {
+    apiService = null;
+    config;
+    configService;
+    useAuth = false;
+    constructor(configService) {
+        this.configService = configService;
+        // Load configuration from environment or config file
+        this.config = this.loadConfig();
+        // Try to use authenticated mode if credentials are available
+        try {
+            this.apiService = new GutApiService();
+            this.useAuth = true;
+        }
+        catch {
+            // No credentials available, use unauthenticated mode
+            this.useAuth = false;
+        }
+    }
+    /**
+     * List tickets with optional status filter
+     */
+    async listTickets(options) {
+        if (this.useAuth && this.apiService) {
+            return this.apiService.listTickets(options);
+        }
+        // Fallback to unauthenticated mode
+        const params = new URLSearchParams();
+        if (options?.status)
+            params.set('status', options.status);
+        if (options?.limit)
+            params.set('limit', String(options.limit));
+        if (options?.nextToken)
+            params.set('nextToken', options.nextToken);
+        const queryString = params.toString();
+        const endpoint = `/gut/tickets${queryString ? `?${queryString}` : ''}`;
+        return this.makeFetchRequest('GET', endpoint);
+    }
+    /**
+     * Get a ticket by ID
+     */
+    async getTicket(ticketId) {
+        if (this.useAuth && this.apiService) {
+            return this.apiService.getTicket(ticketId);
+        }
+        // Fallback to unauthenticated mode
+        try {
+            const response = await this.makeFetchRequest('GET', `/gut/tickets/${encodeURIComponent(ticketId)}`);
+            return response;
+        }
+        catch (error) {
+            if (error.message.includes('404')) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get focus context for a ticket
+     */
+    async focusTicket(ticketId) {
+        if (this.useAuth && this.apiService) {
+            return this.apiService.focusTicket(ticketId);
+        }
+        // Fallback to unauthenticated mode
+        const response = await this.makeFetchRequest('POST', `/gut/tickets/${encodeURIComponent(ticketId)}/focus`);
+        return response;
+    }
+    /**
+     * Add a hint to a ticket
+     */
+    async addHint(ticketId, hint, givenBy) {
+        if (this.useAuth && this.apiService) {
+            return this.apiService.addHint(ticketId, hint, givenBy);
+        }
+        // Fallback to unauthenticated mode
+        const response = await this.makeFetchRequest('POST', `/gut/tickets/${encodeURIComponent(ticketId)}/hints`, { hint, givenBy });
+        return response;
+    }
+    /**
+     * Sync ticket with external source
+     */
+    async syncTicket(ticketId, direction = 'push') {
+        if (this.useAuth && this.apiService) {
+            return this.apiService.syncTicket(ticketId, direction);
+        }
+        // Fallback to unauthenticated mode
+        const response = await this.makeFetchRequest('POST', `/gut/tickets/${encodeURIComponent(ticketId)}/sync?direction=${direction}`);
+        return response;
+    }
+    /**
+     * Update a ticket
+     */
+    async updateTicket(ticketId, updates) {
+        if (this.useAuth && this.apiService) {
+            return this.apiService.updateTicket(ticketId, updates);
+        }
+        // Fallback to unauthenticated mode
+        const response = await this.makeFetchRequest('PATCH', `/gut/tickets/${encodeURIComponent(ticketId)}`, updates);
+        return response;
+    }
+    /**
+     * Download manifest for a ticket
+     */
+    async downloadManifest(manifestUrl, outputPath) {
+        const response = await fetch(manifestUrl);
+        if (!response.ok) {
+            throw new Error(`Failed to download manifest: ${response.statusText}`);
+        }
+        const content = await response.text();
+        fs.writeFileSync(outputPath, content);
+    }
+    /**
+     * Check if API is configured
+     */
+    isConfigured() {
+        return this.useAuth || Boolean(this.config.apiEndpoint && this.config.tenantId);
+    }
+    /**
+     * Check if using authenticated mode
+     */
+    isAuthenticated() {
+        return this.useAuth;
+    }
+    /**
+     * Get current configuration (for debugging)
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Make a fetch request (for unauthenticated mode)
+     */
+    async makeFetchRequest(method, endpoint, body) {
+        const url = `${this.config.apiEndpoint}${endpoint}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            'x-tenant-id': this.config.tenantId
+        };
+        // Add authorization header if available from environment
+        const authToken = process.env.GUT_AUTH_TOKEN;
+        if (authToken) {
+            headers['Authorization'] = `Bearer ${authToken}`;
+        }
+        const response = await fetch(url, {
+            body: body ? JSON.stringify(body) : undefined,
+            headers,
+            method,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text();
+            throw new Error(`API request failed (${response.status}): ${errorBody}`);
+        }
+        return response.json();
+    }
+    /**
+     * Load configuration from environment or config file
+     */
+    loadConfig() {
+        // Try environment variables first
+        const apiEndpoint = process.env.GUT_API_ENDPOINT;
+        const region = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || 'us-east-1';
+        const tenantId = process.env.GUT_TENANT_ID;
+        if (apiEndpoint && tenantId) {
+            return { apiEndpoint, region, tenantId };
+        }
+        // Try loading from .gut/api.json config file
+        const workspaceRoot = this.configService.getWorkspaceRoot();
+        const apiConfigPath = path.join(workspaceRoot, '.gut', 'api.json');
+        if (fs.existsSync(apiConfigPath)) {
+            try {
+                const configContent = fs.readFileSync(apiConfigPath, 'utf8');
+                const config = JSON.parse(configContent);
+                return {
+                    apiEndpoint: config.apiEndpoint || 'https://api.devsquad.com',
+                    region: config.region || region,
+                    tenantId: config.tenantId || 'default'
+                };
+            }
+            catch {
+                console.warn('Warning: Could not parse .gut/api.json');
+            }
+        }
+        // Default fallback
+        return {
+            apiEndpoint: process.env.GUT_API_ENDPOINT || 'https://api.devsquad.com',
+            region,
+            tenantId: process.env.GUT_TENANT_ID || 'default'
+        };
+    }
+}

package/dist/utils/display.d.ts

@@ -0,0 +1,26 @@
+import Table, { type TableConstructorOptions } from 'cli-table3';
+import { type Ora } from 'ora';
+export declare const DisplayUtils: {
+    createSpinner(text?: string): Ora;
+    createTable(options?: TableConstructorOptions): Table.Table;
+    error(message: string): void;
+    formatCommand(command: string): string;
+    formatDuration(ms: number): string;
+    formatEntityType(type: string): string;
+    formatGitStatus(status: string): string;
+    formatList(items: string[], maxItems?: number): string;
+    formatPath(path: string): string;
+    formatRelativeTime(date: Date): string;
+    formatSize(bytes: number): string;
+    formatTimestamp(date: Date): string;
+    highlight(text: string, pattern: RegExp | string): string;
+    info(message: string): void;
+    pluralize(count: number, singular: string, plural?: string): string;
+    printFooter(message?: string, width?: number): void;
+    printHeader(title: string, width?: number): void;
+    progressBar(current: number, total: number, width?: number): string;
+    success(message: string): void;
+    truncate(str: string, maxLength: number): string;
+    warning(message: string): void;
+};
+export default DisplayUtils;