@hyperdrive.bot/gut 0.1.8 → 0.1.10

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { BaseCommand } from './base-command.js';
+export type { AIContext, Config, Entity, EntityMetadata, EntityType, Focus, FocusContext, FocusMode, RepoStatus, } from './models/entity.model.js';
+export { ConfigService } from './services/config.service.js';
+export { EntityService } from './services/entity.service.js';
+export { FocusService } from './services/focus.service.js';
+export { GitService } from './services/git.service.js';
+export * from './utils/index.js';
+/**
+ * gut - Git Unified Tooling
+ *
+ * ESM-compatible entry point for the gut CLI.
+ * Provides the oclif run function for CLI execution.
+ */
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1,16 @@
+// Re-export core components for programmatic usage
+export { BaseCommand } from './base-command.js';
+// Re-export services for advanced integrations
+export { ConfigService } from './services/config.service.js';
+export { EntityService } from './services/entity.service.js';
+export { FocusService } from './services/focus.service.js';
+export { GitService } from './services/git.service.js';
+// Re-export utilities
+export * from './utils/index.js';
+/**
+ * gut - Git Unified Tooling
+ *
+ * ESM-compatible entry point for the gut CLI.
+ * Provides the oclif run function for CLI execution.
+ */
+export { run } from '@oclif/core';

package/dist/models/entity.model.d.ts

