@pb33f/cowboy-components 0.7.18 → 0.8.0

package/dist/mocks/task-mock-generator.d.ts

@@ -0,0 +1,13 @@
+import { TaskMessage } from '../model/task';
+import { TerminalMessage } from '../components/terminal-emulator/terminal-emulator';
+export declare class TaskMockGenerator {
+    private mockIntervals;
+    private taskHandler;
+    private consoleHandler;
+    constructor(taskHandler: (message: TaskMessage) => void, consoleHandler: (message: TerminalMessage) => void);
+    start(): void;
+    stop(): void;
+    private generateMockTask;
+    private scheduleMockSubtasks;
+    private generateMockSubtask;
+}

package/dist/mocks/task-mock-generator.js

@@ -0,0 +1,200 @@
+import { TaskAction } from '../model/task';
+import { ConsoleMessageType } from '../components/terminal-emulator/terminal-emulator';
+export class TaskMockGenerator {
+    constructor(taskHandler, consoleHandler) {
+        this.mockIntervals = [];
+        this.taskHandler = taskHandler;
+        this.consoleHandler = consoleHandler;
+    }
+    start() {
+        // Clear any existing intervals
+        this.stop();
+        // Generate initial tasks immediately
+        this.generateMockTask();
+        setTimeout(() => this.generateMockTask(), 500);
+        setTimeout(() => this.generateMockTask(), 1500);
+        // Start generating new tasks every 5-10 seconds
+        const taskInterval = setInterval(() => {
+            this.generateMockTask();
+        }, Math.random() * 5000 + 5000);
+        this.mockIntervals.push(taskInterval);
+    }
+    stop() {
+        this.mockIntervals.forEach(interval => clearInterval(interval));
+        this.mockIntervals = [];
+    }
+    generateMockTask() {
+        const taskTypes = [
+            { type: 'github-import', name: 'Importing repository' },
+            { type: 'github-scan', name: 'Scanning OpenAPI files' },
+            { type: 'lint-analysis', name: 'Analyzing specifications' },
+            { type: 'doc-generation', name: 'Generating documentation' },
+            { type: 'schema-validation', name: 'Validating schemas' }
+        ];
+        const repos = [
+            'pb33f/openapi-changes',
+            'pb33f/libopenapi',
+            'stripe/stripe-api',
+            'github/rest-api-description',
+            'kubernetes/kubernetes'
+        ];
+        const selectedType = taskTypes[Math.floor(Math.random() * taskTypes.length)];
+        const selectedRepo = repos[Math.floor(Math.random() * repos.length)];
+        const task = {
+            id: `mock-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            type: selectedType.type,
+            name: `${selectedType.name}: ${selectedRepo}`,
+            status: 'active',
+            progress: 0,
+            startedAt: Math.floor(Date.now() / 1000),
+            updatedAt: Math.floor(Date.now() / 1000),
+            userId: 'mock-user',
+            workspaceId: 'mock-workspace',
+            totalSteps: Math.floor(Math.random() * 5) + 5, // 5-10 subtasks
+            currentStep: 0,
+            subtasks: []
+        };
+        // Create the task
+        this.taskHandler({
+            action: TaskAction.Create,
+            task: task
+        });
+        // Schedule subtask updates
+        this.scheduleMockSubtasks(task);
+    }
+    scheduleMockSubtasks(parentTask) {
+        const subtaskMessages = [
+            'Connecting to remote repository...',
+            'Fetching file list...',
+            'Analyzing directory structure...',
+            'Reading OpenAPI specifications...',
+            'Parsing YAML/JSON content...',
+            'Resolving $ref references...',
+            'Validating schema definitions...',
+            'Checking for breaking changes...',
+            'Generating compliance report...',
+            'Building dependency graph...'
+        ];
+        let currentStep = 0;
+        const totalSteps = parentTask.totalSteps || 5;
+        const updateInterval = setInterval(() => {
+            currentStep++;
+            if (currentStep <= totalSteps) {
+                const progress = Math.floor((currentStep / totalSteps) * 100);
+                const message = subtaskMessages[Math.floor(Math.random() * subtaskMessages.length)];
+                // Update the main task
+                const updatedTask = {
+                    ...parentTask,
+                    currentStep: currentStep,
+                    progress: progress,
+                    message: message,
+                    updatedAt: Math.floor(Date.now() / 1000)
+                };
+                this.taskHandler({
+                    action: TaskAction.Update,
+                    task: updatedTask
+                });
+                // Sometimes add a subtask
+                if (Math.random() > 0.6) {
+                    this.generateMockSubtask(parentTask);
+                }
+            }
+            else {
+                // Complete the task
+                clearInterval(updateInterval);
+                const index = this.mockIntervals.indexOf(updateInterval);
+                if (index > -1) {
+                    this.mockIntervals.splice(index, 1);
+                }
+                // Sometimes fail the task instead of completing
+                const shouldFail = Math.random() > 0.85; // 15% chance of failure
+                if (shouldFail) {
+                    const errors = [
+                        'Invalid OpenAPI specification: missing required field "info"',
+                        'Failed to connect to repository: timeout after 30s',
+                        'Schema validation failed: circular reference detected',
+                        'Permission denied: insufficient access to repository',
+                        'Rate limit exceeded: please try again later',
+                        'Parse error: unexpected token at line 42'
+                    ];
+                    const failedTask = {
+                        ...parentTask,
+                        status: 'failed',
+                        error: errors[Math.floor(Math.random() * errors.length)],
+                        completedAt: Math.floor(Date.now() / 1000),
+                        updatedAt: Math.floor(Date.now() / 1000)
+                    };
+                    this.taskHandler({
+                        action: TaskAction.Fail,
+                        task: failedTask
+                    });
+                }
+                else {
+                    const completedTask = {
+                        ...parentTask,
+                        status: 'completed',
+                        progress: 100,
+                        completedAt: Math.floor(Date.now() / 1000),
+                        updatedAt: Math.floor(Date.now() / 1000)
+                    };
+                    this.taskHandler({
+                        action: TaskAction.Complete,
+                        task: completedTask
+                    });
+                }
+            }
+        }, Math.random() * 1000 + 1500); // 1.5-2.5 seconds between updates (slower for better visibility)
+        this.mockIntervals.push(updateInterval);
+    }
+    generateMockSubtask(parentTask) {
+        const subtaskTypes = [
+            'Processing file',
+            'Validating schema',
+            'Checking references',
+            'Analyzing endpoints',
+            'Scanning parameters'
+        ];
+        const subtask = {
+            id: `mock-sub-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            type: 'subtask',
+            parentId: parentTask.id,
+            name: `${subtaskTypes[Math.floor(Math.random() * subtaskTypes.length)]}: ${Math.random().toString(36).substr(2, 6)}.yaml`,
+            status: 'active',
+            progress: Math.floor(Math.random() * 100),
+            startedAt: Math.floor(Date.now() / 1000),
+            updatedAt: Math.floor(Date.now() / 1000),
+            userId: parentTask.userId,
+            workspaceId: parentTask.workspaceId,
+            totalSteps: 0,
+            currentStep: 0
+        };
+        // Add console message for subtask
+        this.consoleHandler({
+            type: Math.random() > 0.8 ? ConsoleMessageType.Warning : ConsoleMessageType.Info,
+            message: `[${parentTask.name}] ${subtask.name}`,
+            timestamp: new Date().toISOString(),
+            metadata: {
+                taskId: parentTask.id,
+                subtaskId: subtask.id
+            }
+        });
+        // Complete subtask quickly
+        setTimeout(() => {
+            const completedSubtask = {
+                ...subtask,
+                status: 'completed',
+                progress: 100,
+                completedAt: Math.floor(Date.now() / 1000)
+            };
+            this.consoleHandler({
+                type: ConsoleMessageType.Success,
+                message: `✓ ${subtask.name} completed`,
+                timestamp: new Date().toISOString(),
+                metadata: {
+                    taskId: parentTask.id,
+                    subtaskId: subtask.id
+                }
+            });
+        }, Math.random() * 2000 + 1000);
+    }
+}

