@wundr.io/cli 1.0.1 → 1.0.2-dev.20260530174250.ef0ec927

package/src/types/modules.d.ts

@@ -1,4 +1,416 @@
-// Type declarations for external modules
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+/**
+ * Ambient module declarations for workspace packages that may not be built.
+ *
+ * These declarations provide type stubs so the CLI package compiles
+ * independently of whether sibling workspace packages have been built.
+ * When the real packages are built and resolvable, TypeScript will prefer
+ * their actual declarations over these ambient ones.
+ */
+
+// ---------------------------------------------------------------------------
+// @wundr.io/computer-setup
+// ---------------------------------------------------------------------------
+
+declare module '@wundr.io/computer-setup' {
+  import { EventEmitter } from 'events';
+
+  export interface DeveloperProfile {
+    name: string;
+    email?: string;
+    role: string;
+    team?: string;
+    company?: string;
+    preferences?: ProfilePreferences;
+    languages?: Record<string, boolean>;
+    frameworks?: Record<string, boolean>;
+    tools: {
+      packageManagers?: Record<string, boolean>;
+      containers?: Record<string, boolean>;
+      editors?: Record<string, boolean>;
+      databases?: Record<string, boolean>;
+      cloud?: Record<string, boolean>;
+      ci?: Record<string, boolean>;
+      languages?: Record<string, boolean>;
+      cloudCLIs?: Record<string, boolean>;
+      monitoring?: Record<string, boolean>;
+      communication?: Record<string, boolean>;
+    };
+  }
+
+  export interface ProfilePreferences {
+    shell: 'bash' | 'zsh' | 'fish';
+    editor: 'vscode' | 'vim' | 'neovim' | 'sublime' | 'intellij';
+    theme: 'dark' | 'light' | 'auto';
+    gitConfig: {
+      userName: string;
+      userEmail: string;
+      signCommits: boolean;
+      gpgKey?: string;
+      sshKey?: string;
+      defaultBranch: string;
+      aliases: Record<string, string>;
+    };
+    aiTools: {
+      claudeCode: boolean;
+      ruflo: boolean;
+      mcpTools: string[];
+      swarmAgents: string[];
+    };
+  }
+
+  export interface SetupPlatform {
+    os: 'darwin' | 'linux' | 'win32';
+    arch: 'x64' | 'arm64';
+    distro?: string;
+    version?: string;
+    node?: string;
+    shell?: string;
+  }
+
+  export interface SetupResult {
+    success: boolean;
+    completedSteps: string[];
+    failedSteps: string[];
+    skippedSteps: string[];
+    warnings: string[];
+    errors: Error[];
+    duration: number;
+    report?: any;
+  }
+
+  export interface SetupProgress {
+    totalSteps: number;
+    completedSteps: number;
+    currentStep: string;
+    percentage: number;
+    estimatedTimeRemaining: number;
+    logs: string[];
+  }
+
+  export interface SetupProfile {
+    name: string;
+    description: string;
+    estimatedTimeMinutes: number;
+    [key: string]: any;
+  }
+
+  // ComputerSetupManager is the single setup orchestrator. (RealSetupOrchestrator
+  // and SetupOrchestrator were retired during the orchestrator consolidation.)
+  export class ComputerSetupManager extends EventEmitter {
+    static getInstance(): ComputerSetupManager;
+    initialize(): Promise<void>;
+    validateSetup(profile?: any): Promise<boolean>;
+    cleanup(): Promise<void>;
+    getProfile(name: string): Promise<DeveloperProfile>;
+    getDefaultProfile(): Promise<DeveloperProfile>;
+    getAvailableProfiles(): Promise<DeveloperProfile[]>;
+    setup(options: any): Promise<SetupResult>;
+    on(event: string, callback: Function): this;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// @wundr.io/core (supplement missing RAG exports)
+// ---------------------------------------------------------------------------
+
+declare module '@wundr.io/core' {
+  // Core exports that exist in built dist
+  export interface WundrError extends Error {
+    code?: string;
+  }
+  export interface EventBusEvent {
+    type: string;
+    payload?: unknown;
+  }
+  export type EventHandler = (event: EventBusEvent) => void | Promise<void>;
+  export interface EventBus {
+    emit(event: EventBusEvent): void;
+    on(type: string, handler: EventHandler): void;
+    off(type: string, handler: EventHandler): void;
+  }
+  export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+  }
+  export type UtilityFunction = (...args: any[]) => any;
+  export type AsyncUtilityFunction = (...args: any[]) => Promise<any>;
+  export interface Result<T> {
+    success: boolean;
+    data?: T;
+    error?: Error;
+  }
+  export interface BaseConfig {
+    [key: string]: unknown;
+  }
+  export type CoreEventType = string;
+  export const CORE_EVENTS: Record<string, string>;
+
+  // Logging
+  export function getLogger(name: string): any;
+  export function log(level: string, message: string, ...args: any[]): void;
+
+  // Events
+  export function getEventBus(): EventBus;
+
+  // Errors
+  export function success<T>(data: T): Result<T>;
+  export function failure(error: Error): Result<never>;
+  export function isSuccess<T>(result: Result<T>): boolean;
+  export function isFailure<T>(result: Result<T>): boolean;
+  export class BaseWundrError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+  }
+
+  // RAG (not yet in built dist)
+  export interface RagInitOptions {
+    projectPath?: string;
+    projectName?: string;
+    force?: boolean;
+    skipIndexing?: boolean;
+    includePatterns?: string[];
+    excludePatterns?: string[];
+    chunkSize?: number;
+    chunkOverlap?: number;
+    embeddingModel?: string;
+  }
+
+  export interface RagInitResult {
+    success: boolean;
+    filesIndexed: number;
+    chunksCreated: number;
+    storePath: string;
+    configPath: string;
+    excludePath: string;
+    errors: string[];
+    warnings: string[];
+    framework: {
+      name: string;
+      projectType: string;
+    };
+  }
+
+  export function initProjectRag(
+    projectPathOrOptions: string | RagInitOptions,
+    options?: RagInitOptions
+  ): Promise<RagInitResult>;
+  export function isRagInitialized(projectPath: string): Promise<boolean>;
+  export function removeRag(projectPath: string): Promise<void>;
+  export function reindexProject(projectPath: string): Promise<RagInitResult>;
+
+  export const version: string;
+  export const name: string;
+}
+
+// ---------------------------------------------------------------------------
+// @wundr.io/governance
+// ---------------------------------------------------------------------------
+
+declare module '@wundr.io/governance' {
+  export interface EvaluationContext {
+    projectPath?: string;
+    configPath?: string;
+    environment?: string;
+    evaluationId?: string;
+    timestamp?: Date;
+    source?: string;
+    repository?: string;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+  }
+
+  export interface EvaluationResult {
+    passed: boolean;
+    score: number;
+    overallScore: number;
+    violations: PolicyViolation[];
+    warnings: string[];
+    details: EvaluationDetail[];
+    results: EvaluationResult[];
+    criticalIssues: string[];
+    issues: any[];
+    recommendations: any[];
+  }
+
+  export interface EvaluationDetail {
+    evaluator: string;
+    passed: boolean;
+    score: number;
+    message: string;
+  }
+
+  export interface PolicyViolation {
+    rule: string;
+    severity: string;
+    message: string;
+    description: string;
+    policyName: string;
+    policyId: string;
+    file?: string;
+    line?: number;
+    location: string;
+    suggestion?: string;
+    suggestedFix: string;
+  }
+
+  export interface ComplianceResult {
+    compliant: boolean;
+    score: number;
+    violations: PolicyViolation[];
+    recommendations: string[];
+    passedPolicies: any[];
+    skippedPolicies: any[];
+  }
+
+  export interface IPREConfig {
+    version: string;
+    metadata?: {
+      name?: string;
+      description?: string;
+      author?: string;
+    };
+    intent?: any;
+    policies?: any;
+    rewards?: any;
+    evaluators?: any;
+  }
+
+  export interface PolicyRule {
+    name: string;
+    description: string;
+    severity: string;
+    check: (context: EvaluationContext) => Promise<boolean>;
+  }
+
+  export interface EvaluatorSuite {
+    policyCompliance: EvaluatorAgent & {
+      checkPolicyCompliance(
+        context: EvaluationContext
+      ): Promise<ComplianceResult>;
+    };
+    rewardAlignment: EvaluatorAgent;
+    driftDetection: EvaluatorAgent;
+    [key: string]: any;
+  }
+
+  export class EvaluatorAgent {
+    constructor(config: any);
+    evaluate(context: EvaluationContext): Promise<EvaluationResult>;
+  }
+
+  export function createEvaluator(config: any): EvaluatorAgent;
+  export function createEvaluatorSuite(configs?: any): EvaluatorSuite;
+  export function runEvaluatorSuite(
+    suite: EvaluatorAgent[] | EvaluatorSuite,
+    context: EvaluationContext
+  ): Promise<EvaluationResult>;
+
+  export class PolicyEngine {
+    constructor(config?: any);
+    loadPolicies(path: string): Promise<void>;
+    check(context: EvaluationContext): Promise<ComplianceResult>;
+    addRule(rule: PolicyRule): void;
+    getViolationStats(): {
+      total: number;
+      bySeverity: Record<string, number>;
+      byCategory: Record<string, number>;
+    };
+  }
+
+  export const version: string;
+  export const name: string;
+}
+
+// ---------------------------------------------------------------------------
+// @wundr.io/guardian-dashboard
+// ---------------------------------------------------------------------------
+
+declare module '@wundr.io/guardian-dashboard' {
+  export type HealthStatus =
+    | 'healthy'
+    | 'degraded'
+    | 'unhealthy'
+    | 'unknown'
+    | 'HEALTHY'
+    | 'CONCERNING'
+    | 'CRITICAL'
+    | 'DEGRADED'
+    | 'UNHEALTHY'
+    | 'UNKNOWN';
+  export type InterventionSeverity = 'critical' | 'high' | 'medium' | 'low';
+
+  export interface SessionDriftData {
+    sessionId: string;
+    driftScore: number;
+    timestamp: Date;
+    metrics: Record<string, number>;
+  }
+
+  export interface AggregatedDriftReport {
+    averageDrift: number;
+    averageScore: number;
+    maxDrift: number;
+    minScore: number;
+    maxScore: number;
+    sessionCount: number;
+    totalSessions: number;
+    overallStatus: HealthStatus;
+    trend: string;
+    trendDirection: 'improving' | 'stable' | 'degrading';
+    sessions: SessionDriftData[];
+    criticalSessions: SessionDriftData[];
+    concerningSessions: SessionDriftData[];
+    timestamp: Date;
+  }
+
+  export interface InterventionRecommendation {
+    id: string;
+    severity: InterventionSeverity;
+    title: string;
+    description: string;
+    suggestedAction: string;
+    estimatedImpact: number;
+    dimension: string;
+    action: string;
+    rationale: string;
+    urgency: number;
+  }
+
+  export interface AlignmentDriftMetrics {
+    overallDrift: number;
+    componentDrifts: Record<string, number>;
+    healthStatus: HealthStatus;
+  }
+
+  export class AlignmentDebtCalculator {
+    constructor(config?: any);
+    calculate(metrics: AlignmentDriftMetrics): number;
+    getDebtTrend(history: AlignmentDriftMetrics[]): string;
+  }
+
+  export class DriftScoreAggregator {
+    constructor(config?: any);
+    aggregate(sessions: SessionDriftData[]): AggregatedDriftReport;
+    addSessions(sessions: SessionDriftData[]): void;
+    aggregateSessionScores(sessions: SessionDriftData[]): AggregatedDriftReport;
+    getHealthStatus(score: number): HealthStatus;
+  }
+
+  export class InterventionRecommender {
+    constructor(config?: any);
+    recommend(report: AggregatedDriftReport): InterventionRecommendation[];
+    recommendInterventions(data: any): InterventionRecommendation[];
+    prioritize(
+      recommendations: InterventionRecommendation[]
+    ): InterventionRecommendation[];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// @wundr/computer-setup (legacy without .io)
+// ---------------------------------------------------------------------------
+
 declare module '@wundr/computer-setup' {
   export class ComputerSetupManager {
     static getInstance(): ComputerSetupManager;
@@ -21,6 +433,10 @@ declare module '@wundr/computer-setup' {
   }
 }
 
+// ---------------------------------------------------------------------------
+// @wundr/core (legacy without .io)
+// ---------------------------------------------------------------------------
+
 declare module '@wundr/core' {
   export interface CoreConfig {
     [key: string]: any;
@@ -29,6 +445,10 @@ declare module '@wundr/core' {
   export function getLogger(name: string): any;
 }
 
+// ---------------------------------------------------------------------------
+// @wundr/project-templates
+// ---------------------------------------------------------------------------
+
 declare module '@wundr/project-templates' {
   export interface TemplateConfig {
     name: string;
@@ -41,6 +461,10 @@ declare module '@wundr/project-templates' {
   export const projectTemplates: Record<string, any>;
 }
 
+// ---------------------------------------------------------------------------
+// open
+// ---------------------------------------------------------------------------
+
 declare module 'open' {
   interface Options {
     app?: string | string[];

package/src/utils/backup-rollback-manager.ts

@@ -3,10 +3,12 @@
  * Handles backup creation and restoration for configuration files
  */
 
+import { existsSync } from 'fs';
 import * as fs from 'fs/promises';
 import * as path from 'path';
-import { existsSync } from 'fs';
+
 import chalk from 'chalk';
+
 import { logger } from './logger';
 
 export interface BackupMetadata {
@@ -37,8 +39,7 @@ export class BackupRollbackManager {
 
   constructor(backupDir?: string) {
     this.homeDir = process.env.HOME || process.env.USERPROFILE || '';
-    this.backupDir =
-      backupDir || path.join(this.homeDir, '.wundr', 'backups');
+    this.backupDir = backupDir || path.join(this.homeDir, '.wundr', 'backups');
     this.metadataFile = path.join(this.backupDir, 'metadata.json');
   }
 
@@ -104,7 +105,7 @@ export class BackupRollbackManager {
 
         logger.info('Backed up file', {
           original: expandedPath,
-          backup: backupFilePath
+          backup: backupFilePath,
         });
       }
 
@@ -120,7 +121,7 @@ export class BackupRollbackManager {
 
       logger.info('Backup created successfully', {
         backupId,
-        filesBackedUp: backupFiles.length
+        filesBackedUp: backupFiles.length,
       });
 
       return metadata;
@@ -159,7 +160,7 @@ export class BackupRollbackManager {
       logger.info('Rolling back', {
         backupId: metadata.backupId,
         dryRun,
-        files: metadata.files.length
+        files: metadata.files.length,
       });
 
       if (dryRun) {
@@ -181,7 +182,7 @@ export class BackupRollbackManager {
         try {
           // Create directory structure
           await fs.mkdir(path.dirname(file.originalPath), {
-            recursive: true
+            recursive: true,
           });
 
           // Restore file
@@ -192,7 +193,7 @@ export class BackupRollbackManager {
         } catch (error) {
           logger.error('Failed to restore file', {
             file: file.originalPath,
-            error
+            error,
           });
           failedFiles.push(file.originalPath);
         }
@@ -201,7 +202,9 @@ export class BackupRollbackManager {
       console.log(chalk.green(`\n✅ Restored ${restoredFiles.length} files`));
 
       if (failedFiles.length > 0) {
-        console.log(chalk.red(`❌ Failed to restore ${failedFiles.length} files`));
+        console.log(
+          chalk.red(`❌ Failed to restore ${failedFiles.length} files`)
+        );
         failedFiles.forEach(file => {
           console.log(chalk.red(`  - ${file}`));
         });
@@ -222,8 +225,9 @@ export class BackupRollbackManager {
     try {
       const content = await fs.readFile(this.metadataFile, 'utf-8');
       const backups = JSON.parse(content) as BackupMetadata[];
-      return backups.sort((a, b) =>
-        new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+      return backups.sort(
+        (a, b) =>
+          new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
       );
     } catch (error) {
       logger.error('Failed to list backups', error);
@@ -256,7 +260,7 @@ export class BackupRollbackManager {
     if (backups.length <= retainCount) {
       logger.info('No backups to clean up', {
         current: backups.length,
-        retain: retainCount
+        retain: retainCount,
       });
       return;
     }
@@ -273,7 +277,7 @@ export class BackupRollbackManager {
       } catch (error) {
         logger.error('Failed to delete backup', {
           backupId: backup.backupId,
-          error
+          error,
         });
       }
     }
@@ -345,7 +349,8 @@ export class BackupRollbackManager {
     console.log(chalk.white('Backup ID:'), chalk.green(metadata.backupId));
     console.log(chalk.white('Timestamp:'), chalk.gray(metadata.timestamp));
     console.log(chalk.white('Reason:'), chalk.gray(metadata.reason));
-    console.log(chalk.white('Status:'),
+    console.log(
+      chalk.white('Status:'),
       metadata.success ? chalk.green('Success') : chalk.red('Failed')
     );
     console.log(chalk.white('Files:'), chalk.cyan(metadata.files.length));