@@ -0,0 +1,234 @@
+export declare const ENTITY_TYPES: readonly ["client", "company", "delivery", "initiative", "module", "prospect", "service", "system", "tool"];
+export type EntityType = typeof ENTITY_TYPES[number];
+export type FocusMode = 'audit' | 'debug' | 'delivery' | 'proposal' | 'research' | 'strategy';
+export interface Entity {
+    description?: string;
+    metadata?: EntityMetadata;
+    name: string;
+    path: string;
+    remote?: string;
+    repo?: string;
+    repository?: string;
+    type: EntityType;
+}
+export interface AIContextMetadata {
+    decision_authority?: string;
+    knowledge_scope?: string;
+    persona?: string;
+}
+export interface BusinessMetadata {
+    contract_value?: string;
+    primary_contact?: string;
+    priority?: 'high' | 'low' | 'medium';
+    status?: string;
+    team_size?: number;
+}
+export interface RelationshipsMetadata {
+    dependent_systems?: string[];
+    related_initiatives?: string[];
+    similar_entities?: string[];
+}
+export interface WorkingPatternsMetadata {
+    common_paired_entities?: string[];
+    strategic_review_frequency?: string;
+    typical_focus_duration?: string;
+}
+export interface EntityMetadata {
+    ai_context?: AIContextMetadata;
+    business?: BusinessMetadata;
+    relationships?: RelationshipsMetadata;
+    working_patterns?: WorkingPatternsMetadata;
+}
+export interface Focus {
+    duration?: string;
+    entities?: Entity[];
+    mode?: FocusMode;
+    name: string;
+    path: string;
+    remember?: boolean;
+    timestamp?: number;
+    type: string;
+}
+export interface AdaptiveSuggestions {
+    contextSpecificTips: string[];
+    dayBasedSuggestions: string[];
+    productivityOptimizations: string[];
+    timeBasedSuggestions: string[];
+    workflowSuggestions: string[];
+}
+export interface ContextIntelligence {
+    complexityLevel: string;
+    contextType: string;
+    estimatedDuration: string;
+    interruptionLikelihood: string;
+    recommendedApproach: string[];
+    successProbability: string;
+}
+export interface CollaborationContext {
+    collaborationPatterns: CollaborationPatterns;
+    communicationPreferences: CommunicationPreferences;
+    coordinationNeeds: CoordinationNeeds;
+    sharedResources: SharedResources;
+    teamMembers: TeamMembersInfo;
+}
+export interface LearningInsights {
+    commonPitfalls: CommonPitfalls;
+    historicalPatterns: HistoricalPatterns;
+    learningOpportunities: LearningOpportunities;
+    similarEntityLessons: SimilarEntityLessons;
+    successFactors: SuccessFactors;
+}
+export interface PerformanceContext {
+    benchmarks: Benchmarks;
+    bottlenecks: Bottlenecks;
+    currentVelocity: VelocityInfo;
+    optimizationOpportunities: OptimizationOpportunities;
+    performanceTrends: PerformanceTrends;
+}
+export interface AvailableData {
+    businessContext: BusinessContext;
+    entityMetadata: EntityMetadata | Record<string, never>;
+    performanceMetrics: PerformanceMetrics;
+    recentActivity: RecentActivity;
+    recentPatterns: RecentPatterns;
+    relatedEntities: RelatedEntityInfo[];
+    teamMembers: TeamMembers;
+    technicalContext: TechnicalContext;
+}
+export interface AIContext {
+    adaptiveSuggestions: AdaptiveSuggestions;
+    availableData: AvailableData;
+    collaborationContext: CollaborationContext;
+    contextIntelligence: ContextIntelligence;
+    knowledgeScope: string[];
+    learningInsights: LearningInsights;
+    performanceContext: PerformanceContext;
+    persona: string;
+    restrictedKnowledge: string[];
+    suggestedActions: string[];
+}
+export interface TeamMembersInfo {
+    active: string[];
+    available: string[];
+}
+export interface Benchmarks {
+    benchmarks: {
+        quality: string;
+        satisfaction: string;
+        velocity: string;
+    };
+}
+export interface BusinessContext {
+    businessImpact: string;
+    clientSatisfaction: string;
+    contractValue?: string;
+    priority: string;
+    status: string;
+    teamSize?: number;
+}
+export interface CollaborationPatterns {
+    patterns: string[];
+}
+export interface CommonPitfalls {
+    pitfalls: string[];
+}
+export interface CommunicationPreferences {
+    preferences: string[];
+}
+export interface CoordinationNeeds {
+    needs: string[];
+}
+export interface VelocityInfo {
+    trend: string;
+    velocity: string;
+}
+export interface HistoricalPatterns {
+    commonIssues: string[];
+    successRate: string;
+}
+export interface LearningOpportunities {
+    opportunities: string[];
+}
+export interface OptimizationOpportunities {
+    opportunities: string[];
+}
+export interface PerformanceMetrics {
+    deploymentFrequency: string;
+    qualityScore: string;
+    technicalDebt: string;
+    testCoverage: string;
+    velocity: string;
+}
+export interface PerformanceTrends {
+    trends: string[];
+}
+export interface RecentActivity {
+    activeBranches: string[];
+    commitsLastWeek: number;
+    filesChanged: number;
+    lastCommit: string;
+}
+export interface RecentPatterns {
+    collaborationPatterns: string[];
+    commonCommitPatterns: string[];
+    frequentFiles: string[];
+    workRhythms: string[];
+}
+export interface RelatedEntityInfo {
+    name: string;
+    relationship: string;
+    type: EntityType;
+}
+export interface SharedResources {
+    resources: string[];
+}
+export interface SimilarEntityLessons {
+    lessons: string[];
+}
+export interface SuccessFactors {
+    factors: string[];
+}
+export interface TeamMembers {
+    activeContributors: string[];
+    expertiseAreas: Record<string, string[]>;
+    recentCollaborators: string[];
+}
+export interface TechnicalContext {
+    architecturePatterns: string[];
+    deploymentStatus: string;
+    performanceStatus: string;
+    securityStatus: string;
+    techStack: string[];
+}
+export interface Bottlenecks {
+    bottlenecks: string[];
+}
+export interface FocusContext {
+    aiContext?: AIContext | Record<string, never>;
+    currentFocus?: Focus;
+    duration?: string;
+    entityName?: string;
+    entityType?: EntityType;
+    mode?: FocusMode;
+    startTime?: string;
+}
+export interface HistoryEntry {
+    entities: string[];
+    timestamp: number;
+}
+export interface Config {
+    defaultRemote?: string;
+    entities: Entity[];
+    initialized: boolean;
+    workspace?: string;
+}
+export interface RepoStatus {
+    ahead: number;
+    behind: number;
+    branch: string;
+    changes: string[];
+    entity: string;
+    hasChanges: boolean;
+    path: string;
+    untracked: string[];
+}