package/dist/model/api-response.d.ts

@@ -1,13 +1,8 @@
+import { PlatformError } from "./errors";
 export declare class APIResponse<T> {
     links?: {
         [key: string]: string;
     };
     response?: T;
 }
-export declare class APIError {
-    type: string;
-    title: string;
-    status: number;
-    detail: string;
-    instance: string;
-}
+export type APIError = PlatformError;

package/dist/model/api-response.js

@@ -1,4 +1,2 @@
 export class APIResponse {
 }
-export class APIError {
-}

package/dist/model/bundle.d.ts

@@ -0,0 +1,35 @@
+import { GraphResponse } from "./graph.js";
+export interface BundleReferenceMapping {
+    bundledPath: string;
+    originalFilePath: string;
+    originalDefinition: string;
+    originalLine: number;
+    originalColumn: number;
+    nodeType: string;
+    canonicalName: string;
+    wasRenamed: boolean;
+    rolodexNodeId: string;
+}
+export interface OriginalFileInfo {
+    filePath: string;
+    rolodexNodeId: string;
+    lineCount: number;
+}
+export interface BundleStatistics {
+    originalFileCount: number;
+    bundledSizeBytes: number;
+    componentsLifted: number;
+    processingTimeMs: number;
+}
+export interface BundleResponse {
+    bundledSpec: string;
+    bundleId: string;
+    sourceHash: string;
+    referenceMap: BundleReferenceMapping[];
+    originalFiles: OriginalFileInfo[];
+    createdAt: string;
+    cached: boolean;
+    warnings?: string[];
+    statistics: BundleStatistics;
+    graph?: GraphResponse;
+}

