@wundr.io/cli 1.0.10 → 1.0.12

package/src/tests/computer-setup-integration.test.ts

@@ -2,7 +2,14 @@
  * Integration tests for computer-setup with Claude Code configuration
  */
 
-import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  jest,
+} from '@jest/globals';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { existsSync } from 'fs';
@@ -79,7 +86,10 @@ describe('Computer Setup Integration Tests', () => {
       await fs.writeFile(testFile, 'original content');
 
       // Create backup
-      const metadata = await backupManager.createBackup([testFile], 'Test backup');
+      const metadata = await backupManager.createBackup(
+        [testFile],
+        'Test backup'
+      );
 
       // Modify file
       await fs.writeFile(testFile, 'modified content');
@@ -102,7 +112,10 @@ describe('Computer Setup Integration Tests', () => {
       const testFile = path.join(testDir, 'test.txt');
       await fs.writeFile(testFile, 'content');
 
-      const metadata = await backupManager.createBackup([testFile], 'Test backup');
+      const metadata = await backupManager.createBackup(
+        [testFile],
+        'Test backup'
+      );
 
       const isValid = await backupManager.verifyBackup(metadata.backupId);
       expect(isValid).toBe(true);
@@ -206,7 +219,9 @@ describe('Computer Setup Integration Tests', () => {
       const conventionsPath = path.join(claudeDir, 'conventions.json');
       expect(existsSync(conventionsPath)).toBe(true);
 
-      const conventions = JSON.parse(await fs.readFile(conventionsPath, 'utf-8'));
+      const conventions = JSON.parse(
+        await fs.readFile(conventionsPath, 'utf-8')
+      );
       expect(conventions).toHaveProperty('fileNaming');
       expect(conventions).toHaveProperty('codeStyle');
     });
@@ -220,9 +235,15 @@ describe('Computer Setup Integration Tests', () => {
       expect(result.success).toBe(true);
 
       const agentsDir = path.join(claudeDir, 'agents');
-      expect(existsSync(path.join(agentsDir, 'backend-developer.json'))).toBe(true);
-      expect(existsSync(path.join(agentsDir, 'frontend-developer.json'))).toBe(true);
-      expect(existsSync(path.join(agentsDir, 'fullstack-developer.json'))).toBe(true);
+      expect(existsSync(path.join(agentsDir, 'backend-developer.json'))).toBe(
+        true
+      );
+      expect(existsSync(path.join(agentsDir, 'frontend-developer.json'))).toBe(
+        true
+      );
+      expect(existsSync(path.join(agentsDir, 'fullstack-developer.json'))).toBe(
+        true
+      );
     });
 
     it('should install git-worktree workflows', async () => {
@@ -279,7 +300,10 @@ describe('Computer Setup Integration Tests', () => {
       expect(result.skipped).toContain('CLAUDE.md');
 
       // Content should remain unchanged
-      const content = await fs.readFile(path.join(claudeDir, 'CLAUDE.md'), 'utf-8');
+      const content = await fs.readFile(
+        path.join(claudeDir, 'CLAUDE.md'),
+        'utf-8'
+      );
       expect(content).toBe('existing content');
     });
 
@@ -296,7 +320,10 @@ describe('Computer Setup Integration Tests', () => {
       expect(result.installed).toContain('CLAUDE.md');
 
       // Content should be updated
-      const content = await fs.readFile(path.join(claudeDir, 'CLAUDE.md'), 'utf-8');
+      const content = await fs.readFile(
+        path.join(claudeDir, 'CLAUDE.md'),
+        'utf-8'
+      );
       expect(content).toContain('Test content');
     });
 
@@ -347,16 +374,20 @@ describe('Computer Setup Integration Tests', () => {
       // Verify all components installed
       expect(existsSync(path.join(claudeDir, 'CLAUDE.md'))).toBe(true);
       expect(existsSync(path.join(claudeDir, 'conventions.json'))).toBe(true);
-      expect(existsSync(path.join(claudeDir, 'hooks', 'pre-commit'))).toBe(true);
-      expect(existsSync(path.join(claudeDir, 'agents', 'backend-developer.json'))).toBe(
+      expect(existsSync(path.join(claudeDir, 'hooks', 'pre-commit'))).toBe(
         true
       );
       expect(
-        existsSync(path.join(claudeDir, 'workflows', 'feature-development.json'))
+        existsSync(path.join(claudeDir, 'agents', 'backend-developer.json'))
+      ).toBe(true);
+      expect(
+        existsSync(
+          path.join(claudeDir, 'workflows', 'feature-development.json')
+        )
+      ).toBe(true);
+      expect(
+        existsSync(path.join(claudeDir, 'scripts', 'validate-setup.sh'))
       ).toBe(true);
-      expect(existsSync(path.join(claudeDir, 'scripts', 'validate-setup.sh'))).toBe(
-        true
-      );
     });
 
     it('should support complete backup and rollback cycle', async () => {

package/src/types/modules.d.ts

@@ -1,5 +1,416 @@
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
-// Type declarations for external modules
+/**
+ * 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;
@@ -22,6 +433,10 @@ declare module '@wundr/computer-setup' {
   }
 }
 
+// ---------------------------------------------------------------------------
+// @wundr/core (legacy without .io)
+// ---------------------------------------------------------------------------
+
 declare module '@wundr/core' {
   export interface CoreConfig {
     [key: string]: any;
@@ -30,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;
@@ -42,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

@@ -39,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');
   }
 
@@ -67,7 +66,7 @@ export class BackupRollbackManager {
    */
   async createBackup(
     files: string[],
-    reason: string = 'Manual backup',
+    reason: string = 'Manual backup'
   ): Promise<BackupMetadata> {
     const backupId = this.generateBackupId();
     const timestamp = new Date().toISOString();
@@ -203,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}`));
         });
@@ -224,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);
@@ -347,8 +349,9 @@ 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:'),
-      metadata.success ? chalk.green('Success') : chalk.red('Failed'),
+    console.log(
+      chalk.white('Status:'),
+      metadata.success ? chalk.green('Success') : chalk.red('Failed')
     );
     console.log(chalk.white('Files:'), chalk.cyan(metadata.files.length));
 

package/src/utils/config-manager.ts

@@ -104,7 +104,7 @@ export class ConfigManager {
         'WUNDR_CONFIG_INVALID',
         'Failed to load or parse configuration file',
         { configPath: configFile },
-        true,
+        true
       );
     }
   }
@@ -129,7 +129,7 @@ export class ConfigManager {
         'WUNDR_CONFIG_INVALID',
         'Failed to save configuration file',
         { configPath: configFile },
-        false,
+        false
       );
     }
   }
@@ -169,7 +169,7 @@ export class ConfigManager {
         return {
           valid: false,
           errors: error.issues.map(
-            issue => `${issue.path.join('.')}: ${issue.message}`,
+            issue => `${issue.path.join('.')}: ${issue.message}`
           ),
         };
       }

package/src/utils/error-handler.ts

@@ -116,7 +116,7 @@ class ErrorHandler {
 
     console.error(chalk.yellow('\n💡 This appears to be an unexpected error.'));
     console.error(
-      chalk.yellow('   Please report this issue with the above details.'),
+      chalk.yellow('   Please report this issue with the above details.')
     );
   }
 
@@ -167,7 +167,7 @@ class ErrorHandler {
     code: string,
     message: string,
     context?: Record<string, any>,
-    recoverable = false,
+    recoverable = false
   ): WundrError {
     const error = new Error(message) as WundrError;
     error.code = code;