package/dist/models/entity.model.js

@@ -0,0 +1 @@
+export const ENTITY_TYPES = ['client', 'company', 'delivery', 'initiative', 'module', 'prospect', 'service', 'system', 'tool'];

package/dist/models/ticket.model.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Ticket Model Types
+ *
+ * Type definitions for gut tickets from the backend API.
+ * These mirror the types in packages/serverless/api/src/services/gut/types.ts
+ */
+export type TicketSourceType = 'jira' | 'github' | 'linear' | 'custom';
+export type GutTicketStatus = 'enriching' | 'needs_clarity' | 'ready' | 'in_progress' | 'testing' | 'in_review' | 'blocked' | 'ready_to_merge' | 'deploying' | 'validating' | 'done';
+export type GutTicketPhase = 'enrichment' | 'planning' | 'implementation' | 'testing' | 'review' | 'merge' | 'deployment' | 'validation';
+export type TicketType = 'bug' | 'feature' | 'task' | 'spike' | 'other';
+export type TicketPriority = 'critical' | 'high' | 'medium' | 'low';
+/**
+ * Gut ticket from the API
+ */
+export interface GutTicket {
+    ticketId: string;
+    tenantId: string;
+    source: {
+        type: TicketSourceType;
+        externalId: string;
+        externalUrl: string;
+        projectKey?: string;
+    };
+    summary: string;
+    description: string;
+    type: TicketType;
+    priority: TicketPriority;
+    labels: string[];
+    status: GutTicketStatus;
+    phase: GutTicketPhase;
+    confidence: number;
+    requiredEntities: string[];
+    relatedEntities?: string[];
+    affectedFiles?: string[];
+    branch: string;
+    manifestS3Key: string;
+    evidenceS3Prefix: string;
+    handoff?: {
+        required: boolean;
+        triggeredAt?: string;
+        reason?: string;
+        confidenceAtTrigger?: number;
+        attemptedFixes?: Array<{
+            attempt: number;
+            action: string;
+            result: string;
+        }>;
+        suggestedNextSteps?: string[];
+        humanHints?: Array<{
+            hint: string;
+            givenAt: string;
+            givenBy: string;
+            result?: string;
+        }>;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Focus ticket response from the API
+ */
+export interface FocusTicketResponse {
+    ticketId: string;
+    manifestUrl: string;
+    entities: string[];
+    branch: string;
+    status: GutTicketStatus;
+    phase: GutTicketPhase;
+    confidence: number;
+    acceptanceCriteria?: string[];
+}
+/**
+ * Hint response from the API
+ */
+export interface HintResponse {
+    ticketId: string;
+    hint: string;
+    givenBy: string;
+    givenAt: string;
+    status: GutTicketStatus;
+    retryTriggered: boolean;
+}
+/**
+ * Sync response from the API
+ */
+export interface SyncResponse {
+    ticketId: string;
+    synced: boolean;
+    source: {
+        type: string;
+        externalUrl: string;
+    };
+    actions: string[];
+}
+/**
+ * List tickets response from the API
+ */
+export interface ListTicketsResponse {
+    tickets: GutTicket[];
+    nextToken?: string;
+}
+/**
+ * Status emoji mapping for display
+ */
+export declare const STATUS_EMOJI: Record<GutTicketStatus, string>;
+/**
+ * Priority emoji mapping for display
+ */
+export declare const PRIORITY_EMOJI: Record<TicketPriority, string>;
+/**
+ * Get status emoji
+ */
+export declare const getStatusEmoji: (status: GutTicketStatus) => string;
+/**
+ * Get priority emoji
+ */
+export declare const getPriorityEmoji: (priority: TicketPriority) => string;

package/dist/models/ticket.model.js

@@ -0,0 +1,43 @@
+/**
+ * Ticket Model Types
+ *
+ * Type definitions for gut tickets from the backend API.
+ * These mirror the types in packages/serverless/api/src/services/gut/types.ts
+ */
+/**
+ * Status emoji mapping for display
+ */
+export const STATUS_EMOJI = {
+    enriching: '🔍',
+    needs_clarity: '❓',
+    ready: '✅',
+    in_progress: '🚧',
+    testing: '🧪',
+    in_review: '👀',
+    blocked: '🚫',
+    ready_to_merge: '🎉',
+    deploying: '🚀',
+    validating: '✔️',
+    done: '✅'
+};
+/**
+ * Priority emoji mapping for display
+ */
+export const PRIORITY_EMOJI = {
+    critical: '🔴',
+    high: '🟠',
+    medium: '🟡',
+    low: '🟢'
+};
+/**
+ * Get status emoji
+ */
+export const getStatusEmoji = (status) => {
+    return STATUS_EMOJI[status] || '📋';
+};
+/**
+ * Get priority emoji
+ */
+export const getPriorityEmoji = (priority) => {
+    return PRIORITY_EMOJI[priority] || '⚪';
+};

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

@@ -0,0 +1,15 @@
+/**
+ * Gut Authentication Service
+ *
+ * Re-exports from @devsquad/cli-auth with gut-specific configuration.
+ */
+import { AuthService as BaseAuthService, type AuthServiceConfig, type AWSCredentials, type CognitoConfig, type CognitoTokens, type StoredCredentials } from '@hyperdrive.bot/cli-auth';
+export type { AWSCredentials, CognitoConfig, CognitoTokens, StoredCredentials };
+declare const GUT_AUTH_CONFIG: AuthServiceConfig;
+/**
+ * Gut-specific AuthService
+ */
+export declare class AuthService extends BaseAuthService {
+    constructor(domain?: string);
+}
+export { GUT_AUTH_CONFIG };

package/dist/services/auth.service.js

@@ -0,0 +1,26 @@
+/**
+ * Gut Authentication Service
+ *
+ * Re-exports from @devsquad/cli-auth with gut-specific configuration.
+ */
+import { AuthService as BaseAuthService, } from '@hyperdrive.bot/cli-auth';
+// Gut-specific configuration
+// Note: Gut uses the same Cognito setup as hyperdrive
+const GUT_AUTH_CONFIG = {
+    appName: 'gut',
+    defaultCognitoClientId: process.env.GUT_COGNITO_CLIENT_ID || '',
+    defaultCognitoDomain: process.env.GUT_COGNITO_DOMAIN || '',
+    defaultIdentityPoolId: process.env.GUT_COGNITO_IDENTITY_POOL_ID || '',
+    defaultUserPoolId: process.env.GUT_COGNITO_USER_POOL_ID || '',
+    defaultRegion: process.env.GUT_AWS_REGION || 'us-east-1',
+};
+/**
+ * Gut-specific AuthService
+ */
+export class AuthService extends BaseAuthService {
+    constructor(domain) {
+        super(GUT_AUTH_CONFIG, domain);
+    }
+}
+// Export config for use by GutApiClient
+export { GUT_AUTH_CONFIG };

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

@@ -0,0 +1,34 @@
+import type { Config, Focus, FocusContext, HistoryEntry } from '../models/entity.model.js';
+export declare class ConfigService {
+    private config;
+    private readonly configFile;
+    private focus;
+    private readonly focusContextFile;
+    private readonly focusDir;
+    private readonly focusFile;
+    private readonly gutDir;
+    private history;
+    private readonly historyFile;
+    private readonly workspaceRoot;
+    constructor(workspaceRoot?: string);
+    addToHistory(focus: Focus): void;
+    clearHistory(): void;
+    getConfig(): Config;
+    getFocus(): Focus | null;
+    getFocusDir(): string;
+    getGutDir(): string;
+    getHistory(): HistoryEntry[];
+    getWorkspaceRoot(): string;
+    initWorkspace(workspacePath: string): Promise<void>;
+    isInitialized(): boolean;
+    loadConfig(): Promise<Config>;
+    saveConfig(config: Config): void;
+    saveFocus(focus: Focus | null): void;
+    saveFocusContext(context: FocusContext): Promise<void>;
+    private convertToYaml;
+    private ensureDirectories;
+    private loadAll;
+    private loadConfigSync;
+    private loadFocus;
+    private loadHistory;
+}