package/dist/model/bundle.js

@@ -0,0 +1 @@
+export {};

package/dist/model/channels.d.ts

@@ -1,10 +1,17 @@
-import { PlatformEvent } from "./platform-events";
+import { PlatformEvent } from "./platform-events.js";
 export declare const DoctorServiceChannel = "doctor-service";
+export declare const ModelServiceChannel = "model-service";
 export declare const SpecStreamChannel = "spec-stream";
 export declare const CreditStreamChannel = "credit-stream";
+export declare const WalletServiceChannel = "wallet-service";
+export declare const RuleSetServiceChannel = "ruleset-service";
 export declare const RodeoServiceChannel = "rodeo";
+export declare const TaskStreamChannel = "task-stream";
+export declare const BrokerConfirmChannel = "broker-confirm";
+export declare const BrokerHeartbeatChannel = "broker-heartbeat";
 export declare const TopicPrefix = "/t/";
 export declare const QueuePrefix = "/q/";
+export declare const PublishQueuePrefix = "/p/q/";
 export declare function isBrokerResponse(obj: any): obj is BrokerResponse;
 export declare function isPlatformEvent(obj: any): obj is PlatformEvent;
 export interface BrokerResponse {

package/dist/model/channels.js

@@ -1,9 +1,16 @@
 export const DoctorServiceChannel = "doctor-service";
+export const ModelServiceChannel = "model-service";
 export const SpecStreamChannel = "spec-stream";
 export const CreditStreamChannel = "credit-stream";
+export const WalletServiceChannel = "wallet-service";
+export const RuleSetServiceChannel = "ruleset-service";
 export const RodeoServiceChannel = "rodeo";
+export const TaskStreamChannel = "task-stream";
+export const BrokerConfirmChannel = "broker-confirm";
+export const BrokerHeartbeatChannel = "broker-heartbeat";
 export const TopicPrefix = "/t/";
 export const QueuePrefix = "/q/";
+export const PublishQueuePrefix = "/p/q/";
 export function isBrokerResponse(obj) {
     return typeof obj === 'object' && obj !== null && typeof obj.broker === 'string';
 }

package/dist/model/drawer-content.d.ts

@@ -0,0 +1,80 @@
+import { TemplateResult } from 'lit';
+/**
+ * event types for drawer content
+ */
+export declare enum DrawerContentType {
+    RULE_DOCS = "ruleDocs",
+    HOW_TO_FIX = "howToFix",
+    FUNCTION_DOCS = "functionDocs",
+    RENDERED_EXAMPLE = "renderedExample",
+    MARKDOWN = "markdown",
+    DIAGRAM = "diagram"
+}
+/**
+ * base event for drawer content
+ */
+export interface DrawerEvent {
+    type: DrawerContentType;
+    data?: any;
+    metadata?: Record<string, any>;
+}
+/**
+ * documentation drawer event
+ */
+export interface DocumentationDrawerEvent extends DrawerEvent {
+    type: DrawerContentType.RULE_DOCS | DrawerContentType.FUNCTION_DOCS;
+    ruleId?: string;
+    functionId?: string;
+    body?: string;
+}
+/**
+ * how-to-fix drawer event
+ */
+export interface HowToFixDrawerEvent extends DrawerEvent {
+    type: DrawerContentType.HOW_TO_FIX;
+    ruleId: string;
+    body?: string;
+}
+/**
+ * example drawer event
+ */
+export interface ExampleDrawerEvent extends DrawerEvent {
+    type: DrawerContentType.RENDERED_EXAMPLE;
+    json: string;
+    yaml?: string;
+    title?: string;
+}
+/**
+ * markdown drawer event
+ */
+export interface MarkdownDrawerEvent extends DrawerEvent {
+    type: DrawerContentType.MARKDOWN;
+    title?: string;
+    body: string;
+}
+/**
+ * diagram drawer event
+ */
+export interface DiagramDrawerEvent extends DrawerEvent {
+    type: DrawerContentType.DIAGRAM;
+    nodeId: string;
+    jsonPath: string;
+    diagram?: string;
+    title?: string;
+}
+/**
+ * union type for all drawer events
+ */
+export type AnyDrawerEvent = DocumentationDrawerEvent | HowToFixDrawerEvent | ExampleDrawerEvent | MarkdownDrawerEvent | DiagramDrawerEvent;
+/**
+ * interface for content handlers
+ */
+export interface DrawerContentHandler {
+    readonly supportedTypes: DrawerContentType[];
+    canHandle(event: DrawerEvent): boolean;
+    render(event: DrawerEvent): TemplateResult | Promise<TemplateResult>;
+    getTitle(event: DrawerEvent): string;
+    getLoadingMessage?(): string;
+    initialize?(): void | Promise<void>;
+    cleanup?(): void;
+}

package/dist/model/drawer-content.js

@@ -0,0 +1,14 @@
+// Copyright 2023-2025 Princess Beef Heavy Industries, LLC / Dave Shanley
+// https://pb33f.io
+/**
+ * event types for drawer content
+ */
+export var DrawerContentType;
+(function (DrawerContentType) {
+    DrawerContentType["RULE_DOCS"] = "ruleDocs";
+    DrawerContentType["HOW_TO_FIX"] = "howToFix";
+    DrawerContentType["FUNCTION_DOCS"] = "functionDocs";
+    DrawerContentType["RENDERED_EXAMPLE"] = "renderedExample";
+    DrawerContentType["MARKDOWN"] = "markdown";
+    DrawerContentType["DIAGRAM"] = "diagram";
+})(DrawerContentType || (DrawerContentType = {}));

package/dist/model/formable.js

@@ -206,12 +206,13 @@ export class Formable extends LitElement {
         const helpText = hasError ? errorMessage : (hint?.helpText || '');
         if (hint?.renderType === RenderType.Textarea) {
             return html `
-                <sl-textarea 
+                <sl-textarea
                     class="label-on-left ${hasError ? 'error' : ''}"
                     label="${this.formatLabel(key)}"
                     value="${this.formData[key] !== undefined ? this.formData[key] : (value || '')}"
                     placeholder="${hint.placeholder || ''}"
                     help-text="${helpText}"
+                    aria-invalid="${hasError ? 'true' : 'false'}"
                     ?required="${hint.required || false}"
                     ?disabled="${this.isLoading}"
                     ?autofocus="${this.isFirstVisibleField(key)}"
@@ -221,12 +222,13 @@ export class Formable extends LitElement {
             `;
         }
         return html `
-            <sl-input 
+            <sl-input
                 class="label-on-left ${hasError ? 'error' : ''}"
                 label="${this.formatLabel(key)}"
                 value="${this.formData[key] !== undefined ? this.formData[key] : (value || '')}"
                 placeholder="${hint?.placeholder || ''}"
                 help-text="${helpText}"
+                aria-invalid="${hasError ? 'true' : 'false'}"
                 ?required="${hint?.required || false}"
                 ?disabled="${this.isLoading}"
                 ?autofocus="${this.isFirstVisibleField(key)}"
@@ -241,7 +243,7 @@ export class Formable extends LitElement {
         const helpText = hasError ? errorMessage : (hint?.helpText || '');
         if (hint?.renderType === RenderType.Slider) {
             return html `
-                <sl-range 
+                <sl-range
                     class="label-on-left ${hasError ? 'error' : ''}"
                     label="${this.formatLabel(key)}"
                     value="${value || 0}"
@@ -249,6 +251,7 @@ export class Formable extends LitElement {
                     max="${hint.max || 100}"
                     step="${hint.step || 1}"
                     help-text="${helpText}"
+                    aria-invalid="${hasError ? 'true' : 'false'}"
                     ?disabled="${this.isLoading}"
                     ?autofocus="${this.isFirstVisibleField(key)}"
                     @sl-change="${(e) => this.handleFieldChange(key, e.target.value)}"
@@ -257,7 +260,7 @@ export class Formable extends LitElement {
             `;
         }
         return html `
-            <sl-input 
+            <sl-input
                 class="label-on-left ${hasError ? 'error' : ''}"
                 type="number"
                 label="${this.formatLabel(key)}"
@@ -267,6 +270,7 @@ export class Formable extends LitElement {
                 max="${hint?.max || ''}"
                 step="${hint?.step || ''}"
                 help-text="${helpText}"
+                aria-invalid="${hasError ? 'true' : 'false'}"
                 ?required="${hint?.required || false}"
                 ?disabled="${this.isLoading}"
                 ?autofocus="${this.isFirstVisibleField(key)}"
@@ -281,8 +285,9 @@ export class Formable extends LitElement {
         const helpText = hasError ? errorMessage : (hint?.helpText || '');
         if (hint?.renderType === RenderType.Switch) {
             return html `
-                <sl-switch 
+                <sl-switch
                     class="label-on-left ${hasError ? 'error' : ''}"
+                    aria-invalid="${hasError ? 'true' : 'false'}"
                     ?checked="${this.formData[key] !== undefined ? this.formData[key] : (value || false)}"
                     ?disabled="${this.isLoading}"
                     ?autofocus="${this.isFirstVisibleField(key)}"
@@ -297,8 +302,9 @@ export class Formable extends LitElement {
         return html `
             <section class="checkbox">
                 <label class="checkbox-label">${this.formatLabel(key)}</label>
-                <sl-checkbox 
+                <sl-checkbox
                     class="${hasError ? 'error' : ''}"
+                    aria-invalid="${hasError ? 'true' : 'false'}"
                     ?checked="${this.formData[key] !== undefined ? this.formData[key] : (value || false)}"
                     ?disabled="${this.isLoading}"
                     ?autofocus="${this.isFirstVisibleField(key)}"
@@ -317,11 +323,12 @@ export class Formable extends LitElement {
         const helpText = hasError ? errorMessage : (hint?.helpText || '');
         if (hint?.renderType === RenderType.Radio) {
             return html `
-                <sl-radio-group 
+                <sl-radio-group
                     class="label-on-left ${hasError ? 'error' : ''}"
                     label="${this.formatLabel(key)}"
                     value="${currentValue}"
                     help-text="${helpText}"
+                    aria-invalid="${hasError ? 'true' : 'false'}"
                     ?disabled="${this.isLoading}"
                     ?autofocus="${this.isFirstVisibleField(key)}"
                     @sl-change="${(e) => this.handleFieldChange(key, e.target.value)}"
@@ -334,12 +341,13 @@ export class Formable extends LitElement {
             `;
         }
         return html `
-            <sl-select 
+            <sl-select
                 class="label-on-left ${hasError ? 'error' : ''}"
                 label="${this.formatLabel(key)}"
                 value="${currentValue}"
                 placeholder="${hint?.placeholder || 'Select an option'}"
                 help-text="${helpText}"
+                aria-invalid="${hasError ? 'true' : 'false'}"
                 ?disabled="${this.isLoading}"
                 ?autofocus="${this.isFirstVisibleField(key)}"
                 @sl-change="${(e) => this.handleFieldChange(key, e.target.value)}"
@@ -462,10 +470,13 @@ export class Formable extends LitElement {
             </section>
         ` : '';
         const loadingDisplay = this.isLoading && this.loadingMessage ? html `
-            <section class="form-loading-message">
+            <section class="form-loading-message"
+                     role="status"
+                     aria-live="polite"
+                     aria-busy="true">
                 <pb33f-attention-box type="${AttentionType.Info}">
-                    ${this.loadingMessage}  
-                    <sl-icon name="circle-half" class="spinner-icon-small"></sl-icon>
+                    ${this.loadingMessage}
+                    <sl-icon name="circle-half" aria-hidden="true" class="spinner-icon-small"></sl-icon>
                 </pb33f-attention-box>
             </section>
         ` : '';

package/dist/model/github.d.ts

@@ -0,0 +1,125 @@
+export interface GitHubInstallation {
+    installationId: string;
+    gitHubInstallationId: number;
+    accountId: number;
+    accountLogin: string;
+    accountType: string;
+    active: boolean;
+    claimed: boolean;
+    userId?: string;
+    repositories?: GitHubRepositoryInfo[];
+}
+export interface GitHubRepositoryInfo {
+    repositoryId: string;
+    gitHubRepositoryId: number;
+    name: string;
+    fullName: string;
+    private: boolean;
+    defaultBranch: string;
+    monitoringEnabled: boolean;
+}
+export interface GitHubRepository {
+    repository: GitHubRepositoryInfo;
+    branches: string[];
+    availableRootDocuments: GitHubFile[];
+}
+export interface GitHubBranch {
+    name: string;
+    sha: string;
+    protected: boolean;
+}
+export interface GitHubFile {
+    path: string;
+    sha: string;
+    size: number;
+    type: 'file' | 'dir';
+    isRootCandidate?: boolean;
+    lastModifiedAt?: string;
+    lastAuthor?: string;
+    isImported?: boolean;
+    workspaceId?: string;
+}
+export interface GitHubClaimRequest {
+    installationId: number;
+}
+export interface GitHubClaimResponse {
+    success: boolean;
+    message?: string;
+    taskId?: string;
+}
+export interface GitHubAttachRequest {
+    repositoryId: string;
+    branch: string;
+    rootFile: string;
+}
+export interface GitHubAttachResponse {
+    message: string;
+    progressPath: string;
+    status: string;
+    workspaceId: string;
+    taskId: string;
+}
+export interface GitHubInstallationsResponse {
+    installations: GitHubInstallation[];
+    count: number;
+}
+export interface GitHubRepositoriesResponse {
+    repositories: GitHubRepository[];
+    count: number;
+}
+export interface GitHubScanJobResponse {
+    jobID: string;
+    status: string;
+    message: string;
+    progressPath: string;
+}
+export interface GitHubScanProgress {
+    jobID: string;
+    status: string;
+    label: string;
+    current: number;
+    total: number;
+    startedAt: string;
+    updatedAt: string;
+    error?: string;
+    result?: GitHubRepository[];
+}
+export type PRTrackingStatus = "active" | "merged" | "closed";
+export interface GitHubPRTracking {
+    trackingId: string;
+    repositoryId: string;
+    workspaceId: string;
+    prNumber?: number;
+    branchName: string;
+    latestCommitSha: string;
+    latestChangeId: string;
+    status: PRTrackingStatus;
+    lastProcessedAt: string;
+    expiresAt: string;
+    retentionDays: number;
+}
+export type ImportStatus = "importing" | "complete" | "partial" | "failed";
+export interface GitHubCachedState {
+    installations: GitHubInstallation[];
+    repositories: GitHubRepository[];
+    installationsLastRefreshed?: string;
+    repositoriesLastRefreshed?: string;
+    lastError?: {
+        message: string;
+        timestamp: string;
+    };
+}
+export interface GitHubRepositoryWorkspace {
+    associationId: string;
+    repositoryId: string;
+    workspaceId: string;
+    branch: string;
+    rootFile: string;
+    lastSyncedCommit?: string;
+    importStatus: ImportStatus;
+    failOnBreakingChanges: boolean;
+    failOnScoreThreshold: boolean;
+    scoreThreshold: number;
+    failOnScoreRegression: boolean;
+    failOnLintingErrors: boolean;
+}

package/dist/model/github.js

@@ -0,0 +1 @@
+export {};